PHP verwaltet den globalen Status

                                                                                 

Globalen Zustand verwalten

In imperativen Sprachen ist immer etwas globaler Raum erforderlich. Bei der Programmierung von PHP oder Erweiterungen werden wir eine klare Unterscheidung zwischen sogenannten anforderungsgebundenen globalen Variablen und echten globalen Variablen treffen.

Anforderungsglobale Variablen sind globale Variablen, die während der Anforderungsverarbeitung Informationen transportieren und speichern müssen. Ein einfaches Beispiel ist, wenn Sie den Benutzer auffordern, einen Wert in einem Funktionsparameter anzugeben, und diesen in anderen Funktionen verwenden möchten. Abgesehen davon, dass diese Informationen über mehrere PHP-Funktionsaufrufe hinweg „ihren Wert behalten“, behalten sie nur den Wert für die aktuelle Anfrage. Die nächste Anfrage, die kommt, sollte nichts wissen. PHP bietet einen Mechanismus zum Verwalten globaler Anforderungsvariablen unabhängig vom gewählten Multiprocessing-Modell, auf den wir später in diesem Kapitel ausführlich eingehen werden.

Echte globale Variablen sind Informationen, die über alle Anfragen hinweg beibehalten werden. Diese Informationen sind normalerweise schreibgeschützt. Wenn Sie im Rahmen der Anforderungsbearbeitung in eine solche globale Variable schreiben müssen, kann PHP Ihnen nicht helfen. Wenn Sie Threads als Multiprocessing-Modell verwenden, müssen Sie die Speichersperre selbst implementieren. Wenn Sie Prozesse als Multiprocessing-Modell verwenden, müssen Sie Ihren eigenen IPC (Inter-Process-Communication) verwenden. Dies sollte jedoch bei der PHP-Erweiterungsprogrammierung nicht passieren.

Verwandte Lernempfehlungen: PHP-Programmierung vom Einstieg bis zur Kompetenz

Anfrage-Globalvariablen verwalten

Das Folgende ist eine Anfrage-Global Variable Einfaches Erweiterungsbeispiel:

/* 真正的 C 全局 */
static zend_long rnd = 0;

static void pib_rnd_init(void)
{
    /* 在 0 到 100 之间随机一个数字 */
    php_random_int(0, 100, &rnd, 0);
}

PHP_RINIT_FUNCTION(pib)
{
    pib_rnd_init();

    return SUCCESS;
}

PHP_FUNCTION(pib_guess)
{
    zend_long r;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &r) == FAILURE) {
        return;
    }

    if (r == rnd) {
        /* 将数字重置以进行猜测 */
        pib_rnd_init();
        RETURN_TRUE;
    }

    if (r < rnd) {
        RETURN_STRING("more");
    }

    RETURN_STRING("less");
}

PHP_FUNCTION(pib_reset)
{
    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    pib_rnd_init();
}

Wie Sie sehen können, wählt diese Erweiterung eine zufällige Ganzzahl am Anfang der Anfrage aus und versucht dann, das Array über pib_guess() zu erraten. Sobald die Zahl erraten wurde, wird sie zurückgesetzt. Wenn der Benutzer die Nummer manuell zurücksetzen möchte, kann er auch manuell pib_reset() aufrufen, um den Wert zurückzusetzen.
Die Zufallszahl wird als eine globale C-Variable implementiert. Wenn PHP prozessintern als Teil eines Multiprozessmodells verwendet wird, stellt die spätere Verwendung von Threads kein Problem mehr dar, dies ist ein Nein-Nein.

HINWEIS

Zur Erinnerung: Sie müssen nicht wissen, welches Multiprozessmodell Sie verwenden werden. Wenn Sie eine Erweiterung entwerfen, müssen Sie auf beide Modelle vorbereitet sein.

Bei der Verwendung von Threads wird eine globale C-Variable für jeden Thread im Server gemeinsam genutzt. In unserem Beispiel oben hat beispielsweise jeder gleichzeitige Benutzer des Netzwerkservers denselben Wert. Einige setzen den Wert möglicherweise zunächst zurück, während andere versuchen, ihn zu erraten. Kurz gesagt, Sie verstehen klar, worum es bei Threads geht.

Wir müssen die Daten auf derselben Anfrage beibehalten. Auch wenn die Ausführung des PHP-Multiprozessmodells Threads verwendet, müssen sie an die aktuelle Anfrage gebunden sein.

