Merge branch 'v5-dev' into v5-dev

2025-07-21 15:09:48 +08:00 · 2025-04-21 18:16:32 +08:00
parent ab0f7a0619 a2cc1e1587
commit 78b75f4283
49 changed files with 1378 additions and 90 deletions
--- a/hutool-core/pom.xml
+++ b/hutool-core/pom.xml
@@ -9,7 +9,7 @@
 	<parent>
 		<groupId>cn.hutool</groupId>
 		<artifactId>hutool-parent</artifactId>
-		<version>5.8.37</version>
+		<version>5.8.38-SNAPSHOT</version>
 	</parent>

 	<artifactId>hutool-core</artifactId>
--- a/hutool-core/src/main/java/cn/hutool/core/io/file/PathUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/file/PathUtil.java
@@ -165,7 +165,7 @@ public class PathUtil {
 	 * @since 4.4.2
 	 */
 	public static boolean del(Path path) throws IORuntimeException {
-		if (Files.notExists(path)) {
+		if (null == path || Files.notExists(path)) {
 			return true;
 		}

--- a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
@@ -435,7 +435,7 @@ public class CharSequenceUtil {
 	}

 	/**
-	 * 是否存都不为{@code null}或空对象或空白符的对象，通过{@link #hasBlank(CharSequence...)} 判断元素
+	 * 是否全都不为{@code null}或空对象或空白符的对象，通过{@link #hasBlank(CharSequence...)} 判断元素
 	 *
 	 * @param args 被检查的对象,一个或者多个
 	 * @return 是否都不为空
@@ -4237,6 +4237,42 @@ public class CharSequenceUtil {

 	// ------------------------------------------------------------------------ lower and upper

+	/**
+	 * 将字符串转为小写
+	 *
+	 * @param str 被转的字符串
+	 * @return 转换后的字符串
+	 * @see String#toLowerCase()
+	 * @since 5.8.38
+	 */
+	public static String toLoweCase(final CharSequence str) {
+		if (null == str) {
+			return null;
+		}
+		if(0 == str.length()){
+			return EMPTY;
+		}
+		return str.toString().toLowerCase();
+	}
+
+	/**
+	 * 将字符串转为大写
+	 *
+	 * @param str 被转的字符串
+	 * @return 转换后的字符串
+	 * @see String#toUpperCase()
+	 * @since 5.8.38
+	 */
+	public static String toUpperCase(final CharSequence str) {
+		if (null == str) {
+			return null;
+		}
+		if(0 == str.length()){
+			return EMPTY;
+		}
+		return str.toString().toUpperCase();
+	}
+
 	/**
 	 * 原字符串首字母大写并在其首部添加指定字符串 例如：str=name, preString=get =》 return getName
 	 *
--- a/hutool-core/src/main/java/cn/hutool/core/thread/lock/LockUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/thread/lock/LockUtil.java
@@ -1,5 +1,8 @@
 package cn.hutool.core.thread.lock;

+import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.concurrent.locks.StampedLock;

@@ -40,4 +43,101 @@ public class LockUtil {
 	public static NoLock getNoLock(){
 		return NO_LOCK;
 	}
+
+	/**
+	 * 创建分段锁（强引用），使用 ReentrantLock
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @return 分段锁实例
+	 */
+	public static SegmentLock<Lock> createSegmentLock(int segments) {
+		return SegmentLock.lock(segments);
+	}
+
+	/**
+	 * 创建分段读写锁（强引用），使用 ReentrantReadWriteLock
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @return 分段读写锁实例
+	 */
+	public static SegmentLock<ReadWriteLock> createSegmentReadWriteLock(int segments) {
+		return SegmentLock.readWriteLock(segments);
+	}
+
+	/**
+	 * 创建分段信号量（强引用）
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param permits 每个信号量的许可数
+	 * @return 分段信号量实例
+	 */
+	public static SegmentLock<Semaphore> createSegmentSemaphore(int segments, int permits) {
+		return SegmentLock.semaphore(segments, permits);
+	}
+
+	/**
+	 * 创建弱引用分段锁，使用 ReentrantLock，懒加载
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @return 弱引用分段锁实例
+	 */
+	public static SegmentLock<Lock> createLazySegmentLock(int segments) {
+		return SegmentLock.lazyWeakLock(segments);
+	}
+
+	/**
+	 * 根据 key 获取分段锁（强引用）
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param key 用于映射分段的 key
+	 * @return 对应的 Lock 实例
+	 */
+	public static Lock getSegmentLock(int segments, Object key) {
+		return SegmentLock.lock(segments).get(key);
+	}
+
+	/**
+	 * 根据 key 获取分段读锁（强引用）
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param key 用于映射分段的 key
+	 * @return 对应的读锁实例
+	 */
+	public static Lock getSegmentReadLock(int segments, Object key) {
+		return SegmentLock.readWriteLock(segments).get(key).readLock();
+	}
+
+	/**
+	 * 根据 key 获取分段写锁（强引用）
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param key 用于映射分段的 key
+	 * @return 对应的写锁实例
+	 */
+	public static Lock getSegmentWriteLock(int segments, Object key) {
+		return SegmentLock.readWriteLock(segments).get(key).writeLock();
+	}
+
+	/**
+	 * 根据 key 获取分段信号量（强引用）
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param permits 每个信号量的许可数
+	 * @param key 用于映射分段的 key
+	 * @return 对应的 Semaphore 实例
+	 */
+	public static Semaphore getSegmentSemaphore(int segments, int permits, Object key) {
+		return SegmentLock.semaphore(segments, permits).get(key);
+	}
+
+	/**
+	 * 根据 key 获取弱引用分段锁，懒加载
+	 *
+	 * @param segments 分段数量，必须大于 0
+	 * @param key 用于映射分段的 key
+	 * @return 对应的 Lock 实例
+	 */
+	public static Lock getLazySegmentLock(int segments, Object key) {
+		return SegmentLock.lazyWeakLock(segments).get(key);
+	}
 }
--- a/hutool-core/src/main/java/cn/hutool/core/thread/lock/SegmentLock.java
+++ b/hutool-core/src/main/java/cn/hutool/core/thread/lock/SegmentLock.java
@@ -0,0 +1,511 @@
+package cn.hutool.core.thread.lock;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Assert;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+
+/**
+ * 分段锁工具类，支持 Lock、Semaphore 和 ReadWriteLock 的分段实现。
+ * <p>
+ * 通过将锁分成多个段（segments），不同的操作可以并发使用不同的段，避免所有线程竞争同一把锁。
+ * 相等的 key 保证映射到同一段锁（如 key1.equals(key2) 时，get(key1) 和 get(key2) 返回相同对象）。
+ * 但不同 key 可能因哈希冲突映射到同一段，段数越少冲突概率越高。
+ * <p>
+ * 支持两种实现：
+ * <ul>
+ *     <li>强引用：创建时初始化所有段，内存占用稳定。</li>
+ *     <li>弱引用：懒加载，首次使用时创建段，未使用时可被垃圾回收，适合大量段但使用较少的场景。</li>
+ * </ul>
+ *
+ * @param <L> 锁类型
+ * @author Guava,dakuo
+ * @since 5.8.38
+ */
+public abstract class SegmentLock<L> {
+
+	/** 当段数大于此阈值时，使用 ConcurrentMap 替代大数组以节省内存（适用于懒加载场景） */
+	private static final int LARGE_LAZY_CUTOFF = 1024;
+
+	private SegmentLock() {}
+
+	/**
+	 * 根据 key 获取对应的锁段，保证相同 key 返回相同对象。
+	 *
+	 * @param key 非空 key
+	 * @return 对应的锁段
+	 */
+	public abstract L get(Object key);
+
+	/**
+	 * 根据索引获取锁段，索引范围为 [0, size())。
+	 *
+	 * @param index 索引
+	 * @return 指定索引的锁段
+	 */
+	public abstract L getAt(int index);
+
+	/**
+	 * 计算 key 对应的段索引。
+	 *
+	 * @param key 非空 key
+	 * @return 段索引
+	 */
+	abstract int indexFor(Object key);
+
+	/**
+	 * 获取总段数。
+	 *
+	 * @return 段数
+	 */
+	public abstract int size();
+
+	/**
+	 * 批量获取多个 key 对应的锁段列表，按索引升序排列，避免死锁。
+	 *
+	 * @param keys 非空 key 集合
+	 * @return 锁段列表（可能有重复）
+	 */
+	public Iterable<L> bulkGet(Iterable<?> keys) {
+		@SuppressWarnings("unchecked")
+		List<Object> result = (List<Object>) CollUtil.newArrayList(keys);
+		if (CollUtil.isEmpty(result)) {
+			return Collections.emptyList();
+		}
+		int[] stripes = new int[result.size()];
+		for (int i = 0; i < result.size(); i++) {
+			stripes[i] = indexFor(result.get(i));
+		}
+		Arrays.sort(stripes);
+		int previousStripe = stripes[0];
+		result.set(0, getAt(previousStripe));
+		for (int i = 1; i < result.size(); i++) {
+			int currentStripe = stripes[i];
+			if (currentStripe == previousStripe) {
+				result.set(i, result.get(i - 1));
+			} else {
+				result.set(i, getAt(currentStripe));
+				previousStripe = currentStripe;
+			}
+		}
+		@SuppressWarnings("unchecked")
+		List<L> asStripes = (List<L>) result;
+		return Collections.unmodifiableList(asStripes);
+	}
+
+	// 静态工厂方法
+
+	/**
+	 * 创建强引用的分段锁，所有段在创建时初始化。
+	 *
+	 * @param stripes 段数
+	 * @param supplier 锁提供者
+	 * @param <L> 锁类型
+	 * @return 分段锁实例
+	 */
+	public static <L> SegmentLock<L> custom(int stripes, Supplier<L> supplier) {
+		return new CompactSegmentLock<>(stripes, supplier);
+	}
+
+	/**
+	 * 创建强引用的可重入锁分段实例。
+	 *
+	 * @param stripes 段数
+	 * @return 分段锁实例
+	 */
+	public static SegmentLock<Lock> lock(int stripes) {
+		return custom(stripes, PaddedLock::new);
+	}
+
+	/**
+	 * 创建弱引用的可重入锁分段实例，懒加载。
+	 *
+	 * @param stripes 段数
+	 * @return 分段锁实例
+	 */
+	public static SegmentLock<Lock> lazyWeakLock(int stripes) {
+		return lazyWeakCustom(stripes, () -> new ReentrantLock(false));
+	}
+
+	/**
+	 * 创建弱引用的分段锁，懒加载。
+	 *
+	 * @param stripes 段数
+	 * @param supplier 锁提供者
+	 * @param <L> 锁类型
+	 * @return 分段锁实例
+	 */
+	private static <L> SegmentLock<L> lazyWeakCustom(int stripes, Supplier<L> supplier) {
+		return stripes < LARGE_LAZY_CUTOFF
+			? new SmallLazySegmentLock<>(stripes, supplier)
+			: new LargeLazySegmentLock<>(stripes, supplier);
+	}
+
+	/**
+	 * 创建强引用的信号量分段实例。
+	 *
+	 * @param stripes 段数
+	 * @param permits 每个信号量的许可数
+	 * @return 分段信号量实例
+	 */
+	public static SegmentLock<Semaphore> semaphore(int stripes, int permits) {
+		return custom(stripes, () -> new PaddedSemaphore(permits));
+	}
+
+	/**
+	 * 创建弱引用的信号量分段实例，懒加载。
+	 *
+	 * @param stripes 段数
+	 * @param permits 每个信号量的许可数
+	 * @return 分段信号量实例
+	 */
+	public static SegmentLock<Semaphore> lazyWeakSemaphore(int stripes, int permits) {
+		return lazyWeakCustom(stripes, () -> new Semaphore(permits, false));
+	}
+
+	/**
+	 * 创建强引用的读写锁分段实例。
+	 *
+	 * @param stripes 段数
+	 * @return 分段读写锁实例
+	 */
+	public static SegmentLock<ReadWriteLock> readWriteLock(int stripes) {
+		return custom(stripes, ReentrantReadWriteLock::new);
+	}
+
+	/**
+	 * 创建弱引用的读写锁分段实例，懒加载。
+	 *
+	 * @param stripes 段数
+	 * @return 分段读写锁实例
+	 */
+	public static SegmentLock<ReadWriteLock> lazyWeakReadWriteLock(int stripes) {
+		return lazyWeakCustom(stripes, WeakSafeReadWriteLock::new);
+	}
+
+	// 内部实现类
+
+	/**
+	 * 弱引用安全的读写锁实现，确保读锁和写锁持有对自身的强引用。
+	 */
+	private static final class WeakSafeReadWriteLock implements ReadWriteLock {
+		private final ReadWriteLock delegate;
+
+		WeakSafeReadWriteLock() {
+			this.delegate = new ReentrantReadWriteLock();
+		}
+
+		@Override
+		public Lock readLock() {
+			return new WeakSafeLock(delegate.readLock(), this);
+		}
+
+		@Override
+		public Lock writeLock() {
+			return new WeakSafeLock(delegate.writeLock(), this);
+		}
+	}
+
+	/**
+	 * 弱引用安全的锁包装类，确保持有强引用。
+	 */
+	private static final class WeakSafeLock implements Lock {
+		private final Lock delegate;
+		private final WeakSafeReadWriteLock strongReference;
+
+		WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {
+			this.delegate = delegate;
+			this.strongReference = strongReference;
+		}
+
+		@Override
+		public void lock() {
+			delegate.lock();
+		}
+
+		@Override
+		public void lockInterruptibly() throws InterruptedException {
+			delegate.lockInterruptibly();
+		}
+
+		@Override
+		public boolean tryLock() {
+			return delegate.tryLock();
+		}
+
+		@Override
+		public boolean tryLock(long time, java.util.concurrent.TimeUnit unit) throws InterruptedException {
+			return delegate.tryLock(time, unit);
+		}
+
+		@Override
+		public void unlock() {
+			delegate.unlock();
+		}
+
+		@Override
+		public Condition newCondition() {
+			return new WeakSafeCondition(delegate.newCondition(), strongReference);
+		}
+	}
+
+	/**
+	 * 弱引用安全的条件包装类。
+	 */
+	@SuppressWarnings("FieldCanBeLocal")
+	private static final class WeakSafeCondition implements Condition {
+		private final Condition delegate;
+
+		/** 防止垃圾回收 */
+		private final WeakSafeReadWriteLock strongReference;
+
+		WeakSafeCondition(Condition delegate, WeakSafeReadWriteLock strongReference) {
+			this.delegate = delegate;
+			this.strongReference = strongReference;
+		}
+
+		@Override
+		public void await() throws InterruptedException {
+			delegate.await();
+		}
+
+		@Override
+		public void awaitUninterruptibly() {
+			delegate.awaitUninterruptibly();
+		}
+
+		@Override
+		public long awaitNanos(long nanosTimeout) throws InterruptedException {
+			return delegate.awaitNanos(nanosTimeout);
+		}
+
+		@Override
+		public boolean await(long time, TimeUnit unit) throws InterruptedException {
+			return delegate.await(time, unit);
+		}
+
+		@Override
+		public boolean awaitUntil(Date deadline) throws InterruptedException {
+			return delegate.awaitUntil(deadline);
+		}
+
+		@Override
+		public void signal() {
+			delegate.signal();
+		}
+
+		@Override
+		public void signalAll() {
+			delegate.signalAll();
+		}
+	}
+
+	/**
+	 * 抽象基类，确保段数为 2 的幂。
+	 */
+	private abstract static class PowerOfTwoSegmentLock<L> extends SegmentLock<L> {
+		final int mask;
+
+		PowerOfTwoSegmentLock(int stripes) {
+			Assert.isTrue(stripes > 0, "Segment count must be positive");
+			this.mask = stripes > Integer.MAX_VALUE / 2 ? ALL_SET : ceilToPowerOfTwo(stripes) - 1;
+		}
+
+		@Override
+		final int indexFor(Object key) {
+			int hash = smear(key.hashCode());
+			return hash & mask;
+		}
+
+		@Override
+		public final L get(Object key) {
+			return getAt(indexFor(key));
+		}
+	}
+
+	/**
+	 * 强引用实现，使用固定数组存储段。
+	 */
+	private static class CompactSegmentLock<L> extends PowerOfTwoSegmentLock<L> {
+		private final Object[] array;
+
+		CompactSegmentLock(int stripes, Supplier<L> supplier) {
+			super(stripes);
+			Assert.isTrue(stripes <= Integer.MAX_VALUE / 2, "Segment count must be <= 2^30");
+			this.array = new Object[mask + 1];
+			for (int i = 0; i < array.length; i++) {
+				array[i] = supplier.get();
+			}
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public L getAt(int index) {
+			if (index < 0 || index >= array.length) {
+				throw new IllegalArgumentException("Index " + index + " out of bounds for size " + array.length);
+			}
+			return (L) array[index];
+		}
+
+		@Override
+		public int size() {
+			return array.length;
+		}
+	}
+
+	/**
+	 * 小规模弱引用实现，使用 AtomicReferenceArray 存储段。
+	 */
+	private static class SmallLazySegmentLock<L> extends PowerOfTwoSegmentLock<L> {
+		final AtomicReferenceArray<ArrayReference<? extends L>> locks;
+		final Supplier<L> supplier;
+		final int size;
+		final ReferenceQueue<L> queue = new ReferenceQueue<>();
+
+		SmallLazySegmentLock(int stripes, Supplier<L> supplier) {
+			super(stripes);
+			this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;
+			this.locks = new AtomicReferenceArray<>(size);
+			this.supplier = supplier;
+		}
+
+		@Override
+		public L getAt(int index) {
+			if (size != Integer.MAX_VALUE) {
+				Assert.isTrue(index >= 0 && index < size, "Index out of bounds");
+			}
+			ArrayReference<? extends L> existingRef = locks.get(index);
+			L existing = existingRef == null ? null : existingRef.get();
+			if (existing != null) {
+				return existing;
+			}
+			L created = supplier.get();
+			ArrayReference<L> newRef = new ArrayReference<>(created, index, queue);
+			while (!locks.compareAndSet(index, existingRef, newRef)) {
+				existingRef = locks.get(index);
+				existing = existingRef == null ? null : existingRef.get();
+				if (existing != null) {
+					return existing;
+				}
+			}
+			drainQueue();
+			return created;
+		}
+
+		private void drainQueue() {
+			Reference<? extends L> ref;
+			while ((ref = queue.poll()) != null) {
+				ArrayReference<? extends L> arrayRef = (ArrayReference<? extends L>) ref;
+				locks.compareAndSet(arrayRef.index, arrayRef, null);
+			}
+		}
+
+		@Override
+		public int size() {
+			return size;
+		}
+
+		private static final class ArrayReference<L> extends WeakReference<L> {
+			final int index;
+
+			ArrayReference(L referent, int index, ReferenceQueue<L> queue) {
+				super(referent, queue);
+				this.index = index;
+			}
+		}
+	}
+
+	/**
+	 * 大规模弱引用实现，使用 ConcurrentMap 存储段。
+	 */
+	private static class LargeLazySegmentLock<L> extends PowerOfTwoSegmentLock<L> {
+		final ConcurrentMap<Integer, L> locks;
+		final Supplier<L> supplier;
+		final int size;
+
+		LargeLazySegmentLock(int stripes, Supplier<L> supplier) {
+			super(stripes);
+			this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;
+			this.locks = new ConcurrentHashMap<>();
+			this.supplier = supplier;
+		}
+
+		@Override
+		public L getAt(int index) {
+			if (size != Integer.MAX_VALUE) {
+				Assert.isTrue(index >= 0 && index < size, "Index out of bounds");
+			}
+			L existing = locks.get(index);
+			if (existing != null) {
+				return existing;
+			}
+			L created = supplier.get();
+			existing = locks.putIfAbsent(index, created);
+			return existing != null ? existing : created;
+		}
+
+		@Override
+		public int size() {
+			return size;
+		}
+	}
+
+	private static final int ALL_SET = ~0;
+
+	private static int ceilToPowerOfTwo(int x) {
+		return 1 << (Integer.SIZE - Integer.numberOfLeadingZeros(x - 1));
+	}
+
+	private static int smear(int hashCode) {
+		hashCode ^= (hashCode >>> 20) ^ (hashCode >>> 12);
+		return hashCode ^ (hashCode >>> 7) ^ (hashCode >>> 4);
+	}
+
+	/**
+	 * 填充锁，避免缓存行干扰。
+	 */
+	private static class PaddedLock extends ReentrantLock {
+		private static final long serialVersionUID = 1L;
+
+		long unused1;
+		long unused2;
+		long unused3;
+
+		PaddedLock() {
+			super(false);
+		}
+	}
+
+	/**
+	 * 填充信号量，避免缓存行干扰。
+	 */
+	private static class PaddedSemaphore extends Semaphore {
+		private static final long serialVersionUID = 1L;
+
+		long unused1;
+		long unused2;
+		long unused3;
+
+		PaddedSemaphore(int permits) {
+			super(permits, false);
+		}
+	}
+
+}
--- a/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
@@ -1592,7 +1592,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	}

 	/**
-	 * 是否存都为{@code null}或空对象，通过{@link ObjectUtil#isEmpty(Object)} 判断元素
+	 * 是否全都为{@code null}或空对象，通过{@link ObjectUtil#isEmpty(Object)} 判断元素
 	 *
 	 * @param args 被检查的对象,一个或者多个
 	 * @return 是否都为空
@@ -1608,7 +1608,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	}

 	/**
-	 * 是否存都不为{@code null}或空对象，通过{@link ObjectUtil#isEmpty(Object)} 判断元素
+	 * 是否全都不为{@code null}或空对象，通过{@link ObjectUtil#isEmpty(Object)} 判断元素
 	 *
 	 * @param args 被检查的对象,一个或者多个
 	 * @return 是否都不为空
--- a/hutool-core/src/test/java/cn/hutool/core/date/IssueIC00HGTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/IssueIC00HGTest.java
@@ -0,0 +1,13 @@
+package cn.hutool.core.date;
+
+import cn.hutool.core.lang.Console;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+public class IssueIC00HGTest {
+	@Test
+	@Disabled
+	void dateToStringTest(){
+		Console.log(DateUtil.date().toString());
+	}
+}
--- a/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java
@@ -66,7 +66,11 @@ public class FileUtilTest {
 		final String parseSmbPath = FileUtil.getAbsolutePath(smbPath);
 		assertEquals(smbPath, parseSmbPath);
 		assertTrue(FileUtil.isAbsolutePath(smbPath));
-		assertTrue(Paths.get(smbPath).isAbsolute());
+		if(FileUtil.isWindows()){
+			// 在Windows下`\`路径是绝对路径，也表示SMB路径
+			// 但是在Linux下，`\`表示转义字符，并不被识别为路径
+			assertTrue(Paths.get(smbPath).isAbsolute());
+		}
 	}

 	@Test
@@ -480,21 +484,26 @@ public class FileUtilTest {
 		final List<String> list = ListUtil.of("text/javascript", "application/x-javascript");
 		assertTrue(list.contains(mimeType));

-		// office03
-		mimeType = FileUtil.getMimeType("test.doc");
-		assertEquals("application/msword", mimeType);
-		mimeType = FileUtil.getMimeType("test.xls");
-		assertEquals("application/vnd.ms-excel", mimeType);
-		mimeType = FileUtil.getMimeType("test.ppt");
-		assertEquals("application/vnd.ms-powerpoint", mimeType);
+		if(FileUtil.isWindows()){
+			// Linux下的OpenJDK无法正确识别
+
+			// office03
+			mimeType = FileUtil.getMimeType("test.doc");
+			assertEquals("application/msword", mimeType);
+			mimeType = FileUtil.getMimeType("test.xls");
+			assertEquals("application/vnd.ms-excel", mimeType);
+			mimeType = FileUtil.getMimeType("test.ppt");
+			assertEquals("application/vnd.ms-powerpoint", mimeType);
+
+			// office07+
+			mimeType = FileUtil.getMimeType("test.docx");
+			assertEquals("application/vnd.openxmlformats-officedocument.wordprocessingml.document", mimeType);
+			mimeType = FileUtil.getMimeType("test.xlsx");
+			assertEquals("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", mimeType);
+			mimeType = FileUtil.getMimeType("test.pptx");
+			assertEquals("application/vnd.openxmlformats-officedocument.presentationml.presentation", mimeType);
+		}

-		// office07+
-		mimeType = FileUtil.getMimeType("test.docx");
-		assertEquals("application/vnd.openxmlformats-officedocument.wordprocessingml.document", mimeType);
-		mimeType = FileUtil.getMimeType("test.xlsx");
-		assertEquals("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", mimeType);
-		mimeType = FileUtil.getMimeType("test.pptx");
-		assertEquals("application/vnd.openxmlformats-officedocument.presentationml.presentation", mimeType);

 		// pr#2617@Github
 		mimeType = FileUtil.getMimeType("test.wgt");
--- a/hutool-core/src/test/java/cn/hutool/core/io/file/PathUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/io/file/PathUtilTest.java
@@ -1,13 +1,16 @@
 package cn.hutool.core.io.file;

 import cn.hutool.core.io.FileUtil;
-import static org.junit.jupiter.api.Assertions.*;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;

+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;

+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class PathUtilTest {

 	@Test
@@ -82,7 +85,10 @@ public class PathUtilTest {
 	@Test
 	public void issue3179Test() {
 		final String mimeType = PathUtil.getMimeType(Paths.get("xxxx.jpg"));
-		assertEquals("image/jpeg", mimeType);
+		if(FileUtil.isWindows()){
+			// Linux下，OpenJDK可能报路径不存在
+			assertEquals("image/jpeg", mimeType);
+		}
 	}

 	/**
@@ -93,4 +99,11 @@ public class PathUtilTest {
 	public void moveTest2(){
 		PathUtil.move(Paths.get("D:\\project\\test1.txt"), Paths.get("D:\\project\\test2.txt"), false);
 	}
+
+	@Test
+	@Disabled
+	public void delNullDirTest() {
+		Path path = null;
+		assertTrue(PathUtil.del(path));
+	}
 }
--- a/hutool-core/src/test/java/cn/hutool/core/lang/SimpleCacheTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/lang/SimpleCacheTest.java
@@ -51,7 +51,7 @@ public class SimpleCacheTest {
 	@Test
 	public void getConcurrencyTest(){
 		final SimpleCache<String, String> cache = new SimpleCache<>();
-		final ConcurrencyTester tester = new ConcurrencyTester(9000);
+		final ConcurrencyTester tester = new ConcurrencyTester(500);
 		tester.test(()-> cache.get("aaa", ()-> {
 			ThreadUtil.sleep(200);
 			return "aaaValue";
--- a/hutool-core/src/test/java/cn/hutool/core/swing/ClipboardUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/swing/ClipboardUtilTest.java
@@ -1,9 +1,10 @@
 package cn.hutool.core.swing;

-import static org.junit.jupiter.api.Assertions.*;
+import cn.hutool.core.swing.clipboard.ClipboardUtil;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;

-import cn.hutool.core.swing.clipboard.ClipboardUtil;
+import static org.junit.jupiter.api.Assertions.assertEquals;

 /**
 * 剪贴板工具类单元测试
@@ -14,6 +15,7 @@ import cn.hutool.core.swing.clipboard.ClipboardUtil;
 public class ClipboardUtilTest {

 	@Test
+	@Disabled
 	public void setAndGetStrTest() {
 		try {
 			ClipboardUtil.setStr("test");
--- a/hutool-core/src/test/java/cn/hutool/core/text/csv/Issue3705Test.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/csv/Issue3705Test.java
@@ -1,6 +1,5 @@
 package cn.hutool.core.text.csv;

-import cn.hutool.core.util.CharUtil;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;

@@ -19,10 +18,7 @@ public class Issue3705Test {
 			csvWriter.flush();
 		}

-		String lineSeparator = new String(new char[]{CharUtil.CR, CharUtil.LF});
-
-		Assertions.assertEquals(
-			"\"2024-08-20 14:24:35,\"" + lineSeparator + "最后一行",
-			stringWriter.toString());
+		// CsvWriteConfig中默认为`\r\n`
+		Assertions.assertEquals("\"2024-08-20 14:24:35,\"\r\n最后一行", stringWriter.toString());
 	}
 }
--- a/hutool-core/src/test/java/cn/hutool/core/thread/SegmentLockTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/thread/SegmentLockTest.java
@@ -0,0 +1,209 @@
+package cn.hutool.core.thread;
+
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.thread.lock.SegmentLock;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * SegmentLock 单元测试类
+ */
+public class SegmentLockTest {
+
+	private static final int SEGMENT_COUNT = 4;
+	private SegmentLock<Lock> strongLock;
+	private SegmentLock<Lock> weakLock;
+	private SegmentLock<Semaphore> semaphore;
+	private SegmentLock<ReadWriteLock> readWriteLock;
+
+	@BeforeEach
+	public void setUp() {
+		strongLock = SegmentLock.lock(SEGMENT_COUNT);
+		weakLock = SegmentLock.lazyWeakLock(SEGMENT_COUNT);
+		semaphore = SegmentLock.semaphore(SEGMENT_COUNT, 2);
+		readWriteLock = SegmentLock.readWriteLock(SEGMENT_COUNT);
+	}
+
+	@Test
+	public void testSize() {
+		assertEquals(SEGMENT_COUNT, strongLock.size());
+		assertEquals(SEGMENT_COUNT, weakLock.size());
+		assertEquals(SEGMENT_COUNT, semaphore.size());
+		assertEquals(SEGMENT_COUNT, readWriteLock.size());
+	}
+
+	@SuppressWarnings("StringOperationCanBeSimplified")
+	@Test
+	public void testGetWithSameKey() {
+		// 相同 key 应返回相同锁
+		String key1 = "testKey";
+		String key2 = new String("testKey"); // equals 但不同对象
+		Lock lock1 = strongLock.get(key1);
+		Lock lock2 = strongLock.get(key2);
+		assertSame(lock1, lock2, "相同 key 应返回同一锁对象");
+
+		Lock weakLock1 = weakLock.get(key1);
+		Lock weakLock2 = weakLock.get(key2);
+		assertSame(weakLock1, weakLock2, "弱引用锁相同 key 应返回同一锁对象");
+	}
+
+	@Test
+	public void testGetAt() {
+		for (int i = 0; i < SEGMENT_COUNT; i++) {
+			Lock lock = strongLock.getAt(i);
+			assertNotNull(lock, "getAt 返回的锁不应为 null");
+		}
+		assertThrows(IllegalArgumentException.class, () -> strongLock.getAt(SEGMENT_COUNT),
+			"超出段数的索引应抛出异常");
+	}
+
+	@Test
+	public void testBulkGet() {
+		List<String> keys = CollUtil.newArrayList("key1", "key2", "key3");
+		Iterable<Lock> locks = strongLock.bulkGet(keys);
+		List<Lock> lockList = CollUtil.newArrayList(locks);
+
+		assertEquals(3, lockList.size(), "bulkGet 返回的锁数量应与 key 数量一致");
+
+		// 检查顺序性
+		int prevIndex = -1;
+		for (Lock lock : lockList) {
+			int index = findIndex(strongLock, lock);
+			assertTrue(index >= prevIndex, "bulkGet 返回的锁应按索引升序");
+			prevIndex = index;
+		}
+	}
+
+	@Test
+	public void testLockConcurrency() throws InterruptedException {
+		int threadCount = SEGMENT_COUNT * 2;
+		CountDownLatch startLatch = new CountDownLatch(1);
+		CountDownLatch endLatch = new CountDownLatch(threadCount);
+		ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+		List<String> keys = new ArrayList<>();
+		for (int i = 0; i < threadCount; i++) {
+			keys.add("key" + i);
+		}
+
+		for (int i = 0; i < threadCount; i++) {
+			final String key = keys.get(i);
+			executor.submit(() -> {
+				try {
+					startLatch.await();
+					Lock lock = strongLock.get(key);
+					lock.lock();
+					try {
+						Thread.sleep(100); // 模拟工作
+					} finally {
+						lock.unlock();
+					}
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+				} finally {
+					endLatch.countDown();
+				}
+			});
+		}
+
+		startLatch.countDown();
+		assertTrue(endLatch.await(2000, java.util.concurrent.TimeUnit.MILLISECONDS),
+			"并发锁测试应在 2 秒内完成");
+		executor.shutdown();
+	}
+
+	@Test
+	public void testSemaphore() {
+		Semaphore sem = semaphore.get("testKey");
+		assertEquals(2, sem.availablePermits(), "信号量初始许可应为 2");
+
+		sem.acquireUninterruptibly(2);
+		assertEquals(0, sem.availablePermits(), "获取所有许可后应为 0");
+
+		sem.release(1);
+		assertEquals(1, sem.availablePermits(), "释放一个许可后应为 1");
+	}
+
+	@SuppressWarnings("ResultOfMethodCallIgnored")
+	@Test
+	public void testReadWriteLock() throws InterruptedException {
+		ReadWriteLock rwLock = readWriteLock.get("testKey");
+		Lock readLock = rwLock.readLock();
+		Lock writeLock = rwLock.writeLock();
+
+		// 测试读锁可重入
+		readLock.lock();
+		assertTrue(readLock.tryLock(), "读锁应允许多个线程同时持有");
+		readLock.unlock();
+		readLock.unlock();
+
+		CountDownLatch latch = new CountDownLatch(1);
+		ExecutorService executor = Executors.newSingleThreadExecutor();
+		AtomicBoolean readLockAcquired = new AtomicBoolean(false);
+
+		writeLock.lock();
+		executor.submit(() -> {
+			readLockAcquired.set(readLock.tryLock());
+			latch.countDown();
+		});
+
+		latch.await(500, TimeUnit.MILLISECONDS);
+		assertFalse(readLockAcquired.get(), "写锁持有时读锁应失败");
+		writeLock.unlock();
+
+		executor.shutdown();
+		executor.awaitTermination(1, TimeUnit.SECONDS);
+	}
+
+	@Test
+	public void testWeakReferenceCleanup() throws InterruptedException {
+		SegmentLock<Lock> weakLockLarge = SegmentLock.lazyWeakLock(1024); // 超过 LARGE_LAZY_CUTOFF
+		Lock lock = weakLockLarge.get("testKey");
+
+		System.gc();
+		Thread.sleep(100);
+
+		// 弱引用锁未被其他引用，应仍可获取
+		Lock lockAgain = weakLockLarge.get("testKey");
+		assertSame(lock, lockAgain, "弱引用锁未被回收时应返回同一对象");
+	}
+
+	@Test
+	public void testInvalidSegmentCount() {
+		assertThrows(IllegalArgumentException.class, () -> SegmentLock.lock(0),
+			"段数为 0 应抛出异常");
+		assertThrows(IllegalArgumentException.class, () -> SegmentLock.lock(-1),
+			"负段数应抛出异常");
+	}
+
+	@Test
+	public void testHashDistribution() {
+		SegmentLock<Lock> lock = SegmentLock.lock(4);
+		int[] counts = new int[4];
+		for (int i = 0; i < 100; i++) {
+			int index = findIndex(lock, lock.get("key" + i));
+			counts[index]++;
+		}
+		for (int count : counts) {
+			assertTrue(count > 0, "每个段都应至少被分配到一个 key");
+		}
+	}
+
+	private int findIndex(SegmentLock<Lock> lock, Lock target) {
+		for (int i = 0; i < lock.size(); i++) {
+			if (lock.getAt(i) == target) {
+				return i;
+			}
+		}
+		return -1;
+	}
+}
--- a/hutool-core/src/test/java/cn/hutool/core/util/NumberUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/NumberUtilTest.java
@@ -144,43 +144,43 @@ public class NumberUtilTest {
 	@Test
 	public void roundStrTest() {
 		final String roundStr = NumberUtil.roundStr(2.647, 2);
-		assertEquals(roundStr, "2.65");
+		assertEquals("2.65", roundStr);

 		final String roundStr1 = NumberUtil.roundStr(0, 10);
-		assertEquals(roundStr1, "0.0000000000");
+		assertEquals("0.0000000000", roundStr1);
 	}

 	@Test
 	public void roundHalfEvenTest() {
 		String roundStr = NumberUtil.roundHalfEven(4.245, 2).toString();
-		assertEquals(roundStr, "4.24");
+		assertEquals("4.24", roundStr);
 		roundStr = NumberUtil.roundHalfEven(4.2450, 2).toString();
-		assertEquals(roundStr, "4.24");
+		assertEquals("4.24", roundStr);
 		roundStr = NumberUtil.roundHalfEven(4.2451, 2).toString();
-		assertEquals(roundStr, "4.25");
+		assertEquals("4.25", roundStr);
 		roundStr = NumberUtil.roundHalfEven(4.2250, 2).toString();
-		assertEquals(roundStr, "4.22");
+		assertEquals("4.22", roundStr);

 		roundStr = NumberUtil.roundHalfEven(1.2050, 2).toString();
-		assertEquals(roundStr, "1.20");
+		assertEquals("1.20", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2150, 2).toString();
-		assertEquals(roundStr, "1.22");
+		assertEquals("1.22", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2250, 2).toString();
-		assertEquals(roundStr, "1.22");
+		assertEquals("1.22", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2350, 2).toString();
-		assertEquals(roundStr, "1.24");
+		assertEquals("1.24", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2450, 2).toString();
-		assertEquals(roundStr, "1.24");
+		assertEquals("1.24", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2550, 2).toString();
-		assertEquals(roundStr, "1.26");
+		assertEquals("1.26", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2650, 2).toString();
-		assertEquals(roundStr, "1.26");
+		assertEquals("1.26", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2750, 2).toString();
-		assertEquals(roundStr, "1.28");
+		assertEquals("1.28", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2850, 2).toString();
-		assertEquals(roundStr, "1.28");
+		assertEquals("1.28", roundStr);
 		roundStr = NumberUtil.roundHalfEven(1.2950, 2).toString();
-		assertEquals(roundStr, "1.30");
+		assertEquals("1.30", roundStr);
 	}

 	@Test
@@ -673,4 +673,10 @@ public class NumberUtilTest {
 		final double result = NumberUtil.add(v1, v2);
 		assertEquals(91007279.3545, result, 0);
 	}
+
+	@Test
+	void issueIC1MXETest(){
+		final boolean equals = NumberUtil.equals(104557543L, 104557544);
+		assertFalse(equals);
+	}
 }