ThreadService: introduce the getParent(Thread) method

Due to the use of a thread pool, it is impossible to determine which
thread called the current one.

Sometimes we need that, though, e.g. when ImageJ 1.x wants to determine
the (thread-local) macro options and runs in a thread that was spawned
through the thread service.

So let's add API to determine the parent thread, so that the ImageJ 1.x
patcher can be extended to support macro options even when the
ThreadService is involved.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>

Author: dscho

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

@@ -33,6 +33,7 @@
 
 import java.awt.EventQueue;
 import java.lang.reflect.InvocationTargetException;
+import java.util.WeakHashMap;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -63,18 +64,20 @@ public final class DefaultThreadService extends AbstractService implements
 
 	private boolean disposed;
 
+	private WeakHashMap<Thread, Thread> parents = new WeakHashMap<Thread, Thread>();
+
 	// -- ThreadService methods --
 
 	@Override
 	public <V> Future<V> run(final Callable<V> code) {
 		if (disposed) return null;
-		return executor().submit(code);
+		return executor().submit(wrap(code));
 	}
 
 	@Override
 	public Future<?> run(final Runnable code) {
 		if (disposed) return null;
-		return executor().submit(code);
+		return executor().submit(wrap(code));
 	}
 
 	@Override
@@ -92,13 +95,18 @@ public void invoke(final Runnable code) throws InterruptedException,
 		}
 		else {
 			// invoke on the EDT
-			EventQueue.invokeAndWait(code);
+			EventQueue.invokeAndWait(wrap(code));
 		}
 	}
 
 	@Override
 	public void queue(final Runnable code) {
-		EventQueue.invokeLater(code);
+		EventQueue.invokeLater(wrap(code));
+	}
+
+	@Override
+	public Thread getParent(final Thread thread) {
+		return parents.get(thread != null ? thread : Thread.currentThread());
 	}
 
 	// -- Disposable methods --
@@ -128,4 +136,37 @@ private ExecutorService executor() {
 		return executor;
 	}
 
+	private Runnable wrap(final Runnable r) {
+		final Thread parent = Thread.currentThread();
+		return new Runnable() {
+			@Override
+			public void run() {
+				final Thread thread = Thread.currentThread();
+				try {
+					if (parent != thread) parents.put(thread, parent);
+					r.run();
+				}
+				finally {
+					if (parent != thread) parents.remove(thread);
+				}
+			}
+		};
+	}
+
+	private <V> Callable<V> wrap(final Callable<V> c) {
+		final Thread parent = Thread.currentThread();
+		return new Callable<V>() {
+			@Override
+			public V call() throws Exception {
+				final Thread thread = Thread.currentThread();
+				try {
+					if (parent != thread) parents.put(thread, parent);
+					return c.call();
+				}
+				finally {
+					if (parent != thread) parents.remove(thread);
+				}
+			}
+		};
+	}
 }

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

@@ -113,4 +113,14 @@ void invoke(final Runnable code) throws InterruptedException,
 	 */
 	void queue(final Runnable code);
 
+	/**
+	 * Returns the thread that called the specified thread.
+	 * <p>
+	 * This works only on threads which the thread service knows about, of course.
+	 * </p>
+	 * 
+	 * @param thread the managed thread, null refers to the current thread
+	 * @return the thread that asked the {@link ThreadService} to spawn the specified thread
+	 */
+	Thread getParent(final Thread thread);
 }