Tämä artikkeli kattaa Python-ohjelmointikielen monisäikeisyyden perusteet. Ihan kuin monikäsittely , monisäikeisyys on tapa saavuttaa moniajo. Monisäikeisessä käsite langat käytetään. Ymmärrämme ensin käsitteen lanka tietokonearkkitehtuurissa.
Mikä on prosessi Pythonissa?
Tietojenkäsittelyssä a käsitellä asiaa on ilmentymä suoritettavasta tietokoneohjelmasta. Jokaisessa prosessissa on 3 peruskomponenttia:
- Suoritettava ohjelma.
- Ohjelman tarvitsemat liittyvät tiedot (muuttujat, työtila, puskurit jne.)
- Ohjelman suorituskonteksti (prosessin tila)
Johdatus Python-ketjuun
A lanka on prosessin kokonaisuus, joka voidaan ajastaa suoritettavaksi. Se on myös pienin käsittelyyksikkö, joka voidaan suorittaa käyttöjärjestelmässä (käyttöjärjestelmässä). Yksinkertaisesti sanottuna säie on tällaisten ohjeiden sarja ohjelman sisällä, joka voidaan suorittaa muusta koodista riippumatta. Yksinkertaisuuden vuoksi voit olettaa, että säie on yksinkertaisesti prosessin osajoukko! Säie sisältää kaikki nämä tiedot kohdassa a Kierteen ohjauslohko (TCB) :
java while-silmukka
- Viestiketjun tunniste: Yksilöllinen tunnus (TID) määritetään jokaiselle uudelle säikeelle
- Pinoosoitin: Osoittaa säikeen pinoon prosessissa. Pino sisältää paikalliset muuttujat säikeen laajuudessa.
- Ohjelmalaskuri: rekisteri, joka tallentaa säikeen parhaillaan suorittaman käskyn osoitteen.
- Säikeen tila: voi olla käynnissä, valmis, odottaa, käynnistyä tai valmis.
- Säikeen rekisterisarja: lankaan määrätyt rekisterit laskelmia varten.
- Vanhemman prosessin osoitin: Osoitin prosessin ohjauslohkoon (PCB), jossa säie elää.
Harkitse alla olevaa kaaviota ymmärtääksesi prosessin ja sen säikeen välisen suhteen:
Prosessin ja sen säikeen välinen suhde
Yhdessä prosessissa voi olla useita säikeitä, joissa:
- Jokainen lanka sisältää omansa rekisterisetti ja paikalliset muuttujat (tallennettu pinoon) .
- Prosessin kaikki säikeet jakavat globaalit muuttujat (tallennettu kasaan) ja ohjelmakoodi .
Harkitse alla olevaa kaaviota ymmärtääksesi kuinka useita säikeitä on muistissa:
Useiden säikeiden olemassaolo muistissa
Johdatus ketjutukseen Pythonissa
Monisäikeinen määritellään prosessorin kyvyksi suorittaa useita säikeitä samanaikaisesti. Yksinkertaisessa yhden ytimen suorittimessa se saavutetaan käyttämällä toistuvaa vaihtoa säikeiden välillä. Tätä kutsutaan nimellä kontekstin vaihtaminen . Kontekstivaihdossa säikeen tila tallennetaan ja toisen säikeen tila ladataan aina, kun jokin keskeytys (I/O:sta tai manuaalisesti asetetusta syystä) tapahtuu. Kontekstin vaihtaminen tapahtuu niin usein, että kaikki säikeet näyttävät kulkevan rinnakkain (tätä kutsutaan nimellä moniajo ).
Tarkastellaan alla olevaa kaaviota, jossa prosessi sisältää kaksi aktiivista säiettä:
Monisäikeinen
Monisäikeistys Pythonissa
Sisään Python , langoitus moduuli tarjoaa erittäin yksinkertaisen ja intuitiivisen API:n useiden säikeiden luomiseen ohjelmaan. Yritetään ymmärtää monisäikeinen koodi askel askeleelta.
Vaihe 1: Tuo moduuli
Tuo ensin langoitusmoduuli.
import threading>
Vaihe 2: Luo ketju
Uuden säikeen luomiseksi luomme objektin Lanka luokkaa. Se ottaa 'kohde' ja 'argumentit' parametreina. The kohde on säikeen suorittama toiminto, kun taas args on kohdefunktiolle välitettävät argumentit.
t1 = threading.Thread(target, args) t2 = threading.Thread(target, args)>
Vaihe 3: Aloita ketju
Aloitaksesi ketjun käytämme alkaa() Thread-luokan menetelmä.
t1.start() t2.start()>
Vaihe 4: Lopeta ketjun suoritus
Kun säikeet alkavat, myös nykyinen ohjelma (voit ajatella sitä pääsäikeenä) jatkaa myös suorittamista. Pysäytäksemme nykyisen ohjelman suorittamisen, kunnes säie on valmis, käytämme liittyä seuraan() menetelmä.
t1.join() t2.join()>
Tämän seurauksena nykyinen ohjelma odottaa ensin ohjelman valmistumista t1 ja sitten t2 . Kun ne on suoritettu, nykyisen ohjelman loput käskyt suoritetaan.
Esimerkki:
Tarkastellaan yksinkertaista esimerkkiä kierteitysmoduulin avulla.
Tämä koodi osoittaa, kuinka Pythonin ketjutusmoduulia käytetään laskemaan luvun neliö ja kuutio samanaikaisesti. Kaksi lankaa, t1> ja t2> , luodaan näiden laskelmien suorittamista varten. Ne käynnistetään ja niiden tulokset tulostetaan rinnakkain ennen kuin ohjelma tulostaa Valmis! kun molemmat langat ovat päättyneet. Säikeistystä käytetään rinnakkaisuuden saavuttamiseen ja ohjelman suorituskyvyn parantamiseen, kun käsitellään laskennallisesti vaativia tehtäviä.
Python 3
import> threading> def> print_cube(num):> >print>(>'Cube: {}'> .>format>(num>*> num>*> num))> def> print_square(num):> >print>(>'Square: {}'> .>format>(num>*> num))> if> __name__>=>=>'__main__'>:> >t1>=> threading.Thread(target>=>print_square, args>=>(>10>,))> >t2>=> threading.Thread(target>=>print_cube, args>=>(>10>,))> >t1.start()> >t2.start()> >t1.join()> >t2.join()> >print>(>'Done!'>)> |
rivi vs sarake
>
>
Lähtö:
Square: 100 Cube: 1000 Done!>
Tarkastele alla olevaa kaaviota saadaksesi paremman käsityksen yllä olevan ohjelman toiminnasta:
matriisin viipalointi java
Monisäikeinen
Esimerkki:
Tässä esimerkissä käytämme os.getpid() toiminto saada nykyisen prosessin tunnus. Käytämme threading.main_thread() funktio saada pääsäieobjekti. Normaaleissa olosuhteissa pääsäie on säie, josta Python-tulkki käynnistettiin. nimi säiettäobjektin attribuuttia käytetään säikeen nimen saamiseksi. Sitten käytämme threading.current_thread() funktio hakeaksesi nykyisen säikeen objektin.
Harkitse alla olevaa Python-ohjelmaa, jossa tulostetaan säikeen nimi ja vastaava prosessi jokaiselle tehtävälle.
Tämä koodi osoittaa, kuinka Pythonin ketjutusmoduulia käytetään kahden tehtävän suorittamiseen samanaikaisesti. Pääohjelma käynnistää kaksi säiettä, t1> ja t2> , joista jokainen on vastuussa tietyn tehtävän suorittamisesta. Säikeet kulkevat rinnakkain, ja koodi antaa tietoa prosessin tunnuksesta ja säikeiden nimistä. Theos>moduulia käytetään pääsyyn prosessitunnukseen ja ' threading'> moduulia käytetään säikeiden ja niiden suoritusten hallintaan.
Python 3
import> threading> import> os> def> task1():> >print>(>'Task 1 assigned to thread: {}'>.>format>(threading.current_thread().name))> >print>(>'ID of process running task 1: {}'>.>format>(os.getpid()))> def> task2():> >print>(>'Task 2 assigned to thread: {}'>.>format>(threading.current_thread().name))> >print>(>'ID of process running task 2: {}'>.>format>(os.getpid()))> if> __name__>=>=> '__main__'>:> >print>(>'ID of process running main program: {}'>.>format>(os.getpid()))> >print>(>'Main thread name: {}'>.>format>(threading.current_thread().name))> >t1>=> threading.Thread(target>=>task1, name>=>'t1'>)> >t2>=> threading.Thread(target>=>task2, name>=>'t2'>)> >t1.start()> >t2.start()> >t1.join()> >t2.join()> |
>
>
Lähtö:
ID of process running main program: 1141 Main thread name: MainThread Task 1 assigned to thread: t1 ID of process running task 1: 1141 Task 2 assigned to thread: t2 ID of process running task 2: 1141>
Alla oleva kaavio selventää yllä olevan käsitteen:
Monisäikeinen
Joten tämä oli lyhyt johdatus Pythonin monisäikeiseen käyttöön. Seuraava artikkeli tässä sarjassa kattaa synkronointi useiden säikeiden välillä . Monisäikeisyys Pythonissa | Sarja 2 (synkronointi)
Python ThreadPool
Säiepooli on kokoelma säikeitä, jotka on luotu etukäteen ja joita voidaan käyttää uudelleen useiden tehtävien suorittamiseen. Pythonin concurrent.futures-moduuli tarjoaa ThreadPoolExecutor-luokan, jonka avulla säievalikoiman luominen ja hallinta on helppoa.
Tässä esimerkissä määritämme funktiotyöntekijän, joka suoritetaan säikeessä. Luomme ThreadPoolExecutorin, jossa on enintään 2 työntekijäsäiettä. Lähetämme sitten kaksi tehtävää pooliin käyttämällä lähetysmenetelmää. Pool hallinnoi tehtävien suorittamista työsäikeissään. Käytämme sammutusmenetelmää odottamaan kaikkien tehtävien valmistumista ennen kuin pääsäie jatkuu.
Monisäikeistys voi auttaa sinua tekemään ohjelmistasi tehokkaampia ja reagoivampia. On kuitenkin tärkeää olla varovainen kierteiden kanssa työskennellessäsi, jotta vältytään kilpailuolosuhteilta ja umpikujalta.
Tämä koodi käyttää säiepoolia, joka on luotu concurrent.futures.ThreadPoolExecutor> suorittaa kahta työntekijätehtävää samanaikaisesti. Pääsäie odottaa, että työsäikeet ovat lopettaneet käytön pool.shutdown(wait=True)> . Tämä mahdollistaa tehtävien tehokkaan rinnakkaiskäsittelyn monisäikeisessä ympäristössä.
Python 3
import> concurrent.futures> def> worker():> >print>(>'Worker thread running'>)> pool>=> concurrent.futures.ThreadPoolExecutor(max_workers>=>2>)> pool.submit(worker)> pool.submit(worker)> pool.shutdown(wait>=>True>)> print>(>'Main thread continuing to run'>)> |
>
java-tyypin muunnos ja valu
>Lähtö
Worker thread running Worker thread running Main thread continuing to run>