Kas ir ExecutorService Java valodā un kā to izveidot?

Šis raksts aptver Executor apakšsaskarnes ExecutorService Java jēdzienu ar dažādiem piemēriem, lai izskaidrotu pavedienu izveidi un pārvaldību Java.

Java programmēšanas valoda darbojas ļoti efektīvi lietojumprogrammas, kurām uzdevumi jāveic vienlaicīgi pavedienā. Jebkurai lietojumprogrammai kļūst grūti vienlaikus izpildīt lielu skaitu pavedienu. Lai pārvarētu šo problēmu, nāk ar ExecutorService, kas ir . Šajā rakstā mēs apspriedīsim ExecutorService funkcionalitāti Java. Šajā emuārā apskatītas šādas tēmas:



Kas ir Executor Framework?

Diezgan vieglāk ir izveidot un izpildīt vienu vai divus pavedienus vienlaicīgi. Bet kļūst grūti, ja pavedienu skaits palielinās līdz ievērojamam skaitam. Lielām vairāku pavedienu lietojumprogrammām vienlaikus darbosies simtiem pavedienu. Tāpēc ir pilnīgi jēga atdalīt pavedienu izveidi no pavedienu pārvaldības lietojumprogrammā.



Izpildītājs ir a palīdz jums izveidot un pārvaldīt pavedienus lietojumprogrammā. The palīdz jums veikt šādus uzdevumus.

  • Vītņu izveide: tā piedāvā dažādas metodes pavedienu izveidei, kas palīdz vienlaikus palaist jūsu lietojumprogrammas.



  • Vītņu vadība: tā pārvalda arī pavedienu dzīves ciklu. Pirms uzdevuma iesniegšanas izpildei jums nav jāuztraucas, ja pavediens ir aktīvs, aizņemts vai miris.

  • Uzdevuma iesniegšana un izpilde: izpildītāja ietvars piedāvā metodes uzdevumu iesniegšanai pavedienu krājumā. Tas arī dod tiesības izlemt, vai pavediens tiks izpildīts vai nē.

izpildītāju pakalpojums-izpildītāju pakalpojums java -edurekā

ExecutorService Java piemērā

Tā ir izpildītāja ietvara apakšsaskarne, kas pievieno dažas funkcijas, lai pārvaldītu lietojumprogrammas pavedienu dzīves ciklu. Tas nodrošina arī iesniegšanas () metodi, ar kuru var pieņemt gan palaistu, gan izsaucamu objektiem.



Šajā piemērā mēs izveidosim ExecutorService ar vienu pavedienu un pēc tam iesniegsim izpildāmo uzdevumu pavediena iekšpusē.

