大家应该都知道，线程之间是抢占式随机执行的，但是我们并不希望这样。因为这样非常混乱，并不好去预估程序的执行结果。我们甚至希望，线程之间能够配合执行，那么我们就可以使用wait()和notify()来做到。
一、wait()方法
wait有两个方法：
wait()：让当前线程进入等待（阻塞）状态。死等，没有唤醒就会一直阻塞
wait(long timeout) ：指定时间内，让线程进入等待（阻塞）状态。
1.wait()主要做的事
- 使当前执行代码的线程进行等待。（把线程放到等待队列中）
- 释放当前的锁
- 满足条件被notify()唤醒，重新尝试获取这个锁
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
System.out.println("wait 之前");
/**
* Object中有wait方法,通过Object对象调用wait方法
* wait没有参数的版本是默认死等
* wait带参数的版本是指定超时时间，如果超时了还没有notify就继续执行
*
* 使用wait有三个操作：
* （1）释放锁
* （2）进入阻塞等待，准备接受通知
* （3）收到通知之后唤醒，并且重新获取锁
*/
/**
* 因为wait会解锁，所以wait必须在synchronized内部
* 而且synchronized括号内的Object对象，必须和调用wait的是同一对象
*/
synchronized(object) {
object.wait();
}
System.out.println("wait 之后");
}
2.wait()的结束条件
- 其他线程调⽤该对象的 notify ⽅法.
- wait 等待时间超时 (wait ⽅法提供⼀个带有 timeout 参数的版本, 来指定等待时间).
- 其他线程调⽤该等待线程的 interrupt ⽅法, 导致 wait 抛出 InterruptedException 异常，并清除中断标志位(给程序员自由发挥的空间),并重新尝试获取锁。
public static void main(String[] args) throws InterruptedException { Object locker = new Object(); Thread t1 = new Thread(() -> { //获取当前线程 Thread current = Thread.currentThread(); int count = 0; //标志位默认为false，为true就是被中断了 while (!current.isInterrupted()) { //如果中断位被清空了，不会执行第二次 System.out.println("t1线程第一次执行" + count++); synchronized (locker) { //因为Thread并没有处理这个异常，所以必须在这里使用try-catch处理一下 try { //开始等待 //如果被interrupt中断会抛出异常，并清除中断位 //并重新尝试获取锁 locker.wait(); } catch (InterruptedException e) { System.err.println("被interrupt唤醒"); } } } }); t1.start(); while (true) { Thread.sleep(1000); t1.interrupt(); } }
3.有参数的wait()
public static void main(String[] args) {
Object locker = new Object();
Thread t1 = new Thread(() -> {
long start = System.currentTimeMillis();
System.out.println("wait之前");
synchronized (locker) {
try {
locker.wait(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println("wait之后 耗时：" + (end - start));
});
t1.start();
}结果：
二、notify()
notify⽅法是唤醒等待的线程，主要配合wait()：notify()：唤醒同一对象调用正在wait()的线程，如果有多个线程正在wait(）就会随机唤醒一个线程
notifyAll()：唤醒所有正在wait()的线程
1.notify()主要做的事
- ⽅法notify()也要在同步⽅法或同步块中调⽤，该⽅法是⽤来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
- 如果有多个线程等待，则有线程调度器随机挑选出⼀个呈 wait 状态的线程。(并没有 "先来后到")
public static void main(String[] args) throws InterruptedException {
Object locker = new Object();
Thread t1 = new Thread(() -> {
synchronized (locker) {
System.out.println("wait之前~");
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("wait之后！");
}
});
Thread t2 = new Thread(() -> {
synchronized (locker) {
System.out.println("notify之前");
locker.notify();
//notify之后，并不会马上释放锁结束，至少会
//把synchronized中的语句执行完
System.out.println("未解锁之后的notify");
}
//看是否会执行到这一条语句
System.err.println("解锁之后的notify");
});
t1.start();
//防止执行到notify了，t2还没阻塞(wait)
Thread.sleep(500);
t2.start();
}结果分析：
注意事项：
2.notify() 会唤醒sleep()吗？
public static void main(String[] args) throws InterruptedException {
Object locker = new Object();
Thread t1 = new Thread(() -> {
System.out.println("sleep睡眠");
try {
//sleep不需要在synchronized里
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sleep睡醒了");
});
Thread t2 = new Thread(() -> {
synchronized (locker) {
System.out.println("notify之前");
locker.notify();
System.out.println("notify之后");
}
});
t1.start();
Thread.sleep(1000);
t2.start();
}结果：
3.notifyAll()
唤醒所有正在等待的线程
public static void main(String[] args) throws InterruptedException {
Object locker = new Object();
Thread t1 = new Thread(() -> {
System.out.println("t1线程开始");
synchronized (locker) {
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.err.println("t1线程结束");
});
Thread t2 = new Thread(() -> {
System.out.println("t2线程开始");
synchronized (locker) {
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.err.println("t2线程结束");
});
Thread t3 = new Thread(() -> {
System.out.println("t3线程开始");
synchronized (locker) {
try {
locker.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.err.println("t3线程结束");
});
Thread t4 = new Thread(() -> {
synchronized (locker) {
System.out.println("notify之前");
locker.notifyAll();
System.out.println("notify之后");
}
});
t1.start();
t2.start();
t3.start();
//保证上面的线程都已经执行了wait
Thread.sleep(1000);
t4.start();
}
三、调用 wait\notify\synchronized 使用的对象
注意：wait和notify都必须放在synchronized中，不然会抛出异常：IllegalMonitorStateException
public static void main(String[] args) { Object locker = new Object(); Thread t1 = new Thread(() -> { System.out.println("t1线程开始"); try { locker.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.err.println("t1线程结束"); }); Thread t4 = new Thread(() -> { try { Thread.sleep(1000); locker.notify(); } catch (InterruptedException e) { e.printStackTrace(); } }); t1.start(); t4.start(); }
并且synchronized括号内部，必须和调用的是同一对象，不然依然会抛异常：
public static void main(String[] args) { Object locker1 = new Object(); Object locker2 = new Object(); Thread t1 = new Thread(() -> { synchronized (locker1) { System.out.println("t1线程开始"); try { locker2.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.err.println("t1线程结束"); } }); Thread t4 = new Thread(() -> { synchronized (locker1) { try { Thread.sleep(1000); locker2.notify(); } catch (InterruptedException e) { e.printStackTrace(); } } }); t1.start(); t4.start(); }
四、wait和sleep的比较/区别（面试题）
其实理论上 wait 和 sleep 完全是没有可⽐性的，因为⼀个是⽤于线程之间的通信的，⼀个是让线程阻塞⼀段时间。相同点：
- 都会让线程放弃执行一段时间
- 都可以被interrupt唤醒，并且都会抛出 InterruptedException 异常，并且清空标志位
不同点：
- wait是Object的方法，sleep是Thread的静态方法
- wait必须在synchronized中，sleep不需要
- wait阻塞的时候释放锁，sleep并不会，sleep会抱着锁一起阻塞
- wait用于线程间通信（如生产者-消费者模型），sleep用于阻塞线程
扫一扫
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
