Partage d'exemples d'exploration SAPI du noyau PHP

En tant que langage simple et puissant, PHP peut fournir de nombreuses fonctionnalités linguistiques adaptées au Web. En partant de la pratique, après avoir exploré le principe des variables faiblement typées, Wang Shuai continuera à vous amener à clarifier certaines parties communes du noyau PHP. Cette question est une compréhension approfondie de SAPI.

SAPI est l'abréviation de Server Application Programming Interface. PHP fournit un ensemble d'interfaces via SAPI pour l'interaction des données entre les applications et le noyau PHP.

Pour faire simple, tout comme l'entrée et la sortie d'une fonction, nous exécutons un morceau de code PHP via la ligne de commande Linux. L'essentiel est que le shell Linux transmet un ensemble de paramètres via le SAPI de PHP. . Une fois que le moteur Zend l'a exécuté, il renvoie au shell, le processus affiché par le shell. De même, PHP est appelé via Apache et les données sont transmises à SAPI via le serveur Web. Une fois le moteur Zend exécuté, elles sont renvoyées à Apache et Apache les affiche sur la page.

Figure 1. Diagramme d'architecture PHP

PHP fournit de nombreuses formes d'interfaces, notamment apache, apache2filter, apache2handler, caudium, cgi, cgi-fcgi, cli, cli-server, continuité , embed, isapi, litespeed, milter, nsapi, phttpd pi3web, roxen, thttpd, tux et webjames. Mais il n'existe que 5 formulaires couramment utilisés, CLI/CGI (ligne de commande), Multiprocess (multi-processus), Multithreaded (multi-thread), FastCGI et Embedded (embarqué).

PHP fournit une fonction pour afficher le type d'interface SAPI actuel :

string php_sapi_name ( void )

PHP en cours d'exécution et en chargement

Peu importe le SAPI utilisé, avant et après que PHP exécute le script, contient une série d'événements : Init du module (MINT) et arrêt (MSHUTDOWN), Init de la demande (RINT) et arrêt (RSHUTDOWN). La première phase est la phase d'initialisation du module PHP (MINT), qui peut initialiser des variables internes étendues, allouer des ressources et enregistrer des processeurs de ressources. Ce processus n'est exécuté qu'une seule fois pendant tout le cycle de vie de l'instance PHP.

Qu'est-ce qu'un module PHP ? Grâce au diagramme d'architecture PHP ci-dessus, vous pouvez utiliser la fonction get_loaded_extensions en PHP pour afficher tous les modules/extensions compilés et chargés, ce qui équivaut à php -m en mode CLI.

Prenons comme exemple le code source de l'extension Memcached de PHP :

