redis key对应巡视任务

inspect-base/inspect-base-core/src/main/java/com/inspect/base/core/constant/RedisConst.java

@@ -1,16 +1,17 @@
 package com.inspect.base.core.constant;
 
 public class RedisConst {
-    public static final String TASK_PATROL_ID = "TASK_PATROL_ID";
-    public static final String TASK_PATROL_ID_EX = "TASK+PATROL+ID@";
-    public static final String TASK_PATROL_STATE = "TASK_PATROL_STATE";
-    public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";
+//    public static final String TASK_PATROL_ID_EX = "TASK+PATROL+ID@";//没有获取该key的地方
+//    public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";//没有获取该key的地方
+    public static final String TASK_CODE_EX = "TASK_CODE@*";//查询匹配用
+
+    public static final String TASK_PATROL_ID = "TASK_PATROL_ID@";
+    public static final String TASK_PATROL_STATE = "TASK_PATROL_STATE@";
     public static final String TASK_CODE = "TASK_CODE@";
-    public static final String TASK_CODE_EX = "TASK_CODE@*";
-    public static final String TASK_RECORD_CNT = "TASK_RECORD_CNT";
+    public static final String TASK_RECORD_CNT = "TASK_RECORD_CNT@";
     public static final String TASK_CURRENT_CODE = "TASK_CURRENT_CODE@";
     public static final String TASK_REPEAT_CODE = "TASK_REPEAT_CODE@";
-    public static final String TASK_TIMER_CLOCK = "TASK_TIMER_CLOCK";
-    public static final String IMMEDIATELY_EXEC_TASK_TIME = "IMMEDIATELY_EXEC_TASK_TIME";
+    public static final String TASK_TIMER_CLOCK = "TASK_TIMER_CLOCK@";
+    public static final String IMMEDIATELY_EXEC_TASK_TIME = "IMMEDIATELY_EXEC_TASK_TIME@";
     public static final String REQUEST_UUID = "REQUEST_UUID@";
 }

inspect-base/inspect-base-redis/src/main/java/com/inspect/base/redis/service/RedisService.java

@@ -31,11 +31,23 @@ public class RedisService {
       redisTemplate.opsForValue().set(key, value);
    }
 
+   public <T> void setCacheObjectOfTask(String key, String taskCode, T value) {
+      //logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject key: {}" + Color.END, key);
+      redisTemplate.opsForValue().set(key + taskCode, value);
+      logger.info("RedisService.trace setCacheObjectOfTask: {}", key + taskCode);
+   }
+
    public <T> void setCacheObject(String key, T value, Long timeout, TimeUnit timeUnit) {
       //logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
       redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
 
+   public <T> void setCacheObjectOfTask(String key, String taskCode, T value, Long timeout, TimeUnit timeUnit) {
+      //logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
+      redisTemplate.opsForValue().set(key + taskCode, value, timeout, timeUnit);
+      logger.info("RedisService.trace setCacheObjectOfTask2: {}", key + taskCode);
+   }
+
    public boolean expire(String key, long timeout) {
       return expire(key, timeout, TimeUnit.SECONDS);
    }
@@ -57,10 +69,21 @@ public class RedisService {
       return operation.get(key);
    }
 
+   public <T> T getCacheObjectOfTask(String key, String taskCode) {
+      ValueOperations<String, T> operation = redisTemplate.opsForValue();
+      logger.info("RedisService.trace getCacheObjectOfTask: {}", key + taskCode);
+      return operation.get(key + taskCode);
+   }
+
    public boolean deleteObject(String key) {
       return redisTemplate.delete(key).booleanValue();
    }
 
+   public boolean deleteObjectOfTask(String key, String taskCode) {
+      logger.info("RedisService.trace deleteObjectOfTask: {}", key + taskCode);
+      return redisTemplate.delete(key + taskCode).booleanValue();
+   }
+
    public long deleteObject(Collection collection) {
       return redisTemplate.delete(collection).longValue();
    }

inspect-job/src/main/java/com/inspect/job/task/JobMainTask.java

@@ -71,7 +71,7 @@ public class JobMainTask {
     private String BIG_FILE_POINT = "BIG_FILE_POINT";
     private String API_CONTROL_PRESET = "/api/v1/control/preset";
 
-    private static int execRecordCounter = 0;
+    private static Map<String, Integer> execRecordCounterMap = new HashMap<>();
 
     @Value("${liveSIPB.url}")
     private String liveIVS_URL;
@@ -164,7 +164,7 @@ public class JobMainTask {
                                 week = intervalExecuteTime[i];
                                 time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
                                 if (day == Integer.parseInt(week) && task.getCycleExecuteTime() != null) {
-                                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
+//                                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
                                 }
                             }
                         } else if (StringUtils.isNotEmpty(task.getCycleWeek())) {
@@ -174,7 +174,7 @@ public class JobMainTask {
                                 week = intervalExecuteTime[i];
                                 time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
                                 if (currentWeek.equals(week)) {
-                                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
+//                                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
                                 }
                             }
                         }
@@ -188,7 +188,7 @@ public class JobMainTask {
                                 }
 
                                 time = hour + minute + cycleExecuteTime[2];
-                                redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
+//                                redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
                             }
                         } else if ("2".equals(task.getIntervalType())) {
                             for (j = 0; j < task.getIntervalNumber(); ++j) {
@@ -196,7 +196,7 @@ public class JobMainTask {
                                     intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
                                 }
 
-                                redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
+//                                redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
                             }
                         }
                     }
