Ang wika ng programa sa Java ay gumagana nang mahusay mga application na nangangailangan ng mga gawain upang maisagawa nang sabay-sabay sa isang thread. Nagiging mahirap para sa anumang aplikasyon na magpatupad ng isang malaking bilang ng mga thread nang sabay-sabay. Kaya upang mapagtagumpayan ang problemang ito, ay may ExecutorService na kung saan ay isang sub-interface ng . Sa artikulong ito, tatalakayin namin ang pagpapaandar ng ExecutorService sa Java. Ang mga sumusunod ay ang mga paksang sakop sa blog na ito:
- Ano ang Framework ng Tagapagpatupad?
- Halimbawa ng ExecutorService sa Java
- Pagpapatupad ng Java ExecutorService
- Paggamit ng ExecutorService
- Runnable vs Callable
- Pag-shutdown ng ExecutorService
Ano ang Framework ng Tagapagpatupad?
Ito ay medyo madali upang gumawa at magpatupad ng isa o dalawang mga thread nang sabay-sabay. Ngunit naging mahirap kapag ang bilang ng mga thread ay tumataas sa isang makabuluhang numero. Ang mga malalaking application na may maraming sinulid ay magkakaroon ng daan-daang mga thread na tumatakbo nang sabay-sabay. Samakatuwid ito ay may ganap na kahulugan upang paghiwalayin ang paggawa ng thread mula sa pamamahala ng thread sa isang application.
Ang tagapagpatupad ay isang tumutulong sa iyo sa paglikha at pamamahala ng mga thread sa isang application. Ang tumutulong sa iyo sa mga sumusunod na gawain.
Paglikha ng Thread: Nagbibigay ito ng iba't ibang mga pamamaraan para sa paglikha ng mga thread na makakatulong sa pagpapatakbo ng iyong mga aplikasyon nang sabay-sabay.
Pamamahala sa Thread: Namamahala rin ito sa siklo ng buhay ng thread. Hindi ka dapat magalala kung ang thread ay aktibo, abala o patay bago isumite ang gawain para sa pagpapatupad.
Pagsumite ng Gawain At Pagpapatupad: Ang balangkas ng tagapagpatupad ay nagbibigay ng mga pamamaraan para sa pagsusumite ng gawain sa thread pool, Nagbibigay din ito ng kapangyarihan na magpasya kung ang thread ay papatayin o hindi.
Halimbawa ng ExecutorService sa Java
Ito ay isang sub-interface ng framework ng tagapagpatupad na nagdaragdag ng ilang mga pag-andar upang pamahalaan ang ikot ng buhay ng thread ng isang application. Nagbibigay din ito ng isang magsumite () na pamamaraan na maaaring tanggapin ang parehong runnable at callable mga bagay
Sa sumusunod na halimbawa, lilikha kami ng isang ExecutorService na may isang solong thread at pagkatapos ay isumite ang gawain na naisakatuparan sa loob ng thread.
import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Halimbawa {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('paglikha ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('Lumilikha ng isang runnable') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' isumite ang gawain na tinukoy ng runnable sa executorservice ') executorservice.submit (runnable)}}Output: Sa loob: pangunahing paglikha ng ExecutorService na lumilikha ng isang runnable isumite ang gawain na tinukoy ng runnable sa executorservice sa loob: pool-1-thread-1
Sa itaas ipinapakita kung paano kami makakalikha ng isang ExecutorService at magpatupad ng isang gawain sa loob ng tagapagpatupad. Kung ang isang gawain ay naisumite para sa pagpapatupad at ang thread ay kasalukuyang abala sa pagpapatupad ng isa pang gawain, pagkatapos ang gawain ay maghihintay sa isang pila hanggang sa ang thread ay malayang ipatupad ito.
Kapag pinatakbo mo ang nasa itaas na programa, hindi lalabas ang programa. Kakailanganin mong i-shut down ito nang malinaw dahil ang serbisyo ng tagapagpatupad ay patuloy na nakikinig para sa mga bagong gawain.
Pagpapatupad ng Java ExecutorService
Ang ExecutorService ay halos kapareho ng isang thread pool. Sa katunayan, ang pagpapatupad ng ExecutorService sa java.util.concurrent pakete ay isang pagpapatupad ng threadpool. Ang ExecutorService ay may mga sumusunod na pagpapatupad sa java.util.concurrent package:
ThreadPoolExecutor
Isinasagawa ng ThreadPoolExecutor ang mga naibigay na gawain gamit ang isa sa mga panloob na naka-pool na thread.
Lumilikha ng isang threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 mahabang keepAliveTime = 5000 ExecutorService threadPoolExecutor = bagong threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, bagong LinkedBlockingQueue ())
Nakaiskedyul naThreadPoolExecutor
Ang java.util.concurrent.ScheduledThreadPoolExecutor ay isang ExecutorService na maaaring mag-iskedyul ng mga gawain upang tumakbo pagkatapos ng isang pagka-antala o upang maipatupad nang paulit-ulit na may isang nakapirming agwat ng oras sa pagitan ng bawat pagpapatupad.
Halimbawa
Naka-iskedyulExecutorServicechedexecutorservice = Executors.newSchedosedThreadPool (5) naka-iskedyulFuturechedfuture = naka-iskedyulExecutorService.schedule (bagong Callable () {public Object call () nagtatapon ng Exception {System.out.println ('pinaandar') bumalik 'tinatawag na'}}, 5, TimeUnit. SECONDS)Paggamit ng ExecutorService
Mayroong ilang magkakaibang paraan upang maibigay ang mga gawain sa isang ExecutorService.
magpatupad (Runnable)
isumite (Runnable)
invokeAny ()
invokeAll ()
Isagawa ang Runnable
Ang Java ExecutorService execute (Runnable) ay tumatagal ng isang java.lang.Runnable object at isinasagawa ito nang hindi magkakasabay.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execut (bagong Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()Walang paraan upang makuha ang resulta ng pagpapatupad ng Runnable, para sa na kailangan mong gamitin ang Callable.
Isumite ang Runnable
Ang pamamaraan ng pagsumite ng Java ExecutorService (Runnable) ay tumatagal ng isang Runnable na pagpapatupad at nagbabalik ng isang hinaharap na object. Ang hinaharap na bagay ay maaaring magamit upang suriin kung ang Runnable ay natapos nang magpatupad.
Hinaharap na hinaharap = executorService.submit (bagong Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // babalik kung ang gawain ay tapos nang tama.Magsumite ng Callable
Ang pamamaraan ng pagsumite ng Java ExecutorService (Callable) ay katulad ng pagsumite (Runnable) ngunit tumatagal ito ng Java Callable sa halip na Runnable.
Hinaharap na hinaharap = executorService.submit (bagong Callable () {public Object call () ay nagtatapon ng Exception {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('Future.get ( ) = 'hinaharap.get ())Output: Asynchroous callable future.get = Natatawag na Resulta
invokeAny ()
Ang invokeAny () na pamamaraan ay tumatagal ng isang koleksyon ng mga Maaaring tawaging bagay. Ang pagsisikap sa pamamaraang ito ay hindi magbabalik ng anumang hinaharap, ngunit ibabalik ang resulta ng isa sa mga Maaaring tawaging bagay.
ExecutorService executorService = Executors.newSingleThreadExecutor () Itakdamga callable = bagong HashSet () callables.add (bagong Callable () {public String call () ay nagtatapon ng Exception {return'task A '}}) callables.add (bagong Callable () {public String call () ay nagtapon ng Exception {return'task B'} }) callables.add (bagong Callable () {public String call () ay nagtatapon ng Exception {return'task C '}}) String resulta = executorService.invokeAny (callables) System.out.println (' resulta = '+ resulta) executorService .shutdown ()
Kapag pinatakbo mo ang code sa itaas, nagbabago ang resulta. Maaaring ito ang Gawain A, Gawain B at iba pa.
InvokeAll ()
Inilalagay ng pamamaraang invokeAll () ang lahat ng mga Maaaring tawaging bagay na naipasa bilang mga parameter. Ibinabalik nito ang mga hinaharap na bagay na maaaring magamit upang makuha ang mga resulta ng pagpapatupad ng bawat Callable.
ExecutorService executorService = Executors.newSingleThreadExecutor () Itakdamga callable = bagong HashSet () callables.add (bagong Callable () {public String call () ay nagtatapon ng Exception {return 'Task A'}}) callables.add (bagong Callable () {public String call () ay nagtapon ng Exception {return 'Task B'} }) callables.add (bagong Callable () {public String call () ay nagtatapon ng Exception {return 'Task C'}}) Listahan futures = executorService.invokeAll (callables) para sa (Hinaharap sa hinaharap: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
Ang runnable at callable interface ay halos magkatulad sa bawat isa. Ang pagkakaiba ay nakikita sa deklarasyon ng mga interface. Ang parehong mga interface ay kumakatawan sa isang gawain na maaaring maisagawa nang sabay-sabay ng isang thread o ExecutorService.
Natatawag na Pahayag:
pampublikong interface Natatawag na {public object call () ay nagtapon ng Exception}Runnable Declaration:
pampublikong interface Maaaring mapatakbo ang {public void run ()}Ang pangunahing pagkakaiba sa pagitan ng dalawa ay ang paraan ng pagtawag () na maaaring ibalik ang isang bagay mula sa pamamaraang tawagan. At ang paraan ng pagtawag () ay maaaring magtapon ng isang habang ang run () na pamamaraan ay hindi maaaring.
java cast string hanggang ngayon
kanselahin ang gawain
Maaari mong kanselahin ang gawaing isinumite sa ExecutorService sa pamamagitan lamang ng pagtawag sa paraan ng pagkansela sa hinaharap na isinumite kapag ang gawain ay naisumite.
hinaharap.cancel ()
Pag-shutdown ng ExecutorService
Upang maiwasang tumakbo ang mga thread kahit na nakumpleto ang pagpapatupad, dapat mong patayin ang ExecutorService.
pag-shutdown ()
Upang wakasan ang mga thread sa loob ng isang ExecutorService maaari mong tawagan ang paraan ng pag-shutdown ().
executorService.shutdown ()
Dadalhin tayo nito sa pagtatapos ng artikulong ito kung saan natutunan namin kung paano namin magagamit ang ExecutorService upang magpatupad ng mga gawain sa isang thread. Inaasahan kong malinaw ka sa lahat ng naibahagi sa iyo sa tutorial na ito.
Kung nahanap mo ang artikulong ito sa 'ExecutorService in Java' na may kaugnayan, tingnan ang isang pinagkakatiwalaang kumpanya sa online na pag-aaral na may isang network ng higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo.
Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay at magkaroon ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang katulad Hibernate & .
Kung may nahahanap kang anumang mga katanungan, huwag mag atubili na tanungin ang lahat ng iyong mga katanungan sa seksyon ng mga komento ng 'ExecutorService in Java' at ang aming koponan ay nalulugod na sagutin.