Comment implémenter des fonctions de contrôle de concurrence et de limitation de courant dans les microservices PHP

Comment implémenter des fonctions de contrôle de concurrence et de limitation de courant dans les microservices PHP

Introduction :
Avec le développement rapide d'Internet et la forte augmentation du nombre d'utilisateurs, les exigences en matière de contrôle de concurrence et de fonctions de limitation de courant sur le serveur sont de plus en plus élevés. Cet article présentera comment implémenter des fonctions de contrôle de concurrence et de limitation de courant dans les microservices PHP, et fournira des exemples de code spécifiques.

1. La nécessité d'un contrôle de simultanéité

Dans les applications uniques traditionnelles, la demande de contrôle de simultanéité n'est pas très élevée. Cependant, dans une architecture de microservices, chaque service est déployé et exécuté indépendamment et peut faire face à un grand nombre de requêtes simultanées. Si rien n’est fait, cela peut entraîner une charge élevée du serveur, des temps de réponse longs ou même des plantages. Il est donc crucial d’implémenter des fonctions de contrôle de concurrence dans les microservices.

2. Méthodes pour implémenter le contrôle de concurrence

1. Utiliser le sémaphore (Semaphore)

Le sémaphore est un mécanisme de contrôle de concurrence courant, qui peut contrôler le nombre de threads simultanés accédant à une ressource en même temps. En PHP, les sémaphores peuvent être implémentés à l'aide de l'extension Semaphore.

Tout d’abord, nous devons installer l’extension Semaphore. Il peut être installé via la ligne de commande suivante :

$ pecl install sem

Après avoir installé l'extension, nous pouvons utiliser la classe Semaphore pour implémenter le contrôle de concurrence. Voici un exemple de code simple :

// 初始化信号量，参数1表示资源的数量
$sem = new Semaphore(10);

// 等待可用资源
$sem->acquire();

// 执行需要控制并发的代码

// 释放资源
$sem->release();

Dans l'exemple ci-dessus, nous avons initialisé un sémaphore avec 10 ressources. Chaque fois que vous exécutez du code nécessitant un contrôle de concurrence, utilisez la méthode acquire pour attendre les ressources disponibles et utilisez la méthode release pour libérer les ressources après l'exécution.

2. Utilisation des files d'attente

La file d'attente est un mécanisme de contrôle de concurrence courant qui peut traiter les demandes simultanées dans l'ordre. En PHP, vous pouvez utiliser des files d'attente de messages pour contrôler la concurrence.

Il existe de nombreuses implémentations de files d'attente de messages en PHP, telles que RabbitMQ, Redis, etc. Ici, nous prenons Redis comme exemple pour présenter comment utiliser Redis pour implémenter le contrôle de concurrence.

Tout d'abord, nous devons installer l'extension Redis et la bibliothèque Predis. Il peut être installé via la ligne de commande suivante :

$ pecl install redis
$ composer require predis/predis

Après avoir installé l'extension et la bibliothèque, nous pouvons utiliser le type Redis List pour implémenter la file d'attente. Voici un exemple de code :

// 连接Redis
$redis = new PredisClient();

// 将请求添加到队列
$redis->rpush('request_queue', time());

// 从队列中取出请求
$request = $redis->lpop('request_queue');

// 执行需要控制并发的代码

// 删除已处理的请求
$redis->lrem('request_queue', 0, $request);

Dans l'exemple ci-dessus, nous ajoutons la requête à la file d'attente via la méthode rpush et retirons la requête de la file d'attente via la méthode lpop pour la traiter. Après le traitement, supprimez la demande traitée via la méthode lrem.

3. La nécessité d'une limitation de courant

La limitation de courant est une méthode courante côté serveur pour contrôler les requêtes simultanées, qui peut limiter le nombre de requêtes par unité de temps. L’utilisation de la limitation dans les microservices peut protéger les services backend d’une pression excessive des demandes.

4. Méthodes pour implémenter la limitation de courant

1. Utilisez l'algorithme du compartiment à jetons

L'algorithme du compartiment à jetons est l'un des algorithmes de limitation de courant courants. Il maintient un compartiment à jetons à capacité fixe, et chaque requête consomme un jeton. traité. Lorsqu'il n'y a pas assez de jetons dans le bucket, la demande sera rejetée.

Voici un exemple de code pour l'algorithme de bucket de jetons implémenté à l'aide de Redis :

// 连接Redis
$redis = new PredisClient();

// 每秒生成10个令牌
$rate = 10;

// 桶的容量为20个令牌
$capacity = 20;

// 获取当前时间
$time = microtime(true);

// 计算当前桶中的令牌数量
$tokens = $redis->get('tokens');

// 重新计算桶中的令牌数量
if ($tokens === null) {
    $tokens = $capacity;
    $redis->set('tokens', $tokens);
    $redis->set('last_time', $time);
} else {
    $interval = $time - $redis->get('last_time');
    $newTokens = $interval * $rate;

    $tokens = min($tokens + $newTokens, $capacity);
    $redis->set('tokens', $tokens);
    $redis->set('last_time', $time);
}

// 判断是否有足够的令牌
$allow = $redis->get('tokens') >= 1;

if ($allow) {
    // 消耗一个令牌
    $redis->decr('tokens');

    // 执行请求处理代码
} else {
    // 拒绝请求
}

Dans l'exemple ci-dessus, nous utilisons Redis pour stocker le nombre de jetons dans le bucket et l'heure de la dernière mise à jour. Chaque fois qu'une demande arrive, le nombre de nouveaux jetons est calculé en comparant l'intervalle de temps entre l'heure actuelle et l'heure de la dernière mise à jour, puis le nombre de jetons est mis à jour dans Redis.

S'il y a suffisamment de jetons dans le bucket, la demande est autorisée à passer et le nombre de jetons est réduit de 1 ; s'il n'y a pas assez de jetons dans le bucket, la demande est rejetée.

Résumé :
L'implémentation de fonctions de contrôle de concurrence et de limitation de courant dans les microservices PHP est très importante pour garantir la stabilité et l'optimisation des performances du service. Cet article explique comment utiliser le sémaphore et les files d'attente pour implémenter le contrôle de concurrence, et comment utiliser l'algorithme du compartiment à jetons pour implémenter la limitation de courant, et fournit des exemples de code spécifiques. En utilisant ces fonctions de manière rationnelle, les demandes simultanées peuvent être mieux contrôlées et la stabilité et les performances du service peuvent être améliorées.

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!