#优化运行速度

Junjie

8 小时以前 9b8ff50b66361c4b56074b7586b2d5951ecf2091

#优化运行速度

 src/main/java/com/zy/core/plugin/FakeProcess.java

@@ -28,7 +28,8 @@
import com.zy.core.plugin.store.StoreInTaskContext;
import com.zy.core.plugin.store.StoreInTaskGenerationService;
import com.zy.core.plugin.store.StoreInTaskPolicy;
import com.zy.core.task.MainProcessAsyncTaskScheduler;
import com.zy.core.task.MainProcessLane;
import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.CrnThread;
import com.zy.core.thread.DualCrnThread;
import com.zy.core.thread.StationThread;
@@ -47,14 +48,8 @@
@Slf4j
@Component
public class FakeProcess implements MainProcessPluginApi, StoreInTaskPolicy {
    private static final String CRN_TASK_LANE = "fake-crn";
    private static final String STATION_TASK_LANE = "fake-station";
    private static final String DUAL_CRN_TASK_LANE = "fake-dual-crn";
    private static final String GENERATE_STORE_TASK_LANE_PREFIX = "fake-generate-store-";
    private static final String ASYNC_TASK_LANE_PREFIX = "fake-async-";
    private static final long MAIN_DISPATCH_INTERVAL_MS = 200L;
    private static final long ASYNC_DISPATCH_INTERVAL_MS = 50L;
    private static final long TASK_SLOW_LOG_THRESHOLD_MS = 1000L;

    private static final Map<Integer, Long> stationStayTimeMap = new ConcurrentHashMap<>();
    private static volatile String enableFake = "N";
@@ -91,34 +86,39 @@
    @Autowired
    private StationCommandDispatcher stationCommandDispatcher;
    @Autowired
    private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;
    private MainProcessTaskSubmitter mainProcessTaskSubmitter;

    @Override
    public void run() {
        long startTime = System.currentTimeMillis();
        refreshFakeConfig();

        // 仿真相关任务按各自 lane 串行提交，互不阻塞
        submitAsyncTask("checkInStationHasTask", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationHasTask);
        submitAsyncTask("generateFakeInTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeInTask);
        submitAsyncTask("generateFakeOutTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeOutTask);
        submitAsyncTask("calcAllStationStayTime", ASYNC_DISPATCH_INTERVAL_MS, this::calcAllStationStayTime);
        submitAsyncTask("checkOutStationStayTimeOut", ASYNC_DISPATCH_INTERVAL_MS, this::checkOutStationStayTimeOut);
        submitAsyncTask("checkInStationCrnTake", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationCrnTake);
        submitStationTask("checkStationRunBlock", ASYNC_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationRunBlock);
        // 仿真异步任务
        submitAsyncTasks(ASYNC_DISPATCH_INTERVAL_MS);
        // 仿真输送线堵塞检测
        stationOperateProcessUtils.submitCheckStationRunBlockTasks(MainProcessLane.FAKE_STATION_RUN_BLOCK, ASYNC_DISPATCH_INTERVAL_MS);

        // 请求生成入库任务，按站点拆成独立串行通道，避免单站阻塞整轮扫描
        // 请求生成入库任务
        generateStoreWrkFile();

        // 堆垛机、输送线、双工位堆垛机任务分别进入各自串行通道逐个执行
        submitCrnTask("crnIoExecute", MAIN_DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecute);
        submitCrnTask("crnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, this::crnIoExecuteFinish);
        submitStationTask("stationInExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationInExecute);
        submitStationTask("crnStationOutExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::crnStationOutExecute);
        submitStationTask("checkStationOutOrder", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationOutOrder);
        submitStationTask("watchCircleStation", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::watchCircleStation);
        submitDualCrnTask("dualCrnIoExecute", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecute);
        submitDualCrnTask("dualCrnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecuteFinish);
        // 执行堆垛机任务
        crnOperateUtils.submitCrnIoTasks(MainProcessLane.FAKE_CRN_IO, MAIN_DISPATCH_INTERVAL_MS);
        // 堆垛机任务执行完成
        submitCrnIoExecuteFinishTasks(MAIN_DISPATCH_INTERVAL_MS);
        // 执行输送站点入库任务
        stationOperateProcessUtils.submitStationInTasks(MainProcessLane.FAKE_STATION_IN, MAIN_DISPATCH_INTERVAL_MS);
        // 检测入库任务是否已经到达目标站台
        stationOperateProcessUtils.submitInboundStationArrivalTasks(MAIN_DISPATCH_INTERVAL_MS);
        // 输送线执行堆垛机出库后的站台流转
        stationOperateProcessUtils.submitCrnStationOutTasks(MainProcessLane.FAKE_STATION_OUT, MAIN_DISPATCH_INTERVAL_MS);
        // 检测并处理出库排序
        stationOperateProcessUtils.submitCheckStationOutOrderTasks(MainProcessLane.FAKE_STATION_OUT_ORDER, MAIN_DISPATCH_INTERVAL_MS);
        // 监控输送线绕圈站点
        stationOperateProcessUtils.submitWatchCircleStationTasks(MainProcessLane.FAKE_STATION_WATCH_CIRCLE, MAIN_DISPATCH_INTERVAL_MS);
        // 执行双工位堆垛机任务
        dualCrnOperateProcessUtils.submitDualCrnIoTasks(MainProcessLane.FAKE_DUAL_CRN_IO, MAIN_DISPATCH_INTERVAL_MS);
        // 双工位堆垛机任务执行完成
        dualCrnOperateProcessUtils.submitDualCrnIoExecuteFinishTasks(MainProcessLane.FAKE_DUAL_CRN_IO_FINISH, MAIN_DISPATCH_INTERVAL_MS);

        News.info("[WCS Debug] 主线程Run执行完成,耗时:{}ms", System.currentTimeMillis() - startTime);
    }
@@ -148,20 +148,40 @@
        }
    }

    private void submitCrnTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(CRN_TASK_LANE, taskName, minIntervalMs, task);
    }

    private void submitStationTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(STATION_TASK_LANE, taskName, minIntervalMs, task);
    }

    private void submitDualCrnTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(DUAL_CRN_TASK_LANE, taskName, minIntervalMs, task);
    private void submitAsyncTasks(long minIntervalMs) {
        submitAsyncTask("checkInStationHasTask", minIntervalMs, this::checkInStationHasTask);
        submitAsyncTask("generateFakeInTask", minIntervalMs, this::generateFakeInTask);
        submitAsyncTask("generateFakeOutTask", minIntervalMs, this::generateFakeOutTask);
        submitAsyncTask("calcAllStationStayTime", minIntervalMs, this::calcAllStationStayTime);
        submitAsyncTask("checkOutStationStayTimeOut", minIntervalMs, this::checkOutStationStayTimeOut);
        submitAsyncTask("checkInStationCrnTake", minIntervalMs, this::checkInStationCrnTake);
    }

    private void submitAsyncTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(ASYNC_TASK_LANE_PREFIX + taskName, taskName, minIntervalMs, task);
        mainProcessTaskSubmitter.submitKeyedSerialTask(
                MainProcessLane.FAKE_ASYNC,
                taskName,
                taskName,
                minIntervalMs,
                task
        );
    }

    private void submitCrnIoExecuteFinishTasks(long minIntervalMs) {
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
            if (crnNo == null) {
                continue;
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    MainProcessLane.FAKE_CRN_IO_FINISH,
                    crnNo,
                    "crnIoExecuteFinish",
                    minIntervalMs,
                    () -> crnIoExecuteFinish(basCrnp)
            );
        }
    }

    private void submitGenerateStoreTasks() {
@@ -173,24 +193,16 @@
                if (stationId == null) {
                    continue;
                }
                submitGenerateStoreTask(stationId, MAIN_DISPATCH_INTERVAL_MS,
                        () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
                storeInTaskGenerationService.submitGenerateStoreTask(
                        this,
                        basDevp,
                        stationObjModel,
                        MainProcessLane.FAKE_GENERATE_STORE,
                        MAIN_DISPATCH_INTERVAL_MS,
                        () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel)
                );
            }
        }
    }

    private void submitGenerateStoreTask(Integer stationId, long minIntervalMs, Runnable task) {
        submitProcessTask(GENERATE_STORE_TASK_LANE_PREFIX + stationId, "generateStoreWrkFile", minIntervalMs, task);
    }

    private void submitProcessTask(String laneName, String taskName, long minIntervalMs, Runnable task) {
        mainProcessAsyncTaskScheduler.submit(
                laneName,
                taskName,
                minIntervalMs,
                TASK_SLOW_LOG_THRESHOLD_MS,
                task
        );
    }

    // 检测入库站是否有任务生成，并仿真生成模拟入库站点数据