@@ -538,7 +538,8 @@ public class JobMainTask {
     private boolean isPointFinished(final PatrolTaskInfo taskInfo, final PatrolTaskExecRecord execRecord) {
         final String deviceId = taskInfo.getDeviceId();
         String taskPatrolId = getTaskPatrolledId(taskInfo.getDevNo(), execRecord.getTaskPatrolId());
-        List<PatrolTaskPointExecRecord> pointExecRecords = taskExecClient.selectPatrolTaskPointExecRecordList(PatrolTaskPointExecRecord.builder().taskPatrolledId(taskPatrolId).deviceId(deviceId).isOk(1).build());
+        List<PatrolTaskPointExecRecord> pointExecRecords = taskExecClient.selectPatrolTaskPointExecRecordList(
+                PatrolTaskPointExecRecord.builder().taskPatrolledId(taskPatrolId).deviceId(deviceId).isOk(1).build());
         return !pointExecRecords.isEmpty();
     }
 
@@ -892,37 +893,37 @@ public class JobMainTask {
 //        return value;
 //    }
 
-    private void resetTaskTimerClock() {
-        redisService.setCacheObject(RedisConst.TASK_TIMER_CLOCK, System.currentTimeMillis());
+    private void resetTaskTimerClock(String taskPatrolId) {
+        redisService.setCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, taskPatrolId, System.currentTimeMillis());
     }
 
-    private void resetExecRecordCounter() {
-        execRecordCounter = 0;
+    private void resetExecRecordCounter(String taskPatrolId) {
+        execRecordCounterMap.put(taskPatrolId, 0);
     }
 
-    synchronized private void taskStartInitialize() {
-        resetTaskTimerClock();
-        resetExecRecordCounter();
+    synchronized private void taskStartInitialize(String taskPatrolId) {
+        resetTaskTimerClock(taskPatrolId);
+        resetExecRecordCounter(taskPatrolId);
     }
 
-    synchronized private void resetRecordCounter() {
-        resetExecRecordCounter();
-        redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, 0);
+    synchronized private void resetRecordCounter(String taskPatrolId) {
+        resetExecRecordCounter(taskPatrolId);
+        redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId, 0);
     }
 
-    synchronized private void resetRedisCurrentCode() {
-        final String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+    synchronized private void resetRedisCurrentCode(String taskPatrolId) {
+        final String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
         if (StringUtils.isNotEmpty(taskCode)) {
             redisService.deleteObject(taskCode);
         }
-        redisService.deleteObject(RedisConst.TASK_CURRENT_CODE);
+        redisService.deleteObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
     }
 
     synchronized private void calcExecCostTime(final String oldPatrolId) {
-        Long startTime = redisService.getCacheObject(RedisConst.TASK_TIMER_CLOCK);
+        Long startTime = redisService.getCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, oldPatrolId);
         if (startTime != null) {
             log.info(Color.MAGENTA + "[JOB] TASK: [{}], COST: [{} ms]" + Color.END, oldPatrolId, System.currentTimeMillis() - startTime);
-            redisService.setCacheObject(RedisConst.TASK_TIMER_CLOCK, 0L);
+            redisService.setCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, oldPatrolId, 0L);
         }
     }
 
@@ -933,7 +934,9 @@ public class JobMainTask {
         final int finish = execRecord.getFinishNumber();
         log.info(Color.GREEN + "[JOB] cursor:{}, finish:{}, total:{}, patrolId:{}" + Color.END, cursor, finish, total, taskPatrolId);
         if (cursor == total) {
+            Integer execRecordCounter = execRecordCounterMap.get(taskPatrolId);
             execRecordCounter++;
+            execRecordCounterMap.put(taskPatrolId, execRecordCounter);
             execRecord.setEndTime(new Date());
             if (finish == total) { // record下的点全部执行成功
                 //仅仅靠一个record成功执行不能代表所有的record都执行成功,只能设置该record执行成功标记
@@ -951,19 +954,19 @@ public class JobMainTask {
                         totalProgress,
                         TaskStatus.DONE.getCode()
                 );
-                final Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
+                final Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId);
                 log.info(Color.MAGENTA + "RECORD ROUND, patrolId: {}, recordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
                 if (execRecordCounter == redisRecCnt) { // 最后一个record
-                    resetRecordCounter();
-                    final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
+                    resetRecordCounter(taskPatrolId);
+                    final String repeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId);
                     if (StringUtils.isEmpty(repeatCode)) {
                         //所有的records都完美的执行成功, 要把redis标记清除，不然以后的任务如何执行？
-                        resetRedisCurrentCode();
+                        resetRedisCurrentCode(taskPatrolId);
                     }
 
-                    String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                    String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskPatrolId);
                     if (!StringUtils.isEmpty(redisImmediatelyExecTaskTime)) {
-                        redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                        redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskPatrolId);
                     }
                     calcExecCostTime(execRecord.getOldTaskPatrolId());
                 }
@@ -973,17 +976,17 @@ public class JobMainTask {
                     times--;
                     execRecord.setRebootTimes(times);
                     execRecord.setCursorNumber(0);
-                    final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
+                    final int redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId);
                     log.info(Color.MAGENTA + "[JOB] TIMES > 0, taskPatrolId: {}, execRecordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
                     if (execRecordCounter == redisRecCnt) {//最后一个record, 复位
-                        resetRecordCounter();
+                        resetRecordCounter(taskPatrolId);
                         calcExecCostTime(execRecord.getOldTaskPatrolId());
                     }
-                    final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
+                    final String repeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId);
                     if (StringUtils.isEmpty(repeatCode)) {
                         log.info(Color.MAGENTA + "[JOB] SET REPEAT FLAG patrolId: {}" + Color.END, taskPatrolId);
-                        String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
-                        redisService.setCacheObject(RedisConst.TASK_REPEAT_CODE, taskRepeatCode);
+                        String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
+                        redisService.setCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId, taskRepeatCode);
                     }
                 } else if (times == 0) {//一个record的尝试次数为0，其它的record正在执行中
                     //设置本record的执行状态为终止
@@ -1000,11 +1003,11 @@ public class JobMainTask {
                             TaskStatus.DONE.getCode()
                     );
                     //在不知道其它record是否执行完毕的情况下，不能把TASK_CURRENT_CODE锁删除
-                    final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
+                    final int redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, execRecord.getTaskPatrolId());
                     log.info(Color.MAGENTA + "[JOB] TIMES 0, execRecordCounter: {}, redisRecCnt: {}" + Color.END, execRecordCounter, redisRecCnt);
                     if (execRecordCounter == redisRecCnt) {
-                        resetRecordCounter();
-                        resetRedisCurrentCode();
+                        resetRecordCounter(execRecord.getTaskPatrolId());
+                        resetRedisCurrentCode(taskPatrolId);
                         calcExecCostTime(execRecord.getOldTaskPatrolId());
                     }
                 }
