Der zugrunde liegende Betriebsmechanismus und die Prinzipien von PHP

PHP gilt als einfach, aber es ist nicht leicht, es zu beherrschen. Wir müssen nicht nur in der Lage sein, es zu verwenden, sondern auch sein zugrunde liegendes Funktionsprinzip kennen.

PHP ist eine dynamische Sprache, die für die Webentwicklung geeignet ist. Genauer gesagt handelt es sich um ein Software-Framework, das die Sprache C verwendet, um eine große Anzahl von Komponenten zu implementieren. Im engeren Sinne kann es als leistungsstarkes UI-Framework betrachtet werden.

Was ist der Zweck, die zugrunde liegende Implementierung von PHP zu verstehen? Um dynamische Sprache gut nutzen zu können, müssen wir zunächst verstehen, dass Speicherverwaltungs- und Framework-Modelle unserer Referenz würdig sind. Durch erweiterte Entwicklung können wir leistungsfähigere Funktionen erreichen und die Leistung unserer Programme optimieren.

1. Designkonzept und Eigenschaften von PHP

Multiprozessmodell: Da PHP ein Multiprozessmodell ist, stören sich verschiedene Anfragen nicht gegenseitig, was sicherstellt, dass eine Anfrage fehlschlägt , der gesamte Dienst wird davon natürlich nicht betroffen sein, mit der Entwicklung der Zeit hat PHP bereits das Multithreading-Modell unterstützt.

Schwach typisierte Sprache: Im Gegensatz zu C/C, Java, C# und anderen Sprachen ist PHP eine schwach typisierte Sprache. Der Typ einer Variablen wird nicht zu Beginn bestimmt und es kann zu einer impliziten oder expliziten Typkonvertierung kommen. Die Flexibilität dieses Mechanismus ist in der Webentwicklung sehr praktisch sind detailliert in.

Der Engine (Zend)-Komponentenmodus (ext) reduziert die interne Kopplung.

Die mittlere Schicht (Sapi) isoliert den Webserver und PHP.

Die Syntax ist einfach und flexibel, ohne zu viele Spezifikationen. Mängel führen zu gemischten Stilen, aber egal wie schlecht ein Programmierer ist, er wird kein Programm schreiben, das zu unverschämt ist und die Gesamtsituation gefährdet.

2. Das vierschichtige System von PHP

Die Kernarchitektur von PHP ist wie folgt:

Wie möglich Auf dem Bild ist PHP von unten nach oben ein 4-Schichten-System:

Zend-Engine: Zend ist vollständig in reinem C implementiert und ist der Kernbestandteil von PHP. Es übersetzt PHP-Code (lexikalisch, Syntaxanalyse). und andere Kompilierungsprozesse) Es verarbeitet ausführbare Opcodes und implementiert entsprechende Verarbeitungsmethoden, implementiert grundlegende Datenstrukturen (wie Hashtable, oo), Speicherzuweisung und -verwaltung und stellt entsprechende API-Methoden für externe Aufrufe bereit. Es ist der Kern von allem und allen Peripheriegeräten Alle Funktionen rund um Zend implementiert.

Erweiterungen: Erweiterungen basieren auf der Zend-Engine und bieten verschiedene grundlegende Dienste auf Komponentenbasis. Unsere gemeinsamen verschiedenen integrierten Funktionen (z. B. Array-Serien), Standardbibliotheken usw. werden alle durch Erweiterungen implementiert . Benutzer können bei Bedarf auch eigene Erweiterungen implementieren, um Funktionserweiterungen, Leistungsoptimierungen und andere Zwecke zu erreichen (z. B. sind die PHP-Mittelschicht und die Rich-Text-Analyse, die derzeit von Tieba verwendet werden, typische Erweiterungsanwendungen).

Sapi: Der vollständige Name von Sapi ist Server Application Programming Interface. Dabei handelt es sich um die Server-Anwendungsprogrammierschnittstelle, die es PHP ermöglicht, über eine Reihe von Hook-Funktionen mit Peripheriedaten zu interagieren Durch Sapi wird PHP selbst erfolgreich von Anwendungen der oberen Ebene entkoppelt und isoliert. PHP kann nicht mehr berücksichtigen, wie es mit verschiedenen Anwendungen kompatibel ist, und die Anwendung selbst kann auch unterschiedliche Verarbeitungsmethoden entsprechend ihren eigenen Eigenschaften implementieren.

