Français
Français
Lorsque vous utilisez la fonction de poignée partagée Curl ( curl_share_init () ) dans PHP, si le développeur ne publie pas correctement les ressources partagées, il est très susceptible de provoquer des problèmes de fuite des ressources, ce qui affectera les performances du serveur et même la stabilité. Cet article se concentrera sur l'utilisation correcte de curl_share_init () et curl_share_close () pour aider les développeurs à éviter les risques potentiels.
curl_share_init () est une fonction fournie par PHP pour initialiser une poignée de partage de curl. Cette poignée peut être utilisée pour partager des informations telles que les caches DNS, les cookies et plus entre plusieurs sessions de boucle pour améliorer les performances et la réutilisation des ressources.
Un processus typique d'utilisation d'une poignée partagée est la suivante:
$sh = curl_share_init();
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
La poignée partagée peut ensuite être associée à plusieurs demandes de curl via curl_setopt () :
$ch = curl_init('https://www.m66.net/api/data');
curl_setopt($ch, CURLOPT_SHARE, $sh);
curl_exec($ch);
curl_close($ch);
Le problème est que de nombreux développeurs oublient d'appeler curl_share_close () pour libérer des ressources après avoir terminé l'utilisation de poignées partagées.
// Exemple d'erreur：Poignée partagée non fermée
$sh = curl_share_init();
// ... Une série d'opérations
// oublier curl_share_close($sh);
Cette négligence entraînera l'utilisation continue des ressources à l'intérieur du serveur (comme la mémoire, le cache DNS, etc.), qui peut éventuellement déclencher un avertissement de "fuite de mémoire", une dégradation des performances et même terminer avec force le travailleur PHP-FPM par le système d'exploitation.
Vous devez toujours appeler curl_share_close () pour libérer la ressource après l'utilisation de la poignée partagée:
$sh = curl_share_init();
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
// Effectuez plusieurs demandes
foreach ($urls as $url) {
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_SHARE, $sh);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
}
curl_share_close($sh); // Libérer les ressources partagées
Ceci est similaire à la curl_close normale () , la clé est que les développeurs ne peuvent pas manquer la libération de poignées partagées.
La poignée partagée Curl est conçue pour être un seul processus et ne peut pas être partagée entre plusieurs threads ou plusieurs processus. Cela signifie que dans le modèle multi-processus PHP-FPM, chaque processus d'enfant doit gérer sa propre poignée partagée.
Une fois qu'une poignée partagée est associée à une demande de boucle, ses options de partage ne peuvent pas être modifiées, sinon une exception à l'état interne peut être augmentée. Par exemple:
$sh = curl_share_init();
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
// Le définir avant l'association est correcte，Ne le modifiez pas plus tard
Le cache DNS partagé peut rendre le résultat de la résolution "périmé". Un TTL raisonnable doit être défini en fonction des besoins réels, et le cache doit être nettoyé régulièrement ou les poignées partagées doivent être réinitialisées.
Lors de l'encapsulation des classes de demande HTTP, un pool de poignées partagé est introduit et publié uniformément dans les fonctions de destructeur de classe ou d'arrêt;
Combiné avec registre_shutdown_function () Enregistrement et logique de nettoyage;
Utilisez le partage pour ajouter des journaux ou déboguer des informations pour vous assurer qu'aucune ressource suspendue n'est publiée;
Pour les environnements de concurrence élevés, il est recommandé d'évaluer si les améliorations des performances du partage sont significatives, sinon il est plus facile et plus sûr d'utiliser la poignée par défaut.
curl_share_init () est un outil important pour améliorer les performances de Curl, mais il s'accompagne également de la responsabilité de la gestion des ressources. Les développeurs doivent toujours appeler curl_share_close () une fois l'utilisation terminée pour libérer les ressources et s'assurer que le cycle de vie de la poignée partagée est clair et contrôlé. Ce n'est que de cette manière que nous pouvons éviter les déchets inutiles de ressources et les risques potentiels tout en profitant des avantages de performance apportés par le partage.
