„Python“ programavimo kalba leidžia naudoti daugiaprocesinį arba daugialypį gijimą. Šioje pamokoje sužinosite, kaip „Python“ rašyti daugiagijas programas.
Kas yra gija?
Gija yra lygiagretaus programavimo egzekcijos vienetas. Daugialypis gijimas yra technika, leidžianti procesoriui vienu metu atlikti daugybę vieno proceso užduočių. Šias gijas galima vykdyti atskirai, kartu dalijantis savo proceso ištekliais.
Kas yra procesas?
Procesas iš esmės yra vykdoma programa. Paleidus programą kompiuteryje (pvz., Naršyklėje ar teksto rengyklėje), operacinė sistema sukuria procesą.
Kas yra „Multithreading“ sistemoje „Python“?
Daugialypis gijimas „Python“ programavime yra gerai žinoma technika, kai kelios proceso gijos dalijasi savo duomenų erdve su pagrindine gija, todėl informacija ir bendravimas gijose tampa lengvas ir efektyvus. Siūlai yra lengvesni nei procesai. Kelios gijos gali būti vykdomos atskirai, tuo pačiu dalijantis savo proceso ištekliais. Daugialypio sriegio tikslas yra paleisti kelias užduotis ir funkcines ląsteles vienu metu.
Kas yra daugiaprocesinis procesas?
Daugkartinis apdorojimas leidžia vienu metu vykdyti kelis nesusijusius procesus. Šie procesai nesidalija savo ištekliais ir bendrauja per IPC.
„Python“ daugialypis ryšys ir daugiaprocesinis procesas
Norėdami suprasti procesus ir gijas, apsvarstykite šį scenarijų: .exe failas jūsų kompiuteryje yra programa. Kai jį atidarote, OS jį įkelia į atmintį, o procesorius jį įvykdo. Dabar vykdomos programos egzempliorius vadinamas procesu.
Kiekvienas procesas turės 2 pagrindinius komponentus:
- Kodas
- Duomenys
Dabar procese gali būti viena ar kelios dalys, vadinamos gijomis. Tai priklauso nuo OS architektūros. Galite galvoti apie giją kaip proceso dalį, kurią operacinė sistema gali vykdyti atskirai.
Kitaip tariant, tai yra instrukcijų srautas, kurį OS gali vykdyti savarankiškai. Vieno proceso gijos dalijasi to proceso duomenimis ir yra skirtos veikti kartu palengvinant lygiagretumą.
Šioje pamokoje sužinosite,
- Kas yra gija?
- Kas yra procesas?
- Kas yra daugialypis sriegimas?
- Kas yra daugiaprocesinis procesas?
- „Python“ daugialypis ryšys ir daugiaprocesinis procesas
- Kodėl naudoti Multithreading?
- „Python MultiThreading“
- Siūlų ir siūlų moduliai
- Siūlų modulis
- Sriegimo modulis
- Aklavietės ir lenktynių sąlygos
- Sinchronizuojamos gijos
- Kas yra GIL?
- Kodėl reikėjo GIL?
Kodėl naudoti Multithreading?
Daugialypis gijimas leidžia suskirstyti programą į kelias paprogrames ir vykdyti šias užduotis vienu metu. Jei tinkamai naudojate daugialypį gijimą, jūsų programos greitis, našumas ir atvaizdavimas gali būti patobulinti.
„Python MultiThreading“
„Python“ palaiko tiek daugiaprocesinio, tiek daugialypio gijimo konstrukcijas. Šioje pamokoje pirmiausia sutelksite dėmesį į daugiasriegių programų diegimą su „Python“. Yra du pagrindiniai moduliai, kurie gali būti naudojami tvarkant gijas „Python“:
- Sriegis modulis, ir
- Sriegimo modulis
Tačiau „Python“ taip pat yra kažkas, kas vadinama visuotiniu vertėjų užraktu (GIL). Tai neleidžia gauti daug našumo ir netgi gali sumažinti kai kurių daugiagijinių programų našumą. Apie tai sužinosite būsimuose šios pamokos skyriuose.
Siūlų ir siūlų moduliai
Du moduliai, apie kuriuos sužinosite šioje pamokoje, yra sriegio modulis ir sriegimo modulis .
Tačiau gijų modulis jau seniai nebenaudojamas. Pradedant nuo „Python 3“, jis buvo pažymėtas kaip pasenęs ir prieinamas tik kaip __thread, kad būtų galima suderinti atgal.
Programoms, kurias ketinate diegti, turėtumėte naudoti aukštesnio lygio sriegimo modulį. Siūlų modulis čia buvo aprėpiamas tik švietimo tikslais.
Siūlų modulis
Sintaksė norint sukurti naują giją naudojant šį modulį yra tokia:
thread.start_new_thread(function_name, arguments)
Gerai, dabar jūs apžvelgėte pagrindinę teoriją pradėti koduoti. Taigi, atidarykite savo IDLE arba bloknotą ir įveskite:
import timeimport _threaddef thread_test(name, wait):i = 0while i <= 3:time.sleep(wait)print("Running %s\n" %name)i = i + 1print("%s has finished execution" %name)if __name__ == "__main__":_thread.start_new_thread(thread_test, ("First Thread", 1))_thread.start_new_thread(thread_test, ("Second Thread", 2))_thread.start_new_thread(thread_test, ("Third Thread", 3))
Išsaugokite failą ir paspauskite F5, kad paleistumėte programą. Jei viskas buvo padaryta teisingai, tai turėtumėte pamatyti išvestį:
Sužinosite daugiau apie varžybų sąlygas ir kaip jas tvarkyti artimiausiuose skyriuose
KODO PAAIŠKINIMAS
- Šie teiginiai importuoja laiko ir gijos modulį, naudojamą „Python“ gijų vykdymui ir atidėjimui tvarkyti.
- Čia jūs apibrėžėte funkciją, vadinamą thread_test, kuri bus iškviesta metodu start_new_thread . Funkcija vykdo tam tikrą ciklo ciklą keturiems pasikartojimams ir išspausdina ją iškvietusios gijos pavadinimą. Kai iteracija bus baigta, ji išspausdins pranešimą, kuriame sakoma, kad gija baigta vykdyti.
- Tai yra pagrindinis jūsų programos skyrius. Čia kaip argumentą tiesiog iškviečiate metodą start_new_thread su funkcija thread_test .
Tai sukurs naują giją funkcijai, kurią perduodate kaip argumentą, ir pradėsite ją vykdyti. Atminkite, kad galite pakeisti šią (gijos _ testą) bet kuria kita funkcija, kurią norite paleisti kaip giją.
Sriegimo modulis
Šis modulis yra aukšto lygio diegimas „Python“ diegime ir de facto daugialypių programų valdymo standartas. Tai suteikia daugybę funkcijų, palyginti su sriegio moduliu.
Štai keletas naudingų funkcijų, apibrėžtų šiame modulyje, sąrašas:
| Funkcijos pavadinimas | apibūdinimas |
| activeCount () | Pateikia vis dar gyvų objektų „ Thread “ skaičių |
| currentThread () | Grąžina dabartinį „Thread“ klasės objektą. |
| surašyti () | Išvardija visus aktyvius „Thread“ objektus. |
| isDaemon () | Grąžina tiesą, jei gija yra demonas. |
| gyvas() | Grąžina tiesą, jei gija dar gyva. |
| Siūlų klasės metodai | |
| pradžia () | Pradeda gijos veiklą. Kiekvienai gijai jis turi būti iškviestas tik vieną kartą, nes, jei bus iškviestas kelis kartus, jis sukels vykdymo klaidą. |
| paleisti () | Šis metodas žymi gijos veiklą ir gali būti pakeistas klase, pratęsiančia gijos klasę. |
| prisijungti () | Jis blokuoja kito kodo vykdymą, kol bus nutraukta gija, ant kurios buvo vadinamas „join ()“ metodas. |
Backstory: siūlų klasė
Prieš pradedant koduoti daugiasrieges programas naudojant sriegimo modulį, labai svarbu suprasti apie gijų klasę. Gijų klasė yra pagrindinė klasė, apibrėžianti šabloną ir gijos operacijas python.
Dažniausias būdas sukurti daugialypę python programą yra deklaruoti klasę, kuri pratęsia „Thread“ klasę ir nepaiso jos „run“ () metodo.
„Thread“ klasė apibendrintai reiškia kodų seką, einančią atskiroje valdymo gijoje .
Taigi, rašydami daugialypę programą, atliksite šiuos veiksmus:
- apibrėžti klasę, kuri pratęsia siūlų klasę
- Nepaisyti konstruktoriaus __init__
- Nepaisyti run () metodo
Atlikus gijos objektą , šios veiklos vykdymui pradėti gali būti naudojamas pradžios () metodas, o prisijungimo () metodas gali būti naudojamas blokuoti visus kitus kodus, kol baigsis dabartinė veikla.
Dabar pabandykime naudoti sriegimo modulį, kad įgyvendintumėte ankstesnį pavyzdį. Vėlgi, suaktyvinkite savo IDLE ir įveskite:
import timeimport threadingclass threadtester (threading.Thread):def __init__(self, id, name, i):threading.Thread.__init__(self)self.id = idself.name = nameself.i = idef run(self):thread_test(self.name, self.i, 5)print ("%s has finished execution " %self.name)def thread_test(name, wait, i):while i:time.sleep(wait)print ("Running %s \n" %name)i = i - 1if __name__=="__main__":thread1 = threadtester(1, "First Thread", 1)thread2 = threadtester(2, "Second Thread", 2)thread3 = threadtester(3, "Third Thread", 3)thread1.start()thread2.start()thread3.start()thread1.join()thread2.join()thread3.join()
Tai bus išvestis, kai vykdysite pirmiau nurodytą kodą:
KODO PAAIŠKINIMAS
- Ši dalis yra tokia pati kaip ir ankstesnis mūsų pavyzdys. Čia importuojate laiko ir gijos modulį, naudojamą „Python“ gijų vykdymui ir atidėjimams tvarkyti.
- Šioje bitoje kuriate klasę, vadinamą „threadtester“, kuri paveldi arba pratęsia sriegimo modulio „ Thread“ klasę. Tai yra vienas iš labiausiai paplitusių gijų kūrimo būdų. Tačiau programoje turėtumėte nepaisyti tik konstruktoriaus ir run () metodo. Kaip matote aukščiau pateiktame kodo pavyzdyje, metodas __init__ (konstruktorius) buvo nepaisytas.
Panašiai jūs taip pat nepaisėte bėgimo () metodo. Jame yra kodas, kurį norite vykdyti gijos viduje. Šiame pavyzdyje jūs iškvietėte funkciją thread_test ().
- Tai yra thread_test () metodas, kuris ima i reikšmę kaip argumentą, sumažina ją po 1 kiekvienoje iteracijoje ir peržiūri likusį kodą, kol i tampa 0. Kiekvienoje iteracijoje jis išspausdina šiuo metu vykdančios gijos pavadinimą ir miega laukimo sekundes (kas taip pat laikoma argumentu).
- thread1 = threadtester (1, "Pirmoji gija", 1)
Čia mes kuriame temą ir perduodame tris parametrus, kuriuos deklaravome __init__. Pirmasis parametras yra gijos ID, antrasis parametras yra gijos pavadinimas, o trečiasis parametras yra skaitiklis, kuris nustato, kiek kartų ciklas turėtų veikti.
- thread2.start ()
Pradžios metodas naudojamas norint pradėti giją. Viduje funkcija start () iškviečia jūsų klasės run () metodą.
- thread3.join ()
Join () metodas blokuoja kito kodo vykdymą ir laukia, kol gija, ant kurios jis buvo vadinamas, baigsis.
Kaip jau žinote, tame pačiame procese esančios gijos turi prieigą prie to proceso atminties ir duomenų. Todėl, jei daugiau nei viena gija vienu metu bando pakeisti arba pasiekti duomenis, klaidos gali nuslėpti.
Kitame skyriuje pamatysite įvairių rūšių komplikacijas, kurios gali pasireikšti, kai gijos pasiekia duomenis ir kritinės sekcijos, netikrindamos esamų prieigos operacijų.
Aklavietės ir lenktynių sąlygos
Prieš sužinant apie aklavietes ir varžybų sąlygas, bus naudinga suprasti keletą pagrindinių apibrėžimų, susijusių su tuo pačiu programavimu:
- Kritinis skyrius
Tai yra kodo fragmentas, kuris pasiekia arba modifikuoja bendrus kintamuosius ir turi būti atliekamas kaip atominė operacija.
- Konteksto jungiklis
Tai procesas, kurį seka procesorius, kad išsaugotų gijos būseną prieš keisdamas vieną užduotį į kitą, kad vėliau būtų galima tęsti iš to paties taško.
Aklavietės
Aklavietės yra labiausiai bijoma problema, su kuria susiduria kūrėjai, kai python'e rašo lygiagrečias / daugiagijas programas. Geriausias būdas suprasti aklavietę yra klasikinės informatikos pavyzdžio problemos, žinomos kaip „ Valgomojo filosofo problema“.
Vakarienės filosofų problemos išdėstymas yra toks:
Penki filosofai sėdi ant apvalaus stalo su penkiomis spagečių plokštelėmis (makaronų rūšimi) ir penkiomis šakutėmis, kaip parodyta diagramoje.
Bet kuriuo metu filosofas turi arba valgyti, arba mąstyti.
Be to, prieš valgydamas spagečius, filosofas turi pasiimti dvi šalia esančias šakutes (ty kairę ir dešinę šakutes). Aklavietės problema kyla tada, kai visi penki filosofai vienu metu pasiima dešiniąsias šakutes.
Kadangi kiekvienas iš filosofų turi po vieną šakę, jie visi lauks, kol kiti padės šakę. Todėl nė vienas iš jų negalės valgyti spagečių.
Panašiai ir lygiagrečioje sistemoje aklavietė įvyksta, kai skirtingos gijos ar procesai (filosofai) tuo pačiu metu bando įsigyti bendrus sistemos išteklius (šakutes). Todėl nė vienas iš procesų neturi galimybės įvykdyti, nes jie laukia kito šaltinio, kurį turi kitas procesas.
Lenktynių sąlygos
Lenktynių sąlyga yra nepageidaujama programos būsena, kuri atsiranda, kai sistema vienu metu atlieka dvi ar daugiau operacijų. Pavyzdžiui, apsvarstykite šį paprastą ciklą:
i=0; # a global variablefor x in range(100):print(i)i+=1;
Jei sukursite n gijų, kurios vienu metu paleidžia šį kodą, skaičių, negalėsite nustatyti i vertės (kurią dalijasi gijos), kai programa baigs vykdyti. Taip yra todėl, kad tikroje daugialypėje aplinkoje gijos gali sutapti, o gija gauta ir modifikuota i vertė gali pasikeisti, kai prie jos prisijungia kai kurie kiti gijos.
Tai yra dvi pagrindinės problemų klasės, kurios gali kilti daugiagijėje arba paskirstytoje python programoje. Kitame skyriuje sužinosite, kaip įveikti šią problemą sinchronizuojant gijas.
Sinchronizuojamos gijos
Norėdami išspręsti varžybų sąlygas, aklavietes ir kitas gijomis pagrįstas problemas, sriegimo modulis pateikia „ Lock“ objektą. Idėja yra ta, kad kai gija nori prieigos prie konkretaus šaltinio, ji įgyja šiam šaltiniui užraktą. Kai gija užrakina tam tikrą šaltinį, jokia kita gija negali jo pasiekti, kol užraktas nebus atleistas. Dėl to išteklių pokyčiai bus atominiai ir bus išvengta lenktynių sąlygų.
Užraktas yra žemo lygio sinchronizavimo primityvas, kurį įgyvendina modulis __thread . Bet kuriuo metu spyna gali būti viena iš 2 būsenų: užrakinta arba atrakinta. Jis palaiko du metodus:
- įsigyti ()
Kai atrakinimo būsena bus atrakinta, iškvietus įgyti () metodą būsena bus pakeista į užrakintą ir grįš. Tačiau, jei būsena yra užrakinta, raginimas įsigyti () yra užblokuotas, kol „release ()“ metodas bus iškviestas kitomis gijomis.
- išleisti ()
Atleidimo () metodas naudojamas nustatyti būseną atrakintai, ty atlaisvinti užraktą. Jį galima vadinti bet kokiu siūlu, nebūtinai tuo, kuris įsigijo spyną.
Štai spynų naudojimo programose pavyzdys. Suaktyvinkite savo IDLE ir įveskite:
import threadinglock = threading.Lock()def first_function():for i in range(5):lock.acquire()print ('lock acquired')print ('Executing the first funcion')lock.release()def second_function():for i in range(5):lock.acquire()print ('lock acquired')print ('Executing the second funcion')lock.release()if __name__=="__main__":thread_one = threading.Thread(target=first_function)thread_two = threading.Thread(target=second_function)thread_one.start()thread_two.start()thread_one.join()thread_two.join()
Dabar paspauskite F5. Turėtumėte pamatyti tokį išėjimą:
KODO PAAIŠKINIMAS
- Čia tiesiog sukuriate naują užraktą, paskambinę „ threading.Lock“ ( gamyklos) funkcija. Viduje „Lock“ () pateikia efektyviausios betoninės „Lock“ klasės egzempliorių, kurį prižiūri platforma.
- Pirmajame sakinyje užraktą įsigyjate paskambinę įgyti () metodą. Suteikę užraktą, konsolėje atspausdinsite „užraktą, įgytą“ . Baigę vykdyti visą kodą, kurį norite, kad gija būtų paleista, atleiskite užraktą iškvietę metodą release ().
Teorija yra puiki, bet kaip žinoti, kad spyna tikrai veikė? Pažvelgę į išvestį pamatysite, kad kiekviena iš atspausdintų ataskaitų vienu metu spausdina tiksliai po vieną eilutę. Prisiminkime, kad ankstesniame pavyzdyje spausdinimo išvestys yra atsitiktinės, nes kelios gijos vienu metu naudojasi metodu print (). Čia spausdinimo funkcija iškviečiama tik įsigijus spyną. Taigi, išėjimai rodomi po vieną ir eilutė po eilutės.
Be spynų, „python“ taip pat palaiko kai kuriuos kitus mechanizmus, skirtus tvarkyti gijų sinchronizavimą, kaip nurodyta toliau:
- RLocks
- Semaforai
- Sąlygos
- Įvykiai ir
- Kliūtys
Visuotinio vertėjo užraktas (ir kaip su juo elgtis)
Prieš įsigilindami į pitono GIL detales, apibrėžkime keletą terminų, kurie bus naudingi norint suprasti būsimą skyrių:
- Su CPU susietas kodas: tai reiškia bet kurį kodo fragmentą, kurį tiesiogiai vykdys procesorius.
- Įvesties / išvesties kodas: tai gali būti bet kuris kodas, prieinantis failų sistemą per OS
- „CPython“: tai yra pagrindinis „Python“ diegimas ir gali būti apibūdinamas kaip vertėjas, parašytas C ir Python (programavimo kalba).
Kas yra GIL „Python“?
Visuotinis vertėjo užraktas (GIL) pitone yra proceso užraktas arba muteksas, naudojamas dirbant su procesais. Tai užtikrina, kad viena gija vienu metu gali pasiekti konkretų šaltinį, taip pat neleidžia vienu metu naudoti objektų ir baitekodų. Tai naudinga vienos gijos programoms, kai padidėja našumas. GIL python yra labai paprasta ir lengvai įgyvendinama.
Užraktą galima naudoti norint įsitikinti, kad tam tikru laiku prieigą prie konkretaus resurso turi tik viena gija.
Viena iš „Python“ ypatybių yra ta, kad kiekvienam vertėjo procesui naudojama visuotinė užraktas, o tai reiškia, kad kiekvienas procesas pats „Python“ vertėją traktuoja kaip šaltinį.
Pvz., Tarkime, kad parašėte pitono programą, kuri naudoja dvi gijas tiek procesoriaus, tiek „įvesties / išvesties“ operacijoms atlikti. Kai vykdote šią programą, atsitinka taip:
- Python vertėjas sukuria naują procesą ir sukuria gijas
- Pradėjus veikti „thread-1“, jis pirmiausia įgis GIL ir jį užrakins.
- Jei „thread-2“ nori vykdyti dabar, jis turės palaukti, kol GIL bus išleistas, net jei kitas procesorius yra laisvas.
- Tarkime, kad „thread-1“ laukia I / O operacijos. Šiuo metu ji išleis GIL ir „thread-2“ ją įgis.
- Baigęs įvesties / išvesties operacijas, jei „thread-1“ nori vykdyti dabar, jis vėl turės laukti, kol „GIL“ bus išleistas „thread-2“.
Todėl bet kuriuo metu prie vertėjo gali prisijungti tik viena gija, o tai reiškia, kad tam tikru momentu bus tik viena gija, vykdanti pitono kodą.
Tai gerai vieno branduolio procesoriuje, nes jis tvarkydamas gijas naudos laiko pjaustymą (žr. Pirmąjį šios pamokos skyrių). Tačiau kelių branduolių procesorių atveju su procesoriumi susijusi funkcija, vykdanti kelias gijas, turės didelę įtaką programos efektyvumui, nes ji iš tikrųjų nenaudos visų turimų branduolių tuo pačiu metu.
Kodėl reikėjo GIL?
„CPython“ šiukšlių surinkėjas naudoja efektyvią atminties tvarkymo techniką, vadinamą nuorodų skaičiavimu. Štai kaip tai veikia: Kiekvienam python objekte yra nuorodų skaičius, kuris padidėja, kai jis priskiriamas naujam kintamojo pavadinimui arba pridedamas prie konteinerio (pvz., Rinkiniai, sąrašai ir kt.). Panašiai nuorodų skaičius sumažėja, kai nuoroda išeina iš taikymo srities arba kai iškviečiamas del sakinys. Kai objekto pamatinis skaičius pasiekia 0, surenkamos šiukšlės ir atlaisvinama skirta atmintis.
Tačiau problema ta, kad atskaitos skaičiaus kintamasis yra linkęs į lenktynių sąlygas, kaip ir bet kuris kitas pasaulinis kintamasis. Norėdami išspręsti šią problemą, pitono kūrėjai nusprendė naudoti visuotinį vertėjo užraktą. Kita galimybė buvo pridėti kiekvieno objekto užraktą, kuris būtų sukėlęs aklavietę ir padidėjęs pridėtinių () ir atleidimo () skambučių pridėtinės išlaidos.
Todėl GIL yra reikšmingas daugiasluoksnių python programų, vykdančių sunkias su procesoriumi susietas operacijas (efektyviai paverčiantis jas vieno gija), apribojimas. Jei norite savo programoje naudoti keletą procesoriaus branduolių, vietoj to naudokite daugiaprocesorinį modulį.
Santrauka
- „Python“ palaiko 2 modulius, reikalingus daugialypiam gijimui:
- __thread modulis: jis teikia žemo lygio diegimą ir yra pasenęs.
- sriegimo modulis : jis teikia aukšto lygio kelių gijų diegimą ir yra dabartinis standartas.
- Norėdami sukurti giją naudodami sriegimo modulį, turite atlikti šiuos veiksmus:
- Sukurkite klasę, kuri pratęsia siūlų klasę.
- Nepaisyti jo konstruktoriaus (__init__).
- Nepaisyti jo run () metodo.
- Sukurkite šios klasės objektą.
- Giją galima įvykdyti iškvietus start () metodą.
- Prisijungti () metodas gali būti naudojamas blokuoti kitas temas, kol šioje temoje (vienas, dėl kurio prisijungti vadinosi) baigia vykdyti.
- Lenktynių sąlyga įvyksta, kai kelios gijos vienu metu pasiekia arba modifikuoja bendrą išteklių.
- To galima išvengti sinchronizuojant gijas.
- „Python“ palaiko 6 gijų sinchronizavimo būdus:
- Spynos
- RLocks
- Semaforai
- Sąlygos
- Įvykiai ir
- Kliūtys
- Spynos leidžia į kritinę sekciją patekti tik tam tikram gijai, kuri yra užrakinta spyną.
- Spyna turi 2 pagrindinius metodus:
- įgyti () : nustato užrakto būseną . Jei iškviečiamas užrakintas objektas, jis užblokuoja tol, kol šaltinis yra laisvas.
- release () : nustato užrakto būseną atrakintą ir grįžta. Jei iškviečiamas neužrakintas objektas, jis pateikia klaidingą reikšmę.
- Visuotinis vertėjo užraktas yra mechanizmas, kurį vienu metu gali vykdyti tik 1 „CPython“ vertėjo procesas.
- Jis buvo naudojamas siekiant palengvinti „CPythons“ šiukšlių surinkėjo etalonų skaičiavimo funkcionalumą.
- Norėdami sukurti „Python“ programas naudodami sunkias su procesoriumi susietas operacijas, turėtumėte naudoti daugiaprocesorinį modulį.