A Python multiprocessing funkciója lehetővé teszi a munkaterhelés több folyamat között történő felosztását, ezzel csökkentve a teljes végrehajtási időt. Ez különösen hasznos nagy számítások elvégzéséhez vagy nagy adathalmazok kezeléséhez.

Mi az a Python multiprocessing?

A Pythonban a többfolyamatú feldolgozás több folyamat egyidejű futtatását jelenti, ami lehetővé teszi a többmagos rendszerek maximális kihasználását. Az egyfolyamatú módszerekkel ellentétben, amelyek a feladatokat egyenként kezelik, a többfolyamatú feldolgozás lehetővé teszi a program különböző részeinek párhuzamos futtatását, mindegyik a saját magán. Minden folyamat saját memóriaterületet kap, és külön processzormagokon futtatható, ami jelentősen lerövidíti a nagy teljesítményt igénylő vagy időérzékeny műveletek végrehajtási idejét.

A Python multiprocessing széles körű alkalmazási lehetőségekkel rendelkezik. A multiprocessingot gyakran használják az adatfeldolgozásban és -elemzésben a nagy adathalmazok gyorsabb feldolgozása és a komplex elemzések felgyorsítása érdekében. A multiprocessing szimulációkban és modellezési számításokban (pl. tudományos alkalmazásokban) is felhasználható a komplex számítások végrehajtási idejének lerövidítésére. Amellett, hogy több webhelyről egyszerre tölt le adatokat, így elősegítve a webes adatgyűjtést, növeli a képfeldolgozás és a számítógépes látás hatékonyságát is, ami gyorsabb képelemzést eredményez.

Hogyan valósítsuk meg a Python többfolyamatú feldolgozást?

A Python számos lehetőséget kínál a többfolyamatú feldolgozás megvalósításához. A következő szakaszokban három általános eszközt mutatunk be: a multiprocessing modult, az concurrent.futures könyvtárat és a joblib csomagot.

multiprocessing modul

A multiprocessing modul a Python multiprocessing standard modulja. Ezzel a modullal folyamatokat hozhat létre, adatokat oszthat meg közöttük, és szinkronizálhatja őket zárak, sorok és egyéb eszközök segítségével.

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

A fenti példában a multiprocessing.Process osztályt használjuk a task() függvényt végrehajtó folyamatok létrehozására és futtatására, amely egy adott szám négyzetét számítja ki. A folyamatok inicializálása után megvárjuk, amíg befejeződnek, mielőtt folytatnánk a fő programot. Az eredményt egy f-string segítségével jelenítjük meg, amely egy kifejezéseket tartalmazó Python string formátum módszer. Érdemes megjegyezni, hogy a kimenet sorrendje véletlenszerű és nem determinisztikus. Python multiprocessing segítségével folyamatpoolt is létrehozhat:

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() funkcióval a task() funkciót alkalmazzák egy adatsorozatra, majd az eredményeket összegyűjtik és kimenetként kiadják.

concurrent.futures könyvtár

Ez a modul magas szintű interfészt biztosít a folyamatok aszinkron végrehajtásához és párhuzamos feldolgozásához. A Pool Executor segítségével végzi el a feladatokat egy folyamat- vagy szálpoolon. A concurrent.futures modul egyszerűbb módja az aszinkron feladatok feldolgozásának, és sok esetben könnyebben kezelhető, mint a Python multiprocessing modul.

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

A kód a concurrent.futures module használja a feladatok párhuzamos feldolgozásához a ProcessPoolExecutor. A task(n) függvényt az 1-től 5-ig terjedő számokra adja át. A as_completed() metódus megvárja a feladatok befejezését, majd bármilyen sorrendben kinyomtatja az eredményeket.

joblib csomag

joblib egy külső Python könyvtár, amelynek célja a Pythonban végzett párhuzamos feldolgozás egyszerűsítése, például olyan ismétlődő feladatok esetében, mint a különböző bemeneti paraméterekkel rendelkező függvények végrehajtása vagy nagy mennyiségű adat feldolgozása. A joblib fő funkciói a feladatok párhuzamosítása, a függvények eredményeinek gyorsítótárazása, valamint a memória és a számítási erőforrások optimalizálása.

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

A Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) kifejezés elindítja a task() függvény párhuzamos végrehajtását az 1-től 10-ig terjedő számok esetében. Parallel n_jobs=4 van konfigurálva, ami azt jelenti, hogy legfeljebb négy párhuzamos feladat feldolgozható. delayed(task)(i) hívása létrehozza a párhuzamosan végrehajtandó feladatot az 1-től 10-ig terjedő tartományban lévő minden i számra. Ez azt jelenti, hogy a task() függvényt egyidejűleg hívják meg ezeknek a számoknak mindegyikére. Az 1-től 10-ig terjedő számok eredményei results -ban kerülnek tárolásra és kimenetre.

Ugrás a főmenübe