Question

Consider a user interface that accepts configuration settings for a service that takes a long time to initialize (for example, the parameters for a JDBC connection). We want our user interface to remain responsive while the service initialization occurs. If the user makes additional changes, the initialization should be cancelled and restarted using the new parameters.

Because parameters are incorporated in the configuration as the user types each character, it’s possible that a number of initialization requests could be created in a row. Only the last one should be executed.

We have code that we’ve put together that achieves this result, but it seems like this behavior is a very good candidate for implementation as an ExecutorService. Before we refactor everything into an ExecutorService, I figured I would ask if there are similar implementations already out in the world.

To be more specific:

The ExecutorService would have one worker thread. As soon as a new task is submitted, the current task is cancelled (and the worker interrupted). The new task is then captured for the next execution. If another task is submitted, the current task is cancelled again, and the “next execution” task is set to this new task. When the worker thread finally picks up the next task for execution, it will always be the last task submitted – all other tasks are either cancelled or discarded.

Does anyone have an implementation like that they’d be willing to share? Or is there maybe a standard library that covers this type of behavior? It’s not hard to implement, but getting the thread safety nailed down can be tricky, so I’d rather use proven code if we can.

Answer 1

Here’s what I eventually came up with – I’m interested in any comments:

public class InterruptingExecutorService extends ThreadPoolExecutor{
    private volatile FutureTask<?> currentFuture;

    public InterruptingExecutorService(boolean daemon) {
        super(0, 1, 1000L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), 
                daemon ? new DaemonThreadFactory() : Executors.defaultThreadFactory());

    }

    public static class DaemonThreadFactory implements ThreadFactory{
        ThreadFactory delegate = Executors.defaultThreadFactory();

        @Override
        public Thread newThread(Runnable r) {
            Thread t = delegate.newThread(r);
            t.setDaemon(true);
            return t;
        }

    }

    private void cancelCurrentFuture(){
        // cancel all pending tasks
        Iterator<Runnable> it = getQueue().iterator();
        while(it.hasNext()){
            FutureTask<?> task = (FutureTask<?>)it.next();
            task.cancel(true);
            it.remove();
        }

        // cancel the current task
        FutureTask<?> currentFuture = this.currentFuture;
        if(currentFuture != null){
            currentFuture.cancel(true);
        }
    }

    @Override
    public void execute(Runnable command) {
        if (command == null) throw new NullPointerException();

        cancelCurrentFuture();
        if (!(command instanceof FutureTask)){ // we have to be able to cancel a task, so we have to wrap any non Future
            command = newTaskFor(command, null);
        }
        super.execute(command);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        // it is safe to access currentFuture like this b/c we have limited the # of worker threads to only 1
        // it isn't possible for currentFuture to be set by any other thread than the one calling this method
        this.currentFuture = (FutureTask<?>)r;
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        // it is safe to access currentFuture like this b/c we have limited the # of worker threads to only 1
        // it isn't possible for currentFuture to be set by any other thread than the one calling this method
        this.currentFuture = null;
    }
}