ExecutorService-grensesnitt

Hvorfor trenger du Executor-grensesnittet?

Før Java 5 måtte du skrive all din egen kodetrådhåndtering i applikasjonen din. I tillegg oppretter du enny trådobjekt er en ressurskrevende operasjon, og det gir ikke mening å lage en ny tråd for hver lett oppgave. Og fordi dette problemet er kjent for absolutt alle utviklere av flertrådede applikasjoner, bestemte de seg for å bringe denne funksjonaliteten inn i Java som Executor- rammeverket.

Hva er den store ideen? Det er enkelt: i stedet for å lage en ny tråd for hver ny oppgave, holdes tråder i et slags «lager», og når en ny oppgave kommer, henter vi en eksisterende tråd i stedet for å lage en ny.

Hovedgrensesnittene til dette rammeverket er Executor , ExecutorService og ScheduledExecutorService , som hver utvider funksjonaliteten til den forrige.

Executor-grensesnittet er basisgrensesnittet. Den erklærer en enkelt void execute (kjørbar kommando) metode som er implementert av et kjørbart objekt.

ExecutorService - grensesnittet er mer interessant. Den har metoder for å administrere fullføringen av arbeid, samt metoder for å returnere en eller annen form for resultat. La oss se nærmere på metodene:

La oss se på et lite eksempel på arbeid med 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;
       }
   }
}

Produksjon:

Hver oppgave varer i 5 sekunder. Vi laget et basseng for to tråder, så de to første linjene med utdata gir perfekt mening.

Seks sekunder etter at programmet starter, blir invokeAll- metoden tidsavbrutt, og resultatet returneres som en liste over Futures . Dette kan sees fra utdatastrengen Futures receives .

Etter at de to første oppgavene er gjort, begynner to til. Men fordi tidsavbruddet satt i invokeAll -metoden utløper, har ikke disse to oppgavene tid til å fullføre. De mottar en "avbryt" -kommando. Det er derfor utgangen har to linjer med dvale 1: dvale avbrutt .

Og så kan du se to linjer til med ferdig . Dette er bivirkningen jeg nevnte når jeg beskrev invokeAll- metoden.

Den femte og siste oppgaven kommer aldri i gang, så vi ser ikke noe om det i utdataene.

De to siste linjene er resultatet av å kalle metodene isShutdown og isTerminated .

Det er også interessant å kjøre dette eksemplet i feilsøkingsmodus og se på oppgavestatusen etter at tidsavbruddet har gått (sett et bruddpunkt på linjen med executorService.shutdown(); ):

Vi ser at to oppgaver Fullført normalt , og tre oppgaver ble "Avbrutt" .

ScheduledExecutorService

For å avslutte vår diskusjon om eksekutører, la oss ta en titt på ScheduledExecutorService .

Den har 4 metoder: