Hvad er ExecutorService i Java, og hvordan oprettes det?

Denne artikel dækker begrebet Executor-subgrænseflade ExecutorService i Java med forskellige eksempler til forklaring af trådoprettelse og -administration i Java.

Java-programmeringssprog fungerer meget effektivt med applikationer, der kræver, at opgaverne udføres samtidigt i en tråd. Det bliver svært for enhver applikation at udføre et stort antal tråde samtidigt. Så for at overvinde dette problem, leveres med ExecutorService, som er en undergrænseflade til . I denne artikel vil vi diskutere funktionaliteten af ​​ExecutorService i Java. Følgende er de emner, der er dækket af denne blog:



Hvad er Executor Framework?

Det er ret nemmere at oprette og udføre en eller to tråde samtidigt. Men det bliver svært, når antallet af tråde stiger til et betydeligt antal. Store applikationer med flere tråde har hundreder af tråde, der kører samtidigt. Derfor giver det mening at adskille trådoprettelsen fra trådadministration i en applikation.



Eksekutøren er en hjælper dig med at oprette og administrere tråde i en applikation. Det hjælper dig med følgende opgaver.

  • Trådoprettelse: Det giver en række forskellige metoder til oprettelse af tråde, der hjælper med at køre dine applikationer samtidigt.



  • Trådadministration: Det styrer også trådens livscyklus. Du behøver ikke bekymre dig, hvis tråden er aktiv, optaget eller død, inden du sender opgaven til udførelse.

  • Opgavesendelse og udførelse: Eksekverer-rammen giver metoder til indsendelse af opgaver i trådpuljen. Det giver også beføjelse til at beslutte, om tråden skal udføres eller ej.

executorservice-executorservice i java-edureka

ExecutorService i Java-eksempel

Det er en undergrænseflade af eksekvererrammen, der tilføjer visse funktioner til at styre trådens livscyklus for en applikation. Det giver også en submit () -metode, der kan acceptere både kørbar og kaldbar genstande.



I det følgende eksempel opretter vi en ExecutorService med en enkelt tråd og sender derefter den opgave, der skal udføres inde i tråden.

