Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-haiku-20241022· AnthropicHugging Face LMArena Human Preference 140K

批量处理有bug,预期是100ms,实际最大可能是300ms

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro-preview-03-25’s answer.
  1. User

    批量处理有bug,预期是100ms,实际最大可能是300ms

  2. Claude Assistant

    你说得对。以下是一个改进的批量处理方法,确保总体超时时间不超过指定时间:

    public static <T> List<T> getQuietly(List<CompletableFuture<T>> futures, long timeout, TimeUnit timeUnit) {
        if (CollectionUtils.isEmpty(futures)) {
            return Collections.emptyList();
        }
    
        long startTime = System.currentTimeMillis();
        List<T> results = new ArrayList<>(futures.size());
    
        for (CompletableFuture<T> future : futures) {
            // 计算剩余超时时间
            long elapsedTime = System.currentTimeMillis() - startTime;
            long remainingTimeout = timeout - elapsedTime;
    
            // 如果已经超时,直接退出
            if (remainingTimeout <= 0) {
                break;
            }
    
            // 使用剩余时间获取结果
            T result = getQuietly(future, remainingTimeout, timeUnit);
            results.add(result);
        }
    
        return results;
    }
    
    // 并行处理的优化版本
    public static <T> List<T> getQuietlyParallel(List<CompletableFuture<T>> futures, long timeout, TimeUnit timeUnit) {
        if (CollectionUtils.isEmpty(futures)) {
            return Collections.emptyList();
        }
    
        // 创建一个组合的 Future,设置总体超时
        CompletableFuture<Void> allOf = CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        );
    
        try {
            // 等待所有 Future 完成,但不超过指定时间
            allOf.get(timeout, timeUnit);
    
            // 收集结果
            return futures.stream()
                .map(future -> getQuietly(future, timeout, timeUnit))
                .collect(Collectors.toList());
    
        } catch (TimeoutException e) {
            // 如果超时,收集已完成的结果
            return futures.stream()
                .filter(CompletableFuture::isDone)
                .map(future -> getQuietly(future, 0, timeUnit))
                .collect(Collectors.toList());
        } catch (Exception e) {
            log.error("Parallel future processing error", e);
            return Collections.emptyList();
        }
    }
    

    使用示例:

    // 串行处理
    List<CompletableFuture<String>> futures = Arrays.asList(
        CompletableFuture.supplyAsync(() -> { sleep(50); return "A"; }),
        CompletableFuture.supplyAsync(() -> { sleep(50); return "B"; }),
        CompletableFuture.supplyAsync(() -> { sleep(50); return "C"; })
    );
    
    // 总超时时间100ms,每个任务最多50ms
    List<String> results = FutureUtils.getQuietly(futures, 100, TimeUnit.MILLISECONDS);
    
    // 并行处理
    List<String> parallelResults = FutureUtils.getQuietlyParallel(futures, 100, TimeUnit.MILLISECONDS);
    

    这两个方法的关键改进:

    1. 串行版本 getQuietly:

      • 动态计算剩余超时时间
      • 如果总体已超时,停止处理
      • 确保总体处理时间不超过指定超时时间
    2. 并行版本 getQuietlyParallel:

      • 使用 CompletableFuture.allOf() 协调多个 Future
      • 设置总体超时
      • 如果超时,只返回已完成的结果
      • 更高效,适合并行处理场景

    额外建议:

    // 如果需要更精细的控制,可以添加一个重载方法
    public static <T> List<T> getQuietlyParallel(
        List<CompletableFuture<T>> futures, 
        long timeout, 
        TimeUnit timeUnit, 
        boolean returnPartialResults
    ) {
        // 实现更复杂的部分结果处理逻辑
    }
    

    注意事项:

    • 确保导入必要的工具类(CollectionUtils)
    • 根据具体业务场景选择串行或并行方法
    • 并行方法性能更好,但需要注意资源消耗

    这个实现确保了:

    1. 总体处理时间不会显著超过指定超时时间
    2. 能够处理部分完成的任务
    3. 提供了灵活的错误处理机制

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.