Français
Français
Lorsque vous utilisez CURL pour plusieurs demandes en PHP, la série de fonctions Curl_Multi_ * peut améliorer considérablement les performances du programme, en particulier dans le scénario des demandes simultanées. Cependant, de nombreux développeurs ont tendance à ignorer certains problèmes de gestion des erreurs et de libération des ressources clés lors de l'utilisation de ces fonctions, en particulier l'utilisation de curl_multi_close . Si curl_multi_close est appelé incorrectement, il peut entraîner une fuite de ressources, des problèmes de performances et même des problèmes de débordement de mémoire.
Cet article expliquera en détail comment utiliser correctement la fonction curl_multi_close lors de la gestion des erreurs pour éviter la fuite des ressources et d'autres problèmes potentiels.
La fonction CURL_MULTI_CLOSE est une fonction dans l'extension Curl PHP qui ferme toutes les poignées initialisées dans une session Curl multiple. La fonction Curl_Multi_ * permet de exécuter plusieurs demandes Curl en parallèle, tandis que CURL_MULTI_CLOSE est utilisé pour clôturer correctement chaque session Curl une fois toutes les demandes terminées pour libérer des ressources.
Lors de l'exécution de plusieurs demandes simultanées, nous devons utiliser CURL_MULTI_INIT pour initialiser une ressource multi-session, puis utiliser Curl_Multi_Add_Handle pour ajouter chaque session Curl individuelle à cette multi-session. Une fois la demande terminée, Curl_Multi_Close doit être appelé pour fermer la ressource multi-sessions.
Exemple de code:
// Combien d'initialisationcURLSession
$mh = curl_multi_init();
$ch1 = curl_init();
$ch2 = curl_init();
// installationcURLOptions
curl_setopt($ch1, CURLOPT_URL, "https://gitbox.net/api/endpoint1");
curl_setopt($ch2, CURLOPT_URL, "https://gitbox.net/api/endpoint2");
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
// 添加Session到多重Session资源中
curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);
// Effectuez plusieurs demandes
do {
$status = curl_multi_exec($mh, $active);
if ($active) {
// Attendez que la demande se termine
curl_multi_select($mh);
}
} while ($active && $status == CURLM_OK);
// Obtenir et traiter les données de retour
$response1 = curl_multi_getcontent($ch1);
$response2 = curl_multi_getcontent($ch2);
// fermeturecURLSession
curl_multi_remove_handle($mh, $ch1);
curl_multi_remove_handle($mh, $ch2);
// 最后fermeture多重cURLSession
curl_multi_close($mh);
La gestion des erreurs est une partie cruciale de plusieurs demandes. Lors de l'exécution de plusieurs demandes, diverses erreurs peuvent être rencontrées, notamment le délai d'expiration de connexion, la réponse non valide, l'erreur de serveur, etc. Pour éviter que la ressource ne soit publiée lorsqu'une erreur se produit, un coup de main peut être utilisé pour assurer des exceptions pour s'assurer que la ressource est correctement fermée, que la demande soit réussie ou non.
Exemple de code d'erreur:
try {
// Combien d'initialisationcURLSession
$mh = curl_multi_init();
$ch1 = curl_init();
$ch2 = curl_init();
// installationcURLOptions
curl_setopt($ch1, CURLOPT_URL, "https://gitbox.net/api/endpoint1");
curl_setopt($ch2, CURLOPT_URL, "https://gitbox.net/api/endpoint2");
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
// 添加Session到多重Session资源中
curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);
// Effectuez plusieurs demandes
do {
$status = curl_multi_exec($mh, $active);
if ($active) {
// Attendez que la demande se termine
curl_multi_select($mh);
}
} while ($active && $status == CURLM_OK);
// Vérifiez les résultats de chaque demande
if ($status != CURLM_OK) {
throw new Exception("cURLÉchec de la demande，Code d'erreur：" . $status);
}
// Obtenir et traiter les données de retour
$response1 = curl_multi_getcontent($ch1);
$response2 = curl_multi_getcontent($ch2);
// Traiter les données renvoyées ici...
} catch (Exception $e) {
// Partie de gestion des erreurs：Journal d'erreur de journal
error_log("Échec de la demande：" . $e->getMessage());
} finally {
// Assurez-vous qu'il y a des erreurs ou non，Les ressources seront publiées correctement
if (isset($mh)) {
// fermetureSession资源
if (isset($ch1)) {
curl_multi_remove_handle($mh, $ch1);
curl_close($ch1);
}
if (isset($ch2)) {
curl_multi_remove_handle($mh, $ch2);
curl_close($ch2);
}
curl_multi_close($mh);
}
}
Si CURL_MULTI_CLOSE n'est pas appelé une fois la demande terminée, la session PHP occupera les ressources système, entraînant des fuites de mémoire et des problèmes de performances. Dans le cas de plusieurs demandes, des poignées de boucle non clôturées peuvent s'accumuler au fil du temps, affectant la stabilité du programme et même provoquer le casque du processus. Par conséquent, il est crucial d'utiliser correctement Curl_Multi_Close .
Les fuites de ressources se produisent généralement dans les situations suivantes:
J'ai oublié d'appeler la fonction curl_multi_close .
Lorsqu'une erreur se produit, le programme ne parvient pas à entrer le bloc final pour libérer la ressource.
Dans une boucle ou une demande répétée, une nouvelle session est créée à plusieurs reprises, mais l'ancienne session n'est pas fermée.
La meilleure pratique pour éviter ces problèmes consiste à toujours utiliser la structure essai-capture-finale pour s'assurer que toutes les sessions peuvent être fermées correctement même s'il y a des erreurs.
Une utilisation appropriée de curl_multi_close est une étape critique pour éviter la fuite des ressources et d'autres problèmes de performances. Lorsque des demandes simultanées, nous devons toujours prêter attention à la gestion des erreurs et à la gestion des ressources. Assurer la libération correcte des ressources après chaque demande par le biais de la structure TRY-Patch-finalement assure la stabilité de l'application dans un environnement de concurrence élevé.
Dans le développement réel, nous devons toujours faire attention à gérer chaque session Curl pour éviter de manquer la fermeture des ressources en cas de défaillance de la demande ou d'autres erreurs. Ce n'est que de cette manière que nos multiples demandes de boucle peuvent être plus efficaces et stables, évitant les fuites de mémoire potentielles et les goulots d'étranglement de performances.
