Interfață ExecutorService

De ce aveți nevoie de interfața Executor?

Înainte de Java 5, trebuia să scrieți tot propriul dvs. management de fire de cod în aplicația dvs. În plus, crearea unuithread nouobiectul este o operațiune care necesită mult resurse și nu are sens să creați un fir nou pentru fiecare sarcină ușoară. Și pentru că această problemă este familiară absolut tuturor dezvoltatorilor de aplicații multi-threaded, ei au decis să aducă această funcționalitate în Java ca framework Executor .

Care este ideea cea mare? Este simplu: în loc să creăm un fir nou pentru fiecare sarcină nouă, firele sunt păstrate într-un fel de „stocare”, iar când sosește o sarcină nouă, recuperăm un fir existent în loc să creăm unul nou.

Principalele interfețe ale acestui cadru sunt Executor , ExecutorService și ScheduledExecutorService , fiecare dintre acestea extinzând funcționalitatea celui precedent.

Interfața Executor este interfața de bază. Acesta declară o singură metodă void execute (comandă Runnable) care este implementată de un obiect Runnable .

Interfața ExecutorService este mai interesantă . Are metode de gestionare a finalizării lucrărilor, precum și metode de returnare a unui fel de rezultat. Să aruncăm o privire mai atentă asupra metodelor sale:

Să ne uităm la un mic exemplu de lucru cu 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;
       }
   }
}

Ieșire:

Fiecare sarcină rulează timp de 5 secunde. Am creat un pool pentru două fire, așa că primele două linii de ieșire au sens perfect.

La șase secunde după pornirea programului, metoda invokeAll expiră și rezultatul este returnat ca o listă de Futures . Acest lucru poate fi văzut din șirul de ieșire Futures primit .

După ce sunt terminate primele două sarcini, încep alte două. Dar, deoarece expiră timpul stabilit în metoda invokeAll , aceste două sarcini nu au timp să fie finalizate. Ei primesc o comandă „anulează” . De aceea ieșirea are două linii cu sleep 1: sleep întrerupt .

Și apoi puteți vedea încă două rânduri cu terminat . Acesta este efectul secundar pe care l-am menționat când am descris metoda invokeAll .

A cincea și ultima sarcină nici măcar nu începe niciodată, așa că nu vedem nimic despre ea în rezultat.

Ultimele două linii sunt rezultatul apelării metodelor isShutdown și isTerminated .

De asemenea, este interesant să rulați acest exemplu în modul de depanare și să priviți starea sarcinii după expirarea timpului (setați un punct de întrerupere pe linie cu executorService.shutdown(); ):

Vedem că două sarcini au fost finalizate în mod normal și trei sarcini au fost „Anulate” .

ScheduledExecutorService

Pentru a încheia discuția noastră despre executanți, să aruncăm o privire la ScheduledExecutorService .

Are 4 metode: