Springboot如何优雅的关闭应用

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-actuator</artifactId>
 </dependency

# 开发环境配置
server:
  # 服务器的HTTP端口，默认为80
  port: 80

management:
  endpoint:
    shutdown:
      enabled: true
  endpoints:
    web:
      exposure:
        include: "shutdown"
      base-path: /monitor

curl -X POST http://localhost:80/monitor/shutdown

package com.angel.ocean.tool.util;

import com.angel.ocean.tool.task.CommonTask;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 异步任务工具类
 */
@Slf4j
public class TaskExecutorUtil {

    // Task运行状态
    public static volatile boolean isRunning = true;

    // Task运行结果Future集合
    private final static List<Future<?>> runningTasks = new ArrayList<>();

    // 线程池
    static ExecutorService executorPool = new ThreadPoolExecutor(corePoolSize(), maximumPoolSize(), 10, TimeUnit.MINUTES,
            new ArrayBlockingQueue<Runnable>(1000), new ThreadPoolExecutor.CallerRunsPolicy());

    /**
     * Task执行
     */
    public static void executeTask(CommonTask task) {
        Future<?> future = executorPool.submit(task);
        runningTasks.add(future);
    }

    /**
     * 关闭运行中所有线程，如果任务正在执行中，待执行完成再中断该线程
     */
    public static void stopAllTasks() {
        isRunning = false;
        for (Future<?> future : runningTasks) {
            try {
                boolean flag = true;
                while (flag) {
                    // 如果任务还在执行中，就休眠100ms
                    if(!future.isDone()) {
                        Thread.sleep(100);
                    } else {
                        flag = false;
                    }
                }
            } catch (InterruptedException e) {
                // 打印异常
                log.error("TaskExecutorUtil stopAllTasks {}", e.getMessage(), e);
            } finally {
                // 中断任务
                future.cancel(true);
            }
        }
    }

    /**
     * 关闭线程池
     */
    public static void waitForTasksToComplete() {
        // 等待所有任务完成
        executorPool.shutdown();
    }

    /**
     * 核心线程数
     */
    private static int corePoolSize() {
        return Runtime.getRuntime().availableProcessors();
    }

    /**
     * 最大线程数
     */
    private static int maximumPoolSize() {
        return Runtime.getRuntime().availableProcessors() * 2;
    }
}

package com.angel.ocean.tool.event;

import com.angel.ocean.tool.util.TaskExecutorUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.stereotype.Component;

/**
 *  监听 Spring 应用的关闭事件
 */
@Slf4j
@Component
public class ShutdownListener implements ApplicationListener<ContextClosedEvent> {
    @Override
    public void onApplicationEvent(ContextClosedEvent event) {

        log.info("应用正在关闭...");

        // 中断所有正在运行的任务
        TaskExecutorUtil.stopAllTasks();

        // 等待所有任务完成
        TaskExecutorUtil.waitForTasksToComplete();

        log.info("应用已经关闭...");
    }
}

package com.angel.ocean.tool.runner;

import com.angel.ocean.tool.task.MyTask;
import com.angel.ocean.tool.util.TaskExecutorUtil;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class MyTaskRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 创建并执行任务
        MyTask task = new MyTask();
        TaskExecutorUtil.executeTask(task);
        System.out.println("任务已启动...");
    }
}

package com.angel.ocean.tool.task;

import com.angel.ocean.tool.util.TaskExecutorUtil;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyTask extends CommonTask {
    @Override
    public void handler() {
        while (TaskExecutorUtil.isRunning) {
            log.info("本次任务开始执行.......");
            try {
                for(int i = 0; i < 10; i++) {
                    // 模拟任务执行时间，等待1s
                    Thread.sleep(1000);
                    log.info("i = {}", i);
                }
                log.info("本次任务执行完成.......");
            } catch (InterruptedException e) {
                // 处理中断请求
                Thread.currentThread().interrupt();
                log.info("任务被中断.......");
            }
        }
    }
}

package com.angel.ocean.tool.task;

import lombok.extern.slf4j.Slf4j;

/**
 * Task抽象类
 */
@Slf4j
public abstract class CommonTask implements Runnable {

    @Override
    public void run() {
        handler();
    }

    public void handler() {

    }
}