Java中断方法和中断异常

最新推荐文章于 2023-08-23 11:37:50 发布

cblstc

最新推荐文章于 2023-08-23 11:37:50 发布

阅读量1.2k

点赞数 3

分类专栏：并发编程

并发编程专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

原文：
https://codepumpkin.com/interrupt-interrupted-isinterrupted-java-multithreading/
https://codepumpkin.com/interruptedexception-java-multithreading/

学习Java中断时，看到两篇浅显易懂的文章(虽然比较啰嗦)，尝试翻译下来，略有增删改。

interrupt/interrupted和isInterrupted方法

这篇文章，我们将浅析Java多线程的interrupt/interrupted和isInterrupted方法.

如果你对中断机制比较感兴趣可以看这篇文章InterruptedException in Java Multithreading

在Java中，我们通过调用Thread的start方法去开启一个线程，其内部调用了run方法，run方法结束即线程结束。

强制中断线程意味着中断线程的执行，即使run方法还没结束。

在现实中，可能有一个场景需要利用多线程去完成任务，且当某些事件发生时需要中断这些线程。

比如，我们从服务器下载50个文件，开启了5个不同的线程去操作，每个线程处理10个文件，我们同时需要有一个按钮去取消下载。怎么做到？我们需要中断这5个线程。

下载操作的伪代码：

while (true) {
  	// Do Nothing
}

这是一个死循环，只有在JVM停止运行或者我们使用CTRL+C时才会停止运行。

接下来我们把死循环放入线程的run方法

Thread loop = new Thread(
  new Runnable() {
    @Override
    public void run() {
      while (true) {
         // Do Nothing
      }
    }
  }
);
loop.start();
// Now how do we stop it?

我们应该怎么样停止一个线程？

如果在JDK1.0，我们可以调用Thread的废弃方法stop去停止。使用stop方法是非常危险的，因为它会杀死你的线程，即使它正在执行一些重要的任务。

我们应该怎么安全的停止一个线程？

Java是这么设计的，每一个线程都有一个中断状态标志，可在线程外部去设置，比如在main方法。线程偶尔会检查这个状态并且中断执行。

Thread loop = new Thread(
  new Runnable() {
    @Override
    public void run() {
      while (true) {
        if (Thread.interrupted()) {
          break;
        }
        // Continue to do nothing
      }
    }
  }
);
loop.start();
loop.interrupt();

这个例子使用了两个方法。

interrupt：当我们调用interrupt时，中断状态设置为true
interrupted：这是一个static方法，检查中断状态。当我们调用interrupted时，会返回当前的中断状态，同时把中断状态置为false。

所以，如果我们没有在run中调用interrupted方法，当flag=true时不退出，那么线程就不会停止。换句话说，父线程会告诉子线程我调用了interrupt方法，但是子线程不一定要处理中断。

JDK文档是这么描述的

中断意味着一个线程需要停止当前正在执行的任务，而去执行其他的事情。需要由开发人员自行决定如何去响应中断，这是一个非常普遍的让线程停止的方式。

isInterrupted：另外一个方法需要我们熟知。这是一个实例方法，返回中断状态。

Interrupted() VS IsInterrupted()

interrupted: 静态方法，返回中断状态，同时清除中断状态

isInterrupted: 实例方法，返回中断状态，不清除中断状态

InterruptedException

当线程在等待、睡眠或其他状态时，线程被中断，那么就会抛出InterruptedException。

JDK有一些方法会去检查中断状态，如果设置为true时，就会自动抛出InterruptedException。比如，阻塞方法wait/sleep/join等。

我看到很多程序员没有正确处理InterruptedException。大多数时间，程序员把InterruptedException视为一个非常恼人的事情，因为他们不得不去捕获异常。

仅仅只是忽略IDE的编译错误，他们把sleep或者wait方法catch起来。

问题出现了，为什么所有阻塞方法抛出InterruptedException？我们通过以下例子来加深理解。这是一个Thread的run方法实现。

@Override
public void run() 
{
    while (true) 
    {
        if (Thread.interrupted()) 
        {
            break;
        }
        // Case 1 : code to be executed before sleep method call
        try
        {
            sleep(10_000_000); // Case 2 : sleep for 10,000 seconds
        }
        catch(InterruptedException ie)
        {
            // Clean up code
        }
        // Case 3 : code to be executed after sleep method call
    }
    // Clean up code
}

上面的代码，在死循环的开始，会检查中断状态。如果中断状态为true，就会跳出循环，否则，就会一直循环下去。

让我们理解一下，当我们的父线程调用interrupt方法时，会发生什么事情。

case 3 :

当代码执行到Case 3时（sleep之后）
此时，main线程调用interrupt方法
下一个循环开始
Thread.interrupted返回true，然后结束循环
接下来Clean up code被执行

case 2 :

