Класс ThreadPoolExecutor

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

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

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

public class ThreadPoolExecutor
extends AbstractExecutorService

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

Пулы потоков решают две разные проблемы: они обычно обеспечивают улучшенную производительность при выполнении большого количества асинхронных задач из-за снижения накладных расходов на вызов каждой задачи, и они предоставляют способ ограничения и управления ресурсами, включая потоки, используемые при выполнении набора задач. Каждый ThreadPoolExecutor также сохраняет некоторые основные статистические данные, такие как количество завершённых задач.

Для удобства использования в широком диапазоне контекстов этот класс предоставляет много регулируемых параметров и возможности расширения. Однако программистам рекомендуется использовать более удобные фабричные методы Executors Executors.newCachedThreadPool() (бесконечный пул потоков с автоматическим возвратом потоков), Executors.newFixedThreadPool(int) (пул потоков фиксированного размера) и Executors.newSingleThreadExecutor() (один фоновый поток), которые предварительно настраивают параметры для самых распространённых сценариев использования. В противном случае, воспользуйтесь следующим руководством при ручной настройке и оптимизации этого класса:

Размер ядра и максимальный размер пула

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

Построение по запросу

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

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

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

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

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

setKeepAliveTime(long,
 TimeUnit)

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

Очереди

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

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

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

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

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

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

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

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

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

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

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

Поддержание очереди

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

Освобождение

Пул, на который больше нет ссылок в программе И у которого нет оставшихся потоков, может быть освобождён (утилизирован сборщиком мусора) без явного закрытия. Вы можете настроить пул для разрешения всем неиспользуемым потокам в конечном итоге умереть, установив соответствующие значения времени ожидания, используя нижнюю границу в ноль для потоков ядра и/или установку 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();
     }
   }
 }

С момента:: 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)`	Устанавливает политику, определяющую, могут ли основные потоки отключаться и завершаться, если в течение времени ожидания keep-alive не поступают задачи, а при необходимости заменяться новыми задачами.
`boolean`	`allowsCoreThreadTimeOut()`	Возвращает true, если этот пул позволяет основным потокам отключаться и завершаться, если в течение времени ожидания keepAlive не поступают задачи, а при необходимости заменяться новыми задачами.
`protected void`	`beforeExecute(Thread t, Runnable r)`	Метод, вызываемый перед выполнением заданного Runnable в заданном потоке.
`void`	`execute(Runnable command)`	Выполняет заданную задачу в будущем.
`protected void`	`finalize()`	Устарело.
`int`	`getActiveCount()`	Возвращает приблизительное количество потоков, активно выполняющих задачи.
`long`	`getCompletedTaskCount()`	Возвращает приблизительное общее количество задач, завершивших выполнение.
`int`	`getCorePoolSize()`	Возвращает количество основных потоков.
`long`	`getKeepAliveTime(TimeUnit unit)`	Возвращает время ожидания keep-alive потока, которое представляет собой период времени, в течение которого потоки могут оставаться бездействующими перед завершением.
`int`	`getLargestPoolSize()`	Возвращает максимальное количество потоков, которое когда-либо одновременно находилось в пуле.
`int`	`getMaximumPoolSize()`	Возвращает максимальное разрешённое количество потоков.
`int`	`getPoolSize()`	Возвращает текущее количество потоков в пуле.
`BlockingQueue<Runnable>`	`getQueue()`	Возвращает очередь задач, используемую этим исполняющим потоком.
`RejectedExecutionHandler`	`getRejectedExecutionHandler()`	Возвращает текущий обработчик невыполнимых задач.
`long`	`getTaskCount()`	Возвращает приблизительное общее количество задач, которые когда-либо планировались для выполнения.
`ThreadFactory`	`getThreadFactory()`	Возвращает фабрику потоков, используемую для создания новых потоков.
`boolean`	`isTerminating()`	Возвращает true, если этот исполняющий поток находится в процессе завершения после `shutdown()` или `shutdownNow()`, но не завершился полностью.
`int`	`prestartAllCoreThreads()`	Запускает все основные потоки, заставляя их бездействовать в ожидании работы.
`boolean`	`prestartCoreThread()`	Запускает основной поток, заставляя его бездействовать в ожидании работы.
`void`	`purge()`	Пытается удалить из очереди задач все `Future` задачи, которые были отменены.
`boolean`	`remove(Runnable task)`	Удаляет эту задачу из внутренней очереди исполняющего потока, если она присутствует, тем самым не позволяя её выполнить, если она ещё не началась.
`void`	`setCorePoolSize(int corePoolSize)`	Устанавливает количество основных потоков.
`void`	`setKeepAliveTime(long time, TimeUnit unit)`	Устанавливает время ожидания keep-alive потока, которое представляет собой период времени, в течение которого потоки могут оставаться бездействующими перед завершением.
`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

