Explication détaillée du cycle de vie PHP au bas de PHP

Cet article partage principalement avec vous l'explication détaillée du cycle de vie PHP au bas de PHP. J'espère qu'il pourra vous aider.

1. Mode de fonctionnement PHP :

Les deux modes de fonctionnement de PHP sont le mode WEB et le mode CLI. Quel que soit le mode, PHP fonctionne de la même manière, fonctionnant comme SAPI.

1. Lorsque nous tapons la commande php dans le terminal, elle utilise la CLI.

C'est comme un serveur Web qui prend en charge php pour terminer la requête. Une fois la requête terminée, le contrôle est rendu au terminal.

2. Lorsque vous utilisez Apache ou un autre serveur Web comme hôte, lorsqu'une requête arrive, PHP prendra en charge l'exécution de la requête. Généralement :

Multi-processus (généralement compilé comme un module Apache pour gérer les requêtes PHP)

Mode multithread

2. Le début de tout : l'interface SAPI

Habituellement, lorsque nous écrivons des programmes Web php, nous testons le script via des serveurs Web tels qu'Apache ou Nginx. Ou Exécutez le script PHP via le programme php sur la ligne de commande. Une fois le script exécuté, le serveur répond et le navigateur affiche les informations de réponse ou affiche le contenu sur la sortie standard une fois la commande terminée. Nous nous soucions rarement de l'endroit où se trouve l'interpréteur PHP. Bien que l'exécution de scripts via un serveur Web et un programme en ligne de commande soient très différents, leur travail est en fait le même. Les programmes en ligne de commande sont similaires aux programmes Web et les paramètres de ligne de commande y sont transmis. l'exécution Le script équivaut à demander une page PHP via l'URL. Une fois le script terminé, le résultat de la réponse est renvoyé, mais le résultat de la réponse en ligne de commande est affiché sur le terminal. Le début de l'exécution du script est effectué via l'interface SAPI. .

1), démarrer Apache :Quand un SAPI donné démarre, par exemple en réponse à /usr/local/apache/bin/apachectl start. , PHP Commencez par initialiser son sous-système noyau. Vers la fin de la routine de démarrage, il charge le code de chaque extension et appelle sa routine d'initialisation de module (MINIT). Cela permet à chaque extension d'initialiser des variables internes, d'allouer des ressources, d'enregistrer des gestionnaires de ressources et d'enregistrer ses propres fonctions auprès de ZE afin que ZE sache quel code exécuter lorsque le script appelle les fonctions.

2) Initialisation du traitement des demandes  : Ensuite, PHP attend que la couche SAPI demande que la page soit traitée. Pour les SAPI comme CGI ou CLI, cela se produira immédiatement et une seule fois. Pour Apache, IIS ou tout autre serveur Web mature SAPI, cela se produira chaque fois que l'utilisateur distant demandera la page, donc cela sera répété plusieurs fois, éventuellement simultanément. Quelle que soit la manière dont la requête est générée, PHP commence par demander à ZE de configurer l'environnement d'exécution du script, puis appelle l'initialisation de la requête de chaque extension. (RINIT). RINIT donne aux extensions la possibilité de définir des variables d'environnement spécifiques, d'allouer des ressources sur demande ou d'effectuer d'autres tâches telles que l'audit. Il existe un exemple typique du rôle de RINIT dans l'extension de session. Si l'option session.auto_start est activée, RINIT déclenchera automatiquement la fonction session_start() dans l'espace utilisateur et la variable $_SESSION préassemblée.

3) Exécuter le code php  : Une fois la requête initialisée, ZE commence à prendre le contrôle, traduit le script PHP en symboles, et enfin forme l'opcode et l'exécute étape par étape. Si un opcode doit appeler une fonction étendue, ZE liera les paramètres à la fonction et abandonnera temporairement le contrôle jusqu'à ce que la fonction soit terminée.

4) Fin du script : Une fois le script exécuté, PHP appelle la fonction d'arrêt de demande (RSHUTDOWN) de chaque extension pour effectuer le travail de nettoyage final (comme l'enregistrement des variables de session sur le disque). Ensuite, ZE effectue un processus de nettoyage (garbage collection) - désactivant efficacement () chaque variable utilisée lors de la requête précédente.

5), sapi se ferme  : Une fois terminé, PHP continue d'attendre d'autres demandes de documents de SAPI ou un signal d'arrêt. Pour les SAPI tels que CGI et CLI, il n'y a pas de « requête suivante », donc le SAPI commence immédiatement à se fermer . Pendant l'arrêt, PHP parcourt à nouveau chaque extension, appelle sa fonction d'arrêt de module (MSHUTDOWN) et arrête finalement son propre sous-système de noyau.

Le bref processus est le suivant :

