@TOC
对象等待集来干预线程的调度
wait 和 notify 为了处理线程调度随机性的问题。
还是那句话,多线程的调度,因为它的随机性,就导致代码谁先执行,谁后执行,存在太多的变数。
而我们程序员是不喜欢随机性,我们喜欢确定的东西。
需要能够让线程彼此之间,有一个固定的顺序。
举个例子:打篮球
篮球里面有一个典型的操作:传球,上篮。
那么我们肯定得先传球,再上篮。需要两个队员的相互配合。
两个队员也就是两个线程。
如果是先做个上篮动作,但是球没到,也就上了个寂寞。
一般最稳的方法,都是先传球再上篮。
像这样的顺序,在我们实际开发中也是非常需要的。
因此我们就需要有手段去控制!
之前讲到的 join 也是一种控制顺序的方式,但是 join更倾向于控制线程结束
。因此 join 是有使用的局限性。
就不像 wait 和 notify 用起来更加合适。
wait 方法
其实wait()方法就是使线程停止运行。
方法wait()的作用是使当前执行代码的线程进行等待
,wait( )方法是Object类的方法,该方法是用来将当前线程置入“预执行队列”中,并且在wait()所在的代码处停止执行,直到接到通知或被中断为止。wait( )方法只能在同步方法中或同步块中调用。如果调用wait()时,没有持有适当的锁,会抛出异常
。- wait( )方法执行后,当前线程释放锁,并一直处于等待通知状态, 直到其他线程唤醒该线程后与其它线程竞争重新获取锁。
调用 wait 方法的线程,就会陷入阻塞,阻塞到有其它线程通过 notify 来通知。
public class ThreadTest2 {
public static void main(String[] args) {
Object locker = new Object();
Thread t = new Thread() {
@Override
public void run() {
synchronized (locker) {
System.out.println("t 开始运行");
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" t 运行结束");
}
}
};
t.start();
}
}
notify 方法
一个线程执行到object.wait()之后就一直等待下去,那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。
notify方法就是使停止的线程继续运行
方法notify()也要在同步方法或同步块中调用
,该方法是用来通知那些可能等待该对象的对象锁的其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁。如果有多个线程等待,则有线程规划器随机挑选出一个呈wait状态的线程。
- 在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁。
public class Test18 {
// 为了两个线程能够顺利交互,我们创建一个锁对象
private static Object locker = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
//进行 wait
synchronized (locker){
System.out.println("wait 之前");
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("wait 之后");
}
});
t1.start();
// 为了大家能更清楚的观察到现象,我这里使用 sleep 延迟3s
Thread.sleep(3000);
Thread t2 = new Thread(()->{
// 进行 notify
synchronized (locker){
System.out.println("notify 之前");
locker.notify();
System.out.println("notify 之后");
}
});
t2.start();
}
}
根据这种机制我们可以编排多个线程的顺序
notifyAll 方法
前面说的 wait 和 notify 都是针对同一个对象来操作。
例如:
现在有一个对象 o
,被 10个线程调用了 o.wait
。
此时 10 个 线程都是阻塞状态
。
如果调用了 o.notify
,就会把 10个线程中的一个给唤醒
【随机唤醒:不确定下一个被唤醒的线程是哪一个】
被唤醒的线程就会继续往下执行。其他线程仍处于阻塞状态。
如果调用的 o.notifyAll
,就会把所有的线程全部唤醒
wait 在被唤醒之后,会重新尝试获取到锁,这个过程就会发生竞争
唤醒所有的线程,都去抢锁。
抢到的,才可以继续往下执行。
没抢到的线程,继续等待,等待下一次的 notifyAll。**
wait方法总结
-
wait( )
的作用是让当前线程进入等待状态
,同时,wait( )也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,使当前线程被唤醒(进入“就绪状态”)
-
notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程
notify()是唤醒单个线程
notifyAll()是唤醒所有的线程
, 然后这些线程再去竞争那同一把锁。(不建议使用notifyAll ) -
wait(long timeout)让当前线程处于“等待(阻塞)状态
”-
“直到其他线程调用此对象的notify()方法或 notifyAll() 方法
- 或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)
-
总结:
wait() 的工作过程就是:
释放对象锁(所以必须有一个锁才能正常执行)
等待通知
(时间可能会长, 因为不参与后序锁的竞争直到有其他线程调用该对象的notify()去唤醒该线程)收到通知后 尝试重新获取对象锁 继续往下执行
特别注意
-
wait() 和 notify() 操作必须放在 synchronized 的代码块之内使用
否则会报异常 -
调用wait() 和 notify() 的对象必须是同一个对象 才能起到等待和唤醒操作
更准确的说: 因为wait 和 notify 要在 synchronized 的代码块内 所以上锁的对象也应该和 wait() 和 notify() 的对象必须是同一个对象 这样就是4个对象得保持一致
notify方法总结
- 一个线程执行到object.wait()之后就一直等待下去,那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。
- notify方法就是使停止的线程继续运行。
- 方法notify()也要在同步方法或同步块中调用,该方法是用来通知那些可能等待该对象的对象锁的其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁。如果有多个线程等待,则有线程规划器随机挑选出一个呈wait状态的线程。
- 在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁。
注意:
唤醒线程不能过早,如果在还没有线程在等待中时,过早的唤醒线程,这个时候就会出现先唤醒,在等待的效果了。
这样 就没有必要在去运行wait方法了。导致竞态条件问题
public class ThreadTest3 {
public static void main(String[] args) {
Object locker = new Object();
Thread t = new Thread() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (locker) {
System.out.println(" t 开始运行");
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" t 运行结束");
}
}
};
t.start();
Thread t1 = new Thread() {
@Override
public void run() {
synchronized (locker) {
System.out.println(" t1 开始运行");
locker.notify();
System.out.println(" t1 运行结束");
}
}
};
t1.start();
Thread t2 = new Thread() {
@Override
public void run() {
synchronized (locker) {
System.out.println(" t2 开始运行");
System.out.println(" t2 运行结束");
}
}
};
t2.start();
}
}
运行结果:
竞态条件问题
竞态条件问题
当一个 t 线程执行了wait()方法释放了对象锁之后 另外一个 t1 线程获取了锁然后立即执行了notify()方法区通知 t 线程 但是 t 线程还没有执行到等待通知的那段代码 所以这个通知就错过了 这样线程 t 就会一直等待下去 这就是一个竞态条件问题- 为了解决和
避免这个问题 事实上当我们在执行wait() 操作的时候 释放锁和等待接收通知是处于一个原子性质上执行的 最后才执行尝试重新获取锁
wait与sleep的对比
- wait用于线程之间的通信 sleep用于让线程阻塞一段时间
- wait之前必须要有锁 wait之后会释放锁 等被唤醒之后再重尝试请求锁
- sleep是无视锁的存在的 即不会要求有锁 也不会去释放锁
- wait是object的方法
- sleep是thread的静态方法
- 唯一相同点就是都可以让线程放弃执行一段时间