Detaillierte Erläuterung des PHP-Lebenszyklus am Ende von PHP

Dieser Artikel teilt Ihnen hauptsächlich die detaillierte Erklärung des PHP-Lebenszyklus am Ende von PHP mit. Ich hoffe, er kann Ihnen helfen.

1. PHP-Betriebsmodus:

Die beiden Betriebsmodi von PHP sind WEB-Modus und CLI-Modus. PHP funktioniert unabhängig vom Modus gleich und läuft als SAPI.

1. Wenn wir den PHP-Befehl in das Terminal eingeben, wird die CLI verwendet.

Es ist wie ein Webserver, der PHP zum Vervollständigen der Anfrage unterstützt. Nachdem die Anfrage abgeschlossen ist, wird die Kontrolle an das Terminal zurückgegeben.

2. Wenn Sie Apache oder einen anderen Webserver als Host verwenden, unterstützt PHP die Vervollständigung der Anfrage. Im Allgemeinen:

Multiprozess (normalerweise als Apache-Modul kompiliert, um PHP-Anfragen zu verarbeiten)

Multithread-Modus

2. Der Anfang von allem: SAPI-Schnittstelle

Wenn wir PHP-Webprogramme schreiben, testen wir das Skript normalerweise über Webserver wie Apache oder Nginx. Oder führen Sie das PHP-Skript über das PHP-Programm in der Befehlszeile aus. Nachdem das Skript ausgeführt wurde, antwortet der Server und der Browser zeigt die Antwortinformationen an oder zeigt den Inhalt in der Standardausgabe an, nachdem der Befehl beendet ist. Es ist uns kaum wichtig, wo sich der PHP-Interpreter befindet. Obwohl die Ausführung von Skripten über einen Webserver und ein Befehlszeilenprogramm sehr unterschiedlich aussieht, ähneln Befehlszeilenprogramme denen von Webprogrammen, und Befehlszeilenparameter werden an sie übergeben Die Ausführung des Skripts entspricht dem Anfordern einer PHP-Seite über die URL. Nach Abschluss des Skripts wird das Antwortergebnis zurückgegeben, das Befehlszeilenantwortergebnis wird jedoch auf dem Terminal angezeigt. Der Beginn der Skriptausführung erfolgt über die SAPI Schnittstelle.

1), Apache starten:Wenn eine bestimmte SAPI startet, zum Beispiel als Antwort auf /usr/local/apache/bin/apachectl start, PHP beginnt mit der Initialisierung seines Kernel-Subsystems. Gegen Ende der Startroutine lädt es den Code jeder Erweiterung und ruft seine Modulinitialisierungsroutine (MINIT) auf. Dadurch kann jede Erweiterung interne Variablen initialisieren, Ressourcen zuweisen, Ressourcenhandler registrieren und ihre eigenen Funktionen bei ZE registrieren, sodass ZE weiß, welcher Code ausgeführt werden muss, wenn das Skript die Funktionen aufruft.

2) Initialisierung der Anforderungsverarbeitung : Als nächstes wartet PHP darauf, dass die SAPI-Schicht die Verarbeitung der Seite anfordert. Bei SAPIs wie CGI oder CLI geschieht dies sofort und nur einmal. Bei Apache, IIS oder anderen ausgereiften Webserver-SAPIs geschieht dies jedes Mal, wenn der Remote-Benutzer die Seite anfordert, sodass es viele Male, möglicherweise gleichzeitig, wiederholt wird. Unabhängig davon, wie die Anfrage generiert wird, fordert PHP zunächst ZE auf, die Ausführungsumgebung des Skripts einzurichten, und ruft dann die Anfrageinitialisierung jeder Erweiterung auf (RINIT)-Funktion. RINIT gibt Erweiterungen die Möglichkeit, bestimmte Umgebungsvariablen festzulegen, Ressourcen auf Anfrage zuzuweisen oder andere Aufgaben wie Audits durchzuführen. Es gibt ein typisches Beispiel für die Rolle von RINIT bei der Sitzungserweiterung. Wenn die Option session.auto_start aktiviert ist, löst RINIT automatisch die Funktion session_start() im Benutzerbereich und die vormontierte Variable $_SESSION aus.

3) PHP-Code ausführen : Sobald die Anfrage initialisiert ist, beginnt ZE, die Kontrolle zu übernehmen, übersetzt das PHP-Skript in Symbole, bildet schließlich den Opcode und führt ihn Schritt für Schritt aus. Wenn ein Opcode eine erweiterte Funktion aufrufen muss, bindet ZE die Parameter an die Funktion und gibt die Kontrolle vorübergehend auf, bis die Funktion abgeschlossen ist.

