Die gleichzeitige Implementierung der Curl-Funktion in PHP reduziert die Backend-Zugriffszeit

Der Inhalt dieses Artikels besteht darin, die Parallelitätsimplementierung der Curl-Funktion in PHP mitzuteilen, um die Back-End-Zugriffszeit zu verkürzen. Sie hat einen gewissen Referenzwert.

Zuerst Lassen Sie uns die PHP-Curl-Multithread-Funktion verstehen in:

# 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_s elect

Im Allgemeinen sollte der Zweck bei der Verwendung dieser Funktionen offensichtlich darin bestehen, mehrere URLs gleichzeitig anzufordern, anstatt sie einzeln anzufordern um 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 es schmutzig ist):

Der gesamte Verwendungsprozess ist Fast das Gleiche. Dieser einfache Code hat jedoch eine schwerwiegende Schwäche: Der Abschnitt der Do-Schleife ist während der gesamten URL-Anfrage eine Endlosschleife, die leicht dazu führen kann, dass die CPU 100 % auslastet.

/*
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);

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 Do-Abschnitt oben wie folgt:
                                                                                                                                       Sobald neue Daten eingehen, kann diese aktiviert werden, um mit der Ausführung fortzufahren. 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]);



<🎜 vor curl_multi_getcontent >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, sodass dies leicht beseitigt werden kann.

Normalerweise wird cURL in PHP blockierend ausgeführt Nach dem Erstellen einer cURL-Anforderung müssen Sie warten, bis die nächste Anforderung ausgeführt wird. Die Funktion „curl_multi_*“ ermöglicht den erfolgreichen gleichzeitigen Zugriff. Die Verwendung ist wie folgt :

1. $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);

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

1. <?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并发访问方式以及耗时统计

1. <?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相关参数
   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

   Das obige ist der detaillierte Inhalt vonDie gleichzeitige Implementierung der Curl-Funktion in PHP reduziert die Backend-Zugriffszeit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!