Java线程关闭方式详解：优化多线程管理的多种策略

举报
bug菌 发表于 2024/09/30 17:59:33 2024/09/30
【摘要】 咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java SE相关知识点了，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹没了哦~🏆本文收录于「滚雪球学Java」专栏中，这个专栏专为有志于提升Java技能的你打造，覆盖Java编程的方方面面，助你从零基础到掌握Java开发的精髓。赶紧关注，收藏，学习吧！环境说明...

咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java SE相关知识点了，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹没了哦~

🏆本文收录于「滚雪球学Java」专栏中，这个专栏专为有志于提升Java技能的你打造，覆盖Java编程的方方面面，助你从零基础到掌握Java开发的精髓。赶紧关注，收藏，学习吧！

环境说明：Windows 10 + IntelliJ IDEA 2021.3.2 + Jdk 1.8

前言

随着应用程序复杂性的增加，多线程编程已经成为提升性能和并发处理能力的核心技术。然而，线程的管理问题也随之而来，尤其是如何优雅地关闭线程。一个错误的线程管理可能会导致死锁、内存泄漏以及系统资源被无谓地占用。本文将通过深入分析Java中的几种线程关闭方式，帮助开发者在复杂场景下实现线程的安全、高效管理。

线程关闭不仅仅是简单的停止它们的运行。要做到线程的安全关闭，必须考虑各种边界条件，比如线程是否处于等待、阻塞或执行中的状态，以及如何处理线程池中的未完成任务。因此，深入理解Java中不同的关闭方法，能够帮助开发者在并发场景中写出更加健壮、稳定的代码。

本文不仅介绍常见的线程关闭方式，还结合实践案例，帮助你在开发过程中更好地运用这些方法。

Java线程的生命周期及状态转换

在讨论线程关闭之前，先了解Java中线程的生命周期及其状态转换过程有助于我们更好地掌握线程关闭的时机和方法。Java线程有五种主要状态：

  1. 新建（New）：线程对象被创建，但尚未调用start()方法。
  2. 就绪（Runnable）：调用start()方法后，线程进入就绪状态，等待系统的CPU调度。
  3. 运行（Running）：线程获得CPU时间片，开始执行。
  4. 阻塞（Blocked）：线程由于等待某个资源（例如IO操作）而进入阻塞状态。
  5. 终止（Terminated）：线程执行结束或由于异常中止。

在管理线程生命周期的过程中，确保线程安全、优雅地从运行状态转换到终止状态，是线程管理的关键。接下来，我们将探讨几种常用的Java线程关闭方式，并深入分析它们的应用场景。

Java线程的关闭方式

1. 使用标志位控制线程关闭

标志位是一种常见的线程控制方法，适用于长时间运行的任务。通过设置一个共享的布尔变量，在线程的执行过程中不断检查该变量的状态，决定是否继续执行。这种方法简单、直观，但需要注意标志位的可见性问题，通常通过volatile关键字来确保多个线程能够准确看到标志位的更新。

实例代码：

class StoppableThread extends Thread {
    private volatile boolean running = true; // volatile保证变量的可见性

    public void run() {
        while (running) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
            try {
                Thread.sleep(1000); // 模拟工作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 恢复中断状态
            }
        }
        System.out.println("线程 " + Thread.currentThread().getName() + " 已停止");
    }

    public void stopThread() {
        running = false; // 设置标志位为false
    }
}

public class FlagExample {
    public static void main(String[] args) throws InterruptedException {
        StoppableThread thread = new StoppableThread();
        thread.start();
        Thread.sleep(3000); // 主线程等待3秒
        thread.stopThread(); // 安全停止线程
    }
}

这种方式适用于需要长时间运行，并且能够频繁检查状态的任务。但需要注意，标志位仅仅是一种温和的停止方法，线程必须主动检查标志位才能终止，无法处理立即中断的需求。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段Java代码定义了一个名为StoppableThread的线程类，它使用一个控制标志来优雅地停止线程。还有一个名为FlagExample的类，它演示了如何启动和停止StoppableThread线程。以下是代码的逐行解读：

