Monisäikeisyys Pythonissa, esimerkki GIL (Global Interpreter Lock)

Python-ohjelmointikielen avulla voit käyttää moniprosessointia tai monisäikeisyyttä. Tässä opetusohjelmassa opit kirjoittamaan monisäikeisiä sovelluksia Pythonissa.

Mikä on lanka?

Lanka on samanaikaisen ohjelmoinnin yksikkö. Monisäikeisyys on tekniikka, jonka avulla keskusyksikkö voi suorittaa useita prosessin tehtäviä samanaikaisesti. Nämä ketjut voidaan suorittaa erikseen jaettaessa samalla prosessiresursseja.

Mikä on prosessi?

Prosessi on periaatteessa suoritettava ohjelma. Kun käynnistät sovelluksen tietokoneellasi (kuten selain tai tekstieditori), käyttöjärjestelmä luo prosessin.

Mitä monisäikeisyys on Pythonissa?

Monisäikeisyys Python- ohjelmoinnissa on tunnettu tekniikka, jossa prosessin useat säikeet jakavat tietotilansa pääkierteen kanssa, mikä tekee tiedon jakamisesta ja viestinnästä ketjujen sisällä helppoa ja tehokasta. Kierteet ovat kevyempiä kuin prosessit. Useat ketjut voidaan suorittaa erikseen jaettaessa prosessiresursseja. Monisäikeisyyden tarkoituksena on suorittaa useita tehtäviä ja toimintosoluja samanaikaisesti.

Mikä on moniprosessointi?

Moniprosessoinnin avulla voit suorittaa useita etuyhteydettömiä prosesseja samanaikaisesti. Nämä prosessit eivät jaa resurssejaan ja kommunikoivat IPC: n kautta.

Python-monisäikeisyys vs. moniprosessointi

Harkitse tätä skenaariota ymmärtääksesi prosessit ja ketjut: Tietokoneesi .exe-tiedosto on ohjelma. Kun avaat sen, käyttöjärjestelmä lataa sen muistiin, ja CPU suorittaa sen. Nyt käynnissä olevan ohjelman instanssia kutsutaan prosessiksi.

Jokaisessa prosessissa on 2 perustekijää:

• Koodi
• Tiedot

Nyt prosessi voi sisältää yhden tai useampia alaosia, joita kutsutaan säikeiksi. Tämä riippuu käyttöjärjestelmän arkkitehtuurista .Voit ajatella ketjua prosessin osana, jonka käyttöjärjestelmä voi suorittaa erikseen.

Toisin sanoen se on ohjeiden virta, jonka käyttöjärjestelmä voi suorittaa itsenäisesti. Yhden prosessin säikeet jakavat prosessin tiedot ja on suunniteltu toimimaan yhdessä rinnakkaisuuden helpottamiseksi.

Tässä opetusohjelmassa opit,

• Mikä on lanka?
• Mikä on prosessi?
• Mikä on monisäikeinen?
• Mikä on moniprosessointi?
• Python-monisäikeisyys vs. moniprosessointi
• Miksi käyttää monisäikeistä?
• Python MultiThreading
• Kierre- ja langoitusmoduulit
• Lankamoduuli
• Langoitusmoduuli
• Salpalukot ja kilpailuolosuhteet
• Synkronoidaan ketjut
• Mikä on GIL?
• Miksi GIL: ää tarvittiin?

Miksi käyttää monisäikeistä?

Monisäikeisyyden avulla voit jakaa sovelluksen useisiin alitehtäviin ja suorittaa nämä tehtävät samanaikaisesti. Jos käytät monisäikeisyyttä oikein, sovelluksen nopeutta, suorituskykyä ja hahmonnusta voidaan parantaa.

Python MultiThreading

Python tukee rakenteita sekä moniprosessointiin että monisäikeisiin ketjuihin. Tässä opetusohjelmassa keskityt ensisijaisesti monisäikeisten sovellusten toteuttamiseen pythonilla. Pythonissa ketjuja voidaan käyttää kahdella päämoduulilla:

1. Lanka -moduuli, ja
2. Ketjuttaminen moduuli

