Класс ThreadPoolExecutor

java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - java.util.concurrent.ThreadPoolExecutor

Все реализуемые интерфейсы:: Executor, ExecutorService

Прямые известные подклассы:: ScheduledThreadPoolExecutor

public class ThreadPoolExecutor
extends AbstractExecutorService

An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.

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 Executors.newCachedThreadPool() (неограниченный пул потоков с автоматическим возвратом потоков), Executors.newFixedThreadPool(int) (пул потоков фиксированного размера) и Executors.newSingleThreadExecutor() (один фоновый поток), которые предварительно настраивают параметры для наиболее распространенных сценариев использования. В противном случае, используйте следующее руководство при ручном конфигурировании и настройке этого класса:

Базовые и максимальные размеры пула

А ThreadPoolExecutor автоматически скорректирует размер пула (см. getPoolSize()) в соответствии с границами, заданными corePoolSize (см. getCorePoolSize()) и maximumPoolSize (см. getMaximumPoolSize()). При отправке новой задачи в методе execute(Runnable), и если запущено меньше, чем corePoolSize потоков, новый поток создаётся для обработки запроса, даже если другие рабочие потоки простаивают. Если запущено более corePoolSize, но меньше maximumPoolSize потоков, новый поток будет создан только в том случае, если очередь заполнена. Установив corePoolSize и maximumPoolSize одинаковыми, вы создаёте пул потоков фиксированного размера. Установив maximumPoolSize на существенно неограниченное значение, например, Integer.MAX_VALUE, вы разрешаете пулу вмещать произвольное количество одновременных задач. Обычно базовый и максимальный размеры пула устанавливаются только при создании, но их также можно изменить динамически с помощью setCorePoolSize(int) и setMaximumPoolSize(int).

Построение по требованию

По умолчанию, даже базовые потоки первоначально создаются и запускаются только при поступлении новых задач, но это можно динамически переопределить с помощью метода prestartCoreThread() или prestartAllCoreThreads(). Вероятно, вам нужно предварительно запустить потоки, если вы создаёте пул с ненулевой очередью.

Создание новых потоков

Новые потоки создаются с помощью ThreadFactory. Если не указано иное, используется Executors.defaultThreadFactory(), который создаёт потоки, все в одной ThreadGroup и с одинаковым NORM_PRIORITY приоритетом и без статуса демона. Предоставление другого ThreadFactory позволяет изменить имя потока, группу потоков, приоритет, статус демона и т. д. Если ThreadFactory не удаётся создать поток при возврате null от newThread, выполнение исполнителя продолжится, но он может не смочь выполнить какие-либо задачи. Потоки должны обладать разрешением "modifyThread" RuntimePermission. Если рабочие потоки или другие потоки, использующие пул, не обладают этим разрешением, производительность может снизиться: изменения конфигурации могут не вступить в силу своевременно, и завершающийся пул может оставаться в состоянии, в котором завершение возможно, но не завершено.

Временные интервалы ожидания

Если в пуле в данный момент находится более чем corePoolSize потоков, избыточные потоки будут завершены, если они простаивали более чем keepAliveTime (см. getKeepAliveTime(TimeUnit)). Это обеспечивает возможность уменьшения потребления ресурсов, когда пул не используется активно. Если пул станет более активным позже, новые потоки будут созданы. Этот параметр также можно изменить динамически, используя метод

setKeepAliveTime(long,
 TimeUnit)

. Использование значения Long.MAX_VALUE TimeUnit.NANOSECONDS фактически отключает простаивающие потоки от завершения до завершения работы. По умолчанию политика ожидания применяется только в том случае, если потоков больше, чем corePoolSize. Но метод allowCoreThreadTimeOut(boolean) может быть использован для применения этой политики тайм-аута и к основным потокам, при условии, что значение keepAliveTime не равно нулю.

Очереди

Для передачи и хранения отправленных задач может использоваться любая BlockingQueue. Использование этой очереди взаимодействует с размером пула:

Если запущено меньше, чем corePoolSize потоков, исполнитель всегда предпочитает добавление нового потока, а не размещение в очереди.
Если запущено corePoolSize или больше потоков, исполнитель всегда предпочитает размещение запроса в очереди, а не добавление нового потока.
Если запрос не может быть помещён в очередь, новый поток создаётся, если это не превысит maximumPoolSize, в противном случае задача будет отклонена.