@@ -633,84 +645,90 @@
    public void crnIoExecuteFinish() {
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
            if (crnThread == null) {
                continue;
            }

            CrnProtocol crnProtocol = crnThread.getStatus();
            if (crnProtocol == null) {
                continue;
            }

            if (crnProtocol.getMode() == CrnModeType.AUTO.id
                    && crnProtocol.getTaskNo() > 0
                    && crnProtocol.getStatus() == CrnStatusType.WAITING.id) {
                Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
                if (lock != null) {
                    continue;
                }

                // 获取待确认工作档
                WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
                if (wrkMast == null) {
                    News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                    continue;
                }

                Long updateWrkSts = null;
                if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
                    updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
                } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
                    updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;

                    // 生成仿真站点数据
                    List<StationObjModel> outStationList = basCrnp.getOutStationList$();
                    if (outStationList.isEmpty()) {
                        News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
                        continue;
                    }

                    for (StationObjModel stationObjModel : outStationList) {
                        if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
                            continue;
                        }

                        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
                                stationObjModel.getDeviceNo());
                        if (stationThread == null) {
                            continue;
                        }
                        // 生成仿真站点数据
                        StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998,
                                wrkMast.getSourceStaNo(), 0, 0);
                        stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "crn-out-complete-write-info");
                        redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
                    }
                } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
                    updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
                } else if (wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts) {
                    updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
                } else {
                    News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                    continue;
                }

                Date now = new Date();
                wrkMast.setWrkSts(updateWrkSts);
                wrkMast.setSystemMsg("");
                wrkMast.setIoTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastService.updateById(wrkMast)) {
                    wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
                    CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
                    MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
                    News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                }

                redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock", 10);
            }
            crnIoExecuteFinish(basCrnp);
        }
    }

    private void crnIoExecuteFinish(BasCrnp basCrnp) {
        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
        if (crnThread == null) {
            return;
        }

        CrnProtocol crnProtocol = crnThread.getStatus();
        if (crnProtocol == null) {
            return;
        }

        if (crnProtocol.getMode() != CrnModeType.AUTO.id
                || crnProtocol.getTaskNo() <= 0
                || crnProtocol.getStatus() != CrnStatusType.WAITING.id) {
            return;
        }

        Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
        if (lock != null) {
            return;
        }

        // 获取待确认工作档
        WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
        if (wrkMast == null) {
            News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
            return;
        }

        Long updateWrkSts = null;
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
            updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
            updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;

            // 生成仿真站点数据
            List<StationObjModel> outStationList = basCrnp.getOutStationList$();
            if (outStationList.isEmpty()) {
                News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
                return;
            }

            for (StationObjModel stationObjModel : outStationList) {
                if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
                    continue;
                }

                StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
                        stationObjModel.getDeviceNo());
                if (stationThread == null) {
                    continue;
                }
                // 生成仿真站点数据
                StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998,
                        wrkMast.getSourceStaNo(), 0, 0);
                stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "crn-out-complete-write-info");
                redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
            }
        } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
            updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
        } else if (wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts) {
            updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
        } else {
            News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
            return;
        }

        Date now = new Date();
        wrkMast.setWrkSts(updateWrkSts);
        wrkMast.setSystemMsg("");
        wrkMast.setIoTime(now);
        wrkMast.setModiTime(now);
        if (wrkMastService.updateById(wrkMast)) {
            wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
            CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
            MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
            News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
        }

        redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock", 10);
    }

}

 src/main/java/com/zy/core/plugin/GslProcess.java

@@ -23,7 +23,6 @@
import com.zy.core.plugin.store.StoreInTaskContext;
import com.zy.core.plugin.store.StoreInTaskGenerationService;
import com.zy.core.plugin.store.StoreInTaskPolicy;
import com.zy.core.task.MainProcessAsyncTaskScheduler;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.CrnOperateProcessUtils;
import com.zy.core.utils.StationOperateProcessUtils;
@@ -37,12 +36,8 @@
@Slf4j
@Component
public class GslProcess implements MainProcessPluginApi, StoreInTaskPolicy {
    private static final String CRN_TASK_LANE = "crn";
    private static final String STATION_TASK_LANE = "station";
    private static final String GENERATE_STORE_TASK_LANE_PREFIX = "generate-store-";
    private static final long DISPATCH_INTERVAL_MS = 200L;
    private static final long MAINTENANCE_INTERVAL_MS = 500L;
    private static final long TASK_SLOW_LOG_THRESHOLD_MS = 1000L;

    @Autowired
    private CrnOperateProcessUtils crnOperateUtils;
@@ -58,8 +53,6 @@
    private StoreInTaskGenerationService storeInTaskGenerationService;
    @Autowired
    private StationCommandDispatcher stationCommandDispatcher;
    @Autowired
    private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;

    @Override
    public void run() {
@@ -68,29 +61,28 @@
        //请求生成入库任务，保留按站点 lane 串行提交
        generateStoreWrkFile();

        //堆垛机与输送站点都按单个任务提交到各自串行通道，逐个执行
        // 堆垛机执行入出库主流程
        submitCrnTask("crnIoExecute", DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecute);
        // 堆垛机收尾并推进后续状态
        submitCrnTask("crnIoExecuteFinish", DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecuteFinish);
        // 输送线执行入库任务下发
        submitStationTask("stationInExecute", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationInExecute);
        // 执行堆垛机任务
        crnOperateUtils.submitCrnIoTasks(DISPATCH_INTERVAL_MS);
        // 堆垛机任务执行完成
        crnOperateUtils.submitCrnIoExecuteFinishTasks(DISPATCH_INTERVAL_MS);
        // 执行输送站点入库任务
        stationOperateProcessUtils.submitStationInTasks(DISPATCH_INTERVAL_MS);
        // 检测入库任务是否已经到达目标站台
        stationOperateProcessUtils.submitInboundStationArrivalTasks(DISPATCH_INTERVAL_MS);
        // 输送线执行堆垛机出库后的站台流转
        submitStationTask("crnStationOutExecute", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::crnStationOutExecute);
        // 高频检测出库任务是否已经到达目标站台
        submitStationTask("stationOutExecuteFinish", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationOutExecuteFinish);
        // 高频检测入库任务是否已经到达目标站台
        submitStationTask("scanInboundStationArrival", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::scanInboundStationArrival);
        stationOperateProcessUtils.submitCrnStationOutTasks(DISPATCH_INTERVAL_MS);
        // 检测出库任务是否已经到达目标站台
        stationOperateProcessUtils.submitStationOutExecuteFinishTasks(DISPATCH_INTERVAL_MS);
        // 检测站台运行完成后的任务转完成
        submitStationTask("checkTaskToComplete", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkTaskToComplete);
        stationOperateProcessUtils.submitCheckTaskToCompleteTasks(DISPATCH_INTERVAL_MS);
        // 检测并处理出库排序
        submitStationTask("checkStationOutOrder", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationOutOrder);
        stationOperateProcessUtils.submitCheckStationOutOrderTasks(MAINTENANCE_INTERVAL_MS);
        // 监控输送线绕圈站点
        submitStationTask("watchCircleStation", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::watchCircleStation);
        stationOperateProcessUtils.submitWatchCircleStationTasks(MAINTENANCE_INTERVAL_MS);
        // 检测输送线运行堵塞
        submitStationTask("checkStationRunBlock", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationRunBlock);
        stationOperateProcessUtils.submitCheckStationRunBlockTasks(MAINTENANCE_INTERVAL_MS);
        // 检测站台空闲超时后的恢复处理
        submitStationTask("checkStationIdleRecover", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationIdleRecover);
        stationOperateProcessUtils.submitCheckStationIdleRecoverTasks(MAINTENANCE_INTERVAL_MS);
    }

    @Override
@@ -178,10 +170,6 @@
        }
    }

    private void submitStationTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(STATION_TASK_LANE, taskName, minIntervalMs, task);
    }

    private void generateStoreWrkFile() {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
@@ -207,7 +195,7 @@
                if (!canRequestStoreIn(stationMap.get(stationId))) {
                    continue;
                }
                submitGenerateStoreTask(stationId, DISPATCH_INTERVAL_MS,
                storeInTaskGenerationService.submitGenerateStoreTask(this, basDevp, stationObjModel, DISPATCH_INTERVAL_MS,
                        () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
            }
        }
@@ -220,24 +208,6 @@
                && stationProtocol.isInEnable()
                && stationProtocol.getTaskNo() > 0
                && !Cools.isEmpty(stationProtocol.getBarcode());
    }

    private void submitGenerateStoreTask(Integer stationId, long minIntervalMs, Runnable task) {
        submitProcessTask(GENERATE_STORE_TASK_LANE_PREFIX + stationId, "generateStoreWrkFile", minIntervalMs, task);
    }

    private void submitCrnTask(String taskName, long minIntervalMs, Runnable task) {
        submitProcessTask(CRN_TASK_LANE, taskName, minIntervalMs, task);
    }

    private void submitProcessTask(String laneName, String taskName, long minIntervalMs, Runnable task) {
        mainProcessAsyncTaskScheduler.submit(
                laneName,
                taskName,
                minIntervalMs,
                TASK_SLOW_LOG_THRESHOLD_MS,
                task
        );
    }

}

 src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java

@@ -18,6 +18,8 @@
import com.zy.core.enums.SlaveType;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.task.MainProcessLane;
import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.StationOperateProcessUtils;
import com.zy.core.utils.WmsOperateUtils;
@@ -44,6 +46,8 @@
    private WmsOperateUtils wmsOperateUtils;
    @Autowired
    private CommonService commonService;
    @Autowired
    private MainProcessTaskSubmitter mainProcessTaskSubmitter;

    /**
     * 保留当前按站点 lane 并发的能力，同时用一个简单计数避免并发生成把站点任务数顶穿上限。
@@ -97,6 +101,30 @@
        }
    }

    public void submitGenerateStoreTask(StoreInTaskPolicy policy,
                                        BasDevp basDevp,
                                        StationObjModel stationObjModel,
                                        long minIntervalMs,
                                        Runnable task) {
        submitGenerateStoreTask(policy, basDevp, stationObjModel, MainProcessLane.GENERATE_STORE, minIntervalMs, task);
    }

    public void submitGenerateStoreTask(StoreInTaskPolicy policy,
                                        BasDevp basDevp,
                                        StationObjModel stationObjModel,
                                        MainProcessLane lane,
                                        long minIntervalMs,
                                        Runnable task) {
        Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
        mainProcessTaskSubmitter.submitKeyedSerialTask(
                lane,
                stationId,
                "generateStoreWrkFile",
                minIntervalMs,
                task
        );
    }

    private void generateByStation(StoreInTaskPolicy policy, BasDevp basDevp, StationObjModel stationObjModel,
                                   HashMap<String, String> systemConfigMap) {
        StoreInTaskContext context = buildContext(basDevp, stationObjModel);

 src/main/java/com/zy/core/task/MainProcessLane.java

New file
@@ -0,0 +1,48 @@
package com.zy.core.task;

public enum MainProcessLane {
    CRN("crn"),
    CRN_IO("crn-io-"),
    CRN_IO_FINISH("crn-io-finish-"),
    DUAL_CRN_IO("dual-crn-io-"),
    DUAL_CRN_IO_FINISH("dual-crn-io-finish-"),
    STATION("station"),
    STATION_IN("station-in-"),
    STATION_OUT("station-out-"),
    STATION_OUT_FINISH("station-out-finish-"),
    STATION_IN_ARRIVAL("station-in-arrival-"),
    STATION_COMPLETE("station-complete-"),
    STATION_OUT_ORDER("station-out-order-"),
    STATION_WATCH_CIRCLE("station-watch-circle-"),
    STATION_RUN_BLOCK("station-run-block-"),
    STATION_IDLE_RECOVER("station-idle-recover-"),
    GENERATE_STORE("generate-store-"),
    FAKE_CRN_IO("fake-crn-io-"),
    FAKE_CRN_IO_FINISH("fake-crn-io-finish-"),
    FAKE_STATION_IN("fake-station-in-"),
    FAKE_STATION_OUT("fake-station-out-"),
    FAKE_STATION_OUT_ORDER("fake-station-out-order-"),
    FAKE_STATION_WATCH_CIRCLE("fake-station-watch-circle-"),
    FAKE_STATION_RUN_BLOCK("fake-station-run-block-"),
    FAKE_DUAL_CRN_IO("fake-dual-crn-io-"),
    FAKE_DUAL_CRN_IO_FINISH("fake-dual-crn-io-finish-"),
    FAKE_GENERATE_STORE("fake-generate-store-"),
    FAKE_ASYNC("fake-async-");

    private final String laneName;

    MainProcessLane(String laneName) {
        this.laneName = laneName;
    }

    public String laneName() {
        return laneName;
    }

    public String keyedLaneName(Object laneKey) {
        if (laneKey == null) {
            return null;
        }
        return laneName + laneKey;
    }
}

 src/main/java/com/zy/core/task/MainProcessTaskSubmitter.java

New file
@@ -0,0 +1,62 @@
package com.zy.core.task;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MainProcessTaskSubmitter {

    private static final long DEFAULT_SLOW_LOG_THRESHOLD_MS = 1000L;

    @Autowired
    private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;

    public boolean submitSerialTask(String laneName,
                                    String taskName,
                                    long minIntervalMs,
                                    Runnable task) {
        return mainProcessAsyncTaskScheduler.submit(
                laneName,
                taskName,
                minIntervalMs,
                DEFAULT_SLOW_LOG_THRESHOLD_MS,
                task
        );
    }

    public boolean submitSerialTask(MainProcessLane lane,
                                    String taskName,
                                    long minIntervalMs,
                                    Runnable task) {
        if (lane == null) {
            return false;
        }
        return submitSerialTask(lane.laneName(), taskName, minIntervalMs, task);
    }

    public boolean submitKeyedSerialTask(String lanePrefix,
                                         Object laneKey,
                                         String taskName,
                                         long minIntervalMs,
                                         Runnable task) {
        if (laneKey == null) {
            return false;
        }
        return submitSerialTask(lanePrefix + laneKey, taskName, minIntervalMs, task);
    }

    public boolean submitKeyedSerialTask(MainProcessLane lane,
                                         Object laneKey,
                                         String taskName,
                                         long minIntervalMs,
                                         Runnable task) {
        if (lane == null) {
            return false;
        }
        String laneName = lane.keyedLaneName(laneKey);
        if (laneName == null) {
            return false;
        }
        return submitSerialTask(laneName, taskName, minIntervalMs, task);
    }
}

 src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java

@@ -31,6 +31,8 @@
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.task.MainProcessLane;
import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.CrnThread;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
@@ -69,30 +71,40 @@
    private StationOperateProcessUtils stationOperateProcessUtils;
    @Autowired
    private WrkAnalysisService wrkAnalysisService;
    @Autowired
    private MainProcessTaskSubmitter mainProcessTaskSubmitter;

    private static final String CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG = "crnOutRequireStationOutEnable";

    public synchronized void crnIoExecute() {
        Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            crnIoExecute(basCrnp, crnMoveBlockedCrnNos);
        }
    }

    public void crnIoExecute(BasCrnp basCrnp, Set<Integer> crnMoveBlockedCrnNos) {
        if (basCrnp == null || basCrnp.getCrnNo() == null) {
            return;
        }
        Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
        if (systemConfigMapObj != null) {
            HashMap<String, String> systemConfigMap = (HashMap<String, String>) systemConfigMapObj;
            if (systemConfigMap.get("crnRunMethod").equals("solver")) {
                plannerExecute();
                plannerExecute(basCrnp, crnMoveBlockedCrnNos);
            }else {
                crnIoExecuteNormal();
                crnIoExecuteNormal(basCrnp, crnMoveBlockedCrnNos);
            }
        }
    }

    //入出库  ===>>  堆垛机入出库作业下发
    public synchronized void crnIoExecuteNormal() {
        Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();

        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
    private void crnIoExecuteNormal(BasCrnp currentCrn, Set<Integer> crnMoveBlockedCrnNos) {
        Map<Integer, BasCrnp> dispatchCrnMap = new HashMap<>();
        Map<Integer, CrnThread> dispatchThreadMap = new HashMap<>();
        Map<Integer, CrnProtocol> dispatchProtocolMap = new HashMap<>();
        for (BasCrnp basCrnp : basCrnps) {
        for (BasCrnp basCrnp : java.util.Collections.singletonList(currentCrn)) {
            if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
                continue;
            }
@@ -611,110 +623,120 @@
    public synchronized void crnIoExecuteFinish() {
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
            if(crnThread == null){
                continue;
            crnIoExecuteFinish(basCrnp);
        }
    }

    public void crnIoExecuteFinish(BasCrnp basCrnp) {
        if (basCrnp == null || basCrnp.getCrnNo() == null) {
            return;
        }
        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
        if(crnThread == null){
            return;
        }

        CrnProtocol crnProtocol = crnThread.getStatus();
        if(crnProtocol == null){
            return;
        }

        if (crnProtocol.getMode() == CrnModeType.AUTO.id
                && crnProtocol.getTaskNo() > 0
                && crnProtocol.getStatus() == CrnStatusType.WAITING.id
        ) {
            Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
            if(lock != null){
                return;
            }

            CrnProtocol crnProtocol = crnThread.getStatus();
            if(crnProtocol == null){
                continue;
            WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
            if (wrkMast == null) {
                News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                return;
            }

            if (crnProtocol.getMode() == CrnModeType.AUTO.id
                    && crnProtocol.getTaskNo() > 0
                    && crnProtocol.getStatus() == CrnStatusType.WAITING.id
            ) {
                Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
                if(lock != null){
                    continue;
            Long updateWrkSts = null;
            Date now = new Date();
            if(wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts){
                updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_COMPLETE, null);
            }else if(wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts){
                updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_COMPLETE, null);

                List<StationObjModel> outStationList = basCrnp.getOutStationList$();
                if(outStationList.isEmpty()){
                    News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
                    return;
                }

                // 获取待确认工作档
                WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
                if (wrkMast == null) {
                    News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                    continue;
                }

                Long updateWrkSts = null;
                Date now = new Date();
                if(wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_COMPLETE, null);
                }else if(wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts){
                    updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_COMPLETE, null);

                    List<StationObjModel> outStationList = basCrnp.getOutStationList$();
                    if(outStationList.isEmpty()){
                        News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
                        return;
                StationObjModel outStationObjModel = null;
                for (StationObjModel stationObjModel : outStationList) {
                    if (stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
                        outStationObjModel = stationObjModel;
                        break;
                    }

                    StationObjModel outStationObjModel = null;
                    for (StationObjModel stationObjModel : outStationList) {
                        if (stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
                            outStationObjModel = stationObjModel;
                            break;
                        }
                    }
                    redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(outStationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
                }else if(wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_COMPLETE, null);
                }else if(wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
                }else{
                    News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                    continue;
                }

                wrkMast.setWrkSts(updateWrkSts);
                wrkMast.setSystemMsg("");
                wrkMast.setIoTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastService.updateById(wrkMast)) {
                    wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
                    CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
                    MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
                    News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                }

                redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock",10);
                redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(outStationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
            }else if(wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts){
                updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_COMPLETE, null);
            }else if(wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts){
                updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
            }else{
                News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                return;
            }

            wrkMast.setWrkSts(updateWrkSts);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
                CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
                MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
                News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
            }

            redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock",10);
        }
    }

    public synchronized void plannerExecute() {
        Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();

        int nowSec = (int) (System.currentTimeMillis() / 1000);
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
                continue;
            }
            plannerExecute(basCrnp, crnMoveBlockedCrnNos);
        }
    }

    private void plannerExecute(BasCrnp basCrnp, Set<Integer> crnMoveBlockedCrnNos) {
        int nowSec = (int) (System.currentTimeMillis() / 1000);
        if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
            return;
        }
            String key = RedisKeyType.PLANNER_SCHEDULE.key + "CRN-" + basCrnp.getCrnNo();
            List<Object> items = redisUtil.lGet(key, 0, -1);
            if (items == null || items.isEmpty()) {
                continue;
                return;
            }

            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
            if (crnThread == null) {
                continue;
                return;
            }
            CrnProtocol crnProtocol = crnThread.getStatus();
            if (crnProtocol == null) {
                continue;
                return;
            }
            List<WrkMast> running = wrkMastService.list(new QueryWrapper<WrkMast>()
                    .eq("crn_no", basCrnp.getCrnNo())
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts, WrkStsType.CRN_MOVE_RUN.sts)
            );
            if (!running.isEmpty()) {
                continue;
                return;
            }
            if (!(crnProtocol.getMode() == CrnModeType.AUTO.id
                    && crnProtocol.getTaskNo() == 0
@@ -722,7 +744,7 @@
                    && crnProtocol.getLoaded() == 0
                    && crnProtocol.getForkPos() == 0
                    && crnProtocol.getAlarm() == 0)) {
                continue;
                return;
            }

            for (Object v : items) {
@@ -785,7 +807,6 @@
                    }
                }
            }
        }
    }

    private synchronized boolean crnExecuteMovePlanner(BasCrnp basCrnp, CrnThread crnThread, WrkMast wrkMast) {
@@ -950,6 +971,53 @@
        return blockedCrnNoSet;
    }

    public Set<Integer> executeCrnMoveTaskAndGetBlockedCrnNos() {
        return executeCrnMoveTask();
    }

    public void submitCrnIoTasks(long minIntervalMs) {
        submitCrnIoTasks(MainProcessLane.CRN_IO, minIntervalMs);
    }

    public void submitCrnIoTasks(MainProcessLane lane, long minIntervalMs) {
        Set<Integer> blockedCrnNos = executeCrnMoveTaskAndGetBlockedCrnNos();
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
            if (crnNo == null) {
                continue;
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    crnNo,
                    "crnIoExecute",
                    minIntervalMs,
                    () -> crnIoExecute(basCrnp, blockedCrnNos)
            );
        }
    }

    public void submitCrnIoExecuteFinishTasks(long minIntervalMs) {
        submitCrnIoExecuteFinishTasks(MainProcessLane.CRN_IO_FINISH, minIntervalMs);
    }

    public void submitCrnIoExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
            if (crnNo == null) {
                continue;
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    crnNo,
                    "crnIoExecuteFinish",
                    minIntervalMs,
                    () -> crnIoExecuteFinish(basCrnp)
            );
        }
    }

    //检测浅库位状态
    public synchronized boolean checkShallowLocStatus(String locNo, Integer taskNo) {
        String checkDeepLocOutTaskBlockReport = "Y";

 src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java

@@ -33,6 +33,8 @@
import com.zy.core.model.param.SendDualCrnCommandParam;
import com.zy.core.model.protocol.DualCrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.task.MainProcessLane;
import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.DualCrnThread;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
@@ -72,6 +74,8 @@
    private WrkAnalysisService wrkAnalysisService;
    @Autowired
    private StationCommandDispatcher stationCommandDispatcher;
    @Autowired
    private MainProcessTaskSubmitter mainProcessTaskSubmitter;

    private static final String CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG = "crnOutRequireStationOutEnable";

@@ -79,38 +83,42 @@
    public synchronized void dualCrnIoExecute() {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
            if(dualCrnThread == null){
                continue;
            }

            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            if(dualCrnProtocol == null){
                continue;
            }

            List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                    .eq("dual_crn_no", basDualCrnp.getCrnNo())
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts)
            );
            if(wrkMasts.size() >= 2){
                continue;
            }

            if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
                continue;
            }

            if(dualCrnProtocol.getAlarm() != 0) {
                continue;
            }

            if(dualCrnProtocol.getTaskSend() != 0 || dualCrnProtocol.getTaskSendTwo() != 0) {
                continue;
            }

            this.crnExecute(basDualCrnp, dualCrnThread);
            dualCrnIoExecute(basDualCrnp);
        }
    }

    public void dualCrnIoExecute(BasDualCrnp basDualCrnp) {
        DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
        if(dualCrnThread == null){
            return;
        }

        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if(dualCrnProtocol == null){
            return;
        }

        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("dual_crn_no", basDualCrnp.getCrnNo())
                .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts)
        );
        if(wrkMasts.size() >= 2){
            return;
        }

        if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
            return;
        }

        if(dualCrnProtocol.getAlarm() != 0) {
            return;
        }

        if(dualCrnProtocol.getTaskSend() != 0 || dualCrnProtocol.getTaskSendTwo() != 0) {
            return;
        }

        this.crnExecute(basDualCrnp, dualCrnThread);
    }

    private synchronized void crnExecute(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
@@ -742,33 +750,78 @@
    public synchronized void dualCrnIoExecuteFinish() {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
            if(dualCrnThread == null){
                continue;
            }
            dualCrnIoExecuteFinish(basDualCrnp);
        }
    }

            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            if(dualCrnProtocol == null){
                continue;
            }
    public void dualCrnIoExecuteFinish(BasDualCrnp basDualCrnp) {
        DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
        if(dualCrnThread == null){
            return;
        }

            if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
                continue;
            }
        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if(dualCrnProtocol == null){
            return;
        }

            if(dualCrnProtocol.getAlarm() != 0) {
                continue;
            }
        if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
            return;
        }

            if((dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getDeviceTaskNo() > 0) && dualCrnProtocol.getTaskSend() == 0 && dualCrnProtocol.getStatus().equals(DualCrnStatusType.WAITING.id)) {
                executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNo(), 1);
                continue;
            }
        if(dualCrnProtocol.getAlarm() != 0) {
            return;
        }

            if((dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getDeviceTaskNoTwo() > 0) && dualCrnProtocol.getTaskSendTwo() == 0 && dualCrnProtocol.getStatusTwo().equals(DualCrnStatusType.WAITING.id)) {
                executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNoTwo(), 2);
        if((dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getDeviceTaskNo() > 0) && dualCrnProtocol.getTaskSend() == 0 && dualCrnProtocol.getStatus().equals(DualCrnStatusType.WAITING.id)) {
            executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNo(), 1);
            return;
        }

        if((dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getDeviceTaskNoTwo() > 0) && dualCrnProtocol.getTaskSendTwo() == 0 && dualCrnProtocol.getStatusTwo().equals(DualCrnStatusType.WAITING.id)) {
            executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNoTwo(), 2);
        }
    }

    public void submitDualCrnIoTasks(long minIntervalMs) {
        submitDualCrnIoTasks(MainProcessLane.DUAL_CRN_IO, minIntervalMs);
    }

    public void submitDualCrnIoTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            Integer crnNo = basDualCrnp == null ? null : basDualCrnp.getCrnNo();
            if (crnNo == null) {
                continue;
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    crnNo,
                    "dualCrnIoExecute",
                    minIntervalMs,
                    () -> dualCrnIoExecute(basDualCrnp)
            );
        }
    }

    public void submitDualCrnIoExecuteFinishTasks(long minIntervalMs) {
        submitDualCrnIoExecuteFinishTasks(MainProcessLane.DUAL_CRN_IO_FINISH, minIntervalMs);
    }

    public void submitDualCrnIoExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            Integer crnNo = basDualCrnp == null ? null : basDualCrnp.getCrnNo();
            if (crnNo == null) {
                continue;
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    crnNo,
                    "dualCrnIoExecuteFinish",
                    minIntervalMs,
                    () -> dualCrnIoExecuteFinish(basDualCrnp)
            );
        }
    }


 src/main/java/com/zy/core/utils/StationOperateProcessUtils.java

@@ -1,8 +1,10 @@
package com.zy.core.utils;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.service.WrkMastService;
@@ -11,7 +13,10 @@
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.task.MainProcessLane;
import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.station.StationDispatchLoadSupport;
import com.zy.core.utils.station.StationOutboundDispatchProcessor;
@@ -33,6 +38,8 @@
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private BasStationService basStationService;
    @Autowired
    private WrkAnalysisService wrkAnalysisService;
@@ -44,15 +51,27 @@
    private StationOutboundDispatchProcessor stationOutboundDispatchProcessor;
    @Autowired
    private StationRerouteProcessor stationRerouteProcessor;
    @Autowired
    private MainProcessTaskSubmitter mainProcessTaskSubmitter;

    //执行输送站点入库任务
    public synchronized void stationInExecute() {
        stationRegularDispatchProcessor.stationInExecute();
    }

    // 执行单个站点的入库任务下发
    public void stationInExecute(BasDevp basDevp, StationObjModel stationObjModel) {
        stationRegularDispatchProcessor.stationInExecute(basDevp, stationObjModel);
    }

    //执行堆垛机输送站点出库任务
    public synchronized void crnStationOutExecute() {
        stationOutboundDispatchProcessor.crnStationOutExecute();
    }

    // 执行单个出库任务对应的输送站点下发
    public void crnStationOutExecute(WrkMast wrkMast) {
        stationOutboundDispatchProcessor.crnStationOutExecute(wrkMast);
    }

    //执行双工位堆垛机输送站点出库任务
@@ -63,6 +82,11 @@
    //检测输送站点出库任务执行完成
    public synchronized void stationOutExecuteFinish() {
        stationRegularDispatchProcessor.stationOutExecuteFinish();
    }

    // 检测单个出库任务是否到达目标站台
    public void stationOutExecuteFinish(WrkMast wrkMast) {
        stationRegularDispatchProcessor.stationOutExecuteFinish(wrkMast);
    }

    // 检测入库任务是否到达站台并转为站台运行完成
@@ -100,9 +124,43 @@
        }
    }

    // 检测单个入库任务是否到达目标站台
    public void scanInboundStationArrival(WrkMast wrkMast) {
        if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null) {
            return;
        }
        BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>()
                .eq("station_id", wrkMast.getStaNo())
                .last("limit 1"));
        if (basStation == null || basStation.getDeviceNo() == null) {
            return;
        }
        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
        if (stationThread == null) {
            return;
        }
        Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
        StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
        boolean arrived = stationProtocol != null
                && wrkMast.getWrkNo().equals(stationProtocol.getTaskNo())
                && stationProtocol.isLoading();
        if (!arrived && !stationThread.hasRecentArrival(basStation.getStationId(), wrkMast.getWrkNo())) {
            return;
        }
        boolean updated = wrkAnalysisService.completeInboundStationRun(wrkMast, new Date());
        if (updated) {
            News.info("入库站点到达扫描命中，工作号={}，目标站={}", wrkMast.getWrkNo(), wrkMast.getStaNo());
        }
    }

    // 检测任务转完成
    public synchronized void checkTaskToComplete() {
        stationRegularDispatchProcessor.checkTaskToComplete();
    }

    // 检测单个出库任务是否可以转完成
    public void checkTaskToComplete(WrkMast wrkMast) {
        stationRegularDispatchProcessor.checkTaskToComplete(wrkMast);
    }

    //检测输送站点是否运行堵塞
@@ -110,9 +168,19 @@
        stationRerouteProcessor.checkStationRunBlock();
    }

    // 检测单个站点是否运行堵塞
    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        stationRerouteProcessor.checkStationRunBlock(basDevp, stationId);
    }

    //检测输送站点任务停留超时后重新计算路径
    public synchronized void checkStationIdleRecover() {
        stationRerouteProcessor.checkStationIdleRecover();
    }

    // 检测单个站点任务停留超时后的恢复处理
    public void checkStationIdleRecover(BasDevp basDevp, Integer stationId) {
        stationRerouteProcessor.checkStationIdleRecover(basDevp, stationId);
    }

    //获取输送线任务数量
@@ -138,11 +206,244 @@
        stationRerouteProcessor.checkStationOutOrder();
    }

    // 检测单个站点的出库排序
    public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
        stationRerouteProcessor.checkStationOutOrder(basDevp, stationObjModel);
    }

    // 监控绕圈站点
    public synchronized void watchCircleStation() {
        stationRerouteProcessor.watchCircleStation();
    }

    // 监控单个绕圈站点
    public void watchCircleStation(BasDevp basDevp, Integer stationId) {
        stationRerouteProcessor.watchCircleStation(basDevp, stationId);
    }

    public void submitStationInTasks(long minIntervalMs) {
        submitStationInTasks(MainProcessLane.STATION_IN, minIntervalMs);
    }

    public void submitStationInTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                continue;
            }
            Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
            if (stationMap == null || stationMap.isEmpty()) {
                continue;
            }
            for (StationObjModel stationObjModel : basDevp.getBarcodeStationList$()) {
                Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
                if (stationId == null || !stationMap.containsKey(stationId)) {
                    continue;
                }
                StationProtocol stationProtocol = stationMap.get(stationId);
                if (stationProtocol == null
                        || !stationProtocol.isAutoing()
                        || !stationProtocol.isLoading()
                        || stationProtocol.getTaskNo() <= 0) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationId,
                        "stationInExecute",
                        minIntervalMs,
                        () -> stationInExecute(basDevp, stationObjModel)
                );
            }
        }
    }

    public void submitCrnStationOutTasks(long minIntervalMs) {
        submitCrnStationOutTasks(MainProcessLane.STATION_OUT, minIntervalMs);
    }

    public void submitCrnStationOutTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
                .isNotNull("crn_no"));
        for (WrkMast wrkMast : wrkMasts) {
            Integer laneKey = wrkMast == null ? null : wrkMast.getSourceStaNo();
            if (laneKey == null) {
                laneKey = wrkMast == null ? null : wrkMast.getWrkNo();
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    laneKey,
                    "crnStationOutExecute",
                    minIntervalMs,
                    () -> crnStationOutExecute(wrkMast)
            );
        }
    }

    public void submitStationOutExecuteFinishTasks(long minIntervalMs) {
        submitStationOutExecuteFinishTasks(MainProcessLane.STATION_OUT_FINISH, minIntervalMs);
    }

    public void submitStationOutExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("wrk_sts", WrkStsType.STATION_RUN.sts)
                .isNotNull("sta_no"));
        for (WrkMast wrkMast : wrkMasts) {
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    wrkMast.getStaNo(),
                    "stationOutExecuteFinish",
                    minIntervalMs,
                    () -> stationOutExecuteFinish(wrkMast)
            );
        }
    }

    public void submitInboundStationArrivalTasks(long minIntervalMs) {
        submitInboundStationArrivalTasks(MainProcessLane.STATION_IN_ARRIVAL, minIntervalMs);
    }

    public void submitInboundStationArrivalTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("io_type", 1)
                .eq("wrk_sts", WrkStsType.INBOUND_STATION_RUN.sts)
                .isNotNull("sta_no"));
        for (WrkMast wrkMast : wrkMasts) {
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    wrkMast.getStaNo(),
                    "scanInboundStationArrival",
                    minIntervalMs,
                    () -> scanInboundStationArrival(wrkMast)
            );
        }
    }

    public void submitCheckTaskToCompleteTasks(long minIntervalMs) {
        submitCheckTaskToCompleteTasks(MainProcessLane.STATION_COMPLETE, minIntervalMs);
    }

    public void submitCheckTaskToCompleteTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts)
                .isNotNull("sta_no"));
        for (WrkMast wrkMast : wrkMasts) {
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    wrkMast.getStaNo(),
                    "checkTaskToComplete",
                    minIntervalMs,
                    () -> checkTaskToComplete(wrkMast)
            );
        }
    }

    public void submitCheckStationOutOrderTasks(long minIntervalMs) {
        submitCheckStationOutOrderTasks(MainProcessLane.STATION_OUT_ORDER, minIntervalMs);
    }

    public void submitCheckStationOutOrderTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            for (StationObjModel stationObjModel : basDevp.getOutOrderList$()) {
                Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
                if (stationId == null) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationId,
                        "checkStationOutOrder",
                        minIntervalMs,
                        () -> checkStationOutOrder(basDevp, stationObjModel)
                );
            }
        }
    }

    public void submitWatchCircleStationTasks(long minIntervalMs) {
        submitWatchCircleStationTasks(MainProcessLane.STATION_WATCH_CIRCLE, minIntervalMs);
    }

    public void submitWatchCircleStationTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                continue;
            }
            for (StationProtocol stationProtocol : stationThread.getStatus()) {
                Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
                if (stationId == null) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationId,
                        "watchCircleStation",
                        minIntervalMs,
                        () -> watchCircleStation(basDevp, stationId)
                );
            }
        }
    }

    public void submitCheckStationRunBlockTasks(long minIntervalMs) {
        submitCheckStationRunBlockTasks(MainProcessLane.STATION_RUN_BLOCK, minIntervalMs);
    }

    public void submitCheckStationRunBlockTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                continue;
            }
            for (StationProtocol stationProtocol : stationThread.getStatus()) {
                Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
                if (stationId == null) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationId,
                        "checkStationRunBlock",
                        minIntervalMs,
                        () -> checkStationRunBlock(basDevp, stationId)
                );
            }
        }
    }

    public void submitCheckStationIdleRecoverTasks(long minIntervalMs) {
        submitCheckStationIdleRecoverTasks(MainProcessLane.STATION_IDLE_RECOVER, minIntervalMs);
    }

    public void submitCheckStationIdleRecoverTasks(MainProcessLane lane, long minIntervalMs) {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                continue;
            }
            for (StationProtocol stationProtocol : stationThread.getStatus()) {
                Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
                if (stationId == null) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationId,
                        "checkStationIdleRecover",
                        minIntervalMs,
                        () -> checkStationIdleRecover(basDevp, stationId)
                );
            }
        }
    }

    RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
                                               RerouteDecision decision) {
        return stationRerouteProcessor.buildRerouteCommandPlan(context, decision);

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

@@ -53,114 +53,126 @@

    public void crnStationOutExecute() {
        try {
            DispatchLimitConfig baseLimitConfig =
                    stationDispatchLoadSupport.getDispatchLimitConfig(null, null);
            int[] currentStationTaskCountRef = new int[]{stationDispatchLoadSupport.countCurrentStationTask()};
            LoadGuardState loadGuardState =
                    stationDispatchLoadSupport.buildLoadGuardState(baseLimitConfig);

            List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                    .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
                    .isNotNull("crn_no"));
            List<Integer> outOrderList = stationOutboundDecisionSupport.getAllOutOrderList();

            for (WrkMast wrkMast : wrkMasts) {
                Object infoObj = redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
                if (infoObj == null) {
                    News.info("出库任务{}数据缓存不存在", wrkMast.getWrkNo());
                    continue;
                }
                crnStationOutExecute(wrkMast);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

                StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
                StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
                if (stationThread == null) {
                    continue;
                }
    public void crnStationOutExecute(WrkMast wrkMast) {
        try {
            if (wrkMast == null || wrkMast.getWrkNo() == null) {
                return;
            }

                Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
                StationProtocol stationProtocol = stationMap.get(stationObjModel.getStationId());
                if (stationProtocol == null) {
                    continue;
                }
            Object infoObj = redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
            if (infoObj == null) {
                News.info("出库任务{}数据缓存不存在", wrkMast.getWrkNo());
                return;
            }

                Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
                if (lock != null) {
                    continue;
                }
            StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
            if (stationObjModel == null || stationObjModel.getDeviceNo() == null || stationObjModel.getStationId() == null) {
                return;
            }

                if (stationProtocol.isAutoing()
                        && stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 0) {
                    Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
                    OutOrderDispatchDecision dispatchDecision =
                            stationOutboundDecisionSupport.resolveOutboundDispatchDecision(
                                    stationProtocol.getStationId(),
                                    wrkMast,
                                    outOrderList,
                                    pathLenFactor
                            );
                    Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
                    if (moveStaNo == null) {
                        continue;
                    }
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
            if (stationThread == null) {
                return;
            }

                    DispatchLimitConfig limitConfig =
                            stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
                    LoopHitResult loopHitResult =
                            stationDispatchLoadSupport.findPathLoopHit(
                                    limitConfig,
                                    stationProtocol.getStationId(),
                                    moveStaNo,
                                    loadGuardState,
                                    wrkMast,
                                    pathLenFactor
                            );
                    if (stationDispatchLoadSupport.isDispatchBlocked(
                            limitConfig,
                            currentStationTaskCountRef[0],
                            loadGuardState,
                            loopHitResult.isThroughLoop())) {
                        return;
                    }
            Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = stationMap == null ? null : stationMap.get(stationObjModel.getStationId());
            if (stationProtocol == null) {
                return;
            }

                    StationCommand command = stationOutboundDecisionSupport.buildOutboundMoveCommand(
                            stationThread,
                            wrkMast,
            Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
            if (lock != null) {
                return;
            }

            if (!(stationProtocol.isAutoing()
                    && stationProtocol.isLoading()
                    && stationProtocol.getTaskNo() == 0)) {
                return;
            }

            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            List<Integer> outOrderList = stationOutboundDecisionSupport.getAllOutOrderList();
            OutOrderDispatchDecision dispatchDecision =
                    stationOutboundDecisionSupport.resolveOutboundDispatchDecision(
                            stationProtocol.getStationId(),
                            moveStaNo,
                            wrkMast,
                            outOrderList,
                            pathLenFactor
                    );
                    if (command == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                        continue;
                    }
            Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
            if (moveStaNo == null) {
                return;
            }

                    Date now = new Date();
                    wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
                    wrkMast.setSystemMsg("");
                    wrkMast.setIoTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastService.updateById(wrkMast)) {
                        wrkAnalysisService.markOutboundStationStart(wrkMast, now);
                        boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
                        if (offered && stationMoveCoordinator != null) {
                            stationMoveCoordinator.recordDispatch(
                                    wrkMast.getWrkNo(),
                                    stationProtocol.getStationId(),
                                    "crnStationOutExecute",
                                    command,
                                    false
                            );
                        }
                        News.info("输送站点出库命令下发成功，站点号={}，工作号={}，命令数据={}",
                                stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
                        redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
                        redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
                        currentStationTaskCountRef[0]++;
                        loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
                        stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
                    }
            DispatchLimitConfig limitConfig =
                    stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
            int currentStationTaskCount = stationDispatchLoadSupport.countCurrentStationTask();
            LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(limitConfig);
            LoopHitResult loopHitResult =
                    stationDispatchLoadSupport.findPathLoopHit(
                            limitConfig,
                            stationProtocol.getStationId(),
                            moveStaNo,
                            loadGuardState,
                            wrkMast,
                            pathLenFactor
                    );
            if (stationDispatchLoadSupport.isDispatchBlocked(
                    limitConfig,
                    currentStationTaskCount,
                    loadGuardState,
                    loopHitResult.isThroughLoop())) {
                return;
            }

            StationCommand command = stationOutboundDecisionSupport.buildOutboundMoveCommand(
                    stationThread,
                    wrkMast,
                    stationProtocol.getStationId(),
                    moveStaNo,
                    pathLenFactor
            );
            if (command == null) {
                News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                return;
            }

            Date now = new Date();
            wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                wrkAnalysisService.markOutboundStationStart(wrkMast, now);
                boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
                if (offered && stationMoveCoordinator != null) {
                    stationMoveCoordinator.recordDispatch(
                            wrkMast.getWrkNo(),
                            stationProtocol.getStationId(),
                            "crnStationOutExecute",
                            command,
                            false
                    );
                }
                News.info("输送站点出库命令下发成功，站点号={}，工作号={}，命令数据={}",
                        stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
                redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
                redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
                loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
                stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
            }
        } catch (Exception e) {
            e.printStackTrace();

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

@@ -65,100 +65,11 @@

    public void stationInExecute() {
        try {
            DispatchLimitConfig baseLimitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(null, null);
            int[] currentStationTaskCountRef = new int[]{stationDispatchLoadSupport.countCurrentStationTask()};
            LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(baseLimitConfig);

            List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
            for (BasDevp basDevp : basDevps) {
                StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
                if (stationThread == null) {
                    continue;
                }

                Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
                List<StationObjModel> stationList = basDevp.getBarcodeStationList$();
                for (StationObjModel entity : stationList) {
                    Integer stationId = entity.getStationId();
                    if (!stationMap.containsKey(stationId)) {
                        continue;
                    }

                    StationProtocol stationProtocol = stationMap.get(stationId);
                    if (stationProtocol == null) {
                        continue;
                    }

                    Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
                    if (lock != null) {
                        continue;
                    }

                    if (!stationProtocol.isAutoing()
                            || !stationProtocol.isLoading()
                            || stationProtocol.getTaskNo() <= 0) {
                        continue;
                    }

                    WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
                    if (wrkMast == null || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_INBOUND.sts)) {
                        continue;
                    }

                    String locNo = wrkMast.getLocNo();
                    FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
                    if (findCrnNoResult == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}工作,未匹配到堆垛机", wrkMast.getWrkNo());
                        continue;
                    }

                    Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
                    if (targetStationId == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}站点,搜索入库站点失败", stationId);
                        continue;
                    }

                    DispatchLimitConfig limitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
                    LoopHitResult loopHitResult = stationDispatchLoadSupport.findPathLoopHit(
                            limitConfig,
                            stationProtocol.getStationId(),
                            targetStationId,
                            loadGuardState
                    );
                    if (stationDispatchLoadSupport.isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
                        continue;
                    }

                    StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
                    if (command == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}工作,获取输送线命令失败", wrkMast.getWrkNo());
                        continue;
                    }

                    Date now = new Date();
                    wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
                    wrkMast.setSourceStaNo(stationProtocol.getStationId());
                    wrkMast.setStaNo(targetStationId);
                    wrkMast.setSystemMsg("");
                    wrkMast.setIoTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastService.updateById(wrkMast)) {
                        wrkAnalysisService.markInboundStationStart(wrkMast, now);
                        boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "stationInExecute");
                        if (offered && stationMoveCoordinator != null) {
                            stationMoveCoordinator.recordDispatch(
                                    wrkMast.getWrkNo(),
                                    stationProtocol.getStationId(),
                                    "stationInExecute",
                                    command,
                                    false
                            );
                        }
                        News.info("输送站点入库命令下发成功，站点号={}，工作号={}，命令数据={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
                        redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
                        loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
                        stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
                    }
                    stationInExecute(basDevp, entity);
                }
            }
        } catch (Exception e) {
@@ -170,36 +81,47 @@
        try {
            List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN.sts));
            for (WrkMast wrkMast : wrkMasts) {
                Integer wrkNo = wrkMast.getWrkNo();
                Integer targetStaNo = wrkMast.getStaNo();
                if (wrkNo == null || targetStaNo == null) {
                    continue;
                }
                stationOutExecuteFinish(wrkMast);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

                boolean complete = false;
                Integer targetDeviceNo = null;
                StationThread stationThread = null;
                BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
                if (basStation != null) {
                    targetDeviceNo = basStation.getDeviceNo();
                    stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
                    if (stationThread != null) {
                        Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
                        StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
                        boolean arrived = stationProtocol != null && wrkNo.equals(stationProtocol.getTaskNo());
                        if (arrived || stationThread.hasRecentArrival(basStation.getStationId(), wrkNo)) {
                            complete = true;
                            if (!arrived) {
                                News.info("输送站点出库到达判定使用最近到站补偿，工作号={}，目标站={}", wrkNo, targetStaNo);
                            }
    public void stationOutExecuteFinish(WrkMast wrkMast) {
        try {
            if (wrkMast == null) {
                return;
            }
            Integer wrkNo = wrkMast.getWrkNo();
            Integer targetStaNo = wrkMast.getStaNo();
            if (wrkNo == null || targetStaNo == null) {
                return;
            }

            boolean complete = false;
            Integer targetDeviceNo = null;
            StationThread stationThread = null;
            BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
            if (basStation != null) {
                targetDeviceNo = basStation.getDeviceNo();
                stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
                if (stationThread != null) {
                    Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
                    StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
                    boolean arrived = stationProtocol != null && wrkNo.equals(stationProtocol.getTaskNo());
                    if (arrived || stationThread.hasRecentArrival(basStation.getStationId(), wrkNo)) {
                        complete = true;
                        if (!arrived) {
                            News.info("输送站点出库到达判定使用最近到站补偿，工作号={}，目标站={}", wrkNo, targetStaNo);
                        }
                    }
                }
            }

                if (complete) {
                    attemptClearTaskPath(stationThread, wrkNo);
                    completeStationRunTask(wrkMast, targetDeviceNo);
                }
            if (complete) {
                attemptClearTaskPath(stationThread, wrkNo);
                completeStationRunTask(wrkMast, targetDeviceNo);
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -210,38 +132,49 @@
        try {
            List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts));
            for (WrkMast wrkMast : wrkMasts) {
                Integer wrkNo = wrkMast.getWrkNo();
                Integer targetStaNo = wrkMast.getStaNo();
                checkTaskToComplete(wrkMast);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

                Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
                if (lock != null) {
                    continue;
                }
    public void checkTaskToComplete(WrkMast wrkMast) {
        try {
            if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null) {
                return;
            }
            Integer wrkNo = wrkMast.getWrkNo();
            Integer targetStaNo = wrkMast.getStaNo();

                BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
                if (basStation == null) {
                    continue;
                }
            Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
            if (lock != null) {
                return;
            }

                StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
                if (stationThread == null) {
                    continue;
                }
            BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
            if (basStation == null) {
                return;
            }

                Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
                StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
                if (stationProtocol == null) {
                    continue;
                }
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
            if (stationThread == null) {
                return;
            }

                if (!Objects.equals(stationProtocol.getTaskNo(), wrkNo)) {
                    if (stationMoveCoordinator != null) {
                        stationMoveCoordinator.finishSession(wrkNo);
                    }
                    wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                    wrkMast.setIoTime(new Date());
                    wrkMastService.updateById(wrkMast);
            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
            if (stationProtocol == null) {
                return;
            }

            if (!Objects.equals(stationProtocol.getTaskNo(), wrkNo)) {
                if (stationMoveCoordinator != null) {
                    stationMoveCoordinator.finishSession(wrkNo);
                }
                wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                wrkMast.setIoTime(new Date());
                wrkMastService.updateById(wrkMast);
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -285,4 +218,99 @@
        StationCommandDispatchResult dispatchResult = stationCommandDispatcher.dispatch(deviceNo, command, "station-operate-process", scene);
        return dispatchResult.isAccepted();
    }

    public void stationInExecute(BasDevp basDevp, StationObjModel entity) {
        if (basDevp == null || basDevp.getDevpNo() == null || entity == null || entity.getStationId() == null) {
            return;
        }

        Integer stationId = entity.getStationId();
        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
        if (stationThread == null) {
            return;
        }

        Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
        if (stationMap == null || !stationMap.containsKey(stationId)) {
            return;
        }

        StationProtocol stationProtocol = stationMap.get(stationId);
        if (stationProtocol == null) {
            return;
        }

        Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
        if (lock != null) {
            return;
        }

        if (!stationProtocol.isAutoing()
                || !stationProtocol.isLoading()
                || stationProtocol.getTaskNo() <= 0) {
            return;
        }

        WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
        if (wrkMast == null || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_INBOUND.sts)) {
            return;
        }

        String locNo = wrkMast.getLocNo();
        FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
        if (findCrnNoResult == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}工作,未匹配到堆垛机", wrkMast.getWrkNo());
            return;
        }

        Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
        if (targetStationId == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}站点,搜索入库站点失败", stationId);
            return;
        }

        DispatchLimitConfig limitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
        int currentStationTaskCount = stationDispatchLoadSupport.countCurrentStationTask();
        LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(limitConfig);
        LoopHitResult loopHitResult = stationDispatchLoadSupport.findPathLoopHit(
                limitConfig,
                stationProtocol.getStationId(),
                targetStationId,
                loadGuardState
        );
        if (stationDispatchLoadSupport.isDispatchBlocked(limitConfig, currentStationTaskCount, loadGuardState, loopHitResult.isThroughLoop())) {
            return;
        }

        StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
        if (command == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}工作,获取输送线命令失败", wrkMast.getWrkNo());
            return;
        }

        Date now = new Date();
        wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
        wrkMast.setSourceStaNo(stationProtocol.getStationId());
        wrkMast.setStaNo(targetStationId);
        wrkMast.setSystemMsg("");
        wrkMast.setIoTime(now);
        wrkMast.setModiTime(now);
        if (wrkMastService.updateById(wrkMast)) {
            wrkAnalysisService.markInboundStationStart(wrkMast, now);
            boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "stationInExecute");
            if (offered && stationMoveCoordinator != null) {
                stationMoveCoordinator.recordDispatch(
                        wrkMast.getWrkNo(),
                        stationProtocol.getStationId(),
                        "stationInExecute",
                        command,
                        false
                );
            }
            News.info("输送站点入库命令下发成功，站点号={}，工作号={}，命令数据={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
            redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
            loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
            stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
        }
    }
}

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

@@ -83,53 +83,76 @@
                if (stationThread == null) {
                    continue;
                }

                List<Integer> runBlockReassignLocStationList = new ArrayList<>();
                for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
                    runBlockReassignLocStationList.add(stationObjModel.getStationId());
                }
                List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();

                for (StationProtocol stationProtocol : stationThread.getStatus()) {
                    if (stationProtocol.isAutoing()
                            && stationProtocol.isLoading()
                            && stationProtocol.getTaskNo() > 0
                            && stationProtocol.isRunBlock()) {
                        WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
                        if (wrkMast == null) {
                            News.info("输送站点号={} 运行阻塞，但无法找到对应任务，工作号={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
                            continue;
                        }

                        Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
                        if (lock != null) {
                            continue;
                        }
                        redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);

                        if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
                            executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
                            continue;
                        }

                        Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
                        RerouteContext context = RerouteContext.create(
                                RerouteSceneType.RUN_BLOCK_REROUTE,
                                basDevp,
                                stationThread,
                                stationProtocol,
                                wrkMast,
                                outOrderStationIds,
                                pathLenFactor,
                                "checkStationRunBlock_reroute"
                        ).withRunBlockCommand()
                                .withSuppressDispatchGuard()
                                .withCancelSessionBeforeDispatch()
                                .withResetSegmentCommandsBeforeDispatch();
                        executeSharedReroute(context);
                    if (stationProtocol == null || stationProtocol.getStationId() == null) {
                        continue;
                    }
                    checkStationRunBlock(basDevp, stationProtocol.getStationId());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
                return;
            }
            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(stationId);
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || !stationProtocol.isRunBlock()) {
                return;
            }

            List<Integer> runBlockReassignLocStationList = new ArrayList<>();
            for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
                runBlockReassignLocStationList.add(stationObjModel.getStationId());
            }
            List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();

            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            if (wrkMast == null) {
                News.info("输送站点号={} 运行阻塞，但无法找到对应任务，工作号={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
                return;
            }

            Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
            if (lock != null) {
                return;
            }
            redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);

            if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
                executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
                return;
            }

            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.RUN_BLOCK_REROUTE,
                    basDevp,
                    stationThread,
                    stationProtocol,
                    wrkMast,
                    outOrderStationIds,
                    pathLenFactor,
                    "checkStationRunBlock_reroute"
            ).withRunBlockCommand()
                    .withSuppressDispatchGuard()
                    .withCancelSessionBeforeDispatch()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -145,11 +168,8 @@
                }

                for (StationProtocol stationProtocol : stationThread.getStatus()) {
                    if (stationProtocol.isAutoing()
                            && stationProtocol.isLoading()
                            && stationProtocol.getTaskNo() > 0
                            && !stationProtocol.isRunBlock()) {
                        checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
                    if (stationProtocol != null && stationProtocol.getStationId() != null) {
                        checkStationIdleRecover(basDevp, stationProtocol.getStationId());
                    }
                }
            }
@@ -158,53 +178,87 @@
        }
    }

    public void checkStationIdleRecover(BasDevp basDevp, Integer stationId) {
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
                return;
            }
            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(stationId);
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || stationProtocol.isRunBlock()) {
                return;
            }
            checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void checkStationOutOrder() {
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
        for (BasDevp basDevp : basDevps) {
            List<StationObjModel> orderList = basDevp.getOutOrderList$();
            for (StationObjModel stationObjModel : orderList) {
                checkStationOutOrder(basDevp, stationObjModel);
            }
        }
    }

    public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationObjModel == null || stationObjModel.getStationId() == null) {
                return;
            }
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                continue;
                return;
            }
            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            List<StationObjModel> orderList = basDevp.getOutOrderList$();
            List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
            for (StationObjModel stationObjModel : orderList) {
                StationProtocol stationProtocol = statusMap.get(stationObjModel.getStationId());
                if (stationProtocol == null
                        || !stationProtocol.isAutoing()
                        || !stationProtocol.isLoading()
                        || stationProtocol.getTaskNo() <= 0
                        || stationProtocol.isRunBlock()
                        || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
                    continue;
                }

                WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
                if (wrkMast == null
                        || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
                        || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
                    continue;
                }
                if (stationOutboundDecisionSupport.shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
                    continue;
                }

                Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
                RerouteContext context = RerouteContext.create(
                        RerouteSceneType.OUT_ORDER,
                        basDevp,
                        stationThread,
                        stationProtocol,
                        wrkMast,
                        outOrderStationIds,
                        pathLenFactor,
                        "checkStationOutOrder"
                ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
                        .withSuppressDispatchGuard()
                        .withOutOrderDispatchLock()
                        .withResetSegmentCommandsBeforeDispatch();
                executeSharedReroute(context);
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationObjModel.getStationId());
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || stationProtocol.isRunBlock()
                    || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
                return;
            }

            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            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())) {
                return;
            }

            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.OUT_ORDER,
                    basDevp,
                    stationThread,
                    stationProtocol,
                    wrkMast,
                    basDevp.getOutOrderIntList(),
                    pathLenFactor,
                    "checkStationOutOrder"
            ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
                    .withSuppressDispatchGuard()
                    .withOutOrderDispatchLock()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

@@ -215,41 +269,60 @@
            if (stationThread == null) {
                continue;
            }

            List<Integer> outOrderList = basDevp.getOutOrderIntList();
            for (StationProtocol stationProtocol : stationThread.getStatus()) {
                if (!stationProtocol.isAutoing()
                        || !stationProtocol.isLoading()
                        || stationProtocol.getTaskNo() <= 0
                        || !stationOutboundDecisionSupport.isWatchingCircleArrival(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
                if (stationProtocol == null || stationProtocol.getStationId() == null) {
                    continue;
                }

                WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
                if (wrkMast == null
                        || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
                        || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
                    continue;
                }

                Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
                RerouteContext context = RerouteContext.create(
                        RerouteSceneType.WATCH_CIRCLE,
                        basDevp,
                        stationThread,
                        stationProtocol,
                        wrkMast,
                        outOrderList,
                        pathLenFactor,
                        "watchCircleStation"
                ).withSuppressDispatchGuard()
                        .withOutOrderDispatchLock()
                        .withResetSegmentCommandsBeforeDispatch();
                executeSharedReroute(context);
                watchCircleStation(basDevp, stationProtocol.getStationId());
            }
        }
    }

    public void watchCircleStation(BasDevp basDevp, Integer stationId) {
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
                return;
            }
            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(stationId);
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || !stationOutboundDecisionSupport.isWatchingCircleArrival(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
                return;
            }

            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            if (wrkMast == null
                    || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
                    || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
                return;
            }

            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.WATCH_CIRCLE,
                    basDevp,
                    stationThread,
                    stationProtocol,
                    wrkMast,
                    basDevp.getOutOrderIntList(),
                    pathLenFactor,
                    "watchCircleStation"
            ).withSuppressDispatchGuard()
                    .withOutOrderDispatchLock()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
                                                      RerouteDecision decision) {
        if (context == null) {