java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能

2401_84153262

于 2024-05-03 08:31:11 发布

阅读量773

点赞数 25

分类专栏：程序员文章标签： java wpf 开发语言

本文链接：https://blog.csdn.net/2401_84153262/article/details/138409174

版权

程序员专栏收录该内容

167 篇文章 0 订阅

订阅专栏

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

lock.lock();

try {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

try {

condition.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

} finally {

lock.unlock();

}

});

t1.setName(“t1”);

t1.start();

//休眠5秒

TimeUnit.SECONDS.sleep(5);

lock.lock();

try {

condition.signal();

} finally {

lock.unlock();

}

输出：

1563594349632,t1 start!

1563594354634,t1 被唤醒!

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

示例2

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

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo5 {

static ReentrantLock lock = new ReentrantLock();

static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

try {

condition.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

});

t1.setName(“t1”);

t1.start();

//休眠5秒

TimeUnit.SECONDS.sleep(5);

condition.signal();

}

输出：

Exception in thread “t1” java.lang.IllegalMonitorStateException

1563594654865,t1 start!

at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)

at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)

at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)

at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)

at com.itsoku.chat10.Demo5.lambda$main$0(Demo5.java:19)

at java.lang.Thread.run(Thread.java:745)

Exception in thread “main” java.lang.IllegalMonitorStateException

at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)

at com.itsoku.chat10.Demo5.main(Demo5.java:29)

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

示例3

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

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo6 {

static ReentrantLock lock = new ReentrantLock();

static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) {

e.printStackTrace();

}

lock.lock();

try {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

try {

condition.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

} finally {

lock.unlock();

}

});

t1.setName(“t1”);

t1.start();

//休眠5秒

TimeUnit.SECONDS.sleep(1);

lock.lock();

try {

condition.signal();

} finally {

lock.unlock();

}

System.out.println(System.currentTimeMillis() + “,condition.signal();执行完毕”);

}

运行结果:

1563594886532,condition.signal();执行完毕

1563594890532,t1 start!

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

关于Condition中方法使用总结：

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

Object和Condition的局限性

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

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

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

LockSupport类介绍

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

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

当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。

当调用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线程，代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.LockSupport;

import java.util.concurrent.locks.ReentrantLock;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo7 {

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

LockSupport.park();

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

});

t1.setName(“t1”);

t1.start();

//休眠5秒

TimeUnit.SECONDS.sleep(5);

LockSupport.unpark(t1);

System.out.println(System.currentTimeMillis() + “,LockSupport.unpark();执行完毕”);

}

输出：

1563597664321,t1 start!

1563597669323,LockSupport.unpark();执行完毕

1563597669323,t1 被唤醒!

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

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

示例2

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

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo8 {

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

LockSupport.park();

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

});

t1.setName(“t1”);

t1.start();

//休眠1秒

TimeUnit.SECONDS.sleep(1);

LockSupport.unpark(t1);

System.out.println(System.currentTimeMillis() + “,LockSupport.unpark();执行完毕”);

}

输出：

1563597994295,LockSupport.unpark();执行完毕

1563597998296,t1 start!

1563597998296,t1 被唤醒!

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

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

示例3

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

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo9 {

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " start!");

System.out.println(Thread.currentThread().getName() + “,park()之前中断标志：” + Thread.currentThread().isInterrupted());

LockSupport.park();

System.out.println(Thread.currentThread().getName() + “,park()之后中断标志：” + Thread.currentThread().isInterrupted());

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + " 被唤醒!");

});

t1.setName(“t1”);

t1.start();

//休眠5秒

TimeUnit.SECONDS.sleep(5);

t1.interrupt();

}

输出：

1563598536736,t1 start!

t1,park()之前中断标志：false

t1,park()之后中断标志：true

1563598541736,t1 被唤醒!

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

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

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

示例4

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

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo10 {

static class BlockerDemo {

}

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(() -> {

LockSupport.park();

});

t1.setName(“t1”);

t1.start();

Thread t2 = new Thread(() -> {

LockSupport.park(new BlockerDemo());

});

t2.setName(“t2”);

t2.start();

}

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

“t2” #13 prio=5 os_prio=0 tid=0x00000000293ea800 nid=0x91e0 waiting on condition [0x0000000029c3f000]

java.lang.Thread.State: WAITING (parking)

at sun.misc.Unsafe.park(Native Method)

parking to wait for <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)

at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)

at com.itsoku.chat10.Demo10.lambda$main$1(Demo10.java:22)

at com.itsoku.chat10.Demo10$$Lambda$2/824909230.run(Unknown Source)

at java.lang.Thread.run(Thread.java:745)

“t1” #12 prio=5 os_prio=0 tid=0x00000000293ea000 nid=0x9d4 waiting on condition [0x0000000029b3f000]

java.lang.Thread.State: WAITING (parking)

at sun.misc.Unsafe.park(Native Method)

at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)

at com.itsoku.chat10.Demo10.lambda$main$0(Demo10.java:16)

at com.itsoku.chat10.Demo10$$Lambda$1/1389133897.run(Unknown Source)

at java.lang.Thread.run(Thread.java:745)

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

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

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

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

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

3种方式对比：

| — | — | — | — |

| 无限等待 | 支持 | 支持 | 支持 |

| 超时等待 | 支持 | 支持 | 支持 |

| 等待到将来某个时间返回 | 不支持 | 支持 | 支持 |

| 等待状态中释放锁 | 会释放 | 会释放 | 不会释放 |

| 唤醒方法先于等待方法执行，能否唤醒线程 | 否 | 否 | 可以 |

| 是否能响应线程中断 | 是 | 是 | 是 |

| 线程中断是否会清除中断标志 | 是 | 是 | 否 |

| 是否支持等待状态中不响应中断 | 不支持 | 支持 | 不支持 |

码子不易，感觉还可以的，帮忙分享一下，谢谢！

java高并发系列目录：

1.java高并发系列 - 第1天:必须知道的几个概念

2.java高并发系列 - 第2天:并发级别

3.java高并发系列 - 第3天:有关并行的两个重要定律

4.java高并发系列 - 第4天:JMM相关的一些概念

5.java高并发系列 - 第5天:深入理解进程和线程

6.java高并发系列 - 第6天:线程的基本操作

总结

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。

如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
不支持 | 支持 | 支持 |

| 等待状态中释放锁 | 会释放 | 会释放 | 不会释放 |

| 唤醒方法先于等待方法执行，能否唤醒线程 | 否 | 否 | 可以 |

| 是否能响应线程中断 | 是 | 是 | 是 |

| 线程中断是否会清除中断标志 | 是 | 是 | 否 |

| 是否支持等待状态中不响应中断 | 不支持 | 支持 | 不支持 |

码子不易，感觉还可以的，帮忙分享一下，谢谢！

java高并发系列目录：

1.java高并发系列 - 第1天:必须知道的几个概念

2.java高并发系列 - 第2天:并发级别

3.java高并发系列 - 第3天:有关并行的两个重要定律

4.java高并发系列 - 第4天:JMM相关的一些概念

5.java高并发系列 - 第5天:深入理解进程和线程

6.java高并发系列 - 第6天:线程的基本操作

总结

[外链图片转存中…(img-9aPQLU50-1714696260216)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

2401_84153262

关注

25
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
复制链接

扫一扫