LockSupport 深度解析

原文：CSDN（历史文章导入，当前状态为草稿）

1. 引言：为什么需要 LockSupport？

在 Java 的并发世界中，线程同步是保证数据一致性和程序正确性的核心。
我们熟悉的 synchronized 关键字和 Object 类提供的 wait(), notify(), notifyAll() 方法，是 Java 内建的线程同步和通信机制。然而，它们在使用上存在一些固有的限制和不便之处：

1. 强依赖 synchronized: wait/notify/notifyAll 必须在 synchronized 同步块或方法内部调用，这意味着线程在等待或唤醒前，必须先获取对象的监视器锁（Monitor Lock）。这增加了编码的复杂性，并且将线程的等待/唤醒与锁的获取/释放紧密耦合。
2. 唤醒目标不精确: notify() 方法只能随机唤醒一个在该对象监视器上等待的线程，开发者无法指定唤醒哪个线程。notifyAll() 虽然能唤醒所有等待线程，但这可能导致“惊群效应”（Thundering Herd），大量线程被唤醒后争抢同一个锁，造成不必要的性能开销。
3. 可能丢失的信号: 如果 notify() 在 wait() 之前被调用，那么 wait() 的线程将永远无法被唤醒，因为它错过了那个通知信号。这要求开发者必须小心翼翼地控制 wait 和 notify 的调用顺序，并通常需要在循环中检查条件变量，以处理所谓的“信号丢失”和“虚假唤醒”问题。
4. 繁琐的范式: 正确使用 wait/notify 需要遵循固定的范式（通常是 while(condition) { obj.wait(); }），忘记检查条件或错误处理中断都可能导致程序错误。

为了克服这些限制，提供更灵活、更底层、更精确的线程阻塞和唤醒原语，Java 并发包（JUC，java.util.concurrent）引入了 LockSupport 工具类。

什么是 LockSupport？

LockSupport 是 JUC 包中的一个核心工具类（位于 java.util.concurrent.locks 包下），它提供了一组静态方法，用于 阻塞（Parking） 和 唤醒（Unparking） 线程，而无需持有任何锁。它像是线程的一个“停车许可证”（Permit），线程可以通过 park() 方法“停车”（阻塞自己），而其他线程可以通过 unpark(Thread t) 方法发放“许可证”（唤醒指定线程）。

LockSupport 的核心作用：

• 提供基础的线程阻塞/唤醒原语: 它是构建更高级同步组件（如 ReentrantLock, Semaphore, CountDownLatch, FutureTask 等）的底层基石。AQS (AbstractQueuedSynchronizer) 框架就严重依赖 LockSupport 来管理等待线程的阻塞与唤醒。
• 解耦锁与等待/唤醒: park/unpark 操作不依赖于对象锁，可以在任何代码位置调用，极大简化了某些并发场景的设计。
• 精确唤醒: unpark(Thread thread) 可以精确地唤醒指定的目标线程，避免了 notify() 的随机性。
• 解决信号丢失: LockSupport 的设计允许 unpark 先于 park 调用。即使目标线程尚未 park，unpark 也会为其发放一个“许可证”，当该线程后续调用 park 时，会消耗这个许可证并立即返回，不会阻塞。

虽然我们可能不会频繁地直接使用 LockSupport 来编写业务代码（通常我们会使用更高级的 ReentrantLock, Semaphore 等），但理解 LockSupport 的原理和机制，对于深入掌握 JUC 并发组件的工作方式、排查并发问题以及设计自定义同步器都至关重要。它揭示了 JUC 如何在 JVM 和操作系统层面实现高效、灵活的线程调度。

2. 核心概念：许可证（Permit）机制

LockSupport 的核心在于其 许可证（Permit） 机制。可以将其理解为与每个线程关联的一个 二值信号量（Binary Semaphore），也就是说，这个许可证只有两种状态：存在（值为 1） 或 不存在（值为 0）。

关键特性：

1. 线程私有: 每个线程都拥有自己独立的许可证，线程之间的许可证互不干扰。
2. 状态简单: 许可证只有 0 和 1 两种状态，不能累积。这意味着连续多次调用 unpark 和调用一次的效果是完全相同的。
3. 初始状态: 线程刚创建时，其许可证的初始状态为 0（不存在）。

许可证与 park/unpark 的交互：

• park() 方法: 当一个线程调用 LockSupport.park() 时：
  • 它会检查自己当前是否持有许可证（即许可证值是否为 1）。
  • 如果持有许可证（值为 1）：线程会消耗掉这个许可证（将其值设置为 0），然后立即返回，不会阻塞。
  • 如果不持有许可证（值为 0）：线程会被阻塞，进入等待状态，直到其他线程对其调用 unpark 或发生中断。
• unpark(Thread thread) 方法: 当一个线程调用 LockSupport.unpark(targetThread) 时：
  • 它会尝试给目标线程 targetThread 发放一个许可证。
  • 如果目标线程的许可证已经是 1：unpark 操作不会有任何效果，许可证的值依然是 1（不会累加）。
  • 如果目标线程的许可证是 0：unpark 会将目标线程的许可证设置为 1。
  • 唤醒检查: 如果目标线程当前正因为调用 park 而处于阻塞状态，那么这次 unpark 操作会唤醒它。如果目标线程并未阻塞，那么这次 unpark 只是单纯地将许可证设置为 1，供其后续 park 时使用。

理解帮助：许可证就像一个通行令牌

想象一下，每个线程都有一个存放通行令牌的“口袋”，但这个口袋最多只能放一个令牌。

• park() 就像是线程尝试通过一个关卡。
  • 如果口袋里有令牌，线程就交出令牌，顺利通过关卡（不阻塞）。
  • 如果口袋里没令牌，线程就必须在关卡前排队等待（阻塞）。
• unpark(thread) 就像是另一个线程给 thread 的口袋里放一个令牌。
  • 如果口袋已经是满的（有一个令牌了），再放也还是一个（不能累积）。
  • 如果口袋是空的，就放进去一个令牌。
  • 如果 thread 正好在关卡前排队等待，放入令牌后，它就能拿起令牌通过关卡（被唤醒）。

关键优势：解决信号丢失问题（先 unpark 后 park）

这个许可证机制最巧妙的地方在于它允许 unpark 先于 park 调用。

