How do we correctly interrupt a thread that is executing? ?

[[358852]]

The author has developed a simple, stable, and scalable delayed message queue framework for high-concurrency scenarios. It has precise timed tasks and delayed queue processing functions. Since it was open sourced for more than half a year, it has successfully provided precise timed scheduling solutions for more than a dozen small and medium-sized enterprises and has withstood the test of production environments. In order to benefit more friends, the open source framework address is now provided: https://github.com/sunshinelyz/mykit-delay

Preface

When we call the wait() method of a Java object or the sleep() method of a thread, we need to catch and handle the InterruptedException. If we do not handle the InterruptedException properly, unexpected consequences will occur! Today, we will use a case to explain in detail why interrupting the execution of a thread does not work.

Program Case

For example, in the following program code, the InterruptedTask class implements the Runnable interface. In the run() method, the handle of the current thread is obtained, and in the while(true) loop, the isInterrupted() method is used to detect whether the current thread is interrupted. If the current thread is interrupted, the while(true) loop is exited. At the same time, in the while(true) loop, there is a line of Thread.sleep(100) code, and the InterruptedException is caught. The entire code is shown below.

 package io.binghe.concurrent.lab08; 
 
 /**
 * @author binghe
 * @version 1.0.0
 * @description Thread test interruption
 */
 public class InterruptedTask implements Runnable{ 
 
 @Override
 public void run() { 
 
        Thread currentThread = Thread.currentThread();
 while ( true ) {
            if(currentThread.isInterrupted()){
 break;
 } 
 
 try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
 }
 }
 }
 }

The original intention of the above code is to check whether the thread is interrupted by the isInterrupted() method, and if it is interrupted, exit the while loop. Other threads interrupt the executing thread by calling the interrupt() method of the executing thread, which sets the interrupt flag of the executing thread, so that currentThread.isInterrupted() returns true, so that the while loop can be exited.

This seems to be fine! But is it really so? We create an InterruptedTest class for testing, the code is as follows.

 package io.binghe.concurrent.lab08; 
 
 /**
 * @author binghe
 * @version 1.0.0
 * @description Test thread interruption
 */
 public class InterruptedTest {
 public   static void main(String[] args){
        InterruptedTask interruptedTask = new InterruptedTask();
        Thread interruptedThread = new Thread(interruptedTask);
        interruptedThread.start();
 try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
 }
        interruptedThread.interrupt();
 }
 }

We run the main method as shown below.

This is actually different from what we imagined! Different! Different! Why is this?

Problem Analysis

The above code clearly calls the interrupt() method of the thread to interrupt the thread, but it does not work. The reason is that when the run() method of the thread is executed, it is blocked on sleep(100) most of the time. When other threads interrupt the executing thread by calling the interrupt() method of the executing thread, it is likely to trigger InterruptedException. When the InterruptedException is triggered, the JVM will clear the interrupt flag of the thread at the same time. Therefore, the currentThread.isInterrupted() judged in the run() method will return false, and the current while loop will not be exited.

Now that the problem has been analyzed clearly, how do we interrupt the thread and exit the program?

Problem Solving

The correct way to handle it should be to reset the interrupt flag after catching the exception in the while(true) loop in the run() method in the InterruptedTask class. Therefore, the correct code of the InterruptedTask class is as follows.

 package io.binghe.concurrent.lab08; 
 
 /**
 * @author binghe
 * @version 1.0.0
 * @description Interrupt thread test
 */
 public class InterruptedTask implements Runnable{ 
 
 @Override
 public void run() { 
 
        Thread currentThread = Thread.currentThread();
 while ( true ) {
            if(currentThread.isInterrupted()){
 break;
 } 
 
 try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
                currentThread.interrupt();
 }
 }
 }
 }

As you can see, we added a new line of code in the catch code block that captures the InterruptedException exception.

 currentThread.interrupt();

This allows us to reset the thread's interrupt flag after catching the InterruptedException, thereby interrupting the currently executing thread.

We run the main method of the InterruptedTest class again as shown below.

Summarize

Be careful when handling InterruptedException. If an InterruptedException is thrown when the execution thread is interrupted by calling the interrupt() method of the execution thread, the JVM will clear the interrupt flag of the execution thread at the same time as the InterruptedException is triggered. At this time, calling the isInterrupted() method of the execution thread will return false. At this time, the correct way to handle it is to catch the InterruptedException in the run() method of the execution thread and reset the interrupt flag (that is, in the catch code block that catches the InterruptedException, call the interrupt() method of the current thread again).

This article is reprinted from the WeChat public account "Glacier Technology". You can follow it through the QR code below. To reprint this article, please contact the Glacier Technology public account.