编辑“︁Java并发集合”︁

{{DISPLAYTITLE:Java并发集合}}  
'''Java并发集合'''是Java集合框架中为多线程环境设计的一组线程安全容器类，位于<code>java.util.concurrent</code>包中。它们通过高效的并发控制机制（如CAS操作、分段锁等）解决了传统集合（如<code>ArrayList</code>、<code>HashMap</code>）在多线程下的性能与安全问题。

== 概述 ==  
Java并发集合的核心目标是：  
* '''线程安全'''：无需外部同步即可在多线程环境下使用。  
* '''高性能'''：通过细粒度锁或无锁算法减少竞争。  
* '''可扩展性'''：适合高并发场景。  

与使用<code>Collections.synchronizedXXX()</code>包装的集合相比，并发集合在吞吐量和一致性上更具优势。

== 主要并发集合类 ==  
以下是<code>java.util.concurrent</code>包中的关键实现：

=== 1. ConcurrentHashMap ===  
高并发优化的哈希表，通过分段锁（JDK 7）或CAS+synchronized（JDK 8+）实现线程安全。  

'''示例代码：'''  
<syntaxhighlight lang="java">  
import java.util.concurrent.ConcurrentHashMap;  

public class ConcurrentHashMapExample {  
    public static void main(String[] args) {  
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();  
        map.put("A", 1);  
        map.putIfAbsent("B", 2); // 原子操作  
        System.out.println(map.get("A")); // 输出: 1  
    }  
}  
</syntaxhighlight>  

=== 2. CopyOnWriteArrayList ===  
通过写时复制（Copy-On-Write）实现的线程安全列表，适合读多写少的场景。  

'''示例代码：'''  
<syntaxhighlight lang="java">  
import java.util.concurrent.CopyOnWriteArrayList;  

public class CopyOnWriteExample {  
    public static void main(String[] args) {  
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();  
        list.add("Java");  
        list.add("Python");  
        list.forEach(System.out::println); // 线程安全遍历  
    }  
}  
</syntaxhighlight>  

=== 3. BlockingQueue 接口 ===  
支持阻塞操作的队列，常用于生产者-消费者模型。实现类包括：  
* <code>ArrayBlockingQueue</code>：基于数组的有界队列  
* <code>LinkedBlockingQueue</code>：基于链表的可选有界队列  

'''示例代码：'''  
<syntaxhighlight lang="java">  
import java.util.concurrent.ArrayBlockingQueue;  

public class BlockingQueueExample {  
    public static void main(String[] args) throws InterruptedException {  
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);  
        queue.put("Task1"); // 阻塞直到空间可用  
        String task = queue.take(); // 阻塞直到元素可用  
    }  
}  
</syntaxhighlight>  

== 并发控制机制 ==  
Java并发集合通过以下技术实现线程安全：  

<mermaid>  
flowchart LR  
    A[并发集合] --> B[锁分段技术]  
    A --> C[CAS操作]  
    A --> D[写时复制]  
    B --> E[ConcurrentHashMap JDK7]  
    C --> F[ConcurrentHashMap JDK8+]  
    D --> G[CopyOnWriteArrayList]  
</mermaid>  

数学上，CAS操作可以表示为：  
<math>  
\text{CAS}(V, E, N) = \begin{cases}  
\text{true} & \text{if } V = E \text{ then } V \gets N \\  
\text{false} & \text{otherwise}  
\end{cases}  
</math>  

== 实际应用案例 ==  
'''场景：'''Web服务器请求计数器  
使用<code>ConcurrentHashMap</code>统计不同API的访问次数：  

<syntaxhighlight lang="java">  
import java.util.concurrent.ConcurrentHashMap;  

public class RequestCounter {  
    private final ConcurrentHashMap<String, Integer> counter = new ConcurrentHashMap<>();  

    public void increment(String apiPath) {  
        counter.compute(apiPath, (k, v) -> (v == null) ? 1 : v + 1);  
    }  

    public int getCount(String apiPath) {  
        return counter.getOrDefault(apiPath, 0);  
    }  
}  
</syntaxhighlight>  

== 性能对比 ==  
{| class="wikitable"  
|+ 并发集合 vs 同步包装集合  
! 操作 !! <code>ConcurrentHashMap</code> !! <code>Collections.synchronizedMap</code>  
|-  
| 读操作 || 无锁 || 全表锁  
|-  
| 写操作 || 分段锁/CAS || 全表锁  
|}  

== 最佳实践 ==  
* 优先使用<code>ConcurrentHashMap</code>而非<code>Hashtable</code>  
* 读多写少时选择<code>CopyOnWriteArrayList</code>  
* 避免在迭代过程中修改<code>ConcurrentHashMap</code>（弱一致性迭代器）  

== 参见 ==  
* [[Java内存模型]]  
* [[Java并发工具类]]  

{{Java集合框架导航}}

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java集合框架]]