参考链接：
LockSupport使用场景及原理详解
AQS的引入

LockSupport的使用

LockSupport是一个工具类，提供了基本的线程阻塞和唤醒功能，它是创建锁和其他同步组件的基础工具，内部是使用sun.misc.Unsafe类实现的。LockSupport和使用它的线程都会关联一个许可，park方法表示消耗一个许可，调用park方法时，如果许可可用则park方法返回，如果没有许可则一直阻塞直到许可可用。unpark方法表示增加一个许可，多次调用并不会积累许可，因为许可数最大值为1。

其次，注意：某个线程可以先被unpark（这时，该线程就获得了一个许可），然后这个线程调用LockSupport.park()时，此时，发现有许可可用，则使用此许可而不会阻塞。

关于LockSupport的补充

LockSupport会为每个线程设置一个permit值，也就是许可。1代表许可可用，0代表许可不可用。permit的最大值是1，最小值是0，当调用park()方法时，如果permit为1，则减为0，继续执行。如果permit已经为0，则阻塞。同理，unpark()方法会消耗一个许可，如果permit的值为0，则增加为1，代表发放许可，如果permit的值已经为1，则不在增加，也就是多次方法许可，并不会累加。当然这里所讲的permit在LockSupport的代码当中没有体现，需要到HotSpot的源码当中查看，以下为截图供查看：

1、/share/vm/runtime/park.hpp中许可的定义字段_counter

2、park()的实现(部分截图)

3、unpark()实现

示例：让3个线程按顺序打印ABC

package com.zzhua;

import java.util.concurrent.locks.LockSupport;

public class TestABC {

    private void printA(Thread thread) {
        System.out.println("A");
        LockSupport.unpark(thread);
    }

    private void printB(Thread thread) {
        LockSupport.park();
        System.out.println("B");
        LockSupport.unpark(thread);
    }

    private void printC() {
        LockSupport.park();
        System.out.println("C");
    }

    public static void main(String[] args) {

		/* 无论下面哪个线程先被执行，当B和C未获得它们的许可时，都会被阻塞掉，一直到获得许可。
		   或者，它们在它们执行顺先前面的线程执行完后，先给了它们许可后，它们再在park时，再消费此许可
		   这样就可以保证它们的打印顺序
		   LockSupport的存在目的就是为了替换掉jdk自带的wait-notify等待唤醒机制(它只能结合synchronized使用，并且只能唤醒一个或全部唤醒，不够灵活) */
		
        TestABC testABC = new TestABC();

        Thread tC = new Thread(() -> {
            testABC.printC();
        });

        Thread tB = new Thread(() -> {
            testABC.printB(tC);
        });

        Thread tA = new Thread(() -> {
            testABC.printA(tB);
        });

        tC.start();
        tB.start();
        tA.start();

    }

}

可正常响应中断

LockSupport.park()方法可以阻塞当前线程，阻塞的过程中，是可以正常响应中断的（如下面例子）。而jdk自带的synchornized当处于阻塞时，是不会响应中断的。

package com.zzhua;

import java.util.concurrent.locks.LockSupport;

public class TestPark {

    public static void main(String[] args) {

        Thread mainThread = Thread.currentThread();

        new Thread(() -> {
            try {
                Thread.sleep(3000L);
                mainThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        LockSupport.park();
        
        System.out.println("main....");

		// 3s后，正常输出main....
		// 说明park()方法可正常响应中断

    }

}

jdk自带的synchronized在阻塞期间是不会响应中断的，以下示例，在10s后，正常输出main…

package com.zzhua;


public class TestPark {

    public static void main(String[] args) throws InterruptedException {

        Thread mainThread = Thread.currentThread();

        new Thread(() -> {
            try {
                Thread.sleep(3000L);
                mainThread.interrupt();
                System.out.println("尝试中断main线程...(但是main线程没反应)");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                synchronized (TestPark.class) {
                    Thread.sleep(10000L);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(50L);

        System.out.println("要进入synchronized了");
        synchronized (TestPark.class) {
            System.out.println("main....");
        }

    }

}