CountedCompleter クラス
定義
重要
一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない ForkJoinTask 。
[Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public abstract class CountedCompleter : Java.Util.Concurrent.ForkJoinTask[<Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
type CountedCompleter = class
inherit ForkJoinTask- 継承
- 属性
注釈
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない ForkJoinTask 。 CountedCompleters は、一般に、他の形式の ForkJoinTasks よりもサブタスクのストールとブロックが存在する場合の方が堅牢ですが、プログラムの直感的性は低くなります。 CountedCompleter の使用は、他の完了ベースのコンポーネント ( java.nio.channels.CompletionHandler など) と似ていますが、複数の <em>pending</em> 完了が、完了アクション #onCompletion(CountedCompleter)をトリガーするために必要になる場合があります。 初期化されない限り、#getPendingCount 保留中のカウントは 0 から始まりますが、 #setPendingCount、 #addToPendingCount、および #compareAndSetPendingCountメソッドを使用して (アトミックに) 変更される可能性があります。
#tryCompleteの呼び出し時に、保留中のアクション数が 0 以外の場合はデクリメントされます。それ以外の場合は完了アクションが実行され、この完了者自体に完了がある場合は、その完了処理が続行されます。
PhaserやSemaphoreなどの関連する同期コンポーネントの場合と同様に、これらのメソッドは内部カウントにのみ影響します。それ以上の内部ブックキーピングは確立されません。 特に、保留中のタスクの ID は保持されません。 次に示すように、必要に応じて保留中のタスクまたはその結果の一部またはすべてを記録するサブクラスを作成できます。 次に示すように、完了トラバーサルのカスタマイズをサポートするユーティリティ メソッドも提供されています。 ただし、CountedCompleters では基本的な同期メカニズムのみが提供されるため、関連する一連の使用法に適したリンケージ、フィールド、追加のサポート メソッドを維持する抽象サブクラスをさらに作成すると便利な場合があります。
具体的な CountedCompleter クラスでは、メソッド #computeを定義する必要があります。ほとんどの場合 (次に示すように)、戻る前に tryComplete() を 1 回呼び出す必要があります。 このクラスは、通常の完了時にアクションを実行するメソッド #onCompletion(CountedCompleter) を必要に応じてオーバーライドし、例外時にアクションを実行するメソッド #onExceptionalCompletion(Throwable, CountedCompleter) することもできます。
CountedCompleters はほとんどの場合、結果を保持しません。その場合、通常は CountedCompleter<Void>として宣言され、常に結果値として null が返されます。 それ以外の場合は、メソッド #getRawResult をオーバーライドして、 join(), invoke()および関連するメソッドの結果を提供する必要があります。 通常、このメソッドは、完了時に結果を保持する CountedCompleter オブジェクトのフィールド (または 1 つ以上のフィールドの関数) の値を返す必要があります。 CountedCompleters では、既定で #setRawResult メソッドは役割を果たしません。 結果データを保持する他のオブジェクトまたはフィールドを維持するために、このメソッドをオーバーライドすることは可能ですが、ほとんど適用できません。
それ自体が完了していない CountedCompleter (つまり、 #getCompleter が nullを返す関数) は、この追加機能を備えた通常の ForkJoinTask として使用できます。 ただし、別の完了者を持つすべての完了者は、他の計算の内部ヘルパーとしてのみ機能するため、( ForkJoinTask#isDone などのメソッドで報告される) 独自のタスクの状態は任意です。この状態は、 #complete、 ForkJoinTask#cancel、 ForkJoinTask#completeExceptionally(Throwable) の明示的な呼び出し、またはメソッド computeの例外的な完了時にのみ変化します。 例外的な完了時に、例外が存在し、それ以外の場合は完了していない場合は、タスクの完了者 (およびその完了者など) に中継される可能性があります。 同様に、CountedCompleter の内部を取り消す場合は、そのコンプリートに対してローカルな影響しか与えないため、あまり役に立ちません。
<b>Sample Usages.</b>
<b>Parallel 再帰分解.</b> CountedCompleters は、 RecursiveActionでよく使用されるツリーと同様のツリーに配置できますが、通常、設定に関係する構造は異なります。 ここで、各タスクの完了者は、計算ツリー内の親です。 彼らは少し多くのブックキーピングを伴うが、CountedCompletersは、おそらく時間のかかる操作(それ以上分割することはできません)を配列またはコレクションの各要素に適用する際のより良い選択肢かもしれません。特に、組み込みのバリエーション (I/O など) やガベージ コレクションなどの補助効果が原因で、一部の要素に対して操作の完了に著しく異なる時間がかかる場合。 CountedCompleters は独自の継続を提供するため、他のタスクが実行を待機するのをブロックする必要はありません。
たとえば、2 除算再帰分解を使用して作業を 1 つの部分 (リーフ タスク) に分割するユーティリティ メソッドの初期バージョンを次に示します。 作業が個々の呼び出しに分割されている場合でも、通常、ツリーベースの手法は、スレッド間通信を減らし、負荷分散を向上させるので、リーフ タスクを直接フォークすることをお勧めします。 再帰的なケースでは、終了するサブタスクの各ペアの 2 番目のサブタスクは、親の完了をトリガーします (結果の組み合わせが実行されないため、メソッド onCompletion の既定の no-op 実装はオーバーライドされません)。 ユーティリティ メソッドはルート タスクを設定し、それを呼び出します (ここでは、 ForkJoinPool#commonPool()を暗黙的に使用します)。 保留中の数を子タスクの数に常に設定し、戻る直前に tryComplete() を呼び出すことは、単純で信頼性が高い (ただし最適ではありません)。
{@code
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();
}}
この設計を改善するには、再帰的なケースでは、タスクが右のタスクをフォークした後に何もする必要がないため、戻る前に左のタスクを直接呼び出すことができます。 (これは、テール 再帰の削除のアナログです)。また、タスクの最後のアクションがサブタスクをフォークまたは呼び出す場合 ("テール コール") は、保留中のカウントを "1 つずつオフ" にすることで、 tryComplete() の呼び出しを最適化できます。
{@code
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に置き換えることができます。
{@code
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();
}}
保留中のカウントを事前計算できる場合は、コンストラクターで確立できます。
{@code
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 つで分割し、常に単一の要素に分割するのではなく、アダプティブしきい値を使用します。
<b>Searching.</b> CountedCompleters のツリーは、データ構造のさまざまな部分で値またはプロパティを検索し、見つかったらすぐに java.util.concurrent.atomic.AtomicReference AtomicReference 結果を報告できます。 他のユーザーは、不要な作業を回避するために結果をポーリングできます。 (さらに、他のタスクを取り消 #cancel 可能性がありますが、通常は、結果が設定されていることに気付き、それ以上の処理をスキップする方が簡単で効率的です)。完全なパーティション分割を使用して配列を再度示します (実際には、リーフ タスクはほとんどの場合、複数の要素を処理します)。
{@code
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();) にすることができます。
<b>Recording subtasks.</b> 複数のサブタスクの結果を結合する CountedCompleter タスクは、通常、メソッド #onCompletion(CountedCompleter)でこれらの結果にアクセスする必要があります。 次のクラスに示すように (マッピングと縮小がすべて E型である map-reduce の簡略化された形式を実行します)、分割およびコンカーデザインでこれを行う方法の 1 つは、各サブタスクがその兄弟を記録して、メソッド onCompletionでアクセスできるようにすることです。 この手法は、左右の結果を組み合わせる順序が重要ではない削減に適用されます。順序付けされた削減には、明示的な左または右の指定が必要です。 上記の例で見られる他の合理化のバリエーションも適用される場合があります。
{@code
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 は、結果を組み合わせた多くの完成設計に共通する形式を取ります。 このコールバック スタイルのメソッドは、保留中のカウントが 0 になる 2 つの異なるコンテキストのいずれかで、タスクごとに 1 回トリガーされます。(1) タスク自体は、 tryCompleteの呼び出し時に保留中のカウントが 0 の場合、または (2) いずれかのサブタスクが完了して保留中のカウントを 0 にデクリメントします。
caller引数はケースを区別します。 ほとんどの場合、呼び出し元が this場合、アクションは必要ありません。 それ以外の場合は、呼び出し元の引数を (通常はキャストを介して) 使用して、結合する値 (および/または他の値へのリンク) を指定できます。 保留中のカウントを適切に使用すると、 onCompletion 内のアクションは、タスクとそのサブタスクの完了時に (1 回) 発生します。 このメソッド内では、このタスクまたはその他の完了したタスクのフィールドへのアクセスのスレッド セーフを確保するために、追加の同期は必要ありません。
<b>Completion Traversals.</b>onCompletion を使用して完了を処理することが不可能または不便な場合は、 #firstComplete メソッドと #nextComplete を使用してカスタム トラバーサルを作成できます。 たとえば、3 番目の ForEach の例の形式で右側のタスクのみを分割する MapReducer を定義するには、次のように実行できる、不足していないサブタスク リンクに沿って補完を協調的に減らす必要があります。
{@code
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();
}
}}
<b>Triggers.</b> CountedCompleters 自体がフォークされることはありませんが、代わりに他の設計では、1 つ以上の非同期タスクの完了によって別の非同期タスクがトリガーされるものも含め、配管のビットとして機能します。 例えば次が挙げられます。
{@code
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 で追加されました。
このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。
コンストラクター
| 名前 | 説明 |
|---|---|
| CountedCompleter() |
新しい CountedCompleter を作成します。完了者はなく、最初の保留中のカウントは 0 です。 |
| CountedCompleter(CountedCompleter, Int32) |
指定された完了者と初期保留中のカウントを使用して、新しい CountedCompleter を作成します。 |
| CountedCompleter(CountedCompleter) |
新しい CountedCompleter を作成し、指定された完了者と最初の保留中のカウントを 0 に設定します。 |
| CountedCompleter(IntPtr, JniHandleOwnership) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
プロパティ
| 名前 | 説明 |
|---|---|
| Class |
この |
| Completer |
このタスクのコンストラクターで確立されたコンプリートを返します。存在しない場合は |
| Exception |
基本計算によってスローされた例外、または取り消された場合は |
| ForkJoinTaskTag |
このタスクのタグを返します。 (継承元 ForkJoinTask) |
| Handle |
基になる Android インスタンスへのハンドル。 (継承元 Object) |
| IsCancelled |
このタスクが正常に完了する前に取り消された場合は、 |
| IsCompletedAbnormally |
このタスクが例外をスローした場合、または取り消された場合に |
| IsCompletedNormally |
このタスクが例外をスローせずに完了し、取り消されなかった場合に |
| IsDone |
このタスクが完了した場合 |
| JniIdentityHashCode |
相互運用ランタイムによってこのJava ピアに割り当てられた ID ハッシュ コードを取得します。 (継承元 Object) |
| JniManagedPeerState |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| JniPeerMembers |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| PeerReference |
このJava ピアの JNI オブジェクト参照を取得します。 (継承元 Object) |
| PendingCount |
現在の保留中の数を返します。 または、保留中のカウントを指定された値に設定します。 |
| RawRawResult |
このタスクが異常に完了した場合でも、 Join()によって返される結果を返します。このタスクが完了していない場合は |
| RawResult |
計算の結果を返します。 |
| Root |
現在の計算のルートを返します。i. |
| ThresholdClass |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| ThresholdType |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
メソッド
| 名前 | 説明 |
|---|---|
| AddToPendingCount(Int32) |
指定された値を保留中のカウントに (アトミックに) 追加します。 |
| Cancel(Boolean) |
このタスクの実行を取り消そうとします。 (継承元 ForkJoinTask) |
| Clone() |
このオブジェクトのコピーを作成して返します。 (継承元 Object) |
| CompareAndSetForkJoinTaskTag(Int16, Int16) |
このタスクのタグ値をアトミックに条件付きで設定します。 (継承元 ForkJoinTask) |
| CompareAndSetPendingCount(Int32, Int32) |
保留中のカウントを特定のカウントに (アトミックに) 設定するのは、現在指定された期待値を保持している場合のみです。 |
| Complete(Object) |
保留中の数に関係なく、 |
| CompleteExceptionally(Throwable) |
このタスクを異常終了し、まだ中止または取り消されていない場合は、 |
| Compute() |
このタスクによって実行される主な計算。 |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| DecrementPendingCountUnlessZero() |
保留中のカウントが 0 以外の場合、(アトミックに) デクリメントされます。 |
| Dispose() |
このJava ピアによって保持されているリソースを解放します。 (継承元 Object) |
| Dispose(Boolean) |
このJava ピアによって保持されているリソースを解放します。 (継承元 Object) |
| DisposeUnlessReferenced() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| Equals(Object) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| Equals(Object) |
他のオブジェクトがこのオブジェクトと "等しい" かどうかを示します。 (継承元 Object) |
| ExceptionNow() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| Exec() |
CountedCompleters の実行規則を実装します。 |
| FirstComplete() |
このタスクの保留中の数が 0 の場合は、このタスクを返します。それ以外の場合は、保留中のカウントをデクリメントし、 |
| Fork() |
現在のタスクが実行されているプールで非同期的にこのタスクを実行するように配置します (該当する場合)。または |
| Get() |
計算が完了するまで必要に応じて待機し、その結果を取得します。 (継承元 ForkJoinTask) |
| Get(Int64, TimeUnit) |
必要に応じて、計算が完了するまで最大で指定された時間待機し、その結果 (使用可能な場合) を取得します。 (継承元 ForkJoinTask) |
| GetHashCode() |
オブジェクトのハッシュ コード値を返します。 (継承元 Object) |
| HelpComplete(Int32) |
このタスクが完了していない場合は、このタスクが完了パス上にある他の未処理のタスクの数 (存在することが判明している場合) を最大で処理しようとします。 |
| Invoke() |
このタスクの実行を開始し、必要に応じて完了を待機して結果を返すか、基になる計算が実行された場合は (オフの) |
| JavaFinalize() |
古い.
オブジェクトへの参照がなくなったとガベージ コレクションによって判断されたときに、オブジェクトのガベージ コレクターによって呼び出されます。 (継承元 Object) |
| Join() |
#isDone が完了したときに計算の結果を返します。 (継承元 ForkJoinTask) |
| NextComplete() |
このタスクに完了機能がない場合は、 |
| Notify() |
このオブジェクトのモニターで待機している 1 つのスレッドを起動します。 (継承元 Object) |
| NotifyAll() |
このオブジェクトのモニターで待機しているすべてのスレッドを起動します。 (継承元 Object) |
| OnCompletion(CountedCompleter) |
メソッド |
| OnExceptionalCompletion(Throwable, CountedCompleter) |
メソッド |
| PropagateCompletion() |
|
| QuietlyComplete() |
値を設定せずにこのタスクを正常に完了します。 (継承元 ForkJoinTask) |
| QuietlyCompleteRoot() |
|
| QuietlyInvoke() |
このタスクの実行を開始し、必要に応じて完了を待機します。結果を返したり、例外をスローしたりしません。 (継承元 ForkJoinTask) |
| QuietlyJoin() |
結果を返したり、例外をスローしたりせずに、このタスクに参加します。 (継承元 ForkJoinTask) |
| QuietlyJoin(Int64, TimeUnit) |
指定されたタイムアウトの前に完了し、現在のスレッドが中断されていない場合は true を返して、このタスクに参加しようとします。 (継承元 ForkJoinTask) |
| QuietlyJoinUninterruptibly(Int64, TimeUnit) |
このタスクへの参加を試みます。指定されたタイムアウトの前に完了した場合は true を返します (例外が発生する可能性があります)。 (継承元 ForkJoinTask) |
| Reinitialize() |
このタスクの内部ブックキーピング状態をリセットし、後続の |
| ResultNow() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| SetForkJoinTaskTag(Int16) |
このタスクのタグ値をアトミックに設定し、古い値を返します。 (継承元 ForkJoinTask) |
| SetHandle(IntPtr, JniHandleOwnership) |
Handle プロパティを設定します。 (継承元 Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| SetRawResult(Object) |
結果を保持する CountedCompleters が、必要に応じて結果データの維持に使用できるメソッド。 |
| State() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| ToArray<T>() |
このJava配列ラッパーからマネージド配列を作成します。 (継承元 Object) |
| ToString() |
オブジェクトの文字列形式を返します。 (継承元 Object) |
| TryComplete() |
保留中のカウントが 0 以外の場合は、カウントをデクリメントします。それ以外の場合は、 |
| TryUnfork() |
このタスクの実行スケジュールの解除を試みます。 (継承元 ForkJoinTask) |
| UnregisterFromRuntime() |
相互運用ランタイムからこのJava ピアの登録を解除します。 (継承元 Object) |
| Wait() |
現在のスレッドが起動するまで待機します。通常は、 <em>notified</em> または <em>interrupted</em>。 (継承元 Object) |
| Wait(Int64, Int32) |
現在のスレッドは、通常、 <em>notified</em> または <em>interrupted</em>、または一定のリアルタイムが経過するまで、起動されるまで待機します。 (継承元 Object) |
| Wait(Int64) |
現在のスレッドは、通常、 <em>notified</em> または <em>interrupted</em>、または一定のリアルタイムが経過するまで、起動されるまで待機します。 (継承元 Object) |
明示的なインターフェイスの実装
| 名前 | 説明 |
|---|---|
| IJavaPeerable.Disposed() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.Finalized() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.JniObjectReferenceControlBlock |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| IJavaPeerable.UnregisterFromRuntime() |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
拡張メソッド
| 名前 | 説明 |
|---|---|
| GetAsync(IFuture, Int64, TimeUnit) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| GetAsync(IFuture) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| GetJniTypeName(IJavaPeerable) |
インスタンス |
| JavaAs<TResult>(IJavaPeerable) |
|
| JavaCast<TResult>(IJavaObject) |
Android ランタイムチェック型変換を実行します。 |
| JavaCast<TResult>(IJavaObject) |
トリガーされたときに完了アクションが実行され、保留中のアクションが残っていない |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
|