Français
Français
Dans le développement de PHP, en particulier lorsqu'un grand nombre de demandes de réseau ou de connexions de base de données sont nécessaires, les opérations de synchronisation à fil unique deviennent souvent un goulot d'étranglement, affectant l'efficacité globale du programme. Pour résoudre ce problème, nous pouvons améliorer les performances en créant plusieurs instances de connexion et en tirant parti du traitement parallèle. Cet article combinera l'exemple de fonction Connect () de PHP pour expliquer comment implémenter plusieurs connexions d'instance et utiliser le traitement parallèle pour accélérer les opérations.
Le code PHP traditionnel est souvent exécuté de manière synchrone, comme:
<?php
function connect($url) {
// Demande de simulation
$content = file_get_contents($url);
return $content;
}
$urls = [
'http://example.com/api/1',
'http://example.com/api/2',
'http://example.com/api/3',
];
foreach ($urls as $url) {
$result = connect($url);
echo $result . "\n";
}
?>
Dans le code ci-dessus, chaque demande doit attendre le dernier achèvement, ce qui entraîne une inefficacité. Si chaque demande prend 1 seconde, il faut 3 secondes pour que les trois demandes soient remplies.
Nous pouvons créer une instance de connexion indépendante pour chaque demande:
<?php
class Connector {
private $url;
public function __construct($url) {
$this->url = $url;
}
public function connect() {
return file_get_contents($this->url);
}
}
$urls = [
'http://m66.net/api/1',
'http://m66.net/api/2',
'http://m66.net/api/3',
];
$connectors = [];
foreach ($urls as $url) {
$connectors[] = new Connector($url);
}
De cette façon, nous encapsulons chaque demande dans un objet, mais synchronisons toujours la demande.
PHP prend en charge plusieurs façons de mettre en œuvre le parallélisme, comme:
Utilisez la série de fonctions Curl_Multi_ * pour faire des demandes simultanées.
Profitez du multithreading (comme l'extension PTHREADS ).
Utilisez des bibliothèques asynchrones telles que ReactPHP .
Ici, Curl_Multi est utilisé comme exemple pour montrer comment traiter plusieurs instances de connexion en parallèle.
<?php
class Connector {
private $url;
private $ch;
public function __construct($url) {
$this->url = $url;
$this->ch = curl_init();
curl_setopt($this->ch, CURLOPT_URL, $this->url);
curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
}
public function getCurlHandle() {
return $this->ch;
}
public function getContent() {
return curl_multi_getcontent($this->ch);
}
}
<?php
$urls = [
'http://m66.net/api/1',
'http://m66.net/api/2',
'http://m66.net/api/3',
];
$connectors = [];
foreach ($urls as $url) {
$connectors[] = new Connector($url);
}
$multiHandle = curl_multi_init();
foreach ($connectors as $connector) {
curl_multi_add_handle($multiHandle, $connector->getCurlHandle());
}
$running = null;
do {
curl_multi_exec($multiHandle, $running);
curl_multi_select($multiHandle);
} while ($running > 0);
foreach ($connectors as $connector) {
$content = $connector->getContent();
echo $content . "\n";
curl_multi_remove_handle($multiHandle, $connector->getCurlHandle());
}
curl_multi_close($multiHandle);
Grâce à Curl_Multi , nous pouvons initier plusieurs demandes HTTP en même temps, en attendant que toutes les demandes soient remplies et en traitement des résultats en même temps, ce qui économise considérablement le temps d'attente.
Utilisez la fonction connect () pour encapsuler les demandes et créez plusieurs instances de connexion pour une gestion facile.
Utilisez les fonctions de la série Curl_Multi de PHP pour implémenter le traitement parallèle des demandes.
Le traitement parallèle améliore considérablement l'efficacité des demandes ou des connexions du réseau, et convient aux scénarios où plusieurs interfaces sont accessibles simultanément.
