RateLimit--使用guava来做接口限流

一、问题描述  

　　某天A君突然发现自己的接口请求量突然涨到之前的10倍，没多久该接口几乎不可使用，并引发连锁反应导致整个系统崩溃。如何应对这种情况呢？生活给了我们答案：比如老式电闸都安装了保险丝，一旦有人使用超大功率的设备，保险丝就会烧断以保护各个电器不被强电流给烧坏。同理我们的接口也需要安装上“保险丝”，以防止非预期的请求对系统压力过大而引起的系统瘫痪，当流量过大时，可以采取拒绝或者引流等机制。 

二、常用的限流算法

      常用的限流算法有两种：漏桶算法和令牌桶算法，这篇博文介绍得比较清晰（过载保护算法浅析）。

      漏桶算法思路很简单，请求先进入到漏桶里，漏桶以一定的速度出水，当水请求过大会直接溢出，可以看出漏桶算法能强行限制数据的传输速率。

图1 漏桶算法示意图

      对于很多应用场景来说，除了要求能够限制数据的平均传输速率外，还要求允许某种程度的突发传输。这时候漏桶算法可能就不合适了，令牌桶算法更为适合。如图2所示，令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。

图2 令牌桶算法示意图

三、限流工具类RateLimiter

 　　google开源工具包guava提供了限流工具类RateLimiter，该类基于“令牌桶算法”，非常方便使用。该类的接口描述请参考：RateLimiter接口描述，具体的使用请参考：RateLimiter使用实践。

RateLimiter 使用Demo

package ratelimite;

import com.google.common.util.concurrent.RateLimiter;
 
public class RateLimiterDemo {
    public static void main(String[] args) {
    	testNoRateLimiter();
    	testWithRateLimiter();
    }
 
    public static void testNoRateLimiter() {
    	Long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            System.out.println("call execute.." + i);
            
        }
        Long end = System.currentTimeMillis();
        
        System.out.println(end - start);
        
    }
    
    public static void testWithRateLimiter() {
    	Long start = System.currentTimeMillis();
        RateLimiter limiter = RateLimiter.create(10.0); // 每秒不超过10个任务被提交
        for (int i = 0; i < 10; i++) {
            limiter.acquire(); // 请求RateLimiter, 超过permits会被阻塞
            System.out.println("call execute.." + i);
            
        }
        Long end = System.currentTimeMillis();
        
        System.out.println(end - start);
        
    }
    
}
 

四 Guava并发：ListenableFuture与RateLimiter示例

概念

        ListenableFuture顾名思义就是可以监听的Future，它是对java原生Future的扩展增强。我们知道Future表示一个异步计算任务，当任务完成时可以得到计算结果。如果我们希望一旦计算完成就拿到结果展示给用户或者做另外的计算，就必须使用另一个线程不断的查询计算状态。这样做，代码复杂，而且效率低下。使用ListenableFuture Guava帮我们检测Future是否完成了，如果完成就自动调用回调函数，这样可以减少并发程序的复杂度。      

        推荐使用第二种方法，因为第二种方法可以直接得到Future的返回值，或者处理错误情况。本质上第二种方法是通过调动第一种方法实现的，做了进一步的封装。

另外ListenableFuture还有其他几种内置实现：

1. SettableFuture：不需要实现一个方法来计算返回值，而只需要返回一个固定值来做为返回值，可以通过程序设置此Future的返回值或者异常信息

2. CheckedFuture： 这是一个继承自ListenableFuture接口，他提供了checkedGet()方法，此方法在Future执行发生异常时，可以抛出指定类型的异常。

   
   

    RateLimiter类似于JDK的信号量Semphore，他用来限制对资源并发访问的线程数，本文介绍RateLimiter使用

代码示例

import  java.util.concurrent.Callable;
import  java.util.concurrent.ExecutionException;
import  java.util.concurrent.Executors;
import  java.util.concurrent.TimeUnit;

import  com.google.common.util.concurrent.FutureCallback;
import  com.google.common.util.concurrent.Futures;
import  com.google.common.util.concurrent.ListenableFuture;
import  com.google.common.util.concurrent.ListeningExecutorService;
import  com.google.common.util.concurrent.MoreExecutors;
import  com.google.common.util.concurrent.RateLimiter;

public  class  ListenableFutureDemo {
    public  static  void  main(String[] args) {
        testRateLimiter();
        testListenableFuture();
    }

    /**
     * RateLimiter类似于JDK的信号量Semphore，他用来限制对资源并发访问的线程数
     */
    public  static  void  testRateLimiter() {
        ListeningExecutorService executorService = MoreExecutors
                .listeningDecorator(Executors.newCachedThreadPool());

        RateLimiter limiter = RateLimiter.create( 5.0 );  // 每秒不超过4个任务被提交

        for  ( int  i =  0 ; i <  10 ; i++) {
            limiter.acquire();  // 请求RateLimiter, 超过permits会被阻塞

            final  ListenableFuture listenableFuture = executorService
                    .submit( new  Task( "is " + i));
        }
    }

    public  static  void  testListenableFuture() {
        ListeningExecutorService executorService = MoreExecutors
                .listeningDecorator(Executors.newCachedThreadPool());

        final  ListenableFuture listenableFuture = executorService
                .submit( new  Task( "testListenableFuture" ));


        //同步获取调用结果
        try  {
            System.out.println(listenableFuture.get());
        }  catch  (InterruptedException e1) {
            e1.printStackTrace();
        }  catch  (ExecutionException e1) {
            e1.printStackTrace();
        }

        //第一种方式
        listenableFuture.addListener( new  Runnable() {
            @Override
            public  void  run() {
                try  {
                    System.out.println( "get listenable future's result "
                            + listenableFuture.get());
                }  catch  (InterruptedException e) {
                    e.printStackTrace();
                }  catch  (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }, executorService);

        //第二种方式
        Futures.addCallback(listenableFuture,  new  FutureCallback() {
            @Override
            public  void  onSuccess(Integer result) {
                System.out
                        .println( "get listenable future's result with callback "
                                + result);
            }

            @Override
            public  void  onFailure(Throwable t) {
                t.printStackTrace();
            }
        });
    }
}

class  Task  implements  Callable {
    String str;
    public  Task(String str){
        this .str = str;
    }
    @Override
    public  Integer call()  throws  Exception {
        System.out.println( "call execute.."  + str);
        TimeUnit.SECONDS.sleep( 1 );
        return  7 ;
    }
}

Guava版本

< dependency >
            < groupId >com.google.guava groupId >
            < artifactId >guava artifactId >
            < version >14.0.1 version >
        dependency >

本文是对以下文章的加工整合。

http://www.w2bc.com/Article/10235

http://my.oschina.net/cloudcoder/blog/359598