Python multiprosesseringslås

Pythons multiprosesseringspakke lar brukerne lage nye prosesser og få tilgang til Python API. Hvis du noen gang har lekt med trådmodulen, er dette veldig sammenlignbart. Flere oppgaveutførelser er nødvendig. Vi må importere multiprosesseringsmodulen til Python -skriptet for å utføre multiprosesseringsoperasjoner. Når to prosesser eller tråder prøver å få tilgang til en delt ressurs som minnefiler eller andre data, kan det føre til problemer i programmeringsverdenen. Dermed må vi sikre den tilgangen ved hjelp av en lås. Deling av hovedminnet og tilbehøret lar behandlingsenhetene kjøre programmene samtidig.

Multiprosesseringsapplikasjonen deler seg opp i mindre enheter og fungerer separat. Operativsystemet tildeler en prosessor til hver prosess. For å forhindre at en annen prosess kjører en tilsvarende funksjon til låsen er utgitt, bruker vi multiprosesseringslåseklassen for å få en lås på prosessen. Låseklassen utfører først og fremst to funksjoner. Acquire () -metoden brukes til å først få en lås, mens frigjøringsfunksjonen () brukes til å frigjøre låsen.

Pythons implementering av låsen () i multiprosessering

I dette eksemplet konstruerer vi en lås og bruker deretter multiprosesseringsmodulen for å bruke Lock () -metoden etter å ha opprettet to prosesser. Vi kan generere og vedlikeholde de nye barneoppgavene i Python ved å bruke multiprosesseringspakken. Den multiprosesseringskomponenten gjør det lettere å lage prosessene ved å bruke et grensesnitt som ligner på trådkomponenten. Multiprosesseringsmodulen støtter både lokal og global samtidighet ved bruk av individuelle deler i stedet for tråder, og eliminerer den globale tolkningslåsen. Python har en mutex -lås som kan brukes med flere prosesser på en gang.Klasselås. Prosesser kan konstruere, skaffe og deretter frigjøre et objekt av låsingen før du får tilgang til et viktig område.

La oss nå begynne å implementere koden for å kjøre Python Multiprocessing -skriptet. “Spyder” brukes også. Vi importerer først multiprosesseringsmodulen. Vi må importere multiprosesseringsmodulen siden vi må lage en prosess i skriptet. Etter det bygger vi en brukerdefinert funksjon som heter “Funksjon” og passerer “Lock” -argumentet til det i linjen som følger. Acquire () -metoden kalles deretter med "lås" -frasen som gir en trådmyndighet over en lås. En tråd blokkerer til den andre tråden slipper låsen hvis den prøver å skaffe seg en som allerede blir holdt av en annen tråd. I det øyeblikket konkurrerer den med alle andre tråd som søker å gripe låsen. En tråd om gangen kan bare ha låsen. Uttalelsen om "viktig seksjon" blir deretter ført som inndata når vi kaller "print ()" i følgende trinn følgende.

Deretter, i det påfølgende trinnet, kaller vi "print ()" -funksjonen en gang til, og passerer den uttrykket "det kan bare være en prosess om gangen" før vi kaller "Release ()" -funksjonen med "låsen". Når det er gjort på denne måten, slippes låsen alltid selv om det er en feil eller feil i den avgjørende regionen, og tydelig definerer begynnelsen og slutten av den beskyttede koden.

Nå som vi definerte en funksjon med navnet "Funksjon Run", går vi videre til neste fase der vi oppretter en prosess og deretter kaller den ved hjelp av "Lock ()" -modulen. Vi holder den i låsparameteren og bruker “Multiprosessing.lås () ”for å ringe låsen med prosessen. Nå som vi opprettet prosess 1, bruker vi “Multiprocessing.prosess ”for å kalle funksjonen i den prosessen. Vi gir også argumentlåsen til funksjonen ved å bruke "Argu" = "-låsen" og lagre prosessen 1 i "P1" -variabelen.

