前言
三种让线程等待和唤醒的方法如下：
- 方式一：使用 Object 中的 wait() 方法让线程等待，使用 Object 中的
notify()方法唤醒线程 - 方式二：使用 JUC 包中 Condition 的 await() 方法让线程等待，使用
signal()方法唤醒线程 - 方式三：LockSupport 类可以阻塞当前线程以及唤醒指定被阻塞的线程。
下面分别来介绍一下，希望对大家看完有帮助！
一、Object类自带的方法
使用wait()方法来阻塞线程，使用notify()和notifyAll()方法来唤醒线程。
-
调用wait()方法后，线程将被阻塞，wait()方法将会释放当前持有的监视器锁(monitor)，直到有线程调用
notify/notifyAll()方法后方能继续执行。 -
notify/notifyAll()方法只是解除了等待线程的阻塞，并不会马上释放监视器锁，而是在相应的被synchronized关键字修饰的同步方法或同步代码块执行结束后才自动释放锁。
默认使用非公平锁，无法修改。
缺点：
- 使用几个方法时，必须处于被synchronized关键字修饰的同步方法或同步代码块中，否则程序运行时，会抛出IllegalMonitorStateException异常。
- 线程的唤醒必须在线程阻塞之后，否则，当前线程被阻塞之后，一直没有唤醒，线程将会一直等待下去（对比LockSupport）
public class SynchronizedDemo {
// 三个线程交替打印ABC
public static void main(String[] args) {
Print print = new Print();
new Thread(() -> {
while (true) {
print.printA();
}
}, "A").start();
new Thread(() -> {
while (true) {
print.printB();
}
}, "B").start();
new Thread(() -> {
while (true) {
print.printC();
}
}, "C").start();
}
}
class Print {
Object object = new Object();
int num = 1;
public void printA() {
synchronized (object) {
try {
while (num != 1) {
object.wait();
}
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "==>A");
}
num = 2;
object.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void printB() {
synchronized (object) {
try {
while (num != 2) {
object.wait();
}
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "==>B");
}
num = 3;
object.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void printC() {
synchronized (object) {
try {
while (num != 3) {
object.wait();
}
for (int i = 0; i < 15; i++) {
System.out.println(Thread.currentThread().getName() + "==>C");
}
num = 1;
object.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
二、Condition接口
使用 JUC 包中 Condition 的await()方法来阻塞线程，signal()/singnalAll()方法来唤醒线程。
需要使用lock对象的newCondition()方法获得Condition条件对象（可有多个）。
可实现公平锁，默认是非公平锁
缺点：
- 必须被Lock包裹，否则会在运行时抛出IllegalMonitorStateException异常。
- 线程的唤醒必须在线程阻塞之后
- Lock的实现是基于AQS，效率稍高于synchronized
public class ConditionDemo {
// 三个线程交替打印ABC
public static void main(String[] args) {
Print print = new Print();
new Thread(() -> {
while (true) {
print.printA();
}
}, "A").start();
new Thread(() -> {
while (true) {
print.printB();
}
}, "B").start();
new Thread(() -> {
while (true) {
print.printC();
}
}, "C").start();
}
}
class Print {
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private int num = 1;
public void printA() {
lock.lock();
try {
while (num != 1) {
condition1.await();
}
for (int i = 0; i < 5; ++i) {
System.out.println(Thread.currentThread().getName() + "==>A");
}
num = 2;
condition2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB() {
lock.lock();
try {
while (num != 2) {
condition2.await();
}
for (int i = 0; i < 10; ++i) {
System.out.println(Thread.currentThread().getName() + "==>B");
}
num = 3;
condition3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC() {
lock.lock();
try {
while (num != 3) {
condition3.await();
}
for (int i = 0; i < 15; ++i) {
System.out.println(Thread.currentThread().getName() + "==>C");
}
num = 1;
condition1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
三、LockSupport
使用park()来阻塞线程，用unpark()方法来唤醒线程。
这里有一个许可证的概念，许可不能累积，并且最多只能有一个许可，只有1和0的区别。
特点：
- 使用灵活，可以直接使用
- 线程唤醒可在线程阻塞之前，因为调用unpark()方法后，线程已经获得了一个许可证（但也只能有一个许可证），之后阻塞时，可以直接使用这个许可证来通行。
- 效率高
public class LockSupportDemo {
// 三个线程交替打印ABC
public static void main(String[] args) throws Exception {
Print print = new Print();
Thread threadA = new Thread(() -> {
while (true) {
print.printA();
}
}, "A");
Thread threadB = new Thread(() -> {
while (true) {
print.printB();
}
}, "B");
Thread threadC = new Thread(() -> {
while (true) {
print.printC();
}
}, "C");
threadA.start();
threadB.start();
threadC.start();
while (true) {
LockSupport.unpark(threadA);
LockSupport.unpark(threadB);
LockSupport.unpark(threadC);
}
}
}
class Print {
private int num = 1;
public void printA() {
while (num != 1) {
LockSupport.park();
}
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "==>A");
}
num = 2;
}
public void printB() {
while (num != 2) {
LockSupport.park();
}
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "==>B");
}
num = 3;
}
public void printC() {
while (num != 3) {
LockSupport.park();
}
for (int i = 0; i < 15; i++) {
System.out.println(Thread.currentThread().getName() + "==>C");
}
num = 1;
}
}
四、相关面试题
-
为什么可以先唤醒线程后阻塞线程？
答：先唤醒线程意味着你调用了 unpark() 方法，那么凭证加1，再去阻塞线程，即调用 park() 方法，这个时候有凭证，所以直接消耗掉凭证然后正常退出
-
为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？
答：唤醒两次意味着调用了两次 unpark() 方法，但是凭证无法累加最多只有 1，然后阻塞两次，即调用两次 park() 方法，需要消费 2 张凭证才能正常退出，但是只有 1 张凭证，所以凭证不够，阻塞。
总结：
LockSupport 是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport 是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport 调用的是 Unsafe 类中的 native 方法。
LockSupport 提供 park() 和 unpark() 方法实现阻塞线程和解除线程阻塞的过程
LockSupport 和每个使用它的线程都有一个许可（permit）关联。 permit 默认是 0。
- 调用一次 unpark 就加 1 变成 1
- 调用一次 park 会消费 permit ，也就是将 1 变成 0，同时 park 立即返回。
- 如果再次调用 park 会变成阻塞（因为 permit 为 0 会阻塞在这里，一直到 permit 为 1），这时候调用 unpark 会把 permit 置为 1
- 每个线程都有一个相关的 permit，permit 最多只有一个，重复调用 unpark 不会积累凭证。
简单来说：
线程阻塞需要消耗凭证（permit），这个凭证最多只有一个。
- 当调用 park 方法时
- 如果有凭证，则会直接消耗掉这个凭证然后正常退出
- 如果没有凭证，就必须阻塞等待凭证可用
- 当调用 unpark 方法时
- 它会增加一个凭证，但凭证最多只能有一个，无法累加。