正文

向技术致敬的最佳方案：给予技术分享传播者一个点赞、收藏。

（方案不是很成熟，但是可以尝试）

开搞：

① 引入相关依赖，pom.xml ：

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

② （其实就是使用guava的，简单做了一层业务包装）MyRateLimiter.java ：

vimport com.google.common.util.concurrent.RateLimiter;
import org.springframework.stereotype.Component;
@Component
public class MyRateLimiter {
    /**
     * 账号注册限流器 每秒只发出5个令牌
     */
    private RateLimiter accountRegisterRateLimiter = RateLimiter.create(5.0);
    /**
     * 短信发送限流器    每秒只发出3个令牌
     */
    private RateLimiter smsSendRateLimiter = RateLimiter.create(3.0);
    /**
     * 尝试获取令牌，返回尝试结果
     *
     * @return
     */
    public boolean tryAccountRegisterAcquire() {
        return accountRegisterRateLimiter.tryAcquire();
    }
    /**
     * 取令牌，暂时取不到会一直去尝试
     * @return
     */
    public double accountRegisterAcquire() {
        return accountRegisterRateLimiter.acquire();
    }
    /**
     * 尝试获取令牌
     *
     * @return
     */
    public boolean trySmsSendAcquire() {
        return smsSendRateLimiter.tryAcquire();
    }
}

代码简析：

源码解析：

用的简单，但是我们需要简单看看源码，方便我们可以根据业务场景做相关调整。

简单翻译一下两个用的比较多的create函数里面的注释:

方法一

public static RateLimiter create(double permitsPerSecon)；

咱大白话翻译(其实源码上有注释，还有举例)：

保证每秒处理不超过 permitsPerSecond个请求。

如果每秒请求数爆炸，超过我们设置的permitsPerSecond 数量，会慢慢处理。

如果每秒请求书很少，这个permitsPerSecond相当于令牌，会囤积起来，最多囤积permitsPerSecond个。

方法二

public static RateLimiter create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) ；

咱大白话翻译(其实源码上有注释，还有举例)：

保证了平均每秒不超过permitsPerSecond个请求。

但是这个创建出来的限流器有一个热身期(warmup period)。

热身期内，RateLimiter会平滑的将其释放令牌的速率加大，直到起达到最大速率。

同样，如果RateLimiter在热身期没有足够的请求(unused),则起速率会逐渐降低到冷却状态。
玩过阿里的那个 Sentinel组件的话，应该对这种热身限流策略不会陌生，其实限流策略都是这几种，万变不离其宗。

设计这个的意图是为了满足那种资源提供方需要热身时间，

而不是每次访问都能提供稳定速率的服务的情况(比如带缓存服务，需要定期刷新缓存的)

参数warmupPeriod和unit决定了其从冷却状态到达最大速率的时间。

再来简单看看尝试获取令牌的 tryAcquire函数

//尝试获取一个令牌,立即返回尝试结果

public boolean tryAcquire();

//尝试获取 permits 个令牌，立即返回尝试结果

public boolean tryAcquire(int permits);

//尝试获取一个令牌,带超时时间传参

public boolean tryAcquire(long timeout, TimeUnit unit);

//尝试获取permits个令牌,带超时时间传参

public boolean tryAcquire(int permits, long timeout, TimeUnit unit);

再看看获取令牌的 acquire函数

//默认 permits是 1 ，也就是默认拿1个令牌

public double acquire();

//令牌自己定，权重大一点的业务，也许需要拿3个令牌才能执行一次（举例）

public double acquire(int permits);

可以看到返回值是个dubbo ，其实这是一个等待的时间：

rateLimiter.acquire()该方法会阻塞线程，直到令牌桶中能取到令牌为止才继续向下执行，并返回等待的时间。

好了，开始结合实际案例玩一把。

模拟场景，我们提供一个账号注册接口，注册接口需要限流。

然后我们再模拟一个并发接口，多线程去调度注册接口，模拟出注册接口被短时间并发调用的场景，看看限流器RateLimiter 玩出来的效果。

首先写个简单的HTTP GET 请求调用函数：

HttpUtil.java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
public class HttpUtil {
    /**
     * get请求
     *
     * @param realUrl
     * @return
     */
    public static String sendGet(URL realUrl) {
        String result = "";
        BufferedReader in = null;
        try {
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 定义 BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(
                    connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送GET请求出现异常！" + e);
            e.printStackTrace();
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return result;
    }
}

然后写个模拟的注册接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@Controller
public class UserController {
    @Autowired
    MyRateLimiter myRateLimiter;
    @RequestMapping("/userRegister")
    @ResponseBody
    public String userRegister() {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //尝试获取令牌
        boolean acquire = myRateLimiter.tryAccountRegisterAcquire();
        System.out.println(Thread.currentThread().getName() + " 尝试 获取令牌结果"+acquire);
        if (acquire) {
            try {
                //模拟业务执行500毫秒
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return Thread.currentThread().getName()+"userRegister 拿到令牌很顺利success [" +  dtf.format(LocalDateTime.now()) + "]";
        } else {
            return Thread.currentThread().getName()+"userRegister 被 limit 限制了 [" +  dtf.format(LocalDateTime.now())+ "]";
        }
    }
}

可以看到这个接口里面，我们当前只玩了一下尝试获取令牌函数 tryAcquire 。

OK，我们来写个多线程调用接口，来看看这时候限流的效果：

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import static com.example.dotest.util.HttpUtil.sendGet;
import static java.util.concurrent.Executors.*;
@RestController
public class TestController {
    ExecutorService fixedThreadPool = newFixedThreadPool(10);
    @RequestMapping("/test")
    public void test() throws MalformedURLException, InterruptedException {
        final URL url = new URL("http://localhost:8696/userRegister");
        for(int i=0;i<10;i++) {
            fixedThreadPool.submit(() -> System.out.println(sendGet(url)));
        }
        fixedThreadPool.shutdown();
        fixedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
    }
}

简析：

可以看到效果：

可以看到我们的代码，目前用的这个 tryAcquire 函数，返回boolean值，只要是拿不到令牌我们就直接不做处理了。

这时候其实也可以考虑这么使用，拿不到的做一些降级、熔断操作或者重试等待啥的。

那么，我们如果想，尝试拿的时候拿不到，让线程自己去帮我们继续自旋去等待持续获取令牌呢？

这时候我们就需要用的是 acquire 函数。

改造一下刚才的模拟接口：

    @RequestMapping("/userRegister")
    @ResponseBody
    public String userRegister() {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //尝试获取令牌
        boolean tryAcquire = myRateLimiter.tryAccountRegisterAcquire();
        System.out.println(Thread.currentThread().getName() + " 尝试 获取令牌结果"+tryAcquire);
        double registerAcquireWaitTime = myRateLimiter.accountRegisterAcquire();
        System.out.println(Thread.currentThread().getName() + "  坚持  获取令牌，被限制的时间是"+registerAcquireWaitTime);
        if (tryAcquire) {
            //模拟业务执行500毫秒
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return Thread.currentThread().getName()+"userRegister 拿到令牌很顺利success [" +  dtf.format(LocalDateTime.now()) + "]";
        } else {
            return Thread.currentThread().getName()+"userRegister拿到令牌不是很顺利被 limit 过，但是还是拿到了 [" +  dtf.format(LocalDateTime.now())+ "]";
        }
    }
}

简析：

继续调用一下接口，看看这时候限流器的效果：

限流效果：

Springboot 小巧简便的限流器使用 RateLimiter

正文

热门文章

最新文章

相关课程

相关电子书

相关实验场景