#算法耗时优化

Junjie

2026-04-13 2cb43c8bcc1f5b7e6807dfe16bc9e08109bf7833

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -54,6 +54,8 @@
@Component
public class NavigateUtils {

    private static final long STATION_PATH_SLOW_LOG_THRESHOLD_MS = 500L;
    private static final long STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS = 200L;
    private static final double CONGESTION_BUSY_BASE = 1.0d;
    private static final double CONGESTION_ISSUED_RESERVE_BASE = 0.75d;
    private static final double CONGESTION_PENDING_QUEUE_BASE = 0.45d;
@@ -75,6 +77,9 @@
    @Autowired
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    private final Object runtimeSnapshotLock = new Object();
    private volatile CachedStationPathRuntimeSnapshot cachedRuntimeSnapshot;

    public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
                                                         Integer endStationId,
                                                         Integer currentTaskNo,
@@ -91,11 +96,13 @@
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
                StationPathCalcMode.REROUTE,
                runtimeSnapshot
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
@@ -107,7 +114,8 @@
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
                endStationId,
                runtimeSnapshot
        );
        return normalizeCandidatePaths(orderedPathList);
    }
@@ -130,34 +138,61 @@
                                                   Integer currentTaskNo,
                                                   Double pathLenFactor,
                                                   StationPathCalcMode calcMode) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        String pathSource = "fallback";
        int candidateCount = 0;
        List<NavigateNode> resultPath = new ArrayList<>();

        long stepStartNs = System.nanoTime();
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        stepCostMap.put("resolvePolicy", elapsedMillis(stepStartNs));
        stepStartNs = System.nanoTime();
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        stepCostMap.put("loadRuntimeSnapshot", elapsedMillis(stepStartNs));
        if (calcMode != StationPathCalcMode.REROUTE) {
            stepStartNs = System.nanoTime();
            List<NavigateNode> directPath = findStationDirectPath(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
                    resolvedPolicy,
                    runtimeSnapshot
            );
            stepCostMap.put("directPath", elapsedMillis(stepStartNs));
            if (!directPath.isEmpty()) {
                return normalizeStationPath(directPath);
                pathSource = "direct";
                resultPath = normalizeStationPath(directPath);
                logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, pathSource, candidateCount, resultPath.size(), stepCostMap, totalStartNs);
                return resultPath;
            }
        }

        stepStartNs = System.nanoTime();
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
                calcMode,
                runtimeSnapshot
        );
        stepCostMap.put("buildSearchContext", elapsedMillis(stepStartNs));
        if (context.allList.isEmpty()) {
            logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, "empty", candidateCount, 0, stepCostMap, totalStartNs);
            return new ArrayList<>();
        }
        candidateCount = context.allList.size();
        stepStartNs = System.nanoTime();
        List<NavigateNode> list = calcMode == StationPathCalcMode.REACHABILITY
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        return normalizeStationPath(list);
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        stepCostMap.put("selectBestPath", elapsedMillis(stepStartNs));
        pathSource = calcMode == StationPathCalcMode.REACHABILITY ? "reachability" : "twoStage";
        resultPath = normalizeStationPath(list);
        logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, pathSource, candidateCount, resultPath.size(), stepCostMap, totalStartNs);
        return resultPath;
    }

    public List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
@@ -276,18 +311,24 @@
                                                     Integer currentTaskNo,
                                                     Double pathLenFactor,
                                                     StationPathCalcMode calcMode,
                                                     StationPathResolvedPolicy resolvedPolicy) {
                                                     StationPathResolvedPolicy resolvedPolicy,
                                                     StationPathRuntimeSnapshot runtimeSnapshot) {
        if (!supportsDirectPathMode(calcMode, resolvedPolicy, pathLenFactor)) {
            return new ArrayList<>();
        }

        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        long stepStartNs = System.nanoTime();
        DirectStationPathContext context = buildDirectStationPathContext(
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode,
                resolvedPolicy
                resolvedPolicy,
                runtimeSnapshot
        );
        stepCostMap.put("buildDirectContext", elapsedMillis(stepStartNs));
        if (context == null) {
            return new ArrayList<>();
        }
@@ -298,6 +339,7 @@
                endStationId,
                calcMode.name());

        stepStartNs = System.nanoTime();
        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
