CountedCompleter 클래스
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
ForkJoinTask 트리거될 때 완료 작업이 수행되고 보류 중인 작업이 남아 있지 않은 A입니다.
[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 트리거될 때 완료 작업이 수행되고 보류 중인 작업이 남아 있지 않은 A입니다. CountedCompleter는 일반적으로 다른 형태의 ForkJoinTasks보다 하위 작업 중단 및 막힘이 있는 경우 더 강력하지만 프로그램에는 덜 직관적입니다. CountedCompleter의 사용은 다른 완성 기반 구성 요소(예: java.nio.channels.CompletionHandler)와 유사합니다. 단 하나만이 아니라 완료 작업을 #onCompletion(CountedCompleter)트리거하는 데 여러 <>em 보류</em> 완료가 필요할 수 있다는 점을 제외하면 됩니다. 그렇지 않으면 초기화되지 않는 한 보류 중인 #getPendingCount 개수는 0부터 시작하지만 메서드#setPendingCount#addToPendingCount를 사용하여 (원자성으로) 변경될 수 있습니다#compareAndSetPendingCount. #tryComplete호출 시 보류 중인 작업 수가 0이 아닌 경우 감소됩니다. 그렇지 않으면 완료 작업이 수행되고 이 완료자 자체에 완료자 자체가 있는 경우 프로세스는 완료자를 사용하여 계속됩니다. 이와 같은 Phaser 관련 동기화 구성 요소의 경우와 Semaphore마찬가지로 이러한 메서드는 내부 개수에만 영향을 줍니다. 추가 내부 부기 기능은 설정하지 않습니다. 특히 보류 중인 작업의 ID는 유지 관리되지 않습니다. 아래 그림과 같이 필요한 경우 보류 중인 작업의 일부 또는 전부 또는 그 결과를 기록하는 서브클래스를 만들 수 있습니다. 아래 그림과 같이 완료 통과의 사용자 지정을 지원하는 유틸리티 메서드도 제공됩니다. 그러나 CountedCompleters는 기본 동기화 메커니즘만 제공하므로 링크, 필드 및 관련 사용 집합에 적합한 추가 지원 메서드를 유지하는 추상 하위 클래스를 만드는 것이 유용할 수 있습니다.
구체적인 CountedCompleter 클래스는 메서드를 정의해야 합니다. 이 메서드 #compute는 대부분의 경우(아래 그림 참조) 반환하기 전에 한 번 호출 tryComplete() 해야 합니다. 또한 클래스는 필요에 따라 메서드를 재정 #onCompletion(CountedCompleter) 의하여 정상적인 완료 시 작업을 수행하고 예외 시 작업을 수행하는 메서드 #onExceptionalCompletion(Throwable, CountedCompleter) 를 재정의할 수도 있습니다.
CountedCompleters는 일반적으로 로 선언되고 항상 결과 값으로 CountedCompleter<Void>반환 null 되는 결과를 제공하지 않는 경우가 많습니다. 다른 경우에는 메서드 #getRawResult 를 재정의하여 결과 및 관련 메서드를 join(), invoke()제공해야 합니다. 일반적으로 이 메서드는 완료 시 결과를 보유하는 CountedCompleter 개체의 필드(또는 하나 이상의 필드 함수)의 값을 반환해야 합니다. 기본적으로 메서드 #setRawResult 는 CountedCompleters에서 아무 역할도 하지 않습니다. 결과 데이터를 보유하는 다른 개체 또는 필드를 유지 관리하기 위해 이 메서드를 재정의하는 것은 가능하지만 거의 적용되지 않습니다.
완성기가 없는 CountedCompleter(즉, 반환null되는 #getCompleter 항목)는 이 추가된 기능을 사용하여 일반 ForkJoinTask로 사용할 수 있습니다. 그러나 다른 완료자가 있는 모든 완료자는 다른 계산에 대한 내부 도우미로만 사용되므로 고유한 작업 상태(예: ForkJoinTask#isDone메서드에 보고됨)는 임의 ForkJoinTask#completeExceptionally(Throwable)#completeForkJoinTask#cancel적입니다. 이 상태는 명시적 호출 또는 메서드compute의 예외적 완료 시만 변경됩니다. 예외가 완료되면 예외가 존재하고 아직 완료되지 않은 경우 작업의 완료자(및 완료자 등)에게 릴레이될 수 있습니다. 마찬가지로, 내부 CountedCompleter를 취소하면 해당 완료자에 대한 로컬 효과만 있으므로 유용하지 않은 경우가 많습니다.
<b>샘플 사용법.</b>
<b>병렬 재귀 분해.</b> CountedCompleter는 S와 함께 RecursiveAction자주 사용되는 것과 유사한 트리에 정렬될 수 있지만, 이러한 트리를 설정하는 데 관련된 구조는 일반적으로 다양합니다. 여기서 각 작업의 완료는 계산 트리의 부모입니다. 더 많은 부기 작업이 수반되더라도 CountedCompleters는 배열 또는 컬렉션의 각 요소에 시간이 많이 걸리는 작업(더 이상 세분화할 수 없음)을 적용할 때 더 나은 선택이 될 수 있습니다. 특히 기본 변형(예: I/O) 또는 가비지 수집과 같은 보조 효과로 인해 일부 요소에 대해 완료하는 데 시간이 크게 다른 경우 특히 그렇습니다. CountedCompleters는 고유한 연속 작업을 제공하므로 다른 작업은 수행 대기를 차단할 필요가 없습니다.
예를 들어 다음은 분할-바이-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();
}}
이 디자인은 재귀 사례에서 태스크가 올바른 작업을 포크한 후에는 아무 상관이 없으므로 반환하기 전에 왼쪽 작업을 직접 호출할 수 있다는 사실을 알아차리면 개선될 수 있습니다. (이것은 꼬리 재귀 제거의 아날로그입니다.) 또한 작업의 마지막 작업이 하위 작업("비상 호출")을 포크하거나 호출하는 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();
}
}}
추가 최적화를 통해 왼쪽 작업도 존재하지 않아도 됩니다. 새 작업을 만드는 대신 원래 작업을 계속 사용하고 각 포크에 대해 보류 중인 개수를 추가할 수 있습니다. 또한 이 트리에 메서드 tryComplete 를 구현하는 #onCompletion(CountedCompleter) 작업이 없으므로 .로 #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();
}}
이러한 클래스의 추가 최적화는 리프 단계에 대한 특수 클래스를 수반할 수 있으며, 반복당 두 개 대신 4개를 세분화하고 항상 단일 요소로 세분화하지 않고 적응 임계값을 사용할 수 있습니다.
<b>검색.</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>하위 작업을 기록합니다.</b> 여러 하위 작업의 결과를 결합하는 CountedCompleter 작업은 일반적으로 메서드 #onCompletion(CountedCompleter)에서 이러한 결과에 액세스해야 합니다. 다음 클래스에 설명된 것처럼(매핑 및 감소가 모두 형식 E인 경우 간단한 형태의 지도 축소를 수행함) 분할 및 정복 디자인에서 이 작업을 수행하는 한 가지 방법은 각 하위 작업이 형제를 기록하도록 하여 메서드 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이 되거나 0이 되는 두 가지 컨텍스트 중 하나에서 트리거됩니다. (1) 보류 중인 수가 호출 tryComplete시 0이면 작업 자체에 의해, 또는 (2) 완료하고 보류 중인 수를 0으로 감소할 때 해당 하위 작업 중 하나에 의해 트리거됩니다. 인수는 caller 대/소문자를 구분합니다. 호출자가 호출자일 this때는 아무 작업도 필요하지 않은 경우가 많습니다. 그렇지 않으면 호출자 인수를 사용하여(일반적으로 캐스트를 통해) 결합할 값(및/또는 다른 값에 대한 링크)을 제공할 수 있습니다. 보류 중인 개수를 적절하게 사용한다고 가정하면 작업 및 하위 작업이 완료될 때 내부 onCompletion 작업이 한 번 발생합니다. 이 작업 또는 기타 완료된 작업의 필드에 대한 액세스의 스레드 안전을 보장하기 위해 이 메서드 내에서 추가 동기화가 필요하지 않습니다.
<b>완료 순회.</b> 완료를 처리하는 데 사용할 onCompletion 수 없거나 불편할 경우 메서드 #firstComplete#nextComplete 를 사용하고 사용자 지정 순회를 만들 수 있습니다. 예를 들어 세 번째 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>트리거.</b> 일부 CountedCompleters 자체는 포크되지 않지만 대신 하나 이상의 비동기 작업이 완료되어 다른 비동기 작업을 트리거하는 것을 포함하여 다른 디자인에서 배관의 비트 역할을 합니다. 예시:
{@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에 추가되었습니다.
에 대한 java.util.concurrent.CountedCompleterJava 설명서
이 페이지의 일부는 Android 오픈 소스 프로젝트에서 만들고 공유하고 Creative Commons 2.5 특성 라이선스에 설명된 용어에 따라 사용되는 작업을 기반으로 하는 수정 사항입니다.
생성자
| CountedCompleter() |
완료자가 없고 초기 보류 중인 개수가 0인 새 CountedCompleter를 만듭니다. |
| CountedCompleter(CountedCompleter) |
지정된 완료자와 초기 보류 횟수가 0인 새 CountedCompleter를 만듭니다. |
| CountedCompleter(CountedCompleter, Int32) |
지정된 완료자 및 초기 보류 횟수를 사용하여 새 CountedCompleter를 만듭니다. |
| CountedCompleter(IntPtr, JniHandleOwnership) |
|
속성
| Class |
이 |
| Completer |
이 작업의 생성자에 설정된 완료자를 반환하거나 |
| Exception |
기본 계산에서 throw된 예외 또는 |
| ForkJoinTaskTag |
이 작업의 태그를 반환합니다. (다음에서 상속됨 ForkJoinTask) |
| Handle |
기본 Android 인스턴스에 대한 핸들입니다. (다음에서 상속됨 Object) |
| IsCancelled |
이 작업이 정상적으로 완료되기 전에 취소되었는지를 반환 |
| IsCompletedAbnormally |
이 작업이 예외를 throw했거나 취소된 경우를 반환 |
| IsCompletedNormally |
|
| IsDone |
이 작업이 완료되었는지를 반환합니다 |
| JniIdentityHashCode |
|
| JniPeerMembers |
|
| PeerReference |
|
| PendingCount |
현재 보류 중인 개수를 반환합니다. -또는- 보류 중인 수를 지정된 값으로 설정합니다. |
| RawRawResult |
이 작업이 비정상적으로 완료되었거나 |
| RawResult |
계산 결과를 반환합니다. |
| Root |
현재 계산의 루트를 반환합니다. 나는. |
| ThresholdClass |
|
| ThresholdType |
|
메서드
| AddToPendingCount(Int32) |
지정된 값을 보류 중인 개수에 원자성으로 추가합니다. |
| Cancel(Boolean) |
이 작업의 실행을 취소하려고 시도합니다. (다음에서 상속됨 ForkJoinTask) |
| Clone() |
이 개체의 복사본을 만들고 반환합니다. (다음에서 상속됨 Object) |
| CompareAndSetForkJoinTaskTag(Int16, Int16) |
이 작업의 태그 값을 조건부로 설정합니다. (다음에서 상속됨 ForkJoinTask) |
| CompareAndSetPendingCount(Int32, Int32) |
현재 지정된 예상 값을 보유하는 경우에만 보류 중인 개수를 지정된 개수로 원자성으로 설정합니다. |
| Complete(Object) |
보류 중인 개수에 관계없이 이 작업이 있는 경우 이 작업을 완료로 표시하고 이 작업의 완료자에서 추가 트리거 |
| CompleteExceptionally(Throwable) |
이 작업을 비정상적으로 완료하고, 아직 중단되거나 취소되지 않은 경우 지정된 예외 |
| Compute() |
이 태스크에서 수행하는 기본 계산입니다. |
| DecrementPendingCountUnlessZero() |
보류 중인 수가 0이 아닌 경우(원자성으로) 감소합니다. |
| Dispose() |
|
| Dispose(Boolean) |
|
| Equals(Object) |
다른 개체가 이 개체와 "같음"인지 여부를 나타냅니다. (다음에서 상속됨 Object) |
| Exec() |
CountedCompleters에 대한 실행 규칙을 구현합니다. |
| FirstComplete() |
이 작업의 보류 중인 수가 0이면 이 작업을 반환합니다. 그렇지 않으면 보류 중인 개수가 감소하고 반환됩니다 |
| Fork() |
현재 작업이 실행 중인 풀에서 이 작업을 비동기적으로 실행하도록 정렬합니다(해당하는 경우). 그렇지 않은 |
| Get() |
계산이 완료될 때까지 필요한 경우 대기한 다음 결과를 검색합니다. (다음에서 상속됨 ForkJoinTask) |
| Get(Int64, TimeUnit) |
계산이 완료될 때까지 최대 지정된 시간 동안 필요한 경우 대기한 다음, 사용 가능한 경우 결과를 검색합니다. (다음에서 상속됨 ForkJoinTask) |
| GetHashCode() |
개체에 대한 해시 코드 값을 반환합니다. (다음에서 상속됨 Object) |
| HelpComplete(Int32) |
이 작업이 완료되지 않은 경우 이 태스크가 완료 경로에 있는 처리되지 않은 다른 작업의 최대 개수를 처리하려고 시도합니다(있는 것으로 알려진 경우). |
| Invoke() |
이 작업 수행을 시작하고, 필요한 경우 완료를 기다리고, 결과를 반환하거나,(선택되지 않은) |
| JavaFinalize() |
가비지 수집에서 개체에 대한 참조가 더 이상 없다고 판단할 때 개체의 가비지 수집기에서 호출됩니다. (다음에서 상속됨 Object) |
| Join() |
#isDone 계산이 완료되면 계산 결과를 반환합니다. (다음에서 상속됨 ForkJoinTask) |
| NextComplete() |
이 작업에 completer가 없으면 호출하고 반환합니다 |
| Notify() |
이 개체의 모니터에서 대기 중인 단일 스레드를 해제합니다. (다음에서 상속됨 Object) |
| NotifyAll() |
이 개체의 모니터에서 대기 중인 모든 스레드를 해제합니다. (다음에서 상속됨 Object) |
| OnCompletion(CountedCompleter) |
메서드 |
| OnExceptionalCompletion(Throwable, CountedCompleter) |
메서드가 호출되거나 메서드 |
| PropagateCompletion() |
완료 경로와 |
| QuietlyComplete() |
값을 설정하지 않고 이 작업을 정상적으로 완료합니다. (다음에서 상속됨 ForkJoinTask) |
| QuietlyCompleteRoot() |
|
| QuietlyInvoke() |
이 작업을 시작하고 필요한 경우 결과를 반환하거나 예외를 throw하지 않고 완료를 기다립니다. (다음에서 상속됨 ForkJoinTask) |
| QuietlyJoin() |
결과를 반환하거나 예외를 throw하지 않고 이 작업을 조인합니다. (다음에서 상속됨 ForkJoinTask) |
| Reinitialize() |
이 작업의 내부 부기 상태를 다시 설정하여 후속 |
| SetForkJoinTaskTag(Int16) |
이 작업의 태그 값을 원자성으로 설정하고 이전 값을 반환합니다. (다음에서 상속됨 ForkJoinTask) |
| SetHandle(IntPtr, JniHandleOwnership) |
Handle 속성을 설정합니다. (다음에서 상속됨 Object) |
| SetRawResult(Object) |
결과 베어링 CountedCompleters가 선택적으로 결과 데이터를 유지 관리하는 데 사용할 수 있는 메서드입니다. |
| ToArray<T>() |
|
| ToString() |
개체의 문자열 표현을 반환합니다. (다음에서 상속됨 Object) |
| TryComplete() |
보류 중인 수가 0이 아니면 개수가 감소합니다. 그렇지 않으면 호출한 |
| TryUnfork() |
실행을 위해 이 작업의 일정을 취소하려고 시도합니다. (다음에서 상속됨 ForkJoinTask) |
| UnregisterFromRuntime() |
|
| Wait() |
현재 스레드가 각성될 때까지 대기하게 하며, 일반적으로 <알림을 받<>거나 <><중단/종료>합니다.> (다음에서 상속됨 Object) |
| Wait(Int64) |
현재 스레드가 각성될 때까지 대기하게 하며, 일반적으로 <>알림을 받<거나 <중단/>종료><>하거나 일정량의 실시간 경과가 발생할 때까지 대기합니다. (다음에서 상속됨 Object) |
| Wait(Int64, Int32) |
현재 스레드가 각성될 때까지 대기하게 하며, 일반적으로 <>알림을 받<거나 <중단/>종료><>하거나 일정량의 실시간 경과가 발생할 때까지 대기합니다. (다음에서 상속됨 Object) |
명시적 인터페이스 구현
| IJavaPeerable.Disposed() |
|
| IJavaPeerable.DisposeUnlessReferenced() |
|
| IJavaPeerable.Finalized() |
|
| IJavaPeerable.JniManagedPeerState |
|
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
|
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
|
| IJavaPeerable.SetPeerReference(JniObjectReference) |
|
확장 메서드
| JavaCast<TResult>(IJavaObject) |
Android 런타임 확인 형식 변환을 수행합니다. |
| JavaCast<TResult>(IJavaObject) |
|
| GetJniTypeName(IJavaPeerable) |
|
| GetAsync(IFuture) |
|
| GetAsync(IFuture, Int64, TimeUnit) |
|