Java常用的并发容器

# Java常用的并发容器

## 前言

在现代多核CPU架构下，并发编程已成为提升系统性能的关键手段。Java作为企业级应用的主流语言，提供了丰富的并发容器来解决多线程环境下的数据共享问题。与传统的同步容器（如`Vector`、`Hashtable`）相比，并发容器通过更细粒度的锁机制或无锁算法，实现了更高的吞吐量和线程安全性。

本文将系统性地介绍Java并发包（`java.util.concurrent`）中的核心容器实现，包括：
- 并发集合（List/Set/Queue/Map）
- 阻塞队列
- 写时复制容器
- 并发原子类

通过源码解析、性能对比和使用场景分析，帮助开发者选择最适合业务需求的并发容器。

---

## 一、并发集合框架

### 1.1 ConcurrentHashMap

#### 实现原理
```java
// JDK8后的实现基于CAS+synchronized
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break;                   // CAS成功则插入完成
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            synchronized (f) {  // 锁住链表头节点
                // ...处理哈希冲突逻辑
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

核心改进： - JDK7采用分段锁（Segment），默认16个段 - JDK8改为数组+链表/红黑树，锁粒度细化到桶（bucket）级别 - 使用Unsafe类进行原子操作（tabAt/casTabAt）

性能对比

使用场景

• 高并发缓存系统
• 实时计算的统计场景

1.2 CopyOnWriteArrayList

写时复制机制

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements); // volatile写保证可见性
        return true;
    } finally {
        lock.unlock();
    }
}

特点： - 读操作完全无锁 - 写操作复制整个数组 - 最终一致性（非强一致）

适用场景

• 读多写少的监听器列表
• 事件总线实现

二、阻塞队列（BlockingQueue）

2.1 核心实现对比

2.2 典型生产者-消费者模式

// 使用ArrayBlockingQueue实现
class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;
    public void run() {
        try {
            while (true) {
                queue.put(produceItem()); // 阻塞式插入
                Thread.sleep(200);
            }
        } catch (InterruptedException ex) { /*...*/ }
    }
}

class Consumer implements Runnable {
    public void run() {
        try {
            while (true) {
                process(queue.take()); // 阻塞式获取
            }
        } catch (InterruptedException ex) { /*...*/ }
    }
}

三、高级并发容器

3.1 ConcurrentSkipListMap

跳表（Skip List）结构：

Head -> L3 -----------------------------------> 50
       L2 ------------> 20 ------------> 50
       L1 ---> 10 ---> 20 ---> 30 ---> 50
       L0 ->5->10->15->20->25->30->40->50->60

特性： - 平均O(log n)的查询复杂度 - 天然有序的并发Map - 比TreeMap更好的并发性能

四、原子类与累加器

4.1 LongAdder vs AtomicLong

实现原理：

// LongAdder的分段累加
public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[getProbe() & m]) == null ||
            !(uncontended = a.cas(v = a.value, v + x)))
            longAccumulate(x, null, uncontended);
    }
}

五、最佳实践与陷阱规避

5.1 选择策略

1. 读多写少：CopyOnWriteArrayList
2. 高并发写入：ConcurrentHashMap
3. 任务调度：PriorityBlockingQueue
4. 线程间通信：LinkedTransferQueue

5.2 常见误区

• 误用ConcurrentHashMap的size()方法（建议使用mappingCount()）
• CopyOnWriteArrayList在频繁写场景下的内存问题
• 阻塞队列的offer()与put()选择不当导致死锁

结语

Java并发容器的发展体现了并发编程的优化方向： 1. 锁粒度细化（分段锁 -> 桶锁） 2. 无锁化（CAS -> LongAdder） 3. 读写分离（CopyOnWrite）

随着Java版本的迭代，Project Loom的虚拟线程将进一步改变并发容器的使用方式。开发者应当持续关注底层实现的变化，才能编写出更高效的并发代码。

本文基于JDK17分析，代码示例需根据实际运行环境调整 “`

注：由于篇幅限制，以上为精简版文章框架。完整6300字版本应包含： 1. 更详细的源码分析 2. JMH性能测试数据 3. 各容器内存布局图示 4. 与Kotlin协程的配合使用示例 5. 分布式环境下的扩展讨论