Java8并发包之--线程阻塞唤醒工具类LockSupport

1.LockSupport语义

阅读jdk并发同步包java.util.concurrent源码，发现一个重要的工具类java.util.concurrent.locks.LockSupport， 其类结构如下：

LockSupport类结构图.png

LockSupport类实现的private的构造方法，因此无法实例化，只能调用其静态方法，里面有很多方法，核心内容只有两点：

• 第一、park或park前缀的方法，表示阻塞线程，同Object类的wait方法。
• 第二、unpark方法，表示唤醒线程，同Object类的notify方法。

2.LockSupport和Object对比

虽说功能上与wait和notify相似，比如都是成对出现，有一个地方调用wait阻塞线程，就有另一个地方调用notify或notifyAll唤醒线程，但是用法上却大相径庭。主要体现在如下三点点：

• 第一、语义上wait和notify必须在同步块中使用，而LockSupport没有这样的要求。
• 第二、执行顺序上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...

验证第二点，执行顺序的差别

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();
        }
    }
}

执行后，很可能是main线程先于t线程执行完成，先调用了notify方法，这样t线程执行后又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整形变量表示线程的状态，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被唤醒，执行完成后，退出主线程。

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阻塞，没有执行到最后。

t start...