@@ -1383,22 +1386,22 @@ public class JobMainTask {
 
     @PostMapping({"/immediatelyExecTask"})
     public void immediatelyExecTask(@RequestBody PatrolTask patrolTask) {
-        String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
-        if (StringUtils.isNotEmpty(taskCode)) {
-            log.info(Color.CYAN + "[JOB] TASK SLOT IS TAKEN BY: {}" + Color.END, taskCode);
-            return;
-        }
+        String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
+//        if (StringUtils.isNotEmpty(taskCode)) {
+//            log.info(Color.CYAN + "[JOB] TASK SLOT IS TAKEN BY: {}" + Color.END, taskCode);
+//            return;
+//        }
 
         PatrolTaskInfo patrolTaskInfo = new PatrolTaskInfo();
         List<PatrolTask> patrolTaskList = new ArrayList<>();
         patrolTaskList.add(patrolTask);
         List<PatrolTask> cameraPatrolTasks = new ArrayList<>();
         assembleVideoTask(patrolTaskList, cameraPatrolTasks);
-        String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
-        if (redisImmediatelyExecTaskTime != null) {
-            log.info(Color.RED + "[JOB IMMEDIATE] IMMEDIATELY_EXEC_TASK_TIME TASK TAKEN :{}" + Color.END, redisImmediatelyExecTaskTime);
-            return;
-        }
+        String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTask.getTaskCode());
+//        if (redisImmediatelyExecTaskTime != null) {
+//            log.info(Color.RED + "[JOB IMMEDIATE] IMMEDIATELY_EXEC_TASK_TIME TASK TAKEN :{}" + Color.END, redisImmediatelyExecTaskTime);
+//            return;
+//        }
 
         if (shaoXinBigModel.isSwitchStatus()) {
             log.info("[BIG] Temporary gathering, close bigSwitch in nacos");
@@ -1406,14 +1409,15 @@ public class JobMainTask {
         }
 
         String immediatelyExecTaskTime = DateUtils.parseDateToStr(DateUtils.yyyyMMddHHmmss, new Date());
-        redisService.setCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, immediatelyExecTaskTime);
-        log.info(Color.CYAN + "[JOB IMMEDIATE] TASK_CURRENT_CODE: {}, value: {}" + Color.END, RedisConst.TASK_CURRENT_CODE, RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
-        redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
-        taskStartInitialize();
+        redisService.setCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTask.getTaskCode(), immediatelyExecTaskTime);
+        log.info(Color.CYAN + "[JOB IMMEDIATE] TASK_CURRENT_CODE: {}, value: {}" + Color.END, RedisConst.TASK_CURRENT_CODE + patrolTask.getTaskCode(), RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
+        redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskCode(), RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
+        taskStartInitialize(patrolTask.getTaskCode());
         log.info(Color.CYAN + "[JOB IMMEDIATE] TASK REC CNT: {}" + Color.END, cameraPatrolTasks.size());
-        setRedisRecordCount(cameraPatrolTasks.size());
+        setRedisRecordCount(patrolTask.getTaskCode(), cameraPatrolTasks.size());
         for (PatrolTask task : cameraPatrolTasks) {
             List<PatrolTaskInfo> taskInfos = getInfosByRecord(PatrolTaskExecRecord.builder().devNo(task.getDevNo()).taskId(task.getTaskId()).build());
+
             PatrolTaskExecRecord patrolTaskExecRecord = new PatrolTaskExecRecord();
             Date time = task.getFixedStartTime();
             String timeStr = time == null ? immediatelyExecTaskTime : DateUtils.parseDateToStr(DateUtils.yyyyMMddHHmmss, time);
@@ -1436,7 +1440,8 @@ public class JobMainTask {
             patrolTaskExecRecord.setDeviceId("0");
             patrolTaskExecRecord.setExecPointId(0L);
             patrolTaskExecRecord.setTotalNumber(taskInfos.isEmpty() ? 1 : taskInfos.size());
-            log.info(Color.CYAN + "[JOB IMMEDIATE] taskName: {}, taskCode: {}, taskPatrolledId: {}" + Color.END, patrolTaskExecRecord.getTaskName(), patrolTaskExecRecord.getTaskCode(), patrolTaskExecRecord.getTaskPatrolId());
+            log.info(Color.CYAN + "[JOB IMMEDIATE] taskName: {}, taskCode: {}, taskPatrolledId: {}" + Color.END,
+                    patrolTaskExecRecord.getTaskName(), patrolTaskExecRecord.getTaskCode(), patrolTaskExecRecord.getTaskPatrolId());
             taskExecClient.addPatrolTaskExecRecord(patrolTaskExecRecord);
             patrolTaskInfo.setTaskMajorId(task.getTaskId().toString());
             patrolTaskInfo.setDevNo(task.getDevNo());
@@ -1454,6 +1459,7 @@ public class JobMainTask {
                     .devType("2")
                     .build());
             return patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);
+
         } catch (Exception e) {
             log.error("[JOB] getInfosByTaskCode exception: {}", e.getMessage());
             return patrolTaskInfoList;
@@ -1467,28 +1473,28 @@ public class JobMainTask {
                     .devNo(record.getDevNo())
                     .taskMajorId(record.getTaskId().toString())
                     .build());
-            return patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);
+            return patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);//把检修区域的点位删除
         } catch (Exception e) {
             log.error("[JOB] get infos exception: {}", e.getMessage());
             return patrolTaskInfoList;
         }
     }
 
-    private void incrementRedisRecordCounter() {
-        Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
+    private void incrementRedisRecordCounter(String patrolTaskCode) {
+        Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode);
         if (redisRecCnt == null) {
             redisRecCnt = 1;
-            redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
+            redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, redisRecCnt);
         } else {
             redisRecCnt++;
-            redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
+            redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, redisRecCnt);
         }
 
         log.info(Color.GREEN + "[JOB] redisRecCnt: {}" + Color.END, redisRecCnt);
     }
 
