De fork-systeemaanroep wordt gebruikt om een nieuw proces aan 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 zullen beide processen dezelfde programmateller (pc) hebben, 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.
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, maakt 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 door 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-vertragingswaarde van de onderliggende klasse is hetzelfde als de huidige timer-vertragingswaarde 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.
- Verwerk bijbehorende recordvergrendelingen (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 een geheel getal. U moet de volgende header-bestanden opnemen wanneer fork() wordt gebruikt:
#erbij betrekken
#erbij betrekken
#erbij betrekken
Bij het werken met fork(), kan worden gebruikt voor type pid_t voor processen-ID's zoals pid_t is gedefinieerd in .
Het headerbestand is waar fork() is gedefinieerd, dus je moet het aan je programma toevoegen om fork() te gebruiken.
Het retourtype is gedefinieerd in en fork()-aanroep is gedefinieerd in . Daarom moet u beide in uw programma opnemen om de systeemaanroep fork() te gebruiken.
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.
No arguments are passed to fork().
Voorbeeld 1: Calling fork()
Beschouw het volgende voorbeeld waarin we de systeemaanroep fork() hebben gebruikt om een nieuw onderliggend proces te maken:
CODE:
#erbij betrekken#erbij betrekken
#erbij betrekken
inthoofd()
{
vork();
printf ('Fork() systeemaanroep gebruiken'N');
opbrengst 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 2Ntijden, 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:
#erbij betrekken#erbij betrekken
#erbij betrekken
inthoofd()
{
vork();
vork();
vork();
vork();
printf ('Fork() systeemaanroep gebruiken');
opbrengst 0;
}
Uitgang:
Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call
Nu is het totale aantal gecreëerde processen 24= 16 en we laten onze printopdracht 16 keer uitvoeren.
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:
#erbij betrekken#erbij betrekken
#erbij betrekken
inthoofd()
{
pid_t p;
P=vork();
indien(P== -1)
{
printf ('Er is een fout opgetreden bij het aanroepen van fork()');
}
indien(P==0)
{
printf ('We zitten in het kindproces');
}
anders
{
printf ('We zitten in het ouderproces');
}
opbrengst 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 onderliggende proces 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.