Merge branch 'feature-v4.10.0-20230621-dsx' into test

# Conflicts:
#	src/main/java/com/fdkankan/scene/schedule/ScheduleJob.java

src/main/java/com/fdkankan/scene/config/ScheduledConfig.java

@@ -1,21 +1,51 @@
 package com.fdkankan.scene.config;
 
+import org.springframework.boot.autoconfigure.batch.BatchProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.scheduling.TaskScheduler;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.scheduling.annotation.SchedulingConfigurer;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+import org.springframework.scheduling.config.ScheduledTaskRegistrar;
+import org.springframework.util.CollectionUtils;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.concurrent.Executors;
 
 @Configuration
-public class ScheduledConfig {
+public class ScheduledConfig implements SchedulingConfigurer {
 
     /**
-     * 这里从新定义定时任务线程池大小，如果不定义大小，框架默认大小是1，当有多个定时任务时，不能同时启动，只能一个一个同步执行
-     * 这里定义了线程池大小之后，就可以实现 同一个任务同步执行，不同任务可以同时执行
+     * 此配置实现：
+     * 1、同一个定时任务等待上一次执行完毕后再执行
+     * 2、不同定时任务同时执行
+     * @param taskRegistrar
      */
-    @Bean
-    public TaskScheduler taskScheduler() {
-        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
-        taskScheduler.setPoolSize(10);
-        return taskScheduler;
+    @Override
+    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
+        Method[] methods = BatchProperties.Job.class.getMethods();
+        int defaultPoolSize = 3;
+        int corePoolSize = 0;
+
+        if (!CollectionUtils.isEmpty(Arrays.asList(methods))) {
+
+            for (Method method : methods) {
+
+                Scheduled annotation = method.getAnnotation(Scheduled.class);
+
+                if (annotation != null) {
+
+                    corePoolSize++;
+                }
+            }
+            if (defaultPoolSize > corePoolSize) {
+
+                corePoolSize = defaultPoolSize;
+            }
+
+            taskRegistrar.setScheduler(Executors.newScheduledThreadPool(corePoolSize));
+        }
     }
 }

src/main/java/com/fdkankan/scene/schedule/ScheduleJob.java

@@ -11,8 +11,6 @@ import lombok.extern.log4j.Log4j2;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
-import org.springframework.scheduling.annotation.Async;
-import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 
@@ -21,7 +19,6 @@ import javax.annotation.PostConstruct;
 @RefreshScope
 @Log4j2
 @Component
-@EnableAsync
 public class ScheduleJob {
 
     @Value("${environment:#{null}}")
@@ -44,70 +41,63 @@ public class ScheduleJob {
         log.info("定时清除全景图压缩包完毕");
     }
 
-//    /**
-//     * 删除场景原始资源
-//     * 每天凌晨执行
-//     */
-//    @Scheduled(cron="0 0 1 * * ?")
-//    public void cleanOssHomeV3() {
-//        log.info("删除v3场景原始资源开始");
-//        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_ORIG_V3;
-//        try {
-//            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
-//            if(!lock){
-//                return;
-//            }
-//            sceneCleanOrigService.cleanOrigV3();
-//        }finally {
-//            redisLockUtil.unlockLua(lockKey);
-//        }
-//        log.info("删除v3场景原始资源结束");
-//    }
-//
-//    /**
-//     * 删除场景原始资源
-//     * 每天凌晨执行
-//     */
-//    @Scheduled(cron="0 0 1 * * ?")
-//    public void cleanOssHomeV4() {
-//        log.info("删除v4场景原始资源开始");
-//        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_ORIG_V4;
-//        try {
-//            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
-//            if(!lock){
-//                return;
-//            }
-//            sceneCleanOrigService.cleanOrigV4();
-//        }finally {
-//            redisLockUtil.unlockLua(lockKey);
-//        }
-//        log.info("删除v4场景原始资源结束");
-//    }
+    /**
+     * 删除场景原始资源
+     * 每天凌晨执行
+     */
+    @Scheduled(cron="0 0 1 * * ?")
+    public void cleanOssHomeV3() {
+        log.info("删除v3场景原始资源开始");
+        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_ORIG_V3;
+        try {
+            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
+            if(!lock){
+                return;
+            }
+            sceneCleanOrigService.cleanOrigV3();
+        }finally {
+            redisLockUtil.unlockLua(lockKey);
+        }
+        log.info("删除v3场景原始资源结束");
+    }
+
+    /**
+     * 删除场景原始资源
+     * 每天凌晨执行
+     */
+    @Scheduled(cron="0 0 1 * * ?")
+    public void cleanOssHomeV4() {
+        log.info("删除v4场景原始资源开始");
+        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_ORIG_V4;
+        try {
+            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
+            if(!lock){
+                return;
+            }
+            sceneCleanOrigService.cleanOrigV4();
+        }finally {
+            redisLockUtil.unlockLua(lockKey);
+        }
+        log.info("删除v4场景原始资源结束");
+    }
 
     /**
      * 删除已删除场景原始资源及caches
      * 每天凌晨执行
      */
-//    @PostConstruct
-    @Async
-    @Scheduled(cron="0/5 * * * * ?")
+    @Scheduled(cron="0 0 1 * * ?")
     public void cleanOss4DeletedSceneV3() {
         log.info("删除已删除V3场景原始资源开始");
+        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_DELETED_ORIG_V3;
         try {
-            Thread.sleep(60000L);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
+            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
+            if(!lock){
+                return;
+            }
+            sceneCleanOrigService.cleanOss4DeletedSceneV3();
+        }finally {
+            redisLockUtil.unlockLua(lockKey);
         }
-//        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_DELETED_ORIG_V3;
-//        try {
-//            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
-//            if(!lock){
-//                return;
-//            }
-//            sceneCleanOrigService.cleanOss4DeletedSceneV3();
-//        }finally {
-//            redisLockUtil.unlockLua(lockKey);
-//        }
         log.info("删除已删除V3场景原始资源结束");
     }
 
@@ -116,27 +106,21 @@ public class ScheduleJob {
      * 删除已删除场景原始资源及caches
      * 每天凌晨执行
      */
-//    @PostConstruct
-//    @Scheduled(cron="0 0 1 * * ?")
-//    public void cleanOss4DeletedSceneV4() {
-//        log.info("删除已删除V4场景原始资源开始");
-//        try {
-//            Thread.sleep(60000L);
-//        } catch (InterruptedException e) {
-//            e.printStackTrace();
-//        }
-//        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_DELETED_ORIG_V4;
-//        try {
-//            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
-//            if(!lock){
-//                return;
-//            }
-//            sceneCleanOrigService.cleanOss4DeletedSceneV4();
-//        }finally {
-//            redisLockUtil.unlockLua(lockKey);
-//        }
-//        log.info("删除已删除V4场景原始资源结束");
-//    }
+    @Scheduled(cron="0 0 1 * * ?")
+    public void cleanOss4DeletedSceneV4() {
+        log.info("删除已删除V4场景原始资源开始");
+        String lockKey = RedisLockKey.LOCK_CLEAN_SCENE_DELETED_ORIG_V4;
+        try {
+            boolean lock = redisLockUtil.lock(lockKey, 24*60*60);
+            if(!lock){
+                return;
+            }
+            sceneCleanOrigService.cleanOss4DeletedSceneV4();
+        }finally {
+            redisLockUtil.unlockLua(lockKey);
+        }
+        log.info("删除已删除V4场景原始资源结束");
+    }
 
 //    /**
 //     * 删除测试相机场景原始资源及caches