Java并发编程：Lock与synchronized的协同与差异解析

2026年2月10日 互联网

在Java并发编程中，同步机制是确保多线程安全的核心工具。开发者常常面临这样的困惑：既然Java提供了Lock接口及其实现类（如ReentrantLock），为何还要保留synchronized关键字？这两种同步方式在底层实现、使用场景和性能特性上存在哪些本质差异？本文将从并发编程的三大核心特性——原子性、可见性、有序性出发，结合具体代码示例和性能对比，系统性解析两者的协同与差异。

一、原子性：同步机制的核心保障

原子性是指一个操作或多个操作要么全部执行成功，要么全部不执行，中间不会被其他线程打断。在多线程环境下，若缺乏原子性保障，共享变量的修改可能导致数据不一致。

1. synchronized的原子性实现

synchronized通过JVM内置的monitor锁机制实现原子性。当线程进入同步代码块时，会尝试获取对象的monitor锁，若锁已被占用则进入阻塞状态。这种机制天然支持方法级和代码块级的同步。

  1. public class Counter {
  2.     private int count = 0;
  4.     // synchronized修饰方法
  5.     public synchronized void increment() {
  6.         count++;
  7.     }
  9.     // synchronized代码块
  10.     public void decrement() {
  11.         synchronized(this) {
  12.             count--;
  13.         }
  14.     }
  15. }

在上述示例中，increment()方法和decrement()方法中的count++和count--操作均被包装为原子操作。JVM会确保同一时间只有一个线程能执行这些同步代码块。

2. Lock的原子性实现

Lock接口（如ReentrantLock）通过显式的锁获取与释放实现原子性。开发者需要手动调用lock()和unlock()方法，配合try-finally块确保锁的释放。

  1. import java.util.concurrent.locks.ReentrantLock;
  3. public class SafeCounter {
  4.     private final ReentrantLock lock = new ReentrantLock();
  5.     private int count = 0;
  7.     public void increment() {
  8.         lock.lock();
  9.         try {
  10.             count++;
  11.         } finally {
  12.             lock.unlock();
  13.         }
  14.     }
  15. }

ReentrantLock的原子性保障依赖于其内部实现的AQS（AbstractQueuedSynchronizer）框架，通过CAS操作和队列管理实现线程的公平或非公平调度。

3. 原子性对比与适用场景

  • synchronized：适合简单的同步需求，代码简洁，由JVM自动管理锁的获取与释放，减少人为错误。
  • Lock：提供更灵活的锁操作，如可中断的锁获取、超时机制、公平锁选择等，适合复杂的并发控制场景。

二、内存可见性：多线程下的数据一致性

内存可见性是指一个线程对共享变量的修改能够及时被其他线程观察到。在缺乏同步机制时，由于JVM的指令重排序和CPU缓存优化，可能导致线程读取到过期的数据。

1. synchronized的可见性保障

synchronized通过以下机制确保内存可见性：

  • 锁释放前的写缓冲刷新：线程释放锁前，会将工作内存中的修改刷新到主内存。
  • 锁获取前的缓存失效：线程获取锁时，会清空工作内存，从主内存重新加载变量值。
  1. public class VisibilityDemo {
  2.     private boolean flag = false;
  4.     public synchronized void setFlag() {
  5.         flag = true;
  6.     }
  8.     public synchronized boolean getFlag() {
  9.         return flag;
  10.     }
  11. }

在上述示例中，setFlag()和getFlag()方法的同步块确保了flag变量的修改对其他线程立即可见。

2. Lock的可见性保障

Lock接口通过volatile语义的变量（如AQS中的state字段）和内存屏障（Memory Barrier）实现可见性。显式的锁操作会强制刷新CPU缓存。

  1. import java.util.concurrent.locks.ReentrantLock;
  3. public class LockVisibilityDemo {
  4.     private final ReentrantLock lock = new ReentrantLock();
  5.     private boolean flag = false;
  7.     public void setFlag() {
  8.         lock.lock();
  9.         try {
  10.             flag = true;
  11.         } finally {
  12.             lock.unlock();
  13.         }
  14.     }
  16.     public boolean getFlag() {
  17.         lock.lock();
  18.         try {
  19.             return flag;
  20.         } finally {
  21.             lock.unlock();
  22.         }
  23.     }
  24. }

虽然上述代码中flag未被声明为volatile，但Lock的锁操作隐含了可见性保障，确保flag的修改对其他线程可见。