Существует три общие стратегии очереди:

Прямые передачи. Хорошим выбором для очереди задач является SynchronousQueue, которая передает задачи потокам без удержания их в противном случае. Здесь попытка поместить задачу в очередь завершится неудачей, если нет потоков, готовых её выполнить, поэтому будет создан новый поток. Эта политика предотвращает блокировку при обработке наборов запросов, которые могут иметь внутренние зависимости. Прямые передачи обычно требуют неограниченных maximumPoolSizes, чтобы избежать отклонения новых отправленных задач. В свою очередь, это допускает возможность неограниченного роста потоков, когда команды продолжают поступать в среднем быстрее, чем они могут быть обработаны.
Неограниченные очереди. Использование неограниченной очереди (например, LinkedBlockingQueue без предварительно заданной вместимости) приведет к ожиданию новых задач в очереди, когда все потоки corePoolSize заняты. Таким образом, будет создано не более corePoolSize потоков. (И значение maximumPoolSize, следовательно, не имеет никакого эффекта.) Это может быть уместно, когда каждая задача полностью независима от других, поэтому задачи не могут влиять на выполнение друг друга; например, в веб-сервере. Хотя этот тип очереди может быть полезен для сглаживания кратковременных всплесков запросов, он допускает возможность неограниченного роста очереди задач, когда команды продолжают поступать в среднем быстрее, чем они могут быть обработаны.
Ограниченные очереди. Ограниченная очередь (например, ArrayBlockingQueue) помогает предотвратить истощение ресурсов при использовании конечных maximumPoolSizes, но может быть сложнее настроить и контролировать. Размеры очереди и максимальные размеры пула могут быть взаимозаменены: использование больших очередей и небольших пулов минимизирует использование процессора, ресурсы ОС и накладные расходы при переключении контекста, но может привести к искусственно низкой пропускной способности. Если задачи часто блокируются (например, если они ограничены ввода-выводом), система может планировать время для большего количества потоков, чем вы позволяете иначе. Использование небольших очередей обычно требует больших размеров пулов, что удерживает процессоры занятыми, но может столкнуться с неприемлемыми расходами на планирование, что также уменьшает пропускную способность.

Отклоненные задачи

Новые задачи, отправленные в методе execute(Runnable), будут отклонены при остановке исполнителя, а также при использовании исполнителем конечных границ для максимального количества потоков и вместимости очереди задач, и при насыщении. В любом случае, метод execute вызывает метод RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor) своего RejectedExecutionHandler. Предоставляются четыре предварительно определённые политики обработчика:

В стандартной ThreadPoolExecutor.AbortPolicy обработчик выбрасывает исключение времени выполнения RejectedExecutionException при отклонении.
В ThreadPoolExecutor.CallerRunsPolicy поток, вызывающий execute, сам выполняет задачу. Это обеспечивает простую механику обратной связи, которая замедлит скорость отправки новых задач.
В ThreadPoolExecutor.DiscardPolicy задача, которую нельзя выполнить, просто отбрасывается.
В ThreadPoolExecutor.DiscardOldestPolicy, если исполнитель не остановлен, задача в начале очереди задач отбрасывается, а затем выполнение повторяется (что может снова завершиться неудачей, заставив повторить это).

Возможна разработка и использование других типов RejectedExecutionHandler классов. Это требует осторожности, особенно когда политики разработаны для работы только при определённых параметрах вместимости или очередях.

Методы-заглушки

Этот класс предоставляет protected переопределяемые методы beforeExecute(Thread, Runnable) и afterExecute(Runnable, Throwable), вызываемые перед и после выполнения каждой задачи. Их можно использовать для управления средой выполнения; например, для повторной инициализации ThreadLocals, сбора статистики или добавления записей в журнал. Кроме того, метод terminated() можно переопределить, чтобы выполнить любую специальную обработку, которая должна быть выполнена после полного завершения исполнителя.

Если методы-заглушки или обратные вызовы генерируют исключения, внутренние рабочие потоки могут, в свою очередь, выйти из строя и прервать выполнение.

Управление очередью

Метод getQueue() позволяет получить доступ к очереди задач для целей мониторинга и отладки. Использование этого метода для любых других целей настоятельно не рекомендуется. Два предоставленных метода, remove(Runnable) и purge(), доступны для помощи в освобождении памяти при больших количествах отменённых задач в очереди.

