Os processos em sistemas operacionais do tipo UNIX (incluindo Linux, MacOS, BSD etc.) são criados e excluídos por meio de uma combinação de chamadas do sistema e mecanismos internos do kernel.
Criação do processo: A principal maneira como um novo processo é criado é através da chamada do sistema `Fork ()`. `fork ()` cria uma cópia quase idêntica do processo de chamada (o processo * pai *). Tanto o pai e o processo recém -criado * Child * continuam a execução a partir do ponto da chamada `fork ()`. A principal diferença é o valor de retorno de `fork ()`:
*
no processo pai: `Fork ()` Retorna o ID do processo (PID) do processo filho. Este PID é um identificador único para a criança.
*
no processo infantil: `fork ()` retorna 0.
Após `fork ()`, os processos pais e filhos normalmente seguem diferentes caminhos de execução. O processo infantil geralmente usa a família de chamadas da família `Exec () '(` Execl`, `Execv`,` Execvp` etc.) para substituir sua imagem atual por um novo programa. `Exec ()` substitui o espaço de memória da criança com o código e os dados do novo programa. Se a criança não usar `Exec ()`, continuará executando o mesmo código que o pai, criando um clone verdadeiro.
Outras maneiras pelas quais os processos são criados incluem:
*
`vFork ()` (menos comum e potencialmente problemático): Semelhante ao `fork ()`, mas com diferenças sutis no compartilhamento de memória. Geralmente evitado devido a possíveis impasse.
*
`clone ()` (mais avançado): Oferece controle de granulação mais fina sobre os recursos compartilhados entre os processos pais e filhos. Usado em bibliotecas e modelos avançados de rosqueamento.
*
Inicialização do sistema: O processo init (PID 1) é o ancestral de todos os outros processos do sistema. É responsável por iniciar outros processos durante a inicialização.
*
`pthread_create ()`: Esta função é usada para criar threads dentro de um processo. Embora os threads compartilhem o mesmo espaço de memória que o processo dos pais, ainda são consideradas unidades de execução separadas gerenciadas pelo kernel.
Exclusão do processo (terminação): Um processo termina (é excluído) em várias circunstâncias:
*
terminação normal: O processo conclui sua execução e chama a chamada do sistema `exit ()`. Isso sinaliza o sistema operacional que ele terminou. O status de saída pode ser usado para transmitir sucesso ou falha.
*
Terminar anormal: O processo trava devido a uma falha de segmentação, instrução ilegal ou outro erro. O kernel encerra o processo.
*
Terminação do sinal: Outro processo (ou o próprio kernel) pode enviar um sinal (por exemplo, `sigterm`,` sigkill`) para um processo, forçando seu término. `Sigterm` permite que o processo seja limpo antes de sair, enquanto o` sigkill` termina imediatamente o processo sem nenhuma limpeza.
*
Terminação do processo pai: Se um processo pai terminar, seus processos filhos também poderão ser encerrados, dependendo das configurações do sistema operacional (geralmente herdadas do grupo de processos dos pais). O processo `init" normalmente adota crianças órfãs.
O papel do kernel: O kernel desempenha um papel crucial no gerenciamento de processos ao longo de seu ciclo de vida. Ele lida com a criação de processos, agendamento, alocação de memória, gerenciamento de recursos, manipulação de sinais e terminação de processos. O kernel mantém estruturas de dados (como a tabela de processos) para rastrear informações sobre cada processo em execução.
Em resumo, a criação e exclusão de processos no UNIX são cuidadosamente orquestradas pelo kernel e envolvem um conjunto de chamadas do sistema que permitem que os programadores controlem o ciclo de vida do processo. O `fork ()` e `Exec ()` família (para criação) e `exit ()` e sinais (para exclusão) são os componentes principais.