-    private void setRedisRecordCount(final int size) {
-        redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, size);
+    private void setRedisRecordCount(String patrolTaskCode, final int size) {
+        redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, size);
     }
 
     private String getTaskPatrolId(final PatrolTask patrolTask) {
@@ -1502,10 +1508,10 @@ public class JobMainTask {
     }
 
     public void execEveryDayTask(List<PatrolTask> patrolTaskList) {
-        setRedisRecordCount(patrolTaskList.size());
         for (PatrolTask patrolTask : patrolTaskList) {
             List<PatrolTaskInfo> taskInfos = getInfosByRecord(PatrolTaskExecRecord.builder().devNo(patrolTask.getDevNo()).taskId(patrolTask.getTaskId()).build());
             final String taskPatrolId = getTaskPatrolId(patrolTask);
+            setRedisRecordCount(taskPatrolId,patrolTaskList.size());
             final String oldTaskPatrolId = getOldTaskPatrolId(patrolTask);
             log.info(Color.GREEN + "[JOB] NEW EXEC RECORD: {}, OLD: {}" + Color.END, taskPatrolId, oldTaskPatrolId);
             PatrolTaskExecRecord patrolTaskExecRecord = PatrolTaskExecRecord.builder()
@@ -1561,7 +1567,7 @@ public class JobMainTask {
             int times = execRecord.getRebootTimes();
             if (finish < total) {
                 log.info(Color.GREEN + "[JOB] REPEAT EXEC RECORD: id: {}, finish: {}, total: {}, times: {}, progress: {}" + Color.END, execRecord.getTaskPatrolId(), finish, total, times, execRecord.getTaskProgress());
-                incrementRedisRecordCounter();
+                incrementRedisRecordCounter(taskPatrolId);
                 threadPool.submit(() -> {
                     log.info(Color.MAGENTA + "[JOB] REPEAT START devNo: {}, taskId: {}" + Color.END, execRecord.getDevNo(), execRecord.getTaskId());
                     prePointExecImmediate(execRecord);
@@ -1668,6 +1674,7 @@ public class JobMainTask {
         }
 
         log.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!resList size: {}", resList.size());
+
         return resList;
     }
 
@@ -1869,80 +1876,50 @@ public class JobMainTask {
         return nf.format(decimalFormatNum * 100.0F);
     }
 
-    @SuppressWarnings({"unused"})
-    public void execEveryDayTask() {
-        if (isTaskSlotEmpty()) {
-            Collection<String> redisKeys = redisService.keys(RedisConst.TASK_CODE_EX);
-            for (String redisKey : redisKeys) {
-                String[] keywords = StringUtils.split(redisKey, StringUtils.AT);
-                if (keywords.length == 3) {
-                    String taskCode = keywords[1];
-                    String fixedStartTime = keywords[2];
-                    long currentDays = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
-                    long fixedDays = TimeUnit.MILLISECONDS.toDays(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
-                    long currentMinutes = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
-                    long fixedStartMinutes = TimeUnit.MILLISECONDS.toMinutes(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
-                    if (currentDays == fixedDays && currentMinutes >= fixedStartMinutes) {
-                        //if ("1220".equals(taskCode))
-                        {
-                            //log.info("[GABRIEL] key: {}, curMin: {}, fixedMin:{}\n , curDay: {}, fixedDay:{}!", key, currentMinutes, fixedStartMinutes, currentDays, fixedDays);
-                            extractRedisTask(redisKey);
-                        }
-                    }
-                }
-            }
-        } else {
-//            log.info(Color.YELLOW + "[JOB] CUR: [{}] IS TAKEN, REPEAT: {}, redisRecCnt: {}" + Color.END,
-//                    redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE),
-//                    redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE),
-//                    redisService.getCacheObject(RedisConst.TASK_RECORD_CNT));
-        }
-    }
-
-    private boolean isTaskSlotEmpty() {
-        String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
-        String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE); //repeat空了就不执行
-        Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
+    private boolean isTaskSlotEmpty(String taskCode) {
+        String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
+        String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode); //repeat空了就不执行
+        Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskCode);
         log.info(Color.YELLOW + "[JOB] TASK_CURRENT_CODE@: [{}] TAKEN, TASK_REPEAT_CODE@: {}, TASK_RECORD_CNT: {}" + Color.END, taskCurrentCode, taskRepeatCode, redisRecCnt);
         return StringUtils.isEmpty(taskCurrentCode) ||
                 !StringUtils.isEmpty(taskCurrentCode) && !StringUtils.isEmpty(taskRepeatCode) && (redisRecCnt == null || redisRecCnt == 0);
 
     }
 
-    private boolean isTaskRunning() {
-        final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+    private boolean isTaskRunning(String taskCode) {
+        final String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
         return StringUtils.isNotEmpty(taskCurrentCode);
     }
 
-    private boolean isTaskRepeatPending() {
-        final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
-        final String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
+    private boolean isTaskRepeatPending(String taskCode) {
+        final String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
+        final String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode);
         return StringUtils.isNotEmpty(taskCurrentCode)
                 && StringUtils.isNotEmpty(taskRepeatCode)
                 && taskCurrentCode.equals(taskRepeatCode);
     }
 
-    private void clearRepeatTask() {
-        redisService.deleteObject(RedisConst.TASK_REPEAT_CODE);
+    private void clearRepeatTask(String taskCode) {
+        redisService.deleteObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode);
     }
 
-    synchronized private void extractRedisTask(String redisKey) {
-        if (!isTaskRunning()) {/*执行新任务*/
+    synchronized private void extractRedisTask(String taskCode, String redisKey) {
+        if (!isTaskRunning(taskCode)) {/*执行新任务*/
             List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
             if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
                 log.info(Color.GREEN + "[JOB] ADD NEW TASK [{}], TASK LIST SIZE: {}" + Color.END, redisKey, patrolTaskList.size());
-                redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, redisKey);
-                taskStartInitialize();
+                redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode, redisKey);
+                taskStartInitialize(patrolTaskList.get(0).getTaskCode());
                 execEveryDayTask(patrolTaskList);
             }
         }
 
-        if (isTaskRunning() && isTaskRepeatPending()) {/*执行需要再次执行的任务*/
-            clearRepeatTask();
+        if (isTaskRunning(taskCode) && isTaskRepeatPending(taskCode)) {/*执行需要再次执行的任务*/
+            clearRepeatTask(taskCode);
             log.info(Color.GREEN + "[JOB] REPEAT TASK [{}]" + Color.END, redisKey);
             List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
             if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
-                taskStartInitialize();
+                taskStartInitialize(patrolTaskList.get(0).getTaskCode());
                 execRepeatDayTask(patrolTaskList);
             }
         }

inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecController.java

@@ -286,27 +286,27 @@ public class PatrolTaskExecController extends BaseController {
                 updateTaskExecRecord(TaskStatus.RUNNING.getCode(), execRecords);
             } else if (TaskStatus.HALTED.getCode().equals(state)) {
                 updateTaskExecRecord(TaskStatus.HALTED.getCode(), execRecords);
-                String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskCode);
                 if (StringUtils.isNotEmpty(redisImmediatelyExecTaskTime)) {
-                    redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                    redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskCode);
                 }
 
-                Integer redisTaskPatrolState = redisService.getCacheObject(RedisConst.TASK_PATROL_STATE);
+                Integer redisTaskPatrolState = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, taskCode);
                 if (redisTaskPatrolState != null) {
-                    redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
+                    redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, taskCode);
                 }
 
-                String redisTaskPatrolId = redisService.getCacheObject(RedisConst.TASK_PATROL_ID);
+                String redisTaskPatrolId = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_ID, taskCode);
                 if (!StringUtils.isEmpty(redisTaskPatrolId)) {
-                    redisService.deleteObject(RedisConst.TASK_PATROL_ID);
+                    redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, taskCode);
                 }
 
-                String key = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+                String key = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
                 if (key != null) {
                     log.info("[TASK] [{}] FINISH", key);
-                    redisService.deleteObject(RedisConst.TASK_CURRENT_CODE);
-                    log.info("[TASK] [{}] REMOVE FROM QUEUE", key);
-                    redisService.deleteObject(key);
+                    redisService.deleteObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
+                    boolean b = redisService.deleteObject(key);
+                    log.info("[TASK] [{}] REMOVE FROM QUEUE:{}", key, b);
                 }
             }
         }
