Package org.apache.syncope.core.spring.task

Class VirtualThreadPoolTaskExecutor

java.lang.Object
org.springframework.util.CustomizableThreadCreator
org.springframework.scheduling.concurrent.CustomizableThreadFactory
org.springframework.scheduling.concurrent.ExecutorConfigurationSupport
org.apache.syncope.core.spring.task.VirtualThreadPoolTaskExecutor
All Implemented Interfaces:
Serializable, Executor, ThreadFactory, EventListener, Aware, BeanNameAware, DisposableBean, InitializingBean, ApplicationContextAware, ApplicationListener<ContextClosedEvent>, Lifecycle, Phased, SmartLifecycle, AsyncTaskExecutor, TaskExecutor, SchedulingTaskExecutor
public class VirtualThreadPoolTaskExecutor extends ExecutorConfigurationSupport implements AsyncTaskExecutor, SchedulingTaskExecutor
See Also:

  • Constructor Details

    • VirtualThreadPoolTaskExecutor

      public VirtualThreadPoolTaskExecutor()

  • Method Details

    • setPoolSize

      public void setPoolSize(int poolSize)
      Set the the maximum number of managed threads.
      Parameters:
      poolSize - the value to set (default is Integer.MAX_VALUE)

    • setTaskTerminationTimeout

      public void setTaskTerminationTimeout(long taskTerminationTimeout)
      Specify a timeout (in milliseconds) for task termination when closing this executor. The default is 0, not waiting for task termination at all.

      Note that a concrete >0 timeout specified here will lead to the wrapping of every submitted task into a task-tracking runnable which involves considerable overhead in case of a high number of tasks. However, for a modest level of submissions with longer-running tasks, this is feasible in order to arrive at a graceful shutdown.

      Parameters:
      taskTerminationTimeout - the timeout in milliseconds
      See Also:

    • setTaskDecorator

      public void setTaskDecorator(TaskDecorator taskDecorator)
      Specify a custom TaskDecorator to be applied to any Runnable about to be executed.

      Note that such a decorator is not necessarily being applied to the user-supplied Runnable/Callable but rather to the actual execution callback (which may be a wrapper around the user-supplied task).

      The primary use case is to set some execution context around the task's invocation, or to provide some monitoring/statistics for task execution.

      NOTE: Exception handling in TaskDecorator implementations is limited to plain Runnable execution via execute calls. In case of #submit calls, the exposed Runnable will be a FutureTask which does not propagate any exceptions; you might have to cast it and call Future#get to evaluate exceptions. See the ThreadPoolExecutor#afterExecute javadoc for an example of how to access exceptions in such a Future case.

      Parameters:
      taskDecorator - value to set

    • initializeExecutor

      protected ExecutorService initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler)
      Specified by:
      initializeExecutor in class ExecutorConfigurationSupport

    • execute

      public void execute(Runnable task)
      Specified by:
      execute in interface Executor
      Specified by:
      execute in interface TaskExecutor

    • submit

      public Future<?> submit(Runnable task)
      Specified by:
      submit in interface AsyncTaskExecutor

    • submit

      public <T> Future<T> submit(Callable<T> task)
      Specified by:
      submit in interface AsyncTaskExecutor

    • shutdown

      public void shutdown()
      Overrides:
      shutdown in class ExecutorConfigurationSupport