深入理解Java多线程：核心方法、状态与并发实践111

好的，作为一名专业的程序员，我将为您撰写一篇关于Java线程方法详解的优质文章，并配上一个符合搜索习惯的新标题。
---

在现代计算机系统中，并发编程已成为开发高性能、高响应性应用不可或缺的一部分。Java作为一门广泛应用于企业级开发的语言，其强大的多线程支持是其核心竞争力之一。理解Java线程的工作原理及其提供的各种方法，对于编写高效、稳定且易于维护的并发程序至关重要。本文将带您深入探索Java线程的核心方法，剖析线程的生命周期与状态，并探讨一些现代并发实践。

1. 线程的创建与启动：生命之旅的起点

在Java中，创建线程主要有两种方式，它们是线程生命周期的起点，而`start()`方法则是其真正执行的序章。

1.1 两种创建方式

1. 继承 `Thread` 类： 创建一个新类，继承自 ``，并重写其 `run()` 方法。`run()` 方法包含了线程要执行的任务逻辑。class MyThread extends Thread {
@Override
public void run() {
("通过继承Thread类创建的线程正在运行...");
}
}
// 使用：
// MyThread thread1 = new MyThread();
// ();

2. 实现 `Runnable` 接口： 创建一个类实现 `` 接口，并实现其 `run()` 方法。然后将这个 `Runnable` 实例作为参数传递给 `Thread` 类的构造器来创建 `Thread` 对象。class MyRunnable implements Runnable {
@Override
public void run() {
("通过实现Runnable接口创建的线程正在运行...");
}
}
// 使用：
// MyRunnable myRunnable = new MyRunnable();
// Thread thread2 = new Thread(myRunnable);
// ();

推荐使用 `Runnable` 接口方式： 这种方式更加灵活，因为它允许任务类继承其他类，并且可以将同一个 `Runnable` 对象传递给多个 `Thread` 实例，实现资源共享。`Thread` 类自身也实现了 `Runnable` 接口。

1.2 `start()` 与 `run()` 的区别

`public void start()`：
用于启动线程，使线程进入就绪（`RUNNABLE`）状态。
它会调用JVM底层方法，为新线程分配必要的系统资源，并最终由JVM调用该线程的 `run()` 方法。
每个线程只能调用一次 `start()` 方法，多次调用会导致 `IllegalThreadStateException`。
当 `start()` 方法执行后，主线程会继续执行，与新启动的线程并发运行。

`public void run()`：
包含了线程实际执行的任务代码。
如果直接调用 `run()` 方法，它将作为一个普通方法在当前线程中执行，而不是启动一个新线程。
线程的并发执行效果将无法实现。

2. 线程的生命周期与状态：理解其流转

Java线程具有六种基本状态，理解这些状态有助于我们更好地管理和调试线程。

枚举定义了以下状态：
`NEW` (新建)： 线程刚被创建，但尚未调用 `start()` 方法。
`RUNNABLE` (可运行/运行中)： 线程对象已调用 `start()` 方法，正在Java虚拟机中执行。操作系统中的线程调度器可能会选择运行此线程。线程可能正在运行，也可能正在等待CPU资源。
`BLOCKED` (阻塞)： 线程正在等待获取一个监视器锁（`synchronized` 关键字），以便进入一个同步方法或同步代码块。
`WAITING` (等待)： 线程无限期地等待另一个线程执行特定操作。例如，通过调用 `()`、`()` 或 `()`。
`TIMED_WAITING` (有时限等待)： 线程在指定的时间内等待另一个线程执行特定操作。例如，通过调用 `(long)`、`(long)`、`(long)`、`()` 或 `()`。
`TERMINATED` (终止)： 线程已执行完毕（`run()` 方法执行完成或因异常退出）。

3. 核心控制方法：管理线程的执行

Java `Thread` 类提供了一系列方法来控制线程的执行流程。

3.1 `sleep()`：暂停执行

`public static void sleep(long millis)`

`public static void sleep(long millis, int nanos)`
作用： 使当前正在执行的线程暂停指定的时间（毫秒或纳秒）。
特点： `sleep()` 是一个静态方法，它作用于当前正在执行的线程。它不会释放任何对象监视器锁（`synchronized` 块或方法持有的锁）。
异常： 可能会抛出 `InterruptedException`，这意味着在线程睡眠期间，有其他线程调用了它的 `interrupt()` 方法。
状态： 调用 `sleep()` 后，线程从 `RUNNABLE` 进入 `TIMED_WAITING` 状态。时间结束后或被中断后，再次进入 `RUNNABLE` 状态。

try {
(().getName() + " is going to sleep...");
(2000); // 暂停2秒
(().getName() + " woke up.");
} catch (InterruptedException e) {
(().getName() + " was interrupted while sleeping.");
().interrupt(); // 重新设置中断标志
}