• 如果线程 A 调用 unpark(threadB)，而线程 B 此时尚未调用 park()。
• unpark 会将线程 B 的许可证设置为 1。
• 随后，当线程 B 调用 park() 时，它会发现自己持有许可证 (值为 1)。
• 于是，线程 B 消耗掉这个许可证 (设置为 0)，并立即从 park() 返回，完全不会阻塞。

这与 wait/notify 机制形成了鲜明对比。如果 notify 在 wait 之前调用，wait 将永远等待。而 LockSupport 的许可证机制像是在线程中“预存”了一个唤醒信号，确保了这个信号不会丢失。这极大地简化了并发编程，尤其是在难以保证 park 和 unpark 调用顺序的复杂场景中。

总结许可证机制：

• 每个线程一个二值 (0/1) 许可证。
• park(): 有证则消耗并返回，无证则阻塞。
• unpark(t): 给线程 t 设置许可证为 1 (如果已经是 1 则不变)，如果 t 正在 park 则唤醒。
• 许可证不能累积，多次 unpark 等同一次。
• 支持先 unpark 后 park，许可证会被“保存”。

理解了这个核心的许可证机制，我们就能更好地掌握 LockSupport 的各个方法。

3. 核心方法详解

LockSupport 提供的方法都是静态的，可以直接通过类名调用。主要可以分为 park 系列（用于阻塞）和 unpark（用于唤醒），以及一个辅助方法 getBlocker。

3.1 park()

public static void park()

• 作用: 阻塞当前线程，除非/直到许可证可用。

• 行为:

  1. 检查当前线程的许可证状态。
  2. 如果许可证可用（值为 1），则消耗许可证（设置为 0）并立即返回。
  3. 如果许可证不可用（值为 0），则 禁用当前线程 以进行线程调度，并使其进入等待状态，直到发生以下情况之一：
     • 其他某个线程调用了针对当前线程的 unpark。
     • 其他某个线程中断了当前线程。
     • 发生“虚假唤醒”（虽然概率极低，但理论上可能）。
  4. 线程被唤醒后，park 方法返回。

• 中断处理:

  • park() 方法响应中断。如果线程在 park 等待期间被中断，它会立即返回。
  • 与 Object.wait() 或 Thread.sleep() 不同，park() 不会抛出 InterruptedException。
  • 但是，线程的中断状态会被设置 (变为 true)。调用者需要手动检查线程的中断状态（例如通过 Thread.currentThread().isInterrupted() 或 Thread.interrupted()）来判断 park 是因为 unpark 返回还是因为中断返回，并进行相应的处理。

• 使用场景: 当线程需要等待某个条件成立，而这个条件由其他线程触发时，可以使用 park() 进入等待。

• 示例:

// 线程 B
LockSupport.park(); // 阻塞线程 B，等待许可证

// 检查是否因中断而返回
if (Thread.currentThread().isInterrupted()) {
    System.out.println("线程 B 被中断了...");
    // 可能需要进行中断处理逻辑，比如清理资源或重新设置中断状态
    // Thread.currentThread().interrupt(); // 如果需要向上传递中断
} else {
    System.out.println("线程 B 被正常唤醒了...");
}


// 线程 A (在某个时刻)
// Thread threadB = ... 获取线程 B 的引用
// LockSupport.unpark(threadB); // 给线程 B 发放许可证，如果 B 正在 park，则唤醒它

3.2 park(Object blocker)

public static void park(Object blocker)

• 作用: 与 park() 基本相同，但在线程阻塞时，额外关联一个 blocker 对象。

• blocker 对象: 这个对象主要用于监控和诊断。当线程被 park(blocker) 阻塞时：

  • 可以通过 getBlocker(Thread t) 方法获取到这个 blocker 对象。
  • 像 JConsole、VisualVM 或 jstack 这样的工具可以显示线程当前被哪个 blocker 对象阻塞，这对于排查死锁或性能瓶颈非常有用。

• 推荐用法: 在实际开发中，特别是编写同步器或框架代码时，推荐使用 park(Object blocker) 而不是无参的 park()。blocker 通常设置为 this（如果是在同步器类内部调用）或其他能标识阻塞原因的对象。

• 示例 (模拟 AQS 中的用法):

// 假设在一个自定义锁的实现中
public class MyLock {
    // ... 其他代码 ...

    public void lock() {
        while (!tryAcquire()) { // 尝试获取锁失败
            // 记录阻塞原因（当前锁对象），然后阻塞
            LockSupport.park(this);
            // 唤醒后，需要检查中断状态
            if (Thread.currentThread().isInterrupted()) {
                // 处理中断，可能需要抛出异常或清理
            }
        }
    }

    public void unlock() {
        if (release()) { // 释放锁成功
            Thread nextThread = findNextWaiter(); // 找到下一个等待线程
            if (nextThread != null) {
                // 使用 unpark 唤醒下一个等待者
                LockSupport.unpark(nextThread);
            }
        }
    }

    // ... tryAcquire, release, findNextWaiter 的实现 ...
}

3.3 unpark(Thread thread)

public static void unpark(Thread thread)

• 作用: 使目标线程 thread 的许可证可用。

• 行为:

  1. 如果 thread 为 null，则不执行任何操作。
  2. 将 thread 的许可证状态设置为 1。
  3. 如果 thread 当前因为调用 park 系列方法而阻塞，则唤醒它。
  4. 如果 thread 没有阻塞，那么下次它调用 park 时会直接消耗这个许可证并返回。

• 关键特性:

  • 精确唤醒: 明确指定要唤醒的线程。
  • 非累积性: 多次调用 unpark 对同一个线程的效果与调用一次相同。
  • 允许先于 park: 可以在目标线程 park 之前调用，许可证会被“寄存”。
  • 空指针安全: 传入 null 不会抛异常。

• 使用场景: 当某个条件满足，需要唤醒一个或多个特定等待线程时使用。这是 LockSupport 实现精确控制的关键。

3.4 parkNanos(long nanos) 和 parkNanos(Object blocker, long nanos)

public static void parkNanos(long nanos)
public static void parkNanos(Object blocker, long nanos)

