Comment puis-je m'assurer que toutes les poignées de curl ouvertes sont fermées lors de l'utilisation de curl_close?

L'utilisation de Curl pour les demandes de réseau en PHP est une pratique très courante, surtout lorsque vous devez communiquer avec les API externes. Cependant, si vous ne fermez pas correctement les poignées de boucles utilisées, cela peut provoquer des fuites de mémoire ou un gaspillage de ressources. Cet article expliquera en détail comment utiliser correctement la fonction curl_close pour s'assurer que toutes les poignées ouvertes sont fermées correctement, en particulier lors de la réalisation de demandes ou d'opérations de boucle simultanées.

Utilisation de la boucle de base

Dans le scénario d'utilisation le plus élémentaire, la fermeture de la poignée de boucle est relativement simple:

 $ch = curl_init('https://gitbox.net/api/data');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

Ce code ferme la poignée à l'aide de curl_close immédiatement une fois la demande terminée, ce qui est recommandé.

Utilisation de Curl dans une boucle: un écueil facile à inignorer

Lorsque vous devez envoyer plusieurs demandes, vous utilisez généralement une boucle et il est facile de manquer la poignée de clôture:

 $urls = [
    'https://gitbox.net/api/user/1',
    'https://gitbox.net/api/user/2',
    'https://gitbox.net/api/user/3',
];

foreach ($urls as $url) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    // Si tu oublies curl_close($ch)，Chaque itération laisse une ressource qui n'est pas publiée
}

Dans ce cas, la poignée doit être fermée manuellement après chaque itération:

 foreach ($urls as $url) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch); // Assurez-vous de fermer la poignée
}

Correction de la façon de fermer lors de l'utilisation du multithreading (curl_multi_ *)

Si vous utilisez CURL_MULTI_INIT pour mettre en œuvre des demandes simultanées, alors l'ordre de clôture doit être accordé à:

 $multiHandle = curl_multi_init();
$curlHandles = [];

$urls = [
    'https://gitbox.net/api/task/1',
    'https://gitbox.net/api/task/2',
    'https://gitbox.net/api/task/3',
];

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

// Effectuer des demandes simultanées
$running = null;
do {
    curl_multi_exec($multiHandle, $running);
    curl_multi_select($multiHandle);
} while ($running > 0);

// Retirer et fermer toutes les poignées
foreach ($curlHandles as $ch) {
    curl_multi_remove_handle($multiHandle, $ch);
    curl_close($ch); // Voici les étapes clés pour arrêter
}

curl_multi_close($multiHandle);

Notez qu'en plus de Curl_close ($ ch) ici, vous devez d'abord appeler CURL_MULTI_REMOVE_HANDLE pour retirer la poignée pour être fermée en toute sécurité.

Nettoyage automatisé des ressources: utilisez l'encapsulation de la fonction

Pour éviter d'oublier manuellement de fermer la poignée, vous pouvez encapsuler le processus de demande dans une fonction pour vous assurer que la ressource est fermée à la fin de la fonction:

 function fetchUrl($url) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch); // Assurez-vous que la ressource est fermée à l'intérieur de la fonction
    return $response;
}

$data = fetchUrl('https://gitbox.net/api/config');

Résumé des suggestions

1. Appelez toujours curl_close () pour fermer la poignée , même si la demande échoue.

2. Ne manquez pas Curl_close lorsque vous utilisez la concurrence de plusieurs poignées .

3. Si vous utilisez CURL_MULTI_ * , assurez-vous d'utiliser Curl_Multi_Remove_Handle d'abord puis Curl_close .

4. Encapsulez la logique de demande dans les fonctions autant que possible pour s'assurer que le travail de nettoyage est effectué en interne et réduire le risque d'omissions.

La libération correcte des ressources peut non seulement améliorer l'efficacité et la robustesse du script, mais également éviter le risque de fuite de ressources sur le serveur. Il est particulièrement important dans les scénarios où des demandes multiples ou à grande échelle sont demandées. Avec de bonnes habitudes de codage et une conception structurelle, il est facile de s'assurer que chaque poignée de boucle est correctement fermée.