ThreadService: add ability to queue jobs flexibly

Previously, you could only queue a job to the special dispatch thread
(typically the EDT). But in some scenarios, the EDT is exactly the wrong
one to use. This commit adds the capability to queue jobs to any
arbitrarily named queue. Essentially, each ID corresponds to a different
single thread processing its jobs one at a time.

This commit is dedicated to Hadrien Mary.

Author: ctrueden

src/main/java/org/scijava/thread/DefaultThreadService.java

@@ -33,6 +33,8 @@
 
 import java.awt.EventQueue;
 import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.WeakHashMap;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
@@ -65,6 +67,9 @@ public final class DefaultThreadService extends AbstractService implements
 
 	private ExecutorService executor;
 
+	/** Mapping from ID to single-thread {@link ExecutorService} queue. */
+	private Map<String, ExecutorService> queues;
+
 	private int nextThread = 0;
 
 	private boolean disposed;
@@ -117,6 +122,16 @@ public void queue(final Runnable code) {
 		EventQueue.invokeLater(wrap(code));
 	}
 
+	@Override
+	public Future<?> queue(final String id, final Runnable code) {
+		return executor(id).submit(wrap(code));
+	}
+
+	@Override
+	public <V> Future<V> queue(final String id, final Callable<V> code) {
+		return executor(id).submit(wrap(code));
+	}
+
 	@Override
 	public Thread getParent(final Thread thread) {
 		return parents.get(thread != null ? thread : Thread.currentThread());
@@ -147,6 +162,11 @@ public synchronized void dispose() {
 			executor.shutdown();
 			executor = null;
 		}
+		if (queues != null) {
+			for (final ExecutorService queue : queues.values()) {
+				queue.shutdown();
+			}
+		}
 	}
 
 	// -- ThreadFactory methods --
@@ -164,6 +184,16 @@ private ExecutorService executor() {
 		return executor;
 	}
 
+	private synchronized ExecutorService executor(final String id) {
+		if (disposed) return null;
+		if (queues == null) queues = new HashMap<>();
+		if (!queues.containsKey(id)) {
+			final ExecutorService queue = Executors.newSingleThreadExecutor();
+			queues.put(id, queue);
+		}
+		return queues.get(id);
+	}
+
 	private synchronized void initExecutor() {
 		if (executor != null) return;
 		executor = Executors.newCachedThreadPool(this);

src/main/java/org/scijava/thread/ThreadService.java

@@ -153,6 +153,31 @@ void invoke(Runnable code) throws InterruptedException,
 	 */
 	void queue(Runnable code);
 
+	/**
+	 * Queues the given code for later execution in a dispatch thread associated
+	 * with the specified ID, returning immediately.
+	 *
+	 * @param id The ID designating which dispatch thread will execute the code.
+	 * @param code The code to execute.
+	 * @return A {@link Future} whose {@link Future#get()} method blocks until the
+	 *         queued code has completed executing and returns {@code null}.
+	 * @see ExecutorService#submit(Runnable)
+	 */
+	Future<?> queue(String id, Runnable code);
+
+	/**
+	 * Queues the given code for later execution in a dispatch thread associated
+	 * with the specified ID, returning immediately.
+	 *
+	 * @param id The ID designating which dispatch thread will execute the code.
+	 * @param code The code to execute.
+	 * @return A {@link Future} whose {@link Future#get()} method blocks until the
+	 *         queued code has completed executing and returns the result of the
+	 *         execution.
+	 * @see ExecutorService#submit(Callable)
+	 */
+	<V> Future<V> queue(String id, Callable<V> code);
+
 	/**
 	 * Returns the thread that called the specified thread.
 	 * <p>