Java你们的限流是怎么做的

在Java中,限流(Rate Limiting)是一种控制服务访问速率的技术,以防止服务过载或被滥用。限流通常用于API、数据库访问、网络连接等场景。在Java中实现限流,你可以使用以下几种方法:

1. 计数器(Counter):

使用一个计数器和时间窗口来实现限流。在指定的时间窗口内,限制访问次数。当访问次数达到阈值时,拒绝后续访问。

```java
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.TimeUnit;

public class RateLimiter {
    private final int limit;
    private final long timeInterval;
    private AtomicInteger counter;

    public RateLimiter(int limit, long timeInterval, TimeUnit timeUnit) {
        this.limit = limit;
        this.timeInterval = TimeUnit.MILLISECONDS.convert(timeInterval, timeUnit);
        this.counter = new AtomicInteger(0);
    }

    public boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (counter.get() < limit) {
            if (now - counter.get() < timeInterval) {
                return false;
            }
            counter.set(now);
            return true;
        } else {
            return false;
        }
    }
}
```

2. 令牌桶(Token Bucket):

令牌桶算法是一种基于令牌(token)的限流方法,令牌以固定的速率生成,并存储在桶中。当有请求到达时,先从桶中获取令牌,如果获取到令牌,则允许访问;否则,拒绝访问。

```java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class TokenBucketRateLimiter {
    private final int tokenCapacity;
    private final long refillInterval;
    private final BlockingQueue<Integer> bucket;

    public TokenBucketRateLimiter(int tokenCapacity, long refillInterval, TimeUnit timeUnit) {
        this.tokenCapacity = tokenCapacity;
        this.refillInterval = TimeUnit.MILLISECONDS.convert(refillInterval, timeUnit);
        this.bucket = new LinkedBlockingQueue<>(tokenCapacity);
        refill();
    }

    public boolean tryAcquire() {
        bucket.poll();
        if (bucket.size() < tokenCapacity) {
            refill();
        }
        return !bucket.isEmpty();
    }

    private void refill() {
        new Thread(() -> {
            while (true) {
                try {
                    bucket.offer(1, refillInterval, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
}
```

3. 漏桶(Leaky Bucket):

漏桶算法是一种基于固定速率的限流方法,请求以任意速率到达,然后放入漏桶。漏桶以固定速率处理请求,当请求速率超过漏桶的处理速率时,多余的请求将被丢弃。

```java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class LeakyBucketRateLimiter {
    private final int tokenCapacity;
    private final long refillInterval;
    private final BlockingQueue<Long> bucket;

    public LeakyBucketRateLimiter(int tokenCapacity, long refillInterval, TimeUnit timeUnit) {
        this.tokenCapacity = tokenCapacity;
        this.refillInterval = TimeUnit.MILLISECONDS.convert(refillInterval, timeUnit);
        this.bucket = new LinkedBlockingQueue<>(tokenCapacity);
        refill();
    }

    public boolean tryAcquire() {
        bucket.poll();
        if (bucket.size() < tokenCapacity) {
            refill();
        }
        return !bucket.isEmpty();
    }

    private void refill() {
        new Thread(() -> {
            while (true) {
                try {
                    bucket.offer(System.currentTimeMillis() + refillInterval, refillInterval, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
}
```

以上三种方法都可以实现Java中的限流。根据实际需求,你可以选择合适的限流算法。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值