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提供更灵活的锁控制,支持:

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. 核心原子类

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分段锁:

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的四大参数:

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. 互斥:资源不可共享
  2. 持有并等待:进程持有资源同时申请新资源
  3. 不可剥夺:资源不可强制回收
  4. 循环等待:存在资源等待环路

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自定义异常处理。