@@ -313,23 +355,30 @@
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略关键途经点约束后重试");
            }
        }
        stepCostMap.put("searchDirectPath", elapsedMillis(stepStartNs));
        if (searchResult.path.isEmpty()) {
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, 0, stepCostMap, totalStartNs);
            return new ArrayList<>();
        }

        stepStartNs = System.nanoTime();
        if (!isDirectPathValid(
                searchResult.path,
                context,
                searchResult.includeWaypoint,
                searchResult.includeSoftPreference)) {
            stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
            return new ArrayList<>();
        }
        stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));

        News.info("[WCS Debug] 站点路径快速计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode.name());
        logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
        return searchResult.path;
    }

@@ -374,8 +423,12 @@
                return new ArrayList<>();
            }

            NavigateNode segmentStartNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId);
            NavigateNode segmentStartNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentEndStationId);
            if (segmentStartNode == null || segmentEndNode == null) {
                return new ArrayList<>();
            }
@@ -416,7 +469,9 @@
                return buildDirectPath(currentState);
            }

            List<NavigateNode> nextNodeList = context.navigateSolution.extend_current_node(context.stationMap, currentState.node);
            List<NavigateNode> nextNodeList = context.navigateMapIndex == null
                    ? context.navigateSolution.extend_current_node(context.stationMap, currentState.node)
                    : context.navigateSolution.getNeighborNodes(context.navigateMapIndex, currentState.node);
            for (NavigateNode nextNode : safeList(nextNodeList)) {
                if (!isDirectTransitionAllowed(context, currentState.node, nextNode, endNode)) {
                    continue;
@@ -554,23 +609,10 @@
    }

    private int calcLiftTransferPenalty(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return 0;
        }
        try {
            JSONObject valueObject = JSON.parseObject(node.getNodeValue());
            if (valueObject == null) {
                return 0;
            }
            Object isLiftTransfer = valueObject.get("isLiftTransfer");
            if (isLiftTransfer == null) {
                return 0;
            }
            String text = String.valueOf(isLiftTransfer);
            return ("1".equals(text) || "true".equalsIgnoreCase(text)) ? 1 : 0;
        } catch (Exception ignore) {
            return 0;
        }
        return Boolean.TRUE.equals(node.getLiftTransfer()) ? 1 : 0;
    }

    private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
