java.util.concurrent.CountedCompleter<T>

型パラメータ:: T - コンプリタの結果のタイプ

すべての実装されたインタフェース:: Serializable, Future<T>

public abstract class CountedCompleter<T> extends ForkJoinTask<T>

トリガーされた時点で保留中のアクションが残っていない場合に実行される完了アクションを含むForkJoinTaskです。 CountedCompleterは、一般にサブタスクの停止やブロックが発生した場合は他の形式のForkJoinTaskより堅牢ですが、直感的にプログラミングしにくくなります。 CountedCompleterの使用方法は他の完了ベースのコンポーネント(CompletionHandlerなど)と同様ですが、完了アクションonCompletion(CountedCompleter)をトリガーするためには、1つではなく複数の保留完了が必要になることがあります。別の方法で初期化された場合を除き、保留カウントはゼロから始まりますが、setPendingCount(int)、addToPendingCount(int)およびcompareAndSetPendingCount(int, int)メソッドを使用して(原子的に)変更できます。 tryComplete()を呼び出したときに、保留アクションのカウントがゼロでない場合は、値が減らされます。それ以外の場合は、完了アクションが実行され、このコンプリータ自体がコンプリータを持っている場合はそのコンプリータで処理が続行されます。 PhaserやSemaphoreなどの関連する同期化コンポーネントと同様に、これらのメソッドは内部のカウントにしか影響を与えず、それ以上の内部登録を確立しません。特に、保留タスクの識別情報は保持されません。次に示すように、必要に応じて保留タスクまたはそれらの結果の一部または全部を記録するサブクラスを作成できます。次に示すように、完了のトラバースのカスタマイズをサポートするユーティリティ・メソッドも提供されます。ただし、CountedCompleterは基本的な同期化メカニズムのみを提供するため、一連の関連する用途に適したリンク、フィールドおよび追加のサポート・メソッドを保持するその他の抽象サブクラスを作成するときに便利な場合があります。

具象CountedCompleterクラスは、ほとんどのケースで(次に示すように)復帰する前にtryComplete()を1回呼び出すcompute()メソッドを定義する必要があります。このクラスでは、オプションで、正常な完了時にアクションを実行するonCompletion(CountedCompleter)メソッドと、例外の発生時にアクションを実行するonExceptionalCompletion(Throwable, CountedCompleter)メソッドをオーバーライドすることもできます。

ほとんどの場合、CountedCompleterは結果を生成しません。通常はCountedCompleter<Void>として宣言され、結果値として常にnullを返します。それ以外の場合は、getRawResult()メソッドをオーバーライドして、join()、invoke()および関連メソッドから結果を提供するようにしてください。一般に、このメソッドは完了時の結果を保持するCountedCompleterオブジェクトのフィールド(または1つ以上のフィールドの関数)の値を返す必要があります。 setRawResult(T)メソッドは、デフォルトではCountedCompleterに何の影響も与えません。適用可能なケースはほとんどありませんが、このメソッドをオーバーライドして、結果データを持つ他のオブジェクトやフィールドを保持することも可能です。

それ自体ではコンプリータを持たない(つまり、getCompleter()がnullを返す)CountedCompleterは、この追加機能を含む通常のForkJoinTaskとして使用できます。ただし、別のコンプリータを持つコンプリータは、他の計算の内部ヘルパーとしてのみ機能するため、(ForkJoinTask.isDone()などのメソッドで報告される)それ自体のタスク・ステータスは不定です。このステータスは、complete(T)、ForkJoinTask.cancel(boolean)、ForkJoinTask.completeExceptionally(Throwable)の明示的な呼出し時、またはcomputeメソッドの例外完了時にのみ変更されます。例外完了時に、タスクのコンプリータ(およびそのコンプリータ、以下同様)が存在し、まだ完了していない場合は、それらに例外が中継されます。同様に、内部のCountedCompleterを取り消しても、そのコンプリータに対するローカルの効果しかないため、多くの場合有効ではありません。

使用例。

並列の再帰的分解。 CountedCompleterは、RecursiveActionで使用されるものと同様のツリーに配置できます。ただし、それらの設定では通常、異なる方法で構築が行われます。この場合、各タスクのコンプリータは、計算ツリーではタスクの親になります。必要な登録作業がやや多くなりますが、配列またはコレクションの各要素に時間のかかる(それ以上分割できない)オペレーションを適用する場合(特に、入出力などの固有の差違またはガベージ・コレクションなどの補助効果のいずれかが原因で、そのオペレーションの完了にかかる時間が要素によって大幅に異なる場合)、CountedCompleterはより適切な方法である可能性があります。 CountedCompletersは独自の継続を提供するため、他のタスクは実行を待機してブロックする必要はありません。

