Environnement de processus – gestion des processus

Quand le programme est exécuté, comment la fonction principale est appelée, comment les paramètres de ligne de commande sont transmis au programme, à quoi ressemble la disposition typique de l'espace de stockage, comment allouer un autre espace de stockage, comment le processus utilise les variables d'environnement, la fin du processus, etc. Ce sont les bases du contrôle des processus.

Démarrage et arrêt du processus

Lorsque le noyau exécute un programme c, il utilise la fonction exec pour appeler une routine de démarrage spéciale, qui se trouve dans le kernel Récupère les paramètres de ligne de commande et les valeurs des variables d'environnement.

Situations de fin de processus

5 situations de fin normales :

（1）从main函数返回；
（2）调用exit；
（3）调用_exit和_Exit函数;
（4）最后一个线程调用pthread_exit;
（5）最后一个线程从其启动例程返回；

3 situations de fin anormales

（1）调用abort；
（2）接到一个信号；
（3）最后一个线程对取消请求做出响应；

Démarrage et fin du processus Figure

fonction atexit

Un processus peut enregistrer jusqu'à 32 fonctions (par exemple : fonction signal), qui sont automatiquement appelées par la fonction exit. Ces fonctions sont appelées lorsque le programme se termine pour former un gestionnaire de terminaison afin d'effectuer le travail de finition avant de terminer le processus. La fonction exit utilise l'enregistrement d'enregistrement de la fonction atexit pour déterminer les fonctions à appeler.

fonction de sortie

Cette fonction est définie par ISO C et ses opérations incluent le traitement du gestionnaire de terminaison, puis la fermeture de tous les flux d'E/S standard. Il est à noter qu'il ne gère pas les descripteurs de fichiers, le multi-processus (processus parent-enfant) et le contrôle des tâches.

Fonction _e(E)xit
ISO C Le but de la définition de cette fonction est de fournir un moyen pour le processus de terminer le programme sans exécuter de gestionnaire de terminaison ou de fonction de gestion de signal. Mais le fait que ISO C vide le flux d'E/S standard dépend de l'implémentation du système d'exploitation. Sous Unix, le vidage n’est pas effectué.

Codes d'état des fonctions de sortie et _e(E)ixt

Peu importe la façon dont le processus se termine, il exécutera le même code sur le noyau (comme le montre le démarrage et la sortie du processus diagramme). Ce code ferme tous les descripteurs de fichiers et libère tout l'espace de stockage.

Une fois le programme terminé, utilisez le code de sortie pour informer le processus parent du processus. Le processus parent utilise la fonction wait ou waitpid pour compléter les conséquences du processus enfant (obtenir des informations sur le processus enfant et libérer les ressources occupées par le processus enfant). Si le processus parent ne gère pas l'état de sortie du processus enfant, le processus enfant devient un processus zombie. Au contraire, si le processus parent se termine avant le processus enfant, le processus enfant devient un processus orphelin . Le processus orphelin sera reçu par le processus n°1 (processus init). Le processus général est le suivant :

Fonctions wait et waitpid

（1）进程终止时，内核逐个检查所有活动的进程；
（2）分析查找该终止进程的子进程；
（3）将该进程的子进程的父进程ID改为1；

Lorsque le programme se termine normalement ou anormalement, le noyau enverra SIGNAL au processus parent Signal. La fin du processus enfant est un événement asynchrone, ce signal est donc également un signal asynchrone. Ce signal est généralement ignoré par le processus parent par défaut. Ou fournissez une fonction de traitement du signal pour gérer les conséquences. Les fonctions wait et waitpid font partie de la fonction de traitement du signal.

La différence entre les fonctions wait et waitpid est la suivante :

（1）wait会阻塞调用者进程等待直至第一个终止的子进程到来；
（2）waitpid可以通过参数设置，来实现调用者进程不阻塞，或选择要阻
塞等待的子进程；

L'appelant ici fait référence au processus parent

Table d'environnement et environnement variables

Schéma de structure de la table d'environnement

Chaque programme reçoit une table d'environnement
La table d'environnement est aussi un tableau de pointeurs de caractères
enrivon est appelé le pointeur d'environnement
Le tableau de pointeurs est appelé table d'environnement
🎜>

• La chaîne pointée par chaque pointeur est appelée la chaîne d'environnement

Variable d'environnement

• La Le noyau Unix ne vérifie pas la chaîne d'environnement, leur L'explication dépend entièrement de chaque processus d'application

• Définir généralement des variables d'environnement dans un fichier de démarrage du shell pour contrôler les actions du shell

• Modifier ou ajouter l'environnement Lorsqu'une variable est utilisée, elle ne peut affecter que l'environnement du processus en cours et de tous les processus enfants ultérieurs générés et appelés (mais pas les précédents), mais elle ne peut pas affecter le environnement de son processus parent

