java.util.concurrent

Класс ThreadPoolExecutor

java.lang. Объект

java.util.concurrent.AbstractExecutorService

java.util.concurrent. ThreadPoolExecutor

Все Реализованные Интерфейсы:

Исполнитель, Эксекуторсервайс

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

ScheduledThreadPoolExecutor

public class ThreadPoolExecutor
extends AbstractExecutorService

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

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

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

Ядро и максимум объединяют размеры в пул

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

По требованию конструкция

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

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

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

Сохраните - живые времена

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

Организация очередей

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

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

Есть три общих стратегии организации очередей:

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

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

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

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

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

Методы рычага

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

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

Обслуживание очереди

Метод getQueue() предоставляет доступ к рабочему списку в целях контролировать и отладить. Использованию этого метода в любой другой цели строго обескураживают. Два предоставленных метода, remove(java.lang.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();
     }
   }
 }

С тех пор:

1.5

Вложенная Сводка Класса

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

Модификатор и Тип	Класс и Описание
static class	ThreadPoolExecutor. AbortPolicy Обработчик для отклоненных задач, который бросает a 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) Метод, вызванный на завершение выполнения данного Выполнимого.
void	allowCoreThreadTimeOut(boolean value) Устанавливает управление политики, могут ли базовые потоки время и завершаться, если никакие задачи не прибывают в пределах хранения - живое время, будучи замененным если нужно, когда новые задачи прибывают.
boolean	allowsCoreThreadTimeOut() Возвращает true, если этот пул позволяет базовые потоки времени и оконечный, если никакие задачи не прибывают в пределах keepAlive времени, будучи замененным если нужно, когда новые задачи прибывают.
boolean	awaitTermination(long timeout, TimeUnit unit) Блоки до всех задач завершили выполнение после запроса завершения работы, или тайм-аут происходит, или текущий поток прерывается, какой бы ни происходит сначала.
protected void	beforeExecute(Thread t, Runnable r) Метод, вызванный до выполнения данного Выполнимого в данном потоке.
void	execute(Runnable command) Выполняет данную задачу когда-то в будущем.
protected void	finalize() Вызывает shutdown когда на этого исполнителя больше не ссылаются, и у этого нет никаких потоков.
int	getActiveCount() Возвращает приблизительное количество потоков, которые активно выполняют задачи.
long	getCompletedTaskCount() Возвращает приблизительное общее количество задач, которые завершили выполнение.
int	getCorePoolSize() Возвращает базовое число потоков.
long	getKeepAliveTime(TimeUnit unit) Возвращается поток сохраняют - живое время, которое является количеством времени, которое распараллеливает сверх базового размера пула, может остаться неактивным прежде, чем быть завершенным.
int	getLargestPoolSize() Возвращает наибольшее число потоков, которые когда-либо одновременно были в пуле.
int	getMaximumPoolSize() Возвращает максимальное позволенное число потоков.
int	getPoolSize() Возвращает текущее число потоков в пуле.
BlockingQueue<Runnable>	getQueue() Возвращает очередь задачи, используемую этим исполнителем.
RejectedExecutionHandler	getRejectedExecutionHandler() Возвращает текущий обработчик для неисполнимых задач.
long	getTaskCount() Возвращает приблизительное общее количество задач, которые когда-либо планировались для выполнения.
ThreadFactory	getThreadFactory() Возвращает фабрику потока, используемую, чтобы создать новые потоки.
boolean	isShutdown() true возвратов, если этот исполнитель был выключен.
boolean	isTerminated() true возвратов, если все задачи завершились следующий выключенный.
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) Устанавливает ограничение по времени, для которого потоки могут остаться неактивными прежде, чем быть завершенным.
void	setMaximumPoolSize(int maximumPoolSize) Определяет максимальный позволенный номер потоков.
void	setRejectedExecutionHandler(RejectedExecutionHandler handler) Устанавливает новый обработчик для неисполнимых задач.
void	setThreadFactory(ThreadFactory threadFactory) Устанавливает фабрику потока, используемую, чтобы создать новые потоки.
void	shutdown() Инициирует аккуратное завершение работы, на котором выполняются ранее представленные задачи, но никакие новые задачи не будут приняты.
List<Runnable>	shutdownNow() Попытки остановить все активно выполняющиеся задачи, останавливает обработку ожидающих задач, и возвращает список задач, которые ждали выполнения.
protected void	terminated() Метод, вызванный, когда Исполнитель завершил.
Строка	toString() Возвращает строку, идентифицирующую этот пул, так же как его состояние, включая индикации относительно выполненного состояния и оцененного рабочего и количеств задачи.

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

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

