Java程序中优雅处理Ctrl+C中断的5种方法

Java程序中优雅处理Ctrl+C中断是一种常见的需求，特别是在后台服务或者长时间运行的程序中。以下介绍五种处理Ctrl+C中断的优雅方法：

方法一：使用try-catch捕获异常

在Java中，Ctrl+C会触发InterruptedException。可以通过捕获这个异常来优雅地处理中断。

public class CtrlCExample {
    public static void main(String[] args) {
        try {
            while (true) {
                System.out.println("程序正在运行...");
                Thread.sleep(1000); // 模拟长时间运行的任务
            }
        } catch (InterruptedException e) {
            System.out.println("程序被用户中断，准备退出...");
            // 这里可以添加一些清理资源或者保存状态的代码
            System.exit(0);
        }
    }
}

方法二：注册钩子（Hook）

Java提供了Runtime.getRuntime().addShutdownHook()方法来注册一个关闭钩子，这个钩子会在程序退出时执行。

public class CtrlCExample {
    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("程序即将退出，进行资源清理...");
            // 这里可以添加一些清理资源或者保存状态的代码
        }));

        try {
            while (true) {
                System.out.println("程序正在运行...");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 保留中断状态
        }
    }
}

方法三：使用volatile变量

使用一个volatile变量来标志程序是否应该继续运行，并在main方法中轮询检查这个变量。

public class CtrlCExample {
    private static volatile boolean running = true;

    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("程序即将退出，进行资源清理...");
            running = false; // 设置标志，停止程序
        }));

        while (running) {
            System.out.println("程序正在运行...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                running = false; // 重新设置标志，确保程序退出
            }
        }
    }
}

方法四：使用ExecutorService和Future

对于涉及到多线程的程序，可以使用ExecutorService和Future来处理中断。

import java.util.concurrent.*;

public class CtrlCExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<?> future = executor.submit(() -> {
            try {
                while (true) {
                    System.out.println("程序正在运行...");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println("程序被用户中断，准备退出...");
            }
        });

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("程序即将退出，进行资源清理...");
            future.cancel(true); // 取消任务
        }));

        try {
            future.get(); // 等待任务完成
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdownNow(); // 关闭线程池
        }
    }
}

方法五：使用ReentrantLock和Condition

使用ReentrantLock和Condition可以提供更细粒度的控制。

import java.util.concurrent.locks.*;

public class CtrlCExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private volatile boolean running = true;

    public static void main(String[] args) {
        CtrlCExample example = new CtrlCExample();
        example.start();

        Runtime.getRuntime().addShutdownHook(new Thread(example::shutdown));
    }

    public void start() {
        lock.lock();
        try {
            Thread thread = new Thread(() -> {
                try {
                    while (running) {
                        System.out.println("程序正在运行...");
                        condition.await(); // 等待信号
                    }
                } catch (InterruptedException e) {
                    System.out.println("程序被用户中断，准备退出...");
                }
            });
            thread.start();
        } finally {
            lock.unlock();
        }
    }

    public void shutdown() {
        lock.lock();
        try {
            running = false;
            condition.signalAll(); // 通知所有等待的线程
            System.out.println("程序即将退出，进行资源清理...");
        } finally {
            lock.unlock();
        }
    }
}

以上五种方法都可以优雅地处理Java程序中的Ctrl+C中断，具体选择哪种方法取决于程序的具体需求和场景。