一、LockSupport概述

1、LockSupport是什么

在java.util.concurrent.locks包下，有一个不经常被人关注的类：LockSupport。用于创建锁和其他同步类的基本线程阻塞元语。

总共有如下几个方法：

LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（Permit），但是与Semaphore不同的是，许可的累加上限是1。

大概的意思就是：LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。类似于wait和notify，类似于await和signal。

2、三种等待唤醒机制

Java中线程等待唤醒机制有很多：
使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程；
使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程；
LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。

那么这三种方式有什么区别呢？

3、其他线程等待唤醒方式（了解）

在Java中，除了这三种方式可以实现线程的阻塞、唤醒之外，还可以使用Semaphore、CyclicBarrier、CountDownLatch等类进行实现，但是这几种场景不在本文讨论范围之内，感兴趣小伙伴可以自行关注。

java之Semaphore信号量做限流
java的CyclicBarrier使用
java的CountDownLatch使用

二、代码实例分析

1、使用wait()+notify()

（1）代码实例

以下例子我们可以看出，使用wait()+notify() 需要配合synchronized 关键字：

// 正确使用wait + notify
public static void main(String[] args)
{
    Object objectLock = new Object();

    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 ----被唤醒");
        }
    },"t1").start();

    //暂停几秒钟线程
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

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

如果不用synchronized 的话，直接抛出了IllegalMonitorStateException：

public static void main(String[] args)
{
    Object objectLock = new Object();

    new Thread(() -> {
        System.out.println(Thread.currentThread().getName()+"\t ----come in");
        try {
            objectLock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
    },"t1").start();

    //暂停几秒钟线程
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

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

我们再反过来看看，如果先nofity，再wait会怎么样：
从结果我们也可以看出，先发出nofity信号再wait，wait之前的nofity信号是没有用的，只有wait之后的nofity信号才可以解除wait。

public static void main(String[] args)
{
    Object objectLock = new Object();

    new Thread(() -> {
        try { TimeUnit.SECONDS.sleep(1); } 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 ----被唤醒");
        }
    },"t1").start();

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

（2）分析总结

通过wait和notify实例我们可以看出，要使用这两个方法，必须要配合synchronized同步代码块才能实现，否则会抛出异常；而且必须要先等待后再唤醒，先唤醒后等待的话，是不会生效的。

2、使用await()+signal()

（1）代码实例

同样的，使用await()+signal()也需要配合lock()和unlock()方法：

    private static void main(String[] args)
    {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try
            {
                System.out.println(Thread.currentThread().getName()+"\t ----come in");
                condition.await();
                System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            lock.lock();
            try
            {
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }

如果不使用lock()和unlock()方法，同样也会抛出异常：

而我们调整代码，先signal()后await()，同样也会导致await()阻塞：

public static void main(String[] args)
{
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

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

    new Thread(() -> {
        lock.lock();
        try
        {
            condition.signal();
            System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
        }finally {
            lock.unlock();
        }
    },"t2").start();
}

（2）分析总结

通过await和signal实例我们可以看出，要使用这两个方法，也必须要配合lock同步代码块才能实现，否则会抛出异常；而且必须要先等待后再唤醒，先唤醒后等待的话，是不会生效的。

3、使用LockSupport

（1）代码实例

通过下面的实例我们可以看出，使用LockSupport的park和unpark方法，也可以实现线程的阻塞。并且如果先调用unpark的话，会累计一个许可证（最多累计一个），下次调用park时可以直接使用该许可证。

public static void main(String[] args)
{
    Thread t1 = new Thread(() -> {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName() + "\t ----come in"+System.currentTimeMillis());
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "\t ----被唤醒"+System.currentTimeMillis());
    }, "t1");
    t1.start();

    //暂停几秒钟线程
    //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

    new Thread(() -> {
        LockSupport.unpark(t1);
        // LockSupport.unpark(t1); 多次unpark并不会累计多个许可证，只会累计一个
        System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
    },"t2").start();

}

（2）源码分析

通过底层的UNSAFE类，实现的。
最终都是调用的native方法。

public static void park() {
    UNSAFE.park(false, 0L);
}
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

（3）分析总结

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSuppot是一个线程阻寨工县类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻寨之后也有对应的唤醒方法。

LockSupport调用的Unsafe中的native代码。

LockSupport 提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程。

LockSupport和每个使用它的线程都有一个许可(permit)关联。每个线程都有一个相关的permit,permit最多只有一个，重复调用unpark也不会积累凭证。

线程阻寒需要消耗凭证(permit)，这个凭证最多只有1个。
当调用park方法时，如果有凭证，则会直接消耗掉这个凭证然后正常退出； 如果无凭证，就必须阻塞等待凭证可用。

而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。