たとえば、divide-by-two再帰的分解を使用して作業を1つの部分(リーフ・タスク)に分割するユーティリティ・メソッドの初期バージョンを次に示します。作業が個別の呼出しに分割されている場合でも、通常はリーフ・タスクを直接フォークするより、スレッド間通信が減少し、負荷分散が向上するツリーベースの手法をお薦めします。再帰的ケースでは、終了するサブタスクの各ペアの2番目が、親の(結果の組合せが実行されないため、メソッドonCompletionのデフォルトのno-op実装はオーバーライドされません)の完了をトリガーします。ユーティリティ・メソッドは、ルート・タスクを設定し、それを(ここでは、ForkJoinPool.commonPool()を暗黙的に使用)を呼び出します。保留数を常に子タスクの数に設定し、戻す直前に tryComplete()をコールするのは、簡単で信頼性の高い(最適ではない)です。

public static <E> void forEach(E[] array, Consumer<E> action) {
  class Task extends CountedCompleter<Void> {
    final int lo, hi;
    Task(Task parent, int lo, int hi) {
      super(parent); this.lo = lo; this.hi = hi;
    }

    public void compute() {
      if (hi - lo >= 2) {
        int mid = (lo + hi) >>> 1;
        // must set pending count before fork
        setPendingCount(2);
        new Task(this, mid, hi).fork(); // right child
        new Task(this, lo, mid).fork(); // left child
      }
      else if (hi > lo)
        action.accept(array[lo]);
      tryComplete();
    }
  }
  new Task(null, 0, array.length).invoke();
}

再帰的なケースでは、タスクがその右側のタスクをフォークした後で何も実行しないため、復帰する前にその左側のタスクを直接呼び出すことができる点に気づくことで、この設計を改良できます。 (これは末尾再帰の削除に似ています。) また、タスクの最後のアクションがサブタスク(a "テール・コール")をフォークまたは呼び出す場合、 tryComplete()へのコールは、保留カウントを"1つずつオフ"に見せるコストで最適化できます。

    public void compute() {
      if (hi - lo >= 2) {
        int mid = (lo + hi) >>> 1;
        setPendingCount(1); // looks off by one, but correct!
        new Task(this, mid, hi).fork(); // right child
        new Task(this, lo, mid).compute(); // direct invoke
      } else {
        if (hi > lo)
          action.accept(array[lo]);
        tryComplete();
      }
    }

さらなる最適化として、左側のタスクも存在する必要がないことに注意してください。新しいタスクを作成するかわりに、元のタスクを引き続き使用し、フォークごとに保留カウントを追加できます。また、このツリー内のタスクはonCompletion(CountedCompleter)メソッドを実装していないため、tryCompleteをpropagateCompletion()に置き換えることができます。

    public void compute() {
      int n = hi - lo;
      for (; n >= 2; n /= 2) {
        addToPendingCount(1);
        new Task(this, lo + n/2, lo + n).fork();
      }
      if (n > 0)
        action.accept(array[lo]);
      propagateCompletion();
    }

保留中のカウントを事前計算できる場合は、コンストラクタ内で確立できます:

public static <E> void forEach(E[] array, Consumer<E> action) {
  class Task extends CountedCompleter<Void> {
    final int lo, hi;
    Task(Task parent, int lo, int hi) {
      super(parent, 31 - Integer.numberOfLeadingZeros(hi - lo));
      this.lo = lo; this.hi = hi;
    }

    public void compute() {
      for (int n = hi - lo; n >= 2; n /= 2)
        new Task(this, lo + n/2, lo + n).fork();
      action.accept(array[lo]);
      propagateCompletion();
    }
  }
  if (array.length > 0)
    new Task(null, 0, array.length).invoke();
}

このようなクラスの追加の最適化には、リーフ・ステップのクラスを専門とし、反復ごとに2つではなく4つずつ細分化し、常に1つの要素に細分化するのではなく適応しきい値を使用することが必要になる場合があります。

検索。 CountedCompleterのツリーでは、データ構造の様々な部分に含まれる値またはプロパティを検索し、結果が見つかった場合はただちにAtomicReferenceに結果を報告できます。他のタスクはその結果をポーリングして、不要な作業を回避できます。 (さらに、他のタスクを取り消すこともできますが、通常は結果が設定されたことをそれらに通知し、その場合は後続の処理を省略させるのがより簡単で効率的です。) 完全なパーティション化を使用する配列を使って再度説明します(この場合も、実際には、リーフ・タスクはほとんど常に複数の要素を処理します)。

class Searcher<E> extends CountedCompleter<E> {
  final E[] array; final AtomicReference<E> result; final int lo, hi;
  Searcher(CountedCompleter<?> p, E[] array, AtomicReference<E> result, int lo, int hi) {
    super(p);
    this.array = array; this.result = result; this.lo = lo; this.hi = hi;
  }
  public E getRawResult() { return result.get(); }
  public void compute() { // similar to ForEach version 3
    int l = lo, h = hi;
    while (result.get() == null && h >= l) {
      if (h - l >= 2) {
        int mid = (l + h) >>> 1;
        addToPendingCount(1);
        new Searcher(this, array, result, mid, h).fork();
        h = mid;
      }
      else {
        E x = array[l];
        if (matches(x) && result.compareAndSet(null, x))
          quietlyCompleteRoot(); // root task is now joinable
        break;
      }
    }
    tryComplete(); // normally complete whether or not found
  }
  boolean matches(E e) { ... } // return true if found