3.2 `join()`：等待线程终止

`public final void join()`

`public final void join(long millis)`

`public final void join(long millis, int nanos)`
作用： 当前线程等待调用 `join()` 方法的那个线程执行完毕。
特点： 比如在主线程中调用 `()`，那么主线程会被阻塞，直到 `workerThread` 执行完毕。
异常： 可能会抛出 `InterruptedException`。
状态： 调用 `join()` 的线程从 `RUNNABLE` 进入 `WAITING` 或 `TIMED_WAITING` 状态。

Thread worker = new Thread(() -> {
try {
("Worker thread started.");
(3000);
("Worker thread finished.");
} catch (InterruptedException e) {
("Worker interrupted.");
().interrupt();
}
});
();
try {
("Main thread waiting for worker to finish.");
(); // 主线程等待 worker 线程完成
("Worker thread has joined, Main thread continues.");
} catch (InterruptedException e) {
("Main thread interrupted while waiting for worker.");
().interrupt();
}

3.3 `interrupt()` 相关方法：中断线程

Java通过协作式的方式处理线程中断，即发送一个中断请求，线程自己决定如何响应。
`public void interrupt()`： 实例方法。向目标线程发送一个中断请求，设置该线程的中断标志位为 `true`。如果目标线程当前正处于 `wait()`、`sleep()` 或 `join()` 等阻塞状态，它会立即退出阻塞状态，并抛出 `InterruptedException`。
`public boolean isInterrupted()`： 实例方法。检查该线程是否被中断。它只返回中断标志位的当前状态，不会清除标志位。
`public static boolean interrupted()`： 静态方法。检查 *当前线程* 是否被中断。与 `isInterrupted()` 不同的是，它会清除当前线程的中断标志位（将其设置为 `false`）。

使用场景： 通常用于请求线程优雅地终止其当前任务。Thread stoppableThread = new Thread(() -> {
while (!().isInterrupted()) { // 检查中断标志
("Stoppable thread is running...");
try {
(1000);
} catch (InterruptedException e) {
("Stoppable thread was interrupted!");
// 收到中断信号并抛出异常，此时中断标志已被清除
().interrupt(); // 重新设置中断标志，以便外层可以感知
break; // 退出循环
}
}
("Stoppable thread finished.");
});
();
try {
(3500); // 让线程运行一段时间
(); // 发送中断请求
} catch (InterruptedException e) {
().interrupt();
}

3.4 `yield()`：谦让CPU

`public static void yield()`
作用： 这是一个对线程调度器发出“我愿意让出CPU，以便其他优先级相同或更高的线程可以运行”的提示。
特点： `yield()` 的行为是高度依赖于JVM实现和操作系统的，不能保证线程会立即放弃CPU。它不会使线程进入阻塞状态，只是从 `RUNNABLE` 状态重新回到 `RUNNABLE` 队列中。
使用： 在实际开发中很少直接使用 `yield()`，因为它不可靠且难以控制。

4. 线程间协作方法：`wait()`、`notify()` 与 `notifyAll()`

这三个方法是 `Object` 类的方法，而非 `Thread` 类的方法，但它们是Java中实现线程间通信和同步的核心机制，通常用于“生产者-消费者”模型等场景。

重要前提： 这三个方法必须在 `synchronized` 代码块或同步方法中调用，并且作用于同一个对象监视器（锁）。

4.1 `wait()`：释放锁并等待

`public final void wait()`

`public final void wait(long timeout)`

`public final void wait(long timeout, int nanos)`
作用： 使当前线程进入等待状态，并释放其持有的对象监视器锁。
特点： 线程会进入此对象的等待队列，直到被 `notify()` 或 `notifyAll()` 唤醒，或者等待超时（对于带超时参数的 `wait()`）。被唤醒的线程会尝试重新获取锁，成功后才能继续执行。
异常： 可能会抛出 `InterruptedException`。
状态： 调用 `wait()` 的线程从 `RUNNABLE` 进入 `WAITING` 或 `TIMED_WAITING` 状态。
最佳实践： 应该总是在一个 `while` 循环中检查等待条件，以防止“假唤醒”（spurious wakeups）。

synchronized (this) {
while (conditionIsNotMet) { // 总是用while循环检查条件
try {
(); // 释放锁并等待
} catch (InterruptedException e) {
().interrupt();
// 处理中断
}
}
// 条件满足，继续执行
}

4.2 `notify()`：唤醒一个等待线程

`public final void notify()`
作用： 唤醒在此对象监视器上等待的线程中的一个。
特点： 如果有多个线程在等待，JVM会任意选择一个线程进行唤醒。被唤醒的线程会从 `WAITING` 或 `TIMED_WAITING` 状态回到 `BLOCKED` 状态，等待重新获取锁。`notify()` 不会立即释放锁。