Verwenden Sie TSRM-Makros, um den globalen Speicherplatz zu schützen

PHP ist mit Ebenen ausgestattet, die Erweiterungs- und Kernel-Entwicklern bei der Bearbeitung globaler Anforderungen helfen. Diese Ebene heißt TSRM (Thread-Safe Resource Management) und wird als eine Reihe von Makros bereitgestellt, die Sie verwenden müssen, wann immer Sie auf die anforderungsgebundenen Globals zugreifen müssen (Lesen und Schreiben). Im Fall eines Multiprozessmodells, das Prozesse verwendet, werden diese Makros hinter den Kulissen in Code aufgelöst, der dem oben gezeigten ähnelt. Wie wir sehen können, ist der obige Code vollständig gültig, wenn kein Threading verwendet wird. Bei der Verwendung von Prozessen werden diese Makros also zu ähnlichen Makros erweitert.

Als Erstes müssen Sie eine Struktur deklarieren, die die Wurzel aller Ihrer globalen Variablen sein wird:

ZEND_BEGIN_MODULE_GLOBALS(pib)
    zend_long rnd;
ZEND_END_MODULE_GLOBALS(pib)

/* 解析为 :
*
* typedef struct _zend_pib_globals {
*    zend_long rnd;
* } zend_pib_globals;
*/

Dann erstellen Sie eine globale Variable wie diese:

ZEND_DECLARE_MODULE_GLOBALS(pib)

/* 解析为 zend_pib_globals pib_globals; */

Jetzt können Sie mithilfe globaler Makrozugriffsfunktionen auf die Daten zugreifen. Dieses Makro wird vom Framework erstellt und sollte in Ihrer Header-Datei

php_pib.h

definiert werden. Das sieht so aus:

#ifdef ZTS
#define PIB_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(pib, v)
#else
#define PIB_G(v) (pib_globals.v)
#endif

Wie Sie sehen können, wenn der ZTS-Modus nicht aktiviert ist, d sicher), löst das Makro einfach die in der Struktur deklarierten Daten auf. Daher gibt es die folgenden Änderungen:

static void pib_rnd_init(void)
{
    php_random_int(0, 100, &PIB_G(rnd), 0);
}

PHP_FUNCTION(pib_guess)
{
    zend_long r;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &r) == FAILURE) {
        return;
    }

    if (r == PIB_G(rnd)) {
        pib_rnd_init();
        RETURN_TRUE;
    }

    if (r < PIB_G(rnd)) {
        RETURN_STRING("more");
    }

    RETURN_STRING("less");
}

Beachten Sie, dass

bei Verwendung eines Prozessmodells das

TSRM

-Makro in einen Zugriff auf eine globale C-Variable aufgelöst wird .

Bei der Verwendung von Threads, also beim Kompilieren von ZTS PHP, wird es komplizierter. Dann werden alle Makros, die wir sehen, zu etwas völlig anderem aufgelöst, was hier schwer zu erklären ist. Wenn TSRM

mit ZTS kompiliert wird, leistet es im Grunde genommen mit TLS (Thread Local Storage) harte Arbeit.

Hinweis

Kurz gesagt, beim Kompilieren in ZTS sind globale Variablen an den aktuellen Thread gebunden. Beim Kompilieren mit NTS werden globale Variablen an den aktuellen Prozess gebunden. Das TSRM-Makro übernimmt die harte Arbeit. Vielleicht interessiert Sie, wie das funktioniert, und durchsuchen Sie das /TSRM-Verzeichnis des PHP-Quellcodes, um mehr über die PHP-Thread-Sicherheit zu erfahren.

在扩展中使用全局钩子

有时，可能需要将全局变量初始化为一些默认值，通常为零。引擎帮助下的TSRM系统提供了一个钩子来为您的全局变量提供默认值，我们称之为GINIT。

注意

关于 PHP 挂钩的完整信息，请参考 PHP 生命周期章节。

让我们将随机值设为零：

PHP_GSHUTDOWN_FUNCTION(pib)
{ }

PHP_GINIT_FUNCTION(pib)
{
    pib_globals->rnd = 0;
}

