How to use Redis to implement distributed current limiting function

How to use Redis to implement distributed current limiting function

Introduction:
With the rapid development of the Internet, the number of visits to business systems is also increasing. When traffic is concentrated in a certain business system, it will pose certain threats to the stability and performance of the system. In order to protect business systems, current limiting has become an indispensable means. In a distributed system, Redis can be used to easily implement the distributed current limiting function. This article will introduce how to use Redis to implement distributed current limiting and provide specific code examples.

1. The basic principles and data structure of Redis
Redis is a high-performance key-value storage system based on memory. It supports a variety of data structures such as strings, lists, hashes, etc. Here, we mainly focus on the two data structures of counters and ordered sets in Redis.

1. Counter: The counter in Redis uses the String (string) data structure. The counter can be incremented through the INCR command, and the expiration time can be set to facilitate regular cleaning.
2. Ordered set: The ordered set in Redis uses the ZSet (ordered set) data structure. Each element can be associated with a score and sorted based on the score. In an ordered set, you can use the ZRANGE command to obtain members within a certain range by score.

2. Ideas for implementing the current limiting function
Through Redis counters and ordered collections, the distributed current limiting function can be easily implemented. The specific ideas are as follows:

1. Set a counter to record the number of traffic requests.
2. Set a scheduled task to regularly clear the number of expired requests in the counter.
3. Use an ordered collection to record the timestamp of each request, arranged by time.
4. Every time there is a request, obtain the earliest request time within a certain time range based on the timestamp in the ordered set.
5. If there are more than the maximum number of requests within a certain time range (such as 1 second), it will be judged as exceeding the current limit.

3. Code Example

The following is a code example of Redis distributed current limiting written in Java:

import redis.clients.jedis.Jedis;

public class RateLimiter {
    private Jedis jedis;
    private String key; // Redis中的键
    private int maxRequests; // 最大请求数
    private int timeWindow; // 时间窗口，单位为秒

    public RateLimiter(Jedis jedis, String key, int maxRequests, int timeWindow) {
        this.jedis = jedis;
        this.key = key;
        this.maxRequests = maxRequests;
        this.timeWindow = timeWindow;
    }

    public boolean allowRequest() {
        long now = System.currentTimeMillis() / 1000; // 当前时间戳，单位为秒
        long earliest = now - timeWindow; // 最早的请求时间

        jedis.zremrangeByScore(key, 0, earliest); // 清理过期的请求时间

        long count = jedis.zcount(key, earliest, now); // 统计指定时间范围内的请求数

        if (count < maxRequests) {
            jedis.zadd(key, now, String.valueOf(now)); // 添加当前请求的时间
            return true;
        } else {
            return false;
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        RateLimiter rateLimiter = new RateLimiter(jedis, "requestCounter", 10, 1); // 最大请求数为10，时间窗口为1秒

        for (int i = 0; i < 20; i++) {
            System.out.println("第" + (i + 1) + "次请求：" + rateLimiter.allowRequest());
        }
        
        jedis.close();
    }
}

The above code implements a simple distribution current limiting function. Among them, the RateLimiter class encapsulates the current limiting logic, and the Main class is used for testing.

Conclusion:
Using Redis to implement distributed current limiting function can easily protect the stability and performance of the business system. Through the cooperation of counters and ordered collections, the number of requests can be flexibly controlled, and by setting the expiration time, expired requests can be automatically cleared. The above is a sample code. The specific usage scenario needs to be adjusted and optimized according to the actual situation. Hope this article helps you!

The above is the detailed content of How to use Redis to implement distributed current limiting function. For more information, please follow other related articles on the PHP Chinese website!