Phenquestions
Fork systeemoproep
De fork-systeemaanroep wordt gebruikt om een nieuw proces te maken. Het nieuw gecreëerde proces is het onderliggende proces. Het proces dat fork aanroept en een nieuw proces creëert, is het bovenliggende proces. De onderliggende en bovenliggende processen worden gelijktijdig uitgevoerd.
Maar de onderliggende en bovenliggende processen bevinden zich op verschillende geheugenruimten. Deze geheugenruimten hebben dezelfde inhoud en welke bewerking door het ene proces wordt uitgevoerd, heeft geen invloed op het andere proces.
Wanneer de onderliggende processen worden gemaakt; nu hebben beide processen dezelfde programmateller (pc), dus beide processen zullen naar dezelfde volgende instructie verwijzen. De bestanden die door het bovenliggende proces worden geopend, zijn hetzelfde voor het onderliggende proces.
Het onderliggende proces is precies hetzelfde als het bovenliggende proces, maar er is een verschil in de proces-ID's:
- De proces-ID van het onderliggende proces is een unieke proces-ID die verschilt van de ID's van alle andere bestaande processen.
- De ouderproces-ID is hetzelfde als die van de proces-ID van de ouder van het kind child.
Eigenschappen van het onderliggende proces
Hieronder volgen enkele van de eigenschappen die een onderliggend proces heeft:
- De CPU-tellers en het resourcegebruik worden geïnitialiseerd om op nul te worden gereset.
- Wanneer het bovenliggende proces wordt beëindigd, ontvangen onderliggende processen geen signaal omdat het kenmerk PR_SET_PDEATHSIG in prctl() opnieuw is ingesteld.
- De thread die wordt gebruikt om fork() aan te roepen, creëert het onderliggende proces. Het adres van het onderliggende proces zal dus hetzelfde zijn als dat van de ouder.
- De bestandsdescriptor van het bovenliggende proces wordt overgenomen door het onderliggende proces. De offset van het bestand of de status van vlaggen en de I/O-attributen worden bijvoorbeeld gedeeld tussen de bestandsdescriptoren van onderliggende en bovenliggende processen. Dus de bestandsdescriptor van de bovenliggende klasse zal verwijzen naar dezelfde bestandsdescriptor van de onderliggende klasse.
- De beschrijvingen van de open berichtenwachtrij van het bovenliggende proces worden overgenomen door het onderliggende proces. Als een bestandsdescriptor bijvoorbeeld een bericht in het bovenliggende proces bevat, zal hetzelfde bericht aanwezig zijn in de corresponderende bestandsdescriptor van het onderliggende proces. We kunnen dus zeggen dat de vlagwaarden van deze bestandsdescriptors hetzelfde zijn.
- Op dezelfde manier zullen open directory-streams worden overgenomen door de onderliggende processen.
- De standaard Timer-slapte-waarde van de onderliggende klasse is hetzelfde als de huidige timer-slapte-waarde van de bovenliggende klasse.
Eigenschappen die niet worden overgenomen door het onderliggende proces
De volgende zijn enkele van de eigenschappen die niet worden overgenomen door een onderliggend proces:
- Geheugensloten
- Het wachtende signaal van een onderliggende klas is leeg.
- Geassocieerde recordvergrendelingen verwerken (fcntl())
- Asynchrone I/O-bewerkingen en I/O-inhoud.
- Meldingen voor directorywijzigingen.
- Timers zoals alarm(), setitimer() worden niet overgenomen door de onderliggende klasse.
vork() in C
Er zijn geen argumenten in fork() en het retourtype van fork() is integer. U moet de volgende header-bestanden opnemen wanneer fork() wordt gebruikt:
#include#include
#include
Bij het werken met fork(),
Het header-bestand
Het retourtype is gedefinieerd in
Syntaxis van fork()
De syntaxis van fork() systeemaanroep in Linux, Ubuntu is als volgt:
pid_t fork (ongeldig);In de syntaxis is het retourtype pid_t. Wanneer het onderliggende proces met succes is gemaakt, wordt de PID van het onderliggende proces geretourneerd in het bovenliggende proces en wordt 0 geretourneerd naar het onderliggende proces zelf.
Als er een fout is, wordt -1 geretourneerd naar het bovenliggende proces en wordt het onderliggende proces niet gemaakt.
Er worden geen argumenten doorgegeven aan fork().
Voorbeeld 1: Calling fork()
Beschouw het volgende voorbeeld waarin we de systeemaanroep fork() hebben gebruikt om een nieuw onderliggend proces te maken:
CODE:
#include#include
#include
int hoofd()
vork();
printf("Fork() systeemoproep gebruiken\n");
retourneer 0;
UITGANG:
Fork() systeemaanroep gebruikenFork() systeemaanroep gebruiken
In dit programma hebben we fork() gebruikt, dit zal een nieuw kindproces creëren. Wanneer het onderliggende proces is gemaakt, wijzen zowel het bovenliggende proces als het onderliggende proces naar de volgende instructie (dezelfde programmateller). Op deze manier zullen de resterende instructies of C-statements het totale aantal procestijden worden uitgevoerd, dat is 2nee keer, waarbij n het aantal fork() systeemaanroepen is.
Dus wanneer de fork()-aanroep een keer wordt gebruikt zoals hierboven (21 = 2) we zullen onze output 2 keer hebben.
Wanneer hier de systeemaanroep fork() wordt gebruikt, ziet de interne structuur er als volgt uit:
Beschouw het volgende geval waarin de fork() 4 keer wordt gebruikt:
CODE:
#include#include
#include
int hoofd()
vork();
vork();
vork();
vork();
printf("Fork() systeemaanroep gebruiken");
retourneer 0;
Uitgang:
Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork gebruiken () system call Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken Fork() system call gebruiken
Nu is het totale aantal gecreëerde processen 24 = 16 en we hebben onze printopdracht 16 keer uitgevoerd.
Voorbeeld 2: Testen of fork() succesvol was
In het volgende voorbeeld hebben we de beslissingsconstructie gebruikt om de waarde (int) te testen die wordt geretourneerd door fork(). En de bijbehorende berichten worden weergegeven:
CODE:
#include#include
#include
int hoofd()
pid_t p;
p = vork();
als(p==-1)
printf("Er is een fout opgetreden bij het aanroepen van fork()");
als(p==0)
printf("We zitten in het onderliggende proces");
anders
printf("We bevinden ons in het bovenliggende proces");
retourneer 0;
UITGANG:
We zitten in het ouderprocesWe zitten in het kinderproces
In het bovenstaande voorbeeld hebben we het type pid_t gebruikt dat de retourwaarde van fork() zal opslaan. fork() wordt online aangeroepen:
p = vork();Dus de integerwaarde die wordt geretourneerd door fork() wordt opgeslagen in p en vervolgens wordt p vergeleken om te controleren of onze fork()-aanroep succesvol was.
Wanneer de aanroep fork() wordt gebruikt en het kind met succes is gemaakt, wordt de id van het onderliggende proces geretourneerd naar het bovenliggende proces en wordt 0 geretourneerd naar het onderliggende proces.De ID van het onderliggende proces in het bovenliggende proces zal niet hetzelfde zijn als de ID van het onderliggende proces in het onderliggende proces zelf. In het onderliggende proces is de ID van het onderliggende proces 0.
Met deze tutorial kun je zien hoe je aan de slag kunt met de fork-systeemaanroep in linux.
