feat: Make an Executor available through VaadinService (#21424)

* feat: Make an Executor available through VaadinService

Provides access to an Executor instance from VaadinService to submit
asynchronous tasks. The default single-threaded executor can be
replaced by a custom instance by registering it with a VaadinServiceInitListener.
The spring add-on tries to detect an existing TaskExecutor bean,
otherwise it falls back to the default executor.
To provide a specific TaskExecutor bean, different from the application
default, the bean definition can be named VaadinTaskExecutor or be annotated with
`@VaadinTaskExecutor`.

Closes #21366

* fix test

* better default executor

* fix test

* format

* apply review suggestions

---------

Co-authored-by: Mikhail Shabarov <61410877+mshabarov@users.noreply.github.com>

Author: mcollovati

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

@@ -15,14 +15,16 @@
  */
 package com.vaadin.flow.server;
 
-import com.vaadin.flow.server.communication.IndexHtmlRequestListener;
-
 import java.util.ArrayList;
 import java.util.EventObject;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.Executor;
 import java.util.stream.Stream;
 
+import com.vaadin.flow.server.communication.IndexHtmlRequestListener;
+
 /**
  * Event fired to {@link VaadinServiceInitListener} when a {@link VaadinService}
  * is being initialized.
@@ -39,6 +41,7 @@ public class ServiceInitEvent extends EventObject {
     private List<IndexHtmlRequestListener> addedIndexHtmlRequestListeners = new ArrayList<>();
     private List<DependencyFilter> addedDependencyFilters = new ArrayList<>();
     private List<VaadinRequestInterceptor> addedVaadinRequestInterceptors = new ArrayList<>();
+    private Executor executor;
 
     /**
      * Creates a new service init event for a given {@link VaadinService} and
@@ -107,6 +110,27 @@ public void addVaadinRequestInterceptor(
         addedVaadinRequestInterceptors.add(vaadinRequestInterceptor);
     }
 
+    /**
+     * Sets the {@link Executor} to be used by Vaadin for running asynchronous
+     * tasks.
+     * <p>
+     * The application can also benefit from this executor to submit its own
+     * asynchronous tasks.
+     * <p>
+     * The developer is responsible for managing the executor's lifecycle, for
+     * example, by registering a {@link VaadinService} destroy listener to shut
+     * it down.
+     * <p>
+     * A {@literal null} value can be given to switch back to the Vaadin default
+     * executor.
+     *
+     * @param executor
+     *            the executor to set.
+     */
+    public void setExecutor(Executor executor) {
+        this.executor = executor;
+    }
+
     /**
      * Gets a stream of all custom request handlers that have been added for the
      * service.
@@ -147,6 +171,17 @@ public Stream<VaadinRequestInterceptor> getAddedVaadinRequestInterceptor() {
         return addedVaadinRequestInterceptors.stream();
     }
 
+    /**
+     * Gets the optional {@link Executor} that is currently set to be used by
+     * Vaadin for running asynchronous tasks.
+     *
+     * @return an {@link Optional} containing the {@link Executor}, or an empty
+     *         {@link Optional} if no executor is set.
+     */
+    public Optional<Executor> getExecutor() {
+        return Optional.ofNullable(executor);
+    }
+
     @Override
     public VaadinService getSource() {
         return (VaadinService) super.getSource();

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

@@ -41,8 +41,14 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
 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;
@@ -184,6 +190,10 @@ public abstract class VaadinService implements Serializable {
 
     private Instantiator instantiator;
 
+    private Executor executor;
+
+    private boolean defaultExecutorInUse;
+
     private VaadinContext vaadinContext;
 
     private Iterable<VaadinRequestInterceptor> vaadinRequestInterceptors;
@@ -267,6 +277,9 @@ public void init() throws ServiceException {
             instantiator.getServiceInitListeners()
                     .forEach(listener -> listener.serviceInit(event));
 
+            this.executor = event.getExecutor()
+                    .orElseGet(this::createDefaultExecutor);
+
             event.getAddedRequestHandlers().forEach(handlers::add);
 
             Collections.reverse(handlers);
@@ -293,6 +306,18 @@ public void init() throws ServiceException {
                     .collect(Collectors.toList());
         });
 
+        if (this.executor == null) {
+            throw new ServiceException(
+                    "Unable to create the default Executor for "
+                            + getClass().getName()
+                            + ". This is most likely a bug in a custom VaadinService implementation "
+                            + "that overrides the createDefaultExecutor() method "
+                            + "but returns a null Executor instance. "
+                            + "As a workaround, you can register a "
+                            + VaadinServiceInitListener.class.getSimpleName()
+                            + " providing a custom Executor instance.");
+        }
+
         DeploymentConfiguration configuration = getDeploymentConfiguration();
         if (!configuration.isProductionMode()) {
             Logger logger = getLogger();
@@ -503,6 +528,98 @@ public Instantiator getInstantiator() {
         return instantiator;
     }
 
+    /**
+     * 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.
+     * <p>
+     * A custom {@link VaadinService} implementation can override this method to
+     * provide its own ad-hoc executor tailored to specific environments like
+     * CDI or Spring.
+     * <p>
+     * Implementors should never return {@literal null}; if an executor instance
+     * cannot be provided, the method should call
+     * {@code super.createDefaultExecutor()}.
+     * <p>
+     * The application can provide a more appropriate executor implementation
+     * through a {@link VaadinServiceInitListener} and calling
+     * {@link ServiceInitEvent#setExecutor(Executor)}.
+     *
+     * @return a default executor instance to use, never {@literal null}.
+     * @see VaadinServiceInitListener
+     * @see ServiceInitEvent#setExecutor(Executor)
+     */
+    protected Executor createDefaultExecutor() {
+        this.defaultExecutorInUse = true;
+        int corePoolSize = 8;
+        int keepAliveTimeSec = 60;
+
+        class VaadinThreadFactory implements ThreadFactory {
+            private final AtomicInteger threadNumber = new AtomicInteger(0);
+
+            @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;
+    }
+
+    /**
+     * Gets the executor instance used by Vaadin for managing concurrent tasks.
+     * <p>
+     * By default, a thread pool executor with a custom with core pool size of
+     * 8, an unbounded maximum pool size, and a keep-alive time of 60 seconds
+     * for idle threads is provided. The thread pool grows dynamically as
+     * required, and idle core threads are allowed to time out.
+     * <p>
+     * {@link VaadinService} implementations for specific environments like CDI
+     * or Spring might provide their own ad-hoc Executors tailored to those
+     * environments.
+     * <p>
+     * A custom executor can be configured by registering a
+     * {@link VaadinServiceInitListener} and providing the executor instance to
+     * the {@link ServiceInitEvent}.
+     * <p>
+     * A Vaadin application can also benefit from this executor to submit
+     * asynchronous tasks.
+     *
+     * @return the Executor instance, never {@literal null}.
+     * @see VaadinServiceInitListener
+     * @see ServiceInitEvent#setExecutor(Executor)
+     */
+    public Executor getExecutor() {
+        return executor;
+    }
+
     /**
      * Gets the class loader to use for loading classes loaded by name, e.g.
      * custom UI classes. This is by default the class loader that was used to
@@ -2216,6 +2333,10 @@ public Registration addServiceDestroyListener(
      */
     public void destroy() {
         ServiceDestroyEvent event = new ServiceDestroyEvent(this);
+        if (defaultExecutorInUse && executor instanceof ExecutorService cast) {
+            cast.shutdownNow();
+            this.executor = null;
+        }
         RuntimeException exception = null;
         for (ServiceDestroyListener listener : serviceDestroyListeners) {
             try {

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

@@ -15,11 +15,11 @@
  */
 package com.vaadin.flow.server;
 
-import jakarta.servlet.ServletException;
-
 import java.util.Collections;
 import java.util.List;
 
+import jakarta.servlet.ServletException;
+
 import com.vaadin.flow.di.Instantiator;
 import com.vaadin.flow.function.DeploymentConfiguration;
 import com.vaadin.flow.router.Router;
@@ -67,11 +67,22 @@ public MockVaadinServletService() {
         this(new MockDeploymentConfiguration());
     }
 
+    public MockVaadinServletService(boolean init) {
+        this(new MockDeploymentConfiguration(), init);
+    }
+
     public MockVaadinServletService(
             DeploymentConfiguration deploymentConfiguration) {
+        this(deploymentConfiguration, true);
+    }
+
+    public MockVaadinServletService(
+            DeploymentConfiguration deploymentConfiguration, boolean init) {
         super(new MockVaadinServlet(deploymentConfiguration),
                 deploymentConfiguration);
-        init();
+        if (init) {
+            init();
+        }
     }
 
     public void setRouter(Router router) {