Завершение

Пул, на который больше нет ссылок в программе И у которого нет оставшихся потоков, будет shutdown автоматически. Если вы хотите убедиться, что неиспользуемые пулы будут освобождены, даже если пользователи забудут вызвать shutdown(), то вы должны позаботиться о том, чтобы неиспользуемые потоки в конечном итоге завершились, установив соответствующие временные интервалы ожидания, используя нижнюю границу в ноль для основных потоков и/или установив allowCoreThreadTimeOut(boolean).

Пример расширения. Большинство расширений этого класса переопределяют один или несколько защищённых методов-заглушек. Например, вот подкласс, который добавляет простую функцию паузы/возобновления:

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
   private boolean isPaused;
   private ReentrantLock pauseLock = new ReentrantLock();
   private Condition unpaused = pauseLock.newCondition();

   public PausableThreadPoolExecutor(...) { super(...); }

   protected void beforeExecute(Thread t, Runnable r) {
     super.beforeExecute(t, r);
     pauseLock.lock();
     try {
       while (isPaused) unpaused.await();
     } catch (InterruptedException ie) {
       t.interrupt();
     } finally {
       pauseLock.unlock();
     }
   }

   public void pause() {
     pauseLock.lock();
     try {
       isPaused = true;
     } finally {
       pauseLock.unlock();
     }
   }

   public void resume() {
     pauseLock.lock();
     try {
       isPaused = false;
       unpaused.signalAll();
     } finally {
       pauseLock.unlock();
     }
   }
 }

C:: 1.5

Вложенные классы

Модификатор и тип	Класс и описание
`static class`	`ThreadPoolExecutor.AbortPolicy` Обработчик отклоненных задач, который выбрасывает `RejectedExecutionException`.
`static class`	`ThreadPoolExecutor.CallerRunsPolicy` Обработчик отклоненных задач, который выполняет отклоненную задачу непосредственно в вызывающем потоке метода `execute`, если исполнитель не остановлен, в противном случае задача отбрасывается.
`static class`	`ThreadPoolExecutor.DiscardOldestPolicy` Обработчик отклоненных задач, который отбрасывает самую старую необработанную задачу из очереди и затем повторно пытается `execute`, если исполнитель не остановлен, в противном случае задача отбрасывается.
`static class`	`ThreadPoolExecutor.DiscardPolicy` Обработчик отклоненных задач, который молчаливо отбрасывает отклоненную задачу.

Конструкторы

Конструктор и описание
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)` Создаёт новый `ThreadPoolExecutor` с заданными начальными параметрами, заводской фабрикой потоков и обработчиком отклоненных задач.
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)` Создаёт новый `ThreadPoolExecutor` с заданными начальными параметрами и заводской фабрикой потоков.
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)` Создаёт новый `ThreadPoolExecutor` с заданными начальными параметрами и заводским обработчиком отклоненных задач.
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)` Создаёт новый `ThreadPoolExecutor` с заданными начальными параметрами.

Методы