importēt java.util.concurrent.ExecutorService importēt java.util.concurrent.Executors public class Piemērs {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('ExecutorService izveide') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('izveidojot palaižamu') Runnable runnable = () -> {System.out.println (iekšpusē '+ Thread.currentThread (). GetName ())} System.out.println (' iesniedz izpildāmā pakalpojuma izpildāmā uzdevuma norādīto uzdevumu ') executorservice.submit (palaižams)}}
 Izeja: Iekšpusē: galvenā izveides ExecutorService izveidojot palaižamu uzdevumu, kuru norādījis izpildāms, iesniedz izpildītājam iekšpusē: pool-1-thread-1

Augšējais parāda, kā mēs varam izveidot ExecutorService un izpildīt uzdevumu izpildītāja iekšpusē. Ja uzdevums ir iesniegts izpildei un pavediens pašlaik ir aizņemts, izpildot citu uzdevumu, uzdevums gaidīs rindā, līdz pavediens varēs to izpildīt.

Palaidot iepriekš minēto programmu, programma nekad netiks izieta. Jums tas būs skaidri jāizslēdz, jo izpildītāja dienests turpina klausīties jaunus uzdevumus.

Java ExecutorService ieviešana

ExecutorService ir ļoti līdzīgs pavedienu kopai. Faktiski ExecutorService ieviešana java.util.concurrent iepakojums ir threadpool ieviešana. ExecutorService pakotnē java.util.concurrent ir šādas realizācijas:

ThreadPoolExecutor

ThreadPoolExecutor izpilda dotos uzdevumus, izmantojot vienu no tā iekšēji apvienotajiem pavedieniem.

ThreadPoolExecutor izveide

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

ScheduledThreadPoolExecutor

Java.util.concurrent.ScheduledThreadPoolExecutor ir ExecutorService, kas var ieplānot uzdevumu izpildi pēc aizkavēšanās vai atkārtotu izpildi ar noteiktu laika intervālu starp katru izpildi.

Piemērs

ScheduledExecutorService scheduleexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture ieplānotais nākotne = plānotaisExecutorService.schedule (jauns izsaucamais () {publiskā objekta izsaukums () izņēmums {System.out.println ('izpildīts') atgriež 'Laiks'}}} SECONDS)

ExecutorService lietojums

Ir daži dažādi veidi, kā deleģēt uzdevumus ExecutorService.

  • izpildīt (Runnable)

  • iesniegt (darbojas)

  • invokeAny ()

  • invokeAll ()

Izpildīt Runnable

Java ExecutorService izpildīt (Runnable) aizņem java.lang.Runnable objektu un izpilda to asinhroni.

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

Nekādi nevar iegūt izpildāmās Runnable rezultātu, tāpēc jums jāizmanto Callable.

Iesniegt Runnable

Java ExecutorService iesniegšanas (palaist) metode aizpilda Runnable ieviešanu un atgriež nākotnes objektu. Nākamo objektu var izmantot, lai pārbaudītu, vai Runnable ir izpildījis.

Nākotnes nākotne = executorService.submit (jauns Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // atgriež nulli, ja uzdevums ir pabeigts pareizi.

Iesniegt izsaucamo

Java ExecutorService iesniegšanas (izsaucamās) metode ir līdzīga iesniegšanai (Runnable), taču Runnable vietā tā prasa Java Callable.

Nākotnes nākotne = executorService.submit (new Callable () {public Object call () izmet izņēmumu {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('future.get ( ) = 'nākotne.get ())
 Izeja: Asynchroous callable future.get = Zvana rezultāts

invokeAny ()

Metode invokeAny () aizņem objektu Callable kolekciju. Šīs metodes izsaukšana neatgriež nekādu nākotni, bet atgriež viena no objekta Callable rezultātu.

ExecutorService executorService = Executors.newSingleThreadExecutor () kopacallable = jauns HashSet() callables.add (new Callable () {public String call () throws Exception {return'task A '}}) callables.add (new Callable () {public String call () throws Exception {return'task B'} }) callables.add (new Callable () {public String call () izmet izņēmumu {return'task C '}}) virknes rezultāts = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .izslēgt()

Palaidot iepriekš minēto kodu, rezultāts mainās. Tas var būt uzdevums A, uzdevums B un tā tālāk.

InvokeAll ()

Metode invokeAll () izsauc visus parametros nodotos izsaucamos objektus. Tas atgriež nākotnes objektus, kurus var izmantot, lai iegūtu katra Callable izpildes rezultātus.

ExecutorService executorService = Executors.newSingleThreadExecutor () kopacallable = jauns HashSet() callables.add (new Callable () {public String call () throws Exception {return 'Task A'}}}) callables.add (new Callable () {public String call () throws Exception {return 'Task B'} }) callables.add (new Callable () {public String call () izmet izņēmumu {return 'Task C'}})futures = executorService.invokeAll (izsaucamie) domēnam [Future future: futures] {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

Runnable vs Callable

Skrienamās un izsaucamās saskarnes ir ļoti līdzīgas viena otrai. Atšķirība ir redzama Deklarācijā saskarnes. Abas saskarnes ir uzdevums, kuru vienlaicīgi var izpildīt pavediens vai ExecutorService.

Deklarējama deklarācija:

publiskā saskarne Zvana {public object call () throws Exception}

Darbināmā deklarācija:

publiskā saskarne Palaižama {public void run ()}

Galvenā atšķirība starp abiem ir tā, ka metode call () var atgriezt objektu no metodes izsaukuma. Un zvana () metode var iemest kamēr run () metode nevar.

ir un ir attiecības java

atcelt uzdevumu

Jūs varat atcelt ExecutorService iesniegto uzdevumu, vienkārši izsaucot atcelšanas metodi nākotnē iesniegtajam, kad uzdevums ir iesniegts.

future.cancel ()

ExecutorService izslēgšana

Lai pavedieni netiktu palaisti pat pēc izpildes pabeigšanas, jāizslēdz ExecutorService.

izslēgt()

Lai pārtrauktu pavedienus ExecutorService iekšienē, varat izsaukt shutdown () metodi.

executorService.shutdown ()

Tādējādi mēs nonākam līdz šī raksta beigām, kur mēs esam iemācījušies, kā mēs varam izmantot ExecutorService, lai izpildītu uzdevumus pavedienā. Es ceru, ka jums ir skaidrs viss, kas ar jums ir kopīgots šajā apmācībā.

Ja jums šis raksts par “ExecutorService in Java” ir aktuāls, pārbaudiet uzticams tiešsaistes mācību uzņēmums ar vairāk nekā 250 000 apmierinātu izglītojamo tīklu visā pasaulē.

Mēs esam šeit, lai palīdzētu jums katrā solī jūsu ceļojumā un izdomātu mācību programmu, kas paredzēta studentiem un profesionāļiem, kuri vēlas būt Java izstrādātāji. Kurss ir paredzēts, lai dotu jums sākumu Java programmēšanā un apmācītu gan pamata, gan uzlabotas Java koncepcijas kopā ar dažādām patīk Pārziemot & .

Ja rodas kādi jautājumi, droši uzdodiet visus jautājumus komentāru sadaļā “ExecutorService in Java”, un mūsu komanda ar prieku atbildēs.