文章目录
- 写在前面
- 等待/通知相关方法
- 使用实例与解析
- 等待/通知的经典范式
写在前面
一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作,整个过程开始于一个线程,而最终执行又是另一个线程。前者是生产者,后者就是消费者,这种模式隔离了“做什么”(what)和“怎么做”(How),在功能层面上实现了解耦,体系结构上具备了良好的伸缩性,在 Java 语言中如何实现类似的功能呢?
答案:Java 通过内置的等待/通知机制能够很好地解决线程间通信的功能。
等待/通知相关方法
等待/通知的相关方法是任意 Java 对象都具备的,因为这些方法被定义在所有对象的超类 java.lang.Object 上,方法和描述如下表
方法名称 | 描述 |
notify() | 通知一个在对象上等待的线程,使其从wait()方法返回,而返回的前提是该线程获取到了对象的锁 |
notyfyAll() | 通知所有等待在该对象上的线程 |
wait() | 调用该方法的线程进入WAITING状态,只有等待另外线程的通知或被中断才会返回,需要注意,调用wait()方法后,会释放对象的锁 |
wait(long) | 超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n毫秒,如果没有通知就超时返回 |
wait(long, int) | 对于超时时间更细粒度的控制,可以达到纳秒 |
等待/通知机制,是指一个线程 A 调用了对象 O 的 wait()方法进入等待状态,而另一个线程 B 调用了对象 O 的 notify()或者 notifyAll()方法,线程 A 收到通知后从对象 O 的wait()方法返回,进而执行后续操作。上述两个线程通过对象 O 来完成交互,而对象上的wait()和 notify/notifyAll()的关系就如同开关信号一样,用来完成等待方和通知方之间的交互工作。
使用实例与解析
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class WaitNotifyTest {
static volatile boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) throws Exception {
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
}
public static String getDate() {
return new SimpleDateFormat(" HH: mm: ss ").format(new Date());
}
static class Wait implements Runnable {
public void run() {
// 加锁,拥有 lock 的 Monitor
synchronized (lock) {
// 当条件不满足时,继续 wait,同时释放了 lock 的锁
while (flag) {
try {
System.out.println(Thread.currentThread() + " flag is true. wa @ " + getDate());
lock.wait();
} catch (InterruptedException e) {
}
}
// 条件满足时,完成工作
System.out.println(Thread.currentThread() + " flag is false. running @ " + getDate());
}
}
}
static class Notify implements Runnable {
public void run() {
// 加锁,拥有 lock 的 Monitor
synchronized (lock) {
// 获取 lock 的锁,然后进行通知,通知时不会释放 lock 的锁,
// 直到当前线程释放了 lock 后,WaitThread 才能从 wait 方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify @ " + getDate());
lock.notifyAll();
flag = false;
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 再次加锁
synchronized (lock) {
System.out.println(Thread.currentThread() + " hold lock again. sleep @ " + getDate());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
执行结果:
Thread[WaitThread,5,main] flag is true. wa @ 15: 59: 53
Thread[NotifyThread,5,main] hold lock. notify @ 15: 59: 54
Thread[WaitThread,5,main] flag is false. running @ 15: 59: 59
Thread[NotifyThread,5,main] hold lock again. sleep @ 15: 59: 59
上述例子主要说明了调用 wait()、notify()以及 notifyAll()时需要注意的细节,如下:
- 使用 wait()、notify()和 notifyAll()时需要先对调用对象加锁。
- 调用 wait()方法后,线程状态由 RUNNING 变为 WAITING,并将当前线程放置到对象的等待队列。
- notify()或 notifyAll()方法调用后,等待线程依旧不会从 wait()返回,需要调用notify()或 notifAll()的线程释放锁之后,等待线程才有机会从 wait()返回。
- notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列,被移动的线程状态由 WAITING 变为 BLOCKED。
- 从 wait()方法返回的前提是获得了调用对象的锁。
从上述细节中可以看到,等待/通知机制依托于同步机制,其目的就是确保等待线程 从 wait()方法返回时能够感知到通知线程对变量做出的修改。
以下是该实例的执行过程
WaitThread 首先获取了对象的锁,然后调用对象的 wait()方法,从而放弃了锁并进入了对象的等待队列 WaitQueue 中,进入等待状态。由于 WaitThread 释放了对象的锁, NotifyThread 随后获取了对象的锁,并调用对象的 notify()方法,将WaitThread 从 WaitQueue 移到 SynchronizedQueue 中,此时 WaitThread 的状态变为阻塞状态。NotifyThread 释放了锁之后, WaitThread 再次获取到锁并从 wait()方法返回继续执行。
等待/通知的经典范式
等待/通知的经典范式分为两部分,分别针对等待方(消费者)和通知方(生产者)。
等待方遵循如下原则:
- 获取对象的锁。
- 如果条件不满足,那么调用对象的 wait()方法,被通知后仍要检查条件。
- 条件满足则执行对应的逻辑。
对应的伪代码如下:
synchronized(对象) {
while(条件不满足) {
对象.wait();
}
对应的处理逻辑
}
通知方遵循如下原则:
- 获得对象的锁。
- 改变条件。
- 通知所有等待在对象上的线程。
对应的伪代码如下:
synchronized(对象){
改变条件
对象.notifyAll();
}