Français
Français
Dans PHP, la série de fonctions Curl_Multi_ * offre la possibilité de des demandes simultanées asynchrones, qui sont généralement utilisées en conjonction avec Curl_Multi_Add_Handle et Curl_Multi_Exec . Lorsque vous utilisez CURL_MULTI_ADD_HANDLE pour ajouter plusieurs poignées Curl à plusieurs poignées, Curl_Multi_Remove_Handle peut supprimer chaque poignée de la poignée multiple une fois la demande terminée.
$multiCurl = curl_multi_init();
$curlHandles = [];
// Ajouter plusieurscurlManipulermultiDans la poignée
for ($i = 0; $i < 5; $i++) {
$curlHandles[$i] = curl_init("http://gitbox.net/api/data$i");
curl_multi_add_handle($multiCurl, $curlHandles[$i]);
}
// Exécuter une demande
do {
$status = curl_multi_exec($multiCurl, $active);
} while ($active);
// Retirez chaque poignée
foreach ($curlHandles as $ch) {
curl_multi_remove_handle($multiCurl, $ch);
curl_close($ch);
}
curl_multi_close($multiCurl);
Dans le code ci-dessus, nous supprimons chaque poignée CURL via Curl_Multi_Remove_Handle . Bien qu'il garantit que les ressources sont correctement publiées, les appels fréquents vers Curl_Multi_Remove_Handle dans une boucle peuvent entraîner des frais généraux de performances, en particulier lorsque le nombre de demandes est élevé.
Lors de l'appel Curl_Multi_Remove_Handle , PHP doit mettre à jour l'état de la manche multiple en bas. Il s'agit d'une opération relativement longue, en particulier lorsque le nombre de demandes simultanées est importante. Lorsque chaque demande est terminée, la poignée est supprimée, PHP doit traiter et mettre à jour les informations d'état du multi-thread. La suppression fréquente des poignées peut entraîner les problèmes de performance suivants:
Gestion fréquente de la mémoire : lors de la suppression des poignées, le mécanisme de gestion de la mémoire sous-jacent doit réaffecter les ressources, ce qui entraîne des frais généraux d'allocation et de libération de la mémoire.
Synchronisation de verrouillage et de thread : Curl_Multi_Remove_Handle impliquera des opérations de verrouillage de filetage lors de la demande en parallèle. Les appels fréquents peuvent conduire à la concurrence de verrouillage, ce qui réduit encore l'efficacité de l'exécution.
Complexité de la pile d'appels : chaque appel augmente la profondeur de la pile, en particulier dans une concurrence élevée, où l'augmentation de la pile d'appels peut affecter les performances globales.
Par conséquent, l'optimisation de ces opérations est très importante pour améliorer les performances, en particulier lorsque des demandes simultanées fréquentes sont nécessaires.
Au lieu d'appeler Curl_Multi_Remove_Handle immédiatement après la fin de chaque demande, nous pouvons retirer la poignée uniformément une fois toutes les demandes terminées. Cela peut éviter les mises à jour fréquentes de ressources et réduire les pertes de performances.
$multiCurl = curl_multi_init();
$curlHandles = [];
// Ajouter plusieurscurlPoignée
for ($i = 0; $i < 5; $i++) {
$curlHandles[$i] = curl_init("http://gitbox.net/api/data$i");
curl_multi_add_handle($multiCurl, $curlHandles[$i]);
}
// Effectuer des demandes simultanées
do {
$status = curl_multi_exec($multiCurl, $active);
} while ($active);
// 统一移除所有Poignée
foreach ($curlHandles as $ch) {
curl_multi_remove_handle($multiCurl, $ch);
curl_close($ch);
}
curl_multi_close($multiCurl);
En supprimant les poignées uniformément une fois toutes les demandes terminées, les opérations intermédiaires inutiles peuvent être réduites et les performances peuvent être améliorées.
Dans certains scénarios, nous pouvons réduire le nombre d'appels à curl_multi_remove_handle en ajustant le nombre de demandes simultanées. Par exemple, le traitement par lots de toutes les demandes, puis retirez uniformément la poignée en fonction de l'achèvement par lots.
$multiCurl = curl_multi_init();
$curlHandles = [];
// Supposer un traitement10Une demande
$batchSize = 10;
for ($i = 0; $i < 100; $i++) {
$curlHandles[$i] = curl_init("http://gitbox.net/api/data$i");
curl_multi_add_handle($multiCurl, $curlHandles[$i]);
if (count($curlHandles) == $batchSize) {
// Effectuer des demandes simultanées
do {
$status = curl_multi_exec($multiCurl, $active);
} while ($active);
// 统一移除当前批次的所有Poignée
foreach ($curlHandles as $ch) {
curl_multi_remove_handle($multiCurl, $ch);
curl_close($ch);
}
// 清空当前批次的Poignée数组
$curlHandles = [];
}
}
// S'il reste des demandes，Continuer à traiter
if (count($curlHandles) > 0) {
do {
$status = curl_multi_exec($multiCurl, $active);
} while ($active);
// 统一移除剩余Poignée
foreach ($curlHandles as $ch) {
curl_multi_remove_handle($multiCurl, $ch);
curl_close($ch);
}
}
curl_multi_close($multiCurl);
Par traitement par lots des demandes, le nombre d'appels de curl_multi_remove_handle peut être considérablement réduit, améliorant ainsi les performances.
Dans certains cas, si vous effectuez les mêmes appels API fréquemment, vous pourriez envisager d'activer les connexions persistantes HTTP (Keep-Alive). Cela fait que Curl demande à plusieurs fois sur la même connexion, plutôt que d'établir une nouvelle connexion à chaque fois, réduisant beaucoup de frais de connexion et des appels fréquents à curl_multi_remove_handle .
Vous pouvez désactiver la réutilisation de la connexion en définissant Curlopt_forbid_reuse à TRUE pour vous assurer qu'une nouvelle connexion est utilisée pour chaque demande. Garder le multiplexage des connexions améliore généralement les performances sans besoins spéciaux.
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Connection: keep-alive',
]);
En persistant les connexions, la fréquence de création et de destruction des connexions est réduite, améliorant ainsi les performances.
Si votre volume de demande est très important, PHP Curl n'est peut-être pas le meilleur choix. Dans ce cas, envisagez d'utiliser des méthodes de demande simultanées plus avancées, telles que l'utilisation de clients HTTP modernes tels que Guzzle , qui ont généralement une meilleure gestion des performances et de la mémoire lors de la gestion des demandes très simultanées.
