Detailed explanation of thread interrupt method

How can we pause the running of another thread in one thread ？
It is not recommended to use stop Method , Use stop Method can forcibly terminate a running or suspended thread , But use stop The method is very dangerous .stop Method will really kill the thread , If the thread locks the shared resource , Then when it is killed, it will never have a chance to release the lock , Other threads will never acquire locks

We can use interrupt Method . When using this method , It's not like stop Method will interrupt a running thread , Instead, the thread will continue to run ; But the interrupt state of the thread will be set , It is set to true, The thread will detect this interrupt flag bit from time to time , To determine whether the thread should be interrupted （ Whether the interrupt status is true）

public class test2 {
    
    public static void main(String[] args) {
    
        try {
    
            test2();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    }
    private static void test2() throws InterruptedException {
    
        Thread t2 = new Thread(()->{
    
            while(true) {
    
                Thread current = Thread.currentThread();
                boolean interrupted = current.isInterrupted();
                System.out.println(interrupted);
                // Decide whether to stop the operation on site 
                if(interrupted) {
    
                    System.out.println(interrupted);
                    break;
                }
            }
        }, "t2");
        t2.start();
        // Let the main thread sleep 
        Thread.sleep(500);
        t2.interrupt();
    }
}

Output results ：

But when we interrupt Blocked （sleep,wait,join） The thread of will make this thread produce a InterruptedException abnormal , End the thread . But if the exception is caught by the thread , The thread can still decide the subsequent processing by itself （ Terminate run , Continue operation , Do some aftercare work and so on ）, And the thread in the interrupt block will reset the flag state to false;

@Slf4j
public class test1 {
    
    public static void main(String[] args) throws InterruptedException {
    
        TwoParseTermination twoParseTermination = new TwoParseTermination();
        twoParseTermination.start();
        Thread.sleep(3500);
        twoParseTermination.stop();
    }
}
@Slf4j
class TwoParseTermination {
    
    private Thread monitor;
    //  Start thread 
    public void start() {
    
        monitor = new Thread(() -> {
    
            while (true) {
    
                // Get the current thread 
                Thread thread = Thread.currentThread();
                if(thread.isInterrupted()) {
     //  call  isInterrupted Get the tag value   This will not clear the mark 
                    System.out.println(" Take care of future affairs  ...");
                    break;  // Thread termination 
                } else {
    
                    try {
    
                        Thread.sleep(1000);
                        System.out.println(" Perform the function of monitoring  ...");
                    } catch (InterruptedException e) {
    
                        System.out.println(" Set break flag  ...");
                        // Because the tag value becomes false, Here's another interruption , It is equivalent to interrupting the running thread , So the tag value here becomes ture, If the tag value is not reset here, the thread will always run 
                        thread.interrupt();
                        e.printStackTrace();
                    }
                }
            }
        }, "monitor");
        monitor.start();
    }
    //  Thread termination 
    public void stop() {
    
        monitor.interrupt();
    }
}

About isInterrupted() and Interrupted() Method
Both of these methods can determine the interruption state of the current thread , The difference lies in ：

interrupted() It's a static method , And reset the interrupt status of the current thread （ still false）. and isInterrupted() The current state will not be reset

public class test2 {
    
    public static void main(String[] args) {
    
        Thread thread = new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                try {
    
                    Thread.sleep(100 * 1000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.interrupt();
        Thread.currentThread().interrupt();
        System.out.println(" for the first time "+Thread.interrupted());
        System.out.println(" The second time "+Thread.interrupted());
    }
}

Here we are interrupt 了 main Threads , call interrupted() The method will be reset to false