Java中断程序运行的方案

在Java中，我们可以使用多种方法来中断程序的运行。本文将介绍以下几种常用的方案，并给出代码示例和相关图示。

方案一：使用线程的interrupt()方法

Java中的线程有一个interrupt()方法，可以用来中断线程的执行。当一个线程调用另一个线程的interrupt()方法时，被调用线程的中断标志会被设置为true，可以通过Thread类的isInterrupted()方法来检查中断标志。

下面是一个使用interrupt()方法中断线程的示例代码：

public class MyThread extends Thread {
    public void run() {
        while (!isInterrupted()) {
            // 线程执行的逻辑代码
            // ...
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程

        // 等待一段时间后中断线程
        try {
            Thread.sleep(1000);
            thread.interrupt(); // 中断线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代码中，MyThread类继承自Thread类，并重写了run()方法，在run()方法中执行线程的逻辑代码。在Main类的main()方法中创建并启动线程，等待一段时间后调用线程的interrupt()方法中断线程。

方案二：使用共享变量

除了使用线程的interrupt()方法来中断线程，我们还可以使用共享变量来控制程序的运行。通过改变共享变量的值，可以让线程在适当的时机退出循环或停止执行。

下面是一个使用共享变量中断线程的示例代码：

public class MyThread extends Thread {
    private volatile boolean running = true;

    public void run() {
        while (running) {
            // 线程执行的逻辑代码
            // ...
        }
    }

    public void stopRunning() {
        running = false;
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程

        // 等待一段时间后停止线程
        try {
            Thread.sleep(1000);
            thread.stopRunning(); // 停止线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代码中，MyThread类同样继承自Thread类，并添加了一个名为running的共享变量。在run()方法中，线程会不断地检查running的值，只有当running为true时才继续执行。在Main类的main()方法中创建并启动线程，等待一段时间后调用线程的stopRunning()方法停止线程。

方案三：使用Future和Callable接口

Java中的Future和Callable接口也可以用来中断线程的执行。Future表示一个可能还没有完成的计算任务，Callable是一个具有返回值的任务。

我们可以通过调用Future的cancel()方法来中断任务的执行，同时传入一个布尔值来指定是否中断正在执行的任务。被中断的任务会抛出CancellationException异常。

下面是一个使用Future和Callable接口中断线程的示例代码：

import java.util.concurrent.*;

public class MyTask implements Callable<String> {
    public String call() {
        while (!Thread.currentThread().isInterrupted()) {
            // 任务执行的逻辑代码
            // ...
        }
        return "任务已中断";
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyTask());

        // 等待一段时间后取消任务
        try {
            Thread.sleep(1000);
            future.cancel(true); // 取消任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (CancellationException e) {
            e.printStackTrace();
        }

        executor.shutdown();
    }
}

上述代码中，MyTask类实现了Callable接口，并重写了call()方法，在call()方法中执行任务的逻辑代码。在Main类的main()方法中使用ExecutorService创建线程池，并提交MyTask任务，返回一个Future对象。在一段时间后调用Future的cancel()方法取消任务。

序列图

下面是使用mermaid语法绘制的中断程序运行的序列