Java怎么和线程同步|并发编程核心机制全景解析
在现代多核CPU架构下,并发编程已成为Java开发者的必备技能。而线程同步作为保障数据一致性和程序正确性的基石,其重要性不言而喻。本文从基础原理出发,系统梳理synchronized、Lock、volatile、并发容器、线程池等核心组件的设计思想与实战应用,结合真实案例、常见误区与性能调优策略,帮助您构建完整的线程同步知识体系。
⚡ 为什么需要线程同步?
当多个线程并发访问共享数据时,若缺乏同步机制,将引发三大核心问题:
- 可见性问题:线程A修改了共享变量,线程B可能读取到旧值(因CPU缓存未及时刷新)
- 原子性问题:复合操作(如i++)被中断,导致结果不一致
- 有序性问题:指令重排序导致程序执行顺序与代码顺序不符
例如:count++在字节码层面包含三步:读取count→加1→写回count。若两个线程同时执行,可能均读取到5,各自加1后写回6,导致本应为7的结果被错误覆盖。
⚙️ 同步的三大维度
Java线程同步机制覆盖以下三个维度:
- 内存模型维度:通过happens-before规则保证可见性与有序性
- 执行控制维度:利用互斥锁(Mutex)实现临界区保护
- 通信协调维度:通过wait/notify、Condition等实现线程间协作
理解这三者的关系,是构建健壮并发程序的前提。
一、synchronized:Java内置同步基石
synchronized是Java最基础、最可靠的同步工具,其本质是基于对象头中的monitor(监视器锁)实现的。从JVM角度,它支持三种使用方式:
1. 同步实例方法
锁对象为当前实例(this)。示例:
public class Counter {
private int count = 0;
public synchronized void increment() {
count++; // 线程安全
}
public int getCount() {
return count;
}
}
关键点:
- 多个线程竞争同一对象的同步方法时互斥执行
- 不同对象的同步方法可并发执行(锁粒度为对象)
2. 同步代码块
显式指定锁对象,更灵活,可减少锁持有时间:
public class SafeList {
private final List<String> list = new ArrayList<>();
private final Object lock = new Object();
public void add(String item) {
synchronized (lock) {
list.add(item);
}
}
}
优化建议:
- 避免使用this或Class对象作为锁(可能被外部误用)
- 锁对象应为private final,防止外部访问
- 同步范围越小越好,避免阻塞无关操作
3. 同步静态方法
锁对象为Class对象(如Counter.class)。适用于静态变量保护:
public class GlobalCounter {
private static int count = 0;
public static synchronized void increment() {
count++;
}
public static int getCount() {
return count;
}
}
注意:实例同步方法与静态同步方法使用不同锁,可并发执行!
💡 深入原理:synchronized在字节码层面通过monitorenter/monitorexit指令实现。JVM对锁做了大量优化(偏向锁→轻量级锁→重量级锁的升级机制),在无竞争时偏向锁几乎无开销。
二、Lock体系:可编程的高级锁机制
相比synchronized,Lock提供更灵活的锁控制,支持:
- 尝试非阻塞获取锁(tryLock)
- 可中断获取锁(lockInterruptibly)
- 公平锁/非公平锁选择
- 多条件队列(Condition)
1. ReentrantLock:可重入锁
public class BankAccount {
private final Lock lock = new ReentrantLock();
private int balance = 1000;
public void withdraw(int amount) {
lock.lock();
try {
if (balance >= amount) {
balance -= amount;
System.out.println("取出: " + amount + ",余额: " + balance);
} else {
throw new RuntimeException("余额不足");
}
} finally {
lock.unlock(); // 必须在finally中释放锁!
}
}
}
2. ReadWriteLock:读写分离锁
适用于读多写少场景,允许多个读线程并发,但写线程独占:
public class Cache {
private final Map<String, Object> cache = new HashMap<>();
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public Object get(String key) {
rwLock.readLock().lock();
try {
return cache.get(key);
} finally {
rwLock.readLock().unlock();
}
}
public void put(String key, Object value) {
rwLock.writeLock().lock();
try {
return cache.put(key, value);
} finally {
rwLock.writeLock().unlock();
}
}
}
⚠️ 重要提醒:使用Lock时必须手动释放锁!建议始终在finally块中调用unlock(),否则可能导致死锁。synchronized则由JVM自动释放,更安全。
⚡ Lock vs synchronized 对比表
| 特性 | synchronized | Lock |
|---|---|---|
| 锁获取方式 | 隐式,自动释放 | 显式,需手动unlock |
| 可中断性 | 不可中断 | 支持lockInterruptibly() |
| 超时获取 | 不支持 | tryLock(long, TimeUnit) |
| 公平性 | 非公平锁 | 可选公平/非公平 |
| 性能 | 无竞争时极优 | 高竞争下更稳定 |
三、原子类:无锁的高效并发方案
当同步需求仅涉及单个变量时,Atomic类(如AtomicInteger)通过CAS(Compare-And-Swap)机制实现无锁并发,避免线程阻塞,性能更优。
1. 核心原子类
- 基本类型:AtomicInteger、AtomicLong、AtomicBoolean
- 数组:AtomicIntegerArray、AtomicLongArray
- 引用:AtomicReference、AtomicMarkableReference
- 字段更新器:AtomicIntegerFieldUpdater、AtomicReferenceFieldUpdater
2. CAS原理与ABA问题
CAS操作包含三个参数:内存位置V、预期值A、新值B。仅当V==A时,将V更新为B,否则失败。其本质是CPU指令级别的原子操作。
public class SafeCounter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 无锁原子自增
}
}
⚙️ ABA问题解决方案
CAS可能遇到ABA问题:线程1读取值A→线程2改为B→再改回A→线程1CAS成功但值已变化。解决方法:
- 版本戳:AtomicStampedReference维护版本号
- 时间戳:AtomicMarkableReference标记变更
示例:
AtomicStampedReference<String> ref =
new AtomicStampedReference<>("A", 0);
int[] stamp = new int[1];
String val = ref.get(stamp);
// val="A", stamp[0]=0
💡 性能对比:在低竞争场景,AtomicInteger性能是synchronized的3-5倍;高竞争时,synchronized经JVM优化后反超。实际选择需结合场景测试。
四、并发容器:线程安全的集合框架
java.util.concurrent提供多种线程安全容器,避免手动加锁的复杂性:
1. CopyOnWriteArrayList
写时复制:每次修改创建新数组副本。适用于读多写少场景(如监听器列表)。
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("item1"); // 复制新数组
list.add("item2");
缺点:内存占用高,写操作开销大。
2. ConcurrentHashMap
JDK8+采用CAS+synchronized分段锁:
- put操作:先尝试CAS插入,失败则加锁当前桶
- 扩容:支持多线程并行扩容
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("count", 1);
map.computeIfAbsent("count", k -> 0); // 原子计算
优势:比Hashtable性能高10倍以上,支持高并发读写。
3. ConcurrentSkipListMap
跳表实现的有序Map,支持并发排序操作:
ConcurrentSkipListMap<String, Integer> sortedMap =
new ConcurrentSkipListMap<>();
sortedMap.put("b", 2);
sortedMap.put("a", 1);
System.out.println(sortedMap.firstKey()); // a
| 容器 | 线程安全 | 有序性 | 适用场景 |
|---|---|---|---|
| ArrayList | ❌ | 插入顺序 | 单线程 |
| Vector | ✅(粗粒度锁) | 插入顺序 | 低并发旧代码 |
| CopyOnWriteArrayList | ✅ | 插入顺序 | 读多写少 |
| LinkedList | ❌ | 插入顺序 | 单线程 |
| ConcurrentLinkedQueue | ✅ | 无序 | 高并发队列 |
| ConcurrentSkipListMap | ✅ | 自然/比较器排序 | 需排序的Map |
五、线程池:资源复用与高效调度
线程池通过复用线程减少创建/销毁开销,实现资源可控。核心类ThreadPoolExecutor的四大参数:
- corePoolSize:核心线程数
- maximumPoolSize:最大线程数
- keepAliveTime:空闲线程存活时间
- workQueue:任务队列
1. 线程池工作流程
① 新任务进入 → ② 若运行线程 < corePoolSize → 创建新线程
③ 否则 → ④ 队列未满 → 加入队列
⑤ 队列满 → ⑥ 运行线程 < maxPoolSize → 创建新线程
⑦ 否则 → 执行拒绝策略
2. 任务队列类型
| 队列类型 | 特点 | 适用场景 |
|---|---|---|
| ArrayBlockingQueue | 有界数组,FIFO | 需控制队列长度 |
| LinkedBlockingQueue | 无界链表(默认Integer.MAX_VALUE) | 任务量波动大 |
| SynchronousQueue | 无存储,直接传递 | 高吞吐量(如ForkJoinPool) |
| PriorityBlockingQueue | 优先级队列 | 需优先级调度 |
3. 拒绝策略
ThreadPoolExecutor的四种拒绝策略
- AbortPolicy:抛出RejectedExecutionException(默认)
- CallerRunsPolicy:由调用线程执行任务
- DiscardPolicy:直接丢弃任务
- DiscardOldestPolicy:丢弃最老任务,插入新任务
4. 实战建议
⚡ 线程池参数配置公式
CPU密集型任务:corePoolSize = CPU核心数 + 1
IO密集型任务:corePoolSize = CPU核心数 × 2
示例:
int cpuCores = Runtime.getRuntime().availableProcessors();
ExecutorService pool = new ThreadPoolExecutor(
cpuCores,
cpuCores * 2,
60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000),
new ThreadPoolExecutor.CallerRunsPolicy()
);
六、死锁:识别、预防与排查
死锁是多线程中最难调试的问题之一,需同时满足四个条件(Coffman条件):
- 互斥:资源不可共享
- 持有并等待:进程持有资源同时申请新资源
- 不可剥夺:资源不可强制回收
- 循环等待:存在资源等待环路
1. 经典死锁示例
public class DeadlockDemo {
private final Object lockA = new Object();
private final Object lockB = new Object();
public void method1() {
synchronized (lockA) {
Thread.sleep(100);
synchronized (lockB) { // 可能死锁
System.out.println("Method 1");
}
}
}
public void method2() {
synchronized (lockB) { // 锁顺序相反
Thread.sleep(100);
synchronized (lockA) {
System.out.println("Method 2");
}
}
}
}
修复方案:统一锁顺序!所有线程按A→B顺序获取锁。
2. 死锁排查工具
⚡ jstack与线程转储
1. 执行:jstack -l <pid>
2. 查找状态为"BLOCKED"的线程
3. 检查"Found one Java-level deadlock:"提示
典型输出:
"Thread-1":
waiting to lock monitor 0x00007f8b4c003b00 (object 0x000000076b5e0d00, a java.lang.Object),
which is held by "Thread-0"
"Thread-0":
waiting to lock monitor 0x00007f8b4c003c00 (object 0x000000076b5e0d10, a java.lang.Object),
which is held by "Thread-1"
3. 预防措施
- 锁排序:按固定顺序获取锁(如按对象哈希码排序)
- 超时机制:使用tryLock()避免无限等待
- 减少锁粒度:细粒度锁降低冲突概率
- 使用并发工具:优先选择Lock/Atomic类而非synchronized
七、性能调优:从理论到实战
线程同步的性能优化需平衡安全性与效率,关键策略如下:
1. 减少锁竞争
⚡ 优化技巧
- 分段锁:ConcurrentHashMap将锁粒度降至桶级别
- 读写分离:ReadWriteLock允许多读一写
- 无锁化:用Atomic类替代synchronized
- 局部变量:减少共享变量,用局部变量避免竞争
2. 避免伪共享(False Sharing)
CPU缓存按缓存行(64字节)加载。相邻变量被不同线程修改时,导致缓存行频繁失效:
// 伪共享示例
class SharedData {
volatile long value1; // 缓存行冲突
volatile long value2; // 可能与value1共享缓存行
}
// 修复:填充缓存行
class PaddedLong {
volatile long value;
// 填充64字节(缓存行大小)
long p1, p2, p3, p4, p5, p6, p7;
}
JDK8+提供@Contended注解(需启用-XX:-RestrictContended):
@Contended
class Counter {
volatile long value;
}
3. 性能测试对比
| 操作 | synchronized | AtomicInteger | ReentrantLock |
|---|---|---|---|
| 1线程,100万次自增 | 12ms | 8ms | 10ms |
| 4线程,100万次自增 | 48ms | 22ms | 35ms |
| 8线程,100万次自增 | 95ms | 45ms | 60ms |
注:测试环境为Intel i7-9750H,JDK11,结果可能因硬件/负载变化。
八、高频问答:Java线程同步核心问题
1. synchronized和ReentrantLock的区别?
synchronized是JVM内置锁,自动释放,适合简单场景;ReentrantLock是API级锁,支持公平锁、超时、可中断等高级特性,适合复杂控制流。性能上,JDK6+后synchronized在低竞争时更快,高竞争时ReentrantLock更稳定。
2. volatile能替代synchronized吗?
不能!volatile仅保证可见性和有序性(禁止指令重排序),不保证原子性。例如:volatile int count=0; count++;仍可能丢失更新。仅当操作满足:
① 写操作不依赖当前值
② 无复合操作
③ 单变量原子操作
时,volatile才安全。
3. 什么是线程安全?如何保证?
线程安全指多线程访问时,程序行为符合预期(如数据一致)。保证方法:
① 不可变对象(String、Long等)
② 同步机制(synchronized/Lock)
③ 原子类(AtomicXXX)
④ 并发容器
⑤ 线程封闭(ThreadLocal)
4. 为什么ConcurrentHashMap比HashMap快?
HashMap非线程安全;Hashtable用全局锁,性能差;ConcurrentHashMap:
• JDK7:分段锁(Segment),锁粒度为桶
• JDK8+:CAS+synchronized,仅锁桶头节点
• 支持并发扩容
• 读操作无锁(volatile保证可见性)
5. 线程池中线程异常退出怎么办?
ThreadPoolExecutor会:
① 捕获线程异常
② 移除故障线程
③ 创建新线程补充至corePoolSize
④ 保证线程池持续运行
开发者可通过uncaughtExceptionHandler自定义异常处理。