Модификатор и тип	Метод и описание
`protected void`	`afterExecute(Runnable r, Throwable t)` Метод, вызываемый по завершении выполнения заданного Runnable.
`void`	`allowCoreThreadTimeOut(boolean value)` Устанавливает политику, определяющую, могут ли основные потоки отключаться по истечении времени ожидания, если в течение этого времени не поступают задачи, и при необходимости заменяться новыми задачами.
`boolean`	`allowsCoreThreadTimeOut()` Возвращает true, если в этом пуле основные потоки могут отключаться по истечении времени ожидания keepAlive, если в течение этого времени не поступают задачи, и при необходимости заменяться новыми задачами.
`boolean`	`awaitTermination(long timeout, TimeUnit unit)` Блокирует выполнение, пока все задачи не будут завершены после запроса остановки, или истечёт таймаут, или текущий поток будет прерван, в зависимости от того, что произойдёт первым.
`protected void`	`beforeExecute(Thread t, Runnable r)` Метод, вызываемый перед выполнением заданного Runnable в заданном потоке.
`void`	`execute(Runnable command)` Выполняет заданную задачу в будущем.
`protected void`	`finalize()` Вызывает `shutdown`, когда на этот Executor больше нет ссылок и у него нет потоков.
`int`	`getActiveCount()` Возвращает приблизительное количество потоков, активно выполняющих задачи.
`long`	`getCompletedTaskCount()` Возвращает приблизительное общее количество завершенных задач.
`int`	`getCorePoolSize()` Возвращает количество основных потоков.
`long`	`getKeepAliveTime(TimeUnit unit)` Возвращает время ожидания потока, которое представляет собой период времени, в течение которого потоки, превышающие размер базового пула, могут оставаться бездействующими, прежде чем будут завершены.
`int`	`getLargestPoolSize()` Возвращает максимальное количество потоков, одновременно присутствовавших в пуле.
`int`	`getMaximumPoolSize()` Возвращает максимальное разрешённое количество потоков.
`int`	`getPoolSize()` Возвращает текущее количество потоков в пуле.
`BlockingQueue<Runnable>`	`getQueue()` Возвращает очередь задач, используемую этим Executor.
`RejectedExecutionHandler`	`getRejectedExecutionHandler()` Возвращает текущего обработчика невыполнимых задач.
`long`	`getTaskCount()` Возвращает приблизительное общее количество задач, когда-либо запланированных для выполнения.
`ThreadFactory`	`getThreadFactory()` Возвращает фабрику потоков, используемую для создания новых потоков.
`boolean`	`isShutdown()` Возвращает `true`, если этот Executor был остановлен.
`boolean`	`isTerminated()` Возвращает `true`, если все задачи завершены после остановки.
`boolean`	`isTerminating()` Возвращает true, если этот Executor находится в процессе завершения после `shutdown()` или `shutdownNow()`, но ещё не завершился полностью.
`int`	`prestartAllCoreThreads()` Запускает все основные потоки, заставляя их бездействовать и ждать работы.
`boolean`	`prestartCoreThread()` Запускает основной поток, заставляя его бездействовать и ждать работы.
`void`	`purge()` Попытка удалить из очереди работы все `Future` задачи, которые были отменены.
`boolean`	`remove(Runnable task)` Удаляет эту задачу из внутренней очереди Executor, если она присутствует, тем самым не допуская её выполнения, если она ещё не началась.
`void`	`setCorePoolSize(int corePoolSize)` Устанавливает количество основных потоков.
`void`	`setKeepAliveTime(long time, TimeUnit unit)` Устанавливает временной лимит, в течение которого потоки могут оставаться бездействующими перед завершением.
`void`	`setMaximumPoolSize(int maximumPoolSize)` Устанавливает максимальное разрешённое количество потоков.
`void`	`setRejectedExecutionHandler(RejectedExecutionHandler handler)` Устанавливает новый обработчик для невыполнимых задач.
`void`	`setThreadFactory(ThreadFactory threadFactory)` Устанавливает фабрику потоков, используемую для создания новых потоков.
`void`	`shutdown()` Производит упорядоченное завершение, в котором ранее отправленные задачи выполняются, но новые задачи не принимаются.
`List<Runnable>`	`shutdownNow()` Попытка остановить все активно выполняющиеся задачи, приостановить обработку ожидающих задач и вернуть список задач, которые ожидали выполнения.
`protected void`	`terminated()` Метод, вызываемый, когда Executor завершился.
`String`	`toString()` Возвращает строку, идентифицирующую этот пул, а также его состояние, включая указания на состояние выполнения и приблизительные количества рабочих потоков и задач.

Методы, унаследованные от класса java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit

Методы, унаследованные от класса java.lang.Object

clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Конструкторы

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

Создаёт новый ThreadPoolExecutor с заданными начальными параметрами и стандартной фабрикой потоков и обработчиком отклоненных задач. Возможно, удобнее использовать один из методов-фабрик Executors, вместо этого универсального конструктора.

Параметры:: corePoolSize - количество потоков, которые необходимо поддерживать в пуле, даже если они простаивают, если allowCoreThreadTimeOut не задан; maximumPoolSize - максимальное количество потоков, которое допускается в пуле; keepAliveTime - если количество потоков больше ядра, это максимальное время, в течение которого избыточные простаивающие потоки будут ожидать новых задач перед завершением.; unit - единица измерения времени для аргумента keepAliveTime; workQueue - очередь для хранения задач перед их выполнением. Эта очередь будет содержать только задачи, представленные методом execute.
Исключения:: IllegalArgumentException - если выполняется одно из следующих условий:
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize; NullPointerException - если workQueue равно null

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