Pythonissa on kuitenkin myös jotain, jota kutsutaan globaaliksi tulkkilukoksi (GIL). Se ei salli paljon suorituskykyä ja saattaa jopa heikentää joidenkin monisäikeisten sovellusten suorituskykyä. Opit kaiken siitä tämän opetusohjelman tulevista osioista.

Kierre- ja langoitusmoduulit

Kaksi moduulia, joista opit tässä opetusohjelmassa, ovat säiemoduuli ja ketjutusmoduuli .

Lankamoduuli on kuitenkin pitkään ollut vanhentunut. Alkaen Python 3: sta, se on nimetty vanhentuneeksi ja se on käytettävissä vain nimellä __thread taaksepäin yhteensopivuuden vuoksi.

Kannattaa käyttää korkeamman tason ketjuttaminen moduuli sovellusten aiot ottaa käyttöön. Lankamoduuli on käsitelty tässä vain koulutustarkoituksiin.

Lankamoduuli

Syntaksi uuden säikeen luomiseksi tämän moduulin avulla on seuraava:

thread.start_new_thread(function_name, arguments)

Selvä, nyt olet käsitellyt perusteorian koodauksen aloittamiseksi. Joten avaa IDLE tai muistilehtiö ja kirjoita seuraava:

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))

Tallenna tiedosto ja paina F5 ohjelman ajamiseksi. Jos kaikki on tehty oikein, sinun pitäisi nähdä tämä tulos:

Opit lisää kilpailuolosuhteista ja niiden käsittelemisestä tulevilla osioilla

KOODISELITYS

1. Nämä lauseet tuovat aika- ja ketjumoduulin, joita käytetään Python-ketjujen suorittamisen ja viivästymisen käsittelemiseen.
2. Tässä olet määrittänyt funktion nimeltä kierteen_testi, jota kutsutaan menetelmällä start_new_thread . Funktio suorittaa hetkellisen silmukan neljälle iteraatiolle ja tulostaa sen kutsuneen ketjun nimen. Kun iterointi on valmis, se tulostaa viestin, jossa kerrotaan, että ketju on suoritettu loppuun.
3. Tämä on ohjelman pääosa. Täällä voit yksinkertaisesti soittaa start_new_thread menetelmän kanssa thread_test funktiota argumenttina.

   Tämä luo uuden säikeen funktiolle, jonka välität argumenttina, ja aloitat sen suorittamisen. Huomaa, että voit korvata tämän (säie _testi ) muulla toiminnolla, jonka haluat suorittaa ketjuna.

Langoitusmoduuli

Tämä moduuli on pythonin ketjutuksen korkean tason toteutus ja tosiasiallinen standardi monisäikeisten sovellusten hallitsemiseksi. Se tarjoaa laajan valikoiman ominaisuuksia verrattuna lankamoduuliin.

Tässä on luettelo joistakin tässä moduulissa määritetyistä hyödyllisistä toiminnoista:

Toiminnon nimi	Kuvaus
activeCount ()	Palauttaa lasken Thread esineitä, jotka ovat vielä elossa
currentThread ()	Palauttaa Thread-luokan nykyisen objektin.
luetella()	Luetteloi kaikki aktiiviset säieobjektit.
isDaemon ()	Palauttaa arvon true, jos säie on daemon.
on elossa()	Palauttaa arvon tosi, jos säie on edelleen elossa.
	Thread-luokan menetelmät
alkaa()	Aloittaa ketjun toiminnan. Sitä täytyy kutsua vain kerran jokaiselle säikeelle, koska se heittää ajonaikaisen virheen, jos sitä kutsutaan useita kertoja.
juosta()	Tämä menetelmä tarkoittaa ketjun aktiivisuutta ja sen voi ohittaa luokka, joka laajentaa säie-luokkaa.
liittyä seuraan()	Se estää muun koodin suorittamisen, kunnes säie, jolle Join () -menetelmää kutsuttiin, lopetetaan.

Backstory: Kierre-luokka

Ennen kuin aloitat monisäikeisten ohjelmien koodaamisen langoitusmoduulin avulla, on tärkeää ymmärtää Thread-luokka. Thread-luokka on ensisijainen luokka, joka määrittelee langan mallin ja toiminnot pythonissa.

