wait使用:
public class WaitDemo {
public static void main(String[] args) {
Object lock = new Object();
Thread t1 = new Thread(() -> {
System.out.println("线程1开始执行");
try {
synchronized (lock) {
System.out.println("线程1调用wait方法....");
// 无限期的等待状态
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1执行完成");
}, "线程1");
t1.start();
}
}
输出：
线程1开始执行
线程1调用wait方法....
（程序仍在执行）
public class WaitDemo2 {
public static void main(String[] args) {
Object lock = new Object();
Object lock2 = new Object();
Thread t1 = new Thread(() -> {
System.out.println("线程1开始执行");
try {
synchronized (lock) {
System.out.println("线程1调用wait方法....");
// 无限期的等待状态
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1执行完成");
}, "线程1");
Thread t2 = new Thread(() -> {
System.out.println("线程2开始执行");
try {
synchronized (lock) {
System.out.println("线程2调用wait方法....");
// 无限期的等待状态
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程2执行完成");
}, "线程2");
t2.start();
t1.start();
// 唤醒 lock 对象上休眠的线程的（随机唤醒一个）
Thread t4 = new Thread(() -> {
//先让线程1,2,3先执行
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
}
System.out.println("线程4：开始执行");
synchronized (lock) {
// 发出唤醒通知
lock.notify();
System.out.println("线程4：执行了唤醒操作");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("线程4：synchronized 执行完了");
}
}, "线程4");
t4.start();
}
}
输出：
线程1开始执行
线程2开始执行
线程1调用wait方法....
线程2调用wait方法....
线程4：开始执行
线程4：执行了唤醒操作
线程4：synchronized 执行完了
线程1执行完成
notify⽅法只是唤醒某⼀个等待线程. 使⽤notifyAll⽅法可以⼀次唤醒所有的等待线程。
public class WaitDemo3 {
public static void main(String[] args) {
Object lock = new Object();
Object lock2 = new Object();
Thread t1 = new Thread(() -> {
System.out.println("线程1开始执行");
try {
synchronized (lock) {
System.out.println("线程1调用wait方法....");
// 无限期的等待状态
lock.wait();
System.out.println("线程1：恢复执行之后又进入休眠状态");
Thread.sleep(2000);
System.out.println("线程1执行完成");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程1");
Thread t2 = new Thread(() -> {
System.out.println("线程2开始执行");
try {
synchronized (lock) {
System.out.println("线程2调用wait方法....");
// 无限期的等待状态
lock.wait();
System.out.println("线程2：恢复执行之后又进入休眠状态");
Thread.sleep(2000);
System.out.println("线程2执行完成");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程2");
Thread t3 = new Thread(() -> {
System.out.println("线程3开始执行");
try {
synchronized (lock) {
System.out.println("线程3调用wait方法....");
// 无限期的等待状态
lock.wait();
System.out.println("线程3：恢复执行之后又进入休眠状态");
Thread.sleep(2000);
System.out.println("线程3执行完成");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程3");
t2.start();
t1.start();
t3.start();
// 唤醒 lock 对象上休眠的线程的（随机唤醒一个）
Thread t4 = new Thread(() -> {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
}
System.out.println("线程4：开始执行");
synchronized (lock) {
// 发出唤醒通知
lock.notifyAll();
lock.notifyAll();
System.out.println("线程4：执行了唤醒操作");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("线程4：synchronized 执行完了");
}
}, "线程4");
t4.start();
}
}
输出：
线程2开始执行
线程2调用wait方法....
线程3开始执行
线程1开始执行
线程3调用wait方法....
线程1调用wait方法....
线程4：开始执行
线程4：执行了唤醒操作
线程4：synchronized 执行完了
线程1：恢复执行之后又进入休眠状态
线程1执行完成
线程3：恢复执行之后又进入休眠状态
线程3执行完成
线程2：恢复执行之后又进入休眠状态
线程2执行完成修改线程3中的lock为lock2
try {
synchronized (lock2) {
System.out.println("线程3调用wait方法....");
// 无限期的等待状态
lock2.wait();
System.out.println("线程3：恢复执行之后又进入休眠状态");
Thread.sleep(2000);
System.out.println("线程3执行完成");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
输出：
线程2开始执行
线程1开始执行
线程3开始执行
线程2调用wait方法....
线程3调用wait方法....
线程1调用wait方法....
线程4：开始执行
线程4：执行了唤醒操作
线程4：synchronized 执行完了
线程1：恢复执行之后又进入休眠状态
线程1执行完成
线程2：恢复执行之后又进入休眠状态
线程2执行完成
由上述两个代码可以得出，notifyAll 并不是唤醒所有的wait 等待的线程，而是唤醒当前对象处于wait 等待的所有线程。