Merge branch 'thread-queues'

This branch improves the thread service.

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());
@@ -141,9 +156,17 @@ public ThreadContext getThreadContext(final Thread thread) {
 	// -- Disposable methods --
 
 	@Override
-	public void dispose() {
+	public synchronized void dispose() {
 		disposed = true;
-		if (executor != null) executor.shutdown();
+		if (executor != null) {
+			executor.shutdown();
+			executor = null;
+		}
+		if (queues != null) {
+			for (final ExecutorService queue : queues.values()) {
+				queue.shutdown();
+			}
+		}
 	}
 
 	// -- ThreadFactory methods --
@@ -157,12 +180,25 @@ public Thread newThread(final Runnable r) {
 	// -- Helper methods --
 
 	private ExecutorService executor() {
-		if (executor == null) {
-			executor = Executors.newCachedThreadPool(this);
-		}
+		if (executor == null) initExecutor();
 		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);
+	}
+
 	private Runnable wrap(final Runnable r) {
 		final Thread parent = Thread.currentThread();
 		return new Runnable() {

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

@@ -112,7 +112,7 @@ public enum ThreadContext {
 
 	/**
 	 * Gets whether the current thread is a dispatch thread for use with
-	 * {@link #invoke} and {@link #queue}.
+	 * {@link #invoke(Runnable)} and {@link #queue(Runnable)}.
 	 * <p>
 	 * In the case of AWT-based applications (e.g., Java on the desktop), this is
 	 * typically the AWT Event Dispatch Thread (EDT). However, ultimately the
@@ -141,7 +141,8 @@ void invoke(Runnable code) throws InterruptedException,
 		InvocationTargetException;
 
 	/**
-	 * Queues the given code for later execution in a special dispatch thread.
+	 * Queues the given code for later execution in a special dispatch thread,
+	 * returning immediately.
 	 * <p>
 	 * In the case of AWT-based applications (e.g., Java on the desktop), this is
 	 * typically the AWT Event Dispatch Thread (EDT). However, ultimately the
@@ -152,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>