JAVA LockSupport停车与唤醒不匹配导致线程无法恢复的问题排查 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JAVA LockSupport 停车与唤醒不匹配导致线程无法恢复的问题排查

大家好，今天我们来聊聊一个在并发编程中比较隐蔽，但又经常会遇到的问题：JAVA LockSupport 的停车与唤醒不匹配，导致线程无法恢复。LockSupport 是一个非常基础且重要的工具，理解其工作原理以及潜在的问题，对于编写健壮的并发程序至关重要。

1. LockSupport 的基本原理

LockSupport 类提供了一组线程阻塞和唤醒的原语，可以看作是 Thread.suspend() 和 Thread.resume() 的更安全、更灵活的替代品。它的核心机制是为每个线程关联一个许可 (permit)，这个许可只能是可用或不可用两种状态。

park() 方法： 如果当前线程的许可可用，则 park() 方法会立即返回，并将许可设置为不可用。如果许可不可用，则当前线程会被阻塞，直到以下情况发生：
- 另一个线程调用了 unpark(Thread) 方法，并将当前线程的许可设置为可用。
- 发生了中断。
- park() 方法“无缘无故”地返回 (spurious wakeup)。
unpark(Thread) 方法： 如果指定的线程的许可当前不可用，则 unpark(Thread) 方法会将许可设置为可用。如果线程还没有被阻塞，那么下次调用 park() 方法时，它会立即返回。

核心特性：

先 unpark 后 park： 即使 unpark() 方法在 park() 方法之前调用，线程仍然可以成功恢复。这是与 Object.wait()/Object.notify() 机制的一个关键区别，后者要求 notify() 必须在 wait() 之后调用，否则信号会丢失。
单个许可： 每个线程只有一个许可。多次调用 unpark() 方法，也只会使许可变为可用一次。后续的 park() 调用会将许可再次设置为不可用。

2. 停车与唤醒不匹配的常见场景

停车与唤醒不匹配，意味着线程进入了 park() 状态，但永远没有接收到对应的 unpark() 信号，从而导致线程永久阻塞。这通常发生在以下场景：

逻辑错误： 代码逻辑存在缺陷，导致 unpark() 方法没有被执行，或者执行的时机不正确。
异常处理不当： 在 unpark() 方法执行之前，发生了异常，导致 unpark() 逻辑被跳过。
线程池的使用： 在线程池中，线程的生命周期由线程池管理，如果任务执行过程中出现问题，可能导致线程无法正确地被唤醒，从而占用线程池资源。
信号丢失： 虽然 LockSupport 避免了 Object.wait()/Object.notify() 的信号丢失问题，但在复杂的并发场景下，仍然可能因为某些意想不到的原因导致信号丢失。
错误的线程对象： unpark() 唤醒了一个错误的线程对象。

3. 代码示例与分析

下面我们通过一些代码示例来具体分析这些场景：

场景 1：逻辑错误导致 unpark() 未被执行

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkExample {

    private static Thread workerThread;

    public static void main(String[] args) throws InterruptedException {
        workerThread = new Thread(() -> {
            System.out.println("Worker thread started.");
            LockSupport.park(); // 线程阻塞
            System.out.println("Worker thread resumed.");
        });

        workerThread.start();
        Thread.sleep(1000); // 等待 worker 线程启动

        // 错误：忘记调用 unpark() 方法
        // LockSupport.unpark(workerThread);

        System.out.println("Main thread finished.");
    }
}

在这个例子中，workerThread 会因为 LockSupport.park() 方法而阻塞，但主线程忘记调用 LockSupport.unpark(workerThread) 方法，导致 workerThread 永远无法恢复。

场景 2：异常处理不当导致 unpark() 被跳过

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkExample2 {

    private static Thread workerThread;

    public static void main(String[] args) throws InterruptedException {
        workerThread = new Thread(() -> {
            System.out.println("Worker thread started.");
            LockSupport.park(); // 线程阻塞
            System.out.println("Worker thread resumed.");
        });

        workerThread.start();
        Thread.sleep(1000); // 等待 worker 线程启动

        try {
            // 模拟可能抛出异常的操作
            int result = 10 / 0; // 抛出 ArithmeticException
            LockSupport.unpark(workerThread); // 期望唤醒 worker 线程
        } catch (Exception e) {
            System.err.println("Exception caught: " + e.getMessage());
            // 缺少处理：没有在异常处理中调用 unpark() 方法
        }

        System.out.println("Main thread finished.");
    }
}

在这个例子中，try 块中发生了 ArithmeticException 异常，导致 LockSupport.unpark(workerThread) 方法没有被执行，workerThread 线程仍然处于阻塞状态。

场景 3：线程池中使用不当

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.LockSupport;

public class ParkUnparkExample3 {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(1);

        executor.submit(() -> {
            System.out.println("Task started.");
            LockSupport.park();
            System.out.println("Task resumed.");
        });

        Thread.sleep(1000);

        // 错误：无法直接唤醒线程池中的线程
        // LockSupport.unpark(/* 需要知道线程对象，但无法直接获取 */);

        System.out.println("Main thread finished.");
        executor.shutdown();
    }
}

在这个例子中，我们使用了一个固定大小为 1 的线程池。提交的任务 LockSupport.park() 后，线程阻塞。由于我们无法直接获取线程池中线程的引用，因此无法调用 LockSupport.unpark() 方法来唤醒线程，导致线程池中的线程被永久占用。正确的做法是，在提交的任务中，使用其他方式来控制线程的唤醒，例如使用 Future 和 CountDownLatch 等工具。

场景 4：错误的线程对象

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkExample4 {

    public static void main(String[] args) throws InterruptedException {
        Thread workerThread1 = new Thread(() -> {
            System.out.println("Worker thread 1 started.");
            LockSupport.park();
            System.out.println("Worker thread 1 resumed.");
        });

        Thread workerThread2 = new Thread(() -> {
            System.out.println("Worker thread 2 started.");
        });

        workerThread1.start();
        workerThread2.start();
        Thread.sleep(1000);

        // 错误：唤醒了错误的线程
        LockSupport.unpark(workerThread2); // 期望唤醒 workerThread1，但唤醒了 workerThread2

        System.out.println("Main thread finished.");

    }
}

这个例子中，workerThread1 阻塞，主线程错误地 unpark 了 workerThread2，导致 workerThread1 永远阻塞。

4. 排查与调试技巧

当遇到 LockSupport 停车与唤醒不匹配的问题时，可以尝试以下排查与调试技巧：

代码审查： 仔细审查代码，检查 park() 和 unpark() 方法是否成对出现，以及执行的条件是否正确。
日志记录： 在 park() 和 unpark() 方法调用前后添加日志，记录线程 ID 和执行时间，以便追踪线程的阻塞和唤醒情况。
线程转储（Thread Dump）： 使用 jstack 命令或者 JVM 自带的工具，生成线程转储文件。分析线程转储文件，查找处于 park() 状态的线程，以及它们的调用栈，从而确定阻塞的原因。
调试器： 使用 IDE 的调试器，单步执行代码，观察线程的执行流程，以及 LockSupport 的状态变化。
使用并发测试工具： 使用并发测试工具，例如 JMH (Java Microbenchmark Harness) 或 JUnit 的并发扩展，模拟高并发场景，以便更容易地发现问题。

线程转储分析示例：

线程转储文件会包含类似下面的信息：

"Worker-1" #10 prio=5 os_prio=0 tid=0x000000001a8b4000 nid=0x2e18 waiting on condition [0x000000001b7ff000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x000000076c1c1930> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
        at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
        at java.lang.Thread.run(Thread.java:745)

从线程转储中，我们可以看到 Worker-1 线程处于 WAITING (parking) 状态，并且调用栈显示它正在等待 AbstractQueuedSynchronizer$ConditionObject.await() 方法。这表明线程可能正在等待某个条件满足，但由于某些原因，条件没有被触发，导致线程永久阻塞。

5. 防御性编程与最佳实践

为了避免 LockSupport 停车与唤醒不匹配的问题，可以采取以下防御性编程措施和最佳实践：

显式地使用 unpark()： 确保在所有可能的情况下，都有对应的 unpark() 方法被调用。
在异常处理中调用 unpark()： 在 try-catch 块中，即使发生了异常，也要确保 unpark() 方法能够被执行，可以使用 finally 块来实现。
避免在线程池中直接使用 LockSupport： 线程池中的线程生命周期由线程池管理，直接使用 LockSupport 容易导致线程泄漏。可以使用 Future、CountDownLatch、Semaphore 等更高级的并发工具来控制线程的唤醒。
使用并发集合类： java.util.concurrent 包中提供了许多线程安全的集合类，例如 BlockingQueue、ConcurrentHashMap 等，它们可以简化并发编程，并减少出错的可能性。
使用高级并发工具： java.util.concurrent 包中还提供了许多高级并发工具，例如 ExecutorService、Future、CountDownLatch、Semaphore 等，它们可以帮助你更好地管理线程和控制并发流程。
单元测试和集成测试： 编写充分的单元测试和集成测试，模拟各种并发场景，以便尽早发现问题。
代码审查： 进行代码审查，让其他开发人员检查你的代码，可以帮助发现潜在的问题。

表格：LockSupport 与 Object.wait()/Object.notify() 的比较

特性	`LockSupport`	`Object.wait()`/`Object.notify()`
许可机制	每个线程关联一个许可，可以是可用或不可用。	没有许可机制，依赖于对象监视器。
先 `unpark` 后 `park`	支持，即使 `unpark()` 在 `park()` 之前调用，线程仍然可以被唤醒。	不支持，`notify()` 必须在 `wait()` 之后调用，否则信号会丢失。
对象关联	不需要与任何对象关联。	必须在 `synchronized` 块中使用，与对象监视器关联。
灵活性	更灵活，可以用于更底层的并发控制。	相对简单，适用于简单的线程同步场景。
易用性	相对复杂，需要理解许可机制。	相对简单，但容易出现信号丢失等问题。

6. 一个更复杂的示例：使用 LockSupport 实现一个简单的阻塞队列

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.LockSupport;

public class SimpleBlockingQueue<T> {

    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;

    private Thread producer = null;
    private Thread consumer = null;

    public SimpleBlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == capacity) {
                producer = Thread.currentThread();
                LockSupport.park(); // 队列已满，生产者阻塞
            }
            queue.offer(item);
            if (queue.size() == 1) {
                if (consumer != null) {
                    LockSupport.unpark(consumer); // 唤醒消费者
                    consumer = null;
                }
            }
        }
    }

    public T take() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                consumer = Thread.currentThread();
                LockSupport.park(); // 队列为空，消费者阻塞
            }
            T item = queue.poll();
            if (queue.size() == capacity - 1) {
                if (producer != null) {
                    LockSupport.unpark(producer); // 唤醒生产者
                    producer = null;
                }
            }
            return item;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SimpleBlockingQueue<Integer> queue = new SimpleBlockingQueue<>(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();

        System.out.println("Finished.");
    }
}

这个例子展示了如何使用 LockSupport 实现一个简单的阻塞队列。生产者线程在队列满时阻塞，消费者线程在队列空时阻塞。通过 LockSupport.park() 和 LockSupport.unpark() 方法，可以实现线程的阻塞和唤醒。需要注意的是，在这个例子中，我们使用了 synchronized 块来保护队列的并发访问。同时，记录了producer和consumer线程，避免并发情况下的错误唤醒。

7. 避免死锁

在使用 LockSupport 时，需要特别注意避免死锁。死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的状态。以下是一些避免死锁的建议：

避免循环等待： 确保线程不会循环等待其他线程释放资源。
使用超时机制： 在 park() 方法中使用超时参数，避免线程永久阻塞。例如，可以使用 LockSupport.parkNanos(Object blocker, long nanos) 或 LockSupport.parkUntil(Object blocker, long deadline) 方法。
保持锁的顺序一致： 如果需要获取多个锁，确保所有线程都按照相同的顺序获取锁。
避免持有锁时进行阻塞操作： 尽量避免在持有锁时调用 park() 方法，因为这可能会导致死锁。

线程安全是关键，谨慎使用工具

LockSupport 是一个强大的工具，但需要谨慎使用。理解其工作原理，并采取防御性编程措施，可以帮助你编写更健壮的并发程序。在复杂的并发场景下，建议使用更高级的并发工具，例如 ExecutorService、Future、CountDownLatch、Semaphore 等，它们可以简化并发编程，并减少出错的可能性。务必记住，线程安全是并发编程中的核心目标，任何时候都不能忽视。

JAVA LockSupport 停车与唤醒不匹配导致线程无法恢复的问题排查

发表回复 取消回复

发表回复取消回复