Spec-Zone.ru › OpenJDK 27

Класс ForkJoinPool

java.lang.Object
java.util.concurrent.AbstractExecutorService
java.util.concurrent.ForkJoinPool
Все реализованные интерфейсы:
AutoCloseable, Executor, ExecutorService, ScheduledExecutorService
public class ForkJoinPool extends AbstractExecutorService implements ScheduledExecutorService
ExecutorService для выполнения задач ForkJoinTask. ForkJoinPool предоставляет точку входа для отправки задач клиентами, не являющимися ForkJoinTask, а также операции управления и мониторинга.

ForkJoinPool отличается от других видов ExecutorService главным образом тем, что использует work-stealing (похищение задач): все потоки в пуле пытаются найти и выполнить задачи, отправленные в пул и/или созданные другими активными задачами (в конечном счёте блокируясь в ожидании работы, если её нет). Это обеспечивает эффективную обработку, когда большинство задач порождают другие подзадачи (как и большинство ForkJoinTask), а также когда множество небольших задач отправляется в пул внешними клиентами. В частности, при установке параметра asyncMode в значение true в конструкторах ForkJoinPool могут быть также подходящими для использования с задачами в стиле событий, которые никогда не объединяются. Все рабочие потоки инициализируются с установленным в true значением Thread.isDaemon().

Доступен статический commonPool(), подходящий для большинства приложений. Общий пул используется любой задачей ForkJoinTask, которая явно не отправлена в указанный пул. Использование общего пула обычно сокращает потребление ресурсов (его потоки постепенно освобождаются в периоды бездействия и восстанавливаются при последующем использовании).

Для приложений, которым нужны отдельные или настраиваемые пулы, можно создать ForkJoinPool с заданным уровнем параллелизма; по умолчанию он равен числу доступных процессоров. Пул пытается поддерживать достаточное количество активных (или доступных) потоков, динамически добавляя, приостанавливая или возобновляя внутренние рабочие потоки, даже если некоторые задачи ожидают объединения с другими. Однако такие корректировки не гарантируются при блокирующем вводе-выводе или другой неуправляемой синхронизации. Вложенный интерфейс ForkJoinPool.ManagedBlocker позволяет расширить набор поддерживаемых видов синхронизации. Политики по умолчанию можно переопределить с помощью конструктора с параметрами, соответствующими описанным в классе ThreadPoolExecutor.

Помимо методов выполнения задач и управления жизненным циклом, этот класс предоставляет методы проверки состояния (например, getStealCount()), предназначенные для помощи в разработке, настройке и мониторинге приложений fork/join. Кроме того, метод toString() возвращает сведения о состоянии пула в удобной для неформального мониторинга форме.

Как и в случае с другими ExecutorService, существуют три основных метода выполнения задач, перечисленные в следующей таблице. Они предназначены прежде всего для клиентов, которые ещё не участвуют в вычислениях fork/join в текущем пуле. Основные формы этих методов принимают экземпляры ForkJoinTask, но перегруженные формы также позволяют смешивать выполнение задач на основе обычных Runnable или Callable. Однако уже выполняющиеся в пуле задачи обычно должны использовать формы для вызова из вычисления, перечисленные в таблице, если только это не асинхронные задачи в стиле событий, которые обычно не объединяются; в этом случае выбор метода не имеет большого значения.

Сводка методов выполнения задач
Вызов из клиента, не участвующего в fork/join Вызов из вычисления fork/join
Запланировать асинхронное выполнение execute(ForkJoinTask) ForkJoinTask.fork()
Дождаться результата и получить его invoke(ForkJoinTask) ForkJoinTask.invoke()
Запланировать выполнение и получить Future submit(ForkJoinTask) ForkJoinTask.fork() (ForkJoinTask — это Future)

Кроме того, этот класс поддерживает методы ScheduledExecutorService для отложенного или периодического выполнения задач, а также метод submitWithTimeout(Callable, long, TimeUnit, Consumer) для отмены задач, выполнение которых занимает слишком много времени. Запланированные функции или действия могут создавать и вызывать другие ForkJoinTask. Отложенные действия становятся доступными для выполнения и ведут себя как обычные отправленные задачи по истечении задержки. Методы планирования возвращают ForkJoinTask, реализующие интерфейс ScheduledFuture. Исчерпание ресурсов после первоначальной отправки приводит к отмене задачи. При использовании методов, зависящих от времени, политики завершения соответствуют политикам по умолчанию класса ScheduledThreadPoolExecutor: при вызове shutdown() существующие периодические задачи больше не выполняются, а пул завершается, когда становится бездействующим и завершается выполнение существующих отложенных задач. Метод cancelDelayedTasksOnShutdown() можно использовать для отключения всех отложенных задач при завершении работы, а метод shutdownNow() — для безусловного запуска завершения работы пула. Методы мониторинга, такие как getQueuedTaskCount(), не учитывают запланированные задачи, выполнение которых ещё не разрешено; их количество отдельно возвращает метод getDelayedTaskCount().

Параметры, используемые для создания общего пула, можно задать с помощью следующих системных свойств:

  • java.util.concurrent.ForkJoinPool.common.parallelism — уровень параллелизма, неотрицательное целое число. Использовать не рекомендуется. Вместо этого используйте setParallelism(int).
  • java.util.concurrent.ForkJoinPool.common.threadFactory — имя класса ForkJoinPool.ForkJoinWorkerThreadFactory. Для загрузки этого класса используется системный загрузчик классов.
  • java.util.concurrent.ForkJoinPool.common.exceptionHandler — имя класса Thread.UncaughtExceptionHandler. Для загрузки этого класса используется системный загрузчик классов.
  • java.util.concurrent.ForkJoinPool.common.maximumSpares — максимальное число дополнительных потоков, разрешённых для поддержания целевого уровня параллелизма (по умолчанию 256).
