compact1, compact2, compact3

java.util.concurrent

Класс ForkJoinTask <V>

java.lang. Объект

java.util.concurrent. ForkJoinTask <V>

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

Сериализуемый, Будущий <V>

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

CountedCompleter, RecursiveAction, RecursiveTask

public abstract class ForkJoinTask<V>
extends Object
implements Future<V>, Serializable

Абстрактный class для задач, которые работают в пределах a ForkJoinPool. A ForkJoinTask нитевидный объект, который является намного более легким весом чем нормальный поток. Огромные числа задач и подзадач могут быть размещены небольшим количеством фактических потоков в ForkJoinPool по цене некоторых ограничений использования.

"Основное" ForkJoinTask начинает выполнение, когда оно явно представляется a ForkJoinPool, или, если не уже занятый вычислением ForkJoin, начатым в ForkJoinPool.commonPool() через fork(), invoke(), или связанные методы. После того, как запущенный, это будет обычно поочередно запускать другие подзадачи. Как обозначено именем этого class, многого использования программ ForkJoinTask используйте только методы fork() и join(), или производные такой как invokeAll. Однако, этот class также обеспечивает много других методов, которые могут играть роль в усовершенствованных использованиях, так же как механике расширения, которые позволяют поддержку новых форм обработки ветвления/соединения.

A ForkJoinTask легкая форма Future. Эффективность ForkJoinTasks происходит от ряда ограничений (которые только частично статически осуществимы), отражение их основного использования в качестве вычислительных задач, вычисляющих чистые функции или работающих на просто изолированных объектах. Основные механизмы координации fork(), это располагает асинхронное выполнение, и join(), это не продолжается, пока результат задачи не был вычислен. Вычисления должны идеально избежать synchronized методы или блоки, и должны минимизировать другую синхронизацию блокирования кроме присоединения к другим задачам или использования синхронизаторов, таких как Фазовращатели, которые рекламируются, чтобы сотрудничать с планированием ветвления/соединения. Подделящиеся задачи не должны также выполнить ввод-вывод блокирования, и если идеально переменные доступа, которые абсолютно независимы от тех, к которым получают доступ другие выполняющиеся задачи. Эти направляющие линии свободно осуществляются, не разрешая проверенные исключения такой как IOExceptions быть брошенным. Однако, вычисления могут все еще встретиться с исключениями непроверенными, которые повторно бросаются в вызывающие стороны, пытающиеся присоединиться к ним. Эти исключения могут дополнительно включать RejectedExecutionException происходя от внутреннего исчерпания ресурса, такого как отказ выделить внутренние очереди задачи. Повторно брошенные исключения ведут себя таким же образом как регулярные исключения, но, когда возможный, содержат трассировки стека (как выведено на экран например использование ex.printStackTrace()) из обоих поток, который инициировал вычисление так же как поток, фактически встречающийся с исключением; минимально только последний.

Возможно определить и использовать ForkJoinTasks, который может блокировать, но выполнение делают требует трех дальнейших соображений: (1) Завершение немногих, если какие-либо другие задачи должны зависеть от задачи, которая блокирует на внешней синхронизации или вводе-выводе. Асинхронные задачи стиля события, к которым никогда не присоединяются (например, те, которые разделяют на подклассы CountedCompleter) часто попадайте в эту категорию. (2), Чтобы минимизировать воздействие ресурса, задачи должны быть маленькими; идеально выполняя только (возможно) блокирующее действие. (3), Если ForkJoinPool.ManagedBlocker API используется, или число возможно блокированных задач, как известно, является меньше чем пул ForkJoinPool.getParallelism() уровень, пул не может гарантировать, что достаточно многие потоки будут доступны, чтобы гарантировать продвижение или хорошую производительность.

Основной метод для того, чтобы ждать завершения и извлечь результаты задачи join(), но есть несколько разновидностей: Future.get() методы поддерживают прерывистый, и/или синхронизированный ожидает завершения и использования результатов отчета Future соглашения. Метод invoke() семантически эквивалентно fork(); join() но всегда попытки начать выполнение в текущем потоке. "Тихие" формы этих методов не извлекают результаты или сообщают об исключениях. Они могут быть полезными, когда ряд задач выполняется, и Вы должны задержать обработку результатов или исключений, пока все не завершаются. Метод invokeAll (доступный в многократных версиях), выполняет наиболее распространенную форму параллельного вызова: разветвление ряда задач и присоединения к ним всем.

