Comment implémenter des requêtes simultanées en php (code)

Le contenu de cet article explique comment implémenter des requêtes simultanées (code) en PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Il existe souvent des exigences de demandes simultanées dans le développement de services back-end. Par exemple, vous devez obtenir les données de bande passante de 10 fournisseurs (chacun fournit un url différent), puis renvoyer des données intégrées. Que feriez-vous?

Dans PHP, le moyen le plus intuitif est de foreach parcourir urls et de sauvegarder le résultat de chaque requête. Ensuite si l'interface fournie par le fournisseur prend en moyenne 5s, votre Ceci. la demande d'interface prend jusqu'à 50s, ce qui est inacceptable pour les sites Web qui recherchent la vitesse et les performances.

À l'heure actuelle, vous avez besoin de demandes simultanées.

PHPRequête

PHP est un modèle de synchronisation à processus unique. Une requête correspond à un processus et I/O est bloquée de manière synchrone. Grâce à l'expansion de services tels que nginx/apache/php-fpm, PHP peut fournir des services à haute concurrence. Le principe est de maintenir un pool de processus chaque fois qu'un service est demandé, un nouveau processus est démarré séparément et chaque processus existe indépendamment.

PHP ne prend pas en charge le mode multithread et le traitement de rappel, donc PHP les scripts internes bloquent de manière synchrone Si vous lancez une 5s requête, le programme I/Obloquer5s, l'exécution du code ne continuera pas tant que la requête n'aura pas renvoyé un résultat. Par conséquent, il est très difficile de répondre aux exigences de requêtes à haute concurrence telles que les robots d'exploration.

Alors comment résoudre le problème des requêtes concurrentes ? En plus des méthodes de requête file_get_contents et fsockopen intégrées, PHP prend également en charge l'extension cURL pour lancer des requêtes. Elle prend en charge les requêtes simples régulières : les détails des requêtes PHP cURL et prend également en charge les requêtes simultanées. Le principe est cURL L'extension utilise le multithreading pour gérer plusieurs requêtes.

PHPRequêtes simultanées

Regardons directement le codedemo :

// 简单demo，默认支持为GET请求
public function multiRequest($urls) {
    $mh = curl_multi_init();
    $urlHandlers = [];
    $urlData = [];
    // 初始化多个请求句柄为一个
    foreach($urls as $value) {
        $ch = curl_init();
        $url = $value['url'];
        $url .= strpos($url, '?') ? '&' : '?';
        $params = $value['params'];
        $url .= is_array($params) ? http_build_query($params) : $params;
        curl_setopt($ch, CURLOPT_URL, $url);
        // 设置数据通过字符串返回，而不是直接输出
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        $urlHandlers[] = $ch;
        curl_multi_add_handle($mh, $ch);
    }
    $active = null;
    // 检测操作的初始状态是否OK，CURLM_CALL_MULTI_PERFORM为常量值-1
    do {
        // 返回的$active是活跃连接的数量，$mrc是返回值，正常为0，异常为-1
        $mrc = curl_multi_exec($mh, $active);
    } while ($mrc == CURLM_CALL_MULTI_PERFORM);
    // 如果还有活动的请求，同时操作状态OK，CURLM_OK为常量值0
    while ($active && $mrc == CURLM_OK) {
        // 持续查询状态并不利于处理任务，每50ms检查一次，此时释放CPU，降低机器负载
        usleep(50000);
        // 如果批处理句柄OK，重复检查操作状态直至OK。select返回值异常时为-1，正常为1（因为只有1个批处理句柄）
        if (curl_multi_select($mh) != -1) {
            do {
                $mrc = curl_multi_exec($mh, $active);
            } while ($mrc == CURLM_CALL_MULTI_PERFORM);
        }
    }
    // 获取返回结果
    foreach($urlHandlers as $index => $ch) {
        $urlData[$index] = curl_multi_getcontent($ch);
        // 移除单个curl句柄
        curl_multi_remove_handle($mh, $ch);
    }
    curl_multi_close($mh);
    return $urlData;
}

Dans cette requête simultanée, créez d'abord un handle de lot, puis Le url handle de cURL est ajouté au handle de lot et l'état d'exécution du handle de lot est interrogé en permanence lorsque l'exécution est terminée, le résultat renvoyé est obtenu.

curl_multiFonctions associées

/** 函数作用：返回一个新cURL批处理句柄
    @return resource 成功返回cURL批处理句柄，失败返回false
*/
resource curl_multi_init ( void )