  public static <E> E search(E[] array) {
      return new Searcher<E>(null, array, new AtomicReference<E>(), 0, array.length).invoke();
  }
}

この例では、タスクが共通の結果をcompareAndSet以外に他の効果を持たない他のタスクと同様に、ルート・タスクの完了後に完了を管理するためにブックキーピングが必要ないため、tryCompleteの末尾の無条件呼出しを条件付き(if (result.get() == null) tryComplete();)にできます。

サブタスクの記録。 複数のサブタスクの結果を結合するCountedCompleterタスクは、通常、onCompletion(CountedCompleter)メソッドでこれらの結果にアクセスする必要があります。次の(マッピングとリダクションの型がすべてEである簡易形式のマップ・リデュースを実行する)クラスに示すように、分割統治型の設計でこれを行う方法の1つは、各サブタスクにその兄弟を記録させ、onCompletionメソッドでそれにアクセスできるようにすることです。この手法は、左と右の結果を結合する順序が問題にならないようなリダクションに適用されます。順序付けされたリダクションでは、左と右を明示的に指定する必要があります。前の例に示した他の合理化方法のバリアントを適用することもできます。

class MyMapper<E> { E apply(E v) {  ...  } }
class MyReducer<E> { E apply(E x, E y) {  ...  } }
class MapReducer<E> extends CountedCompleter<E> {
  final E[] array; final MyMapper<E> mapper;
  final MyReducer<E> reducer; final int lo, hi;
  MapReducer<E> sibling;
  E result;
  MapReducer(CountedCompleter<?> p, E[] array, MyMapper<E> mapper,
             MyReducer<E> reducer, int lo, int hi) {
    super(p);
    this.array = array; this.mapper = mapper;
    this.reducer = reducer; this.lo = lo; this.hi = hi;
  }
  public void compute() {
    if (hi - lo >= 2) {
      int mid = (lo + hi) >>> 1;
      MapReducer<E> left = new MapReducer(this, array, mapper, reducer, lo, mid);
      MapReducer<E> right = new MapReducer(this, array, mapper, reducer, mid, hi);
      left.sibling = right;
      right.sibling = left;
      setPendingCount(1); // only right is pending
      right.fork();
      left.compute();     // directly execute left
    }
    else {
      if (hi > lo)
          result = mapper.apply(array[lo]);
      tryComplete();
    }
  }
  public void onCompletion(CountedCompleter<?> caller) {
    if (caller != this) {
      MapReducer<E> child = (MapReducer<E>)caller;
      MapReducer<E> sib = child.sibling;
      if (sib == null || sib.result == null)
        result = child.result;
      else
        result = reducer.apply(child.result, sib.result);
    }
  }
  public E getRawResult() { return result; }

  public static <E> E mapReduce(E[] array, MyMapper<E> mapper, MyReducer<E> reducer) {
    return new MapReducer<E>(null, array, mapper, reducer,
                             0, array.length).invoke();
  }
}

ここで、onCompletionメソッドは結果を結合する多くの完了設計に共通する形式を取っています。このコールバック形式のメソッドは、保留カウントがゼロである(またはゼロになる)2つの異なるコンテキストのいずれかで、タスクごとに1回トリガーされます。つまり、(1) tryCompleteの呼出し時にその保留カウントがゼロである場合は、そのタスク自体によってトリガーされ、(2)そのサブタスクのいずれかが完了し、保留カウントをゼロに減らしたときは、そのサブタスクによってトリガーされます。 caller引数はケースを区別します。ほとんどの場合、呼出し側がthisであれば、アクションは不要です。それ以外の場合、caller引数は結合される値(または他の値へのリンク、あるいはその両方)を提供するために(通常はキャストを介して)使用されます。保留カウントが適切に使用されていれば、onCompletion内のアクションはタスクおよびそのサブタスクの完了時に(1回)発生します。このタスクまたは他の完了したタスクのフィールドへのアクセスのスレッド安全性を確保するために、このメソッド内に同期化を追加する必要はありません。

完了のトラバース onCompletionを使用して完了を処理することが不適当または不都合である場合は、firstComplete()およびnextComplete()メソッドを使用してカスタム・トラバースを作成できます。たとえば、3番目のForEachの例の形式で右側のタスクを分割するのみのMapReducerを定義するには、使い果たされていないサブタスクのリンクに沿って完了を協調的にリデュースする必要があり、次のように行うことができます。