Создаёт новый ThreadPoolExecutor с заданными начальными параметрами и стандартным обработчиком отклоненных задач.

Параметры:: corePoolSize - количество потоков, которые необходимо поддерживать в пуле, даже если они простаивают, если allowCoreThreadTimeOut не задан; maximumPoolSize - максимальное количество потоков, которое допускается в пуле; keepAliveTime - если количество потоков больше ядра, это максимальное время, в течение которого избыточные простаивающие потоки будут ожидать новых задач перед завершением.; unit - единица измерения времени для аргумента keepAliveTime; workQueue - очередь для хранения задач перед их выполнением. Эта очередь будет содержать только задачи, представленные методом execute.; threadFactory - фабрика, используемая при создании нового потока исполнителем.
Исключения:: IllegalArgumentException - если выполняется одно из следующих условий:
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize; NullPointerException - если workQueue или threadFactory равно null

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)

Создаёт новый ThreadPoolExecutor с заданными начальными параметрами и стандартной фабрикой потоков.

Параметры:: corePoolSize - количество потоков, которые необходимо поддерживать в пуле, даже если они простаивают, если allowCoreThreadTimeOut не задан; maximumPoolSize - максимальное количество потоков, которое допускается в пуле; keepAliveTime - если количество потоков больше ядра, это максимальное время, в течение которого избыточные простаивающие потоки будут ожидать новых задач перед завершением.; unit - единица измерения времени для аргумента keepAliveTime; workQueue - очередь для хранения задач перед их выполнением. Эта очередь будет содержать только задачи, представленные методом execute.; handler - обработчик, используемый при блокировке выполнения из-за достижения границ потоков и емкости очереди
Исключения:: IllegalArgumentException - если выполняется одно из следующих условий:
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize; NullPointerException - если workQueue или handler равно null

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

Создаёт новый ThreadPoolExecutor с заданными начальными параметрами.

Параметры:: corePoolSize - количество потоков, которые необходимо поддерживать в пуле, даже если они простаивают, если allowCoreThreadTimeOut не задан; maximumPoolSize - максимальное количество потоков, которое допускается в пуле; keepAliveTime - если количество потоков больше ядра, это максимальное время, в течение которого избыточные простаивающие потоки будут ожидать новых задач перед завершением.; unit - единица измерения времени для аргумента keepAliveTime; workQueue - очередь для хранения задач перед их выполнением. Эта очередь будет содержать только задачи, представленные методом execute.; threadFactory - фабрика, используемая при создании нового потока исполнителем; handler - обработчик, используемый при блокировке выполнения из-за достижения границ потоков и емкости очереди
Исключения:: IllegalArgumentException - если выполняется одно из следующих условий:
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize; NullPointerException - если workQueue или threadFactory или handler равно null

Методы

execute

public void execute(Runnable command)

Выполняет заданную задачу в будущем. Задача может быть выполнена в новом потоке или в существующем потоке пула. Если задачу нельзя отправить на выполнение, либо потому, что этот исполнитель был остановлен, либо потому, что его емкость достигнута, задача обрабатывается текущим RejectedExecutionHandler.

Параметры:: command - задача для выполнения
Исключения:: RejectedExecutionException - по усмотрению RejectedExecutionHandler, если задачу нельзя принять для выполнения; NullPointerException - если command равно null

shutdown

public void shutdown()

Инициирует упорядоченное завершение, при котором ранее отправленные задачи выполняются, но новые задачи не принимаются. Вызов не имеет дополнительного эффекта, если уже завершён.

Этот метод не ждёт завершения ранее отправленных задач. Используйте awaitTermination для этого.

Исключения:: SecurityException - если существует менеджер безопасности и завершение этого ExecutorService может манипулировать потоками, которые вызывающий элемент не имеет права изменять, потому что он не обладает RuntimePermission("modifyThread"), или метод checkAccess менеджера безопасности отклоняет доступ.

shutdownNow

public List<Runnable> shutdownNow()

Пытается остановить все активно выполняемые задачи, приостанавливает обработку ожидающих задач и возвращает список задач, которые ожидали выполнения. Эти задачи сбрасываются (удаляются) из очереди задач при возврате из этого метода.

Этот метод не ждёт завершения активно выполняемых задач. Используйте awaitTermination для этого.

