Schedulers (Reactor Core 3.1.12.RELEASE)

java.lang.Object
- reactor.core.scheduler.Schedulers

```
public abstract class Schedulers
extends Object
```
Schedulers provides various Scheduler factories useable by publishOn or subscribeOn :
- fromExecutorService(ExecutorService)}.
- newParallel(java.lang.String) : Optimized for fast Runnable executions
- single() : Optimized for low-latency Runnable executions
- immediate().
Factories prefixed with new return a new instance of their flavor of Scheduler, while other factories like elastic() return a shared instance, that is the one used by operators requiring that flavor as their default Scheduler.
Author:

Stephane Maldini

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface Schedulers.Factory
Public factory hook to override Schedulers behavior globally

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Schedulers.Factory` Public factory hook to override Schedulers behavior globally

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_POOL_SIZE` Default pool size, initialized to the number of processors available to the runtime on init (but with a minimum value of 4).

Constructor Summary

Constructors
Constructor and Description

Schedulers()

Constructors
Constructor and Description
`Schedulers()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Scheduler`	`elastic()` `Scheduler` that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
`static Scheduler`	`fromExecutor(Executor executor)` Create a `Scheduler` which uses a backing `Executor` to schedule Runnables for async operators.
`static Scheduler`	`fromExecutor(Executor executor, boolean trampoline)` Create a `Scheduler` which uses a backing `Executor` to schedule Runnables for async operators.
`static Scheduler`	`fromExecutorService(ExecutorService executorService)` Create a `Scheduler` which uses a backing `ExecutorService` to schedule Runnables for async operators.
`static Scheduler`	`immediate()` Executes tasks on the caller's thread immediately.
`static boolean`	`isInNonBlockingThread()` Check if calling a Reactor blocking API in the current `Thread` is forbidden or not, by checking if the thread implements `NonBlocking` (in which case it is forbidden and this method returns `true`).
`static boolean`	`isNonBlockingThread(Thread t)` Check if calling a Reactor blocking API in the given `Thread` is forbidden or not, by checking if the thread implements `NonBlocking` (in which case it is forbidden and this method returns `true`).
`static Scheduler`	`newElastic(int ttlSeconds, ThreadFactory threadFactory)` `Scheduler` that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
`static Scheduler`	`newElastic(String name)` `Scheduler` that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
`static Scheduler`	`newElastic(String name, int ttlSeconds)` `Scheduler` that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
`static Scheduler`	`newElastic(String name, int ttlSeconds, boolean daemon)` `Scheduler` that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
`static Scheduler`	`newParallel(int parallelism, ThreadFactory threadFactory)` `Scheduler` that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
`static Scheduler`	`newParallel(String name)` `Scheduler` that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
`static Scheduler`	`newParallel(String name, int parallelism)` `Scheduler` that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
`static Scheduler`	`newParallel(String name, int parallelism, boolean daemon)` `Scheduler` that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
`static Scheduler`	`newSingle(String name)` `Scheduler` that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
`static Scheduler`	`newSingle(String name, boolean daemon)` `Scheduler` that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
`static Scheduler`	`newSingle(ThreadFactory threadFactory)` `Scheduler` that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
`static void`	`onHandleError(BiConsumer<Thread,? super Throwable> c)` Define a hook that is executed when a `Scheduler` has `handled an error`.
`static Scheduler`	`parallel()` `Scheduler` that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
`static void`	`resetFactory()` Re-apply default factory to `Schedulers`
`static void`	`resetOnHandleError()` Reset the `onHandleError(BiConsumer)` hook to the default no-op behavior.
`static void`	`setFactory(Schedulers.Factory factoryInstance)` Replace `Schedulers` factories (`newParallel`, `newSingle` and `newElastic`).
`static void`	`shutdownNow()` Clear any cached `Scheduler` and call dispose on them.
`static Scheduler`	`single()` `Scheduler` that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
`static Scheduler`	`single(Scheduler original)` Wraps a single `Scheduler.Worker` from some other `Scheduler` and provides `Scheduler.Worker` services on top of it.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_POOL_SIZE
```
public static final int DEFAULT_POOL_SIZE
```
    Default pool size, initialized to the number of processors available to the runtime on init (but with a minimum value of 4).
    
    See Also:
    
    Runtime.availableProcessors()
