Consolidate virtual thread factory creation into VertxThread

Replace three duplicate reflection blocks with a single
VertxThread.virtualThreadFactory(prefix) method. Remove phantom
platform thread hacks for naming in VirtualThreadNioTransport
and VertxTestBase. Update reflect-config.json to point at VertxThread.

Author: franz1981

vertx-core/src/main/java/io/vertx/core/impl/VertxImpl.java

@@ -75,7 +75,6 @@
 import java.io.InputStream;
 import java.lang.ref.Cleaner;
 import java.lang.ref.WeakReference;
-import java.lang.reflect.Method;
 import java.net.InetSocketAddress;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
@@ -113,20 +112,8 @@ public class VertxImpl implements VertxInternal, MetricsProvider {
   private static final String NETTY_IO_RATIO_PROPERTY_NAME = "vertx.nettyIORatio";
   private static final int NETTY_IO_RATIO = Integer.getInteger(NETTY_IO_RATIO_PROPERTY_NAME, 50);
 
-  // Not cached for graalvm
   private static ThreadFactory virtualThreadFactory() {
-    try {
-      Class<?> builderClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder");
-      Class<?> ofVirtualClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder$OfVirtual");
-      Method ofVirtualMethod = Thread.class.getDeclaredMethod("ofVirtual");
-      Object builder = ofVirtualMethod.invoke(null);
-      Method nameMethod = ofVirtualClass.getDeclaredMethod("name", String.class, long.class);
-      Method factoryMethod = builderClass.getDeclaredMethod("factory");
-      builder = nameMethod.invoke(builder, "vert.x-virtual-thread-", 0L);
-      return (ThreadFactory) factoryMethod.invoke(builder);
-    } catch (Exception e) {
-      return null;
-    }
+    return VertxThread.virtualThreadFactory("vert.x-virtual-thread-");
   }
 
   static {

vertx-core/src/main/java/io/vertx/core/impl/VertxThread.java

@@ -15,7 +15,9 @@
 import io.vertx.core.internal.threadchecker.ThreadInfo;
 import io.vertx.core.internal.ContextInternal;
 
+import java.lang.reflect.Method;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -29,6 +31,27 @@ public class VertxThread extends FastThreadLocalThread {
   // One day ScopedValues will be a better choice.
   private static final ConcurrentHashMap<Thread, VtInfo> VIRTUAL_THREADS = new ConcurrentHashMap<>();
 
+  /**
+   * Create a {@link ThreadFactory} that produces virtual threads with the given name prefix
+   * and a monotonically increasing counter. Returns {@code null} if virtual threads are not available.
+   * <p>
+   * Not cached for GraalVM native-image compatibility.
+   */
+  public static ThreadFactory virtualThreadFactory(String prefix) {
+    try {
+      Class<?> builderClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder");
+      Class<?> ofVirtualClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder$OfVirtual");
+      Method ofVirtualMethod = Thread.class.getDeclaredMethod("ofVirtual");
+      Object builder = ofVirtualMethod.invoke(null);
+      Method nameMethod = ofVirtualClass.getDeclaredMethod("name", String.class, long.class);
+      Method factoryMethod = builderClass.getDeclaredMethod("factory");
+      builder = nameMethod.invoke(builder, prefix, 0L);
+      return (ThreadFactory) factoryMethod.invoke(builder);
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
   static final class VtInfo {
     final boolean worker;
     final VertxImpl owner;

vertx-core/src/main/java/io/vertx/core/impl/transports/VirtualThreadNioTransport.java

@@ -14,11 +14,9 @@
 import io.netty.channel.nio.NioIoHandler;
 import io.netty.channel.socket.DatagramChannel;
 import io.netty.channel.socket.InternetProtocolFamily;
-import io.vertx.core.impl.VertxImpl;
 import io.vertx.core.impl.VertxThread;
 import io.vertx.core.spi.transport.Transport;
 
-import java.lang.reflect.Method;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
@@ -33,24 +31,9 @@ public class VirtualThreadNioTransport implements Transport {
   private static final long RUNNING_YIELD_NS = TimeUnit.MICROSECONDS
     .toNanos(Integer.getInteger("io.vertx.virtualthread.running.yield.us", 1));
 
-  private static final ThreadFactory VIRTUAL_THREAD_FACTORY;
-  private static final Throwable UNAVAILABILITY_CAUSE;
-
-  static {
-    ThreadFactory factory = null;
-    Throwable cause = null;
-    try {
-      Class<?> builderClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder");
-      Method ofVirtualMethod = Thread.class.getDeclaredMethod("ofVirtual");
-      Object builder = ofVirtualMethod.invoke(null);
-      Method factoryMethod = builderClass.getDeclaredMethod("factory");
-      factory = (ThreadFactory) factoryMethod.invoke(builder);
-    } catch (Exception e) {
-      cause = e;
-    }
-    VIRTUAL_THREAD_FACTORY = factory;
-    UNAVAILABILITY_CAUSE = cause;
-  }
+  private static final ThreadFactory VIRTUAL_THREAD_FACTORY = VertxThread.virtualThreadFactory("vert.x-eventloop-vt-");
+  private static final Throwable UNAVAILABILITY_CAUSE = VIRTUAL_THREAD_FACTORY == null
+    ? new UnsupportedOperationException("Virtual threads are not available") : null;
 
   public static final Transport INSTANCE = new VirtualThreadNioTransport();
 
@@ -109,17 +92,12 @@ public ChannelFactory<? extends ServerChannel> serverChannelFactory(boolean doma
   @Override
   public EventLoopGroup eventLoopGroup(int type, int nThreads, ThreadFactory threadFactory, int ioRatio) {
     if (VIRTUAL_THREAD_FACTORY == null) {
-      throw new IllegalStateException("Virtual threads are not available", UNAVAILABILITY_CAUSE);
+      throw new IllegalStateException("Virtual threads are not available");
     }
     return new MultiThreadIoEventLoopGroup(nThreads, (Executor) null, ioHandlerFactory()) {
       @Override
       protected IoEventLoop newChild(Executor executor, IoHandlerFactory ioHandlerFactory, Object... args) {
         ManualIoEventLoop eventLoop = new ManualIoEventLoop(this, null, ioHandlerFactory);
-        // Create a platform thread via the Vert.x thread factory to obtain the correct name
-        // and register it with the blocked thread checker. Then name the virtual thread the same.
-        Thread platformThread = threadFactory.newThread(() -> {});
-        VertxImpl owner = (platformThread instanceof VertxThread)
-          ? ((VertxThread) platformThread).owner() : null;
         Runnable pumpTask = () -> {
           while (!eventLoop.isShuttingDown()) {
             eventLoop.run(0, RUNNING_YIELD_NS);
@@ -132,8 +110,7 @@ protected IoEventLoop newChild(Executor executor, IoHandlerFactory ioHandlerFact
             Thread.yield();
           }
         };
-        Thread vt = VIRTUAL_THREAD_FACTORY.newThread(VertxThread.apply(pumpTask, false, owner));
-        vt.setName(platformThread.getName());
+        Thread vt = VIRTUAL_THREAD_FACTORY.newThread(VertxThread.apply(pumpTask, false, null));
         eventLoop.setOwningThread(vt);
         vt.start();
         return eventLoop;

vertx-core/src/main/resources/META-INF/native-image/io.vertx/vertx-core/reflect-config.json

@@ -2,7 +2,7 @@
   {
     "name": "java.lang.Thread$Builder",
     "condition": {
-      "typeReachable": "io.vertx.core.impl.VertxImpl"
+      "typeReachable": "io.vertx.core.impl.VertxThread"
     },
     "methods": [
       {
@@ -14,7 +14,7 @@
   {
     "name": "java.lang.Thread$Builder$OfVirtual",
     "condition": {
-      "typeReachable": "io.vertx.core.impl.VertxImpl"
+      "typeReachable": "io.vertx.core.impl.VertxThread"
     },
     "methods": [
       {
@@ -26,7 +26,7 @@
   {
     "name": "java.lang.Thread",
     "condition": {
-      "typeReachable": "io.vertx.core.impl.VertxImpl"
+      "typeReachable": "io.vertx.core.impl.VertxThread"
     },
     "methods": [
       {

vertx-core/src/test/java/io/vertx/test/core/VertxTestBase.java

@@ -13,6 +13,7 @@
 
 import io.vertx.core.*;
 import io.vertx.core.impl.ThreadPerTaskExecutorService;
+import io.vertx.core.impl.VertxThread;
 import io.vertx.core.internal.VertxInternal;
 import io.vertx.core.internal.logging.Logger;
 import io.vertx.core.internal.logging.LoggerFactory;
@@ -229,37 +230,12 @@ protected Vertx createVertx(VertxOptions options) {
     return vertx;
   }
 
-  private static final java.util.concurrent.ThreadFactory VIRTUAL_THREAD_FACTORY;
-
-  static {
-    java.util.concurrent.ThreadFactory f = null;
-    if (USE_VIRTUAL_THREAD_WORKER) {
-      try {
-        Class<?> builderClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Thread$Builder");
-        java.lang.reflect.Method ofVirtualMethod = Thread.class.getDeclaredMethod("ofVirtual");
-        Object builder = ofVirtualMethod.invoke(null);
-        java.lang.reflect.Method factoryMethod = builderClass.getDeclaredMethod("factory");
-        f = (java.util.concurrent.ThreadFactory) factoryMethod.invoke(builder);
-      } catch (Exception e) {
-        throw new ExceptionInInitializerError(e);
-      }
-    }
-    VIRTUAL_THREAD_FACTORY = f;
-  }
-
   private io.vertx.core.spi.ExecutorServiceFactory createVirtualThreadExecutorServiceFactory() {
-    // Replace worker pool with virtual-thread-per-task executor.
-    // The provided threadFactory is used to obtain thread names for the virtual threads.
-    return (threadFactory, concurrency, maxConcurrency) -> {
-      java.util.concurrent.ThreadFactory namingVtFactory = runnable -> {
-        Thread platformThread = threadFactory.newThread(() -> {});
-        String name = platformThread.getName();
-        Thread vt = VIRTUAL_THREAD_FACTORY.newThread(runnable);
-        vt.setName(name);
-        return vt;
-      };
-      return new ThreadPerTaskExecutorService(namingVtFactory);
-    };
+    java.util.concurrent.ThreadFactory vtFactory = VertxThread.virtualThreadFactory("vert.x-worker-vt-");
+    if (vtFactory == null) {
+      throw new IllegalStateException("Virtual threads are not available");
+    }
+    return (threadFactory, concurrency, maxConcurrency) -> new ThreadPerTaskExecutorService(vtFactory);
   }
 
   /**