1.LockSupport语义
阅读jdk并发同步包java.util.concurrent源码，发现一个重要的工具类java.util.concurrent.locks.LockSupport， 其类结构如下：
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...
