La trucada al sistema de forquilla s’utilitza per crear processos nous. El procés recentment creat és el procés fill. El procés que crida fork i crea un nou procés és el procés principal. Els processos fill i pare s’executen simultàniament.
Però els processos dels fills i dels pares resideixen en diferents espais de memòria. Aquests espais de memòria tenen el mateix contingut i qualsevol operació que faci un procés no afectarà l'altre procés.
Quan es crea el procés infantil; ara tots dos processos tindran el mateix comptador de programes (PC), de manera que tots dos processos apuntaran a la mateixa instrucció següent. Els fitxers oberts pel procés pare seran els mateixos per al procés fill.
El procés fill és exactament el mateix que el seu pare, però hi ha diferències en els identificadors de processos:
- L'identificador de procés del procés fill és un identificador de procés únic que és diferent dels identificadors de tots els altres processos existents.
- L'identificador de procés principal serà el mateix que l'identificador de procés del pare o la mare del fill.
Propietats del procés infantil
Les següents són algunes de les propietats que té un procés fill:
- Els comptadors de CPU i les utilitzacions de recursos s’inicialitzen per restablir-se a zero.
- Quan es finalitza el procés pare, els processos fills no reben cap senyal perquè es restableix l'atribut PR_SET_PDEATHSIG a prctl ().
- El fil utilitzat per anomenar fork () crea el procés fill. Per tant, l’adreça del procés fill serà la mateixa que la dels pares.
- El descriptor de fitxers del procés pare és heretat pel procés fill. Per exemple, el desplaçament del fitxer o l'estat de les marques i els atributs d'E / S es compartiran entre els descriptors de fitxers dels processos fill i pare. Per tant, el descriptor de fitxers de la classe pare es referirà al mateix descriptor de fitxers de la classe fill.
- Els descriptors de la cua de missatges oberts del procés pare són heretats pel procés fill. Per exemple, si un descriptor de fitxers conté un missatge en procés principal, el mateix missatge estarà present al descriptor de fitxer corresponent del procés fill. Per tant, podem dir que els valors de senyalització d’aquests descriptors de fitxers són els mateixos.
- Els fluxos de directori oberts de manera similar seran heretats pels processos fills.
- El valor per defecte del temporitzador de la classe fill és el mateix que el valor actual del temporitzador de la classe pare.
Propietats que no són heretades pel procés fill
A continuació, es mostren algunes de les propietats que un procés fill no hereta:
- Panys de memòria
- El senyal pendent d'una classe infantil està buit.
- Procés de bloqueig de registres associats (fcntl ())
- Operacions d'E / S asíncrones i continguts d'E / S.
- Notificacions de canvis de directori.
- Els temporitzadors com alarm (), setitimer () no són heretats per la classe infantil.
fork () en C.
No hi ha arguments a fork () i el tipus de retorn de fork () és sencer. Heu d'incloure els fitxers de capçalera següents quan s'utilitza fork ():
#incloure
#incloure
#incloure
Quan es treballa amb forquilla (), es pot utilitzar per al tipus pid_t per als identificadors de processos tal com es defineix a pid_t.
El fitxer de capçalera és on es defineix fork (), de manera que heu d'incloure'l al programa per utilitzar fork ().
El tipus de retorn es defineix a i la trucada fork () es defineix a. Per tant, heu d’incloure tots dos al programa per utilitzar la trucada al sistema fork ().
Sintaxi de fork ()
La sintaxi de la trucada al sistema fork () a Linux, Ubuntu és la següent:
pid_t fork (void);A la sintaxi, el tipus de retorn és pid_t . Quan es crea correctament el procés fill, es torna el PID del procés fill al procés pare i es retornarà 0 al procés fill mateix.
Si hi ha algun error, -1 es torna al procés principal i no es crea el procés fill.
No arguments are passed to fork().
Exemple 1: bifurcació de trucades ()
Penseu en el següent exemple en què hem utilitzat la trucada del sistema fork () per crear un procés secundari nou:
CODI:
#incloure#incloure
#incloure
intprincipal()
{
forquilla();
printf ('Utilitzant una trucada al sistema fork () n');
tornar 0;
}
SORTIDA:
Utilitzant una trucada al sistema fork ()Utilitzant una trucada al sistema fork ()
En aquest programa, hem utilitzat fork (), això crearà un procés secundari nou. Quan es crea el procés fill, tant el procés pare com el procés fill apuntaran a la següent instrucció (el mateix comptador de programes). D'aquesta manera, les instruccions o instruccions C restants s'executaran el nombre total de temps de procés, és a dir, 2nvegades, on n és el nombre de trucades al sistema fork ().
Per tant, quan s’utilitza la trucada fork () una vegada com s’ha indicat anteriorment (21= 2) tindrem la nostra sortida 2 vegades.
Quan s’utilitza la trucada del sistema fork (), l’estructura interna serà:
Penseu en el cas següent en què s’utilitza la forquilla () 4 vegades:
CODI:
#incloure#incloure
#incloure
intprincipal()
{
forquilla();
forquilla();
forquilla();
forquilla();
printf ('Utilització de la trucada al sistema fork ()');
tornar 0;
}
Sortida:
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
Ara el nombre total de processos creats són 24= 16 i tenim la nostra instrucció d'impressió executada 16 vegades.
Exemple 2: comprovar si fork () ha estat correcte
A l'exemple següent hem utilitzat la construcció de presa de decisions per provar el valor (int) que retorna fork (). I es mostren els missatges corresponents:
CODI:
#incloure#incloure
#incloure
intprincipal()
{
pid_t pàg;
pàg=forquilla();
si(pàg== -1)
{
printf ('Hi ha un error en trucar a fork ()');
}
si(pàg==0)
{
printf ('Estem en procés infantil');
}
en cas contrari
{
printf ('Estem en el procés principal');
}
tornar 0;
}
SORTIDA:
Estem en el procés principalEstem en procés infantil
A l'exemple anterior hem utilitzat el tipus pid_t que emmagatzemarà el valor retornat de fork (). fork () es diu en línia:
pàg=forquilla();Així, el valor enter retornat per fork () s’emmagatzema a p i es compara p per comprovar si la trucada fork () ha tingut èxit.
Quan s’utilitza la trucada fork () i es crea el fill amb èxit, l’identificador del procés fill es retornarà al procés principal i 0 es retornarà al procés fill. L’identificador del procés fill al procés pare no serà el mateix que el Identificació del procés fill en el procés fill mateix. En el procés fill, l'identificador del procés fill serà 0.
Amb aquest tutorial podeu veure com començar amb la trucada del sistema fork a Linux.