@@ -350,7 +350,7 @@ public class PatrolTaskExecController extends BaseController {
         //log.info("[TASK] MODIFY SUCCESS state:{}", state);
         if (TaskStatus.PAUSED.getCode().equals(state)) {
             //log.info("[TASK] MODIFY ADD STOP TIME, state:{}", state);
-            redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
+//            redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
         }
     }
 
@@ -392,7 +392,7 @@ public class PatrolTaskExecController extends BaseController {
         execRecord.setManualPauseState("1");
         this.patrolTaskExecRecordService.updatePatrolTaskExecRecord(execRecord);
         this.log.info("[EXEC] STOP TASK: {}", JSONObject.toJSONString(execRecord));
-        this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
+//        this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
         return true;
     }
 
@@ -448,169 +448,6 @@ public class PatrolTaskExecController extends BaseController {
         return false;
     }
 
-//    @PostMapping({"/selectCurrentDayTask"})
-//    public Map<String, List<PatrolTask>> selectCurrentDayTask() {
-//        Map<String, List<PatrolTask>> taskMainMap = new HashMap<>();
-//        //logger.info("[GABRIEL] day: {}, hour: {}, minute: {}", DateUtils.getDayInt(), DateUtils.getHourInt(), DateUtils.getMinuteInt());
-//        List<PatrolTask> patrolTaskList
-//                = patrolTaskService.selectPatrolTaskList(PatrolTask.builder().isEnable("0").build());
-//        if (patrolTaskList.isEmpty())
-//            return taskMainMap;
-//
-//        Iterator<PatrolTask> iterator = patrolTaskList.iterator();
-//        while (true) {
-//            PatrolTask task;
-//            String fixedDay;
-//            List<Date> exeTimes;
-//            do {
-//                while (true) {
-//                    do {
-//                        if (!iterator.hasNext()) {
-//                            logger.info("[TASK] iterator end");
-//                            return taskMainMap;
-//                        }
-//                        task = iterator.next();
-//                    } while (StringUtils.isEmpty(task.getDevType()));
-//
-//                    if (isFixedTask(task)) {
-//
-//                        //logger.info("[TASK] REGULAR fixedDay: {}", fixedDay);
-//                        fixedDay = DateUtils.format(DateUtils.yyyyMMdd, task.getFixedStartTime());
-//                        break;
-//                    }
-//
-//                    if (!StringUtils.isEmpty(task.getCycleExecuteTime())
-//                            && task.getCycleStartTime() != null && task.getCycleEndTime() != null
-//                            && DateUtils.toInt(DateUtils.yyyyMMdd, new Date()) >= DateUtils.toInt(DateUtils.yyyyMMdd, task.getCycleStartTime())
-//                            && DateUtils.toInt(DateUtils.yyyyMMdd, new Date()) <= DateUtils.toInt(DateUtils.yyyyMMdd, task.getCycleEndTime())
-//                            && ExecStatus.PERIODIC.getCode().equals(task.getExecutionStatus())) {
-//                        if (!StringUtils.isEmpty(task.getCycleWeek())) {
-//                            String[] intervalExecuteTime = task.getCycleWeek().split(StringUtils.COMMA);
-//                            String[] cycleExecuteTimes = task.getCycleExecuteTime().split(StringUtils.COMMA);
-//                            for (int i = 0; i < intervalExecuteTime.length; ++i) {
-//                                String dayOfWeek = intervalExecuteTime[i];
-//                                if (DateUtils.getDayOfWeek(new Date()).equals(dayOfWeek)) {
-//                                    try {
-//                                        task.setFixedStartTime(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, (DateUtils.format(DateUtils.yyyyMMdd2, new Date()) + " " + cycleExecuteTimes[i])));
-//                                        String[] devNos = task.getDevNo().split(StringUtils.COMMA);
-//                                        for (String devNo : devNos) {
-//                                            String taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                            PatrolTaskExecRecord taskExecRecord
-//                                                    = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                            if (taskExecRecord == null) {
-//                                                List<PatrolTask> cameraPatrolTasks = getPatrolTasks(task);
-//                                                String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                                //logger.info("[GABRIEL] key2: {}", key);
-//                                                taskMainMap.put(key, cameraPatrolTasks);
-//                                                redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                            }
-//                                        }
-//                                    } catch (Exception e) {
-//                                        e.printStackTrace();
-//                                    }
-//                                }
-//                            }
-//                        } else if (!StringUtils.isEmpty(task.getCycleMonth())) {
-//                            String[] intervalExecuteTime = task.getCycleMonth().split(StringUtils.COMMA);
-//                            String[] cycleExecuteTimes = task.getCycleExecuteTime().split(StringUtils.COMMA);
-//
-//                            for (int i = 0; i < intervalExecuteTime.length; ++i) {
-//                                String month = intervalExecuteTime[i];
-//                                if (DateUtils.getDayInt() == Integer.parseInt(month) && task.getCycleExecuteTime() != null) {
-//                                    try {
-//                                        task.setFixedStartTime(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, (DateUtils.format(DateUtils.yyyyMMdd2, new Date()) + " " + cycleExecuteTimes[i])));
-//                                        String[] devNos = task.getDevNo().split(StringUtils.COMMA);
-//                                        for (String devNo : devNos) {
-//                                            String taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                            PatrolTaskExecRecord taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                            if (taskExecRecord == null) {
-//                                                List<PatrolTask> cameraPatrolTasks = getPatrolTasks(task);
-//                                                String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                                log.info("[JOB] key3: {}", key);
-//                                                taskMainMap.put(key, cameraPatrolTasks);
-//                                                redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                            }
-//                                        }
-//                                    } catch (Exception e) {
-//                                        e.printStackTrace();
-//                                    }
-//                                }
-//                            }
-//                        }
-//                    } else if (!StringUtils.isEmpty(task.getIntervalExecuteTime())
-//                            && task.getIntervalStartTime() != null
-//                            && DateUtils.toInt(DateUtils.yyyyMMdd, new Date()) >= DateUtils.toInt(DateUtils.yyyyMMdd, task.getIntervalStartTime())
-//                            && DateUtils.toInt(DateUtils.yyyyMMdd, new Date()) <= DateUtils.toInt(DateUtils.yyyyMMdd, task.getIntervalEndTime())
-//                            && ExecStatus.INTERVAL.getCode().equals(task.getExecutionStatus())) {
-//                        String[] intervalExecuteTime = task.getIntervalExecuteTime().split(StringUtils.COLON);
-//                        String[] devNos;
-//                        String taskPatrolledId;
-//                        PatrolTaskExecRecord taskExecRecord;
-//                        List<PatrolTask> cameraPatrolTasks;
-//                        if (IntervalType.BY_HOUR.getCode().equals(task.getIntervalType())) {
-//                            exeTimes = getExecTimes(task.getIntervalExecuteTime(), task.getIntervalNumber());
-//                            for (Date exeTime : exeTimes) {
-//                                task.setFixedStartTime(exeTime);
-//                                devNos = task.getDevNo().split(StringUtils.COMMA);
-//
-//                                for (String devNo : devNos) {
-//                                    taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                    taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                    if (taskExecRecord == null) {
-//                                        cameraPatrolTasks = this.getPatrolTasks(task);
-//                                        String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                        log.info("[GABRIEL] key4: {}", key);
-//                                        taskMainMap.put(key, cameraPatrolTasks);
-//                                        redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                    }
-//                                }
-//                            }
-//                        } else if (IntervalType.BY_DATE.getCode().equals(task.getIntervalType())) {
-//                            for (int j = 0; j < task.getIntervalNumber(); ++j) {
-//                                if (j != 0) {
-//                                    intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
-//                                }
-//
-//                                try {
-//                                    String time = intervalExecuteTime[0] + ":" + DateUtils.getMinuteInt() + ":" + intervalExecuteTime[2];
-//                                    task.setFixedStartTime(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, (DateUtils.format(DateUtils.yyyyMMdd2, new Date()) + " " + time)));
-//                                    devNos = task.getDevNo().split(StringUtils.COMMA);
-//                                    for (String devNo : devNos) {
-//                                        taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                        taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                        if (taskExecRecord == null) {
-//                                            cameraPatrolTasks = getPatrolTasks(task);
-//                                            String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                            log.info("[GABRIEL] key5: {}", key);
-//                                            taskMainMap.put(key, cameraPatrolTasks);
-//                                            redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                        }
-//                                    }
-//                                } catch (Exception e) {
-//                                    e.printStackTrace();
-//                                }
-//                            }
-//                        }
-//                    }
-//                }
-//            } while (!DateUtils.format(DateUtils.yyyyMMdd, new Date()).equals(fixedDay));
-//
-//            log.info("[GABRIEL] break the out while");
-//            List<PatrolTask> patrolTasks = getPatrolTasks(task);
-//            for (PatrolTask patrolTask : patrolTasks) {
-//                PatrolTaskExecRecord taskExecRecord
-//                        = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(patrolTask.getDevNo() + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime()));
-//                if (taskExecRecord == null) {
-//                    JSONArray.toJSONString(patrolTasks);
-//                    String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                    log.info("[GABRIEL] key6: {}", key);
-//                    taskMainMap.put(key, patrolTasks);
-//                    redisService.setCacheObject(key, JSONArray.toJSONString(patrolTasks));
-//                }
-//            }
-//        }
-//    }
-
     private boolean isFixedTask(final PatrolTask patrolTask) {
         return patrolTask.getFixedStartTime() != null
                 && ExecStatus.REGULAR.getCode().equals(patrolTask.getExecutionStatus());
@@ -705,27 +542,10 @@ public class PatrolTaskExecController extends BaseController {
                             task.setFixedStartTime(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, (DateUtils.format(DateUtils.yyyyMMdd2, new Date()) + " " + cycleTimes[i])));
                             final String taskType = "CYCLE-BY-MONTH";
                             parseTaskToRedis(taskType, task);
-//                            String[] devNos = task.getDevNo().split(StringUtils.COMMA);
-//                            for (String devNo : devNos) {
-//                                String key = "TASK_CODE@" + task.getTaskCode() + StringUtils.AT + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                log.info("[JOB] key3: {}", key);
-//                                String taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                PatrolTaskExecRecord taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                String redisValue = redisService.getCacheObject(key);
-//                                if (taskExecRecord == null && StringUtils.isEmpty(redisValue)) {
-//                                    List<PatrolTask> cameraPatrolTasks = getPatrolTasks(task);
-//                                    taskMainMap.put(key, cameraPatrolTasks);
-//                                    redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                }
-//                            }
                         }
                     }
                 } else if (isInterTask(task)) {
                     String[] intervalExecuteTime = task.getIntervalExecuteTime().split(StringUtils.COLON);
-//                    String[] devNos;
-//                    String taskPatrolledId;
-//                    PatrolTaskExecRecord taskExecRecord;
-//                    List<PatrolTask> cameraPatrolTasks;
                     if (isInterTaskByHour(task)) {
                         int intervalNumber = task.getIntervalNumber();
                         if (intervalNumber > 0) {
@@ -734,20 +554,6 @@ public class PatrolTaskExecController extends BaseController {
                                 task.setFixedStartTime(exeTime);
                                 final String taskType = "INTER-BY-HOUR";
                                 parseTaskToRedis(taskType, task);
-//                                devNos = task.getDevNo().split(StringUtils.COMMA);
-//                                for (String devNo : devNos) {
-//                                    taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                    taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                    if (taskExecRecord == null) {
-//                                        cameraPatrolTasks = getPatrolTasks(task);
-//                                        if(!cameraPatrolTasks.isEmpty()) {
-//                                            String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                            //log.info("[GABRIEL] key4: {}", key);
-//                                            taskMainMap.put(key, cameraPatrolTasks);
-//                                            redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                        }
-//                                    }
-//                                }
                             }
                         } else {
                             log.info("[TASK] isInterTaskByHour intervalNumber error: {}", intervalNumber);
@@ -762,18 +568,6 @@ public class PatrolTaskExecController extends BaseController {
                             task.setFixedStartTime(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, (DateUtils.format(DateUtils.yyyyMMdd2, new Date()) + " " + time)));
                             final String taskType = "INTER-BY-DATE";
                             parseTaskToRedis(taskType, task);
-//                            devNos = task.getDevNo().split(StringUtils.COMMA);
-//                            for (String devNo : devNos) {
-//                                taskPatrolledId = devNo + "_" + task.getTaskCode() + "_" + DateUtils.format(DateUtils.yyyyMMddHHmmss, task.getFixedStartTime());
-//                                taskExecRecord = patrolTaskExecRecordService.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolledId);
-//                                if (taskExecRecord == null) {
-//                                    cameraPatrolTasks = getPatrolTasks(task);
-//                                    String key = "TASK_CODE@" + task.getTaskCode() + "@" + DateUtils.format(DateUtils.yyyyMMddHHmmss2, task.getFixedStartTime());
-//                                    log.info("[GABRIEL] key5: {}", key);
-//                                    taskMainMap.put(key, cameraPatrolTasks);
-//                                    redisService.setCacheObject(key, JSONArray.toJSONString(cameraPatrolTasks));
-//                                }
-//                            }
                         }
                     }
                 }
