Verwenden Sie die Objektverkapselung curl_share, um den gemeinsam genutzten Ressourcenpool zu implementieren

Die häufige Initialisierung und Freisetzung von Curl -Ressourcen kann bei hoher gleichzeitigen HTTP -Anforderungen in PHP Leistungsabfälle verursachen, insbesondere wenn eine große Anzahl von gleichzeitigen Verbindungen beinhaltet. Um dieses Problem zu lösen, bietet die Funktion curl_share_init eine Möglichkeit, bestimmte Ressourcen wie DNS-Cache, Cookies usw. auszutauschen und damit die Ausführungseffizienz in Umgebungen mit mehreren Threads oder Multi-Process-Umgebungen zu verbessern.

In diesem Artikel wird vorgestellt, wie die Funktion curl_share_init verwendet wird, und sie in objektorientiertem Einkapitulieren, um einen effizienten Mechanismus für gemeinsam genutzte Ressourcenpool-Verwaltung zu implementieren.

1. Einführung in die Funktion curl_share_init

curl_share_init () ist eine von libcurl bereitgestellte Funktion zum Initialisieren eines gemeinsam genutzten Griffs. Es ermöglicht mehrere Curl -Handles, die folgenden Ressourcen zu teilen:

• Cookie -Daten

• DNS -Cache

• SSL -Sitzungsinformationen

• Verbindungspool

Der Schlüssel zum Freigeben von Ressourcen ist die Verwendung von Curl_Setopt , um einen gemeinsam genutzten Griff für jeden Curl -Handle festzulegen:

 curl_setopt($ch, CURLOPT_SHARE, $shareHandle);

Das gemeinsame Griff selbst wird von curl_share_init () erstellt und über curl_share_setopt () konfiguriert.

2. Objektorientierte Kapselungs- und Sharing-Management-Klasse

Wir können eine einfache gemeinsame Ressourcenpool-Verwaltungsklasse entwerfen, die die Erstellung, das Management und die Zerstörung gemeinsamer Griffe zusammenfasst und die Wiederverwendung in einer Umgebung mit mehreren Threads unterstützt.

 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. Verwenden Sie Beispiele

Hier ist ein Beispiel für das Senden mehrerer HTTP -Anfragen mit einem freigegebenen Ressourcenpool:

 $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. Vorteilsanalyse

Der größte Vorteil der Verwendung gemeinsamer Griffe besteht darin, dass es vermeidet, DNs wieder zu verparalen und SSL-Verbindungen pro Anfrage wieder herzustellen, was die Effizienz bei hohen Parallelitätszenarien erheblich verbessern kann. Durch die Verwendung von Einkapselungsklassen kann das Ressourcenmanagement vereinfacht, Ressourcenleckage vermieden und für die spätere Wartung und Expansion förderlicher sein.

V. Schlussfolgerung

Obwohl Curl_Share_init in PHP nicht üblich ist, bietet es eine kostengünstige Optimierungsmethode in Systemen mit hohen Leistungsanforderungen. Durch die Einschränkung des Objektmanagementmodells gemeinsamer Handles können wir eine effizientere und stabilere Wiederverwendung von Ressourcen erzielen und damit die Reaktionsgeschwindigkeit und die Parallelitätsfunktionen des Gesamtsystems verbessern.

In praktischen Anwendungen kann dieser Typ weiter erweitert werden, wie z.