Apelul sistemului de furcă este utilizat pentru a crea noi procese. Procesul nou creat este procesul copil. Procesul care apelează furcă și creează un nou proces este procesul părinte. Procesele copil și părinte sunt executate simultan.
Dar procesele copilului și ale părinților se află pe diferite spații de memorie. Aceste spații de memorie au același conținut și orice operație efectuată de un proces nu va afecta celălalt proces.
Când se creează procesele copilului; acum ambele procese vor avea același Program Counter (PC), deci ambele procese vor indica aceeași instrucțiune următoare. Fișierele deschise de procesul părinte vor fi aceleași pentru procesul copil.
Procesul copil este exact același cu părintele său, dar există diferențe în ID-urile proceselor:
- ID-ul procesului procesului copil este un ID de proces unic, care este diferit de ID-urile tuturor celorlalte procese existente.
- ID-ul procesului părinte va fi același cu cel al ID-ului procesului părintelui copilului.
Proprietățile procesului copil
Următoarele sunt câteva dintre proprietățile pe care le deține un proces copil:
- Contoarele CPU și utilizările resurselor sunt inițializate pentru a reveni la zero.
- Când procesul părinte este terminat, procesele copil nu primesc niciun semnal deoarece atributul PR_SET_PDEATHSIG din prctl () este resetat.
- Firul folosit pentru a apela fork () creează procesul copil. Deci, adresa procesului copil va fi aceeași cu cea a părintelui.
- Descriptorul de fișiere al procesului părinte este moștenit de procesul copil. De exemplu, compensarea fișierului sau starea semnalizatoarelor și atributele I / O vor fi partajate între descriptorii de fișiere ale proceselor copil și părinte. Deci, descriptorul de fișiere al clasei părinte se va referi la același descriptor de fișiere din clasa copil.
- Descriptorii cozii de mesaje deschise ale procesului părinte sunt moșteniți de procesul copil. De exemplu, dacă un descriptor de fișier conține un mesaj în procesul părinte, același mesaj va fi prezent în descriptorul de fișiere corespunzător al procesului copil. Deci, putem spune că valorile de semnalizare ale acestor descriptori de fișiere sunt aceleași.
- Fluxurile de directoare deschise în mod similar vor fi moștenite de procesele copil.
- Valoarea implicită a temporizării temporizate a clasei copil este aceeași cu valoarea curentă a temporizării temporizatoare a clasei părinte.
Proprietăți care nu sunt moștenite de procesul Child
Următoarele sunt câteva dintre proprietățile care nu sunt moștenite de un proces copil:
- Blocări de memorie
- Semnalul în așteptare al unei clase de copii este gol.
- Procesează blocările înregistrărilor asociate (fcntl ())
- Operații I / O asincrone și conținut I / O.
- Notificări de modificare a directorului.
- Cronometrele precum alarm (), setitimer () nu sunt moștenite de clasa copil.
furculiță () în C
Nu există argumente în fork (), iar tipul returnat de fork () este întreg. Trebuie să includeți următoarele fișiere antet atunci când este utilizat fork ():
#include
#include
#include
Când lucrați cu furculița (), poate fi utilizat pentru tip pid_t pentru ID-urile proceselor, așa cum este definit în pid_t.
Fișierul antet este locul unde fork () este definit, deci trebuie să îl includeți în programul dvs. pentru a utiliza fork ().
Tipul de returnare este definit în și apelul fork () este definit în. Prin urmare, trebuie să includeți ambele în programul dvs. pentru a utiliza apelul de sistem fork ().
Sintaxa furcii ()
Sintaxa apelului de sistem fork () în Linux, Ubuntu este după cum urmează:
pid_t furcă (nul);În sintaxă, tipul de returnare este pid_t . Când procesul copil este creat cu succes, PID-ul procesului copil este returnat în procesul părinte și 0 va fi returnat procesului copil în sine.
Dacă există vreo eroare, atunci -1 este returnat procesului părinte și procesul copil nu este creat.
No arguments are passed to fork().
Exemplul 1: furcă de apelare ()
Luați în considerare următorul exemplu în care am folosit apelul de sistem fork () pentru a crea un proces copil nou:
COD:
#include#include
#include
intprincipal()
{
furculiţă();
printf ('Folosirea apelului de sistem fork () n');
întoarcere 0;
}
IEȘIRE:
Folosirea apelului de sistem fork ()Folosirea apelului de sistem fork ()
În acest program, am folosit fork (), acest lucru va crea un nou proces copil. Când se creează procesul copil, atât procesul părinte, cât și procesul copil vor indica următoarea instrucțiune (același contor de programe). În acest fel, instrucțiunile rămase sau instrucțiunile C vor fi executate numărul total de ori de proces, adică 2nori, unde n este numărul de apeluri de sistem fork ().
Deci, atunci când apelul fork () este folosit o dată ca mai sus (21= 2) vom avea rezultatul nostru de 2 ori.
Aici, când se folosește apelul de sistem fork (), structura internă va arăta astfel:
Luați în considerare următorul caz în care furca () este utilizată de 4 ori:
COD:
#include#include
#include
intprincipal()
{
furculiţă();
furculiţă();
furculiţă();
furculiţă();
printf („Folosirea apelului de sistem fork ()”);
întoarcere 0;
}
Ieșire:
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
Acum numărul total de procese create este 24= 16 și avem declarația de tipărit executată de 16 ori.
Exemplul 2: Testarea dacă fork () a avut succes
În exemplul următor am folosit construcția de luare a deciziilor pentru a testa valoarea (int) returnată de fork (). Și sunt afișate mesajele corespunzătoare:
COD:
#include#include
#include
intprincipal()
{
pid_t p;
p=furculiţă();
dacă(p== -1)
{
printf („Există o eroare la apelarea fork ()”);
}
dacă(p==0)
{
printf („Suntem în procesul copilului”);
}
altceva
{
printf („Suntem în procesul părinte”);
}
întoarcere 0;
}
IEȘIRE:
Suntem în procesul părinteSuntem în procesul copilului
În exemplul de mai sus am folosit tipul pid_t care va stoca valoarea returnată a forkului (). fork () este apelat on-line:
p=furculiţă();Deci, valoarea întreagă returnată de fork () este stocată în p și apoi p este comparată pentru a verifica dacă apelul nostru fork () a avut succes.
Când apelul fork () este utilizat și copilul este creat cu succes, ID-ul procesului copil va fi returnat procesului părinte și 0 va fi returnat procesului copil. ID-ul procesului copil în procesul părinte nu va fi același cu ID-ul procesului copil în procesul copil în sine. În procesul copil ID-ul procesului copil va fi 0.
Cu acest tutorial puteți vedea cum să începeți cu apelul de sistem furcă în Linux.