4) Ende des Skripts: Nachdem das Skript ausgeführt wurde, ruft PHP die Funktion „Request Shutdown“ (RSHUTDOWN) jeder Erweiterung auf, um letzte Aufräumarbeiten durchzuführen (z. B. das Speichern von Sitzungsvariablen auf der Festplatte). Als nächstes führt ZE einen Bereinigungsprozess (Garbage Collection) durch, bei dem effektiv jede Variable, die während der vorherigen Anfrage verwendet wurde, deaktiviert() wird.

5), sapi schließt : Nach Abschluss wartet PHP weiterhin auf andere Dokumentanforderungen von SAPI oder ein Shutdown-Signal. Für SAPIs wie CGI und CLI gibt es keine „nächste Anfrage“, sodass die SAPI sofort mit dem Herunterfahren beginnt . Während des Herunterfahrens durchläuft PHP erneut jede Erweiterung, ruft die Funktion zum Herunterfahren des Moduls (MSHUTDOWN) auf und fährt schließlich sein eigenes Kernel-Subsystem herunter.

Der kurze Prozess ist wie folgt:

1. PHP läuft beim Start von Apache
2. PHP läuft über mod_php5 Das .so-Modul ist mit Apache verbunden (insbesondere SAPI, der Server-Anwendungsprogrammierschnittstelle); Verarbeitung von Anfragen, Dateiströmen, Fehlerbehandlung und anderen damit verbundenen Vorgängen;
5. Die Zend-Engine (ZE) wird verwendet, um Quelldateien in Maschinensprache zu konvertieren und sie dann auf einer virtuellen Maschine auszuführen Eine Reihe von Funktionen, Bibliotheken und Streams werden von PHP verwendet, um bestimmte Vorgänge auszuführen. Zum Beispiel benötigen wir die MySQL-Erweiterung, um eine Verbindung zur MySQL-Datenbank herzustellen. 7. Wenn ZE das Programm ausführt, muss es möglicherweise eine Verbindung zu mehreren Erweiterungen herstellen. Zu diesem Zeitpunkt übergibt ZE die Kontrolle an die Erweiterung nach der Verarbeitung der spezifischen Aufgabe;
8. Schließlich gibt ZE die Ergebnisse der Programmausführung an den PHP-Kernel zurück, der die Ergebnisse dann an die SAPI-Schicht übermittelt und sie schließlich an den Browser ausgibt.



3. Die Anfangs- und Endphase von PHP
In der Anfangsphase gibt es zwei Prozesse:

Der erste Prozess: Apache startet den Prozess, d. h. erfolgt

bevor eine Anfrage eintrifft. Es handelt sich um die Anfangsphase (MINIT) des gesamten SAPI-Lebenszyklus (z. B. den gesamten Lebenszyklus nach dem Start von Apache oder den gesamten Ausführungsprozess des Befehlszeilenprogramms). Diese Phase wird nur einmal durchgeführt. Nach dem Start von Apache startet auch der PHP-Interpreter; PHP ruft die MINIT-Methode jeder Erweiterung (Modul) auf und versetzt diese Erweiterungen dadurch in einen verfügbaren Zustand. Sehen Sie sich an, welche Erweiterungen in der Datei php.ini geöffnet sind. MINIT bedeutet „Modulinitialisierung“. Jedes Modul definiert eine Reihe von Funktionen, Klassenbibliotheken usw. zur Bearbeitung anderer Anforderungen.

Das Modul kann in dieser Phase einige Initialisierungsarbeiten durchführen, z. B. das Registrieren von Konstanten, das Definieren der vom Modul verwendeten Klassen usw. Die typische Modulrückruffunktion MINIT-Methode lautet wie folgt:

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

Der zweite Prozess findet in der Anforderungsphase statt, wenn eine Seitenanforderung erfolgt . Der Initialisierungsprozess (RINIT-Anforderung beginnt) wird vor jeder Anforderung durchgeführt

Nachdem die Anfrage eintrifft, übergibt die SAPI-Schicht die Kontrolle an die PHP-Schicht, PHP-InitialisierungDiese AnfrageFühren Sie das Skript ausErforderliche Umgebungsvariablen , für Erstellen Sie beispielsweise eine Ausführungsumgebung, einschließlich einer Symboltabelle, die die Variablennamen und Variablenwertinhalte während der Ausführung von PHP speichert. Sowie die Symboltabelle aller aktuellen Funktionen, Klassen und anderen Informationen Es handelt sich beispielsweise um die RINIT des Session-Moduls. Wenn das Session-Modul in php.ini aktiviert ist, wird die Variable $_SESSION initialisiert Rufen Sie die RINIT-Funktion des Moduls auf und lesen Sie den relevanten Inhalt. Dann ruft PHP die RINIT-Funktion aller Module auf, was „Initialisierung anfordern“ bedeutet. Zu diesem Zeitpunkt kann jedes Modul auch einige verwandte Vorgänge ausführen. Die RINIT-Funktion des Moduls ähnelt der MINIT-Funktion. Die RINIT-Methode kann als Vorbereitungsprozess betrachtet werden, der automatisch zwischen Programmausführungen startet.

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

