LockSupport

1、簡單 

在沒有LockSupport以前，線程的掛起和喚醒我們都是經過Object的wait和notify/notifyAll方法實現。

寫一段例子代碼，線程A執行一段業務邏輯後調用wait阻塞住本身。主線程調用notify方法喚醒線程A，線程A而後打印本身執行的結果。

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        final Object obj = new Object();
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i=0;i<10;i++){
                    sum+=i;
                }
                try {
                    obj.wait();
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(sum);
            }
        });
        A.start();
        //睡眠一秒鐘，保證線程A已經計算完成，阻塞在wait方法
        Thread.sleep(1000);
        obj.notify();
    }
}

執行這段代碼，不難發現這個錯誤：

Exception in thread "main" java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)

緣由很簡單，wait和notify/notifyAll方法只能在同步代碼塊裏用(這個有的面試官也會考察)。因此將代碼修改成以下就可正常運行了：

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        final Object obj = new Object();
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i=0;i<10;i++){
                    sum+=i;
                }
                try {
                    synchronized (obj){
                        obj.wait();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(sum);
            }
        });
        A.start();
        //睡眠一秒鐘，保證線程A已經計算完成，阻塞在wait方法
        Thread.sleep(1000);
        synchronized (obj){
            obj.notify();
        }
    }
}

那若是換成LockSupport呢？簡單得很，看代碼：

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i=0;i<10;i++){
                    sum+=i;
                }
                LockSupport.park();
                System.out.println(sum);
            }
        });
        A.start();
        //睡眠一秒鐘，保證線程A已經計算完成，阻塞在wait方法
        Thread.sleep(1000);
        LockSupport.unpark(A);
    }
}

直接調用就能夠了，沒有說非得在同步代碼塊裏才能用。簡單吧。

2、靈活

若是隻是LockSupport在使用起來比Object的wait/notify簡單，那還真不必專門講解下LockSupport。最主要的是靈活性。

上邊的例子代碼中，主線程調用了Thread.sleep(1000)方法來等待線程A計算完成進入wait狀態。若是去掉Thread.sleep()調用，代碼以下：

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        final Object obj = new Object();
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i=0;i<10;i++){
                    sum+=i;
                }
                try {
                    synchronized (obj){
                        obj.wait();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(sum);
            }
        });
        A.start();
        //睡眠一秒鐘，保證線程A已經計算完成，阻塞在wait方法
        //Thread.sleep(1000);
        synchronized (obj){
            obj.notify();
        }
    }
}

多運行幾回上邊的代碼，有的時候可以正常打印結果並退出程序，但有的時候線程沒法打印結果阻塞住了。緣由就在於：主線程調用完notify後，線程A才進入wait方法，致使線程A一直阻塞住。因爲線程A不是後臺線程，因此整個程序沒法退出。

那若是換作LockSupport呢？LockSupport就支持主線程先調用unpark後，線程A再調用park而不被阻塞嗎？是的，沒錯。代碼以下：

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        final Object obj = new Object();
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i=0;i<10;i++){
                    sum+=i;
                }
                LockSupport.park();
                System.out.println(sum);
            }
        });
        A.start();
        //睡眠一秒鐘，保證線程A已經計算完成，阻塞在wait方法
        //Thread.sleep(1000);
        LockSupport.unpark(A);
    }
}

無論你執行多少次，這段代碼都能正常打印結果並退出。這就是LockSupport最大的靈活所在。

總結一下，LockSupport比Object的wait/notify有兩大優點：

①LockSupport不須要在同步代碼塊裏 。因此線程間也不須要維護一個共享的同步對象了，實現了線程間的解耦。

②unpark函數能夠先於park調用，因此不須要擔憂線程間的執行的前後順序。

3、應用普遍

LockSupport在Java的工具類用應用很普遍，我們這裏找幾個例子感覺感覺。以Java裏最經常使用的類ThreadPoolExecutor爲例。先看以下代碼：

public class TestObjWait {

    public static void main(String[] args)throws Exception {
        ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(1000);
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5,5,1000, TimeUnit.SECONDS,queue);

        Future<String> future = poolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                TimeUnit.SECONDS.sleep(5);
                return "hello";
            }
        });
        String result = future.get();
        System.out.println(result);
    }
}

 代碼中咱們向線程池中扔了一個任務，而後調用Future的get方法，同步阻塞等待線程池的執行結果。

這裏就要問了：get方法是如何組塞住當前線程？線程池執行完任務後又是如何喚醒線程的呢？

我們跟着源碼一步步分析，先看線程池的submit方法的實現：

在submit方法裏，線程池將咱們提交的基於Callable實現的任務，封裝爲基於RunnableFuture實現的任務，而後將任務提交到線程池執行，並向當前線程返回RunnableFutrue。

進入newTaskFor方法，就一句話：return new FutureTask<T>(callable);

因此，我們主線程調用future的get方法就是FutureTask的get方法，線程池執行的任務對象也是FutureTask的實例。

接下來看看FutureTask的get方法的實現：

比較簡單，就是判斷下當前任務是否執行完畢，若是執行完畢直接返回任務結果，不然進入awaitDone方法阻塞等待。

awaitDone方法裏，首先會用到上節講到的cas操做，將線程封裝爲WaitNode，保持下來，以供後續喚醒線程時用。再就是調用了LockSupport的park/parkNanos組塞住當前線程。

上邊已經說完了阻塞等待任務結果的邏輯，接下來再看看線程池執行完任務，喚醒等待線程的邏輯實現。

前邊說了，我們提交的基於Callable實現的任務，已經被封裝爲FutureTask任務提交給了線程池執行，任務的執行就是FutureTask的run方法執行。以下是FutureTask的run方法：

c.call()就是執行咱們提交的任務，任務執行完後調用了set方法，進入set方法發現set方法調用了finishCompletion方法，想必喚醒線程的工做就在這裏邊了，看看代碼實現吧：

沒錯就在這裏邊，先是經過cas操做將全部等待的線程拿出來，而後便使用LockSupport的unpark喚醒每一個線程。

在使用線程池的過程當中，不知道你有沒有這麼一個疑問：線程池裏沒有任務時，線程池裏的線程在幹嗎呢？

看過個人這篇文章《線程池的工做原理與源碼解讀》的讀者必定知道，線程會調用隊列的take方法阻塞等待新任務。那隊列的take方法是否是也跟Future的get方法實現同樣呢？我們來看看源碼實現。

以ArrayBlockingQueue爲例，take方法實現以下：

與想象的有點出入，他是使用了Lock的Condition的await方法實現線程阻塞。但當咱們繼續追下去進入await方法，發現仍是使用了LockSupport：