Monisäikeinen sisään Python Esimerkki: Opi GIL sisään Python

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

Mikä on säiettä?

Säie on samanaikaisen ohjelmoinnin suoritusyksikkö. Multithreading on tekniikka, jonka avulla CPU voi suorittaa useita yhden prosessin tehtäviä samanaikaisesti. Nämä säikeet voidaan suorittaa yksitellen samalla, kun ne jakavat prosessiresurssejaan.

Mikä on prosessi?

Prosessi on pohjimmiltaan suoritettava ohjelma. Kun käynnistät sovelluksen tietokoneellasi (kuten selaimen tai tekstieditorin), käyttöjärjestelmä luo a prosessiin.

Mikä on monisäikeistys Python?

Monisäikeinen sisään Python ohjelmointi on hyvin tunnettu tekniikka, jossa useat prosessin säikeet jakavat tietotilansa pääsäikeen kanssa, mikä tekee tiedon jakamisesta ja viestinnän säikeiden sisällä helpoksi ja tehokkaaksi. Langat ovat kevyempiä kuin prosessit. Useita säikeitä voidaan suorittaa yksitellen samalla, kun ne jakavat prosessiresurssejaan. Monisäikeistyksen tarkoitus on suorittaa useita tehtäviä ja funktiosoluja samanaikaisesti.

Mitä on monikäsittely?

multiprocessing voit suorittaa useita toisiinsa liittymättömiä prosesseja samanaikaisesti. Nämä prosessit eivät jaa resurssejaan ja kommunikoi IPC:n kautta.

Python Monisäikeinen vs. moniprosessointi

Jos haluat ymmärtää prosesseja ja säikeitä, harkitse seuraavaa tilannetta: Tietokoneessasi oleva .exe-tiedosto on ohjelma. Kun avaat sen, käyttöjärjestelmä lataa sen muistiin ja suoritin suorittaa sen. Ohjelman esiintymää, joka on nyt käynnissä, kutsutaan prosessiksi.

Jokaisessa prosessissa on kaksi perusosaa:

• Koodi
• Tiedot

Nyt prosessi voi sisältää yhden tai useamman aliosan nimeltä kierteet. Tämä riippuu käyttöjärjestelmän arkkitehtuurista. Voit ajatella säiettä osana prosessia, jonka käyttöjärjestelmä voi suorittaa erikseen.

Toisin sanoen se on ohjevirta, jota käyttöjärjestelmä voi suorittaa itsenäisesti. Yhden prosessin säikeet jakavat prosessin tiedot, ja ne on suunniteltu toimimaan yhdessä rinnakkaisuuden edistämiseksi.

Miksi käyttää Multithreadingiä?

Monisäikeistyksen avulla voit jakaa sovelluksen useisiin alitehtäviin ja suorittaa nämä tehtävät samanaikaisesti. Jos käytät monisäikeistystä oikein, sovelluksesi nopeutta, suorituskykyä ja renderöintiä voidaan parantaa.

Python Multithreading

Python tukee sekä moniprosessointia että monisäierakennetta. Tässä opetusohjelmassa keskityt ensisijaisesti toteuttamiseen monisäikeinen sovellukset pythonilla. On olemassa kaksi päämoduulia, joita voidaan käyttää säikeiden käsittelemiseen Python:

1. - kierre moduuli ja
2. - ketjuttaminen moduuli

Pythonissa on kuitenkin myös jotain, jota kutsutaan globaaliksi tulkin lukitukseksi (GIL). Se ei salli paljon suorituskyvyn lisäystä ja voi jopa olla vähentää joidenkin monisäikeisten sovellusten suorituskykyä. Opit siitä kaiken tämän opetusohjelman tulevissa osissa.

Thread- ja Threading-moduulit

Kaksi moduulia, joista opit tässä opetusohjelmassa, ovat kierremoduuli ja kierteitysmoduuli.

Lankamoduuli on kuitenkin vanhentunut pitkään. alkaen Python 3, se on merkitty vanhentuneeksi ja siihen pääsee vain nimellä __lanka taaksepäin yhteensopivuuden vuoksi.

Sinun pitäisi käyttää korkeampaa tasoa ketjuttaminen moduuli sovelluksille, jotka aiot ottaa käyttöön. Lankamoduuli on käsitelty tässä vain koulutustarkoituksiin.

Lankamoduuli

Syntaksi uuden säikeen luomiseksi tällä moduulilla on seuraava:

thread.start_new_thread(function_name, arguments)

