ExecutorService, bagaimana menunggu semua tugas selesai

Apa cara paling sederhana untuk menunggu semua tugas ExecutorServiceselesai? Tugas saya terutama komputasi, jadi saya hanya ingin menjalankan sejumlah besar pekerjaan - satu di setiap inti. Sekarang pengaturan saya terlihat seperti ini:

ExecutorService es = Executors.newFixedThreadPool(2);
for (DataTable singleTable : uniquePhrases) {   
    es.execute(new ComputeDTask(singleTable));
}
try{
    es.wait();
} 
catch (InterruptedException e){
    e.printStackTrace();
}

ComputeDTaskmengimplementasikan runnable. Ini tampaknya menjalankan tugas dengan benar, tetapi kode macet wait()dengan IllegalMonitorStateException. Ini aneh, karena saya bermain-main dengan beberapa contoh mainan dan tampaknya berhasil.

uniquePhrasesmengandung beberapa puluh ribu elemen. Haruskah saya menggunakan metode lain? Saya mencari sesuatu yang sesederhana mungkin

Pendekatan paling sederhana adalah menggunakan ExecutorService.invokeAll()yang melakukan apa yang Anda inginkan dalam satu-liner. Dalam bahasa Anda, Anda harus memodifikasi atau membungkus ComputeDTaskuntuk mengimplementasikan Callable<>, yang dapat memberi Anda sedikit lebih banyak fleksibilitas. Mungkin di aplikasi Anda ada implementasi yang bermakna Callable.call(), tapi inilah cara untuk membungkusnya jika tidak menggunakan Executors.callable().

ExecutorService es = Executors.newFixedThreadPool(2);
List<Callable<Object>> todo = new ArrayList<Callable<Object>>(singleTable.size());

for (DataTable singleTable: uniquePhrases) { 
    todo.add(Executors.callable(new ComputeDTask(singleTable))); 
}

List<Future<Object>> answers = es.invokeAll(todo);