• 作用: 带超时的 park 版本。阻塞当前线程，最多等待指定的纳秒数 (nanos)。
• 行为:
  • 与 park() / park(blocker) 类似，但增加了超时限制。
  • 如果许可证可用，或在 nanos 纳秒内被 unpark 或中断，则方法返回。
  • 如果等待时间超过 nanos 纳秒，即使没有 unpark 或中断，方法也会自动返回。
  • 同样，方法不抛出 InterruptedException，需要检查中断状态。
  • 返回值是 void，无法直接判断是超时返回还是被唤醒/中断返回（需要结合中断状态和业务逻辑判断）。
• nanos 参数:
  • 等待的相对时间，单位是纳秒。
  • 如果 nanos 为 0，行为类似 park()，但仍会检查超时（几乎立即超时），通常用于非阻塞地检查许可证。
  • 如果 nanos 为负数，行为等同于 park()（无限等待）。注意：文档说明负数等同于0，但实际行为可能更像无限等待或依赖具体实现，建议避免传入负数，若需无限等待请用 park()。更准确地说，负的 nanos 会被视为 0，导致方法几乎立即返回。若需无限等待，应使用 park()。
• 精度: 超时的精度受操作系统调度和计时器精度的影响，不能保证精确的纳秒级控制。
• 使用场景: 需要设置等待超时的场景，避免线程无限期阻塞。例如，尝试获取资源一段时间，超时则放弃。

3.5 parkUntil(long deadline) 和 parkUntil(Object blocker, long deadline)

public static void parkUntil(long deadline)
public static void parkUntil(Object blocker, long deadline)

• 作用: 阻塞当前线程，直到指定的绝对时间点 (deadline)。
• 行为:
  • 与 parkNanos 类似，但参数是绝对时间戳。
  • 如果许可证可用，或在到达 deadline 之前被 unpark 或中断，则方法返回。
  • 如果当前时间已经超过或等于 deadline，或者在等待期间到达了 deadline，方法会自动返回。
  • 同样，不抛出 InterruptedException，需要检查中断状态。
• deadline 参数:
  • 一个绝对时间戳，表示从纪元（1970-01-01T00:00:00Z） 开始计算的毫秒数。通常通过 System.currentTimeMillis() + delayMillis 计算得到。
• 使用场景: 需要在某个确定的未来时间点之前等待的场景。

3.6 getBlocker(Thread t)

public static Object getBlocker(Thread t)

• 作用: 获取指定线程 t 上一次调用带 blocker 参数的 park 方法时设置的 blocker 对象。
• 行为:
  • 如果线程 t 当前没有因为 park(blocker) 而阻塞，或者上次 park 时没有提供 blocker 对象，则返回 null。
  • 如果线程 t 当前正被 park(blocker) 阻塞，则返回那个 blocker 对象。
• 使用场景: 主要用于监控和调试。可以检查特定线程为何被阻塞，以及被哪个同步组件或逻辑所阻塞。

3.7 源码浅析（基于 HotSpot JVM 和 Unsafe）

LockSupport 的核心方法在 Java 层面非常简单，它们都委托给了 sun.misc.Unsafe 类中的本地（native）方法。Unsafe 类提供了一些低级的、不安全的内存和线程操作能力。

以下是 park() 和 unpark() 在 OpenJDK 中可能的简化版 Java 层实现（实际代码可能因版本和平台而异）：

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class LockSupport {

    private static final Unsafe UNSAFE;
    private static final long parkBlockerOffset; // 记录 blocker 在线程中的偏移量

    static {
        try {
            // 通过反射获取 Unsafe 实例
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            UNSAFE = (Unsafe) f.get(null);

            // 获取 Thread 类中用于存放 parkBlocker 的字段偏移量
            // 这个字段在不同 JDK 版本中可能不同 (parkBlocker / _park_blocker 等)
            // 这里仅为示意，实际获取方式更复杂健壮
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("parkBlocker")); // 假设字段名为 parkBlocker

        } catch (Exception e) {
            throw new Error(e);
        }
    }

    // 设置线程的 blocker 对象
    private static void setBlocker(Thread t, Object arg) {
        // 使用 Unsafe 直接写入线程对象的字段
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    public static void park() {
        // 调用 Unsafe 的 park 方法，isAbsolute=false 表示相对时间，time=0 表示无限等待
        // 注意：这里的 false 和 0 是简化表示，实际 native 方法参数可能不同
        // 第一个 false 表示不是绝对时间，第二个 0 表示无限等待
        UNSAFE.park(false, 0L);
    }

    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        // 1. 设置 blocker 对象到当前线程
        setBlocker(t, blocker);
        // 2. 调用 Unsafe 的 park 方法进行阻塞
        UNSAFE.park(false, 0L);
        // 3. park 返回后，清除 blocker 对象（避免内存泄漏）
        setBlocker(t, null);
        // 注意：实际 AQS 等实现中，清除 blocker 的时机可能更复杂
    }

    public static void parkNanos(long nanos) {
        if (nanos > 0) {
            // isAbsolute=false 表示相对时间
            UNSAFE.park(false, nanos);
        } else {
             // nanos <= 0 时不阻塞或行为同 park() 取决于具体实现，这里简化为直接调用 park()
             // 更准确：nanos=0 几乎立即返回，nanos<0 视为0
             UNSAFE.park(false, 0L); // 或者直接返回？看具体实现
        }
    }

    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);
        } else {
             park(blocker); // 简化处理：<=0 时行为同 park(blocker)
        }
    }

    public static void parkUntil(long deadline) {
        // isAbsolute=true 表示绝对时间，时间单位是毫秒
        UNSAFE.park(true, deadline);
    }

     public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    public static void unpark(Thread thread) {
        if (thread != null) {
            // 调用 Unsafe 的 unpark 方法唤醒指定线程
            UNSAFE.unpark(thread);
        }
    }

    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        // 使用 Unsafe 读取线程对象的 blocker 字段
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    // 构造函数私有，防止实例化
    private LockSupport() {}
}

关键点解读：

1. 依赖 Unsafe: LockSupport 的核心功能完全依赖 sun.misc.Unsafe 这个“后门”类，调用其本地方法 park 和 unpark。这意味着 LockSupport 的真正实现是在 JVM 内部以及操作系统层面。
2. park 的参数: Unsafe.park(boolean isAbsolute, long time) 这个本地方法接收两个参数：
   • isAbsolute: false 表示 time 是一个相对时间（纳秒），用于 parkNanos；true 表示 time 是一个绝对时间戳（毫秒），用于 parkUntil。
   • time: 如果 isAbsolute 为 false，time 是等待的纳秒数。如果 time 为 0，表示无限等待（用于 park()）。如果 isAbsolute 为 true，time 是截止时间的毫秒时间戳。