Yleisin tapa luoda monisäikeinen python-sovellus on julistaa luokka, joka laajentaa Thread-luokkaa ja ohittaa sen run () -menetelmän.

Thread luokka, yhteenvetona, merkitsee koodisekvenssin, joka kulkee erillisen säikeen ohjaus.

Joten kirjoittaessasi monisäikeistä sovellusta, toimi seuraavasti:

1. määritä luokka, joka laajentaa säie-luokkaa
2. Ohita __init__- konstruktori
3. Ohita run () -menetelmä

Kun lankaobjekti on tehty, start () -menetelmää voidaan käyttää tämän toiminnon suorittamisen aloittamiseen ja join () -menetelmää voidaan käyttää estämään kaikki muut koodit, kunnes nykyinen toiminto on valmis.

Yritetään nyt käyttää kierteitysmoduulia toteuttamaan edellinen esimerkkisi. Käynnistä uudelleen IDLE ja kirjoita seuraava:

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()

Tämä on tulos, kun suoritat yllä olevan koodin:

KOODISELITYS

1. Tämä osa on sama kuin edellinen esimerkkimme. Täältä tuot aika- ja ketjumoduulin, joita käytetään Python-ketjujen suorittamisen ja viivästysten käsittelemiseen.
2. Tässä bitissä olet luomassa luokkaa nimeltä threadtester, joka perii tai laajentaa ketjutusmoduulin Thread- luokkaa. Tämä on yksi yleisimmistä tavoista luoda ketjuja pythonissa. Sinun tulisi kuitenkin ohittaa vain rakentaja ja run () -menetelmä sovelluksessasi. Kuten yllä olevasta koodinäytteestä näet, menetelmä __init__ (konstruktori) on ohitettu.

   Samoin olet ohittanut run () -menetelmän. Se sisältää koodin, jonka haluat suorittaa langan sisällä. Tässä esimerkissä olet kutsunut toiminto thread_test ().

3. Tämä on thread_test () -menetelmä, joka ottaa i: n arvon argumenttina, pienentää sitä 1: llä kullakin iteraatiolla ja silmukkaa loput koodista läpi, kunnes minusta tulee 0. Kussakin iteraatiossa se tulostaa parhaillaan suoritettavan ketjun nimen ja nukkuu odottamassa sekunteja (mikä otetaan myös argumentiksi).
4. thread1 = threadtester (1, "Ensimmäinen ketju", 1)

   Tässä luomme ketjun ja välitämme kolme parametria, jotka ilmoitimme __init__: ssa. Ensimmäinen parametri on ketjun tunnus, toinen parametri on langan nimi ja kolmas parametri on laskuri, joka määrittää kuinka monta kertaa while-silmukan tulisi toimia.

5. thread2.start ()

   Aloitusmenetelmää käytetään langan suorittamisen aloittamiseen. Sisäisesti start () -funktio kutsuu luokan run () -metodia.

6. thread3.liity ()

   Join () -menetelmä estää toisen koodin suorittamisen ja odottaa, että säie, jolla sitä kutsuttiin, päättyy.

Kuten jo tiedätte, samassa prosessissa olevilla säikeillä on pääsy prosessin muistiin ja tietoihin. Tämän seurauksena, jos useampi kuin yksi ketju yrittää muuttaa tai käyttää tietoja samanaikaisesti, virheet voivat hiipiä.

Seuraavassa osassa näet erilaisia ​​komplikaatioita, joita voi ilmetä, kun ketjut käyttävät tietoja ja kriittisiä osioita tarkistamatta olemassa olevia käyttöoikeustapahtumia.

Salpalukot ja kilpailuolosuhteet

Ennen kuin tutustut umpikujaan ja kilpailuolosuhteisiin, on hyödyllistä ymmärtää muutama samanaikaiseen ohjelmointiin liittyvä perusmääritelmä:

• Kriittinen osa

  Se on koodinpätkä, joka käyttää ja muokkaa jaettuja muuttujia ja joka on suoritettava atomitapahtumana.

• Kontekstikytkin

  CPU seuraa prosessia säikeen tilan tallentamiseksi ennen siirtymistä tehtävästä toiseen, jotta sitä voidaan jatkaa samasta kohdasta myöhemmin.