Anwendung der oberen Ebene: Dies ist das PHP-Programm, das wir normalerweise schreiben. Wir erhalten verschiedene Anwendungsmodi über verschiedene Sapi-Methoden, z. B. die Implementierung von Webanwendungen über einen Webserver, deren Ausführung im Skriptmodus auf der Befehlszeile usw.

Wenn PHP ein Auto ist, dann ist der Rahmen des Autos PHP selbst, Zend ist der Motor (Motor) des Autos und die verschiedenen Komponenten unter Ext sind die Räder des Autos B. eine Straße, und das Auto kann auf verschiedenen Arten von Straßen fahren, und die Ausführung eines PHP-Programms bedeutet, dass das Auto auf der Straße fährt. Wir brauchen also: einen guten Motor, die richtigen Räder, die richtige Spur.

3. Sapi

Wie oben erwähnt, ermöglicht Sapi externen Anwendungen den Austausch von Daten mit PHP über eine Reihe von Schnittstellen und die Implementierung spezifischer Verarbeitungsmethoden entsprechend unterschiedlicher Anwendungsmerkmale Sapis sind:

Apache2handler: Dies ist die Verarbeitungsmethode, wenn Apache als Webserver verwendet und im mod_PHP-Modus ausgeführt wird. Sie ist derzeit auch die am weitesten verbreitete.

cgi: Dies ist eine weitere direkte Interaktionsmethode zwischen Webserver und PHP, das berühmte Fastcgi-Protokoll. In den letzten Jahren wurde fastcgi PHP immer häufiger verwendet und ist auch die einzige Methode, die von asynchronen Webservern unterstützt wird .

cli: Anwendungsmodus für Befehlszeilenaufrufe

4. PHP-Ausführungsprozess &opcode

Werfen wir zunächst einen Blick auf den Prozess der Ausführung von PHP-Code.

Wie Sie auf dem Bild sehen können, implementiert PHP einen typischen dynamischen Sprachausführungsprozess: Nachdem ein Code erhalten wurde, durchläuft er eine lexikalische Analyse , Grammatik Nach dem Parsen und anderen Phasen wird das Quellprogramm in Anweisungen (Opcodes) übersetzt, und dann führt die virtuelle ZEND-Maschine diese Anweisungen nacheinander aus, um den Vorgang abzuschließen. PHP selbst ist in C implementiert, daher sind die letztendlich aufgerufenen Funktionen alle C-Funktionen. Tatsächlich können wir PHP als eine in C entwickelte Software betrachten.

Der Kern der PHP-Ausführung sind die übersetzten Anweisungen, bei denen es sich um Opcodes handelt.

Opcode ist die grundlegendste Einheit der PHP-Programmausführung. Ein Opcode besteht aus zwei Parametern (op1, op2), einem Rückgabewert und einer Verarbeitungsfunktion. Das PHP-Programm wird letztendlich in die sequentielle Ausführung einer Reihe von Opcode-Verarbeitungsfunktionen übersetzt.

Mehrere gängige Verarbeitungsfunktionen:

ZEND_ASSIGN_SPEC_CV_CV_HANDLER : 变量分配 （$a=$b）
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER：函数调用
ZEND_CONCAT_SPEC_CV_CV_HANDLER：字符串拼接 $a.$b
ZEND_ADD_SPEC_CV_CONST_HANDLER: 加法运算 $a+2
ZEND_IS_EQUAL_SPEC_CV_CONST：判断相等 $a==1
ZEND_IS_IDENTICAL_SPEC_CV_CONST：判断相等 $a===1

5. HashTable – Kerndatenstruktur

HashTable ist die Kerndatenstruktur von Zend und wird fast immer für die Implementierung verwendet PHP Für alle gängigen Funktionen ist das uns bekannte PHP-Array die typische Anwendung. Darüber hinaus werden innerhalb von Zend auch Funktionssymboltabellen, globale Variablen usw. basierend auf Hash-Tabellen implementiert.

