Shutdown flag on runnable object

Question

I was writing a program of thread that contains a loop that sleeps for 30 seconds and the loop executes until a “shutdown” flag is set to true on the runnable object executing in the thread.

class MyThread extends Thread{
//set this to true to stop the thread
volatile boolean shutdown = false;

 public void stopMe() {
   shutdown=true;   
 }
 public void run () {
      while (!shutdown) {
      // continue processing
      try {
          Thread.sleep(30000);
      } catch (InterruptedException e) {}
     }
  }
}

But when the shutdown flag is set to true, will the thread exit immediately? What if it is in the sleep call? How can the thread be woken up immediately by another thread? Please help to get answers to these questions as am learning threading

Jean-François Savard · Accepted Answer · 2015-04-19T20:57:33.893

2

When the run method of a thread ends, the thread also end.

To answer your second question, you must take care about the sleeping part.

JLS 17.3. Sleep and Yield

It is important to note that neither Thread.sleep nor Thread.yield have any synchronization semantics. In particular, the compiler does not have to flush writes cached in registers out to shared memory before a call to Thread.sleep or Thread.yield, nor does the compiler have to reload values cached in registers after a call to Thread.sleep or Thread.yield.

For example, in the following (broken) code fragment, assume that this.done is a non-volatile boolean field:

while (!this.done)
    Thread.sleep(1000);

The compiler is free to read the field this.done just once, and reuse the cached value in each execution of the loop. This would mean that the loop would never terminate, even if another thread changed the value of this.done.

Note that in your case, it is correct as your flag is volatile, this is just a warning.

As for your final request, you can wake up a sleeping thread using Thread#interrupt. Note that interrupting a sleeping thread will throw an InterruptedException so make sure to handle it.

edited Apr 19 '15 at 20:57

answered Apr 19 '15 at 20:49

Jean-François Savard

20,626
7
49
76

What about third query ? – user3185653 Apr 19 '15 at 20:54
@user3185653 Edited for your final query, did not see it at first. – Jean-François Savard Apr 19 '15 at 21:01
@Jean-FrançoisSavard Can you modify code by using this InterruptedException ? – user3185653 Apr 19 '15 at 21:01
@user3185653 Check this thread http://stackoverflow.com/questions/24111441/java-wake-sleeping-thread – Jean-François Savard Apr 19 '15 at 21:03
`Thread#interrupt` is only good when you control what the thread is doing besides sleeping. Here there is nothing more, but in real life there can be call somewhere else where interrupt won't be correctly handled. Thus do interrupt but only when actually sleeping - you need to have `isSleeping` flag for this + some synchronization. – Piotr Findeisen Apr 19 '15 at 21:30
I added my own answer that tries to address that. – Piotr Findeisen Apr 19 '15 at 21:45

brain · Answer 2 · 2015-04-19T21:01:50.757

0

During the call to Thread.sleep() the thread can get interrupted. You've had to catch that exception in your code. So if you want to stop your Thread even while it is waiting you'd have to do something like:

MyThread myThread = new MyThread();
myThread.run();

//some time later we want to stop myThread

myThread.stopMe(); //sets the flag
myThread.interrupt(); //wakes the thread up if it is sleeping
myThread.join(); //wait for myThread to finish

edited Apr 19 '15 at 21:01

answered Apr 19 '15 at 20:54

brain

5,496
1
26
29

Can you add whole piece of code ? Am not getting what you are saying – user3185653 Apr 19 '15 at 20:56

score 0 · Answer 3 · answered Apr 19 '15 at 21:42

While the simple Thread.interrupt() answers the original question, this solution does not extend well to threads doing some real stuff when not sleeping. In that case, interrupt delivered in a wrong moment may mishandled by code we do not control. (It shouldn't, but I saw a few of real-life examples when this happens.)

So I would actually "abuse" locks to implements "interruptible sleep"

class MyThread extends Thread {

  private final Object sleepLock = new Object();

   //set this to true to stop the thread
   boolean shutdown = false;

   public void stopMe() {
     synchronized (sleepLock) {
         shutdown = true;
         sleepLock.notifyAll();
     }
   }

   private void sleepCancellably(long millis) throws InterruptedException {
      long sleepEnd = System.currentTimeMillis() + millis;
      synchronized (sleepLock) {
         while (!shutdown) {
           long remaning = sleepEnd - System.currentTimeMillis();
           if (remaining <= 0) {
               break;
           }
           sleepLock.wait(remainig); 
         }
      }
   }

 public void run () {
      while (!shutdown) {

        // when doing some important stuff, stopMe() want interrupt us
        doSomeImportantStuff();

        // continue processing
        try {
            sleepCancellably(30000);
        } catch (InterruptedException e) {
            // not expected. log.errror(e) or e.printStackTrace()
        }
     }
  }
}

Shutdown flag on runnable object

3 Answers3