Если фабрика потоков не указана с помощью системного свойства, общий пул использует фабрику, которая применяет системный загрузчик классов в качестве контекстного загрузчика классов потока. При возникновении ошибок при настройке этих параметров используются значения по умолчанию. Использование потоков можно отключить с помощью фабрики, которая может возвращать null; в этом случае некоторые задачи могут так и не выполниться. Хотя установить для свойства параллелизма значение ноль возможно, настоятельно не рекомендуется этого делать: при наличии задач, изначально являющихся асинхронными, это значение может быть переопределено внутри системы.
Примечание по реализации:
Эта реализация ограничивает максимальное число работающих потоков значением 32767. Попытки создать пулы, в которых число потоков превышает это ограничение, приводят к IllegalArgumentException. Кроме того, эта реализация отклоняет отправленные задачи (то есть выбрасывает RejectedExecutionException) только в том случае, если пул завершает работу или внутренние ресурсы исчерпаны.
Начиная с версии:
1.7

Краткое описание вложенных классов

Модификатор и тип Класс Описание
static interface  ForkJoinPool.ForkJoinWorkerThreadFactory
Фабрика для создания новых ForkJoinWorkerThread.
static interface  ForkJoinPool.ManagedBlocker
Интерфейс для расширения управляемого параллелизма задач, выполняющихся в ForkJoinPool.

Краткое описание полей

Модификатор и тип Поле Описание
static final ForkJoinPool.ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory
Создаёт новый ForkJoinWorkerThread.

Краткое описание конструкторов

Конструктор Описание
ForkJoinPool()
Создаёт ForkJoinPool с уровнем параллелизма, равным Runtime.availableProcessors(), используя значения по умолчанию для всех остальных параметров (см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(int parallelism)
Создаёт ForkJoinPool с указанным уровнем параллелизма, используя значения по умолчанию для всех остальных параметров (см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode)
Создаёт ForkJoinPool с заданными параметрами (для остальных используются значения по умолчанию — см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode, int corePoolSize, int maximumPoolSize, int minimumRunnable, Predicate<? super ForkJoinPool> saturate, long keepAliveTime, TimeUnit unit)
Создаёт ForkJoinPool с заданными параметрами.

Краткое описание методов

Модификатор и тип Метод Описание
boolean awaitQuiescence(long timeout, TimeUnit unit)
Если вызван задачей ForkJoinTask, выполняющейся в этом пуле, по действию эквивалентен ForkJoinTask.helpQuiesce().
boolean awaitTermination(long timeout, TimeUnit unit)
Блокирует выполнение до тех пор, пока все задачи не завершатся после запроса на завершение работы, не истечёт время ожидания или не будет прерван текущий поток — в зависимости от того, что произойдёт раньше.
void cancelDelayedTasksOnShutdown()
Указывает, что запланированные задачи, которые не выполняются и для выполнения которых ещё не наступило время, не будут выполняться и будут отменены при вызове shutdown() (если только этот пул не является commonPool(), который никогда не завершает работу).
void close()
Если это не commonPool(), инициирует упорядоченное завершение работы, при котором ранее отправленные задачи выполняются, но новые задачи не принимаются; затем ожидает завершения всех задач и исполнителя.
static ForkJoinPool commonPool()
Возвращает экземпляр общего пула.
protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c)
Удаляет из очередей планирования все доступные невыполненные отправленные и разветвлённые задачи и добавляет их в указанную коллекцию, не изменяя их состояние выполнения.
void execute(Runnable task)
Выполняет указанную команду в некоторый момент в будущем.
void execute(ForkJoinTask<?> task)
Организует (асинхронное) выполнение указанной задачи.
<T> ForkJoinTask<T> externalSubmit(ForkJoinTask<T> task)
Отправляет указанную задачу так, как если бы она была отправлена клиентом, не являющимся ForkJoinTask.
int getActiveThreadCount()
Возвращает оценку числа потоков, которые в данный момент похищают или выполняют задачи.
boolean getAsyncMode()
Возвращает true, если в этом пуле используется локальный режим планирования «первым поступил — первым обслужен» для разветвлённых задач, которые никогда не объединяются.
static int getCommonPoolParallelism()
Возвращает целевой уровень параллелизма общего пула.
long getDelayedTaskCount()
Возвращает оценку количества отложенных (включая периодические) задач, запланированных в этом пуле, выполнение которых ещё не готово начаться.
ForkJoinPool.ForkJoinWorkerThreadFactory getFactory()
Возвращает фабрику, используемую для создания новых рабочих потоков.
int getParallelism()
Возвращает целевой уровень параллелизма этого пула.
int getPoolSize()
Возвращает число рабочих потоков, которые были запущены, но ещё не завершились.
int getQueuedSubmissionCount()
Возвращает оценку числа задач, отправленных в этот пул, выполнение которых ещё не началось.
long getQueuedTaskCount()
Возвращает оценку общего числа задач, которые в данный момент находятся в очередях рабочих потоков (за исключением задач, отправленных в пул, выполнение которых ещё не началось).
int getRunningThreadCount()
Возвращает оценку числа рабочих потоков, не заблокированных в ожидании объединения задач или другой управляемой синхронизации.
long getStealCount()
Возвращает оценку общего числа завершённых задач, выполненных потоком, отличным от потока, отправившего эти задачи.
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
Возвращает обработчик внутренних рабочих потоков, завершившихся из-за неустранимых ошибок, возникших при выполнении задач.
boolean hasQueuedSubmissions()
Возвращает true, если в этот пул отправлены задачи, выполнение которых ещё не началось.
<T> T invoke(ForkJoinTask<T> task)
Выполняет указанную задачу и возвращает её результат после завершения.
<T> List<Future<T>> invokeAllUninterruptibly(Collection<? extends Callable<T>> tasks)
Версия invokeAll, не реагирующая на прерывания.
boolean isQuiescent()
Возвращает true, если в данный момент все рабочие потоки бездействуют.
boolean isShutdown()
Возвращает true, если работа этого пула была завершена.
boolean isTerminated()
Возвращает true, если после завершения работы все задачи были выполнены.
boolean isTerminating()
Возвращает true, если процесс завершения начался, но ещё не завершился.
<T> ForkJoinTask<T> lazySubmit(ForkJoinTask<T> task)
Отправляет указанную задачу, не гарантируя, что она в конечном счёте будет выполнена при отсутствии доступных активных потоков.
static void managedBlock(ForkJoinPool.ManagedBlocker blocker)
Выполняет указанную задачу, которая может блокироваться.
protected ForkJoinTask<?> pollSubmission()
Удаляет и возвращает следующую невыполненную отправленную задачу, если таковая имеется.
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
Отправляет одноразовую задачу, выполнение которой становится возможным после указанной задержки.
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
Отправляет одноразовую задачу, возвращающую значение и становящуюся доступной для выполнения после указанной задержки.
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
Отправляет периодическое действие, выполнение которого впервые становится возможным после указанной начальной задержки, а затем повторяется с указанным периодом; то есть выполнение начнётся через initialDelay, затем через initialDelay + period, затем через initialDelay + 2 * period и так далее.
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
Отправляет периодическое действие, выполнение которого впервые становится возможным после указанной начальной задержки, а затем повторяется с указанной задержкой между завершением одного выполнения и началом следующего.
int setParallelism(int size)
Изменяет целевой уровень параллелизма этого пула, управляя дальнейшим созданием, использованием и завершением рабочих потоков.
void shutdown()
При необходимости инициирует упорядоченное завершение работы, при котором ранее отправленные задачи выполняются, но новые задачи не принимаются.
List<Runnable> shutdownNow()
При необходимости пытается отменить и/или остановить все задачи и отклонять все последующие отправленные задачи.
ForkJoinTask<?> submit(Runnable task)
Отправляет задачу Runnable для выполнения и возвращает Future, представляющий эту задачу.
<T> ForkJoinTask<T> submit(Runnable task, T result)
Отправляет задачу Runnable для выполнения и возвращает Future, представляющий эту задачу.
<T> ForkJoinTask<T> submit(Callable<T> task)
Отправляет задачу, возвращающую значение, для выполнения и возвращает Future, представляющий ожидающие результаты задачи.
<T> ForkJoinTask<T> submit(ForkJoinTask<T> task)
Отправляет ForkJoinTask для выполнения.
<V> ForkJoinTask<V> submitWithTimeout(Callable<V> callable, long timeout, TimeUnit unit, Consumer<? super ForkJoinTask<V>> timeoutAction)
Отправляет задачу, выполняющую указанную функцию, и отменяет её или выполняет указанное действие при истечении времени ожидания, если задача не завершилась за отведённый период.
String toString()
Возвращает строку, идентифицирующую этот пул и его состояние, включая сведения о состоянии выполнения, уровне параллелизма, а также количестве рабочих потоков и задач.