Гарантий, кроме попыток остановить выполнение активно выполняемых задач, нет. Это реализация отменяет задачи через Thread.interrupt(), поэтому любая задача, которая не реагирует на прерывания, может никогда не завершиться.

Возвращает:: список задач, которые никогда не начинали выполнение
Исключения:: SecurityException - если существует менеджер безопасности и завершение этого ExecutorService может манипулировать потоками, которые вызывающий элемент не имеет права изменять, потому что он не обладает RuntimePermission("modifyThread"), или метод checkAccess менеджера безопасности отклоняет доступ.

isShutdown

public boolean isShutdown()

Описание скопировано из интерфейса: ExecutorService

Возвращает true , если этот исполнитель был остановлен.

Возвращает:: true , если этот исполнитель был остановлен

isTerminating

public boolean isTerminating()

Возвращает true, если этот исполнитель находится в процессе завершения после вызова shutdown() или shutdownNow(), но ещё не завершён. Этот метод может быть полезен для отладки. Возврат true после достаточного периода после завершения может указывать на то, что отправленные задачи игнорировали или подавляли прерывание, из-за чего этот исполнитель не завершился должным образом.

Возвращает:: true , если завершается, но ещё не завершён

isTerminated

public boolean isTerminated()

Описание скопировано из интерфейса: ExecutorService

Возвращает true , если все задачи были выполнены после запроса завершения. Обратите внимание, что isTerminated никогда не true , если не был вызван ни shutdown, ни shutdownNow.

Возвращает:: true , если все задачи были выполнены после запроса завершения

awaitTermination

public boolean awaitTermination(long timeout,
                                TimeUnit unit)
                         throws InterruptedException

Описание скопировано из интерфейса: ExecutorService

Блокирует, пока все задачи не завершат выполнение после запроса завершения или не истечёт таймаут или не будет прерван текущий поток, что произойдёт первым.

Параметры:: timeout - максимальное время ожидания; unit - единица измерения времени аргумента таймаута
Возвращает:: true , если этот исполнитель завершён, и false , если таймаут истек до завершения
Исключения:: InterruptedException - если ожидание прервано

finalize

protected void finalize()

Вызывает shutdown , когда на этот исполнитель больше нет ссылок и у него нет потоков.

Переопределяет:: finalize в классе Object
См. также:: WeakReference, PhantomReference

setThreadFactory

public void setThreadFactory(ThreadFactory threadFactory)

Устанавливает фабрику потоков, используемую для создания новых потоков.

Параметры:: threadFactory - новая фабрика потоков
Исключения:: NullPointerException - если threadFactory равно null
См. также:: getThreadFactory()

getThreadFactory

public ThreadFactory getThreadFactory()

Возвращает фабрику потоков, используемую для создания новых потоков.

Возвращает:: текущая фабрика потоков
См. также:: setThreadFactory(ThreadFactory)

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Устанавливает новый обработчик для задач, которые не могут быть выполнены.

Параметры:: handler - новый обработчик
Исключения:: NullPointerException - если handler равно null
См. также:: getRejectedExecutionHandler()

getRejectedExecutionHandler

public RejectedExecutionHandler getRejectedExecutionHandler()

Возвращает текущий обработчик для задач, которые не могут быть выполнены.

Возвращает:: текущий обработчик
См. также:: setRejectedExecutionHandler(RejectedExecutionHandler)

setCorePoolSize

public void setCorePoolSize(int corePoolSize)

Устанавливает базовое количество потоков. Это переопределяет любое значение, установленное в конструкторе. Если новое значение меньше текущего, избыточные существующие потоки будут завершены при следующем бездействии. Если больше, новые потоки, при необходимости, будут запущены для выполнения любых задач в очереди.

Параметры:: corePoolSize - новый базовый размер
Исключения:: IllegalArgumentException - если corePoolSize < 0
См. также:: getCorePoolSize()

getCorePoolSize

public int getCorePoolSize()

Возвращает базовое количество потоков.

Возвращает:: базовое количество потоков
См. также:: setCorePoolSize(int)

prestartCoreThread

public boolean prestartCoreThread()

Запускает базовый поток, заставляя его бездействовать, ожидая работы. Это переопределяет стандартную политику запуска базовых потоков только при выполнении новых задач. Этот метод вернёт false если все базовые потоки уже были запущены.