StoppableThread 类

  1. 继承Thread类：

    • class StoppableThread extends Thread定义了一个名为StoppableThread的类，继承自Thread类。

  2. 定义控制变量：

    • private volatile boolean running = true;定义了一个running变量，用来控制线程的运行状态。volatile关键字确保变量的可见性，使得多个线程都能看到最新的值。
run 方法

  1. 运行循环：

    • public void run()重写了Thread类的run方法，这是线程执行的入口点。
    • while (running)使用一个while循环，只要running标志为true，线程就继续执行。

  2. 打印消息：

    • System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");打印一条消息，表明线程正在运行。

  3. 模拟工作：

    • Thread.sleep(1000);调用Thread.sleep方法使线程暂停1秒钟，模拟执行一项耗时的任务。

  4. 处理中断异常：

    • try { Thread.sleep(1000); } catch (InterruptedException e)在try块中捕获可能的InterruptedException异常。
    • Thread.currentThread().interrupt();如果线程在睡眠中被中断，捕获异常后调用interrupt()方法恢复中断状态。

  5. 停止线程：

    • System.out.println("线程 " + Thread.currentThread().getName() + " 已停止");当running标志设置为false时，循环结束，打印一条消息，表明线程已停止。
stopThread 方法
  1. 设置控制变量：
    • public void stopThread()定义了一个公共方法stopThread，用于外部控制线程停止。
    • running = false;将running标志设置为false，这样while循环会退出，线程将停止执行。
FlagExample 类

  1. 主方法：

    • public class FlagExample定义了一个名为FlagExample的公共类。
    • public static void main(String[] args)是程序的入口点。

  2. 启动线程：

    • StoppableThread thread = new StoppableThread();创建了StoppableThread的一个实例。
    • thread.start();调用start方法启动线程。

  3. 等待一段时间：

    • Thread.sleep(3000);主线程休眠3秒钟，给线程留出执行时间。

  4. 停止线程：

    • thread.stopThread();调用stopThread方法，通过改变running标志的值来通知线程停止执行。
总结

这个FlagExample类演示了如何使用控制标志来优雅地停止线程。通过定义一个running标志并提供一个公共方法stopThread来改变这个标志的值，可以安全地停止线程。这种方式比使用Thread.stop()方法更安全，因为Thread.stop()方法已经被废弃，它以非安全的方式终止线程，可能会导致资源泄露或者其他不可预知的问题。

注意事项

  • volatile关键字：使用volatile关键字确保running变量的可见性，使得多个线程都能看到最新的值。

  • 优雅停止：通过改变控制标志的值来通知线程停止，而不是强制停止，这样可以确保线程在停止前完成当前工作并释放资源。

  • 异常处理：在run方法中捕获InterruptedException并恢复中断状态，这是处理中断的推荐做法。

  • 资源清理：在实际应用中，应该在线程停止前进行适当的资源清理工作，如关闭文件流或网络连接。

2. 使用interrupt()方法

interrupt()方法是Java中一种标准的中断线程的方法，它允许在运行中的线程被中断。这种方法特别适用于需要中断阻塞操作（如Thread.sleep()或等待输入输出的线程）。当线程被interrupt()时，会抛出InterruptedException，此时可以通过捕获异常并进行相应处理来停止线程。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段Java代码演示了如何正确地中断一个线程，并在线程中优雅地处理中断。以下是代码的逐行解读：

InterruptibleThread 类
  1. class InterruptibleThread extends Thread 定义了一个名为InterruptibleThread的类，它继承自Thread类。
run 方法

  1. public void run() 重写了Thread类的run方法，这是线程执行的入口。

  2. try { 开始一个try块，用于捕获可能发生的异常。

  3. while (!isInterrupted()) 使用一个while循环，只要线程没有被中断，就继续执行。

  4. System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行..."); 打印一条消息，表示线程正在运行。

  5. Thread.sleep(1000); 调用Thread.sleep方法使线程暂停1秒钟，模拟执行一项耗时的任务。

  6. } catch (InterruptedException e) 捕获InterruptedException异常。

  7. System.out.println("线程 " + Thread.currentThread().getName() + " 已被中断"); 如果线程在sleep期间被中断，捕获异常后打印一条消息，表示线程已被中断。

InterruptExample 类
  1. public class InterruptExample 定义了一个名为InterruptExample的公共类。
