本文旨在全面解析Java中的同步机制，重点探讨`synchronized`关键字在保护共享资源方面的应用，以及`wait()`, `notify()`, `notifyAll()`方法实现线程间通信的原理与实践。我们将通过具体场景分析，阐明同步访问共享可变状态的重要性、`wait()`方法释放锁的机制，并提供使用lambda表达式创建线程时进行有效通信的示例，旨在帮助开发者构建健壮、高效的并发应用。
Java并发编程中的同步机制
在多线程环境下，当多个线程访问和修改同一个共享资源时，如果不采取适当的同步措施，就可能导致数据不一致、竞态条件等问题。Java提供了多种同步机制来确保线程安全，其中synchronized关键字是最基础也是最常用的工具。
1. synchronized关键字：保护共享可变状态
synchronized关键字可以用于修饰方法或代码块，它确保在任何时刻，只有一个线程可以执行被同步的代码。当一个线程进入synchronized代码块或方法时，它会获取一个锁（也称为监视器锁或内部锁），其他试图进入相同锁保护的代码的线程将被阻塞，直到持有锁的线程释放锁。
1.1 synchronized代码块与共享资源的可见性
考虑一个常见的场景：一个List作为共享资源，多个线程对其进行添加元素和查询大小的操作。
立即学习“Java免费学习笔记（深入）”；
示例代码：不安全的并发访问
import java.util.ArrayList;
import java.util.List;
public class UnsafeListAccess {
private List<Integer> a = new ArrayList<>();
// foo 方法通过 synchronized(a) 保护了对 a 的添加操作
public void foo(int i) {
synchronized (a) {
a.add(i);
System.out.println(Thread.currentThread().getName() + " added " + i + ", current size: " + a.size());
}
}
// goo 方法没有同步，直接访问 a 的大小
public int goo() {
return a.size();
}
public static void main(String[] args) throws InterruptedException {
UnsafeListAccess demo = new UnsafeListAccess();
// 启动多个线程并发调用 foo
for (int i = 0; i < 5; i++) {
final int value = i;
new Thread(() -> demo.foo(value), "Producer-" + value).start();
}
// 等待一段时间，确保 some foo calls might have happened
Thread.sleep(100);
// 在另一个线程中调用 goo
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " queried size: " + demo.goo());
}, "Checker").start();
}
}问题分析： 在上述代码中，foo方法使用了synchronized(a)来确保对a.add(i)操作的原子性和可见性。这意味着在任何给定时刻，只有一个线程可以执行foo方法中synchronized(a)块内的代码。然而，goo方法没有使用任何同步机制来访问a.size()。
线程A执行foo时，线程B能否访问goo？ 是的，可以。因为foo方法同步在对象a上，而goo方法没有同步。synchronized关键字只锁定指定的监视器对象，不影响其他未同步的代码块或方法。因此，当线程A持有a的锁并执行foo时，线程B可以自由地进入并执行goo方法。
线程A通过goo访问a时，线程B能否进入foo的同步块？ 不能。如果线程A正在执行goo（未同步），而线程B试图进入foo的synchronized(a)块，线程B将需要获取对象a的锁。由于goo没有持有a的锁，线程B可以立即尝试获取锁。一旦线程B成功获取锁，它就可以进入foo的同步块。
数据一致性问题： 尽管线程B可以访问goo，但这种设计存在严重的数据一致性问题。goo()方法返回的a.size()值可能不是最新的。当foo方法向a中添加元素时，这些修改可能不会立即对goo方法可见。这是因为Java内存模型（JMM）规定，没有同步的读写操作不能保证内存可见性。一个线程对共享变量的修改，可能不会立即刷新到主内存，另一个线程从主内存读取时可能读到旧值。
正确做法：同步所有对共享可变状态的访问
为了确保数据一致性和可见性，所有访问共享可变状态的代码都必须进行同步。这意味着goo方法也应该同步在同一个监视器对象上。
import java.util.ArrayList;
import java.util.List;
public class SafeListAccess {
private final List<Integer> a = new ArrayList<>(); // 使用 final 确保引用不变
// foo 方法同步在 a 上
public void foo(int i) {
synchronized (a) {
a.add(i);
System.out.println(Thread.currentThread().getName() + " added " + i + ", current size: " + a.size());
}
}
// goo 方法也同步在 a 上，确保可见性和原子性
public int goo() {
synchronized (a) { // 必须同步在同一个对象上
return a.size();
}
}
public static void main(String[] args) throws InterruptedException {
SafeListAccess demo = new SafeListAccess();
// 启动多个线程并发调用 foo
for (int i = 0; i < 5; i++) {
final int value = i;
new Thread(() -> demo.foo(value), "Producer-" + value).start();
}
// 等待一段时间，确保 some foo calls might have happened
Thread.sleep(100);
// 在另一个线程中调用 goo
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " queried size: " + demo.goo());
}, "Checker").start();
}
}通过同步goo方法，我们确保了在foo对a进行修改后，goo能够看到最新的a的状态。
2. wait(), notify(), notifyAll()：线程间协作
除了保护共享资源，线程间经常需要进行协作，例如一个线程需要等待某个条件满足后才能继续执行，或者一个线程通知其他线程某个条件已经满足。Object类提供的wait(), notify(), notifyAll()方法是实现这种协作的基础。
重要原则：
- 这三个方法都必须在synchronized代码块或方法中调用，并且必须作用于当前线程所持有的监视器对象上。
- wait()方法会释放当前线程持有的监视器锁，并使线程进入等待状态，直到被notify()或notifyAll()唤醒，或者被中断。
- notify()方法会唤醒一个在当前对象上等待的线程。
- notifyAll()方法会唤醒所有在当前对象上等待的线程。
2.1 wait()方法释放锁的机制
示例场景：
public class WaitNotifyDemo {
public synchronized void foo() {
System.out.println(Thread.currentThread().getName() + " entered foo, holding lock.");
// do stuff before wait
notifyAll(); // 尝试唤醒其他线程
// do stuff after notifyAll
if (Thread.currentThread().getName().equals("Thread-1")) { // 假设某个条件
System.out.println(Thread.currentThread().getName() + " going to wait().");
try {
wait(); // 线程1进入等待状态并释放锁
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
System.out.println(Thread.currentThread().getName() + " resumed from wait() or finished.");
// do stuff after wait
}
public static void main(String[] args) throws InterruptedException {
WaitNotifyDemo demo = new WaitNotifyDemo();
Thread t1 = new Thread(() -> demo.foo(), "Thread-1");
Thread t2 = new Thread(() -> demo.foo(), "Thread-2");
t1.start();
Thread.sleep(50); // 确保t1先进入
t2.start();
t1.join();
t2.join();
}
}问题分析： 假设Thread-1先进入foo方法，执行到wait()。
- Thread-1进入foo方法，获取WaitNotifyDemo实例的锁。
- Thread-1执行notifyAll()。此时，如果还没有其他线程在等待，这个notifyAll()将不起作用。
- Thread-1执行wait()方法。关键点：wait()方法会立即释放WaitNotifyDemo实例的锁，然后Thread-1进入等待状态。
- 此时，WaitNotifyDemo实例的锁被释放，Thread-2有机会获取到锁并进入foo方法。
- Thread-2进入foo方法，获取WaitNotifyDemo实例的锁。
- Thread-2执行notifyAll()。由于Thread-1正在等待，它会被这个notifyAll()唤醒。
- Thread-1被唤醒后，它并不能立即继续执行，因为它需要重新获取WaitNotifyDemo实例的锁。
- Thread-2继续执行foo方法中剩余的代码（如果if条件不满足，或者直接执行到方法结束）。
- 当Thread-2退出foo方法时，它会释放WaitNotifyDemo实例的锁。
- Thread-1现在可以尝试重新获取锁。一旦获取成功，它将从wait()方法处继续执行。
总结： wait()方法会释放锁，允许其他线程进入同步块。被notify()/notifyAll()唤醒的线程，必须在重新获得锁之后才能继续执行。
3. Lambda表达式创建线程的通知机制
当使用Lambda表达式创建线程时，我们通常会得到一个Thread对象的引用。要通知这个线程，我们不能直接对Thread对象调用wait()或notify()，因为wait()/notify()是Object类的方法，它们操作的是监视器锁，而不是线程本身。
核心思想： 线程间通信需要一个共享的监视器对象。
示例场景： 如何通知一个由Lambda表达式创建的线程？
public class LambdaThreadNotify {
// 定义一个共享的监视器对象
private final Object monitor = new Object();
private volatile boolean conditionMet = false; // 共享条件
Thread workerThread;
public void startWorker() {
workerThread = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + ": Worker started.");
synchronized (monitor) { // 线程需要同步在同一个监视器对象上
while (!conditionMet) { // 使用循环防止虚假唤醒
try {
System.out.println(Thread.currentThread().getName() + ": Worker waiting for condition...");
monitor.wait(); // 释放 monitor 的锁并等待
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println(Thread.currentThread().getName() + ": Worker interrupted.");
return;
}
}
System.out.println(Thread.currentThread().getName() + ": Worker condition met, continuing...");
// 执行后续任务
}
System.out.println(Thread.currentThread().getName() + ": Worker finished its task.");
}, "LambdaWorker");
workerThread.start();
}
public void notifyWorker() {
synchronized (monitor) { // 通知方也需要同步在同一个监视器对象上
System.out.println(Thread.currentThread().getName() + ": Notifier setting condition and notifying.");
conditionMet = true; // 改变共享条件
monitor.notifyAll(); // 唤醒所有在 monitor 上等待的线程
}
}
public static void main(String[] args) throws InterruptedException {
LambdaThreadNotify demo = new LambdaThreadNotify();
demo.startWorker(); // 启动工作线程
Thread.sleep(1000); // 模拟主线程做一些其他工作
demo.notifyWorker(); // 通知工作线程
demo.workerThread.join(); // 等待工作线程结束
System.out.println("Main thread finished.");
}
}实现方法：
- 共享监视器对象： 创建一个所有相关线程都能访问的共享Object实例（例如monitor）。
- 工作线程等待： 在Lambda线程内部，在synchronized (monitor)块中，使用monitor.wait()来等待某个条件。wait()会释放monitor的锁。
- 通知方唤醒： 在需要通知工作线程的方法中（例如notifyWorker()），同样在synchronized (monitor)块中，修改共享条件（如conditionMet = true），然后调用monitor.notifyAll()来唤醒等待的线程。
- 循环检查条件： 被wait()唤醒的线程，在继续执行前，应再次检查等待条件是否满足（通常在一个while循环中）。这是为了处理虚假唤醒（spurious wakeups）和多个线程被唤醒但条件只满足一个的情况。
总结与最佳实践
- 同步所有访问： 任何对共享可变状态的读写操作都必须通过同步机制进行保护，且所有相关操作应同步在同一个监视器对象上，以确保数据一致性和内存可见性。
- 理解synchronized锁定的对象： synchronized代码块锁定的是括号中的对象，synchronized方法锁定的是方法所属的实例对象（对于静态方法，锁定的是类的Class对象）。
- wait(), notify(), notifyAll()的正确使用： 它们必须在synchronized块中调用，并且作用于当前线程持有的锁对象。wait()会释放锁，而notify()/notifyAll()不会释放锁，直到同步块结束。
- 使用while循环检查等待条件： 永远不要在if语句中调用wait()，因为线程可能被虚假唤醒或被其他条件不满足的notify()唤醒。
- 选择合适的同步工具： 对于更复杂的并发场景，Java并发包（java.util.concurrent）提供了更高级、更灵活的工具，如ReentrantLock, Semaphore, CountDownLatch, CyclicBarrier, BlockingQueue等，它们通常比裸露的synchronized和wait/notify组合更易于使用和管理。例如，BlockingQueue可以优雅地解决生产者-消费者问题，而无需手动实现wait/notify。
深入理解和正确应用Java的同步机制是编写高性能、高可靠性并发应用程序的关键。通过遵循上述原则和最佳实践，开发者可以有效地管理线程间的协作与竞争，避免常见的并发陷阱。
