Ang multiprocessing ay maihahambing sa multithreading. Gayunpaman, ito ay naiiba sa na maaari lamang tayong magsagawa ng isang thread sa isang sandali dahil sa GIL na ginagamit para sa threading. Ang multiprocessing ay ang proseso ng pagsasagawa ng mga operasyon nang sunud-sunod sa ilang CPU core. Ang mga thread ay hindi maaaring gamitin nang magkatulad. Gayunpaman, binibigyang-daan kami ng multiprocessing na itatag ang mga proseso at patakbuhin ang mga ito nang sabay-sabay sa iba't ibang CPU core. Ang loop, gaya ng for-loop, ay isa sa pinakamadalas na ginagamit na mga scripting language. Ulitin ang parehong gawain gamit ang iba't ibang data hanggang sa maabot ang isang pamantayan, tulad ng isang paunang natukoy na bilang ng mga pag-ulit. Naisasagawa ng loop ang bawat pag-ulit nang paisa-isa.
Halimbawa 1: Paggamit ng For-Loop sa Python Multiprocessing Module
Sa halimbawang ito, ginagamit namin ang for-loop at ang Python multiprocessing module class na proseso. Nagsisimula kami sa isang napakasimpleng halimbawa upang mabilis mong maunawaan kung paano gumagana ang Python multiprocessing for-loop. Gamit ang isang interface na maihahambing sa threading module, ang multiprocessing pack ang paglikha ng mga proseso.
Sa pamamagitan ng paggamit ng mga sub-process sa halip na mga thread, ang multiprocessing package ay nagbibigay ng parehong lokal at malayong concurrency, kaya iniiwasan ang Global Interpreter Lock. Gumamit ng for-loop, na maaaring maging string object o tuple, para patuloy na umulit sa isang sequence. Ito ay gumaganap nang mas kaunti tulad ng keyword na nakikita sa iba pang mga programming language at mas katulad ng isang iterator method na makikita sa iba pang mga programming language. Sa pamamagitan ng pagsisimula ng isang bagong multiprocessing, maaari kang magpatakbo ng isang for-loop na nagsasagawa ng isang pamamaraan nang sabay-sabay.
Magsimula tayo sa pamamagitan ng pagpapatupad ng code para sa pagpapatupad ng code sa pamamagitan ng paggamit ng tool na 'spyder'. Naniniwala kami na ang 'spyder' ay ang pinakamahusay din para sa pagpapatakbo ng Python. Nag-import kami ng proseso ng multiprocessing module na pinapatakbo ng code. Ang multiprocessing sa konsepto ng Python na tinatawag na 'klase ng proseso' ay lumilikha ng isang bagong proseso ng Python, binibigyan ito ng paraan upang maisagawa ang code, at binibigyan ang parent application ng paraan upang pamahalaan ang pagpapatupad. Ang klase ng Proseso ay naglalaman ng start() at join() na mga pamamaraan, na parehong mahalaga.
Susunod, tinukoy namin ang isang function na tinukoy ng gumagamit na tinatawag na 'func'. Dahil ito ay isang function na tinukoy ng gumagamit, binibigyan namin ito ng pangalan na aming napili. Sa loob ng katawan ng function na ito, ipinapasa namin ang variable na 'paksa' bilang isang argumento at ang halaga ng 'matematika'. Susunod, tinatawag namin ang function na 'print()', na ipinapasa ang pahayag na 'Ang pangalan ng karaniwang paksa ay' pati na rin ang argumento na 'paksa' na naglalaman ng halaga. Pagkatapos, sa susunod na hakbang, ginagamit namin ang 'if name == _main_,' na pumipigil sa iyong patakbuhin ang code kapag ang file ay na-import bilang isang module at pinahihintulutan ka lamang na gawin ito kapag ang nilalaman ay naisakatuparan bilang isang script.
Ang seksyon ng kundisyon na sinimulan mo ay maaaring isipin sa karamihan ng mga pangyayari bilang isang lokasyon upang magbigay ng nilalaman na dapat lamang isagawa kapag ang iyong file ay tumatakbo bilang isang script. Pagkatapos, ginagamit namin ang paksa ng argumento at nag-iimbak ng ilang mga halaga dito na 'agham', 'Ingles', at 'computer'. Ang proseso ay binibigyan ng pangalang 'process1[]' sa susunod na hakbang. Pagkatapos, ginagamit namin ang 'proseso(target=func)' upang tawagan ang function sa proseso. Ginagamit ang target para tawagan ang function, at ise-save namin ang prosesong ito sa variable na “P”.
Susunod, ginagamit namin ang 'process1' upang tawagan ang function na 'append()' na nagdaragdag ng isang item sa dulo ng listahan na mayroon kami sa function na 'func.' Dahil ang proseso ay naka-imbak sa variable na 'P', ipinapasa namin ang 'P' sa function na ito bilang argumento nito. Sa wakas, ginagamit namin ang function na 'start()' na may 'P' para simulan ang proseso. Pagkatapos nito, pinapatakbo namin muli ang pamamaraan habang nagbibigay ng argumentong 'paksa' at ginagamit ang 'para sa' sa paksa. Pagkatapos, gamit ang 'process1' at ang 'add()' na paraan muli, sinisimulan namin ang proseso. Ang proseso pagkatapos ay tumatakbo at ang output ay ibinalik. Pagkatapos ay sinabihan ang pamamaraan na tapusin gamit ang 'join()' technique. Ang mga prosesong hindi tumatawag sa “join()” na pamamaraan ay hindi lalabas. Ang isang mahalagang punto ay ang parameter ng keyword na 'args' ay dapat gamitin kung gusto mong magbigay ng anumang mga argumento sa pamamagitan ng proseso.
Ngayon, makikita mo sa output na ang pahayag ay unang ipinapakita sa pamamagitan ng pagpasa ng halaga para sa paksang 'matematika' na ipinapasa natin sa function na 'func' dahil tinawag muna natin ito gamit ang function na 'proseso'. Pagkatapos, ginagamit namin ang command na 'append()' upang magkaroon ng mga value na nasa listahan na na idinagdag sa dulo. Pagkatapos, ipinakita ang 'science', 'computer', at 'English'. Ngunit, tulad ng nakikita mo, ang mga halaga ay wala sa tamang pagkakasunud-sunod. Ito ay dahil ginagawa nila ito sa lalong madaling panahon matapos ang pamamaraan at iulat ang kanilang mensahe.
Halimbawa 2: Conversion ng Sequential For-Loop Sa Multiprocessing Parallel For-Loop
Sa halimbawang ito, ang multiprocessing loop na gawain ay isinasagawa nang sunud-sunod bago ma-convert sa isang parallel na for-loop na gawain. Maaari kang umikot sa mga sequence tulad ng koleksyon o string sa pagkakasunud-sunod ng mga ito gamit ang for-loops.
Ngayon, simulan nating ipatupad ang code. Una, ini-import namin ang 'sleep' mula sa time module. Gamit ang 'sleep()' procedure sa time module, maaari mong suspindihin ang pagsasagawa ng calling thread hangga't gusto mo. Pagkatapos, ginagamit namin ang 'random' mula sa random na module, tukuyin ang isang function na may pangalang 'func', at ipasa ang keyword na 'argu'. Pagkatapos, gumawa kami ng random na halaga gamit ang 'val' at itinakda ito sa 'random'. Pagkatapos, nag-block kami nang kaunting panahon gamit ang 'sleep()' na paraan at ipinapasa ang 'val' bilang parameter. Pagkatapos, upang magpadala ng mensahe, pinapatakbo namin ang 'print()' na paraan, na ipinapasa ang mga salitang 'handa' at ang keyword na 'arg' bilang parameter nito, pati na rin ang 'nilikha' at ipinapasa ang halaga gamit ang 'val'.
Sa wakas, ginagamit namin ang 'flush' at itakda ito sa 'True'. Maaaring magpasya ang user kung i-buffer o hindi ang output gamit ang flush na opsyon sa print function ng Python. Ang default na value ng parameter na ito na False ay nagpapahiwatig na ang output ay hindi mabu-buffer. Ang output ay ipinapakita bilang isang serye ng mga linya na sumusunod sa isa't isa kung itinakda mo ito sa true. Pagkatapos, ginagamit namin ang 'kung pangalan == pangunahing' upang ma-secure ang mga punto ng pagpasok. Susunod, isinasagawa namin ang trabaho nang sunud-sunod. Dito, itinakda namin ang hanay sa '10' na nangangahulugang nagtatapos ang loop pagkatapos ng 10 pag-ulit. Susunod, tinatawag namin ang function na 'print()', ipasa ito sa 'ready' input statement, at gamitin ang opsyon na 'flush=True'.
Makikita mo na ngayon na kapag ipinatupad namin ang code, ang loop ay nagiging sanhi ng pagpapatakbo ng function na '10' na beses. Ito ay umuulit nang 10 beses, simula sa index zero at nagtatapos sa index nine. Ang bawat mensahe ay naglalaman ng isang numero ng gawain na isang numero ng function na ipinapasa namin bilang isang 'arg' at isang numero ng paglikha.
Ang sequential loop na ito ay ginagawa na ngayong isang multiprocessing parallel for-loop. Ginagamit namin ang parehong code, ngunit pupunta kami sa ilang karagdagang mga aklatan at function para sa multiprocessing. Samakatuwid, dapat nating i-import ang proseso mula sa multiprocessing, tulad ng ipinaliwanag namin kanina. Susunod, gumawa kami ng function na tinatawag na 'func' at ipinapasa ang keyword na 'arg' bago gamitin ang 'val=random' upang makakuha ng random na numero.
Pagkatapos, pagkatapos gamitin ang 'print()' na paraan upang magpakita ng mensahe at bigyan ang 'val' na parameter upang maantala ng kaunting panahon, ginagamit namin ang function na 'if name= main' upang ma-secure ang mga entry point. Kung saan, lumikha kami ng isang proseso at tinawag ang function sa proseso gamit ang 'proseso' at ipasa ang 'target=func'. Pagkatapos, ipinapasa namin ang 'func', 'arg', ipinapasa ang value na 'm', at ipinapasa ang hanay na '10' na nangangahulugang tinatapos ng loop ang function pagkatapos ng '10' na mga pag-ulit. Pagkatapos, sisimulan natin ang proseso gamit ang 'start()' method na may 'process'. Pagkatapos, tinatawagan namin ang 'join()' na paraan upang maghintay para sa pagpapatupad ng proseso at upang makumpleto ang lahat ng proseso pagkatapos.
Samakatuwid, kapag ipinatupad namin ang code, ang mga function ay tumatawag sa pangunahing proseso at simulan ang kanilang pagpapatupad. Ang mga ito ay tapos na, gayunpaman, hanggang sa ang lahat ng mga gawain ay natapos. Nakikita natin iyon dahil sabay-sabay na isinasagawa ang bawat gawain. Iniuulat nito ang mensahe nito sa sandaling matapos ito. Nangangahulugan ito na bagama't wala sa ayos ang mga mensahe, matatapos ang loop pagkatapos makumpleto ang lahat ng '10' na pag-ulit.
Konklusyon
Sinaklaw namin ang Python multiprocessing for-loop sa artikulong ito. Nagpakita rin kami ng dalawang larawan. Ipinapakita ng unang ilustrasyon kung paano gumamit ng for-loop sa loop na multiprocessing library ng Python. At ipinapakita ng pangalawang paglalarawan kung paano baguhin ang isang sequential for-loop sa isang parallel multiprocessing for-loop. Bago bumuo ng script para sa Python multiprocessing, kailangan nating i-import ang multiprocessing module.