Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How can I kill a thread? without using stop();

Thread currentThread=Thread.currentThread();         public void run()         {                              while(!shutdown)             {                                                try                 {                     System.out.println(currentThread.isAlive());                 Thread.interrupted();                  System.out.println(currentThread.isAlive());                 if(currentThread.isAlive()==false)                 {                     shutdown=true;                 }                 }                 catch(Exception e)                 {                     currentThread.interrupt();                 }                                }         }      });     thread.start(); 
like image 673
greeshma Avatar asked May 06 '11 17:05

greeshma


People also ask

How do you kill a specific thread in Java?

Modern ways to suspend/stop a thread are by using a boolean flag and Thread. interrupt() method. Using a boolean flag: We can define a boolean variable which is used for stopping/killing threads say 'exit'. Whenever we want to stop a thread, the 'exit' variable will be set to true.

How do you kill threads?

Using a hidden function _stop() : In order to kill a thread, we use hidden function _stop() this function is not documented but might disappear in the next version of python.

Can we terminate a thread?

A thread automatically terminates when it returns from its entry-point routine. A thread can also explicitly terminate itself or terminate any other thread in the process, using a mechanism called cancelation.


1 Answers

The alternative to calling stop is to use interrupt to signal to the thread that you want it to finish what it's doing. (This assumes the thread you want to stop is well-behaved, if it ignores InterruptedExceptions by eating them immediately after they are thrown and doesn't check the interrupted status then you are back to using stop().)

Here's some code I wrote as an answer to a threading question here, it's an example of how thread interruption works:

public class HelloWorld {      public static void main(String[] args) throws Exception {         Thread thread = new Thread(new Runnable() {              public void run() {                 try {                     while (!Thread.currentThread().isInterrupted()) {                         Thread.sleep(5000);                         System.out.println("Hello World!");                     }                 } catch (InterruptedException e) {                     Thread.currentThread().interrupt();                 }             }         });         thread.start();         System.out.println("press enter to quit");         System.in.read();         thread.interrupt();     } } 

Some things to be aware of:

  • Interrupting causes sleep() and wait() to immediately throw, otherwise you are stuck waiting for the sleep time to pass.

  • Note that there is no need for a separate boolean flag.

  • The thread being stopped cooperates by checking the interrupted status and catching InterruptedExceptions outside the while loop (using it to exit the loop). Interruption is one place where it's ok to use an exception for flow control, that is the whole point of it.

  • Setting interrupt on the current thread in the catch block is technically best-practice but is overkill for this example, because there is nothing else that needs the interrupt flag set.

Some observations about the posted code:

  • The posted example is incomplete, but putting a reference to the current thread in an instance variable seems like a bad idea. It will get initialized to whatever thread is creating the object, not to the thread executing the run method. If the same Runnable instance is executed on more than one thread then the instance variable won't reflect the right thread most of the time.

  • The check for whether the thread is alive is necessarily always going to result in true (unless there's an error where the currentThread instance variable is referencing the wrong thread), Thread#isAlive is false only after the thread has finished executing, it doesn't return false just because it's been interrupted.

  • Calling Thread#interrupted will result in clearing the interrupt flag, and makes no sense here, especially since the return value is discarded. The point of calling Thread#interrupted is to test the state of the interrupted flag and then clear it, it's a convenience method used by things that throw InterruptedException.

like image 94
Nathan Hughes Avatar answered Oct 11 '22 20:10

Nathan Hughes