- Constructor Detail
  - Schedulers
```
public Schedulers()
```
- Method Detail
  - fromExecutor
```
public static Scheduler fromExecutor(Executor executor)
```
    Create a Scheduler which uses a backing Executor to schedule Runnables for async operators.
    
    Parameters:
    
    executor - an Executor
    
    Returns:
    
    a new Scheduler
  - fromExecutor
```
public static Scheduler fromExecutor(Executor executor,
                                     boolean trampoline)
```
    Create a Scheduler which uses a backing Executor to schedule Runnables for async operators.
    
    Parameters:
    
    executor - an Executor
    
    trampoline - set to false if this Scheduler is used by "operators" that already conflate Runnable executions (publishOn, subscribeOn...)
    
    Returns:
    
    a new Scheduler
  - fromExecutorService
```
public static Scheduler fromExecutorService(ExecutorService executorService)
```
    Create a Scheduler which uses a backing ExecutorService to schedule Runnables for async operators.
    
    Parameters:
    
    executorService - an ExecutorService
    
    Returns:
    
    a new Scheduler
  - elastic
```
public static Scheduler elastic()
```
    Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
    The maximum number of created thread pools is unbounded.
    The default time-to-live for unused thread pools is 60 seconds, use the appropriate factory to set a different value.
    This scheduler is not restartable.
    
    Returns:
    
    default instance of a Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - parallel
```
public static Scheduler parallel()
```
    Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
    
    Returns:
    
    default instance of a Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers
  - immediate
```
public static Scheduler immediate()
```
    Executes tasks on the caller's thread immediately.
    
    Returns:
    
    a reusable Scheduler
  - newElastic
```
public static Scheduler newElastic(String name)
```
    Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
    The maximum number of created thread pools is unbounded.
    The default time-to-live for unused thread pools is 60 seconds, use the appropriate factory to set a different value.
    This scheduler is not restartable.
    
    Parameters:
    
    name - Thread prefix
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newElastic
```
public static Scheduler newElastic(String name,
                                   int ttlSeconds)
```
    Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
    The maximum number of created thread pools is unbounded.
    This scheduler is not restartable.
    
    Parameters:
    
    name - Thread prefix
    
    ttlSeconds - Time-to-live for an idle Scheduler.Worker
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newElastic
```
public static Scheduler newElastic(String name,
                                   int ttlSeconds,
                                   boolean daemon)
```
    Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
    The maximum number of created thread pools is unbounded.
    This scheduler is not restartable.
    
    Parameters:
    
    name - Thread prefix
    
    ttlSeconds - Time-to-live for an idle Scheduler.Worker
    
    daemon - false if the Scheduler requires an explicit Scheduler.dispose() to exit the VM.
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newElastic
```
public static Scheduler newElastic(int ttlSeconds,
                                   ThreadFactory threadFactory)
```
    Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
    The maximum number of created thread pools is unbounded.
    This scheduler is not restartable.
    
    Parameters:
    
    ttlSeconds - Time-to-live for an idle Scheduler.Worker
    
    threadFactory - a ThreadFactory to use each thread initialization
    
    Returns:
    
    a new Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
  - newParallel
```
public static Scheduler newParallel(String name)
```
    Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work. This type of Scheduler detects and rejects usage of blocking Reactor APIs.
    
    Parameters:
    
    name - Thread prefix
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newParallel
```
public static Scheduler newParallel(String name,
                                    int parallelism)
```
    Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work. This type of Scheduler detects and rejects usage of blocking Reactor APIs.
    
    Parameters:
    
    name - Thread prefix
    
    parallelism - Number of pooled workers.
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newParallel
```
public static Scheduler newParallel(String name,
                                    int parallelism,
                                    boolean daemon)
```
    Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work. This type of Scheduler detects and rejects usage of blocking Reactor APIs.
    
    Parameters:
    
    name - Thread prefix
    
    parallelism - Number of pooled workers.
    
    daemon - false if the Scheduler requires an explicit Scheduler.dispose() to exit the VM.
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newParallel
```
public static Scheduler newParallel(int parallelism,
                                    ThreadFactory threadFactory)
```
    Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
    
    Parameters:
    
    parallelism - Number of pooled workers.
    
    threadFactory - a ThreadFactory to use for the fixed initialized number of Thread
    
    Returns:
    
    a new Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work
  - newSingle