import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Eksempel {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('oprettelse af ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('oprettelse af en kørbar') Kørbar kørbar = () -> {System.out.println ('indeni: '+ Thread.currentThread (). GetName ())} System.out.println (' indsend den opgave, der er angivet af den kørende til eksekutortjenesten ') executorservice.submit (kørbar)}}
 Produktion: Inde: hoved opretter ExecutorService opretter en kørbar indsend den opgave, der er kørt af kørbar til eksekutortjenesten inden i: pool-1-tråd-1

Ovenstående viser, hvordan vi kan oprette en ExecutorService og udføre en opgave inde i eksekutoren. Hvis en opgave sendes til udførelse, og tråden i øjeblikket er optaget af at udføre en anden opgave, venter opgaven i en kø, indtil tråden er fri til at udføre den.

Når du kører ovenstående program, afsluttes programmet aldrig. Du bliver nødt til at lukke det eksplicit, da eksekutortjenesten fortsætter med at lytte efter nye opgaver.

Java ExecutorService-implementeringer

ExecutorService ligner meget en trådpulje. Faktisk implementeringen af ​​ExecutorService i java.util.concurrent pakke er en threadpool-implementering. ExecutorService har følgende implementeringer i pakken java.util.concurrent:

ThreadPoolExecutor

ThreadPoolExecutor udfører de givne opgaver ved hjælp af en af ​​dens internt samlede tråde.

Oprettelse af en threadPoolExecutor

int corePoolSize = 5 int maxPoolSize = 10 lang keepAliveTime = 5000 ExecutorService threadPoolExecutor = ny threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, ny LinkedBlockingQueue ())

ScheduledThreadPoolExecutor

Java.util.concurrent.ScheduledThreadPoolExecutor er en ExecutorService, der kan planlægge opgaver, der skal køres efter en forsinkelse eller udføres gentagne gange med et fast tidsinterval mellem hver udførelse.

Eksempel

ScheduledExecutorService scheduledexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture scheduleretfuture = scheduleretExecutorService.schedule (nyt kaldbart () {offentligt objektopkald () kaster undtagelse {System.out.println ('udført') retur 'kaldet'}}, 5, TimeUnit. SEKUNDER)

ExecutorService brug

Der er et par forskellige måder at delegere opgaver til en ExecutorService.

  • udføre (Runnable)

  • indsend (Runnable)

  • påkalde enhver ()

  • påkaldeAlle ()

Udfør Runnable

Java ExecutorService execute (Runnable) tager et java.lang.Runnable-objekt og udfører det asynkront.

ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()

Der er ingen måde at få resultatet af udførelsen Runnable på, for at du skal bruge den Callable.

Send Runnable

Java ExecutorService-indsendemetode (Runnable) tager en implementering, der kan køres, og returnerer et fremtidigt objekt. Det fremtidige objekt kan bruges til at kontrollere, om Runnable er færdig med at udføre.

Fremtidig fremtid = executorService.submit (ny Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // returnerer null, hvis opgaven er færdig korrekt.

Send opkaldelig

Java ExecutorService-sendemetoden (kaldbar) ligner den, der sendes (kan køres), men det kræver Java, der kan kaldes i stedet for kørbar.

Fremtidig fremtid = executorService.submit (ny kaldbar () {offentligt objektopkald () kaster undtagelse {System.out.println ('Asynkron kaldbar') returnerer 'Opkaldeligt resultat'}}) System.out.println ('future.get ( ) = 'future.get ())
 Produktion: Asynkron callable future.get = Resultat, der kan kaldes

påkalde enhver ()

Metoden invokeAny () tager en samling af objekter, der kan kaldes. Påkald af denne metode returnerer ikke nogen fremtid, men returnerer resultatet af et af de genstande, der kan kaldes.

ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nyt HashSet() callables.add (new Callable () {public String call () throw Exception {return'task A '}}) callables.add (new Callable () {public String call () throw Exception {return'task B'} }) callables.add (new Callable () {public String call () throw Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .lukke ned()

Når du kører ovenstående kode, ændres resultatet. Det kan være Opgave A, Opgave B og så videre.

InvokeAll ()

Metoden invokeAll () påkalder alle objekter, der kan kaldes, der er sendt som parametre. Det returnerer de fremtidige objekter, som kan bruges til at få resultaterne af udførelsen af ​​hver Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nyt HashSet() callables.add (new Callable () {public String call () throw Exception {return 'Task A'}}) callables.add (new Callable () {public String call () throw Exception {return 'Task B'} }) callables.add (new Callable () {public String call () throw Exception {return 'Task C'}}) Listfutures = executorService.invokeAll (callables) for (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

Kan køres vs Kaldes

De kørbare og kaldbare grænseflader er meget lig hinanden. Forskellen er synlig i erklæringen fra grænseflader. Begge grænseflader repræsenterer en opgave, der kan udføres samtidigt af en tråd eller ExecutorService.

Opkaldelig erklæring:

offentlig grænseflade, der kan kaldes {offentligt objektopkald () kaster undtagelse}

Kørbar erklæring:

offentlig grænseflade Kan køres {public void run ()}

Hovedforskellen mellem de to er, at call () -metoden kan returnere et objekt fra metodekaldet. Og call () -metoden kan kaste en mens run () -metoden ikke kan.

hvad er charat i java

annullere opgave

Du kan annullere den opgave, der er sendt til ExecutorService, ved blot at ringe til annulleringsmetoden for den fremtidige indsendelse, når opgaven sendes.

future.cancel ()

Lukning af ExecutorService

For at forhindre trådene i at køre, selv efter udførelsen er afsluttet, skal du lukke ExecutorService.

lukke ned()

For at afslutte trådene inde i en ExecutorService kan du kalde metoden shutdown ().

executorService.shutdown ()

Dette bringer os til slutningen af ​​denne artikel, hvor vi har lært, hvordan vi kan bruge ExecutorService til at udføre opgaver i en tråd. Jeg håber, du er klar med alt, hvad der er delt med dig i denne vejledning.

Hvis du fandt denne artikel om “ExecutorService i Java” relevant, skal du tjekke et betroet online læringsfirma med et netværk på mere end 250.000 tilfredse elever spredt over hele kloden.

Vi er her for at hjælpe dig med hvert trin på din rejse og komme med en læseplan, der er designet til studerende og fagfolk, der ønsker at være Java-udvikler. Kurset er designet til at give dig et forspring i Java-programmering og træne dig til både kerne- og avancerede Java-koncepter sammen med forskellige synes godt om Dvale & .

Hvis du støder på spørgsmål, er du velkommen til at stille alle dine spørgsmål i kommentarfeltet i “ExecutorService i Java”, og vores team vil med glæde svare.