About Redis atomic counter incr to prevent concurrent requests

The following column Redis Tutorial will introduce to you about the Redis atomic counter incr to prevent concurrent requests. I hope it will be helpful to friends in need!

I. Introduction

In some systems or functions that have restrictions on high concurrent requests, such as flash sale activities, or some websites return too many current users, please try again later. These limit the number of requests at the same time and are generally used to protect the background system and prevent the system from crashing due to excessive traffic impact. Regarding the consequences of a system crash, it is obviously more acceptable to the maintainers to reject some requests.
Among all kinds of current limiting, in addition to the counter with a lock mechanism designed by the system itself, using Redis to implement it is obviously an efficient, safe, convenient and convenient way.

2. Incr command

The Redis Incr command increases the numeric value stored in key by one.
If key does not exist, the value of key will be initialized to 0 first, and then the INCR operation will be performed.
Return an error if the value contains the wrong type, or if a value of type string cannot be represented as a number.
The value of this operation is limited to 64-bit (bit) signed digital representation.
Example:

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"

Note: Since redis does not have an explicit type to represent integer data, this operation is a string operation.

When performing this operation, the string stored corresponding to key is parsed into decimal 64-bit signed integer data.
In fact, Redis internally uses integer representation (Integer representation) to store corresponding integer values, so this type of string value is actually stored in integer, and there is no string representation (String representation) for storing integers. the additional consumption caused.

3. Usage scenarios

1. Counter

The usage idea is: every time there is a related operation, Send an incr command to the Redis server.
For example, this is a scenario: We have a web application, and we want to record the number of times each user visits this website every day.
The web application only needs to concatenate the user ID and the string representing the current time as the key, and execute the incr command on this key every time the user visits this page.

This scenario can have many extension methods:
By combining the INCR and EXPIRE commands, a counter that only records the number of visits by the user within a specified interval can be implemented
The client can pass GETSET The command gets the current counter value and resets it to 0
Through atomic increment/decrement commands such as DECR or INCRBY, certain values ​​can be increased or decreased according to the user's operations. For example, in online games, the user's game score needs to be calculated. With real-time control, scores may increase or decrease.

2. Speed ​​limiter

The speed limiter is a special scenario that can limit the execution rate of certain operations.
A traditional example is to limit the number of requests for a certain public API.
Suppose we want to solve the following problem: limit the number of requests per IP of an API to no more than 10 times per second.
We can solve this problem in two ways through the incr command.

4. Java implementation of flow control

Here we will use the characteristics of redis-incr in java to build a control that only allows 100 requests in 1 minute. Code, key represents the controlled key value stored in redis.

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;
    }

The above is the detailed content of About Redis atomic counter incr to prevent concurrent requests. For more information, please follow other related articles on the PHP Chinese website!