Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are the ways of interrupting threads in java". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what are the ways of interrupting threads in java?"

Interrupt

Interrupt a thread means that it stops what it is doing before it finishes the task, effectively aborting its current operation. Whether the thread dies, waits for a new task, or continues to run to the next step depends on the program. Although it may seem simple at first glance, you must make some early warning to achieve the desired results. You'd better keep the following warnings in mind.

First, forget the Thread.stop method. Although it does stop a running thread, this approach is unsafe and unadvocated, which means that it will no longer exist in future versions of JAVA.

How to safely end a running thread

Methods related to the Thread class

The java.lang.Thread class contains some commonly used methods, such as start (), stop (), stop (Throwable), suspend (), destroy (), resume (). Through these methods, we can easily manipulate the thread, but of these methods, only the start () method is preserved.

The reasons for abandoning these methods are explained in the JDK help documentation and an article from Sun, "Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?".

To put it simply: although using the stop method can forcibly terminate running or suspended threads, using the stop method is very dangerous, just like suddenly shutting down the computer instead of shutting down the computer according to the normal program, it may produce unpredictable results, therefore, it is not recommended to use the stop method to terminate the thread.

So how on earth should we stop the thread?

1. There is usually a loop structure in the task, and as long as the loop is controlled by a marker, the task can be finished.

2. If the thread is in a frozen state and cannot read the tag, you can use the interrupt () method to restore the thread from the frozen state to the running state, so that the thread is qualified to execute CPU.

(1): use the exit flag

When the run method is executed, the thread exits. But sometimes the run method never ends, such as using threads to listen for client requests in a server program, or other tasks that need to be looped.

In this case, it is common to put these tasks in a loop, such as a while loop. If you want the while loop to exit under certain conditions, the most direct way is to set a flag of type boolean and control whether the while loop exits by setting this flag to true or false.

