Python multiprosesseringseksempel

Python er et programmeringsspråk som er gunstig i å utvikle nettsteder og applikasjoner. Også involvert i datavisualisering og analyse. Det er relativt et enkelt språk og brukes ofte av til og med ikke-programmerere. Denne artikkelen refererer til bruk av multiprosessering i Python.

Multiprosessering

Multiprosessering omhandler potensialet i et system som støtter mer enn en prosessor om gangen. Alle applikasjoner i multiprosessering blir revet til små mønstre, og hvert av disse mønstrene er selvavhengige når det gjelder å jobbe. I denne typen prosesser brukes to eller flere prosesser. Bare la oss vurdere at en datamaskin kjører med bruk av en enkelt prosessor. Hvis vi tildeler flere prosessorer samtidig, vil den strekke hver oppgavebytte til en annen oppgave etter en kort tid for å holde alle prosessene i gang. Med andre ord, hvis det er flere oppgaver som skal gjøres, vanskeligere, vil det være å opprettholde dem på sporet av fullføring. Mens det også er en stor utfordring å fordele hver oppgave. I denne tilstanden må vi oppstå begrepet multiprosessering. Et multiprosesseringssystem kan tillate.

• Multiprosessor: En datamaskin som bruker mer enn en sentral prosessor.
• Multi-core prosessor: En enkelt komponent som bruker to eller flere prosesseringsenheter.

Multiprosessering i Python

Ved hjelp av multiprosesseringskonseptet kan den sentrale prosesseringsenheten enkelt utføre flere oppgaver på en enkelt tid. Python bruker multiprosesseringsmodulen for å introdusere parallelle koder. For å implementere multiprosessering, må du først vite om antall kjerner i systemet ditt. Vi har brukt et enkelt stykke kode her for å vite om CPU -ene som jobber om gangen.

For Python kan du bruke noe annet verktøy for å oppnå kodene. Vi har brukt Spyder -verktøyet for dette formålet som sikkert vil utføre Python -språkkodene.

Importer multiprosessering

trykk ("Antall CPU:", Multiprocessing.cpu_count ())

For det første må vi importere pakken "PG" multiprosessering som vil gjøre det mulig. For hver PC kan utgangen variere. For meg er antall kjerner 4.

Eksempel 1:

Ved hjelp av en multiprosesseringsmodul vil vi beregne kube- og firkantede funksjoner.

La oss forstå den ovennevnte koden. Vi opprettet en prosess, og så opprettet vi et objekt for å behandle klassen.

P1 = multiprosessering.prosess (print (print_cube (5,)))
P2 = multiprosessering.prosess (print (print_square (2,)))

P1 og P2 er gjenstandene for prosessene. Disse prosessene inneholder den funksjonelle samtalen som har en utskriftsfunksjon som direkte vil kalle funksjonen med argumenter som parameter. Print_cube, og print_square.

Vi bruker startmetoder for å starte prosessen.

P1.start()
P2.start()

En av funksjonene som brukes er beskrevet som.

def print_square (num):
Print ("Square: ".Format (num * num))

Den firkantede funksjonen vil beregne torget ved å multiplisere det gitte tallet som brukes i funksjonssamtalen. Funksjonen tar nummeret i variabelen “Num”.

Når vi utfører koden, vil utdataene vise de resulterende verdiene for begge funksjonene.

Eksempel 2:

Ved hjelp av datastrukturer må du være kjent med bruk av stabler og køer på programmeringsspråket. Fra multiprosesseringsmodulen importerer vi en køklasse her som er FIFO (først i første ut) datastruktur. Det vil være to prosesser som fungerer alternativt. Vi bruker to funksjoner her. Put () -funksjonen brukes her for å sette inn data i køen. Mens vi bruker get () for å hente varene fra køen. Nedenfor er koden som illustrerer arbeidet med multiprosessering i køen. Det første trinnet er å introdusere køer.

Fra multiprosessering av importkø

Etter å ha importert modulen, introduserer du navnene på bilen til array -variabelen. Vi vil bruke en for loop for å sette inn verdiene i køen, og put () vil gjøre det slik. En "CNT" -variabel brukes til å telle antallet biler som brukes. Initialiser køobjektet gjennom uttalelsen.

