Conseils d'optimisation des performances pour curl_close et curl_setopt dans php

gitbox 2025-05-18

Curl est l'une des extensions les plus couramment utilisées lors de l'utilisation de PHP pour les demandes HTTP. Il est puissant et prend en charge divers protocoles, mais il existe également de nombreux malentendus potentiels pendant l'utilisation. Surtout en ce qui concerne l'utilisation de curl_close () et curl_setopt () , de nombreux développeurs ne réalisent pas leur impact sur les performances. Cet article analysera ces malentendus communs en profondeur et fournira des suggestions d'optimisation.

1. Analyse des malentendus communs

1. Créer et fermer la ressource de boucle pour chaque demande

C'est le malentendu le plus courant. De nombreux développeurs sont habitués à appeler chaque demande:

 $ch = curl_init();
// Définir diverses options
curl_setopt($ch, CURLOPT_URL, 'https://gitbox.net/api/data');
$response = curl_exec($ch);
curl_close($ch);

Bien que le code écrit de cette manière soit clair et intuitif, il ignore les problèmes de performances. Curl_init () et Curl_close () fréquents entraîneront une allocation et un recyclage fréquents des ressources, augmentant les frais généraux du système.

Suggestions d'optimisation : si plusieurs demandes doivent être envoyées dans un court laps de temps, il est recommandé de réutiliser la même poignée de boucle et de modifier uniquement les paramètres nécessaires.

 $ch = curl_init();

$urls = [
    'https://gitbox.net/api/data1',
    'https://gitbox.net/api/data2',
    'https://gitbox.net/api/data3',
];

foreach ($urls as $url) {
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    // traiter avec $response
}

curl_close($ch);

2. Sur-dépendance sur curl_reset au lieu de réinitialiser les paramètres nécessaires

Certains développeurs appellent CURL_RESET ($ CH) à chaque fois lorsque vous réutilisez les greffes, pensant que c'est une pratique sûre. En fait, Curl_Reset effacera tous les paramètres, ce qui équivaut à la réinitialisation, ce qui n'est pas aussi efficace que de définir manuellement les paramètres nécessaires.

Suggestion : mettez uniquement à mettre à jour les options qui changeront, telles que curlopt_url , curlopt_postfields , plutôt que de réinitialiser toutes les options.

3. Fuite de mémoire causée par une version incorrecte des ressources

Certaines bases de code manquent curl_close () , surtout lorsqu'une exception se produit, la poignée n'est pas fermée dans le bloc final , ce qui entraînera des fuites de mémoire après un fonctionnement à long terme.

Suggestion : assurez-vous toujours que les ressources sont libérées après utilisation. La structure suivante est recommandée:

 $ch = curl_init();

try {
    curl_setopt($ch, CURLOPT_URL, 'https://gitbox.net/api/user');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    // traiter avec $response
} finally {
    curl_close($ch);
}

4. Utiliser incorrectement des poignées dans des demandes simultanées

Lorsque vous utilisez CURL_MULTI_ * pour effectuer des demandes simultanées, les développeurs ferment parfois accidentellement la poignée avant ou pendant l'exécution de la tâche, ce qui fait échouer la demande.

Correction : assurez-vous que toutes les sous-requêtes sont terminées, puis appelez curl_close () :

 $mh = curl_multi_init();
$chs = [];

$urls = [
    'https://gitbox.net/api/a',
    'https://gitbox.net/api/b',
];

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

do {
    $status = curl_multi_exec($mh, $active);
    curl_multi_select($mh);
} while ($active && $status == CURLM_OK);

foreach ($chs as $ch) {
    $response = curl_multi_getcontent($ch);
    curl_multi_remove_handle($mh, $ch);
    curl_close($ch);
}

curl_multi_close($mh);

2. Compétences d'optimisation des performances de curl_setopt

1. Utiliser le multiplexage de connexion raisonnablement

CURL de PHP prend en charge la réutilisation de la connexion (réutilisation de la connexion), mais elle doit prendre en charge la main-d'œuvre côté serveur, et il doit également être activé:

 curl_setopt($ch, CURLOPT_FORBID_REUSE, false);

Vous pouvez également activer les paramètres connexes Curlopt_TCP_Keepalive pour optimiser les performances dans les services de connexion longs.

2. Évitez les paramètres inutiles

Si certaines options sont le comportement dont vous avez besoin par défaut, il n'est pas nécessaire de les définir explicitement à chaque fois. Par exemple:

 // Je n&#39;ai pas besoin d&#39;être réglé pour false，Parce que c&#39;est la valeur par défaut
curl_setopt($ch, CURLOPT_HEADER, false);

La réduction des appels Curl_Setopt inutiles aide à améliorer l'efficacité de l'exécution des scripts.

3. Optimiser pour la résolution DNS

Les requêtes DNS sont l'un des goulots d'étranglement des performances dans les demandes HTTP. Vous pouvez optimiser en configurant l'analyse personnalisée ou en utilisant un mécanisme de cache:

 curl_setopt($ch, CURLOPT_DNS_CACHE_TIMEOUT, 300);

Ou définissez l'analyse locale:

 curl_setopt($ch, CURLOPT_RESOLVE, ['api.gitbox.net:443:192.168.0.1']);

4. Utilisez HTTP2 ou version ultérieure (comme HTTP3)

Avec le support des serveurs modernes, l'activation de HTTP2 peut entraîner une concurrence plus élevée et une vitesse de réponse de demande plus rapide:

 curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);

3. Conclusion

curl_close () semble être juste une fonction de libération de ressources simple, mais son utilisation avec curl_setopt () affecte directement les performances et la stabilité du programme. Le développement de bonnes habitudes d'utilisation peut non seulement éviter les fuites de mémoire, mais également améliorer considérablement l'efficacité de la demande. Pour les scénarios de concurrence élevés, les poignées de réutilisation rationnelles, la rationalisation des paramètres et la gestion des cycles de vie de connexion sont les clés du réglage de la boucle PHP.

Connexe