LockSupport

LockSupport

LockSupport简介 LockSupport是用来创建锁和其他同步类的基本线程阻塞原语，官网对于该类的解释如下图所示，LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。 线程等待和唤醒方法 方式一：使用Object中的wait()方法让线程等待， 使用Object中的notify()方法唤醒线程。 代码演示如下：

public class LockSupportDemo {

    static Object objectLock=new Object();

    public static void main(String[] args) {//main方法，一切程序的入口
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"\t"+"------被唤醒");
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
             synchronized (objectLock){
                 objectLock.notify();
                 System.out.println(Thread.currentThread().getName()+"\t"+"------通知");
             }
        }, "B").start();
    }
}

运行结果如下：

A ------come in B ------通知 A ------被唤醒

特殊情况：如果先通知，再阻塞呢？ 修改上述的代码如下：

public class LockSupportDemo {

    static Object objectLock=new Object();

    public static void main(String[] args) {//main方法，一切程序的入口
        new Thread(() -> {
            //为了让B线程先通知，A线程再阻塞
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"\t"+"------被唤醒");
        }, "A").start();

        new Thread(() -> {
             synchronized (objectLock){
                 objectLock.notify();
                 System.out.println(Thread.currentThread().getName()+"\t"+"------通知");
             }
        }, "B").start();
    }
}

运行结果如下：

B ------通知 A ------come in //A线程一直在阻塞，等待唤醒

小总结 1.wait和notify方法必须要在同步块或者方法里面且成对出现使用 2.先wait后notify才OK

方式二：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程 。代码演示略 传统的synchronized和Lock实现等待唤醒通知的约束 1.线程先要获得并持有锁，必须在锁块（synchronized或lock）中 2.必须要先等待后唤醒，线程才能够被唤醒

方式三：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。 通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作，LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport类使用了一种名为Permit(许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit),permit只有两个值1和零，默认是零。可以把许可看成是一种(0,1)信号量(Semaphore），但与Semaphore不同的是，许可的累加上限是1。 主要方法 1.阻塞：park()/park(Object blocker)阻塞当前线程/阻塞传入的具体线程 permit默认是O，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时,park方法会被唤醒， 然后会将permit再次设置为O并返回。

2.唤醒：unpark(Thread thread)唤醒处于阻断状态的指定线程 调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程， 即之前阻塞中的LockSupport.park()方法会立即返回。

代码演示1：正常+无锁块要求

public class LockSupportDemo1 {
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t"+"------come in");
            LockSupport.park();//被阻塞......等待许可证
            System.out.println(Thread.currentThread().getName()+"\t"+"------被唤醒");
        }, "A");
        a.start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread b = new Thread(() -> {
            LockSupport.unpark(a);
            System.out.println(Thread.currentThread().getName()+"\t"+"------唤醒线程a");
        }, "B");
        b.start();
    }
}

运行结果如下：

A ------come in B ------唤醒线程a A ------被唤醒

代码演示2：之前错误的先唤醒后等待，LockSupport照样支持

public class LockSupportDemo2 {
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"\t"+"------come in");
            LockSupport.park();//被阻塞......等待许可证
            System.out.println(Thread.currentThread().getName()+"\t"+"------被唤醒");
        }, "A");
        a.start();

        Thread b = new Thread(() -> {
            LockSupport.unpark(a);
            System.out.println(Thread.currentThread().getName()+"\t"+"------唤醒线程a");
        }, "B");
        b.start();
    }
}

运行结果如下：

B ------唤醒线程a A ------come in A ------被唤醒

重点说明

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语 LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。 LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程 LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1，0的开关，默认是0， 调用一次unpark就加1变成1，调用一次park会消费permit，也就是将1变成o，同时park立即返回。如再次调用park会变成阻塞(因为permit为零了会阻塞在这里，一直到permit变为1)，这时调用unpark会把permit置为1。 每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累凭证。

形象的理解：线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。

当调用park方法时

• 如果有凭证，则会直接消耗掉这个凭证然后正常退出;
• 如果无凭证，就必须阻塞等待凭证可用; 而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

面试题

1.为什么可以先唤醒线程后阻塞线程?

因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

2.为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证; 而调用两次park却需要消费两个凭证，证不够，不能放行。