汤不热吧并发编程是Java开发中最重要的进阶技能之一。无论是构建高并发的Web服务，还是处理海量数据的批处理任务，深入理解Java并发机制都是每个后端工程师的必修课。本文将从线程池的底层原理出发，深入剖析Java锁机制的演进，再结合并发容器的选型与实战，帮助读者构建完整的Java并发编程知识体系。
一、线程池：Executor框架深度解析
线程池是Java并发编程中最核心的工具之一。它通过复用线程、控制并发度、管理任务队列，极大地提升了多线程应用的性能和稳定性。
1.1 ThreadPoolExecutor核心参数
理解ThreadPoolExecutor的七个核心参数是使用线程池的基础：
| 参数 | 作用 | 说明 |
|---|---|---|
| corePoolSize | 核心线程数 | 即使空闲也保留的线程数量 |
| maximumPoolSize | 最大线程数 | 线程池允许创建的最大线程数量 |
| keepAliveTime | 空闲存活时间 | 超过核心线程数的线程空闲后的存活时间 |
| unit | 时间单位 | keepAliveTime的时间单位 |
| workQueue | 任务队列 | 存储等待执行任务的阻塞队列 |
| threadFactory | 线程工厂 | 创建新线程的工厂 |
| handler | 拒绝策略 | 任务无法执行时的处理策略 |
线程池的工作流程可以概括为以下步骤：
- 提交任务时，如果当前线程数小于corePoolSize，创建新线程执行任务
- 如果当前线程数达到corePoolSize，将任务放入workQueue
- 如果workQueue已满，且当前线程数小于maximumPoolSize，创建新线程执行任务
- 如果当前线程数达到maximumPoolSize，执行拒绝策略
1.2 四种常用线程池及适用场景
Executors工厂类提供了四种预定义的线程池，但实际生产环境中更推荐直接使用ThreadPoolExecutor来精确控制参数：
2
3
4
5
6
7
8
9
10
11
12
13
14
ExecutorService fixedPool = Executors.newFixedThreadPool(10);
// 底层：new ThreadPoolExecutor(n, n, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
// 2. 缓存线程池 - 适合大量短生命周期任务
ExecutorService cachedPool = Executors.newCachedThreadPool();
// 底层：new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>())
// 3. 单线程池 - 适合需要顺序执行任务的场景
ExecutorService singlePool = Executors.newSingleThreadExecutor();
// 4. 调度线程池 - 适合定时或周期性任务
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);
scheduledPool.scheduleAtFixedRate(task, 0, 10, TimeUnit.SECONDS);
1.3 生产级线程池配置实践
在实际生产环境中，我们更推荐手动创建ThreadPoolExecutor：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Runtime.getRuntime().availableProcessors() * 2, // corePoolSize
Runtime.getRuntime().availableProcessors() * 4, // maximumPoolSize
60L, TimeUnit.SECONDS, // keepAliveTime
new LinkedBlockingQueue<>(1000), // 有界队列，防止内存溢出
new ThreadFactoryBuilder().setNameFormat("biz-pool-%d").build(), // 自定义线程名，方便排查
new ThreadPoolExecutor.CallerRunsPolicy() // 调用者运行策略，避免丢弃任务
);
// 监控线程池状态
executor.submit(() -> {
System.out.println(String.format(
"poolSize: %d, activeCount: %d, completedTaskCount: %d, queueSize: %d",
executor.getPoolSize(),
executor.getActiveCount(),
executor.getCompletedTaskCount(),
executor.getQueue().size()
));
});
核心配置原则：
- CPU密集型任务：corePoolSize = CPU核心数 + 1
- IO密集型任务：corePoolSize = CPU核心数 × 2（等待时间/计算时间 + 1）
- 混合型任务：按比例拆分，分别配置线程池
- 务必使用有界队列：无界队列可能导致内存溢出
- 自定义拒绝策略：CallerRunsPolicy是最安全的选择
二、锁机制：从synchronized到AQS的演进之路
Java锁机制经历了从重量级到轻量级的演进，理解其底层原理对于编写高性能并发代码至关重要。
2.1 synchronized关键字：JVM层面的锁
synchronized是Java最基础的同步机制。在JDK 6之后，JVM对其进行了大量优化，引入了偏向锁、轻量级锁和重量级锁的升级机制：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 示例：使用synchronized实现线程安全的计数器
public class SafeCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
// 锁升级过程：
// 1. 偏向锁：只有一个线程访问时，记录线程ID，无需CAS
// 2. 轻量级锁：多个线程交替访问时，使用CAS自旋
// 3. 重量级锁：锁竞争激烈时，升级为OS互斥量，线程阻塞
锁升级的触发条件：
- 有线程竞争偏向锁 → 偏向锁撤销，升级为轻量级锁
- 自旋超过阈值（默认10次）或自旋线程数超过CPU核心数一半 → 升级为重量级锁
2.2 JUC锁：Lock接口与AQS
java.util.concurrent.locks包提供了比synchronized更灵活的锁机制，其核心是AbstractQueuedSynchronizer（AQS）框架：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
ReentrantLock lock = new ReentrantLock(true); // 公平锁
lock.lock();
try {
// 临界区代码
System.out.println("获取锁成功，当前线程：" + Thread.currentThread().getName());
} finally {
lock.unlock(); // 必须在finally中释放锁
}
// 读写锁：读读不互斥，读写互斥，写写互斥
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();
// 读操作
readLock.lock();
try {
// 多个线程可同时读取
Map<String, Object> cache = getCache();
return cache.get(key);
} finally {
readLock.unlock();
}
// 写操作
writeLock.lock();
try {
// 写操作需要独占锁
updateCache(key, value);
} finally {
writeLock.unlock();
}
2.3 AQS核心原理
AQS（AbstractQueuedSynchronizer）是JUC锁和同步器的基石。它维护了一个volatile int state（同步状态）和一个CLH双向队列（等待队列）：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// state: 0表示锁未被持有，1表示被持有，>1表示可重入
// head: 等待队列的头节点
// tail: 等待队列的尾节点
// 自定义一个共享锁，最多允许N个线程同时访问
public class SharedLock {
private final Sync sync;
public SharedLock(int maxCount) {
sync = new Sync(maxCount);
}
static class Sync extends AbstractQueuedSynchronizer {
Sync(int maxCount) {
setState(maxCount);
}
@Override
protected int tryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 || compareAndSetState(available, remaining)) {
return remaining;
}
}
}
@Override
protected boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (compareAndSetState(current, next)) {
return true;
}
}
}
}
public void acquire() { sync.acquireShared(1); }
public void release() { sync.releaseShared(1); }
}
AQS同时支持独占模式（如ReentrantLock）和共享模式（如Semaphore、CountDownLatch），提供模板方法模式让子类只需实现tryAcquire/tryRelease等钩子方法。
2.4 锁的性能对比与选型
| 锁类型 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| synchronized | 使用简单、JVM自动优化 | 不可中断、无法超时 | 简单同步场景 |
| ReentrantLock | 可中断、可超时、支持公平锁、支持Condition | 需手动释放 | 复杂同步需求 |
| ReentrantReadWriteLock | 读写分离、读操作高并发 | 写锁饥饿 | 读多写少场景 |
| StampedLock | 读写效率最高、支持乐观读 | 不可重入、API复杂 | 高并发读场景 |
三、并发容器：线程安全的数据结构选型指南
Java提供了丰富的并发容器，选择合适的容器可以大幅提升并发程序的性能。
3.1 ConcurrentHashMap
ConcurrentHashMap是Java中最常用的并发容器，JDK 1.8后采用数组+链表/红黑树 + CAS + synchronized的实现方式：
2
3
4
5
6
7
8
9
10
11
12
13
14
// 1. 使用Node数组存储数据
// 2. 使用CAS操作插入头节点
// 3. 使用synchronized锁住链表头节点或红黑树根节点
// 4. 链表长度超过8时转为红黑树
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
// 常用方法：
map.put("key", "value"); // 线程安全的put
map.putIfAbsent("key", "value"); // 不存在时才put（原子操作）
map.computeIfAbsent("key", k -> fetchExpensiveData(k)); // 延迟加载
map.forEach((k, v) -> System.out.println(k + ":" + v)); // 线程安全的遍历
map.mappingCount(); // 更精确的元素计数
核心设计亮点：
- 细粒度锁：每个桶一把锁，只有哈希冲突时才会加锁
- CAS操作：插入新节点使用CAS无锁操作
- 红黑树优化：链表长度超过阈值时转红黑树，查询从O(n)降至O(log n)
3.2 CopyOnWriteArrayList
写时复制容器，适用于读多写少的场景：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 观察者模式的典型应用
private CopyOnWriteArrayList<Listener> listeners = new CopyOnWriteArrayList<>();
public void addListener(Listener listener) {
listeners.add(listener); // 创建新数组，成本高
}
public void notifyAll(Event event) {
// 读操作无需加锁，直接遍历
for (Listener listener : listeners) {
listener.onEvent(event);
}
}
}
适用场景：事件监听器列表、缓存白名单、配置信息等读操作远多于写操作的场景。
3.3 BlockingQueue系列
阻塞队列是生产者-消费者模式的核心组件：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
BlockingQueue<String> queue = new ArrayBlockingQueue<>(1000);
// LinkedBlockingQueue：可选有界/无界，基于链表
BlockingQueue<String> queue2 = new LinkedBlockingQueue<>();
// DelayQueue：延迟队列，元素到期才能取出
DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
// PriorityBlockingQueue：优先级阻塞队列
BlockingQueue<Task> priorityQueue = new PriorityBlockingQueue<>();
// 实际应用：实现一个简单的请求限流器
public class RateLimiter {
private final BlockingQueue<Long> requestTimestamps;
private final int maxRequestsPerSecond;
public RateLimiter(int maxRequestsPerSecond) {
this.maxRequestsPerSecond = maxRequestsPerSecond;
this.requestTimestamps = new LinkedBlockingQueue<>(maxRequestsPerSecond);
}
public boolean tryAcquire() {
long now = System.currentTimeMillis();
// 清理1秒前的记录
while (!requestTimestamps.isEmpty() &&
requestTimestamps.peek() < now - 1000) {
requestTimestamps.poll();
}
if (requestTimestamps.size() < maxRequestsPerSecond) {
requestTimestamps.offer(now);
return true; // 允许请求
}
return false; // 限流
}
}
3.4 并发容器性能对比
| 容器 | 并发度 | 读性能 | 写性能 | 内存开销 |
|---|---|---|---|---|
| ConcurrentHashMap | 高（桶粒度） | 极高（无锁读） | 高 | 低 |
| CopyOnWriteArrayList | 低（全量复制） | 极高（无锁读） | 低（复制数组） | 高 |
| LinkedBlockingQueue | 中（双锁） | 中 | 中 | 中 |
| ConcurrentLinkedQueue | 高（CAS） | 高 | 高（CAS） | 中 |
四、实战：构建高并发缓存系统
下面我们将综合运用上述知识，构建一个高并发缓存系统：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
private final ConcurrentHashMap<K, CacheEntry<V>> cache;
private final ReadWriteLock lock;
private final ScheduledExecutorService cleanupExecutor;
private final int expireAfterWriteSeconds;
public HighConcurrencyCache(int expireAfterWriteSeconds) {
this.cache = new ConcurrentHashMap<>();
this.lock = new ReentrantReadWriteLock();
this.expireAfterWriteSeconds = expireAfterWriteSeconds;
this.cleanupExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "cache-cleanup");
t.setDaemon(true);
return t;
});
// 定期清理过期缓存
cleanupExecutor.scheduleAtFixedRate(
this::cleanup, 1, 1, TimeUnit.MINUTES);
}
public V get(K key, Function<K, V> loader) {
CacheEntry<V> entry = cache.get(key);
// 缓存命中且未过期
if (entry != null && !entry.isExpired()) {
return entry.getValue();
}
// 缓存未命中或已过期，使用computeIfAbsent原子加载
try {
lock.readLock().lock();
// 双重检查
entry = cache.get(key);
if (entry != null && !entry.isExpired()) {
return entry.getValue();
}
} finally {
lock.readLock().unlock();
}
// 使用putIfAbsent防止缓存击穿
V value = loader.apply(key);
CacheEntry<V> newEntry = new CacheEntry<>(value, expireAfterWriteSeconds);
try {
lock.writeLock().lock();
cache.putIfAbsent(key, newEntry);
} finally {
lock.writeLock().unlock();
}
return value;
}
public void invalidate(K key) {
try {
lock.writeLock().lock();
cache.remove(key);
} finally {
lock.writeLock().unlock();
}
}
private void cleanup() {
cache.entrySet().removeIf(entry -> entry.getValue().isExpired());
}
public long size() {
return cache.mappingCount();
}
private static class CacheEntry<V> {
private final V value;
private final long expireAt;
CacheEntry(V value, int ttlSeconds) {
this.value = value;
this.expireAt = System.currentTimeMillis() + ttlSeconds * 1000L;
}
V getValue() { return value; }
boolean isExpired() { return System.currentTimeMillis() > expireAt; }
}
}
这个缓存系统综合运用了：
- ConcurrentHashMap 提供高效的线程安全存储
- ReadWriteLock 保护批量操作的一致性
- computeIfAbsent / putIfAbsent 防止缓存击穿
- ScheduledExecutorService 定期清理过期缓存
- 自定义线程工厂 方便运维排查问题
五、常见并发问题与最佳实践
5.1 死锁检测与预防
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class DeadlockExample {
private static final Object lockA = new Object();
private static final Object lockB = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (lockA) {
System.out.println("T1: 持有锁A");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (lockB) {
System.out.println("T1: 持有锁B");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (lockB) {
System.out.println("T2: 持有锁B");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (lockA) {
System.out.println("T2: 持有锁A");
}
}
});
t1.start();
t2.start();
}
}
// 使用jstack检测死锁
// jstack <pid> | grep -A 10 "deadlock"
预防死锁的原则：
- 固定锁顺序：所有线程按相同顺序获取锁
- 锁超时：使用tryLock(long timeout, TimeUnit unit)代替lock()
- 缩小锁范围：只在必要时加锁，减少持锁时间
- 使用高层工具：优先使用并发容器和同步工具而非手动锁
5.2 线程安全最佳实践清单
- 优先使用不可变对象：final字段、不提供修改方法
- 线程封闭：局部变量永远是线程安全的
- 使用并发容器：代替手动同步的HashMap/ArrayList
- 正确发布对象：使用volatile或final确保可见性
- 避免this在构造期间逸出：不要在构造器中启动线程
- 使用已有的同步工具：CountDownLatch、CyclicBarrier、Semaphore等
- 合理设置线程名：自定义ThreadFactory，方便排查问题
- 监控线程池指标：记录活跃线程数、队列长度、拒绝次数
结语
Java并发编程是一个需要持续积累的领域。从线程池的合理配置，到锁机制的正确选择，再到并发容器的精准使用，每个环节都直接影响着系统的性能和稳定性。本文涵盖了并发编程的核心知识点，但真正的掌握还需要在实际项目中不断实践和总结。
建议读者在开发过程中：
- 使用jstack、jvisualvm等工具分析线程状态
- 关注Java新版本（特别是LTS版本）带来的并发新特性
- 在代码Review中重点关注同步策略的正确性
- 定期进行压力测试，验证并发代码的稳定性
记住一句箴言：最好的并发代码，往往是根本不需要加锁的代码。通过合理的数据结构设计、不可变对象和线程封闭等技术，很多时候可以避免复杂的锁竞争，从而获得更好的性能和更低的维护成本。