Класс ForkJoinPool

Все реализованные интерфейсы:
Executor, ExecutorService 
public class ForkJoinPool
extends AbstractExecutorService

A ExecutorService для запуска ForkJoinTasks. A ForkJoinPool предоставляет точку входа для задач, отправляемых извне, а также для управления и мониторинга.

ForkJoinPool отличается от других типов ExecutorService главным образом тем, что использует кражу задач: все потоки в пуле пытаются найти и выполнить задачи, отправленные в пул и/или созданные другими активными задачами (в конечном итоге блокируя ожидание работы, если её нет). Это обеспечивает эффективную обработку, когда большинство задач порождают дочерние задачи (как и большинство ForkJoinTasks), а также когда во внешний пул отправляется много мелких задач. Особенно при установке 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. При любой ошибке при установке этих параметров используются параметры по умолчанию. Возможно отключить или ограничить использование потоков в общем пуле, установив свойство параллельности в ноль и/или используя фабрику, которая может возвращать null. Однако это может привести к тому, что не объединённые задачи никогда не будут выполнены.

Примечания по реализации: Эта реализация ограничивает максимальное количество запущенных потоков 32767. Попытки создать пулы с числом потоков больше максимального приводят к IllegalArgumentException.

Эта реализация отклоняет отправленные задачи (то есть, выбрасывает RejectedExecutionException) только при закрытии пула или исчерпании внутренних ресурсов.

С:
1.7

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

Модификатор и тип Класс Описание
static interface  ForkJoinPool.ForkJoinWorkerThreadFactory

Фабрика для создания новых ForkJoinWorkerThreads.
static interface  ForkJoinPool.ManagedBlocker

Интерфейс для расширения управляемой параллельности для задач, выполняемых в ForkJoinPools.

Поля

Модификатор и тип Поле Описание
static 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)

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

Возвращает экземпляр общего пула.
protected int drainTasksTo​(Collection<? super ForkJoinTask<?>> c)

Удаляет все доступные невыполненные отправленные и разветвлённые задачи из очередей планирования и добавляет их в заданный набор, не изменяя их статус выполнения.
void execute​(Runnable task)

Выполняет заданный командный блок в какое-то время в будущем.
void execute​(ForkJoinTask<?> task)

Организует (асинхронное) выполнение заданной задачи.
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)

Выполняет заданные задачи, возвращая список Future, содержащих их состояние и результаты, когда все завершатся.
boolean isQuiescent()

Возвращает true, если все рабочие нити в настоящее время простаивают.
boolean isShutdown()

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

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

Возвращает true, если процесс завершения начался, но ещё не завершился.
static void managedBlock​(ForkJoinPool.ManagedBlocker blocker)

Выполняет заданную, возможно, блокирующую задачу.
protected ForkJoinTask<?> pollSubmission()

Удаляет и возвращает следующую невыполненную заявку, если она доступна.
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

newTaskFor, newTaskFor

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

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

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

invokeAll, invokeAny, invokeAny

Поля

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 - количество потоков, поддерживаемых в пуле (если не истекло время ожидания keep-alive). Обычно (и по умолчанию) это значение такое же, как уровень параллелизма, но может быть установлено больше для снижения динамической нагрузки, если задачи регулярно блокируются. Использование меньшего значения (например, 0) имеет тот же эффект, что и по умолчанию.
maximumPoolSize - максимальное количество разрешённых потоков. Когда максимум достигнут, попытки заменить заблокированные потоки терпят неудачу. (Однако, поскольку создание и завершение разных потоков могут перекрываться и могут управляться заданной фабрикой потоков, это значение может временно превышаться.) Для того, чтобы получить то же значение, которое используется по умолчанию для общего пула, используйте 256 плюс уровень parallelism. (По умолчанию общий пул разрешает максимальное количество 256 резервных потоков.) Использование значения (например, Integer.MAX_VALUE) больше, чем предел потоков реализации, имеет тот же эффект, что и использование этого предела (что является значением по умолчанию).
minimumRunnable - минимальное допустимое число основных потоков, не заблокированных объединением или ForkJoinPool.ManagedBlocker. Для обеспечения прогресса, когда существует слишком мало разблокированных потоков и могут существовать незапущенные задачи, создаются новые потоки до заданного максимального значения. Для значения по умолчанию используйте 1, что гарантирует жизнеспособность. Большее значение может улучшить производительность в условиях заблокированных операций, но не обязательно, из-за увеличенной нагрузки. Нулевое значение может быть приемлемым, когда отправленные задачи не могут иметь зависимости, требующие дополнительных потоков.
saturate - если не null, предикат, вызываемый при попытках создания большего, чем максимальное допустимое количество потоков. По умолчанию, когда поток собирается заблокироваться на соединении или ForkJoinPool.ManagedBlocker, но не может быть заменён, потому что максимальное значение `maximumPoolSize` будет превышено, выбрасывается RejectedExecutionException. Но если этот предикат возвращает true, то исключение не выбрасывается, поэтому пул продолжает работать с меньшим, чем целевое количество работающих потоков, что может не обеспечить прогресс.
keepAliveTime - время, прошедшее с момента последнего использования, прежде чем поток завершается (а затем позже заменяется при необходимости). Для значения по умолчанию используйте 60, TimeUnit.SECONDS.
unit - единица измерения времени для аргумента keepAliveTime
Возбуждает:
IllegalArgumentException - если уровень параллелизма меньше или равен нулю или больше, чем предел реализации, или если `maximumPoolSize` меньше `parallelism`, или если `keepAliveTime` меньше или равно нулю.
NullPointerException - если фабрика равна null
SecurityException - если существует менеджер безопасности и вызывающая сторона не имеет разрешения на изменение потоков, так как не владеет RuntimePermission("modifyThread")
С:
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.

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

submit

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

Отправляет 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 - если задача не может быть запланирована для выполнения

invokeAll

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

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

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

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

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

Возвращает:
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 через достаточный период после вызова shutdown может указывать на то, что отправленные задачи игнорировали или подавляли прерывания или ожидают ввода/вывода, что приводит к некорректному завершению этого исполнителя. (См. справочные заметки к классу ForkJoinTask, в которых указывается, что задачи обычно не должны включать блокирующие операции. Но если они это делают, они должны прервать их при прерывании.)

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

isShutdown

public boolean isShutdown()

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

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

awaitTermination

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

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

Параметры:
timeout - максимальное время ожидания
unit - единица измерения времени аргумента времени ожидания
Возвращает:
true если этот исполнитель завершился и false если истекло время ожидания до завершения
Исключения:
InterruptedException - если прервано во время ожидания

awaitQuiescence

public boolean awaitQuiescence(long timeout,
                               TimeUnit unit)

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

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

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

Spec-Zone .ru
спецификации, руководства, описания, API