Four methods of thread termination

End of normal operation

This is also the most common , Refers to the completion of thread body execution , Thread ends automatically .

Use the exit flag to exit

In general , stay run When the method is finished , The thread ends normally . However , Some threads are background threads , It takes a long time to run , Only after the system meets some special conditions , To exit these threads . You can use a variable to control the loop , For example, set up a Boolean Type of logo , And by setting this flag to true or false To control while Does the loop exit .

public class ThreadDemo extends Thread {
    
	public volatile boolean exit = false;
	
    @Override
    public void run() {
    
		while (!exit) {
    
			// Business logic code 
		}
	}
}

An exit representation is defined in the above code exit,exit The default value is false. In defining exit I used one Java Key words of volatile, This keyword is used to guarantee exit Thread synchronization is safe , That is, only one thread can modify at a time exit Value , stay exit by true When ,while Loop exit , Thread termination .

Use Interrupt Method to terminate a thread

In the use of Interrupt Method when the thread is terminated , There are two cases

1. Thread is blocked

for example ： In the use of sleep、 Call the lock wait Or call socket Of receive、accept When waiting for the method , It will block the thread . In the calling thread interrupt When the method is used , Will throw out InterruptException abnormal , By catching exceptions in the code , And then through break Jump out of the condition monitoring cycle , End the execution of this thread . Usually many people think that just call interrupt Method will end the thread , This understanding is actually problematic , It must be captured first InterruptedException Pass after exception break Out of the loop , To end normally run Method .

public class InterruptThread {
    
    public static void main(String[] args) {
    
        InterruptDemo thread = new InterruptDemo();
        thread.start();
        thread.interrupt();
    }
}

class InterruptDemo extends Thread {
    
    @Override
    public void run() {
    
        while (Thread.currentThread().isInterrupted()) {
    
            try {
    
                System.out.println(" Execute task code , There is sleep");
                Thread.sleep(1000);// The writing is abnormal , There is an error to throw an exception 
            } catch (InterruptedException e) {
    
                e.printStackTrace();
                break;// When an exception is caught , You can exit the loop 
            }
        }
    }
}

2. The thread is in an unblocked state

At this time , Use isInterrupted Method to determine the interrupt flag of the thread to exit the loop . Calling interrupt Method time , The interrupt flag will be set to true, At this time, you cannot exit the thread immediately, but you need to perform the resource release operation before the thread terminates , Wait for the resources to be released before exiting the thread safely .

Use stop Method to terminate a thread

Use stop Method to terminate a thread is not safe
You can call directly in the program Thread.stop Method to force thread termination , But it's dangerous , It's like suddenly cutting off the power supply of your computer , Instead of ending normally , This may lead to some unpredictable consequences .

Use... In the program Thread.sleep Method to terminate the thread , The child thread of this thread will throw ThreadDeatherror error , And release all the locks held by the child thread lock , Locked code blocks are generally used to protect data consistency , If you're calling Thread.stop Method causes all locks held by the thread lock to be suddenly released, making the lock resources uncontrollable . The protected data may be inconsistent , When other threads use the corrupted data , It is possible that the program is running incorrectly , therefore , It is not recommended to terminate threads in this way .

---

Poke here to learn Java Middle lock

Last one ：===》 Thread life cycle and various methods