class Concurrent::ThreadPoolExecutor
@!macro thread_pool_executor
An abstraction composed of one or more threads and a task queue. Tasks (blocks or `proc` objects) are submitted to the pool and added to the queue. The threads in the pool remove the tasks and execute them in the order they were received. A `ThreadPoolExecutor` will automatically adjust the pool size according to the bounds set by `min-threads` and `max-threads`. When a new task is submitted and fewer than `min-threads` threads are running, a new thread is created to handle the request, even if other worker threads are idle. If there are more than `min-threads` but less than `max-threads` threads running, a new thread will be created only if the queue is full. Threads that are idle for too long will be garbage collected, down to the configured minimum options. Should a thread crash it, too, will be garbage collected. `ThreadPoolExecutor` is based on the Java class of the same name. From the official Java documentation; > Thread pools address two different problems: they usually provide > improved performance when executing large numbers of asynchronous tasks, > due to reduced per-task invocation overhead, and they provide a means > of bounding and managing the resources, including threads, consumed > when executing a collection of tasks. Each ThreadPoolExecutor also > maintains some basic statistics, such as the number of completed tasks. > > To be useful across a wide range of contexts, this class provides many > adjustable parameters and extensibility hooks. However, programmers are > urged to use the more convenient Executors factory methods > [CachedThreadPool] (unbounded thread pool, with automatic thread reclamation), > [FixedThreadPool] (fixed size thread pool) and [SingleThreadExecutor] (single > background thread), that preconfigure settings for the most common usage > scenarios.
@!macro thread_pool_options
@!macro thread_pool_executor_public_api