Die Hash-Tabelle von PHP weist die folgenden Eigenschaften auf:

Unterstützt typische Schlüssel->Wert-Abfragen

Kann als Array verwendet werden

Knoten können hinzugefügt und gelöscht werden O (1) Komplexität

Schlüssel unterstützt gemischte Typen: Es gibt gleichzeitig assoziative Zahlenkombinationsindex-Arrays

Wert unterstützt gemischte Typen: Array ("string",2332)

unterstützt lineare Durchquerung: Zum Beispiel foreach

Zend-Hash-Tabelle implementiert eine typische Hash-Tabellen-Hash-Struktur und bietet gleichzeitig die Funktion der Vorwärts- und Rückwärtsdurchquerung des Arrays durch Anhängen einer doppelt verknüpften Liste. Seine Struktur ist wie folgt:

Wie Sie sehen können, gibt es beide Hash-Strukturen in Form von Schlüssel->Werten und doppelt verknüpften Listen Modus in der Hash-Tabelle, was die Unterstützung der schnellen Suche und des linearen Durchlaufs sehr erleichtert.

Hash-Struktur: Die Hash-Struktur von Zend ist ein typisches Hash-Tabellenmodell, das eine verknüpfte Liste verwendet, um Konflikte zu lösen. Es ist zu beachten, dass die Hash-Tabelle von Zend eine selbstwachsende Datenstruktur ist. Wenn die Hash-Tabelle voll ist, wird sie dynamisch um das Zweifache erweitert und Elemente neu positioniert. Die Anfangsgröße beträgt 8. Darüber hinaus hat Zend selbst bei der Durchführung der schnellen Schlüssel->Wertsuche einige Optimierungen vorgenommen, um den Prozess durch den Austausch von Raum gegen Zeit zu beschleunigen. Beispielsweise wird in jedem Element eine Variable nKeyLength verwendet, um die Länge des Schlüssels zur schnellen Bestimmung zu identifizieren.

Doppelt verknüpfte Liste: Die Zend-Hash-Tabelle implementiert die lineare Durchquerung von Elementen durch eine verknüpfte Listenstruktur. Theoretisch reicht es aus, eine einseitig verknüpfte Liste zum Durchlaufen zu verwenden. Der Hauptzweck der Verwendung einer doppelt verknüpften Liste besteht darin, das Durchlaufen schnell zu löschen und zu vermeiden. Die Zend-Hash-Tabelle ist eine zusammengesetzte Struktur, die gängige assoziative Arrays unterstützt und auch als sequentielle Indexnummern verwendet werden kann und sogar eine Mischung aus beiden ermöglicht.

PHP-Assoziatives Array: Assoziatives Array ist eine typische hash_table-Anwendung. Ein Abfrageprozess durchläuft die folgenden Schritte (wie aus dem Code ersichtlich ist, handelt es sich hierbei um einen üblichen Hash-Abfrageprozess und es werden einige schnelle Beurteilungen hinzugefügt, um die Suche zu beschleunigen.):

getKeyHashValue h;
index = n & nTableMask;
Bucket *p = arBucket[index];
while (p) {
if ((p->h == h) & (p->nKeyLength == nKeyLength)) {
RETURN p->data;
}
p=p->next;
}

PHP-Index-Array : Das Index-Array ist das, was wir üblicherweise als Array of sehen, auf das über einen Index zugegriffen wird. Beispiel: $arr[0], Zend HashTable wird intern normalisiert und der Hash-Wert und nKeyLength (0) werden auch dem Indextypschlüssel zugewiesen. Die interne Mitgliedsvariable nNextFreeElement ist die aktuell zugewiesene maximale ID, die nach jedem Push automatisch um eins erhöht wird. Es ist dieser Normalisierungsprozess, der es PHP ermöglicht, eine Mischung aus assoziativen und nicht-assoziativen Daten zu erreichen. Aufgrund der Besonderheit des Push-Vorgangs wird die Reihenfolge der Indexschlüssel im PHP-Array nicht durch die Größe des Index bestimmt, sondern durch die Reihenfolge des Pushs. Zum Beispiel: $arr[1] = 2; $arr[2] = 3; für Schlüssel vom Typ Double behandelt Zend HashTable sie als Indexschlüssel