Методы, объявленные в классе AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor
Модификатор и тип Метод Описание
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
Выполняет указанные задачи и возвращает список Future с их состояниями и результатами после завершения всех задач.
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
Выполняет указанные задачи и возвращает список Future с их состояниями и результатами после завершения всех задач или истечения времени ожидания — в зависимости от того, что произойдёт раньше.
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
Выполняет указанные задачи и возвращает результат одной из них, завершившейся успешно (то есть без исключения), если такая задача есть.
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
Выполняет указанные задачи и возвращает результат одной из них, завершившейся успешно (то есть без исключения), если такая задача есть до истечения указанного времени ожидания.
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value)
Возвращает RunnableFuture для указанного объекта Runnable и значения по умолчанию.
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable)
Возвращает RunnableFuture для указанной задачи Callable.

Методы, объявленные в классе Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
Модификатор и тип Метод Описание
protected Object clone()
Создаёт и возвращает копию этого объекта.
boolean equals(Object obj)
Указывает, является ли другой объект «равным» этому объекту.
protected void finalize()
Устарело, будет удалено: этот элемент API может быть удалён в будущей версии.
Финализация объявлена устаревшей и может быть удалена в одном из будущих выпусков.
final Class<?> getClass()
Возвращает класс времени выполнения этого Object.
int hashCode()
Возвращает хеш-код этого объекта.
final void notify()
Пробуждает один поток, ожидающий на мониторе этого объекта.
final void notifyAll()
Пробуждает все потоки, ожидающие на мониторе этого объекта.
final void wait()
Заставляет текущий поток ожидать пробуждения, обычно вследствие вызова notify или interrupt.
final void wait(long timeoutMillis)
Заставляет текущий поток ожидать пробуждения, обычно вследствие вызова notify или interrupt, либо до истечения указанного промежутка реального времени.
final void wait(long timeoutMillis, int nanos)
Заставляет текущий поток ожидать пробуждения, обычно вследствие вызова notify или interrupt, либо до истечения указанного промежутка реального времени.

Подробное описание полей

defaultForkJoinWorkerThreadFactory

public static final ForkJoinPool.ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory
Создает новый ForkJoinWorkerThread. Эта фабрика используется, если она не переопределена в конструкторах ForkJoinPool.

Подробное описание конструкторов

ForkJoinPool

public ForkJoinPool()
Создает ForkJoinPool с параллелизмом, равным Runtime.availableProcessors(), используя значения по умолчанию для всех остальных параметров (см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).

ForkJoinPool

