Java-并发编程-特性-可见性-synchronized如何保证可见性?

synchronized 能保证可见性吗？

在Java并发编程中，synchronized 关键字不仅用于实现互斥访问，还能够保证内存可见性。理解这一点需要了解Java内存模型（Java Memory Model，JMM）以及happens-before（先行发生）原则。

---

1. Java内存模型（JMM）概述

Java内存模型定义了Java虚拟机（JVM）如何与计算机的内存（主内存）交互，以及如何在多线程环境下保证线程之间的可见性和有序性。主要涉及两个重要概念：

• 主内存（Main Memory）：所有线程共享的内存区域，用于存储类的字段、实例变量等。
• 工作内存（Working Memory）：每个线程独立拥有的内存空间，用于存储线程使用的变量的副本。

线程对变量的操作主要在工作内存中进行，必须通过读写主内存实现线程间共享数据。

---

2. synchronized 的双重作用

sychronized 关键字在Java中扮演着关键角色，主要有以下两个作用：

1. 互斥访问（Mutual Exclusion）：

   • 保证同一时间内只有一个线程可以执行被synchronized修饰的代码块或方法，防止竞态条件（Race Condition）的发生。

2. 内存可见性（Memory Visibility）：

   • 确保进入synchronized块之前，线程看到的主内存中共享变量的最新值。
   • 线程退出synchronized块时，会将工作内存中的修改立即刷新回主内存。

2.1 互斥访问

通过锁机制，synchronized 确保了同一时间只有一个线程可以持有锁并执行同步代码。这防止了多个线程同时修改共享资源可能导致的数据不一致问题。

2.2 内存可见性

synchronized 通过内存屏障（Memory Barrier）机制实现内存可见性，具体表现在以下两个方面：

• 进入同步块前：
  • 线程会清空自己的工作内存，从主内存中重新读取同步变量的最新值。
• 退出同步块后：
  • 线程会将工作内存中的修改刷新到主内存，确保其他持有同一锁的线程能够看到最新的值。

---

3. happens-before 原则

Java内存模型中，happens-before 关系定义了操作之间的执行顺序，并确保happens-before 关系中的先行操作对后续操作可见。

synchronized 的内存可见性保障基于以下 happens-before 规则：

1. 解锁（Unlock）操作 happens-before 加锁（Lock）操作：

   • 一个线程在释放锁之前对共享变量所做的所有写操作，happens-before 另一个线程随后获得同一锁时对这些共享变量的读取操作。

   举例说明：

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

   • 线程A调用increment()方法并释放锁，线程B随后调用getCount()方法获取锁时，B线程能够看到A线程对count所做的修改。

2. 当前线程的操作 happens-before 同步块内的操作：

   • 这确保了在同一个线程内，进入synchronized块之前的所有操作对synchronized块内可见。

---

4. 实例解析

4.1 内存可见性示例

考虑以下示例，展示sychronized如何保证内存可见性：

class SharedData {private int value = 0;public synchronized void setValue(int newValue) {value = newValue;}public synchronized int getValue() {return value;}
}public class VisibilityDemo {public static void main(String[] args) {SharedData data = new SharedData();// 线程A：设置值Thread threadA = new Thread(() -> {data.setValue(42);System.out.println("ThreadA set value to 42");});// 线程B：获取值Thread threadB = new Thread(() -> {int val = data.getValue();System.out.println("ThreadB read value: " + val);});threadA.start();threadB.start();}
}

解释：

1. threadA 调用 setValue(42) 并释放锁，value 的值被更新并刷新到主内存。
2. threadB 调用 getValue() 并获取锁，读取到的value是最新的42。

如果没有synchronized，threadB 可能读取到旧的值0，因为线程间没有保证可见性。

4.2 不使用 synchronized 的可见性问题

class SharedData {private int value = 0;public void setValue(int newValue) {value = newValue;}public int getValue() {return value;}
}public class VisibilityIssueDemo {public static void main(String[] args) {SharedData data = new SharedData();// 线程A：设置值Thread threadA = new Thread(() -> {data.setValue(42);System.out.println("ThreadA set value to 42");});// 线程B：获取值Thread threadB = new Thread(() -> {int val = data.getValue();System.out.println("ThreadB read value: " + val);});threadA.start();threadB.start();}
}

可能输出：

ThreadA set value to 42
ThreadB read value: 0

原因：没有synchronized保护，threadB 可能在 threadA 更新 value 之前读取到旧值，导致数据不一致。

---

5. synchronized 与其他同步机制的对比

5.1 volatile 与 synchronized

• volatile：

  • 保证变量的可见性，但不保证原子性。
  • 适用于单一变量的更新，如状态标志。

• synchronized：

  • 保证可见性和原子性。
  • 适用于需要进行复合操作（如检查-然后-执行）的场景。

示例：

class VolatileExample {private volatile boolean flag = false;public void setFlag() {flag = true;}public boolean getFlag() {return flag;}
}

适用于简单的标志位控制，但若需要对flag进行复合操作（如if (!flag) { flag = true; }），则需要synchronized确保原子性。

5.2 ReentrantLock 与 synchronized

• synchronized：

  • 由JVM层面实现，语法简单。
  • 隐式释放锁，无法手动中断。

• ReentrantLock：

  • 由Java库提供，功能更丰富，如可中断锁请求、定时获取锁、实现公平锁等。
  • 需要显式释放锁，使用更加灵活。

示例：

import java.util.concurrent.locks.ReentrantLock;class LockExample {private ReentrantLock lock = new ReentrantLock();private int count = 0;public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {lock.lock();try {return count;} finally {lock.unlock();}}
}

---

6. 注意事项

1. 避免过大范围的同步：

   • 过大的同步块会导致性能下降，尽量缩小synchronized的范围，只保护必要的代码部分。

2. 防止死锁：

   • 若多个线程需要获取多个锁，确保获取锁的顺序一致，避免循环等待导致死锁。

3. 公平性：

   • 默认的synchronized锁是非公平的，即线程获取锁的顺序不保证。但是，可以使用ReentrantLock的公平策略来控制。

4. 适当使用锁：

   • 并非所有情况都需要使用synchronized，在简单的只读数据或只写数据场景下，可以考虑其他并发机制，如volatile、Atomic类等。

---

7. 总结

sychronized 关键字在Java中不仅用于实现线程间的互斥访问，还通过内存屏障机制保证了内存的可见性。具体来说：

• 可见性保证：synchronized 通过强制刷新工作内存与主内存之间的数据，确保一个线程在退出synchronized块时对共享变量的修改对其他线程是可见的。
• 互斥性保证：synchronized 确保同一时间只有一个线程执行被同步的代码块，防止数据竞态。

因此，在需要保证线程安全的场景下，synchronized 是一种简单而有效的同步机制，既能确保数据的一致性，又能维护内存的可见性。

如果需要更高级的锁特性或更细粒度的控制，可以考虑使用java.util.concurrent包中的其他并发工具，如ReentrantLock、ReadWriteLock等。