Spring WebFlux服务按比例分配请求逻辑：随机数生成方案对比

我有一个基于Spring Boot WebFlux的REST API服务，需要根据外部配置的百分比为不同请求分配对应逻辑——比如70%请求执行逻辑A、20%执行逻辑B、10%执行逻辑C。我提出了两种生成1-100随机数的方案来实现这个需求，现在对比它们在随机分布准确性和性能上的优劣，同时给出其他可行方案。

两种方案代码 #

方案一：基于UUID.hashCode生成随机数 #

int logicA = 70;
int logicB = 20;
int logicC = 10;

UUID uuid = UUID.randomUUID();
int randomNumberBetween1and100 = (Math.abs(uuid.hashCode()) % 99) + 1;

if(randomNumberBetween1and100 <= logicA){
    //do logic A operations
}
else if(randomNumberBetween1and100 > logicA && randomNumberBetween1and100 <= (logicA + logicB) ){
    //do logic B operations
}
else if(randomNumberBetween1and100 > (logicA + logicB) && randomNumberBetween1and100 <= (logicA + logicB + logicC) ){
    //do logic C operations
}

方案二：基于Random生成随机数 #

int logicA = 70;
int logicB = 20;
int logicC = 10;

Random random = new Random();
int randomNumberBetween1and100 = random.nextInt(99) + 1;

if(randomNumberBetween1and100 <= logicA){
    //do logic A operations
}
else if(randomNumberBetween1and100 > logicA && randomNumberBetween1and100 <= (logicA + logicB) ){
    //do logic B operations
}
else if(randomNumberBetween1and100 > (logicA + logicB) && randomNumberBetween1and100 <= (logicA + logicB + logicC) ){
    //do logic C operations
}

方案对比 #

1. 随机分布准确性 #

• 方案一：UUID的哈希算法并非为均匀随机分布设计，生成的hashCode存在潜在分布偏差，长期运行可能无法严格匹配配置比例。另外代码中%99会生成0-98的数，加1后仅覆盖1-99，丢失了100这个值，导致逻辑C的实际占比从10%降到9%，直接破坏了比例准确性。
• 方案二：Random是Java专门的伪随机数生成工具，分布均匀性远优于UUID方案。但当前代码中nextInt(99)同样会丢失100这个值，需改成nextInt(100)+1才能覆盖1-100。另外要注意不能每次请求都新建Random实例——高并发下多个实例种子可能重复，导致随机数重复，影响分布均匀性。

2. 性能表现 #

• 方案一：生成UUID需要处理复杂的字节结构与随机数据，计算开销远大于生成单个随机整数，在WebFlux高并发场景下，频繁生成UUID会显著增加服务响应延迟。
• 方案二：Random的性能远高于UUID，但频繁创建Random实例会带来对象初始化开销，且线程安全问题（多个线程共用一个Random会有竞争）也会影响性能。正确复用全局Random或使用ThreadLocalRandom才能发挥其性能优势。

其他可行方案 #

1. ThreadLocalRandom（推荐） #

WebFlux是多线程模型，ThreadLocalRandom为每个线程提供独立的随机数生成器，避免线程竞争，性能最优。同时可以直接生成1-100的数，简化代码：

int logicA = 70;
int logicB = 20;

int randomNum = ThreadLocalRandom.current().nextInt(1, 101);

if (randomNum <= logicA) {
    // 执行逻辑A
} else if (randomNum <= logicA + logicB) {
    // 执行逻辑B
} else {
    // 执行逻辑C
}

2. 加权随机算法（动态比例友好） #

如果后续需要动态调整比例或新增逻辑分支，可将权重与逻辑封装，通过累加权重判断：

// 可从外部配置加载权重与逻辑处理器
List<WeightedLogic> logicList = Arrays.asList(
    new WeightedLogic(70, () -> { /* 逻辑A执行逻辑 */ }),
    new WeightedLogic(20, () -> { /* 逻辑B执行逻辑 */ }),
    new WeightedLogic(10, () -> { /* 逻辑C执行逻辑 */ })
);

int totalWeight = logicList.stream().mapToInt(WeightedLogic::getWeight).sum();
int randomNum = ThreadLocalRandom.current().nextInt(1, totalWeight + 1);

int currentWeight = 0;
for (WeightedLogic logic : logicList) {
    currentWeight += logic.getWeight();
    if (randomNum <= currentWeight) {
        logic.getLogic().run();
        break;
    }
}

// 辅助类
static class WeightedLogic {
    private int weight;
    private Runnable logic;

    public WeightedLogic(int weight, Runnable logic) {
        this.weight = weight;
        this.logic = logic;
    }

    public int getWeight() {
        return weight;
    }

    public Runnable getLogic() {
        return logic;
    }
}

3. 响应式风格实现（贴合WebFlux） #

结合Reactor框架，将随机数生成纳入响应式链，更符合WebFlux编程模型：

int logicA = 70;
int logicB = 20;

Mono.fromSupplier(() -> ThreadLocalRandom.current().nextInt(1, 101))
    .map(randomNum -> {
        if (randomNum <= logicA) {
            return "LOGIC_A";
        } else if (randomNum <= logicA + logicB) {
            return "LOGIC_B";
        } else {
            return "LOGIC_C";
        }
    })
    .doOnNext(logicKey -> {
        switch (logicKey) {
            case "LOGIC_A":
                // 执行逻辑A
                break;
            case "LOGIC_B":
                // 执行逻辑B
                break;
            case "LOGIC_C":
                // 执行逻辑C
                break;
        }
    })
    .subscribe();

内容的提问来源于stack exchange，提问作者DockYard