Sistema fork Call Linux
Ma i processi di figlio e genitore risiedono su diversi spazi di memoria. Questi spazi di memoria hanno lo stesso contenuto e qualunque operazione venga eseguita da un processo non influirà sull'altro processo.
Quando vengono creati i processi figlio; Ora entrambi i processi avranno lo stesso contatore del programma (PC), quindi entrambi questi processi indicheranno la stessa istruzione successiva. I file aperti dal processo genitore saranno gli stessi per il processo figlio.
Il processo figlio è esattamente lo stesso del suo genitore, ma c'è differenza negli ID dei processi:
- L'ID processo del processo figlio è un ID processo univoco che è diverso dagli ID di tutti gli altri processi esistenti.
- L'ID processo genitore sarà lo stesso di quello dell'ID processo del genitore del figlio.
Proprietà del processo figlio
Di seguito sono riportate alcune delle proprietà che contiene un processo figlio:
- I contatori della CPU e le utilizioni delle risorse vengono inizializzate per ripristinare a zero.
- Quando il processo genitore viene terminato, i processi figlio non ricevono alcun segnale perché l'attributo PR_SET_PDEATSIG in PRCTL () viene ripristinato.
- Il thread usato per chiamare il fork () crea il processo figlio. Quindi l'indirizzo del processo figlio sarà lo stesso di quello del genitore.
- Il descrittore dei file del processo genitore è ereditato dal processo figlio. Ad esempio, l'offset del file o lo stato delle flag e gli attributi I/O verrà condiviso tra i descrittori di file dei processi di figlio e genitore. Quindi il descrittore di file della classe genitore si riferirà allo stesso descrittore di file della classe figlio.
- I descrittori di coda di messaggi aperti del processo genitore sono ereditati dal processo figlio. Ad esempio, se un descrittore di file contiene un messaggio nel processo genitore, lo stesso messaggio sarà presente nel corrispondente descrittore di file del processo figlio. Quindi possiamo dire che i valori di flag di questi descrittori di file sono gli stessi.
- Allo stesso modo i flussi di directory aperti saranno ereditati dai processi figlio.
- Il valore di allentamento del timer predefinito della classe figlio è uguale al valore di lento del timer corrente della classe genitore.
Proprietà che non sono ereditate dal processo per bambini
Di seguito sono riportate alcune delle proprietà che non sono ereditate da un processo di bambino:
- Blocchi di memoria
- Il segnale in sospeso di una classe figlio è vuoto.
- Blocchi di record associati al processo (fcntl ())
- Operazioni I/O asincroni e contenuto I/O.
- Notifiche di cambiamento di directory.
- Timer come allarme (), setitimer () non sono ereditati dalla classe figlio.
fork () in c
Non ci sono argomenti in fork () e il tipo di ritorno di fork () è intero. È necessario includere i seguenti file di intestazione quando viene utilizzato FORK ():
#includere#includere
#includere
Quando si lavora con fork (), può essere utilizzato per il tipo pid_t Per i processi ID come PID_T è definito in .
Il file di intestazione è dove è definito FORK (), quindi è necessario includerlo al programma per utilizzare FORK ().
Il tipo di ritorno è definito in e la chiamata fork () è definita in . Pertanto, è necessario includere entrambi nel programma per utilizzare la chiamata di sistema fork ().
Sintassi di fork ()
La sintassi del sistema FORK () Chiama in Linux, Ubuntu è la seguente:
fork pid_t (void);Nella sintassi il tipo di ritorno è pid_t. Quando il processo figlio viene creato con successo, il PID del processo figlio viene restituito nel processo genitore e 0 verrà restituito al processo figlio stesso.
In caso di errore, viene restituito al processo genitore e il processo figlio non viene creato.
Non vengono passati argomenti a fork ().Esempio 1: chiamando fork ()
Considera il seguente esempio in cui abbiamo usato la chiamata di sistema FORK () per creare un nuovo processo di figlio:
#includere#includere
#includere
int main ()
forchetta();
printf ("Utilizzo della chiamata di sistema FORK () \ n");
restituzione 0;
PRODUZIONE:
sysads@linuxhint $ gcc fork.C -o forksysads@linuxhint $ ./forchetta
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
In questo programma, abbiamo usato FORK (), questo creerà un nuovo processo per bambini. Quando viene creato il processo figlio, sia il processo genitore che il processo figlio indicheranno l'istruzione successiva (lo stesso contatore del programma). In questo modo le restanti istruzioni o le dichiarazioni C verranno eseguite il numero totale di tempi di processo, ovvero 2N volte, dove n è il numero di chiamate di sistema fork ().
Quindi quando la chiamata fork () viene utilizzata una volta come sopra (21 = 2) Avremo il nostro output 2 volte.
Qui quando viene utilizzata la chiamata di sistema fork (), la struttura interna sarà simile:
Considera il seguente caso in cui il fork () viene utilizzato 4 volte:
#includere#includere
#includere
int main ()
forchetta();
forchetta();
forchetta();
forchetta();
printf ("Utilizzo della chiamata di sistema FORK () \ n");
restituzione 0;
Produzione:
sysads@linuxhint $ gcc fork.C -o forksysads@linuxhint $ ./forchetta
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
Utilizzo della chiamata di sistema FORK ()
sysads@linuxhint $
Ora il numero totale di processi creati è 24 = 16 e abbiamo eseguito la nostra dichiarazione di stampa 16 volte.
Esempio 2: test se fork () ha avuto successo
Nell'esempio seguente abbiamo usato il costrutto decisionale per testare il valore (int) restituito da fork (). E vengono visualizzati i messaggi corrispondenti:
#includere#includere
#includere
int main ()
pid_t p;
p = fork ();
if (p ==-1)
printf ("C'è un errore mentre si chiama fork () \ n");
if (p == 0)
printf ("Siamo nel processo figlio \ n");
altro
printf ("Siamo nel processo genitore \ n");
restituzione 0;
PRODUZIONE:
sysads@linuxhint $ gcc fork.C -o forksysads@linuxhint $ ./forchetta
Siamo nel processo dei genitori
Siamo nel processo del bambino
Nell'esempio sopra abbiamo usato il tipo PID_T che memorizzerà il valore di restituzione di fork (). FORK () è chiamato in linea:
p = fork ();Quindi il valore intero restituito da fork () viene memorizzato in p e quindi p viene confrontato per verificare se la nostra chiamata fork () ha avuto successo.
Quando viene utilizzata la chiamata fork () e il figlio viene creato correttamente, l'ID del processo figlio verrà restituito al processo genitore e 0 verrà restituito al processo figlio.L'ID del processo figlio nel processo dei genitori non sarà uguale all'ID del processo figlio nel processo figlio stesso. Nel processo figlio l'ID del processo figlio sarà 0.
Con questo tutorial puoi vedere come iniziare con la chiamata del sistema fork in Linux.