@@ -721,18 +763,20 @@
                                                                   Integer endStationId,
                                                                   Integer currentTaskNo,
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathResolvedPolicy resolvedPolicy) {
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
            throw new CoolException("未找到该 " + startStationId + "起点 对应的站点数据");
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(startStation.getStationLev());
        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(startStation.getStationLev());
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (startNode == null || endNode == null) {
            throw new CoolException("未找到该 起点 或 终点 对应的节点");
            throw new CoolException("未找到该 " + startStationId + "起点 或 " + endStationId + "终点 对应的节点");
        }

        DirectStationPathContext context = new DirectStationPathContext();
@@ -740,6 +784,7 @@
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.navigateMapIndex = navigateMapIndex;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
@@ -751,11 +796,12 @@
                ? StationPathProfileConfig.defaultConfig()
                : context.resolvedPolicy.getProfileConfig();
        context.globalPolicy = loadPathGlobalPolicy(context.profileConfig);
        context.statusMap = loadStationStatusMap();
        context.stationLoopLoadMap = loadStationLoopLoadMap();
        context.trafficSnapshot = loadStationTrafficSnapshot(context.statusMap, currentTaskNo);
        context.loopMergeGuardContext = loadLoopMergeGuardContext();
        context.outStationIdSet = loadAllOutStationIdSet();
        context.runtimeSnapshot = runtimeSnapshot == null ? StationPathRuntimeSnapshot.empty() : runtimeSnapshot;
        context.statusMap = context.runtimeSnapshot.statusMap;
        context.stationLoopLoadMap = context.runtimeSnapshot.stationLoopLoadMap;
        context.trafficSnapshot = context.runtimeSnapshot.trafficSnapshot;
        context.loopMergeGuardContext = context.runtimeSnapshot.loopMergeGuardContext;
        context.outStationIdSet = context.runtimeSnapshot.outStationIdSet;
        context.forbidStationIdSet = new HashSet<>(safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidStations()));
        context.forbidEdgeSet = new HashSet<>();
        for (String edgeText : safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidEdges())) {
@@ -803,8 +849,9 @@
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor,
                                                           Integer startStationId,
                                                           Integer endStationId) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
                                                           Integer endStationId,
                                                           StationPathRuntimeSnapshot runtimeSnapshot) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        if (orderedPathList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -816,11 +863,15 @@
                                                                Integer currentTaskNo,
                                                                Double pathLenFactor,
                                                                Integer startStationId,
                                                                Integer endStationId) {
                                                                Integer endStationId,
                                                                StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        if (allList == null || allList.isEmpty()) {
            return new ArrayList<>();
        }

        long stepStartNs = System.nanoTime();
        StationPathRuleConfig ruleConfig = resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : resolvedPolicy.getRuleConfig();
@@ -828,7 +879,9 @@
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();
        PathGlobalPolicy globalPolicy = loadPathGlobalPolicy(profileConfig);
        stepCostMap.put("loadPolicyConfig", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> filteredCandidates = applyRuleFilters(allList, ruleConfig, true);
        if (filteredCandidates.isEmpty() && hasWaypoint(ruleConfig) && !strictWaypoint(ruleConfig)) {
            filteredCandidates = applyRuleFilters(allList, ruleConfig, false);
@@ -851,16 +904,20 @@
            }
            filteredCandidates = allList;
        }
        stepCostMap.put("filterCandidates", elapsedMillis(stepStartNs));

        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, Double> stationLoopLoadMap = loadStationLoopLoadMap();
        StationTrafficSnapshot trafficSnapshot = loadStationTrafficSnapshot(statusMap, currentTaskNo);
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        Map<Integer, Double> stationLoopLoadMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.stationLoopLoadMap;
        StationTrafficSnapshot trafficSnapshot = runtimeSnapshot == null ? new StationTrafficSnapshot() : runtimeSnapshot.trafficSnapshot;
        LoopMergeGuardContext loopMergeGuardContext = runtimeSnapshot == null ? new LoopMergeGuardContext() : runtimeSnapshot.loopMergeGuardContext;
        Set<LoopMergeEntry> mandatoryLoopMergeEntrySet = resolveMandatoryLoopMergeEntrySet(filteredCandidates, loopMergeGuardContext);
        Set<Integer> outStationIdSet = loadAllOutStationIdSet();
        Set<Integer> outStationIdSet = runtimeSnapshot == null ? Collections.emptySet() : runtimeSnapshot.outStationIdSet;
        stepCostMap.put("loadDynamicContext", elapsedMillis(stepStartNs));
        List<PathCandidateMetrics> metricsList = new ArrayList<>();
        int skippedByOtherOutStation = 0;
        int skippedByLoopMergeGuard = 0;
        stepStartNs = System.nanoTime();
        for (List<NavigateNode> path : filteredCandidates) {
            if (path == null || path.isEmpty()) {
                continue;
@@ -886,12 +943,15 @@
            }
            return new ArrayList<>();
        }
        stepCostMap.put("buildMetrics", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        applyPathLengthPreference(metricsList, profileConfig, globalPolicy, pathLenFactor);
        metricsList.sort((a, b) -> compareStaticCandidateMetrics(a, b, pathLenFactor));
        PathCandidateMetrics preferred = metricsList.get(0);
        int maxLen = (int) Math.ceil(preferred.pathLen * safeDouble(profileConfig.getS1MaxLenRatio(), 1.15d));
        int maxTurns = preferred.turnCount + safeInt(profileConfig.getS1MaxTurnDiff(), 1);
        stepCostMap.put("stage1StaticSort", elapsedMillis(stepStartNs));

        List<PathCandidateMetrics> stage1Selected = new ArrayList<>();
        for (PathCandidateMetrics metrics : metricsList) {
@@ -911,6 +971,7 @@
            primaryMetrics = new ArrayList<>(primaryMetrics.subList(0, topK));
        }

        stepStartNs = System.nanoTime();
        primaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        secondaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

@@ -921,11 +982,26 @@
            }
        }
        remainingMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        stepCostMap.put("stage2DynamicSort", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> orderedPathList = new ArrayList<>();
        appendCandidatePathList(orderedPathList, primaryMetrics);
        appendCandidatePathList(orderedPathList, secondaryMetrics);
        appendCandidatePathList(orderedPathList, remainingMetrics);
        stepCostMap.put("buildOrderedPaths", elapsedMillis(stepStartNs));
        logStationPathOrderSlow(startStationId,
                endStationId,
                currentTaskNo,
                pathLenFactor,
                allList.size(),
                filteredCandidates.size(),
                metricsList.size(),
                orderedPathList.size(),
                skippedByLoopMergeGuard,
                skippedByOtherOutStation,
                stepCostMap,
                totalStartNs);
        return orderedPathList;
    }

