文章目录
- 1、LockSupport
- 2、wait和notify存在的问题
- 3、await和signal存在的问题
- 4、park和unpark方法
- 5、LockSupport用法示例
- 6、Permit不会累积
- 7、面试
1、LockSupport
线程等待和唤醒的方式有：
- 使用Object的wait方法让对象上活动的线程等待，使用notify方法来唤醒线程
- 使用JUC报中Condition的await方法让线程等待，使用signal方法来唤醒线程
- LockSupport类来阻塞当前线程以及唤醒指定被阻塞的线程
LockSupport是一个线程阻塞工具类，所有方法都是静态的。可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法，归根结底，LockSupport调用的Unsafe中的native代码。
- LockSupport提供park和unpark方法实现阻塞线程和解除阻塞
- LockSupport和每个使用它的线程都有一个许可permit关联
- 每个线程都有一个相关的permit，permit最多只有一个，重复调用unpark也不会积累凭证
- LockSupport就是通过Permit (许可)的概念来做到阻塞和唤阻线程的功能
2、wait和notify存在的问题
正常使用wait和notify如下：
public class LockSupport1 {
public static void main(String[] args) {
Object o = new Object();
new Thread(() -> {
synchronized (o){
System.out.println(Thread.currentThread().getName() + "\t come in...");
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "\t 被唤醒");
}
},"t1").start();
//歇200ms
try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
synchronized (o){
System.out.println(Thread.currentThread().getName() + "\t come in ...");
o.notify();
System.out.println(Thread.currentThread().getName() + "\t 发出唤醒通知");
}
},"t2").start();
}
}
此时一切正常：
问题1：去掉syncyronized
问题2：先唤醒再等待
可以发现，将notify先于wait执行，等待被唤醒的线程会陷入无限等待中，就像叫你起床的人，先走了，你睡着以后没人再叫你了。
问题点总结：
- wait和notify方法必须要在同步块或者同步方法里面，且成对出现和使用
- 必须先wait再notify，反之唤醒失败
3、await和signal存在的问题
常规用法：
public class LockSupport1 {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
System.out.println(Thread.currentThread().getName() + "\t come in...");
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println(Thread.currentThread().getName() + "\t 被唤醒");
},"t1").start();
//歇200ms
try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t come in...");
condition.signal();
System.out.println(Thread.currentThread().getName() + "\t 发出唤醒通知");
} finally {
lock.unlock();
}
},"t2").start();
}
}
问题1：去掉锁
可以看到去掉lock和unlock加解锁，await和signal都触发了IllegalMonitorStateException异常。
异常2：先唤醒再等待
可以看到，前两种线程等待和唤醒的方式，都有使用限制：
- 线程必须先持有锁（synchronized或者lock）
- 必须先等待后唤醒，才能唤醒成功
4、park和unpark方法
基于前面两种方式的缺陷，LockSupport提供了新的实现思路来解决 ⇒凭证 。通过park()和unpark(thread)来实现阻塞和唤醒线程。
//阻塞当前线程
park()
//阻塞传入的具体线程
park(Thread thread)
当调用park方法时：
- 如果线程有凭证，则直接消耗掉这个凭证然后正常往下执行
- 如果线程没有凭证，就必须阻塞等待到凭证可用
看下源码，第二个参数就是用来指定多久放行的，默认0，即没许可证不放行，直到别的线程给当前线程发放permit：
unpark(Thread thread)
当调用unpark方法时：
- 给传入的线程发一个凭证
- 自动唤醒之前阻塞的LockSupport.park()
- 但凭证最多只有一个，多次调用不会累加
5、LockSupport用法示例
开两个线程t2给t1发通行证：
public class LockSupport2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t ---com in: " + System.currentTimeMillis());
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "\t ---被唤醒: " + System.currentTimeMillis());
}, "t1");
t1.start();
try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t ---com in");
System.out.println(Thread.currentThread().getName() + "给t1线程发了permit");
LockSupport.unpark(t1);
},"t2").start();
}
}
等待唤醒成功，可以发现不用锁块了，也没有synchronized或者lock了。
再看先发许可证会不会被成功唤醒：
public class LockSupport2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
//休息两秒，让t2先执行
try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + "\t ---com in: " + System.currentTimeMillis());
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "\t ---被唤醒: " + System.currentTimeMillis());
}, "t1");
t1.start();
//try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t ---com in");
System.out.println(Thread.currentThread().getName() + "给t1线程发了permit");
LockSupport.unpark(t1);
},"t2").start();
}
}
先发permit，再LockSupport.park()，就像持证上岗，或者高速公路的ETC，提前缴费买了通行证后走高速，遇到关卡一路通畅，此时park形同虚设
6、Permit不会累积
验证一个线程醉倒一个Permit，许可证不会累积：
public class LockSupport3 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
//先让发许可证的线程执行
try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + "\t ---come in");
LockSupport.park();
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
}, "t1");
t1.start();
new Thread(() -> {
LockSupport.unpark(t1);
LockSupport.unpark(t1);
LockSupport.unpark(t1);
LockSupport.unpark(t1);
}).start();
}
}
可以看到多次unpark也不能过两个park：
稍微再改一下，一个凭证用完后，自己再给自己发一个，就可以通过了。
7、面试
Q1：为什么LockSupport可以突破wait/notify原有的调用顺序限制？
A1：因为unpark后线程t获得了一个凭证，之后线程t再调用park，就凭证消费，畅通无阻
Q2：为什么唤醒两次后再阻塞两次，最终结果还是阻塞？
A2：因为凭证的数量最多为1，连续调用两次unpark并不会有两个凭证，而调用两次park却要消耗两个凭证，凭证不够，不能放行。
