【JUC并发编程】JUC锁 LockSupport详解

小颜-

已于 2022-09-18 02:12:34 修改

阅读量263

点赞数

分类专栏： JUC 文章标签：后端 java 开发语言面试

于 2022-07-10 23:21:47 首次发布

本文链接：https://blog.csdn.net/weixin_63566550/article/details/125712631

版权

JUC 专栏收录该内容

24 篇文章 1 订阅

订阅专栏

带着BAT大厂的面试问题去理解

为什么LockSupport也是核心基础类? AQS框架借助于两个类：Unsafe(提供CAS操作)和LockSupport(提供park/unpark操作)
写出分别通过wait/notify和LockSupport的park/unpark实现同步?
LockSupport.park()会释放锁资源吗? 那么Condition.await()呢?
Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park()的区别? 重点
如果在wait()之前执行了notify()会怎样?
如果在park()之前执行了unpark()会怎样?

LockSupport简介

LockSupport用来创建锁和其他同步类的基本线程阻塞原语。简而言之，当调用LockSupport.park时，表示当前线程将会等待，直至获得许可，当调用LockSupport.unpark时，必须把等待获得许可的线程作为参数进行传递，好让此线程继续运行。

该类与使用它的每个线程关联一个许可证（在Semaphore类的意义上）。如果许可证可用，将立即返回park ，并在此过程中消费; 否则可能会阻止。如果尚未提供许可，则致电unpark获得许可。（与Semaphores不同，许可证不会累积。最多只有一个。）可靠的使用需要使用volatile（或原子）变量来控制何时停放或取消停放。对于易失性变量访问保持对这些方法的调用的顺序，但不一定是非易失性变量访问。

方法park和unpark提供了阻止和解除阻塞线程的有效方法，这些线程没有遇到导致不推荐使用的方法Thread.suspend和Thread.resume无法用于此类目的的问题：一个线程调用park和另一个线程尝试unpark将保留活跃性，由于许可证。此外，如果调用者的线程被中断，则会返回park ，并且支持超时版本。 park方法也可以在任何其他时间返回，“无理由”，因此通常必须在返回时重新检查条件的循环内调用。在这个意义上， park可以作为“忙碌等待”的优化，不会浪费太多时间旋转，但必须与unpark配对才能生效。

线程等待与唤醒的方式演进：

synchronized：使用同一把锁同一个对象

正确的等待唤醒顺序：线程 t1 先等待，线程 t2 后唤醒 t1

若线程 t2 先唤醒 t1，线程 t1 后调用等待，则会抛出两个异常： wait 异常 notify 异常

    @SneakyThrows
    @Test
    public void test9(){
        Object objectLock = new Object();

        //wait方法会释放锁 但sleep方法不会释放锁
        new Thread(() -> {
            System.out.println("come in！");
            synchronized (objectLock){
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("被唤醒！");
        },"t1").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            System.out.println("拿到锁！");
            synchronized (objectLock){
                objectLock.notify();
            }
        },"t2").start();
    }

Lock：使用同一把锁同一个对象

正确的等待唤醒顺序：线程 t1 先等待，线程 t2 后唤醒 t1

若线程 t2 先唤醒 t1，线程 t1 后调用等待，则会抛出两个异常： await 异常 signal 异常

    @SneakyThrows
    @Test
    public void test10() {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("come in!");
                condition.await();
                System.out.println("被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t1").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() ->{
            lock.lock();
            condition.signal();
            System.out.println("唤醒");
            lock.unlock();
        },"t2").start();
    }

LockSupport核心函数分析

在分析LockSupport函数之前，先引入sun.misc.Unsafe类中的park和unpark函数，因为LockSupport的核心函数都是基于Unsafe类中定义的park和unpark函数，下面给出两个函数的定义:

public native void park(boolean isAbsolute, long time);
public native void unpark(Thread thread);

说明: 对两个函数的说明如下:

park函数，阻塞线程，并且该线程在下列情况发生之前都会被阻塞: ① 调用unpark函数，释放该线程的许可。② 该线程被中断。③ 设置的时间到了。并且，当time为绝对时间时，isAbsolute为true，否则，isAbsolute为false。当time为0时，表示无限等待，直到unpark发生。

①. permit默认是0,所以一开始调用park()方法,当前线程就会阻塞,直到别的线程将当前线程的permit设置为1时, park方法会被唤醒,然后会将permit再次设置为0并返回

②. static void park( ):底层是unsafe类native方法
unpark函数，释放线程的许可，即激活调用park后阻塞的线程。如果给定线程的许可尚不可用，则使其可用。如果线程在 park 上受阻塞，则它将解除其阻塞状态。否则，保证下一次调用 park 不会受阻塞。如果给定线程尚未启动，则无法保证此操作有任何效果。这个函数不是安全的，调用这个函数时要确保线程依旧存活。
①. 调用unpark(thread)方法后,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,permit值还是1)会自动唤醒thread线程,即之前阻塞中的LockSupport.park()方法会立即返回

    @SneakyThrows
    @Test
    public void test11(){

        Thread t1 = new Thread(() -> {
            System.out.println("come in! ");
            LockSupport.park();
            System.out.println("被唤醒！");
        }, "t1");
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            LockSupport.unpark(t1);
            System.out.println("发通知！");
        },"t2").start();
    }

LockSupport它的解决的痛点

①. LockSupport不用持有锁块,不用加锁,程序性能好
②. 先后顺序,不容易导致卡死(因为unpark获得了一个凭证,之后再调用park方法,就可以名正言顺的凭证消费,故不会阻塞)

/*
(1).阻塞
 (permit默认是O,所以一开始调用park()方法,当前线程就会阻塞,直到别的线程将当前线程的permit设置为1时,
 park方法会被唤醒,然后会将permit再次设置为O并返回)
 static void park()
 static void park(Object blocker)
(2).唤醒
static void unpark(Thread thread)
 (调用unpark(thread)方法后,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,
 permit值还是1)会自动唤醒thread线程,即之前阻塞中的LockSupport.park()方法会立即返回)
 static void unpark(Thread thread)
* */
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1=new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t"+"coming....");
            LockSupport.park();
            /*
            如果这里有两个LockSupport.park(),因为permit的值为1,上一行已经使用了permit
            所以下一行被注释的打开会导致程序处于一直等待的状态
            * */
            //LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t"+"被B唤醒了");
            },"A");
        t1.start();

        //下面代码注释是为了A线程先执行
        //try { TimeUnit.SECONDS.sleep(3);  } catch (InterruptedException e) {e.printStackTrace();}

        Thread t2=new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t"+"唤醒A线程");
            //有两个LockSupport.unpark(t1),由于permit的值最大为1,所以只能给park一个通行证
            LockSupport.unpark(t1);
            //LockSupport.unpark(t1);
        },"B");
        t2.start();
    }
}