Класс ForkJoinPool

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ForkJoinPool

Все реализованные интерфейсы:: AutoCloseable, Executor, ExecutorService

public class ForkJoinPool extends AbstractExecutorService

Служба выполнения ExecutorService для запуска задач ForkJoinTask. Объект ForkJoinPool предоставляет точку входа для задач, отправленных клиентами, не являющимися ForkJoinTask, а также для операций управления и мониторинга.

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

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

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

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

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

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

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

java.util.concurrent.ForkJoinPool.common.parallelism - уровень параллелизма, целое неотрицательное число
java.util.concurrent.ForkJoinPool.common.threadFactory - имя класса ForkJoinPool.ForkJoinWorkerThreadFactory. Загрузка этого класса выполняется с помощью системного загрузчика классов.
java.util.concurrent.ForkJoinPool.common.exceptionHandler - имя класса Thread.UncaughtExceptionHandler. Загрузка этого класса выполняется с помощью системного загрузчика классов.
java.util.concurrent.ForkJoinPool.common.maximumSpares - максимальное количество дополнительных потоков для поддержания целевого уровня параллелизма (по умолчанию 256).

Если фабрика потоков не задана через системное свойство, общий пул использует фабрику, которая использует системный загрузчик классов как контекстный загрузчик класса потока. Кроме того, если присутствует SecurityManager, то общий пул использует фабрику, предоставляющую потоки без включенных Permissions, и не гарантирует сохранение значений переменных ThreadLocal между задачами. При любой ошибке при установке этих настроек используются значения по умолчанию. Возможно отключить или ограничить использование потоков в общем пуле, установив свойство параллелизма в ноль и/или используя фабрику, которая может возвращать 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`	`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` если этот пул использует локальный режим планирования FIFO для разветвлённых задач, которые никогда не объединяются.
`static int`	`getCommonPoolParallelism()`	Возвращает целевой уровень параллелизма общего пула.

`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>>`	`invokeAll(Collection<? extends Callable<T>> tasks)`	Выполняет заданные задачи, возвращая список объектов Futures, содержащих их статус и результаты, когда все они завершены.
`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()`	Удаляет и возвращает следующую незапущенную задачу, если она доступна.
`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 для выполнения.

String

toString()

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

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

invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor

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

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

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

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)

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

ForkJoinPool

public ForkJoinPool(int parallelism)

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

ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)

Параметры:: parallelism - уровень параллелизма
Возбуждает:: IllegalArgumentException - если уровень параллелизма меньше или равен нулю, или больше предела реализации; SecurityException - если менеджер безопасности существует и вызывающий поток не имеет разрешения на изменение потоков, так как не имеет RuntimePermission("modifyThread")

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; SecurityException - если существует менеджер безопасности, и вызывающий объект не имеет разрешения на изменение потоков, потому что не имеет RuntimePermission("modifyThread")

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 — минимальное допустимое число основных потоков, не заблокированных соединением или ForkJoinPool.ManagedBlocker. Для обеспечения прогресса, когда существует слишком мало разблокированных потоков и могут существовать невыполненные задачи, создаются новые потоки до указанного максимального значения пула. Для использования значения по умолчанию, используйте 1, что гарантирует жизнеспособность. Большее значение может улучшить производительность при наличии заблокированных действий, но может и не улучшить из-за увеличения накладных расходов. Значение 0 может быть приемлемым, когда отправленные задачи не могут иметь зависимости, требующие дополнительных потоков.

saturate - если не null, предикат, вызываемый при попытках создать больше, чем максимальное разрешенное количество потоков. По умолчанию, когда поток собирается заблокироваться на ожидание объединения или ForkJoinPool.ManagedBlocker, но не может быть заменен, потому что максимальное количество потоков (maximumPoolSize) будет превышено, выбрасывается исключение RejectedExecutionException. Но если этот предикат возвращает true, то исключение не выбрасывается, и пул продолжает работать с меньшим количеством потоков, чем целевое количество работающих потоков, что может не гарантировать прогресс.; keepAliveTime - время, прошедшее с момента последнего использования, прежде чем поток завершается (и затем позже заменяется, если необходимо). Для значения по умолчанию используйте 60, TimeUnit.SECONDS.; unit - единица измерения времени для аргумента keepAliveTime
Throws:: IllegalArgumentException - если параллелизм меньше или равен нулю, или больше предела реализации, или если максимальное количество потоков (maximumPoolSize) меньше параллелизма, или если время ожидания (keepAliveTime) меньше или равно нулю.; NullPointerException - если фабрика равна null; SecurityException - если существует менеджер безопасности и вызывающему объекту не разрешено изменять потоки, потому что он не владеет RuntimePermission("modifyThread")
Since:: 9