3. unpark 的参数: Unsafe.unpark(Object thread) 直接接收要唤醒的线程对象。
4. blocker 的存储: park(Object blocker) 通过 Unsafe 将 blocker 对象直接写入线程对象内部的一个预留字段（如 parkBlocker）。getBlocker(Thread t) 则通过 Unsafe 读取这个字段的值。使用 getObjectVolatile 确保了可见性。

这个源码分析揭示了 LockSupport 仅仅是 Java 层的一个轻量级封装，真正的魔法发生在 Unsafe 的本地方法调用中，接下来我们会探讨 JVM 和 OS 层面的实现原理。

4. LockSupport 与 Object wait/notify 对比

LockSupport 和 Object 的 wait/notify 机制都能实现线程间的等待和通知，但它们在设计理念、使用方式和特性上存在显著差异。理解这些差异有助于我们在合适的场景选择合适的工具。

特性	LockSupport (park/unpark)	Object (wait/notify/notifyAll)
依赖锁	否，不需要获取任何锁即可调用	是，必须在 synchronized 代码块或方法内调用
唤醒目标	精确，unpark(thread) 可以唤醒指定线程	不精确，notify() 随机唤醒一个，notifyAll() 唤醒全部
信号丢失	不会，允许 unpark 先于 park 调用，许可证会保留	会，如果 notify 先于 wait 调用，信号会丢失
中断处理	响应中断，但不抛出 InterruptedException，需手动检查中断状态	响应中断，并抛出 InterruptedException，强制处理异常
虚假唤醒	理论上可能，但概率极低 (JVM/OS 层面保证较好)	可能发生，必须在循环 (while) 中检查条件
使用方式	作为工具类的静态方法调用	作为Object 类的方法调用
灵活性	高，可在任意位置调用，精确控制	低，受 synchronized 限制，唤醒不精确
实现层面	基于 JVM Parker + OS 原语 (如 futex, event)	基于 对象监视器 (Monitor)
主要用途	构建高级同步器 (AQS 等) 的基础	Java 内建的基本同步机制

详细对比解读：

1. 锁依赖（最大区别）:

   • LockSupport 的最大优势在于它不依赖于任何锁。你可以在任何需要的地方阻塞或唤醒线程，无需关心当前是否持有某个对象的锁。这使得它可以用来实现与锁无关的同步逻辑，或者在持有不同锁的代码块之间进行通信。
   • wait/notify 必须与 synchronized 配合使用，这限制了它们的使用场景，并且可能导致不必要的锁竞争或死锁。

2. 唤醒精度:

   • unpark 的精确唤醒能力对于实现公平锁、控制特定工作线程等场景至关重要。
   • notify 的随机性使得它只适用于所有等待线程处理逻辑都相同的简单场景。notifyAll 则可能带来性能问题。

3. 信号处理（健壮性）:

   • LockSupport 的“先 unpark 后 park”机制极大地提高了并发编程的容错性，开发者不必过于担心 park 和 unpark 的严格调用顺序。
   • wait/notify 的信号丢失问题是常见的并发 bug 来源，需要开发者格外小心。

4. 中断处理（灵活性 vs 规范性）:

   • park 不抛出 InterruptedException 给予了开发者更大的灵活性来处理中断。你可以选择忽略中断、立即响应、延迟响应或者将其转换为其他形式的信号。这对于构建需要精细控制中断策略的库（如 AQS）很有用。
   • wait 抛出 InterruptedException 是一种更“规范”的方式，强制开发者处理中断情况，对于避免忘记处理中断可能更安全，但缺乏灵活性。同时，异常处理本身也有一定的开销。

5. 虚假唤醒:

   • 虽然 park 在理论上也可能发生虚假唤醒（即在没有 unpark 或中断的情况下被唤醒），但在现代 JVM 和 OS 实现中，这种情况非常罕见。因此，使用 park 时通常不需要像 wait 那样放在 while 循环里反复检查条件（除非业务逻辑本身就需要循环检查）。AQS 的实现就没有在 park 外层加 while 循环。
   • wait 则明确要求必须在 while 循环中调用，以应对虚假唤醒和保证条件满足。

何时选择 LockSupport 而不是 wait/notify？

在实际应用中，虽然我们可能不直接大量使用 LockSupport，但理解其优势场景很重要：

1. 实现自定义同步器: 当你需要构建自己的锁、信号量、条件变量、阻塞队列等同步工具时，LockSupport 是理想的底层构建块。JUC 中的 AQS 就是最好的例子。
2. 需要精确唤醒: 当你需要明确唤醒等待队列中的某一个特定线程（例如，实现公平锁时唤醒队首线程）时，unpark 是不二之选。
3. 解耦等待与锁: 当线程的等待条件与某个特定的对象锁无关，或者需要在持有不同锁的代码段之间协调时，LockSupport 提供了更大的灵活性。
4. 避免 wait/notify 的陷阱: 如果你想避免 wait/notify 潜在的信号丢失问题，或者希望更灵活地处理线程中断，LockSupport 是一个替代方案。
5. 性能敏感且需要精细控制: 在一些高性能并发库或框架中，LockSupport 相对于 synchronized + wait/notify 可能提供更轻量级的阻塞/唤醒开销（避免了 Monitor 的获取和释放），但这通常需要仔细的性能测试。

总结: LockSupport 提供了一种更底层、更灵活、更精确的线程阻塞/唤醒机制，是 JUC 同步组件的基石。而 wait/notify 是与 synchronized 紧密集成的传统同步原语。对于应用层开发者，通常优先使用 JUC 提供的更高级同步器；但在需要深入理解 JUC 原理或构建自定义同步组件时，LockSupport 就显得尤为重要。

5. 实现原理深入

LockSupport 的轻量级和高效性源于其巧妙的实现机制，它跨越了 Java API、JVM 和操作系统三个层面。

5.1 JVM 层面：Parker 类

在 HotSpot JVM 内部，每个 Java Thread 对象都关联着一个名为 Parker 的 C++ 对象。这个 Parker 对象是实现 LockSupport 许可证机制的关键。

