// 热点商品限流示例
public class HotProductLimiter {
    private final Cache<String, RateLimiter> productLimiters;
    private final RateLimiter defaultLimiter;
    
    public HotProductLimiter() {
        this.productLimiters = CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();
        this.defaultLimiter = RateLimiter.create(1000); // 默认1000 QPS
    }
    
    public boolean allowAccess(String productId) {
        // 热点商品使用专门的限流器
        if (isHotProduct(productId)) {
            try {
                RateLimiter limiter = productLimiters.get(productId, () -> 
                    RateLimiter.create(getHotProductRate(productId)));
                return limiter.tryAcquire();
            } catch (ExecutionException e) {
                return defaultLimiter.tryAcquire();
            }
        }
        return defaultLimiter.tryAcquire();
    }
    
    private boolean isHotProduct(String productId) {
        // 通过监控数据判断是否为热点商品
        // 实际实现中可以从监控系统获取数据
        return HotProductCache.isHot(productId);
    }
    
    private double getHotProductRate(String productId) {
        // 根据商品重要性和历史数据确定限流阈值
        return HotProductCache.getRate(productId);
    }
}

API开放平台场景

场景特点

多租户：需要为不同的租户提供独立的资源配额
差异化服务：不同级别的用户享受不同的服务质量
滥用防护：需要防止恶意爬虫和滥用行为

保护策略

用户级别限流：为不同用户设置不同的请求频率限制
API级别限流：对不同的API接口设置不同的限流策略
IP黑白名单：通过IP黑白名单机制防止恶意访问

实施要点

// 多租户限流示例
public class MultiTenantLimiter {
    private final Cache<String, TenantLimiter> tenantLimiters;
    
    public MultiTenantLimiter() {
        this.tenantLimiters = CacheBuilder.newBuilder()
            .maximumSize(10000)
            .expireAfterWrite(1, TimeUnit.HOURS)
            .build();
    }
    
    public boolean allowRequest(String tenantId, String apiName) {
        try {
            TenantLimiter limiter = tenantLimiters.get(tenantId, () -> 
                new TenantLimiter(tenantId));
            return limiter.allowRequest(apiName);
        } catch (ExecutionException e) {
            // 如果获取租户限流器失败，默认允许请求
            return true;
        }
    }
}

class TenantLimiter {
    private final Map<String, RateLimiter> apiLimiters;
    private final TenantConfig tenantConfig;
    
    public TenantLimiter(String tenantId) {
        this.tenantConfig = TenantConfigManager.getTenantConfig(tenantId);
        this.apiLimiters = new ConcurrentHashMap<>();
        // 初始化各个API的限流器
        initApiLimiters();
    }
    
    private void initApiLimiters() {
        for (Map.Entry<String, Integer> entry : tenantConfig.getApiLimits().entrySet()) {
            String apiName = entry.getKey();
            Integer limit = entry.getValue();
            apiLimiters.put(apiName, RateLimiter.create(limit));
        }
    }
    
    public boolean allowRequest(String apiName) {
        RateLimiter limiter = apiLimiters.get(apiName);
        if (limiter != null) {
            return limiter.tryAcquire();
        }
        // 如果没有配置特定API的限流器，使用默认限流器
        return getDefaultLimiter().tryAcquire();
    }
    
    private RateLimiter getDefaultLimiter() {
        return RateLimiter.create(tenantConfig.getDefaultLimit());
    }
}

内部服务保护场景

场景特点

服务依赖复杂：服务之间存在复杂的依赖关系
资源竞争激烈：多个上游服务竞争同一资源
故障传播快：一个服务的故障会快速传播到其他服务

保护策略

服务级别限流：对核心服务进行整体保护
调用方隔离：对不同的调用方进行隔离，防止单个调用方拖垮服务
熔断降级：结合熔断机制，在服务异常时快速失败

实施要点

// 内部服务保护示例
public class InternalServiceProtector {
    private final Map<String, RateLimiter> callerLimiters;
    private final RateLimiter serviceLimiter;
    private final CircuitBreaker circuitBreaker;
    
    public InternalServiceProtector(String serviceName, int serviceLimit) {
        this.callerLimiters = new ConcurrentHashMap<>();
        this.serviceLimiter = RateLimiter.create(serviceLimit);
        this.circuitBreaker = CircuitBreaker.ofDefaults(serviceName);
    }
    
