Fork-systemanropet används för att skapa en ny process i Linux och Unix-system, som kallas barnprocess , som körs samtidigt med processen som gör att fork() anropar (överordnad process). Efter att en ny underordnad process har skapats kommer båda processerna att utföra nästa instruktion efter systemanropet fork().
Den underordnade processen använder samma pc(programräknare), samma CPU-register och samma öppna filer som används i den överordnade processen. Den tar inga parametrar och returnerar ett heltalsvärde.
Nedan finns olika värden som returneras av fork().
- Negativt värde : Skapandet av en barnprocess misslyckades.
- Noll : Återgick till den nyskapade underordnade processen.
- Positivt värde : Återlämnas till förälder eller uppringare. Värdet innehåller process-ID för den nyskapade underordnade processen.
Notera: fork() är trådbaserad funktion, för att få rätt utdata kör programmet på ett lokalt system.
Observera att ovanstående program inte kompileras i en Windows-miljö.
Exempel på gaffel() i C
C
konvertera char till int java
#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;> }> |
>
>Produktion
Hello world!, process_id(pid) = 31 Hello world!, process_id(pid) = 32>
Exempel 2: Beräkna antalet gånger hej skrivs ut.
C
#include> #include> #include> int> main()> {> >fork();> >fork();> >fork();> >printf>(>'hello
'>);> >return> 0;> }> |
>
>Produktion
hello hello hello hello hello hello hello hello>
Förklaring
Antalet gånger 'hej' skrivs ut är lika med antalet skapade processer. Totalt antal processer = 2n, där n är antalet gaffelsystemanrop. Så här n = 3, 23= 8 Låt oss sätta några etikettnamn för de tre raderna:
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>
Så det finns totalt åtta processer (nya underordnade processer och en originalprocess). Om vi vill representera relationen mellan processerna som en trädhierarki skulle det vara följande: Huvudprocessen: P0 Processer skapade av den 1:a gaffeln: P1 Processer skapade av den 2:a gaffeln: P2, P3 Processer skapade av den 3:e gaffeln: P4, P5, P6, P7
P0 / | P1 P4 P2 / P3 P6 P5 / P7>
Exempel 3: Förutsäg resultatet av följande program.
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;> }> |
>
>Produktion
Hello from Parent! Hello from Child!>
Notera: I ovanstående kod skapas en underordnad process. fork() returnerar 0 i den underordnade processen och positivt heltal i den överordnade processen. Här är två utgångar möjliga eftersom den överordnade processen och den underordnade processen körs samtidigt. Så vi vet inte om operativsystemet först kommer att ge kontroll till föräldraprocessen eller den underordnade processen.
Förälderprocess och barnprocess kör samma program, men det betyder inte att de är identiska. OS allokerar olika data och tillstånd för dessa två processer, och styrflödet för dessa processer kan vara olika. Se nästa exempel:
Exempel 4: Förutsäg resultatet av följande program.
C
jordnöt vs jordnöt
#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;> }> |
>
>Produktion
Parent has x = 0 Child has x = 2>
eller
Produktion
Child has x = 2 Parent has x = 0>
Här påverkar inte global variabel förändring i en process två andra processer eftersom data/tillstånd för de två processerna är olika. Och även förälder och barn körs samtidigt så två utgångar är möjliga.
gaffel() vs exec()
Gaffelsystemanropet skapar en ny process. Den nya processen skapad av fork() är en kopia av den aktuella processen förutom det returnerade värdet. Å andra sidan ersätter exec() systemanropet den nuvarande processen med ett nytt program.
Problem baserade på C-gaffel()
1. En process exekverar följande kod
C
for> (i = 0; i fork();> |
rom
>
>
Det totala antalet underordnade processer som skapas är (GATE-CS-2008)
(En
(B) 2^n – 1
(C) 2^n
(D) 2^(n+1) – 1
Se detta för en lösning.
2. Tänk på följande kodfragment:
C
if> (fork() == 0) {> >a = a + 5;> >printf>(>'%d, %d
'>, a, &a);> }> else> {> >a = a –5;> >printf>(>'%d, %d
'>, a, &a);> }> |
>
>
Låt u, v vara de värden som skrivs ut av den överordnade processen, och x, y vara de värden som skrivs ut av den underordnade processen. Vilket av följande är SANT? (GATE-CS-2005)
(A) u = x + 10 och v = y
(B) u = x + 10 och v != y
(C) u + 10 = x och v = y
(D) u + 10 = x och v != y
Se detta för en lösning.
3. Förutsäg resultatet av programmet nedan.
C
#include> #include> int> main()> > >fork();> >fork() && fork()> |
>
>
byt namn på katalogen på linux
Se detta för lösningen
Relaterade artiklar :
- C-program för att demonstrera gaffel() och pipe()
- Zombie och föräldralösa processer i C
- fork() och minnesdelade svartvita processer skapade med hjälp av den