newTaskFor, newTaskFor, submit, submit, submit

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

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

Методы, унаследованные от интерфейса java.util.concurrent.ExecutorService

awaitTermination, invokeAll, invokeAll, invokeAny, invokeAny, isShutdown, isTerminated

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

ThreadPoolExecutor

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

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

Возможно, будет удобнее использовать один из методов-фабрик Executors вместо этого универсального конструктора.

Параметры:: corePoolSize - количество потоков, которые необходимо поддерживать в пуле, даже если они простаивают, если allowCoreThreadTimeOut не задан; maximumPoolSize - максимальное количество потоков, разрешённых в пуле; keepAliveTime - когда количество потоков больше ядра, это максимальное время, которое избыточные простаивающие потоки будут ждать новых задач перед завершением.; unit - единица измерения времени для аргумента keepAliveTime; workQueue - очередь, используемая для удержания задач до их выполнения. Эта очередь будет содержать только Runnable задачи, отправленные методом 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 - очередь, используемая для удержания задач до их выполнения. Эта очередь будет содержать только Runnable задачи, отправленные методом 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 - очередь, используемая для удержания задач до их выполнения. Эта очередь будет содержать только Runnable задачи, отправленные методом 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 - очередь, используемая для удержания задач до их выполнения. Эта очередь будет содержать только Runnable задачи, отправленные методом 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 менеджера безопасности отказывает в доступе.

isTerminating

public boolean isTerminating()

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

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

finalize

@Deprecated(since="9")
protected void finalize()

Устарело.

Описание скопировано из класса: Object

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

Общий контракт метода finalize заключается в том, что он вызывается, когда виртуальная машина Java определила, что к этому объекту больше нет доступа ни одному потоку, который еще не завершен, за исключением действий, предпринятых в результате финализации какого-либо другого объекта или класса, готового к финализации. Метод finalize может выполнить любое действие, включая повторную доступность этого объекта для других потоков; однако основная цель метода finalize — выполнить действия по очистке перед окончательным удалением объекта. Например, метод finalize для объекта, представляющего соединение ввода-вывода, может выполнить явные операции ввода-вывода, чтобы разорвать соединение перед окончательным удалением объекта.

Метод finalize класса Object не выполняет никаких специальных действий; он просто возвращает нормальное значение. Подклассы Object могут переопределить это определение.

Язык программирования Java не гарантирует, какой поток вызовет метод finalize для любого заданного объекта. Однако гарантируется, что поток, вызывающий finalize, не будет удерживать какие-либо видимые пользователю блокировки синхронизации при вызове finalize. Если метод finalize вызывает необработанное исключение, исключение игнорируется, и финализация этого объекта завершается.

После вызова метода finalize для объекта никаких дальнейших действий не предпринимается до тех пор, пока виртуальная машина Java снова не определит, что к этому объекту больше нет доступа ни одному потоку, который еще не завершен, включая возможные действия других объектов или классов, готовых к финализации, в этот момент объект может быть удален.

Метод finalize никогда не вызывается виртуальной машиной Java более одного раза для любого данного объекта.

Любое исключение, вызываемое методом finalize, приводит к остановке финализации этого объекта, но в остальном игнорируется.

Переопределяет:: finalize в классе Object
Примечание реализации:: Предыдущие версии этого класса имели метод finalize, который останавливал этот исполняющий сервис, но в этой версии finalize ничего не делает.
См. также:: 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 или corePoolSize больше, чем максимальный размер пула
См. также:: getCorePoolSize()

getCorePoolSize

public int getCorePoolSize()

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

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

prestartCoreThread

public boolean prestartCoreThread()

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

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

prestartAllCoreThreads

public int prestartAllCoreThreads()

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

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

allowsCoreThreadTimeOut

public boolean allowsCoreThreadTimeOut()

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

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

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

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

Параметры:: value - true если нужно истекать, иначе false
Исключения:: IllegalArgumentException - если значение равно true и текущее время ожидания не больше нуля
С момента:: 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 - время ожидания. Значение времени, равное нулю, приведет к немедленному завершению дополнительных потоков после выполнения задач.; time - единица измерения времени аргумента unit
Исключения:: 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<?>
         && ((Future<?>)r).isDone()) {
       try {
         Object result = ((Future<?>) r).get();
       } catch (CancellationException ce) {
         t = ce;
       } catch (ExecutionException ee) {
         t = ee.getCause();
       } catch (InterruptedException ie) {
         // ignore/reset
         Thread.currentThread().interrupt();
       }
     }
     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.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html