功能介绍

ConcurrentLinkedHashMap是Hutool中提供的并发安全的有序Map实现，它结合了ConcurrentHashMap的并发安全特性和LinkedHashMap的有序特性。ConcurrentLinkedHashMap支持插入顺序和访问顺序两种模式，可以根据配置在访问元素时自动调整元素顺序，非常适合实现LRU（最近最少使用）缓存。同时，它支持固定大小，当超过设定容量时会自动移除最旧的条目。

主要特性

• 并发安全，支持多线程操作
• 基于LinkedHashMap实现，支持有序特性
• 支持插入顺序和访问顺序两种模式
• 支持固定大小，自动移除最旧条目
• 支持LRU（最近最少使用）缓存实现
• 基于ConcurrentHashMap实现，性能优异
• 支持所有Map接口方法
• 支持null值，但不支持null键
• 线程安全，适合多线程环境使用
• 高并发场景下性能优异
• 支持并发读写操作

适用场景

1. 高并发环境下的缓存系统
2. 实现LRU（最近最少使用）缓存
3. 需要保持插入顺序或访问顺序的并发Map
4. 多线程环境下的有序Map需求
5. 需要固定大小的并发缓存
6. 高并发场景下的有序数据存储
7. 实现线程安全的FIFO（先进先出）队列
8. 任何需要并发安全且有序的Map场景

使用示例

示例1：基本用法

// 创建ConcurrentLinkedHashMap实例（默认插入顺序）
ConcurrentLinkedHashMap<String, Object> concurrentMap = new ConcurrentLinkedHashMap<>(16, 0.75f, 16);

// 添加键值对
concurrentMap.put("key1", "value1");
concurrentMap.put("key2", "value2");
concurrentMap.put("key3", "value3");
concurrentMap.put("key4", "value4");

// 获取值
Object value1 = concurrentMap.get("key1");
// 输出: value1

// 遍历Map，保持插入顺序
concurrentMap.forEach((key, value) -> {
    Console.log(key + "=" + value);
});
// 输出:
// key1=value1
// key2=value2
// key3=value3
// key4=value4

示例2：创建固定大小的LRU缓存

// 创建固定大小为3的ConcurrentLinkedHashMap，使用访问顺序（LRU模式）
ConcurrentLinkedHashMap<String, Object> lruCache = new ConcurrentLinkedHashMap<>(3, 0.75f, 3, true);

// 添加键值对
lruCache.put("key1", "value1");
lruCache.put("key2", "value2");
lruCache.put("key3", "value3");

// 访问key1，将其移到队尾（最近使用）
lruCache.get("key1");

// 添加第4个键值对，超过容量，自动移除最旧的key2
lruCache.put("key4", "value4");

// 遍历Map，此时key2已被移除
lruCache.forEach((key, value) -> {
    Console.log(key + "=" + value);
});
// 输出:
// key3=value3
// key1=value1
// key4=value4

示例3：使用访问顺序

// 创建使用访问顺序的ConcurrentLinkedHashMap
ConcurrentLinkedHashMap<String, Object> accessOrderMap = new ConcurrentLinkedHashMap<>(16, 0.75f, 16, true);

// 添加键值对
accessOrderMap.put("key1", "value1");
accessOrderMap.put("key2", "value2");
accessOrderMap.put("key3", "value3");

// 访问元素，调整顺序
accessOrderMap.get("key2");
accessOrderMap.get("key1");

// 遍历Map，按访问顺序排序
accessOrderMap.forEach((key, value) -> {
    Console.log(key + "=" + value);
});
// 输出:
// key3=value3
// key2=value2
// key1=value1

示例4：多线程操作

// 创建ConcurrentLinkedHashMap实例
ConcurrentLinkedHashMap<String, Integer> concurrentMap = new ConcurrentLinkedHashMap<>(16, 0.75f, 16);

// 多线程写入
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
    final int index = i;
    executor.submit(() -> {
        concurrentMap.put("key" + index, index);
    });
}

// 等待所有任务完成
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);

