当前位置： 首页 > news >正文

纯干货!详解Java并发之线程中断机制

news 2024/12/26 23:12:55

基础知识

Java并发之线程中断

这个链接引入了外部一篇博文，个人觉得说的不错，对中断API及基本应用的一个认知，如果这些都不清楚，接下来的深入学习可能就丈二的和尚摸不着头脑

线程中断机制应用场景

线程中断机制工作原理：Java 中的线程中断机制是通过设置一个“中断标志位”来工作的。当一个线程被其他线程调用 interrupt() 方法时，这个线程的中断标志位将被设置为 true。此时，线程可以通过检查这个标志位决定是否退出执行或进行相应的处理。
主要的相关方法：
interrupt()：标记当前线程为中断状态。
isInterrupted()：检查线程是否已经被中断（不会清除中断标志）。
Thread.interrupted()：检查线程是否被中断（会清除中断标志位）。

中断机制不强制线程立即停止，而是一个通知机制，具体行为取决于线程自身的设计。当一个线程在调用 wait()、sleep() 或 join() 、take() 、put()等方法时，如果该线程被中断，会抛出 InterruptedException 异常，并且中断标志位被清除。

阻塞队列（BlockingQueue）实现中断机制

阻塞队列的工作原理
BlockingQueue 是 Java 中提供的一种线程安全的队列实现，它在多线程环境下非常有用，尤其适合生产者-消费者模式。常见的 BlockingQueue 实现包括：

  • ArrayBlockingQueue
  • LinkedBlockingQueue
  • PriorityBlockingQueue

BlockingQueue 提供了以下两类方法来插入和获取元素：

  • 阻塞方法：如果队列满了或空了，线程将会阻塞，直到队列状态改变。例如，put() 方法会在队列已满时阻塞，take() 方法会在队列为空时阻塞。
  • 非阻塞方法：立即返回，不会阻塞线程。例如，offer() 和 poll() 方法，它们会立即返回结果。
BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

线程中断与阻塞队列的结合

在使用 BlockingQueue 时，通常会涉及到多线程的生产者-消费者模式。如果某个线程在 BlockingQueue 上调用了阻塞操作（如 take() 或 put()），而同时需要终止该线程，通常会结合线程中断机制来优雅地退出阻塞操作。

BlockingQueue 的阻塞方法，如 take() 和 put()，在被中断时会抛出 InterruptedException。这种行为非常适合用于处理线程的优雅终止。当某个线程被请求中断时，可以通过捕获 InterruptedException 退出阻塞状态并进行资源的清理。

class Consumer implements Runnable {private BlockingQueue<String> queue;public Consumer(BlockingQueue<String> queue) {this.queue = queue;}@Overridepublic void run() {try {while (!Thread.currentThread().isInterrupted()) {String item = queue.take(); // 阻塞方法，会抛出 InterruptedExceptionprocessItem(item);}} catch (InterruptedException e) {System.out.println("Thread was interrupted, exiting gracefully.");Thread.currentThread().interrupt(); // 重新设置中断状态}}private void processItem(String item) {System.out.println("Processing: " + item);}
}

在这个例子中：

