本文深入探讨java中多线程同步的关键机制，通过分析实际场景，详细阐述`synchronized`关键字在方法和代码块层面的作用、内存可见性问题、`wait()`与`notify()`/`notifyall()`的协作原理，以及如何正确协调lambda表达式创建的线程。旨在帮助开发者构建健壮、高效的并发应用。
1. synchronized代码块与内存可见性
在Java多线程编程中，确保共享数据的一致性和可见性至关重要。synchronized关键字是实现这一目标的核心工具。它不仅保证了代码块的原子性，还通过内存屏障确保了内存可见性。
场景分析： 考虑一个共享列表a和两个操作方法foo和goo：
Lista = new ArrayList<>(); // 共享列表 void foo(int i) { synchronized (a) { // 对列表a进行同步 a.add(i); } } int goo() { return a.size(); // 未同步访问 }
问题： 如果多个线程同时运行，一个线程在foo方法中执行同步代码块时，其他线程是否可以访问未同步的goo方法，从而读取a的尺寸？反之，如果一个线程通过未同步的goo访问a，另一个线程能否进入foo的同步块？
深入解析： 是的，在上述代码中，线程可以同时执行foo的同步块和goo的非同步块。
- foo执行时访问goo： 当一个线程在foo中持有a的锁并执行a.add(i)时，其他线程可以自由调用goo()。goo()方法没有对a进行同步，因此它不会尝试获取a的锁。这意味着goo()可能会读取到a的过时（stale）状态，即在foo中添加的元素可能尚未对goo()可见，或者在foo执行过程中，goo()读取到一个不一致的中间状态。这会引发内存可见性问题和数据不一致性。
- goo执行时进入foo： 当一个线程在执行goo()时，它没有持有任何锁。因此，另一个线程可以随时尝试进入foo()的同步块。由于foo()需要获取a的锁，它会尝试获取该锁。如果此时没有其他线程持有a的锁（例如，前一个foo调用已完成），它将成功进入；否则，它将等待直到锁可用。
正确做法： 为了确保共享数据a的线程安全，所有访问a（无论是读还是写）的代码都必须在同一个锁对象上进行同步。这样可以保证操作的原子性和内存可见性。
import java.util.ArrayList;
import java.util.List;
public class SynchronizedListExample {
private final List sharedList = new ArrayList<>();
// 写入操作，同步在sharedList对象上
public void addElement(int i) {
synchronized (sharedList) {
sharedList.add(i);
System.out.println(Thread.currentThread().getName() + " added: " + i + ", size: " + sharedList.size());
}
}
// 读取操作，同样同步在sharedList对象上，确保可见性
public int getSize() {
synchronized (sharedList) {
int size = sharedList.size();
System.out.println(Thread.currentThread().getName() + " read size: " + size);
return size;
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedListExample example = new SynchronizedListExample();
// 启动多个线程进行读写
Runnable writer = () -> {
for (int i = 0; i < 5; i++) {
example.addElement(i);
try {
Thread.sleep(50); // 模拟耗时操作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
};
Runnable reader = () -> {
for (int i = 0; i < 5; i++) {
example.getSize();
try {
Thread.sleep(70); // 模拟耗时操作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
};
Thread t1 = new Thread(writer, "Writer-1");
Thread t2 = new Thread(reader, "Reader-1");
Thread t3 = new Thread(writer, "Writer-2");
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
System.out.println("Final list size: " + example.getSize());
}
} 总结： 任何对共享可变状态的访问都必须通过同步机制进行保护，并且所有访问都必须在同一个锁对象上进行同步。否则，可能导致数据不一致和内存可见性问题。
2. wait(), notifyAll() 与锁的释放和获取
wait(), notify()和notifyAll()是Object类的方法，它们只能在synchronized方法或同步代码块内部调用，并且必须在当前线程持有的锁对象上调用。它们用于实现线程间的协作和通信。
立即学习“Java免费学习笔记（深入）”；
场景分析： 考虑以下同步方法：
void synchronized foo() { // 锁对象是'this'
// do stuff 1
notifyAll();
// do stuff 2
if (someStatement)
return;
try {
wait(); // 线程在此等待
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
// do stuff 3
}问题： 如果一个线程A进入foo并执行到wait()，它会释放this对象的锁。此时，如果另一个线程B进入foo并执行到notifyAll()，线程A应该被唤醒并继续执行，但线程B此时正持有this的锁。那么，线程A会如何处理？
深入解析：
-
线程A执行wait()： 当线程A执行到wait()方法时，它会：
- 释放当前线程持有的this对象的锁。 这是wait()的关键行为，允许其他线程进入foo方法或任何其他同步在this对象上的方法/块。
- 进入等待状态。 线程A会进入this对象的等待队列，直到被唤醒。
-
线程B进入并执行notifyAll()： 此时，this对象的锁已被线程A释放，所以线程B可以成功获取this的锁并进入foo方法。当线程B执行到notifyAll()时：
- notifyAll()会唤醒所有在this对象上等待的线程（包括线程A）。
- 被唤醒的线程（如线程A）并不会立即继续执行。 它会从等待队列移动到就绪队列，重新尝试获取this对象的锁。
- 锁的竞争： 此时，线程B仍然持有this对象的锁。因此，被唤醒的线程A将无法立即获取锁，它会再次进入阻塞状态，等待线程B释放锁。
- 线程B释放锁： 当线程B执行完foo方法（或者在foo方法内部因为wait()而释放锁），它会释放this对象的锁。
- 线程A获取锁并继续： 线程A在线程B释放锁后，会竞争获取this对象的锁。一旦成功获取锁，它将从wait()方法之后继续执行foo方法中的剩余代码（do stuff 3）。
重要提示：
- wait()方法通常需要在一个循环中调用，以防止“虚假唤醒”（spurious wakeups）和确保等待条件真正满足。
- notifyAll()通常比notify()更安全，因为它会唤醒所有等待的线程，避免“丢失的唤醒”问题，尤其是在有多种等待条件时。
public class WaitNotifyExample {
private boolean conditionMet = false;
public synchronized void producer() {
System.out.println(Thread.currentThread().getName() + ": Producer started.");
// do stuff 1
conditionMet = true; // 改变条件
notifyAll(); // 唤醒所有等待的消费者线程
System.out.println(Thread.currentThread().getName() + ": Notified. (do stuff 2)");
// do stuff 2
// 假设这里还有一些工作，或直接返回
// if (someStatement) return; // 模拟提前返回
System.out.println(Thread.currentThread().getName() + ": Producer finished its work before wait.");
// 假设这里也可能需要等待某种条件
// try {
// wait(); // 如果生产者也需要等待，它会释放锁
// } catch (InterruptedException e) {
// Thread.currentThread().interrupt();
// }
// System.out.println(Thread.currentThread().getName() + ": Producer continued after its own wait.");
}
public synchronized void consumer() {
System.out.println(Thread.currentThread().getName() + ": Consumer started.");
// do stuff 1
while (!conditionMet) { // 循环等待，防止虚假唤醒
System.out.println(Thread.currentThread().getName() + ": Condition not met, waiting...");
try {
wait(); // 释放锁并等待
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
System.out.println(Thread.currentThread().getName() + ": Condition met, continuing. (do stuff 3)");
// do stuff 3
}
public static void main(String[] args) throws InterruptedException {
WaitNotifyExample example = new WaitNotifyExample();
Thread consumerThread1 = new Thread(example::consumer, "Consumer-1");
Thread consumerThread2 = new Thread(example::consumer, "Consumer-2");
Thread producerThread = new Thread(example::producer, "Producer-1");
consumerThread1.start();
consumerThread2.start();
Thread.sleep(100); // 确保消费者线程先进入等待状态
producerThread.start();
consumerThread1.join();
consumerThread2.join();
producerThread.join();
}
}3. 协调Lambda表达式创建的线程
当使用Lambda表达式创建线程时，其本质仍然是实现了Runnable接口的对象。要实现线程间的wait()/notify()通信，关键在于确定一个共享的监视器对象（monitor object），所有参与通信的线程都必须在该对象上进行同步。
websenB2B是一套经过完善设计的B2B行业网站程序，是windows nt系列环境下最佳的B2B行业网产站解决方案。精心设计的架构与功能机制，适合从个人到企业各方面应用的要求，为您提供一个安全、稳定、高效、易用而快捷的行业网站商务系统。分普及版和商业版等不同版本。一、网胜B2B电子商务系统SP6.2蓝色风格普及版本升级功能说明：1、邮件群发功能：可以选择某一级别的会员，并放入支持html
场景分析：
class A implements Runnable { // A实现了Runnable，但这不是重点
Thread b; // 引用一个Lambda创建的线程
void foo() {
b = new Thread(() -> {
// some lambda function logic
System.out.println(Thread.currentThread().getName() + " is running.");
// 假设这里需要等待通知
// 怎么等待通知？
}, "Lambda-Thread");
b.start();
}
void goo() {
// 如何通知线程b？
}
@Override
public void run() {
// A的run方法，可能不被使用，或有其他用途
}
}问题： 如何在goo()方法中通知由Lambda表达式创建的线程b？
深入解析：notify()和notifyAll()方法不是直接在Thread对象上调用的，而是作用于线程正在等待的监视器对象上。Thread b只是一个线程的引用，它本身不是一个合适的监视器对象来协调其内部的Lambda逻辑。
要实现线程间的通知，你需要：
- 创建一个共享的监视器对象。 这个对象可以是任何Java对象，但通常是一个专门用于同步的final对象。
- 让需要等待的线程在监视器对象上调用wait()。
- 让需要通知的线程在同一个监视器对象上调用notify()或notifyAll()。
- 所有wait()和notify()/notifyAll()调用都必须在持有该监视器对象的锁的同步块中进行。
示例：使用共享对象进行通知
public class LambdaThreadCoordination {
// 共享的监视器对象，用于线程间的通信
private final Object monitor = new Object();
private boolean condition = false; // 共享条件
public void startLambdaThread() {
Thread b = new Thread(() -> {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + ": Lambda thread started.");
synchronized (monitor) { // 必须同步在同一个监视器对象上
while (!condition) { // 循环等待条件
System.out.println(threadName + ": Condition not met, waiting...");
try {
monitor.wait(); // 释放monitor的锁并等待
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println(threadName + ": Interrupted while waiting.");
return;
}
}
System.out.println(threadName + ": Condition met, proceeding.");
// 执行Lambda线程的后续逻辑
}
System.out.println(threadName + ": Lambda thread finished its work.");
}, "Worker-Lambda-Thread");
b.start();
}
public void notifyLambdaThread() {
synchronized (monitor) { // 必须同步在同一个监视器对象上
System.out.println(Thread.currentThread().getName() + ": Notifying the lambda thread...");
condition = true; // 改变条件
monitor.notifyAll(); // 唤醒所有在monitor上等待的线程
System.out.println(Thread.currentThread().getName() + ": Notification sent.");
}
}
public static void main(String[] args) throws InterruptedException {
LambdaThreadCoordination coordinator = new LambdaThreadCoordination();
// 启动Lambda线程，它会立即进入等待状态
coordinator.startLambdaThread();
Thread.sleep(100); // 确保Lambda线程有时间启动并进入等待
// 在主线程中调用通知方法
coordinator.notifyLambdaThread();
// 可以在这里等待Lambda线程结束，如果需要
// Thread.sleep(500); // 简单的等待
}
}总结： 无论线程是如何创建的（匿名内部类、Lambda表达式、实现Runnable接口的类），wait()和notify()/notifyAll()机制的核心都是基于一个共享的监视器对象。线程必须在持有该监视器对象的锁的情况下调用这些方法。Thread对象本身通常不作为通信的监视器对象，而是作为线程的执行实体。
总结与最佳实践
Java的同步机制是构建可靠并发应用的基础。理解synchronized关键字的原子性和可见性保证，以及wait()/notify()/notifyAll()的协作原理，是至关重要的。
关键点回顾：
- 一致的同步： 所有访问共享可变状态的操作都必须在同一个锁对象上进行同步，以确保数据一致性和内存可见性。
- wait()/notify()的锁行为： wait()会释放锁并进入等待，被唤醒后需要重新获取锁才能继续执行。notify()/notifyAll()必须在持有锁的情况下调用。
- 循环中的wait()： 始终在while循环中调用wait()，以处理虚假唤醒并重新检查条件。
- 共享监视器对象： 线程间通信（wait()/notify()）需要一个所有参与线程都能访问的共享监视器对象，而不是直接在Thread对象上操作。
- notifyAll()优先： 在不确定哪个线程需要被唤醒时，优先使用notifyAll()，以避免“丢失的唤醒”问题。
进阶提示： 对于更复杂的并发场景，java.util.concurrent包提供了更高级和灵活的并发工具，如Lock接口（ReentrantLock）、Semaphore、CountDownLatch、CyclicBarrier以及各种BlockingQueue实现。这些工具提供了比synchronized和wait()/notify()更细粒度的控制和更丰富的功能，有助于编写更健壮、更易于维护的并发代码。
