Java中断机制

Java中断机制为我们提供了一种"试图"停止一个线程的方法。设想我们有一个线程阻塞在一个耗时的I/O中，我们又不想一直等下去，那么我们怎么样才能停止这个线程呢？答案就是 Java 的中断机制。

从Java线程的状态说起

Java线程的状态包括：NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING和TERMINATED总共六种状态:

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }
复制代码

一个线程新建后，在调用该线程的start()方法之前，该线程的状态就是NEW；当线程的start()方法被调用之后，该线程已经准备被CPU调度，此时线程的状态就是RUNNABLE；如果一个对象的monitor lock被其他线程获取了，这个时候我们再通过synchronized关键字去获取改对象的monitor lock时，线程就会进入BLOCKED状态；通过调用Thread#join()方法或者Object#wait()方法（不设置超时时间，with no timeout）或者LockSupport#park()方法可以让一个线程从RUNNABLE状态转为WAITING状态；TIMED_WAITING指线程处于等待中，但是这个等待是有期限的（），通过调用Thread#sleep()，Object#wait(long timeout)，Thread#join(long timeout)，LockSupport#parkNanos()，LockSupport#partUnitl()都可使线程切换到TIMED_WAITING状态。最后一种状态TERMINATED是指线程正常退出或者异常退出后的状态。下面这张图展示了这六种线程状态之间的相互转换关系：

当线程处于等待状态或者有超时的等待状态时（TIMED_WAITING，WAITING）我们可以通过调用线程的interrupt()方法来中断线程的等待，此时线程会抛InterruptedException异常。例如Thread.sleep()方法: public static native void sleep(long millis) throws InterruptedException; 此方法就会抛出这类异常。 但是当线程处于BLOCKED状态或者RUNNABLE（RUNNING）状态时，调用线程的interrupt()方法也只能将线程的状态位设置为true。停止线程的逻辑需要我们自己去实现。

中断原理

查看java源码可以看到Thread类中提供了跟中断相关的一些方法：

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();                                                 1

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {                                               2
                interrupt0();           // Just to set the interrupt flag  3
                b.interrupt(this);                                         4
                return;
            }
        }
        interrupt0();
    }
复制代码

interrupt()方法用于中断一个线程，首先在第1处中断方法会判断当前caller线程是否具有中断本线程的权限，如果没有权限则抛出SecurityException异常。然后在2处方法会判断阻塞当前线程的对象是否为空，如果不为空，则在3处先设置线程的中断flag为true，然后再由Interruptible对象（例如可以中断的I/O操作）去中断操作。从中我们也可以看到如果当前线程不处于WAITING或者TIMED_WAITING状态，则interrupt()方法也只是仅仅设置了该线程的中断flag为true而已。

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
复制代码

再看interrupted()方法，该方法是一个静态的方法，最终会调用具体线程实例的isInterrupted()方法：

public boolean isInterrupted() {
        return isInterrupted(false);
    }
    
    private native boolean isInterrupted(boolean ClearInterrupted);
复制代码

interrupted()方法第一次调用时会返回当前线程的中断flag，然后就清除了这个状态位，但是isInterrupted()方法不会清除该状态位。因此一个线程中断后，第一次调用interrupted()方法会返回true，第二次调用就返回false，因此第一次调用后该状态位已经被清除了。但是同样一个线程中断后，多次调用isInterrupted()方法都会返回true。这是两者的不同之处，但是两者最终都会调用一个名为isInterrupted的native方法。

中断的处理

java中一般方法申明了throws InterruptedException的就是可以中断的方法，比如：ReentrantLock#lockInterruptibly，BlockingQueue#put，Thread#sleep，Object#wait等。当这些方法被中断后会抛出InterruptedException异常，我们可以捕获这个异常，并实现自己的处理逻辑，也可以不处理，继续向上层抛出异常。但是记住不要捕获异常后什么都不做并且不向上层抛异常，也就是说我们不能" 吞掉 "异常。 对于一些没有抛出InterruptedException的方法的中断逻辑只能由我们自己去实现了。例如在一个大的循环中，我们可以自己判断当前线程的中断状态然后选择是否中断当前操作：

public class InterruptTest {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 循环中检测当前线程的中断状态 
                for (int i = 0; i < Integer.MAX_VALUE && !Thread.currentThread().isInterrupted(); i++) {
                    System.out.println(i);
                }
            }
        });
        thread.start();
        Thread.sleep(100);
        thread.interrupt();
    }
}
复制代码