Français
Français
Dans PHP, Curl est une bibliothèque très courante pour effectuer des demandes HTTP. Il offre aux développeurs un moyen flexible et efficace d'interagir avec d'autres serveurs. Habituellement, nous utiliserons curl_init () pour initialiser une session Curl, utiliser Curl_exec () pour exécuter la demande, puis utiliser curl_close () pour fermer la session et libérer des ressources.
Cependant, lorsque nous exécutons plusieurs demandes Curl dans notre code, nous pouvons constater que l'utilisation de la fonction curl_close () ne ferme pas immédiatement toutes les connexions, en particulier lors de l'utilisation de plusieurs demandes parallèles. La raison de ce problème est que les demandes Curl sont exécutées de manière asynchrone, et Curl_close () ferme simplement l'objet de session Curl actuel et ne peut pas immédiatement détruire toutes les connexions réseau en bas.
Curl Lors de l'exécution de plusieurs demandes, en particulier lorsque plusieurs demandes parallèles sont faites, un mécanisme multithread est utilisé pour traiter ces demandes. Ces demandes sont gérées dans le pool de connexion sous-jacente et Curl_exec () ne revient pas immédiatement lorsque la demande est entièrement terminée. Il interagit en fait avec la connexion réseau sous-jacente en attendant que la demande se termine, et ce processus n'est pas directement affecté par Curl_close () .
La fonction de la fonction curl_close () est de fermer une session Curl et de libérer des ressources liées à la session. Cependant, la fermeture d'une session ne signifie pas que toutes les connexions seront publiées immédiatement. Surtout lorsque plusieurs demandes sont exécutées en parallèle, l'arrêt des connexions et la libération des ressources peuvent être retardés. En effet, la bibliothèque Curl utilise un pool de connexions pour plusieurs demandes, et il n'efface pas toutes les connexions immédiatement jusqu'à ce que plusieurs demandes se terminent.
// Créer plusieurs cURL Session
$ch1 = curl_init('http://gitbox.net/example1');
$ch2 = curl_init('http://gitbox.net/example2');
$ch3 = curl_init('http://gitbox.net/example3');
// Définir les options de demande
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch3, CURLOPT_RETURNTRANSFER, true);
// Exécuter les résultats de la demande et de stockage
$response1 = curl_exec($ch1);
$response2 = curl_exec($ch2);
$response3 = curl_exec($ch3);
// 关闭Session
curl_close($ch1);
curl_close($ch2);
curl_close($ch3);
Dans le code ci-dessus, bien que nous appelions curl_close () pour fermer chaque session Curl, la fermeture de la connexion ne se produit pas immédiatement. Curl continue de maintenir la connexion en bas afin que certains processus intermédiaires de la demande soient traités jusqu'à ce que toutes les demandes soient remplies.
Curl Pour améliorer l'efficacité, un pool de connexion est maintenu, en particulier lorsque plusieurs demandes sont effectuées. Chaque fois qu'une demande est terminée, la connexion n'est pas fermée immédiatement, mais est retournée au pool de connexion pour la prochaine utilisation. Cette méthode de multiplexage de connexion améliore considérablement les performances des demandes car il n'est pas nécessaire de rétablir la connexion pour chaque demande.
Cependant, cette approche signifie également que bien que nous fermons certaines sessions Curl via Curl_close () , les connexions dans le pool de connexions peuvent être retardées pour nettoyer jusqu'à ce que toutes les demandes soient remplies, ou le Curl traite entièrement la séquence de demande actuelle.
Si vous devez vous assurer que toutes les connexions sont fermées à la fin, vous pouvez utiliser la fonction Curl_Multi_ * pour gérer plusieurs demandes parallèles. La série de fonctions CURL_MULTI_ * vous permet de gérer l'état d'exécution de plusieurs sessions Curl en parallèle, garantissant que toutes les demandes sont remplies avant de fermer la connexion. Comme indiqué ci-dessous:
// Créer plusieurs cURL Session
$ch1 = curl_init('http://gitbox.net/example1');
$ch2 = curl_init('http://gitbox.net/example2');
$ch3 = curl_init('http://gitbox.net/example3');
// Définir les options de demande
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch3, CURLOPT_RETURNTRANSFER, true);
// Créer uncURL多Session句柄
$mh = curl_multi_init();
// 将Session添加到多Session句柄中
curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);
curl_multi_add_handle($mh, $ch3);
// 执行多Session请求
do {
$status = curl_multi_exec($mh, $active);
if ($active) {
// Attendez que la demande se termine
curl_multi_select($mh);
}
} while ($active);
// 关闭所有Session
curl_multi_remove_handle($mh, $ch1);
curl_multi_remove_handle($mh, $ch2);
curl_multi_remove_handle($mh, $ch3);
curl_multi_close($mh);
curl_close($ch1);
curl_close($ch2);
curl_close($ch3);
Lorsque vous utilisez CURL_MULTI_ * , toutes les connexions seront complètement nettoyées et fermées une fois plusieurs sessions terminées, ce qui garantit que la connexion sous-jacente sera complètement publiée une fois toutes les demandes terminées.
Lorsque vous utilisez Curl pour effectuer plusieurs demandes en PHP, Curl_close () ne ferme pas immédiatement toutes les connexions, en particulier dans le cas des demandes parallèles. En effet, Curl utilise des pools de connexions pour multiplexer les connexions, améliorant les performances, de sorte que la fermeture des connexions peut être retardée. Pour vous assurer que toutes les connexions peuvent être publiées à temps, vous pouvez utiliser la fonction Curl_Multi_ * pour gérer les demandes parallèles, garantissant ainsi que toutes les connexions sont fermées une fois toutes les demandes terminées. Cette méthode résout non seulement le problème de la libération de connexion, mais améliore également l'efficacité de l'exécution des demandes.
