Français
Français
Lorsque vous devez exécuter plusieurs demandes Curl simultanément, vous pouvez utiliser la fonction curl_multi_exec () . Cette fonction permet d'exécuter simultanément les séances de boucles et les gérer avec une poignée multiple.
Voici un exemple de base montrant comment utiliser curl_multi_exec () pour gérer plusieurs demandes Curl:
<?php
// Créer plusieurs cURL Poignée
$ch1 = curl_init("https://gitbox.net/api/data1");
$ch2 = curl_init("https://gitbox.net/api/data2");
$ch3 = curl_init("https://gitbox.net/api/data3");
// Créer un cURL 多Poignée
$multi_handle = curl_multi_init();
// Mettre un seul cURL Poignée加入到多Poignée中
curl_multi_add_handle($multi_handle, $ch1);
curl_multi_add_handle($multi_handle, $ch2);
curl_multi_add_handle($multi_handle, $ch3);
// Exécuter plusieurs cURL demander
$running = null;
do {
curl_multi_exec($multi_handle, $running);
} while ($running > 0);
// Fermer chaque individu cURL Poignée
curl_multi_remove_handle($multi_handle, $ch1);
curl_multi_remove_handle($multi_handle, $ch2);
curl_multi_remove_handle($multi_handle, $ch3);
// fermeture多Poignée
curl_multi_close($multi_handle);
Dans cet exemple, nous créons trois poignées de demande Curl et les exécutons simultanément via Curl_Multi_Exec () . Notez que bien que Curl_Multi_Exec () puisse effectuer plusieurs demandes en même temps, nous devons toujours utiliser Curl_Multi_Remove_Handle () et Curl_Multi_Close () pour s'assurer que les ressources sont correctement publiées.
Une fois chaque demande CURL exécutée, la fonction curl_close () doit être utilisée pour libérer la ressource correspondante. Bien que Curl_Multi_Close () ferme toute la connexion multi-mains, il ne ferme pas automatiquement une poignée de boucle séparée. Par conséquent, après avoir terminé l'opération multitâche, nous devons fermer manuellement chaque poignée de boucle. Si ces ressources ne sont pas libérées correctement, des fuites de mémoire peuvent se produire.
Voici le code amélioré qui utilise correctement Curl_close () pour gratuitement des ressources pour chaque poignée CURL:
<?php
// Créer plusieurs cURL Poignée
$ch1 = curl_init("https://gitbox.net/api/data1");
$ch2 = curl_init("https://gitbox.net/api/data2");
$ch3 = curl_init("https://gitbox.net/api/data3");
// Créer un cURL 多Poignée
$multi_handle = curl_multi_init();
// Mettre un seul cURL Poignée加入到多Poignée中
curl_multi_add_handle($multi_handle, $ch1);
curl_multi_add_handle($multi_handle, $ch2);
curl_multi_add_handle($multi_handle, $ch3);
// Exécuter plusieurs cURL demander
$running = null;
do {
curl_multi_exec($multi_handle, $running);
} while ($running > 0);
// Fermer chaque individu cURL Poignée
curl_close($ch1);
curl_close($ch2);
curl_close($ch3);
// fermeture多Poignée
curl_multi_close($multi_handle);
De cette façon, nous nous assurons qu'après la fin de chaque demande de boucle, les ressources pertinentes peuvent être publiées dans le temps.
Libérez les ressources dans le temps : une fois les demandes de curl terminées, assurez-vous d'appeler Curl_close () pour libérer chaque ressource Curl individuelle et fermer plusieurs poignées à la fin.
Gestion des erreurs appropriées : dans les projets réels, les demandes de réseau peuvent échouer, ce qui entraîne une clôture correcte de certaines poignées de boucle. Vous pouvez ajouter un mécanisme de gestion des erreurs pour vous assurer que la ressource peut être libérée, que la demande soit réussie ou non. Par exemple:
if ($ch1) {
// 如果demander成功，fermeture cURL ressource
curl_close($ch1);
}
Utilisation de la mémoire du moniteur : Lors de la gestion de plusieurs demandes de boucle simultanées, vous pouvez surveiller l'utilisation de la mémoire de PHP pour vous assurer qu'aucune fuite de mémoire ne se produit. Dans certaines applications complexes, l'utilisation de gc_collect_cycles () à temps pour forcer le recyclage des ordures de mémoire PHP peut également aider à réduire l'utilisation de la mémoire.
Limiter le nombre de demandes simultanées : Bien que Curl_Multi_Exec () puisse exécuter plusieurs demandes en même temps, des demandes simultanées excessives peuvent entraîner une consommation excessive de ressources système. Dans les applications pratiques, le nombre de demandes simultanées peut être correctement limitée pour éviter que les demandes de boucle excessives occupent trop de mémoire.
