#堆垛机任务执行优先级修改

Junjie

9 天以前 9a8018c3fbc94f99d5d184c8cb1ef23d7366cea0

 src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java

@@ -2,18 +2,18 @@

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.entity.FindCrnNoResult;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.SlaveConnection;
@@ -29,7 +29,6 @@
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.model.protocol.StationTaskBufferItem;
import com.zy.core.move.StationMoveCoordinator;
import com.zy.core.move.StationMoveSession;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.station.model.OutOrderDispatchDecision;
import com.zy.core.utils.station.model.RerouteCommandPlan;
@@ -38,23 +37,27 @@
import com.zy.core.utils.station.model.RerouteExecutionResult;
import com.zy.core.utils.station.model.RerouteSceneType;
import com.zy.core.utils.WmsOperateUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Slf4j
@Component
public class StationRerouteProcessor {
    private static final int OUT_ORDER_DISPATCH_LIMIT_SECONDS = 2;
    private static final long STATION_MOVE_RESET_WAIT_MS = 1000L;
    private static final int RUN_BLOCK_DIRECT_REASSIGN_LIMIT_SECONDS = 15 * 60;
    private static final int RUN_BLOCK_DIRECT_REASSIGN_LIMIT_SECONDS = 8 * 60;
    private static final int RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_SECONDS = 60 * 60 * 24;
    private static final long CHECK_STATION_OUT_ORDER_SLOW_THRESHOLD_MS = 200L;
    private static final long EXECUTE_REROUTE_PLAN_SLOW_THRESHOLD_MS = 200L;

    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
@@ -73,6 +76,8 @@
    private StationOutboundDecisionSupport stationOutboundDecisionSupport;
    @Autowired
    private StationDispatchRuntimeStateSupport stationDispatchRuntimeStateSupport;
    @Autowired
    private NavigateUtils navigateUtils;

    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        try {
@@ -149,16 +154,19 @@
    }

    public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
        long totalStartMs = System.currentTimeMillis();
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationObjModel == null || stationObjModel.getStationId() == null) {
                return;
            }
            long runtimeStartMs = System.currentTimeMillis();
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                return;
            }
            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationObjModel.getStationId());
            long runtimeCostMs = System.currentTimeMillis() - runtimeStartMs;
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
@@ -168,17 +176,25 @@
                return;
            }

            long loadWrkStartMs = System.currentTimeMillis();
            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            long loadWrkCostMs = System.currentTimeMillis() - loadWrkStartMs;
            if (wrkMast == null
                    || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
                    || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
                return;
            }
            if (stationOutboundDecisionSupport.shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
            long skipCheckStartMs = System.currentTimeMillis();
            boolean skipForExistingRoute = stationOutboundDecisionSupport
                    .shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId());
            long skipCheckCostMs = System.currentTimeMillis() - skipCheckStartMs;
            if (skipForExistingRoute) {
                return;
            }

            long pathFactorStartMs = System.currentTimeMillis();
            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            long pathFactorCostMs = System.currentTimeMillis() - pathFactorStartMs;
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.OUT_ORDER,
                    basDevp,