main 方法

  1. public static void main(String[] args) 是程序的入口点。

  2. InterruptibleThread thread = new InterruptibleThread(); 创建了InterruptibleThread的一个实例。

  3. thread.start(); 调用start方法启动线程。

  4. Thread.sleep(3000); 主线程休眠3秒钟，给线程留出执行时间。

  5. thread.interrupt(); 调用interrupt方法请求中断线程。这会导致线程的中断状态被设置，如果线程处于sleep、wait或其他阻塞状态，将会抛出InterruptedException，并可在catch块中捕获该异常进行相应处理。

总结

这个InterruptExample类演示了如何请求中断一个线程，并在线程内部通过捕获InterruptedException来响应中断。通过检查线程的中断状态（使用isInterrupted()方法），可以在适当的时候退出循环或停止任务，从而优雅地终止线程。

注意事项

  • 中断状态：interrupt方法会设置线程的中断状态。即使线程捕获了InterruptedException，中断状态仍然保持设定状态，除非明确地清除。

  • 清理资源：在捕获InterruptedException后，应该进行适当的清理操作，如关闭文件流或网络连接。

  • 响应中断：最佳实践是，当捕获InterruptedException时，应该尽快退出正在执行的操作，并进行必要的清理工作。

  • 优雅中断：通过检查isInterrupted或捕获InterruptedException，可以使线程在中断时有机会进行清理工作，实现优雅中断。

实例代码：

class InterruptibleThread extends Thread {
    public void run() {
        try {
            while (!isInterrupted()) {
                System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行...");
                Thread.sleep(1000); // 模拟任务
            }
        } catch (InterruptedException e) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 已被中断");
        }
    }
}

public class InterruptExample {
    public static void main(String[] args) throws InterruptedException {
        InterruptibleThread thread = new InterruptibleThread();
        thread.start();
        Thread.sleep(3000); // 主线程等待3秒
        thread.interrupt(); // 请求中断线程
    }
}

这种方法的优势在于，能够中断阻塞状态中的线程，使其尽早结束。而且它提供了一种相对优雅的中断机制，适合用于那些需要长时间等待外部资源的场景。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

3. 使用ExecutorService的关闭方法

在现代Java应用中，通常不直接使用Thread类，而是使用ExecutorService来管理线程池。ExecutorService提供了shutdown()和shutdownNow()两种关闭线程池的方法。前者会等待已提交的任务执行完毕后关闭，而后者会立即中断所有正在执行的任务。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

实例代码：

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

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

        Runnable task = () -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
                try {
                    Thread.sleep(1000); // 模拟任务
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断状态
                }
            }
        };

        executor.submit(task);
        Thread.sleep(3000); // 主线程等待3秒
        executor.shutdown(); // 优雅地关闭线程池
        System.out.println("线程池已关闭");
    }
}

ExecutorService提供了一种更灵活的线程管理方式，特别适合在大规模并发环境中使用。通过shutdown()方法可以确保所有正在运行的任务得以安全完成，避免资源泄漏。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段Java代码演示了如何正确地中断一个线程，并在线程中优雅地处理中断。以下是代码的逐行解读：

InterruptibleThread 类
  1. class InterruptibleThread extends Thread 定义了一个名为InterruptibleThread的类，它继承自Thread类。
run 方法

  1. public void run() 重写了Thread类的run方法，这是线程执行的入口。

  2. try { 开始一个try块，用于捕获可能发生的异常。

  3. while (!isInterrupted()) 使用一个while循环，只要线程没有被中断，就继续执行。

  4. System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行..."); 打印一条消息，表示线程正在运行。

  5. Thread.sleep(1000); 调用Thread.sleep方法使线程暂停1秒钟，模拟执行一项耗时的任务。

  6. } catch (InterruptedException e) 捕获InterruptedException异常。

  7. System.out.println("线程 " + Thread.currentThread().getName() + " 已被中断"); 如果线程在sleep期间被中断，捕获异常后打印一条消息，表示线程已被中断。

InterruptExample 类
  1. public class InterruptExample 定义了一个名为InterruptExample的公共类。
