Java 线程管理详解：如何优雅地终止执行的线程

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

在上期文章中，我们讨论了 Java 中如何加载外部 JAR 文件，详细介绍了通过命令行、IDE以及动态加载的方式来集成外部库。在处理并发编程时，尤其在引入第三方库或复杂计算时，我们经常会使用多线程来提高程序的性能。然而，线程的生命周期管理常常是并发编程中的一大挑战，特别是当我们需要停止正在运行的线程时。

在本篇文章中，我们将重点讨论 Java 中如何kill掉执行的线程。尽管 Java 提供了丰富的线程管理工具，直接“杀死”线程的做法并不提倡。因此，我们将探讨线程的优雅终止方式，并结合代码解析、使用案例、应用场景分析等，为大家详细讲解如何安全地管理线程生命周期。

摘要

本文将围绕如何在 Java 中停止正在执行的线程展开讨论，着重讲解在并发编程中安全地终止线程的方式。通过源码解析、实际应用场景以及测试用例，本文将帮助您更深入地理解线程管理的原则，并学习如何在不影响程序稳定性的情况下终止线程。

概述

Java 中的线程管理是并发编程的核心。在许多语言中，终止一个正在执行的线程是比较直接的操作，但在 Java 中，设计者为了线程安全性和系统稳定性，并没有提供一种立即强制终止线程的机制。Java 虽然有一个 Thread.stop() 方法，但由于该方法会造成资源泄漏和数据不一致性问题，已经被废弃。

通常，我们需要通过 线程协作 的方式来让线程有序退出，比如：

• 使用 volatile 变量标记线程状态。
• 利用 Thread.interrupt() 发出中断信号。
• 在合适的地方捕获异常，优雅地退出线程。

接下来，我们将从多种方式入手，深入解析如何在 Java 中优雅地终止线程。

源码解析

1. 通过 volatile 标记位终止线程

使用 volatile 关键字可以标记线程的运行状态，通过检查标记位，让线程自主决定是否退出。

public class Task implements Runnable {
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 执行任务
            System.out.println("Thread is running...");
        }
        System.out.println("Thread is stopped.");
    }

    public void stop() {
        running = false;
    }
}

在上述代码中，线程的 run() 方法会不断检查 running 标志，外部通过 stop() 方法修改 running 为 false，从而让线程结束执行。

2. 使用 Thread.interrupt() 中断线程

另一种优雅终止线程的方式是使用 Thread.interrupt()。此方法不会立即终止线程，而是发送中断信号，线程可以选择在合适的时机响应并退出。

public class TaskWithInterrupt implements Runnable {
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                // 执行任务
                System.out.println("Thread is running...");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            // 捕获到中断异常，进行收尾工作
            System.out.println("Thread is interrupted.");
        }
    }
}

此代码中，线程通过 isInterrupted() 方法检查是否被中断，Thread.sleep() 时如果线程被中断，会抛出 InterruptedException 异常，并在 catch 块中执行收尾逻辑。

3. 使用 Future.cancel() 配合线程池终止任务

在使用线程池时，可以借助 Future.cancel() 方法来终止任务。此方法提供了 mayInterruptIfRunning 参数，用来决定是否中断正在执行的任务。

import java.util.concurrent.*;

public class TaskWithFuture implements Callable<String> {
    @Override
    public String call() throws Exception {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running...");
            Thread.sleep(1000);
        }
        return "Task Completed.";
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new TaskWithFuture());

        Thread.sleep(3000);  // 让线程运行一段时间
        future.cancel(true); // 尝试中断线程

        executor.shutdown();
    }
}

通过 future.cancel(true) 可以中断正在执行的任务，如果任务中支持中断操作，则线程会优雅退出。

使用案例分享

案例1：处理长时间运行的计算任务

在处理大数据计算或长时间运行的任务时，用户可能需要中途取消任务。通过 Thread.interrupt() 或 Future.cancel()，可以在不强制杀死线程的情况下安全地停止任务。

案例2：定时任务的控制

在某些场景下，定时任务需要根据业务规则灵活中止。例如，如果某些资源在特定时间点已经被处理完毕，则可以主动中断当前的定时任务线程，避免资源浪费。

应用场景分析

适用场景：

• 处理长时间运行的任务时需要提供取消操作。
• 定时任务或异步操作需要动态控制其执行状态。
• 需要安全且优雅地终止线程，避免强制关闭导致的不一致性。

不适用场景：

• 对实时性要求极高的任务，可能不适合通过这种“合作退出”的方式。
• 系统关键任务，如网络通信线程，不能随意终止。

优缺点分析

优点

• 提供了一种安全、可控的线程终止方式，避免了强制终止带来的数据不一致或资源泄露问题。
• 线程能够在合适的时机自行结束，给线程执行清理工作提供了机会。

缺点

• 线程终止并不是立即生效的，需要线程定期检查标志位或处理中断异常。
• 如果编写不当（如线程没有检查标志位或忽略中断信号），线程可能无法正常退出。

核心类方法介绍

Thread.interrupt()

Thread.interrupt() 方法用于向线程发送中断信号。被中断的线程会设置中断状态，可以通过 Thread.isInterrupted() 来检查线程是否被中断。

Thread.sleep()

Thread.sleep() 用于让线程暂停执行一段时间，期间如果线程被中断，则会抛出 InterruptedException。

Future.cancel()

在使用 ExecutorService 提交任务时，Future.cancel() 方法可以用于取消任务，并且可以选择是否中断正在执行的任务。

