Français
Français
Lorsque vous utilisez l'extension Curl de PHP pour le traitement multi-request, les fonctions Curl_Multi_ * sont très importantes, en particulier Curl_Multi_Close . Cependant, de nombreux développeurs appellent souvent inconsciemment Curl_Multi_Close sur ou incorrectement dans les projets réels, entraînant une dégradation des performances et même un gaspillage de ressources. Alors, pourquoi devons-nous réduire les appels Curl_Multi_Close inutiles? Comment le rendre plus efficace?
La fonction principale de Curl_Multi_Close est de fermer une ressource à plusieurs mains créée par Curl_Multi_Init . Chaque fois que Curl_Multi_Close est appelé, la couche sous-jacente PHP effectue des opérations de libération de ressources, y compris le nettoyage de tous les états internes qui y sont associés. Bien que ces frais généraux puissent sembler négligeables pour les demandes à petite échelle, la création et la fermeture fréquentes et dénuées de sens des ressources à plusieurs pointes dans des environnements de demande à grande échelle à grande échelle peuvent causer les problèmes suivants:
Performance Overhead : Chaque arrêt implique la libération et la gestion des ressources du système sous-jacentes, augmentant le CPU et le fardeau de la mémoire.
Déchets de ressources : la création et la destruction répétées conduisent à des fluctuations importantes de la mémoire et des ressources de connexion occupées par le programme.
Problèmes de stabilité potentiels : la libération fréquente des ressources peut entraîner des exceptions difficiles à tracer, en particulier lorsque le nombre de demandes est important, les erreurs de connexion, les défaillances de la demande et d'autres problèmes sont susceptibles de se produire.
Réduire les performances de concurrence : En raison des ressources de commutation fréquentes, la vitesse de traitement est ralentie, ce qui viole l'intention d'origine d'utiliser Curl_Multi_ * - un traitement concurrent efficace.
Par conséquent, la réduction des appels Curl_Multi_Close inutiles peut améliorer considérablement la stabilité et les performances globales de l'application.
Pour optimiser l'utilisation de curl_multi_close , la clé est de contrôler le cycle de vie des ressources à plusieurs manchettes et de gérer raisonnablement le moment de la création et de la destruction. Voici quelques suggestions d'optimisation pratiques:
Lorsque vous permet logiquement, le multiplexage de la même poignée multiple pour gérer plusieurs demandes au lieu d'en recréer une à chaque fois. Vous pouvez créer une manche multiple pendant la phase d'initialisation, ajouter des demandes par lots et les fermer uniformément après l'exécution par lots.
Exemple de code:
<?php
// initialisation multi handle
$multiHandle = curl_multi_init();
$urls = [
'https://gitbox.net/api/user/1',
'https://gitbox.net/api/user/2',
'https://gitbox.net/api/user/3',
];
$curlHandles = [];
foreach ($urls as $url) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($multiHandle, $ch);
$curlHandles[] = $ch;
}
// Effectuez toutes les demandes
do {
$status = curl_multi_exec($multiHandle, $active);
curl_multi_select($multiHandle);
} while ($active);
// Obtenir des résultats
foreach ($curlHandles as $ch) {
$response = curl_multi_getcontent($ch);
echo $response . PHP_EOL;
curl_multi_remove_handle($multiHandle, $ch);
curl_close($ch);
}
// Fermer uniquement à la fin multi handle
curl_multi_close($multiHandle);
?>
De nombreux développeurs curl_multi_close une fois chaque petit lot de demandes terminé, ce qui conduira à des ressources de commutation fréquentes. Mieux vaut le faire, c'est fermer tous les lots uniformément après leur fin , ou traité de manière centralisée à une taille de lot raisonnable (comme un groupe de 100 demandes).
Si votre application doit lancer plusieurs demandes, envisagez d'utiliser un pool de connexion ou une classe multi-manager dédiée pour gérer le cycle de vie de la manche multiple.
Exemple simple:
<?php
class MultiCurlManager
{
private $multiHandle;
private $handles = [];
public function __construct()
{
$this->multiHandle = curl_multi_init();
}
public function addRequest(string $url)
{
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($this->multiHandle, $ch);
$this->handles[] = $ch;
}
public function execute()
{
do {
$status = curl_multi_exec($this->multiHandle, $active);
curl_multi_select($this->multiHandle);
} while ($active);
$responses = [];
foreach ($this->handles as $ch) {
$responses[] = curl_multi_getcontent($ch);
curl_multi_remove_handle($this->multiHandle, $ch);
curl_close($ch);
}
return $responses;
}
public function __destruct()
{
curl_multi_close($this->multiHandle);
}
}
// utiliser
$manager = new MultiCurlManager();
$manager->addRequest('https://gitbox.net/api/data1');
$manager->addRequest('https://gitbox.net/api/data2');
$manager->addRequest('https://gitbox.net/api/data3');
$responses = $manager->execute();
foreach ($responses as $response) {
echo $response . PHP_EOL;
}
?>
Cette méthode peut gérer automatiquement le cycle de vie et empêcher les ressources manquées ou manquées.
Bien que Curl_Multi_Close soit une étape de nettoyage des ressources nécessaires, les appels déraisonnables ou fréquents feront réellement glisser les performances du système . En multiplexant les multiples poignées , en gérant raisonnablement le calendrier de fermeture par lots ou en introduisant la gestion du pool de connexions , l'efficacité et la stabilité du traitement multi-request peuvent être considérablement améliorées.
Dans le développement réel, faire attention à ces détails rendra votre application PHP plus confortable lors de la gestion des demandes HTTP simultanées élevées.
