A többszálú feldolgozás a többszálú feldolgozáshoz hasonlítható. Azonban abban különbözik, hogy a szálfűzéshez használt GIL miatt egyszerre csak egy szálat tudunk végrehajtani. A többszörös feldolgozás az a folyamat, amikor a műveleteket egymás után hajtják végre több CPU-magon. A szálakat nem lehet párhuzamosan működtetni. A többfeldolgozás azonban lehetővé teszi a folyamatok létrehozását és egyidejű futtatását különböző CPU-magokon. A ciklus, mint például a for-loop, az egyik leggyakrabban használt szkriptnyelv. Ismételje meg ugyanazt a munkát különböző adatok felhasználásával, amíg el nem ér egy feltételt, például egy előre meghatározott számú iterációt. A ciklus minden iterációt egyenként hajt végre.
1. példa: A For-Loop használata a Python Multiprocessing Module-ban
Ebben a példában a for-loop és a Python többfeldolgozó modul osztályfolyamatát használjuk. Egy nagyon egyszerű példával kezdjük, hogy gyorsan megértse a Python többfeldolgozó for-loop működését. A szálfűző modulhoz hasonló interfész segítségével a multiprocessing csomagolja a folyamatok létrehozását.
Az alfolyamatok, nem pedig a szálak alkalmazásával a többfeldolgozó csomag helyi és távoli párhuzamosságot is biztosít, így elkerülhető a Global Interpreter Lock. Használjon for ciklust, amely lehet egy karakterlánc objektum vagy egy sor, a sorozat folyamatos iterálásához. Ez kevésbé működik úgy, mint a más programozási nyelvekben használt kulcsszó, és inkább egy iterátor módszer, amely más programozási nyelvekben található. Egy új többfeldolgozás elindításával egy for-hurkot futtathat, amely párhuzamosan hajt végre egy eljárást.
Kezdjük a kód végrehajtásával a „spyder” eszköz használatával. Úgy gondoljuk, hogy a „spyder” a Python futtatására is a legjobb. Egy többfeldolgozó modulfolyamatot importálunk, amelyen a kód fut. A Python-koncepcióban a „folyamatosztálynak” nevezett többfeldolgozás egy új Python-folyamatot hoz létre, módszert ad neki a kód végrehajtására, és módot ad a szülőalkalmazásnak a végrehajtás kezelésére. A Process osztály tartalmazza a start() és a join() eljárásokat, mindkettő kulcsfontosságú.
Ezután definiálunk egy „func” nevű, felhasználó által definiált függvényt. Mivel egy felhasználó által definiált függvényről van szó, tetszőleges nevet adunk neki. A függvény törzsében argumentumként adjuk át a „subject” változót és a „matematika” értéket. Ezután meghívjuk a “print()” függvényt, átadva a “A közös alany neve” utasítást, valamint az értéket tartalmazó “subject” argumentumot. Ezután a következő lépésben az „if name== _main_” paramétert használjuk, amely megakadályozza a kód futtatását, amikor a fájlt modulként importálják, és csak akkor engedi meg ezt, ha a tartalom szkriptként fut.
A feltétel szakaszt, amellyel kezdi, a legtöbb esetben úgy tekinthetjük, mint egy olyan helyet, ahol olyan tartalmat biztosítunk, amelyet csak akkor szabad végrehajtani, ha a fájl szkriptként fut. Ezután az argumentum alanyt használjuk, és tárolunk benne néhány értéket, amelyek a következők: „tudomány”, „angol” és „számítógép”. A folyamat ezután a következő lépésben a „process1[]” nevet kapja. Ezután a „process(target=func)” segítségével hívjuk meg a függvényt a folyamatban. A Target a függvény meghívására szolgál, és ezt a folyamatot a „P” változóba mentjük.
Ezután a „process1” segítségével hívjuk meg az „append()” függvényt, amely hozzáad egy elemet a lista végéhez, amely a „func” függvényben található. Mivel a folyamat a „P” változóban van tárolva, a „P”-t adjuk át ennek a függvénynek argumentumként. Végül a „start()” függvényt használjuk „P”-vel a folyamat elindításához. Ezután újra futtatjuk a metódust, miközben megadjuk a „subject” argumentumot, és a tárgyban használjuk a „for”-t. Ezután a „process1” és az „add()” metódus ismételt használatával elkezdjük a folyamatot. A folyamat ezután lefut, és a kimenet visszakerül. Az eljárás ezután a „join()” technikával fejeződik be. Azok a folyamatok, amelyek nem hívják meg a „join()” eljárást, nem lépnek ki. Az egyik kulcsfontosságú pont az, hogy az „args” kulcsszóparamétert kell használni, ha érveket szeretne megadni a folyamat során.
Most láthatja a kimenetben, hogy az állítás először a „matematika” tárgy értékének átadásával jelenik meg, amelyet átadunk a „func” függvénynek, mert először a „process” függvénnyel hívjuk meg. Ezután az „append()” parancsot használjuk, hogy olyan értékeket kapjunk, amelyek már szerepeltek a listában, amelyet a végére adunk hozzá. Ezután bemutatták a „tudomány”, a „számítógép” és az „angol nyelvet”. De amint láthatja, az értékek nem a megfelelő sorrendben vannak. Ennek az az oka, hogy ezt olyan gyorsan teszik meg, amikor az eljárás befejeződött, és jelentést küldenek üzenetükről.
2. példa: A szekvenciális for-loop átalakítása többfeldolgozó párhuzamos for-hurokká
Ebben a példában a többfeldolgozó hurokfeladatot szekvenciálisan hajtják végre, mielőtt párhuzamos for-loop feladattá konvertálják. A for-ciklusok használatával lépkedhet a sorozatok között, például egy gyűjtemény vagy karakterlánc között, az előfordulásuk sorrendjében.
Most kezdjük el a kód implementálását. Először az „alvást” importáljuk az időmodulból. Az időmodul „sleep()” eljárásával felfüggesztheti a hívó szál végrehajtását, ameddig csak akarja. Ezután a véletlenszerű modulból a „random”-ot használjuk, definiálunk egy „func” nevű függvényt, és átadjuk az „argu” kulcsszót. Ezután létrehozunk egy véletlenszerű értéket a „val” használatával, és beállítjuk „random”-ra. Ezután egy kis ideig blokkoljuk a „sleep()” metódussal, és paraméterként adjuk meg a „val”-t. Ezután az üzenet továbbításához a „print()” metódust futtatjuk, paraméterként átadva a „ready” szavakat és az „arg” kulcsszót, valamint a „created”-t, és a „val” segítségével adjuk át az értéket.
Végül a „flush”-t használjuk, és „True”-ra állítjuk. A felhasználó eldöntheti, hogy puffereli-e a kimenetet a Python nyomtatási funkciójában található flush opcióval. Ennek a paraméternek a False alapértelmezett értéke azt jelzi, hogy a kimenet nem lesz pufferelve. A kimenet egymás utáni sorokként jelenik meg, ha igazra állítja. Ezután az „if name== main”-t használjuk a belépési pontok biztosítására. Ezután a munkát szekvenciálisan hajtjuk végre. Itt a tartományt „10”-re állítjuk, ami azt jelenti, hogy a ciklus 10 iteráció után véget ér. Ezután meghívjuk a „print()” függvényt, átadjuk neki a „ready” bemeneti utasítást, és használjuk a „flush=True” opciót.
Most már láthatja, hogy amikor végrehajtjuk a kódot, a ciklus hatására a függvény „10”-szer fut le. 10-szer ismétlődik, a nulla indextől kezdve a kilences indexen végződik. Minden üzenet tartalmaz egy feladatszámot, amely egy függvényszám, amelyet „arg”-ként és létrehozási számként adunk át.
Ezt a szekvenciális hurkot most egy többfeldolgozó párhuzamos for-hurokká alakítják át. Ugyanazt a kódot használjuk, de néhány extra könyvtárat és függvényt használunk a többfeldolgozáshoz. Ezért a folyamatot a többfeldolgozásból kell importálnunk, ahogy azt korábban kifejtettük. Ezután létrehozunk egy „func” nevű függvényt, és átadjuk az „arg” kulcsszót, mielőtt a „val=random” értéket használnánk egy véletlen szám megadásához.
Ezután, miután meghívtuk a “print()” metódust üzenet megjelenítéséhez, és a “val” paramétert megadtuk egy kis idő elhalasztására, az “if name= main” függvényt használjuk a belépési pontok biztosítására. Ezután létrehozunk egy folyamatot, és a folyamatban a „process” használatával meghívjuk a függvényt, és átadjuk a „target=func”-ot. Ezután átadjuk a „func”, „arg” értéket, az „m” értéket, és a „10” tartományt, ami azt jelenti, hogy a ciklus „10” iteráció után befejezi a függvényt. Ezután elindítjuk a folyamatot a „start()” metódussal a „process”-el. Ezután meghívjuk a „join()” metódust, hogy megvárjuk a folyamat végrehajtását, majd befejezzük az összes folyamatot.
Ezért, amikor végrehajtjuk a kódot, a függvények meghívják a fő folyamatot, és megkezdik a végrehajtásukat. Mindaddig azonban elkészülnek, amíg az összes feladatot el nem végezték. Ezt azért láthatjuk, mert minden feladatot párhuzamosan hajtanak végre. Amint elkészült, jelenti az üzenetét. Ez azt jelenti, hogy bár az üzenetek rendellenesek, a ciklus minden „10” iteráció befejezése után véget ér.
Következtetés
Ebben a cikkben a Python többfeldolgozó for-loopjával foglalkoztunk. Két illusztrációt is bemutattunk. Az első illusztráció azt mutatja be, hogyan lehet for-loopot használni a Python ciklusos többfeldolgozó könyvtárában. A második illusztráció pedig azt mutatja be, hogyan lehet egy szekvenciális for-hurkot párhuzamos többfeldolgozó for-hurokká változtatni. A Python multiprocessing szkriptjének elkészítése előtt importálnunk kell a többfeldolgozó modult.