Multiprocessing is vergelijkbaar met multithreading. Het onderscheidt zich echter doordat we slechts één thread tegelijk kunnen uitvoeren vanwege de GIL die wordt gebruikt voor threading. Multiprocessing is het proces waarbij bewerkingen opeenvolgend worden uitgevoerd op verschillende CPU-kernen. Threads kunnen niet parallel worden gebruikt. Met multiprocessing kunnen we de processen echter opzetten en gelijktijdig uitvoeren op verschillende CPU-kernen. De lus, zoals de for-lus, is een van de meest gebruikte scripttalen. Herhaal hetzelfde werk met verschillende gegevens totdat een criterium, zoals een vooraf bepaald aantal iteraties, is bereikt. De lus voltooit elke iteratie één voor één.
Voorbeeld 1: gebruik van de For-Loop in de Python Multiprocessing Module
In dit voorbeeld gebruiken we de for-loop en het Python multiprocessing module klasseproces. We beginnen met een heel eenvoudig voorbeeld, zodat u snel kunt begrijpen hoe de Python multiprocessing for-loop werkt. Met behulp van een interface die vergelijkbaar is met de threading-module, pakt de multiprocessing het creëren van processen in.
Door gebruik te maken van de subprocessen in plaats van threads, biedt het multiprocessing-pakket zowel lokale als verre gelijktijdigheid, waardoor de Global Interpreter Lock wordt vermeden. Gebruik een for-lus, die een tekenreeksobject of een tuple kan zijn, om continu een reeks te herhalen. Dit werkt minder zoals het trefwoord dat in andere programmeertalen wordt gezien en meer als een iteratormethode die in andere programmeertalen wordt aangetroffen. Door een nieuwe multiprocessing te starten, kunt u een for-lus uitvoeren die tegelijkertijd een procedure uitvoert.
Laten we beginnen met het implementeren van de code voor code-uitvoering door gebruik te maken van de 'spyder' -tool. Wij geloven dat 'spyder' ook het beste is voor het uitvoeren van Python. We importeren een multiprocessing-moduleproces dat door de code wordt uitgevoerd. Multiprocessing in het Python-concept, een 'procesklasse' genoemd, creëert een nieuw Python-proces, geeft het een methode om code uit te voeren en geeft de bovenliggende applicatie een manier om de uitvoering te beheren. De klasse Process bevat de procedures start() en join() die beide cruciaal zijn.
Vervolgens definiëren we een door de gebruiker gedefinieerde functie genaamd 'func'. Omdat het een door de gebruiker gedefinieerde functie is, geven we het een naam naar keuze. Binnen de hoofdtekst van deze functie geven we de variabele 'onderwerp' door als een argument en de waarde 'wiskunde'. Vervolgens noemen we de functie 'print()', waarbij we de instructie 'De naam van het gemeenschappelijke onderwerp is' doorgeven, evenals het argument 'onderwerp' dat de waarde bevat. Vervolgens gebruiken we in de volgende stap de 'if name== _main_', die verhindert dat u de code uitvoert wanneer het bestand als een module wordt geïmporteerd en u dit alleen toestaat om dit te doen wanneer de inhoud wordt uitgevoerd als een script.
De voorwaardesectie waarmee u begint, kan in de meeste gevallen worden gezien als een locatie om de inhoud te leveren die alleen mag worden uitgevoerd wanneer uw bestand als een script wordt uitgevoerd. Vervolgens gebruiken we het argument onderwerp en slaan er enkele waarden in op, namelijk 'wetenschap', 'Engels' en 'computer'. Het proces krijgt dan in de volgende stap de naam “proces1[]”. Vervolgens gebruiken we het 'proces (target = func)' om de functie in het proces aan te roepen. Target wordt gebruikt om de functie aan te roepen en we slaan dit proces op in de variabele 'P'.
Vervolgens gebruiken we 'proces1' om de functie 'append()' aan te roepen die een item toevoegt aan het einde van de lijst die we hebben in de functie 'func'. Omdat het proces is opgeslagen in de variabele 'P', geven we 'P' door aan deze functie als argument. Ten slotte gebruiken we de functie 'start()' met 'P' om het proces te starten. Daarna voeren we de methode opnieuw uit terwijl we het argument 'onderwerp' opgeven en gebruiken we 'voor' in het onderwerp. Vervolgens gebruiken we nogmaals 'proces1' en de methode 'add()' en beginnen we het proces. Het proces wordt vervolgens uitgevoerd en de uitvoer wordt geretourneerd. De procedure wordt vervolgens verteld om te eindigen met behulp van de 'join()' -techniek. De processen die de procedure 'join()' niet aanroepen, worden niet afgesloten. Een cruciaal punt is dat de sleutelwoordparameter 'args' moet worden gebruikt als u tijdens het proces argumenten wilt geven.
Nu kunt u in de uitvoer zien dat de instructie eerst wordt weergegeven door de waarde voor het onderwerp 'wiskunde' door te geven die we doorgeven aan de functie 'func' omdat we deze eerst de functie 'proces' gebruiken. Vervolgens gebruiken we de opdracht 'append()' om waarden te hebben die al in de lijst stonden die aan het einde wordt toegevoegd. Vervolgens werden 'wetenschap', 'computer' en 'Engels' gepresenteerd. Maar zoals u kunt zien, staan de waarden niet in de juiste volgorde. Dit doen ze namelijk zo snel als de procedure is afgerond en melden hun melding.
Voorbeeld 2: Conversie van sequentiële for-lus naar multiprocessing parallelle for-lus
In dit voorbeeld wordt de multiprocessing-lustaak sequentieel uitgevoerd voordat deze wordt geconverteerd naar een parallelle for-lus-taak. U kunt reeksen doorlopen, zoals een verzameling of tekenreeks, in de volgorde waarin ze voorkomen met behulp van de for-loops.
Laten we nu beginnen met het implementeren van de code. Eerst importeren we 'slaap' uit de tijdmodule. Met behulp van de 'sleep()'-procedure in de tijdmodule kunt u de uitvoering van de aanroepende thread zo lang opschorten als u wilt. Vervolgens gebruiken we 'willekeurig' uit de willekeurige module, definiëren we een functie met de naam 'func' en geven we het trefwoord 'argu' door. Vervolgens maken we een willekeurige waarde met behulp van 'val' en stellen deze in op 'willekeurig'. Vervolgens blokkeren we voor een korte periode met behulp van de methode 'sleep()' en geven we 'val' door als parameter. Om vervolgens een bericht te verzenden, voeren we de methode 'print()' uit, waarbij we de woorden 'ready' en het trefwoord 'arg' als parameter doorgeven, evenals 'created' en de waarde doorgeven met 'val'.
Ten slotte gebruiken we 'flush' en stellen deze in op 'True'. De gebruiker kan beslissen om de output al dan niet te bufferen met behulp van de flush-optie in de printfunctie van Python. De standaardwaarde van deze parameter, False, geeft aan dat de uitvoer niet wordt gebufferd. De uitvoer wordt weergegeven als een reeks regels die elkaar opvolgen als u deze instelt op waar. Vervolgens gebruiken we de 'if name== main' om de toegangspunten te beveiligen. Vervolgens voeren we de taak sequentieel uit. Hier stellen we het bereik in op '10', wat betekent dat de lus na 10 iteraties eindigt. Vervolgens noemen we de 'print()'-functie, geven deze de 'ready'-invoeropdracht door en gebruiken de 'flush=True'-optie.
U kunt nu zien dat wanneer we de code uitvoeren, de lus ervoor zorgt dat de functie '10' keer wordt uitgevoerd. Het herhaalt zich 10 keer, beginnend bij index nul en eindigend bij index negen. Elk bericht bevat een taaknummer, een functienummer dat we doorgeven als een 'arg' en een creatienummer.
Deze sequentiële lus wordt nu omgezet in een multiprocessing parallelle for-lus. We gebruiken dezelfde code, maar we gaan naar wat extra bibliotheken en functies voor multiprocessing. Daarom moeten we het proces importeren vanuit multiprocessing, zoals we eerder hebben uitgelegd. Vervolgens maken we een functie met de naam 'func' en geven we het trefwoord 'arg' door voordat we 'val=random' gebruiken om een willekeurig getal te krijgen.
Vervolgens, na het aanroepen van de 'print()'-methode om een bericht weer te geven en het geven van de 'val'-parameter om een korte periode te vertragen, gebruiken we de 'if name=main'-functie om de ingangspunten te beveiligen. Waarna we een proces maken en de functie in het proces aanroepen met 'process' en de 'target=func' doorgeven. Vervolgens passeren we de 'func', 'arg', geven we de waarde 'm' door en passeren we het bereik '10', wat betekent dat de lus de functie beëindigt na '10' iteraties. Vervolgens starten we het proces met behulp van de methode 'start()' met 'proces'. Vervolgens noemen we de methode 'join()' om te wachten op de uitvoering van het proces en om het hele proces daarna te voltooien.
Daarom, wanneer we de code uitvoeren, roepen de functies het hoofdproces aan en beginnen ze met hun uitvoering. Ze zijn echter klaar totdat alle taken zijn volbracht. Dat kunnen we zien omdat elke taak gelijktijdig wordt uitgevoerd. Het rapporteert zijn bericht zodra het klaar is. Dit betekent dat hoewel de berichten niet in orde zijn, de lus eindigt nadat alle '10' iteraties zijn voltooid.
Conclusie
We hebben de Python multiprocessing for-loop in dit artikel behandeld. We presenteerden ook twee illustraties. De eerste illustratie laat zien hoe je een for-lus gebruikt in de loop multiprocessing-bibliotheek van Python. En de tweede illustratie laat zien hoe je een sequentiële for-lus verandert in een parallelle multiprocessing for-lus. Voordat we het script voor Python multiprocessing bouwen, moeten we de multiprocessing-module importeren.