Français
Français
Lors de la réalisation de demandes de réseau efficaces dans PHP, nous devons souvent utiliser Curl pour lancer des demandes HTTP. Cependant, lorsque certaines ressources (telles que les cookies, les descripteurs de fichiers, etc.) doivent être partagées entre plusieurs demandes de curl, les demandes de boucle traditionnelles peuvent rencontrer des problèmes de concurrence et de synchronisation des ressources. Pour résoudre ce problème, PHP fournit la fonction Curl_Share_Init , qui nous aide à partager des ressources entre plusieurs poignées Curl. Cet article explorera en profondeur comment utiliser Curl_share_init pour réaliser une synchronisation des ressources partagées dans plusieurs sous-processus PHP.
CURL_SHARE_INIT est une fonction de PHP pour créer des poignées de boucle partagées. Il peut aider plusieurs demandes de curl pour partager des ressources. Les ressources partagées peuvent être des cookies, des descripteurs de fichiers, des caches DNS, etc. L'utilisation de ressources partagées peut empêcher chaque demande de boucle de charger à plusieurs reprises les mêmes informations, améliorant ainsi l'efficacité du programme.
Les ressources partagées en curl sont très utiles dans les scénarios de concurrence élevés. Par exemple, si plusieurs demandes de curl nécessitent tous l'accès au même site Web, ils peuvent simuler l'état de la session de plusieurs demandes en partageant des cookies, en évitant de recueillir des informations de connexion à chaque fois qu'ils demandent. De plus, l'utilisation de caches DNS partagées peut réduire les requêtes DNS fréquentes et améliorer les performances.
CURL_SHARE_INIT est utilisé pour créer une poignée de ressources partagée qui peut ensuite être associée à plusieurs poignées Curl. Les étapes de base à utiliser sont les suivantes:
Utilisez CURL_SHARE_INIT pour créer une poignée partagée.
Configurez une poignée partagée pour partager des ressources spécifiques (telles que les cookies, le DNS, les descripteurs de fichiers, etc.).
Associez une poignée partagée à plusieurs demandes de curl.
Effectuez les demandes de curl et assurez-vous de partager des ressources.
Enfin, relâchez la poignée partagée et la poignée Curl.
<?php
// Initialiser la poignée partagée
$share = curl_share_init();
// Configurer les ressources partagées（Par exemple cookies）
curl_share_setopt($share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
// Créer plusieurs cURL Poignée
$curl1 = curl_init('http://m66.net/api/endpoint1');
$curl2 = curl_init('http://m66.net/api/endpoint2');
// 将共享Poignée与 cURL Poignée关联
curl_setopt($curl1, CURLOPT_SHARE, $share);
curl_setopt($curl2, CURLOPT_SHARE, $share);
// Mettre en place d'autres cURL Options
curl_setopt($curl1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl2, CURLOPT_RETURNTRANSFER, true);
// Exécuter une demande
$response1 = curl_exec($curl1);
$response2 = curl_exec($curl2);
// Résultat de sortie
echo "Response 1: " . $response1 . "\n";
echo "Response 2: " . $response2 . "\n";
// Libérer les ressources
curl_share_close($share);
curl_close($curl1);
curl_close($curl2);
?>
Dans le code ci-dessus, nous créons d'abord une poignée partagée avec Curl_Share_Init $ Share , puis utilisons Curl_share_Setopt pour configurer la poignée partagée pour partager les données de cookies. Ensuite, nous créons deux poignées Curl $ curl1 et $ curl2 et associons les poignées partagées via l'option curlopt_share . Après avoir exécuté la demande, nous avons fermé la poignée Curl et la poignée partagée.
Dans un environnement multi-processus, en particulier lorsque vous utilisez PHP PCNTL_FORK pour créer plusieurs processus enfants, nous pouvons également utiliser Curl_share_init pour partager des ressources. Chaque processus d'enfant peut partager la même ressource, évitant ainsi l'initialisation des ressources en double et l'activation de la synchronisation des ressources.
<?php
// Initialiser la poignée partagée
$share = curl_share_init();
curl_share_setopt($share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
// créer cURL Poignée
$curl1 = curl_init('http://m66.net/api/endpoint1');
$curl2 = curl_init('http://m66.net/api/endpoint2');
// 将共享Poignée与 cURL Poignée关联
curl_setopt($curl1, CURLOPT_SHARE, $share);
curl_setopt($curl2, CURLOPT_SHARE, $share);
// créerSous-processus
$pid = pcntl_fork();
if ($pid == -1) {
// Gestion des erreurs
die("Fork failed!");
} elseif ($pid == 0) {
// Sous-processus 1
curl_setopt($curl1, CURLOPT_RETURNTRANSFER, true);
$response1 = curl_exec($curl1);
echo "Child Process 1 Response: " . $response1 . "\n";
curl_close($curl1);
} else {
// Processus principal
curl_setopt($curl2, CURLOPT_RETURNTRANSFER, true);
$response2 = curl_exec($curl2);
echo "Parent Process Response: " . $response2 . "\n";
curl_close($curl2);
// 等待Sous-processus结束
pcntl_wait($status);
}
// Libérer les ressources partagées
curl_share_close($share);
?>
Dans cet exemple, nous créons d'abord une poignée de ressources partagée $ partage et définissons des cookies partagés. Ensuite, nous avons créé un processus d'enfant à l'aide de pcntl_fork . Dans le processus enfant, nous exécutons une demande de curl indépendamment, tandis que le processus principal exécute une autre demande. Grâce à des ressources partagées, le processus principal et le processus enfant peuvent éviter le chargement en double des ressources.
Dans un environnement multi-processus, chaque processus copiera le descripteur de fichiers du processus parent et les ressources partagées pour s'assurer que chaque processus s'exécute indépendamment et que l'accès aux ressources partagées est synchronisée.
Lorsque vous utilisez CURL_SHARE_INIT , assurez-vous de fermer la poignée partagée une fois la demande terminée pour libérer la ressource.
Les threads ne sont pas directement pris en charge en PHP, de sorte que les multi-processus sont un moyen courant de réaliser la concurrence. Lorsque vous traitez avec une concurrence à grande échelle, vous pouvez envisager de combiner PCNTL_FORK et CURL_SHARE_INIT pour améliorer les performances.
En utilisant CURL_SHARE_INIT , nous pouvons synchroniser les ressources partagées dans plusieurs processus d'enfants PHP. Ceci est très utile pour améliorer les performances des demandes de réseau et réduire le chargement en double des ressources. En particulier dans un environnement de concurrence élevé, l'utilisation rationnelle des ressources partagées peut réduire efficacement les frais généraux inutiles et améliorer l'efficacité du système. En combinant PCNTL_FORK et CURL pour partager des ressources, nous pouvons mieux faire face aux demandes simultanées complexes et aux problèmes de partage des ressources.
