Français
Français
La fonction curl_share_init () est utilisée pour créer une poignée Curl pour une ressource partagée. Grâce à cette poignée de ressources partagées, plusieurs séances de boucle (c'est-à-dire plusieurs poignées de boucle) peuvent partager les mêmes ressources, telles que les cookies, le cache de requête DNS, etc. L'objectif principal de ce mécanisme est d'éviter les demandes de réseau en double, telles que la requête DNS, la livraison de cookies et d'autres opérations, ainsi améliorant ainsi l'efficacité des demandes concurrentes.
Lorsque vous utilisez plusieurs sessions CURL, chaque session peut avoir besoin de réinsonner le nom de domaine et d'obtenir des cookies et d'autres ressources. En partageant des ressources, ces opérations redondantes peuvent être évitées.
Grâce à la fonction curl_share_init () , certaines ressources sous-jacentes peuvent être partagées entre les sessions Curl, qui peuvent réduire le travail en double entre plusieurs demandes. De nombreuses opérations dans les demandes HTTP (telles que les requêtes DNS, les cookies, etc.) sont partagées lors de la réalisation de demandes multithread, et l'utilisation de ressources partagées réduira considérablement les frais généraux de ces opérations.
Supposons que vous fassiez plusieurs demandes simultanées et que chaque demande nécessite une requête DNS indépendante, une économie de cookies et d'autres opérations, ces opérations elles-mêmes entraîneront certaines frais généraux de performance. Si ces opérations peuvent être partagées entre les différentes demandes, l'efficacité de l'exécution de la demande peut être considérablement améliorée et la consommation de temps par demande peut être réduite.
Ce qui suit est un exemple simple utilisant la fonction curl_share_init () , montrant comment améliorer les performances des demandes multithread PHP en partageant des ressources.
<?php
// Initialiser les ressources partagées
$ch_share = curl_share_init();
curl_share_setopt($ch_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
curl_share_setopt($ch_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
// Mettre en place des demandes simultanées URL Liste
$urls = [
'http://m66.net/api/data1',
'http://m66.net/api/data2',
'http://m66.net/api/data3',
];
// Créer plusieurs cURL Poignée
$multi_handle = curl_multi_init();
$curl_handles = [];
foreach ($urls as $url) {
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SHARE, $ch_share); // En utilisant des ressources partagées
curl_multi_add_handle($multi_handle, $ch);
$curl_handles[] = $ch;
}
// Effectuer des demandes simultanées
$running = null;
do {
curl_multi_exec($multi_handle, $running);
curl_multi_select($multi_handle);
} while ($running > 0);
// Obtenir et sortir le résultat de la demande
foreach ($curl_handles as $ch) {
$response = curl_multi_getcontent($ch);
echo $response . "\n";
curl_multi_remove_handle($multi_handle, $ch);
}
// Fermez la ressource
curl_multi_close($multi_handle);
curl_share_close($ch_share);
?>
Initialisation des ressources partagées : Tout d'abord, créez une poignée de ressources partagée $ ch_share via curl_share_init () . Ensuite, nous définissons le type de ressources partagées via curl_share_setopt () et spécifions les ressources à partager, telles que les cookies et les données DNS.
Configuration de la liste des URL pour les demandes simultanées : nous définissons un tableau d'URL représentant plusieurs URL à demander simultanément.
Créer une poignée Curl : pour chaque URL, nous créons une poignée Curl et définissons l'option Curlopt_share sur la poignée de ressource partagée précédemment créée $ ch_share .
Demande d'exécution simultanée : nous utilisons Curl_Multi_Init () pour créer une ressource Curl à plusieurs manchettes $ Multi_Handle et ajouter plusieurs poignées Curl à la ressource. Les demandes simultanées sont exécutées via curl_multi_exec () jusqu'à ce que toutes les demandes soient remplies.
Obtenez et sortiz le résultat : obtenez le résultat de retour de chaque demande via Curl_Multi_getContent () et sortez-le.
Fermer la ressource : après avoir terminé la demande, utilisez Curl_Multi_Close () pour fermer la ressource multi-mains et enfin fermer la poignée de ressource partagée via Curl_share_close () .
En utilisant curl_share_init () , nous évitons les requêtes et cookies DNS indépendants pour chaque demande. L'effet d'amélioration des performances spécifique doit être mesuré en fonction de différents environnements de réseau et du nombre de demandes. Dans le cas d'un grand nombre de demandes simultanées, la réduction des requêtes DNS en double et du chargement des ressources peut améliorer considérablement les performances globales de la demande.
Cependant, curl_share_init () ne fonctionne pas pour tous les scénarios. Si le contenu demandé est complètement différent et que chaque ressource demandée doit être traitée de manière indépendante, l'utilisation de ressources partagées peut ne pas entraîner une amélioration significative des performances. L'utilisation d'une ressource Curl partagée ne fonctionne que si plusieurs demandes nécessitent du partage de certaines ressources.
La fonction curl_share_init () offre des améliorations de performances dans les demandes multithread, en particulier lorsqu'elle implique des ressources partagées (telles que les cookies, les caches DNS, etc.). En utilisant rationnellement les ressources partagées, nous pouvons réduire les opérations en double et optimiser l'efficacité des demandes simultanées. Cependant, l'utilisation de curl_share_init () peut entraîner des améliorations de performances significatives dans les situations où des ressources partagées ne sont pas nécessaires. Par conséquent, la question de savoir si l'utilisation de cette fonction doit être déterminée en fonction des exigences et des scénarios spécifiques.