В самых типичных использованиях пара соединения ветвления действует как вызов (ветвление) и возврат (соединение) от параллельной рекурсивной функции. Как имеет место с другими формами рекурсивных вызовов, возвраты (соединения) должны быть выполнены самые внутренние сначала. Например, a.fork(); b.fork(); b.join(); a.join(); вероятно, будет существенно более эффективным чем присоединение a прежде b.

Состояние выполнения задач может быть запрошено в нескольких уровнях детализации: isDone() истина, если задача, завершенная всегда (включая случай, где задача была отменена, не выполняясь); isCompletedNormally() истина если задача, завершенная без отмены или обнаружения с исключением; isCancelled() истина, если задача была отменена (когда getException() возвраты a CancellationException); и isCompletedAbnormally() истина, если задача была или отменена или встретилась с исключением, когда getException() возвратит или исключение, с которым встречаются, или CancellationException.

ForkJoinTask class обычно непосредственно не разделяется на подклассы. Вместо этого Вы разделяете один на подклассы из абстрактных классов, которые поддерживают определенный стиль обработки ветвления/соединения, обычно RecursiveAction для большинства вычислений, которые не возвращают результаты, RecursiveTask для тех, которые делают, и CountedCompleter для тех, в которых завершенные действия инициировали другие действия. Обычно, конкретный подкласс ForkJoinTask объявляет поля, включающие его параметры, установленные в конструкторе, и затем определяет a compute метод, который так или иначе использует способы управления, предоставленные этим основным class.

Метод join() и его разновидности являются подходящими для использования только, когда зависимости от завершения являются нециклическими; то есть, параллельное вычисление может быть описано как направленный граф без петель (DAG). Иначе, выполнение может встретиться с формой мертвой блокировки, поскольку задачи циклически ожидают друг друга. Однако, эта платформа поддерживает другие методы и методы (например использование Phaser, helpQuiesce(), и complete(V)) это может быть полезным в построении пользовательских подклассов для проблем, которые статически не структурируются как DAGs. Чтобы поддерживать такие использования, ForkJoinTask может быть атомарно тегирован с a short использование значения setForkJoinTaskTag(short) или compareAndSetForkJoinTaskTag(short, short) и проверенное использование getForkJoinTaskTag(). Реализация ForkJoinTask не использует их protected методы или теги в любой цели, но они могут быть полезными в конструкции специализированных подклассов. Например, параллельные обходы графика могут использовать предоставленные методы, чтобы избежать повторно посещать узлы/задачи, которые были уже обработаны. (Имена методов для того, чтобы тегировать являются большими частично, чтобы поощрить определение методов, которые отражают их образцы использования.)

Большинство основных методов поддержки final, предотвратить переопределение реализаций, которые свойственно связываются к базовой легкой платформе планирования задач. Разработчики, создающие новые основные стили обработки ветвления/соединения, должны минимально реализовать protected методы exec(), setRawResult(V), и getRawResult(), также представляя абстрактный вычислительный метод, который может быть реализован в его подклассах, возможно полагаясь на другой protected методы обеспечили этим class.

ForkJoinTasks должен выполнить относительно небольшие количества вычисления. Большие задачи должны быть разделены на меньшие подзадачи, обычно через рекурсивное разложение. Как очень грубое эмпирическое правило, задача должна выполнить больше чем 100 и меньше чем 10000 основных вычислительных шагов, и должна избежать неопределенного цикличного выполнения. Если задачи являются слишком большими, то параллелизм не может улучшить пропускную способность. Если слишком маленький, то память и внутренние издержки обслуживания задачи могут сокрушить обработку.

Этот class обеспечивает adapt методы для Runnable и Callable, это может быть полезным, смешивая выполнение ForkJoinTasks с другими видами задач. Когда все задачи имеют эту форму, рассматривают использование пула, созданного в asyncMode.

