Français
Français
Dans les demandes de réseau PHP, Curl est l'un des outils les plus couramment utilisés. Surtout lors de la gestion des demandes HTTP simultanées élevées, l'utilisation rationnelle des fonctions liées à Curl est directement liée à la stabilité et à l'utilisation des ressources du système. Cet article se concentrera sur la fonction curl_close () pour discuter de son utilisation correcte dans des scénarios de concurrence élevés, ainsi que sur les problèmes de déchets de ressources qui peuvent être causés par une utilisation incorrecte.
Curl est une bibliothèque de demandes de réseau puissante fournie par PHP et peut être utilisée pour lancer des demandes HTTP / HTTPS. Le processus d'utilisation est à peu près le suivant:
Initialisation: curl_init ()
Définir les paramètres: curl_setopt ()
Exécuter la demande: curl_exec ()
Fermez la ressource: curl_close ()
Habituellement, les développeurs appellent curl_close () après chaque demande de libération de ressources. Cette habitude n'est pas une grosse affaire dans les scripts à faible monnaie ou à court terme, mais dans les services à haute monnaie ou à long terme, les pièges à performance peuvent être cachés.
Lorsque PHP utilise Curl et active des paramètres tels que Curl_share ou Curlopt_Forbid_reuse , la bibliothèque Libcurl sous-jacente essaie de réutiliser les connexions existantes (c'est-à-dire les pools de connexion). Le multiplexage des connexions peut réduire considérablement les frais généraux tels que le bâtiment de connexion TCP et la poignée de main TLS, et améliorer l'efficacité de la demande.
Mais le problème est que chaque fois que Curl_close () est appelé, les informations de connexion correspondant à la poignée actuelle seront détruites. Même si la connexion sous-jacente n'a pas épuisé la valeur de réutilisation, elle sera forcée d'être déconnectée, ce qui entraînera un pool de connexion invalide et le gaspillage de ressources.
function fetchData($url) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch); // Détruisez la connexion à chaque fois
return $response;
}
$data = fetchData("https://gitbox.net/api/data");
Dans une concurrence élevée, ce modèle établira une nouvelle connexion à chaque fois, mettant une grande pression du côté serveur et augmentant la consommation locale de ressources.
Dans les demandes par lots, vous pouvez réutiliser une poignée de boucle et mettre à jour uniquement l'URL et les paramètres de demande.
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$urls = [
"https://gitbox.net/api/user",
"https://gitbox.net/api/data",
"https://gitbox.net/api/config"
];
foreach ($urls as $url) {
curl_setopt($ch, CURLOPT_URL, $url);
$response = curl_exec($ch);
// traiter avec $response
}
curl_close($ch); // Enfin, clôture unifiée
Cette approche réduit considérablement la fréquence d'établissement et de fermeture de connexion et convient à plusieurs demandes similaires dans le même cycle de vie.
Pour les demandes simultanées, il est recommandé d'utiliser CURL_MULTI_INIT () pour gérer plusieurs poignées, puis les fermer uniformément après l'exécution.
$multi = curl_multi_init();
$chs = [];
$urls = [
"https://gitbox.net/api/user",
"https://gitbox.net/api/data",
"https://gitbox.net/api/config"
];
foreach ($urls as $i => $url) {
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($multi, $ch);
$chs[$i] = $ch;
}
$running = null;
do {
curl_multi_exec($multi, $running);
curl_multi_select($multi);
} while ($running > 0);
foreach ($chs as $ch) {
$content = curl_multi_getcontent($ch);
// traiter avec $content
curl_multi_remove_handle($multi, $ch);
curl_close($ch);
}
curl_multi_close($multi);
Cette méthode peut utiliser pleinement la capacité de multiplexage du pool de connexions et est très pratique dans les scénarios de demande d'interface simultanés élevés.
Assurez-vous d'utiliser le protocole HTTP Keep-Alive;
Pour les noms de domaine fréquemment demandés, le cache DNS ou la connexion directe IP doit être considéré;
Utilisez raisonnablement Curlopt_timeout pour éviter les connexions mortes;
Dans un environnement PHP-FPM, en évitant de reconstruire toutes les configurations de boucle par demande, en multiplexant l'encapsulation logique commune.
Dans les applications PHP à haute concurrence, Curl_close () n'est pas un outil "Close-Off". Comprendre son comportement sous-jacent et son mécanisme de réutilisation de connexion aidera les développeurs à écrire une logique de communication réseau plus efficace et stable. En multiplexant les poignées ou en utilisant Curl_Multi , vous pouvez non seulement économiser des ressources, mais aussi améliorer considérablement les performances de la demande.
La gestion rationnelle du cycle de vie de la connexion est une étape clé pour améliorer le débit du système. J'espère que cet article vous inspirera à optimiser dans les projets réels.