Parker 类（简化概念模型）：

// HotSpot JVM 内部 Parker 对象的简化概念表示
class Parker {
private:
    volatile int _counter; // 许可证计数器 (0 或 1)
    // ... 其他字段，例如用于存放等待线程的队列指针 ...

    // 用于线程等待和唤醒的底层同步原语 (mutex 和 condition variable)
    pthread_mutex_t _mutex; // 或者其他平台对应的锁
    pthread_cond_t _cond;   // 或者其他平台对应的条件变量
public:
    Parker() : _counter(0) {
        // 初始化互斥锁和条件变量
        pthread_mutex_init(&_mutex, NULL);
        pthread_cond_init(&_cond, NULL);
    }

    // park 实现逻辑 (简化)
    void park(bool isAbsolute, long time) {
        // 1. 检查许可证 (_counter)
        if (_counter > 0) {
            _counter = 0; // 消耗许可证
            // 不需要锁保护，因为 _counter 的修改是原子性的，或者有其他内存屏障保证
            return; // 直接返回，不阻塞
        }

        // 2. 许可证为 0，准备阻塞
        // ... 可能需要记录时间、设置线程状态等 ...

        // 3. 使用底层同步原语阻塞线程
        pthread_mutex_lock(&_mutex);
        if (_counter == 0) { // 再次检查，防止 park/unpark 竞态
            if (time == 0 && !isAbsolute) { // 无限等待 (park())
                pthread_cond_wait(&_cond, &_mutex);
            } else { // 带超时的等待 (parkNanos / parkUntil)
                // 计算超时的绝对时间 timespec ts = ...;
                // pthread_cond_timedwait(&_cond, &_mutex, &ts);
            }
        }
        // 唤醒后 (或超时后)
        _counter = 0; // 确保唤醒后许可证为 0
        pthread_mutex_unlock(&_mutex);

        // ... 清理工作，恢复线程状态 ...
    }

    // unpark 实现逻辑 (简化)
    void unpark() {
        // 1. 设置许可证
        // 使用原子操作或锁保护来设置 _counter = 1
        // 这里简化为直接设置，实际需要考虑并发
        _counter = 1; // 发放许可证

        // 2. 唤醒可能在等待的线程
        pthread_mutex_lock(&_mutex);
        // 检查是否有线程在条件变量上等待 (简化)
        // if (有线程在等待) {
            pthread_cond_signal(&_cond); // 唤醒一个等待的线程
        // }
        pthread_mutex_unlock(&_mutex);
    }

    // ... 其他方法，如处理中断 ...
};

核心机制解释：

1. _counter 字段: 这就是我们在概念上称之为“许可证”的东西。它是一个 volatile 的整型变量，其值通常只在 0 和 1 之间切换。volatile 保证了多线程之间的可见性，但不保证原子性，因此实际实现中会使用更底层的原子操作或锁来安全地修改 _counter。
2. park 操作:
   • 首先在用户态快速检查 _counter。如果大于 0，表示有许可证，直接将其设置为 0 并返回。这个用户态的快速路径检查避免了不必要的系统调用和内核态切换，是 LockSupport 高效的关键之一。
   • 如果 _counter 为 0，表示需要阻塞。线程会准备进入等待状态，并最终调用底层的同步原语（如 pthread_cond_wait 或 pthread_cond_timedwait）将自己挂起，进入内核态。
   • 在进入等待前和被唤醒后，通常会再次检查 _counter 状态，以处理 park 和 unpark 之间的竞态条件。
3. unpark 操作:
   • 将目标线程的 Parker 对象的 _counter 设置为 1。这一步通常需要原子性保证。
   • 调用底层同步原语（如 pthread_cond_signal）来唤醒可能在该 Parker 对象上等待的线程。如果目标线程并未阻塞，signal 操作通常是无害的（或者根本不执行）。

5.2 操作系统层面：平台相关的实现

Parker 对象内部使用的底层同步原语（如 _mutex 和 _cond）的具体实现是依赖于操作系统的。JVM 会根据不同的操作系统平台，调用相应的系统调用来实现线程的阻塞和唤醒：

• Linux: 主要基于 futex (Fast Userspace Mutex)。futex 是一种高效的内核同步机制，它允许在用户态解决大部分同步情况（当没有竞争时），只有在确实需要阻塞或唤醒线程时才陷入内核态。park 操作在需要阻塞时会调用 futex(FUTEX_WAIT)，而 unpark 则调用 futex(FUTEX_WAKE)。
• Windows: 使用 Windows 的事件（Event）对象和 WaitForSingleObject / WaitForMultipleObjects API。park 会在一个事件对象上等待，而 unpark 则会设置（Set）该事件对象，从而唤醒等待的线程。
• macOS / BSD: 通常基于 POSIX 线程（pthreads）库提供的互斥锁（pthread_mutex_t） 和 条件变量（pthread_cond_t）。park 对应 pthread_cond_wait 或 pthread_cond_timedwait，unpark 对应 pthread_cond_signal。

跨平台设计的优势：

这种分层设计（Java API -> JVM Parker -> OS 原语）带来了几个好处：

1. 性能: 用户态的许可证检查避免了大多数情况下的内核态切换，提高了性能。只有真正需要阻塞时才涉及成本较高的系统调用。
2. 统一接口: LockSupport 为 Java 开发者提供了统一、简单的 API，屏蔽了底层操作系统的复杂性和差异性。
3. 灵活性: 底层可以根据不同平台的特性进行优化。

5.3 与 synchronized 实现的区别

理解了 LockSupport 的实现，再对比 synchronized 的实现，差异就更清晰了：

• synchronized:

  • 基于 对象监视器 (Monitor) 实现。每个 Java 对象都可以关联一个 Monitor。
  • Monitor 内部包含了锁的持有者、等待队列（Wait Set，用于 wait）、入口队列（Entry Set，用于争抢锁）等复杂结构。
  • 获取锁（monitorenter）和释放锁（monitorexit）涉及对对象头（Mark Word）的修改，可能涉及锁的膨胀（偏向锁 -> 轻量级锁 -> 重量级锁）。重量级锁依赖操作系统的互斥量（Mutex）。
  • wait/notify 操作的是 Monitor 内部的 Wait Set。
  • synchronized 提供了完整的互斥和内存可见性语义。

