ExecutorService interface

Hvorfor har du brug for Executor-grænsefladen?

Før Java 5 skulle du skrive al din egen kodetrådshåndtering i din applikation. Desuden skabes enny trådobjekt er en ressourcekrævende operation, og det giver ikke mening at oprette en ny tråd til hver letvægtsopgave. Og fordi dette problem er kendt for absolut alle udviklere af multi-threaded-applikationer, besluttede de at bringe denne funktionalitet ind i Java som Executor- rammeværket.

Hvad er den store idé? Det er enkelt: I stedet for at oprette en ny tråd for hver ny opgave, opbevares tråde i en slags "lager", og når der kommer en ny opgave, henter vi en eksisterende tråd frem i stedet for at oprette en ny.

De vigtigste grænseflader i denne ramme er Executor , ExecutorService og ScheduledExecutorService , som hver udvider funktionaliteten af ​​den forrige.

Executor-grænsefladen er basisgrænsefladen. Den erklærer en enkelt void execute (Kørbar kommando) metode, der er implementeret af et Kørbart objekt.

ExecutorService - grænsefladen er mere interessant. Det har metoder til at styre færdiggørelsen af ​​arbejdet, samt metoder til at returnere en form for resultat. Lad os se nærmere på dens metoder:

Lad os se på et lille eksempel på at arbejde 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;
       }
   }
}

Produktion:

Hver opgave kører i 5 sekunder. Vi skabte en pulje til to tråde, så de første to outputlinjer giver perfekt mening.

Seks sekunder efter programmets start, ophører invokeAll- metoden, og resultatet returneres som en liste over Futures . Dette kan ses fra output-strengen Futures modtaget .

Når de første to opgaver er udført, begynder to mere. Men fordi den timeout, der er angivet i invokeAll -metoden, udløber, har disse to opgaver ikke tid til at fuldføre. De modtager en "annuller" -kommando. Det er derfor, udgangen har to linjer med dvale 1: dvale afbrudt .

Og så kan du se to linjer mere med færdig . Dette er den bivirkning, som jeg nævnte, da jeg beskrev invokeAll - metoden.

Den femte og sidste opgave kommer aldrig i gang, så det ser vi ikke noget om i outputtet.

De sidste to linjer er resultatet af at kalde metoderne isShutdown og isTerminated .

Det er også interessant at køre dette eksempel i debug-tilstand og se på opgavestatus efter timeout er udløbet (indstil et breakpoint på linjen med executorService.shutdown(); ):

Vi ser, at to opgaver fuldført normalt , og tre opgaver blev "Annulleret" .

ScheduledExecutorService

For at afslutte vores diskussion af eksekutører, lad os tage et kig på ScheduledExecutorService .

Det har 4 metoder: