Ang pinakamahalagang elemento ng istraktura ng data ay ang pila. Ang 'first in, first out' na queue ng data structure na siyang batayan para sa Python multiprocessing ay maihahambing. Ibinibigay ang mga queue sa function ng proseso upang payagan ang proseso na mangolekta ng data. Ang unang item ng data na aalisin mula sa queue ay ang unang item na ilalagay. Ginagamit namin ang paraan ng 'put()' ng queue para idagdag ang data sa queue at ang method na 'get()' nito para makuha ang data mula sa queue.
Halimbawa 1: Paggamit ng Queue() Method para Gumawa ng Multiprocessing Queue sa Python
Sa halimbawang ito, gumawa kami ng multiprocessing queue sa Python gamit ang 'queue()' na paraan. Ang multiprocessing ay tumutukoy sa paggamit ng isa o higit pang mga CPU sa isang system upang magsagawa ng dalawa o higit pang mga proseso nang sabay-sabay. Ang multiprocessing, isang itinayong module sa Python, ay nagpapadali sa paglipat sa pagitan ng mga proseso. Dapat tayong maging pamilyar sa property ng proseso bago magtrabaho sa multiprocessing. Alam namin na ang queue ay isang mahalagang bahagi ng modelo ng data. Ang karaniwang queue ng data, na binuo sa ideyang 'First-In-First-Out', at ang Python multiprocessing ay eksaktong katapat. Sa pangkalahatan, iniimbak ng queue ang Python object at mahalaga ito para sa paglipat ng data sa pagitan ng mga gawain.
Ginagamit ang tool na 'spyder' para ipatupad ang Python script na kasalukuyan, kaya magsimula na lang tayo. Kailangan muna nating i-import ang multiprocessing module dahil pinapatakbo natin ang Python multiprocessing script. Ginawa namin ito sa pamamagitan ng pag-import ng multiprocessing module bilang 'm'. Gamit ang 'm.queue()' technique, ginagamit namin ang multiprocessing na 'queue()' na paraan. Dito, lumikha kami ng variable na tinatawag na 'queue' at inilalagay ang multiprocessing na 'queue()' na paraan dito. Tulad ng alam namin na ang queue ay nag-iimbak ng mga item sa isang 'first-in, first-out' order, ang item na una naming idinagdag ay inalis muna. Pagkatapos ilunsad ang multiprocessing queue, pagkatapos ay tinatawag namin ang 'print()' na paraan, na ipinapasa ang pahayag na 'May multiprocessing queue' bilang argument nito upang ipakita ito sa screen. Pagkatapos, dahil iniimbak namin ang nabuong queue sa variable na ito, ini-print namin ang queue sa pamamagitan ng pagpasa sa variable na 'queue' sa panaklong ng 'print()' na paraan.
Ang sumusunod na larawan ay nagpapakita na ang Python multiprocessing queue ay itinayo na ngayon. Unang ipinapakita ang print statement. Matapos mabuo ang multiprocessing queue na ito sa itinalagang memory address, maaari itong magamit upang ilipat ang natatanging data sa pagitan ng dalawa o higit pang tumatakbong proseso.
Halimbawa 2: Paggamit ng “Qsize()” na Paraan upang Matukoy ang Sukat ng Multiprocessing Queue sa Python
Tinutukoy namin ang laki ng multiprocessing queue sa kasong ito. Upang kalkulahin ang laki ng multiprocessing queue, ginagamit namin ang 'qsize()' na paraan. Ang function na 'qsize()' ay nagbabalik ng tunay na laki ng Python multiprocessing queue. Sa madaling salita, ang paraang ito ay nagbibigay ng kabuuang bilang ng mga item sa isang queue.
Magsimula tayo sa pamamagitan ng pag-import ng Python multiprocessing module bilang 'm' bago patakbuhin ang code. Pagkatapos, gamit ang command na 'm.queue()', pinapagana namin ang multiprocessing na 'queue()' function at inilalagay ang resulta sa variable na 'Queue'. Pagkatapos, gamit ang 'put()' na paraan, idinaragdag namin ang mga item sa queue sa sumusunod na linya. Ang pamamaraang ito ay ginagamit upang magdagdag ng data sa isang pila. Samakatuwid, tinatawag namin ang 'Queue' gamit ang 'put()' na paraan at ibigay ang mga integer na numero bilang elemento nito sa panaklong nito. Ang mga numerong idinaragdag namin ay '1', '2', '3', '4', '5', '6,' at '7' gamit ang mga function na 'put()'.
Higit pa rito, gamit ang 'Queue' upang makuha ang laki ng multiprocessing queue, tinatawag namin ang 'qsize()' kasama ang multiprocessing queue. Pagkatapos, sa bagong nabuong variable na 'resulta,' ise-save namin ang kinalabasan ng pamamaraang 'qsize().' Pagkatapos nito, tinatawag namin ang 'print()' na paraan at ipinapasa ang pahayag na 'Ang laki ng multiprocessing queue ay' bilang parameter nito. Susunod, tinatawag namin ang variable na 'resulta' sa function na 'print()' dahil naka-save ang laki sa variable na ito.
Ang output na imahe ay may ipinapakitang laki. Habang ginagamit namin ang function na 'put()' upang magdagdag ng pitong elemento sa multiprocessing queue at ang function na 'qsize()' upang matukoy ang laki, ipinapakita ang laki ng multiprocessing queue na '7'. Ang input statement “ang laki ng multiprocessing queue” ay ipinapakita bago ang laki.
Halimbawa 3: Gamit ang Paraang 'Put()' at 'Get()' sa Python Multiprocessing Queue
Ang 'put()' at 'get()' queue method mula sa Python multiprocessing queue ay ginagamit sa halimbawang ito. Bumuo kami ng dalawang function na tinukoy ng user sa halimbawang ito. Sa halimbawang ito, tinukoy namin ang isang function upang lumikha ng isang proseso na gumagawa ng '5' na mga random na integer. Ginagamit din namin ang 'put()' na paraan upang idagdag ang mga ito sa isang queue. Ang 'put()' na paraan ay ginagamit upang ilagay ang mga item sa queue. Pagkatapos, upang makuha ang mga numero mula sa pila at ibalik ang kanilang mga halaga, sumulat kami ng isa pang function at tinawag ito sa panahon ng pamamaraan. Ginagamit namin ang function na “get()” para kunin ang mga numero mula sa queue dahil ginagamit ang paraang ito para kunin ang data mula sa queue na ipinapasok namin gamit ang method na “put()”.
Simulan natin ang pagpapatupad ng code ngayon. Una, ini-import namin ang apat na aklatan na bumubuo sa script na ito. Nag-import muna kami ng 'sleep' mula sa time module upang maantala ang execution sa loob ng ilang oras na sinusukat sa ilang segundo, na sinusundan ng 'random' mula sa random na module na ginagamit upang bumuo ng mga random na numero, pagkatapos ay 'process' mula sa multiprocessing dahil ang code na ito ay lumilikha ng isang proseso , at panghuli, ang 'pila' mula sa multiprocessing. Sa paunang paggawa ng isang halimbawa ng klase, maaaring gamitin ang pila. Bilang default, nagtatatag ito ng walang katapusang queue o isang queue na walang maximum na laki. Sa pamamagitan ng pagtatakda ng max size na opsyon sa isang numero na mas malaki sa zero, posibleng gumawa ng paglikha na may paghihigpit sa laki.
Tinutukoy namin ang isang function. Pagkatapos, dahil ang function na ito ay tinukoy ng gumagamit, binibigyan namin ito ng pangalang 'function1' at ipinapasa ang terminong 'queue' bilang argumento nito. Kasunod nito, ginagamit namin ang function na 'print()', na ipinapasa dito ang mga 'builder: Running', 'flush', at ang object na 'True' na mga pahayag . Ang print function ng Python ay may natatanging opsyon na tinatawag na flush na nagbibigay-daan sa user na pumili kung i-buffer ang output na ito o hindi. Ang susunod na hakbang ay ang pagbuo ng gawain. Upang gawin ito, ginagamit namin ang 'para sa' at ginagawa ang variable na 'm' at itinakda ang hanay sa '5'. Pagkatapos, sa susunod na linya, gamitin ang “random()” at i-store ang resulta sa variable na ginawa namin na “value.” Ipinapahiwatig nito na ang function ay tinatapos na ngayon ang limang pag-ulit nito, na ang bawat pag-ulit ay lumilikha ng random na integer mula 0 hanggang 5.
Pagkatapos, sa susunod na hakbang, tinatawagan namin ang function na 'sleep()' at ipasa ang argumentong 'value' upang maantala ang bahagi para sa isang tiyak na bilang ng mga segundo. Pagkatapos, tinatawagan namin ang 'queue' gamit ang 'put()' na paraan para mahalagang idagdag ang value sa queue. Pagkatapos ay ipaalam sa user na wala nang karagdagang gawain na dapat gawin sa pamamagitan ng paggamit ng 'queue.put()' na pamamaraan nang isang beses at pagpasa ng 'Wala' na halaga. Pagkatapos, pinapatakbo namin ang 'print()' na paraan, ipasa ang 'tagabuo: handa' na pahayag kasama ang 'flush' at itakda ito sa 'True'.
Tinutukoy namin ngayon ang pangalawang function, 'function2', at itinalaga ang keyword na 'queue' bilang argument nito dito. Pagkatapos, tinatawag namin ang function na “print()” habang ipinapasa ang ulat na nagsasabing “User: Running” at “flush” na nakatakda sa “True”. Sinisimulan namin ang pagpapatakbo ng 'function2' gamit ang while true condition para kunin ang data sa pila at ilagay ito sa bagong likhang variable na 'item'. Pagkatapos, ginagamit namin ang 'kung' kundisyon, 'item ay Wala', upang matakpan ang loop kung ang kundisyon ay totoo. Kung walang available na item, hihinto ito at humihingi ng isa sa user. Ang gawain ay huminto sa loop at magtatapos sa kasong ito kung ang item na nakuha mula sa halaga ay null. Pagkatapos, sa susunod na hakbang, tinatawagan namin ang function na 'print()' at ibigay ang ulat na 'User: ready' at 'flush=True' na mga parameter dito.
Pagkatapos, ipinasok namin ang pangunahing proseso gamit ang 'If-name = main_'. Gumagawa kami ng queue sa pamamagitan ng pagtawag sa 'queue()' na paraan at pag-iimbak nito sa variable na 'queue.' Susunod, lumikha kami ng isang proseso sa pamamagitan ng pagtawag sa function ng user na 'function2'. Para dito, tinatawag namin ang klase ng 'proseso'. Sa loob nito, ipinapasa namin ang 'target=function2' upang tawagan ang function sa proseso, ipasa ang argumentong 'queue', at iimbak ito sa variable na 'User_process'. Magsisimula ang proseso sa pamamagitan ng pagtawag sa 'start()' na paraan na may variable na 'User_ process.' Pagkatapos ay ulitin namin ang parehong pamamaraan upang tawagan ang 'function1' sa proseso at ilagay ito sa variable na 'proseso ng builder'. Pagkatapos, tinatawagan namin ang mga proseso gamit ang paraan na “join()” para hintayin ang execution.
Ngayong ipinakita na ito, makikita mo ang mga pahayag ng parehong function sa output. Ipinapakita nito ang mga item na idinagdag namin gamit ang 'put()' at 'get()' sa pamamagitan ng paggamit ng mga pamamaraang 'get()', ayon sa pagkakabanggit.
Konklusyon
Nalaman namin ang tungkol sa Python multiprocessing queue sa artikulong ito. Ginamit namin ang ibinigay na mga larawan. Noong una, inilarawan namin kung paano gumawa ng queue sa Python multiprocessing gamit ang queue() function. Pagkatapos, ginamit namin ang 'qsize()' paraan para matukoy ang queue ng . Ginamit din namin ang mga pamamaraang put() at get() ng queue. Ang klase ng pagtulog ng time module at ang random na klase ng random na module ay parehong tinalakay sa huling halimbawa.