main 方法

  1. public static void main(String[] args) 是程序的入口点。

  2. InterruptibleThread thread = new InterruptibleThread(); 创建了InterruptibleThread的一个实例。

  3. thread.start(); 调用start方法启动线程。

  4. Thread.sleep(3000); 主线程休眠3秒钟，给线程留出执行时间。

  5. thread.interrupt(); 调用interrupt方法请求中断线程。这会导致线程的中断状态被设置，如果线程处于sleep、wait或其他阻塞状态，将会抛出InterruptedException，并可在catch块中捕获该异常进行相应处理。

总结

这个InterruptExample类演示了如何请求中断一个线程，并在线程内部通过捕获InterruptedException来响应中断。通过检查线程的中断状态（使用isInterrupted()方法），可以在适当的时候退出循环或停止任务，从而优雅地终止线程。

注意事项

  • 中断状态：interrupt方法会设置线程的中断状态。即使线程捕获了InterruptedException，中断状态仍然保持设定状态，除非明确地清除。

  • 清理资源：在捕获InterruptedException后，应该进行适当的清理操作，如关闭文件流或网络连接。

  • 响应中断：最佳实践是，当捕获InterruptedException时，应该尽快退出正在执行的操作，并进行必要的清理工作。

  • 优雅中断：通过检查isInterrupted或捕获InterruptedException，可以使线程在中断时有机会进行清理工作，实现优雅中断。

MyCallable 类
  1. class MyCallable implements Callable<String> 定义了一个名为MyCallable的类，实现了Callable接口，并指定了返回类型为String。
call 方法

  1. public String call() 实现了Callable接口的call方法，这是Callable任务执行的入口。

  2. throws InterruptedException 声明方法可能抛出InterruptedException异常。

  3. 在call方法中：

    • for (int i = 0; i < 5; i++) 循环5次，模拟任务执行。
    • System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行..."); 打印当前执行任务的线程名称。
    • Thread.sleep(1000); 调用Thread.sleep方法使线程暂停1秒钟，模拟执行一项耗时的任务。

  4. return "任务完成"; 在任务执行完成后返回结果。

FutureExample 类
  1. public class FutureExample 定义了一个名为FutureExample的公共类。
main 方法

  1. public static void main(String[] args) 是程序的入口点。

  2. ExecutorService executor = Executors.newSingleThreadExecutor(); 创建了一个单线程的线程池。

  3. Future<String> future = executor.submit(new MyCallable()); 将MyCallable任务提交给线程池执行，并返回一个Future对象，该对象可以用来检查计算是否完成，并检索计算的结果。

  4. Thread.sleep(3000); 主线程休眠3秒钟，给任务留出执行时间。

  5. future.cancel(true); 调用Future对象的cancel方法请求取消任务。参数true表示通过中断执行任务的线程来尝试取消任务。

  6. System.out.println("任务已请求取消"); 打印一条消息，表示任务已请求取消。

  7. executor.shutdown(); 关闭线程池，不再接受新任务，等待已提交的任务执行完成。

总结

这个FutureExample类演示了如何使用Future和Callable来异步执行任务并尝试取消任务。通过ExecutorService提交Callable任务，可以返回一个Future对象，该对象可以用来控制和查询任务的执行状态。

注意事项

  • 任务取消：cancel方法的参数true表示通过中断线程来取消任务。如果任务已经完成或无法被中断，则取消操作可能不会成功。

  • 异常处理：在实际应用中，应该考虑任务执行过程中可能抛出的异常，并进行适当的异常处理。

  • 线程池关闭：调用shutdown方法后，线程池不会立即关闭，而是等待已提交的任务执行完成。如果需要立即关闭线程池，可以使用shutdownNow方法，但这会尝试立即终止所有正在执行的任务。

  • Future.get()：在本例中未使用Future.get()方法来获取任务的返回值。如果在任务取消之前调用get()，它将等待任务完成并返回结果；如果任务取消之后调用get()，它可能会抛出CancellationException。

4. 使用Future结合Callable任务控制线程

在某些情况下，你可能需要对任务进行更精确的控制。Future结合Callable允许你获取任务的返回结果，并提供取消任务的能力。通过Future的cancel()方法，开发者可以中断正在执行的任务。

