Paano Ipapatupad ang Callable Interface sa Java

Sinaksihan ng mga programang Java multithreading ang paggamit ng malawak Tawag at Kinabukasan. Sa ilalim ng paunang kinakailangan na kaalaman sa mga thread at multi-threading, mas madaling maunawaan ng mga mambabasa ang talakayan sa artikulong ito. Tulad ng ipapaliwanag ko sa Callable Interface sa Java sa artikulong ito.

• Recap sa Mga Thread
• Ano ang Callable Interface sa Java
• Pagbabalik ng Callable Interface
• Mga Tampok ng Callable at Future Class
• Paghahambing ng Mga Callable at Runnable Class

Recap sa Mga Thread

Gayunpaman, hayaan mo lamang akong magbigay ng isang maikling pagpapakilala sa konsepto ng mga thread. Ang isang thread ay isang hiwalay na landas ng pagpapatupad, kung sakaling kailangan mong magsagawa ng isang paulit-ulit na gawain, ang trabaho ay maaaring masira sa maraming mga gawain at italaga ang mga ito sa mga thread. Multi-threadingay walang anuman kundi ang pagtatalaga ng maraming mga thread upang maisagawa ang iba't ibang mga gawain nang kahanay upang mabilis na makuha ang resulta.

Ano ang Callable Interface sa Java

Para sa Java 5, ipinakilala ang klase na 'java.util.concurrent'. Ang natatawag na interface na ito ay dinala sa pamamagitan ng package ng concurrency na mukhang katulad sa Runnable interface. Maaari rin nitong ibalik ang anumang bagay at makapagtapon ng isang Exception. Ang isang Java Callable interface ay gumagamit ng Mga Generics, kaya ginagawang posible na ibalik ang anumang uri ng object. Nagbibigay ang Framework ng Tagapagpatupad ng isang magsumite () na pamamaraan upang maipatupad ang mga Maaaring tawaging pagpapatupad sa isang pool ng mga thread. Sa katotohanan, ang Java Executor Framework ay sumusunod sa mga pattern ng WorkerThread.

Sa isang thread pool ang mga gumagamit ay maaaring magpasimula ng mga thread sa pamamagitan ng paggamit ng Executors.newFixedThreadPool (10) na pamamaraan at nang naaayon magsumite ng isang gawain dito. Ang isang runnable na gumaganap bilang target ng isang thread at isang pampublikong void run () na pamamaraan ay utos na ipinatupad upang tukuyin ang gawain. Isasagawa ito ng mga thread sa thread pool. Batay sa pagkakaroon ng mga thread sa pool, ang Executor Framework ay nagtatalaga ng trabaho (runnable target) sa mga thread.Kung ang lahat ng mga thread ay ginagamit, ang gawain ay dapat na tumigil. Matapos makumpleto ng thread ang isang gawain pagkatapos ay bumalik ito sa pool bilang isang magagamit na thread, na handa nang tanggapin ang mga gawain sa hinaharap. Ang Callable ay katulad ng Runnable at maaaring ibalik ang anumang uri ng object kapag nais naming makakuha ng isang resulta o katayuan mula sa gawain.

Pagbabalik ng Callable Interface

Ang Java Callable ay nagbabalik ng java.util.concurrent. Nag-aalok ang Java Future ng isang pagkansela () na paraan upang maalis ang nauugnay na Gawain na gawain. Ito ay isang overloaded na bersyon ng paraan ng pagkuha (), kung saan maaaring tukuyin ng isang tao ang isang tiyak na oras upang maghintay para sa resulta. Kapaki-pakinabang upang maiwasan ang isang kasalukuyang thread, na maaaring ma-block para sa isang mas mahabang panahon. Mangyaring tandaan na ang pamamaraan ng pagkuha ay isang magkasabay na pamamaraan at hanggang sa matapos ang natawagan na gawain nito at ibalik ang isang halaga, maghihintay ito para sa isang matatawag.

Mayroon ding mga pamamaraan na 'isDone ()' at 'isCancelled ()' upang makuha ang kasalukuyang katayuan ng isang nauugnay na Gawain na gawain. Isaalang-alang ang halimbawa kung saan ang isang kabuuan ng lahat ng mga numero mula isa hanggang 100 ay kailangang matagpuan. Maaari kaming mag-loop ng 1 hanggang 100 nang sunud-sunod at sa wakas ay idadagdag ang mga ito. Ang isa pang posibilidad ay sa pamamagitan ng paghahati at pananakop. Sa pamamaraang ito, maaari naming mapangkat ang mga numero sa isang paraan tulad ng bawat pangkat ay may eksaktong dalawang elemento. Sa wakas, maaari naming italaga ang pangkat na iyon sa isang pool ng mga thread. Samakatuwid, ang bawat thread ay nagbabalik ng isang bahagyang kabuuan nang kahanay at pagkatapos ay kinokolekta ang mga bahagyang kabuuan at idagdag ang mga ito upang makuha ang buong kabuuan.

pag-uri-uriin ang array c ++ pataas

Mga Tampok ng Callable at Future Class

