Java线程阻塞方法LockSupport.park()/Thread.sleep()/Object.wait()详解：原理、区别_locksupport.parknanos 和 thread.sleep 的区别-CSDN博客

本文链接：https://blog.csdn.net/zhangzeyuaaa/article/details/147797784

Java线程阻塞方法详解：原理、区别

在多线程编程中，线程阻塞是协调并发任务、管理资源竞争的核心手段。Java提供了多种阻塞方法，每种方法的设计目标和底层机制各不相同。本文将深入解析 LockSupport.park()、Thread.sleep() 和 Object.wait() 的原理、区别及适用场景，并结合实际案例说明其使用技巧。

一、Java线程阻塞的核心方法

1. `LockSupport.park()`

原理与机制

许可证（Permit）模型：
LockSupport.park() 通过许可证机制管理线程状态。默认情况下，许可证为 0，调用 park() 的线程会被挂起，直到以下任一条件满足：
- 其他线程调用 LockSupport.unpark(Thread) 提供许可证（许可证变为 1）。
- 线程被中断（interrupt()）。
- 达到指定的超时时间（parkNanos()/parkUntil()）。
无需同步上下文：
与 Object.wait() 不同，park() 不需要持有对象锁即可调用，适合更灵活的线程控制。
底层实现：
JVM 通过 Parker 类（Linux/Windows/macOS 通用）实现，依赖操作系统原语（如 futex 或 Condition Variable）。

代码示例

Thread thread = new Thread(() -> {
    System.out.println("Waiting for unpark...");
    LockSupport.park(); // 阻塞线程
    System.out.println("Unparked!");
});
thread.start();

// 主线程唤醒
LockSupport.unpark(thread);

适用场景

底层同步工具：
用于构建高级并发工具（如 ReentrantLock、Semaphore、BlockingQueue），或需要精确控制线程状态的场景。
AQS（AbstractQueuedSynchronizer）：
Java 并发包中的核心组件（如 CountDownLatch、CyclicBarrier）均基于 LockSupport 实现。

2. `Thread.sleep()`

原理与机制

主动让出 CPU：
调用 Thread.sleep(long millis) 后，线程进入 TIMED_WAITING 状态，主动释放 CPU 时间片，但 不释放锁。
底层实现：
在 Linux 中通过 nanosleep()，在 Windows 中通过 Sleep() 实现，依赖操作系统调度器。

代码示例

try {
    System.out.println("Sleeping for 1 second...");
    Thread.sleep(1000); // 休眠 1 秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

适用场景

简单延时：
用于模拟耗时操作（如轮询）、调试或控制任务执行节奏。
非资源竞争场景：
由于不涉及锁的释放，适合不需要线程协作的场景。

注意事项

不释放锁：
若线程在持有锁时调用 sleep()，可能导致其他线程因无法获取锁而阻塞，甚至引发死锁。
中断处理：
线程被中断时会抛出 InterruptedException，需显式捕获并处理。

3. `Object.wait()` 与 `notify()`

原理与机制

依赖对象锁：
调用 wait() 前必须持有对象锁（synchronized 块），否则抛出 IllegalMonitorStateException。
释放锁并阻塞：
线程调用 wait() 后，会释放锁并进入对象的 _WaitSet 队列，等待其他线程调用 notify()/notifyAll() 唤醒。
底层实现：
JVM 通过 ObjectMonitor 管理同步对象，依赖操作系统条件变量（如 pthread_cond_wait）。

代码示例

Object lock = new Object();
synchronized (lock) {
    try {
        System.out.println("Waiting for notify...");
        lock.wait(); // 释放锁并阻塞
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

// 另一个线程唤醒
synchronized (lock) {
    lock.notify();
}

适用场景

经典等待-通知模式：
适用于生产者-消费者问题、线程间协作等需要共享资源条件满足的场景。
资源竞争协调：
通过锁和条件变量实现资源的互斥访问与动态唤醒。

注意事项

必须持有锁：
wait() 和 notify() 必须在 synchronized 块内调用，否则抛出异常。
虚假唤醒：
即使未调用 notify()，线程也可能因外部干扰（如系统中断）被唤醒，需在循环中检查条件。

二、方法对比与选型建议

特性	`LockSupport.park()`	`Thread.sleep()`	`Object.wait()`
锁依赖	无需锁	无需锁	必须持有锁
唤醒目标	精准唤醒（指定线程）	全局唤醒（超时或中断）	随机唤醒（`notify()`）或全唤醒（`notifyAll()`）
中断处理	清除中断标志并返回	抛出 `InterruptedException`	抛出 `InterruptedException`
许可证机制	支持许可证累积（`unpark` 可预存信号）	无	无
底层实现	JVM Parker（依赖操作系统原语`futex`/`Condition Variable`）	操作系统休眠 API（`nanosleep`/`Sleep`）	JVM ObjectMonitor（依赖操作系统条件变量`pthread_cond_wait`）
适用场景	精确控制线程状态（如 AQS）	简单延时或调试	线程间通信（如生产者-消费者）

三、实践案例与注意事项

1. 生产者-消费者模型

class SharedResource {
    private int value;
    private boolean available = false;

    public synchronized void produce(int v) {
        while (available) {
            try {
                wait(); // 等待消费
            } catch (InterruptedException e) {}
        }
        value = v;
        available = true;
        notify(); // 通知消费者
    }

    public synchronized int consume() {
        while (!available) {
            try {
                wait(); // 等待生产
            } catch (InterruptedException e) {}
        }
        available = false;
        notify(); // 通知生产者
        return value;
    }
}

2. 避免死锁与资源泄漏

避免嵌套锁：
不要在 synchronized 块中调用其他锁的 wait()，以减少死锁风险。
使用超时机制：
对 wait() 和 sleep() 设置超时时间，防止线程无限期阻塞。
中断处理：
对 InterruptedException 进行恢复中断状态（Thread.currentThread().interrupt()），确保中断信号传递。