Java 入门指南：Java 并发编程 —— LockSupport 线程阻塞唤醒类

news2024/9/22 5:37:16

LockSupport

LockSupport 是Java并发包中用于线程阻塞和唤醒的工具类。它提供了一种基于线程的阻塞和唤醒机制，类似于 Object 类中的 wait() 和 notify() 方法，但与 wait() 和 notify() 方法相比，LockSupport，它不依赖于对象的监视器锁，并且可以在任何地方对线程进行阻塞和唤醒操作。

主要方法

LockSupport 类的主要方法有：

park(): 当前线程阻塞，进入等待状态，直到被其他线程唤醒或被中断。
park(Object blocker): 当前线程阻塞，并关联一个对象，用于识别阻塞原因。
unpark(Thread thread): 唤醒指定的线程，如果线程之前没有被阻塞，则其后续 park() 方法会立即返回。
unpark(Object blocker): 唤醒与指定对象关联的线程，如果线程之前没有被阻塞，则其后续 park() 方法会立即返回。

特点

LockSupport 还具有以下特点：

线程可以在任意顺序下执行 park() 和 unpark() 方法，即使 unpark() 先于 park() 执行，阻塞的线程也不会错过唤醒信号。
LockSupport 提供的线程阻塞和唤醒是基于许可（permit）的。

每个线程都有一个关联的许可，默认情况下是未授权的。调用 park() 方法会使用掉一个许可，调用 unpark() 方法会授予一个许可。

如果线程在阻塞之前已经拥有一个许可，那么它在后续的 park() 方法调用时不会被阻塞。
LockSupport 提供了对线程中断的响应。如果线程在调用 park() 方法之前已经被中断，则 park() 方法会立即返回。

LockSupport 实现线程间的同步

假设我们有一个生产者线程和一个消费者线程，它们通过一个缓冲区进行通信。生产者将数据放入缓冲区，消费者从缓冲区读取数据。为了实现同步，我们使用 LockSupport 来控制线程的阻塞和唤醒。

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {

    private static final Object buffer = new Object();
    private static volatile boolean hasData = false;

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (buffer) {
                    while (hasData) {
                        LockSupport.park();
                    }
                    hasData = true;
                    System.out.println("Produced: " + i);
                    LockSupport.unpark(Thread.currentThread());
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (buffer) {
                    while (!hasData) {
                        LockSupport.park();
                    }
                    hasData = false;
                    System.out.println("Consumed: " + i);
                    LockSupport.unpark(Thread.currentThread());
                }
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

示例说明：

生产者线程：
- 当缓冲区中有数据时，生产者线程通过 LockSupport.park() 进入等待状态。
- 当消费者线程从缓冲区取走数据后，通过 LockSupport.unpark() 唤醒生产者线程。
消费者线程：
- 当缓冲区中没有数据时，消费者线程通过 LockSupport.park() 进入等待状态。
- 当生产者线程放入数据后，通过 LockSupport.unpark() 唤醒消费者线程。
同步控制：
- 使用 synchronized 语句块来确保对 buffer 和 hasData 的访问是同步的。
- 通过 LockSupport 的 park 和 unpark 方法来控制线程的阻塞和唤醒。

Dump 线程

在Java中，Dump线程 通常指的是生成线程转储（Thread Dump）的过程。线程转储是指捕获应用程序在某一时刻的所有线程的状态信息，包括线程ID、线程名称、当前执行的位置（堆栈跟踪）、锁信息等。线程转储对于诊断Java应用程序中的死锁、挂起或其他并发问题非常有用。

线程转储中包括着如以下的一些信息：

线程 ID 和名称：线程的唯一标识符和可读名称。
线程状态：线程的当前状态，例如运行（RUNNABLE）、等待（WAITING）、睡眠（TIMED_WAITING）或阻塞（BLOCKED）。
调用堆栈：线程的调用堆栈跟踪，显示线程从当前执行点回溯到初始调用的完整方法调用序列。
锁信息：如果线程正在等待或持有锁，线程转储通常还包括有关这些锁的信息。

生成线程转储

生成线程转储有多种方法，以下是几种常用的方法：

使用 jstack 命令

jstack 是JDK自带的一个命令行工具，用于生成线程转储。

jstack <pid>

其中 <pid> 是Java进程的PID。如果不知道PID，可以使用如下命令来查找：

jps

使用 Thread.dumpStack() 方法

在Java代码中，可以使用 Thread.dumpStack() 方法生成线程转储。但是这种方法通常不推荐在生产环境中使用，因为它会强制打印当前线程的堆栈跟踪，可能会干扰正常的程序执行。

public class ThreadDump {
    public static void main(String[] args) {
        Thread.dumpStack();
    }
}

使用 ManagementFactory API

Java Management Extensions (JMX) 提供了 ManagementFactory API，可以用来生成线程转储。

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.List;

public class ThreadDumpUsingAPI {
    public static void main(String[] args) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.getAllThreadIds();
        List<ThreadInfo> threadInfos = threadMXBean.getThreadInfo(threadIds);

        for (ThreadInfo info : threadInfos) {
            System.out.println(info);
        }
    }
}

LockSupport 观察线程转储

使用 LockSupport 阻塞一个线程，并且之后通过 IntelliJ IDEA 查看线程的堆栈信息（即所谓的线程转储），可以按照下面的步骤来做：

编写代码以使用 LockSupport 阻塞线程: 你可以创建一个简单的 Java 应用，在其中使用 LockSupport.park() 方法来阻塞某个线程。

![[Pasted image 20240902223249.png]]

启动应用并让线程阻塞: 启动应用，并确保线程进入了阻塞状态。
在 IntelliJ IDEA 中生成线程转储: 当线程处于阻塞状态时，打开 IntelliJ IDEA 并连接到正在运行的应用（如果它不是一个 IntelliJ IDEA 内部启动的进程，则需要附加到该进程）。之后，在 Run 面板中点击「attach debugger」

![[Pasted image 20240902223401.png]]