Java programmeringsspråk fungerer veldig effektivt med applikasjoner som krever at oppgavene utføres samtidig i en tråd. Det blir vanskelig for ethvert program å utføre et stort antall tråder samtidig. Så for å overvinne dette problemet, leveres med ExecutorService som er et undergrensesnitt av . I denne artikkelen vil vi diskutere funksjonaliteten til ExecutorService i Java. Følgende er temaene som dekkes i denne bloggen:
- Hva er Executor Framework?
- ExecutorService i Java Eksempel
- Java ExecutorService Implementations
- Bruk av ExecutorService
- Runnable vs Callable
- Avslutning av ExecutorService
Hva er Executor Framework?
Det er ganske lettere å lage og utføre en eller to tråder samtidig. Men det blir vanskelig når antall tråder øker til et betydelig antall. Store applikasjoner med flere tråder vil ha hundrevis av tråder som kjører samtidig. Derfor er det fullstendig fornuftig å skille trådopprettingen fra trådadministrasjonen i et program.
Eksekutøren er en hjelper deg med å lage og administrere tråder i et program. De hjelper deg med følgende oppgaver.
Trådoppretting: Det gir en rekke metoder for å lage tråder som hjelper deg med å kjøre applikasjonene dine samtidig.
Trådadministrasjon: Den styrer også trådens livssyklus. Du trenger ikke bekymre deg hvis tråden er aktiv, opptatt eller død før du sender oppgaven for utføring.
Oppgaveinnlevering og utføring: Utførende rammeverk gir metoder for oppgaveinnlevering i trådpuljen. Det gir også makt til å bestemme om tråden skal utføres eller ikke.
ExecutorService i Java Eksempel
Det er et undergrensesnitt av utførelsesrammeverket som legger til visse funksjoner for å administrere trådens livssyklus til et program. Det gir også en submit () -metode som kan akseptere både kjørbar og kallbar gjenstander.
I det følgende eksemplet vil vi opprette en ExecutorService med en enkelt tråd og deretter sende oppgaven som skal utføres inne 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 ('create ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('create a runnable') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' send oppgaven som er angitt av den kjørbare til eksekutortjenesten ') executorservice.submit (kjørbar)}}Produksjon: Inside: hovedopprette ExecutorService som oppretter en kjørbar, send inn oppgaven spesifisert av kjørbar til eksekutortjenesten inne: basseng-1-tråd-1
Ovennevnte viser hvordan vi kan opprette en ExecutorService og utføre en oppgave inne i utføreren. Hvis en oppgave sendes for utføring og tråden for tiden er opptatt med å utføre en annen oppgave, vil oppgaven vente i kø til tråden er fri til å utføre den.
Når du kjører ovennevnte program, avsluttes programmet aldri. Du må slå den av eksplisitt siden eksekutortjenesten fortsetter å lytte etter nye oppgaver.
Java ExecutorService Implementations
ExecutorService ligner veldig mye på en trådgruppe. Faktisk implementeringen av ExecutorService i java.util.concurrent pakke er en threadpool-implementering. ExecutorService har følgende implementeringer i pakken java.util.concurrent:
ThreadPoolExecutor
ThreadPoolExecutor utfører de gitte oppgavene ved hjelp av en av sine internt sammenslåtte tråder.
Opprette en threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = new threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ())
ScheduledThreadPoolExecutor
Java.util.concurrent.ScheduledThreadPoolExecutor er en ExecutorService som kan planlegge oppgaver for å kjøre etter en forsinkelse eller for å utføre gjentatte ganger med et fast tidsintervall mellom hver utførelse.
Eksempel
ScheduledExecutorService scheduledexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture scheduledfuture = schedulerExecutorService.schedule (ny Callable () {public Object call () kaster unntak {System.out.println ('utført') retur 'kalt'}}, 5, TimeUnit. SEKUNDER)Bruk av ExecutorService
Det er noen forskjellige måter å delegere oppgaver til en ExecutorService.
kjør (Runnable)
send inn (Runnable)
påkalleAny ()
påkalleAll ()
Utfør Runnable
Java ExecutorService execute (Runnable) tar et java.lang.Runnable-objekt og utfører det asynkront.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()Det er ingen måte å få resultatet av kjøringen Runnable, for det må du bruke Callable.
Send inn Runnable
Java ExecutorService submit (Runnable) -metoden tar en Runnable-implementering og returnerer et fremtidig objekt. Fremtidsobjektet kan brukes til å sjekke om Runnable er ferdig med å kjøre.
Fremtidig fremtid = executorService.submit (ny Runnable () {public void run () {System.out.println (: asynchronous task ')}} future.get () // returnerer null hvis oppgaven er ferdig riktig.Send Callable
Java ExecutorService sende (Callable) -metoden ligner på send (Runnable), men det tar Java Callable i stedet for Runnable.
Fremtidig fremtid = executorService.submit (ny Callable () {public Object call () kaster Unntak {System.out.println ('Asynchronous callable') returnerer 'Callable Result'}}) System.out.println ('future.get ( ) = 'future.get ())Produksjon: Asynkron callable future.get = Resultat som kan kalles
påkalleAny ()
Metoden invokeAny () tar en samling av kallbare objekter. Å påkalle denne metoden returnerer ingen fremtid, men returnerer resultatet av et av de kallbare objektene.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nye 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 () kaster unntak {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .skru av()
Når du kjører ovennevnte kode, endres resultatet. Det kan være oppgave A, oppgave B og så videre.
InvokeAll ()
Metoden invokeAll () påkaller alle kallbare objekter som er sendt som parametere. Den returnerer fremtidige objekter som kan brukes til å få resultatene av utførelsen av hver Callable.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nye 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 () kaster unntak {return 'Oppgave C'}}) Liste futures = executorService.invokeAll (callables) for (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
De kjørbare og kallbare grensesnittene er veldig like hverandre. Forskjellen er synlig i erklæringen fra grensesnitt. Begge grensesnittene representerer en oppgave som kan utføres samtidig av en tråd eller ExecutorService.
Kallbar erklæring:
offentlig grensesnitt Callable {public object call () kaster unntak}Kjørbar erklæring:
offentlig grensesnitt Runnable {public void run ()}Hovedforskjellen mellom de to er at metoden call () kan returnere et objekt fra metodeanropet. Og ring () -metoden kan kaste en mens run () -metoden ikke kan.
Java-program for Fibonacci-serier
avbryte oppgaven
Du kan avbryte oppgaven som sendes til ExecutorService ved å ringe avbrytemetoden for fremtiden som sendes inn når oppgaven sendes.
future.cancel ()
Avslutning av ExecutorService
For å hindre at trådene kjører, selv etter at utførelsen er fullført, bør du slå av ExecutorService.
skru av()
For å avslutte trådene i en ExecutorService kan du ringe shutdown () -metoden.
executorService.shutdown ()
Dette bringer oss til slutten av denne artikkelen hvor vi har lært hvordan vi kan bruke ExecutorService til å utføre oppgaver i en tråd. Jeg håper du er klar med alt som har blitt delt med deg i denne opplæringen.
Hvis du fant denne artikkelen om “ExecutorService in Java” relevant, kan du sjekke ut et pålitelig online læringsfirma med et nettverk av mer enn 250 000 fornøyde elever spredt over hele verden.
Vi er her for å hjelpe deg med hvert trinn på reisen og komme med en læreplan som er designet for studenter og fagpersoner som ønsker å være Java-utvikler. Kurset er designet for å gi deg et forsprang i Java-programmering og trene deg for både kjerne- og avanserte Java-konsepter sammen med forskjellige som Dvalemodus & .
Hvis du kommer over noen spørsmål, er du velkommen til å stille alle spørsmålene dine i kommentarfeltet i “ExecutorService in Java”, og teamet vårt svarer gjerne.