PHP gère le statut global

                                                                                   

Gérer l'état mondial

Nécessite toujours un espace global dans les langues impératives. Lors de la programmation de PHP ou d'extensions, nous ferons une distinction claire entre ce que nous appelons les variables globales liées aux requêtes et les vraies variables globales.

Les variables globales de requête sont des variables globales qui doivent transporter et mémoriser des informations pendant le traitement de la requête. Un exemple simple est lorsque vous demandez à l’utilisateur de fournir une valeur dans un paramètre de fonction et que vous souhaitez pouvoir l’utiliser dans d’autres fonctions. Sauf que cette information "conserve sa valeur" sur plusieurs appels de fonction PHP, elle ne conserve que la valeur de la requête en cours. La prochaine demande qui arrivera ne devrait rien savoir. PHP fournit un mécanisme pour gérer les variables globales des requêtes quel que soit le modèle de multitraitement choisi, que nous aborderons en détail plus loin dans ce chapitre.

Les vraies variables globales sont des éléments d'information qui sont conservés à travers les requêtes. Ces informations sont généralement en lecture seule. Si vous devez écrire dans une telle variable globale dans le cadre du traitement des requêtes, PHP ne peut pas vous aider. Si vous utilisez des threads comme modèle de multitraitement, vous devez implémenter vous-même le verrouillage de la mémoire. Si vous utilisez des processus comme modèle multitraitement, vous devez utiliser votre propre IPC (communication inter-processus). Cependant, cela ne devrait pas se produire dans la programmation d'extensions PHP.

Recommandations d'apprentissage associées : Programmation PHP de l'entrée à la maîtrise

Gérer les variables globales de la requête

Ce qui suit est une requête globale variable Exemple d'extension simple :

/* 真正的 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();
}

Comme vous pouvez le voir, cette extension sélectionne un entier aléatoire au début de la requête, puis essaie de deviner le tableau via pib_guess(). Une fois deviné, le numéro sera réinitialisé. Si l'utilisateur souhaite réinitialiser manuellement le numéro, il peut également appeler manuellement pib_reset() pour réinitialiser la valeur.
Le nombre aléatoire est implémenté comme une variable globale C. Si PHP est utilisé dans le processus dans le cadre d'un modèle multi-processus, ce n'est plus un problème si les threads sont utilisés plus tard, c'est un non-non.

REMARQUE

Pour rappel, vous n'avez pas besoin de savoir quel modèle multi-processus vous allez utiliser. Lorsque vous concevez une extension, vous devez vous préparer aux deux modèles.

Lors de l'utilisation de threads, une variable globale C est partagée pour chaque thread du serveur. Par exemple, dans notre exemple ci-dessus, chaque utilisateur simultané du serveur réseau partagera la même valeur. Certains peuvent réinitialiser la valeur au départ, tandis que d'autres tentent de la deviner. Bref, vous comprenez bien l’enjeu clé des threads.

Nous devons conserver les données dans la même requête, même si l'exécution du modèle multi-processus PHP utilise des threads, il doit être lié à la requête actuelle.

Utilisez les macros TSRM pour protéger l'espace global

PHP est conçu avec des couches qui aident les développeurs d'extensions et de noyau à gérer les requêtes globales. Cette couche est appelée TSRM (Thread-Safe Resource Management) et est exposée sous la forme d'un ensemble de macros que vous devez utiliser chaque fois que vous avez besoin d'accéder aux globales liées aux requêtes (lecture et écriture). Dans le cas d'un modèle multi-processus utilisant des processus, en coulisses, ces macros se résoudront en un code similaire à celui que nous avons montré ci-dessus. Comme nous pouvons le voir, le code ci-dessus est tout à fait valide si le threading n'est pas utilisé. Ainsi, lors de l’utilisation de processus, ces macros seront étendues à des macros similaires.

La première chose que vous devez faire est de déclarer une structure qui sera la racine de toutes vos variables globales :

ZEND_BEGIN_MODULE_GLOBALS(pib)
    zend_long rnd;
ZEND_END_MODULE_GLOBALS(pib)

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

Ensuite, créez une variable globale comme celle-ci :

ZEND_DECLARE_MODULE_GLOBALS(pib)

/* 解析为 zend_pib_globals pib_globals; */

Désormais, vous pouvez accéder aux données à l'aide d'accesseurs de macro globaux. Cette macro est créée par le framework et doit être définie dans votre fichier d'en-tête

php_pib.h

. Cela ressemble à ceci :

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

Comme vous pouvez le voir, si le mode ZTS n'est pas activé, c'est à dire la compilation de PHP et d'extensions non thread-safe (nous l'appelons mode

NTS

 : non-thread safe), la macro résout simplement les données déclarées dans la structure. Par conséquent, il y a les changements suivants :

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");
}

Notez que

lors de l'utilisation d'un modèle de processus, la macro

TSRM

se résout en un accès à une variable globale C .

Lorsque vous utilisez des threads, c'est-à-dire lorsque vous compilez ZTS PHP, les choses deviennent plus compliquées. Ensuite, toutes les macros que nous voyons aboutissent à quelque chose de complètement différent, ce qui est difficile à expliquer ici. Fondamentalement, lorsqu'il est compilé avec ZTS,

TSRM

fait un travail difficile en utilisant TLS (Thread Local Storage).

Remarque

En bref, lors de la compilation en ZTS, les variables globales sont liées au thread actuel. Lors de la compilation de NTS, les variables globales seront liées au processus en cours. La macro TSRM gère le travail acharné. Vous pourriez être intéressé par la façon dont cela fonctionne et parcourez le répertoire /TSRM du code source PHP pour en savoir plus sur la sécurité des threads PHP.

在扩展中使用全局钩子

有时，可能需要将全局变量初始化为一些默认值，通常为零。引擎帮助下的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()中销毁这些字符串。

Ensuite, dans MINIT(), nous sondons un environnement PIB_RAND_MAX et l'utilisons comme valeur de plage maximale pour la sélection de nombres aléatoires. Puisque nous utilisons des entiers non signés et que nous savons que strtoull() ne se plaindra pas des nombres négatifs (enveloppant ainsi la plage d'entiers comme une incompatibilité de signe), nous évitons simplement d'utiliser des nombres négatifs (solution de contournement classique de la libc).

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!