Ano ang BlockingQueue sa Java at kung paano ito ipapatupad?

Ang artikulong ito sa BlockingQueue sa Java ay makakatulong sa iyo upang malaman ang tungkol sa interface ng BlockingQueue. Bibigyan ka din nito ng mga pananaw sa mga pamamaraan nito at pagpapatupad ng pratical

ay napakapopular sa mga programmer dahil sa komprehensibong hanay ng mga built-in na tampok. Karamihan sa mga oras na nagkakaroon ka ng isang nakatuon na solusyon para sa iyong problema kahit na bago ito lumitaw. Ang nasabing isang lubos na kapaki-pakinabang at mahalagang bahagi ng ay ang interface ng BlockingQueue sa Java. Sa pamamagitan ng daluyan ng artikulong ito, magtatapon ako ng ilang ilaw sa BlockingQueue sa Java at ang mga pamamaraan upang maipatupad ito.

Nasa ibaba ang mga paksang sakop sa artikulong ito:





BlockingQueue Interface sa Java

BlockingQueue sa Java ay isang interface na naidagdag sa Java 1.5 kasama ang ilang iba pang mga magkakasabay na klase ng Utility tulad ng ConcurrentHashMap, CopyOnWriteArrrayList, atbp. Ang interface ng BlockingQueue ay kabilang sa java.util.kasalukuyan pakete .Pinagbubuti ng interface na ito ang kontrol sa daloy sa pamamagitan ng pag-aktibo ng pag-block, kung sakaling ang isang thread ay sumusubok na mag-dequeue ng isang walang laman na pila o magpalakas ng isang buong pila. Sa alinmang kaso, madaling gamitin ang interface na ito.Sa mas simpleng mga termino, ipagpalagay na a Sinusubukang magdagdag ng mga elemento sa isang buong pila na. Sa puntong ito ng programa, ang BlockingQueue ay tatawagin na hahadlang sa partikular na thread hanggang sa ilabas ng isa pang thread ang pila upang gumawa ng puwang. Maaari itong maging isang resulta ng alinman sa pag-dequeuing ng isang (mga) elemento ng clearance ng buong pila. Katulad nito, ang BlockingQueue ay tatawagin upang harangan ang isang thread na sinusubukang mag-dequeue ng isang walang laman na pila hanggang sa ilang mga ibang pagsingit ng thread o magdagdag ng isang elemento sa walang laman pila .

Habang nagtatrabaho kasama ang interface ng BlockingQueue sa Java, dapat mong tandaan na hindi ito tumatanggap ng isang null na halaga. Kung sakaling subukan mong gawin iyon ay agad na magtapon ng isang NullPointerException. Ang figure sa ibaba ay kumakatawan sa pagtatrabaho ng interface ng BlockingQueue sa Java.



BlockingQueue - BlockingQueue sa Java - EdurekaIto interface pangunahin na ginagamit sa pagitan ng Mga Producer-Consumer dahil ito ay Thread-Safe.Ang ibig kong sabihin ay ang interface ng BlockingQueue ay maaaring magamit upang lumikha ng isang pila na maaaring ibahagi ng parehong tagagawa at consumer

Upang makapagtrabaho sa BlockingQueue sa Java, una, kailangan mong pamilyar sa mga uri nito. Hayaan mong ipakilala kita sa kanila sa susunod na seksyon ng artikulong ito.

Mga uri ng Tagabuo para sa BlockingQueue sa Java

Mayroong dalawang uri ng mga tagapagbuo para sa interface ng BlockingQueue sa Java:



  • Walang limitasyong pila: Para sa ganitong uri ng pila, maitatakda ang kapasidad sa Integer.MAX_VALUE. Ang isang walang limitasyong pila ay hindi kailanman mai-block dahil maaari itong lumago nang pabagu-bago, sa tuwing may isang elemento na naipasok dito. Nasa ibaba ang syntax upang lumikha ng isang walang limitasyong pila:
BlockingQueue bq = bagong LinkedBlockingDeque ()
  • May limitadong pila: Para sa ganitong uri ng pila, kailangan mong ipasa ang kapasidad ng pila sa oras ng paglikha nito ie bilang isang tagabuo parameter Kapag naitalaga ang laki, hindi ito mababago. Nasa ibaba ang syntax upang lumikha ng isang may hangganan na pila:
BlockingQueue bq = bagong LinkedBlockingDeque (10)

Ngayon na pamilyar ka sa mga paraan upang ipatupad ang BlockingQueue sa Java, hayaan mo akong ilista ang ilan sa mga pamamaraan nito.

pagdedeklara ng isang hanay ng mga bagay sa java

Mga pamamaraan sa BlockingQueue Interface

