En este artículo:
1. Estructura del proceso
2. programa en un proceso de proceso de
3. El proceso de creación
4. Al final del proceso de
antecedentes:
1. El proceso es la entidad en el programa informático en ejecución
2. El proceso es el hilo del recipiente
La instancia real de ejecución 3. El programa en sí es sólo instrucción, los datos y las formas de organización de la descripción, el proceso es el programa
4. Múltiples procesos pueden estar asociados con el mismo programa, pero cada proceso se basa en el funcionamiento independiente de manera síncrona o asíncrona
Una estructura de proceso .Linux
estructura de procesos Linux consta de tres partes: un segmento de código, segmento de datos y el segmento de pila
Fragmento : almacenar código de programa si varios procesos que se ejecutan el mismo programa que utilizan el mismo segmento de código
Los segmentos de datos : variables globales del programa, constantes, variables estáticas
segmento de pila : parámetros de la función, las variables locales definidas en el PCB bloque de control de proceso (pila de núcleo en la parte inferior del proceso)
PD:
1.pcb es existente en un sistema de identificación único proceso percibida por la presencia de proceso PCB
2. Sistema a través del proceso de planificación y gestión de los PCB, incluyendo el proceso de creación, la ejecución del programa, el proceso de dejar de fumar y cambiar la prioridad del proceso, etc.
3. Proceso con identificador de proceso PID es relación uno a uno, y la relación entre un archivo de muchos-a-!
Programa II. En un procedimiento de proceso
programa de generación de Linux se divide en cuatro etapas: pre-compilación, compilar, ensamblar, enlace
PS: G ++ compilador pre-compilado, el compilador, ensamblador de archivos de origen en tres pasos en el archivo de destino, si el programa tiene archivos objeto múltiple o programas utilizan las funciones de la biblioteca, también necesitará el compilador para enlazar todo del objetivo wen arriba, y finalmente formar un programa ejecutable
Programa en las etapas del proceso:
1) El código de programa del núcleo y se leen los datos en la memoria, asignar espacio de memoria para el programa
2) identificador de proceso de asignación de proceso kernel PID y otros recursos
3) y el proceso kernel correspondiente información de estado PID almacenado, el proceso en la cola de ejecución para la ejecución, el programa puede ser convertido en el proceso del sistema operativo después de la ejecución de los programas de planificador
III. La creación de procesos
antecedentes:
1. Crear un proceso de dos maneras: creada por el sistema operativo, creado por el proceso padre
2. Cuando se inicia el sistema, el sistema operativo va a crear algún proceso, que soportan la gestión y asignación de recursos del sistema para tareas, estos procesos a menudo llamado el proceso del sistema
3. El sistema permite un proceso para crear un proceso hijo para formar una estructura de árbol de procesos
4. Todos los procesos de todo el sistema Linux es una estructura de árbol,
5. Además de 0 proceso es creado por el sistema, otros procesos son por su proceso padre creado
En el proceso de creación de un tenedor función:
pid_t tenedor (void)
1. Para el proceso principal, la función devuelve el PID tenedor proceso hijo
2. Para un proceso hijo, la función devuelve 0 tenedor
3. Si se crea un error, devuelve la función tenedor -1
Análisis de funciones: la función tenedor crea un nuevo proceso y una nueva asignación de proceso disponible en el kernel para el proceso identificador PID, entonces el proceso padre copia del kernel espacio para el niño, incluyendo datos y segmentos de pila del proceso padre, y el proceso padre segmentos de código acción, esta vez el proceso padre del niño y exactamente lo mismo!
Pregunta: ¿Por qué para los diferentes procesos (proceso padre, el proceso hijo), devuelve la función tenedor del valor de la misma será diferente?
Debido a que la replicación del segmento de pila en el proceso de replicación, por lo que los dos procesos se han quedado en la función de tenedor, esperando para volver, lo que la función tenedor rendimientos dos veces, con el fin de diferenciar entre los procesos padre e hijo, por lo que el valor de retorno no es el mismo
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
utilizando espacio de nombres std;
int main ()
{
pid_t pid;
pid = tenedor ();
si (pid < 0 )
{
cout << " error tenedor " << endl;// salida anormal
}
demás si (pid == 0 )
{
cout << " proceso hijo, hijo: " << getpid () << "padre: " << getppid () << endl;
} Demás
{
cout << " proceso padre, padre: " << getpid () << " hijo: " << pid << endl;
sueño ( 2 );
} Volver 0 ;
}
Análisis: getpid para obtener el pid del proceso actual, getppid para obtener el pid del proceso actual del proceso padre, el código anterior para verificar el valor de retorno diferente tenedor
Vamos a verificar padres e hijos procesos comparten el segmento de código sólo, sin datos compartidos y segmentos de pila
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
utilizando espacio de nombres std;
int datos_x = 1 ;
int main ()
{
pid_t pid;
int stack_x = 1 ;
int * montón = ( int *) malloc ( sizeof ( int ));
* montón = 3;
pid = tenedor ();
si (pid < 0 )
{
cout << " error tenedor " << endl;
salida ( - 1 );
} Demás si (pid == 0 )
{
datos_x ++ ;
stack_x ++ ;
( * Montón) ++ ;
cout << " hijo, datos_x = " << << datos_x "stack_x = " << << stack_x " ,<< * montón << endl;
de salida ( 0 );
} Demás
{
sueño ( 2 );
cout << " padres, datos_x = " << << datos_x "stack_x = " << << stack_x "montón = " << * montón << endl;
}
Volver 0 ;
}
Análisis: Se encontró que el segmento de datos, pila, montón de datos que los dos procesos no son los mismos, para demostrar que el padre y el niño no comparte el segmento de datos y el segmento de pila! , Los cambios de contenido de segmento sub-procesos de datos y segmento de pila, y no afectarán datos en el proceso padre, el padre y el niño a propósito compartir código fragmentos es ahorrar espacio de almacenamiento
La mayor parte de los recursos de la copia proceso hijo del proceso padre, sólo una pequeña parte es diferente, como PID, ID del proceso padre del proceso y por lo tanto estas cosas
Acerca de "copia en escritura" Descripción del concepto:
Ahora el núcleo de Linux a menudo no se replican inmediatamente en la realización de la función tenedor al crear los datos de proceso hijo y segmentos de pila del proceso padre, pero la operación de copia se producirá cuando el proceso hijo para modificar el contenido de estos datos, el kernel le dará al proceso hijo espacio de proceso de asignación, el contenido del proceso padre copiado, y luego continuar hacia atrás, esta copia con el fin de lograr un poco de su propia para completar algunos de los procesos de trabajo es más razonable! , Mayor eficiencia
Cuatro de la final del proceso:
Linux se divide en el proceso sale normalmente y la salida proceso anormal
1) fuera normal de la forma: la función principal de retorno 0, la función de salida de llamadas, las llamadas de función _exit
2) fuera anormal de la forma: Llamada de abortar la función, proceso recibe una señal y la señal hace que el proceso termine
Por supuesto, no importa la forma, el mismo sistema con el tiempo será la implementación de un código: el proceso utilizado para cerrar los descriptores de archivos abiertos, libere su bloqueo de recursos de memoria ocupada
Hay que distinguir entre que, después de que el control de retorno a la función de llamada, mientras que la salida es una función, después de la implementación de sistemas de control para el sistema de
Veamos ahora en funciones _exit y de salida:
función _exit más cerca de la parte inferior, la función de salida _exit es una función de contenedor, a continuación, salir de la función hacer nada más que la función _exit?
Sale de la función será [lectura / cache escrita IO] operación, mientras que la función _exit no es, en el momento en función de su uso _exit mal no puede garantía de integridad de los datos!
En otras palabras, la función de salida se abre el caso antes de que finalice el proceso será revisado a fondo el archivo, el contenido de la memoria intermedia de archivos se vuelve a escribir el archivo!
¿Por qué se llama a la función de datos _exit está incompleta va a pasar? De entrar en detalles acerca de la Linux subyacente
En la función de biblioteca estándar de Linux, hay una operación conocida [IO] buffer, caracterizado porque correspondiente a cada archivo abierto, en la memoria tiene un tampón, leer continuamente a cabo cada vez que un archivo se lee varias piezas después de los datos de manera que se puede leer en la siguiente lectura directamente desde la memoria búfer para mejorar la velocidad, el mismo, cada archivo de escritura cuando sólo se registra en el búfer de memoria, como se cumplan ciertas condiciones (para acumular un cierto número de caracteres), entonces el contenido de la memoria intermedia de una sola escritura de archivos, esta tecnología ha aumentado en gran medida la velocidad del archivo de leer y escribir, sino también añadir un poco a los boxes de programación, como algunos datos, en teoría, debería escribir en el archivo, pero en realidad debido a que ciertas condiciones no se cumplen, es de conocimiento almacenado en la memoria intermedia, si la función _exit extremo directamente del proceso, se perderán los datos del buffer, por lo que desea garantizar la integridad de los datos , asegúrese de usar la función de salida, en lugar de una función _exit
Dirección reimpresión: https://www.cnblogs.com/yinbiao/p/11202089.html