Selvä, nyt olet käynyt läpi perusteorian aloittaaksesi koodauksen. Joten, avaa omasi IDLE tai muistilehtiö ja kirjoita seuraava:

import time
import _thread

def thread_test(name, wait):
   i = 0
   while i <= 3:
      time.sleep(wait)
      print("Running %s\n" %name)
      i = i + 1

   print("%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 käynnistääksesi ohjelman. Jos kaikki tehtiin oikein, sinun pitäisi nähdä tämä tulos:

Saat lisätietoja kilpailuolosuhteista ja niiden käsittelystä tulevissa osioissa

KOODIN SELITYS

1. Nämä käskyt tuovat aika- ja säiemoduulin, joita käytetään suorittamaan ja viivästymään Python kierteet.
2. Tässä olet määrittänyt funktion nimeltä thread_test, jota kutsutaan nimellä aloita_uusi_ketju menetelmä. Funktio suorittaa while-silmukan neljän iteroinnin ajan ja tulostaa sen kutsuneen säikeen nimen. Kun iteraatio on valmis, se tulostaa viestin, jossa sanotaan, että säiettä on suoritettu loppuun.
3. Tämä on ohjelmasi pääosa. Täällä voit vain soittaa aloita_uusi_ketju menetelmän kanssa thread_test funktio argumenttina. Tämä luo uuden säikeen argumenttina antamallesi funktiolle ja aloittaa sen suorittamisen. Huomaa, että voit korvata tämän (säie_testi) minkä tahansa muun funktion kanssa, jonka haluat suorittaa säietenä.

Langoitusmoduuli

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

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

Toiminnon nimi	Tuotetiedot
ActiveCount()	Palauttaa määrän Kierre esineitä, jotka ovat vielä elossa
nykyinen säie()	Palauttaa Thread-luokan nykyisen objektin.
luetella()	Luetteloi kaikki aktiiviset säikeen objektit.
isDaemon()	Palauttaa tosi, jos säie on demoni.
on elossa()	Palauttaa tosi, jos lanka on vielä elossa.
	Säieluokan menetelmät
alkaa()	Käynnistää säikeen toiminnan. Sitä on kutsuttava vain kerran jokaiselle säikeelle, koska se aiheuttaa ajonaikaisen virheen, jos sitä kutsutaan useita kertoja.
juosta()	Tämä menetelmä ilmaisee säikeen toimintaa, ja sen voi ohittaa luokka, joka laajentaa säikeen luokkaa.
liittyä seuraan()	Se estää muun koodin suorittamisen, kunnes säie, jossa join()-menetelmää kutsuttiin, lopetetaan.

Taustatarina: The Thread Class

Ennen kuin aloitat monisäikeisten ohjelmien koodaamisen ketjutusmoduulilla, on tärkeää ymmärtää Thread-luokka. Säieluokka on ensisijainen luokka, joka määrittelee mallin ja säikeen toiminnot pythonissa.

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

Yhteenvetona Thread-luokka merkitsee koodisekvenssiä, joka suoritetaan erillisenä kierre hallintaan.

Joten, kun kirjoitat monisäikeistä sovellusta, teet seuraavaa:

1. Määritä luokka, joka laajentaa säikeen luokkaa
2. Ohita __init__ rakentaja
3. Ohita juosta() menetelmä

Kun lankaobjekti on tehty, alkaa() menetelmällä voidaan aloittaa tämän toiminnon suorittaminen ja liittyä seuraan() -menetelmää voidaan käyttää estämään kaikki muu koodi, kunnes nykyinen toiminta on päättynyt.

Yritetään nyt käyttää ketjutusmoduulia edellisen esimerkkisi toteuttamiseen. Sytytä uudelleen IDLE ja kirjoita seuraava:

import time
import threading

class threadtester (threading.Thread):
    def __init__(self, id, name, i):
       threading.Thread.__init__(self)
       self.id = id
       self.name = name
       self.i = i
       
    def 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 - 1

if __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:

KOODIN SELITYS

1. Tämä osa on sama kuin edellinen esimerkkimme. Täällä tuot aika- ja säiemoduulin, joita käytetään käsittelemään suorituksen ja viiveet Python kierteet.
2. Tässä bitissä luot luokan nimeltä threadtester, joka perii tai laajentaa Kierre kierteitysmoduulin luokkaa. Tämä on yksi yleisimmistä tavoista luoda säikeitä pythonissa. Sinun tulisi kuitenkin ohittaa vain rakentaja ja juosta() menetelmää sovelluksessasi. Kuten yllä olevasta koodinäytteestä näet, __init__ menetelmä (konstruktori) on ohitettu. Samoin olet myös ohittanut juosta() menetelmä. Se sisältää koodin, jonka haluat suorittaa säikeen sisällä. Tässä esimerkissä olet kutsunut thread_test()-funktiota.
3. Tämä on thread_test()-metodi, joka ottaa arvon i argumenttina pienentää sitä 1:llä kussakin iteraatiossa ja kiertää loput koodista, kunnes i:stä tulee 0. Jokaisessa iteraatiossa se tulostaa parhaillaan suoritettavan säikeen nimen ja nukkuu sekuntia (mitä pidetään myös argumenttina ).
4. thread1 = threadtester(1, "First Thread", 1) Tässä luomme säiettä ja välitämme kolme parametria, jotka määritimme __init__:ssa. Ensimmäinen parametri on säikeen id, toinen parametri on säikeen nimi ja kolmas parametri on laskuri, joka määrittää kuinka monta kertaa while-silmukan tulee suorittaa.
5. thread2.start()T aloitusmenetelmää käytetään säikeen suorittamisen aloittamiseen. Sisäisesti start()-funktio kutsuu luokkasi run()-metodia.
6. thread3.join() Join()-metodi estää muun koodin suorittamisen ja odottaa, kunnes säie, jossa sitä kutsuttiin, päättyy.

Kuten jo tiedät, samassa prosessissa olevilla säikeillä on pääsy prosessin muistiin ja tietoihin. Tämän seurauksena, jos useampi kuin yksi säie yrittää muuttaa tai käyttää tietoja samanaikaisesti, virheitä saattaa hiipiä sisään.

Seuraavassa osiossa näet erilaisia ​​​​komplikaatioita, joita voi ilmetä, kun säikeet käyttävät tietoja ja kriittistä osaa tarkistamatta olemassa olevia käyttötapahtumia.

Umpikujat ja kilpailuolosuhteet

Ennen kuin opit umpikujasta ja kilpailuolosuhteista, on hyödyllistä ymmärtää muutama samanaikaiseen ohjelmointiin liittyvä perusmääritelmä:

• Kriittinen osaSe on koodinpätkä, joka käyttää tai muokkaa jaettuja muuttujia ja joka on suoritettava atomitapahtumana.
• Context SwitchSe on prosessi, jota CPU seuraa säikeen tilan tallentamiseksi ennen siirtymistä tehtävästä toiseen, jotta sitä voidaan jatkaa samasta kohdasta myöhemmin.

Umpikujasta

Umpikujasta 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 esimerkkiongelmaa, joka tunnetaan nimellä Ruokaa Philosophers Ongelma.

Ruokailufilosofien ongelmanratkaisu on seuraava:

Viisi filosofia istuu pyöreällä pöydällä, jossa on viisi lautasta spagettia (eräänlainen pasta) ja viisi haarukkaa, kuten kaaviossa näkyy.

Filosofin täytyy milloin tahansa joko syödä tai ajatella.

Lisäksi filosofin on otettava kaksi vierekkäistä haarukkaa (eli vasen ja oikea haarukka), ennen kuin hän voi syödä spagettia. Umpikujaongelma syntyy, kun kaikki viisi filosofia poimivat oikeat haarukat samanaikaisesti.

Koska jokaisella filosofeilla on yksi haarukka, he kaikki odottavat, että muut laskevat haarukkansa alas. Tämän seurauksena kukaan heistä ei voi syödä spagettia.

Vastaavasti samanaikaisessa järjestelmässä lukkiutuminen tapahtuu, kun eri säikeet tai prosessit (filosofit) yrittävät hankkia jaetut järjestelmäresurssit (haarukat) samanaikaisesti. Tämän seurauksena yksikään prosesseista ei saa mahdollisuutta suorittaa, koska ne odottavat toista resurssia, joka on jonkin muun prosessin hallussa.

Kilpailun ehdot

Kilpailutila on ohjelman ei-toivottu tila, joka tapahtuu, kun järjestelmä suorittaa kaksi tai useampaa toimintoa samanaikaisesti. Harkitse esimerkiksi tätä yksinkertaista silmukkaa:

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

Jos luot n Säikeiden lukumäärä, jotka suorittavat tämän koodin kerralla, et voi määrittää i:n arvoa (jonka säikeet jakavat), kun ohjelma lopettaa suorituksen. Tämä johtuu siitä, että todellisessa monisäikeisessä ympäristössä säikeet voivat mennä päällekkäin, ja säikeen hakeman ja muokkaaman i:n arvo voi muuttua välillä, kun jokin muu säie käyttää sitä.

Nämä ovat kaksi pääasiallista ongelmaluokkaa, joita voi esiintyä monisäikeisessä tai hajautetussa python-sovelluksessa. Seuraavassa osiossa opit ratkaisemaan tämän ongelman synkronoimalla säikeitä.

Synchronisoivat langat

Pujotusmoduuli tarjoaa kilpailuolosuhteiden, umpikujan ja muiden lankaan perustuvien ongelmien ratkaisemiseksi Lukita esine. Ajatuksena on, että kun säie haluaa pääsyn tiettyyn resurssiin, se hankkii lukon tälle resurssille. Kun lanka lukitsee tietyn resurssin, mikään muu säie ei voi käyttää sitä ennen kuin lukko vapautetaan. Tämän seurauksena muutokset resurssissa ovat ydinaseita ja kilpailuolosuhteet vältetään.

Lukko on matalan tason synkronointiprimitiivi, jonka on toteuttanut __lanka moduuli. Koska tahansa lukko voi olla jossakin kahdesta tilasta: lukittu or lukitsematon. Se tukee kahta menetelmää:

1. hankkia()Kun lock-state on lukitsematon, hanki()-menetelmän kutsuminen muuttaa tilan lukituksi ja palaa. Jos tila on kuitenkin lukittu, hanki()-kutsu estetään, kunnes jokin muu säie kutsuu release()-menetelmää.
2. vapauttaa ()Release()-menetelmää käytetään asettamaan tila lukitsemattomaksi, eli vapauttamaan lukko. Sitä voi kutsua mikä tahansa lanka, ei välttämättä se, joka hankki lukon.

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

import threading
lock = 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()

Paina nyt F5. Sinun pitäisi nähdä seuraavanlainen tulos:

KOODIN SELITYS

1. Tässä luot vain uuden lukon soittamalla numeroon ketjutus.Lukko() tehdastoiminto. Sisäisesti Lock() palauttaa tehokkaimman konkreettisen Lock-luokan esiintymän, jota alusta ylläpitää.
2. Ensimmäisessä lauseessa hankit lukon kutsumalla hanki()-menetelmää. Kun lukko on myönnetty, tulostat "lukko hankittu" konsoliin. Kun kaikki koodi, jonka haluat ketjun suorittavan, on suoritettu, vapautat lukon kutsumalla release()-menetelmää.

Teoria on hyvä, mutta mistä tiedät, että lukko todella toimi? Jos katsot tulosta, näet, että jokainen tulostuslause tulostaa täsmälleen yhden rivin kerrallaan. Muista, että aikaisemmassa esimerkissä printin tulosteet olivat 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 säikeiden synkronoinnin käsittelemiseksi, kuten alla on lueteltu:

1. RLukot
2. Semaphores
3. olosuhteet
4. Tapahtumat ja
5. Esteet

Global Interpreter Lock (ja kuinka käsitellä sitä)

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

1. CPU-sidottu koodi: tämä viittaa mihin tahansa koodin osaan, 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 viite täytäntöönpano of Python ja sitä voidaan kuvata C- ja kielellä kirjoitettuna tulkkina Python (ohjelmointikieli).

Lukkoa voidaan käyttää varmistamaan, että vain yhdellä säikeellä on pääsy tiettyyn resurssiin tiettynä aikana.

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

Oletetaan esimerkiksi, että olet kirjoittanut python-ohjelman, joka käyttää kahta säiettä suorittimen ja I/O-toimintojen suorittamiseen. Kun suoritat tämän ohjelman, tapahtuu seuraavaa:

1. Python-tulkki luo uuden prosessin ja synnyttää säikeet
2. Kun säie-1 käynnistyy, se hankkii ensin GIL:n ja lukitsee sen.
3. Jos säie-2 haluaa suorittaa nyt, sen on odotettava GIL:n julkaisua, vaikka toinen prosessori olisi vapaa.
4. Oletetaan nyt, että säie-1 odottaa I/O-toimintoa. Tällä hetkellä se vapauttaa GIL:n ja säie-2 hankkii sen.
5. I/O-operaatioiden suorittamisen jälkeen, jos säie-1 haluaa suorittaa nyt, sen on jälleen odotettava GIL:n vapauttamista säiettä-2:lla.

Tästä johtuen vain yksi säie voi käyttää tulkkia kerrallaan, mikä tarkoittaa, että python-koodia suorittava säie on tietyllä hetkellä vain yksi.

Tämä on kunnossa yhden ytimen prosessorissa, koska se käyttäisi aikaleikkausta (katso tämän opetusohjelman ensimmäinen osa) säikeiden käsittelemiseen. Kuitenkin moniytimisissä prosessoreissa suorittimeen sidottu toiminto, joka suoritetaan useissa säikeissä, vaikuttaa huomattavasti ohjelman tehokkuuteen, koska se ei itse asiassa käytä kaikkia saatavilla olevia ytimiä samanaikaisesti.

Miksi GIL:ää tarvittiin?

CPython roskienkerääjä käyttää tehokasta muistinhallintatekniikkaa, joka tunnetaan nimellä viitelaskenta. Näin se toimii: Jokaisella python-objektilla on viitemäärä, joka kasvaa, kun sille annetaan uusi muuttujan nimi tai se lisätään säilöön (kuten monikot, luettelot jne.). Samoin viitemäärää pienennetään, kun viite menee soveltamisalan ulkopuolelle tai kun del-käskyä kutsutaan. Kun kohteen viiteluku saavuttaa 0:n, se kerätään roskat ja varattu muisti vapautetaan.

Mutta ongelmana on, että viitemäärämuuttuja on altis kilpailuolosuhteille, kuten mikä tahansa muu globaali muuttuja. Tämän ongelman ratkaisemiseksi pythonin kehittäjät päättivät käyttää globaalia tulkin lukitusta. Toinen vaihtoehto oli lisätä lukko jokaiseen objektiin, mikä olisi johtanut lukkiutumiseen ja lisännyt hankinta()- ja release()-kutsujen ylimääräisiä kustannuksia.

Siksi GIL on merkittävä rajoitus monisäikeisille python-ohjelmille, jotka suorittavat raskaita suorittimeen sidottuja operaatioita (tekeen niistä tehokkaasti yksisäikeisiä). Jos haluat käyttää useita CPU-ytimiä sovelluksessasi, käytä monikäsittely moduuli sen sijaan.

Yhteenveto

• Python tukee 2 moduulia monisäikeistykseen:
  1. __lanka moduuli: Se tarjoaa matalan tason toteutuksen ketjutusta varten ja on vanhentunut.
  2. kierteitysmoduuli: Se tarjoaa korkean tason toteutuksen monisäikeistykseen ja on nykyinen standardi.
• Jos haluat luoda säikeen ketjutusmoduulilla, sinun on toimittava seuraavasti:
  1. Luo luokka, joka laajentaa Kierre luokka.
  2. Ohita sen rakentaja (__init__).
  3. Ohita se juosta() menetelmällä.
  4. Luo tämän luokan objekti.
• Säie voidaan suorittaa kutsumalla alkaa() menetelmällä.
• - liittyä seuraan() -menetelmää voidaan käyttää estämään muut säikeet, kunnes tämä säie (join liittyminen kutsuttiin) suorittaa suorituksen loppuun.
• Kilpailutilanne syntyy, kun useat säikeet käyttävät tai muokkaavat jaettua resurssia samanaikaisesti.
• Se voidaan välttää käyttämällä Synchronisoivat langat.
• Python tukee 6 tapaa synkronoida säikeitä:
  1. Lukot
  2. RLukot
  3. Semaphores
  4. olosuhteet
  5. Tapahtumat ja
  6. Esteet
• Lukot sallivat vain tietyn lukon saaneen langan pääsyn kriittiseen osaan.
• Lukolla on kaksi ensisijaista tapaa:
  1. hankkia(): Se asettaa lukitustilan lukittu. Jos sitä kutsutaan lukitulle objektille, se estää, kunnes resurssi on vapaa.
  2. vapauttaa (): Se asettaa lukitustilan auki ja palaa. Jos sitä kutsutaan lukitsemattomalle objektille, se palauttaa epätosi.
• Globaali tulkin lukko on mekanismi, jonka kautta vain 1 CPython tulkkiprosessi voidaan suorittaa kerrallaan.
• Sitä käytettiin helpottamaan C:n viitelaskentatoimintoaPythons:n roskakoriin.
• Jotta Python sovelluksissa, joissa on raskaita suorittimeen sidottuja toimintoja, sinun tulee käyttää moniprosessointimoduulia.