线程的等待通知机制
- 一:情景再现:
- 二:等待通知机制:
- 2.1 wait()方法
- 2.2 notify()方法
- 2.22:唤醒了t2线程,t1线程仍处于阻塞等待状态
- 2.23 唤醒了t1线程,t2线程仍处于阻塞等待状态
- 2.24:notifyAll()
一:情景再现:
假设有3个滑稽,1号滑稽在ATM中取钱,2,3号滑稽只能在门口阻塞等待,1号滑稽发现ATM中没钱了,就从ATM中出来了,在2号滑稽进去之前,1号滑稽又进去了,2号又只能阻塞等待,1号发现仍然没钱,又出来了,然后再2号进去之前,1号 又进去了,就这样,1号进进出出,其他滑稽只能阻塞等待.
上述问题,就称为"线程饿死":线程调度是随机的,很可能出现某个线程频繁的获取释放锁,由于获取的太快,以至于其他 线程捞不到CPU资源,导致程序的效率降低.
二:等待通知机制:
等待通知机制,就可以解决上述问题.
当2号滑稽进ATM后,存了一部分钱,告诉1号滑稽,一号滑稽就可以去取钱了.
通过条件,判断当前逻辑是否能够执行,如果不能执行,就主动wait(主动进行阻塞),就把执行的机会让给别的线程了,避免该线程进行一些无意义的重试.等后续条件实际成熟了(需要其他线程通知),再让阻塞的线程被唤醒.
2.1 wait()方法
wait()方法,是Object提供的方法,任何一个对象,都有这个方法.
wait()内部做的事情,不仅仅是阻塞等待,还要解锁,解锁的同时,进行等待.解锁之后,其他线程就可以获取到锁对象了
要想解锁,那么首先就必须有锁,所以wait()方法往往是和synchronized关键字搭配使用的.
public class Demo3 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
System.out.println("解锁之前");
synchronized (object){
object.wait();
}
System.out.println("解锁之后");
}
}
此时main线程就进入阻塞等待状态,直到其他线程将他唤醒.
通过jconsole也可以看到main线程的状态.
2.2 notify()方法
通过另一个线程,去唤醒阻塞的线程.
public class Demo4 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
Thread t1=new Thread(()->{
synchronized (object){
System.out.println("t1 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 等待之后");
}
});
Thread t2=new Thread(()->{
Scanner scanner=new Scanner(System.in);
synchronized (object){
System.out.println("t2 通知之前");
scanner.next();
object.notify();
System.out.println("t2 通知之后");
}
});
// Thread.sleep(1000);
t2.start();
t1.start();
}
}
当用户时输入内容之后,此时就会使t2线程调度到CPU上,然后才进一步的执行到notify,notify就会唤醒wait()操作,从而使t1回到RUNNABLE状态参与调度.
当然,把t1唤醒,t1是不能立即就能执行的,t1要重新获取到锁.
由于此时t2还没有释放锁,意味着t1会从WAITING->RUNNABLE->BLOCKED
因为t1 ,t2执行抢占式执行,执行顺序不确定,那么就有可能t2先执行了notify,此时t1还没wait,那么notify就不会有任何效果(也不会抛异常),但是后续t1进入wait()之后,就没有人能够唤醒了.
public class Demo4 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
Thread t1=new Thread(()->{
synchronized (object){
System.out.println("t1 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 等待之后");
}
});
Thread t2=new Thread(()->{
Scanner scanner=new Scanner(System.in);//借助 scanner 控制阻塞. 用户输入之前, 都是阻塞状态.
synchronized (object){
System.out.println("t2 通知之前");
scanner.next();
object.notify();
System.out.println("t2 通知之后");
}
});
// Thread.sleep(1000);
t2.start();
t1.start();
}
}
上述代码t1线程就一直处于阻塞状态,进程也不会结束了.
如果有多个要唤醒的线程,那么唤醒哪一个是随机的.
那么就需要多个锁对象,不同的线程使用不同的锁对象来wait,唤醒的时候,再根据锁对象去唤醒.
2.22:唤醒了t2线程,t1线程仍处于阻塞等待状态
public class Demo5 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
Object object2=new Object();
Thread t1=new Thread(()->{
synchronized (object){
System.out.println("t1 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 等待之后");
}
});
Thread t2=new Thread(()->{
synchronized (object2){
System.out.println("t2 等待之前");
try {
object2.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2 等待之后");
}
});
Thread t3=new Thread(()->{
synchronized (object2){
System.out.println("t3 通知之前");
object2.notify();//唤醒了t2线程,t1线程仍处于阻塞等待状态
System.out.println("t3 通知之后");
}
});
t1.start();
t2.start();
Thread.sleep(1000);
t3.start();
}
}
2.23 唤醒了t1线程,t2线程仍处于阻塞等待状态
public class Demo5 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
Object object2=new Object();
Thread t1=new Thread(()->{
synchronized (object){
System.out.println("t1 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 等待之后");
}
});
Thread t2=new Thread(()->{
synchronized (object2){
System.out.println("t2 等待之前");
try {
object2.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2 等待之后");
}
});
Thread t3=new Thread(()->{
synchronized (object){
System.out.println("t3 通知之前");
object.notify();//唤醒了t1线程,t2线程仍处于阻塞等待状态
System.out.println("t3 通知之后");
}
});
t1.start();
t2.start();
Thread.sleep(1000);
t3.start();
}
}
2.24:notifyAll()
唤醒所有等待的线程(锁对象相同).
public class Demo5 {
public static void main(String[] args) throws InterruptedException {
Object object=new Object();
Object object2=new Object();
Thread t1=new Thread(()->{
synchronized (object){
System.out.println("t1 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 等待之后");
}
});
Thread t2=new Thread(()->{
synchronized (object){
System.out.println("t2 等待之前");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2 等待之后");
}
});
Thread t4=new Thread(()->{
synchronized (object2){
System.out.println("t4 等待之前");
try {
object2.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t4 等待之后");
}
});
Thread t3=new Thread(()->{
synchronized (object){
System.out.println("t3 通知之前");
object.notifyAll();//唤醒所有的因object锁引起的阻塞等待,但t4线程不会被唤醒
System.out.println("t3 通知之后");
}
});
t1.start();
t2.start();
t4.start();
Thread.sleep(1000);
t3.start();
}
}