实例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<String> {
    public String call() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
            Thread.sleep(1000); // 模拟任务
        }
        return "任务完成";
    }
}

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

        Thread.sleep(3000); // 主线程等待3秒
        future.cancel(true); // 请求取消
        System.out.println("任务已请求取消");

        executor.shutdown(); // 关闭线程池
    }
}

Future与Callable的结合，适用于那些需要返回结果的并发任务，特别是在需要灵活地取消任务时，能够提供更加精细的控制。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段Java代码演示了如何使用Future和Callable接口来异步执行任务并获取执行结果。以下是代码的逐行解读：

这段Java代码展示了如何使用 Callable 和 Future 来执行一个可以被取消的任务。下面我们将对代码进行详细解析，并探讨如何使用这些类在多线程编程中实现任务的并发执行和控制。

1. MyCallable 类
class MyCallable implements Callable<String> {
    public String call() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
            Thread.sleep(1000); // 模拟任务
        }
        return "任务完成";
    }
}
  • 实现 Callable 接口: MyCallable 类实现了 Callable<String> 接口，该接口允许线程返回结果并抛出异常。
  • 重写 call 方法: 在 call 方法中，使用一个循环来模拟任务执行。在每次循环中，打印当前线程的名称，并通过 Thread.sleep(1000) 模拟任务的耗时（1秒钟）。
  • 返回结果: 循环完成后，返回字符串 “任务完成”，表示任务执行完毕。
2. FutureExample 类
public class FutureExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());

        Thread.sleep(3000); // 主线程等待3秒
        future.cancel(true); // 请求取消
        System.out.println("任务已请求取消");

        executor.shutdown(); // 关闭线程池
    }
}
  • 创建线程池: 使用 Executors.newSingleThreadExecutor() 创建一个单线程的线程池。这意味着只有一个线程会被用来执行任务。
  • 提交任务: 调用 executor.submit(new MyCallable()) 提交任务，返回一个 Future<String> 对象，该对象用于跟踪任务的状态。
  • 主线程休眠: 主线程休眠3秒，模拟主线程与子线程的并发执行。
  • 请求取消: 调用 future.cancel(true) 请求取消任务。这里的 true 参数表示如果任务正在执行，则尝试中断该线程。
  • 关闭线程池: 最后调用 executor.shutdown() 关闭线程池，释放资源。
运行效果

在运行此代码时，控制台可能会看到如下输出（具体输出可能因线程调度而异）：

线程 pool-1-thread-1 正在执行...
线程 pool-1-thread-1 正在执行...
线程 pool-1-thread-1 正在执行...
任务已请求取消
可能的结果分析

  1. 任务被取消: 如果在任务执行过程中请求了取消，任务会被标记为取消，当前的 call 方法如果正在执行 Thread.sleep() 时会被中断，但不会直接停止。

  2. 没有执行完的返回值: 由于请求了取消，future.get() 方法在未执行完成的情况下不会返回任务结果。此时尝试获取结果会抛出 CancellationException。

  3. 需要处理中断: 如果希望能够处理任务被取消的情况，需要在 MyCallable 中检测中断状态，例如通过 Thread.currentThread().isInterrupted()，并在适当的时候退出任务。

示例改进

为了更好地处理任务取消和中断，可以对 MyCallable 类进行改进，使其能够响应中断：

class MyCallable implements Callable<String> {
    public String call() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("线程 " + Thread.currentThread().getName() + " 被中断，任务停止.");
                return "任务未完成";
            }
            System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
            Thread.sleep(1000); // 模拟任务
        }
        return "任务完成";
    }
}
关键改动
  • 检查中断状态: 在每次循环中检查当前线程是否被中断，如果被中断，打印相应信息并返回“任务未完成”。
小结

通过这个示例，我们了解了如何在Java中使用 Callable 和 Future 来执行可取消的任务。ExecutorService 提供了更为灵活的线程管理方式，允许我们提交多个任务、跟踪它们的状态，以及在需要时请求取消。同时，通过处理线程的中断状态，可以使得任务能够安全地响应取消请求，从而提高了程序的健壮性。

这种方式对于需要处理耗时操作的应用场景尤其有效，例如网络请求、文件处理等，可以在需要时优雅地终止任务。

