Virtual threads to isolate ThreadLocals in hooks.

There's something kind of funny about going to great lengths to use our
Reactive Breadth First Search algorithm to achieve the hook ordering we
want without using a background thread, and then right at the last
moment, spawning a thread to run each hook anyway.

I'm leaving it this way for the time being because it has certain
desirable properties:

- The hook queue maintains the desired order. In contrast, if we simply
  submitted the hooks to an executor, all bets are off.
- Only one hook runs at a time. There's a happens-before relationship
  between all the hooks.

In effect, since we're running completely synchronously with the virtual
thread, using it as a kind of structured concurrency sans parallelism,
we're actually just using the virtual thread mechansim as a utility to
isolate ThreadLocals and nothing else.

Anyway, this is a step closer to the semantics we want, and we can
refine the implementation later if we can devise a simpler way to
achieve all the desired properties.

Author: prdoyle

bosk-core/src/main/java/works/bosk/Bosk.java

@@ -11,6 +11,9 @@
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
@@ -89,6 +92,7 @@ public class Bosk<R extends StateTreeNode> implements BoskInfo<R> {
 	private final RootRef rootRef;
 	private final ThreadLocal<R> rootSnapshot = new ThreadLocal<>();
 	private final Queue<HookRegistration<?>> hooks = new ConcurrentLinkedQueue<>();
+	private final ExecutorService hookExecutor = Executors.newVirtualThreadPerTaskExecutor();
 	private final PathCompiler pathCompiler;
 
 	// Mutable state
@@ -542,8 +546,23 @@ private void drainQueueIfAllowed() {
 				if (hookExecutionPermit.tryAcquire()) {
 					try {
 						for (Runnable ex = hookExecutionQueue.pollFirst(); ex != null; ex = hookExecutionQueue.pollFirst()) {
-							ex.run();
+							// Run the task in a separate virtual thread to prevent ThreadLocals from propagating.
+							// This is slightly tragic, because usually ThreadLocal propagation works just the
+							// way we'd want, but not always. Given the choices "always, sometimes, never", if
+							// we can't achieve "always", then the bosk philosophy prefers "never" over "sometimes".
+							hookExecutor.submit(ex).get();
 						}
+					} catch (ExecutionException e) {
+						if (e.getCause() instanceof RuntimeException r) {
+							throw r;
+						} else if (e.getCause() instanceof Error error) {
+							throw error;
+						} else {
+							throw new AssertionError("Hook runnable should catch and wrap checked exceptions", e);
+						}
+					} catch (InterruptedException e) {
+						LOGGER.warn("Interrupted while running hooks", e);
+						return;
 					} finally {
 						hookExecutionPermit.release();
 					}

bosk-core/src/test/java/works/bosk/HooksTest.java

@@ -4,6 +4,8 @@
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -78,6 +80,22 @@ void basic_hooksRunWhenRegistered() {
 			"Hook should fire when it's registered");
 	}
 
+	@Test
+	void basic_hooksDoNotPropagateThreadLocals() throws InterruptedException {
+		ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "initial");
+		threadLocal.set("updated");
+		BlockingQueue<String> queue = new LinkedBlockingQueue<>();
+		bosk.registerHook("foo", bosk.rootReference(), ref -> {
+			try {
+				queue.put(threadLocal.get());
+			} catch (InterruptedException e) {
+				throw new AssertionError("Huh?", e);
+			}
+		});
+		String observed = queue.take();
+		assertEquals("initial", observed, "Thread locals should not propagate into hooks");
+	}
+
 	@ParameterizedTest
 	@EnumSource(Variant.class)
 	void basic_noIrrelevantHooks(Variant variant) {