本文深入探讨java并发编程中的同步机制，重点解析`synchronized`关键字在方法和代码块中的应用，以及`wait()`、`notify()`和`notifyall()`方法实现线程间通信的原理。文章通过具体场景分析了共享资源访问的线程安全性问题，强调了正确使用锁对象的重要性，并提供了示例代码，帮助读者理解如何避免数据不一致和实现有效的线程协作。
理解Java中的同步机制
在多线程环境中，为了保证共享数据的完整性和一致性，Java提供了多种同步机制。其中，synchronized关键字是最基本也是最常用的方式，它基于监视器（Monitor）锁实现。每个Java对象都可以作为一个监视器锁，当一个线程进入synchronized代码块或方法时，它会尝试获取该对象的锁。如果锁已被其他线程持有，当前线程就会被阻塞，直到锁被释放。
1. synchronized与共享资源访问
synchronized关键字可以用于修饰方法或代码块。当修饰方法时，它锁定的是当前实例对象（对于静态方法，锁定的是类的Class对象）；当修饰代码块时，它锁定的是括号中指定的对象。
考虑以下场景，一个共享列表a和两个操作它的方法：
import java.util.ArrayList;
import java.util.List;
public class SynchronizedExample {
private List a = new ArrayList<>();
// 方法foo使用synchronized块来保护对列表a的写入操作
public void foo(int i) {
synchronized (a) { // 锁定列表a对象
a.add(i);
System.out.println(Thread.currentThread().getName() + " added: " + i + ", current size: " + a.size());
}
}
// 方法goo读取列表a的大小
public int goo() {
// 错误的示例：未同步访问共享资源
// return a.size();
// 正确的同步方式：也需要锁定列表a对象
synchronized (a) {
int size = a.size();
System.out.println(Thread.currentThread().getName() + " read size: " + size);
return size;
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedExample example = new SynchronizedExample();
// 线程1执行foo
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
example.foo(i);
try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
}, "WriterThread");
// 线程2执行goo
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
example.goo();
try { Thread.sleep(15); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
}, "ReaderThread");
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final size of list a: " + example.a.size());
}
} 分析：
立即学习“Java免费学习笔记（深入）”；
- 未同步的goo()方法： 如果goo()方法不使用synchronized (a)，那么当一个线程在foo()中持有a的锁并修改a时，另一个线程可以同时进入goo()并访问a。这会导致严重的数据不一致问题。例如，foo()可能已经添加了一个元素，但由于内存可见性问题，goo()可能仍然读取到旧的、未更新的列表大小。synchronized不仅保证了原子性，还保证了内存可见性。
- 正确的同步： 为了确保数据一致性，所有对共享资源（例如这里的List a）的访问（无论是读还是写）都必须通过相同的锁对象进行同步。这意味着goo()方法也应该使用synchronized (a)来保护对a.size()的访问。当一个线程在foo()中获取a的锁时，其他尝试进入foo()或goo()（如果goo()也同步在a上）的线程将被阻塞，直到锁被释放。
结论： 只要访问的是同一个共享对象，并且使用了相同的锁对象进行同步，那么在任何时刻，只有一个线程能够执行受该锁保护的代码块。如果对共享资源的访问没有全部同步，则无法保证线程安全。
2. wait(), notify(), notifyAll() 实现线程协作
wait(), notify(), notifyAll()是Object类的方法，用于实现线程间的协作和通信。它们必须在synchronized代码块或方法内部调用，并且操作的锁对象必须是当前线程所持有的监视器锁。
考虑一个使用wait()和notifyAll()的同步方法：
public class WaitNotifyExample {
private boolean conditionMet = false;
public synchronized void fooWithWaitNotify() {
System.out.println(Thread.currentThread().getName() + " entered fooWithWaitNotify.");
// do stuff before waiting
System.out.println(Thread.currentThread().getName() + " doing stuff before wait.");
// 假设某个条件满足后才需要通知
if (!conditionMet) {
try {
System.out.println(Thread.currentThread().getName() + " is about to wait, releasing lock.");
wait(); // 释放当前对象的锁，并进入等待状态
System.out.println(Thread.currentThread().getName() + " woke up and re-acquired lock.");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
// do stuff after waiting or if conditionMet was true initially
System.out.println(Thread.currentThread().getName() + " doing stuff after wait/condition met.");
// 模拟条件满足，通知其他等待线程
if (Thread.currentThread().getName().equals("NotifierThread")) {
conditionMet = true; // 改变条件
System.out.println(Thread.currentThread().getName() + " notifying all waiting threads.");
notifyAll(); // 通知所有等待在当前对象上的线程
}
System.out.println(Thread.currentThread().getName() + " exiting fooWithWaitNotify.");
}
public static void main(String[] args) throws InterruptedException {
WaitNotifyExample example = new WaitNotifyExample();
Thread t1 = new Thread(() -> {
example.fooWithWaitNotify();
}, "WaiterThread");
Thread t2 = new Thread(() -> {
try {
Thread.sleep(100); // 确保WaiterThread先进入等待
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
example.fooWithWaitNotify(); // 这个线程会触发notifyAll
}, "NotifierThread");
t1.start();
t2.start();
t1.join();
t2.join();
}
}分析：
立即学习“Java免费学习笔记（深入）”；
- 线程1 (WaiterThread)进入fooWithWaitNotify()： 它获取了example对象的锁。
- WaiterThread调用wait()： 当WaiterThread执行到wait()时，它会立即释放example对象的锁，然后进入等待状态（WAITING或TIMED_WAITING）。
- 线程2 (NotifierThread)进入fooWithWaitNotify()： 此时example对象的锁已被WaiterThread释放，所以NotifierThread可以成功获取锁并进入方法。
- NotifierThread调用notifyAll()： NotifierThread执行到notifyAll()，它会唤醒所有（包括WaiterThread）正在example对象上等待的线程。但是，被唤醒的线程（WaiterThread）不会立即恢复执行。它必须重新尝试获取example对象的锁。
- NotifierThread退出方法： NotifierThread继续执行，直到方法结束，此时它会释放example对象的锁。
- WaiterThread恢复执行： NotifierThread释放锁后，WaiterThread才能成功重新获取锁，然后从wait()调用的下一行代码继续执行。
关键点： wait()会释放锁，而notify()/notifyAll()不会释放锁，它们只是将等待线程从等待队列移到同步队列，等待获取锁。
3. 线程间通信与notify()特定线程
wait()和notify()/notifyAll()是基于对象监视器的机制，而不是直接操作Thread实例。这意味着你不能直接“通知”一个特定的Thread对象。相反，你需要让需要被通知的线程在一个共享的锁对象上调用wait()，而通知者则在该同一个共享锁对象上调用notify()或notifyAll()。
如果你的目标是通知一个由Lambda表达式创建的线程，你需要确保这个Lambda表达式所运行的线程能够访问到一个共享的锁对象，并且这个锁对象也能够被通知者访问。
public class A implements Runnable {
Thread b;
// 声明一个共享的锁对象，可以是this，也可以是专门创建的Object
private final Object lock = new Object();
private boolean bStarted = false;
public void foo() {
b = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " (lambda thread) started.");
synchronized (lock) { // Lambda线程在lock对象上等待
bStarted = true;
lock.notify(); // 通知foo方法b线程已经启动
try {
System.out.println(Thread.currentThread().getName() + " (lambda thread) waiting for notification...");
lock.wait(); // 等待goo方法的通知
System.out.println(Thread.currentThread().getName() + " (lambda thread) received notification from goo!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
System.out.println(Thread.currentThread().getName() + " (lambda thread) finished.");
}, "LambdaThread-B");
synchronized (lock) {
b.start();
// 等待LambdaThread-B启动并通知
while (!bStarted) {
try {
lock.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
System.out.println("Main thread: LambdaThread-B has started.");
}
}
public void goo() {
synchronized (lock) { // goo方法也在同一个lock对象上同步
System.out.println(Thread.currentThread().getName() + " in goo, notifying LambdaThread-B.");
lock.notify(); // 通知等待在lock对象上的线程
}
}
@Override
public void run() {
// This run method is not directly used in the example but is required by Runnable
}
public static void main(String[] args) throws InterruptedException {
A instance = new A();
instance.foo(); // 启动lambda线程
Thread.sleep(1000); // 确保lambda线程有时间进入等待状态
instance.goo(); // 通知lambda线程
instance.b.join(); // 等待lambda线程结束
System.out.println("All threads finished.");
}
}分析：
立即学习“Java免费学习笔记（深入）”；
- 共享锁对象： 在A类中定义了一个private final Object lock = new Object();作为共享的锁对象。
- Lambda线程的wait()： b线程（Lambda表达式）在其内部通过synchronized (lock)获取lock对象的锁，然后调用lock.wait()进入等待状态。
- goo()方法的notify()： goo()方法也通过synchronized (lock)获取lock对象的锁，然后调用lock.notify()来唤醒等待在lock对象上的线程（即b线程）。
- foo()中的初始同步： foo()方法也使用lock对象进行同步，并等待b线程启动后发出的通知，这确保了b线程已经准备好接收goo()的通知。
通过这种方式，即使你没有直接的Thread引用来操作，只要能够访问到同一个共享的锁对象，就可以实现线程间的通信。
总结与最佳实践
Java的同步机制是构建健壮并发应用程序的基础。正确理解和应用synchronized、wait()、notify()和notifyAll()至关重要。
- 同步所有对共享可变状态的访问： 任何时候，只要有多个线程可能同时读写一个共享的可变数据，就必须使用同步机制来保护它，并且所有访问点都必须使用相同的锁。
- 选择合适的锁对象： 对于实例方法，通常使用this；对于静态方法，使用Class对象。对于代码块，可以选择任何非null的Object实例作为锁。避免使用字符串字面量或基本类型的包装类作为锁，因为它们可能被JVM缓存，导致意想不到的共享。
- wait()/notify()必须在synchronized块中调用： 并且要确保它们操作的是当前线程持有的锁对象。
- 始终在循环中检查等待条件： 使用while (condition)而不是if (condition)来检查wait()后的条件，因为线程可能被虚假唤醒（spurious wakeup），或者被其他线程通知但条件尚未真正满足。
- 考虑使用java.util.concurrent包： 对于更复杂的并发场景，java.util.concurrent包提供了更高级、更灵活、性能更好的并发工具，如ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier以及各种并发集合（如ConcurrentHashMap、BlockingQueue）。它们通常比内置的synchronized提供更好的控制和可伸缩性。
- 避免死锁： 仔细设计锁的获取顺序，避免循环依赖，以防止死锁的发生。
通过深入理解这些机制并遵循最佳实践，开发者可以有效地构建安全、高效的并发Java应用程序。