Umpikujasta

Salpalukot ovat pelätyin ongelma, jonka kehittäjät kohtaavat kirjoittaessaan samanaikaisia ​​/ monisäikeisiä sovelluksia pythonissa. Paras tapa ymmärtää umpikuja on käyttää klassista tietojenkäsittelytieteen ongelmaa, joka tunnetaan nimellä Dining Philosophers Problem.

Ruokapaikkafilosofien ongelma on seuraava:

Viisi filosofia istuu pyöreällä pöydällä, jossa on viisi spagettilevyä (pastatyyppi) ja viisi haarukkaa, kuten kaaviossa on esitetty.

Milloin tahansa filosofin on joko syötävä tai ajatteleva.

Lisäksi filosofin on otettava kaksi vieressä olevaa haarukkaa (eli vasen ja oikea haarukka) ennen kuin hän voi syödä spagettia. Umpikujaongelma ilmenee, kun kaikki viisi filosofia nostavat oikean haarukan samanaikaisesti.

Koska kaikilla filosofeilla on yksi haarukka, he kaikki odottavat muiden laittavan haarukan. Tämän seurauksena kukaan heistä ei voi syödä spagettia.

Vastaavasti samanaikaisessa järjestelmässä umpikuja tapahtuu, kun eri ketjut tai prosessit (filosofit) yrittävät hankkia jaettuja järjestelmäresursseja (haarukat) samanaikaisesti. Tämän seurauksena mikään prosesseista ei saa mahdollisuutta suorittaa, koska ne odottavat toista jonkin muun prosessin hallussa olevaa resurssia.

Kilpailuehdot

Kilpailu on ohjelman ei-toivottu tila, joka tapahtuu, kun järjestelmä suorittaa kaksi tai useampia toimintoja samanaikaisesti. Harkitse esimerkiksi tätä yksinkertaista silmukalle:

i=0; # a global variablefor x in range(100):print(i)i+=1;

Jos luot n määrän säikeitä, jotka suorittavat tämän koodin kerralla, et voi määrittää i: n arvoa (jonka ketjut jakavat), kun ohjelma on suorittanut suorituksen. Tämä johtuu siitä, että todellisessa monisäikeisessä ympäristössä säikeet voivat olla päällekkäisiä, ja ketjun hakema ja muokkaama i-arvo voi muuttua välillä, kun joku muu lanka pääsee siihen.

Nämä ovat kaksi pääluokkaa ongelmiin, joita voi esiintyä monisäikeisessä tai hajautetussa python-sovelluksessa. Seuraavassa osassa opit voittamaan tämän ongelman synkronoimalla ketjut.

Synkronoidaan ketjut

Kilpailuolosuhteiden, umpikujausten ja muiden säikeisiin perustuvien ongelmien käsittelemiseksi ketjutusmoduuli tarjoaa Lock- objektin. Ajatuksena on, että kun säie haluaa pääsyn tiettyyn resurssiin, se hankkii lukituksen tälle resurssille. Kun ketju lukitsee tietyn resurssin, mikään muu ketju ei pääse siihen, ennen kuin lukitus vapautetaan. Tämän seurauksena resurssin muutokset ovat atomisia ja kilpailuolosuhteet vältetään.

Lukko on matalan tason synkronointiprimitiivi, jonka __thread- moduuli toteuttaa. Lukitus voi milloin tahansa olla jossakin kahdesta tilasta: lukittu tai lukitsematon. Se tukee kahta menetelmää:

1. hankkia()

   Kun lukitustila on lukittu, hankinta () -menetelmän kutsuminen muuttaa tilan lukituksi ja palaa. Jos tila on kuitenkin lukittu, kutsu hankkia () estetään, kunnes jokin muu säie kutsuu release () -menetelmää.

2. julkaisu ()

   Release () -menetelmää käytetään asettamaan tila lukitsematta, ts. Vapauttamaan lukitus. Sitä voidaan kutsua millä tahansa säikeellä, ei välttämättä sillä, joka hankki lukon.

Tässä on esimerkki lukkojen käytöstä sovelluksissasi. Käynnistä IDLE ja kirjoita seuraava:

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()