class MapReducer<E> extends CountedCompleter<E> { // version 2
  final E[] array; final MyMapper<E> mapper;
  final MyReducer<E> reducer; final int lo, hi;
  MapReducer<E> forks, next; // record subtask forks in list
  E result;
  MapReducer(CountedCompleter<?> p, E[] array, MyMapper<E> mapper,
             MyReducer<E> reducer, int lo, int hi, MapReducer<E> next) {
    super(p);
    this.array = array; this.mapper = mapper;
    this.reducer = reducer; this.lo = lo; this.hi = hi;
    this.next = next;
  }
  public void compute() {
    int l = lo, h = hi;
    while (h - l >= 2) {
      int mid = (l + h) >>> 1;
      addToPendingCount(1);
      (forks = new MapReducer(this, array, mapper, reducer, mid, h, forks)).fork();
      h = mid;
    }
    if (h > l)
      result = mapper.apply(array[l]);
    // process completions by reducing along and advancing subtask links
    for (CountedCompleter<?> c = firstComplete(); c != null; c = c.nextComplete()) {
      for (MapReducer t = (MapReducer)c, s = t.forks; s != null; s = t.forks = s.next)
        t.result = reducer.apply(t.result, s.result);
    }
  }
  public E getRawResult() { return result; }

  public static <E> E mapReduce(E[] array, MyMapper<E> mapper, MyReducer<E> reducer) {
    return new MapReducer<E>(null, array, mapper, reducer,
                             0, array.length, null).invoke();
  }
}

トリガー。 CountedCompleterの中には、それ自体はフォークされないが、かわりに他の設計の構成要素の一部として機能するものがあります。これには、1つ以上の非同期タスクの完了が別の非同期タスクをトリガーするCountedCompleterが含まれます。たとえば、

class HeaderBuilder extends CountedCompleter<...> { ... }
class BodyBuilder extends CountedCompleter<...> { ... }
class PacketSender extends CountedCompleter<...> {
  PacketSender(...) { super(null, 1); ... } // trigger on second completion
  public void compute() { } // never called
  public void onCompletion(CountedCompleter<?> caller) { sendPacket(); }
}
// sample use:
PacketSender p = new PacketSender();
new HeaderBuilder(p, ...).fork();
new BodyBuilder(p, ...).fork();

導入されたバージョン:

1.8

関連項目:

ネストされたクラスのサマリー

インタフェースFutureで宣言されたネストされたクラス/インタフェース
Future.State

修飾子と型

インタフェース

説明

static enum

Future.State

計算状態を表します。
コンストラクタのサマリー

コンストラクタ

修飾子

コンストラクタ

説明

protected

CountedCompleter()

コンプリータを持たず、初期の保留カウントがゼロである新しいCountedCompleterを作成します。

protected

CountedCompleter(CountedCompleter<?> completer)

指定されたコンプリータと、保留カウントの初期値ゼロを使用して、新しいCountedCompleterを作成します。

protected

CountedCompleter(CountedCompleter<?> completer, int initialPendingCount)

指定されたコンプリータと初期保留カウントを使用して、新しいCountedCompleterを作成します。
メソッドのサマリー

修飾子と型

メソッド

説明

final void

addToPendingCount(int delta)

指定された値を保留カウントに(原子的に)追加します。

final boolean

compareAndSetPendingCount(int expected, int count)

保留カウントが指定された予想値を現在保持している場合にのみ、保留カウントを指定されたカウントに(原子的に)設定します。

void

complete(T rawResult)

保留カウントに関係なく、onCompletion(CountedCompleter)を呼び出し、このタスクを完了したものとしてマークし、さらにこのタスクのコンプリータに対してtryComplete()をトリガーします(存在する場合)。

abstract void

compute()

このタスクによって実行される主な計算です。

final int

decrementPendingCountUnlessZero()

保留カウントがゼロ以外の場合に、それを(原子的に)減分します。

protected final boolean

exec()

CountedCompleterの実行規則を実装します。

final CountedCompleter<?>

firstComplete()

このタスクの保留カウントがゼロの場合は、このタスクを返します。それ以外の場合は、その保留カウントを減分し、nullを返します。

final CountedCompleter<?>

getCompleter()

このタスクのコンストラクタで確立されたコンプリータがある場合はそれを返し、ない場合はnullを返します。

final int

getPendingCount()

現在の保留カウントを返します。

T

getRawResult()

計算の結果を返します。

final CountedCompleter<?>

getRoot()

現在の計算のルートを返します。つまり、このタスクにコンプリータがない場合はこのタスクを返し、それ以外の場合はそのコンプリータのルートを返します。

final void

helpComplete(int maxTasks)

このタスクが完了していない場合に、このタスクがその完了パスに含まれる他の未処理タスクの処理を、指定された数を限度に試行します(そのようなタスクが存在することがわかっている場合)。

final CountedCompleter<?>

nextComplete()

このタスクにコンプリータがない場合は、ForkJoinTask.quietlyComplete()を呼び出し、nullを返します。

void

onCompletion(CountedCompleter<?> caller)

メソッドtryComplete()が呼び出されたときに保留カウントがゼロの場合、または無条件メソッドcomplete(T)が呼び出された場合、アクションを実行します。