@@ -847,10 +641,10 @@ public class PatrolTaskExecController extends BaseController {
 
     @PostMapping({"/execCurrentDayTask"})
     public void execCurrentDayTask() throws ParseException {
-        String taskCodeStr = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
-        if (!StringUtils.isEmpty(taskCodeStr)) {
-            this.log.info("      【当前正在执行的任务：{}, 其它任务不能执行！！！】", taskCodeStr);
-        } else {
+//        String taskCodeStr = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+//        if (!StringUtils.isEmpty(taskCodeStr)) {
+//            this.log.info("      【当前正在执行的任务：{}, 其它任务不能执行！！！】", taskCodeStr);
+//        } else {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             for (String key : this.redisService.keys(RedisConst.TASK_CODE_EX)) {
                 String fixedStartTime = key.split(StringUtils.AT)[2];
@@ -862,12 +656,12 @@ public class PatrolTaskExecController extends BaseController {
                     extracted(key, key);
                 }
             }
-        }
+//        }
     }
 
     private void extracted(String key, String taskCode) {
         log.info(Color.RED + "[EXEC] Add new task [{}]" + Color.END, key);
-        redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, key);
+        redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode, key);
         log.info("[EXEC] key: {}", key);
         List<PatrolTask> cameraPatrolTasks = redisService.getCacheObject(key);
         if (!cameraPatrolTasks.isEmpty()) {

inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecuteSchedulerController.java

@@ -127,12 +127,14 @@ public class PatrolTaskExecuteSchedulerController extends BaseController {
         String immediatelyExecTaskTime = "";
         Iterator iterator = cameraPatrolTasks.iterator();
         while (true) {
-            PatrolTask task;
+            PatrolTask task = null;
             while (true) {
                 do {
                     if (!iterator.hasNext()) {
                         if (immediatelyExecTaskTime != null && !immediatelyExecTaskTime.isEmpty()) {
-                            this.redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                            if(task != null) {
+                                this.redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, task.getTaskCode());
+                            }
                         }
 
                         return;
@@ -163,20 +165,20 @@ public class PatrolTaskExecuteSchedulerController extends BaseController {
                     this.log.info("暂停当前执行任务 {} ", "taskName:" + patrolTaskExecRecord.getTaskName() + " taskCode:" + patrolTaskExecRecord.getTaskCode() + " execPointId:" + patrolTaskExecRecord.getExecPointId() + " deviceId:" + patrolTaskPointExecRecord.getDeviceId());
                     patrolTaskExecRecord.setTaskState("3");
                     this.taskExecClient.updatePatrolTaskExecRecord(patrolTaskExecRecord);
-                    this.log.info("修改执行状态成功=state:3 ");
-                    this.log.info("====================暂停添加时间记录=state:3");
-                    this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, patrolTaskExecRecord.getDevNo() + "&" + patrolTaskExecRecord.getTaskPatrolId(), new Date());
+//                    this.log.info("修改执行状态成功=state:3 ");
+//                    this.log.info("====================暂停添加时间记录=state:3");
+//                    this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, patrolTaskExecRecord.getDevNo() + "&" + patrolTaskExecRecord.getTaskPatrolId(), new Date());
                     break;
                 }
             }
 
             PatrolTaskExecRecord patrolTaskExecRecord = new PatrolTaskExecRecord();
             if (immediatelyExecTaskTime != null && !immediatelyExecTaskTime.isEmpty()) {
-                immediatelyExecTaskTime = this.redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
+                immediatelyExecTaskTime = this.redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTaskExecRecord.getTaskPatrolId());
             } else {
                 SimpleDateFormat sdfOld = new SimpleDateFormat("yyyyMMddHHmmss");
                 immediatelyExecTaskTime = sdfOld.format(new Date());
-                this.redisService.setCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, immediatelyExecTaskTime);
+                this.redisService.setCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTaskExecRecord.getTaskPatrolId(), immediatelyExecTaskTime);
             }
 
             Date time = task.getFixedStartTime();