Kø = kø ()

Deretter brukes en sløyfe til å legge til verdier; Dette vil bruke et "kø" nøkkelord for å bruke Put () -funksjonen for å argumentere som bilens navn som skal settes inn. "CNT" -funksjonen vil bli økt etter hver innsetting.

For bil i biler:

Kø.Put (bil)
CNT += 1

Tilsvarende, for Put (), brukes en stundsløyfe til hele køen ikke er tom.

Mens du ikke kø.tømme():

Skriv ut ('Element nr:', cnt, ", kø.få())
CNT+= 1

Utgangen viser begge funksjonene som fungerer uavhengig. Når en funksjon er fullført arbeidet, brukes den andre prosessen.

Eksempel 3:

Dette eksemplet inneholder to prosesser. I hver prosess oppnås “PID” gjennom Get () -funksjonen. Vi har brukt to moduler. Den ene er multiprosessering, og den andre er operativsystem OS.

Hver prosess tildeles en annen ID.

Def prosess ():

Print (“ID for prosessløpende arbeider1: ”.Format (OS.getPid ())))

Meldingen er sammenkoblet med funksjonssamtalen for å motta prosess -ID. I hovedprogrammet blir hovedprosess -ID hentet ved å bruke den samme tilnærmingen gjennom get (). Deretter opprettes prosesser gjennom multiprosessering. Hver prosess får tilgang til gjennom sine respektive objekter. Jeg.e., For prosess 1 er objektet P1.

P1 = multiprosessering.Prosess (mål = prosess1)

Mål er funksjonen som skal utføres av prosessen. Når prosessene opprettes, må de komme i gang. Status for hver prosess vises; For dette må vi overvåke fullføringen av prosessen. Dette vil trenge litt tid på å vente. Vi vil bruke en funksjon som vil vente til fullstendig utførelse av prosessen.

P1.bli med()

Når denne sammenføyningsfunksjonen får signalet, skriver den ut uttalelsen om at utførelsen er fullført. Et boolsk flagg vil avgjøre at enten prosessen er i live eller ikke; Hvis ja, så er det sant, ellers er det usant.

Print (“Prosess P1 er i live: ”.Format (P1.er i live()))

Utfør nå programmet og ta utgangen. Du kan se at hoved -IDen først vises, og deretter prosess -ID for hver prosess. Etter at utførelsen er ferdig, vises statusen for begge prosessene, det vil si "falsk".

Eksempel 4:

I dette eksemplet vil du se arbeidet med multiprosessering og importtid, basseng, CPU_Count. Pool brukes til å utføre prosesser med flere innganger og distribuere disse inngangsdataene mellom prosessene. En firkantet funksjon vil beregne kvadratet til inngangsverdien. Ved å bruke tidsmodulen fra pakken, bruker vi søvnfunksjonen.

Tid.søvn (3)

Denne funksjonen har en tidsutvidelse på 3 sekunder. Det betyr at verdien av denne funksjonen vil bli vist etter denne spesifikke tiden. I hovedprogrammet starter vi tidtakeren, og deretter tildeles dummyverdiene til hver 4 kjerner.

Med basseng () som basseng:

Res = basseng.Kart (firkant, verdier)
Trykk (res)

Bassengfunksjonen gir verdier og kaller funksjonen samtidig. Da må vi stoppe tidtakeren. Denne timerfunksjonen vil telle sekundene som brukes til denne funksjonen, kjent som forløpt tid; Det oppnås ved å trekke fra startverdien av tid fra sluttverdien.

Utfør nå programmet. Den første linjen vises, og så tar det 3 sekunder. Etter det vises et annet resultat.

Konklusjon

“Python Multiprocessing Eksempel” er en kort introduksjon til multiprosesseringsfenomenet. Hvert eksempel forklart her importerer forskjellige pakker fra multiprosesseringsmodulen. Denne håndteringen av prosesser parallelt med hverandre oppnås gjennom antall CPU -er. Mer antall CPUer som er større vil være sjansen for god multiprosessering.