Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro-preview-05-06· GoogleHugging Face LMArena Human Preference 140K

给出优化后的完整代码

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4.1-2025-04-14’s answer.
  1. User

    给出优化后的完整代码

  2. Gemini Assistant

    好的,我们来对之前的Java代码进行优化。

    优化的主要方向:

    1. 精确的整体超时控制: 使用 CompletableFuture.allOf() 结合 .get(timeout, unit) 可以更精确地控制整体任务的超时。
    2. 更完善的异常处理与聚合:
      • 任务执行的 lambda 内部捕获异常并记录到结果中。
      • execute 方法可以返回一个包含所有任务执行结果的 Map,包括成功、失败及异常信息。
      • 如果发生整体超时,明确标记未完成的任务状态。
    3. 结果反馈: execute 方法返回一个包含每个任务执行结果的结构,方便调用者了解详细情况。
    4. 代码结构调整: 将单个任务的执行逻辑(包括等待、执行、降级、计时、通知下游)封装得更内聚。
    5. 引入 CompletableFuture: 利用 CompletableFuture 来管理异步任务,可以简化超时和完成状态的处理。

    下面是优化后的代码:

    package com.zhuanzhuan.finance_mall.utils.parallel;
    
    import com.zhuanzhuan.finance_mall.utils.parallel.dto.TaskGraph;
    import com.zhuanzhuan.finance_mall.utils.parallel.dto.TaskNode;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Collections;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.TimeoutException;
    import java.util.stream.Collectors;
    
    /**
     * 通用任务执行入口(优化版)
     *
     * @Author youzhiqiang
     * @Date 2025-05-29 10:26 (Original)
     * @Date 2025-05-30 (Optimized)
     */
    @Slf4j
    public class ParallelTaskEngine<T> {
    
        private final ExecutorService executor;
        private final TaskGraph<T> taskGraph;
    
        public ParallelTaskEngine(ExecutorService executor, TaskGraph<T> taskGraph) {
            if (executor == null) {
                throw new IllegalArgumentException("ExecutorService cannot be null");
            }
            if (taskGraph == null) {
                throw new IllegalArgumentException("TaskGraph cannot be null");
            }
            this.executor = executor;
            this.taskGraph = taskGraph;
        }
    
        /**
         * 执行任务图中的所有任务。
         *
         * @param context          任务上下文
         * @param overallTimeoutMillis 整体执行超时时间(毫秒)
         * @return Map<String, TaskExecutionResult> 每个任务名到其执行结果的映射
         * @throws InterruptedException  如果等待所有任务完成时线程被中断
         * @throws OverallTimeoutException 如果整体执行超时
         */
        public Map<String, TaskExecutionResult> execute(T context, long overallTimeoutMillis)
                throws InterruptedException, OverallTimeoutException {
    
            Map<String, CountDownLatch> latchMap = new ConcurrentHashMap<>();
            Map<String, CompletableFuture<Void>> taskFutures = new ConcurrentHashMap<>();
            Map<String, TaskExecutionResult> results = new ConcurrentHashMap<>();
    
            // 1. 初始化所有任务的执行结果和依赖计数器
            taskGraph.getTaskMap().forEach((taskName, node) -> {
                results.put(taskName, new TaskExecutionResult(taskName));
                latchMap.put(taskName, new CountDownLatch(taskGraph.getDependencyCounts().getOrDefault(taskName, 0)));
            });
    
            // 2. 提交所有任务到线程池
            for (String taskName : taskGraph.getTaskMap().keySet()) {
                TaskNode<T> node = taskGraph.getTaskMap().get(taskName);
                CountDownLatch taskOwnLatch = latchMap.get(taskName); // 此任务等待其上游的latch
                TaskExecutionResult taskResult = results.get(taskName);
    
                CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
                    try {
                        runSingleTaskLogic(context, taskName, node, taskOwnLatch, taskResult, latchMap);
                    } catch (Throwable e) { //捕获所有可能的异常,确保CompletableFuture不会意外终止
                        log.error("ParallelTaskEngine taskName={} Unhandled exception in async execution.", taskName, e);
                        taskResult.setStatus(TaskExecutionResult.Status.FAILED);
                        taskResult.setException(e);
                        // 确保下游任务能感知到失败(如果设计为快速失败,这里可以不 countDown)
                        // 但通常即使失败,也应该通知下游,下游自行决定如何处理(例如,下游也有降级)
                        // 如果不通知,依赖此失败任务的下游会因等待超时而失败。
                        // 当前设计是:即使当前任务失败,也通知下游,让依赖它的任务的latch.await()返回。
                        // 下游任务需要自己检查依赖任务的执行结果(如果需要的话),或依赖引擎的超时。
                        notifyDependents(taskName, latchMap);
                    }
                }, executor);
                taskFutures.put(taskName, future);
            }
    
            // 3. 等待所有任务完成或整体超时
            CompletableFuture<Void> allTasksFuture = CompletableFuture.allOf(
                    taskFutures.values().toArray(new CompletableFuture[0])
            );
    
            try {
                allTasksFuture.get(overallTimeoutMillis, TimeUnit.MILLISECONDS);
            } catch (TimeoutException e) {
                log.warn("ParallelTaskEngine overall execution timed out after {} ms.", overallTimeoutMillis);
                // 标记所有未完成的任务为超时,并尝试取消它们
                taskFutures.forEach((name, fut) -> {
                    if (!fut.isDone()) {
                        fut.cancel(true); // 尝试中断线程
                        TaskExecutionResult result = results.get(name);
                        // 只有当任务本身还未因其他原因(如等待依赖超时)结束时,才标记为整体超时
                        if (result.getStatus() == TaskExecutionResult.Status.PENDING || result.getStatus() == TaskExecutionResult.Status.RUNNING) {
                             result.setStatus(TaskExecutionResult.Status.TIMED_OUT_OVERALL);
                             result.setException(new TimeoutException("Task '" + name + "' cancelled due to overall timeout."));
                        }
                    }
                });
                // 抛出自定义的整体超时异常,可以携带部分结果
                throw new OverallTimeoutException("Overall task execution timed out.", e, Collections.unmodifiableMap(results));
            } catch (InterruptedException e) {
                log.warn("ParallelTaskEngine execution was interrupted.");
                // 尝试取消所有任务
                taskFutures.forEach((name, fut) -> fut.cancel(true));
                Thread.currentThread().interrupt(); // 恢复中断状态
                throw e; // 将InterruptedException向上抛出
            } catch (Exception e) { // CompletableFuture.allOf().get() 在有任务异常完成时会抛出ExecutionException
                log.error("ParallelTaskEngine encountered an error while waiting for all tasks.", e);
                // 此时,部分任务可能已在各自的CompletableFuture中记录了异常和状态
                // 此处的e是第一个失败任务的ExecutionException
                // 我们更依赖于results map中记录的各个任务的详细状态
            }
    
            // 4. 确保所有任务结果都已最终确定 (处理未被 overall timeout 影响,但自行失败的情况)
            // 通常在CompletableFuture的lambda中已经处理了各自的状态。
            // 这里可以再次检查,以防万一。
            taskFutures.forEach((name, fut) -> {
                TaskExecutionResult result = results.get(name);
                if (fut.isCompletedExceptionally() && result.getStatus() == TaskExecutionResult.Status.RUNNING) {
                    // 如果 future 异常完成,但 result 状态还是 RUNNING (可能 lambda 内部未完全更新)
                    try {
                        fut.getNow(null); // 触发异常填充
                    } catch (Exception ex) {
                        result.setStatus(TaskExecutionResult.Status.FAILED);
                        result.setException(ex.getCause() != null ? ex.getCause() : ex);
                    }
                } else if (fut.isCancelled() && result.getStatus() == TaskExecutionResult.Status.RUNNING) {
                     result.setStatus(TaskExecutionResult.Status.CANCELLED);
                     result.setException(new InterruptedException("Task '" + name + "' was cancelled."));
                }
            });
    
    
            return Collections.unmodifiableMap(results);
        }
    
        private void runSingleTaskLogic(T context, String taskName, TaskNode<T> node,
                                        CountDownLatch taskOwnLatch, TaskExecutionResult taskResult,
                                        Map<String, CountDownLatch> allLatchesMap) {
            long taskProcessStartTime = System.currentTimeMillis();
            taskResult.setStartTime(taskProcessStartTime);
            taskResult.setStatus(TaskExecutionResult.Status.WAITING_FOR_DEPS);
    
            // 1. 等待依赖任务完成
            long waitStartTime = System.currentTimeMillis();
            try {
                if (taskOwnLatch.getCount() > 0) { // 只有在确实有依赖时才等待
                    log.debug("ParallelTaskEngine taskName={} waiting for {} dependencies.", taskName, taskOwnLatch.getCount());
                    boolean dependenciesMet = taskOwnLatch.await(node.waitTimeoutMillis, TimeUnit.MILLISECONDS);
                    if (!dependenciesMet) {
                        long waitTime = System.currentTimeMillis() - waitStartTime;
                        taskResult.setWaitTimeMillis(waitTime);
                        taskResult.setEndTime(System.currentTimeMillis());
                        taskResult.setStatus(TaskExecutionResult.Status.TIMED_OUT_WAITING_DEPS);
                        taskResult.setException(new TimeoutException("Task " + taskName + " timed out after " + waitTime + "ms waiting for dependencies."));
                        log.warn("ParallelTaskEngine taskName={} timed out waiting for dependencies. Waited: {}ms", taskName, waitTime);
                        return; // 不再执行后续逻辑,也不通知下游(因为自己未完成)
                    }
                }
            } catch (InterruptedException e) {
                long waitTime = System.currentTimeMillis() - waitStartTime;
                taskResult.setWaitTimeMillis(waitTime);
                taskResult.setEndTime(System.currentTimeMillis());
                taskResult.setStatus(TaskExecutionResult.Status.CANCELLED);
                taskResult.setException(e);
                log.warn("ParallelTaskEngine taskName={} interrupted while waiting for dependencies. Waited: {}ms", taskName, waitTime, e);
                Thread.currentThread().interrupt(); // 恢复中断状态
                return; // 不再执行后续逻辑
            }
            long totalWaitTime = System.currentTimeMillis() - waitStartTime;
            taskResult.setWaitTimeMillis(totalWaitTime);
    
            // 2. 执行主任务逻辑
            taskResult.setStatus(TaskExecutionResult.Status.RUNNING);
            log.info("ParallelTaskEngine taskName={} begin. Waited for deps: {}ms", taskName, totalWaitTime);
            long logicStartTime = System.currentTimeMillis();
            Throwable taskException = null;
            try {
                node.logic.run(context);
                taskResult.setStatus(TaskExecutionResult.Status.SUCCESS);
            } catch (Exception e) {
                taskException = e; // 先保存主逻辑异常
                log.error("ParallelTaskEngine taskName={} main logic error. {}", taskName, node.fallback != null ? "Attempting fallback." : "No fallback.", e);
                // 3. 如果主逻辑异常且存在降级方法,尝试执行降级逻辑
                if (node.fallback != null) {
                    log.info("ParallelTaskEngine taskName={} executing fallback due to error.", taskName);
                    try {
                        node.fallback.accept(context);
                        taskResult.setStatus(TaskExecutionResult.Status.SUCCESS_WITH_FALLBACK);
                        taskException = null; // 降级成功,清除主逻辑异常,任务算部分成功
                    } catch (Exception fallbackError) {
                        log.error("ParallelTaskEngine taskName={} fallback logic also failed!", taskName, fallbackError);
                        taskResult.setStatus(TaskExecutionResult.Status.FAILED_FALLBACK_FAILED);
                        // 记录降级失败的异常,但主异常还是原始的taskException
                        if (taskException != null) {
                            taskException.addSuppressed(fallbackError); // 将降级异常附加到主异常
                        } else { // 这种情况理论上不应发生,因为只有主逻辑出错才进fallback
                            taskException = fallbackError;
                        }
                    }
                } else {
                    // 没有降级逻辑,任务直接失败
                    taskResult.setStatus(TaskExecutionResult.Status.FAILED);
                }
            } finally {
                long logicEndTime = System.currentTimeMillis();
                taskResult.setExecutionTimeMillis(logicEndTime - logicStartTime);
                taskResult.setEndTime(System.currentTimeMillis());
                if (taskException != null) {
                    taskResult.setException(taskException);
                }
                log.info("ParallelTaskEngine taskName={} completed with status {}. WaitTime={}ms, ExecutionTime={}ms, TotalTaskTime={}ms",
                        taskName, taskResult.getStatus(), totalWaitTime, taskResult.getExecutionTimeMillis(),
                        (taskResult.getEndTime() - taskProcessStartTime));
    
                // 4. 通知依赖此任务的其他任务(无论成功失败,都应通知,除非是等待依赖超时或被中断)
                // 如果是因为等待依赖超时或被中断而提前返回,则不应通知下游,因为任务本身未“完成”其承诺。
                // 如果任务执行了(即使失败),它也“完成”了,下游可以继续。
                if (taskResult.getStatus() != TaskExecutionResult.Status.TIMED_OUT_WAITING_DEPS &&
                    taskResult.getStatus() != TaskExecutionResult.Status.CANCELLED) {
                     notifyDependents(taskName, allLatchesMap);
                }
            }
        }
    
        private void notifyDependents(String taskName, Map<String, CountDownLatch> allLatchesMap) {
            taskGraph.getReverseDeps().getOrDefault(taskName, Collections.emptyList())
                .forEach(dependentTaskName -> {
                    CountDownLatch dependentLatch = allLatchesMap.get(dependentTaskName);
                    if (dependentLatch != null) {
                        dependentLatch.countDown();
                        log.debug("ParallelTaskEngine taskName={} notified dependent {}, its latch count is now {}",
                                taskName, dependentTaskName, dependentLatch.getCount());
                    }
                });
        }
    
    
        /**
         * 自定义整体超时异常
         */
        public static class OverallTimeoutException extends Exception {
            private final Map<String, TaskExecutionResult> partialResults;
    
            public OverallTimeoutException(String message, Throwable cause, Map<String, TaskExecutionResult> partialResults) {
                super(message, cause);
                this.partialResults = partialResults;
            }
    
            public Map<String, TaskExecutionResult> getPartialResults() {
                return partialResults;
            }
        }
    }
    

    配套的 TaskExecutionResult 类:

    package com.zhuanzhuan.finance_mall.utils.parallel; // 假设放在同一包下
    
    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @Getter
    @Setter
    @ToString
    public class TaskExecutionResult {
        private final String taskName;
        private Status status;
        private long startTime; // 任务开始处理的时间(包括等待依赖)
        private long endTime;   // 任务结束处理的时间
        private long waitTimeMillis; // 等待上游依赖的时间
        private long executionTimeMillis; // 实际执行逻辑(包括降级)的时间
        private Throwable exception;
    
        public enum Status {
            PENDING,                // 任务已提交,等待执行条件
            WAITING_FOR_DEPS,       // 正在等待依赖完成
            RUNNING,                // 任务逻辑正在执行
            SUCCESS,                // 成功完成
            SUCCESS_WITH_FALLBACK,  // 主逻辑失败,但降级逻辑成功
            FAILED,                 // 主逻辑失败,且无降级或降级未启用
            FAILED_FALLBACK_FAILED, // 主逻辑失败,降级逻辑也失败
            TIMED_OUT_WAITING_DEPS, // 等待依赖超时
            TIMED_OUT_OVERALL,      // 因整体执行超时而被取消/标记
            CANCELLED               // 任务被中断或取消
        }
    
        public TaskExecutionResult(String taskName) {
            this.taskName = taskName;
            this.status = Status.PENDING;
        }
    
        public long getTotalTimeMillis() {
            if (endTime > 0 && startTime > 0) {
                return endTime - startTime;
            }
            return 0;
        }
    }
    

    主要改动和优化点说明:

    1. TaskExecutionResult 类:

      • 用于封装每个任务的执行结果,包括状态(Status枚举)、开始/结束时间、等待时间、执行时间、异常信息。
      • Status 枚举更细致地描述了任务的各种可能状态。
    2. execute 方法:

      • 返回类型: 改为 Map<String, TaskExecutionResult>,返回所有任务的执行结果。
      • 初始化: 在开始时就为每个任务创建 TaskExecutionResult 实例并放入 results map。
      • 任务提交: 使用 CompletableFuture.runAsync() 提交任务。每个 CompletableFuture 的 lambda 内部调用 runSingleTaskLogic。
      • 整体超时:
        • CompletableFuture.allOf(taskFutures.values().toArray(new CompletableFuture[0])) 创建一个代表所有任务完成的 CompletableFuture。
        • allTasksFuture.get(overallTimeoutMillis, TimeUnit.MILLISECONDS) 等待所有任务完成,并应用整体超时。
        • 如果发生 TimeoutException,遍历所有 taskFutures,取消未完成的任务,并更新其在 results 中的状态为 TIMED_OUT_OVERALL。然后抛出自定义的 OverallTimeoutException,该异常可携带部分已完成的任务结果。
      • 异常处理:
        • allTasksFuture.get() 可能抛出 ExecutionException(如果某个任务内部抛异常且未被 CompletableFuture 的 lambda 捕获)或 InterruptedException。
        • InterruptedException 会被妥善处理:恢复中断状态并重新抛出。
      • 结果聚合: 最终返回的 results map 包含了所有任务的最终状态。
    3. runSingleTaskLogic 方法:

      • 这个私有方法封装了单个任务的完整生命周期管理:
        • 状态更新: 在不同阶段更新 TaskExecutionResult 的状态。
        • 等待依赖: taskOwnLatch.await() 等待依赖,并处理等待超时。如果等待超时或被中断,则提前返回,不执行后续逻辑也不通知下游。
        • 计时: 分别记录等待依赖的时间 (waitTimeMillis) 和实际执行逻辑的时间 (executionTimeMillis)。
        • 主逻辑与降级:
          • 执行 node.logic.run()。
          • 如果主逻辑异常,尝试执行 node.fallback.accept()。
          • 根据主逻辑和降级逻辑的执行情况,设置不同的成功/失败状态 (SUCCESS, SUCCESS_WITH_FALLBACK, FAILED, FAILED_FALLBACK_FAILED)。
          • 如果降级也失败,使用 taskException.addSuppressed(fallbackError) 将降级异常附加到主逻辑异常上。
        • 异常记录: 捕获的异常记录到 taskResult.setException()。
        • 日志: 提供更详细的日志,包括等待时间、执行时间和最终状态。
        • 通知下游: 在 finally 块中,如果任务本身不是因为等待依赖超时或被中断而结束,则调用 notifyDependents 来 countDown 依赖此任务的其他任务的 Latch。
    4. notifyDependents 方法:

      • 从 runSingleTaskLogic 中提取出来,负责通知下游任务。
    5. OverallTimeoutException 自定义异常:

      • 用于在整体超时发生时抛出,可以携带当前已有的任务执行结果。
    6. 健壮性:

      • 对 executor 和 taskGraph 参数增加了 null 检查。
      • CompletableFuture.runAsync 的 lambda 中增加了顶层 try-catch (Throwable) 来防止未捕获的异常导致 CompletableFuture 异常完成而没有更新 TaskExecutionResult。

    使用这个优化版本的引擎:

    调用者现在可以从 execute 方法获取一个包含所有任务详细执行结果的 Map。如果发生 OverallTimeoutException,可以通过其 getPartialResults() 方法获取超时发生时已有的任务结果。这使得调用方能够更好地理解并行任务的执行情况并进行相应的处理。

    这种设计在错误处理和状态反馈方面更为完善和明确。

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