PHP Eine schwach typisierte Sprache unterscheidet die Variablentypen nicht streng. PHP muss beim Deklarieren von Variablen den Typ nicht angeben. PHP kann während der Programmausführung implizite Konvertierungen von Variablentypen durchführen. Wie bei anderen stark typisierten Sprachen kann auch eine explizite Typkonvertierung im Programm durchgeführt werden. PHP-Variablen können in einfache Typen (int, string, bool), Sammlungstypen (Array-Ressourcenobjekt) und Konstanten (const) unterteilt werden. Alle oben genannten Variablen haben unter der Haube die gleiche zval-Struktur.

Zval ist eine weitere sehr wichtige Datenstruktur in Zend, die zur Identifizierung und Implementierung von PHP-Variablen verwendet wird:

Zval besteht hauptsächlich aus drei Teilen:

Typ: Gibt den Typ der Variablen an (Ganzzahl, Zeichenfolge, Array usw.)

refcount&is_ref: Wird zur Implementierung der Referenzzählung verwendet (ausführliche Einführung). später) )

Wert: Der Kernteil, der die tatsächlichen Daten der Variablen speichert

Zvalue wird zum Speichern der tatsächlichen Daten einer Variablen verwendet. Da mehrere Typen gespeichert werden müssen, ist zvalue eine Union und implementiert somit eine schwache Typisierung.

Die entsprechende Beziehung zwischen PHP-Variablentypen und ihrem tatsächlichen Speicher ist wie folgt:

Referenzzählung wird häufig beim Speicherrecycling, bei String-Operationen usw. verwendet. Variablen in PHP sind eine typische Anwendung der Referenzzählung. Die Referenzzählung von Zval wird über die Mitgliedsvariablen is_ref und ref_count implementiert. Durch die Referenzzählung können mehrere Variablen dieselben Daten teilen. Vermeiden Sie den hohen Verbrauch, der durch häufiges Kopieren entsteht.

IS_LONG -> lvalue
IS_DOUBLE -> dvalue
IS_ARRAY -> ht
IS_STRING -> str
IS_RESOURCE -> lvalue

Beim Ausführen einer Zuweisungsoperation zeigt Zend die Variable auf denselben zval und ref_count. Während der nicht gesetzten Operation den entsprechenden ref_count-1. Der Zerstörungsvorgang wird nur ausgeführt, wenn ref_count auf 0 reduziert wird. Wenn es sich um eine Referenzzuweisung handelt, ändert Zend is_ref auf 1.

PHP变量通过引用计数实现变量共享数据，那如果改变其中一个变量值呢？当试图写入一个变量时，Zend若发现该变量指向的zval被多个变量共享，则为其复制一份ref_count为1的zval，并递减原zval的refcount，这个过程称为“zval分离”。可见，只有在有写操作发生时zend才进行拷贝操作，因此也叫copy-on-write(写时拷贝)

对于引用型变量，其要求和非引用型相反，引用赋值的变量间必须是捆绑的，修改一个变量就修改了所有捆绑变量。

整数、浮点数是PHP中的基础类型之一，也是一个简单型变量。对于整数和浮点数，在zvalue中直接存储对应的值。其类型分别是long和double。

从zvalue结构中可以看出，对于整数类型，和c等强类型语言不同，PHP是不区分int、unsigned int、long、long long等类型的，对它来说，整数只有一种类型也就是long。由此，可以看出，在PHP里面，整数的取值范围是由编译器位数来决定而不是固定不变的。

对于浮点数，类似整数，它也不区分float和double而是统一只有double一种类型。

在PHP中，如果整数范围越界了怎么办？这种情况下会自动转换为double类型，这个一定要小心，很多trick都是由此产生。

和整数一样，字符变量也是PHP中的基础类型和简单型变量。通过zvalue结构可以看出，在PHP中，字符串是由由指向实际数据的指针和长度结构体组成，这点和c++中的string比较类似。由于通过一个实际变量表示长度，和c不同，它的字符串可以是2进制数据（包含），同时在PHP中，求字符串长度strlen是O(1)操作。

