PHP-Parallelität nutzt Curl-Parallelität, um die Back-End-Zugriffszeit zu verkürzen

Der mit Ihnen in diesem Artikel geteilte Inhalt befasst sich mit der Verwendung von Curl-Parallelität in PHP, um die Back-End-Zugriffszeit zu verkürzen. Freunde in Not können sich darauf beziehen

Lassen Sie uns zunächst die Curl-Multithread-Funktion in PHP verstehen:

# curl_multi_add_handle
# curl_multi_close
# curl_multi_exec
# curl_multi_getcontent
# curl_multi_info_read
# curl_multi_init
# curl_multi_remove_handle
# curl_multi_select

Im Allgemeinen sollte der Zweck bei der Verwendung dieser Funktionen offensichtlich darin bestehen, mehrere URLs anzufordern Zur gleichen Zeit, nicht eine Eine Anfrage nacheinander, andernfalls ist es besser, curl_exec selbst zu schleifen und anzupassen.

Die Schritte sind wie folgt zusammengefasst:

Schritt 1: Curl_multi_init aufrufen
Schritt 2: Curl_multi_add_handle in einer Schleife aufrufen
In diesem Schritt ist zu beachten, dass der zweite Parameter von curl_multi_add_handle wird durch Subhandle von curl_init gegeben.
Schritt 3: Rufen Sie weiterhin „curl_multi_exec“ auf.
Schritt 4: Rufen Sie „curl_multi_getcontent“ in einer Schleife auf, um die Ergebnisse nach Bedarf zu erhalten. „Schritt 5: Rufen Sie „curl_multi_remove_handle“ und „curl_close“ für jedes Worthandle auf curl_multi_close

Hier ist ein einfaches Beispiel, das online gefunden wurde. Der Autor nennt es ein schmutziges Beispiel (ich werde später erklären, warum schmutzig):

/*
Here's a quick and dirty example for curl-multi from PHP, tested on PHP 5.0.0RC1 CLI / FreeBSD 5.2.1
*/

$connomains = array(
"http://www.cnn.com/",
"http://www.canada.com/",
"http://www.yahoo.com/"
);

$mh = curl_multi_init();

foreach ($connomains as $i => $url) {
     $conn[$i]=curl_init($url);
      curl_setopt($conn[$i],CURLOPT_RETURNTRANSFER,1);
      curl_multi_add_handle ($mh,$conn[$i]);
}

do { $n=curl_multi_exec($mh,$active); } while ($active);

foreach ($connomains as $i => $url) {
      $res[$i]=curl_multi_getcontent($conn[$i]);
      curl_close($conn[$i]);
}

print_r($res);

Das Der gesamte Nutzungsprozess ist fast so. Dieser einfache Code hat jedoch eine schwerwiegende Schwäche: In der Do-Schleife handelt es sich um eine Endlosschleife während der gesamten URL-Anfrage, die leicht dazu führen kann, dass die CPU 100 % auslastet.

Jetzt müssen wir eine Funktion „curl_multi_select“ verwenden, für die es fast keine Dokumentation gibt. Obwohl die Curl-Bibliothek von C über Anweisungen für „select“ verfügt, unterscheiden sich die Schnittstelle und die Verwendung in PHP tatsächlich von denen in C.

Ändern Sie den obigen Abschnitt wie folgt:
                                                                                                                              
Wenn es um den Rückgabewert von curl_multi_exec geht, wird beurteilt, ob noch Daten vorhanden sind. Curl_multi_exec wird kontinuierlich aufgerufen Wenn vorerst keine Daten vorhanden sind, wird die Auswahlphase aktiviert. Sobald neue Daten vorliegen, kann die Ausführung fortgesetzt werden. Der Vorteil hierbei ist, dass kein unnötiger CPU-Verbrauch entsteht.

Außerdem: Es gibt einige Details, auf die Sie manchmal stoßen können:

  do {
                        $mrc = curl_multi_exec($mh,$active);
                } while ($mrc == CURLM_CALL_MULTI_PERFORM);
                while ($active and $mrc == CURLM_OK) {
                        if (curl_multi_select($mh) != -1) {
                                do {
                                        $mrc = curl_multi_exec($mh, $active);
                                } while ($mrc == CURLM_CALL_MULTI_PERFORM);
                        }
                }

