Jeg inviterer deg til å teste, kompilere og utføre koden ovenfor, men hvis du vil se hvordan utdataene vil se ut, og du er for "lat" til å kompilere den - når alt kommer til alt er du kanskje en sliten utvikler som samlet C-programmer hele dagen - du finner utdataene fra C-programmet nedenfor sammen med kommandoen jeg brukte til å kompilere det:

Vær ikke redd hvis utdataene ikke er 100% identiske med utdataene mine ovenfor. Husk at å kjøre ting samtidig betyr at oppgaver går ut av ordre, det er ingen forhåndsdefinert bestilling. I dette eksemplet ser du kanskje at barnet løper før foreldre venter, og det er ingenting galt med det. Generelt avhenger bestillingen av kjerneversjonen, antall CPU-kjerner, programmene som for øyeblikket kjører på datamaskinen din, osv.

OK, kom tilbake til koden. Før linjen med gaffel () er dette C-programmet helt normalt: 1 linje kjøres om gangen, det er bare en prosess for dette programmet (hvis det var en liten forsinkelse før gaffelen, kan du bekrefte det i oppgavelederen din).

Etter gaffelen () er det nå to prosesser som kan kjøre parallelt. For det første er det en barneprosess. Denne prosessen er den som er opprettet ved gaffel (). Denne underordnede prosessen er spesiell: den har ikke utført noen av kodelinjene over linjen med gaffel (). I stedet for å lete etter hovedfunksjonen, vil den heller kjøre gaffel () -linjen.

Hva med variablene deklarert før gaffel?

Vel, Linux fork () er interessant fordi den smart svarer på dette spørsmålet. Variabler og faktisk alt minnet i C-programmer blir kopiert til barneprosessen.

La meg definere hva som gjør gaffel med noen få ord: det skaper en klone av prosessen som kaller det. De to prosessene er nesten identiske: alle variablene vil inneholde de samme verdiene, og begge prosessene vil utføre linjen like etter gaffelen (). Imidlertid etter kloningsprosessen, de er atskilt. Hvis du oppdaterer en variabel i den ene prosessen, den andre prosessen vil ikke ha sin variabel oppdatert. Det er virkelig en klon, en kopi, prosessene deler nesten ingenting. Det er veldig nyttig: du kan forberede mye data og deretter fork () og bruke disse dataene i alle kloner.

Separasjonen starter når gaffel () returnerer en verdi. Den opprinnelige prosessen (den heter foreldreprosessen) får prosess-ID for den klonede prosessen. På den andre siden er den klonede prosessen (denne kalles barneprosessen) får 0-tallet. Nå bør du begynne å forstå hvorfor jeg har satt if / else if uttalelser etter fork () linjen. Ved å bruke returverdien kan du instruere barnet om å gjøre noe annet enn det foreldrene gjør - og tro meg, det er nyttig.

På den ene siden, i eksempelkoden ovenfor, gjør barnet en oppgave som tar 5 sekunder og skriver ut en melding. For å imitere en prosess som tar lang tid, bruker jeg søvnfunksjonen. Så går barnet vellykket ut.

På den andre siden skriver foreldrene ut en melding, vent til barnet går ut og til slutt skriver ut en ny melding. Det faktum at foreldrene venter på barnet er viktig. Som et eksempel venter foreldrene det meste av denne tiden på å vente på barnet sitt. Men jeg kunne ha bedt foreldrene om å gjøre noen form for langvarige oppgaver før jeg ba den vente. På denne måten ville det ha gjort nyttige oppgaver i stedet for å vente - tross alt, dette er grunnen til at vi bruker gaffel (), nei?

Imidlertid, som jeg sa ovenfor, er det veldig viktig at foreldre venter på sine barn. Og det er viktig pga zombie prosesser.

Hvordan venting er viktig

Foreldre vil generelt vite om barn er ferdig med behandlingen. For eksempel vil du kjøre oppgaver parallelt, men du absolutt ikke vil foreldrene skal avslutte før childs er ferdig, for hvis det skjedde, ville shell gi en melding mens childs ikke er ferdig ennå - som er rart.

Ventefunksjonen gjør det mulig å vente til en av barneprosessene er avsluttet. Hvis en forelder ringer 10 ganger fork (), må den også ringe 10 ganger vent (), en gang for hvert barn opprettet.