// 多线程读取
for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        for (int j = 0; j < 100; j++) {
            concurrentMap.get("key" + j);
        }
    });
}

// 等待所有任务完成
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);

// 输出Map大小
Console.log("Map size: " + concurrentMap.size());
// 输出: Map size: 1000

示例5：与其他Map的对比

// ConcurrentLinkedHashMap vs ConcurrentHashMap
// ConcurrentLinkedHashMap: 并发安全 + 有序
// ConcurrentHashMap: 并发安全 + 无序

ConcurrentLinkedHashMap<String, Object> concurrentLinkedMap = new ConcurrentLinkedHashMap<>(16, 0.75f, 16);
ConcurrentHashMap<String, Object> concurrentHashMap = new ConcurrentHashMap<>();

// 添加相同的键值对
concurrentLinkedMap.put("b", "value2");
concurrentLinkedMap.put("a", "value1");
concurrentLinkedMap.put("c", "value3");

concurrentHashMap.put("b", "value2");
concurrentHashMap.put("a", "value1");
concurrentHashMap.put("c", "value3");

// 遍历ConcurrentLinkedHashMap，保持插入顺序
Console.log("ConcurrentLinkedHashMap:");
concurrentLinkedMap.forEach((key, value) -> {
    Console.log(key + "=" + value);
});
// 输出:
// b=value2
// a=value1
// c=value3

// 遍历ConcurrentHashMap，无序
Console.log("\nConcurrentHashMap:");
concurrentHashMap.forEach((key, value) -> {
    Console.log(key + "=" + value);
});
// 输出（顺序不确定）:
// a=value1
// b=value2
// c=value3

注意事项

1. ConcurrentLinkedHashMap是线程安全的，适合多线程环境使用
2. 支持插入顺序和访问顺序两种模式，默认为插入顺序
3. 固定大小时，超过容量会自动移除最旧条目
4. 访问顺序模式下，访问元素会将元素移到队尾
5. 不支持null键，但支持null值
6. 性能优异，适合高并发场景
7. 内存占用比HashMap略高，因为需要维护链表结构
8. 适合实现LRU缓存，但不是严格的LRU实现
9. 可以通过构造函数自定义容量、负载因子和最大大小
10. 线程安全，支持并发读写操作

方法列表

ConcurrentLinkedHashMap实现了ConcurrentMap接口，因此支持所有Map接口方法，主要包括：

方法名	描述	参数	返回值
ConcurrentLinkedHashMap(int initialCapacity, float loadFactor, int maxSize)	创建指定容量、负载因子和最大大小的ConcurrentLinkedHashMap（默认插入顺序）	initialCapacity: 初始容量, loadFactor: 负载因子, maxSize: 最大大小	无
ConcurrentLinkedHashMap(int initialCapacity, float loadFactor, int maxSize, boolean accessOrder)	创建指定参数的ConcurrentLinkedHashMap，可选择访问顺序或插入顺序	initialCapacity: 初始容量, loadFactor: 负载因子, maxSize: 最大大小, accessOrder: 是否使用访问顺序	无
put(K key, V value)	添加键值对，超过容量时自动移除最旧条目	key: 键, value: 值	V
get(Object key)	获取值，访问顺序模式下会调整元素顺序	key: 键	V
remove(Object key)	移除键值对	key: 键	V
clear()	清空所有键值对	无	void
size()	获取Map大小	无	int
containsKey(Object key)	判断是否包含指定键	key: 键	boolean
containsValue(Object value)	判断是否包含指定值	value: 值	boolean
keySet()	获取所有键的集合	无	Set
values()	获取所有值的集合	无	Collection
entrySet()	获取所有键值对的集合	无	Set<Map.Entry<K, V>>
forEach(BiConsumer<? super K, ? super V> action)	遍历所有键值对	action: 遍历操作	void
replace(K key, V oldValue, V newValue)	替换键值对（并发安全）	key: 键, oldValue: 旧值, newValue: 新值	boolean
putIfAbsent(K key, V value)	如果键不存在则添加键值对（并发安全）	key: 键, value: 值	V