@@ -1338,19 +1414,8 @@
    private int countLiftTransferCount(List<NavigateNode> path) {
        int count = 0;
        for (NavigateNode node : safeList(path)) {
            try {
                JSONObject valueObject = JSON.parseObject(node.getNodeValue());
                if (valueObject == null) {
                    continue;
                }
                Object isLiftTransfer = valueObject.get("isLiftTransfer");
                if (isLiftTransfer != null) {
                    String text = String.valueOf(isLiftTransfer);
                    if ("1".equals(text) || "true".equalsIgnoreCase(text)) {
                        count++;
                    }
                }
            } catch (Exception ignore) {
            if (node != null && Boolean.TRUE.equals(node.getLiftTransfer())) {
                count++;
            }
        }
        return count;
@@ -1585,6 +1650,95 @@
        return statusMap;
    }

    private StationPathRuntimeSnapshot loadStationPathRuntimeSnapshot(Integer currentTaskNo) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();

        long stepStartNs = System.nanoTime();
        BaseRuntimeSnapshot baseRuntimeSnapshot = loadBaseRuntimeSnapshot(stepCostMap);
        stepCostMap.put("loadBaseSnapshot", elapsedMillis(stepStartNs));
        if (baseRuntimeSnapshot == null) {
            logRuntimeSnapshotSlow(currentTaskNo, false, stepCostMap, totalStartNs);
            return StationPathRuntimeSnapshot.empty();
        }

        stepStartNs = System.nanoTime();
        StationTrafficSnapshot trafficSnapshot = buildStationTrafficSnapshot(
                baseRuntimeSnapshot.statusMap,
                currentTaskNo,
                baseRuntimeSnapshot.activeTraceList
        );
        stepCostMap.put("buildTrafficSnapshot", elapsedMillis(stepStartNs));
        logRuntimeSnapshotSlow(currentTaskNo, baseRuntimeSnapshot.cacheHit, stepCostMap, totalStartNs);
        return new StationPathRuntimeSnapshot(
                baseRuntimeSnapshot.statusMap,
                baseRuntimeSnapshot.stationLoopLoadMap,
                trafficSnapshot,
                baseRuntimeSnapshot.loopMergeGuardContext,
                baseRuntimeSnapshot.outStationIdSet
        );
    }

    private BaseRuntimeSnapshot loadBaseRuntimeSnapshot(Map<String, Long> stepCostMap) {
        long now = System.currentTimeMillis();
        CachedStationPathRuntimeSnapshot cachedSnapshot = cachedRuntimeSnapshot;
        if (cachedSnapshot != null && now - cachedSnapshot.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
            if (stepCostMap != null) {
                stepCostMap.put("baseSnapshotCacheHit", 0L);
            }
            return cachedSnapshot.baseRuntimeSnapshot.toCacheHitSnapshot();
        }
        synchronized (runtimeSnapshotLock) {
            cachedSnapshot = cachedRuntimeSnapshot;
            if (cachedSnapshot != null && now - cachedSnapshot.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
                if (stepCostMap != null) {
                    stepCostMap.put("baseSnapshotCacheHit", 0L);
                }
                return cachedSnapshot.baseRuntimeSnapshot.toCacheHitSnapshot();
            }
            long stepStartNs = System.nanoTime();
            BaseRuntimeSnapshot baseRuntimeSnapshot = buildBaseRuntimeSnapshot(stepCostMap);
            if (stepCostMap != null) {
                stepCostMap.put("buildBaseSnapshot", elapsedMillis(stepStartNs));
            }
            cachedRuntimeSnapshot = new CachedStationPathRuntimeSnapshot(now, baseRuntimeSnapshot);
            return baseRuntimeSnapshot;
        }
    }

    private BaseRuntimeSnapshot buildBaseRuntimeSnapshot(Map<String, Long> stepCostMap) {
        long stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationStatusMap()));
        if (stepCostMap != null) {
            stepCostMap.put("loadStatusMap", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        Map<Integer, Double> stationLoopLoadMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationLoopLoadMap()));
        if (stepCostMap != null) {
            stepCostMap.put("loadLoopLoadMap", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        if (stepCostMap != null) {
            stepCostMap.put("loadLoopMergeGuard", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        Set<Integer> outStationIdSet = Collections.unmodifiableSet(new LinkedHashSet<>(loadAllOutStationIdSet()));
        if (stepCostMap != null) {
            stepCostMap.put("loadOutStationSet", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        List<StationTaskTraceVo> activeTraceList = Collections.unmodifiableList(new ArrayList<>(loadPlanningActiveTraceList(statusMap)));
        if (stepCostMap != null) {
            stepCostMap.put("loadActiveTraceList", elapsedMillis(stepStartNs));
        }
        return new BaseRuntimeSnapshot(false, statusMap, stationLoopLoadMap, loopMergeGuardContext, outStationIdSet, activeTraceList);
    }

    private Map<Integer, Double> loadStationLoopLoadMap() {
        Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        try {
@@ -1710,12 +1864,13 @@
            if (lev == null) {
                continue;
            }
            List<List<NavigateNode>> stationMap;
            NavigateSolution.NavigateMapIndex navigateMapIndex;
            try {
                stationMap = navigateSolution.getStationMap(lev);
                navigateMapIndex = navigateSolution.getStationMapIndex(lev);
            } catch (Exception ignore) {
                continue;
            }
            List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
            if (stationMap == null || stationMap.isEmpty()) {
                continue;
            }
@@ -1727,16 +1882,13 @@
                        continue;
                    }
                    graph.computeIfAbsent(stationId, key -> new LinkedHashSet<>());
                    List<NavigateNode> nextNodeList = navigateSolution.extend_current_node(stationMap, node);
                    for (NavigateNode nextNode : safeList(nextNodeList)) {
                        for (Integer nextStationId : resolveConnectedStationIds(stationId, nextNode)) {
                            if (nextStationId == null || stationId.equals(nextStationId)) {
                                continue;
                            }
                            graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                            graph.get(stationId).add(nextStationId);
                            graph.get(nextStationId).add(stationId);
                    for (Integer nextStationId : navigateSolution.getConnectedStationIds(navigateMapIndex, stationId, node)) {
                        if (nextStationId == null || stationId.equals(nextStationId)) {
                            continue;
                        }
                        graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                        graph.get(stationId).add(nextStationId);
                        graph.get(nextStationId).add(stationId);
                    }
                }
            }
@@ -1746,27 +1898,17 @@

    private Set<Integer> resolveConnectedStationIds(Integer currentStationId, NavigateNode nextNode) {
        Set<Integer> stationIdSet = new LinkedHashSet<>();
        if (nextNode == null || nextNode.getNodeValue() == null) {
        if (nextNode == null) {
            return stationIdSet;
        }
        try {
            JSONObject value = JSON.parseObject(nextNode.getNodeValue());
            if (value == null) {
                return stationIdSet;
        Integer directStationId = extractStationId(nextNode);
        if (directStationId != null && !directStationId.equals(currentStationId)) {
            stationIdSet.add(directStationId);
        }
        for (Integer bridgeStationId : safeList(nextNode.getBridgeStationIds())) {
            if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                stationIdSet.add(bridgeStationId);
            }
            Integer directStationId = value.getInteger("stationId");
            if (directStationId != null && !directStationId.equals(currentStationId)) {
                stationIdSet.add(directStationId);
            }
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                for (Integer bridgeStationId : bridgeStationIds.toJavaList(Integer.class)) {
                    if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                        stationIdSet.add(bridgeStationId);
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return stationIdSet;
    }
@@ -1792,6 +1934,12 @@
    }

    private StationTrafficSnapshot loadStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap, Integer currentTaskNo) {
        return buildStationTrafficSnapshot(statusMap, currentTaskNo, loadPlanningActiveTraceList(statusMap));
    }

    private StationTrafficSnapshot buildStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap,
                                                              Integer currentTaskNo,
                                                              List<StationTaskTraceVo> activeTraceList) {
        StationTrafficSnapshot snapshot = new StationTrafficSnapshot();
        Map<Integer, Integer> busyMap = new HashMap<>();
        Map<Integer, Integer> issuedReserveMap = new HashMap<>();
@@ -1810,8 +1958,11 @@
            }
        }

        for (StationTaskTraceVo traceVo : loadActiveTraceList(currentTaskNo, statusMap)) {
        for (StationTaskTraceVo traceVo : safeList(activeTraceList)) {
            if (traceVo == null) {
                continue;
            }
            if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                continue;
            }
            List<Integer> pendingStationIds = distinctPositiveStationIds(traceVo.getPendingStationIds());
@@ -1986,7 +2137,7 @@
        return false;
    }

    private List<StationTaskTraceVo> loadActiveTraceList(Integer currentTaskNo, Map<Integer, StationProtocol> statusMap) {
    private List<StationTaskTraceVo> loadPlanningActiveTraceList(Map<Integer, StationProtocol> statusMap) {
        Map<Integer, StationTaskTraceVo> traceMap = new LinkedHashMap<>();
        if (stationTaskTraceRegistry != null) {
            try {
@@ -1994,9 +2145,6 @@
                if (traceList != null) {
                    for (StationTaskTraceVo traceVo : traceList) {
                        if (!isPlanningActiveTrace(traceVo)) {
                            continue;
                        }
                        if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                            continue;
                        }
                        if (traceVo.getTaskNo() != null) {
@@ -2007,7 +2155,7 @@
            } catch (Exception ignore) {
            }
        }
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = loadFallbackActiveTraceMap(currentTaskNo, statusMap, traceMap.keySet());
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = loadFallbackActiveTraceMap(null, statusMap, traceMap.keySet());
        if (!fallbackTraceMap.isEmpty()) {
            traceMap.putAll(fallbackTraceMap);
        }
@@ -2430,29 +2578,42 @@
    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathCalcMode calcMode) {
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        int rawCandidateCount = 0;
        int filteredCandidateCount = 0;

        long stepStartNs = System.nanoTime();
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }
        Integer lev = startStation.getStationLev();
        stepCostMap.put("loadStartStation", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(lev);
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();

        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        if (startNode == null) {
            throw new CoolException("未找到该 起点 对应的节点");
        }

        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (endNode == null) {
            throw new CoolException("未找到该 终点 对应的节点");
        }
        stepCostMap.put("loadStationMapAndNode", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();
        stepCostMap.put("loadProfileConfig", elapsedMillis(stepStartNs));

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={},mode={}",
@@ -2463,6 +2624,7 @@
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
                startNode,
@@ -2472,13 +2634,20 @@
                calcMaxCost,
                guideStationSequence
        );
        stepCostMap.put("allSimplePaths", elapsedMillis(stepStartNs));
        rawCandidateCount = allList.size();
        if (allList.isEmpty()) {
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
@@ -2486,7 +2655,132 @@
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
        return new StationPathSearchContext(allList, resolvedPolicy);
    }

    private void logStationPathCalcSlow(Integer startStationId,
                                        Integer endStationId,
                                        Integer currentTaskNo,
                                        Double pathLenFactor,
                                        StationPathCalcMode calcMode,
                                        String pathSource,
                                        int candidateCount,
                                        int resultPathLen,
                                        Map<String, Long> stepCostMap,
                                        long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径总计算耗时较长，startStationId={}，endStationId={}，taskNo={}，mode={}，pathSource={}，pathLenFactor={}，candidateCount={}，resultPathLen={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode == null ? "" : calcMode.name(),
                pathSource,
                pathLenFactor,
                candidateCount,
                resultPathLen,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logStationPathOrderSlow(Integer startStationId,
                                         Integer endStationId,
                                         Integer currentTaskNo,
                                         Double pathLenFactor,
                                         int candidateCount,
                                         int filteredCandidateCount,
                                         int metricsCount,
                                         int orderedPathCount,
                                         int skippedByLoopMergeGuard,
                                         int skippedByOtherOutStation,
                                         Map<String, Long> stepCostMap,
                                         long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径候选排序耗时较长，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}，candidateCount={}，filteredCandidateCount={}，metricsCount={}，orderedPathCount={}，skippedByLoopMergeGuard={}，skippedByOtherOutStation={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                pathLenFactor,
                candidateCount,
                filteredCandidateCount,
                metricsCount,
                orderedPathCount,
                skippedByLoopMergeGuard,
                skippedByOtherOutStation,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logStationPathSearchContextSlow(Integer startStationId,
                                                 Integer endStationId,
                                                 StationPathCalcMode calcMode,
                                                 Integer lev,
                                                 int rawCandidateCount,
                                                 int filteredCandidateCount,
                                                 Map<String, Long> stepCostMap,
                                                 long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径候选生成耗时较长，startStationId={}，endStationId={}，lev={}，mode={}，rawCandidateCount={}，filteredCandidateCount={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                lev,
                calcMode == null ? "" : calcMode.name(),
                rawCandidateCount,
                filteredCandidateCount,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logDirectPathSlow(Integer startStationId,
                                   Integer endStationId,
                                   Integer currentTaskNo,
                                   StationPathCalcMode calcMode,
                                   Double pathLenFactor,
                                   int pathNodeCount,
                                   Map<String, Long> stepCostMap,
                                   long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径快速计算耗时较长，startStationId={}，endStationId={}，taskNo={}，mode={}，pathLenFactor={}，pathNodeCount={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode == null ? "" : calcMode.name(),
                pathLenFactor,
                pathNodeCount,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logRuntimeSnapshotSlow(Integer currentTaskNo,
                                        boolean cacheHit,
                                        Map<String, Long> stepCostMap,
                                        long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径运行时快照加载耗时较长，taskNo={}，cacheHit={}，stepCosts={}，totalCost={}ms",
                currentTaskNo,
                cacheHit,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private long elapsedMillis(long startNs) {
        long elapsedNs = System.nanoTime() - startNs;
        return elapsedNs <= 0L ? 0L : elapsedNs / 1_000_000L;
    }

    private List<List<NavigateNode>> normalizeCandidatePaths(List<List<NavigateNode>> orderedPathList) {
@@ -2513,16 +2807,10 @@
            if (navigateNode == null) {
                continue;
            }
            JSONObject valueObject;
            try {
                valueObject = JSON.parseObject(navigateNode.getNodeValue());
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(navigateNode.getRgvCalcFlag())) {
                continue;
            }
            if (valueObject == null || valueObject.containsKey("rgvCalcFlag")) {
                continue;
            }
            Integer stationId = valueObject.getInteger("stationId");
            Integer stationId = extractStationId(navigateNode);
            if (stationId == null) {
                continue;
            }
@@ -2542,19 +2830,8 @@
            NavigateNode currentNode = filterList.get(i);
            currentNode.setIsInflectionPoint(false);
            currentNode.setIsLiftTransferPoint(false);

            try {
                JSONObject valueObject = JSON.parseObject(currentNode.getNodeValue());
                if (valueObject != null) {
                    Object isLiftTransfer = valueObject.get("isLiftTransfer");
                    if (isLiftTransfer != null) {
                        String isLiftTransferStr = isLiftTransfer.toString();
                        if ("1".equals(isLiftTransferStr) || "true".equalsIgnoreCase(isLiftTransferStr)) {
                            currentNode.setIsLiftTransferPoint(true);
                        }
                    }
                }
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(currentNode.getLiftTransfer())) {
                currentNode.setIsLiftTransferPoint(true);
            }

            NavigateNode nextNode = (i + 1 < filterList.size()) ? filterList.get(i + 1) : null;
@@ -2587,6 +2864,14 @@
        return builder.toString();
    }

    private boolean parseBooleanFlag(Object value) {
        if (value == null) {
            return false;
        }
        String text = String.valueOf(value);
        return "1".equals(text) || "true".equalsIgnoreCase(text);
    }

    private <T> List<T> safeList(List<T> list) {
        return list == null ? Collections.emptyList() : list;
    }
@@ -2611,6 +2896,7 @@
        private Integer startStationId;
        private Integer endStationId;
        private NavigateSolution navigateSolution;
        private NavigateSolution.NavigateMapIndex navigateMapIndex;
        private List<List<NavigateNode>> stationMap;
        private NavigateNode startNode;
        private NavigateNode endNode;
@@ -2618,6 +2904,7 @@
        private StationPathRuleConfig ruleConfig;
        private StationPathProfileConfig profileConfig;
        private PathGlobalPolicy globalPolicy;
        private StationPathRuntimeSnapshot runtimeSnapshot = StationPathRuntimeSnapshot.empty();
        private Map<Integer, StationProtocol> statusMap = new HashMap<>();
        private Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        private StationTrafficSnapshot trafficSnapshot = new StationTrafficSnapshot();
@@ -2661,6 +2948,76 @@
        private static DirectPathSearchResult empty(boolean includeWaypoint,
                                                    boolean includeSoftPreference) {
            return new DirectPathSearchResult(new ArrayList<>(), includeWaypoint, includeSoftPreference);
        }
    }

    private static class StationPathRuntimeSnapshot {
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final StationTrafficSnapshot trafficSnapshot;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;

        private StationPathRuntimeSnapshot(Map<Integer, StationProtocol> statusMap,
                                           Map<Integer, Double> stationLoopLoadMap,
                                           StationTrafficSnapshot trafficSnapshot,
                                           LoopMergeGuardContext loopMergeGuardContext,
                                           Set<Integer> outStationIdSet) {
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.trafficSnapshot = trafficSnapshot == null ? new StationTrafficSnapshot() : trafficSnapshot;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
        }

        private static StationPathRuntimeSnapshot empty() {
            return new StationPathRuntimeSnapshot(Collections.emptyMap(),
                    Collections.emptyMap(),
                    new StationTrafficSnapshot(),
                    new LoopMergeGuardContext(),
                    Collections.emptySet());
        }
    }

    private static class BaseRuntimeSnapshot {
        private final boolean cacheHit;
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;
        private final List<StationTaskTraceVo> activeTraceList;

        private BaseRuntimeSnapshot(boolean cacheHit,
                                    Map<Integer, StationProtocol> statusMap,
                                    Map<Integer, Double> stationLoopLoadMap,
                                    LoopMergeGuardContext loopMergeGuardContext,
                                    Set<Integer> outStationIdSet,
                                    List<StationTaskTraceVo> activeTraceList) {
            this.cacheHit = cacheHit;
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
            this.activeTraceList = activeTraceList == null ? Collections.emptyList() : activeTraceList;
        }

        private BaseRuntimeSnapshot toCacheHitSnapshot() {
            return new BaseRuntimeSnapshot(true,
                    statusMap,
                    stationLoopLoadMap,
                    loopMergeGuardContext,
                    outStationIdSet,
                    activeTraceList);
        }
    }

    private static class CachedStationPathRuntimeSnapshot {
        private final long cacheAtMs;
        private final BaseRuntimeSnapshot baseRuntimeSnapshot;

        private CachedStationPathRuntimeSnapshot(long cacheAtMs, BaseRuntimeSnapshot baseRuntimeSnapshot) {
            this.cacheAtMs = cacheAtMs;
            this.baseRuntimeSnapshot = baseRuntimeSnapshot;
        }
    }

@@ -2824,7 +3181,13 @@
    }

    private Integer extractStationId(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return null;
        }
        if (node.getStationId() != null) {
            return node.getStationId();
        }
        if (node.getNodeValue() == null) {
            return null;
        }
        try {
@@ -2832,7 +3195,16 @@
            if (value == null) {
                return null;
            }
            return value.getInteger("stationId");
            node.setStationId(value.getInteger("stationId"));
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                node.setBridgeStationIds(bridgeStationIds.toJavaList(Integer.class));
            } else {
                node.setBridgeStationIds(Collections.emptyList());
            }
            node.setLiftTransfer(parseBooleanFlag(value.get("isLiftTransfer")));
            node.setRgvCalcFlag(value.containsKey("rgvCalcFlag"));
            return node.getStationId();
        } catch (Exception ignore) {}
        return null;
    }