• LockSupport:

  • 基于 线程关联的 Parker 实现。
  • Parker 内部主要是 _counter 和底层的 OS 同步原语（如 futex 或条件变量）。
  • park/unpark 主要操作 _counter 和调用 OS 原语进行阻塞/唤醒。
  • 不提供锁语义，也不直接保证除 _counter 之外的内存可见性（内存可见性通常由调用 LockSupport 的上层同步器如 AQS 来保证）。
  • 实现相对更轻量级，因为它不涉及复杂的锁状态管理和 Monitor 结构。

总结: LockSupport 是一个更底层的、专注于线程阻塞/唤醒的原语，其实现依赖于 JVM 内部的 Parker 和特定平台的 OS 同步机制。synchronized 则是一个更高级的、提供完整锁和监视器功能的语言级特性。

6. 应用场景举例

LockSupport 作为 JUC 的基石，其身影隐藏在众多我们熟悉的并发工具背后。直接使用 LockSupport 的场景相对较少，但理解它如何在这些工具中发挥作用至关重要。

6.1 AbstractQueuedSynchronizer (AQS)

AQS 是 JUC 中大多数同步器（ReentrantLock, Semaphore, CountDownLatch, ReentrantReadWriteLock, FutureTask 等）的基础框架。AQS 内部维护了一个虚拟的 CLH (Craig, Landin, and Hagersten) 双向队列来管理等待获取同步状态（如锁）的线程。

LockSupport 在 AQS 中的作用：

1. 阻塞获取失败的线程: 当一个线程尝试获取同步状态失败时（例如，调用 lock() 但锁已被占用），AQS 会将该线程包装成一个节点（Node）加入到等待队列的尾部。然后，在将节点安全地插入队列后，AQS 会调用 LockSupport.park(this) （这里的 this 通常是 AQS 实例或代表同步器的对象）来阻塞当前线程。选择 park 而不是 wait 的原因包括：
   • 不需要获取额外的锁。
   • 可以精确唤醒后续的线程。
   • 灵活处理中断。
2. 唤醒等待队列中的后续线程: 当一个线程释放同步状态时（例如，调用 unlock()），AQS 会检查等待队列中是否有需要被唤醒的后继节点。如果找到合适的后继节点（通常是队首的下一个可用节点），AQS 会调用 LockSupport.unpark(node.thread) 来精确地唤醒那个等待的线程。

示例（简化 AQS 逻辑）：

// AQS 内部 acquire/release 的简化逻辑示意
abstract class AbstractQueuedSynchronizer {
    // ... state, head, tail 等字段 ...

    // 尝试获取同步状态 (由子类实现，如 ReentrantLock)
    protected abstract boolean tryAcquire(int arg);
    // 尝试释放同步状态 (由子类实现)
    protected abstract boolean tryRelease(int arg);

    // 获取同步状态 (独占模式)
    public final void acquire(int arg) {
        if (!tryAcquire(arg)) { // 尝试获取失败
            Node node = addWaiter(Node.EXCLUSIVE); // 创建节点并加入等待队列
            boolean interrupted = false;
            try {
                for (;;) { // 自旋等待
                    final Node p = node.predecessor(); // 获取前驱节点
                    if (p == head && tryAcquire(arg)) { // 如果是队首且尝试获取成功
                        setHead(node); // 将自己设为队首
                        p.next = null; // help GC
                        return;
                    }
                    // 判断是否应该阻塞 (避免不必要的 park)
                    if (shouldParkAfterFailedAcquire(p, node)) {
                         // *** 使用 LockSupport 阻塞当前线程 ***
                        LockSupport.park(this); // 使用 this 作为 blocker
                    }
                    // 检查是否被中断 (park 返回后检查)
                    if (Thread.interrupted())
                        interrupted = true;
                }
            } finally {
                if (interrupted)
                    selfInterrupt(); // 如果在 park 期间被中断，重新设置中断状态
            }
        }
    }

    // 释放同步状态 (独占模式)
    public final boolean release(int arg) {
        if (tryRelease(arg)) { // 尝试释放成功
            Node h = head;
            if (h != null && h.waitStatus != 0) {
                // *** 找到需要唤醒的后继节点 ***
                unparkSuccessor(h); // 内部会调用 LockSupport.unpark()
            }
            return true;
        }
        return false;
    }

    // 唤醒后继节点
    private void unparkSuccessor(Node node) {
        // ... 找到队列中第一个需要唤醒的节点 s ...
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            // ... 处理取消的节点，找到实际的下一个有效等待者 s ...
        }
        if (s != null) {
            // *** 使用 LockSupport 唤醒目标线程 ***
            LockSupport.unpark(s.thread);
        }
    }

    // ... addWaiter, shouldParkAfterFailedAcquire, setHead, selfInterrupt 等辅助方法 ...
}

没有 LockSupport，AQS 就无法如此高效、灵活地管理线程的阻塞与唤醒。

6.2 Condition (条件变量)

Condition 接口提供了类似 Object 的 wait/notify/notifyAll 功能，但它与特定的 Lock 实现（通常是 ReentrantLock）绑定，提供了更精细的控制。ReentrantLock.newCondition() 返回的是 AQS 的内部类 ConditionObject 的实例。

LockSupport 在 ConditionObject 中的作用：

1. await(): 当线程调用 condition.await() 时：
   • 它首先会完全释放持有的 Lock。
   • 然后将当前线程作为一个节点加入到 Condition 内部的条件队列中。
   • 最后，调用 LockSupport.park() 将当前线程阻塞，等待 signal。
2. signal(): 当线程调用 condition.signal() 时：
   • 它会从条件队列中取出一个等待节点（通常是队首）。
   • 将这个节点从条件队列移动到 Lock 的 AQS 等待队列中。
   • 然后调用 LockSupport.unpark(node.thread) 来唤醒那个在 await 中 park 的线程。被唤醒的线程接下来会尝试重新获取 Lock。
3. signalAll(): 类似 signal()，但会唤醒条件队列中的所有等待线程，并将它们都转移到 AQS 等待队列中。

可以看到，Condition 的实现也严重依赖 LockSupport 来挂起和唤醒等待条件的线程。

6.3 并发集合类

一些高级并发集合类，在需要实现线程间的等待/通知时，也可能直接或间接（通过 AQS）使用 LockSupport。