    public <T> T execute(String callerId, Supplier<T> supplier) {
        // 熔断器检查
        if (!circuitBreaker.tryAcquirePermission()) {
            throw new ServiceUnavailableException("Service is currently unavailable");
        }
        
        // 调用方限流检查
        if (!checkCallerLimit(callerId)) {
            throw new RateLimitExceededException("Caller rate limit exceeded");
        }
        
        // 服务整体限流检查
        if (!serviceLimiter.tryAcquire()) {
            throw new RateLimitExceededException("Service rate limit exceeded");
        }
        
        // 执行业务逻辑
        long startTime = System.nanoTime();
        try {
            T result = supplier.get();
            long duration = System.nanoTime() - startTime;
            circuitBreaker.onSuccess(duration, TimeUnit.NANOSECONDS);
            return result;
        } catch (Exception e) {
            long duration = System.nanoTime() - startTime;
            circuitBreaker.onError(duration, TimeUnit.NANOSECONDS, e);
            throw e;
        }
    }
    
    private boolean checkCallerLimit(String callerId) {
        RateLimiter limiter = callerLimiters.computeIfAbsent(callerId, 
            k -> RateLimiter.create(getCallerLimit(callerId)));
        return limiter.tryAcquire();
    }
    
    private int getCallerLimit(String callerId) {
        // 根据调用方重要性设置不同的限流阈值
        return CallerConfigManager.getLimit(callerId);
    }
}

资源识别与分类

关键资源识别

计算资源

CPU：高CPU消耗的操作需要特别关注
内存：大内存操作可能导致OOM
线程池：线程池耗尽可能导致请求排队

存储资源

数据库连接：数据库连接池耗尽会影响所有数据库操作
缓存：缓存击穿、穿透问题
文件系统：文件读写操作可能成为瓶颈

网络资源

带宽：网络带宽限制
连接数：TCP连接数限制
第三方服务：对外部服务的调用限制

资源保护策略

// 综合资源保护示例
public class ResourceProtector {
    private final RateLimiter cpuLimiter;
    private final Semaphore memorySemaphore;
    private final Semaphore dbConnectionSemaphore;
    
    public ResourceProtector(ResourceConfig config) {
        this.cpuLimiter = RateLimiter.create(config.getCpuLimit());
        this.memorySemaphore = new Semaphore(config.getMemoryLimit());
        this.dbConnectionSemaphore = new Semaphore(config.getDbConnectionLimit());
    }
    
    public <T> T executeWithProtection(Supplier<T> supplier, 
                                      int memoryCost, 
                                      int dbConnections) {
        // CPU限流
        if (!cpuLimiter.tryAcquire()) {
            throw new ResourceExhaustedException("CPU limit exceeded");
        }
        
        // 内存资源检查
        if (!memorySemaphore.tryAcquire(memoryCost)) {
            throw new ResourceExhaustedException("Memory limit exceeded");
        }
        
        // 数据库连接检查
        if (!dbConnectionSemaphore.tryAcquire(dbConnections)) {
            // 释放已获取的内存资源
            memorySemaphore.release(memoryCost);
            throw new ResourceExhaustedException("Database connection limit exceeded");
        }
        
        try {
            return supplier.get();
        } finally {
            // 释放资源
            dbConnectionSemaphore.release(dbConnections);
            memorySemaphore.release(memoryCost);
        }
    }
}

风险评估与优先级排序

风险评估模型

影响范围：评估问题发生时的影响范围
发生概率：评估问题发生的可能性
恢复难度：评估问题恢复的难度和时间
业务价值：评估相关业务的价值

优先级排序

根据风险评估结果，对需要保护的服务和资源进行优先级排序：

P0级：核心业务服务，影响范围大，业务价值高
P1级：重要业务服务，有一定影响范围和业务价值
P2级：一般业务服务，影响范围较小
P3级：辅助服务，影响范围最小

通过深入的需求与场景分析，我们可以准确识别需要保护的核心服务与资源，为后续的限流平台设计和实施提供坚实的基础。这不仅能提高系统的稳定性和可靠性，还能确保在有限的资源下实现最大的业务价值。