So implementieren Sie gleichzeitige Anforderungen in PHP (Code)

Der Inhalt dieses Artikels befasst sich mit der Implementierung gleichzeitiger Anforderungen (Code) in PHP. Ich hoffe, dass er für Freunde hilfreich ist.

Bei der Entwicklung von Back-End-Diensten gibt es häufig Anforderungen für gleichzeitige Anforderungen. Beispielsweise müssen Sie die Bandbreitendaten von 10 Anbietern abrufen (jeder bietet einen anderen url) und dann integrierte Daten zurückgeben. Was würden Sie tun?

In PHP besteht der intuitivste Weg darin, das Ergebnis jeder Anfrage zu foreach zu durchlaufen urls und dann zu speichern, wenn die vom Lieferanten bereitgestellte Schnittstelle einen Durchschnitt von 5s annimmt Die Anforderungszeit dieser Schnittstelle erreicht 50s, was für Websites, die Geschwindigkeit und Leistung anstreben, nicht akzeptabel ist.

Zu diesem Zeitpunkt benötigen Sie gleichzeitige Anfragen.

PHPAnfrage

PHP ist ein Einzelprozess-Synchronisationsmodell. Eine Anfrage entspricht einem Prozess und I/O wird synchron blockiert. Durch die Erweiterung von Diensten wie nginx/apache/php-fpm kann PHP Dienste mit hoher Parallelität bereitstellen. Das Prinzip besteht darin, einen Prozesspool aufrechtzuerhalten. Jedes Mal, wenn ein Dienst angefordert wird, wird ein neuer Prozess separat gestartet.

PHP unterstützt keinen Multithreading-Modus und keine Rückrufverarbeitung, daher PHP interne Skripte blockieren synchron. Wenn Sie eine 5s-Anfrage initiieren, wird das Programm I/Oblockieren5s. Die Codeausführung wird erst fortgesetzt, wenn die Anforderung ein Ergebnis zurückgibt. Daher ist es sehr schwierig, Anforderungsanforderungen mit hoher Parallelität wie Crawler zu erfüllen.

Wie kann man also das Problem gleichzeitiger Anfragen lösen? Zusätzlich zu den integrierten Anforderungsmethoden file_get_contents und fsockopen unterstützt PHP auch die Erweiterung cURL. Es unterstützt reguläre Einzelanforderungen: PHP-cURL-Anforderungsdetails und gleichzeitige Anforderungen Prinzip ist cURL Die Erweiterung nutzt Multithreading, um mehrere Anfragen zu verwalten.

PHPGleichzeitige Anfrage

Sehen wir uns den Code direkt andemo:

// 简单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;
}

Erstellen Sie in dieser gleichzeitigen Anfrage zuerst ein Batch-Handle und dann url Das cURL-Handle wird dem Batch-Handle hinzugefügt und der Ausführungsstatus des Batch-Handles wird kontinuierlich abgefragt. Wenn die Ausführung abgeschlossen ist, wird das zurückgegebene Ergebnis erhalten.

curl_multiVerwandte Funktionen

/** 函数作用：返回一个新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 )

Vordefinierte Konstanten, die in diesem Beispiel verwendet werden:
CURLM_CALL_MULTI_PERFORM: (int) -1
CURLM_OK: (int) 0

PHPVergleich des gleichzeitigen Anforderungszeitverbrauchs

1. Die erste Anfrage verwendet die obige curl_multi_init-Methode, und gleichzeitige Anfragen sind 105-mal.

2. Die zweite Anfrage verwendet die traditionelle foreach-Methode, und die 105-Zeiten werden mit der curl_init-Methodenanforderung durchlaufen.

Das tatsächliche zeitaufwändige Ergebnis der Anfrage ist:

Ohne downloads ca. 765ms Zeitaufwändig, die Optimierung des reinen Anforderungszeitaufwands hat das 39.83/1.58- bis 25-fache erreicht. Wenn wir den Zeitaufwand im Zusammenhang mit dem Verbindungsaufbau weiterhin eliminieren, sollte er noch höher sein. Zeitaufwändig:

• Option 1: Die langsamste Schnittstelle erreicht 1.58s

• Option 2: 105 Der durchschnittliche Zeitverbrauch der Schnittstelle ist 384ms

Die Anforderung dieses Tests ist die interne Schnittstelle meiner Umgebung, daher ist der Zeitaufwand sehr gering. Die tatsächliche Optimierung der Crawler-Anforderungsumgebung wird offensichtlicher.

Hinweise

Parallelitätslimit

curl_multi verbraucht viele Systemressourcen. Es gibt einen bestimmten Schwellenwert für die Anzahl gleichzeitiger Anfragen, normalerweise 512, aufgrund von CURLInternes Limit, das Überschreiten der maximalen Parallelität führt zu einem Fehler.

Ich habe keine spezifischen Testergebnisse durchgeführt. Sie können auf die Artikel anderer Leute verweisen: Wie viele gleichzeitige Anfragen sind bei jeder Verwendung von Curl Multi angemessen?

Zeitüberschreitung

Um zu verhindern, dass langsame Anfragen Auswirkungen haben Sie können den gesamten Dienst festlegenCURLOPT_TIMEOUTUm die Zeitüberschreitung zu steuern, zu verhindern, dass einige ausgesetzte Anforderungen die Prozessverarbeitung auf unbestimmte Zeit blockieren, und schließlich den Maschinendienst zu beenden.

CPUDie Last ist voll

Wenn Sie im Codebeispiel weiterhin den gleichzeitigen Ausführungsstatus abfragen, führt dies dazu, dass die Last von cpu zu hoch ist, also Sie Sie müssen dem Code eine usleep(50000);-Anweisung hinzufügen.
Gleichzeitig kann curl_multi_select auch die Belegung von cpu steuern. Es bleibt in einem Wartezustand, bis eine Antwort auf die Daten erfolgt. Es wird aktiviert und die Ausführung fortgesetzt, sobald neue Daten eingehen , wodurch der unnötige Verbrauch von CPU reduziert wird.

Verwandte Empfehlungen:

So implementieren Sie AJAX-Warteschlangenanforderungen (mit Code)

PHP verwendet curl_multi, um gleichzeitige Anforderungen zu implementieren Methodenbeispiele PHP-Techniken

Das obige ist der detaillierte Inhalt vonSo implementieren Sie gleichzeitige Anforderungen in PHP (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!