zend_module_entry pib_module_entry = {
    STANDARD_MODULE_HEADER,
    "pib",
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    "0.1",
    PHP_MODULE_GLOBALS(pib),
    PHP_GINIT(pib),
    PHP_GSHUTDOWN(pib),
    NULL, /* PRSHUTDOWN() */
    STANDARD_MODULE_PROPERTIES_EX
};

我们选择仅显示 zend_module_entry（和其他 NULL）的相关部分。如你所见，全局管理挂钩发生在结构的中间。首先是PHP_MODULE_GLOBALS()来确定全局变量的大小，然后是我们的 GINIT和 GSHUTDOWN钩子。然后我们使用了STANDARD_MODULE_PROPERTIES_EX关闭结构，而不是STANDARD_MODULE_PROPERTIES。只需以正确的方式完成结构即可，请参阅？：

#define STANDARD_MODULE_PROPERTIES
    NO_MODULE_GLOBALS, NULL, STANDARD_MODULE_PROPERTIES_EX

在GINIT 函数中，你传递了一个指向全局变量当前存储位置的指针。你可以使用它来初始化全局变量。在这里，我们将零放入随机值（虽然不是很有用，但我们接受它）。

警告

不要在 GINIT 中使用PIB_G()宏。使用你得到的指针。

注意

对于当前进程，在MINIT()之前启动了GINIT()。如果是 NTS，就这样而已。 如果是 ZTS，线程库产生的每个新线程都会额外调用GINIT（）。

警告

GINIT()不作为RINIT()的一部分被调用。如果你需要在每次新请求时清除全局变量，则需要像在本章所示示例中所做的那样手动进行。

完整的例子

这是一个更高级的完整示例。如果玩家获胜，则将其得分（尝试次数）添加到可以从用户区获取的得分数组中。没什么难的，得分数组在请求启动时初始化，然后在玩家获胜时使用，并在当前请求结束时清除：

ZEND_BEGIN_MODULE_GLOBALS(pib)
    zend_long rnd;
    zend_ulong cur_score;
    zval scores;
ZEND_END_MODULE_GLOBALS(pib)

ZEND_DECLARE_MODULE_GLOBALS(pib)

static void pib_rnd_init(void)
{
    /* 重置当前分数 */
    PIB_G(cur_score) = 0;
    php_random_int(0, 100, &PIB_G(rnd), 0);
}

PHP_GINIT_FUNCTION(pib)
{
    /* ZEND_SECURE_ZERO 是 memset(0)。也可以解析为 bzero() */
    ZEND_SECURE_ZERO(pib_globals, sizeof(*pib_globals));
}

ZEND_BEGIN_ARG_INFO_EX(arginfo_guess, 0, 0, 1)
    ZEND_ARG_INFO(0, num)
ZEND_END_ARG_INFO()

PHP_RINIT_FUNCTION(pib)
{
    array_init(&PIB_G(scores));
    pib_rnd_init();

    return SUCCESS;
}

PHP_RSHUTDOWN_FUNCTION(pib)
{
    zval_dtor(&PIB_G(scores));

    return SUCCESS;
}

PHP_FUNCTION(pib_guess)
{
    zend_long r;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &r) == FAILURE) {
        return;
    }

    if (r == PIB_G(rnd)) {
        add_next_index_long(&PIB_G(scores), PIB_G(cur_score));
        pib_rnd_init();
        RETURN_TRUE;
    }

    PIB_G(cur_score)++;

    if (r < PIB_G(rnd)) {
        RETURN_STRING("more");
    }

    RETURN_STRING("less");
}

PHP_FUNCTION(pib_get_scores)
{
    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    RETVAL_ZVAL(&PIB_G(scores), 1, 0);
}

PHP_FUNCTION(pib_reset)
{
    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    pib_rnd_init();
}

static const zend_function_entry func[] = {
    PHP_FE(pib_reset, NULL)
    PHP_FE(pib_get_scores, NULL)
    PHP_FE(pib_guess, arginfo_guess)
    PHP_FE_END
};

zend_module_entry pib_module_entry = {
    STANDARD_MODULE_HEADER,
    "pib",
    func, /* 函数入口 */
    NULL, /* 模块初始化 */
    NULL, /* 模块关闭 */
    PHP_RINIT(pib), /* 请求初始化 */
    PHP_RSHUTDOWN(pib), /* 请求关闭 */
    NULL, /* 模块信息 */
    "0.1", /* 替换为扩展的版本号 */
    PHP_MODULE_GLOBALS(pib),
    PHP_GINIT(pib),
    NULL,
    NULL,
    STANDARD_MODULE_PROPERTIES_EX
};

