#缓存数据清理

Junjie

1 天以前 5a2bd164d3a831e39bf0defaddf181a97de36993

 src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java

@@ -177,7 +177,7 @@
    }

    @Override
    public synchronized StationCommand getRunBlockRerouteCommand(Integer taskNo,
    public StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize) {
@@ -185,7 +185,7 @@
    }

    @Override
    public synchronized StationCommand getRunBlockRerouteCommand(Integer taskNo,
    public StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize,
@@ -197,10 +197,12 @@
            return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize, pathLenFactor);
        }

        long startNs = System.nanoTime();
        StationTaskLoopService taskLoopService = loadStationTaskLoopService();
        StationTaskLoopService.LoopEvaluation loopEvaluation = taskLoopService == null
                ? new StationTaskLoopService.LoopEvaluation(taskNo, stationId, StationTaskLoopService.LoopIdentitySnapshot.empty(), 0, 0, false)
                : taskLoopService.evaluateLoop(taskNo, stationId, true);
        long loopEvalNs = System.nanoTime();
        log.info("输送线堵塞重规划环线识别，taskNo={}, stationId={}, scopeType={}, localStationCount={}, sourceLoopStationCount={}",
                taskNo,
                stationId,
@@ -208,6 +210,7 @@
                loopEvaluation.getLoopIdentity().getLocalStationCount(),
                loopEvaluation.getLoopIdentity().getSourceLoopStationCount());
        List<List<NavigateNode>> candidatePathList = calcCandidatePathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
        long candidatePathNs = System.nanoTime();
        List<StationCommand> candidateCommandList = new ArrayList<>();
        for (List<NavigateNode> candidatePath : candidatePathList) {
            StationCommand rerouteCommand = buildMoveCommand(taskNo, stationId, targetStationId, palletSize, candidatePath);
@@ -216,6 +219,7 @@
            }
            candidateCommandList.add(rerouteCommand);
        }
        long buildCommandNs = System.nanoTime();

        StationV5RunBlockReroutePlanner.PlanResult planResult = runBlockReroutePlanner.plan(
                taskNo,
@@ -223,6 +227,17 @@
                loopEvaluation,
                candidateCommandList
        );
        long planNs = System.nanoTime();
        logRunBlockRerouteCost(taskNo,
                stationId,
                targetStationId,
                candidatePathList == null ? 0 : candidatePathList.size(),
                candidateCommandList.size(),
                startNs,
                loopEvalNs,
                candidatePathNs,
                buildCommandNs,
                planNs);
        if (candidateCommandList.isEmpty()) {
            log.warn("输送线堵塞重规划失败，候选路径为空，taskNo={}, planCount={}, stationId={}, targetStationId={}",
                    taskNo, planResult.getPlanCount(), stationId, targetStationId);
@@ -249,8 +264,8 @@
    }

    @Override
    public synchronized boolean clearPath(Integer taskNo) {
        if (taskNo == null || taskNo <= 0) {
    public boolean clearPath(Integer taskNo) {
        if (taskNo == null) {
            return false;
        }
        if (zyStationConnectDriver == null) {
@@ -274,21 +289,54 @@
                    continue;
                }
                found = true;
                Integer clearedTaskNo = item.getTaskNo();
                if (!zyStationConnectDriver.clearTaskBufferSlot(stationId, item.getSlotIdx())) {
                    success = false;
                    log.warn("输送站缓存区残留路径清理失败。stationId={}, slotIdx={}, taskNo={}",
                            stationId, item.getSlotIdx(), item.getTaskNo());
                            stationId, item.getSlotIdx(), clearedTaskNo);
                    continue;
                }else {
                    item.setTaskNo(0);
                    item.setTargetStaNo(0);
                    success = true;
                    log.warn("输送站缓存区残留路径清理成功。stationId={}, slotIdx={}, taskNo={}",
                            stationId, item.getSlotIdx(), item.getTaskNo());
                }
                item.setTaskNo(0);
                item.setTargetStaNo(0);
                log.warn("输送站缓存区残留路径清理成功。stationId={}, slotIdx={}, taskNo={}",
                        stationId, item.getSlotIdx(), clearedTaskNo);
            }
        }
        return found && success;
    }

    @Override
    public boolean clearPathByStationSlot(Integer stationId, Integer slotIdx) {
        if (stationId == null || slotIdx == null || zyStationConnectDriver == null) {
            return false;
        }
        List<StationProtocol> status = getStatus();
        if (status == null || status.isEmpty()) {
            return false;
        }

        for (StationProtocol stationProtocol : status) {
            if (stationProtocol == null || !Objects.equals(stationId, stationProtocol.getStationId())) {
                continue;
            }
            if (!zyStationConnectDriver.clearTaskBufferSlot(stationId, slotIdx)) {
                log.warn("输送站缓存区残留路径按站点槽位清理失败。stationId={}, slotIdx={}", stationId, slotIdx);
                return false;
            }
            List<StationTaskBufferItem> taskBufferItems = stationProtocol.getTaskBufferItems();
            if (taskBufferItems != null) {
                for (StationTaskBufferItem item : taskBufferItems) {
                    if (item != null && Objects.equals(slotIdx, item.getSlotIdx())) {
                        item.setTaskNo(0);
                        item.setTargetStaNo(0);
                        break;
                    }
                }
            }
            log.warn("输送站缓存区残留路径按站点槽位清理成功。stationId={}, slotIdx={}", stationId, slotIdx);
            return true;
        }
        return false;
    }

    @Override
@@ -351,7 +399,7 @@
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
        return navigateUtils.calcOptimalPathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private List<List<NavigateNode>> calcCandidatePathNavigateNodes(Integer taskNo,
@@ -423,4 +471,35 @@
            return null;
        }
    }

    private void logRunBlockRerouteCost(Integer taskNo,
                                        Integer stationId,
                                        Integer targetStationId,
                                        int candidatePathCount,
                                        int candidateCommandCount,
                                        long startNs,
                                        long loopEvalNs,
                                        long candidatePathNs,
                                        long buildCommandNs,
                                        long planNs) {
        long totalMs = nanosToMillis(planNs - startNs);
        if (totalMs < 1000L) {
            return;
        }
        log.warn("输送线堵塞重规划耗时较长, taskNo={}, stationId={}, targetStationId={}, total={}ms, loopEval={}ms, candidatePath={}ms, buildCommand={}ms, planner={}ms, candidatePathCount={}, candidateCommandCount={}",
                taskNo,
                stationId,
                targetStationId,
                totalMs,
                nanosToMillis(loopEvalNs - startNs),
                nanosToMillis(candidatePathNs - loopEvalNs),
                nanosToMillis(buildCommandNs - candidatePathNs),
                nanosToMillis(planNs - buildCommandNs),
                candidatePathCount,
                candidateCommandCount);
    }

    private long nanosToMillis(long nanos) {
        return nanos <= 0L ? 0L : nanos / 1_000_000L;
    }
}