Python Academy · Oppitunti

multiprocessing-perusteet

Käytä useita suorittimen ytimiä

Oppitunti 3/413 vaihetta

multiprocessing-perusteet on ilmainen Python Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Python Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Python Academy-kurssilla on yhteensä 4 oppituntia.

Miksi multiprocessing?

GIL estää säikeitä suorittamasta Python-tavukoodia rinnakkain. multiprocessing-moduuli kiertää tämän käynnistämällä erillisiä prosesseja, joista kullakin on oma tulkkinsa ja GIL:nsä. Näin suorittimeen sidottu työ suoritetaan todella usealla ytimellä.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Prosessin käynnistäminen

Process(target=func) vastaa säikeistyksen rajapintaa. Käynnistäkää prosessi kutsumalla start()-metodia ja odottakaa sen valmistumista kutsumalla join()-metodia.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

main-suojauksen käyttäminen

Joillakin alustoilla aliprosessit tuovat komentosarjasi uudelleen. Ilman if __name__ == '__main__':-suojausta voit käynnistää prosesseja rekursiivisesti. Sijoittakaa käynnistyskoodi aina sen sisään.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Argumenttien välittäminen

Käyttäkää args-argumenttia sijaintiparametreille ja kwargs-argumenttia avainsanaparametreille aivan kuten säikeiden kanssa. Argumentit sarjallistetaan pickle-muotoon ja lähetetään aliprosessille.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

Työskentelijäprosesseista koostuva pooli

multiprocessing.Pool hallinnoi prosessiryhmää. pool.map jakaa iteroitavan olion prosessien kesken ja kerää tulokset järjestyksessä.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

concurrent.futures-rajapinta tarjoaa myös ProcessPoolExecutor-luokan, jossa on sama submit/map-rajapinta, johon tutustuitte säikeiden yhteydessä.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Erilliset muistiavaruudet

Jokaisella prosessilla on oma muistinsa. Globaalin muuttujan muokkaaminen aliprosessissa ei muuta pääprosessin kopiota. Tiedot on palautettava tai jaettava erikseen.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Tulosten palauttaminen

Koska muistia ei jaeta, palauttakaa tulokset Pool.map-kutsun, suorittajien tai jonojen kautta sen sijaan, että muokkaisitte globaaleja muuttujia.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async yksittäisiin kutsuihin

apply_async ajoittaa yhden kutsun ja palauttaa tulosolion. Kutsukaa .get()-metodia arvon hakemiseksi.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Pickle-muotoon sarjallistamisen vaatimus

Kohteiden ja argumenttien on oltava pickle-muotoon sarjallistettavia, jotta ne voidaan siirtää prosessirajan yli. Ylimmän tason funktiot toimivat, mutta lambda-funktiot ja paikalliset funktiot eivät yleensä toimi.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

Milloin prosesseja kannattaa käyttää

Käyttäkää prosesseja suoritinsidonnaiseen työhön, kuten matematiikkaan, kuvankäsittelyyn ja jäsentämiseen. Prosessien käynnistämisestä ja pickle-muotoon sarjallistamisesta aiheutuva kuormitus tarkoittaa, että ne sopivat paremmin harvempiin ja raskaampiin tehtäviin kuin moniin pieniin tehtäviin.

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Pikatarkistus

Testatkaa, miten hyvin hallitsette multiprocessing-moduulin.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte multiprocessing-moduulin perusteet:

Prosessit ohittavat GIL:n ja mahdollistavat todellisen suorittimen rinnakkaisuuden.
Käyttäkää if __name__ == '__main__'-suojausta.
Pool ja ProcessPoolExecutor jakavat työn ja keräävät tulokset.
Muistia ei jaeta, ja argumenttien on oltava pickle-muotoon sarjallistettavia.

Seuraavaksi: tietojen turvallinen jakaminen jonojen ja lukkojen avulla.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 76
Oppitunnit: 320

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”multiprocessing-perusteet” ilmainen?

Kyllä – oppitunnin ”multiprocessing-perusteet” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Python Academy-kurssin, päivitä CoddyKit PROhon. Python Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”multiprocessing-perusteet”?

Käytä useita suorittimen ytimiä Harjoittelet Python Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Python Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Python Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”multiprocessing-perusteet”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Python Academy-oppitunnilla?

Kyllä. Jokainen Python Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Python Academy