So implementieren Sie die Strombegrenzung einer einzelnen Maschine in Java

Wann ist die Ratenbegrenzung zu verwenden:

Wenn Sie beispielsweise hoffen, dass die QPS Ihrer Anwendung 1000 nicht überschreitet, werden häufig 1000 Token pro Sekunde verwendet, nachdem RateLimiter eine Rate von 1000 festgelegt hat um die Auswirkungen einiger physischer Ressourcen oder logischer Ressourcen zu begrenzen.

Einführung:

Für das aktuelle Limit der Standalone-Version können Sie das Open-Source-Projekt Guava von Google verwenden. Dieses Projekt stellt einige Kernbibliotheken bereit, die von Google in Java-Projekten verwendet werden, darunter Sammlungen, Caching und gleichzeitige Programmierbibliotheken (Parallelität). ), allgemeine Anmerkungen (Common Annotations), String-Operationen und viele sehr praktische Funktionen in E/A-Operationen.

Dieses Projekt beinhaltet auch die Strombegrenzungsfunktion, die auf Basis des Token-Bucket-Algorithmus implementiert wird.

bietet zwei Strombegrenzungsstrategien:

● Sanfte Burst-Strombegrenzung (SmoothBursty)
● Sanfte Vorheizstrombegrenzung (SmoothWarmingUp) Implementierung.

Abhängigkeit:

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>29.0-jre</version>
</dependency>

Methodenbeschreibung:

Simulationsszenario (Beispiel):

Szenario 1:

Wenn wir hoffen, dass die Anzahl der Besuche auf einer bestimmten Schnittstelle nicht überschritten wird 10 Mal pro Sekunde

package org.xhs.test;

import org.apache.curator.shaded.com.google.common.util.concurrent.RateLimiter;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;


/**
 * @Author: hu.chen
 * @Description:
 **/
public class Test {

    /**
     * 存储接口名和令牌生成器的对应关系
     */
   private static Map<String, RateLimiter> interfaces = new ConcurrentHashMap<>();
   
    /**
     * 线程池
     */
    private static ExecutorService threadPool = new ThreadPoolExecutor(10,15,3,TimeUnit.SECONDS,new ArrayBlockingQueue<>(100));

    public static void main(String[] args) throws InterruptedException {

        List<UserRequest> tasks = new ArrayList<UserRequest>();
        // 准备工作，先初始化 10个线程（用户），这10个用户同时访问一个接口
        for (int i = 1; i <= 12; i++) {
            String ip = "127.0.0." + i;
            String userName="chenhu_"+i;
            String interfaceName="user/find_";
            tasks.add(new UserRequest(ip,userName,interfaceName));
        }


        // 先初始化好令牌生成器
        for (UserRequest request : tasks) {
            // 根据接口名限流
            RateLimiter rateLimiter = interfaces.get(request.getInterfaceName());

            if(rateLimiter==null){
                // 创建一个令牌生成器，每秒产生10个令牌
                synchronized (interfaces) {
                    if(rateLimiter==null) {
                        rateLimiter = RateLimiter.create(10);
                        // 将这个令牌生成器和具体的接口进行绑定
                        interfaces.put(request.getInterfaceName(),rateLimiter);
                    }
                }
            }
        }

        // 休眠一秒，让令牌生成器先生成令牌
        Thread.sleep(1000);

        for (UserRequest request : tasks) {
            // 根据接口名限流
            RateLimiter rateLimiter = interfaces.get(request.getInterfaceName());


            // 获取令牌桶中一个令牌，如果获取不到，则等待 timeout 时间，如果还获取不到，则返回false，反之则返回true
            // timeout设置为0，表示不等待
            if(rateLimiter.tryAcquire(1,0,TimeUnit.SECONDS)){

                // 得到令牌，处理请求
                threadPool.execute(()->{
                    System.err.println("接口："+request.getInterfaceName()+" 访问还未达到上限，"+request.getUserName()+"可以访问");
                });
            }else {
                // 已经等待了10秒还获取不到令牌，进行其他业务处理
                System.err.println("当前时间访问失败，"+request.getUserName()+"无法获取令牌");
            }
        }
    }

