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

This article focuses on "how to understand that Volatile+Interrupt is an elegant posture to stop threads". 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 how to understand that Volatile+Interrupt is an elegant posture to stop threads.

Use the stop method

Calling the stop method will cause the running thread to abort directly, possibly leaving some clean work undone. And stop has been marked as an obsolete method and is not recommended.

The correct posture is to use a two-phase termination mode, in which one thread sends a termination instruction and the other thread receives the instruction and decides when to stop.

Use flag bit

Public class RunTask {private volatile boolean stopFlag; private Thread taskThread; public void start () {taskThread = new Thread (()-> {while (! stopFlag) {System.out.println ("doSomething");}}); taskThread.start ();} public void stop () {stopFlag = true;}}

"adding volatile to stopFlag ensures visibility. My example uses the while loop to constantly judge. If while is not used in the project, it can be judged at the key node, and then exit the run method. "

Use the interrupt method

If we have blocking logic in our task, such as calling the Thread.sleep method, how do we stop the thread?

Find the answer from the thread state transition diagram

You can see from the figure that if you want a thread to enter the termination state, the premise is that the thread is running. When we want to terminate a thread, if the thread is in a blocking state, how do we transition it to the running state?

By calling the Thread#interrupt method, we can switch the blocked thread to the ready state, enter the running state scheduled by the operating system, and then terminate.

What happens when a thread calls the interrupt method while it is running?

Public class RunTaskCase1 {private Thread taskThread; public void start () {taskThread = new Thread (()-> {while (true) {System.out.println ("doSomething");}}); taskThread.start ();} public void stop () {taskThread.interrupt ();}}

Call the start method and the stop method in turn, and find that the thread does not stop.

"in fact, when a thread is running, the interrupt method simply marks a stop on the current thread, and the logic of stopping needs to be implemented by ourselves."

"the Thread class provides the following two methods to determine whether a thread is in an interrupted state"

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

IsInterrupted

Interrupted

Although both of these two methods can judge the state, there are slight differences.

@ Test public void testInterrupt () throws InterruptedException {Thread thread = new Thread (()-> {while (true) {}}); thread.start (); TimeUnit.MICROSECONDS.sleep (100); thread.interrupt (); / / true System.out.println (thread.isInterrupted ()); / / true System.out.println (thread.isInterrupted ()); / / true System.out.println (thread.isInterrupted ()) } @ Test public void testInterrupt2 () {Thread.currentThread () .interrupt (); / / true System.out.println (Thread.interrupted ()); / / false System.out.println (Thread.interrupted ()); / / false System.out.println (Thread.interrupted ());}

"the difference between isInterrupted and interrupted is as follows"

Thread#isInterrupted: test whether the thread is in interrupted state. Do not change the state flag Thread#interrupted after execution: test thread is in interrupted state, change the interrupt flag to false after execution

"so at this time, we don't need to customize the state, we can just use the interrupt flag, and the previous code can be changed to the following."

Public class RunTaskCase2 {private Thread taskThread; public void start () {taskThread = new Thread (()-> {while (! Thread.currentThread (). IsInterrupted ()) {System.out.println ("doSomething");}}); taskThread.start ();} public void stop () {taskThread.interrupt ();}}

When a thread is in a blocking state, calling the interrupt method throws an InterruptedException and terminates the execution of the thread

"Note: when an exception occurs, the interrupt flag of the thread is changed from true to false. "

So we have the following implementation when the thread is running: exit with self-defined flag bits when the thread is blocked: exit by throwing an exception

Public class RunTaskCase3 {private volatile boolean stopFlag; private Thread taskThread; public void start () {taskThread = new Thread (()-> {while (stopFlag) {try {System.out.println ("doSomething"); TimeUnit.MICROSECONDS.sleep (100) } catch (InterruptedException e) {e.printStackTrace ();}); taskThread.start ();} public void stop () {stopFlag = true; taskThread.interrupt ();}}

Of course, you can always exit with the interrupt flag, "Note that the interrupt flag bit needs to be reset when an exception occurs."

Public class RunTaskCase4 {private Thread taskThread; public void start () {taskThread = new Thread (() -) {while (! Thread.currentThread (). IsInterrupted ()) {try {System.out.println ("doSomething"); TimeUnit.MICROSECONDS.sleep (100) } catch (InterruptedException e) {/ / reset interrupt flag bit is true Thread.currentThread () .interrupt (); e.printStackTrace ();}); taskThread.start () } public void stop () {taskThread.interrupt ();}} at this point, I believe you have a deeper understanding of "how to understand that Volatile+Interrupt is an elegant posture to stop threads", so you might as well do it in practice! 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.