Question

In the code below, I have a while(true) loop. Consider a situation where there is some code in the try block where the thread is supposed to perform some tasks which takes about a minute, but due to some expected problem, it is running for ever. Can we stop that thread?

public class thread1 implements Runnable {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        thread1 t1 = new thread1();
        t1.run();
    
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            try{        
                Thread.sleep(10);
            
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

Answer 1

First of all, you are not starting any thread here! You should create a new thread and pass your confusingly named thread1 Runnable to it:

thread1 t1 = new thread1();
final Thread thread = new Thread(t1);
thread.start();

Now, when you really have a thread, there is a built in feature to interrupt running threads, called… interrupt():

thread.interrupt();

However, setting this flag alone does nothing, you have to handle this in your running thread:

while(!Thread.currentThread().isInterrupted()){
    try{        
        Thread.sleep(10);
    }
    catch(InterruptedException e){
        Thread.currentThread().interrupt();
        break; //optional, since the while loop conditional should detect the interrupted state
    }
    catch(Exception e){
        e.printStackTrace();
    }

Two things to note: while loop will now end when thread isInterrupted(). But if the thread is interrupted during sleep, JVM is so kind it will inform you about by throwing InterruptedException out of sleep(). Catch it and break your loop. That’s it!

---

As for other suggestions:

• About Thread.stop():

Deprecated. This method is inherently unsafe[…]

• Adding your own flag and keeping an eye on it is fine (just remember to use AtomicBoolean or volatile!), but why bother if JDK already provides you a built-in flag like this? The added benefit is interrupting sleeps, making thread interruption more responsive.