在新增、修改、追加字符串操作时，PHP都会重新分配内存生成新的字符串。最后，出于安全考虑，PHP在生成一个字符串时末尾仍然会添加

常见的字符串拼接方式及速度比较：

假设有如下4个变量：$strA=‘123’; $strB = ‘456’; $intA=123; intB=456;

现在对如下的几种字符串拼接方式做一个比较和说明：

$res = $strA.$strB和$res = “$strA$strB”
这种情况下，zend会重新malloc一块内存并进行相应处理，其速度一般
$strA = $strA.$strB
这种是速度最快的，zend会在当前strA基础上直接relloc，避免重复拷贝
$res = $intA.$intB
这种速度较慢，因为需要做隐式的格式转换，实际编写程序中也应该注意尽量避免
$strA = sprintf (“%s%s”,$strA.$strB);

这会是最慢的一种方式，因为sprintf在PHP中并不是一个语言结构，本身对于格式识别和处理就需要耗费比较多时间，另外本身机制也是malloc。不过sprintf的方式最具可读性，实际中可以根据具体情况灵活选择。

PHP的数组通过Zend HashTable来天然实现。

foreach操作如何实现？对一个数组的foreach就是通过遍历hashtable中的双向链表完成。对于索引数组，通过foreach遍历效率比for高很多，省去了key->value的查找。count操作直接调用HashTable->NumOfElements，O(1)操作。对于’123’这样的字符串，zend会转换为其整数形式。$arr[‘123’]和$arr[123]是等价的

资源类型变量是PHP中最复杂的一种变量，也是一种复合型结构。

PHP的zval可以表示广泛的数据类型，但是对于自定义的数据类型却很难充分描述。由于没有有效的方式描绘这些复合结构，因此也没有办法对它们使用传统的操作符。要解决这个问题，只需要通过一个本质上任意的标识符（label）引用指针，这种方式被称为资源。

在zval中，对于resource，lval作为指针来使用，直接指向资源所在的地址。Resource可以是任意的复合结构，我们熟悉的mysqli、fsock、memcached等都是资源。

如何使用资源：

注册：对于一个自定义的数据类型，要想将它作为资源。首先需要进行注册，zend会为它分配全局唯一标示。

获取一个资源变量：对于资源，zend维护了一个id->实际数据的hash_tale。对于一个resource，在zval中只记录了它的id。fetch的时候通过id在hash_table中找到具体的值返回。

资源销毁：资源的数据类型是多种多样的。Zend本身没有办法销毁它。因此需要用户在注册资源的时候提供销毁函数。当unset资源时，zend调用相应的函数完成析构。同时从全局资源表中删除它。

资源可以长期驻留，不只是在所有引用它的变量超出作用域之后，甚至是在一个请求结束了并且新的请求产生之后。这些资源称为持久资源，因为它们贯通SAPI的整个生命周期持续存在，除非特意销毁。很多情况下，持久化资源可以在一定程度上提高性能。比如我们常见的mysql_pconnect ,持久化资源通过pemalloc分配内存，这样在请求结束的时候不会释放。

对zend来说，对两者本身并不区分。

Wie werden lokale Variablen und globale Variablen in PHP implementiert? Bei einer Anfrage kann PHP jederzeit zwei Symboltabellen (symbol_table und active_symbol_table) sehen, wobei erstere zur Verwaltung globaler Variablen verwendet wird. Letzteres ist ein Zeiger, der auf die aktuell aktive Variablensymboltabelle zeigt. Wenn das Programm eine Funktion aufruft, weist zend ihr eine Symboltabelle x zu und zeigt active_symbol_table auf a. Auf diese Weise wird die Unterscheidung zwischen globalen und lokalen Variablen erreicht.

Variablenwerte abrufen: Die PHP-Symboltabelle wird über hash_table implementiert. Beim Abrufen wird der entsprechende zval entsprechend der Kennung ermittelt und zurückgegeben.

Globale Variablen in Funktionen verwenden: In Funktionen können wir globale Variablen verwenden, indem wir sie explizit als global deklarieren. Erstellen Sie einen Verweis auf die Variable mit demselben Namen in symbol_table in active_symbol_table. Wenn in symbol_table keine Variable mit demselben Namen vorhanden ist, wird diese zuerst erstellt.