什么是wait、notify和notifyAll
wait
、notify
、notifyAll
都是是Object的方法,任何一个继承Object类的对象都可以调用- 所有的操作都是针对
某个特定的对象
来说的,比如对象的引用变了,那么就相当于wait
和notify
作用在了两个不同的对象上,会抛出IllegalMonitorStateException
- 这三个方法只有在当前线程获取到对象的
Monitor
(可以理解为锁)以后才可以调用 同一时间
,只有一个线程
可以获得对象的Monitor
- 当前线程获取对象的
Monitor
有三种方式- 通过执行这个对象的
synchronized
实例方法 - 通过执行以这个对象作为同步锁的
synchronized
方法体 - 对于
Class
类型的对象,执行一个该类型的synchronized
静态方法
- 通过执行这个对象的
wait
调用后,会让线程进入等待状态,知道另外一个线程唤醒它,并释放对象的Monitor
(释放锁)notify
调用后,会唤醒等待当前对象Monitor
的一个线程,具体哪一个不好说,由JVM控制notifyAll
调用后,会唤醒所有等待当前对象Monitor
的线程- 被唤醒的线程不会立刻运行,而是会等待持有对象
Monitor
的线程将Monitor
(锁)释放掉。在Monitor
被释放掉以后,所有被唤醒的线程,将会重新竞争这个锁,获取到锁的线程才会执行wait
的下一条语句 - 官方文档建议将
wait
放到一个循环中,因为在多线程的环境下,共享对象的状态随时可能改变,所以通过while
循环的条件判断,当满足条件的情况下,再触发wait
什么时候释放锁?
由于等待锁的线程只有在获得这把锁之后,才能恢复运行,所以让持有锁的线程在不需要锁的时候及时释放锁是很重要的。
在以下情况下,持有锁的线程会释放锁:
- 执行完同步代码块。
- 在执行同步代码块的过程中,遇到异常而导致线程终止。
- 在执行同步代码块的过程中,执行了锁所属对象的wait()方法,这个线程会释放锁,进行对象的等待池。
除了以上情况外,只要持有锁的线程还没有执行完同步代码块,就不会释放锁。
因此在以下情况下,线程不会释放锁:
- 在执行同步代码块的过程中,执行了Thread.sleep()方法,当前线程放弃CPU,开始睡眠,在睡眠中不会释放锁。
- 在执行同步代码块的过程中,执行了Thread.yield()方法,当前线程放弃CPU,但不会释放锁。
- 在执行同步代码块的过程中,其他线程执行了当前对象的suspend()方法,当前线程被暂停,但不会释放锁。但Thread类的suspend()方法已经被废弃。
三种获取Monitor
的方式
- 对象,锁为对象
public class WaitNotifyMonitorObjectDemo {
private static Object o = new Object();
private static boolean flag = true;
static final class A extends Thread {
@Override
public void run() {
synchronized (o) {
while (flag) {
try {
System.out.println("ready to wait");
o.wait();
System.out.println("i am back");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = true;
}
}
}
static final class B extends Thread {
@Override
public void run() {
synchronized (o) {
o.notify();
System.out.println("wake up o");
flag = false;
}
}
}
public static void main(String[] args) {
A a = new A();
a.start();
B b = new B();
b.start();
}
}
执行结果
ready to wait
i am back
ready to wait
- 同步方法,锁为方法所在对象
public class WaitNotifySyncMethodDemo {
private static boolean flag = true;
static class A {
synchronized void method1() {
while (flag) {
try {
System.out.println("ready to wait");
this.wait();
System.out.println("i am back");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = true;
}
synchronized void method2() {
this.notify();
}
}
public static void main(String[] args) {
final A a = new A();
new Thread(a::method1).start();
new Thread(a::method2).start();
}
}
执行结果
ready to wait
i am back
ready to wait
- 同步静态方法,锁为类对象
public class WaitNotifySyncStaticMethodDemo {
private static boolean flag = true;
private synchronized static void method1() {
while (flag) {
try {
System.out.println("ready to wait");
WaitNotifySyncStaticMethodDemo.class.wait();
System.out.println("i am back");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = true;
}
private synchronized static void method2() {
WaitNotifySyncStaticMethodDemo.class.notify();
}
public static void main(String[] args) {
new Thread(WaitNotifySyncStaticMethodDemo::method1).start();
new Thread(WaitNotifySyncStaticMethodDemo::method2).start();
}
}
执行结果
ready to wait
i am back
ready to wait
notify和notifyAll的区别示例
- 待补充