Возвращает:: true если поток был запущен

prestartAllCoreThreads

public int prestartAllCoreThreads()

Запускает все базовые потоки, заставляя их бездействовать, ожидая работы. Это переопределяет стандартную политику запуска базовых потоков только при выполнении новых задач.

Возвращает:: количество запущенных потоков

allowsCoreThreadTimeOut

public boolean allowsCoreThreadTimeOut()

Возвращает true, если этот пул позволяет базовым потокам отключаться и завершаться, если ни одна задача не появляется в течение времени keepAlive, заменяясь при необходимости, когда появляются новые задачи. При значении true, та же политика keep-alive, применяемая к не-базовым потокам, применяется и к базовым. При значении false (по умолчанию), базовые потоки никогда не завершаются из-за отсутствия входящих задач.

Возвращает:: true если базовым потокам разрешено отключаться, иначе false
С:: 1.6

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

Устанавливает политику, определяющую, могут ли базовые потоки отключаться и завершаться, если ни одна задача не появляется в течение времени keep-alive, заменяясь при необходимости, когда появляются новые задачи. Если false, базовые потоки никогда не завершаются из-за отсутствия входящих задач. Если true, та же политика keep-alive, применяемая к не-базовым потокам, применяется и к базовым. Чтобы избежать постоянной замены потоков, время keep-alive должно быть больше нуля при установке true. Этот метод, как правило, должен вызываться до того, как пул будет активно использоваться.

Параметры:: value - true если должно отключаться, иначе false
Исключения:: IllegalArgumentException - если значение равно true и текущее время keep-alive не больше нуля
С:: 1.6

setMaximumPoolSize

public void setMaximumPoolSize(int maximumPoolSize)

Устанавливает максимальное допустимое количество потоков. Это переопределяет любое значение, установленное в конструкторе. Если новое значение меньше текущего, избыточные существующие потоки будут завершены при следующем бездействии.

Параметры:: maximumPoolSize - новое максимальное значение
Исключения:: IllegalArgumentException - если новое максимальное значение меньше или равно нулю, или меньше размера базового пула
См. также:: getMaximumPoolSize()

getMaximumPoolSize

public int getMaximumPoolSize()

Возвращает максимальное допустимое количество потоков.

Возвращает:: максимальное допустимое количество потоков
См. также:: setMaximumPoolSize(int)

setKeepAliveTime

public void setKeepAliveTime(long time,
                             TimeUnit unit)

Устанавливает временной лимит, в течение которого потоки могут оставаться бездействующими перед завершением. Если количество потоков в пуле больше, чем базовое количество, по истечении этого времени без обработки задачи, избыточные потоки будут завершены. Это переопределяет любое значение, установленное в конструкторе.

Параметры:: time - время ожидания. Значение времени равно нулю приведет к немедленному завершению избыточных потоков после выполнения задач.; unit - единица измерения времени для аргумента time
Исключения:: IllegalArgumentException - если time меньше нуля или если time равно нулю и allowsCoreThreadTimeOut
См. также:: getKeepAliveTime(TimeUnit)

getKeepAliveTime

public long getKeepAliveTime(TimeUnit unit)

Возвращает время ожидания потока, которое представляет собой количество времени, в течение которого потоки, превышающие размер базового пула, могут оставаться бездействующими перед завершением.

Параметры:: unit - желаемая единица измерения времени результата
Возвращает:: временной лимит
См. также:: setKeepAliveTime(long, TimeUnit)

getQueue

public BlockingQueue<Runnable> getQueue()

Возвращает очередь задач, используемая этим исполнителем. Доступ к очереди задач предназначен в основном для отладки и мониторинга. Эта очередь может быть в активном использовании. Получение очереди задач не препятствует выполнению задач в очереди.

Возвращает:: очередь задач

remove

public boolean remove(Runnable task)

Удаляет эту задачу из внутренней очереди исполнителя, если она присутствует, тем самым предотвращая её выполнение, если она ещё не началась.

Этот метод может быть полезен как часть схемы отмены. Он может не удалять задачи, которые были преобразованы в другие формы до помещения в внутреннюю очередь. Например, задача, введённая с помощью submit , может быть преобразована в форму, которая поддерживает Future состояние. Однако в таких случаях может быть использован метод purge() для удаления этих задач, которые были отменены.