测试用例

测试1：通过标志位终止线程

import org.junit.Test;

public class TaskTest {

    @Test
    public void testStopThread() throws InterruptedException {
        Task task = new Task();
        Thread thread = new Thread(task);
        thread.start();

        Thread.sleep(3000);
        task.stop(); // 停止线程
        thread.join(); // 等待线程结束
    }
}

代码解析：

如下是具体的代码解析，希望对大家有所帮助：

这段Java代码定义了一个名为 TaskTest 的类，其中包含一个用于测试线程停止的单元测试方法 testStopThread。不过，代码中有几个问题需要注意：

1. Task 类没有给出，它应该是一个实现了 Runnable 接口的类，并且应该包含一个 stop 方法用于停止线程的执行。
2. 在Java中，官方不推荐使用 stop 方法来停止线程，因为 stop 方法已经被标记为过时（deprecated），并且它的使用是不安全的，因为它可以导致线程的资源无法正常释放。
3. 测试方法 testStopThread 中的 task.stop(); 调用暗示 Task 类有一个 stop 方法，但这样的方法不是标准的线程停止方式。
4. Thread.sleep(3000); 让主线程休眠3000毫秒（3秒），以确保被测试的线程有足够的时间执行。
5. thread.join(); 确保主线程等待被测试的线程结束。

为了正确地停止线程，通常推荐使用以下方法之一：

• 使用一个标志变量来告诉线程何时应该停止运行。
• 使用 ExecutorService 来管理线程，并通过 shutdownNow 方法尝试停止所有线程。

下面是一个改进的示例，使用标志变量来安全地停止线程：

import org.junit.Test;

public class TaskTest {

    static class Task implements Runnable {
        private volatile boolean running = true;

        @Override
        public void run() {
            while (running) {
                // 执行任务
            }
        }

        public void stop() {
            running = false;
        }
    }

    @Test
    public void testStopThread() throws InterruptedException {
        Task task = new Task();
        Thread thread = new Thread(task);
        thread.start();

        Thread.sleep(3000);
        task.stop(); // 停止线程
        thread.join(); // 等待线程结束
    }
}

在这个改进的示例中，Task 类有一个 running 标志变量，run 方法中的循环会检查这个变量。stop 方法将 running 设置为 false，从而允许循环结束，安全地停止线程。

测试2：通过 Thread.interrupt() 终止线程

import org.junit.Test;

public class TaskWithInterruptTest {

    @Test
    public void testInterruptThread() throws InterruptedException {
        Thread thread = new Thread(new TaskWithInterrupt());
        thread.start();

        Thread.sleep(3000);
        thread.interrupt(); // 中断线程
        thread.join(); // 等待线程结束
    }
}

通过这些测试用例，可以验证线程终止机制的有效性。

代码解析：

如下是具体的代码解析，希望对大家有所帮助：

这段Java代码定义了一个名为 TaskWithInterruptTest 的类，其中包含一个用于测试线程中断的单元测试方法 testInterruptThread。

下面是这段代码的详细解读：

1. import org.junit.Test;：导入了JUnit测试框架中的 Test 注解。
2. public class TaskWithInterruptTest { ... }：定义了一个名为 TaskWithInterruptTest 的公共类。
3. @Test：这是一个JUnit注解，表示接下来的方法是测试方法。
4. public void testInterruptThread() throws InterruptedException { ... }：定义了一个名为 testInterruptThread 的测试方法，它声明了可能抛出的 InterruptedException。
5. Thread thread = new Thread(new TaskWithInterrupt());：创建了一个新的 Thread 对象，将 TaskWithInterrupt 对象（实现了 Runnable 接口的任务）作为目标。
6. thread.start();：调用 start 方法启动新创建的线程。
7. Thread.sleep(3000);：主线程休眠3000毫秒（3秒），以确保被测试的线程有足够的时间执行。
8. thread.interrupt();：调用 interrupt 方法中断正在执行的线程。如果线程处于阻塞状态（如 sleep、wait 等），则会抛出 InterruptedException。
9. thread.join();：调用 join 方法等待线程结束。这确保了测试方法在被测试的线程完成之前不会结束。

注意：代码中提到的 TaskWithInterrupt 类没有给出，它应该是一个实现了 Runnable 接口的类。为了使测试有意义，TaskWithInterrupt 类应该在其 run 方法中适当处理中断，例如检查中断状态并相应地清理资源或提前退出。

总言之，我这个测试用例的目的是验证线程在执行过程中能够被中断。测试通过主线程休眠一段时间然后中断子线程，并通过 join 方法等待子线程结束来完成测试。这种测试可以帮助确保线程在接收到中断信号时能够正确地响应。

小结

通过本文，我们了解了在 Java 中如何通过 volatile 标志位、Thread.interrupt() 和 Future.cancel() 等方式优雅地终止线程。这些方法避免了直接“杀死”线程所带来的潜在问题，允许线程在收到退出信号后执行必要的清理工作，并且安全地结束。

总结

线程的终止在并发编程中是一个重要的课题。虽然 Java 不提供直接强制终止线程的方法，但通过协作式的终止手段（如 interrupt 和标志位），我们能够实现安全、优雅的线程管理。在实际开发中，根据应用场景选择适合的终止方式，既可以保证程序的灵活性，也可以确保系统的稳定性。

通过本文的学习，您应当能够应对 Java 线程的终止需求，并灵活地处理并发编程中的复杂场景。

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

... ...

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

***

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。