CountedCompleter Kelas
Definisi
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Dengan ForkJoinTask tindakan penyelesaian yang dilakukan saat dipicu dan tidak ada tindakan yang tersisa yang tertunda.
[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- Warisan
- Atribut
Keterangan
Dengan ForkJoinTask tindakan penyelesaian yang dilakukan saat dipicu dan tidak ada tindakan yang tersisa yang tertunda. CountedCompleters secara umum lebih kuat di hadapan kios subtugas dan penyumbatan daripada bentuk ForkJoinTasks lainnya, tetapi kurang intuitif terhadap program. Penggunaan CountedCompleter mirip dengan komponen berbasis penyelesaian lainnya (seperti java.nio.channels.CompletionHandler) kecuali bahwa beberapa <penyelesaian em>tertunda</em> mungkin diperlukan untuk memicu tindakan #onCompletion(CountedCompleter)penyelesaian , bukan hanya satu. Kecuali diinisialisasi sebaliknya, jumlah #getPendingCount tertunda dimulai pada nol, tetapi mungkin (secara atom) diubah menggunakan metode #setPendingCount, #addToPendingCount, dan #compareAndSetPendingCount. Setelah pemanggilan #tryComplete, jika jumlah tindakan yang tertunda bukan nol, tindakan tersebut akan diturunkan; jika tidak, tindakan penyelesaian dilakukan, dan jika penyelesaian ini sendiri memiliki penyelesaian, proses dilanjutkan dengan penyelesaiannya. Seperti halnya dengan komponen sinkronisasi terkait seperti Phaser dan Semaphore, metode ini hanya memengaruhi jumlah internal; mereka tidak menetapkan pembukuan internal lebih lanjut. Secara khusus, identitas tugas yang tertunda tidak dipertahankan. Seperti yang diilustrasikan di bawah ini, Anda dapat membuat subkelas yang merekam beberapa atau semua tugas yang tertunda atau hasilnya saat diperlukan. Seperti yang diilustrasikan di bawah ini, metode utilitas yang mendukung penyesuaian traversal penyelesaian juga disediakan. Namun, karena CountedCompleters hanya menyediakan mekanisme sinkronisasi dasar, mungkin berguna untuk membuat subkelas abstrak lebih lanjut yang mempertahankan tautan, bidang, dan metode dukungan tambahan yang sesuai untuk serangkaian penggunaan terkait.
Kelas CountedCompleter beton harus menentukan metode #compute, yang seharusnya dalam banyak kasus (seperti yang diilustrasikan di bawah), panggil tryComplete() sekali sebelum kembali. Kelas juga dapat secara opsional mengambil alih metode #onCompletion(CountedCompleter) untuk melakukan tindakan setelah penyelesaian normal, dan metode #onExceptionalCompletion(Throwable, CountedCompleter) untuk melakukan tindakan atas pengecualian apa pun.
CountedCompleters paling sering tidak menanggung hasil, dalam hal ini mereka biasanya dinyatakan sebagai CountedCompleter<Void>, dan akan selalu kembali null sebagai nilai hasil. Dalam kasus lain, Anda harus mengambil alih metode #getRawResult untuk memberikan hasil dari join(), invoke(), dan metode terkait. Secara umum, metode ini harus mengembalikan nilai bidang (atau fungsi dari satu atau beberapa bidang) dari objek CountedCompleter yang menyimpan hasil setelah selesai. Metode #setRawResult secara default tidak memainkan peran dalam CountedCompleters. Dimungkinkan, tetapi jarang berlaku, untuk mengambil alih metode ini untuk mempertahankan objek atau bidang lain yang menyimpan data hasil.
CountedCompleter yang tidak memiliki penyelesaian (yaitu, satu yang #getCompleter pengembaliannya null) dapat digunakan sebagai ForkJoinTask biasa dengan fungsionalitas tambahan ini. Namun, setiap pelengkap yang pada gilirannya memiliki penyelesaian lain hanya berfungsi sebagai pembantu internal untuk komputasi lain, sehingga status tugasnya sendiri (seperti yang dilaporkan dalam metode seperti ForkJoinTask#isDone) bersifat semena-mena; status ini hanya berubah setelah pemanggilan #completeeksplisit , , ForkJoinTask#cancelForkJoinTask#completeExceptionally(Throwable) atau setelah penyelesaian metode computeyang luar biasa . Setelah penyelesaian luar biasa, pengecualian dapat disampaikan ke penyelesaian tugas (dan penyelesaiannya, dan sebagainya), jika ada dan belum selesai. Demikian pula, membatalkan CountedCompleter internal hanya memiliki efek lokal pada penyelesaian tersebut, jadi tidak sering berguna.
<b>Penggunaan Sampel.</b>
<b>Penguraian rekursif paralel.</b> CountedCompleters dapat diatur di pohon yang mirip dengan yang sering digunakan dengan RecursiveActions, meskipun konstruksi yang terlibat dalam pengaturannya biasanya bervariasi. Di sini, penyelesaian setiap tugas adalah induknya di pohon komputasi. Meskipun mereka memerlukan sedikit lebih banyak pembukuan, CountedCompleters mungkin menjadi pilihan yang lebih baik saat menerapkan operasi yang mungkin memakan waktu (yang tidak dapat dibagi lebih lanjut) ke setiap elemen array atau koleksi; terutama ketika operasi membutuhkan waktu yang sangat berbeda untuk diselesaikan untuk beberapa elemen daripada yang lain, baik karena variasi intrinsik (misalnya I/O) atau efek tambahan seperti pengumpulan sampah. Karena CountedCompleters menyediakan kelanjutan mereka sendiri, tugas lain tidak perlu memblokir menunggu untuk melakukannya.
Misalnya, berikut adalah versi awal metode utilitas yang menggunakan penguraian rekursif membagi demi dua untuk membagi pekerjaan menjadi satu bagian (tugas daun). Bahkan ketika pekerjaan dibagi menjadi panggilan individual, teknik berbasis pohon biasanya lebih disukai untuk langsung menepi tugas daun, karena mengurangi komunikasi antar-utas dan meningkatkan penyeimbangan beban. Dalam kasus rekursif, kedua dari setiap pasangan subtugas untuk menyelesaikan pemicu penyelesaian induknya (karena tidak ada kombinasi hasil yang dilakukan, implementasi metode onCompletion no-op default tidak ditimpa). Metode utilitas menyiapkan tugas akar dan memanggilnya (di sini, secara implisit menggunakan ForkJoinPool#commonPool()). Sangat mudah dan dapat diandalkan (tetapi tidak optimal) untuk selalu mengatur jumlah yang tertunda ke jumlah tugas anak dan memanggil tryComplete() segera sebelum kembali.
{@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();
}}
Desain ini dapat ditingkatkan dengan melihat bahwa dalam kasus rekursif, tugas tidak ada hubungannya setelah menempa tugas yang tepat, sehingga dapat langsung memanggil tugas kirinya sebelum kembali. (Ini adalah analog penghapusan rekursi ekor.) Selain itu, ketika tindakan terakhir dalam tugas adalah membuat fork atau memanggil subtugas ("panggilan ekor"), panggilan untuk tryComplete() dapat dioptimalkan, dengan biaya membuat jumlah tertunda terlihat "nonaktif oleh satu".
{@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();
}
}}
Sebagai pengoptimalan lebih lanjut, perhatikan bahwa tugas kiri bahkan tidak perlu ada. Alih-alih membuat yang baru, kita dapat terus menggunakan tugas asli, dan menambahkan jumlah tertunda untuk setiap fork. Selain itu, karena tidak ada tugas di pohon ini yang #onCompletion(CountedCompleter) menerapkan metode, tryComplete dapat diganti dengan #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();
}}
Ketika jumlah yang tertunda dapat dikomputasi sebelumnya, jumlah tersebut dapat dibuat di konstruktor:
{@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();
}}
Pengoptimalan tambahan kelas tersebut mungkin memerlukan kelas khusus untuk langkah daun, membagi dengan mengatakan, empat, bukan dua per iterasi, dan menggunakan ambang adaptif alih-alih selalu membagi ke elemen tunggal.
<b>Pencarian.</b> Pohon CountedCompleters dapat mencari nilai atau properti di berbagai bagian struktur data, dan melaporkan hasilnya java.util.concurrent.atomic.AtomicReference AtomicReference segera setelah ditemukan. Yang lain dapat melakukan polling hasil untuk menghindari pekerjaan yang tidak perlu. (Anda juga dapat #cancel membatalkan tugas lain, tetapi biasanya lebih sederhana dan lebih efisien untuk membiarkan mereka melihat bahwa hasilnya diatur dan jika demikian melewati pemrosesan lebih lanjut.) Mengilustrasikan lagi dengan array menggunakan partisi penuh (sekali lagi, dalam praktiknya, tugas daun hampir selalu akan memproses lebih dari satu elemen):
{@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();
}
}}
Dalam contoh ini, serta yang lain di mana tugas tidak memiliki efek lain kecuali hasil compareAndSet umum, pemanggilan tryComplete tanpa syarat berikutnya dapat dibuat bersyarat (if (result.get() == null) tryComplete();) karena tidak ada pembbukuan lebih lanjut yang diperlukan untuk mengelola penyelesaian setelah tugas root selesai.
<b>Merekam subtugas.</b> Tugas CountedCompleter yang menggabungkan hasil dari beberapa subtugas biasanya perlu mengakses hasil ini dalam metode #onCompletion(CountedCompleter). Seperti yang diilustrasikan dalam kelas berikut (yang melakukan bentuk pengurangan peta yang disederhanakan di mana pemetaan dan pengurangan adalah semua jenis E), salah satu cara untuk melakukan ini dalam desain pembagian dan penaklukan adalah dengan membuat setiap subtugas merekam saudaranya, sehingga dapat diakses dalam metode onCompletion. Teknik ini berlaku untuk pengurangan di mana urutan menggabungkan hasil kiri dan kanan tidak masalah; pengurangan yang diurutkan memerlukan penandaan kiri/kanan eksplisit. Varian persederhanaan lain yang terlihat dalam contoh di atas juga dapat berlaku.
{@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();
}
}}
Di sini, metode onCompletion mengambil bentuk umum untuk banyak desain penyelesaian yang menggabungkan hasil. Metode gaya panggilan balik ini dipicu sekali per tugas, dalam salah satu dari dua konteks berbeda di mana jumlah yang tertunda, atau menjadi, nol: (1) oleh tugas itu sendiri, jika jumlah yang tertunda adalah nol setelah pemanggilan tryComplete, atau (2) oleh salah satu subtugasnya ketika mereka menyelesaikan dan mengurangi jumlah tertunda menjadi nol. Argumen caller membedakan kasus. Paling sering, ketika penelepon adalah this, tidak ada tindakan yang diperlukan. Jika tidak, argumen pemanggil dapat digunakan (biasanya melalui cast) untuk menyediakan nilai (dan/atau tautan ke nilai lain) untuk digabungkan. Dengan asumsi penggunaan jumlah yang tertunda yang tepat, tindakan di dalamnya onCompletion terjadi (sekali) setelah menyelesaikan tugas dan subtugasnya. Tidak ada sinkronisasi tambahan yang diperlukan dalam metode ini untuk memastikan keamanan alur akses ke bidang tugas ini atau tugas lain yang diselesaikan.
<b>Penyelesaian Traversal.</b> Jika menggunakan onCompletion untuk memproses penyelesaian tidak dapat diaplikasikan atau tidak nyaman, Anda dapat menggunakan metode #firstComplete dan #nextComplete untuk membuat traversal kustom. Misalnya, untuk menentukan MapReducer yang hanya membagi tugas kanan dalam bentuk contoh ForEach ketiga, penyelesaiannya harus secara kooperatif mengurangi di sepanjang tautan subtugas yang tidak habis, yang dapat dilakukan sebagai berikut:
{@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>Pemicu.</b> Beberapa CountedCompleters sendiri tidak pernah di-fork, tetapi sebaliknya berfungsi sebagai bit pipa dalam desain lain; termasuk yang mana penyelesaian satu atau beberapa tugas asinkron memicu tugas asinkron lain. Contohnya:
{@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();}
Ditambahkan dalam 1.8.
Dokumentasi Java untuk java.util.concurrent.CountedCompleter.
Bagian halaman ini adalah modifikasi berdasarkan pekerjaan yang dibuat dan dibagikan oleh Proyek Sumber Terbuka Android dan digunakan sesuai dengan istilah yang dijelaskan dalam Lisensi Atribusi Creative Commons 2.5.
Konstruktor
| CountedCompleter() |
Membuat CountedCompleter baru tanpa penyelesaian dan jumlah awal nol yang tertunda. |
| CountedCompleter(CountedCompleter) |
Membuat CountedCompleter baru dengan penyelesaian yang diberikan dan jumlah awal nol yang tertunda. |
| CountedCompleter(CountedCompleter, Int32) |
Membuat CountedCompleter baru dengan pengisi yang diberikan dan jumlah tertunda awal. |
| CountedCompleter(IntPtr, JniHandleOwnership) |
Dengan |
Properti
| Class |
Mengembalikan kelas runtime dari . |
| Completer |
Mengembalikan penyelesaian yang ditetapkan dalam konstruktor tugas ini, atau |
| Exception |
Mengembalikan pengecualian yang dilemparkan oleh komputasi dasar, atau |
| ForkJoinTaskTag |
Mengembalikan tag untuk tugas ini. (Diperoleh dari ForkJoinTask) |
| Handle |
Handel ke instans Android yang mendasar. (Diperoleh dari Object) |
| IsCancelled |
Mengembalikan |
| IsCompletedAbnormally |
Mengembalikan |
| IsCompletedNormally |
Mengembalikan |
| IsDone |
Mengembalikan |
| JniIdentityHashCode |
Dengan |
| JniPeerMembers |
Dengan |
| PeerReference |
Dengan |
| PendingCount |
Mengembalikan jumlah tertunda saat ini. -or- Mengatur jumlah tertunda ke nilai yang diberikan. |
| RawRawResult |
Mengembalikan hasil yang akan dikembalikan oleh Join(), meskipun tugas ini selesai secara tidak normal, atau |
| RawResult |
Mengembalikan hasil komputasi. |
| Root |
Mengembalikan akar komputasi saat ini; saya. |
| ThresholdClass |
Dengan |
| ThresholdType |
Dengan |
Metode
| AddToPendingCount(Int32) |
Menambahkan (secara atomik) nilai yang diberikan ke jumlah yang tertunda. |
| Cancel(Boolean) |
Mencoba membatalkan eksekusi tugas ini. (Diperoleh dari ForkJoinTask) |
| Clone() |
Membuat dan mengembalikan salinan objek ini. (Diperoleh dari Object) |
| CompareAndSetForkJoinTaskTag(Int16, Int16) |
Secara kondisional mengatur nilai tag untuk tugas ini secara atomik. (Diperoleh dari ForkJoinTask) |
| CompareAndSetPendingCount(Int32, Int32) |
Mengatur (secara atomik) jumlah tertunda ke jumlah yang diberikan hanya jika saat ini menyimpan nilai yang diharapkan. |
| Complete(Object) |
Terlepas dari jumlah yang tertunda, memanggil |
| CompleteExceptionally(Throwable) |
Menyelesaikan tugas ini secara tidak normal, dan jika belum dibatalkan atau dibatalkan, menyebabkannya melemparkan pengecualian yang diberikan pada |
| Compute() |
Komputasi utama yang dilakukan oleh tugas ini. |
| DecrementPendingCountUnlessZero() |
Jika jumlah yang tertunda bukan nol, (secara atom) menguranginya. |
| Dispose() |
Dengan |
| Dispose(Boolean) |
Dengan |
| Equals(Object) |
Menunjukkan apakah beberapa objek lain "sama dengan" yang satu ini. (Diperoleh dari Object) |
| Exec() |
Menerapkan konvensi eksekusi untuk CountedCompleters. |
| FirstComplete() |
Jika jumlah tugas ini tertunda adalah nol, mengembalikan tugas ini; jika tidak, mengurangi jumlah yang tertunda dan mengembalikan |
| Fork() |
Mengatur untuk menjalankan tugas ini secara asinkron di kumpulan tempat tugas saat ini berjalan, jika berlaku, atau menggunakan |
| Get() |
Menunggu jika perlu untuk menyelesaikan komputasi, lalu mengambil hasilnya. (Diperoleh dari ForkJoinTask) |
| Get(Int64, TimeUnit) |
Menunggu jika perlu untuk sebagian besar waktu yang diberikan agar komputasi selesai, lalu mengambil hasilnya, jika tersedia. (Diperoleh dari ForkJoinTask) |
| GetHashCode() |
Mengembalikan nilai kode hash untuk objek . (Diperoleh dari Object) |
| HelpComplete(Int32) |
Jika tugas ini belum selesai, upaya untuk memproses paling banyak jumlah tugas lain yang tidak diproses lainnya yang tugas ini berada di jalur penyelesaian, jika ada yang diketahui ada. |
| Invoke() |
Memulai melakukan tugas ini, menunggu penyelesaiannya jika perlu, dan mengembalikan hasilnya, atau melempar (tidak dicentang) |
| JavaFinalize() |
Dipanggil oleh pengumpul sampah pada objek ketika pengumpulan sampah menentukan bahwa tidak ada lagi referensi ke objek. (Diperoleh dari Object) |
| Join() |
Mengembalikan hasil komputasi saat #isDone selesai. (Diperoleh dari ForkJoinTask) |
| NextComplete() |
Jika tugas ini tidak memiliki penyelesaian, panggil |
| Notify() |
Membangunkan satu utas yang menunggu monitor objek ini. (Diperoleh dari Object) |
| NotifyAll() |
Membangunkan semua utas yang menunggu monitor objek ini. (Diperoleh dari Object) |
| OnCompletion(CountedCompleter) |
Melakukan tindakan ketika metode |
| OnExceptionalCompletion(Throwable, CountedCompleter) |
Melakukan tindakan ketika metode |
| PropagateCompletion() |
Setara dengan |
| QuietlyComplete() |
Menyelesaikan tugas ini secara normal tanpa mengatur nilai. (Diperoleh dari ForkJoinTask) |
| QuietlyCompleteRoot() |
Setara dengan |
| QuietlyInvoke() |
Memulai melakukan tugas ini dan menunggu penyelesaiannya jika perlu, tanpa mengembalikan hasilnya atau melemparkan pengecualiannya. (Diperoleh dari ForkJoinTask) |
| QuietlyJoin() |
Menggabungkan tugas ini, tanpa mengembalikan hasilnya atau melemparkan pengecualiannya. (Diperoleh dari ForkJoinTask) |
| Reinitialize() |
Mengatur ulang status pembbukuan internal tugas ini, memungkinkan |
| SetForkJoinTaskTag(Int16) |
Secara atomis mengatur nilai tag untuk tugas ini dan mengembalikan nilai lama. (Diperoleh dari ForkJoinTask) |
| SetHandle(IntPtr, JniHandleOwnership) |
Handle Mengatur properti. (Diperoleh dari Object) |
| SetRawResult(Object) |
Metode yang menghasilkan CountedCompleters dapat secara opsional digunakan untuk membantu mempertahankan data hasil. |
| ToArray<T>() |
Dengan |
| ToString() |
Mengembalikan representasi string objek. (Diperoleh dari Object) |
| TryComplete() |
Jika jumlah yang tertunda bukan nol, akan mengurangi jumlah; jika tidak, |
| TryUnfork() |
Mencoba membatalkan jadwal tugas ini untuk eksekusi. (Diperoleh dari ForkJoinTask) |
| UnregisterFromRuntime() |
Dengan |
| Wait() |
Menyebabkan utas saat ini menunggu sampai terbangun, biasanya dengan <diberitahu></em> atau <em>terganggu</em>. (Diperoleh dari Object) |
| Wait(Int64) |
Menyebabkan utas saat ini menunggu sampai terbangun, biasanya dengan <>diberitahu</em> atau <em>terganggu</em>, atau sampai sejumlah real time telah berlalu. (Diperoleh dari Object) |
| Wait(Int64, Int32) |
Menyebabkan utas saat ini menunggu sampai terbangun, biasanya dengan <>diberitahu</em> atau <em>terganggu</em>, atau sampai sejumlah real time telah berlalu. (Diperoleh dari Object) |
Implementasi Antarmuka Eksplisit
| IJavaPeerable.Disposed() |
Dengan |
| IJavaPeerable.DisposeUnlessReferenced() |
Dengan |
| IJavaPeerable.Finalized() |
Dengan |
| IJavaPeerable.JniManagedPeerState |
Dengan |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Dengan |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Dengan |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Dengan |
Metode Ekstensi
| JavaCast<TResult>(IJavaObject) |
Melakukan konversi jenis yang diperiksa runtime Bahasa Umum Android. |
| JavaCast<TResult>(IJavaObject) |
Dengan |
| GetJniTypeName(IJavaPeerable) |
Dengan |
| GetAsync(IFuture) |
Dengan |
| GetAsync(IFuture, Int64, TimeUnit) |
Dengan |