Bagaimana untuk melaksanakan pengehadan arus mesin tunggal di java

Bila menggunakan pengehad kadar:

Sebagai contoh, jika anda berharap QPS permohonan anda tidak melebihi 1000, maka selepas RateLimiter menetapkan kadar 1000, ia akan membuang 1000 token ke dalam baldi setiap kedua. RateLimiter sering Digunakan untuk mengehadkan kadar akses kepada beberapa sumber fizikal atau sumber logik.

Pengenalan:

Untuk had semasa versi kendiri, anda boleh menggunakan projek Guava sumber terbuka Google Projek ini menyediakan beberapa perpustakaan teras yang digunakan oleh Google dalam projek Java, termasuk koleksi dan cache. (Caching), perpustakaan pengaturcaraan serentak (Concurrency), anotasi biasa (Anotasi biasa), operasi rentetan, dan banyak fungsi yang sangat praktikal dalam operasi I/O.

Projek ini juga termasuk fungsi pengehad semasa, yang dilaksanakan berdasarkan algoritma baldi token.

menyediakan dua strategi pengehadan semasa:

● Pengehadan arus pecah licin (SmoothBursty)
● Pelaksanaan pengehadan arus prapemanasan lancar (SmoothWarmingUp).

Pergantungan:

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

Penerangan kaedah:

Senario simulasi (contoh):

Senario 1:

Apabila kami berharap bilangan lawatan ke antara muka tertentu tidak akan melebihi 10 kali sesaat

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

Senario 2 :

Apabila kita mahu pengguna atau IP tertentu mempunyai tidak lebih daripada 10 lawatan sesaat

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

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengehadan arus mesin tunggal di java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!