【JUC】十六、LockSupport类实现线程等待与唤醒

本文主要是介绍【JUC】十六、LockSupport类实现线程等待与唤醒，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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();//歇200mstry { 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();//歇200mstry { 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却要消耗两个凭证，凭证不够，不能放行。

这篇关于【JUC】十六、LockSupport类实现线程等待与唤醒的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---