Seperti yang telah ditunjukkan orang lain, Anda dapat menggunakan versi batas waktu invokeAll()jika sesuai. Dalam contoh ini, answersakan berisi banyak Futures yang akan mengembalikan nol (lihat definisi Executors.callable(). Mungkin yang ingin Anda lakukan adalah sedikit refactoring sehingga Anda bisa mendapatkan jawaban yang berguna kembali, atau referensi ke yang mendasarinya ComputeDTask, tapi saya bisa dari contoh Anda.

Jika tidak jelas, perhatikan bahwa invokeAll()tidak akan kembali sampai semua tugas selesai. (yaitu, semua yang ada Futuredi answerskoleksi Anda akan melaporkan .isDone()jika diminta.) Ini menghindari semua shutdown manual, menungguTerminasi, dll ... dan memungkinkan Anda untuk menggunakan kembali ini ExecutorServicedengan rapi untuk beberapa siklus, jika diinginkan.

Ada beberapa pertanyaan terkait pada SO:

• Cara menunggu semua utas selesai

• Kembalikan nilai dari utas java

• invokeAll () tidak mau menerima Koleksi <Callable <t>>

• Apakah saya perlu melakukan sinkronisasi?

Tidak ada yang benar-benar tepat untuk pertanyaan Anda, tetapi mereka memang memberikan sedikit warna tentang bagaimana orang berpikir Executor/ ExecutorServiceseharusnya digunakan.

Jika Anda ingin menunggu semua tugas selesai, gunakan shutdownmetode sebagai ganti wait. Kemudian ikuti dengan awaitTermination.

Selain itu, Anda dapat menggunakan Runtime.availableProcessorsuntuk mendapatkan jumlah utas perangkat keras sehingga Anda dapat menginisialisasi threadpool dengan benar.

Jika menunggu semua tugas dalam ExecutorServicepenyelesaian tidak tepat sasaran Anda, melainkan menunggu hingga kumpulan tugas tertentu selesai, Anda dapat menggunakan CompletionService- khusus, sebuah ExecutorCompletionService.

Idenya adalah untuk menciptakan sebuah ExecutorCompletionServicemembungkus Anda Executor, mengirimkan beberapa nomor yang dikenal tugas melalui CompletionService, kemudian menarik bahwa jumlah yang sama dari hasil dari antrian selesai baik menggunakan take()(yang blok) atau poll()(yang tidak). Setelah Anda menggambar semua hasil yang diharapkan sesuai dengan tugas yang Anda kirimkan, Anda tahu semuanya sudah selesai.

Biarkan saya menyatakan ini sekali lagi, karena tidak jelas dari antarmuka: Anda harus tahu berapa banyak hal yang Anda masukkan CompletionServiceuntuk mengetahui berapa banyak hal yang harus dicoba. Ini sangat penting terutama dengan take()metode: panggil sekali saja dan itu akan memblokir utas panggilan Anda sampai beberapa utas lainnya mengirimkan pekerjaan lain ke yang sama CompletionService.

Ada beberapa contoh yang menunjukkan bagaimana menggunakanCompletionService dalam buku Jawa Concurrency dalam Praktek .

Jika Anda ingin menunggu layanan pelaksana untuk menyelesaikan eksekusi, panggil shutdown()dan kemudian, tungguTerminasi (unit, tipe unit) , mis awaitTermination(1, MINUTE). ExecutorService tidak memblokir monitor itu sendiri, jadi Anda tidak dapat menggunakan waitdll.

Anda bisa menunggu pekerjaan selesai pada interval tertentu:

int maxSecondsPerComputeDTask = 20;
try {
    while (!es.awaitTermination(uniquePhrases.size() * maxSecondsPerComputeDTask, TimeUnit.SECONDS)) {
        // consider giving up with a 'break' statement under certain conditions
    }
} catch (InterruptedException e) {
    throw new RuntimeException(e);    
}

Atau Anda bisa menggunakan ExecutorService . kirim ( Runnable ) dan kumpulkan objek Future yang dikembalikan dan panggil get () pada masing-masing pada gilirannya untuk menunggu sampai selesai.

ExecutorService es = Executors.newFixedThreadPool(2);
Collection<Future<?>> futures = new LinkedList<<Future<?>>();
for (DataTable singleTable : uniquePhrases) {
    futures.add(es.submit(new ComputeDTask(singleTable)));
}
for (Future<?> future : futures) {
   try {
       future.get();
   } catch (InterruptedException e) {
       throw new RuntimeException(e);
   } catch (ExecutionException e) {
       throw new RuntimeException(e);
   }
}

InterruptedException sangat penting untuk ditangani dengan benar. Inilah yang memungkinkan Anda atau pengguna perpustakaan Anda menghentikan proses panjang dengan aman.

Gunakan saja

latch = new CountDownLatch(noThreads)

Di setiap utas

latch.countDown();

dan sebagai penghalang

latch.await();

Penyebab root untuk IllegalMonitorStateException :

Dilemparkan untuk menunjukkan bahwa utas telah mencoba untuk menunggu pada monitor objek atau untuk memberi tahu utas lainnya menunggu pada monitor objek tanpa memiliki monitor yang ditentukan.

Dari kode Anda, Anda baru saja menelepon wait () pada ExecutorService tanpa memiliki kunci.

Kode di bawah ini akan diperbaiki IllegalMonitorStateException

try 
{
    synchronized(es){
        es.wait(); // Add some condition before you call wait()
    }
} 

Ikuti salah satu pendekatan di bawah ini untuk menunggu penyelesaian semua tugas, yang telah diserahkan ExecutorService.

1. Iterate melalui semua Futuretugas dari submitpada ExecutorServicedan memeriksa status dengan memblokir panggilan get()pada Futureobjek

2. Gunakan invokeAll onExecutorService

3. Menggunakan CountDownLatch

4. Menggunakan ForkJoinPool atau newWorkStealingPool dari Executors(sejak java 8)

5. Matikan pool seperti yang direkomendasikan di halaman dokumentasi oracle

   void shutdownAndAwaitTermination(ExecutorService pool) {
      pool.shutdown(); // Disable new tasks from being submitted
      try {
      // Wait a while for existing tasks to terminate
      if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
          pool.shutdownNow(); // Cancel currently executing tasks
          // Wait a while for tasks to respond to being cancelled
          if (!pool.awaitTermination(60, TimeUnit.SECONDS))
          System.err.println("Pool did not terminate");
      }
   } catch (InterruptedException ie) {
        // (Re-)Cancel if current thread also interrupted
        pool.shutdownNow();
        // Preserve interrupt status
        Thread.currentThread().interrupt();
   }

   Jika Anda ingin dengan anggun menunggu semua tugas selesai saat Anda menggunakan opsi 5 bukannya opsi 1 hingga 4, ubah

   if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {

   untuk

   a while(condition)yang memeriksa setiap 1 menit.

Anda dapat menggunakan ExecutorService.invokeAllmetode, Ini akan menjalankan semua tugas dan menunggu sampai semua utas menyelesaikan tugas mereka.

Ini javadoc lengkap

Anda juga dapat menggunakan versi berlebih dari metode ini untuk menentukan batas waktu.

Berikut adalah contoh kode dengan ExecutorService.invokeAll

public class Test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        List<Callable<String>> taskList = new ArrayList<>();
        taskList.add(new Task1());
        taskList.add(new Task2());
        List<Future<String>> results = service.invokeAll(taskList);
        for (Future<String> f : results) {
            System.out.println(f.get());
        }
    }

}