boolean

onExceptionalCompletion(Throwable ex, CountedCompleter<?> caller)

メソッドForkJoinTask.completeExceptionally(Throwable)が呼び出されたかメソッドcompute()が例外をスローしたときに、このタスクがまだ正常に完了していない場合、アクションを実行します。

final void

propagateCompletion()

tryComplete()と同等ですが、完了パスに沿ってonCompletion(CountedCompleter)を呼び出しません。保留カウントがゼロ以外の場合は、カウントを減分します。そうでない場合は、同様にこのタスクのコンプリータを完了しようとし、コンプリータが存在しない場合はこのタスクを完了したものとしてマークします。

final void

quietlyCompleteRoot()

getRoot().quietlyComplete()と同等です。

final void

setPendingCount(int count)

保留カウントを指定された値に設定します。

protected void

setRawResult(T t)

結果を生成するCountedCompleterが結果データを保持するためにオプションで使用するメソッドです。

final void

tryComplete()

保留カウントがゼロでない場合は、そのカウントを減らします。それ以外の場合は、onCompletion(CountedCompleter)を呼び出した後、このタスクのコンプリータが存在する場合は、同様にその実行を試み、存在しない場合は、このタスクを完了したものとしてマークします。

クラスで宣言されたメソッド ForkJoinTask
adapt, adapt, adapt, adaptInterruptible, adaptInterruptible, adaptInterruptible, cancel, compareAndSetForkJoinTaskTag, completeExceptionally, exceptionNow, fork, get, get, getException, getForkJoinTaskTag, getPool, getQueuedTaskCount, getSurplusQueuedTaskCount, helpQuiesce, inForkJoinPool, invoke, invokeAll, invokeAll, invokeAll, isCancelled, isCompletedAbnormally, isCompletedNormally, isDone, join, peekNextLocalTask, pollNextLocalTask, pollSubmission, pollTask, quietlyComplete, quietlyInvoke, quietlyJoin, quietlyJoin, quietlyJoinUninterruptibly, reinitialize, resultNow, setForkJoinTaskTag, state, tryUnfork

修飾子と型

メソッド

説明

static ForkJoinTask<?>

adapt(Runnable runnable)

指定されたRunnableのrunメソッドをアクションとして実行する新しいForkJoinTaskを返し、ForkJoinTask.join()実行時にnullの結果を返します。

static <T> ForkJoinTask<T>

adapt(Runnable runnable, T result)

指定されたRunnableのrunメソッドをアクションとして実行する新しいForkJoinTaskを返し、ForkJoinTask.join()実行時に指定された結果を返します。

static <T> ForkJoinTask<T>

adapt(Callable<? extends T> callable)

指定されたCallableのcallメソッドをアクションとして実行する新しいForkJoinTaskを返し、その結果をForkJoinTask.join()実行時に返し、発生したチェック例外をRuntimeExceptionに変換します。

static ForkJoinTask<?>

adaptInterruptible(Runnable runnable)

指定されたRunnableの runメソッドをアクションとして実行する新しいForkJoinTaskを返し、ForkJoinTask.join()でnullを返し、検出されたチェック例外をRuntimeExceptionに変換します。

static <T> ForkJoinTask<T>

adaptInterruptible(Runnable runnable, T result)

指定されたRunnableのrunメソッドをアクションとして実行する新しいForkJoinTaskを返し、ForkJoinTask.join()で指定した結果を返し、検出されたチェック例外をRuntimeExceptionに変換します。

static <T> ForkJoinTask<T>

adaptInterruptible(Callable<? extends T> callable)

指定されたCallableのcallメソッドをアクションとして実行する新しいForkJoinTaskを返し、その結果をForkJoinTask.join()実行時に返し、発生したチェック例外をRuntimeExceptionに変換します。

boolean

cancel(boolean mayInterruptIfRunning)

このタスクの実行の取消しを試みます。

final boolean

compareAndSetForkJoinTaskTag(short expect, short update)

このタスクのタグ値を原子的に条件付きで設定します。

void

completeExceptionally(Throwable ex)

このタスクを強制的に実行し、中断または取り消しされていない場合は、joinおよび関連の操作の実行時に指定された例外がスローされます。

Throwable

exceptionNow()

待機せずにタスクによってスローされた例外を返します。

final ForkJoinTask<T>

fork()

現在のタスクが実行されているプール内でこのタスクを非同期に実行するように手配します。該当する場合は、ForkJoinTask.inForkJoinPool()を使用し、そうでない場合、ForkJoinPool.commonPool()を使用します。

final T

get()

必要に応じて計算が完了するまで待機し、その後、計算結果を取得します。

final T

get(long timeout, TimeUnit unit)

必要に応じて、最大で指定された時間、計算が完了するまで待機し、その後、計算結果が利用可能な場合は結果を取得します。

final Throwable

getException()

基本計算によってスローされた例外を返します。取り消された場合はCancellationException、ない場合またはメソッドがまだ実行されていない場合はnullを返します。

