Furculiță (programare)
Această intrare sau secțiune referitoare la terminologia computerului nu citează sursele necesare sau cei prezenți sunt insuficienți . |
O furcă de programare este modul în care un proces creează o copie a sa în memorie : copia va fi numită procesul copil , în timp ce procesul original va fi numit procesul părinte .
Pe UNIX și Unix- ului de operare sisteme, procesul părinte și procesul copil poate alege instrucțiunile pentru a executa prin intermediul furcii () apel de sistem valoarea de returnare . Valoarea returnată a apelului fork () este 0 în procesul copil, un număr mai mare de 0 în procesul părinte (valoarea returnată este doar PID- ul copilului) sau o valoare mai mică de 0 dacă nu a fost posibil să se creeze un proces nou (de exemplu datorită unui număr excesiv de procese active în prezent).
Când un proces apelează fork () se va crea un nou spațiu de adrese. Cu toate acestea, cu tehnicile de copiere pe scriere , nu va fi ocupată nicio memorie fizică până când unul dintre cele două procese nu scrie. Procesul copil va avea o copie exactă a tuturor segmentelor de memorie ale procesului părinte. Atât procesele părinte, cât și copilul își pot continua execuția independent unul de celălalt.
Importanța furcii () în Unix
Furca () este o parte importantă a Unix, esențială pentru susținerea filozofiei sale de proiectare, care încurajează dezvoltarea filtrelor . În Unix, un filtru este un program mic care își citește intrarea din intrarea standard și își scrie ieșirea în ieșirea standard . O conductă a acestor comenzi poate fi înlănțuită împreună de un shell pentru a crea noi comenzi. De exemplu, puteți lega ieșirea comenzii find și intrarea comenzii wc împreună pentru a crea o nouă comandă care va imprima numărul de fișiere care se termină cu „.cpp” găsit în directorul curent, după cum urmează:
$ gaseste. -nume "* .cpp" -print | wc -l
Pentru a face acest lucru, shell-ul se bifurcă () și folosește conducta pentru a conecta ieșirea comenzii find la intrarea comenzii wc. Sunt create două procese copil, unul pentru fiecare comandă (find și wc). Aceste procese secundare sunt suprapuse cu codul asociat cu programele pe care intenționează să le execute, datorită familiei exec de apeluri de sistem.
Mai general, un fork () este executat de către shell ori de câte ori un utilizator introduce o comandă.
Exemplu
Acesta este un exemplu în Limbajul C care ilustrează ideea de bifurcare într-un mediu asemănător Unix:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main ()
{
int pid ; // pid_t pid;
pid = furculiță ();
if ( pid == 0 )
{
/ * Proces copil.
* Dacă furca () returnează 0, suntem înăuntru
* a procesului copil
* Vom număra până la zece, o dată pe secundă.
* /
int j ;
pentru ( j = 0 ; j < 10 ; j ++ )
{
printf ( "Copil:% d \ n " , j );
somn ( 1 );
}
_exit ( 0 ); / * Rețineți că exit () nu este utilizat * /
}
altfel dacă ( pid > 0 )
{
/ * Procesul părinte, furculita a revenit
* pidul copilului nou creat.
* Mai numărăm până la zece.
* /
int i ;
pentru ( i = 0 ; i < 10 ; i ++ )
{
printf ( "Tată:% d \ n " , i );
somn ( 1 );
}
}
altceva
{
/ * Eroare. * /
fprintf ( stderr , "Eroare în furcă" );
ieșire ( 1 );
}
retur 0 ;
}
O posibilă ieșire generată de executarea codului:
Copil: 0 Tatăl: 0 Fiul: 1 Tatăl: 1 Fiul: 2 Tatăl: 2 Fiul: 3 Tatăl: 3 Fiul: 4 Tată: 4 Fiul: 5 Tată: 5 Fiul: 6 Tată: 6 Fiul: 7 Tată: 7 Fiul: 8 Tată: 8 Fiul: 9 Tată: 9
Ordinea de execuție a proceselor este determinată de planificator .
Elemente conexe
linkuri externe
- (EN) de apel de sistem fork () , pe opengroup.org.