Deretter, i det følgende trinn, bruker vi “Multiprocessing.prosess ”for å kjøre funksjonen i prosess 2 og passere“ Target = -funksjonen ”mens du lagrer den i“ P2 ”-variabelen. Prosessen starter deretter ved å bruke "start ()" -funksjonen med "P1" og "P2". I neste trinn bruker vi “Join ()” med “P1” og “P2” for å vente på at prosessutførelsen skal være ferdig. Deretter bruker vi "hvis navn = main_", som egentlig er et inngangspunkt. "Funksjonsløpet ()" blir deretter påkalt på slutten.

For å oppnå dette, må prosessen først skaffe låsen før du utfører den essensielle delen. Når den kritiske fasen av oppgaven er ferdig, må prosessen fjerne låsen. Både de to prosessene og uttalelsene deres ble vist. Det kan bare være en enkelt oppgave som kjører om gangen presentert etter “Kritiske delen.”

Vi har nå et annet Python multiprosesseringslåseksempel. La oss starte med å importere "søvn" fra tidsmodulen før vi importerer "tilfeldig" fra den tilfeldige modulen. Heltall genereres tilfeldig ved bruk av et Python -program som heter Python Random. Fordi de er pseudo-tilfeldige, er disse tallene ikke virkelig tilfeldige. Du kan bruke denne pakken til å utføre andre tilfeldige operasjoner, skrive ut et tilfeldig tall for en liste eller streng, og generere tilfeldige tall.

Deretter importerer vi prosessen fra multiprosessering i følgende linje. Låsen importeres deretter fra multiprosessering. Funksjonen "func" er deretter definert med "låsen", "identifikatoren" og "val" argumenter som blir bestått. Deretter bruker vi en lås for å få låsen. Denne avgjørende delen innebærer å rapportere en melding og blokkere en ny melding.

Som et resultat utfører vi metoden Print () i låsen, og gir uttalelsen sammen med "identifikatoren" og "val" -samtaler. "Sleep ()" -metoden brukes til å pause utførelsen i et bestemt antall sekunder. Vi kaller da "val" i parentesene. Den delte låsen er etablert ved hjelp av "Lock ()" -metoden og lagres i den nyopprettede "lås" -variabelen når vi bruker "IF Name = main_" -tilstanden. Deretter bruker vi prosessen () -metoden for å lage en prosess, og passerer “Target = FUNC” for å kalle funksjonen inn i prosessen sammen med “Lock” -argumentet, det konstruerte tallet “X”, og “Random ()” funksjon. Denne sløyfen avsluttes etter å ha fullført sine "15" iterasjoner. Vi lagrer denne prosessen i "P" -variabelen.

Her etablerer vi også rekkevidden ved å bruke “for” og sette rekkevidden til “15”. Prosessen starter nå med å ringe "prosessen.start()". Deretter kaller vi prosessen med “Join ()” -metoden for å vente på utførelsen.

Når eksemplet blir utført, startes femten prosesser og hver og en er konfigurert til å bruke vår tilpassede funksjon. Etter det venter hovedprosessen på at hver av barneprosessene skal fullføres før de lanserer dem. Hver barneprosess i funksjonen () -metoden prøver å ta tak i låsen. Låsen kan bare oppnås ved en prosess om gangen. Når det skjer, sender de en melding inkludert identiteten deres og hvor lenge de planlegger å sove så vel som indeksen er ute av drift fordi den vises i utgangen så snart operasjonen er ferdig.

Konklusjon

Vi lærte om Python multiprosesseringslås i denne artikkelen. Låsen er et grunnleggende konsept i multiprosessering og operativsystemteori. I den første delen av eksemplet opprettet vi to prosesser ved hjelp av en lås og ringte dem ved hjelp av en lås for å utføre funksjonen som vi definerte. I den følgende delen av koden brukte vi For-loop og satte rekkevidden til “15” for å utføre prosessen. Prosessen avsluttes når den er fullført sine "15" iterasjoner. I den andre delen benyttet vi også "Sleep ()" -teknikken for å utsette utførelsen en kort stund.