final short

getForkJoinTaskTag()

このタスクのタグを返します。

static ForkJoinPool

getPool()

現在のスレッドをホストしているプールを返します。現在のスレッドがForkJoinPoolの外部で実行されている場合は、nullを返します。

static int

getQueuedTaskCount()

現在のワーカー・スレッドによってフォークされたが、まだ実行されていないタスクの推定数を返します。

static int

getSurplusQueuedTaskCount()

現在のワーカー・スレッドによって保持されているローカルのキューに入っているタスクが、それを横取りする可能性がある他のワーカー・スレッドよりもどれだけ多いかの推定値を返します。このスレッドがForkJoinPoolで動作していない場合はゼロを返します。

static void

helpQuiesce()

現在のタスク「静止」をホストするプールまで、タスクが実行される可能性があります。

static boolean

inForkJoinPool()

現在のスレッドが、ForkJoinPool計算として実行されるForkJoinWorkerThreadの場合、trueを返します。

final T

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が適用されるか、(チェックされない)例外が発生する場合に復帰します。後者の場合、例外が再スローされます。

final boolean

isCancelled()

このタスクが正常に完了する前に取り消された場合はtrueを返します。

final boolean

isCompletedAbnormally()

このタスクが例外をスローしたか取り消された場合はtrueを返します。

final boolean

isCompletedNormally()

このタスクが例外をスローせずに完了し、取り消されなかった場合はtrueが返されます。

final boolean

isDone()

このタスクが完了した場合はtrueを返します。

final T

join()

「完了」の場合の計算結果を返します。

protected static ForkJoinTask<?>

peekNextLocalTask()

現在のスレッドによってキューに入れられたがまだ実行されていないタスクがすぐに使用できる場合、そのタスクを返し、スケジュール解除や実行は行いません。

protected static ForkJoinTask<?>

pollNextLocalTask()

現在のスレッドがForkJoinPoolで動作している場合に、現在のスレッドによってキューに入れられたがまだ実行されていない次のタスクを、実行せずにスケジュール解除して復帰します。

protected static ForkJoinTask<?>

pollSubmission()

現在のスレッドがForkJoinPoolで動作している場合、スケジュールを解除し、実行せずに、プールに外部に送信されたタスク(使用可能な場合)を返します。

protected static ForkJoinTask<?>

pollTask()

現在のスレッドがForkJoinPoolで動作しており、現在のスレッドによってキューに入れられたがまだ実行されていない次のタスクが使用可能な場合、そのタスクを実行せずにスケジュール解除して復帰します。そのようなタスクが使用可能でない場合は、他のスレッドによってフォークされたタスクが対象になります(使用可能な場合)。

final void

quietlyComplete()

値を設定せずにこのタスクを正常に完了します。

final void

quietlyInvoke()

このタスクの実行を開始し、必要な場合は完了まで待機しますが、その結果を返したり例外をスローしたりしません。

final void

quietlyJoin()

このタスクを結合し、その結果を返したり例外をスローしたりしません。

final boolean

quietlyJoin(long timeout, TimeUnit unit)

このタスクへの参加を試みます。指定されたタイムアウトが経過し、現在のスレッドが中断されていないときに(例外的に)が完了した場合はtrueを返します。

final boolean

quietlyJoinUninterruptibly(long timeout, TimeUnit unit)

このタスクへの参加を試みます。指定されたタイムアウトが経過する前に(例外的に)を完了した場合はtrueを返します。

void

reinitialize()

このタスクの内部登録状態をリセットし、後続のforkを許可します。

T

resultNow()

計算された結果を待たずに返します。

final short

setForkJoinTaskTag(short newValue)

このタスクのタグ値を原子的に設定し、古い値を返します。

Future.State

state()

計算状態を返します。

boolean

tryUnfork()

このタスクの実行のスケジュール解除を試みます。

クラスオブジェクトで宣言されたメソッド
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

修飾子と型

メソッド

説明

protected Object

clone()

このオブジェクトのコピーを作成して、返します。

boolean

equals(Object obj)

このオブジェクトと他のオブジェクトが等しいかどうかを示します。

protected void

finalize()

削除予定のため非推奨: このAPI要素は、将来のバージョンで削除される可能性があります。
最終決定は非推奨であり、将来のリリースで削除される可能性があります。

final Class<?>

getClass()

このObjectの実行時クラスを返します。

int

hashCode()

このオブジェクトに対するハッシュ・コード値を返します。

final void

notify()

このオブジェクトのモニターで待機中のスレッドを1つ再開します。

final void

notifyAll()

このオブジェクトのモニターで待機中のすべてのスレッドを再開します。

String

toString()

オブジェクトの文字列表現を返します。

final void

wait()

現在のスレッドが目覚めるまで待機します。通常、notifiedまたはinterruptedです。

final void

wait(long timeoutMillis)

現在のスレッドは、通常、notifiedまたはinterruptedであるか、一定のリアルタイムが経過するまで、目覚めるまで待機します。