Liées aux variables d'environnement Les fonctions sont les suivantes :

#include<stdlib.h>
char *getenv(const char *name);
      返回值：指向与name关联的value的指针；若未找到，返回NULL

int putenv(char *str);
                       返回值：若成功，返回0；若出错，返回非0
                       
int setenv(const char *name, const char *value,
            int rewrite);
int unsetenv(const char *name);
                两个函数返回值：若成功，返回0；若出错，返回-1</stdlib.h>

Comment ces fonctions modifient la table d'environnement

Le La table d'environnement et la chaîne d'environnement sont généralement stockées à des adresses élevées (en haut) de l'espace mémoire. Par conséquent, lors de la modification de sa valeur, la mémoire ne peut pas continuer à s'étendre vers des adresses élevées, mais comme il y a des trames de pile en dessous, elle ne peut pas s'étendre vers le bas. Le processus pour modifier sa valeur est le suivant :

(1) Modifier la table d'environnement

1）新value = 旧value,调用malloc函数，在堆区开辟新的存储空间，
将新value复制到这里，再将这片存储区首地址写到环境表相应的位置处。

(2) Ajouter une table d'environnement

1）新增一个环境变量，调用malloc函数开辟新的存储空间，将原来的环
境表复制到该存储区，其次再添加一个环境变量，然后在尾部赋值为NULL，
最后将environ指向该区域；
2）在 1）过程的基础上，调用realloc函数，多次添加环境变量；

Remarque :

Les variables d'environnement ainsi modifiées ne sont valables que lorsque le programme en cours est en cours d'exécution. À la fin du programme, la zone de stockage correspondante est recyclée par le. système, et ces modifications deviendront invalides.

Explication supplémentaire de la structure de stockage en mémoire

Schéma de la structure de gestion de la mémoire

• Segment de données non initialisé ( bloc démarré par le symbole) :
  Avant que le programme ne commence à exécuter

  , le noyau initialise les données de ce segment à 0 ou à un pointeur nul

• pile :

  Chaque fois qu'une fonction est appelée, son adresse de retour et les informations sur l'environnement de l'appelant (telles que la valeur de certains registres machine) sont stockées sur la pile ;

• 共享库：只需在所有进程都可引用的存储区中保存这种库例程的一个副本；

存储空间分配函数

#include<stdlib.h>
void *malloc(size_t size);
void *calloc(size_t nojy, size_t size);
void *realloc(void *ptr, size_t newsize);
         3个函数返回值：若成功，返回非空指针；若出错，返回NULL</stdlib.h>

• malloc函数：初始值不确定；底层通过调用sbrk函数实现；

• calloc函数：初始值为0；

• realloc函数：增加或减少以前分配区的长度；当增加长度时，可能将以前分配区的内容移到另一个足够大的区域，以便在分配区末尾增加存储区，而新增存储区初始值不确定(例如：可变数组的使用)；

注意：这些动态分配的函数一般在分配存储空间时，会比要求的大。因为在开辟空间的前后部分存储记录管理信息。因此，在使用时，千万不要越界访问，以免造成不可预知的后果。

函数间跳转策略

在c语言中，goto语句是不能跨函数跳转的。尤其是在函数深层调用时的跳转需求，在出错处理的情况下非常有用。

#include<setjmp.h>
int setjmp(jmp_buf env);
          返回值：若直接调用，返回0；若从longjmp返回，返回非0
void longjmp(jmp_buf env, int val);</setjmp.h>

变量值回滚问题：自动变量和寄存器变量会存在回滚现象。利用volatile属性来避免此类情况的发生。(在给变量赋值时，赋的值回首先存储在内存(存储器变量)中，然后在由cpu取走，存储在cpu的寄存器上(寄存器变量)。在做系统优化时，那些频繁使用的变量，会直接存储到寄存器中而不经过内存。)

寄存器变量会存在回滚现象的探究

在调用setjmp函数时，内核会把当前的栈顶指针保存在env变量中，所以在调用longjmp函数返回该位置时，全局变量、静态变量、易失变量和自动变量如果在调用setjmp和longjmp函数之间它们的值被修改过，是不会回滚到setjmp函数调用之前的值(当然，编译器将auto变量优化为寄存器变量除外)。因为，这些存储器变量的值是存储在内存相应的段中，回到原先栈顶状态时，同样访问的还是原先的内存空间。

然而，对于寄存器变量来说，首先要明确一点：寄存器变量是用动态存储的方式。意思是寄存器变量的值可能存在不同的寄存器中。如果在调setjmp和longjmp函数之间它们的值被修改过，这个值可能不会存到setjmp之前的对其赋值的寄存器中，而在调用longjmp函数后，又回到了调用setjmp函数时的状态。这个时候再读取寄存器变量的值时，读到的是原先那个寄存器中存储的值而不是修改过的那个寄存器中存储的值，所以出现的回滚现象。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!