Параметры:: task - задача для удаления
Возвращает:: true если задача была удалена

purge

public void purge()

Пытается удалить из очереди все задачи Future, которые были отменены. Этот метод может быть полезен как операция по освобождению памяти, которая не имеет других последствий для функциональности. Отменённые задачи никогда не выполняются, но могут накапливаться в очередях до тех пор, пока рабочие потоки не смогут их активно удалить. Вызов этого метода пытается удалить их сейчас. Однако этот метод может не удалять задачи в случае вмешательства других потоков.

getPoolSize

public int getPoolSize()

Возвращает текущее количество потоков в пуле.

Возвращает:: количество потоков

getActiveCount

public int getActiveCount()

Возвращает приблизительное количество потоков, активно выполняющих задачи.

Возвращает:: количество потоков

getLargestPoolSize

public int getLargestPoolSize()

Возвращает максимальное количество потоков, которые одновременно находились в пуле.

Возвращает:: количество потоков

getTaskCount

public long getTaskCount()

Возвращает приблизительное общее количество задач, которые когда-либо были запланированы для выполнения. Поскольку состояния задач и потоков могут динамически изменяться во время вычислений, возвращаемое значение является лишь приблизительным.

Возвращает:: количество задач

getCompletedTaskCount

public long getCompletedTaskCount()

Возвращает приблизительное общее количество задач, которые завершили выполнение. Поскольку состояния задач и потоков могут динамически изменяться во время вычислений, возвращаемое значение является лишь приблизительным, но оно никогда не уменьшается при последовательных вызовах.

Возвращает:: количество задач

toString

public String toString()

Возвращает строку, идентифицирующую этот пул, а также его состояние, включая указания на состояние выполнения и приблизительное количество рабочих потоков и задач.

Переопределяет:: toString в классе Object
Возвращает:: строка, идентифицирующая этот пул и его состояние

beforeExecute

protected void beforeExecute(Thread t,
                             Runnable r)

Метод, вызываемый перед выполнением заданного Runnable в заданном потоке. Этот метод вызывается потоком t, который выполнит задачу r, и может использоваться для повторной инициализации ThreadLocals или для ведения журнала.

Эта реализация ничего не делает, но может быть настраиваема в подклассах. Примечание: для правильного вложенного переопределения подклассы, как правило, должны вызывать super.beforeExecute в конце этого метода.

Параметры:: t - поток, который выполнит задачу r; r - задача, которая будет выполнена

afterExecute

protected void afterExecute(Runnable r,
                            Throwable t)

Метод, вызываемый по завершении выполнения заданного Runnable. Этот метод вызывается потоком, выполнившим задачу. Если не null, Throwable — это необработанное RuntimeException или Error, которое привело к преждевременному завершению выполнения.

Это реализация ничего не делает, но может быть настраиваема в подклассах. Примечание: для правильного вложенного переопределения подклассы, как правило, должны вызывать super.afterExecute в начале этого метода.

Примечание: Когда действия заключены в задачи (например, FutureTask) явно или через методы, такие как submit, эти объекты задачи перехватывают и сохраняют вычислительные исключения, поэтому они не вызывают преждевременного завершения, а внутренние исключения не передаются в этот метод. Если вы хотите перехватить оба типа сбоев в этом методе, вы можете дополнительно проверить такие случаи, как в этом образце подкласса, который печатает либо непосредственную причину, либо базовое исключение, если задача была прервана:

class ExtendedExecutor extends ThreadPoolExecutor {
   // ...
   protected void afterExecute(Runnable r, Throwable t) {
     super.afterExecute(r, t);
     if (t == null && r instanceof Future<?>) {
       try {
         Object result = ((Future<?>) r).get();
       } catch (CancellationException ce) {
           t = ce;
       } catch (ExecutionException ee) {
           t = ee.getCause();
       } catch (InterruptedException ie) {
           Thread.currentThread().interrupt(); // ignore/reset
       }
     }
     if (t != null)
       System.out.println(t);
   }
 }

Параметры:: r - Runnable, который завершился; t - исключение, вызвавшее завершение, или null, если выполнение завершилось нормально

terminated

protected void terminated()

Метод, вызываемый при завершении Executor. По умолчанию ничего не делает. Примечание: для правильного вложенного переопределения подклассы, как правило, должны вызывать super.terminated в этом методе.

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.