    private static class UserRequest {
        /**
         * 请求用户ip
         */
        private String ip;

        /**
         * 用户名
         */
        private String userName;

        /**
         * 请求的接口名
         */
        private String interfaceName;
        public UserRequest(String ip, String userName, String interfaceName) {
            this.ip = ip;
            this.userName = userName;
            this.interfaceName = interfaceName;
        }
        public String getIp() {return ip;}

        public String getUserName() { return userName;}
        public String getInterfaceName() {return interfaceName;}
    }
}

Szenario 2:

Wenn wir möchten, dass ein bestimmter Benutzer oder eine bestimmte IP nicht mehr als 10 Besuche pro Sekunde hat

package org.xhs.test;

import org.apache.curator.shaded.com.google.common.util.concurrent.RateLimiter;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;


/**
 * @Author: hu.chen
 * @Description:
 **/
public class Test {

    /**
     * 存储用户名和令牌生成器的对应关系
     */
   private static Map<String, RateLimiter> interfaces = new ConcurrentHashMap<>();

    /**
     * 线程池
     */
    private static ExecutorService threadPool = new ThreadPoolExecutor(10,15,3,TimeUnit.SECONDS,new ArrayBlockingQueue<>(100));

    public static void main(String[] args) throws InterruptedException {

        List<UserRequest> tasks = new ArrayList<UserRequest>();
        // 准备工作，先初始化 10个线程（用户），这10个用户同时访问一个接口
        for (int i = 1; i <= 12; i++) {
            String ip = "127.0.0." + i;
            String userName="chenhu_";
            String interfaceName="user/find_"+i;
            tasks.add(new UserRequest(ip,userName,interfaceName));
        }


        // 先初始化好令牌生成器
        for (UserRequest request : tasks) {
            // 根据接口名限流
            RateLimiter rateLimiter = interfaces.get(request.getUserName());

            if(rateLimiter==null){
                // 创建一个令牌生成器，每秒产生5个令牌
                synchronized (interfaces) {
                    if(rateLimiter==null) {
                        rateLimiter = RateLimiter.create(10);
                        // 将这个令牌生成器和具体的接口进行绑定
                        interfaces.put(request.getUserName(),rateLimiter);
                    }
                }
            }
        }

        // 休眠一秒，让令牌生成器先生成令牌
        Thread.sleep(1000);

        for (UserRequest request : tasks) {
            // 根据接口名限流
            RateLimiter rateLimiter = interfaces.get(request.getUserName());


            // 获取令牌桶中一个令牌，如果获取不到，则等待 timeout 时间，如果还获取不到，则返回false，反之则返回true
            // timeout设置为0，表示不等待
            if(rateLimiter.tryAcquire(1,0,TimeUnit.SECONDS)){

                // 得到令牌，处理请求
                threadPool.execute(()->{
                    System.err.println("用户："+request.getUserName()+" 当前时间访问次数还未达到上限，可以访问");
                });
            }else {
                // 已经等待了10秒还获取不到令牌，进行其他业务处理
                System.err.println("当前时间访问失败，"+request.getUserName()+"无法获取令牌");
            }
        }
    }

    private static class UserRequest {
        /**
         * 请求用户ip
         */
        private String ip;

        /**
         * 用户名
         */
        private String userName;

        /**
         * 请求的接口名
         */
        private String interfaceName;
        public UserRequest(String ip, String userName, String interfaceName) {
            this.ip = ip;
            this.userName = userName;
            this.interfaceName = interfaceName;
        }
        public String getIp() {return ip;}

        public String getUserName() { return userName;}
        public String getInterfaceName() {return interfaceName;}
    }
}

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Strombegrenzung einer einzelnen Maschine in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!