Question

I’m using the below implementation to stop a thread in Tomcat. The code works, but I’m wondering two things:

1. Is it necessary to have Thread.sleep() in the try statement of MyConsumer.java?
2. Instead of checking for my boolean flag, running, should I remove the concept of a flag and just check for while(!Thread.currentThread().isInterrupted)?

ServletContextListener:

public final class ApplicationListener implements ServletContextListener {

    private Thread thread = null;
    private MyConsumer k = null;

    public ApplicationListener() {
    }

    @Override
    public void contextInitialized(ServletContextEvent event) {

        k = new MyConsumer();
        thread = new Thread(k);

        thread.start();

    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        if (thread != null) {
            k.terminate();
            try {
                thread.join();
            } catch (InterruptedException ex) {
                Logger.getLogger(ApplicationListener.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

MyConsumer.java:

public class MyConsumer implements Runnable {

    private volatile boolean running = true;

    public MyConsumer() {
    }

    public void terminate() {
        running = false;
    }

    @Override
    public void run() {

            while (running) {

                try {

                    doStuff();
                    Thread.sleep((long) 1000);

                } catch (InterruptedException ex) {
                    Logger.getLogger(MyConsumer.class.getName()).log(Level.SEVERE, null, ex);
                    running = false;
                }
            }

    }

Answer 1

Is it necessary to have Thread.sleep() in the try statement of MyConsumer.java

No. The sleep call, I presume, is there to make sure that doStuff() is executed with an interval of 1 second between every invocation, rather than executed continuously. If you want this 1 second interval, you need to leave the sleep call there. If you want doStuff() to be executed continuously, then you need to remove the sleep.

Instead of checking for my boolean flag, running, should I remove the concept of a flag and just check for while(!Thread.currentThread().isInterrupted)?

Yes, that’s what I would indeed do. It would remove the need for the flag, and would allow stopping the thread as soon as possible, rather than having to wait for the sleep call to return, after 1 second. The other advantage is that you can check if the thread is interrupted inside the doStuff() method, in case it’s a long-running method that you want to stop ASAP.