LockSupport和AQS

1.LockSupport

1.1 什么是LockSupport

• LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。
• LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
• LockSupport类使用了一种名为Permit(许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit),permit只有两个值1和零，默认是零。可以把许可看成是一种(0,1)信号量(Semaphore），但与Semaphore不同的是，许可的累加上限是1。

1.2 三种等待、唤醒方法

1. Object的wait()等待，notify()唤醒。
2. Condition的await()等待，signal()唤醒，可实现精准通知。
3. LockSupport的park()等待，unpark唤醒。

1.3 为什么要使用LockSupport

• 使用Object缺点：

1. Object类中的wait()，notify()，notifyAll()用于线程的等待唤醒，都必须在synchronized内部中执行，否则会抛出异常Exception in thread “Thread-0” Exception in thread “Thread-1” java.lang.IllegalMonitorStateException。
2. 唤醒后等待会导致线程一致阻塞。

public class ObjectWaitNotify {
    static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\tcome in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"\t被唤醒");
            }
        }).start();

        new Thread(()->{
            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"\t通知");
            }
        }).start();
    }
    /**
     * 正常执行：
     * Thread-0	come in
     * Thread-1	通知
     * Thread-0	被唤醒
     *
     * 去除同步代码块(synchronized)之后：Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
     *
     * 先通知后等待:线程永久阻塞无法唤醒
     * Thread-1	通知
     * Thread-0	come in
     */
}

• 使用Codition的缺点：

3. Condition类await()、signal()和signalAll()用于等待唤醒线程，但是必须放在lock()和unlock()加锁代码块中，否则会出异常：java.lang.IllegalMonitorStateException。
4. 唤醒后等待会导致线程一致阻塞。

public class ConditionAwaitSignal {
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"\tcome in");
                condition.await();
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                lock.unlock();
                System.out.println(Thread.currentThread().getName()+"\t唤醒");
            }
        }).start();

        new Thread(()->{
            try{
                lock.lock();
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"\t通知");
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }).start();
    }
    /**
     * 正常执行:
     * Thread-0	come in
     * Thread-1	通知
     * Thread-0	唤醒
     *
     * 去除加锁之后:java.lang.IllegalMonitorStateException
     *
     * 先通知后等待:线程永久阻塞无法唤醒
     * Thread-1	通知
     * Thread-0	come in
     */
}

• 使用LockSupport优点：

1. LockSupport的使用不需要加到synchronized或lock修饰的同步代码块和同步方法中。LockSupport不用持有锁块，不用加锁，程序性能好。
2. LockSupport可以解决先通知后等待，线程一致阻塞问题。

public class LockSupportParkUnPark {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            try{
                TimeUnit.SECONDS.sleep(3);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"\tcome in");
            // 2.permit为1,所以不阻塞当前线程.permit-1之后放行.
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t唤醒");
        });
        thread.start();

        new Thread(()->{
            // 1.首先执行通知,permit+1(默认permit为0)
            LockSupport.unpark(thread);
            System.out.println(Thread.currentThread().getName()+"\t通知");
        }).start();
    }
}

1.4 核心API

// permit默认是O，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时,park方法会被唤醒，然后会将permit再次设置为O并返回
public static void park(Object blocker) {
    Thread t = Thread.currentThread();
    setBlocker(t, blocker);
    UNSAFE.park(false, 0L);
    setBlocker(t, null);
}
// 调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(permit不可累加，最高为1)
public static void unpark(Thread thread) {
   if (thread != null)
       UNSAFE.unpark(thread);
}

1.5 面试题目

• 为什么可以先唤醒线程后阻塞线程?（唤醒获得凭证，阻塞消耗获取的凭正，所以不会阻塞线程）
• 为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?（凭证最高数量为1，两次唤醒之后，凭证仍然为1。但是阻塞两次需要获取两次凭证，所以还会阻塞线程）

2.AQS

AQS执行流程脑图地址