public ForkJoinPool(int parallelism)
Создает ForkJoinPool с указанным уровнем параллелизма, используя значения по умолчанию для всех остальных параметров (см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
Параметры:
parallelism — уровень параллелизма
Исключения:
IllegalArgumentException — если параллелизм меньше или равен нулю либо превышает ограничение реализации

ForkJoinPool

public ForkJoinPool(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode)
Создает ForkJoinPool с указанными параметрами (для остальных используются значения по умолчанию — см. ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
Параметры:
parallelism — уровень параллелизма. Чтобы использовать значение по умолчанию, укажите Runtime.availableProcessors().
factory — фабрика для создания новых потоков. Чтобы использовать значение по умолчанию, укажите defaultForkJoinWorkerThreadFactory.
handler — обработчик внутренних рабочих потоков, завершающихся из-за невосстановимых ошибок, возникших при выполнении задач. Чтобы использовать значение по умолчанию, укажите null.
asyncMode — если значение равно true, для разделенных задач, которые никогда не присоединяются, устанавливается локальный режим планирования FIFO. Этот режим может быть предпочтительнее стандартного локального режима на основе стека в приложениях, где рабочие потоки обрабатывают только асинхронные задачи событийного типа. Чтобы использовать значение по умолчанию, укажите false.
Исключения:
IllegalArgumentException — если параллелизм меньше или равен нулю либо превышает ограничение реализации
NullPointerException — если фабрика равна null

ForkJoinPool

public ForkJoinPool(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode, int corePoolSize, int maximumPoolSize, int minimumRunnable, Predicate<? super ForkJoinPool> saturate, long keepAliveTime, TimeUnit unit)
Создает ForkJoinPool с указанными параметрами.
Параметры:
parallelism — уровень параллелизма. Чтобы использовать значение по умолчанию, укажите Runtime.availableProcessors().
factory — фабрика для создания новых потоков. Чтобы использовать значение по умолчанию, укажите defaultForkJoinWorkerThreadFactory.
handler — обработчик внутренних рабочих потоков, завершающихся из-за невосстановимых ошибок, возникших при выполнении задач. Чтобы использовать значение по умолчанию, укажите null.
asyncMode — если значение равно true, для разделенных задач, которые никогда не присоединяются, устанавливается локальный режим планирования FIFO. Этот режим может быть предпочтительнее стандартного локального режима на основе стека в приложениях, где рабочие потоки обрабатывают только асинхронные задачи событийного типа. Чтобы использовать значение по умолчанию, укажите false.
corePoolSize — игнорируется: использовался в предыдущих версиях этого класса, но больше не применяется. Использование 0 обеспечивает совместимость между версиями.
maximumPoolSize — максимальное допустимое количество потоков. При достижении этого максимума попытки заменить заблокированные потоки завершаются неудачей. (Однако это значение может временно превышаться, поскольку создание и завершение разных потоков могут происходить одновременно и управляться указанной фабрикой потоков.) Чтобы задать то же значение, которое используется по умолчанию для общего пула, укажите 256 плюс уровень parallelism. (По умолчанию общий пул допускает не более 256 резервных потоков.) Значение (например, Integer.MAX_VALUE), превышающее общий предел потоков, установленный реализацией, действует так же, как этот предел (используемый по умолчанию).
minimumRunnable — минимальное допустимое количество основных потоков, не заблокированных вызовом join или ForkJoinPool.ManagedBlocker. Для обеспечения прогресса, если недостаточно незаблокированных потоков и могут существовать невыполненные задачи, создаются новые потоки — вплоть до указанного значения maximumPoolSize. Чтобы использовать значение по умолчанию, укажите 1, обеспечивающее непрерывную работу. Более высокое значение может повысить пропускную способность при наличии заблокированных операций, но может и не повысить ее из-за дополнительных накладных расходов. Значение 0 может быть допустимым, если отправленные задачи не имеют зависимостей, требующих дополнительных потоков.
saturate — если значение не равно null, предикат, вызываемый при попытках создать количество потоков, превышающее общий допустимый максимум. По умолчанию, когда поток собирается заблокироваться при вызове join или ForkJoinPool.ManagedBlocker, но не может быть заменен, поскольку это привело бы к превышению maximumPoolSize, выбрасывается RejectedExecutionException. Однако если этот предикат возвращает true, исключение не выбрасывается, поэтому пул продолжает работать с количеством выполняемых потоков меньше целевого, что может не обеспечить прогресс.
keepAliveTime — время с момента последнего использования, по истечении которого поток завершается (а позднее при необходимости заменяется). Чтобы использовать значение по умолчанию, укажите 60, TimeUnit.SECONDS.
unit — единица измерения времени для аргумента keepAliveTime
Исключения:
IllegalArgumentException — если параллелизм меньше или равен нулю либо превышает ограничение реализации, если maximumPoolSize меньше параллелизма или если keepAliveTime меньше или равен нулю.
NullPointerException — если фабрика равна null
Начиная с версии:
9

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

commonPool

public static ForkJoinPool commonPool()
Возвращает экземпляр общего пула. Этот пул создается статически; попытки вызвать shutdown() или shutdownNow() не влияют на его состояние выполнения. Однако этот пул и любая выполняющаяся в нем обработка автоматически завершаются при вызове System.exit(int) программы. Программа, которой требуется завершить обработку асинхронных задач до своего завершения, должна вызвать commonPool().awaitQuiescence перед выходом.
Возвращает:
экземпляр общего пула
Начиная с версии:
1.8

invoke

public <T> T invoke(ForkJoinTask<T> task)
Выполняет указанную задачу и возвращает ее результат по завершении. Если при вычислении возникает непроверяемое исключение или ошибка, они повторно выбрасываются как результат этого вызова. Повторно выброшенные исключения ведут себя так же, как обычные исключения, но по возможности содержат трассировки стека (например, отображаемые с помощью ex.printStackTrace()) как текущего потока, так и потока, в котором фактически возникло исключение; как минимум содержится трассировка последнего.
Параметры типа:
T — тип результата задачи
Параметры:
task — задача
Возвращает:
результат задачи
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

execute

public void execute(ForkJoinTask<?> task)
Планирует асинхронное выполнение указанной задачи.
Параметры:
task — задача
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

execute

public void execute(Runnable task)
Описание скопировано из интерфейса: Executor
Выполняет указанную команду в будущем. В зависимости от реализации Executor команда может выполняться в новом потоке, в потоке из пула или в вызывающем потоке.
Определено в:
execute в интерфейсе Executor
Параметры:
task — выполняемая задача
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

submit

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task)
Отправляет ForkJoinTask на выполнение.
Требования к реализации:
Этот метод эквивалентен externalSubmit(ForkJoinTask), если его вызывает поток, не принадлежащий этому пулу.
Параметры типа:
T — тип результата задачи
Параметры:
task — задача для отправки
Возвращает:
задачу
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

submit

public <T> ForkJoinTask<T> submit(Callable<T> task)
Описание скопировано из интерфейса: ExecutorService
Отправляет на выполнение задачу, возвращающую значение, и возвращает Future, представляющий ожидающий результат задачи. Метод get объекта Future вернет результат задачи после ее успешного завершения.

Если требуется немедленно заблокировать выполнение в ожидании задачи, можно использовать конструкции вида result = exec.submit(aCallable).get();

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

Определено в:
submit в интерфейсе ExecutorService
Переопределяет:
submit в классе AbstractExecutorService
Параметры типа:
T — тип результата задачи
Параметры:
task — задача для отправки
Возвращает:
Future, представляющий ожидающее завершения задачи
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

submit

public <T> ForkJoinTask<T> submit(Runnable task, T result)
Описание скопировано из интерфейса: ExecutorService
Отправляет задачу Runnable на выполнение и возвращает Future, представляющий эту задачу. Метод get объекта Future вернет указанный результат после успешного завершения.
Определено в:
submit в интерфейсе ExecutorService
Переопределяет:
submit в классе AbstractExecutorService
Параметры типа:
T — тип результата
Параметры:
task — задача для отправки
result — возвращаемый результат
Возвращает:
Future, представляющий ожидающее завершения задачи
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

submit

public ForkJoinTask<?> submit(Runnable task)
Описание скопировано из интерфейса: ExecutorService
Отправляет задачу Runnable на выполнение и возвращает Future, представляющий эту задачу. Метод get объекта Future вернет null после успешного завершения.
Определено в:
submit в интерфейсе ExecutorService
Переопределяет:
submit в классе AbstractExecutorService
Параметры:
task — задача для отправки
Возвращает:
Future, представляющий ожидающее завершения задачи
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения

externalSubmit

public <T> ForkJoinTask<T> externalSubmit(ForkJoinTask<T> task)
Отправляет указанную задачу так, как если бы она была отправлена клиентом, не являющимся ForkJoinTask. Задача добавляется в очередь планирования отправленных задач пула, даже если метод вызван из потока этого пула.
Требования к реализации:
Этот метод эквивалентен submit(ForkJoinTask), если его вызывает поток, не принадлежащий этому пулу.
Параметры типа:
T — тип результата задачи
Параметры:
task — задача для отправки
Возвращает:
задачу
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения
Начиная с версии:
20

lazySubmit

public <T> ForkJoinTask<T> lazySubmit(ForkJoinTask<T> task)
Отправляет указанную задачу, не гарантируя, что она в итоге будет выполнена при отсутствии активных потоков. В некоторых контекстах этот метод может снизить конкуренцию и накладные расходы, опираясь на специфичные для контекста знания о том, что существующие потоки (возможно, включая вызывающий поток, если он работает в этом пуле) в конечном итоге смогут выполнить задачу.
Параметры типа:
T — тип результата задачи
Параметры:
task — задача
Возвращает:
задачу
Исключения:
NullPointerException — если задача равна null
RejectedExecutionException — если задачу невозможно запланировать для выполнения
Начиная с версии:
19

setParallelism

public int setParallelism(int size)
Изменяет целевой уровень параллелизма этого пула, управляя созданием, использованием и завершением рабочих потоков в будущем. Этот метод может применяться, например, в контекстах, где количество доступных процессоров меняется со временем.
Примечание по реализации:
Эта реализация ограничивает максимальное количество работающих потоков значением 32767
Параметры:
size — целевой уровень параллелизма
Возвращает:
предыдущий уровень параллелизма.
Исключения:
IllegalArgumentException — если размер меньше 1 или больше максимального значения, поддерживаемого этим пулом.
UnsupportedOperationException — это commonPool(), а уровень параллелизма задан системным свойством java.util.concurrent.ForkJoinPool.common.parallelism.
Начиная с версии:
19

invokeAllUninterruptibly

public <T> List<Future<T>> invokeAllUninterruptibly(Collection<? extends Callable<T>> tasks)
Версия invokeAll, не реагирующая на прерывания. Выполняет указанные задачи и возвращает список объектов Future с их состояниями и результатами после завершения всех задач, игнорируя прерывания. Для каждого элемента возвращаемого списка Future.isDone() имеет значение true. Обратите внимание, что завершенная задача могла завершиться как нормально, так и с выбросом исключения. Результаты этого метода не определены, если указанная коллекция изменяется во время выполнения операции.
Примечание к API:
Этот метод поддерживает сценарии использования, которые ранее полагались на несовместимое переопределение ExecutorService.invokeAll(java.util.Collection).
Параметры типа:
T — тип значений, возвращаемых задачами
Параметры:
tasks — коллекция задач
Возвращает:
список объектов Future, представляющих задачи, в том же последовательном порядке, что и итератор указанного списка задач; все задачи в списке завершены
Исключения:
NullPointerException — если tasks или любой из ее элементов равен null
RejectedExecutionException — если какую-либо задачу невозможно запланировать для выполнения
Начиная с версии:
22

schedule

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
Отправляет однократно выполняемую задачу, которая становится доступной для выполнения по истечении указанной задержки. После этого она будет выполнена, если ее явно не отменить; при нехватке ресурсов она может не выполниться (в конечном итоге сообщив об отмене), либо пул будет остановлен вызовом shutdownNow(), либо вызовом shutdown() при отсутствии другой работы, когда действует cancelDelayedTasksOnShutdown().
Определено в:
schedule в интерфейсе ScheduledExecutorService
Параметры:
command — задача для выполнения
delay — задержка выполнения относительно текущего момента
unit — единица измерения времени для параметра задержки
Возвращает:
ForkJoinTask, реализующий интерфейс ScheduledFuture; его метод get() вернет null при нормальном завершении.
Исключения:
RejectedExecutionException — если пул остановлен или при отправке задачи возникла нехватка ресурсов.
NullPointerException — если command или unit равен null
Начиная с версии:
25

schedule

public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
Отправляет однократно выполняемую задачу, возвращающую значение и становящуюся доступной для выполнения по истечении указанной задержки. После этого она будет выполнена, если ее явно не отменить; при нехватке ресурсов она может не выполниться (в конечном итоге сообщив об отмене), либо пул будет остановлен вызовом shutdownNow(), либо вызовом shutdown() при отсутствии другой работы, когда действует cancelDelayedTasksOnShutdown().
Определено в:
schedule в интерфейсе ScheduledExecutorService
Параметры типа:
V — тип результата callable
Параметры:
callable — функция для выполнения
delay — задержка выполнения относительно текущего момента
unit — единица измерения времени для параметра задержки
Возвращает:
ForkJoinTask, реализующий интерфейс ScheduledFuture; его метод get() вернет значение, возвращенное callable, при нормальном завершении.
Исключения:
RejectedExecutionException — если пул остановлен или при отправке задачи возникла нехватка ресурсов.
NullPointerException — если command или unit равен null
Начиная с версии:
25

scheduleAtFixedRate

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
Отправляет периодическое действие, которое впервые становится доступным для выполнения по истечении указанной начальной задержки, а затем выполняется с указанным периодом; то есть выполнение начнется через initialDelay, затем через initialDelay + period, затем через initialDelay + 2 * period и так далее.

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

  • Задача явно отменена
  • Вызван метод shutdownNow()
  • Вызван метод shutdown(), и пул не выполняет другую работу; в этом случае уже выполняющиеся задачи продолжают работу, но последующие запуски не выполняются.
  • При выполнении или обработке задачи возникает нехватка ресурсов.
  • При выполнении задачи выбрасывается исключение. В этом случае вызов get для возвращенного Future выбросит ExecutionException, содержащий это исключение в качестве причины.
Последующие запуски не выполняются. Последующие вызовы isDone() для возвращенного Future будут возвращать true.

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

Определено в:
scheduleAtFixedRate в интерфейсе ScheduledExecutorService
Параметры:
command — задача для выполнения
initialDelay — задержка перед первым выполнением
period — период между последовательными выполнениями
unit — единица измерения времени для параметров initialDelay и period
Возвращает:
ForkJoinTask, реализующий интерфейс ScheduledFuture. Метод get() этого Future никогда не вернет результат нормальным образом и выбросит исключение при отмене задачи или ненормальном завершении ее выполнения.
Исключения:
RejectedExecutionException — если пул остановлен или при отправке задачи возникла нехватка ресурсов.
NullPointerException — если command или unit равен null
IllegalArgumentException — если period меньше или равен нулю
Начиная с версии:
25

scheduleWithFixedDelay

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
Отправляет периодическое действие, которое впервые становится доступным для выполнения по истечении указанной начальной задержки, а затем выполняется с указанной задержкой между завершением одного выполнения и началом следующего.

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

  • Задача явно отменена
  • Вызван метод shutdownNow()
  • Вызван метод shutdown(), и пул не выполняет другую работу; в этом случае уже выполняющиеся задачи продолжают работу, но последующие запуски не выполняются.
  • При выполнении или обработке задачи возникает нехватка ресурсов.
  • При выполнении задачи выбрасывается исключение. В этом случае вызов get для возвращенного Future выбросит ExecutionException, содержащий это исключение в качестве причины.
Последующие запуски не выполняются. Последующие вызовы isDone() для возвращенного Future будут возвращать true.
Определено в:
scheduleWithFixedDelay в интерфейсе ScheduledExecutorService
Параметры:
command — задача для выполнения
initialDelay — задержка перед первым выполнением
delay — задержка между завершением одного выполнения и началом следующего
unit — единица измерения времени для параметров initialDelay и delay
Возвращает:
ForkJoinTask, реализующий интерфейс ScheduledFuture. Метод get() этого Future никогда не вернет результат нормальным образом и выбросит исключение при отмене задачи или ненормальном завершении ее выполнения.
Исключения:
RejectedExecutionException — если пул остановлен или при отправке задачи возникла нехватка ресурсов.
NullPointerException — если command или unit равен null
IllegalArgumentException — если delay меньше или равна нулю
Начиная с версии:
25

submitWithTimeout

public <V> ForkJoinTask<V> submitWithTimeout(Callable<V> callable, long timeout, TimeUnit unit, Consumer<? super ForkJoinTask<V>> timeoutAction)
Отправляет задачу, выполняющую указанную функцию, отменяя ее или выполняя заданное действие timeoutAction, если задача не завершена в течение указанного периода ожидания. Если необязательный параметр timeoutAction равен null, задача отменяется (с помощью cancel(true)). В противном случае выполняется указанное действие, и при необходимости работающая задача может быть прервана. Действия могут включать вызов ForkJoinTask.complete(V) для установки замещающего значения или ForkJoinTask.completeExceptionally(Throwable) для выбрасывания соответствующего исключения. Обратите внимание, что это возможно, только если задача еще не завершилась к моменту выполнения timeoutAction.
Параметры типа:
V — тип результата callable
Параметры:
callable — функция для выполнения
timeout — время ожидания до отмены, если задача не завершена
unit — единица измерения времени для параметра тайм-аута
timeoutAction — если значение не равно null, действие, выполняемое при истечении тайм-аута; в противном случае по умолчанию задача отменяется с помощью cancel(true).
Возвращает:
Future, который можно использовать для получения результата или отмены задачи
Исключения:
RejectedExecutionException — если задачу невозможно запланировать для выполнения
NullPointerException — если callable или unit равен null
Начиная с версии:
25

cancelDelayedTasksOnShutdown

public void cancelDelayedTasksOnShutdown()
Обеспечивает, чтобы запланированные задачи, которые не выполняются и ещё не были допущены к выполнению, не выполнялись и отменялись при вызове shutdown() (если только этот пул не является commonPool(), который никогда не завершает работу). Этот метод можно вызвать как до shutdown(), чтобы он вступил в силу при следующем вызове, так и после него, чтобы отменить такие задачи, что может позволить завершить работу. Обратите внимание, что после завершения работы последующие выполнения периодических задач всегда отключаются, поэтому этот метод имеет смысл применять только к непериодическим задачам.
Начиная с:
25

getFactory

public ForkJoinPool.ForkJoinWorkerThreadFactory getFactory()
Возвращает фабрику, используемую для создания новых рабочих потоков.
Возвращает:
фабрику, используемую для создания новых рабочих потоков

getUncaughtExceptionHandler

public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
Возвращает обработчик для внутренних рабочих потоков, которые завершаются из-за неисправимых ошибок, возникших при выполнении задач.
Возвращает:
обработчик или null, если он отсутствует

getParallelism

public int getParallelism()
Возвращает целевой уровень параллелизма этого пула.
Возвращает:
целевой уровень параллелизма этого пула

getCommonPoolParallelism

public static int getCommonPoolParallelism()
Возвращает целевой уровень параллелизма общего пула.
Возвращает:
целевой уровень параллелизма общего пула
Начиная с:
1.8

getPoolSize

public int getPoolSize()
Возвращает число рабочих потоков, которые были запущены, но ещё не завершились. Результат, возвращаемый этим методом, может отличаться от getParallelism(), когда потоки создаются для поддержания параллелизма, пока другие потоки заблокированы в режиме совместного управления.
Возвращает:
число рабочих потоков

getAsyncMode

public boolean getAsyncMode()
Возвращает true, если этот пул использует локальный режим планирования «первым поступил — первым обслужен» для порождённых задач, к которым никогда не присоединяются.
Возвращает:
true, если этот пул использует асинхронный режим

getRunningThreadCount

public int getRunningThreadCount()
Возвращает оценку числа рабочих потоков, которые не заблокированы в ожидании присоединения задач или другой управляемой синхронизации. Этот метод может завышать число работающих потоков.
Возвращает:
число рабочих потоков

getActiveThreadCount

public int getActiveThreadCount()
Возвращает оценку числа потоков, которые в данный момент извлекают или выполняют задачи. Этот метод может завышать число активных потоков.
Возвращает:
число активных потоков

isQuiescent

public boolean isQuiescent()
Возвращает true, если все рабочие потоки в данный момент простаивают. Простаивающий рабочий поток — это поток, который не может получить задачу для выполнения, поскольку нет доступных задач, которые можно было бы извлечь у других потоков, и в пуле нет ожидающих отправки задач. Этот метод работает консервативно: он может не вернуть true сразу после того, как все потоки перейдут в состояние простоя, но со временем вернёт это значение, если потоки останутся неактивными.
Возвращает:
true, если все потоки в данный момент простаивают

getStealCount

public long getStealCount()
Возвращает оценку общего числа завершённых задач, выполненных потоком, отличным от потока, который их отправил. Если пул не находится в состоянии покоя, сообщаемое значение будет меньше фактического общего числа перехватов. Это значение может быть полезно для мониторинга и настройки программ fork/join: в целом число перехватов должно быть достаточно большим, чтобы потоки оставались занятыми, но достаточно малым, чтобы избежать накладных расходов и конкуренции между потоками.
Возвращает:
число перехватов

getQueuedTaskCount

public long getQueuedTaskCount()
Возвращает оценку общего числа задач, находящихся в данный момент в очередях рабочих потоков (не включая отправленные в пул задачи, выполнение которых ещё не началось). Это значение является лишь приближённым и получается путём обхода всех потоков в пуле. Этот метод может быть полезен для настройки гранулярности задач. Возвращаемое значение не включает запланированные задачи, которые ещё не готовы к выполнению; их число отдельно возвращает метод getDelayedTaskCount().
Возвращает:
число задач в очереди
См. также:
  • ForkJoinWorkerThread.getQueuedTaskCount()

getQueuedSubmissionCount

public int getQueuedSubmissionCount()
Возвращает оценку числа задач, отправленных в этот пул, выполнение которых ещё не началось. Время работы этого метода может быть пропорционально числу отправленных задач.
Возвращает:
число отправленных задач в очереди

getDelayedTaskCount

public long getDelayedTaskCount()
Возвращает оценку числа отложенных (включая периодические) задач, запланированных в этом пуле, которые ещё не готовы к отправке на выполнение. Возвращаемое значение неточно во время обработки отложенных задач.
Возвращает:
оценку числа отложенных задач
Начиная с:
25

hasQueuedSubmissions

public boolean hasQueuedSubmissions()
Возвращает true, если в пул отправлены задачи, выполнение которых ещё не началось.
Возвращает:
true, если в очереди есть отправленные задачи

pollSubmission

protected ForkJoinTask<?> pollSubmission()
Удаляет и возвращает следующую ещё не выполненную отправленную задачу, если она доступна. Этот метод может быть полезен в расширениях данного класса, перераспределяющих работу в системах с несколькими пулами.
Возвращает:
следующую отправленную задачу или null, если такой нет

drainTasksTo

protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c)
Удаляет все доступные ещё не выполненные отправленные и порождённые задачи из очередей планирования и добавляет их в указанную коллекцию, не изменяя их состояние выполнения. В их число могут входить искусственно созданные или обёрнутые задачи. Этот метод следует вызывать только тогда, когда достоверно известно, что пул находится в состоянии покоя. При вызове в других случаях могут быть удалены не все задачи. Ошибка при попытке добавить элементы в коллекцию c может привести к тому, что в момент выброса соответствующего исключения элементы не будут находиться ни в одной из коллекций, будут находиться в одной из них или в обеих. Поведение этой операции не определено, если указанная коллекция изменяется во время её выполнения.
Параметры:
c — коллекция, в которую следует перенести элементы
Возвращает:
число перенесённых элементов