ForkJoinTasks Serializable, который позволяет им использоваться в расширениях, таких как удаленные платформы выполнения. Разумно сериализировать задачи только прежде или после, но не во время, выполнение. На сериализацию не полагаются во время выполнения непосредственно.

С тех пор:

1.7

См. Также:

Сериализированная Форма

Сводка конструктора

Конструкторы

Конструктор и Описание
ForkJoinTask()

Сводка метода

Модификатор и Тип	Метод и Описание
static <T> ForkJoinTask<T>	adapt(Callable<? extends T> callable) Возвращает новое ForkJoinTask это выполняет call метод данного Callable как его действие, и возвраты его результат на join(), преобразование любых проверенных исключений, в которые встречаются RuntimeException.
static ForkJoinTask<?>	adapt(Runnable runnable) Возвращает новое ForkJoinTask это выполняет run метод данного Runnable как его действие, и возвраты нулевой результат на join().
static <T> ForkJoinTask<T>	adapt(Runnable runnable, T result) Возвращает новое ForkJoinTask это выполняет run метод данного Runnable как его действие, и возвраты данный результат на join().
boolean	cancel(boolean mayInterruptIfRunning) Попытки отменить выполнение этой задачи.
boolean	compareAndSetForkJoinTaskTag(short e, short tag) Атомарно условно устанавливает значение тега для этой задачи.
void	complete(V value) Завершает эту задачу, и если не уже прерванный или отмененный, возвращая данное значение как результат последующих вызовов join и связанные операции.
void	completeExceptionally(Throwable ex) Завершает эту задачу неправильно, и если не уже прерванный или отмененный, причины это, чтобы выдать данное исключение на join и связанные операции.
protected abstract boolean	exec() Сразу выполняет основное действие этой задачи и возвращает true, если по возврату из этого метода эта задача, как гарантируют, будет обычно завершаться.
ForkJoinTask<V>	fork() Расположения, чтобы асинхронно выполнить эту задачу в пуле текущая задача работают в, если применимый, или используют ForkJoinPool.commonPool() если нет inForkJoinPool().
V	get() Ожидает в случае необходимости вычисления, чтобы завершиться, и затем получает его результат.
V	get(long timeout, TimeUnit unit) Ожидает в случае необходимости в течение самое большее данного времени для вычисления, чтобы завершиться, и затем получает его результат, при наличии.
Throwable	getException() Возвращает исключение, выданное основным вычислением, или a CancellationException если отменено, или null если ни один или если метод еще не завершился.
short	getForkJoinTaskTag() Возвращает тег для этой задачи.
static ForkJoinPool	getPool() Возвращает пул, размещающий текущее выполнение задачи, или нуль, если эта задача выполняется за пределами какого-либо ForkJoinPool.
static int	getQueuedTaskCount() Возвращает оценку числа задач, которые были разветвлены текущим рабочим потоком, но еще не выполнены.
abstract V	getRawResult() Возвращает результат, который был бы возвращен join(), даже если эта задача завершалась неправильно, или null если эта задача, как известно, не была завершена.
static int	getSurplusQueuedTaskCount() Возвращает оценку того, насколько больше локально задач с очередями сохранено текущим рабочим потоком чем есть другие рабочие потоки, которые могли бы украсть их, или обнулять, если этот поток не работает в ForkJoinPool.
static void	helpQuiesce() Возможно выполняет задачи до пула, размещающего текущую задачу is quiescent.
static boolean	inForkJoinPool() Возвраты true если текущий поток является a ForkJoinWorkerThread выполнение как вычисление ForkJoinPool.
V	invoke() Начинает выполнение этой задачи, ждет ее завершения в случае необходимости, и возвращает ее результат, или бросает (непроверенный) RuntimeException или Error если базовое вычисление сделало так.
static <T extends ForkJoinTask<?>> Collection<T>	invokeAll(Collection<T> tasks) Ветвления все задачи в указанном наборе, возвращаясь, когда isDone содержит для каждой задачи, или с исключением (непроверенным) встречаются, когда исключение повторно бросается.
static void	invokeAll(ForkJoinTask<?>... tasks) Разветвляет данные задачи, возвращаясь когда isDone содержит для каждой задачи, или с исключением (непроверенным) встречаются, когда исключение повторно бросается.
static void	invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2) Разветвляет данные задачи, возвращаясь когда isDone содержит для каждой задачи, или с исключением (непроверенным) встречаются, когда исключение повторно бросается.
boolean	isCancelled() true возвратов, если эта задача была отменена прежде, чем это обычно завершалось.
boolean	isCompletedAbnormally() Возвраты true если эта задача выдавала исключение или была отменена.
boolean	isCompletedNormally() Возвраты true если эта задача, завершенная, не выдавая исключение и, не была отменена.
boolean	isDone() true возвратов, если эта задача завершалась.
V	join() Возвращает результат вычисления когда это is done.
protected static ForkJoinTask<?>	peekNextLocalTask() Возвраты, но не непланирует или выполняется, задача, поставленная в очередь текущим потоком, но еще выполняемый, если Вы будете сразу доступны.
protected static ForkJoinTask<?>	pollNextLocalTask() Нерасписания и возвраты, без выполнения, следующая задача, поставленная в очередь текущим потоком, но еще выполняемый, если текущий поток работает в ForkJoinPool.
protected static ForkJoinTask<?>	pollTask() Если текущий поток работает в ForkJoinPool, нерасписаниях и возвратах, без выполнения, следующая задача, поставленная в очередь текущим потоком, но еще выполняемый, если Вы доступны, или если не доступный, задача, которая была разветвлена некоторым другим потоком при наличии.
void	quietlyComplete() обычно завершает эту задачу, не устанавливая значение.
void	quietlyInvoke() Начинает выполнение этой задачи и ждет ее завершения в случае необходимости, не возвращая ее результат или выдавая его исключение.
void	quietlyJoin() Соединения эта задача, не возвращая ее результат или выдавая ее исключение.
void	reinitialize() Сбрасывает внутреннее бухгалтерское состояние этой задачи, позволяя последующее fork.
short	setForkJoinTaskTag(short tag) Атомарно устанавливает значение тега для этой задачи.
protected abstract void	setRawResult(V value) Вынуждает данное значение быть возвращенным в результате.
boolean	tryUnfork() Попытки незапланировать эту задачу для выполнения.

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

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

