Java-programmeringsspråk fungerar mycket effektivt med applikationer som kräver att uppgifterna ska köras samtidigt i en tråd. Det blir svårt för alla applikationer att köra ett stort antal trådar samtidigt. Så för att övervinna detta problem, levereras med ExecutorService som är ett undergränssnitt för . I den här artikeln kommer vi att diskutera funktionaliteten hos ExecutorService i Java. Följande är ämnen som tas upp i den här bloggen:
- Vad är Executor Framework?
- ExecutorService i Java Exempel
- Java ExecutorService Implementations
- ExecutorService-användning
- Runnable vs Callable
- Avstängning av ExecutorService
Vad är Executor Framework?
Det är ganska lättare att skapa och utföra en eller två trådar samtidigt. Men det blir svårt när antalet trådar ökar till ett betydande antal. Stora applikationer med flera trådar kommer att ha hundratals trådar som körs samtidigt. Därför är det helt meningsfullt att separera trådskapandet från trådhantering i en applikation.
Exekutören är en hjälper dig att skapa och hantera trådar i en applikation. De hjälper dig i följande uppgifter.
Trådskapande: Det ger en mängd olika metoder för att skapa trådar som hjälper dig att köra dina applikationer samtidigt.
Trådhantering: Det hanterar också trådens livscykel. Du behöver inte oroa dig om tråden är aktiv, upptagen eller död innan du skickar uppgiften för körning.
Task Submission And Execution: Executor framework tillhandahåller metoder för uppgiftssändning i trådpoolen. Det ger också befogenhet att avgöra om tråden ska köras eller inte.
ExecutorService i Java Exempel
Det är ett delgränssnitt för exekveringsramen som lägger till vissa funktioner för att hantera trådens livscykel för en applikation. Det ger också en submit () -metod som kan acceptera både körbar och anropbar objekt.
I följande exempel skapar vi en ExecutorService med en enda tråd och skickar sedan uppgiften som ska köras inuti tråden.
import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Exempel {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 (' skicka uppgiften som anges av körbar till körtjänsten ') executorservice.submit (körbar)}}Produktion: Insida: huvudskapande ExecutorService som skapar en körbar skicka uppgiften som anges av körbar till exekutörtjänsten inuti: pool-1-tråd-1
Ovanstående visar hur vi kan skapa en ExecutorService och utföra en uppgift i exekutören. Om en uppgift skickas för körning och tråden för närvarande är upptagen med att utföra en annan uppgift, väntar uppgiften i en kö tills tråden är fri att utföra den.
När du kör programmet ovan kommer programmet aldrig att avslutas. Du måste stänga av det uttryckligen eftersom exekutörtjänsten fortsätter att lyssna på nya uppgifter.
Java ExecutorService Implementations
ExecutorService liknar väldigt mycket en trådpool. Faktum är att implementeringen av ExecutorService i java.util.concurrent paket är en threadpool-implementering. ExecutorService har följande implementeringar i paketet java.util.concurrent:
ThreadPoolExecutor
ThreadPoolExecutor utför de angivna uppgifterna med hjälp av en av sina internt sammanslagna trådar.
Skapa en threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 lång keepAliveTime = 5000 ExecutorService threadPoolExecutor = ny threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ())
ScheduledThreadPoolExecutor
Java.util.concurrent.ScheduledThreadPoolExecutor är en ExecutorService som kan schemalägga att uppgifter ska köras efter en fördröjning eller att köras upprepade gånger med ett fast tidsintervall mellan varje körning.
Exempel
ScheduledExecutorService scheduledexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture scheduledfuture = scheduleradExecutorService.schedule (new Callable () {public Object call) kastar Exception {System.out.println ('executed') return 'called'}}, 5, TimeUnit. SEKUNDER)ExecutorService-användning
Det finns några olika sätt att delegera uppgifter till en ExecutorService.
exekvera (körbar)
skicka (körbar)
anropa alla ()
anropa alla ()
Kör körbar
Java ExecutorService execute (Runnable) tar ett java.lang.Runnable-objekt och kör det asynkront.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()Det finns inget sätt att få resultatet av körningen Runnable, för det måste du använda Callable.
Skicka Runnable
Java ExecutorService-inlämningsmetoden (körbar) tar en körbar implementering och returnerar ett framtida objekt. Det framtida objektet kan användas för att kontrollera om körningen har slutförts.
Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // returnerar null om uppgiften är klar korrekt.Skicka Callable
Java ExecutorService-inlämningsmetoden (anropbar) liknar inlämnande (körbar) men det krävs Java anropbar istället för körbar.
Framtida framtid = executorService.submit (ny Callable () {public Object call () kastar Undantag {System.out.println ('Asynchronous callable') returnerar 'Callable Result'}}) System.out.println ('future.get ( ) = 'future.get ())Produktion: Asynkron anropbar framtid.get = Resultat som kan anropas
anropa alla ()
Metoden invokeAny () tar en samling Callable-objekt. Åberopande av den här metoden returnerar ingen framtid utan returnerar resultatet av ett av de objekt som kan kallas.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nya HashSet () callables.add (new Callable () {public String call () kastar undantag {return'task A '}}) callables.add (new Callable () {public String call () kastar Exception {return'task B'} }) callables.add (new Callable () {public String call () kastar undantag {return'task C '}}) Strängresultat = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .stänga av()
När du kör ovanstående kod ändras resultatet. Det kan vara uppgift A, uppgift B och så vidare.
InvokeAll ()
Metoden invokeAll () anropar alla anrop som kan skickas som parametrar. Den returnerar de framtida objekten som kan användas för att få resultatet av utförandet av varje Callable.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = nya HashSet () callables.add (new Callable () {public Strängsamtal () kastar undantag {return 'Task A'}}) callables.add (new Callable () {public String call () kastar Exception {return 'Task B'} }) callables.add (new Callable () {public String call () kastar undantag {return 'Task C'}}) Lista futures = executorService.invokeAll (callables) för (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
De körbara och anropbara gränssnitten är mycket lika varandra. Skillnaden syns i deklarationen från gränssnitt. Båda gränssnitten representerar en uppgift som kan köras samtidigt av en tråd eller ExecutorService.
Callable deklaration:
offentligt gränssnitt Callable {public object call () kastar Undantag}Körbar deklaration:
offentligt gränssnitt Runnable {public void run ()}Huvudskillnaden mellan de två är att call () -metoden kan returnera ett objekt från metodanropet. Och call () -metoden kan kasta en medan run () -metoden inte kan.
vad är ett reserverat ord i java
avbryta uppgiften
Du kan avbryta uppgiften som skickas till ExecutorService genom att helt enkelt anropa avbrytningsmetoden för framtiden som skickas in när uppgiften skickas.
future.cancel ()
Avstängning av ExecutorService
För att hålla trådarna igång även efter att körningen är klar bör du stänga av ExecutorService.
stänga av()
För att avsluta trådarna i en ExecutorService kan du ringa shutdown () -metoden.
executorService.shutdown ()
Detta leder oss till slutet av den här artikeln där vi har lärt oss hur vi kan använda ExecutorService för att utföra uppgifter i en tråd. Jag hoppas att du är tydlig med allt som har delats med dig i denna handledning.
Om du tyckte att den här artikeln om ”ExecutorService i Java” var relevant, kolla in ett pålitligt online-lärande företag med ett nätverk med mer än 250 000 nöjda elever spridda över hela världen.
Vi är här för att hjälpa dig med varje steg på din resa och komma med en läroplan som är utformad för studenter och yrkesverksamma som vill vara Java-utvecklare. Kursen är utformad för att ge dig ett försprång till Java-programmering och träna dig för både kärn- och avancerade Java-koncept tillsammans med olika tycka om Övervintra & .
Om du stöter på några frågor är du välkommen att ställa alla dina frågor i kommentarsektionen i 'ExecutorService i Java' och vårt team kommer gärna att svara.