toString

public String toString()
Возвращает строку, идентифицирующую этот пул и его состояние, включая сведения о состоянии выполнения, уровне параллелизма, а также количестве рабочих потоков и задач.
Переопределяет:
toString в классе Object
Возвращает:
строку, идентифицирующую этот пул и его состояние

shutdown

public void shutdown()
При необходимости инициирует упорядоченное завершение работы, при котором ранее отправленные задачи выполняются, но новые задачи не принимаются. Вызов не влияет на состояние выполнения, если это commonPool(), и не оказывает дополнительного эффекта, если работа уже завершена. Задачи, отправка которых происходит параллельно с выполнением этого метода, могут быть как отклонены, так и приняты.
Определено в:
shutdown в интерфейсе ExecutorService

shutdownNow

public List<Runnable> shutdownNow()
При необходимости пытается отменить и/или остановить все задачи и отклонять все последующие отправленные задачи. Вызов не влияет на состояние выполнения, если это commonPool(), и не оказывает дополнительного эффекта, если работа уже завершена. В противном случае задачи, отправка или выполнение которых происходит параллельно с выполнением этого метода, могут быть как отклонены, так и приняты. Этот метод отменяет как существующие, так и ещё не выполненные задачи, чтобы обеспечить возможность завершения работы при наличии зависимостей между задачами. Поэтому метод всегда возвращает пустой список (в отличие от некоторых других Executor).
Определено в:
shutdownNow в интерфейсе ExecutorService
Возвращает:
пустой список