Public class test1 {public static volatile boolean exit = false; / / exit flag public static void main (String [] args) {new Thread () {public void run () {System.out.println ("thread started"); while (! exit) {try {Thread.sleep (1000) } catch (InterruptedException e) {e.printStackTrace ();}} System.out.println ("Thread ends");} .start (); try {Thread.sleep (1000 * 5) } catch (InterruptedException e) {e.printStackTrace ();} exit = true;//5 changes the value of the exit flag after a second. Without this code, the thread cannot stop}}

(2) using interrupt method

The Thread.interrupt () method: the function is to interrupt the thread. The interrupt state bit of the thread will be set to true, and whether the resulting thread dies, waits for a new task or continues to run to the next step depends on the program itself. The thread detects this interrupt flag bit from time to time to determine whether the thread should be interrupted (whether the interrupt marker value is true). It doesn't break a running thread like the stop method does.

The interrupt () method simply changes the interrupt state without interrupting a running thread. The user is required to monitor the status of the thread and do the processing. The method that supports thread interrupts (that is, the method in which a thread throws an interruptedException after an interrupt) is to monitor the interrupt state of a thread, and an interrupt exception is thrown once the thread's interrupt state is set to "interrupt state". What this method actually does is send an interrupt signal to the blocked thread so that the blocked thread checks the interrupt flag and can exit the blocked state.

More specifically, if a thread is blocked by one of the three methods Object.wait, Thread.join, or Thread.sleep, and the thread's interrupt () method is called at this time, the thread will throw an InterruptedException interrupt exception (the thread must be prepared to handle this exception in advance), thus terminating the blocked state early. If the thread is not blocked, the call to interrupt () will not work until it reaches wait (), sleep (), and join (), and InterruptedException will not be thrown immediately.

Use interrupt () + InterruptedException to interrupt the thread

When a thread is in a blocking state, such as Thread.sleep, wait, IO blocking, etc., after calling the interrupt method, sleep and other methods will throw an InterruptedException:

Public static void main (String [] args) {Thread thread = new Thread () {public void run () {System.out.println ("Thread started"); try {Thread.sleep (1000 * 100);} catch (InterruptedException e) {e.printStackTrace () } System.out.println (Thread ends);}}; thread.start (); try {Thread.sleep (1000 * 5);} catch (InterruptedException e) {e.printStackTrace ();} thread.interrupt () / / the function is to throw an interrupt signal when the thread is blocked, so that the thread can exit the blocked state}

Use interrupt () + isInterrupted () to interrupt the thread

This.interrupted (): tests whether the current thread has been interrupted (static method). If the method is called continuously, the second call returns false. Explain in the api document that the interrupted () method has the ability to clear the state. After execution, it has the function of clearing the status identification to false.

This.isInterrupted (): test whether the thread has been interrupted, but the status identity cannot be cleared.

Public static void main (String [] args) {Thread thread = new Thread () {public void run () {System.out.println ("Thread started"); while (! isInterrupted ()) {System.out.println (isInterrupted ()) / / true} System.out.println ("Thread ends") after calling interrupt;}}; thread.start (); try {Thread.sleep (1000);} catch (InterruptedException e) {e.printStackTrace ();} thread.interrupt () System.out.println ("whether the thread is interrupted:" + thread.isInterrupted ()); / / true}

.

Let's take a comprehensive example:

Public class test1 {static volatile boolean flag = true; public static void main (String [] args) {Thread thread = new Thread (new Runnable () {@ Override public void run () {System.out.println ("start hibernation"); try {Thread.sleep (100 * 1000) } catch (InterruptedException e) {e.printStackTrace ();} System.out.println ("end dormancy, start endless cycle") While (flag) {} System.out.println ("- child thread ends -"); thread.start (); Scanner scanner = new Scanner (System.in) System.out.println ("input 1 throws an interrupt exception, enter 2 to modify the loop flag bit, enter 3 to determine whether the thread is blocked, enter other end Scanner\ n"); while (scanner.hasNext ()) {String text = scanner.next (); System.out.println ("you entered:" + text + "\ n") If ("1" .equals (text)) {thread.interrupt ();} else if ("2" .equals (text)) {flag = false; / / if not set to false, the child thread is still running after the end of the main thread} else if ("3" .equals (text)) {System.out.println (thread.isInterrupted () } else {scanner.close (); break;}} System.out.println ("- main thread ends -");}}

A situation that cannot be ended.

Note that the following is a situation that cannot be ended at all!

Public class Test {public static void main (String [] args) {Thread thread = new Thread () {public void run () {System.out.println ("Thread started"); while (true) {/ / in this case, even if the thread calls the intentrupt () method and isInterrupted (), the thread continues to run and can't stop! System.out.println (isInterrupted ()); / / true} after calling interrupt; thread.start (); thread.interrupt () Note that this method does not interrupt a running thread, but throws an interrupt signal when the thread is blocked so that the thread can exit the blocked state while (true) {System.out.println ("whether isInterrupted:" + thread.isInterrupted ()); / / true}.

Notes on the interrupted () and isInterrupted () methods

Interrupted () is a static method: the internal implementation is the isInterrupted () of the current thread that is called and resets the interrupt state of the current thread.

Test whether the current thread has been interrupted (static method). The last interrupt state is returned, and it is cleared, so it is called twice in a row, returning true the first time and false the second time.

IsInterrupted () is the instance method, which is the isInterrupted () of the thread represented by the object that called the method, and does not reset the interrupt state of the current thread.

The test thread is currently interrupted, but the status identity cannot be cleared.

Test method verification:

1:

The first thread interrupted in the red box is the thread we created ourselves. The interrupted () I called is to judge the interrupt status of the current thread from the above source code. The current thread is a main thread, and I have not interrupted the main thread at all, so both calls return "false".

2:

The thread interrupted by the first red box is the current thread (main thread). The interrupted () I called is to judge the interrupt state of the current thread from the above source code. The current thread is a main thread, so the result of the first call returns "true" because I did interrupt the main thread.

According to the source code, interrupted () calls isInterrupted () and resets the interrupt state, so the interrupt state is reset after the first call, from the interrupt state to the non-interrupt state, so the result of the second call returns "false".

3:

The first thread interrupted in the red box is the thread created by ourselves. The isInterrupted () I called is to judge the interrupt state of the thread represented by the object executing the method, that is, the interrupt state of the thread represented by the thread reference, so the result of the first call returns "true".

According to the source code, isInterrupted () does not reset the interrupt state, so the interrupt state is not reset after the first call (from the interrupt state to the non-interrupt state), so the result of the second call also returns "true".

At this point, I believe that we have a deeper understanding of the "java interrupt thread in which ways", might as well to the actual operation of it! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.