• Ang tinatawag na klase ay isang interface ng uri ng SAM at kaya maaari itong ipatupad sa expression ng lambda.

• Ang natatawag na klase ay may isang paraan lamang na 'tawagan ()' na nagtataglay ng lahat ng kinakailangang code upang maipatupad nang hindi magkakasabay.

• Sa isang runnable interface na interface, walang posibilidad na ibalik ang resulta ng pagkalkula o itapon ang may tsek na pagbubukod. Samantalang sa Callable na nagbabalik ng isang halaga at nagtatapon ng isang may check na pagbubukod ay magagamit.

• Ang pamamaraan ng Get () ng klase sa Hinaharap ay maaaring magamit upang makuha ang mga resulta kapag tapos na ang pagkalkula. Maaari ring suriin ng mga gumagamit kung ang pagtutuos ay natapos o hindi sa pamamagitan ng paggamit ng tapos na () na pamamaraan.

• Ang pagkansela sa pagkalkula sa pamamagitan ng paggamit ng future.cancel () na pamamaraan ay isang boon din sa ilang mga application.

• Ang Get () ay tinatawag na isang tawag sa pag-block at patuloy itong hahadlangan hanggang sa makumpleto ang pagkalkula.

Paghahambing ng Mga Callable at Runnable Class

Nasa ibaba ang isang simpleng halimbawa ng isang natatawag na klase ng Java na ipinatupad kung saan ibinalik ng code ang pangalan ng tukoy na thread, na nagpapatupad ng gawain pagkatapos ng isang segundo. Ginagamit namin dito ang balangkas ng taga-bunot upang maipatupad ang 100 mga gawain na kahanay ng Java Future sa resulta ng mga naisumite na gawain. Ang unang snippet ay ang output at ang ibaba ay kumakatawan sa code.

package com.journaldev.threads import java.util.ArrayList import java.util.Date import java.util.List import java.util.concurrent.Callable import java.util.concurrent.ExcementException import java.util.concurrent.ExecutorService import java .util.concurrent.Executors import java.util.concurrent.Future public class na MyCallable nagpapatupad ng Callable {@Override public String call () na nagtatapon ng Exception {Thread.s Sleep (1000) // ibalik ang pangalan ng thread na isinasagawa ang tinatawag na task return Thread.currentThread () .getName ()} public static void main (String args []) {// Get ExecutorService from Executors utility class, thread pool size is 10 ExecutorService executor = Executors.newFixedThreadPool (10) // create a list to hold the Future bagay na nauugnay sa Tawag na Listahanlistahan = bagong ArrayList() // Lumikha ng MyCallable instance Callable callable = bagong MyCallable () para sa (int i = 0 i<100 i++){ //submit Callable tasks to be executed by thread pool Future future = executor.submit(callable) //add Future to the list, we can get return value using Future list.add(future) } for(Future fut : list){ try { //print the return value of Future, notice the output delay in console // because Future.get() waits for task to get completed System.out.println(new Date()+ '::'+fut.get()) } catch (InterruptedException | ExecutionException e) { e.printStackTrace() } } //shut down the executor service now executor.shutdown() } } 

Patayin ang Mga Serbisyo ng Tagapagpatupad

Ang mahalaga at mahalagang aspeto na miss ng maraming mga developer ay ang pag-shut down sa ExecutorService. Mahalaga ang ExecutorService at nilikha ng mga karagdagang elemento ng thread. Tandaan na ang JVM ay hihinto lamang kapag ang lahat ng mga di-daemon na thread ay tumigil. Kaya't ang pagsasara lamang sa serbisyo ng tagapagpatupad ay pumipigil sa JVM na huminto.

Upang masabi sa serbisyo ng tagapagpatupad na hindi kailangan para patakbuhin ang mga thread, dapat nating isara ang serbisyo.

Mayroong tatlong paraan upang mag-shutdown:

• walang bisa shutdown () - Nagsisimula ito ng maayos na pag-shutdown kung saan naisagawa ang mga naunang naisumite na gawain, ngunit walang mga bagong gawain ang tatanggapin.
• Listahan ng shutdownNow () - Sinusubukan nitong ihinto ang lahat ng aktibong pagpapatupad ng mga gawain, ihihinto ang pagproseso ng mga nakabinbing gawain, at ibabalik din ang isang listahan ng mga gawain na naghihintay sa pagpapatupad.
• walang bisa ang paghihintayTermination () - Patuloy itong hinaharangan hanggang sa matapos ang lahat ng mga gawain sa pagpapatupad pagkatapos ng isang kahilingan sa pag-shutdown, o maganap ang pag-timeout. Hinaharang din nito kapag nagambala ang kasalukuyang thread. Ang lahat ay nakasalalay sa aling gawain ang mauna.

Sa pamamagitan nito, nakarating kami sa dulo ng Callable Interface sa artikulong Java. Inaasahan kong nakakuha ka ng pag-unawa sa Hinaharap at Callable Interface sa Java.

Suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Callable Interface in Java' at babalikan ka namin sa lalong madaling panahon.