4.3 `notifyAll()`：唤醒所有等待线程

`public final void notifyAll()`
作用： 唤醒在此对象监视器上等待的所有线程。
特点： 所有被唤醒的线程都会尝试重新获取锁。通常推荐使用 `notifyAll()` 而不是 `notify()`，以避免“信号丢失”或“死锁”等复杂问题，尤其是在不确定哪个线程应该被唤醒的情况下。

// 示例：生产者-消费者模型中的notify/wait
public class Buffer {
private int data;
private boolean isEmpty = true;
public synchronized void put(int value) throws InterruptedException {
while (!isEmpty) { // 缓冲区满，生产者等待
wait();
}
data = value;
isEmpty = false;
("Produced: " + data);
notifyAll(); // 唤醒消费者
}
public synchronized int get() throws InterruptedException {
while (isEmpty) { // 缓冲区空，消费者等待
wait();
}
int result = data;
isEmpty = true;
("Consumed: " + result);
notifyAll(); // 唤醒生产者
return result;
}
}

5. 已废弃或不推荐使用的方法：警惕潜在风险

Java在发展过程中，出于安全性和稳定性考虑，废弃了一些线程控制方法。了解它们为何被废弃，对于避免编写危险代码至关重要。

5.1 `stop()`：粗暴终止

`public final void stop()` (Deprecated)
问题： `stop()` 方法会立即终止线程，强制性地停止其执行。这可能导致线程在未释放其持有的所有锁资源的情况下突然中断，从而引发数据不一致、死锁或资源泄露等严重问题。
替代： 应该使用 `interrupt()` 机制，让线程自行判断何时以及如何安全地终止。

5.2 `suspend()` 与 `resume()`：死锁风险

`public final void suspend()` (Deprecated)

`public final void resume()` (Deprecated)
问题： `suspend()` 方法会挂起线程，但不会释放线程持有的任何锁。如果一个被 `suspend()` 的线程持有某个锁，并且尝试获取这个锁的线程又被 `suspend()` 的线程挂起，那么就可能导致死锁。`resume()` 用于恢复被挂起的线程。
替代： 应该使用 `wait()` 和 `notify()`（或 `notifyAll()`）来控制线程的暂停和恢复，因为 `wait()` 会释放锁。

6. 现代并发工具与最佳实践：超越原生Thread

虽然理解 `Thread` 的原生方法是基础，但在复杂的并发场景中，Java的 `` 包提供了更高级、更安全、更易用的并发工具。
`ExecutorService` 与 `ThreadPoolExecutor`： 线程池，用于管理和复用线程，避免频繁创建和销毁线程的开销，提高系统性能。
`Callable` 与 `Future`： `Callable` 类似于 `Runnable`，但它能返回结果并抛出异常。`Future` 用于获取 `Callable` 任务的执行结果。
`Lock` 接口及其实现 (如 `ReentrantLock`)： 提供了比 `synchronized` 关键字更灵活的锁机制，支持公平锁、可中断锁、超时锁等。
`Condition` 接口： 配合 `Lock` 使用，替代 `Object` 的 `wait()` / `notify()` / `notifyAll()`，提供更细粒度的线程协作控制。
原子操作类 (``)： 如 `AtomicInteger`、`AtomicLong`，提供了无锁（lock-free）的线程安全操作，通过CAS（Compare-And-Swap）算法实现。
并发集合 (``)： 如 `ConcurrentHashMap`、`CopyOnWriteArrayList`，提供了线程安全的集合类，避免手动同步。

最佳实践：
优先使用 `` 包中的高级并发工具，而不是直接操作 `Thread`。
合理设计线程池大小，避免资源耗尽。
理解同步机制（`synchronized`、`Lock`）的选择和使用场景。
谨慎处理线程中断，确保线程能够优雅地关闭。
避免共享可变状态，或者使用线程安全的方式进行访问。
使用并发工具时，务必阅读其Javadocs，理解其语义和限制。

Java线程方法是并发编程的基石。从 `start()` 启动线程到 `sleep()` 暂停、`join()` 等待，再到 `wait()` / `notify()` 实现线程间通信，每个方法都有其特定的作用和语义。深入理解这些方法及其对线程状态的影响，是编写健壮并发程序的关键。同时，随着Java并发API的不断发展，我们也应该积极拥抱 `` 包中的现代工具，以更高效、更安全的方式构建高性能的并发应用。---

2025-10-20

---

上一篇：Java高效数据处理：深入理解与实践方法分批返回策略

下一篇：深入理解 Java 转义字符：从基础到高级应用及最佳实践