Français
Français
La fonction Curl_Multi_ * dans PHP est généralement utilisée pour effectuer plusieurs demandes HTTP simultanées, en particulier pour les scénarios de concurrence élevés. curl_multi_close est une fonction utilisée pour fermer toutes les multiples poignées Curl initialisées par curl_multi_init () . Bien qu'il soit très efficace dans de nombreux scénarios, deviendra-t-il un goulot d'étranglement des performances dans des environnements de concurrence élevés? Cet article analysera le principe de travail de Curl_Multi_Close en profondeur, discutera des problèmes de performance qu'il peut apporter et donnent des suggestions d'optimisation pertinentes.
La série de fonctions Curl_Multi_ * fournit un mécanisme qui permet à PHP de gérer plusieurs demandes HTTP en même temps. Les étapes courantes à utiliser comprennent:
curl_multi_init () : initialisez une poignée de boucle multiple.
curl_multi_add_handle () : ajoutez plusieurs poignées de curl à plusieurs poignées de curl.
curl_multi_exec () : exécute toutes les demandes de curl.
curl_multi_getContent () : Obtenez le contenu de la réponse de la demande.
curl_multi_close () : ferme toutes les poignées Curl ajoutées à plusieurs poignées.
La fonction de curl_multi_close est de fermer toutes les poignées Curl et de libérer les ressources correspondantes. Cette fonction doit être appelée une fois toutes les demandes terminées et que les données pertinentes ont été récupérées.
Cependant, dans des environnements de concurrence élevés, en particulier lors du traitement des centaines de milliers de demandes, l'exécution de Curl_Multi_Close peut devenir un goulot d'étranglement des performances. Pourquoi? Jetons un look plus profond.
Dans des environnements de concurrence élevés, Curl_Multi_Close doit fermer toutes les manches Curl une par une, ce qui peut impliquer un grand nombre d'opérations de libération de mémoire. Pour chaque demande, Curl allouera une certaine quantité de mémoire pour stocker les informations de connexion, les données de demande, les données de réponse, etc. Lorsque le nombre de demandes est très important, Curl_Multi_Close doit libérer ces ressources de mémoire une par une, ce qui peut entraîner une fragmentation de la mémoire et consommer une grande quantité de ressources CPU pour le nettoyage, affectant les performances globales du programme.
Curl utilise le pool de connexions réseau du système d'exploitation, de sorte que chaque demande Curl est réellement implémentée via la connexion réseau sous-jacente du système. Lorsque un grand nombre de demandes sont remplies, l'appel à Curl_Multi_Close entraînera la fermeture d'un grand nombre de connexions réseau, ce qui prendra également un certain temps. Si le volume de demande est très important, le processus de fermeture de la connexion peut entraîner des retards, affectant le temps de réponse du système.
Bien que PHP lui-même soit unique, Curl s'appuie sur les threads du système d'exploitation pour la gestion lors de la réalisation de plusieurs demandes simultanées. Dans les scénarios de concurrence élevés, Curl_Multi_Exec () commencera plusieurs threads pour traiter la demande, tandis que Curl_Multi_Close doit attendre que tous les threads se terminent avant de fermer toutes les poignées. Si certaines demandes répondent plus longtemps, Curl_Multi_Close sera bloquée, entraînant une dégradation des performances.
Afin d'éviter Curl_Multi_Close de devenir un goulot d'étranglement des performances, nous pouvons prendre les mesures d'optimisation suivantes:
Essayez d'éviter de lancer trop de demandes simultanées à la fois et utilisez un mécanisme similaire à un pool de demandes pour exécuter les demandes par lots. Par exemple, vous pouvez utiliser la fonction Curl_Multi_Select de PHP pour contrôler le nombre maximal de concurrences demandées.
$multiHandle = curl_multi_init();
$handles = [];
for ($i = 0; $i < 1000; $i++) {
$url = "https://gitbox.net/api/v1/data/{$i}";
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($multiHandle, $ch);
$handles[] = $ch;
}
$active = null;
do {
$mrc = curl_multi_exec($multiHandle, $active);
if ($active) {
curl_multi_select($multiHandle);
}
} while ($active && $mrc == CURLM_OK);
// Fermez toutes les poignées
foreach ($handles as $ch) {
curl_multi_remove_handle($multiHandle, $ch);
curl_close($ch);
}
curl_multi_close($multiHandle);
Pour éviter le blocage de la demande trop longtemps, nous pouvons définir un délai d'expiration approprié pour chaque demande afin que si une demande répond trop lentement, nous pouvons le fermer à temps et continuer à traiter d'autres demandes. Les paramètres de délai d'expiration appropriés peuvent réduire les déchets des ressources système.
curl_setopt($ch, CURLOPT_TIMEOUT, 10); // Définissez le délai d'expiration de la demande à10Deuxième
Pour les scénarios où un grand nombre de demandes répétées pour le même nom de domaine, les techniques de connexion persistante et de mise en commun de connexion peuvent être prises en compte. Curl fournit l'option Curlopt_forbid_reuse pour empêcher le multiplexage des connexions, réduisant ainsi la surcharge de plusieurs connexions.
curl_setopt($ch, CURLOPT_FORBID_REUSE, true); // Désactiver la réutilisation des connexions
Assurez-vous que le serveur peut gérer un grand nombre de connexions simultanées et peut optimiser les performances en augmentant le temps d'exécution maximum de PHP, en ajustant les limites de poignée de fichier du système d'exploitation, etc.
Dans des environnements de concurrence élevés, Curl_Multi_Close peut en effet devenir un goulot d'étranglement des performances, en particulier lorsque le nombre de demandes est très important, le processus de libération des ressources et l'arrêt de la connexion peut apporter la latence et la dégradation des performances. Cependant, en contrôlant raisonnablement le nombre de concurrenances, en optimisant les délais de demande, en utilisant les pools de connexion, etc., les performances du système peuvent être considérablement améliorées et Curl_Multi_Close peut être évité comme un goulot d'étranglement.