```
public static Scheduler newSingle(String name)
```
    Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work. This type of Scheduler detects and rejects usage * of blocking Reactor APIs.
    
    Parameters:
    
    name - Component and thread name prefix
    
    Returns:
    
    a new Scheduler that hosts a single-threaded ExecutorService-based worker
  - newSingle
```
public static Scheduler newSingle(String name,
                                  boolean daemon)
```
    Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work. This type of Scheduler detects and rejects usage of blocking Reactor APIs.
    
    Parameters:
    
    name - Component and thread name prefix
    
    daemon - false if the Scheduler requires an explicit Scheduler.dispose() to exit the VM.
    
    Returns:
    
    a new Scheduler that hosts a single-threaded ExecutorService-based worker
  - newSingle
```
public static Scheduler newSingle(ThreadFactory threadFactory)
```
    Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
    
    Parameters:
    
    threadFactory - a ThreadFactory to use for the unique thread of the Scheduler
    
    Returns:
    
    a new Scheduler that hosts a single-threaded ExecutorService-based worker
  - onHandleError
```
public static void onHandleError(BiConsumer<Thread,? super Throwable> c)
```
    Define a hook that is executed when a Scheduler has handled an error. Note that it is executed after the error has been passed to the thread uncaughtErrorHandler, which is not the case when a fatal error occurs (see Exceptions.throwIfJvmFatal(Throwable)).
    
    Parameters:
    
    c - the new hook to set.
  - isInNonBlockingThread
```
public static boolean isInNonBlockingThread()
```
    Check if calling a Reactor blocking API in the current Thread is forbidden or not, by checking if the thread implements NonBlocking (in which case it is forbidden and this method returns true).
    
    Returns:
    
    true if blocking is forbidden in this thread, false otherwise
  - isNonBlockingThread
```
public static boolean isNonBlockingThread(Thread t)
```
    Check if calling a Reactor blocking API in the given Thread is forbidden or not, by checking if the thread implements NonBlocking (in which case it is forbidden and this method returns true).
    
    Returns:
    
    true if blocking is forbidden in that thread, false otherwise
  - resetFactory
```
public static void resetFactory()
```
    Re-apply default factory to Schedulers
  - resetOnHandleError
```
public static void resetOnHandleError()
```
    Reset the onHandleError(BiConsumer) hook to the default no-op behavior.
  - setFactory
```
public static void setFactory(Schedulers.Factory factoryInstance)
```
    Replace Schedulers factories (newParallel, newSingle and newElastic). Also shutdown Schedulers from the cached factories (like single()) in order to also use these replacements, re-creating the shared schedulers from the new factory upon next use.
    This method should be called safely and with caution, typically on app startup.
    
    Parameters:
    
    factoryInstance - an arbitrary Schedulers.Factory instance.
  - shutdownNow
```
public static void shutdownNow()
```
    Clear any cached Scheduler and call dispose on them.
  - single
```
public static Scheduler single()
```
    Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work. Will cache the returned schedulers for subsequent calls until dispose.
    
    Returns:
    
    default instance of a Scheduler that hosts a single-threaded ExecutorService-based worker
  - single
```
public static Scheduler single(Scheduler original)
```
    Wraps a single Scheduler.Worker from some other Scheduler and provides Scheduler.Worker services on top of it.
    Use the Scheduler.dispose() to release the wrapped worker.
    
    Parameters:
    
    original - a Scheduler to call upon to get the single Scheduler.Worker
    
    Returns:
    
    a wrapping Scheduler consistently returning a same worker from a source Scheduler

Class Schedulers

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_POOL_SIZE

Constructor Detail

Schedulers

Method Detail

fromExecutor

fromExecutor

fromExecutorService

elastic

parallel

immediate

newElastic

newElastic

newElastic

newElastic

newParallel

newParallel

newParallel

newParallel

newSingle

newSingle

newSingle

onHandleError

isInNonBlockingThread

isNonBlockingThread

resetFactory

resetOnHandleError

setFactory

shutdownNow

single

single