Java Thread.stop() vs Thread.interrupt()

Question

I have the following code:

renderThread = new Thread(new Runnable() {

    @Override
    public void run() {
        for (int i = 0; i < 10000000; i++) {
            System.out.println("Number: " + i);
        }
    }
});

renderThread.start();

try {
    Thread.sleep(100);
} catch (InterruptedException ex) {
    ex.printStackTrace();
}

renderThread.interrupt(); //It should stop, but it does not stop.

renderThread.interrupt() does not interrupt the thread, it continues to run. If I replace renderThread.interrupt() with .stop(), then the thread stops. However, .stop() is deprecated. Then, what is the proper way of stopping a thread, if stop is deprecated and interrupt does not work?

Why do you think that calling `interrupt` would _stop_ the thread`? — Sotirios Delimanolis, Dec 11 '13 at 19:10
possible duplicate of [How to properly stop the Thread in Java](http://stackoverflow.com/questions/10961714/how-to-properly-stop-the-thread-in-java) — Mike M, Dec 11 '13 at 19:11
@SotiriosDelimanolis Because, colloquially, "interrupting something" and "stopping something" are synonymous .. I'm not say it's what it *does* (and the documentation is a good place to start unwinding the assumption), but the name is loaded. — user2864740, Dec 11 '13 at 19:40

score 27 · Answer 1 · answered Dec 11 '13 at 19:17

27

When you call interrupt() it triggers a boolean flag which tells the run function it should stop. That is why I usually write my run functions like this.

void run()
{
    while(!Thread.interrupted())
    {
        //Do something
    }
}

Just because you call interrupt doesn't mean the thread will stop immediately or at all. It depends on what is in the run function.

answered Dec 11 '13 at 19:17

chasep255

11,745
8
58
115

So it means, that after an interrupt event happens and the code reaches the end of the `run()`, then the thread automatically ceases to exist? – Ágota Horváth Dec 11 '13 at 19:30
1

Yes. All far as I know threads should only stop when run exits. Interrupting run just lets it know it should exit as soon as possible. The problem with calling stop() is that say run() had to do some cleanup like close a stream then this would not happen. – chasep255 Dec 13 '13 at 16:10
2

I think this solution cannot solve the question here. When the renderThread executes the task, it has no chance to check Thread.interrupted(). – Jimmy May 27 '15 at 04:29
if you have `sleep` method in your thread, you will have to call `interrupt` method in this thread in `try...catch (InterruptedException)`: https://stackoverflow.com/a/36258705/7767664 – user924 Jan 16 '19 at 07:46

score 6 · Answer 2 · answered Dec 11 '13 at 19:18

To really push the point why you shouldnt use Thread.stop()?

Doug Lea recently mentioned that Thread.stop will be the first de-implemented method for Java come Java 8.

His response to this comment from someone:

Also, one other thing synchronized has going for it is it handles async aborts of threads (I.e. thread.stop()). I know stop() is deprecated and all, but you never know.

Was:

But you do know! As of JDK8, Thread.stop is really gone. It is the first deprecated method to have actually been de-implemented. It now just throws UnsupportedOperationException.

http://cs.oswego.edu/pipermail/concurrency-interest/2013-December/012028.html

score 5 · Answer 3 · answered Dec 11 '13 at 19:13

You should take a look at this article: http://10kloc.wordpress.com/2013/03/03/java-multithreading-steeplechase-stopping-threads/

Basically you shouldn't STOP a thread (unsafe), but interrupt it. What you're missing is making the thread handle the interruption.

Sage · Answer 4 · 2013-12-11T20:11:01.557

renderThread.interrupt() does not interrupt the thread, it continues to run.

If the thread is executing and interrupt() is invoked it's interrupt status is set.
If this thread is blocked in an invocation one of wait methods of the Object class, or of the Thread.join and Thread.sleep methods of this class then its interrupt status will be cleared and it will receive an InterruptedException.

For example:

Thread t = new Thread()
      {
          public void run()
          {
              try {
                  for(int i=0; i<10000;i++)
                      System.out.println("Is interrupTed? "+this.isInterrupted());

                  Thread.sleep(200);
              } catch (InterruptedException ex) {
                  Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
              }

          }
      };
      t.start();
      t.interrupt();
    }

The above code, I have used a for loop to intercept the interrput flag with isInterrupted() function and printed it. As t.interrupt() is invoked, isInterrupted() will return true which you will see in the console. As soon as it reaches the Thread.sleep(miliTime) you will see that InterruptedException is caught which was thrown as described above.

Stopping a thread:

you could make use of this isInterrupted() flag check if an interrupt() was invoked on it and return from the execution:

For example:

Thread t = new Thread()
      {
          public void run()
          {
              long executeTime = System.currentTimeMillis() ;
              int i = 0;    
              for(; i<10000 && !this.isInterrupted();i++)
                      System.out.println("Is interrupted? "+this.isInterrupted());

               System.out.println("Was Interrupted? "+this.isInterrupted()
                                  +" after cycle: "+ i);
               System.out.println("Time it gets Executed: "
                                  +(System.currentTimeMillis() - executeTime+" ms"));

          }
      };
      t.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
      t.interrupt();

While running the above code: i have sent the main thread to sleep for 200 inside the static main function to allow the started thread t to run for some time. Then i invoked
t.interrupt() on it which causes the for loop to stop and print a output as following:

Was Interrupted? true after cycle: 1477
Time it gets Executed: 258 ms

Which indicates that the for loop has 1148 iteration before t.interrupt(); was invoked in the main function.

Please read the documentation of Thread.interrupt() function for more details.

score 3 · Answer 5 · answered Dec 07 '14 at 00:10

All You need do to interrupt the current thread or terminate the running process of the thread is to add the below statement within you catch block

try
{
   Thread.sleep(4000);
   System.out.println("VAS CONSULTING")
}
catch(InterruptedException e)
{
   //Stop printing out VAS CONSULTING
   return;  /*This will terminate the thread*/
}

also if a method that doesn't throw an Interrupted Exception isn't used within the run method you can do this to handle Thread Interruption or terminate the Thread

@Override
public void run()
{

   System.out.println("VAS CONSULTING");
   if(Thread.Interrupted())
   {
     doSomethingElse();//process something else within the thread
    return; //Terminates the current Thread
   }

}

I hope this Helps You or Someone Else.

score 0 · Answer 6 · answered Dec 11 '13 at 19:16

0

interrupt() method does not stop the Thread. read this for more detailed explanation http://www.ibm.com/developerworks/java/library/j-jtp05236/

answered Dec 11 '13 at 19:16

csn

376
7
18

Java Thread.stop() vs Thread.interrupt()

6 Answers6

Linked