MyCallable 类
  1. class MyCallable implements Callable<String> 定义了一个名为MyCallable的类，实现了Callable接口，并指定了返回类型为String。
call 方法

  1. public String call() 实现了Callable接口的call方法，这是Callable任务执行的入口。

  2. throws InterruptedException 声明方法可能抛出InterruptedException异常。

  3. 在call方法中：

    • for (int i = 0; i < 5; i++) 循环5次，模拟任务执行。
    • System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行..."); 打印当前执行任务的线程名称。
    • Thread.sleep(1000); 调用Thread.sleep方法使线程暂停1秒钟，模拟执行一项耗时的任务。

  4. return "任务完成"; 在任务执行完成后返回结果。

FutureExample 类
  1. public class FutureExample 定义了一个名为FutureExample的公共类。
main 方法

  1. public static void main(String[] args) 是程序的入口点。

  2. ExecutorService executor = Executors.newSingleThreadExecutor(); 创建了一个单线程的线程池。

  3. Future<String> future = executor.submit(new MyCallable()); 将MyCallable任务提交给线程池执行，并返回一个Future对象，该对象可以用来检查计算是否完成，并检索计算的结果。

  4. Thread.sleep(3000); 主线程休眠3秒钟，给任务留出执行时间。

  5. future.cancel(true); 调用Future对象的cancel方法请求取消任务。参数true表示通过中断执行任务的线程来尝试取消任务。

  6. System.out.println("任务已请求取消"); 打印一条消息，表示任务已请求取消。

  7. executor.shutdown(); 关闭线程池，不再接受新任务，等待已提交的任务执行完成。

小结

这个FutureExample类演示了如何使用Future和Callable来异步执行任务并尝试取消任务。通过ExecutorService提交Callable任务，可以返回一个Future对象，该对象可以用来控制和查询任务的执行状态。

注意事项

  • 任务取消：cancel方法的参数true表示通过中断线程来取消任务。如果任务已经完成或无法被中断，则取消操作可能不会成功。

  • 异常处理：在实际应用中，应该考虑任务执行过程中可能抛出的异常，并进行适当的异常处理。

  • 线程池关闭：调用shutdown方法后，线程池不会立即关闭，而是等待已提交的任务执行完成。如果需要立即关闭线程池，可以使用shutdownNow方法，但这会尝试立即终止所有正在执行的任务。

  • Future.get()：在本例中未使用Future.get()方法来获取任务的返回值。如果在任务取消之前调用get()，它将等待任务完成并返回结果；如果任务取消之后调用get()，它可能会抛出CancellationException。

5. 使用join()确保线程安全完成

join()方法可以让一个线程等待另一个线程执行完毕后再继续运行。在某些情况下，确保线程的执行顺序是很重要的，使用join()可以有效地避免并发冲突，确保线程的工作完整性。

实例代码：

class JoinThread extends Thread {
    public void run() {
        System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行...");
        try {
            Thread.sleep(3000); // 模拟工作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("线程 " + Thread.currentThread().getName() + " 已完成");
    }
}

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        JoinThread thread = new JoinThread();
        thread.start();
        thread.join(); // 等待线程完成
        System.out.println("主线程继续执行");
    }
}

使用join()确保了线程的有序执行，特别是在需要依赖某个线程结果的场景中，非常适用。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

6. 使用ScheduledExecutorService进行定时任务管理

如果你需要定时执行任务或周期性任务，`ScheduledExecutorService

`是一个非常好的选择。它允许你设置延迟执行或周期性执行的任务，并能够轻松管理线程的关闭。

实例代码

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        Runnable task = () -> System.out.println("定时任务执行，线程：" + Thread.currentThread().getName());

        scheduler.scheduleAtFixedRate(task, 0, 2, TimeUnit.SECONDS); // 每2秒执行一次
        Thread.sleep(10000); // 主线程等待10秒
        scheduler.shutdown(); // 关闭调度器
        System.out.println("调度器已关闭");
    }
}

使用ScheduledExecutorService，你可以方便地管理定时任务，非常适合处理周期性业务场景。

代码解析

  在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段Java代码演示了如何使用ScheduledExecutorService来安排定期执行的任务。以下是代码的逐行解读：