Методы

commonPool

public static ForkJoinPool commonPool()

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

Returns:: экземпляр общего пула
Since:: 1.8

вызвать

public <T> T invoke(ForkJoinTask<T> task)

Выполняет заданную задачу, возвращая её результат по завершении. Если вычисление сталкивается с исключением или ошибкой, которое нельзя обработать, оно повторно генерируется как результат этого вызова. Переброшенные исключения ведут себя так же, как обычные исключения, но, по возможности, содержат трассировки стека (например, отображаемые с помощью ex.printStackTrace()) как текущей нити, так и нити, фактически столкнувшейся с исключением; минимально только последняя.

Параметры типа:: T - тип результата задачи
Параметры:: task - задача
Возвращает:: результат задачи
Исключения:: NullPointerException - если задача null; RejectedExecutionException - если задача не может быть запланирована для выполнения

выполнить

public void execute(ForkJoinTask<?> task)

Организует (асинхронное) выполнение заданной задачи.

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

выполнить

public void execute(Runnable task)

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

Выполняет данный командный объект в какой-то момент в будущем. Команда может быть выполнена в новой нити, в пуле нитей или в вызывающей нити, по усмотрению реализации 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, представляющее эту задачу. Метод Future's get вернёт заданный результат при успешном завершении.

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

submit

public ForkJoinTask<?> submit(Runnable task)

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

Отправляет задачу Runnable для выполнения и возвращает Future, представляющее эту задачу. Метод Future's get вернёт 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.; SecurityException - если существует менеджер безопасности, и вызывающему элементу не разрешено изменять потоки, потому что он не имеет RuntimePermission("modifyThread")
С:: 19

invokeAll

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

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

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

Параметры типа:: T - тип значений, возвращаемых задачами
Параметры:: tasks - коллекция задач
Возвращает:: список Futures, представляющих задачи в том же последовательном порядке, что и итератор для заданного списка задач, каждая из которых завершена
Исключения:: NullPointerException - если задачи или любые их элементы null; RejectedExecutionException - если любая задача не может быть запланирована для выполнения

getFactory

public ForkJoinPool.ForkJoinWorkerThreadFactory getFactory()

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

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

Обработчик необработанных исключений

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()

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

Возвращает:

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

См. также:

getQueuedSubmissionCount

public int getQueuedSubmissionCount()

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

Возвращает:: количество ожидающих отправлений

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

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

shutdownNow

public List<Runnable> shutdownNow()

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

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

isTerminated

public boolean isTerminated()

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

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

isTerminating

public boolean isTerminating()

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

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

isShutdown

public boolean isShutdown()

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

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

awaitTermination

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

Ожидает завершения всех задач после запроса остановки, истечения таймаута или прерывания текущего потока — в зависимости от того, что произойдёт первым. Так как пул commonPool() никогда не завершается до завершения программы, при применении к общему пулу этот метод эквивалентен awaitQuiescence(long, TimeUnit), но всегда возвращает false.

Parameters:: timeout - максимальное время ожидания; unit - единица измерения времени для аргумента таймаута
Returns:: true если этот Executor завершился, и false если таймаут истек до завершения
Throws:: InterruptedException - если поток был прерван во время ожидания

awaitQuiescence

public boolean awaitQuiescence(long timeout, TimeUnit unit)

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

Parameters:: timeout - максимальное время ожидания; unit - единица измерения времени для аргумента таймаута
Returns:: true если пул находится в состоянии ожидания; false если истек таймаут.

Закрыть

public void close()

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

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

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

© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/ForkJoinPool.html