Share
Multiprocessing-paketet stöder gasningsprocesser med hjälp av ett API som liknar gängningsmodulen. Det erbjuder också både lokal och fjärransluten samtidighet. Denna handledning kommer att diskutera multiprocessing i Python och hur man använder multiprocessing för att kommunicera mellan processer och utföra synkronisering mellan processer, såväl som loggning.
Multiprocessing fungerar genom att skapa en Bearbeta objekt och sedan ringa det Start() metod som visas nedan.
från multiprocessing import Process def greeting (): skriv ut 'hej världen' om __name__ == '__main__': p = Process (mål = hälsning) p.start () p.join ()
I exemplet ovan ovan importerar vi först Process-klassen och installerar sedan Process-objektet med hälsningsfunktionen som vi vill köra.
Vi berättar sedan för processen att börja använda Start() metod, och vi avslutar slutligen processen med Ansluta sig() metod.
Dessutom kan du också skicka argument till funktionen genom att tillhandahålla args sökordsargument som så:
Accentsconagua
från multiprocessing import Process def greeting (namn): skriv ut 'hej' + "" + namn om __name__ == '__main__': p = Process (mål = hälsning, args = ('world')) p.start .Ansluta sig() Låt oss titta på ett mer detaljerat exempel som täcker alla de begrepp vi har diskuterat ovan.
I det här exemplet ska vi skapa en process som beräknar kvadraten av siffror och skriver resultaten till konsolen.
från multiprocessing import Process kvadrat (x): för x i antal: skriv ut ('% s kvadrerat% s'% (x, x ** 2)) om __name__ == '__main__': siffror = [43, 50, 5, 98, 34, 35] p = Process (mål = kvadrat, args = ('x')) p.start () p.join print "Done" #result Klar 43 kvadrat är 1849 50 kvadrat är 2500 5 kvadrat är 25 98 kvadrat är 9604 34 kvadrat är 1156 35 kvadrat är 1225 Du kan också skapa mer än en process samtidigt, som visas i exemplet nedan, i vilken process p1 får resultaten av siffror kvadrerade, medan den andra processen p2 kontrollerar om de givna siffrorna är jämn.
från multiprocessing import Process def kvadrat (x): för x i antal: print ('% s squared är% s'% (x, x ** 2)) def is_even (x): för x i tal: om x% 2 == 0: print ('% s är ett jämnt tal'% (x)) om __name__ == '__main__': siffror = [43, 50, 5, 98, 34, 35] p1 = Process (mål = args = ('x',)) p2 = Process (mål = is_even, args = ('x',)) p1.start () p2.start () p1.join () p2.join #result 43 squared är 1849 50 squared är 2500 5 squared är 25 98 squared är 9604 34 squared är 1156 35 squared är 1225 50 är ett jämnt tal 98 är ett jämnt nummer 34 är ett jämnt antal klar Multiprocessing stöder två typer av kommunikationskanaler mellan processer:
Kö Objekt används för att överföra data mellan processer. De kan lagra valfri Python-objekt, och du kan använda dem som visas i exemplet nedan:
importera multiprocessing def is_even (siffror, q): för n i tal: om n% 2 == 0: q.put (n) om __name__ == "__main__": q = multiprocessing.Queue () p = multiprocessing.Process target = is_even, args = (intervall (20), q)) p.start () p.join () medan q: print (q.get ())
I ovanstående exempel skapar vi först en funktion som kontrollerar om ett tal är jämnt och lägg sedan resultatet i slutet av kön. Vi instanserar sedan ett köobjekt och ett processobjekt och börjar processen.
Slutligen kontrollerar vi om kön är tom, och om inte, får vi värdena från könets framsida och skriver ut dem till konsolen.
Vi har visat hur du delar data mellan två processer med en kö, och resultatet är som visas nedan.
# resultat 0 2 4 6 8 10 12 14 16 18
Det är också viktigt att notera att Python har en Que-modul som lever i processmodulen och används för att dela data mellan trådar, till skillnad från multiprocessing-köen som lever i delat minne och används för att dela data mellan processer.
Rör i multiprocessing används främst för kommunikation mellan processer. Användningen är så enkel som:
från multiprocessing import Process, Rör def f (conn): conn.send ([hello world ']) conn.close () om __name__ ==' __main__ ': parent_conn, child_conn = Rör () p = Process (mål = f , args = (child_conn,)) p.start () skriv ut parent_conn.recv () p.join ()
Rör() returnerar två anslutningsobjekt som representerar rörets två ändar. Varje anslutningsobjekt har skicka() och recv () metoder. Här skapar vi en process som skriver ut strängen Hej världen och delar sedan data över.
# resultat ['hej värld']
lås arbeta genom att säkerställa att endast en process utförs i taget och därmed blockerar andra processer från att exekvera liknande kod. Detta gör att processen kan slutföras, och först då kan låset släppas.
Exemplet nedan visar en ganska enkel användning av Lås-metoden.
från multiprocessing importprocess, lås def hälsning (l, i): l.acquire () skriv ut 'hej', jag l.release () om __name__ == '__main__': lås = Lås () namn = ['Alex' 'sam', 'Bernard', 'Patrick', 'Jude', 'Williams'] för namn i namn: Process (mål = hälsning, args = (lås, namn)). start () #result hej Alex hej sam hello Bernard hej Patrick hej Jude hej Williams
I den här koden importerar vi först Lås-metoden, förvärvar den, utför utskriftsfunktionen och släpper sedan den.
Multiprocessing-modulen ger också stöd för loggning, även om loggpaketet inte använder lås så meddelanden mellan processer kan sluta blandas under körning.
Användning av loggning är lika enkelt som:
importera multiprocessing, logging logger = multiprocessing.log_to_stderr () logger.setLevel (logging.INFO) logger.warning ('Fel har inträffat')Här importerar vi först loggning och multiprocessing moduler, och vi definierar sedan multiprocessing.log_to_stderr () metod som utför ett samtal till get_logger () såväl som att lägga till en hanterare som skickar utdata till sys.stderr. Slutligen ställer vi in loggernivån och meddelandet vi vill förmedla.
Denna handledning har täckt vad som är nödvändigt för att komma igång med multiprocessing i Python. Multiprocessing övervinner problemet med GIL (Global Interpreter Lock) eftersom det utnyttjar subprocesser istället för trådar.
Det finns mycket mer i Python-dokumentationen som inte omfattas av denna handledning, så gärna besöka Python multiprocessing docs och utnyttja den fulla kraften i denna modul.