Men hva skjer hvis foreldrene kaller ventefunksjon mens alle barn har det allerede avsluttet? Det er her zombieprosesser er nødvendig.

Når et barn slutter før foreldrene ringer vent (), vil Linux-kjernen la barnet avslutte men det vil beholde en billett å fortelle barnet har gått ut. Når foreldrene ringer vent (), vil den finne billetten, slette den billetten og vente () -funksjonen kommer tilbake umiddelbart fordi det vet foreldrene trenger å vite når barnet er ferdig. Denne billetten kalles a zombie prosess.

Derfor er det viktig at foreldresamtaler vent (): hvis det ikke gjør det, forblir zombieprosesser i minnet og Linux-kjernen kan ikke ha mange zombieprosesser i minnet. Når grensen er nådd, vil datamaskinen din ikan ikke lage noen ny prosess og så vil du være i en veldig dårlig form: til og med for å drepe en prosess, må du kanskje lage en ny prosess for det. Hvis du for eksempel vil åpne oppgavebehandling for å drepe en prosess, kan du ikke, fordi oppgavebehandling vil trenge en ny prosess. Selv verste, du kan ikke drep en zombieprosess.

Derfor er det viktig å ringe vent: det tillater kjernen rydde opp barneprosessen i stedet for å fortsette å hoper seg opp med en liste over avsluttede prosesser. Og hva om foreldrene slutter uten å ringe vente()?

Heldigvis, når foreldrene blir sagt opp, kan ingen andre ringe vent () på disse barna, så det er det ingen grunn for å beholde disse zombieprosessene. Derfor når en forelder slutter, alle gjenværende zombie prosesser knyttet til denne forelderen blir fjernet. Zombie prosesser er egentlig bare nyttig for å la foreldreprosesser finne ut at et barn ble avsluttet før foreldre ringte vent ().

Nå foretrekker du kanskje å vite noen sikkerhetstiltak for å gi deg den beste bruken av gaffel uten problemer.

Enkle regler for å ha gaffelen som ønsket

For det første, hvis du kjenner til multitråding, må du ikke forkaste et program ved hjelp av tråder. Unngå faktisk å blande flere samtidige teknologier. gaffel antar å jobbe i normale C-programmer, den har kun til hensikt å klone en parallell oppgave, ikke mer.

For det andre, unngå å åpne eller åpne filer før gaffel (). Filer er noe av det eneste delt og ikke klonet mellom foreldre og barn. Hvis du leser 16 byte i foreldre, vil den flytte lesepekeren fremover på 16 byte både hos foreldrene og hos barnet. Verst, hvis barn og foreldre skriver byte til samme fil samtidig kan bytes til foreldrene være blandet med byte av barnet!

For å være tydelig, utenfor STDIN, STDOUT og STDERR, vil du virkelig ikke dele noen åpne filer med kloner.

For det tredje, vær forsiktig med stikkontakter. Stikkontakter er delte også mellom foreldre og barn. Det er nyttig for å lytte til en port og deretter ha flere barnearbeidere klare til å håndtere en ny klientforbindelse. derimot, hvis du bruker det feil, vil du få problemer.

For det fjerde, hvis du vil ringe fork () i en løkke, gjør du dette med ekstrem forsiktighet. La oss ta denne koden:

Hvis du leser koden, kan du forvente at den lager 4 barn. Men det vil heller skape 16 barn. Det er fordi childs vil også utføre sløyfen, så barn vil i sin tur ringe gaffel (). Når løkken er uendelig, kalles den a gaffelbombe og er en av måtene å bremse et Linux-system så mye at det ikke lenger fungerer og trenger omstart. I et nøtteskall, husk at Clone Wars ikke bare er farlig i Star Wars!

Nå har du sett hvordan en enkel sløyfe kan gå galt, hvordan du bruker sløyfer med gaffel ()? Hvis du trenger en løkke, må du alltid sjekke gaffelens returverdi:

Konklusjon

Nå er det på tide for deg å gjøre dine egne eksperimenter med gaffel ()! Prøv nye måter å optimalisere tid ved å utføre oppgaver på tvers av flere CPU-kjerner eller gjøre bakgrunnsbehandling mens du venter på å lese en fil!

Ikke nøl med å lese manuelle sider via man-kommandoen. Du vil lære om hvordan fork () fungerer nøyaktig, hvilke feil du kan få osv. Og nyt samtidighet!