Java高并发专题之14、JUC中的LockSupport工具类

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量66 收藏
点赞数
文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_KONGlX/article/details/125484566
版权

本文主要内容

  1. 讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例
  2. 介绍LockSupport主要用法
  3. 对比3种方式，了解他们之间的区别

LockSupport位于java.util.concurrent(简称juc)包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要，希望大家一定要掌握。

关于线程等待/唤醒的方法，前面的文章中我们已经讲过2种了：

  1. 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
  2. 方式2：使用juc包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

这2种方式，我们先来看一下示例。

使用Object类中的方法实现线程等待和唤醒

示例1：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  7.  */
  8. public class Demo1 {
  10.     static Object lock = new Object();
  12.     public static void main(String[] args) throws InterruptedException {
  13.         Thread t1 = new Thread(() -> {
  14.             synchronized (lock) {
  15.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  16.                 try {
  17.                     lock.wait();
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  22.             }
  23.         });
  24.         t1.setName("t1");
  25.         t1.start();
  26.         //休眠5秒
  27.         TimeUnit.SECONDS.sleep(5);
  28.         synchronized (lock) {
  29.             lock.notify();
  30.         }
  31.     }
  32. }

输出：


     
     
  1. 1563592938744,t1 start!
  2. 1563592943745,t1 被唤醒!

t1线程中调用lock.wait()方法让t1线程等待，主线程中休眠5秒之后，调用lock.notify()方法唤醒了t1线程，输出的结果中，两行结果相差5秒左右，程序正常退出。

示例2

我们把上面代码中main方法内部改一下，删除了synchronized关键字，看看有什么效果：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  7.  */
  8. public class Demo2 {
  10.     static Object lock = new Object();
  12.     public static void main(String[] args) throws InterruptedException {
  13.         Thread t1 = new Thread(() -> {
  14.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  15.             try {
  16.                 lock.wait();
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  21.         });
  22.         t1.setName("t1");
  23.         t1.start();
  24.         //休眠5秒
  25.         TimeUnit.SECONDS.sleep(5);
  26.         lock.notify();
  27.     }
  28. }

运行结果：


     
     
  1. Exception in thread "t1" java.lang.IllegalMonitorStateException
  2. 1563593178811,t1 start!
  3.     at java.lang.Object.wait(Native Method)
  4.     at java.lang.Object.wait(Object.java:502)
  5.     at com.itsoku.chat10.Demo2.lambda$main$0(Demo2.java:16)
  6.     at java.lang.Thread.run(Thread.java:745)
  7. Exception in thread "main" java.lang.IllegalMonitorStateException
  8.     at java.lang.Object.notify(Native Method)
  9.     at com.itsoku.chat10.Demo2.main(Demo2.java:26)

上面代码中将synchronized去掉了，发现调用wait()方法和调用notify()方法都抛出了IllegalMonitorStateException异常，原因：Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在同步代码中运行(必须用到关键字synchronized)。

示例3

唤醒方法在等待方法之前执行，线程能够被唤醒么？代码如下：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  7.  */
  8. public class Demo3 {
  10.     static Object lock = new Object();
  12.     public static void main(String[] args) throws InterruptedException {
  13.         Thread t1 = new Thread(() -> {
  14.             try {
  15.                 TimeUnit.SECONDS.sleep(5);
  16.             } catch (InterruptedException e) {
  17.                 e.printStackTrace();
  18.             }
  19.             synchronized (lock) {
  20.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  21.                 try {
  22.                     //休眠3秒
  23.                     lock.wait();
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  28.             }
  29.         });
  30.         t1.setName("t1");
  31.         t1.start();
  32.         //休眠1秒之后唤醒lock对象上等待的线程
  33.         TimeUnit.SECONDS.sleep(1);
  34.         synchronized (lock) {
  35.             lock.notify();
  36.         }
  37.         System.out.println("lock.notify()执行完毕");
  38.     }
  39. }

运行代码，输出结果：


     
     
  1. lock.notify()执行完毕
  2. 1563593869797,t1 start!

输出了上面2行之后，程序一直无法结束，t1线程调用wait()方法之后无法被唤醒了，从输出中可见，notify()方法在wait()方法之前执行了，等待的线程无法被唤醒了。说明：唤醒方法在等待方法之前执行，线程无法被唤醒。

关于Object类中的用户线程等待和唤醒的方法，总结一下：

  1. wait()/notify()/notifyAll()方法都必须放在同步代码(必须在synchronized内部执行)中执行，需要先获取锁
  2. 线程唤醒的方法(notify、notifyAll)需要在等待的方法(wait)之后执行，等待中的线程才可能会被唤醒，否则无法唤醒

使用Condition实现线程的等待和唤醒

Condition的使用，前面的文章讲过，对这块不熟悉的可以移步JUC中Condition的使用，关于Condition我们准备了3个示例。

示例1


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Condition;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  9.  */
  10. public class Demo4 {
  12.     static ReentrantLock lock = new ReentrantLock();
  13.     static Condition condition = lock.newCondition();
  15.     public static void main(String[] args) throws InterruptedException {
  16.         Thread t1 = new Thread(() -> {
  17.             lock.lock();
  18.             try {
  19.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  20.                 try {
  21.                     condition.await();
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  26.             } finally {
  27.                 lock.unlock();
  28.             }
  29.         });
  30.         t1.setName("t1");
  31.         t1.start();
  32.         //休眠5秒
  33.         TimeUnit.SECONDS.sleep(5);
  34.         lock.lock();
  35.         try {
  36.             condition.signal();
  37.         } finally {
  38.             lock.unlock();
  39.         }
  41.     }
  42. }

输出：


     
     
  1. 1563594349632,t1 start!
  2. 1563594354634,t1 被唤醒!

t1线程启动之后调用condition.await()方法将线程处于等待中，主线程休眠5秒之后调用condition.signal()方法将t1线程唤醒成功，输出结果中2个时间戳相差5秒。

示例2

我们将上面代码中的lock.lock()、lock.unlock()去掉，看看会发生什么。代码：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Condition;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  9.  */
  10. public class Demo5 {
  12.     static ReentrantLock lock = new ReentrantLock();
  13.     static Condition condition = lock.newCondition();
  15.     public static void main(String[] args) throws InterruptedException {
  16.         Thread t1 = new Thread(() -> {
  17.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  18.             try {
  19.                 condition.await();
  20.             } catch (InterruptedException e) {
  21.                 e.printStackTrace();
  22.             }
  23.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  24.         });
  25.         t1.setName("t1");
  26.         t1.start();
  27.         //休眠5秒
  28.         TimeUnit.SECONDS.sleep(5);
  29.         condition.signal();
  30.     }
  31. }

输出：


     
     
  1. Exception in thread "t1" java.lang.IllegalMonitorStateException
  2. 1563594654865,t1 start!
  3.     at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
  4.     at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
  5.     at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)
  6.     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)
  7.     at com.itsoku.chat10.Demo5.lambda$main$0(Demo5.java:19)
  8.     at java.lang.Thread.run(Thread.java:745)
  9. Exception in thread "main" java.lang.IllegalMonitorStateException
  10.     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)
  11.     at com.itsoku.chat10.Demo5.main(Demo5.java:29)

有异常发生，condition.await();和condition.signal();都触发了IllegalMonitorStateException异常。原因：调用condition中线程等待和唤醒的方法的前提是必须要先获取lock的锁。

示例3

唤醒代码在等待之前执行，线程能够被唤醒么？代码如下：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Condition;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  9.  */
  10. public class Demo6 {
  12.     static ReentrantLock lock = new ReentrantLock();
  13.     static Condition condition = lock.newCondition();
  15.     public static void main(String[] args) throws InterruptedException {
  16.         Thread t1 = new Thread(() -> {
  17.             try {
  18.                 TimeUnit.SECONDS.sleep(5);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.             lock.lock();
  23.             try {
  24.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  25.                 try {
  26.                     condition.await();
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  31.             } finally {
  32.                 lock.unlock();
  33.             }
  34.         });
  35.         t1.setName("t1");
  36.         t1.start();
  37.         //休眠5秒
  38.         TimeUnit.SECONDS.sleep(1);
  39.         lock.lock();
  40.         try {
  41.             condition.signal();
  42.         } finally {
  43.             lock.unlock();
  44.         }
  45.         System.out.println(System.currentTimeMillis() + ",condition.signal();执行完毕");
  46.     }
  47. }

运行结果:


     
     
  1. 1563594886532,condition.signal();执行完毕
  2. 1563594890532,t1 start!

输出上面2行之后，程序无法结束，代码结合输出可以看出signal()方法在await()方法之前执行的，最终t1线程无法被唤醒，导致程序无法结束。

关于Condition中方法使用总结：

  1. 使用Condtion中的线程等待和唤醒方法之前，需要先获取锁。否者会报IllegalMonitorStateException异常
  2. signal()方法先于await()方法之前调用，线程无法被唤醒

Object和Condition的局限性

关于Object和Condtion中线程等待和唤醒的局限性，有以下几点：

  1. 2中方式中的让线程等待和唤醒的方法能够执行的先决条件是：线程需要先获取锁
  2. 唤醒方法需要在等待方法之后调用，线程才能够被唤醒

关于这2点，LockSupport都不需要，就能实现线程的等待和唤醒。下面我们来说一下LockSupport类。

LockSupport类介绍

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。

每个线程都有一个许可(permit)，permit只有两个值1和0，默认是0。

  1. 当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。
  2. 当调用park()方法，如果当前线程的permit是1，那么将permit设置为0，并立即返回。如果当前线程的permit是0，那么当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为0，并返回。

注意：因为permit默认是0，所以一开始调用park()方法，线程必定会被阻塞。调用unpark(thread)方法后，会自动唤醒thread线程，即park方法立即返回。

LockSupport中常用的方法

阻塞线程

  • void park()：阻塞当前线程，如果调用unpark方法或者当前线程被中断，从能从park()方法中返回

  • void park(Object blocker)：功能同方法1，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查

  • void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，增加了超时返回的特性

  • void parkNanos(Object blocker, long nanos)：功能同方法3，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查

  • void parkUntil(long deadline)：阻塞当前线程，直到deadline，deadline是一个绝对时间，表示某个时间的毫秒格式

  • void parkUntil(Object blocker, long deadline)：功能同方法5，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查；

唤醒线程

  • void unpark(Thread thread):唤醒处于阻塞状态的指定线程

示例1

主线程线程等待5秒之后，唤醒t1线程，代码如下：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Condition;
  5. import java.util.concurrent.locks.LockSupport;
  6. import java.util.concurrent.locks.ReentrantLock;
  8. /**
  9.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  10.  */
  11. public class Demo7 {
  13.     public static void main(String[] args) throws InterruptedException {
  14.         Thread t1 = new Thread(() -> {
  15.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  16.             LockSupport.park();
  17.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  18.         });
  19.         t1.setName("t1");
  20.         t1.start();
  21.         //休眠5秒
  22.         TimeUnit.SECONDS.sleep(5);
  23.         LockSupport.unpark(t1);
  24.         System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");
  25.     }
  26. }

输出：


     
     
  1. 1563597664321,t1 start!
  2. 1563597669323,LockSupport.unpark();执行完毕
  3. 1563597669323,t1 被唤醒!

t1中调用LockSupport.park();让当前线程t1等待，主线程休眠了5秒之后，调用LockSupport.unpark(t1);将t1线程唤醒，输出结果中1、3行结果相差5秒左右，说明t1线程等待5秒之后，被唤醒了。

LockSupport.park();无参数，内部直接会让当前线程处于等待中；unpark方法传递了一个线程对象作为参数，表示将对应的线程唤醒。

示例2

唤醒方法放在等待方法之前执行，看一下线程是否能够被唤醒呢？代码如下：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.LockSupport;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  8.  */
  9. public class Demo8 {
  11.     public static void main(String[] args) throws InterruptedException {
  12.         Thread t1 = new Thread(() -> {
  13.             try {
  14.                 TimeUnit.SECONDS.sleep(5);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  19.             LockSupport.park();
  20.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  21.         });
  22.         t1.setName("t1");
  23.         t1.start();
  24.         //休眠1秒
  25.         TimeUnit.SECONDS.sleep(1);
  26.         LockSupport.unpark(t1);
  27.         System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");
  28.     }
  29. }

输出：


     
     
  1. 1563597994295,LockSupport.unpark();执行完毕
  2. 1563597998296,t1 start!
  3. 1563597998296,t1 被唤醒!

代码中启动t1线程，t1线程内部休眠了5秒，然后主线程休眠1秒之后，调用了LockSupport.unpark(t1);唤醒线程t1，此时LockSupport.park();方法还未执行，说明唤醒方法在等待方法之前执行的；输出结果中2、3行结果时间一样，表示LockSupport.park();没有阻塞了，是立即返回的。

说明：唤醒方法在等待方法之前执行，线程也能够被唤醒，这点是另外2中方法无法做到的。Object和Condition中的唤醒必须在等待之后调用，线程才能被唤醒。而LockSupport中，唤醒的方法不管是在等待之前还是在等待之后调用，线程都能够被唤醒。

示例3

park()让线程等待之后，是否能够响应线程中断？代码如下：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.LockSupport;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  8.  */
  9. public class Demo9 {
  11.     public static void main(String[] args) throws InterruptedException {
  12.         Thread t1 = new Thread(() -> {
  13.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
  14.             System.out.println(Thread.currentThread().getName() + ",park()之前中断标志：" + Thread.currentThread().isInterrupted());
  15.             LockSupport.park();
  16.             System.out.println(Thread.currentThread().getName() + ",park()之后中断标志：" + Thread.currentThread().isInterrupted());
  17.             System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
  18.         });
  19.         t1.setName("t1");
  20.         t1.start();
  21.         //休眠5秒
  22.         TimeUnit.SECONDS.sleep(5);
  23.         t1.interrupt();
  25.     }
  26. }

输出：


     
     
  1. 1563598536736,t1 start!
  2. t1,park()之前中断标志：false
  3. t1,park()之后中断标志：true
  4. 1563598541736,t1 被唤醒!

t1线程中调用了park()方法让线程等待，主线程休眠了5秒之后，调用t1.interrupt();给线程t1发送中断信号，然后线程t1从等待中被唤醒了，输出结果中的1、4行结果相差5秒左右，刚好是主线程休眠了5秒之后将t1唤醒了。结论：park方法可以相应线程中断。

LockSupport.park方法让线程等待之后，唤醒方式有2种：

  1. 调用LockSupport.unpark方法
  2. 调用等待线程的interrupt()方法，给等待的线程发送中断信号，可以唤醒线程

示例4

LockSupport有几个阻塞放有一个blocker参数，这个参数什么意思，上一个实例代码，大家一看就懂了：


     
     
  1. package com.itsoku.chat10;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.LockSupport;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等)，喜欢请关注！
  8.  */
  9. public class Demo10 {
  11.     static class BlockerDemo {
  12.     }
  14.     public static void main(String[] args) throws InterruptedException {
  15.         Thread t1 = new Thread(() -> {
  16.             LockSupport.park();
  17.         });
  18.         t1.setName("t1");
  19.         t1.start();
  21.         Thread t2 = new Thread(() -> {
  22.             LockSupport.park(new BlockerDemo());
  23.         });
  24.         t2.setName("t2");
  25.         t2.start();
  26.     }
  27. }

运行上面代码，然后用jstack查看一下线程的堆栈信息：


     
     
  1. "t2" #13 prio=5 os_prio=0 tid=0x00000000293ea800 nid=0x91e0 waiting on condition [0x0000000029c3f000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.         at sun.misc.Unsafe.park(Native Method)
  4.         - parking to wait for  <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)
  5.         at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
  6.         at com.itsoku.chat10.Demo10.lambda$main$1(Demo10.java:22)
  7.         at com.itsoku.chat10.Demo10$$Lambda$2/824909230.run(Unknown Source)
  8.         at java.lang.Thread.run(Thread.java:745)
  10. "t1" #12 prio=5 os_prio=0 tid=0x00000000293ea000 nid=0x9d4 waiting on condition [0x0000000029b3f000]
  11.    java.lang.Thread.State: WAITING (parking)
  12.         at sun.misc.Unsafe.park(Native Method)
  13.         at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  14.         at com.itsoku.chat10.Demo10.lambda$main$0(Demo10.java:16)
  15.         at com.itsoku.chat10.Demo10$$Lambda$1/1389133897.run(Unknown Source)
  16.         at java.lang.Thread.run(Thread.java:745)

代码中，线程t1和t2的不同点是，t2中调用park方法传入了一个BlockerDemo对象，从上面的线程堆栈信息中，发现t2线程的堆栈信息中多了一行- parking to wait for <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)，刚好是传入的BlockerDemo对象，park传入的这个参数可以让我们在线程堆栈信息中方便排查问题，其他暂无他用。

LockSupport的其他等待方法，包含有超时时间了，过了超时时间，等待方法会自动返回，让线程继续运行，这些方法在此就不提供示例了，有兴趣的朋友可以自己动动手，练一练。

线程等待和唤醒的3种方式做个对比

到目前为止，已经说了3种让线程等待和唤醒的方法了

  1. 方式1：Object中的wait、notify、notifyAll方法
  2. 方式2：juc中Condition接口提供的await、signal、signalAll方法
  3. 方式3：juc中的LockSupport提供的park、unpark方法

3种方式对比：

ObjectCondtionLockSupport
前置条件需要在synchronized中运行需要先获取Lock的锁无
无限等待支持支持支持
超时等待支持支持支持
等待到将来某个时间返回不支持支持支持
等待状态中释放锁会释放会释放不会释放
唤醒方法先于等待方法执行，能否唤醒线程否否可以
是否能响应线程中断是是是
线程中断是否会清除中断标志是是否
是否支持等待状态中不响应中断不支持支持不支持
来源：http://itsoku.com/course/1/14
「已注销」
关注
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
java高并发系列 - 第14天:JUC中的LockSupport工具类，必备技能
yuzhiqiang_1的博客
11-11 210
java高并发系列 - 第14天:JUC中的LockSupport工具类，必备技能 原创：路人甲Java路人甲Java7月20日 java高并发系列第14篇文章 本文主要内容： 讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例 介绍LockSupport主要用法 对比3种方式，了解他们之间的区别 LockSupport位于java.util.c...
java juc LockSupport详解
qq_37385585的博客
02-02 177
LockSupport是什么 用来创建锁和其他同步类的基本线程阻塞原语 LockSupport就是线程等待唤醒机制 wait/notify 的改良加强版 那么问题来了，为什么要加强等待唤醒机制，原来使用的等待唤醒机制有什么缺点 使用synchornized和Lock的等待唤醒机制 1. 使用Object中的 wait() 方法让线程等待，使用Object中的notify() 方法唤醒线程 问题1.使用wait和notify的时候 必须包裹在synchronized关键字中 使用wait和notify的时候，
Java 多线程与并发(9-26)-JUC锁- LockSupport详解.pdf
07-23
LockSupport是Java中用于多线程同步的一个工具类，它提供了一组基础的线程阻塞和解除阻塞的方法。这个类位于java.util.concurrent.locks包下，是实现并发编程中AQS（AbstractQueuedSynchronizer）框架的重要基础之一...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
Tools 类则提供了一些有用的工具类，例如 LockSupport 类，用于创建锁和其他同步类的基本线程阻塞原语。 2.Collections： Collections 部分提供了一些并发集合类，例如 CopyOnWriteArrayList、ConcurrentHashMap ...
笔记_Java并发编程(2).docx
05-07
Java并发编程是Java开发中的重要组成部分，涉及到多线程、锁机制以及Java并发工具集（JUC）。在Java中，线程是程序执行的基本单元，它比进程更轻量级，能有效利用多核CPU资源，提高程序的执行效率。 进程是操作系统...
java编发编程：JUC综合讲解
08-09
Java并发编程中的JUC（Java Util Concurrent）库是开发者处理多线程问题的关键工具，尤其在多核处理器的环境中，其重要性不言而喻。JUC库包含了一系列的类和接口，帮助开发者构建高效、稳定的并发程序。下面将详细...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 547
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1105
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 148
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 626
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 906
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 340
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1175
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1059
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
服装|基于Java+vue的服装定制系统(源码+数据库+文档)
weixin_66413741的博客
09-10 729
服装定制将是广大用户们不可忽视的一块。但是管理好服装定制又面临很多麻烦需要解决,我们可以发现服装定制方面的系统并不是相当普及,在服装定制方面的可以有许多改进。即服装定制系统慢慢的被人们关注。服装定制管理方面的任务繁琐,以至于每年都在服装定制管理这方面投入较多的精力却效果甚微,
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 977
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
JAVA——方法重载
bengbeng2345的博客
09-12 205
返回值不能作为重载条件。
基于SpringBoot的医院挂号预约管理系统
计算机学姐的博客
09-11 823
【2025最新】基于Java+SpringBoot+Vue+MySQL的医院挂号预约管理系统，前后端分离。
Java并发高级探索： Unsafe与LockSupport详解及JUC框架优化
为了克服这个难题，程序员需要理解并利用Java提供的核心并发工具，如java.util.concurrent (JUC) 包中的类和API。 在讲解部分，文章聚焦于以下几个关键主题： 1. `rt.jar` 中的 `Unsafe` 类：`Unsafe` 是一个底层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值