Die Endphase ist in zwei Teile unterteilt:

Anfrage abgeschlossen Wenn das Skript dann bis zum Ende ausgeführt wird oder die Funktion „exit()“ oder „die()“ aufgerufen wird, tritt es in die Endphase ein. Entsprechend der Startphase ist auch die Endphase unterteilt zwei Links, einer nach Ende der Anfrage (RSHUWDOWN), einer am Ende des SAPI-Lebenszyklus (MSHUTDOWN).

Erster Link: Endphase nachdem die Anfrage verarbeitet wurde: Nachdem die Anfrage verarbeitet wurde, tritt sie in die Endphase ein und PHP beginnt mit der Bereinigung Verfahren. Es ruft nacheinander die RSHUTDOWN-Methode jedes Moduls auf. RSHUTDOWN wird verwendet, um die Symboltabelle zu löschen, die während der Ausführung des Programms generiert wird, d. h. um die Unset-Funktion für jede Variable aufzurufen. Die typische RSHUTDOWN-Methode lautet wie folgt:

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

Zweiter Link: Endlich wurden alle Anfragen verarbeitet und SAPI ist bereit Zum Schließen ruft PHP die MSHUTDOWN-Methode jeder Erweiterung auf. Dies ist die letzte Chance für jedes Modul, Speicher freizugeben. (Dies istFür SAPI wie CGI und CLI gibt es keine „nächste Anfrage“, daher beginnt die SAPI sofort mit dem Schließen. )

Die typische RSHUTDOWN-Methode ist wie folgt:

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

Auf diese Weise ist der gesamte PHP-Lebenszyklus beendet. Es ist zu beachten, dass der „Startschritt eins“ und der „Abschlussschritt zwei“ nur dann ausgeführt werden, wenn keine Anfrage vom Server vorliegt.

SAPI führt PHP durch die folgenden Phasen aus:
1. Modulinitialisierungsphase (Modulinit) :
Das heißt, das Aufrufen jeder Erweiterung im Quellcode Methoden in PHP_MINIT_FUNCTION initialisieren das Modul, wenden einige vom Modul benötigte Variablen an, weisen Speicher zu usw.
2. Anforderungsinitphase (Anforderungsinit) ：
Das heißt, nach Erhalt der Clientanforderung wird die Methode in jeder erweiterten PHP_RINIT_FUNCTION aufgerufen, um die Ausführung zu initialisieren die PHP-Skriptumgebung.
3. PHP-Skript ausführen
4. Herunterfahren anfordern (Request Shutdown) ：
Wird dabei aufgerufen Zeit: Die PHP_RSHUTDOWN_FUNCTION-Methode jeder Erweiterung bereinigt die Anforderungsseite und ZE beginnt mit der Rückgewinnung von Variablen und Speicher.
5. Modul herunterfahren :
Wenn der Webserver beendet wird oder das Befehlszeilenskript ausgeführt und beendet wird, wird die Methode PHP_MSHUTDOWN_FUNCTION im Quellcode der Erweiterung aufgerufen

4. Einzelprozess-SAPI-Lebenszyklus

CLI/CGI-Modus PHP gehört zum Einzelprozess-SAPI-Modus. Diese Art von Anfrage wird nach einmaliger Bearbeitung der Anfrage geschlossen. Das heißt, es werden nur die folgenden Links durchlaufen: Start – Anforderung startet – Anforderung schließt – Ende Die SAPI-Schnittstellenimplementierung schließt ihren Lebenszyklus ab. Wie in der Abbildung gezeigt:

                                                                                                        Modul zur Verarbeitung von PHP-Anfragen. Apache übernimmt im Allgemeinen den Multiprozessmodus und gibt mehrere untergeordnete Prozesse aus. Jeder untergeordnete Prozess durchläuft die Start- und Endphase Phase jedes Prozesses< Das 🎜>-Segment wird erst ausgeführt, nachdem der Prozess abgebrochen wurde, und mehrere Anforderungen können während des gesamten Prozesslebenszyklus verarbeitet werden. Nur wenn Apache heruntergefahren oder verarbeitet wird

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

如图所示：

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更有优势：他能够使用那些没有处理好线程安全的第三方模块，并 且对于那些线程调试困难的平台而言，他也更容易调试一些。

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des PHP-Lebenszyklus am Ende von PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!