在 Spring Boot 中优雅地停止正在运行的函数并启动新函数

心靈之曲

发布时间：2025-10-04 13:42:01

204人浏览过

来源于php中文网

原创

在 spring boot 中优雅地停止正在运行的函数并启动新函数

摘要：本文旨在提供一种在 Spring Boot 应用中优雅地停止长时间运行的任务，并允许启动新任务的方法。通过使用线程管理和唯一标识符，我们可以安全地中断正在执行的任务，避免资源浪费和潜在的并发问题。本文将提供详细的代码示例和解释，帮助开发者理解和实现这一功能。

在 Spring Boot 应用中，有时我们需要执行一些长时间运行的任务，例如日志记录、数据处理等。这些任务通常在一个独立的线程中运行，以避免阻塞主线程。然而，在某些情况下，我们可能需要停止这些正在运行的任务，并启动新的任务。以下提供一种使用线程和唯一 ID 来管理和停止后台任务的有效方法。

使用线程和唯一 ID 管理任务

核心思想是创建一个后台线程，并将其引用（以及可选的唯一ID）保存在一个数据结构中。当需要停止任务时，可以通过ID获取线程引用，并中断它。

1. 创建线程安全的线程存储

首先，我们需要一个线程安全的数据结构来存储线程的引用。ConcurrentHashMap 是一个不错的选择，因为它允许多个线程同时访问和修改它。

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

private static volatile Map threadlookup = new ConcurrentHashMap<>();

threadlookup 是一个静态的 ConcurrentHashMap，用于存储线程的唯一标识符 (UUID) 和线程对象之间的映射关系。volatile 关键字确保了多线程环境下的可见性。

2. 启动任务并存储线程信息

多墨智能

多墨智能 - AI 驱动的创意工作流写作工具

下载

当收到启动任务的请求时，创建一个新的线程，启动它，并将线程的 UUID 和线程对象存储到 threadlookup 中。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TaskController {

    private static volatile Map threadlookup = new ConcurrentHashMap<>();

    @GetMapping("/start")
    public String startTask() {
        UUID uuid = UUID.randomUUID();
        Thread thread = new Thread(() -> {
            // 这里是长时间运行的任务
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    System.out.println("Task running... UUID: " + uuid);
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 重新设置中断状态
                    System.out.println("Task interrupted. UUID: " + uuid);
                }
            }
        });
        thread.start();
        threadlookup.put(uuid.toString(), thread);

        return uuid.toString(); // 返回 UUID
    }
}

在上面的代码中：

UUID.randomUUID() 生成一个唯一的 UUID，用于标识该线程。
Thread thread = new Thread(() -> { ... }); 创建一个新的线程，并在 run() 方法中定义任务的逻辑。
thread.start(); 启动线程。
threadlookup.put(uuid.toString(), thread); 将 UUID 和线程对象存储到 threadlookup 中。
最后，返回 UUID，以便客户端在停止任务时使用。
在任务的 run() 方法中，使用 Thread.currentThread().isInterrupted() 检查线程是否被中断。如果被中断，则抛出 InterruptedException 异常，并在 catch 块中重新设置中断状态 (Thread.currentThread().interrupt();)，确保线程能够正确地退出。

3. 停止任务

当收到停止任务的请求时，根据 UUID 从 threadlookup 中获取线程对象，并中断它。

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TaskController {

    private static volatile Map threadlookup = new ConcurrentHashMap<>();

    // startTask() 方法省略

    @GetMapping("/stop/{uuid}")
    public ResponseEntity stopTask(@PathVariable String uuid) {
        Thread thread = threadlookup.get(uuid);
        if (thread == null) {
            return new ResponseEntity<>("Thread not found with UUID: " + uuid, HttpStatus.NOT_FOUND);
        } else {
            thread.interrupt();
            threadlookup.remove(uuid); // 从 map 中移除
            return new ResponseEntity<>("Thread interrupted with UUID: " + uuid, HttpStatus.OK);
        }
    }
}

在上面的代码中：

@PathVariable String uuid 从请求路径中获取 UUID。
threadlookup.get(uuid) 根据 UUID 从 threadlookup 中获取线程对象。
如果线程对象不存在，则返回 404 错误。
thread.interrupt(); 中断线程。 interrupt() 方法会设置线程的中断状态，并抛出 InterruptedException 异常（如果线程正在 sleep() 或 wait() 中）。
threadlookup.remove(uuid); 从 threadlookup 中移除线程对象，释放资源。

完整示例代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

@SpringBootApplication
public class SpringBootTaskManagementApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootTaskManagementApplication.class, args);
    }

    @RestController
    public static class TaskController {

        private static volatile Map threadlookup = new ConcurrentHashMap<>();

        @GetMapping("/start")
        public String startTask() {
            UUID uuid = UUID.randomUUID();
            Thread thread = new Thread(() -> {
                // 这里是长时间运行的任务
                while (!Thread.currentThread().isInterrupted()) {
                    try {
                        System.out.println("Task running... UUID: " + uuid);
                        Thread.sleep(1000); // 模拟任务执行
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // 重新设置中断状态
                        System.out.println("Task interrupted. UUID: " + uuid);
                    }
                }
            });
            thread.start();
            threadlookup.put(uuid.toString(), thread);

            return uuid.toString(); // 返回 UUID
        }

        @GetMapping("/stop/{uuid}")
        public ResponseEntity stopTask(@PathVariable String uuid) {
            Thread thread = threadlookup.get(uuid);
            if (thread == null) {
                return new ResponseEntity<>("Thread not found with UUID: " + uuid, HttpStatus.NOT_FOUND);
            } else {
                thread.interrupt();
                threadlookup.remove(uuid); // 从 map 中移除
                return new ResponseEntity<>("Thread interrupted with UUID: " + uuid, HttpStatus.OK);
            }
        }
    }
}