final void

wait(long timeoutMillis, int nanos)

現在のスレッドは、通常、notifiedまたはinterruptedであるか、一定のリアルタイムが経過するまで、目覚めるまで待機します。

コンストラクタの詳細
- CountedCompleter
  
  protected CountedCompleter(CountedCompleter<?> completer, int initialPendingCount)
  
  指定されたコンプリータと初期保留カウントを使用して、新しいCountedCompleterを作成します。
  
  パラメータ:
  
  completer - このタスクのコンプリータ。存在しない場合はnull
  
  initialPendingCount - 初期の保留カウント
- CountedCompleter
  
  protected CountedCompleter(CountedCompleter<?> completer)
  
  指定されたコンプリータと、保留カウントの初期値ゼロを使用して、新しいCountedCompleterを作成します。
  
  パラメータ:
  
  completer - このタスクのコンプリータ。存在しない場合はnull
- CountedCompleter
  
  protected CountedCompleter()
  
  コンプリータを持たず、初期の保留カウントがゼロである新しいCountedCompleterを作成します。
メソッドの詳細
- compute
  
  public abstract void compute()
  
  このタスクによって実行される主な計算です。
- onCompletion
  
  public void onCompletion(CountedCompleter<?> caller)
  
  メソッドtryComplete()が呼び出されたときに保留カウントがゼロの場合、または無条件メソッドcomplete(T)が呼び出された場合、アクションを実行します。デフォルトでは、このメソッドは何も行いません。指定された呼出し側引数の識別情報を確認することで、ケースを区別できます。 thisと等しくない場合は、通常、結合する結果(または他の結果へのリンク、あるいはその両方)を含む可能性があるサブタスクです。
  
  パラメータ:
  
  caller - このメソッドを呼び出しているタスク(このタスク自体である場合もある)
- onExceptionalCompletion
  
  public boolean onExceptionalCompletion(Throwable ex, CountedCompleter<?> caller)
  
  メソッドForkJoinTask.completeExceptionally(Throwable)が呼び出されたかメソッドcompute()が例外をスローしたときに、このタスクがまだ正常に完了していない場合、アクションを実行します。このメソッドに入ったときは、このタスクはForkJoinTask.isCompletedAbnormally() (異常な状態での完了)になります。このメソッドの戻り値は、さらなる伝播を左右します。戻り値がtrueで、このタスクが完了していないコンプリータを持っている場合は、そのコンプリータもこのコンプリータと同じ例外で完了します。このメソッドのデフォルト実装は、trueを返す以外何もしません。
  
  パラメータ:
  
  ex - 例外
  
  caller - このメソッドを呼び出しているタスク(このタスク自体である場合もある)
  
  戻り値:
  
  この例外をこのタスクのコンプリータ(存在する場合)に伝播する必要がある場合はtrue。
- getCompleter
  
  public final CountedCompleter<?> getCompleter()
  
  このタスクのコンストラクタで確立されたコンプリータがある場合はそれを返し、ない場合はnullを返します。
  
  戻り値:
  
  コンプリータ
- getPendingCount
  
  public final int getPendingCount()
  
  現在の保留カウントを返します。
  
  戻り値:
  
  現在の保留カウント
- setPendingCount
  
  public final void setPendingCount(int count)
  
  保留カウントを指定された値に設定します。
  
  パラメータ:
  
  count - カウント
- addToPendingCount
  
  public final void addToPendingCount(int delta)
  
  指定された値を保留カウントに(原子的に)追加します。
  
  パラメータ:
  
  delta - 追加する値
- compareAndSetPendingCount
  
  public final boolean compareAndSetPendingCount(int expected, int count)
  
  保留カウントが指定された予想値を現在保持している場合にのみ、保留カウントを指定されたカウントに(原子的に)設定します。
  
  パラメータ:
  
  expected - 予想値
  
  count - 新しい値
  
  戻り値:
  
  成功した場合はtrue
- decrementPendingCountUnlessZero
  
  public final int decrementPendingCountUnlessZero()
  
  保留カウントがゼロ以外の場合に、それを(原子的に)減分します。
  
  戻り値:
  
  このメソッドに入ったときに保持される初期の(減分されていない)保留カウント
- getRoot
  
  public final CountedCompleter<?> getRoot()
  
  現在の計算のルートを返します。つまり、このタスクにコンプリータがない場合はこのタスクを返し、それ以外の場合はそのコンプリータのルートを返します。
  
  戻り値:
  
  現在の計算のルート
- tryComplete
  
  public final void tryComplete()
  
  保留カウントがゼロでない場合は、そのカウントを減らします。それ以外の場合は、onCompletion(CountedCompleter)を呼び出した後、このタスクのコンプリータが存在する場合は、同様にその実行を試み、存在しない場合は、このタスクを完了したものとしてマークします。
