Allow virtual thread factory to work with ForkJoinPool

ForkJoinWorkerThread extends Thread (platform) and cannot be virtual.
Fall back to a platform ManagedForkJoinWorkerThread instead of throwing
UnsupportedOperationException. The TCK expects ForkJoinPool to function
with virtual factories — the worker threads are platform but the pool
still operates correctly.
m>

Author: rzo1

container/openejb-core/src/main/java/org/apache/openejb/threads/impl/ManagedThreadFactoryImpl.java

@@ -75,9 +75,8 @@ public Thread newThread(final Runnable r) {
 
     @Override
     public ForkJoinWorkerThread newThread(final ForkJoinPool pool) {
-        if (virtual) {
-            throw new UnsupportedOperationException("Virtual thread factory does not support ForkJoinPool threads");
-        }
+        // ForkJoinWorkerThread extends Thread (platform) — cannot be virtual.
+        // For virtual factories, fall back to a platform ForkJoinWorkerThread.
         return new ManagedForkJoinWorkerThread(pool, priority, contextService);
     }
 

container/openejb-core/src/test/java/org/apache/openejb/threads/impl/ManagedThreadFactoryVirtualTest.java

@@ -29,6 +29,7 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.TimeUnit;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -91,14 +92,23 @@ public void virtualThreadExecutesTask() {
         }
     }
 
-    @Test(expected = UnsupportedOperationException.class)
-    public void virtualFactoryRejectsForkJoinPool() {
+    @Test
+    public void virtualFactoryFallsBackToPlatformForForkJoinPool() {
         Assume.assumeTrue("Virtual threads require Java 21+", VirtualThreadHelper.isSupported());
 
         final ContextServiceImpl contextService = ContextServiceImplFactory.newDefaultContextService();
         final ManagedThreadFactoryImpl factory = new ManagedThreadFactoryImpl("test-vt-", null, contextService, true);
 
-        factory.newThread(new ForkJoinPool());
+        // ForkJoinWorkerThread cannot be virtual — should fall back to platform thread
+        final ForkJoinPool pool = new ForkJoinPool(1, factory, null, false);
+        try {
+            final java.util.concurrent.Future<String> result = pool.submit(() -> "ok");
+            assertEquals("ForkJoinPool should work with virtual factory", "ok", result.get(5, java.util.concurrent.TimeUnit.SECONDS));
+        } catch (final Exception e) {
+            fail("ForkJoinPool with virtual factory should not throw: " + e);
+        } finally {
+            pool.shutdown();
+        }
     }
 
     @Test