PHP_MINIT_FUNCTION(memcached) { 	
	zend_class_entry ce;  	
	memcpy(&memcached_object_handlers,zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 	
memcached_object_handlers.clone_obj = NULL;  	/* 执行了一些类似的初始化操作 */  	
return SUCCESS; 
}

La deuxième phase est la phase d'initialisation de la demande (RINT). Une fois le module initialisé et activé, l'environnement d'exécution PHP sera exécuté. être créé et en même temps appeler la fonction RINT enregistrée par tous les modules, appeler la fonction d'initialisation de demande de chaque extension, définir des variables d'environnement spécifiques, allouer des ressources ou effectuer d'autres tâches telles que l'audit.

PHP_RINIT_FUNCTION(memcached) { 	
	/* 执行一些关于请求的初始化 */  	
	return SUCCESS; 
}

Dans la troisième étape, une fois le traitement de la demande terminé, PHP_RSHUTDOWN_FUNCTION sera appelé pour le recyclage. Il s'agit de la fonction de fermeture de demande de chaque extension pour effectuer le travail de nettoyage final. Le moteur Zend effectue un processus de nettoyage, un garbage collection et désinitialise chaque variable utilisée lors des requêtes précédentes. La requête peut être complétée jusqu'à ce que le script soit terminé, ou elle peut être complétée en appelant la fonction die() ou exit()

Dans la quatrième étape, lorsque le cycle de vie PHP se termine, PHP_MSHUTDOWN_FUNCTION recycle le module. Ceci concerne chaque fonction d'arrêt de module étendu, utilisée pour arrêter son propre sous-système de noyau.

PHP_MSHUTDOWN_FUNCTION(memcached) { /* 执行关于模块的销毁工作 */ UNREGISTER_INI_ENTRIES(); return SUCCESS; }

Modes de fonctionnement courants

Il existe cinq modes SAPI courants :

• Mode CLI et CGI (mode processus unique)

• Mode multi-processus

• Mode multi-thread

• Mode FastCGI

• Embedded

1. Mode CLI/CGI

CLI et CGI appartiennent tous deux au mode mono-processus, et le cycle de vie de PHP est terminé en un seul. demande. C'est-à-dire qu'à chaque fois qu'un script PHP est exécuté, les quatre événements INT et Shutdown mentionnés dans la deuxième partie seront exécutés.

Figure 2. Cycle de vie CGI/CLI

2. Mode multiprocessus (Multiprocessus)

Le mode multiprocessus peut intégrer PHP dans le serveur Web PHP Cela peut être. compilé en mode MPM prefork et dans le module APXS sous Apache. Au démarrage d'Apache, il créera de nombreux processus enfants, et chaque processus enfant possède son propre espace d'adressage de processus indépendant.

Figure 3. Cycle de vie en mode multi-processus

Dans un processus enfant, le cycle de vie de PHP consiste à exécuter plusieurs requêtes (RINT/RSHUTDOWN) après avoir appelé MINT pour démarrer. MSHUTDOWN ne sera appelé pour la phase de recyclage qu'après l'arrêt d'Apache ou la fin du processus.

Figure 4. Cycle de vie du multi-processus

Dans le modèle multi-processus, chaque sous-processus s'exécute indépendamment sans partager de code ni de données, donc un sous-processus se termine, sorties et redémarrages La génération n'affectera pas la stabilité des autres processus enfants.

3. Mode multithread (Multithread)

Worker MPM d'Apache2 adopte un modèle multithread, créant plusieurs threads sous un seul processus et les exécutant dans le même espace d'adressage de processus.

Figure 5. Cycle de vie multithread

4. Mode FastCGI

Le Nginx+PHP-FPM que nous utilisons utilise le mode FastCGI est un mode CGI spécial. Type de processus résident de CGI Il peut bifurquer plusieurs processus après son exécution. Il n'est pas nécessaire de passer du temps à bifurquer dynamiquement des sous-processus, et il n'est pas nécessaire d'appeler MINT/MSHUTDOWN pour chaque requête. PHP gère et planifie le pool de processus de FastCGI via PHP-FPM. Nginx et PHP-FPM communiquent via TCP Socket et Unix Socket locaux.

Figure 6. Cycle de vie du mode FastCGI

PHP-FPM进程管理器自身初始化，启动多个CGI解释器进程等待来自Nginx的请求。当客户端请求达到PHP-FPM，管理器选择到一个CGI进程进行处理，Nginx将CGI环境变量和标准输入发送到一个PHP-CIG子进程。PHP-CGI子进程处理完成后，将标准输出和错误信息返回给Nginx，当PHP-CGI子进程关闭连接时，请求处理完成。PHP-CGI子进程等待着下一个连接。

可以想象CGI的系统开销有多大。每一个Web 请求PHP都必须重新解析php.ini、载入全部扩展并始化全部数据结构。使用FastCGI，所有这些都只在进程启动时发生一次。另外，对于数据库和Memcache的持续连接可以工作。

5. 内嵌模式（Embedded）

Embed SAPI是一种特殊的SAPI，允许在C/C++语言中调用PHP提供的函数。这种SAPI和CLI模式一样，按照Module Init => Request Init => Request => Request Shutdown => Module Shutdown的模式运行。

Embed SAPI可以调用PHP丰富的类库，也可以实现高级玩法，比如可以查看PHP的OPCODE（PHP执行的中间码，Zend引擎的指令，由PHP代码生成）。

详细请见： http://www.laruence.com/2008/09/23/539.html

SAPI的运行机制

我们以CGI为例，看一下SAPI的运行机制。

static sapi_module_struct cgi_sapi_module = {     
	"cgi-fcgi",                     /* 输出给php_info()使用 */     "CGI/FastCGI",                  /* pretty name */      
	php_cgi_startup,                /* startup 当SAPI初始化时，首先会调用该函数 */     
	php_module_shutdown_wrapper,    /* shutdown  关闭函数包装器，它用来释放所有的SAPI的数据结构、内存等，调用php_module_shutdown */      
	sapi_cgi_activate,              /* activate  此函数会在每个请求开始时调用，它会做初始化，资源分配 */     
	sapi_cgi_deactivate,            /* deactivate  此函数会在每个请求结束时调用，它用来确保所有的数据都得到释放 */      
	sapi_cgi_ub_write,              /* unbuffered write  不缓存的写操作(unbuffered write)，它是用来向SAPI外部输出数据 */     
	sapi_cgi_flush,                 /* flush  刷新输出，在CLI模式下通过使用C语言的库函数fflush实现*/     NULL,                           /* get uid */     
	sapi_cgi_getenv,                /* getenv 根据name查找环境变量 */      
	php_error,                      /* error handler 注册错误处理函数  */      
	NULL,                           /* header handler PHP调用header()时候被调用 */     
	sapi_cgi_send_headers,          /* send headers handler 发送头部信息*/     
	NULL,                           /* send header handler 发送一个单独的头部信息 */      
	sapi_cgi_read_post,             /* read POST data  当请求的方法是POST时，程序获取POST数据，写入$_POST数组 */     
	sapi_cgi_read_cookies,          /* read Cookies 获取Cookie值  */      
	sapi_cgi_register_variables,    /* register server variables 给$_SERVER添加环境变量 */     
	sapi_cgi_log_message,           /* Log message 输出错误信息 */     
	NULL,                           /* Get request time */     
	NULL,                           /* Child terminate */      
	STANDARD_SAPI_MODULE_PROPERTIES 
};

由上面代码可见，PHP的SAPI像是面向对象中基类，SAPI.h和SAPI.c包含的函数是抽象基类的声明和定义，各个服务器用的SAPI模式，则是继承了这个基类，并重新定义基类方法的子类。

总结

PHP的SAPI是Zend引擎提供的一组标准交互接口，通过注册初始化、析构、输入、输出等接口，我们可以将应用程序运行在Zend引擎上，也可以把PHP嵌入到类似Apache的Web Server中。PHP常见的SAPI模式有五种，CGI/CLI模式、多进程模式、多线程模式、FastCGI模式和内嵌模式。

了解PHP的SAPI机制意义重大，帮助我们理解PHP的生命周期，并了解如何更好的通过C/C++为PHP编写扩展，并在生命周期中找到提高系统性能的方式。

相关推荐：

详解PHP内核解释器的执行

PHP内核-简单讲解PHP灵魂HashTble

PHP内核--探究内存管理与缓存机制的图文详解

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!