- propagateCompletion
  
  public final void propagateCompletion()
  
  tryComplete()と同等ですが、完了パスに沿ってonCompletion(CountedCompleter)を呼び出しません。保留カウントがゼロ以外の場合は、カウントを減分します。そうでない場合は、同様にこのタスクのコンプリータを完了しようとし、コンプリータが存在しない場合はこのタスクを完了したものとしてマークします。このメソッドは、計算内の各コンプリータに対してonCompletionを呼び出すことができない(または必要でない)場合に役立つことがあります。
- complete
  
  public void complete(T rawResult)
  
  保留カウントに関係なく、onCompletion(CountedCompleter)を呼び出し、このタスクを完了したものとしてマークし、さらにこのタスクのコンプリータに対してtryComplete()をトリガーします(存在する場合)。指定されたrawResultは、onCompletion(CountedCompleter)を呼び出すか、またはこのタスクを完了したものとしてマークする前に、setRawResult(T)への引数として使用されます。その値は、setRawResultをオーバーライドするクラスでのみ有効です。このメソッドは保留カウントを変更しません。
  このメソッドは、複数のサブタスクの結果の(すべてではなく)いずれかが取得された直後に強制的に完了する場合に役立つことがあります。ただし、 setRawResultがオーバーライドされない一般的な(推奨)の場合、この効果はquietlyCompleteRoot()を使用してより簡単に取得できます。
  
  オーバーライド:
  
  complete、クラスForkJoinTask<T>
  
  パラメータ:
  
  rawResult - 生の結果
- firstComplete
  
  public final CountedCompleter<?> firstComplete()
  
  このタスクの保留カウントがゼロの場合は、このタスクを返します。それ以外の場合は、その保留カウントを減分し、nullを返します。このメソッドは、完了トラバース・ループでnextComplete()とともに使用するように設計されています。
  
  戻り値:
  
  保留カウントがゼロだった場合はこのタスク。それ以外の場合はnull
- nextComplete
  public final CountedCompleter<?> nextComplete()
  
  このタスクにコンプリータがない場合は、ForkJoinTask.quietlyComplete()を呼び出し、nullを返します。または、コンプリータの保留カウントがゼロ以外の場合は、その保留カウントを減分し、nullを返します。それ以外の場合は、コンプリータを返します。このメソッドは、同種類のタスク階層に対する完了トラバース・ループの一部として使用できます。
  for (CountedCompleter<?> c = firstComplete(); c != null; c = c.nextComplete()) { // ... process c ... }
  
  戻り値:
  
  コンプリータ。存在しない場合はnull
- quietlyCompleteRoot
  
  public final void quietlyCompleteRoot()
  
  getRoot().quietlyComplete()と同等です。
- helpComplete
  
  public final void helpComplete(int maxTasks)
  
  このタスクが完了していない場合に、このタスクがその完了パスに含まれる他の未処理タスクの処理を、指定された数を限度に試行します(そのようなタスクが存在することがわかっている場合)。
  
  パラメータ:
  
  maxTasks - 処理するタスクの最大数。ゼロまたはそれより小さい場合、タスクは処理されない。
- exec
  
  protected final boolean exec()
  
  CountedCompleterの実行規則を実装します。
  
  定義:
  
  exec、クラスForkJoinTask<T>
  
  戻り値:
  
  このタスクが正常に完了したことがわかっている場合はtrue
- getRawResult
  
  public T getRawResult()
  
  計算の結果を返します。デフォルトでは、Voidアクションに適したnullを返しますが、それ以外の場合は、ほとんどの場合、完了時に結果を保持するフィールドのフィールドまたは関数を返すようにオーバーライドする必要があります。
  
  定義:
  
  getRawResult、クラスForkJoinTask<T>
  
  戻り値:
  
  計算の結果
- setRawResult
  
  protected void setRawResult(T t)
  
  結果を生成するCountedCompleterが結果データを保持するためにオプションで使用するメソッドです。デフォルトでは、何もしません。オーバーライドはお薦めしません。ただし、このメソッドをオーバーライドして既存のオブジェクトまたはフィールドを更新する場合は、一般にこのメソッドをスレッド・セーフになるように定義する必要があります。
  
  定義:
  
  setRawResult、クラスForkJoinTask<T>
  
  パラメータ:
  
  t - 値

クラスCountedCompleter<T>

ネストされたクラスのサマリー

インタフェースFutureで宣言されたネストされたクラス/インタフェース

コンストラクタのサマリー

メソッドのサマリー

クラスで宣言されたメソッド ForkJoinTask

クラスオブジェクトで宣言されたメソッド

コンストラクタの詳細

CountedCompleter

CountedCompleter

CountedCompleter

メソッドの詳細

compute

onCompletion

onExceptionalCompletion

getCompleter

getPendingCount

setPendingCount

addToPendingCount

compareAndSetPendingCount

decrementPendingCountUnlessZero

getRoot

tryComplete

propagateCompletion

complete

firstComplete

nextComplete

quietlyCompleteRoot

helpComplete

exec

getRawResult

setRawResult