Dans cet article:
1. Structure du processus
2. programme dans un processus de processus
3. Le processus de création
4. A la fin du processus
contexte:
1. Le processus est l'entité dans le programme d'ordinateur exécutant
2. Le processus est le filetage du récipient
La véritable instance de fonctionnement 3. Le programme lui-même est seulement l'instruction, les données et les formes d'organisation de la description, le processus est le programme
4. Plusieurs processus peuvent être associés au même programme, mais chaque processus est basé sur de manière synchrone ou asynchrone fonctionnement indépendant
Une structure de processus .Linux
Structure de processus Linux se compose de trois parties: un segment de code, le segment de données et le segment pile
Snippet : stocker un code de programme si plusieurs processus exécutés le même programme , ils utilisent le même segment de code
segments de données : programme des variables globales, les constantes, les variables statiques de
segment de pile : paramètres de fonction, les variables locales définies dans le bloc PCB de commande de processus (pile de noyau au fond du processus)
ps:
1.PCB est existant dans un système d'identification unique de processus perçu par la présence de processus de PCB
2. Système à travers le processus de planification et de gestion des PCB, PCB, y compris le processus de création, la mise en œuvre du programme, quittez le processus et changer la priorité du processus, etc.
3. Procédé d'identificateur de processus PID est une à une relation, et la relation entre un nombre dans un fichier!
II. Programme dans une procédure de processus
programme de génération de Linux est divisé en quatre étapes: Précompilation, décompiler, assembler, lien
ps: G ++ compilateur pré-compilé, le compilateur, les fichiers source assembleur en trois étapes dans le fichier cible, si le programme a plusieurs fichiers d'objets ou programmes utilisent les fonctions de la bibliothèque, le compilateur devra également relier tous la cible wen , et former enfin un programme exécutable
Programme en étapes du processus:
1) Le code de programme de noyau et les données sont lues dans la mémoire, allouer de l'espace mémoire pour le programme
2) identificateur de processus d'allocation de processus PID du noyau et d'autres ressources
3) et le traitement de noyau correspondant des informations d'état stockées PID, le processus dans la file d'attente d'exécution pour l'exécution, le programme peut être converti en le processus de système d'exploitation après l'exécution de l'horaire du planificateur
III. Création de processus
contexte:
1. Créez un processus de deux façons: créé par le système d'exploitation, créé par le processus parent
2. Lorsque le système démarre, le système d'exploitation va créer un processus, ils portent la gestion et l'allocation des ressources du système à des tâches, ces processus souvent appelé le processus système
3. Le système permet à un processus de création d'un processus enfant pour former une structure d'arborescence de processus
4. Tous les processus de l'ensemble du système Linux est une structure arborescente,
5. En plus de 0 processus est créé par le système, d'autres processus sont par leur processus parent créé
Sur le processus de création d'une fourchette de fonction:
Fourche pid_t (void)
1. Pour le processus parent, la fonction retourne la fourche PID de processus enfant
2. Pour un processus enfant, retourne la fonction de fourchette 0
3. Si vous créez une erreur, la fonction retourne fourchette -1
Analyse de fonctions: fonction de fourche crée un nouveau procédé et une nouvelle répartition des processus disponibles à partir du noyau de processus identifiant PID, alors le processus parent copie espace de noyau à l'enfant, y compris les données et les segments de pile du processus parent, et le processus parent segments de code de l' action, cette fois l'enfant et le processus parent exactement la même chose!
Question: Pourquoi les différents processus (le processus parent, le processus de l'enfant), la fonction retourne fourchette la valeur de celui-ci sera différent?
Étant donné que la replication du segment de pile dans le processus de réplication, de sorte que les deux processus ont séjourné dans la fonction de la fourche, en attente de retour, de sorte que la fonction retourne la fourche à deux reprises, afin de différencier entre les processus parent et enfant, de sorte que la valeur de retour est différent
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
en utilisant l' espace de noms std;
int main ()
{
pid_t pid;
pid = fork ();
si (pid < 0 )
{
Cout << " erreur de fourche " << endl;// sortie anormale
}
autre si (pid == 0 )
{
Cout << " processus fils, fils: " << getpid () << "parent: " << getppid () << endl;
} Autre
{
Cout << " processus parent, parent: " << getpid () << " fils: " << pid << endl;
sommeil ( 2 );
} Retour 0 ;
}
Analyse: getpid pour obtenir le processus en cours pid, getppid pour obtenir pid le processus actuel du processus parent, le code ci-dessus pour vérifier la valeur différente de retour de la fourche
Vérifions un processus parent et enfant partagent le segment de code uniquement, sans segments de données partagées et de la pile
#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include < string .h>
#include <unistd.h>
#include <errno.h>
#include < semaphore.h>
en utilisant l' espace de noms std;
int données_x = 1 ;
int main ()
{
pid_t pid;
int stack_x = 1 ;
int * tas = ( int *) malloc ( sizeof ( int ));
* tas = 3;
pid = fork ();
si (pid < 0 )
{
Cout << " erreur de fourche " << endl;
exit ( - 1 );
} Autre si (pid == 0 )
{
données_x ++ ;
stack_x ++ ;
( * Tas) ++ ;
Cout << " fils, données_x = " << données_x << "stack_x = " << stack_x << " ,<< * tas << endl;
exit ( 0 );
} Autre
{
sommeil ( 2 );
Cout << " parent, données_x = " << données_x << "stack_x = " << stack_x << "tas = " << * tas << endl;
}
Retour 0 ;
}
Analyse: Nous avons constaté que le segment de données, pile, tas de données que les deux processus ne sont pas les mêmes, pour prouver le parent et l'enfant ne partage pas le segment de données et le segment de pile! , Le segment de données sous-processus et des changements de contenu segment de pile, et n'affectera pas les données dans le processus parent, le parent et l' enfant au but de partager le code est d'économiser de l' espace de stockage
La plupart des ressources du processus parent copie processus enfant, seule une petite partie est différente, comme pid, processus parent ID du processus et donc ces choses
A propos de concept de "copy-on-write" Description:
Maintenant, le noyau Linux est souvent pas immédiatement répliqué dans la réalisation de la fonction de la fourche lors de la création des données de processus des enfants et des segments de pile du processus parent, mais l'opération de copie se produit lorsque le processus enfant de modifier le contenu de ces données, le noyau donnera le processus enfant allocation d'espace de processus, le contenu du processus parent copié, puis continuer en arrière, cette copie afin d'obtenir une partie de leur propre pour compléter une partie du processus de travail est plus raisonnable! , Une plus grande efficacité
Quatre de la fin du processus:
Linux est divisé en processus se termine normalement et sortie du processus anormal
1) à la normale du chemin: retour de la fonction principale 0, la fonction de sortie d'appel, la fonction appelle _exit
2) anormale de la route: appel interrompre la fonction, le processus reçoit un signal et le signal provoque l'arrêt du processus
Bien sûr, quelle que soit la manière, le même système sera éventuellement la mise en œuvre d'un code: le processus utilisé pour fermer les descripteurs de fichiers, libérer son verrou occupé des ressources de mémoire
Il faut distinguer entre ce, après le contrôle de retour à la fonction d'appel, tandis que la sortie est une fonction, après la mise en œuvre des systèmes de contrôle du système
Examinons maintenant les fonctions _exit et de sortie:
fonction _exit plus près du fond, la fonction _exit de sortie est une fonction d'emballage, puis quittez la fonction ne rien faire plus que la fonction _exit?
fonction de sortie sera [lecture / cache écrite IO] opération, alors que la fonction _exit n'est pas, à la fonction emploi du temps mauvais _exit ne peut garantir l'intégrité des données!
En d'autres termes, la fonction de sortie ouvre le cas avant la fin du processus sera vérifié à fond le fichier, le contenu du tampon de fichier est écrit dans le fichier!
Pourquoi est-il appeler des données de fonction _exit est incomplète qui va se passer? Nous allons dans les détails sur le Linux sous-jacent
Dans la fonction de bibliothèque standard Linux, il y a une opération de tampon connu [IO], caractérisé en ce que correspondant à chaque fichier ouvert, dans la mémoire a une mémoire tampon, lire en continu chaque fois qu'un fichier est lu plusieurs pièces après les données afin qu'il puisse être lu lors de la prochaine lecture directement depuis la mémoire tampon pour améliorer la vitesse, le même, chacun des fichiers d'écriture quand il est seulement écrit dans la mémoire tampon de mémoire, telles que certaines conditions sont remplies (accumuler un certain nombre de caractères), le contenu du fichier à écriture unique tampon, cette technologie a considérablement augmenté la vitesse de lecture de fichier et de l'écriture, mais aussi ajouter un peu aux stands de programmation, tels que des données, en théorie, devrait écrire dans le fichier, mais en fait parce que certaines conditions ne sont pas remplies, il est de notoriété stockée dans la mémoire tampon, si la fonction _exit fin directement du processus, les données tampons seront perdues, de sorte que vous voulez vous assurer que l'intégrité des données , assurez-vous d'utiliser la fonction de sortie, plutôt qu'une fonction _exit
réimpression Adresse: https://www.cnblogs.com/yinbiao/p/11202089.html
