update

src/main/java/com/qmth/exam/reserve/cache/CacheConstants.java

@@ -98,8 +98,8 @@ public interface CacheConstants {
 
     /**
      * 考点时段操作锁
-     * $lock:exam_site_time_period:{examSiteId}_{timePeriodId}
+     * $lock:exam_site_time_period:{examSiteId}
      */
-    String LOCK_EXAM_SITE_TIME_PERIOD = "exam_site_time_period:%s_%s";
+    String LOCK_EXAM_SITE_TIME_PERIOD = "exam_site_time_period:%s";
 
 }

src/main/java/com/qmth/exam/reserve/service/impl/ExamRoomServiceImpl.java

@@ -316,34 +316,34 @@ public class ExamRoomServiceImpl extends ServiceImpl<ExamRoomDao, ExamRoomEntity
         Map<Long, TimePeriodExamRoomEntity> timePeriodExamRoomMap = timePeriodExamRooms.stream().collect(
                 Collectors.toMap(TimePeriodExamRoomEntity::getTimePeriodId, Function.identity()));
 
-        for (TimePeriodEntity timePeriod : timePeriods) {
-            String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examSiteId, timePeriod.getId());
-            RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
-            try {
-                if (!examSiteTimePeriodLock.tryLock()) {
-                    log.warn("[考场容量更新] 获取锁失败，不能同时修改考点考场容量, lockKey:{}", examSiteTimePeriodLock);
-                    throw new StatusException("考场保存失败，请稍后再试");
-                } else {
+        String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examSiteId);
+        RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
+        try {
+            if (!examSiteTimePeriodLock.tryLock()) {
+                log.warn("[考场容量更新] 获取锁失败，不能同时修改考点考场容量, lockKey:{}", examSiteTimePeriodLock);
+                throw new StatusException("考场保存失败，请稍后再试");
+            } else {
+                for (TimePeriodEntity timePeriod : timePeriods) {
                     //刷新缓存
                     TimePeriodExamRoomEntity timePeriodExamRoomEntity = timePeriodExamRoomMap.get(timePeriod.getId());
                     if (timePeriodExamRoomEntity == null || timePeriodExamRoomEntity.getEnable()) {
                         cacheService.refreshApplyAvailableCountCache(examSiteId, timePeriod.getId(), oldCapacity, newCapacity);
                     }
                 }
-            } catch (Exception e) {
-                log.error("[考场容量更新] 考场保存失败, msg:{}", e.getMessage());
-                throw new StatusException("考场保存失败，请稍后再试");
-            } finally {
-                try {
-                    if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
-                        examSiteTimePeriodLock.unlock();
-                        log.info("[考场容量更新] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
-                    }
-                } catch (Exception e) {
-                    log.warn(e.getMessage());
+
+            }
+        } catch (Exception e) {
+            log.error("[考场容量更新] 考场保存失败, msg:{}", e.getMessage());
+            throw new StatusException("考场保存失败，请稍后再试");
+        } finally {
+            try {
+                if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
+                    examSiteTimePeriodLock.unlock();
+                    log.info("[考场容量更新] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
                 }
+            } catch (Exception e) {
+                log.warn(e.getMessage());
             }
-
         }
     }
 

src/main/java/com/qmth/exam/reserve/service/impl/TimePeriodExamRoomServiceImpl.java

@@ -402,65 +402,60 @@ public class TimePeriodExamRoomServiceImpl extends ServiceImpl<TimePeriodExamRoo
     }
 
     private void refreshDisableTimePeriodCache(List<TimePeriodExamRoomEntity> disableList, ExamRoomEntity examRoom) {
-        disableList.stream()
-                .filter(item -> !item.getEnable())
-                .forEach(item -> {
-                    String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examRoom.getExamSiteId(),
-                            item.getTimePeriodId());
-                    RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
-                    try {
-                        if (!examSiteTimePeriodLock.tryLock()) {
-                            log.warn("[考场排班设置] 获取锁失败，不能同时修改考场排班设置, lockKey:{}", examSiteTimePeriodLock);
-                            throw new StatusException("考场排班保存失败，请稍后再试");
-                        } else {
+        String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examRoom.getExamSiteId());
+        RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
+
+        try {
+            if (!examSiteTimePeriodLock.tryLock()) {
+                log.warn("[考场排班设置] 获取锁失败，不能同时修改考场排班设置, lockKey:{}", examSiteTimePeriodLock);
+                throw new StatusException("考场排班保存失败，请稍后再试");
+            } else {
+                disableList.stream()
+                        .filter(item -> !item.getEnable())
+                        .forEach(item -> {
                             // 更新容量缓存,禁用需要减考场容量
                             applyTaskCacheService.refreshApplyAvailableCountCache(
                                     examRoom.getExamSiteId(),
                                     item.getTimePeriodId(),
-//                                    examSite.getCapacity(),
-//                                    examSite.getCapacity()- examRoom.getCapacity()
                                     examRoom.getCapacity(),
                                     0
                             );
-                        }
-
-                    } catch (Exception e) {
-                        log.error("[考场排班设置] 考场排班失败, msg:{}", e.getMessage());
-                        throw new StatusException("考场排班保存失败，请稍后再试");
-                    } finally {
-                        try {
-                            if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
-                                examSiteTimePeriodLock.unlock();
-                                log.info("[考场排班设置] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
-                            }
-                        } catch (Exception e) {
-                            log.warn(e.getMessage());
-                        }
-                    }
-                });
+                        });
+            }
+        } catch (Exception e) {
+            log.error("[考场排班设置] 考场排班失败, msg:{}", e.getMessage());
+            throw new StatusException("考场排班保存失败，请稍后再试");
+        } finally {
+            try {
+                if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
+                    examSiteTimePeriodLock.unlock();
+                    log.info("[考场排班设置] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
+                }
+            } catch (Exception e) {
+                log.warn(e.getMessage());
+            }
+        }
+
     }
 
     private void refreshUpdatedTimePeriodCache(List<TimePeriodExamRoomEntity> updateList,
             Map<Long, TimePeriodExamSiteBean> timePeriodMap, ExamRoomEntity examRoom) {
-        updateList.forEach(item -> {
-            TimePeriodExamSiteBean timePeriod = timePeriodMap.get(item.getId());
-            String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examRoom.getExamSiteId(),
-                    item.getTimePeriodId());
-            RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
+        String examSiteTimePeriodLockKey = String.format(CacheConstants.LOCK_EXAM_SITE_TIME_PERIOD, examRoom.getExamSiteId());
+        RLock examSiteTimePeriodLock = (RLock) concurrentService.getLock(examSiteTimePeriodLockKey);
 
-            try {
-                if (!examSiteTimePeriodLock.tryLock()) {
-                    log.warn("[考场排班设置] 获取锁失败，不能同时修改考场排班设置, lockKey:{}", examSiteTimePeriodLock);
-                    throw new StatusException("考场排班保存失败，请稍后再试");
-                } else {
+        try {
+            if (!examSiteTimePeriodLock.tryLock()) {
+                log.warn("[考场排班设置] 获取锁失败，不能同时修改考场排班设置, lockKey:{}", examSiteTimePeriodLock);
+                throw new StatusException("考场排班保存失败，请稍后再试");
+            } else {
+                updateList.forEach(item -> {
+                    TimePeriodExamSiteBean timePeriod = timePeriodMap.get(item.getId());
                     //由启用变为禁用,缓存容量=-考场的容量
                     if (timePeriod != null && Boolean.TRUE.equals(timePeriod.getEnable()) && !item.getEnable()) {
                         // 更新容量缓存
                         applyTaskCacheService.refreshApplyAvailableCountCache(
                                 examRoom.getExamSiteId(),
                                 timePeriod.getTimePeriodId(),
-                                //                                examSite.getCapacity(),
-                                //                                examSite.getCapacity() - examRoom.getCapacity()
                                 examRoom.getCapacity(),
                                 0
                         );
@@ -472,28 +467,27 @@ public class TimePeriodExamRoomServiceImpl extends ServiceImpl<TimePeriodExamRoo
                         applyTaskCacheService.refreshApplyAvailableCountCache(
                                 examRoom.getExamSiteId(),
                                 timePeriod.getTimePeriodId(),
-                                //                                examSite.getCapacity(),
-                                //                                examSite.getCapacity() + examRoom.getCapacity()
                                 0,
                                 examRoom.getCapacity()
                         );
                     }
-                }
+                });
+            }
 
-            } catch (Exception e) {
-                log.error("[考场排班设置] 考场排班失败, msg:{}", e.getMessage());
-                throw new StatusException("考场排班保存失败，请稍后再试");
-            } finally {
-                try {
-                    if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
-                        examSiteTimePeriodLock.unlock();
-                        log.info("[考场排班设置] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
-                    }
-                } catch (Exception e) {
-                    log.warn(e.getMessage());
+        } catch (Exception e) {
+            log.error("[考场排班设置] 考场排班失败, msg:{}", e.getMessage());
+            throw new StatusException("考场排班保存失败，请稍后再试");
+        } finally {
+            try {
+                if (examSiteTimePeriodLock.isLocked() && examSiteTimePeriodLock.isHeldByCurrentThread()) {
+                    examSiteTimePeriodLock.unlock();
+                    log.info("[考场排班设置] 解锁成功,lockKey:{}", examSiteTimePeriodLock);
                 }
+            } catch (Exception e) {
+                log.warn(e.getMessage());
             }
-        });
+        }
+
     }
 
 }