LockSupport详解

1、LockSupport简介

LockSupport 是 Java 并发包（java.util.concurrent）中的一个工具类，提供了基本的线程阻塞和唤醒机制。它主要用于实现锁和其他同步类，如AQS、 ReentrantLock、Semaphore、CountDownLatch 等。

LockSupport 提供的主要方法是 park 和 unpark，它们分别用于挂起和唤醒线程(LockSupport.park()会让线程进入WATING状态)。 AQS中对线程进行挂起和唤醒操作最终使用的就是LockSupport.park(xxx);和LockSupport.unpark(xxx)。 AQS相关内容可以参考 我的上一篇博客 AQS详解。

LockSupport 类的构造方法

// 构造方法是私有的，意味着LockSupport类不能被实例化。
// 这个设计表明LockSupport类只是一个工具类，提供静态方法供外部调用。
private LockSupport() {}

LockSupport 类的属性

// 这个静态常量持有一个Unsafe类的实例。Unsafe类提供了一些底层操作的能力。
// 如直接内存访问、CAS操作等。由于其强大的功能和潜在的危险性，Unsafe类的使用受到严格限制，通常只在JDK内部使用。
private static final sun.misc.Unsafe UNSAFE;//parkBlockerOffset常量保存了Thread类中parkBlocker字段的内存偏移量。parkBlocker字段用于记录调用park方法时的阻塞对象。
private static final long parkBlockerOffset;
// 这些静态常量分别保存了Thread类中
// threadLocalRandomSeed
// threadLocalRandomProbe
// threadLocalRandomSecondarySeed字段的内存偏移量。
private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;static {try {// 获取 Unsafe 实例UNSAFE = sun.misc.Unsafe.getUnsafe();// 获取 Thread 类的相关字段的偏移量Class<?> tk = Thread.class;// 获取 parkBlocker 字段的偏移量parkBlockerOffset = UNSAFE.objectFieldOffset(tk.getDeclaredField("parkBlocker"));// 获取 threadLocalRandomSeed 字段的偏移量SEED = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSeed"));// 获取 threadLocalRandomProbe 字段的偏移量PROBE = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomProbe"));// 获取 threadLocalRandomSecondarySeed 字段的偏移量SECONDARY = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSecondarySeed"));} catch (Exception ex) {throw new Error(ex);}
}

总结：
LockSupport类提供了线程阻塞和唤醒的基础设施，通过使用Unsafe类进行底层内存操作来实现。其核心是利用park和unpark方法来管理线程的状态，确保并发编程中的高效和安全。
通过获取Thread类中关键字段的偏移量，LockSupport类能够直接操作这些字段，实现对线程状态的控制。
关于sun.misc.Unsafe UNSAFE类，后续再另写一篇博客分析。

Thread类的parkBlocker属性

volatile Object parkBlocker;

Thread类的parkBlocker属性是一个volatile的Object类型变量，用于记录线程在调用LockSupport.park(Object blocker)时被阻塞的原因或对象。通过parkBlocker，我们可以在调试或分析时更容易地了解线程的阻塞原因。这种设计有助于提高并发编程的可调试性和可维护性。

比如有一个锁对象，线程在获取锁时被阻塞，可以通过parkBlocker记录这个锁对象，以便在调试或分析时知道线程因为什么原因被阻塞。

为啥这样设计呢？
因为在JDK1.5的时候 LockSupport 没设计Thread 类的parkBlocker来记录阻塞信息，这导致分析线程变得困难。所以1.6加入了这个特性。 此外虽然 synchronized 本身不支持像 parkBlocker 这样的灵活机制但是在 JVM 内部，synchronized 会记录阻塞线程的锁对象，这也有利于调试。

下面的park(Object blocker)方法就是这么用的。

LockSupport 类的常用方法

挂起线程的相关方法

①、park(Object blocker)方法：
挂起当前线程，并设置阻塞对象。阻塞对象通常用于调试或监视线程状态。挂起结束后清除阻塞对象。

public static void park(Object blocker) {// 获取当前线程Thread t = Thread.currentThread();// 设置阻塞对象setBlocker(t, blocker);// 挂起当前线程UNSAFE.park(false, 0L);// 注意： (这里因为上面的  UNSAFE.park(false, 0L) 会让线程挂起)  // 当线程被唤醒的时候必须要清除唤醒线程的blocker对象 或者下面直接跟了setBlocker(t, null); // 这就保证了当线程被唤醒之后能够确保清除唤醒线程的blocker对象// 挂起结束后清除阻塞对象 setBlocker(t, null);
}// 通过 UNSAFE.putObject 方法将阻塞对象 arg 设置到线程 t 中的 parkBlocker 字段中。
private static void setBlocker(Thread t, Object arg) {UNSAFE.putObject(t, parkBlockerOffset, arg);
}// park 方法是一个本地方法，具体实现依赖于底层操作系统
public native void park(boolean isAbsolute, long time);

②、parkNanos(Object blocker, long nanos)方法：
挂起当前线程指定的纳秒数，并设置阻塞对象。挂起结束后清除阻塞对象。

public static void parkNanos(Object blocker, long nanos) {if (nanos > 0) {// 获取当前线程Thread t = Thread.currentThread();// 设置阻塞对象setBlocker(t, blocker);// 挂起当前线程指定的纳秒数UNSAFE.park(false, nanos);// 挂起结束后清除阻塞对象setBlocker(t, null);}
}

③、parkUntil(Object blocker, long deadline)方法：
挂起当前线程直到指定的时间，并设置阻塞对象。挂起结束后清除阻塞对象。

public static void parkUntil(Object blocker, long deadline) {// 获取当前线程Thread t = Thread.currentThread();// 设置阻塞对象setBlocker(t, blocker);// 挂起当前线程直到指定的时间UNSAFE.park(true, deadline);// 挂起结束后清除阻塞对象setBlocker(t, null);
}

④、park()方法：
挂起当前线程，直到其他线程调用unpark或线程被中断。

public static void park() {// 挂起当前线程UNSAFE.park(false, 0L);
}

⑤、parkNanos(long nanos)方法：
挂起当前线程指定的纳秒数。

public static void parkNanos(long nanos) {if (nanos > 0) {// 挂起当前线程指定的纳秒数UNSAFE.park(false, nanos);}
}

⑥、parkUntil(long deadline)方法：
挂起当前线程直到指定的时间。

public static void parkUntil(long deadline) {// 挂起当前线程直到指定的时间UNSAFE.park(true, deadline);
}

唤醒线程的相关方法

unpark(Thread thread)方法：
unpark方法用于唤醒被park方法挂起的线程。

public static void unpark(Thread thread) {// 检查传入的线程是否为 nullif (thread != null) {// 使用 UNSAFE 类的 unpark 方法唤醒指定的线程UNSAFE.unpark(thread);}
}

unpark(Thread thread)方法注意点

这个方法上注释有一句话：
This operation is not guaranteed to have any effect at all if the given thread has not been started.
意思是：如果给定的线程尚未启动(也就是线程调用start方法之前的状态)，则无法保证此操作有效。

比如对一个处于NEW状态的线程 调用unpark，再让线程start，当线程处于RUNNABLE状态后再调用park方法，那么这个线程可能会被挂起。也就是 unpark方法不一定生效。

这里先留个印象，下面第2节 分析 LockSupport原理 还会提到。

看下面的例子：

import java.util.concurrent.locks.LockSupport;public class TestA {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// ③、t1此时的状态是 RUNNABLE ,再 park t1线程LockSupport.park();  // 可能会阻塞  因为 unpark方法不保证 对未启动的线程生效System.out.println("123");}, "t1");// ①、先 unpark  NEW状态的 线程 t1LockSupport.unpark(t1);// ②、启动 t1线程t1.start();}
}

上面代码, t1线程尚未启动(也就是线程调用start方法之前的状态) LockSupport.unpark(t1) 未生效。

LockSupport使用示例

利用LockSupport，实现线程间通信，交替打印 牛 马 人

import java.util.concurrent.locks.LockSupport;public class TestA {// t1负责打印牛// t2负责打印马// t3负责打印人private static Thread t1, t2, t3;// 控制打印顺序的状态变量 0表示执行t1 唤醒t2// 控制打印顺序的状态变量 1表示执行t2 唤醒t3// 控制打印顺序的状态变量 2表示执行t3 唤醒t1private static volatile int state = 0;public static void main(String[] args) {t1 = new Thread(() -> {for (int i = 0; i < 3; ++i) {while (state != 0) {LockSupport.park(); // 挂起 t1 线程，直到被唤醒}System.out.print("牛 ");state = 1; // 设置为 1，表示下一个打印马LockSupport.unpark(t2); // 唤醒 t2}});t2 = new Thread(() -> {for (int i = 0; i < 3; ++i) {while (state != 1) {LockSupport.park(); // 挂起 t2 线程，直到被唤醒}System.out.print("马 ");state = 2; // 设置为 2，表示下一个打印人LockSupport.unpark(t3); // 唤醒 t3}});t3 = new Thread(() -> {for (int i = 0; i < 3; ++i) {while (state != 2) {LockSupport.park(); // 挂起 t3 线程，直到被唤醒}System.out.print("人 ");state = 0; // 设置为 0，表示下一个打印牛LockSupport.unpark(t1); // 唤醒 t1}});t1.start();t2.start();t3.start();}
}

运行结果：

牛 马 人 牛 马 人 牛 马 人 

判断park的条件建议使用while而不是if

LockSupport源码中注释也是这么建议的：

while (!canProceed()) { ... LockSupport.park(this); }

为什么这么用呢？
如果使用 if 条件，线程被唤醒后只检查一次条件。如果是条件不满足的唤醒，但线程已经继续执行，这会导致错误的行为。
而while 循环在每次被唤醒时都会重新检查条件。如果条件仍然不满足，线程会继续等待。这确保了线程在条件未满足时不会继续执行。

比如上面打印牛马人示例中：

new Thread(() -> {for (int i = 0; i < 3; ++i) {while (state != 2) {  // 这里的while 换成两次if也可以LockSupport.park(); // 挂起 t3 线程，直到被唤醒}System.out.print("人 ");state = 0; // 设置为 0，表示下一个打印牛LockSupport.unpark(t1); // 唤醒 t1}
});// 上代码可以用下面代码替换   因为条件比较简单 
new Thread(() -> {for (int i = 0; i < 3; ++i) {if (state != 2) {LockSupport.park(); // 挂起 t3 线程，直到被唤醒}if (state == 2) {System.out.print("人 ");state = 0; // 设置为 0，表示下一个打印牛LockSupport.unpark(t1); // 唤醒 t1}else {LockSupport.park();}}});

明显可以看出，使用while更加简洁明了。 实际上即使是很简单的state != 2 的条件用if看着也很臃肿了，如果条件比较复杂就更不推荐多个if检查条件了，会让代码变得臃肿且难以理解和维护。

引出Guarded Suspension模式

在《图解Java多线程设计模式》这本书中第82页就有介绍这个模式。下面引用一下原书的内容。

Guarded是被守护、被保卫、被保护的意思Suspension则是“暂停”的意思。如果执行现在的处理会造成问题，就让执行处理的线程进行等待–这就是 Guarded Suspension 模式。

当你正在家换衣服时，门铃突然响了，原来是邮递员来送邮件了。这时，因为正在换衣服出不去，所以只能先喊道“请稍等一下”，让邮递员在门口稍等一会儿。换好衣服后，才说着“让您久等了”并打开门。

这个例子很日式呀，让您久等了~ 因为这本书作者就是日本人 。 非常推荐大家看看这本书《图解Java多线程设计模式》 。

再拿上面打印牛马人的例子说明一下问题，其中利用 while来判断park条件 就是为了保证线程只打印该打印的东西，不该打印的时候就挂起。

总结

LockSupport类提供了多种挂起线程的方法，主要是通过Unsafe类的park方法实现。挂起线程的方法分为带阻塞对象的和不带阻塞对象的，带阻塞对象的方法在挂起线程时会记录阻塞的原因或对象，以便调试和监视。每种方法还支持不同的挂起时长，包括无限期挂起、挂起指定的纳秒数和挂起直到某个时间点。通过这些方法，LockSupport类为高级并发控制提供了基础设施。比如AQS以及依赖AQS为基础实现的锁或者同步器，最终都是通过LockSupport提供的park和unpark实现的线程挂起和唤醒。

2、LockSupport原理分析

先思考一个问题
看下面代码：

import java.util.concurrent.locks.LockSupport;public class TestA {public static void main(String[] args) throws InterruptedException {LockSupport.unpark(Thread.currentThread());LockSupport.park();System.out.println("LockSupport  先unpark 后park");TestA testA = new TestA();synchronized (testA) {testA.notify();testA.wait();System.out.println("synchronized  先notify 后wait");}}
}

运行结果：

根据代码执行的结果可以看出：
代码调用 LockSupport.unpark 来唤醒当前线程。即使当前线程没有被阻塞，这个操作也会起作用。
当前线程已经调用过一次 LockSupport.unpark 后，再调用 LockSupport.park()就不会被阻塞了，因为已经提前唤醒了一次。

而synchronized 同步代码块中 先调用 notify没有任何作用，因为没有线程在 testA锁对象 上等待。
当前线程已经调用过一次 testA.notify(); 后，再调用 testA.wait(); 线程仍然会被阻塞。

总结：
LockSupport 提供了更灵活的阻塞和唤醒机制，能够在任何时候调用 unpark 而不必担心线程是否已经阻塞。

下面这段内容来自Java官方的JDK1.6中文版文档。
（如果英语掌握的很好，还是推荐自己去阅读源码上的英文注释比较好，虽然下面是官方的JDK1.6中文版文档，但是翻译的还是比较生硬~）

用来创建锁和其他同步类的基本线程阻塞原语。 此类以及每个使用它的线程与一个许可关联（从 Semaphore 类的意义上说）。如果该许可可用，并且可在进程中使用，则调用 park 将立即返     
回；否则可能 阻塞。如果许可尚不可用，则可以调用 unpark 使其可用。（但与 Semaphore 不同的是，许可不能累积，并且最多只能有一个    
许可。） park 和 unpark 方法提供了阻塞和解除阻塞线程的有效方法，并且不会遇到导致过时方法 Thread.suspend 和 Thread.resume 因为以  
下目的变得不可用的问题：由于许可的存在，调用 park 的线程和另一个试图将其 unpark 的线程之间的竞争将保持活性。此外，如果调用者线  
程被中断，并且支持超时，则 park 将返回。park 方法还可以在其他任何时间“毫无理由”地返回，因此通常必须在重新检查返回条件的循环里  
调用此方法。从这个意义上说，park 是“忙碌等待”的一种优化，它不会浪费这么多的时间进行自旋，但是必须将它与 unpark 配对使用才更高  
效。   三种形式的 park 还各自支持一个 blocker 对象参数。此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。  
（这样的工具可以使用方法 getBlocker(java.lang.Thread) 访问 blocker。）建议最好使用这些形式，而不是不带此参数的原始形式。  
在锁实现中提供的作为 blocker 的普通参数是 this。   这些方法被设计用来作为创建高级同步实用工具的工具，对于大多数并发控制应用程序而言，它们本身并不是很有用。park 方法仅设计用于以下  
形式的构造： while (!canProceed()) { ... LockSupport.park(this); }在这里，在调用 park 之前，canProceed 和其他任何动作都不会锁定  
或阻塞。因为每个线程只与一个许可关联，park 的任何中间使用都可能干扰其预期效果。 示例用法。 以下是一个先进先出 (first-in-first-out) 非重入锁类的框架。 class FIFOMutex {private final AtomicBoolean locked = new AtomicBoolean(false);private final Queue<Thread> waiters= new ConcurrentLinkedQueue<Thread>();public void lock() {boolean wasInterrupted = false;Thread current = Thread.currentThread();waiters.add(current);// Block while not first in queue or cannot acquire lockwhile (waiters.peek() != current ||!locked.compareAndSet(false, true)) {LockSupport.park(this);if (Thread.interrupted()) // ignore interrupts while waitingwasInterrupted = true;}waiters.remove();if (wasInterrupted)          // reassert interrupt status on exitcurrent.interrupt();}public void unlock() {locked.set(false);LockSupport.unpark(waiters.peek());}}

总结下LockSupport类设计思路的关键点：

• ①、许可机制： LockSupport通过一个许可的概念来控制线程的阻塞和恢复。这个许可类似于Semaphore中的许可，但需要注意的是它不支持累积，即最多只有一个许可可用。这意味着即使多次调用unpark也只会保留一个许可。

• ②、阻塞操作： LockSupport.park()方法会尝试获取许可。如果许可存在，线程会立即返回并继续执行。如果没有许可，线程将被阻塞，直到另一个线程调用LockSupport.unpark(Thread)方法来释放许可，或者线程接收到中断信号。

• ③、非累积性： 与Semaphore不同，LockSupport的许可不能累积。这意味着即使一个线程被多次unpark，它也只能被唤醒一次，多余的unpark操作不会产生额外的效果。
  例如：

import java.util.concurrent.locks.LockSupport;public class TestA {public static void main(String[] args) {// unpark 主线程两次LockSupport.unpark(Thread.currentThread());LockSupport.unpark(Thread.currentThread());// park主线程两次LockSupport.park();System.out.println("park第一次");  // 正常打印LockSupport.park();   // 在这就会阻塞System.out.println("park第二次"); // 不打印}
}

• ④线程关联： 每个线程都有一个与之关联的LockSupport许可。当一个线程调用unpark时，它必须指定要唤醒的线程。这允许了更细粒度的控制，因为可以精确地选择哪个线程应该被唤醒。

• ⑤、中断处理： 当一个线程被阻塞时，它可以被中断。LockSupport.park()会检查中断状态，并在检测到中断时抛出InterruptedException。这使得LockSupport可以安全地与其他Java中断机制协同工作。

至于再底层的实现就是通过Unsafe类，以及操作系统提供的原语了。
例如，在 Linux 上，LockSupport 可能会利用 pthread 库中的 pthread_mutex_lock 和 pthread_cond_wait 等函数来实现这些功能。这里就不再细说了，水平有限~

3、park\unpark VS wait\notify\sleep\await\singnal

直接列个表格简单直观：

方法	描述	对比
park/unpark	park 阻塞当前线程，直到被 unpark 唤醒。unpark 唤醒指定线程。	直接操作线程，不依赖锁或条件。 可以在非同步块中使用。 提供更细粒度的控制。 park 可以指定阻塞时间。 可以先 unpark 再 park 由于park不依赖于锁或者其他条件，所以如果一个线程持有锁，调用了park，那么该线程挂起后并不会释放锁
wait/notify	wait 使当前线程等待，直到被 notify 或 notifyAll 唤醒。	需要在synchronized同步代码块中使用。 wait 会释放持有的对象锁。 notify 唤醒单个等待线程，notifyAll 唤醒所有等待线程。 notify 在wait之前调用没有效果
sleep	使当前线程休眠指定时间。	不释放锁。 主要用于时间控制。 休眠时间结束后自动恢复。
await/signal	用于 Condition 对象上的线程等待和唤醒。	必须在锁条件下使用。 await 会释放锁并进入等待状态，直到被 signal 或 signalAll 唤醒。 用于更复杂的同步需求。