Use MethodHandle.invokeExact for VT factory, conditionally wrap worker executor

Replace reflection with MethodHandle.invokeExact (adapted via asType for
JDK 11 source compatibility). Only wrap worker executors with
WrappedWorkerExecutorService when a custom ExecutorServiceFactory is
provided, avoiding per-task lambda+VtInfo allocation overhead in the
default VertxThread case.

Author: franz1981

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

@@ -189,12 +189,12 @@ private static ThreadFactory virtualThreadFactory() {
     long maxWorkerExecuteTime = options.getMaxWorkerExecuteTime();
 
     ThreadFactory workerThreadFactory = createThreadFactory(threadFactory, checker, useDaemonThread, maxWorkerExecuteTime, maxWorkerExecuteTimeUnit, "vert.x-worker-thread-", true);
-    ExecutorService workerExec = new WrappedWorkerExecutorService(
-      executorServiceFactory.createExecutor(workerThreadFactory, workerPoolSize, workerPoolSize), true, this);
+    ExecutorService workerExec = wrapWorkerExecutor(
+      executorServiceFactory.createExecutor(workerThreadFactory, workerPoolSize, workerPoolSize), executorServiceFactory);
     PoolMetrics workerPoolMetrics = metrics != null ? metrics.createPoolMetrics("worker", "vert.x-worker-thread", options.getWorkerPoolSize()) : null;
     ThreadFactory internalWorkerThreadFactory = createThreadFactory(threadFactory, checker, useDaemonThread, maxWorkerExecuteTime, maxWorkerExecuteTimeUnit, "vert.x-internal-blocking-", true);
-    ExecutorService internalWorkerExec = new WrappedWorkerExecutorService(
-      executorServiceFactory.createExecutor(internalWorkerThreadFactory, internalBlockingPoolSize, internalBlockingPoolSize), true, this);
+    ExecutorService internalWorkerExec = wrapWorkerExecutor(
+      executorServiceFactory.createExecutor(internalWorkerThreadFactory, internalBlockingPoolSize, internalBlockingPoolSize), executorServiceFactory);
     PoolMetrics internalBlockingPoolMetrics = metrics != null ? metrics.createPoolMetrics("worker", "vert.x-internal-blocking", internalBlockingPoolSize) : null;
 
     ThreadFactory virtualThreadFactory = virtualThreadFactory();
@@ -1118,8 +1118,8 @@ private synchronized WorkerPool createSharedWorkerPool(CloseFuture closeFuture,
     }
     WorkerPool shared = createSharedResource("__vertx.shared.workerPools", name, closeFuture, cf -> {
       ThreadFactory workerThreadFactory = createThreadFactory(threadFactory, checker, useDaemonThread, maxExecuteTime, maxExecuteTimeUnit, name + "-", true);
-      ExecutorService workerExec = new WrappedWorkerExecutorService(
-        executorServiceFactory.createExecutor(workerThreadFactory, poolSize, poolSize), true, VertxImpl.this);
+      ExecutorService workerExec = wrapWorkerExecutor(
+        executorServiceFactory.createExecutor(workerThreadFactory, poolSize, poolSize), executorServiceFactory);
       PoolMetrics workerMetrics = metrics != null ? metrics.createPoolMetrics("worker", name, poolSize) : null;
       WorkerPool pool = new WorkerPool(workerExec, workerMetrics);
       cf.add(completion -> {
@@ -1155,6 +1155,20 @@ private ThreadFactory createThreadFactory(VertxThreadFactory threadFactory, Bloc
     };
   }
 
+  /**
+   * Wrap the executor with {@link WrappedWorkerExecutorService} only when a custom
+   * {@link ExecutorServiceFactory} is used, since its threads may not be {@link VertxThread}
+   * instances (e.g. virtual threads) and need CHM-based identity registration for
+   * {@link VertxThread#isVertxThread()}, {@link VertxThread#isCurrentWorker()} etc. to work.
+   * Skipped for the default factory whose threads are already {@link VertxThread}.
+   */
+  private ExecutorService wrapWorkerExecutor(ExecutorService exec, ExecutorServiceFactory factory) {
+    if (factory != ExecutorServiceFactory.INSTANCE) {
+      return new WrappedWorkerExecutorService(exec, true, this);
+    }
+    return exec;
+  }
+
   @Override
   public Vertx exceptionHandler(Handler<Throwable> handler) {
     exceptionHandler = handler;

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.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
@@ -39,15 +41,21 @@ public class VertxThread extends FastThreadLocalThread {
    */
   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) {
+      MethodHandles.Lookup lookup = MethodHandles.publicLookup();
+      Class<?> builderClass = Class.forName("java.lang.Thread$Builder");
+      Class<?> ofVirtualClass = Class.forName("java.lang.Thread$Builder$OfVirtual");
+      MethodHandle ofVirtual = lookup.findStatic(Thread.class, "ofVirtual",
+        MethodType.methodType(ofVirtualClass)).asType(MethodType.methodType(Object.class));
+      MethodHandle name = lookup.findVirtual(ofVirtualClass, "name",
+        MethodType.methodType(ofVirtualClass, String.class, long.class))
+        .asType(MethodType.methodType(Object.class, Object.class, String.class, long.class));
+      MethodHandle factory = lookup.findVirtual(builderClass, "factory",
+        MethodType.methodType(ThreadFactory.class))
+        .asType(MethodType.methodType(ThreadFactory.class, Object.class));
+      Object builder = (Object) ofVirtual.invokeExact();
+      builder = (Object) name.invokeExact(builder, prefix, 0L);
+      return (ThreadFactory) factory.invokeExact(builder);
+    } catch (Throwable e) {
       return null;
     }
   }