LockSupport
LockSupport要从wait/notify/notifyAll 、condition.await/signal/signalAll 说起
在JUC包中很多地方都会使用到LockSupport 比如我们前边写的ReentrantLock中,获取锁失败之后会加入队列调用LockSupport.park() 等待前边一个获取锁的线程unpark自己
下边以小强和小月月用同一个水杯喝水为例 讲解wait/notify 、await/signal 、park/unpark
一、 wait notify
wait nofity 的详细讲解 前边文章有写过 这里只是简单实用 仅为了与LockSupport比较
class TestWaitNotify { public Object obj = new Object(); public static void main(String[] args) { TestWaitNotify test = new TestWaitNotify(); new Thread(test::xiaoqiang).start(); new Thread(test::xiaoyueyue).start(); } /** * 小强喝水 */ public void xiaoqiang(){ synchronized (obj){ while (true){ try{ System.out.println("小强喝水"); //通知别人喝水 obj.notify(); // 自己wait obj.wait(); } catch (Exception e){ e.printStackTrace(); } } } } /** * 小月月喝水 */ public void xiaoyueyue(){ synchronized (obj){ while (true){ try{ System.out.println("小月月喝水"); //通知别人喝水 obj.notify(); // 自己wait obj.wait(); } catch (Exception e){ e.printStackTrace(); } } } } } 输出结果: 小强喝水 小月月喝水 小强喝水 小月月喝水 小强喝水 小月月喝水 ...
小强喝完了通知别人可以喝了,然后自己等着
小月月收到通知,喝水,喝完了通知别人可以喝了,然后自己等着
如此循环往复...
wait/notify/notifyAll 还是老生常谈的问题:
1. 必须在synchronized代码块或者synchronized修饰的方法内 否则会报异常:java.lang.IllegalMonitorStateException 2. nofity只有在wait方法调用之后调用才能生效 先调用notify再调用wait 没用。。。 3. 线程interrupt 中断会打断wait
二、await signal
class TestAwaitSignal { Lock lock = new ReentrantLock(); Condition cd = lock.newCondition(); public static void main(String[] args) { TestAwaitSignal test = new TestAwaitSignal(); new Thread(test::xiaoqiang).start(); new Thread(test::xiaoyueyue).start(); } /** * 小强喝水 */ public void xiaoqiang(){ try { lock.lock(); while (true){ try{ System.out.println("小强喝水"); //signal通知别人喝水 cd.signal(); // 自己await cd.await(); } catch (Exception e){ e.printStackTrace(); } } } catch (Exception e){ e.printStackTrace(); } finally { lock.unlock(); } } /** * 小月月喝水 */ public void xiaoyueyue(){ try { lock.lock(); while (true){ try{ System.out.println("小月月喝水"); //signal通知别人喝水 cd.signal(); // 自己await cd.await(); } catch (Exception e){ e.printStackTrace(); } } } catch (Exception e){ e.printStackTrace(); } finally { lock.unlock(); } } } 输出结果: 小强喝水 小月月喝水 小强喝水 小月月喝水 小强喝水 小月月喝水 小强喝水 小月月喝水 小强喝水 ...
await/signal/signalAll还是老生常谈的问题:
1. 必须在lock获取锁代码块中执行 否则会报IllegalMonitorStateException异常 2. lock必须在finally中手动释放锁 3. signal 必须 在await之后调用 否则不起作用 4. condition.await比wait多可中断、到达指定时(前边文章有写)间停止等功能(前边文章有写) 5. 一个lock可以new多个互不干扰的condition (前边文章有写)
三、LockSupport
3.1 使用
这是要给很好的东西
park /pɑːk/ 停车场、停放
unpark 把车从停车场离开
从一个故事走进park/unpark ,小强开着车走进一个停车场park了一下,然后他就出不去了,只能一直在停车场停着,直到小月月给他送来停车券unpark,这时候他才能出去
停车例子:
class TestParkUnpark { public static void main(String[] args) throws InterruptedException { TestParkUnpark test = new TestParkUnpark(); Thread thread = new Thread(test::xiaoqiang); thread.start(); Thread.sleep(5000); // 小月月给停车券 new Thread(()->{ test.xiaoyueyue(thread); }).start(); } /** * 小强进入停车场 */ public void xiaoqiang(){ System.out.println("停车等着出停车场"); LockSupport.park(); System.out.println("我出来了!!"); } /** * 小月月给停车券 */ public void xiaoyueyue(Thread thread){ System.out.println("给小强那二傻子送个停车券"); LockSupport.unpark(thread); } } 输出: 停车等着出停车场 给小强那二傻子送个停车券 我出来了!!
很明显看出来了,
1.LockSupport 与wait/condition.await最大的区别就是 他不要锁,不需要在锁代码块中使用
3.2 不分顺序
LockSupport还有一个特点就是unpark可以先于park执行,就是小强这二傻子去停车场之前,小月月先把停车券给他了unpark,等他想走的时候手里有停车券不需要再一次获取停车券unpark了。
class TestParkUnpark02 { public static void main(String[] args) throws InterruptedException { TestParkUnpark02 test = new TestParkUnpark02(); Thread thread = new Thread(test::xiaoqiang); // 进入停车场 thread.start(); // 小月月先给停车券 new Thread(()->{ test.xiaoyueyue(thread); }).start(); } /** * 小强进入停车场 */ public void xiaoqiang() { try { // 在外边潇洒呢 Thread.sleep(10000); // 进停车场了 System.out.println("停车等着出停车场"); LockSupport.park(); System.out.println("我出来了!!"); } catch (Exception e){ } } /** * 小月月给停车券 */ public void xiaoyueyue(Thread thread){ System.out.println("给小强那二傻子送个停车券"); LockSupport.unpark(thread); } } 输出结果: 给小强那二傻子送个停车券 停车等着出停车场 我出来了!!
3.3 可中断 可超时返回 可指定等待时间点返回
class TestParkUnpark03 { public static void main(String[] args) { TestParkUnpark03 test = new TestParkUnpark03(); // 可中断 停止park Thread thread = new Thread(test::xiaoqiang); thread.start(); thread.interrupt(); } /** * 可中断 */ public void xiaoqiang() { // 进停车场了 System.out.println("停车等着出停车场"); LockSupport.park(); boolean interrupted = Thread.currentThread().isInterrupted(); if (interrupted){ System.out.println("被中断的 强行闯卡"); } else { System.out.println("拿到票 我出来了!!"); } } }
class TestParkUnpark04 { public static void main(String[] args) { TestParkUnpark04 test = new TestParkUnpark04(); // 可超时 Thread thread = new Thread(test::xiaoqiang); thread.start(); } /** * 可超时 */ public void xiaoqiang() { // 进停车场了 System.out.println("停车等着出停车场"); // 5秒后自己出去 long nanos = TimeUnit.SECONDS.toNanos(5); LockSupport.parkNanos(nanos); System.out.println("结束park 要么是给了券 要么是小强跟门卫耗了半天让他出去了"); } }
class TestParkUnpark04 { public static void main(String[] args) { TestParkUnpark04 test = new TestParkUnpark04(); // 可指定等待时间点 到这个点就停止park Thread thread = new Thread(test::xiaoqiang); thread.start(); } /** * 可指定等待时间点 到这个点就停止park */ public void xiaoqiang() { // 进停车场了 System.out.println("停车等着出停车场"); // 10秒后自己出去 long nanos = TimeUnit.SECONDS.toMillis(10); Date date= new Date(System.currentTimeMillis()+nanos); // 到指定时间就停止 LockSupport.parkUntil(date.getTime()); System.out.println("结束park 要么是给了券 要么是小强跟门卫耗了半天让他出去了 要么是到了晚上(指定时间)门卫不在 自己溜出去了"); } }
3.4还有一个 功能
这个功能乍一看没啥作用。
class TestParkUnpark04 { public static void main(String[] args) { TestParkUnpark04 test = new TestParkUnpark04(); new Thread(test::xiaoqiang01,"线程001").start(); new Thread(test::xiaoqiang02,"线程002").start(); } public void xiaoqiang01() { // 这里传入了一个对象 LockSupport.park(); } public void xiaoqiang02() { // 这里传入了一个对象 LockSupport.park(new ParkParam()); } } class ParkParam{ }
我们用jps找到当前java进程,再用jstack查看堆栈信息
1. 打开cmd 2. jps 11672 TestParkUnpark04 3. jstack -l 11672 部分输出内容: "线程002" #12 prio=5 os_prio=0 tid=0x000000001e042800 nid=0x263c waiting on condition [0x000000001eaff000] java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method) - parking to wait for <0x000000076bbb1a20> (a vip.freeedu.ParkParam) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175) at vip.freeedu.TestParkUnpark04.xiaoqiang02(TestParkUnpark04.java:25) at vip.freeedu.TestParkUnpark04$$Lambda$2/990368553.run(Unknown Source) at java.lang.Thread.run(Thread.java:748) Locked ownable synchronizers: - None "线程001" #11 prio=5 os_prio=0 tid=0x000000001e03f800 nid=0x25fc waiting on condition [0x000000001e9ff000] java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304) at vip.freeedu.TestParkUnpark04.xiaoqiang01(TestParkUnpark04.java:21) at vip.freeedu.TestParkUnpark04$$Lambda$1/2003749087.run(Unknown Source) at java.lang.Thread.run(Thread.java:748)
可以看到线程002 多了一行 -parking for wait for xxxx
这样我们在排查问题的时候就容易知道是哪儿出了问题 ,每个park处都new不一样的对象,这样很容易定位
3.5 LockSupport**优点出来了
1. 不用与锁混合使用!! 2. 可以先unpark拿到停车券 在park的时候就可以直接用停车券通过!! 3. 可以超时停止等待 ; wait await都支持 4. 可停止到指定时间 ;await支持 5. 可中断 ;wait await都支持 await支持不响应中断
这里说一点哈 ,Object的wait也支持wait超时停止等待
3.6 注意:unpark不能累计
park和unpark的实现原理。。 我看了一下hotspot的实现 没有看懂 ,但是我看注释意思可能就是这样的,
有一个标志位_event ,
3.7 park
当调用park的时候就会判断_event值
如果是-1 非法数据
如果是1 那就设置为0 返回(不阻塞直接过)相当于手持停车券 出停车场 顺畅无阻 (先unpark 再 park )
如果是0 那就把_event设置为-1
void os::PlatformEvent::park() { // AKA "down()" // Transitions for _event: // -1 => -1 : illegal // 1 => 0 : pass - return immediately // 0 => -1 : block; then set _event to 0 before returning
3.8 unpark
当调用unpark**的时候就会判断_event值
如果是0,设置_event为1 这就是为什么unpark可以在park之前调用,因为这里设置为1 然后park的时候就会用这个值
如果是1 返回 ,不会累积 这就是为什么unpark多次只能park使用一次
如果是-1 那就把_event设置为0 或 1 ,唤醒目标线程
void os::PlatformEvent::unpark() { // Transitions for _event: // 0 => 1 : just return // 1 => 1 : just return // -1 => either 0 or 1; must signal target thread // That is, we can safely transition _event from -1 to either // 0 or 1.
欢迎关注公众号: