synchronized 和 volatile 的区别是什么？

synchronized保证原子性和可见性，通过锁对象的monitor实现，同一时刻仅一个线程可执行同步代码块；volatile仅保证可见性，禁止指令重排序，适用于状态标志等场景。两者性能与适用场景不同，需根据需求选择。此外，Java还提供Lock、原子类、并发集合等更灵活的同步机制。

synchronized 和 volatile，这两个 Java 关键字，就像武林中的两门绝学，虽然都能提升多线程环境下的数据安全，但修炼心法和适用场景却大相径庭。简单来说，

synchronized

是重量级锁，保证原子性和可见性，而

volatile

是轻量级同步机制，只保证可见性。

synchronized 和 volatile 的区别

synchronized 到底锁了什么？

synchronized

可不是简单地给变量加个锁这么简单。它锁的是对象。更准确地说，是对象的 monitor（监视器）。每个 Java 对象都关联一个 monitor，当线程进入

synchronized

修饰的代码块或方法时，它会尝试获取该对象的 monitor。如果 monitor 已经被其他线程持有，那么该线程就会进入阻塞状态，直到 monitor 被释放。

synchronized

保证原子性的方式是，同一时刻只有一个线程可以持有对象的 monitor，因此对该对象的任何操作都相当于串行执行，避免了竞态条件。

而

synchronized

保证可见性的方式，则是在线程释放 monitor 时，会将工作内存中的变量值刷新到主内存中，并且在线程获取 monitor 时，会从主内存中重新加载变量值到工作内存中。这样就保证了不同线程之间对共享变量的可见性。

举个例子，假设我们有一个计数器类：

public class counter {     private int count = 0;      public synchronized void increment() {         count++;     }      public synchronized int getCount() {         return count;     } }

在这个例子中，

increment()

和

getCount()

方法都使用了

synchronized

关键字。这意味着，当一个线程调用

increment()

方法时，它会获取

Counter

对象的 monitor。其他线程如果也想调用

increment()

或

getCount()

方法，就必须等待第一个线程释放 monitor。这样就保证了

count

变量的原子性和可见性。

但是，

synchronized

也有缺点，那就是性能开销比较大。线程在获取 monitor 时，需要进行上下文切换，这会消耗大量的 CPU 时间。此外，

synchronized

还会导致线程阻塞，降低程序的并发性。

volatile 只能保证可见性，那它有什么用？

volatile

关键字告诉 jvm，该变量的值可能被多个线程同时修改，因此每次使用该变量时，都应该从主内存中重新加载。这样就保证了不同线程之间对该变量的可见性。

但需要注意的是，

volatile

只能保证可见性，不能保证原子性。也就是说，如果多个线程同时修改一个

volatile

变量，仍然可能出现竞态条件。

例如：

boardmix博思白板

boardmix博思白板，一个点燃团队协作和激发创意的空间，集aigc，一键PPT，思维导图，笔记文档多种创意表达能力于一体，将团队工作效率提升到新的层次。

39

查看详情

public class VolatileCounter {     private volatile int count = 0;      public void increment() {         count++; // 这是一个复合操作，不是原子性的     }      public int getCount() {         return count;     } }

在这个例子中，

count

变量使用了

volatile

关键字。虽然

volatile

保证了

count

变量的可见性，但

increment()

方法中的

count++

操作并不是原子性的。它实际上包含了三个步骤：

1. 读取

   count

   的值。

2. 将

   count

   的值加 1。

3. 将结果写回

   count

   。

如果多个线程同时执行

increment()

方法，那么可能会出现以下情况：

1. 线程 A 读取

   count

   的值为 10。

2. 线程 B 读取

   count

   的值为 10。

3. 线程 A 将

   count

   的值加 1，得到 11，然后将 11 写回

   count

   。

4. 线程 B 将

   count

   的值加 1，得到 11，然后将 11 写回

   count

   。

最终，

count

的值是 11，而不是 12。这就是竞态条件。

那么，

volatile

到底有什么用呢？

volatile

最常用的场景是作为状态标志，例如：

public class Worker {     private volatile boolean running = true;      public void start() {         new Thread(() -> {             while (running) {                 // 执行一些任务             }             System.out.println("Worker stopped.");         }).start();     }      public void stop() {         running = false;     } }

在这个例子中，

running

变量使用了

volatile

关键字。当调用

stop()

方法时，

running

的值会被设置为

false

。由于

running

是

volatile

变量，所以所有线程都会立即看到这个变化，从而停止执行任务。

何时使用 synchronized，何时使用 volatile？

这其实是一个权衡的问题。

• 需要保证原子性：必须使用

  synchronized

  或其他原子类（如

  AtomicInteger

  ）。

  volatile

  无能为力。

• 只需要保证可见性，并且对变量的写操作不依赖于当前值：可以使用

  volatile

  。例如，上述的状态标志。

• 性能要求较高：如果

  synchronized

  带来的性能开销过大，可以考虑使用

  volatile

  ，但前提是必须满足上述条件。

总的来说，

synchronized

是一个更强大的同步机制，可以保证原子性和可见性，但性能开销也比较大。

volatile

是一个轻量级的同步机制，只能保证可见性，但性能开销比较小。在选择使用哪个关键字时，需要根据具体的场景进行权衡。

除了 synchronized 和 volatile，还有哪些同步机制？

Java 并发编程的世界远不止

synchronized

和

volatile

这么简单。还有很多其他的同步机制，例如：

• Lock 接口及其实现类：

  Lock

  接口提供了比

  synchronized

  更灵活的锁机制，例如可重入锁

  ReentrantLock

  、读写锁

  ReadWriteLock

  等。

  Lock

  需要手动释放锁，因此需要放在

  try...finally

  块中。

• 原子类：

  java.util.concurrent.atomic

  包下提供了一系列的原子类，例如

  AtomicInteger

  、

  AtomicLong

  、

  AtomicReference

  等。这些类使用 CAS（Compare-and-Swap）算法来实现原子操作，性能通常比

  synchronized

  更高。

• 并发集合：

  java.util.concurrent

  包下提供了一系列的并发集合，例如

  ConcurrentHashMap

  、

  CopyOnWriteArrayList

  等。这些集合针对并发场景进行了优化，可以提供更高的并发性能。

• CountDownLatch、CyclicBarrier、Semaphore：这些是 Java 并发包中提供的同步工具类，用于协调多个线程之间的执行。

选择哪种同步机制，取决于具体的并发场景和性能要求。没有银弹，只有最适合的工具。理解每种工具的优缺点，才能在并发编程的世界里游刃有余。