Java 线程
LockSupport 线程工具类 - 图1

LockSupport基本概念

LockSupport是线程工具类,主要作用是阻塞和唤醒线程,底层实现依赖Unsafe,同时它还是锁和其他同步类实现的基础,LockSupport提供两类静态函数分别是parkunpark,即阻塞与唤醒线程,下面是两段代码示例

示例-1

  1. public static void main(String[] agrs) throws InterruptedException {
  2. Thread th = new Thread(() -> {
  3. //阻塞当前线程
  4. LockSupport.park();
  5. System.out.println("子线程执行---------");
  6. });
  7. th.start();
  8. //睡眠2秒
  9. Thread.sleep(2000);
  10. System.out.println("主线程执行---------");
  11. //唤醒线程
  12. LockSupport.unpark(th);
  13. }
  14. }

输出结果:

  1. 主线程执行---------
  2. 子线程执行---------

上述示例中,子线程th调用LockSupport.park()阻塞,主线程睡眠2秒后,执行LockSupport.unpark(th)唤醒th线程,先阻塞后唤醒非常好理解,接下来再看下面的示例

示例-2

  1. public static void main(String[] agrs) throws InterruptedException {
  2. Thread th = new Thread(() -> {
  3. //唤醒当前线程
  4. LockSupport.unpark(Thread.currentThread());
  5. //阻塞当前线程
  6. LockSupport.park();
  7. System.out.println("子线程执行---------");
  8. });
  9. th.start();
  10. //睡眠2秒
  11. Thread.sleep(2000);
  12. System.out.println("主线程执行---------");
  13. }

输出结果:

  1. 子线程执行---------
  2. 主线程执行---------

嗯?先唤醒th线程,再阻塞th线程,最终th线程没有被阻塞,这是为什么?下面LockSupport的设计思路会为读者们解开疑惑,并更进一步明确是parkunpark的语义(从广义上来说parkunpark代表阻塞和唤醒)。

设计思路

LockSupport的设计思路是通过许可证来实现的,就像汽车上高速公路,入口处要获取通行卡,出口处要交出通行卡,如果没有通行卡就无法出站,当然可以选择补一张通行卡。
LockSupport会为使用它的线程关联一个许可证(permit)状态,permit的语义「是否拥有许可」,0代表否,1代表是,默认是0。

  • LockSupport.unpark:指定线程关联的permit直接更新为1,如果更新前的permit<1,唤醒指定线程
  • LockSupport.park:当前线程关联的permit如果>0,直接把permit更新为0,否则阻塞当前线程

LockSupport 线程工具类 - 图2

  • 线程A执行LockSupport.park,发现permit为0,未持有许可证,阻塞线程A
  • 线程B执行LockSupport.unpark(入参线程A),为A线程设置许可证,permit更新为1,唤醒线程A
  • 线程B流程结束
  • 线程A被唤醒,发现permit为1,消费许可证,permit更新为0
  • 线程A执行临界区
  • 线程A流程结束

经过上面的分析得出结论unpark的语义明确为「使线程持有许可证」,park的语义明确为「消费线程持有的许可」,所以unparkpark的执行顺序没有强制要求,只要控制好使用的线程即可,unpark=>park执行流程如下
LockSupport 线程工具类 - 图3

  • permit默认是0,线程A执行LockSupport.unparkpermit更新为1,线程A持有许可证
  • 线程A执行LockSupport.park,此时permit是1,消费许可证,permit更新为0
  • 执行临界区
  • 流程结束

最后再补充下park注意点,因park阻塞的线程不仅仅会被unpark唤醒,还可能会被线程中断(Thread.interrupt)唤醒,而且不会抛出InterruptedException异常,所以建议在park后自行判断线程中断状态,来做对应的业务处理。

优点

