Sistema de garfo chamado Linux

A chamada do sistema de garfo é usada para criar um novo processo. O processo recém -criado é o processo infantil. O processo que chama fork e cria um novo processo é o processo pai. Os processos de criança e pai são executados simultaneamente.

Mas os processos da criança e dos pais residem em diferentes espaços de memória. Esses espaços de memória têm o mesmo conteúdo e qualquer operação executada por um processo não afetará o outro processo.

Quando a criança processos é criada; Agora, ambos os processos terão o mesmo contador de programas (PC), então esses dois processos apontarão para a mesma próxima instrução. Os arquivos abertos pelo processo pai serão os mesmos para o processo infantil.

O processo infantil é exatamente o mesmo que seus pais, mas há diferença nos IDs de processos:

1. O ID do processo do processo infantil é um ID de processo exclusivo que é diferente dos IDs de todos os outros processos existentes.
2. O ID do processo pai será o mesmo que o do ID do processo dos pais da criança.

Propriedades do processo infantil

A seguir, são apresentadas algumas das propriedades que um processo infantil possui:

1. Os contadores da CPU e as utilizações de recursos são inicializados para redefinir para zero.
2. Quando o processo pai é encerrado, os processos filhos não recebem nenhum sinal porque o atributo pr_set_pdeathsig em prctl () é redefinido.
3. O tópico usado para chamar o Fork () cria o processo infantil. Portanto, o endereço do processo infantil será o mesmo que o pai.
4. O descritor de arquivo do processo pai é herdado pelo processo infantil. Por exemplo, o deslocamento do arquivo ou status dos sinalizadores e os atributos de E/S serão compartilhados entre os descritores de arquivos dos processos filhos e pais. Portanto, o descritor de arquivo da classe pai se referirá ao mesmo descritor de arquivo da classe infantil.
5. Os descritores da fila de mensagens abertas do processo pai são herdados pelo processo infantil. Por exemplo, se um descritor de arquivo contiver uma mensagem no processo pai, a mesma mensagem estará presente no descritor de arquivo correspondente do processo filho. Para que possamos dizer que os valores de bandeira desses descritores de arquivos são iguais.
6. Da mesma forma, os fluxos de diretórios abertos serão herdados pelos processos infantis.
7. O valor de folga do timer padrão da classe infantil é o mesmo que o atual valor do tempo do timer da classe pai.

Propriedades que não são herdadas pelo processo infantil

A seguir, são apresentadas algumas das propriedades que não são herdadas por um processo infantil:

1. Bloqueios de memória
2. O sinal pendente de uma classe infantil está vazio.
3. Processo Bloqueios de registro associados (fcntl ())
4. Operações de E/S assíncronas e de E/S.
5. Notificações de mudança de diretório.
6. Timers como Alarm (), Setitimer () não são herdados pela classe infantil.

garfo () em C

Não há argumentos no fork () e o tipo de retorno de garfo () é inteiro. Você deve incluir os seguintes arquivos de cabeçalho quando o Fork () é usado:

#incluir
#incluir
#incluir

Ao trabalhar com fork (), pode ser usado para tipo pid_t Para processos, o IDs como pid_t é definido em .

O arquivo de cabeçalho é onde o Fork () é definido, então você deve incluí -lo no seu programa para usar o Fork ().

O tipo de retorno é definido e a chamada fork () é definida em . Portanto, você precisa incluir os dois no seu programa para usar o System Call ().

Sintaxe do garfo ()

A sintaxe do sistema Fork () Sistema no Linux, o Ubuntu é o seguinte:

pid_t fork (void);

Na sintaxe, o tipo de retorno é pid_t. Quando o processo infantil é criado com sucesso, o PID do processo infantil é devolvido no processo pai e 0 será devolvido ao próprio processo infantil.

Se houver algum erro, -1 será devolvido ao processo pai e o processo infantil não será criado.

Nenhum argumento é passado para o Fork ().

Exemplo 1: Calling Fork ()

Considere o exemplo a seguir, no qual usamos o sistema Fork () para criar um novo processo infantil:

#incluir
#incluir
#incluir
int main ()

garfo();
printf ("Usando o sistema Fork () CHAMADA \ N");
retornar 0;

SAÍDA:

sysads@linuxhint $ GCC Fork.C -O Fork
sysads@linuxhint $ ./garfo
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()

Neste programa, usamos fork (), isso criará um novo processo infantil. Quando o processo infantil é criado, o processo pai e o processo filho apontam para a próxima instrução (o mesmo contador do programa). Dessa maneiraⁿ vezes, onde n é o número de chamadas do sistema de bifurcação ().

Então, quando a chamada do garfo () é usada uma vez como acima (2¹ = 2) Teremos nossa saída 2 vezes.

Aqui quando a chamada do sistema Fork () for usada, a estrutura interna será:

Considere o seguinte caso em que o garfo () é usado 4 vezes:

#incluir
#incluir
#incluir
int main ()

garfo();
garfo();
garfo();
garfo();
printf ("Usando o sistema Fork () CHAMADA \ N");
retornar 0;

Saída:

sysads@linuxhint $ GCC Fork.C -O Fork
sysads@linuxhint $ ./garfo
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
Usando a chamada do sistema Fork ()
sysads@linuxhint $

Agora o número total de processos criados são 2⁴ = 16 e temos nossa declaração de impressão executada 16 vezes.

Exemplo 2: Teste se o garfo () foi bem -sucedido

No exemplo seguinte, usamos o construto de tomada de decisão para testar o valor (int) retornado pelo garfo (). E as mensagens correspondentes são exibidas:

#incluir
#incluir
#incluir
int main ()

pid_t p;
p = fork ();
if (p ==-1)

printf ("Há um erro ao chamar o fork () \ n");

if (p == 0)

printf ("Estamos no processo infantil \ n");

outro

printf ("Estamos no processo pai \ n");

retornar 0;

SAÍDA:

sysads@linuxhint $ GCC Fork.C -O Fork
sysads@linuxhint $ ./garfo
Estamos no processo pai
Estamos no processo infantil

No exemplo acima, usamos o tipo pid_t que armazenará o valor de retorno do garfo (). fork () é chamado on -line:

p = fork ();

Portanto, o valor inteiro retornado por Fork () é armazenado em P e depois P é comparado para verificar se nossa chamada Fork () foi bem -sucedida.

Quando a chamada fork () é usada e a criança for criada com sucesso, o ID do processo infantil será devolvido ao processo dos pais e 0 será devolvido ao processo infantil.O ID do processo infantil no processo dos pais não será o mesmo que o ID do processo infantil no próprio processo infantil. No processo infantil, o ID do processo infantil será 0.

Com este tutorial, você pode ver como começar com o sistema de garfo no Linux.