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中的限流。根据实际需求，你可以选择合适的限流算法。