3. 可见性对比与最佳实践

  • synchronized：适合简单的可见性需求，无需显式声明volatile变量。
  • Lock：在复杂场景下，可结合volatile变量和锁操作实现更细粒度的控制。例如，使用volatile修饰标志位，配合Lock保护数据修改。

三、有序性：指令重排序的约束

有序性是指程序执行的顺序按照代码的书写顺序执行。在单线程环境下，JVM和CPU会通过指令重排序优化性能，但在多线程环境下，重排序可能导致逻辑错误。

1. synchronized的有序性保障

synchronized通过以下机制防止重排序：

  • 同步块的边界：JVM会在同步块的入口和出口插入内存屏障，禁止指令跨同步块重排序。
  • happens-before原则：synchronized的锁释放操作happens-before后续的锁获取操作，确保锁保护范围内的代码顺序。
  1. public class OrderDemo {
  2.     private int x = 0, y = 0;
  3.     private boolean flag = false;
  5.     public synchronized void write() {
  6.         x = 1;
  7.         flag = true;
  8.     }
  10.     public synchronized boolean read() {
  11.         if (flag) {
  12.             return y == 0; // 确保x=1先于flag=true执行
  13.         }
  14.         return false;
  15.     }
  16. }

在上述示例中，write()和read()方法的同步块确保了x=1和flag=true的顺序不会被重排序。

2. Lock的有序性保障

Lock通过以下机制防止重排序：

  • AQS的内部同步：AQS通过CAS操作和状态变量（state）的修改确保操作的原子性，隐含了有序性。
  • 显式的内存屏障：Lock的锁操作会插入内存屏障，禁止指令重排序。
  1. import java.util.concurrent.locks.ReentrantLock;
  3. public class LockOrderDemo {
  4.     private final ReentrantLock lock = new ReentrantLock();
  5.     private int x = 0, y = 0;
  6.     private boolean flag = false;
  8.     public void write() {
  9.         lock.lock();
  10.         try {
  11.             x = 1;
  12.             flag = true;
  13.         } finally {
  14.             lock.unlock();
  15.         }
  16.     }
  18.     public boolean read() {
  19.         lock.lock();
  20.         try {
  21.             if (flag) {
  22.                 return y == 0;
  23.             }
  24.             return false;
  25.         } finally {
  26.             lock.unlock();
  27.         }
  28.     }
  29. }

在上述示例中，Lock的锁操作确保了x=1和flag=true的顺序不会被重排序。

3. 有序性对比与优化建议

  • synchronized：适合简单的有序性需求，无需手动插入内存屏障。
  • Lock：在复杂场景下，可结合volatile变量和锁操作实现更细粒度的控制。例如，使用volatile修饰标志位，配合Lock保护数据修改。

四、性能与功能对比：如何选择同步机制

1. 性能对比

  • 低竞争场景：synchronized的性能优于Lock，因为synchronized是JVM内置机制，无需额外的对象创建和上下文切换。
  • 高竞争场景：Lock（如ReentrantLock）的性能优于synchronized，因为Lock提供了公平锁和非公平锁的选择，可减少线程饥饿。

2. 功能对比

  • synchronized：
    • 简单易用，代码简洁。
    • 支持方法级和代码块级同步。
    • 由JVM自动管理锁的获取与释放。
  • Lock：
    • 提供更灵活的锁操作，如可中断的锁获取、超时机制、公平锁选择等。
    • 支持条件变量（Condition），可实现更复杂的线程等待/通知机制。
    • 适合需要细粒度控制的并发场景。

3. 选择建议

  • 简单同步需求：优先使用synchronized，代码简洁且性能足够。
  • 复杂并发控制：选择Lock，利用其灵活的锁操作和条件变量。
  • 高性能场景：在高竞争环境下，Lock的性能优势更明显。

五、总结：Lock与synchronized的协同与差异

在Java并发编程中，Lock与synchronized并非替代关系，而是互补关系。synchronized提供了简单易用的同步机制，适合大多数场景；而Lock提供了更灵活的锁操作和更细粒度的控制，适合复杂的并发场景。开发者应根据具体需求选择合适的同步机制，并结合volatile变量、内存屏障等技术实现高效、安全的多线程编程。

通过理解原子性、可见性、有序性三大并发基石，以及Lock与synchronized在实现上的差异，开发者可以设计出更健壮、更高效的并发程序。无论是简单的计数器还是复杂的分布式系统，掌握这些同步机制的核心原理都是必不可少的技能。

最新文章