How can I report progress from a background task?

Question

I have a long running task that is executing in the background on an ExecutorService thread pool. What are some best practices in terms of this task returning progress or intermediate results? Are there any libraries that provide this functionality?

EDIT: To clarify, I'm talking about reporting progress to other code, not to the user.

Normally I would use SwingWorker, but I'm working with a Java/Groovy backend for a Grails app, and I'm unsure how that would behave in a headless server environment since it has EDT ties.

Another example is the Jobs framework in Eclipse RCP, but I would need something that doesn't have ties to the UI.

Answer 1

Hey you could possibly try and implement the Observer Pattern and have interested parties subscribe to the worker thread (extension of java.util.Observable or similar) or another Class that manages the observers.

You could use java.util.Observer and java.util.Observable or roll your own.

Simple Example of some Interfaces implementing the Observer Pattern:

public interface ObservableSubject<T extends SubjectObserver, V> {

   void registerObserver(T observer);

   void removeObserver(T observer);

   void notifyObservers(V notificationPayload); 

}


public interface SubjectObserver<T> {

   void handleNotification(T notificationPayload);
}

More info: Observer Pattern on Wikipedia

Answer 2

Why not just use a callback? When starting the background task, pass an object with a callback function to the task and let the task report progress that way. Without any involved UI you dont need to change thread to do so.

Answer 3

The answers from Adrian and edwardTheGreat are both good options. It all depends on how you want the "other code" to consume status updates. A third option is to use a message queue into which the background thread writes periodic status. A really general version of this would use JMS.

Answer 4

I designed a simple interface for this:

public interface Process<TState, TResult> {

    void onProgress(final Consumer<TState> callback);

    void onCompletion(final Consumer<TResult> callback);
}

The usage is like this:

final Process<Float, Either<IOException, String>> p = download(executor, url);

p.onProgress(progress -> {
    System.out.println("Progress: " + progress * 100);
});

p.onComplete(result -> {
    System.out.println("Finished: " + result.toString());
});

And an generic implementation, which should be thread-safe:

import com.google.common.base.Preconditions;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public final class SettableProcess<TState, TResult> implements Process<TState, TResult> {

    private final Object LOCK = new Object();

    private final List<Consumer<TState>> progressCallbacks;
    private final List<Consumer<TResult>> completionCallbacks;

    private volatile boolean isComplete;
    private volatile TResult result;

    private SettableProcess() {

        progressCallbacks = new ArrayList<>();
        completionCallbacks = new ArrayList<>();

        isComplete = false;
        result = null;
    }

    @Override
    public void onProgress(final Consumer<TState> callback) {
        Preconditions.checkNotNull(callback);
        if (!isComplete) {
            synchronized (LOCK) {
                if (!isComplete) {
                    progressCallbacks.add(callback);
                }
            }
        }
    }

    @Override
    public void onCompletion(final Consumer<TResult> callback) {
        Preconditions.checkNotNull(callback);
        synchronized (LOCK) {
            if (isComplete) {
                callback.accept(result);
            } else {
                completionCallbacks.add(callback);
            }
        }
    }

    public void complete(final TResult result) {
        Preconditions.checkNotNull(result);
        Preconditions.checkState(!isComplete);
        synchronized (LOCK) {
            Preconditions.checkState(!isComplete);
            this.isComplete = true;
            this.result = result;
            for (final Consumer<TResult> callback : completionCallbacks) {
                callback.accept(result);
            }
        }
        completionCallbacks.clear();
        progressCallbacks.clear();
    }

    public void progress(final TState state) {
        Preconditions.checkNotNull(state);
        Preconditions.checkState(!isComplete);
        synchronized (LOCK) {
            Preconditions.checkState(!isComplete);
            for (final Consumer<TState> callback : progressCallbacks) {
                callback.accept(state);
            }
        }
    }

    public static <TState, TResult> SettableProcess<TState, TResult> of() {
        return new SettableProcess<>();
    }
}

This could be extended to support cancellation and so on.