Spec-Zone .ru
спецификации, руководства, описания, API
|
public class ThreadPoolExecutor extends AbstractExecutorService
ExecutorService
это выполняет каждую представленную задачу, используя один возможно из нескольких объединенных в пул потоков, обычно сконфигурированное использование Executors
методы фабрики. Пулы потоков рассматривают две различных проблемы: они обычно обеспечивают улучшенную производительность, выполняя большие количества асинхронных задач, из-за уменьшенных издержек вызова на задачу, и они обеспечивают средство ограничения и управления ресурсами, включая потоки, использованные, выполняя набор задач. Каждый ThreadPoolExecutor
также поддерживает немного основной статистики, такой как число завершенных задач.
Чтобы быть полезным через широкий диапазон контекстов, этот class обеспечивает много корректируемых параметров и рычагов расширяемости. Однако, программистов убеждают использовать более удобное Executors
методы фабрики Executors.newCachedThreadPool()
(неограниченный пул потоков, с автоматическим восстановлением потока), Executors.newFixedThreadPool(int)
(пул потоков фиксированного размера) и Executors.newSingleThreadExecutor()
(единственный фоновый поток), которые предварительно конфигурируют настройки для наиболее распространенных сценариев использования. Иначе, используйте следующее руководство, вручную конфигурируя и настраивая этот class:
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()
. Вы, вероятно, хотите предварительно запустить потоки, если Вы создаете пул с непустой очередью. ThreadFactory
. Если не иначе определенный, a Executors.defaultThreadFactory()
используется, который создает потоки ко всем быть в том же самом ThreadGroup
и с тем же самым NORM_PRIORITY
приоритет и состояние недемона. Предоставляя различный ThreadFactory, можно изменить имя потока, группу потока, приоритет, состояние демона, и т.д. Если a ThreadFactory
сбои, чтобы создать поток когда спрошено, возвращая нуль из newThread
, исполнитель будет продолжать, но не мог бы быть в состоянии выполнить любые задачи. Потоки должны обладать "modifyThread" RuntimePermission
. Если рабочие потоки или другие потоки, используя пул не обладают этим разрешением, обслуживание может быть ухудшено: изменения конфигурации, возможно, не вступают в силу своевременно, и пул завершения работы может остаться в состоянии, в котором завершение возможно, но не завершенное.getKeepAliveTime(java.util.concurrent.TimeUnit)
). Это обеспечивает средство сокращения потребления ресурсов, когда пул активно не используется. Если пул станет более активным позже, то новые потоки будут созданы. Этот параметр может также быть изменен, динамически используя метод setKeepAliveTime(long, java.util.concurrent.TimeUnit)
. Используя значение Long.MAX_VALUE
TimeUnit.NANOSECONDS
эффективно отключает неактивные потоки от когда-либо завершения до выключенного. По умолчанию хранение - живая политика применяется только, когда есть больше чем corePoolSizeThreads. Но метод allowCoreThreadTimeOut(boolean)
может использоваться, чтобы применить эту политику тайм-аута к базовым потокам также, пока значение keepAliveTime является ненулевым. BlockingQueue
может использоваться, чтобы передать и содержать представленные задачи. Использование этой очереди взаимодействует с калибровкой пула: SynchronousQueue
это вручает от задач потокам, иначе не содержа их. Здесь, попытка поставить задачу в очередь перестанет работать, если никакие потоки не будут сразу доступны, чтобы выполнить ее, таким образом, новый поток будет создан. Эта политика избегает тупиков, обрабатывая наборы запросов, у которых могли бы быть внутренние зависимости. Прямые handoffs обычно требуют, чтобы неограниченный maximumPoolSizes избежал отклонения новых представленных задач. Это поочередно допускает возможность неограниченного роста потока, когда команды продолжают прибывать в среднем быстрее, чем они могут быть обработаны. LinkedBlockingQueue
без предопределенной емкости), вызовет новые задачи ожидать в очереди, когда все потоки corePoolSize заняты. Таким образом, не больше, чем corePoolSize потоки будет когда-либо создаваться. (И значение maximumPoolSize поэтому не имеет никакого эффекта.) Это может быть соответствующим, когда каждая задача абсолютно независима от других, таким образом, задачи не могут влиять на каждое выполнение других; например, в сервере веб-страницы. В то время как этот стиль организации очередей может быть полезным в сглаживании переходных пакетов запросов, это допускает возможность неограниченного роста рабочего списка, когда команды продолжают прибывать в среднем быстрее, чем они могут быть обработаны. ArrayBlockingQueue
) помогает предотвратить исчерпание ресурса когда использующийся с конечным maximumPoolSizes, но может быть более трудным настроить и управлять. Между размерами очереди и максимальными размерами пула можно балансировать друг для друга: Используя многочисленные очереди и маленькие пулы минимизирует использование ЦП, ресурсы ОС, и издержки контекстного переключения, но может привести к искусственно низкой пропускной способности. Если задачи часто блокируют (например, если они - связанный ввод-вывод), система может быть в состоянии запланировать время для большего количества потоков, чем Вы иначе позволяете. Использование малочисленных очередей обычно требует больших размеров пула, который сохраняет ЦП более занятыми, но может встретиться с недопустимыми издержками планирования, которые также уменьшают пропускную способность. execute(java.lang.Runnable)
будет отклонен, когда Исполнитель был выключен, и также когда Исполнитель использует конечные границы и для максимальных потоков и для емкости рабочего списка, и насыщается. В любом случае, execute
метод вызывает RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)
метод RejectedExecutionHandler
. Обеспечиваются четыре предопределенных политики обработчика: ThreadPoolExecutor.AbortPolicy
, обработчик бросает время выполнения RejectedExecutionException
на отклонение. ThreadPoolExecutor.CallerRunsPolicy
, поток, который вызывает execute
непосредственно выполняет задачу. Это обеспечивает простой механизм управления обратной связи, который замедлит уровень, что представляются новые задачи. ThreadPoolExecutor.DiscardPolicy
, задача, которая не может быть выполнена, просто отбрасывается. 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 переопределяет один или больше защищенных методов рычага. Например, вот подкласс, который добавляет простую опцию паузы/резюме:
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();
}
}
}
Модификатор и Тип | Класс и Описание |
---|---|
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()
Возвращает строку, идентифицирующую этот пул, так же как его состояние, включая индикации относительно выполненного состояния и оцененного рабочего и количеств задачи.
|
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit
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
нуль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
нуль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
нуль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 менеджера безопасности лишает доступа.public List<Runnable> shutdownNow()
Этот метод не ожидает активного выполнения задач завершиться. Использовать awaitTermination
сделать это.
Нет никаких гарантий вне попыток максимальных усилий прекратить обрабатывать активно выполняющиеся задачи. Эта реализация отменяет задачи через Thread.interrupt()
, таким образом, любая задача, которая не в состоянии ответить на прерывания, никогда, возможно, не завершается.
SecurityException
- если менеджер безопасности существует, и завершающий работу этого ExecutorService может управлять потоками, которые вызывающей стороне не разрешают изменить, потому что это не содержит RuntimePermission
("modifyThread"), или метод checkAccess менеджера безопасности лишает доступа.public boolean isShutdown()
ExecutorService
public boolean isTerminating()
shutdown()
или shutdownNow()
но не полностью завершился. Этот метод может быть полезным для отладки. Возврат true
сообщаемый достаточный период после завершения работы может указать, что представленные задачи проигнорировали или подавили прерывание, заставляя этого исполнителя не должным образом завершиться.public boolean isTerminated()
ExecutorService
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
ExecutorService
timeout
- максимальное время, чтобы ожидатьunit
- единица измерения времени параметра тайм-аутаInterruptedException
- если прервано, ожидаяprotected void finalize()
shutdown
когда на этого исполнителя больше не ссылаются, и у этого нет никаких потоков.finalize
в class Object
WeakReference
, PhantomReference
public void setThreadFactory(ThreadFactory threadFactory)
threadFactory
- фабрика нового потокаNullPointerException
- если threadFactory является нулемgetThreadFactory()
public ThreadFactory getThreadFactory()
setThreadFactory(java.util.concurrent.ThreadFactory)
public void setRejectedExecutionHandler(RejectedExecutionHandler handler)
handler
- новый обработчикNullPointerException
- если обработчик является нулемgetRejectedExecutionHandler()
public RejectedExecutionHandler getRejectedExecutionHandler()
setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler)
public void setCorePoolSize(int corePoolSize)
corePoolSize
- новый базовый размерIllegalArgumentException
- если corePoolSize < 0
getCorePoolSize()
public int getCorePoolSize()
setCorePoolSize(int)
public boolean prestartCoreThread()
false
если все базовые потоки были уже запущены.true
если поток был запущенpublic int prestartAllCoreThreads()
public boolean allowsCoreThreadTimeOut()
true
если базовые потоки позволяются времени, еще false
public void allowCoreThreadTimeOut(boolean value)
true
. Этот метод нужно вообще вызвать прежде, чем пул активно используется.value
- true
если должен время, еще false
IllegalArgumentException
- если значение true
и текущее хранение - живое время не больше чем нульpublic void setMaximumPoolSize(int maximumPoolSize)
maximumPoolSize
- новый максимумIllegalArgumentException
- если новый максимум меньше чем или равен нулю, или меньше чем базовый размер пулаgetMaximumPoolSize()
public int getMaximumPoolSize()
setMaximumPoolSize(int)
public void setKeepAliveTime(long time, TimeUnit unit)
time
- время, чтобы ожидать. Временная стоимость нуля заставит избыточные потоки сразу завершиться после выполняющихся задач.unit
- единица измерения времени time
параметрIllegalArgumentException
- если time
меньше чем нуль или если time
нуль и allowsCoreThreadTimeOut
getKeepAliveTime(java.util.concurrent.TimeUnit)
public long getKeepAliveTime(TimeUnit unit)
unit
- требуемая единица измерения времени результатаsetKeepAliveTime(long, java.util.concurrent.TimeUnit)
public BlockingQueue<Runnable> getQueue()
public boolean remove(Runnable task)
Этот метод может быть полезным как одна часть схемы отмены. Это может быть не в состоянии удалить задачи, которые были преобразованы в другие формы прежде, чем быть помещенным во внутреннюю очередь. Например, задача ввела использование submit
мог бы быть преобразован в форму, которая поддерживает Future
состояние. Однако, в таких случаях, методе purge()
может использоваться, чтобы удалить тот Фьючерс, который был отменен.
task
- задача удалитьpublic void purge()
Future
задачи, которые были отменены. Этот метод может быть полезным как работа восстановления хранения, которая не оказывает никакое другое влияние на функциональность. Отмененные задачи никогда не выполняются, но могут накопиться в рабочих списках, пока рабочие потоки не могут активно удалить их. Вызов этого метода вместо этого пытается удалить их теперь. Однако, этот метод может быть не в состоянии удалить задачи в присутствии интерференции другими потоками.public int getPoolSize()
public int getActiveCount()
public int getLargestPoolSize()
public long getTaskCount()
public long getCompletedTaskCount()
public String toString()
protected void beforeExecute(Thread t, Runnable r)
t
это выполнит задачу r
, и может использоваться, чтобы повторно инициализировать ThreadLocals, или выполнить журналирование. Эта реализация ничего не делает, но может быть настроена в подклассах. Отметьте: Чтобы должным образом вложить многократный overridings, подклассы должны обычно вызвать super.beforeExecute
в конце этого метода.
t
- поток, который выполнит задачу r
r
- задача, которая будет выполнятьсяprotected void afterExecute(Runnable r, Throwable t)
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()
super.terminated
в пределах этого метода.
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2013, Oracle и/или его филиалы. Все права защищены.
Проект сборка-b92