Методы java.lang унаследованный от класса. Объект

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 - очередь, чтобы использовать для содержания задач прежде, чем они будут выполнены. Эта очередь будет содержать только Runnable задачи, представленные execute метод.

Броски:

IllegalArgumentException - если одно из следующего содержит:
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize

NullPointerException - если workQueue нуль

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 нуль

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 нуль

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 нуль

Деталь метода

выполниться

public void execute(Runnable command)

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

Параметры:

command - задача выполниться

Броски:

RejectedExecutionException - по усмотрению RejectedExecutionHandler, если задача не может быть принята для выполнения

NullPointerException - если command нуль

завершение работы

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 сообщаемый достаточный период после завершения работы может указать, что представленные задачи проигнорировали или подавили прерывание, заставляя этого исполнителя не должным образом завершиться.

Возвраты:

истина, завершаясь, но еще завершенный

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 - если прервано, ожидая

завершить

protected void finalize()

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

Переопределения:

finalize в классе Object

setThreadFactory

public void setThreadFactory(ThreadFactory threadFactory)

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

Параметры:

threadFactory - фабрика нового потока

Броски:

NullPointerException - если threadFactory является нулем

См. Также:

getThreadFactory()

getThreadFactory

public ThreadFactory getThreadFactory()

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

Возвраты:

фабрика текущего потока

См. Также:

setThreadFactory(java.util.concurrent.ThreadFactory)

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

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

Параметры:

handler - новый обработчик

Броски:

NullPointerException - если обработчик является нулем

См. Также:

getRejectedExecutionHandler()

getRejectedExecutionHandler

public RejectedExecutionHandler getRejectedExecutionHandler()

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

Возвраты:

текущий обработчик

См. Также:

setRejectedExecutionHandler(java.util.concurrent.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 если базовые потоки позволяются времени, еще false

С тех пор:

1.6

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

Устанавливает управление политики, могут ли базовые потоки время и завершаться, если никакие задачи не прибывают в пределах хранения - живое время, будучи замененным если нужно, когда новые задачи прибывают. Когда ложь, базовые потоки никогда не завершаются из-за нехватки входящих задач. Когда истина, то же самое сохраняет - живая политика, применяющаяся к неосновным потокам, применяется также к базовым потокам. Чтобы избежать непрерывной замены потока, хранения - живое время должно быть больше чем нуль, устанавливая 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 - время, чтобы ожидать. Временная стоимость нуля заставит избыточные потоки сразу завершиться после выполняющихся задач.

unit - единица измерения времени time параметр

Броски:

IllegalArgumentException - если time меньше чем нуль или если time нуль и allowsCoreThreadTimeOut

См. Также:

getKeepAliveTime(java.util.concurrent.TimeUnit)

getKeepAliveTime

public long getKeepAliveTime(TimeUnit unit)

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

Параметры:

unit - требуемая единица измерения времени результата

Возвраты:

ограничение по времени

См. Также:

setKeepAliveTime(long, java.util.concurrent.TimeUnit)

getQueue

public BlockingQueue<Runnable> getQueue()

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

Возвраты:

очередь задачи

удалить

public boolean remove(Runnable task)

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

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

Параметры:

task - задача удалить

Возвраты:

истина, если задача была удалена

чистка

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)

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

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

Параметры:

t - поток, который выполнит задачу r

r - задача, которая будет выполняться

afterExecute

protected void afterExecute(Runnable r,
                Throwable t)

Метод, вызванный на завершение выполнения данного Выполнимого. Этот метод вызывается потоком, который выполнил задачу. Если ненуль, Throwable является непойманным RuntimeException или Error то вызванное выполнение, чтобы завершиться резко.

Эта реализация ничего не делает, но может быть настроена в подклассах. Отметьте: Чтобы должным образом вложить многократный overridings, подклассы должны обычно вызвать 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 - выполнимое, которое завершилось

t - исключение, которое вызвало завершение, или нуль если выполнение, завершаемое обычно

завершенный

protected void terminated()

Метод, вызванный, когда Исполнитель завершил. Реализация по умолчанию ничего не делает. Отметьте: Чтобы должным образом вложить многократный overridings, подклассы должны обычно вызвать super.terminated в пределах этого метода.