• LinkedTransferQueue: 这是一个高性能的无界队列，它支持 transfer 操作，即生产者可以直接将元素传递给正在等待的消费者，无需入队。当生产者调用 transfer 但没有消费者在等待时，或者消费者尝试获取元素但队列为空时，它们可能会使用 LockSupport.parkNanos() 或 park() 来阻塞自己，等待匹配的操作发生。匹配发生后，另一方会调用 unpark 唤醒等待者。
• Phaser: 一个更灵活的同步屏障，其内部协调参与者线程的到达和等待也可能用到 LockSupport。

6.4 ForkJoinPool

ForkJoinPool 是用于执行 ForkJoinTask 的线程池，它使用了工作窃取（Work-Stealing） 算法来提高效率。

LockSupport 在 ForkJoinPool 中的作用：

当 ForkJoinPool 中的工作线程（Worker Thread）发现自己的任务队列为空，并且尝试从其他线程的队列中窃取任务也失败时，这个工作线程可能会进入休眠状态，以避免空转消耗 CPU。这种休眠通常就是通过 LockSupport.park() 或其带超时的变体来实现的。当有新的任务提交到线程池，或者其他线程释放了可窃取的任务时，会调用 LockSupport.unpark() 来唤醒休眠的工作线程。

6.5 实现自定义同步器

如果你需要实现 JUC 中没有提供的特定同步逻辑，LockSupport 就是你的有力武器。例如：

• 自定义信号量: 实现一个只允许特定类型线程通过的信号量。
• 异步转同步: 在某些异步回调场景中，需要阻塞当前线程直到异步结果返回，可以使用 park/unpark 来实现。主线程 park 等待，回调线程处理完结果后 unpark 主线程。
• 简单的一次性门闩:

import java.util.concurrent.locks.LockSupport;

public class OneTimeLatch {
    private volatile boolean opened = false;
    private Thread waiter = null;

    public void await() {
        if (!opened) {
            waiter = Thread.currentThread();
            while (!opened) {
                // 使用 park 阻塞，等待 open()
                LockSupport.park(this); // 使用 latch 自身作为 blocker
                // park 返回后再次检查 opened 状态 (应对极低概率的虚假唤醒或中断)
            }
            waiter = null; // 清理 waiter
        }
    }

    public void open() {
        opened = true;
        Thread w = waiter;
        if (w != null) {
            // 使用 unpark 唤醒可能在 await 中等待的线程
            LockSupport.unpark(w);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        OneTimeLatch latch = new OneTimeLatch();

        Thread t1 = new Thread(() -> {
            System.out.println("线程1: 开始等待门闩...");
            latch.await();
            System.out.println("线程1: 门闩已打开，继续执行。");
        });

        t1.start();

        System.out.println("主线程: 准备打开门闩...");
        Thread.sleep(2000); // 模拟耗时操作
        latch.open();
        System.out.println("主线程: 门闩已打开。");

        t1.join();
    }
}

这个例子展示了如何使用 park/unpark 实现一个简单的一次性同步屏障。

总而言之，LockSupport 是 JUC 实现高效、灵活线程同步的幕后英雄。虽然我们不常直接调用它，但理解它的工作原理和应用场景，是深入掌握 Java 并发编程的关键一步。

7. 高级问题探讨

7.1 park 方法如何响应中断？与 wait/sleep 的区别？

这是 LockSupport 的一个重要特性，也是面试中常考的点。

• LockSupport.park():

  • 响应中断: 当线程 T 正在 park() 阻塞时，如果其他线程调用了 T.interrupt()，park() 方法会立即返回。
  • 不抛出异常: 与 Object.wait() 和 Thread.sleep() 不同，park() 不会抛出 InterruptedException。
  • 设置中断状态: park() 返回时，线程 T 的中断状态会被设置为 true。
  • 处理方式: 调用 park() 的代码需要显式地检查线程的中断状态（通常使用 Thread.interrupted() 或 Thread.currentThread().isInterrupted()）来判断 park 是正常返回（被 unpark）还是因中断返回，并决定后续如何处理。

• Object.wait():

  • 响应中断: 等待中的线程被中断时，wait() 方法会立即返回。
  • 抛出异常: wait() 会抛出 InterruptedException。
  • 清除中断状态: 抛出 InterruptedException 之前，JVM 会清除线程的中断状态（设置为 false）。
  • 处理方式: 必须在 try-catch 块中捕获 InterruptedException。如果在 catch 块中需要保留中断信号（例如，让上层调用者知道发生了中断），必须手动调用 Thread.currentThread().interrupt() 来重新设置中断状态。

• Thread.sleep():

  • 响应中断: 休眠中的线程被中断时，sleep() 方法会立即返回。
  • 抛出异常: sleep() 会抛出 InterruptedException。
  • 清除中断状态: 抛出 InterruptedException 之前，JVM 会清除线程的中断状态（设置为 false）。
  • 处理方式: 与 wait() 类似，需要捕获 InterruptedException，并根据需要重新设置中断状态。

对比总结:

方法	响应中断	抛出 InterruptedException	返回时中断状态	处理方式
LockSupport.park()	是	否	true	手动检查 Thread.interrupted()
Object.wait()	是	是	false	catch 异常，需要时 Thread.currentThread().interrupt()
Thread.sleep()	是	是	false	catch 异常，需要时 Thread.currentThread().interrupt()

为什么 park 不抛异常？

LockSupport 被设计为构建同步器的底层工具。不抛出 InterruptedException 给了上层实现者（如 AQS）更大的灵活性来决定如何处理中断。例如，AQS 提供了可中断 (acquireInterruptibly) 和不可中断 (acquire) 的获取同步状态的方法。在不可中断的方法内部，即使 park 因中断返回，AQS 也会继续尝试获取同步状态，而不是立即抛出异常。如果 park 抛出异常，实现这种不可中断的逻辑会更复杂。

使用 park 时如何处理中断？

LockSupport.park(this); // 阻塞

// park 返回后，必须检查中断状态
if (Thread.interrupted()) { // interrupted() 会检查并清除中断状态
    // 线程被中断了
    System.out.println("Park 被中断了...");
    // 在这里决定如何处理中断：
    // 1. 向上抛出 InterruptedException (如果方法签名允许)
    //    throw new InterruptedException();
    // 2. 重新设置中断状态，让上层代码感知 (常见于库代码)
    //    Thread.currentThread().interrupt();
    // 3. 执行清理操作并退出
    //    cleanup(); return;
    // 4. 忽略中断 (如果业务逻辑允许)
    //    // do nothing
    // 5. 继续执行，但可能需要标记中断状态
    //    interruptedFlag = true; continue;
} else {
    // 线程被正常 unpark 了
    System.out.println("Park 被 unpark 了...");
}

关键在于，使用 park 时，中断处理的责任完全交给了开发者。

7.2 如何处理 park 方法导致的线程长时间阻塞问题？

虽然 LockSupport.park() 本身是 JUC 正常工作的一部分，但在某些情况下，如果 unpark 操作因为逻辑错误、死锁或其他原因迟迟没有发生，调用 park() 的线程可能会无限期阻塞，导致程序无响应或资源无法释放。

排查与解决策略：

1. 使用带 blocker 的 park:

   • 始终优先使用 park(Object blocker) 而不是无参的 park()。
   • 当出现线程阻塞问题时，使用 jstack <pid> 命令查看线程堆栈。带有 blocker 的 park 会在堆栈信息中显示 - parking to wait for <blocker object description>，这能帮助你快速定位是哪个同步对象或逻辑导致了阻塞。

2. 使用带超时的 parkNanos 或 parkUntil:

   • 预防: 如果业务逻辑允许等待超时，或者为了增加系统的健壮性，应优先考虑使用 parkNanos 或 parkUntil 替代无限等待的 park()。

   • 示例:

     long waitNanos = TimeUnit.SECONDS.toNanos(30); // 最多等待30秒
     LockSupport.parkNanos(this, waitNanos);
     
     if (Thread.interrupted()) {
         // 处理中断
     } else if (/* 条件依然不满足，说明可能是超时了 */) {
         // 处理超时逻辑，例如：记录日志、放弃操作、重试等
         log.warn("等待 {} 超时", blocker);
         // throw new TimeoutException("等待超时");
     } else {
         // 被正常唤醒
     }
     
     
     + 1
     + 2
     + 3
     + 4
     + 5
     + 6
     + 7
     + 8
     + 9
     + 10
     + 11
     + 12

   • 注意: parkNanos 和 parkUntil 返回 void，需要结合中断状态和业务条件判断是哪种情况导致返回。

3. 监控和诊断工具:

   • JMX (Java Management Extensions): 可以在代码中暴露相关的 JMX Bean，用于监控等待队列的长度、等待时间等信息。
   • 线程 Dump (jstack): 定期或在出现问题时执行 jstack，分析线程状态（WAITING (parking)），查看 blocker 信息，检查是否存在死锁。
   • Arthas 等动态诊断工具: 可以实时查看线程状态、调用栈，甚至动态修改代码或执行命令来辅助诊断。

4. 实现看门狗（Watchdog）线程:

   • 对于非常关键或容易出问题的等待逻辑，可以考虑实现一个独立的看门狗线程。
   • 看门狗线程定期检查目标线程的状态（例如通过 Thread.getState()）或相关的业务状态。
   • 如果发现目标线程长时间处于 WAITING (parking) 状态且超过了预设阈值，看门狗线程可以采取行动，例如：
     • 记录严重错误日志。
     • 尝试中断目标线程 (targetThread.interrupt())，看其是否能正确响应中断。
     • 触发报警通知运维人员。
     • 在极端情况下，尝试强制 unpark（但通常不推荐，可能破坏同步逻辑）。
   • 注意: 看门狗线程本身的设计也要小心，避免引入新的复杂性和资源消耗。

5. 代码审查和逻辑分析:

   • 根本原因: 长时间阻塞往往是代码逻辑问题的体现。仔细审查 park 和 unpark 的调用路径，确保：
     • unpark 总会被调用（没有遗漏的分支）。
     • 没有死锁（例如，A 等待 B unpark，B 等待 A unpark）。
     • 条件变量的判断正确。
     • 中断被正确处理。
   • 简化逻辑: 复杂的同步逻辑更容易出错，考虑是否能简化设计。

总结: 处理长时间 park 的关键在于：使用 blocker 便于诊断，优先使用超时避免无限等待，利用监控工具发现问题，通过代码审查和逻辑分析找到根本原因。看门狗线程可以作为最后的保障措施。

8. 总结

LockSupport 是 Java 并发包（JUC）提供的一个强大而灵活的底层线程阻塞与唤醒工具。虽然不会频繁直接使用它，但它是理解和掌握 JUC 核心同步器（如 ReentrantLock, Semaphore, Condition 等基于 AQS 的组件）工作原理的关键。

核心要点回顾：

1. 目的: 提供比 Object.wait/notify 更灵活、更精确、与锁解耦的线程阻塞/唤醒原语。
2. 核心机制: 基于每个线程关联的 许可证（Permit），这是一个二值信号量（0 或 1）。
3. 关键方法:
   • park() / park(blocker): 消耗许可证或阻塞线程，推荐使用带 blocker 的版本。
   • unpark(thread): 发放许可证给目标线程，并唤醒（如果正在 park）。
   • parkNanos/parkUntil: 带超时的 park。
4. 关键特性:
   • 无需锁: 调用 park/unpark 不要求持有任何锁。
   • 精确唤醒: unpark 可以指定唤醒哪个线程。
   • 无信号丢失: unpark 可以先于 park 调用，许可证会被保存。
   • 中断响应: park 响应中断但不抛出 InterruptedException，需手动检查中断状态。
5. 实现原理: Java 层通过 sun.misc.Unsafe 调用本地方法，JVM 层通过线程关联的 Parker 对象（包含 _counter 和 OS 同步原语）实现，OS 层依赖 futex (Linux)、事件 (Windows) 或条件变量 (macOS) 等机制。
6. 应用场景: 主要作为 AQS 的基础，用于实现 JUC 中的各种同步器；也用于 Condition、ForkJoinPool 以及自定义同步工具的构建。
7. 与 wait/notify 对比: 主要区别在于锁依赖、唤醒精度、信号丢失处理和中断处理方式。

LockSupport提供了基础而强大的功能。虽然直接使用它需要更加小心（需要自己处理同步和内存可见性问题），但它无疑是 Java 并发工具箱中不可或缺的一部分，支撑起了 JUC 的半壁江山。