isTerminated

public boolean isTerminated()
Возвращает true, если после завершения работы все задачи выполнены.
Определено в:
isTerminated в интерфейсе ExecutorService
Возвращает:
true, если после завершения работы все задачи выполнены

isTerminating

public boolean isTerminating()
Возвращает true, если процесс завершения работы начался, но ещё не завершился. Этот метод может быть полезен при отладке. Возвращаемое значение true спустя достаточное время после завершения работы может указывать на то, что отправленные задачи проигнорировали или подавили прерывание либо ожидают ввода-вывода, из-за чего этот исполнитель не может завершить работу должным образом. (См. рекомендации для класса ForkJoinTask, в которых говорится, что задачи обычно не должны включать блокирующие операции. Если же они их включают, такие операции необходимо прерывать при получении сигнала прерывания.)
Возвращает:
true, если завершение работы началось, но ещё не завершилось

isShutdown

public boolean isShutdown()
Возвращает true, если работа этого пула была завершена.
Определено в:
isShutdown в интерфейсе ExecutorService
Возвращает:
true, если работа этого пула была завершена

awaitTermination

public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
Блокирует выполнение до тех пор, пока не произойдёт одно из следующих событий: все задачи завершат выполнение после запроса на завершение работы, истечёт время ожидания или текущий поток будет прерван. Поскольку commonPool() не завершает работу до завершения программы, при вызове для общего пула этот метод эквивалентен awaitQuiescence(long, TimeUnit), но всегда возвращает false.
Определено в:
awaitTermination в интерфейсе ExecutorService
Параметры:
timeout — максимальное время ожидания
unit — единица измерения времени для аргумента времени ожидания
Возвращает:
true, если работа этого исполнителя завершилась, и false, если время ожидания истекло до завершения работы
Выбрасывает:
InterruptedException — если поток был прерван во время ожидания

