Sistema de garfo chamado em C

A chamada do sistema Fork () é usada para criar processos infantis em um programa C. fork () é usado onde o processamento paralelo é necessário em seu aplicativo. A função do sistema fork () é definida nos cabeçalhos sys/tipos.h e unistd.h. Em um programa em que você usa o Fork, você também precisa usar a chamada do sistema Wait (). espera () A chamada do sistema é usada para esperar no processo pai para o processo infantil terminar. Para terminar um processo infantil, a chamada do sistema de saída () é usada no processo infantil. A função espera () é definida no cabeçalho sys/espera.h e a função exit () é definida no cabeçalho stdlib.h.

Fig 1: Fluxo de trabalho básico ()

Neste artigo, vou mostrar a você como usar o System Call para criar processos infantis em C. Então vamos começar.

Fork () Sintaxe e Valor de Retorno:

A sintaxe da função do sistema Fork () é a seguinte:

pid_t fork (void);

A função do sistema Fork () não aceita nenhum argumento. Ele retorna um número inteiro do tipo pid_t.

No sucesso, Fork () retorna o PID do processo infantil, que é maior que 0. Dentro do processo infantil, o valor de retorno é 0. Se o Fork () falhar, ele retornará -1.

Exemplo simples do garfo ():

Um exemplo simples de garfo () é dado abaixo:

#incluir
#incluir
#incluir
#incluir
#incluir
int main (void)
pid_t pid = fork ();
if (pid == 0)
printf ("filho => ppid: %d pid: %d \ n", getppid (), getpid ());
saída (exit_success);

else if (pid> 0)
printf ("pai => pid: %d \ n", getpid ());
printf ("Esperando o processo infantil terminar.\ n ");
espere (nulo);
printf ("Processo infantil terminado.\ n ");

outro
printf ("Não é possível criar um processo infantil.\ n ");

return exit_success;

Aqui, usei o Fork () para criar um processo filho a partir do processo principal/pai. Em seguida, imprimi o PID (ID do processo) e o PPID (ID do processo pai) do processo infantil e pai. No processo dos pais, espera (nulo) é usado para esperar o processo infantil terminar. No processo infantil, o exit () é usado para terminar o processo infantil. Como você pode ver, o PID do processo pai é o PPID do processo infantil. Então, o processo infantil 24738 pertence ao processo pai 24731.

Você também pode usar funções para tornar seu programa mais modular. Aqui eu usei processTask () e parentTask () funções para os processos de criança e pai, respectivamente. É assim que o garfo () é realmente usado.

#incluir
#incluir
#incluir
#incluir
#incluir
Void ChildTask ()
printf ("Hello World \ n");

void parentTask ()
printf ("Tarefa Principal.\ n ");

int main (void)
pid_t pid = fork ();
if (pid == 0)
ChildTask ();
saída (exit_success);

else if (pid> 0)
espere (nulo);
parentTask ();

outro
printf ("Não é possível criar um processo infantil.");

return exit_success;

A saída do programa acima:

Executando vários processos infantis usando fork () e loop:

Você também pode usar o loop para criar tantos processos infantis quanto precisar. No exemplo abaixo, criei 5 processos infantis usando o loop. Eu também imprimi o PID e o PPID dos processos filhos.

#incluir
#incluir
#incluir
#incluir
#incluir
int main (void)
para (int i = 1; i <= 5; i++)
pid_t pid = fork ();
if (pid == 0)
printf ("Child Process => ppid =%d, pid =%d \ n", getppid (), getpid ());
saída (0);

outro
printf ("Processo pai => pid =%d \ n", getpid ());
printf ("Esperando os processos filhos terminarem… \ n");
espere (nulo);
printf ("Processo infantil terminado.\ n ");


return exit_success;

Como você pode ver, o ID do processo pai é o mesmo em todos os processos infantis. Então, todos eles pertencem ao mesmo pai. Eles também executam de maneira linear. Um após o outro. Controlar processos infantis é uma tarefa sofisticada. Se você aprender mais sobre a programação do sistema Linux e como ele funciona, poderá controlar o fluxo desses processos de qualquer maneira você quiser.

Exemplo da vida real:

Diferentes cálculos matemáticos complexos, como MD5, SHA256, etc. a geração de hash requer muito poder de processamento. Em vez de calcular coisas assim no mesmo processo do programa principal, você pode simplesmente calcular o hash em um processo infantil e devolver o hash ao processo principal.

No exemplo seguinte, eu gerei um código de pino de 4 dígitos em um processo infantil e o enviei para o processo pai, o programa principal. Então, eu imprimi o código do PIN a partir daí.

#incluir
#incluir
#incluir
#incluir
#incluir
int getpin ()
// Use PPID e PID como semente
srand (getpid () + getppid ());
int secret = 1000 + rand () % 9000;
segredo de retorno;

int main (void)
int fd [2];
tubo (FD);
pid_t pid = fork ();
if (pid> 0)
fechar (0);
fechar (FD [1]);
dup (fd [0]);
int secretNumber;
size_t readbytes = leia (fd [0], & secretNumber, sizeof (secretNumber));
printf ("Esperando pelo pino… \ n");
espere (nulo);
printf ("Bytes Leia: %ld \ n", readbytes);
printf ("Pin: %d \ n", secretNumber);

else if (pid == 0)
fechar (1);
fechar (fd [0]);
dup (FD [1]);
int secret = getpin ();
Write (FD [1], & Secret, sizeof (secreto));
saída (exit_success);

return exit_success;

Como você pode ver, cada vez que executo o programa, recebo um código de pino de 4 dígitos diferente.

Então, é basicamente assim que você usa o System Call in Linux no Linux. Obrigado por ler este artigo.