文章/答案/技术大牛

发布

社区首页 >专栏 >话说 LockSupport

话说 LockSupport

原创

木子的昼夜

修改于 2021-04-06 03:09:09

4540

文章被收录于专栏：互联网底层的我们互联网底层的我们

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.