Napsauta nyt F5. Sinun pitäisi nähdä tällainen lähtö:

KOODISELITYS

1. Täällä luodaan yksinkertaisesti uusi lukitus kutsumalla tehdasfunktio threading.Lock () . Sisäisesti Lock () palauttaa tehokkaimman betonilukon luokan, jota foorumi ylläpitää.
2. Ensimmäisessä lauseessa hankit lukon kutsumalla hankinta () -metodin. Kun lukko on myönnetty, tulostat "hankitun lukon" konsoliin. Kun kaikki koodi, jonka haluat langan suorittavan, on suoritettu loppuun, vapautat lukituksen kutsumalla release () -menetelmän.

Teoria on hieno, mutta mistä tiedät, että lukko todella toimi? Jos tarkastelet tulosta, huomaat, että kukin tulostuslauseke tulostaa täsmälleen yhden rivin kerrallaan. Muistakaamme, että aikaisemmassa esimerkissä tulosteet tulostuksesta ovat sattumanvaraisia, koska useat säikeet käyttivät print () -menetelmää samanaikaisesti. Tässä tulostustoimintoa kutsutaan vasta, kun lukko on hankittu. Joten lähdöt näytetään yksi kerrallaan ja rivi riviltä.

Lukkojen lisäksi python tukee myös joitain muita mekanismeja langan synkronoinnin käsittelemiseksi, kuten alla on lueteltu:

1. R-lukot
2. Semaforeja
3. Ehdot
4. Tapahtumat ja
5. Rajat

Yleinen tulkkilukko (ja miten sitä käsitellään)

Ennen kuin ryhdymme pythonin GIL: n yksityiskohtiin, määritellään muutama termi, joista on hyötyä tulevan osan ymmärtämisessä:

1. Suorittimeen sidottu koodi: tämä viittaa mihin tahansa koodinpätkään, jonka suoritin suorittaa suoraan.
2. I / O-sidottu koodi: tämä voi olla mikä tahansa koodi, joka käyttää tiedostojärjestelmää käyttöjärjestelmän kautta
3. CPython: se on viittaus täytäntöönpanon Python ja voidaan kuvata tulkin kirjoitettu C ja Python (ohjelmointikieli).

Mikä on GIL Pythonissa?

Pythonin yleinen tulkkilukko (GIL) on prosessilukko tai mykistys, jota käytetään prosessien käsittelyssä. Se varmistaa, että yksi ketju voi käyttää tiettyä resurssia kerrallaan, ja se estää myös esineiden ja tavukoodien käytön kerralla. Tämä hyödyttää yksisäikeisiä ohjelmia suorituskyvyn kasvussa. GIL pythonissa on hyvin yksinkertainen ja helppo toteuttaa.

Lukolla voidaan varmistaa, että vain yhdellä ketjulla on pääsy tiettyyn resurssiin tiettynä ajankohtana.

Yksi Pythonin ominaisuuksista on, että se käyttää globaalia lukkoa jokaisessa tulkkiprosessissa, mikä tarkoittaa, että jokainen prosessi käsittelee itse python-tulkkia resurssina.

Oletetaan esimerkiksi, että olet kirjoittanut python-ohjelman, joka käyttää kahta ketjua suorittamaan sekä suorittimen että I / O-operaatiot. Kun suoritat tämän ohjelman, näin tapahtuu:

1. Python-tulkki luo uuden prosessin ja synnyttää ketjut
2. Kun thread-1 alkaa toimia, se hankkii ensin GIL: n ja lukitsee sen.
3. Jos thread-2 haluaa suorittaa nyt, sen on odotettava GIL: n julkaisua, vaikka toinen prosessori olisi vapaa.
4. Oletetaan nyt, että lanka-1 odottaa I / O-operaatiota. Tällä hetkellä se vapauttaa GIL: n ja thread-2 hankkii sen.
5. I / O-toimintojen suorittamisen jälkeen, jos säie-1 haluaa suorittaa nyt, sen on jälleen odotettava, että säie-2 vapauttaa GIL: n.

Tämän vuoksi vain yksi ketju voi käyttää tulkkia milloin tahansa, mikä tarkoittaa, että vain yksi ketju suorittaa python-koodin tiettynä ajankohtana.

