Java多线程中断代码详解

在Java多线程编程中，线程中断机制是非常重要的，可以让我们更加灵活地控制线程执行过程。本文将详细讲解Java多线程中断机制的实现细节，包括如何设置和捕获中断信号，以及如何通过中断信号优雅地终止线程。

什么是线程中断

线程中断是一种机制，可以向线程发出请求，让线程在适当的时候停止执行，并抛出InterruptedException异常。线程中断机制是基于信号量的，即通过发送中断信号来告知线程应该停止执行。线程中断相当于一种协作式的停止机制，因此，线程在响应中断时，需要将当前的执行状态保存下来，确保在下一次执行时，能够从原来的状态继续执行。

设置线程中断标志

Java中通过Thread.interrupt()方法来设置线程中断标志位，当线程接收到中断信号时，会将中断标志位设置为true。中断信号分为两种：软件中断和硬件中断，软件中断是通过Thread.interrupt()方法来触发的，而硬件中断则是由操作系统的硬件中断机制触发的，例如系统磁盘出错、CPU出现超时等，这种类型的中断一般无法被Java代码直接捕捉。由于Java中只存在软件中断，因此本文只针对软件中断进行讲解。

在Java中，当线程被中断时，线程的中断标志会被设置为true，可以通过Thread.isInterrupted()方法查询线程的中断状态。

Thread thread = new Thread(() -> {
   while(!Thread.interrupted()) { 
      // do something
   }
   // 如果收到中断信号，这里会抛出InterruptedException异常
});
thread.start();

在上面的示例中，我们使用了Thread.interrupted()方法来检查线程的中断标志位，并退出了线程的执行。需要注意的是，Thread.interrupted()会清除线程的中断标志，因此在循环内部每次检查中断标志时，都需要重新设置一下中断标志，否则线程可能会一直处于运行状态。

另外，在线程执行过程中，需要定期检查中断标志，以确保能够快速响应中断，从而优雅地终止线程。

捕获InterruptedException异常

当线程被中断时，会将中断标志位设置为true，并且抛出InterruptedException异常，因此，在编写多线程代码的过程中，需要及时捕获并处理这个异常。

Thread thread = new Thread(() -> {
   try {
      while(!Thread.interrupted()) { 
         // do something
      }
   } catch(InterruptedException e) {
      // 处理中断异常逻辑
   }
});
thread.start();

上面的示例中，我们在while循环中添加了try-catch语句，用于捕获InterruptedException异常。需要注意的是，当线程被中断时，虽然中断标志位被设置为true，但线程并不会立即停止执行，还会继续执行一段时间，直到执行完当前的代码段，才会抛出InterruptedException异常。因此，需要在try-catch语句内部进行一些清理工作，并确保线程可以优雅地终止。

示例1：通过中断信号优雅地终止线程

class MyTask implements Runnable {
    @Override
    public void run() {
        while(!Thread.interrupted()) {
            System.out.println("Task is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Task is interrupted.");
                // 恢复中断状态，确保线程可以正常退出
                Thread.currentThread().interrupt();
                break;
            }
        }
        System.out.println("Task is stopped.");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyTask());
        thread.start();
        Thread.sleep(5000);
        // 发送中断信号，通知线程停止执行
        thread.interrupt();
        Thread.sleep(2000);
        // 等待线程运行完毕
        thread.join();
        System.out.println("Main is stopped.");
    }
}

在上面的示例中，我们定义了一个MyTask类，并实现了Runnable接口。MyTask类的run()方法中，会不断地循环执行一些任务，并且每次循环后，都会调用Thread.sleep()方法来让线程休眠一段时间。

Main类中，我们启动了一个新的线程，并且让它运行5秒钟，在5秒钟之后，我们使用thread.interrupt()方法来发送中断信号，通知线程停止执行。在MyTask类中，当线程被中断时，会先恢复中断状态（Thread.currentThread().interrupt()），然后终止线程的执行（break）。

最后，我们使用thread.join()方法等待线程的执行完毕，并输出一句日志，表示程序已经正常退出。需要注意的是，如果在线程被中断后，没有正确地恢复中断状态，那么线程就无法正常退出，这可能会导致程序无法正常停止。

示例2：使用Lock对象响应中断请求

class MyTask implements Runnable {
    private Lock lock = new ReentrantLock();

    public void doSomething() throws InterruptedException {
        try {
            lock.lockInterruptibly();
            System.out.println("Acquired lock...");
            Thread.sleep(5000);
        } finally {
            System.out.println("Release lock...");
            lock.unlock();
        }
    }

    @Override
    public void run() {
        try {
            doSomething();
        } catch (InterruptedException e) {
            System.out.println("Task is interrupted.");
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyTask());
        thread.start();
        Thread.sleep(1000);
        // 发送中断信号，通知线程停止执行
        thread.interrupt();
        Thread.sleep(2000);
        // 等待线程运行完毕
        thread.join();
        System.out.println("Main is stopped.");
    }
}

在上面的示例中，我们定义了一个MyTask类，并使用了一个Lock对象来控制线程的执行。在doSomething()方法中，我们使用lock.lockInterruptibly()方法来获取锁，并且在获取锁的过程中，检查线程是否被中断。如果线程被中断，那么就会立即抛出InterruptedException异常，并且释放锁资源。

在Main类中，我们启动了一个新的线程，并且让它运行1秒钟。1秒后，我们使用thread.interrupt()方法来中断线程的执行。在MyTask类中，当线程被中断时，lock.lockInterruptibly()方法会立即抛出InterruptedException异常，并且释放锁资源，然后线程就会退出。

需要注意的是，在使用Lock对象控制线程的执行时，需要特别注意线程的中断状态，并且正确地响应中断请求，否则可能会出现死锁等问题。

总结

Java多线程中断机制是一种非常重要的线程协作机制，可以让我们更加灵活地控制线程的执行。在编写多线程代码时，需要特别注意线程的中断状态，并且正确地响应中断请求，否则可能会出现死锁等问题。本文介绍了如何设置线程中断标志，以及如何响应中断请求，并且给出了两个详细的示例，希望能够帮助读者更好地理解Java多线程中断机制的实现细节。