目录
一、概念
二、用法
(1)举个栗子:
(2)wait和notify的使用
1、没有上锁的wait
2、当一个线程被wait,但没有其他线程notify来释放这个wait
3、两个线程,有一个线程wait,有一个线程notify来释放wait
4、notifyAll
(3)wait的三个选项
三、wait、sleep、join
我们知道,多线程在系统中的调度是随机的,我们不能干预多个线程的执行顺序,但是我们可以使某个线程放弃被系统调用,让其他线程先被调用,这样,可以达到我们的预期效果;
wait就是让多线程进行锁竞争的时候,让后执行的线程,放弃和别的线程进行锁竞争,别的线程执行完后,别的线程使用notify,将wait的线程不想进行锁竞争这个信息释放掉,再次和其他线程锁竞争。等待,通知的机制(和join用途类似)
现在有很多滑稽老铁要去ATM里,滑稽A是取钱的,滑稽B是存钱的,滑稽C是运钞票的人员,负责给ATM机补充钱,防止ATM机没钱了,别人取不到钱。而这里的滑稽A,滑稽B,滑稽C我们当做是线程,每次去ATM机里,只能有一个人进去,相当于上锁了,其他人不能进去,等ATM机里面的人完成操作后,出来后,别的人才能进去,但是这里是多线程的原因,其他线程会有锁竞争。
当A进去ATM机里后,就上锁,其他人不能进去,如图:
把滑稽A比作是线程,当A线程进去后就会上锁,A线程要进行取钱的操作,其他线程不能进去操作,当A线程执行完自己的操作后,其他线程才能去锁竞争。
但是如果ATM机里面没有钱时,A线程就不能完成取钱这个操作,它会退出ATM机,但退出后呢,它因为没有完成取钱的操作,就会想继续进去ATM里面,完成取钱这个操作,就会继续和其他线程进行锁竞争,因为A线程拿到了锁,处于RUNNABLE状态,其他线程因为阻塞,处于BLOCKED状态,需要被系统唤醒后,才能去竞争锁,但是线程A呢,不用唤醒就能去竞争锁,后面又被A线程拿到锁的可能性还是很大的(类似近水楼台先得月)。如果这样子,那线程A频繁的进去又出来,干不了事,但是其他线程也不能进去操作,用通俗的话说,就是占着茅坑不拉屎的意思。也就出现线程安全问题了。其他线程,无法拿到锁,这个情况称为 “线程饿死”。
这里的线程A的代码大概逻辑是这样的:
当A线程没有取到钱,就会一直重复加锁,解锁的操作。
这样的bug没有死锁那么严重,但也是要解决的。那如何解决呢。这时,就可以用wait和notify了。期望改进成,如下图:
这里的wait内部做了三件事
(1)释放锁,给其他线程竞争锁
(2)进入阻塞等待
(3)等其他线程使用notify后,解除wait,参与到锁竞争中
wait的使用前提必须是当前对象被上锁了才能使用,不能你对象没被上锁,就wait了,那也不知道是在wait谁。同时,有线程wait了,也必须有其他线程notify来释放这个wait,不然这个wait就会一直阻塞。
代码:
public class TestDemo1 { public static void main(String[] args) throws InterruptedException { Object locker = new Object(); locker.wait(); } }
执行结果:
代码:
public class TestDemo3 { public static void main(String[] args) { Object locker = new Object(); Thread t1 = new Thread(() -> { synchronized (locker) { System.out.println("wait之前"); try { locker.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("wait之后"); } }); t1.start(); } }
执行结果:
打印不了 “wait之后”,一直是阻塞等待状态,在jconsole中,状态如图
代码:
public class TestDemo2 { public static void main(String[] args) { Object locker = new Object(); Thread t1 = new Thread(() -> { synchronized (locker) { System.out.println("t1 wait之前"); try { locker.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("t2 wait之后"); } }); Thread t2 = new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (locker) { System.out.println("t2 notify之前"); locker.notify(); System.out.println("t2 notify之后"); } }); t1.start(); t2.start(); } }
注意:这里的释放wait的notify,用的对象必须是要一样的,如果不一样,wait是不能被释放的,t1也就不能被唤醒了.
在系统中,notify可以不用上锁,但是在java中,规定了要上锁,而且上锁的对象也要和notify对象一样,所以和系统是有区别的。
执行结果:
结果解析:
t1 和 t2 执行的时候
(1)因为t1 sleep了1秒,所以能保证t1 先wait,所以先打印 “t1 wait之前”,这时,t1就进入阻塞等待状态。
(2)t2线程sleep了1秒后,获得这个locker锁,打印“t2 notify 之前”,当t2线程执行了notify后,t1 线程的wait就被释放了。
(3)因为t2还在持有锁,所以t1会还会进入阻塞,t2打印 “t2 notify之后” ,释放锁。
(4)t1拿到锁,再打印“t1 wait之后”。
唤醒等待这个对象的所有线程;假设有很多个线程,都使用同一个对象wait,这时,使用notifyAll,所有使用了这个对象的wait的线程,都会被唤醒。
注意:当这些线程都被唤醒时,就要重新获取锁,他们还是要进行锁竞争的,这里也就相当于串行执行了(线程调度还是随机调度的)。而且使用notifyAll后,全部使用同一对象wait的线程,都被唤醒了,不好控制,更加推荐使用notify。
如图:
没有参数的就是死等,但是很多情况,死等是不合理的,所以我们加参数,就是让某个线程在一定时间wait,如果超出了这个时间,就不wait了,直接过掉wait。
有一个参数的精确范围是毫秒级别,两个参数的精确范围是纳秒级别。
wait:需要搭配synchronized使用,线程wait时,处于WAITING状态,需要其他线程notify后,才能被唤醒,或者设置时间,到时就唤醒,可以兜底。
sleep:线程sleep时,要到一定休眠时间才能被唤醒,但是也能被interrupt终止,但是这种情况是会抛异常的,是非常规手段,不符合我们预期的效果。
join:啥线程调用join,当前线程就要等啥线程执行完,才能之前当前线程;和wait一样有参数可以选择,到时就不等了。