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却需要消费两个凭证，证不够，不能放行。