feat!: Use virtual threads for the default service executor (#22782)

Fixes #22780

Author: Legioth

flow-server/src/main/java/com/vaadin/flow/server/VaadinService.java

@@ -22,6 +22,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.Serializable;
+import java.lang.Thread.Builder.OfVirtual;
 import java.lang.reflect.Constructor;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
@@ -42,12 +43,10 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
@@ -609,13 +608,8 @@ public Instantiator getInstantiator() {
     }
 
     /**
-     * Creates a default executor instance to use with this service.
-     * <p>
-     * This default implementation creates a thread pool executor with a custom
-     * thread factory to generate daemon threads. It uses a core pool size of 8,
-     * an unbounded maximum pool size, and a keep-alive time of 60 seconds for
-     * idle threads. The thread pool grows dynamically as required, and idle
-     * core threads are allowed to time out.
+     * Creates a default executor instance to use with this service. This
+     * default implementation creates a virtual tread executor.
      * <p>
      * A custom {@link VaadinService} implementation can override this method to
      * provide its own ad-hoc executor tailored to specific environments like
@@ -635,42 +629,17 @@ public Instantiator getInstantiator() {
      */
     protected Executor createDefaultExecutor() {
         this.defaultExecutorInUse = true;
-        int corePoolSize = 8;
-        int keepAliveTimeSec = 60;
-
-        class VaadinThreadFactory implements ThreadFactory {
-            private final AtomicInteger threadNumber = new AtomicInteger(0);
+        ThreadFactory namedVirtualThreadFactory = defaultExecutorFactory()
+                .factory();
+        return Executors.newThreadPerTaskExecutor(namedVirtualThreadFactory);
+    }
 
-            @Override
-            public Thread newThread(Runnable runnable) {
-                int threadNumber = this.threadNumber.incrementAndGet();
-                if (threadNumber == 1) {
-                    getLogger().info(
-                            "The application is using Vaadin's default ThreadPoolExecutor "
-                                    + "(pool size = {}, keep alive time = {} seconds). "
-                                    + "A custom executor with an appropriate thread pool "
-                                    + "can be provided registering a {}.",
-                            corePoolSize, keepAliveTimeSec,
-                            VaadinServiceInitListener.class.getSimpleName());
-                }
-                Thread thread = new Thread(runnable,
-                        "VaadinTaskExecutor-thread-" + threadNumber);
-                // Thread marked as daemon to prevent task execution to block
-                // JVM shutdown
-                thread.setDaemon(true);
-                thread.setPriority(Thread.NORM_PRIORITY);
-                return thread;
-            }
-        }
-        // Defaults taken from Spring Boot configuration
-        // org.springframework.boot.autoconfigure.task.TaskExecutionProperties.Pool
-        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
-                corePoolSize, Integer.MAX_VALUE, keepAliveTimeSec,
-                TimeUnit.SECONDS, new LinkedBlockingQueue<>(),
-                new VaadinThreadFactory());
-        // Enables dynamic growing and shrinking of the pool.
-        threadPoolExecutor.allowCoreThreadTimeOut(true);
-        return threadPoolExecutor;
+    /*
+     * Package private to allow overriding with an uncaught exception handler in
+     * tests
+     */
+    OfVirtual defaultExecutorFactory() {
+        return Thread.ofVirtual().name("VaadinTaskExecutor-thread-", 1);
     }
 
     /**

flow-server/src/test/java/com/vaadin/flow/server/MockVaadinServletService.java

@@ -17,13 +17,10 @@
 
 import jakarta.servlet.ServletException;
 
+import java.lang.Thread.Builder.OfVirtual;
 import java.lang.reflect.Field;
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
 
 import org.mockito.Mockito;
 import org.slf4j.LoggerFactory;
@@ -181,23 +178,12 @@ private void resetSignalEnvironment() {
     }
 
     @Override
-    protected Executor createDefaultExecutor() {
-        Executor executor = super.createDefaultExecutor();
-        if (executor instanceof ThreadPoolExecutor threadPoolExecutor) {
-            threadPoolExecutor.setCorePoolSize(0);
-            threadPoolExecutor.setMaximumPoolSize(4);
-            threadPoolExecutor.setKeepAliveTime(10, TimeUnit.SECONDS);
-            ThreadFactory threadFactory = threadPoolExecutor.getThreadFactory();
-            threadPoolExecutor.setThreadFactory(r -> {
-                Thread thread = threadFactory.newThread(r);
-                thread.setUncaughtExceptionHandler((t, e) -> {
+    OfVirtual defaultExecutorFactory() {
+        return super.defaultExecutorFactory()
+                .uncaughtExceptionHandler((t, e) -> {
                     LoggerFactory.getLogger(getClass()).error(
                             "An uncaught exception occurred in thread {}",
                             t.getName(), e);
                 });
-                return thread;
-            });
-        }
-        return executor;
     }
 }