Pamamaraan Paglalarawan
boolean add (E e) Tumutulong ang pamamaraang ito sa pagpasok ng tinukoy na elemento sa pila na ito kung may puwang sa pila pamagtapon ng isangIllegalStateException
naglalaman ang boolean (Bagay o) Ang pamamaraang ito ay bumalik nang totoo kung naglalaman ang pila ng tinukoy na elemento
int drainTo (Koleksyon c) Aalisin ng pamamaraang ito ang lahat ng mga magagamit na elemento mula sa pila at idagdag ang mga ito sa tinukoy na koleksyon
int drainTo (Koleksyon c, int maxElemen) Aalisin ang pamamaraang ito sa ibinigay na bilang ng mga magagamit na elemento mula sa pila at idagdag ang mga ito sa tinukoy
alok ng booloean (E e) Ipapasok ng pamamaraang ito ang tinukoy na elemento sa pila kung hindi ito buo at babalik totoo, kung hindi man ay babalik itong hindi totoo
alok ng boolean (E e, mahabang oras ng pag-timeout, yunit ng TimeUnit) Ipapasok ng pamamaraang ito ang tinukoy na elemento sa pila. Kung sakaling puno ang pila, maghihintay ito hanggang sa tinukoy na oras ng paghihintay para sa puwang na magagamit.
E poll (mahabang oras ng pag-timeout, yunit ng TimeUnit) Ang pamamaraang ito ay tumutulong sa pagkuha at pag-alis ng ulo ng pila. Kung sakaling walang laman ang pila, maghihintay ito hanggang sa tinukoy na oras ng paghihintay para sa isang sangkap na magagamit
void put (E e) Ipapasok ng pamamaraang ito ang tinukoy na elemento sa pila sa pamamagitan ng paghihintay para sa puwang na magagamit kung sakaling puno ang pila
int natitirang Kapasidad () Nakakatulong ang pamamaraang ito sa pagbabalik ng bilang ng mga karagdagang elemento na maaaring makatanggap ng perpektong linya ng pila nang hindi na-block
alisin ang boolean (Bagay o) Aalisin ng pamamaraang ito ang isang solong halimbawa ng tinukoy na elemento mula sa pila lamang kung mayroon ito
E kumuha () Ang pamamaraang ito ay makakatulong sa pagkuha at pag-alis ng ulo ng pila sa pamamagitan ng paghihintay para sa isang sangkap na magagamit, kung sakaling walang laman ang pila.

Pagpapatupad ng BlockingQueue

Dito ay ipapatupad ko ang isang simpleng halimbawa ng BlockingQueue sa Java kung saanklase EduProducer ay bumubuo ng data at ipasok ito sa a pila , sabay-sabay, isa pang klase, aalisin ng EduConsumer ang data mula sa parehong pila.

Para dito lilikha ako ng 3 klase na:

  1. EduProducer
  2. EduConsumer
  3. EdurekaMain

Isa-isa nating likhain ang bawat isa sa mga klase.

EduProducer.java

package edureka import java.util.concurrent.BlockingQueue public class EduProducer nagpapatupad ng Runnable {pribadong final BlockingQueue pila @Override public void run () {try {process ()} catch (InterruptException e) {Thread.currentThread (). makagambala ()} } pribadong proseso ng walang bisa () nagtatapon ng InterruptException {// Ilagay ang 10 ints sa Queue para sa (int i = 0 i<10 i++) { System.out.println('[Producer] Add : ' + i) queue.put(i) System.out.println('[Producer] Queue's Remaining Capacity : ' + queue.remainingCapacity()) Thread.sleep(150) } } public EduProducer(BlockingQueue queue) { this.queue = queue } }

EduConsumer.java

package edureka import java.util.concurrent.BlockingQueue public class EduConsumer nagpapatupad ng Runnable {pribadong huling BlockingQueue pila @Override public void run () {try {habang (totoo) {Integer take = queue.take () proseso (take)}} catch (InterruptException e) {Thread.currentThread (). Makagambala ()}} pribadong proseso ng walang bisa (pagkuha ng Integer) ay nagtatapon ng InterruptException {System.out.println ('[Consumer] Alisin:' + take) Thread.sulog (500)} pampubliko EduConsumer (pila ng BlockingQueue) {this.queue = pila}}

EdurekaMain.java

c ++ recursive fibonacci
package edureka import java.util.concurrent.BlockingQueue import java.util.concurrent.LinkedBlockingQueue public class EdurekaMain {public static void main (String [] args) {BlockingQueue pila = bagong LinkedBlockingQueue (10) bagong Thread (bagong EduProducer (pila)) .start () bagong Thread (bagong EduConsumer (pila)). start ()}}

Kapag natapos mo na ang pagsulat ng code, ipatupad ang programa upang makuha ang output sa ibaba:

[Producer] Idagdag: 0 [Consumer] Dalhin: 0 [Producer] Nananatili na Kapasidad ng Queue: 9 [Producer] Idagdag: 1 [Producer] Natitirang Kapasidad ng Queue: 9 [Producer] Idagdag: 2 [Natitirang Kapasidad ng Queue: 8 [Producer ] Idagdag: 3 [Natitirang Kapasidad ng Queue: 7 [Consumer] Dalhin: 1 [Producer] Idagdag: 4 [Producer] Nananatili na Kapasidad ng Queue: 7 [Producer] Idagdag: 5 [Natapos ang Kapasidad ng Queue: 6 [Producer] Idagdag : 6 [Natitirang Kapasidad ng Queue: 5 [Consumer] Dalhin: 2 [Producer] Idagdag: 7 [Producer] Queue's Capacity: 5 [Producer] Add: 8 [Producer] Queue's Queue Capacity: 4 [Producer] Add: 9 [Producer] Natitirang Kapasidad ng Queue: 3 [Consumer] Dalhin: 3 [Consumer] Take: 4 [Consumer] Take: 5 [Consumer] Take: 6 [Consumer] Take: 7 [Consumer] Take: 8 [Consumer] Take: 9

Dinadala tayo nito sa pagtatapos ng artikulong ito sa BlockingQueue sa Java. Kung nais mong malaman ang Java nang mas detalyado maaari kang mag-refer sa aming din.

Ngayon na naintindihan mo ang mga pangunahing kaalaman sa BlockingQueue sa Java, tingnan 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 Java J2EE at SOA ng Edureka at SOA ay 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 Java Programming at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

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