如何让Java程序先尝试正常关闭线程，再以System.exit作为备份方案？

这问题我太熟了！之前维护一个后台服务时就踩过类似的坑——线程挂住导致进程残留，还占着数据库连接锁，排查起来头都大。你想做ExitWatcher的思路完全靠谱，咱们来捋捋怎么落地：

本质上它要扮演一个「线程管家」的角色：跟踪所有需要优雅关闭的业务线程，在应用收到关闭信号时，主动触发线程的终止流程，同时监控线程状态，对顽固线程进行针对性处理，最后尽可能保证进程干净退出，避免资源泄漏。

1. 线程注册机制 #

先给需要监控的线程做统一管理：

• 用线程安全的集合（比如CopyOnWriteArrayList）存储所有需监控的线程，避免并发注册时出现问题。
• 可以封装一个ManagedThread抽象类，让业务线程继承它，创建时自动注册到ExitWatcher，减少业务代码的侵入性。

2. 监听应用关闭事件 #

利用Java的ShutdownHook来捕获应用关闭信号（比如Ctrl+C、容器停止指令）：

Runtime.getRuntime().addShutdownHook(new Thread(this::startGracefulShutdown));

这个钩子会在JVM准备退出时触发，是优雅关闭的核心入口。

3. 优雅关闭流程 #

分三步走，兼顾友好性和兜底：

• 第一步：发送终止信号
  给每个注册线程发送明确的终止指令——比如给自定义线程设置一个volatile boolean isRunning标志位，让线程在循环中检测到标志位后，主动退出并执行清理逻辑（比如关闭文件流、释放数据库连接）；如果是线程池，调用shutdown()而非shutdownNow()，给任务留完成的机会。
• 第二步：等待+状态检查
  等待一段合理时长（比如30秒），然后检查线程是否全部终止。对未终止的线程，打印它的线程栈（用Thread.getAllStackTraces()），方便后续排查到底卡在哪里（死锁？阻塞在I/O？）。
• 第三步：强制中断（可选）
  对超时未终止的线程，尝试调用thread.interrupt()。但要注意：不是所有线程都响应中断——比如阻塞在Socket I/O的线程可能需要额外处理（比如关闭套接字），线程内部也要正确捕获InterruptedException并终止逻辑。

4. 极端兜底（可选） #

如果经过上述步骤后还有线程残留，你可以选择：

• 记录严重告警日志，提醒运维排查；
• 加个开关控制是否调用System.exit(1)——虽然你不想随便用，但在必须保证进程退出的场景下，这是最后一道防线。

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;

public class ExitWatcher {
    private static final ExitWatcher INSTANCE = new ExitWatcher();
    private final List<ManagedThread> registeredThreads = new CopyOnWriteArrayList<>();
    private static final long SHUTDOWN_WAIT_SECONDS = 30;
    private static final long INTERRUPT_WAIT_MS = 5000;

    private ExitWatcher() {
        // 注册JVM关闭钩子
        Runtime.getRuntime().addShutdownHook(new Thread(this::gracefulShutdown));
    }

    public static ExitWatcher getInstance() {
        return INSTANCE;
    }

    // 注册需要监控的线程
    public void registerThread(ManagedThread thread) {
        registeredThreads.add(thread);
    }

    private void gracefulShutdown() {
        System.out.println("===== 启动优雅关闭流程 =====");

        // 1. 给所有线程发送终止信号
        registeredThreads.forEach(ManagedThread::signalShutdown);

        // 2. 等待线程终止
        boolean allTerminated = true;
        for (ManagedThread thread : registeredThreads) {
            try {
                if (!thread.awaitTermination(SHUTDOWN_WAIT_SECONDS, TimeUnit.SECONDS)) {
                    allTerminated = false;
                    System.err.printf("线程 [%s] 未在指定时间内终止，打印线程栈：%n", thread.getName());
                    thread.dumpStack();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("关闭流程被中断");
                return;
            }
        }

        if (!allTerminated) {
            // 3. 尝试中断顽固线程
            System.err.println("===== 尝试中断未终止线程 =====");
            registeredThreads.stream()
                    .filter(Thread::isAlive)
                    .forEach(Thread::interrupt);

            // 再等待一小会儿
            try {
                Thread.sleep(INTERRUPT_WAIT_MS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            // 最后检查
            registeredThreads.stream()
                    .filter(Thread::isAlive)
                    .forEach(t -> System.err.printf("线程 [%s] 中断后仍存活%n", t.getName()));

            // 可选：极端情况强制退出
            // System.exit(1);
        }

        System.out.println("===== 优雅关闭流程完成 =====");
    }

    // 可管理的线程抽象类
    public abstract static class ManagedThread extends Thread {
        protected volatile boolean isRunning = true;

        public ManagedThread(String threadName) {
            super(threadName);
            ExitWatcher.getInstance().registerThread(this);
        }

        @Override
        public void run() {
            while (isRunning) {
                try {
                    doBusinessWork();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break; // 捕获中断后主动退出
                }
            }
            doCleanup(); // 执行资源清理
        }

        // 子类实现业务逻辑
        protected abstract void doBusinessWork() throws InterruptedException;

        // 子类实现清理逻辑（比如释放资源）
        protected abstract void doCleanup();

        // 发送终止信号
        public void signalShutdown() {
            isRunning = false;
        }

        // 等待线程终止
        public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
            join(unit.toMillis(timeout));
            return !isAlive();
        }
    }
}

• 不要监控守护线程：JVM退出时会自动终止守护线程，不需要额外处理。
• 线程安全第一：ExitWatcher的所有公共方法必须保证线程安全，尤其是注册线程的逻辑。
• 控制关闭时长：ShutdownHook的执行时间有限，太长可能被JVM强制终止，所以等待时长要根据业务场景合理设置。
• 日志要详细：线程未终止时的线程栈是排查问题的关键，一定要打印出来。

内容的提问来源于stack exchange，提问作者Tinus Tate