From 45052042f06689096093fc86cae36560b2eeb1f0 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期四, 02 四月 2026 15:38:48 +0800
Subject: [PATCH] #优化运行速度
---
src/main/java/com/zy/core/utils/StationOperateProcessUtils.java | 401 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 392 insertions(+), 9 deletions(-)
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index 85dc30d..6c278cd 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -1,14 +1,24 @@
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;
+import com.zy.core.News;
+import com.zy.core.cache.SlaveConnection;
+import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
-import com.zy.core.utils.station.StationDispatchLoadSupport;
-import com.zy.core.utils.station.StationOutboundDispatchProcessor;
-import com.zy.core.utils.station.StationRegularDispatchProcessor;
-import com.zy.core.utils.station.StationRerouteProcessor;
+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.*;
import com.zy.core.utils.station.model.RerouteCommandPlan;
import com.zy.core.utils.station.model.RerouteContext;
import com.zy.core.utils.station.model.RerouteDecision;
@@ -16,12 +26,20 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
+import java.util.Date;
import java.util.List;
+import java.util.Map;
@Component
public class StationOperateProcessUtils {
@Autowired
private WrkMastService wrkMastService;
+ @Autowired
+ private BasDevpService basDevpService;
+ @Autowired
+ private BasStationService basStationService;
+ @Autowired
+ private WrkAnalysisService wrkAnalysisService;
@Autowired
private StationRegularDispatchProcessor stationRegularDispatchProcessor;
@Autowired
@@ -30,15 +48,29 @@
private StationOutboundDispatchProcessor stationOutboundDispatchProcessor;
@Autowired
private StationRerouteProcessor stationRerouteProcessor;
+ @Autowired
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
+ @Autowired
+ private StationOutboundDecisionSupport stationOutboundDecisionSupport;
//鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
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);
}
//鎵ц鍙屽伐浣嶅爢鍨涙満杈撻�佺珯鐐瑰嚭搴撲换鍔�
@@ -51,27 +83,111 @@
stationRegularDispatchProcessor.stationOutExecuteFinish();
}
+ // 妫�娴嬪崟涓嚭搴撲换鍔℃槸鍚﹀埌杈剧洰鏍囩珯鍙�
+ public void stationOutExecuteFinish(WrkMast wrkMast) {
+ stationRegularDispatchProcessor.stationOutExecuteFinish(wrkMast);
+ }
+
+ // 妫�娴嬪叆搴撲换鍔℃槸鍚﹀埌杈剧珯鍙板苟杞负绔欏彴杩愯瀹屾垚
+ public synchronized void scanInboundStationArrival() {
+ 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) {
+ if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null) {
+ continue;
+ }
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>()
+ .eq("station_id", wrkMast.getStaNo())
+ .last("limit 1"));
+ if (basStation == null || basStation.getDeviceNo() == null) {
+ continue;
+ }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+ 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())) {
+ continue;
+ }
+ boolean updated = wrkAnalysisService.completeInboundStationRun(wrkMast, new Date());
+ if (updated) {
+ News.info("鍏ュ簱绔欑偣鍒拌揪鎵弿鍛戒腑锛屽伐浣滃彿={}锛岀洰鏍囩珯={}", wrkMast.getWrkNo(), wrkMast.getStaNo());
+ }
+ }
+ }
+
+ // 妫�娴嬪崟涓叆搴撲换鍔℃槸鍚﹀埌杈剧洰鏍囩珯鍙�
+ 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() {
+ public void checkTaskToComplete() {
stationRegularDispatchProcessor.checkTaskToComplete();
}
+ // 妫�娴嬪崟涓嚭搴撲换鍔℃槸鍚﹀彲浠ヨ浆瀹屾垚
+ public void checkTaskToComplete(WrkMast wrkMast) {
+ stationRegularDispatchProcessor.checkTaskToComplete(wrkMast);
+ }
+
//妫�娴嬭緭閫佺珯鐐规槸鍚﹁繍琛屽牭濉�
- public synchronized void checkStationRunBlock() {
+ public void checkStationRunBlock() {
stationRerouteProcessor.checkStationRunBlock();
}
+ // 妫�娴嬪崟涓珯鐐规槸鍚﹁繍琛屽牭濉�
+ public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
+ stationRerouteProcessor.checkStationRunBlock(basDevp, stationId);
+ }
+
//妫�娴嬭緭閫佺珯鐐逛换鍔″仠鐣欒秴鏃跺悗閲嶆柊璁＄畻璺緞
- public synchronized void checkStationIdleRecover() {
+ public void checkStationIdleRecover() {
stationRerouteProcessor.checkStationIdleRecover();
}
+ // 妫�娴嬪崟涓珯鐐逛换鍔″仠鐣欒秴鏃跺悗鐨勬仮澶嶅鐞�
+ public void checkStationIdleRecover(BasDevp basDevp, Integer stationId) {
+ stationRerouteProcessor.checkStationIdleRecover(basDevp, stationId);
+ }
+
//鑾峰彇杈撻�佺嚎浠诲姟鏁伴噺
- public synchronized int getCurrentStationTaskCount() {
+ public int getCurrentStationTaskCount() {
return stationDispatchLoadSupport.countCurrentStationTask();
}
- public synchronized int getCurrentOutboundTaskCountByTargetStation(Integer stationId) {
+ public int getCurrentOutboundTaskCountByTargetStation(Integer stationId) {
if (stationId == null) {
return 0;
}
@@ -89,11 +205,278 @@
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) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ for (StationObjModel stationObjModel : basDevp.getOutOrderList$()) {
+ Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
+ if (stationId == null) {
+ continue;
+ }
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap.get(stationId);
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || stationProtocol.isRunBlock()
+ || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
+ 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;
+ }
+ if (!stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || !stationOutboundDecisionSupport.isWatchingCircleArrival(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
+ 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;
+ }
+ if (!stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || !stationProtocol.isRunBlock()) {
+ 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;
+ }
+ if (!stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || stationProtocol.isRunBlock()) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "checkStationIdleRecover",
+ minIntervalMs,
+ () -> checkStationIdleRecover(basDevp, stationId)
+ );
+ }
+ }
+ }
+
RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
RerouteDecision decision) {
return stationRerouteProcessor.buildRerouteCommandPlan(context, decision);
--
Gitblit v1.9.1