1. PHP s'exécute au démarrage d'Apache
2. PHP s'exécute via mod_php5 ; Le module .so est connecté à Apache (plus précisément SAPI, l'interface de programmation d'applications serveur) ;
3. PHP a trois modules au total : le noyau, le moteur Zend et la couche d'extension
4. Le noyau PHP est utilisé pour ; Traitement des requêtes, des flux de fichiers, gestion des erreurs et autres opérations associées ;
5. Le moteur Zend (ZE) est utilisé pour convertir les fichiers sources en langage machine puis l'exécuter sur une machine virtuelle
6. La couche d'extension est ; un ensemble de fonctions, de bibliothèques et de flux sont utilisés par PHP pour effectuer des opérations spécifiques. Par exemple, nous avons besoin de l'extension mysql pour nous connecter à la base de données MySQL ;
7. Lorsque ZE exécute le programme, il devra peut-être se connecter à plusieurs extensions. À ce stade, ZE confiera le contrôle à l'extension et le rendra. après avoir traité la tâche spécifique ;
8. Enfin, ZE renvoie les résultats du programme en cours d'exécution au noyau PHP, qui transmet ensuite les résultats à la couche SAPI et les envoie enfin au navigateur.

3. Les phases de début et de fin de PHP

Il y a deux processus dans la phase de début :

Le premier processus : Apache démarre le processus, c'est-à-dire se produit avant l'arrivée de toute demande. Il s'agit de la phase de début (MINIT) de tout le cycle de vie de SAPI (comme tout le cycle de vie après le démarrage d'Apache ou tout le processus d'exécution du programme en ligne de commande). Cette phase n'est effectuée qu'une seule fois . Après avoir démarré Apache, l'interpréteur PHP démarre également ; PHP appelle la méthode MINIT de chaque extension (module), faisant ainsi passer ces extensions à un état disponible. Jetez un œil aux extensions ouvertes dans le fichier php.ini ; MINIT signifie « initialisation du module ». Chaque module définit un ensemble de fonctions, de bibliothèques de classes, etc. pour gérer d'autres requêtes. Le module peut effectuer certains travaux d'initialisation à ce stade, comme l'enregistrement de constantes, la définition des classes utilisées par le module, etc. La fonction de rappel du module typique Méthode MINIT est la suivante :

PHP_MINIT_FUNCTION(myphpextension) { /* Initialize functions, classes etc */ }
{
    // 注册常量或者类等初始化操作
    return SUCCESS; 
}

Le deuxième processus se produit dans la phase de requête , lorsqu'une requête de page se produit Le processus d'initialisation (démarrage de la requête RINIT) sera effectué avant chaque requête

Après l'arrivée de la requête, la

La couche SAPI confie le contrôle à la couche PHP, Initialisation PHPCette requêteExécuter le scriptVariables d'environnement requises , pour Par exemple, créez un environnement d'exécution, comprenant une table de symboles qui enregistre les noms de variables et le contenu des valeurs des variables pendant l'exécution de PHP. Ainsi que la table des symboles de toutes les fonctions, classes et autres informations actuelles Par exemple, c'est le RINIT du module Session Si le module Session est activé dans php.ini, la variable $_SESSION sera initialisée lorsque. le RINIT du module est appelé, et Lire le contenu pertinent ; Ensuite, PHP appellera la fonction RINIT de tous les modules, qui est une "demande d'initialisation". A ce stade, chaque module peut également effectuer certaines opérations associées. La fonction RINIT du module est similaire à la fonction MINIT. La méthode RINIT peut être considérée comme un processus de préparation, qui démarrera automatiquement entre les exécutions du programme.

PHP_RINIT_FUNCTION(myphpextension)
{
    // 例如记录请求开始时间
    // 随后在请求结束的时候记录结束时间.这样我们就能够记录下处理请求所花费的时间了
    return SUCCESS; 
}

L'étape finale est divisée en deux parties :

Demande complétée Ensuite, il entre dans la phase de fin. Généralement, lorsque le script est exécuté jusqu'à la fin ou en appelant la fonction exit() ou die(), PHP entrera dans la phase de fin. Correspondant à la phase de démarrage, la phase de fin est également divisée en. deux liens, un après la fin de la requête (RSHUWDOWN), un à la fin du cycle de vie SAPI (MSHUTDOWN).

Premier lien : Phase de fin après le traitement de la requête : Une fois la requête traitée, elle entre dans la phase de fin et PHP lancera le processus de nettoyage . Il appellera la méthode RSHUTDOWN de chaque module dans l'ordre. RSHUTDOWN permet d'effacer la table des symboles générée lors de l'exécution du programme, c'est-à-dire d'appeler la fonction unset sur chaque variable. La méthode RSHUTDOWN typique est la suivante :

