org.glassfish.jersey.spi

## Class ScheduledThreadPoolExecutorProvider

- java.lang.Object
- - org.glassfish.jersey.spi.AbstractThreadPoolProvider<ScheduledThreadPoolExecutor>
  - - org.glassfish.jersey.spi.ScheduledThreadPoolExecutorProvider

All Implemented Interfaces:
  AutoCloseable, ExecutorServiceProvider, ScheduledExecutorServiceProvider

    public class ScheduledThreadPoolExecutorProvider
    extends AbstractThreadPoolProvider<ScheduledThreadPoolExecutor>
    implements ScheduledExecutorServiceProvider

Default implementation of the Jersey `scheduled executor service provider SPI`.

This provider creates and provisions a shared `ScheduledThreadPoolExecutor` instance using the customizable `core threads`, `backing thread factory` and `rejected task handler` values. Subclasses may override the respective methods to customize the parameters of the provisioned scheduler.

When Jersey runtime no longer requires the use of a provided executor service instance, it invokes the provider's `dispose(java.util.concurrent.ExecutorService)` method to signal the provider that the executor service instance can be disposed of. In this method, provider is free to implement the proper shut-down logic for the disposed executor service instance and perform other necessary cleanup. Yet, some providers may wish to implement a shared executor service strategy. In such case, it may not be desirable to shut down the released executor service in the `dispose(java.util.concurrent.ExecutorService)` method. Instead, to perform the eventual shut-down procedure, the provider may either rely on an explicit invocation of it's specific clean-up method. Since all Jersey providers operate in a container environment, a good clean-up strategy for a shared executor service provider implementation is to expose a `@PreDestroy`-annotated method that will be invoked for all instances managed by the container, before the container shuts down.

IMPORTANT: Please note that any pre-destroy methods may not be invoked for instances created outside of the container and later registered within the container. Pre-destroy methods are only guaranteed to be invoked for those instances that are created and managed by the container.

Since:
  2.18
Author:
  Marek Potociar

### Field Summary

### Fields inherited from class org.glassfish.jersey.spi.AbstractThreadPoolProvider

`DEFAULT_TERMINATION_TIMEOUT`

### Constructor Summary

Constructors
Constructor and Description
`ScheduledThreadPoolExecutorProvider(String name)` Create a new instance of the scheduled thread pool executor provider.

### Method Summary

All Methods Instance Methods Concrete Methods
`protected ScheduledThreadPoolExecutor` `createExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)` Create a new instance of the thread pool executor that should be provided by the `AbstractThreadPoolProvider.getExecutor()` method.
`void` `dispose(ExecutorService executorService)` Invoked when Jersey runtime no longer requires use of the provided executor service.
`ScheduledExecutorService` `getExecutorService()` Get a scheduled executor service to be used by Jersey client or server runtime to schedule execution of specific tasks.
`void` `preDestroy()` Container pre-destroy handler method.

### Methods inherited from class org.glassfish.jersey.spi.AbstractThreadPoolProvider

`close, getBackingThreadFactory, getCorePoolSize, getExecutor, getRejectedExecutionHandler, getTerminationTimeout, isClosed, onClose`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### ScheduledThreadPoolExecutorProvider

    public ScheduledThreadPoolExecutorProvider(String name)

Create a new instance of the scheduled thread pool executor provider.

Parameters:
  `name` - provider name. The name will be used to name the threads created & used by the provisioned scheduled thread pool executor.

### Method Detail

#### getExecutorService

    public ScheduledExecutorService getExecutorService()

Description copied from interface: `ScheduledExecutorServiceProvider`
Get a scheduled executor service to be used by Jersey client or server runtime to schedule execution of specific tasks.

This method is usually invoked just once at either Jersey client or server application runtime initialization, it may however be invoked multiple times. Once the instance of the provided scheduled executor service is not needed anymore by Jersey application runtime, it will be `disposed`. This typically happens in one of the following situations:

- Jersey client instance is closed (client runtime is shut down).
- Jersey container running a server-side Jersey application is shut down.
- Jersey server-side application is un-deployed.

Specified by:
  `getExecutorService` in interface `ExecutorServiceProvider`
Specified by:
  `getExecutorService` in interface `ScheduledExecutorServiceProvider`
Returns:
  a scheduled executor service. Must not return `null`.

#### createExecutor

    protected ScheduledThreadPoolExecutor createExecutor(int corePoolSize,
                                                         ThreadFactory threadFactory,
                                                         RejectedExecutionHandler handler)

Description copied from class: `AbstractThreadPoolProvider`
Create a new instance of the thread pool executor that should be provided by the `AbstractThreadPoolProvider.getExecutor()` method.

Concrete implementations of this class must override this method and implement the logic that creates the executor service to be provided. The returned thread pool executor will be shut down when this provider instance is `closed`.

This method is invoked at most once, during the first call to the `getExecutor()` method.

Specified by:
  `createExecutor` in class `AbstractThreadPoolProvider<ScheduledThreadPoolExecutor>`
Parameters:
  `corePoolSize` - number of core threads the provisioned thread pool executor should provide.
  `threadFactory` - thread factory to be used by the provisioned thread pool executor when creating new threads.
  `handler` - handler for tasks that cannot be executed by the provisioned thread pool executor (e.g. due to a shutdown).
Returns:
  new instance of the provided thread pool executor.
See Also:
  `AbstractThreadPoolProvider.getExecutor()`, `AbstractThreadPoolProvider.close()`, `AbstractThreadPoolProvider.getCorePoolSize()`, `AbstractThreadPoolProvider.getBackingThreadFactory()`, `AbstractThreadPoolProvider.getRejectedExecutionHandler()`

#### dispose

    public void dispose(ExecutorService executorService)

Description copied from interface: `ExecutorServiceProvider`
Invoked when Jersey runtime no longer requires use of the provided executor service.

Specified by:
  `dispose` in interface `ExecutorServiceProvider`
Parameters:
  `executorService` - executor service to be disposed.

#### preDestroy

    @PreDestroy
    public void preDestroy()

Container pre-destroy handler method.

Invoking the method `closes` this provider.