awaitQuiescence

public boolean awaitQuiescence(long timeout, TimeUnit unit)
Если этот метод вызван задачей ForkJoinTask, выполняющейся в этом пуле, он действует так же, как ForkJoinTask.helpQuiesce(). В противном случае ожидает и/или пытается помочь выполнить задачи, пока пул не isQuiescent() или не истечёт указанный период ожидания.
Параметры:
timeout — максимальное время ожидания
unit — единица измерения времени для аргумента времени ожидания
Возвращает:
true, если пул находится в состоянии покоя; false, если время ожидания истекло.

close

public void close()
Если это не commonPool(), инициирует упорядоченное завершение работы, при котором ранее отправленные задачи выполняются, но новые задачи не принимаются, и ожидает завершения всех задач и самого исполнителя.

Если работа уже завершена или это commonPool(), метод не влияет на выполнение и не ожидает завершения. В противном случае, если поток прерывается во время ожидания, этот метод останавливает все выполняемые задачи, как если бы был вызван shutdownNow(). Затем он продолжает ожидание до завершения всех выполняемых задач. Задачи, ожидающие выполнения, не запускаются. Перед возвратом из метода статус прерывания будет восстановлен.

Определено в:
close в интерфейсе AutoCloseable
Определено в:
close в интерфейсе ExecutorService
Начиная с:
19