  • queue.take() 方法是一个阻塞操作，当队列为空时，它会使线程进入等待状态。
  • 当线程被中断时，会抛出 InterruptedException，从而跳出循环并执行线程终止的逻辑。
  • 在 catch 块中，重新调用 Thread.currentThread().interrupt() 来恢复线程的中断状态。

线程中断结合生产者-消费者模式

下面是一个完整的例子，展示了如何结合线程中断机制和阻塞队列来管理生产者和消费者线程：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;public class ProducerConsumerExample {public static void main(String[] args) throws InterruptedException {BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);Producer producer = new Producer(queue);Consumer consumer = new Consumer(queue);Thread producerThread = new Thread(producer);Thread consumerThread = new Thread(consumer);producerThread.start();consumerThread.start();// 运行一段时间后中断线程Thread.sleep(5000);producerThread.interrupt();consumerThread.interrupt();// 等待线程结束producerThread.join();consumerThread.join();System.out.println("All threads finished.");}
}class Producer implements Runnable {private BlockingQueue<String> queue;public Producer(BlockingQueue<String> queue) {this.queue = queue;}@Overridepublic void run() {int i = 0;try {while (!Thread.currentThread().isInterrupted()) {String item = "Item-" + i++;queue.put(item);  // 阻塞方法System.out.println("Produced: " + item);Thread.sleep(1000); // 模拟生产时间}} catch (InterruptedException e) {System.out.println("Producer was interrupted.");Thread.currentThread().interrupt(); // 重新设置中断状态}}
}class Consumer implements Runnable {private BlockingQueue<String> queue;public Consumer(BlockingQueue<String> queue) {this.queue = queue;}@Overridepublic void run() {try {while (!Thread.currentThread().isInterrupted()) {String item = queue.take();  // 阻塞方法System.out.println("Consumed: " + item);}} catch (InterruptedException e) {System.out.println("Consumer was interrupted.");Thread.currentThread().interrupt(); // 重新设置中断状态}}
}

代码解释：
生产者线程不断向队列中添加数据，使用 put() 方法，当队列满时会阻塞。
消费者线程不断从队列中获取数据，使用 take() 方法，当队列为空时会阻塞。
主线程休眠 5 秒后，通过调用 interrupt() 中断生产者和消费者线程，触发 InterruptedException，从而优雅退出线程

wait()、sleep()、join()、take() 和 put() 等方法中如何处理中断

InterruptedException 异常的抛出和中断标志位的清除是 Java 线程机制中的关键概念。要理解它们的源码实现，尤其是在 wait()、sleep()、join()、take() 和 put() 等方法中如何处理中断，我们需要探讨以下几个关键部分：

  1. 线程中断的核心原理：
    • 线程中断本质上是一个“请求”，即通过调用 Thread.interrupt() 方法通知线程它应当中断，但是否响应和如何响应中断由线程自身决定。
    • 每个线程都有一个中断标志位，当调用 interrupt() 时，标志位被设置为 true。
  2. InterruptedException 的抛出：
    • InterruptedException 通常会在线程被阻塞（例如在 wait()、sleep()、join() 等方法中）时抛出。
    • 抛出 InterruptedException 的关键在于阻塞时检测到线程被中断，并将该标志位清除，从而使得中断请求可以正确处理

我们可以从源码的角度来分析线程的中断机制在阻塞方法中的具体实现。

sleep() 方法的实现

Thread.sleep() 方法用于让当前线程休眠一段时间。在休眠期间，如果线程被中断，会抛出 InterruptedException。

sleep() 源码实现（摘自 Thread.java）

public static void sleep(long millis) throws InterruptedException {if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}// 调用本地方法实现真正的睡眠if (millis == 0) {return;}long startTime = System.currentTimeMillis();long remaining = millis;// 在睡眠过程中不断检查是否被中断while (remaining > 0) {try {Thread.sleep(remaining);return;} catch (InterruptedException e) {// 如果线程被中断，则抛出 InterruptedException，并清除中断标志throw e;} finally {remaining = millis - (System.currentTimeMillis() - startTime);}}
}

工作原理：
sleep() 调用了一个 JVM 本地方法 Thread.sleep(remaining)，它在底层阻塞线程。
如果线程在睡眠期间被中断，JVM 会检测到中断标志位并抛出 InterruptedException。
抛出异常时，中断标志会被自动清除。
在底层，Thread.sleep() 实际上是通过 JVM 的本地方法来完成的，这些本地方法会检测到线程的中断状态，并主动抛出 InterruptedException。

wait() 方法的实现

Object.wait() 方法使得当前线程等待，直到其他线程调用 notify() 或 notifyAll()，或者线程被中断。

wait() 源码实现（摘自 Object.java）

public final void wait(long timeout) throws InterruptedException {if (timeout < 0) {throw new IllegalArgumentException("timeout value is negative");}synchronized (this) {// 当线程调用 wait() 时，JVM 内部会检查中断状态if (Thread.interrupted()) {throw new InterruptedException();}// 调用本地方法，执行实际的等待操作wait(timeout, 0);}
}

工作原理：
调用 wait() 时，线程必须先获得锁（synchronized 块），然后进入等待状态。
Thread.interrupted() 检查线程是否已经被中断，如果是，则抛出 InterruptedException。
如果线程在 wait() 状态中被中断，则 JVM 会通过内部机制抛出 InterruptedException，并清除中断标志。

join() 方法的实现

Thread.join() 方法允许一个线程等待另一个线程的结束。如果在等待过程中当前线程被中断，则抛出 InterruptedException。

join() 源码实现（摘自 Thread.java）

public final synchronized void join(long millis) throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (millis == 0) {while (isAlive()) {wait(0);  // 阻塞等待目标线程终止}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);  // 阻塞等待指定时间或线程终止now = System.currentTimeMillis() - base;}}
}

工作原理：
join() 方法通过 wait() 实现，当目标线程存活时，当前线程进入等待状态。
如果当前线程被中断，wait() 方法会抛出 InterruptedException，并清除中断标志。

take() 和 put() 方法（以 ArrayBlockingQueue 为例）

take() 和 put() 是 BlockingQueue 的阻塞方法。当队列为空或满时，调用 take() 或 put() 的线程将被阻塞，直到满足条件。如果线程在阻塞过程中被中断，则抛出 InterruptedException。

take() 源码实现（摘自 ArrayBlockingQueue.java）

public E take() throws InterruptedException {final ReentrantLock lock = this.lock;lock.lockInterruptibly();  // 获取锁，并允许被中断try {while (count == 0) {   // 队列为空，进入等待notEmpty.await();  // 阻塞，直到队列不为空}return dequeue();      // 取出元素} finally {lock.unlock();         // 解锁}
}

put() 源码实现（摘自 ArrayBlockingQueue.java）

public void put(E e) throws InterruptedException {if (e == null) throw new NullPointerException();final ReentrantLock lock = this.lock;lock.lockInterruptibly();  // 获取锁，并允许被中断try {while (count == items.length) {  // 队列已满，进入等待notFull.await();             // 阻塞，直到队列不满}enqueue(e);                      // 插入元素} finally {lock.unlock();                   // 解锁}
}

工作原理：
take() 和 put() 方法都会在必要时阻塞线程。
使用 lockInterruptibly() 获取锁，这意味着如果线程被中断，线程会立即抛出 InterruptedException。
阻塞时通过条件变量（Condition）的 await() 方法进入等待状态。
如果线程被中断，await() 会抛出 InterruptedException，并退出阻塞状态。

Thread.interrupt() 如何清除中断标志

当 InterruptedException 被抛出时，线程的中断标志位会被自动清除。这是由 JVM 在处理 InterruptedException 时自动完成的。例如，当 Thread.sleep() 或 wait() 方法抛出 InterruptedException 时，JVM 内部会自动清除该线程的中断状态。

在 Thread.sleep() 和 wait() 这样的阻塞方法内部，检测到线程中断时，会先处理中断标志，并且在抛出 InterruptedException 的同时清除中断标志位。这就是为什么在捕获 InterruptedException 后，通常需要调用 Thread.currentThread().interrupt() 重新设置中断状态，以便线程的上层逻辑能够感知到中断。

总结
中断检测：sleep()、wait()、join()、take() 和 put() 方法在阻塞时会检查线程的中断状态，如果检测到线程中断，则抛出 InterruptedException。
中断标志清除：当抛出 InterruptedException 时，线程的中断标志位会被自动清除，因此在处理 InterruptedException 时，通常需要手动重新设置中断状态。
源码中的核心机制：通过 Thread.interrupted()、Condition.await() 等底层机制来检测和处理线程的中断。

如果检测到了中断抛出了异常 接下来如何处理呢

中断检测与异常抛出

如果线程在等待获取锁的过程中被中断，lockInterruptibly() 内部通过 Thread.interrupted() 检测到中断，随后会抛出 InterruptedException。这个异常抛出过程在 AbstractQueuedSynchronizer.acquireInterruptibly() 方法中发生：

if (Thread.interrupted())  // 检查线程是否被中断throw new InterruptedException();

一旦检测到中断，该线程不会继续尝试获取锁，而是直接抛出 InterruptedException 并结束当前的锁获取操作。这意味着线程不再进入队列或者继续等待获取锁，而是直接退出锁获取流程。

异常捕获与处理

通常调用 lockInterruptibly() 的代码会使用 try-catch 块捕获 InterruptedException，在捕获异常后，开发者可以决定如何处理线程的中断状态。常见的处理方式包括：

  • 停止当前任务：中断信号经常用于通知线程应该停止当前任务，因此线程可以选择结束当前逻辑。
  • 清理资源：在任务结束之前，可以释放资源、关闭文件、回滚事务等。
  • 重新设置中断状态：中断标志在抛出 InterruptedException 后会被清除。如果需要上层逻辑知道该线程已经被中断，通常需要重新设置中断标志。

以下是典型的异常捕获模式：

try {lock.lockInterruptibly();  // 尝试获取锁并响应中断// 执行临界区代码
} catch (InterruptedException e) {// 处理中断，例如停止任务或恢复中断标志Thread.currentThread().interrupt();  // 恢复中断状态// 清理资源或采取其他措施
} finally {if (lock.isHeldByCurrentThread()) {lock.unlock();  // 确保在获取锁后释放}
}

在这个例子中：

  • 捕获 InterruptedException 后，可能会进行一些资源清理。
  • 通常会重新设置中断标志 Thread.currentThread().interrupt()，以便上层逻辑能够感知到线程的中断状态。
  • 最后，在 finally 块中确保如果当前线程获取了锁，那么在退出时会释放锁。

中断的进一步传播或停止

根据业务需求，中断信号可以被进一步传播或者被“吞掉”：

  • 重新中断线程：在某些情况下，当前任务处理完毕后可能希望继续保持中断状态，以便上层逻辑能够处理。例如，在线程池中，中断信号可能要传递给上层管理逻辑。在这种情况下，可以通过 Thread.currentThread().interrupt() 恢复中断状态。
catch (InterruptedException e) {Thread.currentThread().interrupt();  // 恢复中断状态
}
  • 终止当前线程：如果线程的中断信号是一个通知，表明该线程应该被终止，捕获到 InterruptedException 后可以退出循环或者方法，从而停止线程的工作
catch (InterruptedException e) {// 处理逻辑，例如停止任务或退出方法return;  // 退出当前方法
}
  • 资源清理：中断经常用于在执行耗时任务时通知线程应该尽早退出。因此，捕获 InterruptedException 后可能会进行一些必要的清理工作。例如，关闭打开的资源，释放锁或者文件句柄，取消数据库事务等。
catch (InterruptedException e) {// 执行资源清理，例如释放锁、关闭文件等if (lock.isHeldByCurrentThread()) {lock.unlock();}
}

常见的使用场景和处理策略

线程池中的任务中断

在使用 ExecutorService 或其他线程池执行任务时，线程可能会被中断。例如，当线程池被关闭或者任务超时时，线程会接收到中断信号。在这种情况下，捕获 InterruptedException 可以决定任务是否应该提前终止，或者如何处理已经执行的部分任务。

try {lock.lockInterruptibly();// 业务逻辑
} catch (InterruptedException e) {Thread.currentThread().interrupt();  // 恢复中断状态，以便线程池处理
} finally {lock.unlock();  // 确保锁的释放
}

阻塞队列中的中断处理

在 BlockingQueue（如 ArrayBlockingQueue）的 take() 和 put() 操作中，线程可能会因阻塞而被中断。在这种情况下，InterruptedException 也会抛出，并允许程序逻辑适当响应。

try {queue.put(element);  // 阻塞直到队列中有空间
} catch (InterruptedException e) {// 中断处理逻辑，比如退出循环或终止任务return;
}

总结：
1、lockInterruptibly() 允许线程在等待锁的过程中响应中断。检测到中断时，会抛出 InterruptedException。
2、当 InterruptedException 被抛出时，捕获异常后可以采取各种处理措施，例如资源清理、停止任务、恢复中断状态等。
3、恢复中断状态的操作通常是通过 Thread.currentThread().interrupt()，因为抛出 InterruptedException 后，中断标志会被清除。

捕获到中断异常为何还需要恢复中断标识？

比如下面这行代码块：

try {lock.lockInterruptibly();// 业务逻辑
} catch (InterruptedException e) {Thread.currentThread().interrupt();  // 恢复中断状态，以便线程池处理
} finally {lock.unlock();  // 确保锁的释放
} 
为什么还需要恢复中断标识呀

在 catch 块中调用 Thread.currentThread().interrupt(); 重新设置中断标志的原因是：InterruptedException 被捕获时，线程的中断标志位已经被清除，但程序通常希望上层代码或调用者知道线程已经被中断过。恢复中断标志可以让调用者继续处理或感知到这个中断状态。

我们换一个更简单的例子来说明 为什么需要恢复中断标志，以及如果不恢复中断标志可能会带来什么问题。

下载文件的任务

假设我们有一个任务，它会从网络上下载文件。我们希望这个任务能够响应中断，比如当用户取消下载时，线程可以优雅地停止工作。为了模拟任务下载的行为，我们会在任务中使用 Thread.sleep() 来模拟等待（类似网络请求耗时操作），并且让它能响应中断。

不恢复中断标志的情况
public class DownloadTask implements Runnable {@Overridepublic void run() {try {System.out.println("Start downloading...");Thread.sleep(5000);  // 模拟下载时间，可能被中断System.out.println("Download complete.");} catch (InterruptedException e) {// 捕获到中断异常，但不恢复中断标志System.out.println("Download was interrupted.");}// 继续做一些事情System.out.println("Cleaning up after download...");}
}

在这个例子中，任务在 Thread.sleep(5000) 时可能会被中断，触发 InterruptedException。我们捕获到异常后，只是打印了一条消息，没有恢复中断标志。即便任务被中断了，任务的后续代码（如 System.out.println(“Cleaning up after download…”)）还是会继续执行。
执行流程：

  1. 任务开始下载（模拟的等待）。
  2. 在等待过程中，假如任务被中断，抛出 InterruptedException。
  3. 捕获异常，打印“Download was interrupted.”。
  4. 没有恢复中断标志，线程的中断状态被清除。
  5. 任务继续执行“清理”操作，并打印“Cleaning up after download…”。

结果：
即使下载被中断了，任务还是会继续执行后续的“清理”代码，而线程已经失去了中断状态。如果这个任务是在一个线程池中运行，线程池无法感知到这个线程的中断状态，可能会让它继续执行其他任务。

恢复中断标志的情况
public class DownloadTask implements Runnable {@Overridepublic void run() {try {System.out.println("Start downloading...");Thread.sleep(5000);  // 模拟下载时间，可能被中断System.out.println("Download complete.");} catch (InterruptedException e) {// 捕获到中断异常，并恢复中断标志System.out.println("Download was interrupted.");Thread.currentThread().interrupt();  // 恢复中断标志}// 检查中断标志，决定是否继续执行后续代码if (Thread.currentThread().isInterrupted()) {System.out.println("Thread is interrupted, stopping further execution.");return;  // 停止后续操作}System.out.println("Cleaning up after download...");}
}

在这个版本中，我们捕获到 InterruptedException 后，使用 Thread.currentThread().interrupt() 恢复了线程的中断标志。接下来，在任务的后续部分，我们检查 Thread.currentThread().isInterrupted()，并在检测到线程已经中断时，停止进一步的操作。

执行流程：

  1. 任务开始下载（模拟的等待）。
  2. 在等待过程中，假如任务被中断，抛出 InterruptedException。
  3. 捕获异常，打印“Download was interrupted.”。
  4. 恢复中断标志，线程的中断状态被重新设置为 true。
  5. 检查中断状态，发现线程已经被中断，打印“Thread is interrupted, stopping further execution.”。
  6. 任务终止，未执行后续的“清理”操作。

结果：
恢复了中断标志后，我们能够在后续代码中感知到线程被中断，任务会优雅地停止，不会继续执行无意义的代码。

为什么恢复中断标志很重要？
如果线程的中断标志被清除（即没有恢复中断标志），上层代码或者其他代码模块将无法知道线程曾经被中断过。例如：
1、在复杂的多线程环境中，某些任务的中断状态是关键的，如果你捕获了 InterruptedException 但不恢复中断标志，后续的代码或者其他线程会认为这个线程没有被中断过，导致逻辑错误。
2、在线程池中，线程被中断后，如果中断标志被清除，线程池的管理逻辑可能无法正确地管理线程，可能会继续分配任务给一个应该已经中断的线程。
总结：
通过恢复中断标志，可以让后续的代码或者上层管理逻辑感知到线程曾经被中断，从而做出正确的决策，比如停止执行后续任务或让线程池不再继续分配任务给该线程。

那既然都需要恢复 为什么还需要捕获呢 ？

这个问题很关键！为什么我们既然要恢复中断标志，为什么还要捕获 InterruptedException？其实，捕获和恢复中断标志是各有目的的。捕获 InterruptedException 允许我们在线程被中断时执行一些必要的操作，而恢复中断标志确保线程的中断状态能够被正确传递到上层。下面详细解释两者的必要性。

为什么需要捕获 InterruptedException？

当线程被中断时，像 Thread.sleep()、Object.wait() 或 BlockingQueue.take() 这样的阻塞操作都会抛出 InterruptedException。如果不捕获这个异常，程序会因为未处理的异常而终止。这时，捕获 InterruptedException 可以让你：

  • 清理资源：在线程被中断的情况下，你可以在 catch 块中释放锁、关闭文件或网络连接等，以避免资源泄露。
  • 记录日志：你可以记录中断信息，这在调试或监控中可能非常重要。可以帮助开发人员了解系统中哪些任务被中断了。
  • 自定义行为：捕获异常后，可以做出相应的自定义处理，比如决定是否重试操作、停止任务或执行特定的业务逻辑。

为什么还需要恢复中断标志？

捕获异常后，中断标志会被自动清除，导致上层代码无法感知到这个中断。因此，恢复中断标志 是为了确保：

  • 上层代码感知中断：线程的调用方（比如线程池、主线程）通常依赖中断标志位来判断线程是否应该被终止。如果捕获了 InterruptedException 而不恢复标志，调用方会误以为线程没有被中断，可能继续让它执行其他任务或工作。
  • 后续阻塞操作能够快速响应中断：当中断标志被重新设置为 true，后续再调用像 Thread.sleep() 或 BlockingQueue.take() 这样的操作时，这些方法会立即抛出 InterruptedException，而不会再次进入阻塞状态。

捕获和恢复中断标志相结合的完整例子：
我们以一个例子来说明捕获异常的作用以及为什么要恢复中断标志。

例子：文件上传的场景
假设我们有一个文件上传任务，上传过程中可能会被用户中断。任务需要确保在中断时进行清理工作，比如删除临时文件，确保不会继续占用存储资源。同时，我们希望线程能够正确传递中断信号到上层，以便调用方能够感知到这个任务已被中断。

public class FileUploadTask implements Runnable {@Overridepublic void run() {try {System.out.println("Start uploading file...");// 模拟长时间上传for (int i = 0; i < 5; i++) {// 每次上传一部分，可能会被中断Thread.sleep(1000);  // 模拟阻塞操作System.out.println("Uploaded part " + (i + 1));}System.out.println("File upload complete.");} catch (InterruptedException e) {// 捕获异常，进行清理操作System.out.println("Upload was interrupted, cleaning up...");// 删除临时文件（假设有这样一个方法）deleteTemporaryFile();// 恢复中断标志Thread.currentThread().interrupt();}// 如果线程被中断，停止进一步执行if (Thread.currentThread().isInterrupted()) {System.out.println("Thread is interrupted, stopping further execution.");return;  // 终止后续代码}// 假设还需要继续处理上传结果的操作System.out.println("Processing upload result...");}private void deleteTemporaryFile() {System.out.println("Temporary file deleted.");}
}

解释：

  1. 捕获异常的作用：

    • 当线程被中断时，上传操作正在进行中，比如调用 Thread.sleep()。此时，抛出 InterruptedException。
    • 我们捕获这个异常，执行清理工作——删除上传的临时文件。
    • 如果不捕获 InterruptedException，上传中的文件可能会一直保留在系统中，占用空间，造成资源泄漏。

  2. 恢复中断标志的作用：

    • 捕获异常后，线程的中断标志已经被清除，但我们希望让上层代码知道这个线程被中断过。
    • 调用 Thread.currentThread().interrupt() 恢复中断标志，确保后续的代码能够感知到线程被中断。
    • 恢复中断标志后，接下来的代码 if (Thread.currentThread().isInterrupted()) 能够检测到线程的中断状态，从而决定停止进一步操作。

  3. 清理与恢复的关系：

    • 在清理工作（删除临时文件）完成后，通过 Thread.currentThread().interrupt() 恢复中断标志，保证后续逻辑能够正确判断中断状态，而不会继续执行上传结果处理的逻辑。

为什么不直接抛出异常，而需要捕获？

如果不捕获异常，那么抛出的 InterruptedException 会向上层传播，可能会导致整个线程直接退出。如果你不想让线程立即退出，而是希望在中断时执行一些善后处理（如清理、日志记录等），就需要捕获异常。

比如，假如在上传过程中遇到了中断，我们不仅仅想终止任务，还想确保上传过程中创建的临时文件被删除。这就需要你在捕获异常后执行清理操作。

总结：
捕获 InterruptedException 的目的：是为了在中断时执行特定的业务逻辑，比如清理资源、记录日志等，而不是让线程立即退出。
恢复中断标志的目的：是为了确保中断信号不被“吞掉”，让上层代码或者后续操作能够感知到线程曾经被中断，从而做出正确的响应。
这两者结合起来，既可以在捕获异常时完成必要的清理工作，又可以保持中断状态的传递，确保整个系统能正确处理线程的中断请求。


http://www.mrgr.cn/news/48071.html

相关文章：

  • 05.HTTPS的实现原理-HTTPS的握手流程（TLS1.2）
  • Docker完整技术汇总
  • PCL-计算点云AABB包围盒
  • 1.系统学习-线性回归
  • Mongoose入门教程
  • 【数据结构练习题】链表与LinkedList
  • Docker理念
  • Android Studio 安装和认识
  • SpringBoot集成Redis
  • 牛上脑和各类牛排的叫法，不要土老帽了~
  • v-html里面的标签设置样式没有用怎么办？
  • 【Linux调试工具】gdb/cgdb
  • 文件之间的输入输出
  • 在python中如何判断回文串（一）？
  • Linux内核 --内存管理之 Slab 分配器介绍
  • 太速科技-628-基于VU3P的双路100G光纤加速计算卡
  • Docker 入门篇
  • 【前端碎片记录】大文件分片上传
  • 【selenium】webdriver测试脚本
  • 常用的web服务器简述
  • ubuntu24 finalshell 无法连接ubuntu服务器， 客户端无法连接ubuntu, 无法远程连接ubuntu。
  • go开发环境设置-安装与交叉编译
  • 【C++进阶】关联式容器map的使用
  • Ubuntu安装Apache教程
  • 排队论:根据λ（到达率）和 μ（服务率）的用户等待时间公式
  • 打开传奇提示connection closed是什么意思？怎么解决？