限流:漏桶和令牌桶算法 单机实现

import java.time.LocalDateTime;

/**
 * 漏桶
 */
public class LeakyBucket {
    //流水速率  固定
    private double rate;
    //桶的大小
    private double burst;
    //最后更新时间
    private int refreshTime;
    //private Long refreshTime;
    //桶里面的水量
    private int water;

    public LeakyBucket(double rate,double burst){
        this.rate=rate;
        this.burst=burst;
    }

    /**
     * 刷新桶的水量
     */
    private void refreshWater(){
        //long now = System.currentTimeMillis(); //毫秒生成
        LocalDateTime time=LocalDateTime.now();　　//每秒生成
        int now = time.getSecond();
        //现在时间-上次更新的时间   中间花费的时间(秒)*流水速率=流水量(处理的请求的数量)  通过上次水总量减去流水量等于现在的水量
        //如果流水量太多导致桶里都没那么多水就应该置0, 所以通过math.max函数实现
        water = (int)Math.max(0,water-(now-refreshTime)*rate);
        //更新上次时间
        refreshTime = now;
    }

    /**
     * 获取令牌
     */
    public synchronized boolean tryAcquire(){
        //刷新桶的水量
        refreshWater();
        //如果桶的水量小于桶的容量就可以添加进来
        if(water<burst){
            water++;
            return true;
        }else {
            return false;
        }
    }
}

import java.util.concurrent.CountDownLatch;public class LeakyBucketTest {
    public static LeakyBucket leakyBucket = new LeakyBucket(10,100);
    public static void main(String[] args) {long start = System.currentTimeMillis();
        for (int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(leakyBucket.tryAcquire());
                }
            }).start();
        }
        System.out.println("总花费:"+(System.currentTimeMillis()-start));
        System.out.println("线程执行完毕");
    }
}

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>

import com.google.common.util.concurrent.RateLimiter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 令牌桶
 */
public class TokenBucket {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    /**
     * permitsPerSecond为每秒生成的令牌
     *
     */
     /** 平衡稳定 
     * * 创建一个稳定输出令牌的RateLimiter，保证了平均每秒不超过permitsPerSecond个请求
     * * 当请求到来的速度超过了permitsPerSecond，保证每秒只处理permitsPerSecond个请求
     * * 当这个RateLimiter使用不足(即请求到来速度小于permitsPerSecond)，会囤积最多permitsPerSecond个请求
     */
    /**平衡预热
     * 创建一个稳定输出令牌的RateLimiter，保证了平均每秒不超过permitsPerSecond个请求
     * 还包含一个热身期(warmup period),热身期内，RateLimiter会平滑的将其释放令牌的速率加大，直到起达到最大速率
     * 同样，如果RateLimiter在热身期没有足够的请求(unused),则起速率会逐渐降低到冷却状态
     * 设计这个的意图是为了满足那种资源提供方需要热身时间，而不是每次访问都能提供稳定速率的服务的情况(比如带缓存服务，需要定期刷新缓存的)
     * 参数warmupPeriod和unit决定了其从冷却状态到达最大速率的时间
     */
    private static final RateLimiter rateLimiter = RateLimiter.create(10,2L, TimeUnit.SECONDS);
    //private static final RateLimiter rateLimiter = RateLimiter.create(10);

    /**
     * tryAcquire尝试获取permit，默认超时时间是0，意思是拿不到就立即返回false
     * @return
     */
    public String sayHello(){
        if(rateLimiter.tryAcquire()){    //一次拿一个
            System.out.println(sdf.format(new Date()));
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            return "no";
        }
        return "hello";
    }

    /**
     * acquire拿不到就等待,拿到为止
     * @return
     */
    public String sayHi(){
        rateLimiter.acquire(1);  //一次拿5个  意思就是生成10个令牌才去全部拿去给一个请求
        System.out.println(sdf.format(new Date()));
        return "hi";
    }
}

import java.util.concurrent.CountDownLatch;public class LeakyBucketTest {
    private static TokenBucket tokenBucket = new TokenBucket();
    public static void main(String[] args) {long start = System.currentTimeMillis();
        for (int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(tokenBucket.sayHi());
                }
            }).start();
        }
        System.out.println("总花费:"+(System.currentTimeMillis()-start));
        System.out.println("线程执行完毕");
    }
}