Java 多线程并发编程中的核心容器与协作工具。详细讲解了 ConcurrentHashMap 的分段锁与 CAS 原理、CopyOnWriteArrayList 的写时复制机制以及 BlockingQueue 的阻塞特性。同时阐述了 CountDownLatch、CyclicBarrier 和 Semaphore 的使用场景与代码实现。最后通过生产者消费者模式案例，展示了如何结合并发容器解决实际问题，提供了选型建议以提升系统性能与稳定性。
💡 学习目标：掌握 JAVA 中常用并发容器的特性与适用场景，理解线程间协作的核心原理，能够运用并发容器和协作工具解决实际并发问题。
💡 学习重点：并发容器与普通容器的区别、ConcurrentHashMap 核心原理、CountDownLatch/CyclicBarrier/Semaphore 的使用、生产者消费者模式实现。
在多线程场景下，普通的集合容器（如 HashMap、ArrayList）是线程不安全的。多个线程同时对其进行读写操作时，会导致数据错乱、ConcurrentModificationException 异常等问题。
⚠️ 注意事项：即使使用 Collections.synchronizedXXX() 方法包装普通容器，也只是通过 synchronized 实现简单的加锁。这种方式锁粒度较粗，并发性能较低。
✅ 核心结论：并发容器是 JAVA 为多线程场景设计的高性能容器。它们通过细粒度锁或无锁算法实现线程安全，能够在保证数据一致性的同时，大幅提升并发访问效率。
ConcurrentHashMap：高效并发哈希表ConcurrentHashMap 是 HashMap 的并发安全版本，是日常开发中使用频率最高的并发容器。
synchronized 实现。锁粒度缩小到单个 Node 节点，并发性能进一步提升。volatile 保证可见性），写操作仅锁定当前节点，不会阻塞其他操作。null 键值：与 HashMap 不同，ConcurrentHashMap 的键和值都不能为 null，避免歧义。import java.util.concurrent.ConcurrentHashMap;
/**
* ConcurrentHashMap 实战示例
*/
public class ConcurrentHashMapDemo {
public static void main(String[] args) throws InterruptedException {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// 1. 插入数据
map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 30);
// 2. 并发修改数据
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
// 原子性操作：获取并增加
map.computeIfPresent("apple", (k, v) -> v + 1);
System.out.println(Thread.currentThread().getName() + " : apple = " + map.get("apple"));
}
}, "线程 1");
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
map.computeIfPresent("apple", (k, v) -> v + 1);
System.out.println(Thread.currentThread().getName() + " : apple = " + map.get("apple"));
}
}, "线程 2");
thread1.start();
thread2.start();
thread1.join();
thread2.join();
// 3. 遍历数据
map.forEach((k, v) -> System.out.println(k + " : " + v));
}
}
CopyOnWriteArrayList：写时复制数组CopyOnWriteArrayList 是 ArrayList 的并发安全版本，核心思想是写时复制。
① 📝 写操作：当执行添加、删除、修改操作时，会复制一份新的数组。在新数组上完成操作后，再将原数组的引用指向新数组。 ② 🔍 读操作：直接读取原数组，无需加锁，保证了读操作的高效性。 ③ ⚠️ 数据一致性：写操作是原子性的，读操作可能读取到旧数据。该容器适用于读多写少的场景。
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* CopyOnWriteArrayList 实战示例
*/
public class CopyOnWriteArrayListDemo {
public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("Java");
list.add("Python");
list.add("Go");
// 1. 并发遍历与添加
Thread writeThread = new Thread(() -> {
list.add("C++");
System.out.println(Thread.currentThread().getName() + " 添加元素：C++");
}, "写线程");
Thread readThread = new Thread(() -> {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(Thread.currentThread().getName() + " 遍历元素：" + iterator.next());
// 模拟延迟
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "读线程");
readThread.start();
Thread.sleep(50);
writeThread.start();
readThread.join();
writeThread.join();
// 2. 最终遍历结果
System.out.println("最终集合元素：" + list);
}
}
BlockingQueue：阻塞队列BlockingQueue 是一个支持阻塞操作的队列，是实现生产者消费者模式的核心工具。
ArrayBlockingQueue（数组实现，有界）、LinkedBlockingQueue（链表实现，可选有界）、SynchronousQueue（同步队列，无容量）。| 方法类型 | 抛出异常 | 返回特殊值 | 阻塞 | 超时退出 |
|---|---|---|---|---|
| 入队 | add(e) | offer(e) | put(e) | offer(e, time, unit) |
| 出队 | remove() | poll() | take() | poll(time, unit) |
| 检查 | element() | peek() | - | - |
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* BlockingQueue 实战示例
*/
public class BlockingQueueDemo {
// 定义有界阻塞队列，容量为 3
private static final BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
public static void main(String[] args) {
// 生产者线程
new Thread(() -> {
String[] products = {"产品 A", "产品 B", "产品 C", "产品 D"};
for (String product : products) {
try {
System.out.println(Thread.currentThread().getName() + " 生产：" + product);
queue.put(product);
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "生产者").start();
// 消费者线程
new Thread(() -> {
while (true) {
try {
String product = queue.take();
System.out.println(Thread.currentThread().getName() + " 消费：" + product);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, ).start();
}
}
在复杂的并发场景中，需要多个线程协同完成任务。JAVA 提供了 CountDownLatch、CyclicBarrier、Semaphore 等工具类，简化线程协作的开发。
CountDownLatch：倒计时门闩CountDownLatch 允许一个或多个线程等待其他线程完成操作后，再继续执行。
countDown() 方法，计数器值减 1。await() 方法，会阻塞直到计数器值变为 0。CountDownLatch 只能使用一次。import java.util.concurrent.CountDownLatch;
/**
* CountDownLatch 实战：多线程数据统计
*/
public class CountDownLatchDemo {
// 定义计数器，需要等待 3 个任务完成
private static final CountDownLatch latch = new CountDownLatch(3);
public static void main(String[] args) throws InterruptedException {
System.out.println("主线程：开始执行数据统计任务");
// 任务 1：用户数据统计
new Thread(() -> {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "：用户数据统计完成");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}, "任务线程 1").start();
// 任务 2：订单数据统计
new Thread(() -> {
try {
Thread.sleep(1500);
System.out.println(Thread.currentThread().getName() + "：订单数据统计完成");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}, "任务线程 2").start();
// 任务 3：商品数据统计
new Thread(() -> {
{
Thread.sleep();
System.out.println(Thread.currentThread().getName() + );
} (InterruptedException e) {
e.printStackTrace();
} {
latch.countDown();
}
}, ).start();
latch.await();
System.out.println();
}
}
CyclicBarrier：循环栅栏CyclicBarrier 允许一组线程相互等待，直到所有线程都到达某个屏障点后，再继续执行。
await() 方法，会阻塞直到所有线程都到达。CyclicBarrier可以重复使用。import java.util.concurrent.CyclicBarrier;
/**
* CyclicBarrier 实战：数据分片处理
*/
public class CyclicBarrierDemo {
// 定义循环栅栏，4 个线程参与，所有线程到达后执行屏障动作
private static final CyclicBarrier barrier = new CyclicBarrier(4, () -> {
System.out.println("屏障动作：所有分片数据处理完成，开始合并结果");
});
public static void main(String[] args) {
// 模拟 4 个数据分片
for (int i = 0; i < 4; i++) {
int shard = i + 1;
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() + "：处理分片" + shard + "数据");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "：分片" + shard + "处理完成，等待其他线程");
// 到达屏障点
barrier.await();
System.out.println(Thread.currentThread().getName() + "：结果合并完成，继续后续任务");
} catch (Exception e) {
e.printStackTrace();
}
}, "分片线程" + shard).start();
}
}
}
CountDownLatch vs CyclicBarrier| 特性 | CountDownLatch | CyclicBarrier |
|---|---|---|
| 计数器重置 | 不可重置，只能用一次 | 可重置，可重复使用 |
| 等待方向 | 一个或多个线程等待其他线程 | 多个线程相互等待 |
| 核心场景 | 主线程等待子线程完成 | 线程组协同完成任务 |
Semaphore：信号量Semaphore 用于控制同时访问特定资源的线程数量，通过许可证机制实现资源限流。
acquire() 方法获取许可证。无可用许可证时，线程会阻塞。release() 方法归还许可证。import java.util.concurrent.Semaphore;
/**
* Semaphore 实战：接口限流
*/
public class SemaphoreDemo {
// 定义信号量，允许 3 个线程同时访问
private static final Semaphore semaphore = new Semaphore(3);
// 模拟接口方法
public static void apiInvoke(String threadName) throws InterruptedException {
// 获取许可证
semaphore.acquire();
try {
System.out.println(threadName + "：获取许可证，开始调用接口");
Thread.sleep(1000);
System.out.println(threadName + "：接口调用完成");
} finally {
// 归还许可证
semaphore.release();
System.out.println(threadName + "：归还许可证，当前可用许可证：" + semaphore.availablePermits());
}
}
public static void main(String[] args) {
// 模拟 10 个线程并发调用接口
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
try {
apiInvoke( + finalI);
} (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
}
生产者消费者模式是并发编程中的经典模式。它通过阻塞队列解耦生产者和消费者，平衡生产和消费速度。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* 实战：基于 BlockingQueue 实现生产者消费者模式
*/
public class ProducerConsumerPattern {
// 定义有界阻塞队列，容量为 5
private static final BlockingQueue<Product> queue = new ArrayBlockingQueue<>(5);
// 商品实体类
static class Product {
private String id;
private String name;
public Product(String id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Product{id='" + id + "', name='" + name + "'}";
}
}
// 生产者类
static class Producer implements Runnable {
private String producerName;
public Producer(String producerName) {
this.producerName = producerName;
}
@Override
public void run {
;
() {
{
( + count, + count);
queue.put(product);
System.out.println(producerName + + product + + queue.size());
count++;
TimeUnit.SECONDS.sleep();
} (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
}
{
String consumerName;
{
.consumerName = consumerName;
}
{
() {
{
queue.take();
System.out.println(consumerName + + product + + queue.size());
TimeUnit.SECONDS.sleep();
} (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
}
{
( ()).start();
( ()).start();
( ()).start();
( ()).start();
( ()).start();
}
}
✅ 实战结论：基于 BlockingQueue 实现生产者消费者模式，无需手动加锁和控制线程状态。这种方式代码简洁、性能稳定，是并发编程中的优选方案。
| 工具类型 | 具体实现 | 核心优势 | 适用场景 |
|---|---|---|---|
| 并发 Map | ConcurrentHashMap | 高并发读写、细粒度锁 | 缓存存储、键值对数据共享 |
| 并发 List | CopyOnWriteArrayList | 读操作无锁、性能高 | 读多写少、配置列表 |
| 阻塞队列 | ArrayBlockingQueue/LinkedBlockingQueue | 自动阻塞、解耦生产者消费者 | 任务队列、消息传递 |
| 线程协作 | CountDownLatch | 主线程等待子线程完成 | 任务汇总、系统启动 |
| 线程协作 | CyclicBarrier | 线程组相互等待、可重复使用 | 数据分片处理、批量任务 |
| 限流工具 | Semaphore | 控制并发访问数 | 接口限流、资源池管理 |
💡 本章重点讲解了 JAVA 中常用的并发容器和线程协作工具。包括 ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue 的核心原理与使用方法，以及 CountDownLatch、CyclicBarrier、Semaphore 三个协作工具的实战场景。
💡 通过生产者消费者模式的完整案例，掌握了如何结合并发容器和协作工具，实现高效、安全的并发编程。
✅ 并发容器和协作工具是 JAVA 并发编程的核心组件。合理选择和使用这些工具，能够大幅降低并发编程的复杂度，提升系统的稳定性和性能。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online