导入必要的类
  1. import java.util.concurrent.Executors; 导入了Executors类，用于创建线程池。
  2. import java.util.concurrent.ScheduledExecutorService; 导入了ScheduledExecutorService类，用于安排定时任务。
  3. import java.util.concurrent.TimeUnit; 导入了TimeUnit枚举，用于时间单位的转换。
ScheduledExecutorExample 类
  1. public class ScheduledExecutorExample 定义了一个名为ScheduledExecutorExample的公共类。
main 方法
  1. public static void main(String[] args) throws InterruptedException 是程序的入口点，声明了可能抛出的InterruptedException异常。
创建调度器
  1. ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); 创建了一个单线程的ScheduledExecutorService，用于安排任务的执行。
定义任务
  1. Runnable task = () -> System.out.println("定时任务执行，线程：" + Thread.currentThread().getName()); 定义了一个Runnable任务，打印出执行任务的线程名称。
安排任务
  1. scheduler.scheduleAtFixedRate(task, 0, 2, TimeUnit.SECONDS); 安排任务按照固定频率执行。
    • 第一个参数task是要执行的任务。
    • 第二个参数0是任务的初始延迟时间。
    • 第三个参数2是任务执行的周期，单位是秒。
    • 第四个参数TimeUnit.SECONDS是时间单位。
主线程等待
  1. Thread.sleep(10000); 主线程休眠10秒钟，给调度的任务留出执行时间。
关闭调度器

  1. scheduler.shutdown(); 关闭调度器，调度器关闭后将不再接受新任务，等待已提交的任务执行完成。

  2. System.out.println("调度器已关闭"); 打印消息表示调度器已关闭。

小结

这个ScheduledExecutorExample类演示了如何使用ScheduledExecutorService来安排定期执行的任务。通过scheduleAtFixedRate方法，可以安排任务按照指定的周期重复执行。这种机制在需要周期性执行任务的场景中非常有用，例如定时检查、定时报告生成等。

注意事项

  • 线程池关闭：调用shutdown方法后，线程池不会立即关闭，而是等待已提交的任务执行完成。如果需要立即关闭线程池，可以使用shutdownNow方法，但这会尝试立即终止所有正在执行的任务。

  • 异常处理：在实际应用中，应该考虑任务执行过程中可能抛出的异常，并进行适当的异常处理。

  • 任务执行频率：scheduleAtFixedRate方法确保任务按照固定的频率执行，但是实际执行间隔可能会受到任务执行时间的影响。如果任务执行时间较长，实际的执行频率可能会低于预期。

  • 定时任务与周期任务：ScheduledExecutorService提供了scheduleAtFixedRate和scheduleWithFixedDelay两种方法，前者是按固定频率执行，后者是在每次任务执行完毕后按照固定延迟再执行下一次。

总结

Java中关闭线程的方法有多种，开发者在选择时应根据具体需求进行综合考虑。使用标志位和interrupt()方法适合简单的多线程场景，而ExecutorService和Future提供了更为灵活和强大的控制方式。对于需要定时执行的任务，ScheduledExecutorService则是一个不错的选择。掌握这些关闭方法，不仅能提高代码的可维护性，还能在复杂的多线程环境中确保系统的稳定性和高效性。

希望通过本文的探讨，能够帮助你更好地理解Java线程的管理与关闭，提升你的编程技巧和对多线程技术的掌握。

☀️建议/推荐你

无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学Java」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门Java编程，就像滚雪球一样，越滚越大，指数级提升。

码字不易，如果这篇文章对你有所帮助，帮忙给bug菌来个一键三连(关注、点赞、收藏) ，您的支持就是我坚持写作分享知识点传播技术的最大动力。
  同时也推荐大家关注我的硬核公众号:「猿圈奇妙屋」 ；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有！

📣关于我

我是bug菌，CSDN | 掘金 | infoQ | 51CTO 等社区博客专家，历届博客之星Top30，掘金年度人气作者Top40，51CTO年度博主Top12，掘金等平台签约作者，华为云 | 阿里云| 腾讯云等社区优质创作者，全网粉丝合计30w+ ；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板等海量资料。

–End

【声明】本内容来自华为云开发者社区博主，不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息，否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

目录

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入