Springboot如何优雅的关闭应用_Java

使用spring boot actuator会中断运行中的业务吗？

当你向 /actuator/shutdown 端点发送 post 请求以关闭应用时，spring boot actuator 会触发应用的关闭操作。这意味着应用会执行相应的关闭逻辑，并尝试优雅地停止正在运行的业务。

如果你的业务逻辑中实现了优雅关闭的机制，例如捕获了中断信号并正确处理了中断，那么应用关闭时不会突然中断运行中的业务。相反，应用会尝试完成当前正在执行的任务，然后安全地关闭。这种方式可以确保在关闭应用时不会丢失数据或者导致不一致的状态。

然而，如果你的业务逻辑没有实现优雅关闭的机制，或者在关闭操作中遇到了异常，那么关闭应用时可能会导致正在运行的业务被中断。这取决于应用的具体实现和业务逻辑。

如何使用spring boot actuator关闭应用

1.引入actuator包

<dependency>
     <groupid>org.springframework.boot</groupid>
     <artifactid>spring-boot-starter-actuator</artifactid>
 </dependency

2.application.yml配置

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

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

3.curl 命令关闭应用的示例

curl -x post http://localhost:80/monitor/shutdown

4.运行截图

使用spring boot actuator关闭应用，会终止正在运行中的程序，如果想要运行中的业务不中断，需要自定义关闭器的关闭事件，使运行中的程序处理完成才关闭应用。

如何自定义关闭监听器关闭事件优雅的关闭应用

本实例使用异步线程任务来模拟运行中的任务。

1.定义异步管理类

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;
    }
}

2.定义监听 spring 应用的关闭事件

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("应用已经关闭...");
    }
}

3.定义异步任务task

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() {

    }
}

4.验证截图