class Task1 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(2000);
            return "Task 1 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task1";
        }
    }
}

class Task2 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(3000);
            return "Task 2 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task2";
        }
    }
}

Saya juga memiliki situasi dimana saya memiliki set dokumen untuk dijelajahi. Saya mulai dengan dokumen "seed" awal yang harus diproses, dokumen itu berisi tautan ke dokumen lain yang juga harus diproses, dan seterusnya.

Di program utama saya, saya hanya ingin menulis sesuatu seperti yang berikut, di mana Crawlermengontrol banyak utas.

Crawler c = new Crawler();
c.schedule(seedDocument); 
c.waitUntilCompletion()

Situasi yang sama akan terjadi jika saya ingin menavigasi pohon; saya akan muncul di root node, prosesor untuk setiap node akan menambahkan anak-anak ke antrian seperlunya, dan banyak thread akan memproses semua node di pohon, sampai tidak ada lagi.

Saya tidak dapat menemukan apa pun di JVM yang saya pikir agak mengejutkan. Jadi saya menulis kelas ThreadPoolyang bisa digunakan secara langsung atau subclass untuk menambahkan metode yang cocok untuk domain, misalnya schedule(Document). Semoga ini bisa membantu!

ThreadPool Javadoc | Maven

Tambahkan semua utas dalam koleksi dan kirimkan dengan menggunakan invokeAll. Jika Anda dapat menggunakan invokeAllmetode ExecutorService, JVM tidak akan melanjutkan ke baris berikutnya sampai semua utas selesai.

Di sini ada contoh yang bagus: invokeAll via ExecutorService

Kirim tugas Anda ke dalam Runner dan kemudian tunggu memanggil metode waitTillDone () seperti ini:

Runner runner = Runner.runner(2);

for (DataTable singleTable : uniquePhrases) {

    runner.run(new ComputeDTask(singleTable));
}

// blocks until all tasks are finished (or failed)
runner.waitTillDone();

runner.shutdown();

Untuk menggunakannya tambahkan dependensi gradle / maven ini: 'com.github.matejtymes:javafixes:1.0'

Untuk lebih jelasnya lihat di sini: https://github.com/MatejTymes/JavaFixes atau di sini: http://matejtymes.blogspot.com/2016/04/executor-that-notifies-you-when-task.html

Alternatif sederhana untuk ini adalah menggunakan utas bersama dengan bergabung. Refer: Menggabung Thread

Saya hanya akan menunggu sampai eksekutor berakhir dengan batas waktu yang ditentukan yang menurut Anda cocok untuk menyelesaikan tugas-tugas tersebut.

 try {  
         //do stuff here 
         exe.execute(thread);
    } finally {
        exe.shutdown();
    }
    boolean result = exe.awaitTermination(4, TimeUnit.HOURS);
    if (!result)

    {
        LOGGER.error("It took more than 4 hour for the executor to stop, this shouldn't be the normal behaviour.");
    }

Kedengarannya seperti yang Anda butuhkan ForkJoinPooldan gunakan kumpulan global untuk menjalankan tugas.

public static void main(String[] args) {
    // the default `commonPool` should be sufficient for many cases.
    ForkJoinPool pool = ForkJoinPool.commonPool(); 
    // The root of your task that may spawn other tasks. 
    // Make sure it submits the additional tasks to the same executor that it is in.
    Runnable rootTask = new YourTask(pool); 
    pool.execute(rootTask);
    pool.awaitQuiescence(...);
    // that's it.
}

Keindahan adalah di pool.awaitQuiescencemana metode akan memblokir memanfaatkan utas penelepon untuk melaksanakan tugasnya dan kemudian kembali ketika itu benar - benar kosong.