这里必须要注意的是，如果你希望在请求之间保持分数，PHP 不提供任何便利。而是需要一个持久的共享存储，例如文件，数据库，某些内存区域等。PHP 的设计目的不是将信息持久存储在其内部的请求，因此它不提供这么做，但它提供了实用程序来访问请求绑定的全局空间，如我们所示。

然后，很容易地在RINIT()中初始化一个数组，然后在RSHUTDOWN()中销毁它。请记住，array_init创建一个zend_array 并放入一个 zval。但这是免分配的，不要担心分配用户无法使用的数组（因此浪费分配），array_init()非常廉价 (阅读源代码)。

当我们将这样的数组返回给用户时，我们不会忘记增加其引用计数（在 RETVAL_ZVAL中），因为我们在扩展中保留了对此类数组的引用。

使用真实的全局变量

真实全局变量是非线程保护的真实C全局变量。有时可能会需要它们。但是请记住主要规则：在处理请求时，不能安全地写入此类全局变量。因此，通常在 PHP 中，我们需要此类变量并将其用作只读变量。

请记住，在 PHP 生命周期的MINIT()或MSHUTDOWN()步骤中编写真实全局变量是绝对安全的。但是不能在处理请求时给他们写入值（但可以从他们那里读取）。

因此，一个简单的示例是你想要读取环境值以对其进行处理。此外，初始化持久性的 zend_string并在之后处理某些请求时加以利用是很常见的。

这是介绍真实全局变量的修补示例，我们仅显示与先前代码的差异，而不显示完整代码：

static zend_string *more, *less;
static zend_ulong max = 100;

static void register_persistent_string(char *str, zend_string **result)
{
    *result = zend_string_init(str, strlen(str), 1);
    zend_string_hash_val(*result);

    GC_FLAGS(*result) |= IS_INTERNED;
}

static void pib_rnd_init(void)
{
    /* 重置当前分数 */
    PIB_G(cur_score) = 0;
    php_random_int(0, max, &PIB_G(rnd), 0);
}

PHP_MINIT_FUNCTION(pib)
{
    char *pib_max;

    register_persistent_string("more", &more);
    register_persistent_string("less", &less);

    if (pib_max = getenv("PIB_RAND_MAX")) {
        if (!strchr(pib_max, '-')) {
            max = ZEND_STRTOUL(pib_max, NULL, 10);
        }
    }

    return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(pib)
{
    zend_string_release(more);
    zend_string_release(less);

    return SUCCESS;
}

PHP_FUNCTION(pib_guess)
{
    zend_long r;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &r) == FAILURE) {
        return;
    }

    if (r == PIB_G(rnd)) {
        add_next_index_long(&PIB_G(scores), PIB_G(cur_score));
        pib_rnd_init();
        RETURN_TRUE;
    }

    PIB_G(cur_score)++;

    if (r < PIB_G(rnd)) {
        RETURN_STR(more);
    }

    RETURN_STR(less);
}

在这里我们创建了两个 zend_string 变量 more 和 less。这些字符串不需要像以前一样在使用时立即创建和销毁。这些是不可变的字符串，只要保持不变，就可以分配一次并在需要的任何时间重复使用（即只读）。我们在zend_string_init()中使用持久分配，在MINIT()中初始化这两个字符串，我们现在预先计算其哈希值（而不是先执行第一个请求），并且我们告诉 zval 垃圾收集器，这些字符串已被扣留，因此它将永远不会尝试销毁它们（但是，如果将它们用作写操作（例如连接）的一部分，则可能需要复制它们）。显然我们不会忘记在MSHUTDOWN()中销毁这些字符串。

Dann untersuchen wir in MINIT() eine PIB_RAND_MAX Umgebung und verwenden diese als maximalen Bereichswert für die Zufallszahlenauswahl. Da wir vorzeichenlose Ganzzahlen verwenden und wissen, dass sich strtoull() nicht über negative Zahlen beschwert (wodurch der Ganzzahlbereich als Zeichenkonflikt umschlossen wird), vermeiden wir einfach die Verwendung negativer Zahlen (klassische libc-Problemumgehung).

Das obige ist der detaillierte Inhalt vonPHP verwaltet den globalen Status. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!