Shutting down a thread instantly - should this work?

[John McParland]

Hi folks,

in my application, when a user chooses to shutdown, I need to stop a few threads instantly which may have be sleeping. I think I have a solution for this but unfortunately there are folks who've noticed the thread is still running when the app has been shut down. I can't reproduce this behaviour and I was wondering if anyone would kindly have a look at the code below to see if there's anything obviously wrong?

package john;

import java.util.Collection;

/**
 * Periodically checks the log for events and when needed, cleans it out
 */
public class LogRunner implements Runnable
{

    /**
     * The logger which will be checked
     */
    private Logger<? extends LogEvent> logger = null;

    /**
     * Can the runner run?
     */
    private boolean canRun = false;

    /**
     * The length of time to sleep for in seconds
     */
    private int sleepTime = 60;

    /**
     * Should the last message be sent?
     */
    private boolean sendLastMessage = true;

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    public void run()
    {
        while (getCanRun())
        {
            // We do this out of the synchronized context
            sendLogMsg(cloneQueue());
            // Go to sleep for a while
            try
            {
                Thread.sleep(getSleepTime() * 1000);
            }
            catch (InterruptedException ie)
            {
                // This is ok, in fact this is how this object stops running,
                // see Thread#interrupt()
            }
        }
        // Just before exiting send any remaining messages (regardless of how many)
        if (getSendLastMessage())
        {
            sendLogMsg(cloneQueue());
        }
    }

    /**
     * Clone the loggers queue so that messages can be sent
     * 
     * @return A copy of the loggers queue
     */
    private Collection<? extends LogEvent> cloneQueue()
    {
        Collection<? extends LogEvent> clonedQueue = null;
        synchronized (getLogger().getQueue().getQueue())
        {
            clonedQueue = getLogger().getQueue().cloneQueue();
            // Clear the original
            getLogger().getQueue().getQueue().clear();
        }
        return clonedQueue;
    }

    /**
     * Send a log message with the list of messages given
     * 
     * @param queue The list of messages
     */
    private void sendLogMsg(Collection<? extends LogEvent> queue)
    {
        LogMessage msg = new LogMessage(queue, getLogger().getType());
        // do something to send message
    };

    /**
     * @return the logger
     */
    public Logger<? extends LogEvent> getLogger()
    {
        return logger;
    }

    public void setLogger(Logger<? extends LogEvent> logger)
    {
        this.logger = logger;
    }

    public boolean getCanRun()
    {
        return canRun;
    }

    /**
     * Dissallow this runner from running.
     * <p>
     * If you wish to completely stop this LogRunner running call {@link stop()} instead.
     * </p>
     * 
     * @param Can this run?
     */
    public void setCanRun(boolean canRun)
    {
        this.canRun = canRun;
    }

    public int getSleepTime()
    {
        return sleepTime;
    }

    public void setSleepTime(int sleepTime)
    {
        this.sleepTime = sleepTime;
    }

    /**
     * Stop this runner running
     * <p>
     * You must also call interrupt() on the thread which uses this Runnable
     * </p>
     * 
     * @param sendLast Should the last message be sent or not
     */
    public void stop(boolean sendLast)
    {
        setCanRun(false);
        setSendLastMessage(sendLast);
        setSleepTime(1);
    }

    public boolean getSendLastMessage()
    {
        return sendLastMessage;
    }

    public void setSendLastMessage(boolean sendLast)
    {
        sendLastMessage = sendLast;
    }

}
 

The code to start the thread is;

   
LogRunner auditLogRunner = new LogRunner();
auditLogRunner.setLogger(AuditLogger.instance());
auditLogRunner.setSleepTime((int) STUserConfig.instance().getLong(60);
auditLogRunner.setCanRun(true);

Thread auditLogThread = new Thread(auditLogRunner, "Audit log thread");
auditLogThread.start();
 

And the code to stop is;

    
        if (null != auditLogThread && null != auditLogRunner)
        {
            // Need to tell the runner to stop then interrupt the thread in case it is sleeping
            auditLogRunner.stop(nice);
            auditLogThread.interrupt();
            // Join up the threads of execution
            try
            {
                auditLogThread.join(auditLogRunner.getSleepTime() * 1000);
            }
            catch (InterruptedException ie)
            {
                ie.printStackTrace();
            }
            finally
            {
                auditLogRunner = null;
                auditLogThread = null;
            }
        }

[William Brogden]

Seems to me that if you make all these other Threads daemon threads then the JVM will automatically stop them when your main user Threads exit.

See java.lang.Thread.setDaemon( true ); javadocs.

Bill