在现代高并发系统开发中,Java线程安全的手段已成为开发者必须掌握的核心技能。随着多核处理器的普及和分布式架构的演进,单机并发能力成为系统性能的关键瓶颈。若缺乏有效的线程安全保障机制,轻则导致数据错乱、业务异常,重则引发服务雪崩,造成严重生产事故。本页面系统梳理Java线程安全的手段,从底层原理到工程实践,结合真实业务场景,帮助开发者构建健壮、高效、可维护的并发程序。
需要明确的是,线程安全并非简单的“加锁”问题,而是涉及JVM内存模型、指令重排序、可见性、原子性、有序性等多维度的综合保障体系。在JDK 1.5之后,随着java.util.concurrent包的引入,Java提供了从底层锁(synchronized)到高级抽象(CompletableFuture、ForkJoinPool)的完整工具链。本文将围绕以下核心维度展开:synchronized、ReentrantLock、volatile、ThreadLocal、CAS机制、并发容器、线程池隔离等,每部分均配以深度解析与可运行代码示例。
以电商秒杀场景为例:若库存扣减未做线程安全保护,100件商品可能被超卖至120件,直接导致财务损失;在金融交易中,账户余额未同步更新,可能造成资金重复入账或丢失;在日志系统中,多线程写入未加锁的日志组件,可能引发日志内容错乱、丢失或服务阻塞。据2025年阿里云安全报告统计,约32%的线上故障源于并发问题,其中78%与Java线程安全的手段误用或缺失相关。因此,深入理解并正确应用线程安全的手段,是保障系统稳定性的基石。
从实现层级看,线程安全的手段可分为三类:底层JVM指令级保障(如volatile、final)、语言级同步机制(如synchronized、Lock)、库级并发工具(如ConcurrentHashMap、AtomicInteger)。三者构成由低到高的完整防护体系。
Java内存模型(JMM)定义了线程如何与主内存交互。其核心特性包括:
long、double除外)为原子操作;复杂操作需借助synchronized或Atomic*类保障。volatile通过内存屏障强制刷新主内存;synchronized通过获取锁时刷新工作内存实现。happens-before原则约束重排序,其中volatile写-读、synchronized锁-释放是强有序保障。volatile变量的读写具备原子性,复合操作(如i++)即使变量为volatile仍非原子,需额外加锁。
下表对比主流语言级线程安全的手段的适用场景与性能特征:
| 手段 | 实现方式 | 是否可中断 | 是否可超时 | 公平性 | 适用场景 |
|---|---|---|---|---|---|
synchronized | 对象监视器(Monitor) | 否 | 否 | 非公平 | 简单同步、临界区小 |
ReentrantLock | Unsafe + AQS | 是(lockInterruptibly) | 是(tryLock) | 可选(构造参数) | 复杂同步、需要中断/超时控制 |
ReentrantReadWriteLock | AQS共享锁+独占锁 | 是 | 是 | 可选 | 读多写少场景 |
volatile | 内存屏障 | 不适用 | 不适用 | 不适用 | 状态标志、单次写入 |
需特别注意:synchronized在JDK 1.6后引入偏向锁、轻量级锁等优化,其性能已接近ReentrantLock。对于简单同步场景,优先使用synchronized以减少代码复杂度。
java.util.concurrent(JUC)提供了丰富的线程安全的手段:
AtomicInteger、AtomicReference等基于CAS实现无锁并发,适用于计数器、状态更新。ConcurrentHashMap分段锁/红黑树优化;CopyOnWriteArrayList适用于读多写少场景。CountDownLatch(倒计时)、CyclicBarrier(循环栅栏)、Semaphore(信号量)。ThreadPoolExecutor提供精细化的线程管理策略。以ConcurrentHashMap为例,其在JDK 1.8中放弃分段锁,改用synchronized + CAS + 红黑树,兼顾读写性能与内存开销。
某电商系统需支持10万QPS的库存扣减,原始代码存在超卖风险:
// ❌ 错误示例:非线程安全
public class StockService {
private int stock = 100;
public boolean deduct() {
if (stock > 0) {
stock--; // 多线程下可能同时判断stock>0,导致超卖
return true;
}
return false;
}
}
采用synchronized保障原子性:
// ✅ 正确示例:synchronized同步方法
public class StockService {
private int stock = 100;
public synchronized boolean deduct() {
if (stock > 0) {
stock--;
return true;
}
return false;
}
}
进一步优化为ReentrantLock,支持超时与中断:
// ✅ 高级方案:ReentrantLock + 超时控制
public class StockService {
private int stock = 100;
private final ReentrantLock lock = new ReentrantLock();
public boolean deduct() {
if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
try {
if (stock > 0) {
stock--;
return true;
}
} finally {
lock.unlock();
}
}
return false; // 超时未获取锁
}
}
若需更高性能,可结合AtomicInteger与CAS自旋:
// ✅ 无锁方案:AtomicInteger + CAS
public class StockService {
private AtomicInteger stock = new AtomicInteger(100);
public boolean deduct() {
while (true) {
int current = stock.get();
if (current <= 0) return false;
if (stock.compareAndSet(current, current - 1)) {
return true;
}
}
}
}
注:CAS方案在高竞争下自旋开销大,需评估业务场景。秒杀场景建议结合Redis分布式锁或数据库乐观锁。
synchronized的5种锁状态演进JDK 1.6引入锁升级机制,避免直接进入重量级锁:
对象未被任何线程持有,偏向锁未启用或已撤销。
第一个线程获取锁时,将对象头Mark Word中的线程ID设为当前线程;后续该线程再次请求锁时无需CAS,直接进入。
多个线程交替执行时,通过CAS自旋获取锁,避免OS挂起线程的开销。
轻量级锁自旋失败后,若预测短时间可释放,继续自旋(默认10次)。
自旋多次失败后,升级为OS互斥量,挂起等待线程。
可通过-XX:+UseBiasedLocking启用/禁用偏向锁(JDK 15后默认关闭)。
ReentrantLock的公平性与条件变量ReentrantLock支持公平锁(true)与非公平锁(默认false):
// 公平锁:按请求顺序获取锁,避免线程饥饿
ReentrantLock fairLock = new ReentrantLock(true);
// 非公平锁:允许插队,吞吐量更高
ReentrantLock unfairLock = new ReentrantLock();
结合Condition实现精确线程等待/通知:
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await(); // 等待非满条件
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal(); // 唤醒消费者
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await(); // 等待非空条件
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal(); // 唤醒生产者
return x;
} finally {
lock.unlock();
}
}
}
相比Object.wait()/notify(),Condition支持多条件队列,避免“惊群效应”。
volatile的深度应用volatile的可见性保障机制volatile通过插入内存屏障(Memory Barrier)实现:
典型应用场景:
// ✅ 状态标志:线程间通信
public class ShutdownDemo {
private volatile boolean shutdownRequested;
public void shutdown() {
shutdownRequested = true;
}
public void run() {
while (!shutdownRequested) {
// 执行任务
}
}
}
⚠️ 注意:volatile不保证复合操作的原子性!以下代码仍需加锁:
// ❌ 错误示例:volatile++非原子
public class Counter {
private volatile int count = 0;
public void increment() {
count++; // 实际为:读取→加1→写入,非原子
}
}
正确实现应使用AtomicInteger:
// ✅ 正确示例
public class Counter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // CAS保证原子性
}
}
ThreadLocal的线程隔离机制ThreadLocal为每个线程提供变量副本,实现“以空间换时间”的线程安全:
public class UserContext {
private static final ThreadLocal currentUser =
ThreadLocal.withInitial(() -> "anonymous");
public static void set(String user) {
currentUser.set(user);
}
public static String get() {
return currentUser.get();
}
public static void remove() {
currentUser.remove(); // 防止内存泄漏!
}
}
⚠️ 注意:ThreadLocal的内存泄漏风险!在线程池场景中,线程复用导致ThreadLocalMap的Entry无法回收。必须调用remove()显式清理:
finally块中调用ThreadLocal.remove(),或使用InheritableThreadLocal传递子线程上下文。
典型应用:数据库连接管理、Spring的TransactionSynchronizationManager、日志TraceID透传。
CAS(Compare-And-Swap)通过硬件指令保障原子性,但存在ABA问题:
解决方案:使用AtomicStampedReference添加版本戳:
AtomicStampedReference ref =
new AtomicStampedReference<>(100, 1);
// 线程1:获取当前值和版本
int[] stamp = new int[1];
int value = ref.get(stamp);
// 线程2:修改值为200,版本+1
ref.compareAndSet(100, 200, stamp[0], stamp[0] + 1);
// 线程1:尝试将值改回100,但版本已变,失败!
ref.compareAndSet(value, 100, stamp[0], stamp[0] + 1); // 返回false
其他原子类:AtomicLong、AtomicBoolean、AtomicReference均支持泛型,可封装复杂对象。
LongAdder vs AtomicLong在高竞争场景下,AtomicLong的CAS自旋开销大;LongAdder采用分段累加策略:
AtomicLong)。// 高并发计数场景推荐LongAdder
public class StatsCounter {
private final LongAdder requestCount = new LongAdder();
public void recordRequest() {
requestCount.increment();
}
public long getRequestCount() {
return requestCount.sum();
}
}
性能测试:1000线程并发累加100万次,LongAdder耗时约AtomicLong的1/5。
CountDownLatch:倒计时等待典型场景:主线程等待多个子任务完成:
public class DataLoader {
public void load() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
// 启动3个加载线程
new Thread(() -> {
loadFromDB();
latch.countDown();
}).start();
new Thread(() -> {
loadFromCache();
latch.countDown();
}).start();
new Thread(() -> {
loadFromRemote();
latch.countDown();
}).start();
latch.await(); // 等待所有加载完成
mergeData();
}
}
⚠️ 注意:countDown()必须在finally中调用,防止异常导致计数不归零。
CyclicBarrier:循环栅栏典型场景:多线程分阶段计算(如MapReduce):
public class MatrixSum {
private final CyclicBarrier barrier;
private final int[][] data;
public MatrixSum(int[][] data, int threads) {
this.data = data;
this.barrier = new CyclicBarrier(threads, () -> {
// 所有线程到达后执行汇总
System.out.println("阶段完成,汇总结果...");
});
}
public void process() {
ExecutorService pool = Executors.newFixedThreadPool(threads);
for (int i = 0; i < threads; i++) {
final int threadId = i;
pool.execute(() -> {
// 各线程计算部分结果
int partialSum = calculatePart(threadId);
try {
barrier.await(); // 等待其他线程
// 下一阶段自动开始
} catch (Exception e) {
e.printStackTrace();
}
});
}
pool.shutdown();
}
}
与CountDownLatch区别:CyclicBarrier可重用,且支持 barrierAction(汇总操作)。
Semaphore:信号量控制典型场景:限流(如数据库连接池):
public class ConnectionPool {
private final Semaphore semaphore = new Semaphore(10); // 最多10个连接
public Connection acquire() throws InterruptedException {
semaphore.acquire(); // 获取许可
return createConnection();
}
public void release(Connection conn) {
if (conn != null) {
conn.close();
semaphore.release(); // 释放许可
}
}
}
可结合tryAcquire(timeout, unit)实现带超时的限流。
ConcurrentHashMap的演进之路JDK 1.7:分段锁(Segment),每段独立哈希表;
JDK 1.8:取消分段锁,采用synchronized + CAS + 红黑树:
synchronized,保证插入/删除的原子性。volatile保证可见性。ConcurrentHashMap的put操作平均时间从JDK 1.7的2.1μs降至0.8μs。
CopyOnWriteArrayList的适用场景写时复制策略:每次修改创建新数组,适用于读多写少场景:
// 示例:监听器注册表
public class ListenerRegistry {
private final CopyOnWriteArrayList listeners =
new CopyOnWriteArrayList<>();
public void addListener(EventListener l) {
listeners.add(l);
}
public void removeListener(EventListener l) {
listeners.remove(l);
}
public void notifyListeners(Event e) {
for (EventListener l : listeners) {
l.onEvent(e); // 遍历快照,不抛ConcurrentModificationException
}
}
}
⚠️ 注意:CopyOnWriteArrayList内存开销大(写操作需复制整个数组),写操作频繁时慎用!
| 队列类型 | 有界/无界 | 线程安全 | 适用场景 |
|---|---|---|---|
ArrayBlockingQueue | 有界 | 是(单锁) | 生产者-消费者,需限制容量 |
LinkedBlockingQueue | 默认无界 | 是(双锁) | 吞吐量优先,读写分离 |
PriorityBlockingQueue | 无界 | 是 | 优先级任务调度 |
SynchronousQueue | 无缓冲 | 是 | 直接提交,如CachedThreadPool |
LinkedTransferQueue | 无界 | 是 | 高吞吐量,支持tryTransfer |
线程池默认使用LinkedBlockingQueue,但高并发场景建议自定义ArrayBlockingQueue防止OOM。
ThreadPoolExecutor参数深度解析new ThreadPoolExecutor(
corePoolSize, // 核心线程数
maximumPoolSize, // 最大线程数
keepAliveTime, // 空闲线程存活时间
unit,
workQueue, // 阻塞队列
threadFactory, // 自定义线程工厂
handler // 拒绝策略
);
关键参数组合:
拒绝策略选择:
AbortPolicy:抛异常(默认)。CallerRunsPolicy:由调用线程执行(防过载)。DiscardPolicy:直接丢弃。DiscardOldestPolicy:丢弃最旧任务。陷阱1:共享变量未同步
// ❌ 错误示例
public class Task implements Runnable {
private int count = 0; // 非线程安全!
public void run() {
count++; // 多线程竞争
}
}
正确做法:任务内部使用局部变量,或外部传入线程安全对象:
// ✅ 正确示例
public class Task implements Runnable {
private final AtomicInteger counter;
public Task(AtomicInteger counter) {
this.counter = counter;
}
public void run() {
counter.incrementAndGet(); // 线程安全
}
}
陷阱2:线程池未正确关闭
必须调用shutdown() → awaitTermination(),否则JVM无法退出:
executor.shutdown();
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
executor.shutdownNow();
executor.awaitTermination(10, TimeUnit.SECONDS);
}
volatile变量在多线程下仍不安全?volatile仅保证可见性,不保证原子性。复合操作(如i++)需额外加锁或使用原子类。synchronized和ReentrantLock如何选择?synchronized;需要中断/超时/公平锁时用ReentrantLock。JDK 1.6后两者性能接近。Thread.setDefaultUncaughtExceptionHandler。jstack查看线程堆栈;或在代码中添加死锁检测(如锁超时+重试)。典型死锁场景:线程A锁住X等待Y,线程B锁住Y等待X。volatile?synchronized或Atomic*?ThreadLocal是否调用remove()?CopyOnWriteArrayList或加锁?