Share
Het multiprocessing-pakket ondersteunt paaiprocessen met een API die vergelijkbaar is met de threading-module. Het biedt ook zowel lokale als externe concurrency. Deze tutorial bespreekt multiprocessing in Python en hoe multiprocessing te gebruiken om te communiceren tussen processen en synchronisatie tussen processen uit te voeren, evenals logging.
Multiprocessing werkt door een Werkwijze object en noem het dan begin() methode zoals hieronder getoond.
from multiprocessing import Process def greeting (): druk 'hello world' in als __name__ == '__main__': p = Process (target = greeting) p.start () p.join ()
In de bovenstaande voorbeeldcode importeren we eerst de klasse Process en maken we het Process-object instantiel met de begroetingsfunctie die we willen uitvoeren.
Vervolgens vertellen we het proces om de. Te gebruiken begin() methode, en we voltooien het proces uiteindelijk met de join () methode.
Bovendien kunt u ook argumenten aan de functie doorgeven door de args zoekwoordargument als volgt:
Accentsconagua
from multiprocessing import Process def groet (naam): print 'hallo' + "" + naam if __name__ == '__main__': p = Process (target = greeting, args = ('world',)) p.start () p .join () Laten we een meer gedetailleerd voorbeeld bekijken dat alle concepten behandelt die we hierboven hebben besproken.
In dit voorbeeld gaan we een proces maken dat het kwadraat van getallen berekent en de resultaten naar de console afdrukt.
from multiprocessing import Process def square (x): voor x in cijfers: print ('% s squared is% s'% (x, x ** 2)) if __name__ == '__main__': nummers = [43, 50, 5, 98, 34, 35] p = Proces (doel = vierkant, args = ('x',)) p.start () p.een druk 'Gereed' #resultaat Gereed 43 vierkant is 1849 50 vierkant is 2500 5 vierkant is 25 98 vierkant is 9604 34 vierkant is 1156 35 vierkant is 1225 Je kunt ook meer dan één proces tegelijkertijd maken, zoals in het onderstaande voorbeeld, waarin proces p1 de resultaten van getallen in het kwadraat krijgt, terwijl het tweede proces p2 controleert of de gegeven getallen even zijn.
from multiprocessing import Process def square (x): voor x in cijfers: print ('% s squared is% s'% (x, x ** 2)) def is_even (x): voor x in cijfers: if x% 2 == 0: print ('% s is een even getal'% (x)) als __name__ == '__main__': nummers = [43, 50, 5, 98, 34, 35] p1 = Verwerken (doel = vierkant, args = ('x',)) p2 = Proces (doel = is_even, args = ('x',)) p1.start () p2.start () p1.join () p2.join () print "Klaar" #resultaat 43 kwadraat is 1849 50 vierkant is 2500 5 vierkant is 25 98 vierkant is 9604 34 vierkant is 1156 35 vierkant is 1225 50 is een even getal 98 is een even getal 34 is een even getal Klaar Multiprocessing ondersteunt twee soorten communicatiekanalen tussen processen:
Wachtrij objecten worden gebruikt om gegevens tussen processen door te geven. Ze kunnen elk pickle-able Python-object opslaan en u kunt ze gebruiken zoals in het onderstaande voorbeeld wordt getoond:
import multiprocessing def is_even (numbers, q): for n in numbers: if n% 2 == 0: q.put (n) if __name__ == "__main__": q = multiprocessing.Queue () p = multiprocessing.Process ( target = is_even, args = (range (20), q)) p.start () p.join () while q: print (q.get ())
In het bovenstaande voorbeeld maken we eerst een functie die controleert of een getal even is en zet het resultaat aan het einde van de wachtrij. We instantiëren vervolgens een wachtrijobject en een procesobject en beginnen het proces.
Ten slotte controleren we of de wachtrij leeg is en als dat niet het geval is, krijgen we de waarden aan de voorkant van de wachtrij en drukken deze af naar de console.
We hebben laten zien hoe gegevens tussen twee processen met behulp van een wachtrij kunnen worden gedeeld en het resultaat is zoals hieronder weergegeven.
# resultaat 0 2 4 6 8 10 12 14 16 18
Het is ook belangrijk om op te merken dat Python een wachtrijmodule heeft die leeft in de procesmodule en wordt gebruikt om gegevens tussen threads te delen, in tegenstelling tot de multiprocessing-wachtrij die in gedeeld geheugen leeft en wordt gebruikt om gegevens tussen processen te delen.
Pipes in multiprocessing worden voornamelijk gebruikt voor communicatie tussen processen. Gebruik is zo simpel als:
from multiprocessing import Process, Pipe def f (conn): conn.send (['hello world']) conn.close () if __name__ == '__main__': parent_conn, child_conn = Pipe () p = Process (target = f , args = (child_conn,)) p.start () print parent_conn.recv () p.join ()
Pijp() retourneert twee verbindingsobjecten die de twee uiteinden van de pijp vertegenwoordigen. Elk verbindingsobject heeft sturen() en recv () methoden. Hier maken we een proces dat de string afdrukt Hallo Wereld en deelt de gegevens vervolgens met elkaar.
# resultaat ['hallo wereld']
sloten werk door ervoor te zorgen dat slechts één proces tegelijk wordt uitgevoerd, waardoor andere processen worden geblokkeerd voor het uitvoeren van vergelijkbare code. Hierdoor kan het proces worden voltooid en pas dan kan het slot worden vrijgegeven.
Het onderstaande voorbeeld toont een vrij eenvoudig gebruik van de Lock-methode.
from multiprocessing import Process, Lock def groet (l, i): l.acquire () print 'hallo', i l.release () if __name__ == '__main__': lock = Lock () names = ['Alex', 'sam', 'Bernard', 'Patrick', 'Jude', 'Williams'] voor namen in namen: Process (target = greeting, args = (lock, name)) start () #result hallo Alex hallo sam hallo Bernard hallo Patrick hallo Jude hallo Williams
In deze code importeren we eerst de Lock-methode, nemen deze op, voeren de afdrukfunctie uit en geven deze vervolgens vrij.
De multiprocessing-module biedt ook ondersteuning voor logboekregistratie, hoewel het logboekpakket geen vergrendelingen gebruikt, zodat berichten tussen processen tijdens de uitvoering kunnen worden verwisseld..
Gebruik van loggen is zo simpel als:
import multiprocessing, logging logger = multiprocessing.log_to_stderr () logger.setLevel (logging.INFO) logger.warning ('Fout is opgetreden')Hier importeren we eerst de logging- en multiprocessing-modules en definiëren we de multiprocessing.log_to_stderr () methode, die een oproep doet naar get_logger () evenals het toevoegen van een handler waarnaar de uitvoer wordt verzonden sys.stderr. Ten slotte stellen we het logger-niveau en het bericht in dat we willen overbrengen.
Deze tutorial heeft betrekking op wat nodig is om aan de slag te gaan met multiprocessing in Python. Multiprocessing overwint het probleem van GIL (Global Interpreter Lock) omdat het gebruik maakt van subprocessen in plaats van threads.
Er is veel meer in de Python-documentatie die niet in deze zelfstudie aan de orde komt, dus bezoek de Python-multiprocessingdocumenten en maak gebruik van de volledige kracht van deze module.
