Pythonin mo­nipro­ses­soin­ti mah­dol­lis­taa työmäärän jakamisen useiden pro­ses­sien kesken, mikä lyhentää ko­ko­nais­kes­toa. Tämä on erityisen hyö­dyl­lis­tä suurten las­kel­mien suo­rit­ta­mi­ses­sa tai suurten tie­to­jouk­ko­jen kä­sit­te­lys­sä.

Mitä on Python-mo­nipro­ses­soin­ti?

Pythonin mo­nipro­ses­soin­ti tar­koit­taa useiden pro­ses­sien sa­ma­nai­kais­ta suo­rit­ta­mis­ta, jolloin voit hyödyntää mo­niy­din­sys­tee­mien etuja. Toisin kuin yk­si­säi­kei­set me­ne­tel­mät, jotka kä­sit­te­le­vät tehtäviä yksi ker­ral­laan, mo­nipro­ses­soin­ti mah­dol­lis­taa ohjelman eri osien rin­nak­kai­sen suo­rit­ta­mi­sen, kukin omalla pro­ses­so­ril­la. Jokainen prosessi saa oman muis­tia­lu­een­sa ja voi suorittaa eril­li­sil­lä pro­ses­so­rin ytimillä, mikä lyhentää huo­mat­ta­vas­ti raskaiden tai ai­kak­riit­tis­ten toi­min­to­jen suo­ri­tusai­kaa.

Pythonin mo­nipro­ses­soin­ti on mo­ni­puo­li­nen sovellus. Mo­nipro­ses­soin­tia käytetään usein tie­to­jen­kä­sit­te­lys­sä ja ana­ly­soin­nis­sa suurten tie­to­jouk­ko­jen no­peam­paan kä­sit­te­lyyn ja mo­ni­mut­kais­ten ana­lyy­sien no­peut­ta­mi­seen. Mo­nipro­ses­soin­tia voidaan käyttää myös si­mu­loin­neis­sa ja mal­lin­nus­las­kel­mis­sa (esim. tie­teel­li­sis­sä so­vel­luk­sis­sa) mo­ni­mut­kais­ten las­kel­mien suo­ri­tusai­ko­jen ly­hen­tä­mi­sek­si. Sen lisäksi, että se tehostaa verk­ko­si­vu­jen kaap­paus­ta hakemalla dataa useilta si­vus­toil­ta sa­ma­nai­kai­ses­ti, se myös parantaa te­hok­kuut­ta ku­van­kä­sit­te­lys­sä ja tie­to­ko­neen nä­kö­ky­vys­sä, mikä nopeuttaa kuvien ana­ly­soin­tia.

Pythonin mo­nipro­ses­soin­nin to­teut­ta­mi­nen

Python tarjoaa useita vaih­toeh­to­ja mo­nipro­ses­soin­nin to­teut­ta­mi­seen. Seu­raa­vis­sa osioissa esit­te­lem­me kolme yleistä työkalua: multiprocessing, concurrent.futures ja joblib paketin.

multiprocessing moduuli

multiprocessing on Python-mo­nipro­ses­soin­nin va­kio­mo­duu­li. Tämän moduulin avulla voit luoda pro­ses­se­ja, jakaa tietoja niiden välillä ja synk­ro­noi­da niitä lukkojen, jonojen ja muiden työ­ka­lu­jen avulla.

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()
python

Yllä olevassa esi­mer­kis­sä käytämme luokkaa multiprocessing.Process pro­ses­sien luomiseen ja suo­rit­ta­mi­seen, jotka suo­rit­ta­vat toiminnon task(), joka laskee annetun luvun neliön. Pro­ses­sien alus­ta­mi­sen jälkeen odotamme niiden val­mis­tu­mis­ta ennen kuin jatkamme pää­oh­jel­man suo­rit­ta­mis­ta. Tulos näytetään f-merk­ki­jo­nol­la, joka on Python-merk­ki­jo­no­muo­toi­lu­me­ne­tel­mä, joka sisältää lausek­kei­ta. On syytä huomata, että tu­los­tuk­sen järjestys on sa­tun­nai­nen ja ei-de­ter­mi­nis­ti­nen. Voit myös luoda pro­ses­si­poo­lin Python multiprocessing:llä:

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]
python

pool.map() lla funktio task() so­vel­le­taan da­ta­jo­noon, ja tulokset kerätään ja tu­los­te­taan.

concurrent.futures kirjasto

Tämä moduuli tarjoaa korkean tason ra­ja­pin­nan pro­ses­sien asynk­ro­ni­seen suo­rit­ta­mi­seen ja rin­nak­kai­seen kä­sit­te­lyyn. Se käyttää Pool Executor -ohjelmaa tehtävien suo­rit­ta­mi­seen prosessi- tai säi­keis­tö­jou­kos­sa. concurrent.futures on yk­sin­ker­tai­sem­pi tapa käsitellä asynk­ro­ni­sia tehtäviä, ja se on monissa ta­pauk­sis­sa helpompi käyttää kuin Python multiprocessing.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order
python

Koodi käyttää concurrent.futures module tehtävien rin­nak­kai­seen kä­sit­te­lyyn ProcessPoolExecutor kanssa. Funktio task(n) vä­li­te­tään nu­me­roil­le 1–5. Menetelmä as_completed() odottaa tehtävien val­mis­tu­mis­ta ja tulostaa tulokset missä tahansa jär­jes­tyk­ses­sä.

joblib paketti

joblib on ulkoinen Python-kirjasto, joka on suun­ni­tel­tu yk­sin­ker­tais­ta­maan rin­nak­kaispro­ses­soin­tia Pyt­ho­nis­sa, esi­mer­kik­si tois­tet­ta­vis­sa teh­tä­vis­sä, kuten eri syöt­tö­pa­ra­met­reil­la toimivien funk­tioi­den suo­rit­ta­mi­ses­sa tai suurten tie­to­mää­rien kä­sit­te­lys­sä. joblib n pää­toi­min­not ovat tehtävien rin­nak­kais­ta­mi­nen, funk­tioi­den tulosten vä­li­muis­tiin tal­len­ta­mi­nen sekä muistin ja las­ken­ta­re­surs­sien op­ti­moin­ti.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10
python

Ilmaisu Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) käyn­nis­tää funktion task() rin­nak­kai­sen suo­ri­tuk­sen nu­me­roil­le 1–10. Parallel on kon­fi­gu­roi­tu n_jobs=4 kanssa, mikä tar­koit­taa, että voidaan käsitellä enintään neljä rin­nak­kais­ta tehtävää. Kut­su­mal­la delayed(task)(i) luodaan tehtävä, joka suo­ri­te­taan rin­nak­kain jo­kai­sel­le numerolle i alueella 1–10. Tämä tar­koit­taa, että funktiota task() kutsutaan sa­ma­nai­kai­ses­ti jo­kai­sel­le näistä nu­me­rois­ta. Tulokset nu­me­roil­le 1–10 tal­len­ne­taan results:een ja tu­los­te­taan. 630ef2b8ef2f762ab06e12069453e656

Siirry pää­va­lik­koon