Demander des compétences en matière de contrôle de concurrence et d'optimisation des ressources dans l'accueil de l'interface PHP Huawei Cloud API

Demander des compétences en matière de contrôle de concurrence et d'optimisation des ressources dans l'amarrage de l'interface PHP Huawei Cloud API

Lors de l'utilisation de PHP pour ancrer l'interface API Huawei Cloud, le contrôle de concurrence des demandes et l'optimisation des ressources sont très importants. Contrôler correctement le nombre de requêtes simultanées et le nombre maximum de connexions, ainsi que l'optimisation de l'utilisation des ressources, peut améliorer considérablement les performances et la stabilité du système. Ensuite, cet article présente quelques conseils pratiques et des exemples de code.

1. Contrôle de simultanéité des demandes

1. Contrôle des demandes multithread

Lors des requêtes API, nous pouvons utiliser le multithread pour améliorer l'efficacité du traitement. Utilisez la fonction curl_multi_* de PHP pour contrôler les requêtes simultanées multithread.

Ce qui suit est un exemple de code simple qui montre comment utiliser les fonctions curl_multi_* pour le contrôle des requêtes multithread. Supposons que nous devions demander des interfaces API avec trois URL différentes :

<?php
// 待请求的URL列表
$urls = [
    "https://api.example.com/api1",
    "https://api.example.com/api2",
    "https://api.example.com/api3",
];

// 初始化curl
$handles = [];
$mh = curl_multi_init();

// 创建并添加curl句柄
foreach ($urls as $i => $url) {
    $handles[$i] = curl_init();
    curl_setopt($handles[$i], CURLOPT_URL, $url);
    curl_setopt($handles[$i], CURLOPT_RETURNTRANSFER, 1);
    curl_multi_add_handle($mh, $handles[$i]);
}

// 执行并发请求
$running = null;
do {
    curl_multi_exec($mh, $running);
} while ($running > 0);

// 获取请求结果
$results = [];
foreach ($handles as $i => $handle) {
    $results[$i] = curl_multi_getcontent($handle);
    curl_multi_remove_handle($mh, $handle);
    curl_close($handle);
}

// 关闭curl
curl_multi_close($mh);

// 处理并输出结果
foreach ($results as $i => $result) {
    echo "Request URL: " . $urls[$i] . ", Result: " . $result . "
";
}
?>

2. Contrôle du numéro de requête

Lorsque nous effectuons des requêtes API, nous devons généralement limiter le nombre de requêtes par seconde ou par minute pour éviter que la surcharge des requêtes ne provoque une dégradation des performances ou étant bloqué par l'interdiction du fournisseur d'API. Nous pouvons utiliser le timer de PHP pour contrôler la fréquence des requêtes d'interface.

Ce qui suit est un exemple de code qui montre comment utiliser un minuteur pour limiter le nombre de requêtes autorisées par seconde :

<?php
// 允许的请求次数和时间间隔
$maxRequests = 10; // 每秒允许的最大请求数量
$maxTime = 1; // 时间间隔（秒）

// 当前请求次数
$requestCount = 0;

// 请求开始时间
$requestStartTime = microtime(true);

// 模拟发送10次请求
for ($i = 1; $i <= 10; $i++) {
    usleep(100000); // 模拟请求的耗时

    // 计算请求间隔时间
    $requestEndTime = microtime(true);
    $requestInterval = $requestEndTime - $requestStartTime;

    // 如果请求次数超过限制或时间间隔超过限制，则等待剩余时间
    if ($requestCount >= $maxRequests || $requestInterval >= $maxTime) {
        $sleepTime = max(($maxTime - $requestInterval) * 1000000, 0); // 将剩余时间转换成微秒数
        usleep($sleepTime);
        $requestCount = 0;
        $requestStartTime = microtime(true);
    }

    // 发送API请求
    echo "Send request " . $i . "
";

    $requestCount++;
}

?>

2. Techniques d'optimisation des ressources

1. Mise en cache

La mise en cache est une technique courante d'optimisation des ressources qui peut réduire Dupliquez les requêtes API et améliorez les performances du système. En PHP, nous pouvons utiliser divers mécanismes de mise en cache, tels que Redis, Memcached, la mise en cache de fichiers, etc.

Voici un exemple de code qui montre comment utiliser Redis comme cache pour optimiser les requêtes API :

<?php
// 获取Redis连接
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// 定义需要缓存的API请求URL
$apiUrl = "https://api.example.com/api1";

// 检查Redis缓存是否存在
if ($redis->exists($apiUrl)) {
    // 获取缓存数据
    $apiData = $redis->get($apiUrl);
    echo "Get data from cache: " . $apiData . "
";
} else {
    // 发送API请求
    $apiData = file_get_contents($apiUrl);

    // 将API请求结果存入Redis缓存，并设置过期时间
    $redis->set($apiUrl, $apiData);
    $redis->expire($apiUrl, 60); // 设置缓存过期时间为60秒

    echo "Get data from API: " . $apiData . "
";
}

// 关闭Redis连接
$redis->close();
?>

2. Data batching

Batching est une technique d'optimisation des ressources efficace lorsque de grandes quantités de données doivent être traitées. En traitant plusieurs éléments de données en même temps, le nombre de requêtes API peut être réduit et les performances du système améliorées.

Ce qui suit est un exemple de code qui montre comment utiliser le traitement par lots pour réduire les requêtes API :

<?php
// 定义批量处理的数据
$data = [
    ["name" => "Tom", "age" => 18],
    ["name" => "Jerry", "age" => 20],
    ["name" => "Alice", "age" => 22],
];

// 将数据转换成JSON格式
$jsonData = json_encode($data);

// 发送API请求
$apiUrl = "https://api.example.com/api1";
$apiData = file_get_contents($apiUrl, false, stream_context_create([
    'http' => [
        'method' => 'POST',
        'header' => 'Content-type: application/json',
        'content' => $jsonData
    ]
]));

// 处理API请求结果
$result = json_decode($apiData, true);
foreach ($result as $item) {
    echo "Name: " . $item["name"] . ", Age: " . $item["age"] . "
";
}
?>

Résumé

Lorsque PHP est connecté à l'interface API Huawei Cloud, il peut raisonnablement contrôler le nombre de requêtes simultanées et le nombre maximum. des connexions et optimiser l’utilisation des ressources. Les performances et la stabilité du système sont essentielles. Cet article présente quelques conseils pratiques et des exemples de code, dans l'espoir de vous aider dans le développement réel. En appliquant correctement ces techniques, vous pouvez optimiser l'efficacité du traitement des requêtes API et améliorer les performances et la stabilité du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!