inspect-main/inspect-main-task/src/main/java/com/inspect/task/controller/PatrolTaskController.java

@@ -397,7 +397,7 @@ public class PatrolTaskController extends BaseController {
                 List<PatrolTask> eqList = toPatrolTaskList(parseObject, flag);
                 makeupPatrolTaskDetails(eqList, flag);
                 PatrolTask patrolTask = eqList.get(0);
-                String key = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+                String key = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
                 if (key != null && key.contains(String.valueOf(patrolTask.getTaskId()))) {
                     return AjaxResult.error("Task is executing, modify forbidden!");
                 }

inspect-main/inspect-main-task/src/main/java/com/inspect/taskstatus/controller/PatrolTaskStatusController.java

@@ -514,7 +514,7 @@ public class PatrolTaskStatusController extends BaseController {
     //立即执行任务
     @GetMapping({"/controlChange"})
     public AjaxResult controlChange(PatrolTask patrolTask) {
-        String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+        String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
         if (!StringUtils.isEmpty(taskCode)) {
             log.info("[TASK] CURRENT EXEC TASK: {}", taskCode);
             return AjaxResult.error(501, "THERE TASK IS RUNNING!");
@@ -551,7 +551,7 @@ public class PatrolTaskStatusController extends BaseController {
 
     private void extracted(PatrolTask patrolTask) throws InterruptedException {
         Thread.sleep(20000L);
-        String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
+        String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
         if (taskCode != null && taskCode.contains(String.valueOf(patrolTask.getTaskId()))) {
             this.log.info("[TASK STATUS] UPDATE TASK: {} STATUS to IMMEDIATE", taskCode);
             PatrolTaskStatus patrolTaskStatus = new PatrolTaskStatus();
@@ -717,24 +717,24 @@ public class PatrolTaskStatusController extends BaseController {
             if (!TaskStatus.DONE.getCode().equals(patrolTaskStatus.getCommand())) {
                 if (TaskStatus.RUNNING.getCode().equals(patrolTaskStatus.getCommand())) {
                     cmd = TaskStatus.PAUSED.getCode();
-                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskPatrolledId());
-                    redisService.setCacheObject(RedisConst.TASK_PATROL_STATE, cmd);
+                    redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode(), patrolTaskStatus.getTaskPatrolledId());
+                    redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode(), cmd);
                     log.info("[TASK] PAUSE, UPDATE STATUS STATE: {}, patrolId: {}", DescUtil.getTaskStatusDesc(cmd), patrolTaskStatus.getTaskPatrolledId());
                 } else if (TaskStatus.PAUSED.getCode().equals(patrolTaskStatus.getCommand())) {
                     cmd = TaskStatus.RUNNING.getCode();
-                    redisService.deleteObject(RedisConst.TASK_PATROL_ID);
-                    redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
-                    redisTaskPatrolId = redisService.getCacheObject(RedisConst.TASK_PATROL_ID);
-                    String redisTaskPatrolState = redisService.getCacheObject(RedisConst.TASK_PATROL_STATE);
+                    redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
+                    redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
+                    redisTaskPatrolId = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
+                    String redisTaskPatrolState = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
                     log.info("[TASK] CONTINUE, UPDATE STATUS STATE: {}, patrolId: {}", DescUtil.getTaskStatusDesc(redisTaskPatrolState), redisTaskPatrolId);
                     if (!StringUtils.isEmpty(redisTaskPatrolId) && TaskStatus.PAUSED.getCode().equals(redisTaskPatrolState)) {
-                        redisService.deleteObject(RedisConst.TASK_PATROL_ID);
-                        redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
+                        redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
+                        redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
                     }
                 } else if (TaskStatus.HALTED.getCode().equals(patrolTaskStatus.getCommand())) {
                     cmd = TaskStatus.HALTED.getCode();
-                    redisService.setCacheObject(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskPatrolledId());
-                    redisService.setCacheObject(RedisConst.TASK_PATROL_STATE, cmd);
+                    redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode(), patrolTaskStatus.getTaskPatrolledId());
+                    redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode(), cmd);
                     log.info("[TASK] HALT, UPDATE STATUS STATE: [{}], ID: [{}]", cmd, patrolTaskStatus.getTaskPatrolledId());
                 }
             }