Деталь конструктора

ForkJoinTask

public ForkJoinTask()

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

ветвление

public final ForkJoinTask<V> fork()

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

Возвраты:

this, упростить использование

соединение

public final V join()

Возвращает результат вычисления когда это is done. Этот метод отличается от get() в том аварийном завершении приводит к RuntimeException или Error, нет ExecutionException, и это прерывания вызывающего потока не заставляет метод резко возвращаться, бросая InterruptedException.

Возвраты:

вычисленный результат

вызвать

public final V invoke()

Начинает выполнение этой задачи, ждет ее завершения в случае необходимости, и возвращает ее результат, или бросает (непроверенный) RuntimeException или Error если базовое вычисление сделало так.

Возвраты:

вычисленный результат

invokeAll

public static void invokeAll(ForkJoinTask<?> t1,
                             ForkJoinTask<?> t2)

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

Параметры:

t1 - первая задача

t2 - вторая задача

Броски:

NullPointerException - если какой-либо задачей является нуль

invokeAll

public static void invokeAll(ForkJoinTask<?>... tasks)

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

Параметры:

tasks - задачи

Броски:

NullPointerException - если какой-либо задачей является нуль

invokeAll

public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks)

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

Параметры:

tasks - набор задач

Возвраты:

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

Броски:

NullPointerException - если задачами или каким-либо элементом является нуль

отмена

public boolean cancel(boolean mayInterruptIfRunning)

Попытки отменить выполнение этой задачи. Эта попытка перестанет работать, если задача уже завершилась или не могла бы быть отменена по некоторой другой причине. В случае успеха, и эта задача не запустилась когда cancel вызывается, выполнение этой задачи подавляется. После того, как этот метод возвращается успешно, если нет прошедший звонок reinitialize(), последующие звонки isCancelled(), isDone(), и cancel возвратится true и звонки join() и связанные методы приведут к CancellationException.

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