@@ -192,7 +208,29 @@
                    .withSuppressDispatchGuard()
                    .withOutOrderDispatchLock()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
            long rerouteStartMs = System.currentTimeMillis();
            RerouteExecutionResult result = executeSharedReroute(context);
            long rerouteCostMs = System.currentTimeMillis() - rerouteStartMs;
            long totalCostMs = System.currentTimeMillis() - totalStartMs;
            log.info("checkStationOutOrder profile, taskNo={}, stationId={}, deviceNo={}, batch={}, batchSeq={}, finalTargetStationId={}, pathLenFactor={}, runtimeCostMs={}ms, loadWrkCostMs={}ms, skipCheckCostMs={}ms, pathFactorCostMs={}ms, rerouteCostMs={}ms, totalCostMs={}ms, result={}",
                    stationProtocol.getTaskNo(),
                    stationProtocol.getStationId(),
                    stationObjModel.getDeviceNo(),
                    wrkMast.getBatch(),
                    wrkMast.getBatchSeq(),
                    wrkMast.getStaNo(),
                    pathLenFactor,
                    runtimeCostMs,
                    loadWrkCostMs,
                    skipCheckCostMs,
                    pathFactorCostMs,
                    rerouteCostMs,
                    totalCostMs,
                    result == null ? null : result.skipReason());
            if (totalCostMs > CHECK_STATION_OUT_ORDER_SLOW_THRESHOLD_MS) {
                log.warn("checkStationOutOrder slow, taskNo={}, stationId={}, totalCostMs={}ms, rerouteCostMs={}ms, loadWrkCostMs={}ms, pathFactorCostMs={}ms",
                        stationProtocol.getTaskNo(), stationProtocol.getStationId(), totalCostMs, rerouteCostMs, loadWrkCostMs, pathFactorCostMs);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -283,6 +321,7 @@
    }

    public RerouteDecision resolveSharedRerouteDecision(RerouteContext context) {
        long startMs = System.currentTimeMillis();
        if (context == null || context.wrkMast() == null || context.stationProtocol() == null) {
            return RerouteDecision.skip("missing-runtime-dependency");
        }
@@ -294,9 +333,13 @@
        if (context.sceneType() == RerouteSceneType.IDLE_RECOVER
                && !Objects.equals(context.wrkMast().getWrkSts(), WrkStsType.STATION_RUN.sts)) {
            Integer targetStationId = context.wrkMast().getStaNo();
            return targetStationId == null || Objects.equals(targetStationId, currentStationId)
            RerouteDecision decision = targetStationId == null || Objects.equals(targetStationId, currentStationId)
                    ? RerouteDecision.skip("same-station")
                    : RerouteDecision.proceed(targetStationId);
            log.info("resolveSharedRerouteDecision profile, sceneType={}, taskNo={}, currentStationId={}, targetStationId={}, decision={}, decisionCostMs={}ms",
                    context.sceneType(), context.wrkMast().getWrkNo(), currentStationId, targetStationId,
                    decision.skip() ? decision.skipReason() : "proceed", System.currentTimeMillis() - startMs);
            return decision;
        }

        OutOrderDispatchDecision dispatchDecision =
@@ -307,20 +350,155 @@
                        context.pathLenFactor()
                );
        Integer targetStationId = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
        if (targetStationId == null || Objects.equals(targetStationId, currentStationId)) {
            return RerouteDecision.skip("same-station");
        }
        return RerouteDecision.proceed(targetStationId, dispatchDecision);
        RerouteDecision decision = targetStationId == null || Objects.equals(targetStationId, currentStationId)
                ? RerouteDecision.skip("same-station")
                : RerouteDecision.proceed(targetStationId, dispatchDecision);
        log.info("resolveSharedRerouteDecision profile, sceneType={}, taskNo={}, currentStationId={}, targetStationId={}, decision={}, circle={}, decisionCostMs={}ms",
                context.sceneType(), context.wrkMast().getWrkNo(), currentStationId, targetStationId,
                decision.skip() ? decision.skipReason() : "proceed",
                dispatchDecision != null && dispatchDecision.isCircle(),
                System.currentTimeMillis() - startMs);
        return decision;
    }

    public boolean shouldUseRunBlockDirectReassign(WrkMast wrkMast,
                                                   Integer stationId,
                                                   List<Integer> runBlockReassignLocStationList) {
        return wrkMast != null
                && Objects.equals(wrkMast.getIoType(), WrkIoType.IN.id)
                && stationId != null
                && runBlockReassignLocStationList != null
                && runBlockReassignLocStationList.contains(stationId);
        if (wrkMast == null || stationId == null) {
            return false;
        }
        if (!Objects.equals(wrkMast.getIoType(), WrkIoType.IN.id)) {
            return false;
        }
        if (runBlockReassignLocStationList == null || !runBlockReassignLocStationList.contains(stationId)) {
            return false;
        }
        if (shouldForceRunBlockPathReroute(wrkMast, stationId, runBlockReassignLocStationList)) {
            return false;
        }
        return true;
    }

    private boolean shouldForceRunBlockPathReroute(WrkMast wrkMast,
                                                   Integer stationId,
                                                   List<Integer> runBlockReassignLocStationList) {
        if (wrkMast == null || stationId == null) {
            return false;
        }
        Integer nearestStationId = resolveNearestRunBlockDirectReassignStationId(wrkMast, runBlockReassignLocStationList);
        return nearestStationId != null && !Objects.equals(stationId, nearestStationId);
    }

    private Integer resolveNearestRunBlockDirectReassignStationId(WrkMast wrkMast,
                                                                  List<Integer> runBlockReassignLocStationList) {
        if (wrkMast == null
                || wrkMast.getStaNo() == null
                || navigateUtils == null
                || runBlockReassignLocStationList == null
                || runBlockReassignLocStationList.isEmpty()) {
            return null;
        }
        Integer targetStationId = wrkMast.getStaNo();
        Integer cachedStationId = loadCachedNearestRunBlockDirectReassignStationId(targetStationId, runBlockReassignLocStationList);
        if (cachedStationId != null) {
            return cachedStationId;
        }
        Integer nearestStationId = null;
        int nearestPathLen = Integer.MAX_VALUE;
        for (Integer candidateStationId : runBlockReassignLocStationList) {
            if (candidateStationId == null) {
                continue;
            }
            List<NavigateNode> path = navigateUtils.calcOptimalPathByStationId(candidateStationId, targetStationId, wrkMast.getWrkNo(), null);
            if (path == null || path.isEmpty()) {
                continue;
            }
            int pathLen = countStationNodes(path);
            if (pathLen <= 0) {
                continue;
            }
            if (pathLen < nearestPathLen
                    || (pathLen == nearestPathLen && nearestStationId != null && candidateStationId < nearestStationId)) {
                nearestStationId = candidateStationId;
                nearestPathLen = pathLen;
            }
        }
        cacheNearestRunBlockDirectReassignStationId(targetStationId, runBlockReassignLocStationList, nearestStationId);
        return nearestStationId;
    }

    private Integer loadCachedNearestRunBlockDirectReassignStationId(Integer targetStationId,
                                                                     List<Integer> runBlockReassignLocStationList) {
        String cacheKey = buildNearestRunBlockDirectReassignCacheKey(targetStationId, runBlockReassignLocStationList);
        if (cacheKey == null || redisUtil == null) {
            return null;
        }
        Object cacheValue = redisUtil.get(cacheKey);
        if (cacheValue == null) {
            return null;
        }
        try {
            Integer stationId = Integer.valueOf(String.valueOf(cacheValue));
            return runBlockReassignLocStationList.contains(stationId) ? stationId : null;
        } catch (Exception ignore) {
            return null;
        }
    }

    private void cacheNearestRunBlockDirectReassignStationId(Integer targetStationId,
                                                             List<Integer> runBlockReassignLocStationList,
                                                             Integer nearestStationId) {
        String cacheKey = buildNearestRunBlockDirectReassignCacheKey(targetStationId, runBlockReassignLocStationList);
        if (cacheKey == null || nearestStationId == null || redisUtil == null) {
            return;
        }
        redisUtil.set(cacheKey, nearestStationId, RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_SECONDS);
    }

    private String buildNearestRunBlockDirectReassignCacheKey(Integer targetStationId,
                                                              List<Integer> runBlockReassignLocStationList) {
        if (targetStationId == null || runBlockReassignLocStationList == null || runBlockReassignLocStationList.isEmpty()) {
            return null;
        }
        List<Integer> normalizedStationIdList = new ArrayList<>();
        for (Integer stationId : runBlockReassignLocStationList) {
            if (stationId != null && !normalizedStationIdList.contains(stationId)) {
                normalizedStationIdList.add(stationId);
            }
        }
        if (normalizedStationIdList.isEmpty()) {
            return null;
        }
        Collections.sort(normalizedStationIdList);
        return RedisKeyType.STATION_RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_.key
                + targetStationId
                + "_"
                + JSON.toJSONString(normalizedStationIdList);
    }

    private int countStationNodes(List<NavigateNode> path) {
        if (path == null || path.isEmpty()) {
            return 0;
        }
        int count = 0;
        for (NavigateNode node : path) {
            if (extractStationId(node) != null) {
                count++;
            }
        }
        return count;
    }

    private Integer extractStationId(NavigateNode node) {
        if (node == null || Cools.isEmpty(node.getNodeValue())) {
            return null;
        }
        try {
            JSONObject valueObject = JSONObject.parseObject(node.getNodeValue());
            return valueObject == null ? null : valueObject.getInteger("stationId");
        } catch (Exception ignore) {
            return null;
        }
    }

    private boolean shouldSkipRunBlockStation(BasDevp basDevp, Integer stationId) {
@@ -348,6 +526,7 @@
                                                                  StationProtocol stationProtocol,
                                                                  Integer taskNo,
                                                                  Integer stationId) {
        long startMs = System.currentTimeMillis();
        boolean runBlockReroute = context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE;
        int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), taskNo);
        if (currentTaskBufferCommandCount > 0 && !runBlockReroute) {
@@ -359,37 +538,65 @@
                    taskNo,
                    currentTaskBufferCommandCount);
        }
        if (!runBlockReroute
        long suppressStartMs = System.currentTimeMillis();
        boolean suppressDispatch = !runBlockReroute
                && context.checkSuppressDispatch()
                && stationMoveCoordinator != null
                && stationMoveCoordinator.shouldSuppressDispatch(taskNo, stationId, plan.command())) {
                && stationMoveCoordinator.shouldSuppressDispatch(taskNo, stationId, plan.command());
        long suppressCostMs = System.currentTimeMillis() - suppressStartMs;
        if (suppressDispatch) {
            return RerouteExecutionResult.skip("dispatch-suppressed");
        }
        if (context.requireOutOrderDispatchLock()
                && !stationDispatchRuntimeStateSupport.tryAcquireOutOrderDispatchLock(taskNo, stationId, OUT_ORDER_DISPATCH_LIMIT_SECONDS)) {
        long outOrderLockStartMs = System.currentTimeMillis();
        boolean outOrderLockAcquired = !context.requireOutOrderDispatchLock()
                || stationDispatchRuntimeStateSupport.tryAcquireOutOrderDispatchLock(taskNo, stationId, OUT_ORDER_DISPATCH_LIMIT_SECONDS);
        long outOrderLockCostMs = System.currentTimeMillis() - outOrderLockStartMs;
        if (!outOrderLockAcquired) {
            return RerouteExecutionResult.skip("out-order-lock");
        }

        if (!isBlank(context.executionLockKey())
                && !stationDispatchRuntimeStateSupport.tryAcquireLock(context.executionLockKey(), context.executionLockSeconds())) {
                return RerouteExecutionResult.skip("scene-lock");
        long sceneLockStartMs = System.currentTimeMillis();
        boolean sceneLockAcquired = isBlank(context.executionLockKey())
                || stationDispatchRuntimeStateSupport.tryAcquireLock(context.executionLockKey(), context.executionLockSeconds());
        long sceneLockCostMs = System.currentTimeMillis() - sceneLockStartMs;
        if (!sceneLockAcquired) {
            return RerouteExecutionResult.skip("scene-lock");
        }
        long resetCostMs = 0L;
        if (context.resetSegmentCommandsBeforeDispatch()) {
            long resetStartMs = System.currentTimeMillis();
            stationDispatchRuntimeStateSupport.signalSegmentReset(taskNo, STATION_MOVE_RESET_WAIT_MS);
            resetCostMs = System.currentTimeMillis() - resetStartMs;
        }

        int clearedCommandCount = 0;
        long cancelSessionCostMs = 0L;

        if (context.cancelSessionBeforeDispatch() && stationMoveCoordinator != null) {
            long cancelSessionStartMs = System.currentTimeMillis();
            stationMoveCoordinator.markCancelPending(taskNo, "reroute_pending");
            stationMoveCoordinator.cancelSession(taskNo);
            cancelSessionCostMs = System.currentTimeMillis() - cancelSessionStartMs;
        }
        long registerDispatchStartMs = System.currentTimeMillis();
        preRegisterDispatchSession(context, plan);
        long registerDispatchCostMs = System.currentTimeMillis() - registerDispatchStartMs;

        long offerDispatchStartMs = System.currentTimeMillis();
        boolean offered = offerDevpCommandWithDedup(context.dispatchDeviceNo(), plan.command(), plan.dispatchScene());
        long offerDispatchCostMs = System.currentTimeMillis() - offerDispatchStartMs;
        if (!offered) {
            return RerouteExecutionResult.skip("dispatch-dedup");
        }
        if (context.cancelSessionBeforeDispatch() && stationMoveCoordinator != null) {
            stationMoveCoordinator.markCancelPending(taskNo, "reroute_pending");
            stationMoveCoordinator.cancelSession(taskNo);
        }

        applyRerouteDispatchEffects(context, plan, clearedCommandCount);
        long totalCostMs = System.currentTimeMillis() - startMs;
        log.info("executeReroutePlanWithTaskLock profile, sceneType={}, taskNo={}, stationId={}, suppressCostMs={}ms, outOrderLockCostMs={}ms, sceneLockCostMs={}ms, resetCostMs={}ms, cancelSessionCostMs={}ms, registerDispatchCostMs={}ms, offerDispatchCostMs={}ms, totalCostMs={}ms",
                context.sceneType(), taskNo, stationId, suppressCostMs, outOrderLockCostMs, sceneLockCostMs, resetCostMs, cancelSessionCostMs, registerDispatchCostMs, offerDispatchCostMs, totalCostMs);
        if (totalCostMs > EXECUTE_REROUTE_PLAN_SLOW_THRESHOLD_MS) {
            log.warn("executeReroutePlanWithTaskLock slow, sceneType={}, taskNo={}, stationId={}, totalCostMs={}ms, resetCostMs={}ms, registerDispatchCostMs={}ms, offerDispatchCostMs={}ms",
                    context.sceneType(), taskNo, stationId, totalCostMs, resetCostMs, registerDispatchCostMs, offerDispatchCostMs);
        }
        return RerouteExecutionResult.dispatched(plan.command(), clearedCommandCount);
    }

@@ -400,6 +607,24 @@
        }
        RerouteCommandPlan plan = buildRerouteCommandPlan(context, decision);
        return executeReroutePlan(context, plan);
    }

    private void preRegisterDispatchSession(RerouteContext context, RerouteCommandPlan plan) {
        if (context == null || plan == null || plan.command() == null || context.wrkMast() == null || context.stationProtocol() == null) {
            return;
        }
        if (stationMoveCoordinator == null) {
            return;
        }
        OutOrderDispatchDecision dispatchDecision =
                plan.decision() == null ? null : plan.decision().dispatchDecision();
        stationMoveCoordinator.recordDispatch(
                context.wrkMast().getWrkNo(),
                context.stationProtocol().getStationId(),
                plan.dispatchScene(),
                plan.command(),
                dispatchDecision != null && dispatchDecision.isCircle()
        );
    }

    private void applyRerouteDispatchEffects(RerouteContext context,
@@ -420,15 +645,6 @@
                dispatchDecision,
                plan.command()
        );
        if (stationMoveCoordinator != null) {
            stationMoveCoordinator.recordDispatch(
                    wrkMast.getWrkNo(),
                    stationProtocol.getStationId(),
                    plan.dispatchScene(),
                    plan.command(),
                    dispatchDecision != null && dispatchDecision.isCircle()
            );
        }
        if (context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE) {
            News.info("输送站点堵塞后重新计算路径命令下发成功，站点号={}，工作号={}，命令数据={}",
                    stationProtocol.getStationId(),
@@ -461,7 +677,7 @@
        if (stationDispatchRuntimeStateSupport.hasRunBlockDirectReassignLimit(
                wrkMast.getWrkNo(),
                stationProtocol.getStationId())) {
            News.info("输送站点运行堵塞重分配已跳过，15分钟内不允许重复申请。站点号={}，工作号={}",
            News.info("输送站点运行堵塞重分配已跳过，8分钟内不允许重复申请。站点号={}，工作号={}",
                    stationProtocol.getStationId(),
                    wrkMast.getWrkNo());
            return;
@@ -547,10 +763,6 @@
                stationProtocol.getStationId(),
                RUN_BLOCK_DIRECT_REASSIGN_LIMIT_SECONDS);
        stationDispatchRuntimeStateSupport.signalSegmentReset(wrkMast.getWrkNo(), STATION_MOVE_RESET_WAIT_MS);
        boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
        if (!offered) {
            return;
        }
        if (stationMoveCoordinator != null) {
            stationMoveCoordinator.markCancelPending(wrkMast.getWrkNo(), "reroute_pending");
            stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
@@ -562,6 +774,10 @@
                    false
            );
        }
        boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
        if (!offered) {
            News.warn("输送站点堵塞直派命令入队被拒绝(可能重复)，站点号={}，工作号={}", stationProtocol.getStationId(), wrkMast.getWrkNo());
        }
    }

    private int countCurrentTaskBufferCommands(List<StationTaskBufferItem> taskBufferItems, Integer currentTaskNo) {