在现代高并发系统中,线程同步是保障数据一致性与程序正确性的基石。当多个线程同时访问共享资源时,若缺乏有效的同步机制,极易引发竞态条件、数据不一致、死锁等问题,轻则导致业务逻辑异常,重则引发系统崩溃。Java作为企业级开发的主流语言,其线程同步体系经过多次演进,已形成一套成熟、灵活且高性能的并发工具集。
本文系统梳理Java线程同步的核心技术栈,涵盖从基础语法到高级原理,从理论机制到实战调优,全面解答开发者最关心的同步问题。内容不仅适用于初级开发者夯实基础,也面向中高级工程师提供性能调优与避坑指南,助您构建高吞吐、低延迟、零竞态的并发应用。
在单线程时代,程序顺序执行,不存在并发问题。但随着多核CPU普及,Java程序普遍采用多线程提升吞吐量。此时,若多个线程同时读写共享变量,可能产生以下经典问题:
以银行转账为例:账户A余额100元,A向B转账50元。若无同步,可能出现A扣款成功但B未入账,或A未扣款但B已入账,最终余额异常。此类问题在电商库存、秒杀系统、订单状态机中尤为致命。
理解线程同步前,必须厘清并发编程的四大核心属性:
指操作不可被中断,要么全部执行成功,要么完全不执行。Java中通过以下方式保障原子性:
⚠️ 注意:Java基本类型赋值操作并非全原子!long/double在32位JVM上赋值非原子(分两次32位写入),需用volatile或同步防护。
指一个线程对共享变量的修改,其他线程能立即看到。Java内存模型(JMM)通过以下机制保障可见性:
示例:未用volatile可能导致无限循环:
public class VisibilityDemo {
private static boolean flag = false;
public static void main(String[] args) {
new Thread(() -> {
while (!flag) {
// 可能永远不退出!flag修改对主线程不可见
}
System.out.println("Thread exited");
}).start();
try { Thread.sleep(100); } catch (Exception ignored) {}
flag = true; // 主线程修改
}
}指程序执行顺序与代码顺序一致。JMM允许编译器和CPU对指令重排序以提升性能,但需保证as-if-serial语义(单线程下结果不变)。多线程下需通过以下方式禁止重排序:
经典案例:双重检查锁定单例模式中,volatile防止指令重排序导致对象未完全初始化就被返回:
public class Singleton {
private static volatile Singleton instance; // 关键:禁止重排序
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton(); // 非原子操作:分配内存→初始化→赋值引用
}
}
}
return instance;
}
}指访问共享资源的代码段,必须确保互斥执行。设计临界区需遵循:
作为Java内置同步机制,synchronized因使用简单、语义清晰成为最广泛使用的锁方案。但其性能曾被诟病,自Java 6起通过偏向锁、轻量级锁等优化大幅改善。
synchronized可修饰代码块、实例方法、静态方法:
底层通过对象头的Mark Word实现。每个Java对象可视为一把锁,对象头记录锁状态(无锁/偏向/轻量级/重量级)及线程ID、哈希码等信息。
// 示例:同步代码块
synchronized (lockObj) {
// 临界区
sharedVar++;
}
// 示例:同步实例方法
public synchronized void update() {
sharedVar++;
}
// 示例:同步静态方法
public static synchronized void reset() {
sharedVar = 0;
}为减少重量级锁的系统调用开销,JVM采用锁升级策略:
📌 注意:偏向锁在JVM启动时默认延迟4秒激活(适应冷启动场景),可通过-XX:+UseBiasedLocking启用/禁用。
benchmark数据(100线程,10万次递增):
| 方案 | 平均耗时(ms) | 吞吐量(ops/ms) |
|---|---|---|
| synchronized | 82.4 | 1214 |
| ReentrantLock | 76.1 | 1314 |
| AtomicInteger | 45.8 | 2183 |
| 无锁环形队列 | 22.3 | 4484 |
相比synchronized,ReentrantLock提供更灵活的锁控制,支持公平/非公平模式、可中断锁获取、超时机制等。
Lock lock = new ReentrantLock(true); // 公平锁
try {
lock.lock();
// 临界区代码
sharedVar++;
} finally {
lock.unlock(); // 必须在finally中释放
}⚠️ 注意:必须手动释放锁!若未释放,其他线程将永久阻塞。
适用于读多写少场景,允许多个读线程并发,但写线程独占:
class Cache {
final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
final Lock r = rwLock.readLock();
final Lock w = rwLock.writeLock();
public Object get(String key) {
r.lock();
try { return cache.get(key); } finally { r.unlock(); }
}
public void put(String key, Object value) {
w.lock();
try { cache.put(key, value); } finally { w.unlock(); }
}
}📌 benchmark:读写比例9:1时,读写锁比synchronized快2.3倍;读写比例1:1时,性能接近。
volatile是轻量级同步机制,仅保证可见性和有序性,不保证原子性。适用于状态标志、一次性发布等场景。
| 特性 | volatile | synchronized |
|---|---|---|
| 原子性 | ❌ | ✅ |
| 可见性 | ✅ | ✅ |
| 有序性 | ✅ | ✅ |
| 阻塞 | ❌ | ✅ |
| 适用场景 | 状态标志、单次发布 | 复合操作、临界区 |
❌ 错误:volatile无法保障i++原子性:
volatile int count = 0;
// 多线程执行count++,结果可能小于预期!
// 因为read-modify-write非原子操作✅ 正确:用AtomicInteger或synchronized:
AtomicInteger count = new AtomicInteger();
count.incrementAndGet(); // 原子操作volatile写入时插入StoreStore+StoreLoad屏障,读取时插入LoadLoad+LoadStore屏障,确保:
这保证了volatile变量的修改对其他线程立即可见,并防止指令重排序破坏程序语义。
CAS(Compare-And-Swap)是硬件级原子指令,通过乐观锁机制避免线程阻塞,显著提升高并发性能。
CAS(V, E, N):比较内存值V与期望值E,若相等则更新为N,返回true;否则返回false。
Java中通过Unsafe类实现:
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);核心方法getAndIncrement()实现:
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
// Unsafe.getAndAddInt实现
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset); // 读取当前值
} while (!compareAndSwapInt(o, offset, v, v + delta)); // CAS尝试更新
return v;
}📌 注意:当竞争激烈时,自旋开销增大,性能可能低于synchronized。此时应考虑分段计数(LongAdder)。
问题:线程A读取值为1,线程B将其改为2再改回1,A的CAS仍成功,但值已被修改过。
解决方案:使用AtomicStampedReference添加版本戳:
AtomicStampedReference ref = new AtomicStampedReference<>(1, 0);
int[] stamp = new int[1];
int current = ref.get(stamp);
// 其他线程修改:ref.compareAndSet(1, 2, stamp[0], stamp[0]+1);
// 再改回:ref.compareAndSet(2, 1, stamp[0], stamp[0]+1);
// A尝试更新:ref.compareAndSet(1, 3, stamp[0], stamp[0]+1) // 失败!版本已变 ThreadLocal为每个线程提供变量副本,实现线程隔离,避免同步开销。
每个Thread对象维护一个ThreadLocalMap,以ThreadLocal实例为key,存储线程私有值:
public class DbConnection {
private static final ThreadLocal conn = ThreadLocal.withInitial(() -> {
try { return DriverManager.getConnection("jdbc:mysql://..."); }
catch (SQLException e) { throw new RuntimeException(e); }
});
public static Connection get() { return conn.get(); }
public static void close() { conn.remove(); } // 必须清理!
} ThreadLocalMap的Entry继承WeakReference,key为弱引用。若ThreadLocal对象被回收,但线程仍存活,Entry的value将无法访问,导致内存泄漏。
✅ 最佳实践:
场景:秒杀系统中库存扣减,1000线程并发请求。
// LongAdder实现高并发计数
LongAdder counter = new LongAdder();
// 并发执行1000次 increment
// 最终值 ≈ 1000,且性能比AtomicInteger高3-5倍双重检查锁定(DCL)必须加volatile:
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) { // 第一次检查(无锁)
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查(加锁)
instance = new Singleton();
}
}
}
return instance;
}
}📌 禁止用synchronized修饰整个方法,因每次调用都需获取锁,性能极差。
使用BlockingQueue简化同步逻辑:
BlockingQueue queue = new ArrayBlockingQueue<>(100);
// 生产者
new Thread(() -> {
try { queue.put("item"); } // 阻塞直到有空间
catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}).start();
// 消费者
new Thread(() -> {
try { String item = queue.take(); } // 阻塞直到有元素
catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}).start(); ✅ 优势:自动处理线程同步、等待/通知,避免手写wait/notify。
❌ 不能!volatile仅保证可见性,不保证原子性。复合操作(如i++)必须用synchronized或Atomic类。
必须在任务结束后调用remove()!线程复用会导致ThreadLocal值残留,引发数据错乱。
executor.submit(() -> {
try {
// 业务逻辑
} finally {
threadLocal.remove(); // 关键:清理资源
}
});用AtomicStampedReference添加版本戳,或用AtomicMarkableReference标记指针变化。
CAS基于硬件原子指令,无操作系统内核态切换开销。仅在竞争激烈时性能下降,此时可用LongAdder分段计数。
推荐静态内部类或枚举单例:
public enum Singleton {
INSTANCE; // JVM保证线程安全,防止反射攻击
}会!volatile变量读写需插入内存屏障,禁止重排序,比普通变量慢约10-20%。仅在必要时使用。