/** 函数作用：向curl批处理会话中添加单独的curl句柄
    @param $mh 由curl_multi_init返回的批处理句柄
    @param $ch 由curl_init返回的cURL句柄
    @return resource 成功返回cURL批处理句柄，失败返回false
*/
int curl_multi_add_handle ( resource $mh , resource $ch )

/** 函数作用：运行当前 cURL 句柄的子连接
    @param $mh 由curl_multi_init返回的批处理句柄
    @param $still_running 一个用来判断操作是否仍在执行的标识的引用
    @return 一个定义于 cURL 预定义常量中的 cURL 代码
*/
int curl_multi_exec ( resource $mh , int &$still_running )

/** 函数作用：等待所有cURL批处理中的活动连接
    @param $mh 由curl_multi_init返回的批处理句柄
    @param $timeout 以秒为单位，等待响应的时间
    @return 成功时返回描述符集合中描述符的数量。失败时，select失败时返回-1，否则返回超时(从底层的select系统调用).
*/
int curl_multi_select ( resource $mh [, float $timeout = 1.0 ] )

/** 函数作用：移除cURL批处理句柄资源中的某个句柄资源
    说明：从给定的批处理句柄mh中移除ch句柄。当ch句柄被移除以后，仍然可以合法地用curl_exec()执行这个句柄。如果要移除的句柄正在被使用，则这个句柄涉及的所有传输任务会被中止。
    @param $mh 由curl_multi_init返回的批处理句柄
    @param $ch 由curl_init返回的cURL句柄
    @return 成功时返回0，失败时返回CURLM_XXX中的一个
*/
int curl_multi_remove_handle ( resource $mh , resource $ch )

/** 函数作用：关闭一组cURL句柄
    @param $mh 由curl_multi_init返回的批处理句柄
    @return void
*/
void curl_multi_close ( resource $mh )

/** 函数作用：如果设置了CURLOPT_RETURNTRANSFER，则返回获取的输出的文本流
    @param $ch 由curl_init返回的cURL句柄
    @return string 如果设置了CURLOPT_RETURNTRANSFER，则返回获取的输出的文本流。
*/
string curl_multi_getcontent ( resource $ch )

Constantes prédéfinies utilisées dans cet exemple :
CURLM_CALL_MULTI_PERFORM: (int) -1
CURLM_OK: (int) 0

PHPComparaison de la consommation de temps des requêtes simultanées

1. La première requête utilise la méthode curl_multi_init ci-dessus, et les requêtes simultanées sont 105 fois.

2. La deuxième requête utilise la méthode traditionnelle foreach, et les temps 105 sont parcourus à l'aide de la requête de la méthode curl_init.

Le résultat réel de la demande, qui prend beaucoup de temps, est :

À l'exclusion des env. download Chronophage, l'optimisation du temps de requête pure a atteint 765ms à 39.83/1.58 fois. Si l'on continue d'éliminer le temps lié à l'établissement d'une connexion, il devrait être encore plus élevé. Prend du temps : 25

• Option 1 : L'interface la plus lente atteint

  1.58s

• Option 2 :

  La consommation de temps moyenne de l'interface est 105384ms

La requête de ce test est l'interface interne de mon environnement, donc la consommation de temps est très courte. L'optimisation réelle de l'environnement de requête du robot sera plus évidente.

Notes

Limite de concurrence

consommera beaucoup de ressources système. Il existe un certain seuil pour le nombre de requêtes simultanées, généralement curl_multi, en raison de Limite interne, dépasser la concurrence maximale entraînera un échec. 512Je n'ai pas effectué de résultats de tests spécifiques. Vous pouvez vous référer aux articles d'autres personnes : Combien de requêtes simultanées sont appropriées à chaque fois que vous utilisez curl multi ?CURLDélai d'expiration

Afin d'éviter que les requêtes lentes n'affectent l'ensemble du service, vous pouvez le définir

Pour contrôler le délai d'attente, empêcher certaines requêtes suspendues de bloquer indéfiniment le traitement du processus et enfin tuer le service machine.

CURLOPT_TIMEOUT

La charge est pleine

CPUDans l'exemple de code, si vous continuez à interroger l'état d'exécution simultanée, la charge de

sera trop élevée, vous besoin d'ajouter .

En même temps, cpu peut également contrôler l'occupation de usleep(50000);. Il sera dans un état d'attente jusqu'à ce qu'il y ait une réponse aux données. Il sera réveillé et poursuivra son exécution dès que de nouvelles données arriveront. , réduisant la consommation inutile de
. curl_multi_selectcpuRecommandations associées : CPU

Comment implémenter les requêtes de file d'attente AJAX (avec code)

PHP utilise curl_multi pour implémenter des requêtes simultanées Exemples de méthodes techniques 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!