Neste artigo:
1. Estrutura do processo
2. programa em um processo de processo
3. O processo de criação
4. No final do processo
Antecedentes:
1. O processo é a entidade no programa de computador em execução
2. O processo é a rosca do recipiente
A instância verdadeira corrida 3. O programa em si é única instrução, dados e formas organizacionais de descrição, o processo é o programa
4. Vários processos podem ser associados com o mesmo programa, mas cada processo baseia-se na operação independente maneira síncrona ou assíncrona
Uma estrutura processo .Linux
estrutura processo Linux consiste em três partes: um segmento de código, segmento de dados e segmento de pilha
Trecho : armazenar código de programa se vários processos em execução o mesmo programa que eles usam o mesmo segmento de código
segmentos de dados : variáveis globais do programa, constantes, variáveis estáticas
segmento Pilha : parâmetros da função, as variáveis locais definidas no PCB bloco de controlo de processo (pilha de núcleo na parte inferior do processo)
ps:
1.pcb é que existe num sistema de identificação único processo percebida pela presença de processo PCB
2. Sistema através do processo de agendamento e gerenciamento de PCB, PCB, incluindo o processo de criação, a implementação do programa, sair do processo e alterar a prioridade do processo etc.
3. Processo com identificador de processo PID é 1-1 relacionamento, e a relação entre um arquivo de muitos-para-!
II. Programa para um procedimento do processo
programa de geração de Linux é dividido em quatro fases: pré-compilação, compilação, montagem, ligação
ps: compilador G ++ pré-compilado, o compilador, arquivos de origem assembler em três etapas para o arquivo de destino, se o programa tiver vários arquivos objeto ou programas usam as funções de biblioteca, o compilador também terá de ligar todos o alvo wen -se e, finalmente, formar um programa executável
Programa em etapas do processo:
1) O código do programa kernel e os dados são lidos para a memória, alocar espaço de memória para o programa
2) Identificador do processo de alocação de processo kernel do PID e outros recursos
3) e o processo do kernel correspondente informações de estado PID armazenado, o processo para a fila de execução para a execução, o programa pode ser convertido para o processo do sistema operacional após a execução das programações do programador
III. Processos de Criação
Antecedentes:
1. Criar um processo de duas maneiras: criado pelo sistema operacional, criado pelo processo pai
2. Quando o sistema é iniciado, o sistema operacional irá criar algum processo, eles suportar a gestão e atribuição de recursos do sistema para as tarefas, esses processos muitas vezes chamado de processo do sistema
3. O sistema permite um processo para criar um processo filho para formar uma estrutura de árvore processo
4. Todos os processos de todo o sistema Linux é uma estrutura de árvore,
5. Além 0 processo é criado pelo sistema, outros processos são, pela sua processo pai criado
No processo de criação de um garfo função:
fork pid_t (void)
1. Para o processo pai, forquilha função retorna o PID processo filho
2. Para um processo filho, forquilha função retorna 0
3. Se você criar um erro, forquilha função retorna -1
Análise de função: função fork cria um novo processo e uma nova alocação de processo disponível a partir do kernel para processo identificador PID, em seguida, o processo pai cópia espaço kernel para a criança, incluindo dados e segmentos de pilha do processo pai, e os segmentos de código share processo pai, desta vez a criança eo processo pai exatamente o mesmo!
Pergunta: Por que para diferentes processos (o processo pai, o processo filho), função fork retorna o valor que vai ser diferente?
Uma vez que a replicação do segmento de pilha no processo de replicação, de modo que os dois processos de ter ficado na função de garfo, esperando para retornar, de modo que a função forquilha retornos duas vezes, a fim de diferenciar entre os processos pai e filho, de modo que o valor de retorno não é a mesma
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string de .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
usando namespace std;
int main ()
{
pid_t pid;
pid = forquilha ();
se (pid < 0 )
{
cout << " erro fork " << endl;// saída anormal
}
else se (pid == 0 )
{
cout << " processo filho, filho: " << getpid () << "parent: " << getppid () << endl;
} Else
{
cout << " processo pai, pai: " << getpid () << " filho: " << pid << endl;
sono ( 2 );
} Retornar 0 ;
}
Análise: getpid obter o pid do processo atual, getppid para obter pid o processo atual do processo pai, o código acima para verificar o valor garfo retorno diferente
Vamos verificar um pai e filho processos compartilham o segmento de código só, sem dados compartilhados e segmentos de pilha
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string de .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
usando namespace std;
int dados_x = 1 ;
int main ()
{
pid_t pid;
int stack_x = 1 ;
int * montão = ( int *) malloc ( sizeof ( int ));
* montão = 3;
pid = forquilha ();
se (pid < 0 )
{
cout << " erro fork " << endl;
saída ( - 1 );
} Else se (pid == 0 )
{
dados_x ++ ;
stack_x ++ ;
( * Montão) ++ ;
cout << " filho, dados_x = " << dados_x << "stack_x = " << stack_x << " ,<< * pilha << endl;
saída ( 0 );
} Else
{
sono ( 2 );
cout << " pai, dados_x = " << dados_x << "stack_x = " << stack_x << "montão = " << * pilha << endl;
}
Retornar 0 ;
}
Análise: Descobrimos que o segmento de dados, pilha, montão de dados que os dois processos não são o mesmo, para provar o pai ea criança não compartilham o segmento de dados e segmento de pilha! , O segmento de dados sub-processos e segmento de pilha alterações de conteúdo, e não afetará os dados no processo pai, o pai ea criança para fins código de compartilhar trechos é para economizar espaço de armazenamento
A maior parte dos recursos da cópia processo filho do processo pai, apenas uma pequena parte é diferente, como pid, ID do processo pai do processo e assim estas coisas
Sobre "copy-on-write" conceito Descrição:
Agora Linux kernel é muitas vezes não imediatamente replicadas na realização da função fork ao criar os dados do processo da criança e segmentos de pilha do processo pai, mas a operação de cópia irá ocorrer quando o processo filho para modificar o teor desses dados, o kernel dará o processo filho alocação de espaço de processo, o conteúdo do processo pai copiado, e depois continuar para trás, esta cópia a fim de alcançar alguns dos seus próprios para completar alguns do processo de trabalho é mais razoável! , Maior eficiência
Quatro do final do processo:
Linux é dividido no processo será encerrado normalmente e de saída do processo anormal
1) a normal do caminho: principal função de retorno 0, função de saída chamada, a função chama _exit
2) para fora anormal da maneira: chamada função de interrupção, o processo de receber um sinal e o sinal faz com que o processo para encerrar
Claro, não importa o caminho, o mesmo sistema acabará por ser a implementação de um código: o processo usado para fechar descritores de arquivos abertos, liberar seu bloqueio ocupada recursos de memória
Precisamos distinguir entre que, após o controle de retorno para a função de chamada, enquanto a saída é uma função, após a implementação de sistemas de controle para o sistema
Vamos agora olhar para funções _exit e saída:
função _exit mais perto do fundo, função de saída _exit é uma função wrapper, em seguida, sair da função de fazer nada mais do que a função _exit?
função de saída será [IO leitura / cache escrito] operação, enquanto a função _exit não é, no momento função uso _exit errado não pode garantir a integridade dos dados!
Em outras palavras, a função de saída abre o caso antes do final do processo será verificado o arquivo, o conteúdo do buffer de arquivo é escrito de volta para o arquivo!
Por que é chamar dados função _exit está incompleta vai acontecer? Nós entrar em detalhes sobre o Linux subjacente
Na função de biblioteca padrão Linux, existe uma operação conhecida [IO] tampão, caracterizado pelo facto de que corresponde a cada ficheiro aberto, na memória tem um tampão, ler continuamente a cada vez que um ficheiro é lido várias peças após os dados de modo que possa ser lido na próxima leitura diretamente da memória tampão para melhorar a velocidade, a mesma, cada arquivos de gravação quando só é escrito para o buffer de memória, como sejam cumpridas certas condições (para acumular um certo número de caracteres), então o conteúdo do buffer write-once arquivo, esta tecnologia tem aumentado significativamente a velocidade de arquivo ler e escrever, mas também adicionar um pouco para os poços de programação, tais como alguns dados, em teoria, deve escrever no arquivo, mas, na verdade, porque não forem cumpridas certas condições, é de conhecimento armazenado no buffer de memória, se a função _exit acabar diretamente do processo, os dados do buffer serão perdidos, assim que você quer para garantir a integridade dos dados , certifique-se de usar a função de saída, em vez de um _exit função
Endereço reimpressão: https://www.cnblogs.com/yinbiao/p/11202089.html