当代码执行到Case 2，即正在执行sleep方法
此时，main线程调用interrupt方法
sleep方法抛出InterruptedException。想象如果没有抛出InterruptedException的机制。尽管我们的父线程调用了interrupt方法，子线程并不能马上中断线程，必须等到sleep方法结束后（10,000s，大约三个小时）。为了解决这种问题，sleep内部会帮我们检查中断状态

Java的sleep方法内部可能是这么实现的。

public static void sleep(long millis) throws InterruptedException 
{
    while (/* still waiting for millis to become zero */) 
    {
        if (Thread.interrupted())
        {
            throw new InterruptedException();
        }
        // Keep waiting
    }
}

Note : sleep方法是一个native方法，上面的代码块仅仅是为了展示它的较高层次大概做了什么事。

catch代码块会执行，最终执行到Clean up code

case 1 :

代码执行到Case 1(sleep之前)
此时，main线程调用interrupt方法
代码接下来执行sleep方法
sleep方法抛出中断异常。
catch代码块被执行，最终执行到Clean up code

InterruptedException的实际使用

抛出InterruptedException的主要原因是退出阻塞状态，并且执行清理代码。我们举个应用关闭的例子。

当你关闭应用，如果存在线程正在等待状态(sleep/wait)，如果你没有告诉它们应用正在关闭，它们还是会继续等待。如果这些线程不是后台线程，那么你的应用就不会关闭。

所以，你必须检查中断条件并且处理它们。比如说关闭，你必须检查关闭的状态，然后去执行清理工作。

如果开发者吞掉InterruptedException会发生什么？

try {
  Thread.sleep( 100 );
}  catch (InterruptedException ex) {
}

记住，Thread.interrupted不仅返回中断状态而且会重置中断状态为false。所以当InterruptedException抛出的时候，flag已经为true了。父线程不能够再知道中断的状态了。

线程告诉我们要停止，Thread.sleep觉察到这个请求，就抛出InterruptedException。如果你再次调用Thread.sleep，因为中断状态此时被重置了，所以不会抛出异常。

所以InterruptedException的处理非常重要。我们不能吞掉这个异常，这严重违反了多线程的设计理念。线程告诉我们要中断，我们却忽略它，这是一个非常不好的做法。

下面是我们经常使用的处理InterruptedException的操作

try {
  Thread.sleep(100);
} catch (InterruptedException ex) {
  throw new RuntimeException(ex);
}

看起来很符合逻辑，但是它并不保证上层会停止所有事情并退出。它们仅仅只是捕获运行时异常，然后线程还是存活着。这显然不是我们想看到的。

我们必须告知更高的层级，我们捕获到了中断请求，我们不能仅仅抛出运行时异常，这是非常不负责任的。线程接收到中断请求，我们仅仅是吞掉它，然后抛出一个运行时异常，我们不能这样轻松的对待这么严肃的问题。

所以我们要这么做：

try {
  Thread.sleep(100);
} catch (InterruptedException ex) {
  Thread.currentThread().interrupt(); // Here!
  throw new RuntimeException(ex);
}

我们重新设置中断状态为true。

现在，没有人会责备我们对这个中断状态采取不负责任的态度。我们发现中断状态为true（此时状态被重置了），我们就给它手动设置为true，然后抛出一个异常。接下来的事情，我们不关心。

以上就是关于InterruptedException的内容，不要吞掉异常！

译者总结

interrupt一般用来发起中断，会设置中断状态为true，至于线程是否响应中断，需要我们手动去处理。一般就是在线程内部调用Thread.interrupted方法获得中断状态，然后根据状态做一些处理。

interrupted和isInterrupted方法的区别主要有两点：

前者是静态方法，后者是实例方法。
前者会清空中断状态为false，后者不会。查看interrupted方法源码，其实内部就是调用isInterrupted(true)

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
public boolean isInterrupted() {
    return isInterrupted(false);
}
private native boolean isInterrupted(boolean ClearInterrupted); // ClearInterrupted表示是否清除中断标志

InterruptedException的理解：

阻塞方法一般需要手动处理InterruptedException，假设阻塞方法无需处理InterruptedException，那么会导致方法一直阻塞，无法退出中断，或者需要等待阻塞时间结束才能处理中断。我们需要阻塞方法接收到中断请求后，立刻响应中断。

对于阻塞方法，当接收到中断请求后，会抛出InterruptedException（阻塞方法内部应该是会判断中断状态来决定是否结束阻塞），我们可以捕获该异常或者向上抛出。在捕获异常时，最好设置中断状态为true。因为interrupted方法会清空中断状态，在抛出InterruptedException后，中断状态已经为false了。

@Test
public void testInterrupt() {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("中断了，状态为" + Thread.currentThread().isInterrupted()); // false
                Thread.currentThread().interrupt(); // 设置中断状态为true
                System.out.println("设置中断，状态为" + Thread.currentThread().isInterrupted()); // true
                throw new RuntimeException();
            }
        }
    });
    thread.start();
    System.out.println("初始状态：" + thread.isInterrupted());
    thread.interrupt(); // 发起中断
}