Tämä on kunnossa yhden ytimen prosessorissa, koska se käyttää aikaviivaa (katso tämän opetusohjelman ensimmäinen osa) ketjujen käsittelemiseen. Usean ytimen suorittimien tapauksessa useille säikeille suoritettavalla prosessoriin sidotulla toiminnolla on kuitenkin merkittävä vaikutus ohjelman tehokkuuteen, koska se ei todellakaan käytä kaikkia käytettävissä olevia ytimiä samanaikaisesti.

Miksi GIL: ää tarvittiin?

CPython-roskien kerääjä käyttää tehokasta muistinhallintatekniikkaa, joka tunnetaan nimellä viitteiden laskenta. Näin se toimii: Jokaisella python-objektilla on viitemäärä, joka kasvaa, kun se määritetään uudelle muuttujan nimelle tai lisätään säilöön (kuten sarakkeet, luettelot jne.). Samoin viitemäärää pienennetään, kun viite menee ulkopuolelle tai kun kutsutaan del-käskyä. Kun objektin viitemäärä saavuttaa 0, se kerätään roskiin ja varattu muisti vapautuu.

Mutta ongelmana on, että viitemäärän muuttuja on taipuvainen kilpailuolosuhteisiin kuten mikä tahansa muu globaali muuttuja. Tämän ongelman ratkaisemiseksi pythonin kehittäjät päättivät käyttää yleistä tulkkilukkoa. Toinen vaihtoehto oli lisätä lukko kuhunkin objektiin, mikä olisi johtanut umpikujaan ja lisääntyneisiin yleiskustannuksiin hankinta- () ja vapauttamispuheluista ().

Siksi GIL on merkittävä rajoitus monisäikeisille python-ohjelmille, jotka suorittavat raskaita CPU-sidottuja operaatioita (tehden niistä yksisäikeisiä). Jos haluat käyttää useita suorittimen ytimiä sovelluksessasi, käytä sen sijaan moniprosessointimoduulia .

Yhteenveto

• Python tukee kahta moduulia monilangoitukseen:
  1. __thread- moduuli: Se tarjoaa matalan tason ketjuttamisen ja on vanhentunut.
  2. langoitusmoduuli : Se tarjoaa korkean tason toteutuksen monisäikeisyyteen ja on nykyinen standardi.
• Voit luoda ketjun langoitusmoduulin avulla seuraavasti:
  1. Luo luokka, joka laajentaa säiettä .
  2. Ohita sen rakentaja (__init__).
  3. Ohita sen run () -menetelmä.
  4. Luo tämän luokan objekti.
• Lanka voidaan suorittaa kutsumalla start () -metodi.
• Liittyä () menetelmää voidaan käyttää estämään muut ketjut, kunnes tätä säiettä (se, johon liittyy kutsuttiin) suoritus päättyy.
• Kilpailuehto esiintyy, kun useat ketjut käyttävät tai muuttavat jaettua resurssia samanaikaisesti.
• Se voidaan välttää synkronoimalla säikeet.
• Python tukee kuutta tapaa synkronoida ketjut:
  1. Lukot
  2. R-lukot
  3. Semaforeja
  4. Ehdot
  5. Tapahtumat ja
  6. Rajat
• Lukot sallivat kriittiseen osioon pääsyn vain tietyn langan, joka on hankkinut lukon.
• Lukolla on 2 ensisijaista menetelmää:
  1. hankkia () : Se asettaa lukitustilan lukittavaksi. Jos sitä kutsutaan lukitulle objektille, se estää, kunnes resurssi on vapaa.
  2. release () : Se asettaa lukitustilan avattavaksi ja palaa. Jos soitetaan lukitsemattomalle objektille, se palauttaa arvon false.
• Yleinen tulkin lukitus on mekanismi, jonka kautta vain yksi CPython-tulkin prosessi voi suorittaa kerrallaan.
• Sitä käytettiin helpottamaan CPythonsin roskakorin referenssilaskentatoimintoa.
• Jos haluat tehdä Python-sovelluksia raskailla prosessoriin liittyvillä operaatioilla, käytä moniprosessointimoduulia.