Présentation du compteur atomique Redis incr pour empêcher les requêtes simultanées

La colonne suivante du Tutoriel Redis vous présentera l'augmentation du compteur atomique Redis pour éviter les demandes simultanées. J'espère que cela sera utile aux amis dans le besoin !

1. Introduction
Dans certains systèmes ou fonctions qui ont des restrictions sur les demandes simultanées élevées, telles que les activités de vente flash ou certains sites Web renvoyant trop d'utilisateurs actuels, veuillez essayez plus tard. Celles-ci limitent le nombre de requêtes simultanées et sont généralement utilisées pour protéger le système en arrière-plan et empêcher le système de planter en raison d'un impact excessif sur le trafic. Concernant les conséquences d'un crash système, il est évidemment plus acceptable pour les mainteneurs de rejeter certaines requêtes.
Parmi les diverses limitations actuelles, en plus du compteur avec un mécanisme de verrouillage conçu par le système lui-même, l'utilisation de Redis est évidemment un moyen efficace, sûr, pratique et pratique de le mettre en œuvre.

2. Commande incr
La commande Redis Incr augmente de un la valeur numérique stockée dans la clé.
Si la clé n'existe pas, la valeur de la clé sera d'abord initialisée à 0, puis l'opération INCR sera effectuée.
Renvoie une erreur si la valeur contient le mauvais type ou si une valeur de type chaîne ne peut pas être représentée sous forme de nombre.
La valeur de cette opération est limitée à la représentation de nombres signés 64 bits.
Exemple :

127.0.0.1:6379> set num 10
OK
127.0.0.1:6379> incr num
(integer) 11
127.0.0.1:6379> get num    # 数字值在 Redis 中以字符串的形式保存
"11"

Remarque : Puisque redis n'a pas de type explicite pour représenter des données entières, cette opération est une opération de chaîne.
Lors de l'exécution de cette opération, la chaîne stockée correspondant à la clé est analysée en données entières décimales signées de 64 bits.
En fait, Redis utilise en interne une représentation entière (Représentation entière) pour stocker les valeurs entières correspondantes, donc ce type de valeur de chaîne est en fait stocké en entier, il n'y a donc pas de représentation sous forme de chaîne (Représentation chaîne) pour stocker des entiers la consommation supplémentaire. provoqué.

3. Scénarios d'utilisation
1. Compteur
L'idée d'utilisation est la suivante : chaque fois qu'il y a une opération associée, envoyez une commande incr au serveur Redis.
Par exemple, voici un scénario : nous avons une application Web et nous souhaitons enregistrer le nombre de fois que chaque utilisateur visite ce site Web chaque jour.
L'application Web n'a besoin que de concaténer l'ID utilisateur et la chaîne représentant l'heure actuelle comme clé, et d'exécuter la commande incr sur cette clé à chaque fois que l'utilisateur visite cette page.

Ce scénario peut être étendu de plusieurs manières :
En combinant les commandes INCR et EXPIRE, un compteur qui enregistre uniquement le nombre de visites de l'utilisateur dans un intervalle spécifié peut être implémenté
Le client peut passer GETSET La commande obtient la valeur actuelle du compteur et la réinitialise à 0
Grâce à des commandes d'incrémentation/décrémentation atomique telles que DECR ou INCRBY, certaines valeurs peuvent être augmentées ou diminuées en fonction des opérations de l'utilisateur, par exemple en ligne. jeux, le score de jeu de l'utilisateur doit être calculé. Avec un contrôle en temps réel, les scores peuvent augmenter ou diminuer.

2. Limiteur de vitesse
Un limiteur de vitesse est un scénario particulier qui peut limiter la vitesse d'exécution de certaines opérations.
Un exemple traditionnel consiste à limiter le nombre de requêtes pour une certaine API publique.
Supposons que nous voulions résoudre le problème suivant : limiter le nombre de requêtes par IP d'une API à pas plus de 10 fois par seconde.
Nous pouvons résoudre ce problème de deux manières grâce à la commande incr.

4. Implémentation Java du contrôle de flux
Ici, nous utiliserons la fonctionnalité redis-incr de Java pour créer un code de contrôle qui n'autorise que 100 requêtes en 1 minute. valeur clé étant contrôlée.

public static boolean flowControl(String key){        //最大允许100
        int max = 100;        long total = 1L;        try {            if (jedisInstance.get(key) == null) {                //jedisInstance是Jedis连接实例，可以使单链接也可以使用链接池获取，实现方式请参考之前的blog内容                //如果redis目前没有这个key，创建并赋予0，有效时间为60s
                jedisInstance.setex(key, 60, "0");
            } else {                //获取加1后的值
                total = jedisInstance.incr(redisKey).longValue();                //Redis TTL命令以秒为单位返回key的剩余过期时间。当key不存在时，返回-2。当key存在但没有设置剩余生存时间时，返回-1。否则，以秒为单位，返回key的剩余生存时间。
                if (jedisInstance.ttl(redisKey).longValue() == -1L)
                {                    //为给定key设置生存时间，当key过期时(生存时间为0)，它会被自动删除。
                    jedisInstance.expire(redisKey, 60);
                }
            }
        } catch (Exception e) {
            logger.error("流量控制组件:执行计数操作失败,无法执行计数");
        }        long keytotaltransations = max;        //判断是否已超过最大值，超过则返回false
        if (total > keytotaltransations) {            return false;
        }        return true;
    }

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!