Kontrollieren Sie das Timeout jeder Anfrage, tun Sie dies über curl_setopt vor curl_multi_add_handle:
curl_setopt($ch , CURLOPT_TIMEOUT, $ timeout);

Um festzustellen, ob ein Timeout oder andere Fehler vorliegen, verwenden Sie: curl_error($conn[$i]);



Hier Ich verwende einfach das oben erwähnte schmutzige Beispiel (es reicht aus und ich habe keine 100-prozentige CPU-Auslastung gefunden).

Simulieren Sie Parallelität auf einer bestimmten Schnittstelle von „Kandian.com“. Die Funktion besteht darin, Daten zu lesen und in den Memcache zu schreiben. Aus Gründen der Vertraulichkeit werden relevante Daten und Ergebnisse nicht veröffentlicht.

Beim ersten Mal wurden 1000 Threads gleichzeitig angefordert. Beim zweiten Mal wurden 1000 Threads gleichzeitig angefordert Zeit (es ist schon ziemlich anstrengend, ich traue mich nicht in Einstellungen mit mehr als 1000 Multithreads).

Es scheint, dass die Parallelität der Curl-Multithread-Simulation immer noch gewisse Einschränkungen aufweist.

Darüber hinaus hatte ich auch den Verdacht, dass aufgrund der Multi-Thread-Verzögerung ein großer Fehler in den Ergebnissen vorliegen könnte, und habe dies durch einen Vergleich der Daten herausgefunden. Es gibt keinen großen Unterschied in der Zeit, die für die Initialisierung und Einstellung aufgewendet wird. Der Unterschied liegt in der Get-Methode, daher kann dies einfach eliminiert werden~~~

http ://log.dongsheng.org/2008/07/16/curl-multiple-handlers/

Normalerweise wird cURL in PHP blockierend ausgeführt, was bedeutet, dass nach dem Erstellen eines cURL-Anfrage, Sie müssen warten, bis die nächste Anfrage ausgeführt wird. Die Funktion „curl_multi_*“ ermöglicht den erfolgreichen gleichzeitigen Zugriff folgt:

源码打印？

$requests = array('http://www.baidu.com', 'http://www.google.com');  
$main    = curl_multi_init();  
$results = array();  
$errors  = array();  
$info = array();  
$count = count($requests);  
for($i = 0; $i < $count; $i++)   
{    
$handles[$i] = curl_init($requests[$i]);    
var_dump($requests[$i]);    
curl_setopt($handles[$i], CURLOPT_URL, $requests[$i]);    
curl_setopt($handles[$i], CURLOPT_RETURNTRANSFER, 1);    
curl_multi_add_handle($main, $handles[$i]);  
}  
$running = 0;   
do {    
curl_multi_exec($main, $running);  
}   
while($running > 0);   
for($i = 0; $i < $count; $i++)  
{  $results[] = curl_multi_getcontent($handles[$i]);    
$errors[]  = curl_error($handles[$i]);    
$info[]    = curl_getinfo($handles[$i]);    
curl_multi_remove_handle($main, $handles[$i]);  
}  
curl_multi_close($main);  
var_dump($results);  
var_dump($errors);  
var_dump($info);

 

 

http://www.searchtb.com/2010/12/using-multicurl-to-improve-performance.html

前言：在我们平时的程序中难免出现同时访问几个接口的情况，平时我们用curl进行访问的时候，一般都是单个、顺序访问，假如有3个接口，每个接口耗时500毫秒那么我们三个接口就要花费1500毫秒了，这个问题太头疼了严重影响了页面访问速度，有没有可能并发访问来提高速度呢？今天就简单的说一下，利用curl并发来提高页面访问速度，希望大家多指导。1、老的curl访问方式以及耗时统计

源码打印？

<?php function curl_fetch($url, $timeout=3){       
$ch = curl_init();       
curl_setopt($ch, CURLOPT_URL, $url);       
curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);       
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);       
$data = curl_exec($ch);       
$errno = curl_errno($ch);       
if ($errno>0) {           
$data = false;       
}       
curl_close($ch);       
return $data;   
}   
function microtime_float()   
{      
list($usec, $sec) = explode(" ", microtime());      
return ((float)$usec + (float)$sec);   
}   
$url_arr=array(        
"taobao"=>"http://www.taobao.com",        
"sohu"=>"http://www.sohu.com",        
"sina"=>"http://www.sina.com.cn",        
);    
$time_start = microtime_float();    
$data=array();    
foreach ($url_arr as $key=>$val)    
{        
$data[$key]=curl_fetch($val);    
}    
$time_end = microtime_float();    
$time = $time_end - $time_start;    
echo "耗时:{$time}";   
?>

耗时:0.614秒 
2、curl并发访问方式以及耗时统计

源码打印？

<?php   
function curl_multi_fetch($urlarr=array()){       
$result=$res=$ch=array();       
$nch = 0;       
$mh = curl_multi_init();       
foreach ($urlarr as $nk => $url) {           
$timeout=2;           
$ch[$nch] = curl_init();           
curl_setopt_array($ch[$nch], array(           
CURLOPT_URL => $url,           
CURLOPT_HEADER => false,           
CURLOPT_RETURNTRANSFER => true,           
CURLOPT_TIMEOUT => $timeout,           
));           
curl_multi_add_handle($mh, $ch[$nch]);           
++$nch;     }       
/* wait for performing request */      
do {           
$mrc = curl_multi_exec($mh, $running);       
} while (CURLM_CALL_MULTI_PERFORM == $mrc);         
while ($running && $mrc == CURLM_OK) {           
// wait for network           
if (curl_multi_select($mh, 0.5) > -1) {               
// pull in new data;               
do {                   
$mrc = curl_multi_exec($mh, $running);               
} while (CURLM_CALL_MULTI_PERFORM == $mrc);           
}       
}         
if ($mrc != CURLM_OK) {           
error_log("CURL Data Error");       
}         
/* get data */      
$nch = 0;       
foreach ($urlarr as $moudle=>$node) {           
if (($err = curl_error($ch[$nch])) == &#39;&#39;) {               
$res[$nch]=curl_multi_getcontent($ch[$nch]);             $result[$moudle]=$res[$nch];         }           
else          
{               
error_log("curl error");           
}           
curl_multi_remove_handle($mh,$ch[$nch]);           
curl_close($ch[$nch]);           
++$nch;       
}       
curl_multi_close($mh);       
return  $result;   
}   
$url_arr=array(        
"taobao"=>"http://www.taobao.com",        
"sohu"=>"http://www.sohu.com",        
"sina"=>"http://www.sina.com.cn",        
);   
function microtime_float()   
{      
list($usec, $sec) = explode(" ", microtime());      
return ((float)$usec + (float)$sec);   
}   
$time_start = microtime_float();   
$data=curl_multi_fetch($url_arr);   
$time_end = microtime_float();   
$time = $time_end - $time_start;   
echo "耗时:{$time}";   
?>

耗时:0.316秒
帅气吧整个页面访问后端接口的时间节省了一半
3、curl相关参数
来自：http://cn2.php.net/manual/en/ref.curl.php
curl_close — Close a cURL session
curl_copy_handle — Copy a cURL handle along with all of its preferences
curl_errno — Return the last error number
curl_error — Return a string containing the last error for the current session
curl_exec — Perform a cURL session
curl_getinfo — Get information regarding a specific transfer
curl_init — Initialize a cURL session
curl_multi_add_handle — Add a normal cURL handle to a cURL multi handle
curl_multi_close — Close a set of cURL handles
curl_multi_exec — Run the sub-connections of the current cURL handle
curl_multi_getcontent — Return the content of a cURL handle if CURLOPT_RETURNTRANSFER is set
curl_multi_info_read — Get information about the current transfers
curl_multi_init — Returns a new cURL multi handle
curl_multi_remove_handle — Remove a multi handle from a set of cURL handles
curl_multi_select — Wait for activity on any curl_multi connection
curl_setopt_array — Set multiple options for a cURL transfer
curl_setopt — Set an option for a cURL transfer
curl_version — Gets cURL version information

前端开发中的性能那点事（三）php的opcode缓存

前端开发中的性能那点事（一）巧用xdebug

 

http://www.oschina.net/question/234345_42245

 相关推荐：

php并发之关于查询MySQL的示例（图）

PHP并发读写文件如何解决

Das obige ist der detaillierte Inhalt vonPHP-Parallelität nutzt Curl-Parallelität, um die Back-End-Zugriffszeit zu verkürzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!