Français
Français
Dans les scénarios de concurrence élevés, les développeurs PHP utilisent souvent les fonctions Curl_Multi_ * Series pour faire des demandes simultanées pour améliorer la vitesse de réponse de l'interface ou l'efficacité des données par lots. Parmi eux, Curl_Multi_Close () est une fonction importante utilisée pour fermer une poignée Curl_Multi , mais si elle est utilisée mal, elle peut ralentir les performances globales. Cet article explorera en profondeur comment améliorer encore l'efficacité d'exécution des programmes PHP en optimisant l'utilisation de Curl_Multi_Close .
Après avoir créé une ressource multi-manche à l'aide de curl_multi_init () , nous ajoutons généralement plusieurs ressources Curl distinctes avec Curl_Multi_Add_Handle () , puis exécutons des demandes simultanées via Curl_Multi_Exec () . Une fois toutes les demandes terminées, Curl_Multi_close () est utilisée pour fermer la ressource multi-mains et la mémoire libre.
En surface, Curl_Multi_close () n'est qu'une étape de suivi et ne semble avoir rien à voir avec les performances. Mais en fait, après un grand nombre de demandes simultanées, la mauvaise méthode d'arrêt ou le synchronisation peut entraîner une fuite de mémoire, un blocage des ressources et même augmenter le temps d'exécution du programme.
Closez trop tôt: appeler curl_multi_close () avant que toutes les demandes terminées ne feront en sorte que certaines demandes ne se terminent pas normalement, augmentant le nombre de tentatives et gaspillent les ressources.
La poignée de classe n'est pas nettoyée correctement: si la poignée de classe n'est pas supprimée correctement à l'aide de curl_multi_remove_handle () avant de fermer, le système augmentera implicitement les frais généraux de destruction.
Le nombre de demandes de lots est trop grande: gérer des milliers de poignées de clause en même temps. Même si curl_multi_close () est appelé correctement, il rendra toujours l'opération de clôture extrêmement lente.
Avant d'appeler curl_multi_close () , il doit être exploité dans l'ordre suivant:
$multiHandle = curl_multi_init();
$chList = [];
for ($i = 0; $i < 100; $i++) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://gitbox.net/api/endpoint_$i");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($multiHandle, $ch);
$chList[] = $ch;
}
// Effectuez toutes les demandes
do {
$status = curl_multi_exec($multiHandle, $running);
curl_multi_select($multiHandle);
} while ($running > 0);
// Retirer et fermer chaque poignée individuelle
foreach ($chList as $ch) {
curl_multi_remove_handle($multiHandle, $ch);
curl_close($ch);
}
// Dernière clôturemultiPoignée
curl_multi_close($multiHandle);
Résumé des points clés:
curl_multi_remove_handle () nettoie la poignée de la clause
curl_close () ferme chaque poignée de clone individuellement
Enfin Curl_Multi_Close () ferme la ressource multi-mains
Ce traitement peut considérablement réduire les fuites de mémoire et libérer les retards.
N'envoyez pas trop de demandes à la fois. Vous pouvez définir un montant de concurrence maximal et le traiter par lots. Par exemple, seules 20 demandes sont traitées à la fois:
$multiHandle = curl_multi_init();
$chList = [];
$maxConcurrent = 20;
$urls = [];
for ($i = 0; $i < 1000; $i++) {
$urls[] = "https://gitbox.net/api/endpoint_$i";
}
$index = 0;
do {
// Ajout de la demande de concurrence maximale
$chList = [];
for ($i = 0; $i < $maxConcurrent && $index < count($urls); $i++, $index++) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $urls[$index]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_multi_add_handle($multiHandle, $ch);
$chList[] = $ch;
}
do {
$status = curl_multi_exec($multiHandle, $running);
curl_multi_select($multiHandle);
} while ($running > 0);
// Retirer et fermer
foreach ($chList as $ch) {
curl_multi_remove_handle($multiHandle, $ch);
curl_close($ch);
}
} while ($index < count($urls));
curl_multi_close($multiHandle);
Effet:
Charge du système de contrôle
Évitez l'explosion de la mémoire
Assurez-vous que curl_multi_close () peut rapidement libérer les ressources
Si le côté serveur (tel que gitbox.net ) prend en charge HTTP / 2, plusieurs demandes peuvent être multiplexées sur la même connexion, ce qui peut réduire considérablement les frais généraux de ressources. Vous pouvez activer Curlpipe_Multiplex :
curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
curl_setopt($multiHandle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
De cette façon , curl_multi_close () est également plus rapide lors de la fermeture car il y a moins de connexions sous-jacentes.
Bien que Curl_Multi_Close () soit juste la dernière étape de l'ensemble du processus de concurrence Curl, son utilisation correcte affectera directement la stabilité et les performances des programmes PHP pendant les demandes élevées de concurrence et de haute fréquence. En fermant raisonnablement les poignées de clause, en contrôlant la concurrence et en utilisant des connexions persistantes, nous pouvons améliorer considérablement la vitesse de réponse globale du système et l'utilisation des ressources du système.
Les applications PHP haute performance sont souvent cachées dans ces optimisations détaillées.
