De Fork-systeemaanroep wordt gebruikt voor het maken van een nieuw proces in Linux- en Unix-systemen, dat de kind proces , dat gelijktijdig wordt uitgevoerd met het proces dat de fork()-aanroep doet (bovenliggend proces). Nadat een nieuw onderliggend proces is aangemaakt, zullen beide processen de volgende instructie uitvoeren na de systeemaanroep fork().
Het onderliggende proces gebruikt dezelfde pc (programmateller), dezelfde CPU-registers en dezelfde geopende bestanden die in het bovenliggende proces worden gebruikt. Er zijn geen parameters nodig en het retourneert een geheel getal.
Hieronder staan verschillende waarden die door fork() worden geretourneerd.
- Negatieve waarde : Het maken van een onderliggend proces is mislukt.
- Nul : Teruggekeerd naar het nieuw gemaakte onderliggende proces.
- Positieve waarde : Teruggestuurd naar ouder of beller. De waarde bevat de proces-ID van het nieuw gemaakte onderliggende proces.
Opmerking: fork() is een op threading gebaseerde functie, om de juiste uitvoer te krijgen, voert u het programma uit op een lokaal systeem.
Houd er rekening mee dat de bovenstaande programma's niet in een Windows-omgeving compileren.
Voorbeeld van fork() in C
C
java hallo wereld voorbeeld
#include> #include> #include> int> main()> {> > >// make two process which run same> >// program after this instruction> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >printf>(>'Hello world!, process_id(pid) = %d
'>,getpid());> >return> 0;> }> |
>
>Uitvoer
Hello world!, process_id(pid) = 31 Hello world!, process_id(pid) = 32>
Voorbeeld 2: Bereken het aantal keren dat hallo wordt afgedrukt.
C
#include> #include> #include> int> main()> {> >fork();> >fork();> >fork();> >printf>(>'hello
'>);> >return> 0;> }> |
>
>Uitvoer
hello hello hello hello hello hello hello hello>
Uitleg
Het aantal keren dat ‘hallo’ wordt afgedrukt, is gelijk aan het aantal aangemaakte processen. Totaal aantal processen = 2N, waarbij n het aantal fork-systeemoproepen is. Dus hier n = 3, 23= 8 Laten we enkele labelnamen voor de drie regels plaatsen:
fork (); // Line 1 fork (); // Line 2 fork (); // Line 3 L1 // There will be 1 child process / // created by line 1. L2 L2 // There will be 2 child processes / / // created by line 2 L3 L3 L3 L3 // There will be 4 child processes // created by line 3>
Er zijn dus in totaal acht processen (nieuwe onderliggende processen en één origineel proces). Als we de relatie tussen de processen als een boomhiërarchie willen weergeven, zou dit er als volgt uitzien: Het hoofdproces: P0 Processen gecreëerd door de 1e fork: P1 Processen gecreëerd door de 2e fork: P2, P3 Processen gecreëerd door de 3e fork: P4, P5, P6, P7
P0 / | P1 P4 P2 / P3 P6 P5 / P7>
Voorbeeld 3: Voorspel de uitvoer van het volgende programma.
C
#include> #include> #include> #include> void> forkexample()> {> >pid_t p;> >p = fork();> >if>(p<0)> >{> >perror>(>'fork fail'>);> >exit>(1);> >}> >// child process because return value zero> >else> if> ( p == 0)> >printf>(>'Hello from Child!
'>);> > >// parent process because return value non-zero.> >else> >printf>(>'Hello from Parent!
'>);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Uitvoer
Hello from Parent! Hello from Child!>
Opmerking: In de bovenstaande code wordt een onderliggend proces gemaakt. fork() retourneert 0 in het onderliggende proces en een positief geheel getal in het bovenliggende proces. Hier zijn twee uitgangen mogelijk omdat het bovenliggende proces en het onderliggende proces gelijktijdig worden uitgevoerd. We weten dus niet of het besturingssysteem eerst de controle over het bovenliggende proces of het onderliggende proces zal geven.
Het bovenliggende proces en het onderliggende proces voeren hetzelfde programma uit, maar dit betekent niet dat ze identiek zijn. OS wijst verschillende gegevens en statussen toe voor deze twee processen, en de besturingsstroom van deze processen kan verschillend zijn. Zie het volgende voorbeeld:
Voorbeeld 4: Voorspel de uitvoer van het volgende programma.
C
np waar
#include> #include> #include> #include> > void> forkexample()> {> >int> x = 1;> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >else> if> (p == 0)> >printf>(>'Child has x = %d
'>, ++x);> >else> >printf>(>'Parent has x = %d
'>, --x);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Uitvoer
Parent has x = 0 Child has x = 2>
of
als door Rudyard Kipling samenvatting
Uitvoer
Child has x = 2 Parent has x = 0>
Hier heeft de globale variabeleverandering in één proces geen invloed op twee andere processen, omdat de gegevens/status van de twee processen verschillend zijn. En ook ouder en kind draaien gelijktijdig waardoor er twee uitgangen mogelijk zijn.
fork() versus exec()
De fork-systeemaanroep creëert een nieuw proces. Het nieuwe proces gemaakt door fork() is een kopie van het huidige proces, behalve de geretourneerde waarde. Aan de andere kant vervangt de systeemaanroep exec() het huidige proces door een nieuw programma.
Problemen gebaseerd op C-vork()
1. Een proces voert de volgende code uit
C
for> (i = 0; i fork();> |
>
>
Het totale aantal gemaakte onderliggende processen is (POORT-CS-2008)
(Een
(B) 2^n – 1
(C) 2^n
(D) 2^(n+1) – 1
Zie dit voor een oplossing.
2. Beschouw het volgende codefragment:
C
string java-indexof
if> (fork() == 0) {> >a = a + 5;> >printf>(>'%d, %d
'>, a, &a);> }> else> {> >a = a –5;> >printf>(>'%d, %d
'>, a, &a);> }> |
>
>
Laat u, v de waarden zijn die door het ouderproces worden afgedrukt, en x, y de waarden die door het kindproces worden afgedrukt. Welke van de volgende beweringen is WAAR? (POORT-CS-2005)
(A) u = x + 10 en v = y
(B) u = x + 10 en v != y
(C) u + 10 = x en v = y
(D) u + 10 = x en v != y
Zie dit voor een oplossing.
3. Voorspel de uitvoer van het onderstaande programma.
C
#include> #include> int> main()> > >fork();> >fork() && fork()> |
>
>
Zie dit voor de oplossing
Gerelateerde artikelen :
- C-programma om fork() en pipe() te demonstreren
- Zombie- en weesprocessen in C
- fork() en geheugen gedeelde zwart-witprocessen die ermee zijn gemaakt