Ang oras ang pinakan kritikal na kadahilanan sa buhay. Dahil sa kahalagahan nito, ang mundo ng programa ay nagbibigay ng iba't ibang mga trick at diskarte na makabuluhang makakatulong sa iyo na mabawasan ang pagkonsumo ng oras, sa gayon pagtaas ng pagganap. Ang isang ganoong diskarte ay ang Multithreading sa Python, na kung saan ay isa sa pinakamahalagang konsepto na sakop sa ilalim .
Narito ang isang mabilis na buod ng lahat ng mga majors na sakop sa artikulong ito:
Ano ang multitasking sa Python?
Ano ang isang thread?
Ano ang multithreading sa sawa?
Kailan gagamit ng multithreading sa Python?
Paano makamit ang Multithreading sa Python?
Paano lumikha ng mga thread sa Python?
- nang hindi lumilikha ng isang klase
- sa pamamagitan ng pagpapalawak ng klase ng thread
- nang walang pagpapahaba ng klase ng thread
Mga kalamangan sa paggamit ng multithreading sa Python
Upang magsimula, subukan muna nating unawain ang multitasking bago simulan ang pag-alam tungkol sa Multithreading sa Python.
Ano ang Multitasking sa Python?
Ang multitasking, sa pangkalahatan, ay ang kakayahang magsagawa ng maraming mga gawain nang sabay-sabay. Sa mga teknikal na termino, ang multitasking ay tumutukoy sa kakayahan ng isang operating system na magsagawa ng iba't ibang mga gawain nang sabay. Halimbawa , nagda-download ka ng isang bagay sa iyong PC pati na rin ang pakikinig sa mga kanta at kasabay na pag-play ng isang laro, atbp. Ang lahat ng mga gawaing ito ay ginaganap ng parehong OS isang naka-sync. Ito ay walang iba kundi ang multitasking na hindi lamang makakatulong sa iyong makatipid ng oras ngunit nagdaragdag din ng pagiging produktibo.
java convert ng doble sa int
Mayroong dalawang uri ng multitasking sa isang OS:
- Batay sa proseso
- Nakabatay sa thread
Sa artikulong ito, malalaman mo ang tungkol sa Nakabatay sa thread multitasking o Multithreading .
Ano ang isang thread?
Ang isang thread ay karaniwang an malaya daloy ng pagpapatupad. Ang isang solong proseso ay maaaring binubuo ng maraming mga thread. Ang bawat thread sa isang programa ay gumaganap ng isang partikular na gawain. Halimbawa, kapag naglalaro ka ng isang laro sabihin ang FIFA sa iyong PC, ang laro sa kabuuan ay isang solong proseso , ngunit binubuo ito ng maraming mga thread na responsable para sa pagtugtog ng musika, pagkuha ng input mula sa gumagamit, pagpapatakbo ng kalaban nang magkasabay, atbp. Ang lahat ng ito ay magkakahiwalay na mga thread na responsable para sa pagtupad ng iba't ibang mga gawain sa parehong programa.
Ang bawat proseso ay may isang thread na palaging tumatakbo. Ito ang pangunahing thread. Ang pangunahing thread na ito ay talagang lumilikha ng mga object ng bata na thread. Ang thread ng bata ay sinimulan din ng pangunahing thread. Ipapakita ko sa iyo ang lahat nang malayo sa artikulong ito kung paano suriin ang kasalukuyang tumatakbo na thread.
Kaya sa ito, inaasahan kong malinaw na naintindihan mo kung ano ang isang thread. Sa pagpapatuloy, tingnan natin kung ano ang Multithreading sa Python.
Kailan gagamit ng Multithreading sa Python?
Ang multithreading ay lubhang kapaki-pakinabang para sa pag-save ng oras at pagpapabuti ng pagganap, ngunit hindi ito mailalapat kahit saan.
Sa nakaraang halimbawa ng FIFA, ang thread ng musika ay independiyente sa thread na kumukuha ng iyong input at ang thread na kumukuha ng iyong input ay independiyente sa thread na nagpapatakbo sa iyong kalaban. Ang mga thread na ito ay tumatakbo nang nakapag-iisa dahil hindi sila nakasalalay sa pagitan.
Samakatuwid, ang multithreading ay maaaring magamit lamang kung ang dependency sa pagitan ng mga indibidwal na mga thread ay hindi umiiral.
Ipinapakita pa rin ng artikulong ito kung paano mo makakamtan ang Multithreading sa Python.
Paano makamit ang Multithreading sa Python?
Ang multithreading sa Python ay maaaring makamit sa pamamagitan ng pag-import ng sinulid modyul
Bago i-import ang modyul na ito, kakailanganin mong i-install ito nito. Upang mai-install ito sa iyong kapaligiran sa anaconda, isagawa ang sumusunod na utos sa iyong anaconda prompt:
pag-install ng conda -c conda-forge tbb
Matapos itong matagumpay na na-install, maaari mong gamitin ang alinman sa mga sumusunod na utos upang mai-import ang threading module:
i-import ang threading mula sa threading import *
Ngayon na mayroon kang naka-install na module ng pag-thread, hayaan nating magpatuloy at gawin ang Multithreading sa Python.
ano ang jit sa java
Paano lumikha ng mga thread sa Python?
Ang mga thread sa Python ay maaaring likhain sa tatlong paraan:
- Nang hindi lumilikha ng isang klase
- Sa pamamagitan ng pagpapalawak ng klase ng Thread
- Nang walang pagpapahaba ng klase ng Thread
Nang hindi lumilikha ng isang klase
Ang multithreading sa Python ay maaaring magawa nang hindi lumilikha rin ng isang klase. Narito ang isang halimbawa upang maipakita ang pareho:
Halimbawa:
mula sa pag-import ng threading * print (current_thread (). getName ()) def mt (): print ('Child Thread') bata = Thread (target = mt) child.start () print ('Executing thread name:', current_thread ( ) .getName ())Output:
MainThread Batang Thread Pagpapatupad ng pangalan ng thread: MainThreadIpinapakita ng output sa itaas na ang unang thread na naroroon ay, ang pangunahing thread. Ang pangunahing thread na ito pagkatapos ay lumilikha ng isang thread ng bata na nagpapatupad ng pagpapaandar at pagkatapos ang pangwakas na pahayag na naka-print ay naisakatuparan muli ng pangunahing thread.
Ngayon ay magpatuloy tayo at tingnan kung paano gawin ang Multithreading sa sawa sa pamamagitan ng pagpapalawak ng klase ng Thread.
Sa pamamagitan ng pagpapalawak ng klase ng Thread:
Kapag ang isang klase ng bata ay nilikha sa pamamagitan ng pagpapalawak ng klase ng Thread, ang klase ng bata ay kumakatawan sa isang bagong thread na nagpapatupad ng ilang gawain. Kapag pinapalawak ang klase ng Thread, ang klase ng bata ay maaaring mag-override lamang ng dalawang pamamaraan ibig sabihin ang __init __ () na pamamaraan at ang run () na pamamaraan. Walang ibang paraan na maaaring ma-override maliban sa dalawang pamamaraang ito.
Narito ang isang halimbawa ng kung paano pahabain ang klase ng Thread upang lumikha ng isang thread:
Halimbawa:
import threading import time class mythread (threading.Thread): def run (sarili): para sa x sa saklaw (7): print ('Kumusta mula sa bata') a = mythread () a.start () a.join () print ('Paalam mula sa', kasalukuyang_thread (). GetName ()) Output:
Kumusta mula sa bata
Kumusta mula sa bata
Kumusta mula sa bata
Kumusta mula sa bata
Kumusta mula sa bata
Kumusta mula sa bata
Kumusta mula sa bata
Paalam mula sa MainThread
Ipinapakita ng halimbawa sa itaas na ang myclass sa klase ay nagmamana ng klase ng Thread at ang klase ng bata kung saan ang myclass ay overriding sa run na pamamaraan. Bilang default, ang unang parameter ng anumang pag-andar ng klase ay kailangang maging sarili na kung saan ay ang pointer sa kasalukuyang object. Ipinapakita ng output na ang thread ng bata ay nagpapatupad ng run () na pamamaraan at ang pangunahing thread ay naghihintay para sa pagpapatupad ng mga bata. Ito ay dahil sa function na sumali (), na hinihintay ang pangunahing thread para matapos ang bata.
Ang pamamaraang ito ng paglikha ng mga thread ay ang pinaka ginustong pamamaraan sapagkat ito ang karaniwang pamamaraan. Ngunit kung sakaling nais mong lumikha ng mga thread nang hindi nagmamana o nagpapalawak ng klase ng Thread, magagawa mo ito sa sumusunod na pamamaraan.
Nang walang Pagpapalawak ng klase ng Thread
Upang lumikha ng isang thread nang hindi pinalawak ang klase ng Thread, maaari mong gawin ang mga sumusunod:
Halimbawa:
mula sa pag-import ng thread * class ex: def myfunc (sarili): # Kinakailangan ang sarili bilang unang parameter sa isang class func para sa x sa saklaw (7): i-print ('Bata') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('tapos')Output:
Bata
Bata
Bata
Bata
Bata
Bata
Bata
tapos na
Mga kalamangan ng paggamit ng threading
Ang Multithreading ay may maraming mga pakinabang na ang ilan sa mga ito ay ang mga sumusunod:
mga uri ng filter sa tableau
- Mas mahusay na paggamit ng mga mapagkukunan
- Pinapasimple ang code
- Pinapayagan ang kasabay at parallel na paglitaw ng iba't ibang mga gawain
- Binabawasan ang oras ng pagkonsumo o oras ng pagtugon, sa gayon, pagtaas ng pagganap.
Narito ang isang halimbawa upang suriin kung gaano katagal bago magawa ang isang code na may at walang multithreading sa sawa:
Halimbawa: pag-import ng oras def sqr (n): para sa x sa n: oras. pagtulog (1) x% 2 def cube (n): para sa x sa n: oras. pagtulog (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cube (n) e = time.time () print (es)
Output:
16.042309284210205
Sa itaas ay ang oras ng output na kinuha upang maisagawa ang programa nang hindi gumagamit ng mga thread. Gumamit tayo ngayon ng mga thread at tingnan kung ano ang nangyayari sa parehong programa:
Halimbawa:
pag-import ng pag-thread mula sa pag-import ng pag-import * pag-import ng oras def sqr (n): para sa x in n: time. sleep (1) print ('Remainder pagkatapos na hatiin ng 2', x% 2) def cube (n): para sa x in n: oras. tulog (1) i-print ('Natitirang pagkatapos ng paghahati sa 3', x% 3) n = [1,2,3,4,5,6,7,8] pagsisimula = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (target = cube, args = (n,)) t1.start () time.s Sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start) Output: 9.040220737457275 Ang output sa itaas ay malinaw na ipinapakita na ang oras na ginugol kapag gumagamit kami ng mga thread ay mas mababa kumpara sa oras na ginugol para sa parehong programa upang maipatupad nang hindi gumagamit ng mga thread.
Inaasahan kong malinaw ka sa mga konsepto na sakop sa ilalim ng artikulong ito na nauugnay sa Multithreading sa Python. Tiyaking magsanay hangga't maaari hangga't ito ay isa sa pinakamahalagang konsepto na ginamit sa pagprograma.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Multithreading in Python' at kami ay bumalik sa iyo sa lalong madaling panahon.
Upang makakuha ng malalim na kaalaman sa Python kasama ang iba't ibang mga application nito, maaari kang magpatala nang live na may 24/7 na suporta at habambuhay na pag-access.