PHP_RSHUTDOWN_FUNCTION(myphpextension)
{
    // 例如记录请求结束时间, 并把相应的信息写入到日至文件中.
    return SUCCESS; 
}

Deuxième lien : Enfin, toutes les demandes ont été traitées et SAPI a été prêt. pour fermer, PHP appelle la méthode MSHUTDOWN de chaque extension. C'est la dernière chance pour chaque module de libérer de la mémoire. (C'estPour les SAPI tels que CGI et CLI, il n'y a pas de « requête suivante », donc le SAPI commence immédiatement à se fermer. )

La méthode RSHUTDOWN typique est la suivante :

PHP_MSHUTDOWN_FUNCTION(extension_name) { 
    /* Free handlers and persistent memory etc */ 
    return SUCCESS; 
}

De cette façon, tout le cycle de vie de PHP est terminé. A noter que « démarrer la première étape » et « fermer la deuxième étape » ne seront exécutés que lorsqu'il n'y a pas de requête du serveur.

SAPI exécute PHP à travers les étapes suivantes :
1. Phase d'initialisation du module (Module init)  :
C'est-à-dire appeler chaque extension dans le code source. les méthodes dans PHP_MINIT_FUNCTION initialisent le module, appliquent certaines variables requises par le module, allouent de la mémoire, etc.
2. Phase d'initialisation de la demande (Request init) ：
Autrement dit, après avoir reçu la demande du client, la méthode dans chaque PHP_RINIT_FUNCTION étendue est appelée pour initialiser l'exécution de l'environnement de script PHP.
3. Exécuter le script PHP
4. Demande d'arrêt (Demande d'arrêt) ：
Appelé à cela time La méthode PHP_RSHUTDOWN_FUNCTION de chaque extension nettoie le site de requête et ZE commence à récupérer les variables et la mémoire.
5. Arrêt du module :
Lorsque le serveur Web se ferme ou que le script de ligne de commande est exécuté et se termine, la méthode PHP_MSHUTDOWN_FUNCTION dans le code source de l'extension sera appelée

4. Cycle de vie SAPI mono-processus

Mode CLI/CGI PHP appartient au mode SAPI mono-processus. Ce type de demande est clôturé après avoir traité une seule fois la demande. C'est-à-dire qu'elle ne passera que par les liens suivants : Début - Début de la requête - Clôture de la requête - Fin L'implémentation de l'interface SAPI termine son cycle de vie. Comme le montre la figure :

                                                                                                  Module pour gérer les requêtes PHP. Apache adopte généralement le mode multi-processus. Après le démarrage d'Apache, il

déboursera plusieurs processus enfants. Chaque processus dispose d'un espace mémoire indépendant. Chaque processus enfant passera par les étapes de début et de fin, mais le démarrage. étape de chaque processus

n'est effectué qu'après la fin du processus, et plusieurs demandes peuvent être traitées tout au long du cycle de vie du processus. Uniquement si Apache est arrêté ou en cours de traitement

被结束之后才会进行关闭阶段，在这两个阶段之间会随着每个请求重复请求开始-请求关闭的环节。 

如图所示：

                                     

6、多线程的SAPI生命周期

多线程模式和多进程中的某个进程类似，不同的是在整个进程的生命周期内会并行的重复着 请求开始-请求关闭的环节.

在这种模式下，只有一个服务器进程在运行着，但会同时运行很多线程，这样可以减少一些资源开销，向Module init和Module shutdown就只需要运行一遍就行了，一些全局变量也只需要初始化一次，因为线程独具的特质，使得各个请求之间方便的共享一些数据成为可能。

 多线程工作方式如下图

                              

7、Apache一般使用多进程模式prefork

        在linux下使用#http –l 命令可以查看当前使用的工作模式。也可以使用#apachectl -l命令。
        看到的prefork.c，说明使用的prefork工作模式。

        prefork 进程池模型，用在 UNIX 和类似的系统上比较多，主要是由于写起来方便，也容易移植，还不容易出问题。要知道，如果采用线程模型的话，用户线程、内核线程和混合型线程有不同的特性，移植起来就麻烦。prefork 模型，即预先 fork() 出来一些子进程缓冲一下，用一个锁来控制同步，连接到来了就放行一个子进程，让它去处理。

    prefork MPM 使用多个子进程，每个子进程只有一个线程。每个进程在某个确定的时间只能维持一个连接。在大多数平台上，Prefork MPM在效率上要比Worker MPM要高，但是内存使用大得多。prefork的无线程设计在某些情况下将比worker更有优势：他能够使用那些没有处理好线程安全的第三方模块，并 且对于那些线程调试困难的平台而言，他也更容易调试一些。

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!