Этот метод разрабатывается, чтобы быть вызванным другими задачами. Чтобы завершить текущую задачу, можно только возвратить или выдать исключение непроверенное от его метода вычисления, или вызвать completeExceptionally(Throwable).

Определенный:

cancel в интерфейсе Future<V>

Параметры:

mayInterruptIfRunning - это значение не имеет никакого эффекта в реализации по умолчанию, потому что прерывания не используются, чтобы управлять отменой.

Возвраты:

true если эта задача теперь отменяется

isDone

public final boolean isDone()

Описание скопировало с интерфейса: Future

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

Определенный:

isDone в интерфейсе Future<V>

Возвраты:

true, если эта задача завершалась

isCancelled

public final boolean isCancelled()

Описание скопировало с интерфейса: Future

true возвратов, если эта задача была отменена прежде, чем это обычно завершалось.

Определенный:

isCancelled в интерфейсе Future<V>

Возвраты:

true, если эта задача была отменена прежде, чем это завершалось

isCompletedAbnormally

public final boolean isCompletedAbnormally()

Возвраты true если эта задача выдавала исключение или была отменена.

Возвраты:

true если эта задача выдавала исключение или была отменена

isCompletedNormally

public final boolean isCompletedNormally()

Возвраты true если эта задача, завершенная, не выдавая исключение и, не была отменена.

Возвраты:

true если эта задача, завершенная, не выдавая исключение и, не была отменена

getException

public final Throwable getException()

Возвращает исключение, выданное основным вычислением, или a CancellationException если отменено, или null если ни один или если метод еще не завершился.

Возвраты:

исключение, или null если ни один

completeExceptionally

public void completeExceptionally(Throwable ex)

Завершает эту задачу неправильно, и если не уже прерванный или отмененный, причины это, чтобы выдать данное исключение на join и связанные операции. Этот метод может использоваться, чтобы вызвать исключения в асинхронных задачах, или вызвать завершение задач, которые иначе не завершились бы. Его использованию в других ситуациях обескураживают. Этот метод является переопределяемым, но переопределенные версии должны вызвать super реализация, чтобы поддержать гарантии.

Параметры:

ex - исключение, чтобы бросить. Если это исключение не является a RuntimeException или Error, фактическое выданное исключение будет a RuntimeException с причиной ex.

полный

public void complete(V value)

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

Параметры:

value - значение результата для этой задачи

quietlyComplete

public final void quietlyComplete()

обычно завершает эту задачу, не устанавливая значение. Новое значение, установленное setRawResult(V) (или null по умолчанию), будет возвращен как результат последующих вызовов join и связанные операции.

С тех пор:

1.8

добраться

public final V get()
            throws InterruptedException,
                   ExecutionException

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

Определенный:

get в интерфейсе Future<V>

Возвраты:

вычисленный результат

Броски:

CancellationException - если вычисление было отменено

ExecutionException - если вычисление выдавало исключение

InterruptedException - если текущий поток не является элементом ForkJoinPool и был прерван, ожидая

добраться

