How to interrupt a running thread in Java (1)

Multi-threading presents a new set of problems for programmers during the programming process, and how to interrupt a running thread is one of the problems. In this article, the author will describe related methods.

The procedure is very simple. However, multithreading presents a new set of challenges for programmers that, if not addressed appropriately, can lead to unexpected behavior and subtle, hard-to-find errors.

In this article, we address one of these problems: how to interrupt a running thread.

Background interrupting a thread means stopping everything the thread is doing before it completes its task, effectively aborting its current operation. Whether the thread dies, waits for a new task, or continues to the next step depends on this program. While it may seem simple at first, you must take some forewarning to achieve the desired results. You'd better keep the following warnings in mind.

First of all, forget about the Thread.stop method. Although it does stop a running thread, however, this method is unsafe and not recommended, which means that in a future version of Java, it will no longer exist.

Some rash fellows may be fooled by another method, Thread.interrupt. Despite what its name seems to imply, however, this method does not interrupt a running thread (more on this later), as described in Listing A. It creates a thread and tries to stop it using the Thread.interrupt method. The call to the Thread.sleep() method provides ample time for the thread to initialize and terminate. The thread itself does not participate in any useful operations.

class Example1 extends Thread {
            boolean stop=false;
            public static void main( String args[] ) throws Exception {
            Example1 thread = new Example1();
            System.out.println( "Starting thread..." );
            thread.start();
            Thread.sleep( 3000 );
            System.out.println( "Interrupting thread..." );
            thread.interrupt();
            Thread.sleep( 3000 );
            System.out.println("Stopping application..." );
            //System.exit(0);
            }
            public void run() {
            while(!stop){
            System.out.println( "Thread is running..." );
            long time = System.currentTimeMillis();
            while((System.currentTimeMillis()-time < 1000)) {
            }
            }
            System.out.println("Thread exiting under request..." );
            }
            }

If you run the code in Listing A, you will see the following output on the console:

Starting thread...
Thread is running...
Thread is running...
Thread is running...
Interrupting thread...
Thread is running...
Thread is running...
Thread is running...
Stopping application...
Thread is running...
Thread is running...
Thread is running...
.....................

Even after Thread.interrupt() is called, the thread continues to run .

Really interrupting a thread

The best and most recommended way to interrupt a thread is to use a shared variable to signal that the thread must stop the running task. The thread must periodically check this variable (especially during redundant operations) and then terminate the task in an orderly manner. Listing B describes this approach.

Listing B
class Example2 extends Thread {
  volatile boolean stop = false;
  public static void main( String args[] ) throws Exception {
    Example2 thread = new Example2();
   System.out.println( "Starting thread..." );
   thread.start();
   Thread.sleep( 3000 );
   System.out.println( "Asking thread to stop..." );
   thread.stop = true;
   Thread.sleep( 3000 );
   System.out.println( "Stopping application..." );
   //System.exit( 0 );
  }
  public void run() {
    while ( !stop ) {
     System.out.println( "Thread is running..." );
      long time = System.currentTimeMillis();
      while ( (System.currentTimeMillis()-time < 1000) && (!stop) ) {
      }
    }
   System.out.println( "Thread exiting under request..." );
  }
}

Running the code in Listing B will produce the following output (note how the threads exit in an orderly manner)

Starting thread...
Thread is running...
Thread is running...
Thread is running...
Asking thread to stop...
Thread exiting under request...
Stopping application...

Although this method requires some coding, it is not difficult to implement. At the same time, it gives the threads a chance to do the necessary cleanup work, which is absolutely necessary in any multi-threaded application. Make sure to define the shared variable as volatile or enclose all access to it in synchronized blocks/methods.

So far so good! But what happens when a thread is blocked waiting for some event to occur? Of course, if the thread is blocked, it cannot check the shared variables and cannot stop. This happens in many situations, such as when calling Object.wait(), ServerSocket.accept(), and DatagramSocket.receive(), just to name a few.

They may all block the thread permanently. Even if a timeout occurs, it is not feasible and appropriate to continue waiting before the timeout expires. Therefore, some mechanism must be used to allow the thread to exit the blocked state earlier.

Unfortunately, there is no such mechanism that works in all situations, but specific techniques can be used depending on the situation. In the following links, I will answer the most common examples.

The above is the content of how to interrupt a running thread (1) in Java. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!