为什么推荐使用LockSupport来做线程的阻塞与唤醒(线程间协同工作),因为它具备如下优点

  • 以线程为操作对象更符合阻塞线程的直观语义
  • 操作更精准,可以准确地唤醒某一个线程(notify随机唤醒一个线程,notifyAll唤醒所有等待的线程)
  • 无需竞争锁对象(以线程作为操作对象),不会因竞争锁对象产生死锁问题
  • unparkpark没有严格的执行顺序,不会因执行顺序引起死锁问题,比如「Thread.suspendThread.resume」没按照严格顺序执行,就会产生死锁

另外LockSupport还提供了park的重载函数,提升灵活性

  • void parkNanos(long nanos):增加了超时机制
  • void parkUntil(long deadline):加入超时机制(指定到某个时间点,1970年到指定时间点的毫秒数)
  • void park(Object blocker):设置blocker对象,当线程没有许可证被阻塞时,该对象会被记录到该线程的内部,方便后续使用诊断工具进行问题排查
  • void parkNanos(Object blocker, long nanos):设置blocker对象,加入超时机制
  • void parkUntil(Object blocker, long deadline):设置blocker对象,加入超时机制(指定到某个时间点,1970年到指定时间点的毫秒数)

建议使用时,传入blocker对象,至于超时根据业务场景选择

实践

使用LockSupport来完成一道阿里经典的多线程协同工作面试题。
有3个独立的线程,一个只会输出A,一个只会输出B,一个只会输出C,在三个线程启动的情况下,请用合理的方式让他们按顺序打印ABCABC。
思路如下

  • 准备3个线程,分别固定打印A、B、C
  • 线程输出完A、B、C后需要阻塞等待唤醒
  • 额外准备第4个线程,作为另外3个线程的调度器,有序的控制3个线程执行

是不是很简单,下面通过代码来实践

  1. public static void main(String[] agrs) throws InterruptedException {
  2. LockSupportMain lockSupportMain = new LockSupportMain();
  3. //定义线程t1、t2、t3执行的函数方法
  4. Consumer<String> consumer = str -> {
  5. while (true) {
  6. //线程消费许可证,并传入blocker,方便后续排查问题
  7. LockSupport.park(lockSupportMain);
  8. //防止线程是因中断操作唤醒
  9. if (Thread.currentThread().isInterrupted()){
  10. throw new RuntimeException("线程被中断,异常结束");
  11. }
  12. System.out.println(Thread.currentThread().getName() + ":" + str);
  13. }
  14. };
  15. /**
  16. * 定义分别输出A、B、C的线程
  17. */
  18. Thread t1 = new Thread(() -> {
  19. consumer.accept("A");
  20. },"T1");
  21. Thread t2 = new Thread(() -> {
  22. consumer.accept("B");
  23. },"T2");
  24. Thread t3 = new Thread(() -> {
  25. consumer.accept("C");
  26. },"T3");
  27. /**
  28. * 定义调度线程
  29. */
  30. Thread dispatch = new Thread(() -> {
  31. int i=0;
  32. try {
  33. while (true) {
  34. if((i%3)==0) {
  35. //线程t1设置许可证,并唤醒线程t1
  36. LockSupport.unpark(t1);
  37. }else if((i%3)==1) {
  38. //线程t2设置许可证,并唤醒线程t2
  39. LockSupport.unpark(t2);
  40. }else {
  41. //线程t3设置许可证,并唤醒线程t3
  42. LockSupport.unpark(t3);
  43. }
  44. i++;
  45. TimeUnit.MILLISECONDS.sleep(500);
  46. }
  47. } catch (InterruptedException e) {
  48. e.printStackTrace();
  49. }
  50. });
  51. //启动相关线程
  52. t1.start();
  53. t2.start();
  54. t3.start();
  55. dispatch.start();
  56. }

输出内容:

  1. T1:A
  2. T2:B
  3. T3:C
  4. T1:A
  5. T2:B
  6. T3:C
  7. T1:A
  8. T2:B
  9. T3:C