Python programmēšanas valoda ļauj jums izmantot daudzapstrādi vai daudzsavienojumu. Šajā apmācībā jūs uzzināsiet, kā rakstīt daudzlīniju programmas Python.
Kas ir pavediens?
Vītne ir vienības programmēšanas vienība. Multitreading ir tehnika, kas ļauj centrālajam procesoram vienlaikus izpildīt daudz viena procesa uzdevumus. Šīs tēmas var izpildīt atsevišķi, vienlaikus koplietojot savus procesa resursus.
Kas ir process?
Process būtībā ir izpildāmā programma. Startējot lietojumprogrammu datorā (piemēram, pārlūkprogrammā vai teksta redaktorā), operētājsistēma izveido procesu.
Kas ir daudzsavienojums Python?
Daudzlīniju vītne Python programmēšanā ir plaši pazīstama metode, kurā vairāki procesa pavedieni koplieto datu vietu ar galveno pavedienu, kas padara informācijas koplietošanu un saziņu pavedienos vieglu un efektīvu. Vītnes ir vieglākas nekā procesi. Vairākas tēmas var izpildīt atsevišķi, vienlaikus koplietojot savus procesa resursus. Vairāku pavedienu mērķis ir vienlaikus izpildīt vairākus uzdevumus un funkciju šūnas.
Kas ir daudzapstrāde?
Daudzapstrāde ļauj vienlaikus vadīt vairākus nesaistītus procesus. Šie procesi nedala savus resursus un sazinās, izmantojot IPC.
Python daudzsavienojums vs daudzapstrāde
Lai saprastu procesus un pavedienus, apsveriet šo situāciju: .exe fails jūsu datorā ir programma. Atverot to, OS ielādē to atmiņā, un CPU to izpilda. Tagad palaistās programmas instanci sauc par procesu.
Katram procesam būs 2 pamatkomponenti:
- Kods
- Dati
Tagad process var saturēt vienu vai vairākas apakšdaļas, ko sauc par pavedieniem. Tas ir atkarīgs no OS arhitektūras. Jūs varat domāt par pavedienu kā procesa sadaļu, kuru operētājsistēma var izpildīt atsevišķi.
Citiem vārdiem sakot, tā ir instrukciju plūsma, kuru OS var palaist neatkarīgi. Viena procesa pavedieni dala šī procesa datus un ir paredzēti sadarbībai, lai veicinātu paralēlismu.
Šajā apmācībā jūs uzzināsiet,
- Kas ir pavediens?
- Kas ir process?
- Kas ir daudzsavienojums?
- Kas ir daudzapstrāde?
- Python daudzsavienojums vs daudzapstrāde
- Kāpēc izmantot Multithreading?
- Python MultiThreading
- Vītnes un vītnes moduļi
- Vītnes modulis
- Vītņu modulis
- Strupceļi un sacīkšu apstākļi
- Sinhronizējot pavedienus
- Kas ir GIL?
- Kāpēc vajadzēja GIL?
Kāpēc izmantot Multithreading?
Daudzlīniju pavedieni ļauj sadalīt lietojumprogrammu vairākos apakšuzdevumos un vienlaikus izpildīt šos uzdevumus. Ja pareizi izmantojat daudzsavienojumu, jūsu lietojumprogrammas ātrumu, veiktspēju un renderēšanu var uzlabot.
Python MultiThreading
Python atbalsta konstrukcijas gan daudzapstrādei, gan daudzsavienošanai. Šajā apmācībā jūs galvenokārt koncentrēsieties uz daudzpavedienu lietojumprogrammu ieviešanu ar pitonu. Ir divi galvenie moduļi, kurus var izmantot, lai apstrādātu pavedienus Python:
- Vītne modulis, un
- Vītņu modulis
Tomēr pitonā ir arī kaut kas, ko sauc par globālo tulku bloķēšanu (GIL). Tas nepieļauj lielu veiktspējas pieaugumu un pat var samazināt dažu daudzšķiedru lietojumprogrammu veiktspēju. Jūs visu uzzināsiet šīs apmācības nākamajās sadaļās.
Vītnes un vītnes moduļi
Divi moduļi, par kuriem uzzināsiet šajā apmācībā, ir pavedienu modulis un pavedienu modulis .
Tomēr pavedienu modulis jau sen ir novecojis. Sākot ar Python 3, tas ir atzīts par novecojušu un ir pieejams tikai kā __vītne, lai nodrošinātu savietojamību atpakaļ.
Lietojumprogrammām, kuras plānojat izvietot, jums jāizmanto augstākā līmeņa pavedienu modulis. Vītņu modulis šeit ir apskatīts tikai izglītības nolūkos.
Vītnes modulis
Sintakse, lai izveidotu jaunu pavedienu, izmantojot šo moduli, ir šāda:
thread.start_new_thread(function_name, arguments)
Labi, tagad jūs esat aprakstījis pamata teoriju, lai sāktu kodēšanu. Tātad, atveriet savu IDLE vai piezīmju bloku un ierakstiet šo:
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))
Saglabājiet failu un nospiediet taustiņu F5, lai palaistu programmu. Ja viss tika izdarīts pareizi, jums vajadzētu redzēt šo izvadi:
Vairāk par sacensību apstākļiem un to, kā rīkoties, uzzināsiet nākamajās sadaļās
KODA PASKAIDROJUMS
- Šie priekšraksti importē laika un pavedienu moduli, kas tiek izmantots, lai apstrādātu Python pavedienu izpildi un aizkavēšanu.
- Šeit esat definējis funkciju ar nosaukumu thread_test, kuru izsauks ar metodi start_new_thread . Funkcija palaiž kādu cilpu četrām atkārtojumiem un izdrukā pavediena nosaukumu, kas to izsauca. Kad atkārtojums ir pabeigts, tas izdrukā ziņojumu, kurā teikts, ka pavediens ir pabeigts.
- Šī ir jūsu programmas galvenā sadaļa. Šeit jūs vienkārši izsaucat metodi start_new_thread ar argumentu thread_test .
Tas izveidos jaunu pavedienu funkcijai, kuru nododat kā argumentu, un sāksit to izpildīt. Ņemiet vērā, ka šo (pavediena _ tests) varat aizstāt ar jebkuru citu funkciju, kuru vēlaties palaist kā pavedienu.
Vītņu modulis
Šis modulis ir augsta līmeņa vītņu ieviešana pitonā un de facto standarts vairāku pavedienu lietojumprogrammu pārvaldībai. Tas nodrošina plašu funkciju klāstu, salīdzinot ar pavedienu moduli.
Šeit ir saraksts ar dažām šajā modulī definētām noderīgām funkcijām:
| Funkcijas nosaukums | Apraksts |
| activeCount () | Atgriež vēl dzīvu pavedienu skaitu |
| currentThread () | Atgriež pašreizējo klases Thread objektu. |
| uzskaitīt () | Uzskaita visus aktīvos Thread objektus. |
| isDaemon () | Atgriež vērtību true, ja pavediens ir dēmons. |
| ir dzīvs() | Atgriež vērtību true, ja pavediens joprojām ir dzīvs. |
| Vītņu klases metodes | |
| sākt() | Sāk pavediena darbību. Katram pavedienam tas jāizsauc tikai vienu reizi, jo tas izsauks izpildlaika kļūdu, ja to izsauks vairākas reizes. |
| palaist () | Šī metode apzīmē pavediena darbību, un to var ignorēt klase, kas paplašina pavedienu klasi. |
| pievienoties () | Tas bloķē cita koda izpildi, līdz tiek izbeigts pavediens, uz kura tika izsaukta metode join (). |
Backstory: pavedienu klase
Pirms sākat kodēt daudzlīniju programmas, izmantojot vītņu moduli, ir svarīgi saprast par pavedienu klasi. Vītņu klase ir primārā klase, kas nosaka veidnes un pavediena darbības pitonā.
Visizplatītākais veids, kā izveidot daudzšķiedru pitona lietojumprogrammu, ir deklarēt klasi, kas paplašina Thread klasi un ignorē tās run () metodi.
Klase Thread īsumā nozīmē kodu secību, kas darbojas atsevišķā vadības pavedienā .
Tātad, rakstot daudzlīniju lietotni, jūs rīkojieties šādi:
- definējiet klasi, kas paplašina Thread klasi
- Ignorēt __init__ konstruktoru
- Ignorēt run () metodi
Kad pavediena objekts ir izveidots, metodi Start () var izmantot, lai sāktu šīs darbības izpildi, un metodi Join () var izmantot, lai bloķētu visus pārējos kodus, līdz pašreizējā darbība būs pabeigta.
Tagad mēģināsim izmantot vītņu moduli, lai ieviestu iepriekšējo piemēru. Atkal aktivizējiet savu IDLE un ierakstiet šo:
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()
Tas būs izvade, izpildot iepriekš minēto kodu:
KODA PASKAIDROJUMS
- Šī daļa ir tāda pati kā mūsu iepriekšējais piemērs. Šeit jūs importējat laika un pavedienu moduli, kas tiek izmantots, lai apstrādātu Python pavedienu izpildi un aizkavēšanos.
- Šajā bitā jūs izveidojat klasi ar nosaukumu threadtester, kas pārmanto vai paplašina vītnes moduļa Thread klasi. Šis ir viens no visizplatītākajiem veidiem, kā izveidot pavedienus pitonā. Tomēr jūsu lietotnē ir jāignorē tikai konstruktors un Run () metode. Kā redzat iepriekš minētajā koda paraugā, __init__ metode (konstruktors) ir ignorēta.
Līdzīgi jūs arī esat ignorējis run () metodi. Tas satur kodu, kuru vēlaties izpildīt pavedienā. Šajā piemērā esat izsaucis funkciju thread_test ().
- Šī ir metode thread_test (), kas ņem argumenta i vērtību, katrā atkārtojumā samazina to par 1 un cilpo pārējo kodu, līdz i kļūst 0. Katrā iterācijā tiek izdrukāts pašreiz izpildāmā pavediena nosaukums un guļ gaidīšanas sekundes (ko arī ņem par argumentu).
- thread1 = threadtester (1, "Pirmais pavediens", 1)
Šeit mēs izveidojam pavedienu un nododam trīs parametrus, kurus mēs deklarējām __init__. Pirmais parametrs ir pavediena ID, otrais parametrs ir pavediena nosaukums, bet trešais parametrs ir skaitītājs, kas nosaka, cik reizes kamēr cilpa ir jāpalaiž.
- thread2.start ()
Sākuma metodi izmanto, lai sāktu pavediena izpildi. Iekšēji funkcija start () izsauc jūsu klases run () metodi.
- thread3.join ()
Join () metode bloķē cita koda izpildi un gaida, kamēr pavediens, uz kura to sauca, beidzas.
Kā jūs jau zināt, tajā pašā procesā esošajiem pavedieniem ir piekļuve šī procesa atmiņai un datiem. Rezultātā, ja vairāk nekā viena pavediena vienlaicīgi mēģina mainīt vai piekļūt datiem, var ielīst kļūdas.
Nākamajā sadaļā redzēsit dažāda veida sarežģījumus, kas var parādīties, kad pavedieni piekļūst datiem un kritiskajai sadaļai, nepārbaudot esošos piekļuves darījumus.
Strupceļi un sacīkšu apstākļi
Pirms uzzināt par strupceļiem un sacensību apstākļiem, būs noderīgi saprast dažas pamata definīcijas, kas saistītas ar vienlaicīgu programmēšanu:
- Kritiskā sadaļa
Tas ir koda fragments, kas piekļūst kopīgajiem mainīgajiem vai modificē tos, un tas jāveic kā atomu darījums.
- Konteksta slēdzis
Tas ir process, kuru CPU seko, lai saglabātu pavediena stāvokli pirms pārejas no viena uzdevuma uz otru, lai vēlāk to varētu atsākt no tā paša punkta.
Strupceļi
Strupceļš ir visbīstamākais jautājums, ar kuru izstrādātāji saskaras, rakstot vienlaicīgas / daudzšķiedru lietojumprogrammas pitonā. Labākais veids, kā izprast strupceļus, ir izmantot klasiskās datorzinātnes piemēra problēmu, kas pazīstama kā Ēdināšanas filozofu problēma.
Ēdināšanas filozofu problēmu izklāsts ir šāds:
Pieci filozofi ir apsēdušies uz apaļa galda ar piecām spageti plāksnēm (makaronu veids) un piecām dakšām, kā parādīts diagrammā.
Jebkurā brīdī filozofam ir vai nu jāēd, vai jādomā.
Turklāt, pirms viņš var ēst spageti, filozofam jāņem divas blakus esošās dakšas (ti, kreisā un labā dakša). Strupceļa problēma rodas, kad visi pieci filozofi vienlaikus paņem labās dakšas.
Tā kā katram no filozofiem ir viena dakša, viņi visi gaidīs, kamēr pārējie noliks dakšiņu. Rezultātā neviens no viņiem nevarēs ēst spageti.
Līdzīgi vienlaicīgā sistēmā strupceļš rodas, kad dažādi pavedieni vai procesi (filozofi) vienlaikus cenšas iegūt koplietojamos sistēmas resursus (dakšiņas). Rezultātā neviens no procesiem nesaņem iespēju tos izpildīt, jo viņi gaida citu resursu, kuru tur kāds cits process.
Sacensību apstākļi
Sacensību nosacījums ir nevēlams programmas stāvoklis, kas rodas, kad sistēma vienlaikus veic divas vai vairākas darbības. Piemēram, apsveriet šo vienkāršo cilpu:
i=0; # a global variablefor x in range(100):print(i)i+=1;
Ja izveidojat n pavedienu skaitu, kas palaiž šo kodu uzreiz, nevarat noteikt i vērtību (kuru dala pavedieni), kad programma pabeidz izpildi. Tas ir tāpēc, ka reālā daudzsavienojuma vidē pavedieni var pārklāties, un i vērtība, kuru izguva un modificēja pavediens, var mainīties starplaikā, kad tam piekļūst kāds cits pavediens.
Šīs ir divas galvenās problēmu klases, kas var rasties daudzlīniju vai izplatītā pitona lietojumprogrammā. Nākamajā sadaļā jūs uzzināsiet, kā pārvarēt šo problēmu, sinhronizējot pavedienus.
Sinhronizējot pavedienus
Lai risinātu sacensību apstākļus, strupceļus un citus ar pavedieniem saistītus jautājumus, pavedienu modulis nodrošina bloķēšanas objektu. Ideja ir tāda, ka tad, kad pavediens vēlas piekļūt konkrētam resursam, tas iegūst šī resursa slēdzeni. Kad pavediens ir bloķējis konkrētu resursu, neviens cits pavediens tam nevar piekļūt, kamēr bloķēšana nav atbrīvota. Tā rezultātā izmaiņas resursā būs atomu formas un tiks novērsti sacensību apstākļi.
Bloķēšana ir zema līmeņa sinhronizācijas primitīvs, ko ievieš modulis __thread . Jebkurā brīdī slēdzene var būt vienā no 2 stāvokļiem: bloķēta vai atbloķēta. Tas atbalsta divas metodes:
- iegūt ()
Kad bloķēšanas stāvoklis ir atbloķēts, izsaucot metodi iegūt (), stāvoklis tiks mainīts uz bloķētu un atgriezīsies. Tomēr, ja stāvoklis ir bloķēts, zvans iegūt () tiek bloķēts, līdz atbrīvošanas () metodi izsauc kāds cits pavediens.
- atbrīvot ()
Atbrīvošanas () metodi izmanto, lai iestatītu stāvokli atbloķētu, ti, atbrīvotu slēdzeni. To var izsaukt ar jebkuru pavedienu, ne vienmēr to, kas ieguva slēdzeni.
Šeit ir piemērs slēdzeņu izmantošanai jūsu lietotnēs. Aktivizējiet savu IDLE un ierakstiet šo:
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()
Tagad nospiediet F5. Jums vajadzētu redzēt šādu izvadi:
KODA PASKAIDROJUMS
- Šeit jūs vienkārši izveidojat jaunu bloķēšanu, izsaucot rūpnīcas funkciju threading.Lock () . Iekšēji Lock () atgriež visefektīvākās betona Lock klases eksemplāru, kuru uztur platforma.
- Pirmajā paziņojumā jūs iegūstat slēdzeni, izsaucot iegūšanas () metodi. Kad bloķēšana ir piešķirta, konsolē tiek izdrukāta “iegūtā slēdzene” . Kad viss kods, kuru vēlaties, lai pavediens darbotos, ir izpildīts, jūs atlaižat slēdzeni, izsaucot metodi release ().
Teorija ir laba, bet kā jūs zināt, ka slēdzene patiešām darbojās? Ja paskatās uz izvadi, redzēsiet, ka katrs no izdrukātajiem paziņojumiem vienlaikus drukā tieši vienu rindu. Atgādināsim, ka agrākā piemērā izejas no drukas ir nejaušas, jo vairākas pavedieni vienlaicīgi piekļuva metodei print (). Šeit drukas funkcija tiek izsaukta tikai pēc tam, kad ir iegūta slēdzene. Tātad, rezultāti tiek parādīti pa vienam un pa rindai.
Papildus slēdzenēm pitons atbalsta arī dažus citus mehānismus, lai apstrādātu pavedienu sinhronizāciju, kā norādīts zemāk:
- RLocks
- Semaforas
- Nosacījumi
- Notikumi un
- Barjeras
Globālā tulka bloķēšana (un kā ar to rīkoties)
Pirms iedziļināties python GIL detaļās, definēsim dažus terminus, kas būs noderīgi, lai izprastu gaidāmo sadaļu:
- Ar CPU saistīts kods: tas attiecas uz jebkuru koda daļu, kuru tieši izpildīs CPU.
- I / O piesaistīts kods: tas var būt jebkurš kods, kas piekļūst failu sistēmai, izmantojot OS
- CPython: tā ir Python atsauces ieviešana , un to var raksturot kā tulku, kas rakstīts C un Python (programmēšanas valodā).
Kas ir GIL Python?
Globālā tulka bloķēšana (GIL) pitonā ir procesa bloķēšana vai muteks, ko izmanto, strādājot ar procesiem. Tas nodrošina, ka viens pavediens vienlaikus var piekļūt konkrētam resursam, kā arī novērš objektu un baitkodu izmantošanu vienlaikus. Tas dod labumu vienpavedienu programmām, palielinot veiktspēju. GIL pitonā ir ļoti vienkārša un viegli īstenojama.
Bloķēšanu var izmantot, lai pārliecinātos, ka tikai vienam pavedienam ir piekļuve noteiktam resursam noteiktā laikā.
Viena no Python iezīmēm ir tā, ka katram tulka procesam tā izmanto globālo bloķēšanu, kas nozīmē, ka katrs process pats pitona tulku uzskata par resursu.
Piemēram, pieņemsim, ka esat uzrakstījis pitona programmu, kas izmanto divus pavedienus, lai veiktu gan centrālā procesora, gan 'I / O' darbības. Izpildot šo programmu, notiek šādi:
- Pitona tulks izveido jaunu procesu un nārsto pavedienus
- Kad 1. pavediens sāk darboties, tas vispirms iegūs GIL un bloķēs to.
- Ja thread-2 vēlas izpildīt tagad, tai būs jāgaida GIL izlaišana, pat ja cits procesors ir brīvs.
- Pieņemsim, ka 1. pavediens gaida I / O darbību. Šajā laikā tas atbrīvos GIL, un thread-2 to iegūs.
- Pēc I / O opciju pabeigšanas, ja thread-1 vēlas izpildīt tagad, tai atkal būs jāgaida, kamēr GIL atbrīvos thread-2.
Sakarā ar to tulkotājam jebkurā laikā var piekļūt tikai viens pavediens, tas nozīmē, ka noteiktā brīdī būs tikai viens pavediens, kas izpilda pitona kodu.
Viena kodola procesorā tas ir labi, jo pavedienu apstrādei tas izmantotu laika sagriešanu (skat. Šīs apmācības pirmo sadaļu). Tomēr daudzkodolu procesoru gadījumā ar CPU saistītai funkcijai, kas tiek izpildīta vairākos pavedienos, būs ievērojama ietekme uz programmas efektivitāti, jo tā faktiski neizmantos visus pieejamos kodolus vienlaikus.
Kāpēc vajadzēja GIL?
Atkritumu savācējs CPython izmanto efektīvu atmiņas pārvaldības paņēmienu, kas pazīstams kā atsauces skaitīšana. Tas darbojas šādi: Katram pitona objektam ir atsauču skaits, kas tiek palielināts, kad tas tiek piešķirts jaunam mainīgā nosaukumam vai tiek pievienots konteineram (piemēram, kopas, saraksti utt.). Tāpat atsauču skaits tiek samazināts, kad atsauce iziet no darbības jomas vai tiek izsaukts del priekšraksts. Kad objekta atskaites skaits sasniedz 0, tiek savākti atkritumi un atbrīvota atvēlētā atmiņa.
Bet problēma ir tā, ka atsauces skaita mainīgais ir pakļauts sacensību apstākļiem, tāpat kā jebkurš cits globālais mainīgais. Lai atrisinātu šo problēmu, pitona izstrādātāji nolēma izmantot globālo tulka bloķēšanu. Otra iespēja bija katram objektam pievienot slēdzeni, kas būtu izraisījusi strupceļus un palielinātu pieskaitāmo daļu no iegādes () un atbrīvošanas () zvaniem.
Tāpēc GIL ir ievērojams ierobežojums daudzlīniju pitonu programmām, kurās darbojas smagas ar CPU saistītas darbības (faktiski padarot tās par vienvītnēm). Ja vēlaties savā lietojumprogrammā izmantot vairākus CPU kodolus, tā vietā izmantojiet daudzapstrādes moduli.
Kopsavilkums
- Python atbalsta 2 moduļus daudzsavienošanai:
- __thread modulis: tas nodrošina zema līmeņa ieviešanu pavedieniem un ir novecojis.
- vītņu modulis : tas nodrošina augsta līmeņa ieviešanu daudzsavienošanai un ir pašreizējais standarts.
- Lai izveidotu pavedienu, izmantojot pavedienu moduli, jums jādara šādi:
- Izveidojiet klasi, kas paplašina Thread klasi.
- Ignorēt tā konstruktoru (__init__).
- Ignorēt tā run () metodi.
- Izveidojiet šīs klases objektu.
- Vītni var izpildīt, izsaucot metodi start () .
- Pievienoties () metodi var izmantot, lai bloķētu citus pavedienus, kamēr šo pavedienu (vienu, uz kura pievienojas sauca) apdari izpildi.
- Sacensību nosacījums rodas, ja vairāki pavedieni vienlaikus piekļūst vai modificē koplietojamo resursu.
- To var izvairīties, sinhronizējot pavedienus.
- Python atbalsta 6 veidus, kā sinhronizēt pavedienus:
- Slēdzenes
- RLocks
- Semaforas
- Nosacījumi
- Notikumi un
- Barjeras
- Slēdzenes ļauj kritiskajā sadaļā iekļūt tikai noteiktam pavedienam, kurš ir ieguvis slēdzeni.
- Bloķētājam ir 2 galvenās metodes:
- iegūt () : tiek iestatīts bloķēšanas stāvoklis . Ja tiek izsaukts uz bloķēta objekta, tas tiek bloķēts, līdz resurss ir brīvs.
- atbrīvot () : tas nosaka bloķēšanas stāvokli atbloķētam un atgriežas. Ja tiek izsaukts uz atbloķētu objektu, tas atgriež false.
- Globālā tulka bloķēšana ir mehānisms, ar kuru vienlaikus var izpildīt tikai 1 CPython tulka procesu.
- To izmantoja, lai atvieglotu CPythons atkritumu savācēja atskaites skaitīšanas funkcionalitāti.
- Lai izveidotu Python lietotnes ar smagām ar CPU saistītām darbībām, jums jāizmanto daudzapstrādes modulis.