public final V get(long timeout,
                   TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException

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

Определенный:

get в интерфейсе Future<V>

Параметры:

timeout - максимальное время, чтобы ожидать

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

Возвраты:

вычисленный результат

Броски:

CancellationException - если вычисление было отменено

ExecutionException - если вычисление выдавало исключение

InterruptedException - если текущий поток не является элементом ForkJoinPool и был прерван, ожидая

TimeoutException - если ожидание синхронизированного

quietlyJoin

public final void quietlyJoin()

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

quietlyInvoke

public final void quietlyInvoke()

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

helpQuiesce

public static void helpQuiesce()

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

повторно инициализировать

public void reinitialize()

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

После завершения этого метода, isDone() отчеты false, и getException() отчеты null. Однако, значение, возвращенное getRawResult незатронуто. Чтобы очистить это значение, можно вызвать setRawResult(null).

getPool

public static ForkJoinPool getPool()

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

Возвраты:

пул, или null если ни один

См. Также:

inForkJoinPool()

inForkJoinPool

public static boolean inForkJoinPool()

Возвраты true если текущий поток является a ForkJoinWorkerThread выполнение как вычисление ForkJoinPool.

Возвраты:

true если текущий поток является a ForkJoinWorkerThread выполнение как вычисление ForkJoinPool, или false иначе

tryUnfork

public boolean tryUnfork()

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

Возвраты:

true если неразветвлено

getQueuedTaskCount

public static int getQueuedTaskCount()

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

Возвраты:

число задач

getSurplusQueuedTaskCount

public static int getSurplusQueuedTaskCount()

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

Возвраты:

избыточное число задач, которые могут быть отрицательными

getRawResult

public abstract V getRawResult()

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

Возвраты:

результат, или null если не завершенный

setRawResult

protected abstract void setRawResult(V value)

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

Параметры:

value - значение

exec

protected abstract boolean exec()

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

Возвраты:

true если эта задача, как известно, обычно завершалась

peekNextLocalTask

protected static ForkJoinTask<?> peekNextLocalTask()

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

Возвраты:

следующая задача, или null если ни один не доступен

pollNextLocalTask

protected static ForkJoinTask<?> pollNextLocalTask()

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

Возвраты:

следующая задача, или null если ни один не доступен

pollTask

protected static ForkJoinTask<?> pollTask()

Если текущий поток работает в ForkJoinPool, нерасписаниях и возвратах, без выполнения, следующая задача, поставленная в очередь текущим потоком, но еще выполняемый, если Вы доступны, или если не доступный, задача, которая была разветвлена некоторым другим потоком при наличии. Доступность может быть переходным процессом, таким образом, a null результат не обязательно подразумевает неподвижность пула, в котором работает эта задача. Этот метод разрабатывается прежде всего, чтобы поддерживать расширения, и вряд ли будет полезен иначе.

Возвраты:

задача, или null если ни один не доступен

getForkJoinTaskTag

public final short getForkJoinTaskTag()

Возвращает тег для этой задачи.

Возвраты:

тег для этой задачи

С тех пор:

1.8

setForkJoinTaskTag

public final short setForkJoinTaskTag(short tag)

Атомарно устанавливает значение тега для этой задачи.

Параметры:

tag - значение тега

Возвраты:

предыдущее значение тега

С тех пор:

1.8

compareAndSetForkJoinTaskTag

public final boolean compareAndSetForkJoinTaskTag(short e,
                                                  short tag)

Атомарно условно устанавливает значение тега для этой задачи. Среди других приложений теги могут использоваться в качестве маркеров посещения в задачах, работающих на графиках, как в методах, которые проверяют: if (task.compareAndSetForkJoinTaskTag((short)0, (short)1)) перед обработкой, иначе выходя, потому что узел уже посетили.

Параметры:

e - ожидаемое значение тега

tag - новое значение тега

Возвраты:

истина в случае успеха; то есть, текущая стоимость была равна e и является теперь тегом.

С тех пор:

1.8

адаптироваться

public static ForkJoinTask<?> adapt(Runnable runnable)

Возвращает новое ForkJoinTask это выполняет run метод данного Runnable как его действие, и возвраты нулевой результат на join().

Параметры:

runnable - выполнимое действие

Возвраты:

задача

адаптироваться

public static <T> ForkJoinTask<T> adapt(Runnable runnable,
                                        T result)

Возвращает новое ForkJoinTask это выполняет run метод данного Runnable как его действие, и возвраты данный результат на join().

Параметры:

runnable - выполнимое действие

result - результат после завершения

Возвраты:

задача

адаптироваться

public static <T> ForkJoinTask<T> adapt(Callable<? extends T> callable)

Возвращает новое ForkJoinTask это выполняет call метод данного Callable как его действие, и возвраты его результат на join(), преобразование любых проверенных исключений, в которые встречаются RuntimeException.

Параметры:

callable - вызываемое действие

Возвраты:

задача