1.LockSupport語義

閱讀jdk并發(fā)同步包java.util.concurrent源碼，發(fā)現一個重要的工具類java.util.concurrent.locks.LockSupport， 其類結構如下：

LockSupport類結構圖.png

LockSupport類實現的private的構造方法，因此無法實例化，只能調用其靜態(tài)方法，里面有很多方法，核心內容只有兩點：

• 第一、park或park前綴的方法，表示阻塞線程，同Object類的wait方法。
• 第二、unpark方法，表示喚醒線程，同Object類的notify方法。

2.LockSupport和Object對比

雖說功能上與wait和notify相似，比如都是成對出現，有一個地方調用wait阻塞線程，就有另一個地方調用notify或notifyAll喚醒線程，但是用法上卻大相徑庭。主要體現在如下三點點：

• 第一、語義上wait和notify必須在同步塊中使用，而LockSupport沒有這樣的要求。
• 第二、執(zhí)行順序上wait和notify有先后順序的差別，比如先notify后wait，那么該線程將永遠被阻塞，而LockSupport卻無此限制，釋放-阻塞 和 阻塞-釋放語義相同。

首先驗證第一點：

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t finished...");
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        obj.notify();
    }
}

運行結果如下，很明顯運行異常，java不允許在非同步塊中使用wait和notify

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
t start...
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at sw.melody.concurrent.WaitNotifyAndLockSupport.lambda$main$0(WaitNotifyAndLockSupport.java:15)
at java.lang.Thread.run(Thread.java:748)
Exception in thread "main" java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at sw.melody.concurrent.WaitNotifyAndLockSupport.main(WaitNotifyAndLockSupport.java:30)

修正后：

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            synchronized (obj) {
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("t finished...");
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main Thread sleep 3 s");
        synchronized (obj) {
            obj.notify();
        }
    }
}

運行結果如下，程序按照符合預期。

t start...
main Thread sleep 3 s
t finished...

驗證第二點，執(zhí)行順序的差別

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            synchronized (obj) {
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("t finished...");
        });
        t.start();
        synchronized (obj) {
            obj.notify();
        }
    }
}

執(zhí)行后，很可能是main線程先于t線程執(zhí)行完成，先調用了notify方法，這樣t線程執(zhí)行后又wait阻塞，那么t線程將永遠無法喚醒。相比與LockSupport，卻仍然能夠實現同步-喚醒語義。

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            LockSupport.park();
            System.out.println("t finished...");
        });
        t.start();
        LockSupport.unpark(t);
    }
}

使用LockSupport后，t線程無論如何都能被喚醒，完成t線程的任務。
總結來說，wait和notify需要共同的同步對象，先阻塞再喚醒，而LockSupport解耦了同步對象和線程的關系，不需要擔心阻塞和喚醒的先后順序。

3. LockSupport原理

park方法引用native方法，核心是利用_counter整形變量表示線程的狀態(tài)，park方法調用時將_counter=0，unpark調用時_counter=1，如果unpark方法先于park方法調用，_counter的值為1，代表unpark方法已經調用過了，再調用park方法時直接返回了。另外，_counter方法時賦值，不是累加，所以先調用兩次unpark方法和調用一次unpark方法，再調用一次park方法，兩者的效果是一樣。同樣，先調用兩次unpark方法、再調用兩次park方法，線程仍然阻塞，并不會喚醒。

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            LockSupport.park();
            System.out.println("t finished...");
        });
        t.start();
        LockSupport.unpark(t);
        LockSupport.unpark(t);
    }
}

運行結果如下，線程t被喚醒，執(zhí)行完成后，退出主線程。

t start...
t finished...

public class WaitNotifyAndLockSupport {
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("t start...");
            LockSupport.park();
            LockSupport.park();
            System.out.println("t finished...");
        });
        t.start();
        LockSupport.unpark(t);
        LockSupport.unpark(t);
    }
}

運行結果如下，線程t阻塞，沒有執(zhí)行到最后。

t start...