managedBlock

public static void managedBlock(ForkJoinPool.ManagedBlocker blocker) throws InterruptedException
Выполняет указанную потенциально блокирующую задачу. При выполнении в ForkJoinPool этот метод при необходимости может обеспечить активацию резервного потока, чтобы поддерживать достаточный уровень параллелизма, пока текущий поток заблокирован в blocker.block().

Этот метод повторно вызывает blocker.isReleasable() и blocker.block(), пока один из методов не вернёт true. Каждому вызову blocker.block() предшествует вызов blocker.isReleasable(), вернувший false.

Если выполнение происходит не в ForkJoinPool, поведение этого метода эквивалентно

while (!blocker.isReleasable())
  if (blocker.block())
    break;
Если выполнение происходит в ForkJoinPool, пул может быть предварительно расширен, чтобы обеспечить достаточный уровень параллелизма во время вызова blocker.block().
Параметры:
blocker — задача-блокировщик
Выбрасывает:
InterruptedException — если это произошло в blocker.block()

Сообщить об ошибке или предложить улучшение
Дополнительные справочные материалы по API и документацию для разработчиков см. в разделе Документация Java SE, содержащем более подробные описания для разработчиков, обзоры концепций, определения терминов, обходные решения и примеры работающего кода. Другие версии.
Java является товарным знаком или зарегистрированным товарным знаком Oracle и/или её аффилированных лиц в США и других странах.
Авторские права © 1993, 2026, Oracle и/или её аффилированные лица, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
Все права защищены. Использование регулируется условиями лицензии и политикой распространения документации.

© 1993, 2025, 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.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API