Antarmuka ExecutorService

Mengapa Anda memerlukan antarmuka Pelaksana?

Sebelum Java 5, Anda harus menulis semua manajemen utas kode Anda sendiri di aplikasi Anda. Selain itu, membuat aUtas baruobjek adalah operasi intensif sumber daya, dan tidak masuk akal untuk membuat utas baru untuk setiap tugas ringan. Dan karena masalah ini sudah tidak asing lagi bagi setiap pengembang aplikasi multi-utas, mereka memutuskan untuk membawa fungsionalitas ini ke dalam Java sebagai kerangka kerja Pelaksana .

Apa ide besarnya? Sederhana: alih-alih membuat utas baru untuk setiap tugas baru, utas disimpan dalam semacam "penyimpanan", dan ketika tugas baru tiba, kami mengambil utas yang ada alih-alih membuat yang baru.

Antarmuka utama kerangka kerja ini adalah Executor , ExecutorService dan ScheduledExecutorService , yang masing-masing memperluas fungsionalitas yang sebelumnya.

Antarmuka Pelaksana adalah antarmuka dasar. Ini mendeklarasikan metode eksekusi tunggal (perintah Runnable) yang diimplementasikan oleh objek Runnable .

Antarmuka ExecutorService lebih menarik. Ini memiliki metode untuk mengelola penyelesaian pekerjaan, serta metode untuk mengembalikan semacam hasil. Mari kita lihat lebih dekat metodenya:

Mari kita lihat contoh kecil bekerja dengan ExecutorService .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

Keluaran:

Setiap tugas berjalan selama 5 detik. Kami membuat kumpulan untuk dua utas, jadi dua baris keluaran pertama sangat masuk akal.

Enam detik setelah program dimulai, metode invokeAll habis waktu dan hasilnya dikembalikan sebagai daftar Futures . Hal ini terlihat dari output string Futures yang diterima .

Setelah dua tugas pertama selesai, dua lagi dimulai. Namun karena batas waktu yang diatur dalam metode invokeAll telah berlalu, kedua tugas ini tidak memiliki waktu untuk diselesaikan. Mereka menerima perintah "batal" . Itu sebabnya outputnya memiliki dua baris dengan sleep 1: sleep interrupt .

Dan kemudian Anda dapat melihat dua baris lagi dengan done . Ini adalah efek samping yang saya sebutkan saat menjelaskan metode invokeAll .

Tugas kelima dan terakhir bahkan tidak pernah dimulai, jadi kami tidak melihat apa pun tentangnya di keluaran.

Dua baris terakhir adalah hasil pemanggilan metode isShutdown dan isTerminated .

Menarik juga untuk menjalankan contoh ini dalam mode debug dan melihat status tugas setelah batas waktu berlalu (setel breakpoint pada baris dengan executorService.shutdown(); ):

Kami melihat bahwa dua tugas Selesai secara normal , dan tiga tugas "Dibatalkan" .

ScheduledExecutorService

Untuk menyimpulkan diskusi kita tentang pelaksana, mari kita lihat ScheduledExecutorService .

Ini memiliki 4 metode: