Utilisez l'objet encapsulation curl_share pour implémenter le pool de ressources partagées

L'initialisation et la libération fréquentes des ressources CURL peuvent provoquer des déchets de performances lors de la réalisation de demandes HTTP simultanées élevées en PHP, en particulier lorsqu'elle implique un grand nombre de connexions simultanées. Pour résoudre ce problème, la fonction Curl_Share_Init fournit un moyen de partager des ressources spécifiques, telles que le cache DNS, les cookies, etc., améliorant ainsi l'efficacité de l'exécution dans des environnements multi-thread ou multi-processus.

Cet article présentera comment utiliser la fonction Curl_Share_Init et le résumer d'une manière orientée objet pour implémenter un mécanisme de gestion efficace des ressources partagés.

1. Introduction à la fonction Curl_share_init

curl_share_init () est une fonction fournie par libcurl pour initialiser une poignée partagée. Il permet à plusieurs poignées de curl de partager les ressources suivantes:

• Données de cookies

• Cache DNS

• Informations sur la session SSL

• Pool de connexion

La clé pour partager les ressources est d'utiliser Curl_setopt pour définir une poignée partagée pour chaque poignée Curl:

 curl_setopt($ch, CURLOPT_SHARE, $shareHandle);

La poignée partagée elle-même est créée par curl_share_init () et configurée via curl_share_setopt () .

2.

Nous pouvons concevoir une classe de gestion de pool de ressources partagée simple qui résume la création, la gestion et la destruction de poignées partagées, et soutient la réutilisation dans un environnement multithread.

 class CurlSharePool
{
    private static $instance = null;
    private $shareHandle;

    private function __construct()
    {
        $this->shareHandle = curl_share_init();
        curl_share_setopt($this->shareHandle, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
        curl_share_setopt($this->shareHandle, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
        curl_share_setopt($this->shareHandle, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
    }

    public static function getInstance()
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public function getShareHandle()
    {
        return $this->shareHandle;
    }

    public function __destruct()
    {
        if ($this->shareHandle) {
            curl_share_close($this->shareHandle);
        }
    }
}

3. Utilisez des exemples

Voici un exemple de l'envoi de plusieurs demandes HTTP à l'aide d'un pool de ressources partagé:

 $urls = [
    "https://m66.net/api/v1/data1",
    "https://m66.net/api/v1/data2",
    "https://m66.net/api/v1/data3"
];

$share = CurlSharePool::getInstance()->getShareHandle();
$multiHandle = curl_multi_init();
$curlHandles = [];

foreach ($urls as $url) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SHARE, $share);
    curl_multi_add_handle($multiHandle, $ch);
    $curlHandles[] = $ch;
}

$running = null;
do {
    curl_multi_exec($multiHandle, $running);
    curl_multi_select($multiHandle);
} while ($running > 0);

foreach ($curlHandles as $ch) {
    $response = curl_multi_getcontent($ch);
    echo $response . PHP_EOL;
    curl_multi_remove_handle($multiHandle, $ch);
    curl_close($ch);
}

curl_multi_close($multiHandle);

4. Analyse des avantages

Le plus grand avantage de l'utilisation de poignées partagées est qu'il évite de réprimer le DNS et de rétablir les connexions SSL par demande, ce qui peut améliorer considérablement l'efficacité des scénarios de concurrence élevés. L'utilisation de classes d'encapsulation peut simplifier la gestion des ressources, éviter les fuites des ressources et être plus propices à la maintenance et à l'expansion ultérieures.

V. Conclusion

Bien que Curl_Share_Init ne soit pas courant dans PHP, il fournit une méthode d'optimisation à faible coût dans les systèmes avec des exigences de performance élevées. En encapsulant le modèle de gestion des objets des poignées partagées, nous pouvons obtenir une réutilisation des ressources plus efficace et stable, améliorant ainsi la vitesse de réponse et les capacités de concurrence du système global.

Dans les applications pratiques, ce type peut être élargi, comme l'introduction d'un mécanisme de verrouillage des threads pour assurer la sécurité des threads, la prise en charge des configurations de politique de plusieurs types de ressources, etc. J'espère que cet article pourra fournir une référence et une inspiration pratiques pour votre développement de PHP haute performance.