face和liveness去掉锁

themis-business/src/main/java/com/qmth/themis/business/constant/SystemConstant.java

@@ -230,21 +230,6 @@ public class SystemConstant {
     //手机锁
     public static final String REDIS_LOCK_MOBILE_AUTHORIZATION_PREFIX = "lock:mobile:authorization_";
 
-    //人脸检测锁
-    public static final String REDIS_LOCK_FACE_VERIFY_PREFIX = "lock:face:verify_";
-
-    //多张人脸检测锁
-    public static final String REDIS_LOCK_FACE_MULTIPLE_VERIFY_PREFIX = "lock:face:multiple:verify_";
-
-    //人脸比对异常锁
-    public static final String REDIS_LOCK_FACE_COMPARE_VERIFY_PREFIX = "lock:face:compare:verify_";
-
-    //真实性锁
-    public static final String REDIS_LOCK_REALNESS_VERIFY_PREFIX = "lock:realness:verify_";
-
-    //闭眼检测锁
-    public static final String REDIS_LOCK_EYE_CLOSE_VERIFY_PREFIX = "lock:eye_close:verify_";
-
     /**
      * redis过期时间
      */

themis-exam/src/main/java/com/qmth/themis/exam/api/TEExamController.java

@@ -74,7 +74,9 @@ public class TEExamController {
         }
         String shortCode = String.valueOf(mapParameter.get("shortCode"));
         QueryWrapper<TEExam> teExamQueryWrapper = new QueryWrapper<>();
-        teExamQueryWrapper.lambda().eq(TEExam::getShortCode, shortCode).eq(TEExam::getEnable, 1);
+        teExamQueryWrapper.lambda().eq(TEExam::getShortCode, shortCode)
+                .eq(TEExam::getEnable, 1)
+                .eq(TEExam::getArchived, 1);
         TEExam teExam = teExamService.getOne(teExamQueryWrapper);
         if (Objects.isNull(teExam)) {
             throw new BusinessException(ExceptionResultEnum.EXAM_NO);

themis-exam/src/main/java/com/qmth/themis/exam/api/TEFaceController.java

@@ -89,7 +89,7 @@ public class TEFaceController {
         transMap.put("exception", param.getException());
         //mq发送消息start
         MqDto mqDto = new MqDto(mqUtil.getMqGroupDomain().getTopic(), MqTagEnum.FACE_VERIFY_SAVE.name(), transMap, MqTagEnum.FACE_VERIFY_SAVE, param.getRecordId().toString(), param.getRecordId().toString());
-        mqDtoService.assembleSendOneOrderMsg(mqDto);
+        mqDtoService.assembleSendOneWayMsg(mqDto);
         return ResultUtil.ok(ret);
     }
 

themis-exam/src/main/java/com/qmth/themis/exam/api/TELivenessController.java

@@ -88,7 +88,7 @@ public class TELivenessController {
         // mq发送消息start
         MqDto mqDto = new MqDto(mqUtil.getMqGroupDomain().getTopic(), MqTagEnum.LIVENESS_VERIFY_SAVE.name(), transMap,
                 MqTagEnum.LIVENESS_VERIFY_SAVE, param.getRecordId().toString(), param.getRecordId().toString());
-        mqDtoService.assembleSendOneOrderMsg(mqDto);
+        mqDtoService.assembleSendOneWayMsg(mqDto);
         return ResultUtil.ok(ret);
     }
 

themis-mq/src/main/java/com/qmth/themis/mq/service/impl/MqLogicServiceImpl.java

@@ -118,9 +118,6 @@ public class MqLogicServiceImpl implements MqLogicService {
     @Resource
     MqUtil mqUtil;
 
-    @Resource
-    TGErrorService tgErrorService;
-
     /**
      * mq最大重试次数逻辑
      *
@@ -361,46 +358,23 @@ public class MqLogicServiceImpl implements MqLogicService {
             WarningDto warningDto = new WarningDto(warningEnum, faceCount, realness, recordId, photoUrl);
             if (Objects.equals(VerifyExceptionEnum.NONE, warningEnum)) {//无异常，往考生日志表里插一条
                 if (Objects.nonNull(realness) && realness.intValue() == 0) {//真实性异常
-                    boolean lock = false;
-                    for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                        lock = redisUtil.lock(SystemConstant.REDIS_LOCK_REALNESS_VERIFY_PREFIX + recordId,
-                                SystemConstant.REDIS_CACHE_TIME_OUT);
-                        if (lock) {
-                            try {
-                                String realnessErrorRandom = ExamRecordCacheUtil.getRealnessErrorRandom(recordId);
-                                if (Objects.isNull(realnessErrorRandom)) {
-                                    realnessErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                    ExamRecordCacheUtil.setRealnessErrorRandom(recordId, realnessErrorRandom);
-                                }
-                                ExamRecordCacheUtil
-                                        .setRealnessErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getRealnessErrorNum(recordId).incrementAndGet()));
-                                warningDto.setRandom(realnessErrorRandom);
-                                faceVerifyHistoryService
-                                        .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
-                                                realnessErrorRandom);
-                                Integer count = ExamRecordCacheUtil.getRealnessErrorNum(recordId).get();
-                                if (count > teConfig.getRealnessCount()) {
-                                    ExamRecordCacheUtil.setRealnessErrorRandom(recordId,
-                                            String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                    ExamRecordCacheUtil.setRealnessErrorNum(recordId, new AtomicInteger(0));
-                                    warningService.realnessError(warningDto);
-                                }
-                                break;
-                            } finally {
-                                if (Objects.nonNull(recordId)) {
-                                    redisUtil.releaseLock(SystemConstant.REDIS_LOCK_REALNESS_VERIFY_PREFIX + recordId);
-                                }
-                            }
-                        } else {
-                            try {
-                                Thread.sleep(500);
-                            } catch (InterruptedException e) {
-                                e.printStackTrace();
-                            }
-                        }
+                    String realnessErrorRandom = ExamRecordCacheUtil.getRealnessErrorRandom(recordId);
+                    if (Objects.isNull(realnessErrorRandom)) {
+                        realnessErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                        ExamRecordCacheUtil.setRealnessErrorRandom(recordId, realnessErrorRandom);
                     }
-                    if (!lock) {
-                        tgErrorService.saveExamTgError(recordId, "faceVerifyRealnessError");
+                    ExamRecordCacheUtil
+                            .setRealnessErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getRealnessErrorNum(recordId).incrementAndGet()));
+                    warningDto.setRandom(realnessErrorRandom);
+                    faceVerifyHistoryService
+                            .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
+                                    realnessErrorRandom);
+                    Integer count = ExamRecordCacheUtil.getRealnessErrorNum(recordId).get();
+                    if (count > teConfig.getRealnessCount()) {
+                        ExamRecordCacheUtil.setRealnessErrorRandom(recordId,
+                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                        ExamRecordCacheUtil.setRealnessErrorNum(recordId, new AtomicInteger(0));
+                        warningService.realnessError(warningDto);
                     }
                 } else {
                     faceVerifyHistoryService
@@ -409,173 +383,81 @@ public class MqLogicServiceImpl implements MqLogicService {
             } else {
                 if (Objects.equals(VerifyExceptionEnum.FACE_COUNT_ERROR, warningEnum)) {//人脸数量异常
                     if (faceCount > 1) {//多张人脸
-                        boolean lock = false;
-                        for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                            lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_MULTIPLE_VERIFY_PREFIX + recordId,
-                                    SystemConstant.REDIS_CACHE_TIME_OUT);
-                            if (lock) {
-                                try {
-                                    String multipleFaceRandom = ExamRecordCacheUtil.getMultipleFaceCountErrorRandom(recordId);
-                                    if (Objects.isNull(multipleFaceRandom)) {
-                                        multipleFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                        ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId, multipleFaceRandom);
-                                    }
-                                    ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId,
-                                            new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
-                                    warningDto.setRandom(multipleFaceRandom);
-                                    faceVerifyHistoryService
-                                            .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
-                                                    multipleFaceRandom);
-                                    Integer count = ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).get();
-                                    if (count > teConfig.getMultipleFaceCountError()) {
-                                        ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId,
-                                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                        ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId, new AtomicInteger(0));
-                                        warningService.faceCountError(warningDto);
-                                    }
-                                    break;
-                                } finally {
-                                    if (Objects.nonNull(recordId)) {
-                                        redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_MULTIPLE_VERIFY_PREFIX + recordId);
-                                    }
-                                }
-                            } else {
-                                try {
-                                    Thread.sleep(500);
-                                } catch (InterruptedException e) {
-                                    e.printStackTrace();
-                                }
-                            }
+                        String multipleFaceRandom = ExamRecordCacheUtil.getMultipleFaceCountErrorRandom(recordId);
+                        if (Objects.isNull(multipleFaceRandom)) {
+                            multipleFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                            ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId, multipleFaceRandom);
                         }
-                        if (!lock) {
-                            tgErrorService.saveExamTgError(recordId, "faceVerifyMultipleFaceCountError");
+                        ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId,
+                                new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
+                        warningDto.setRandom(multipleFaceRandom);
+                        faceVerifyHistoryService
+                                .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
+                                        multipleFaceRandom);
+                        Integer count = ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).get();
+                        if (count > teConfig.getMultipleFaceCountError()) {
+                            ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId,
+                                    String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                            ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId, new AtomicInteger(0));
+                            warningService.faceCountError(warningDto);
                         }
                     } else if (faceCount <= 0) {
-                        boolean lock = false;
-                        for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                            lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_VERIFY_PREFIX + recordId,
-                                    SystemConstant.REDIS_CACHE_TIME_OUT);
-                            if (lock) {
-                                try {
-                                    String noFaceRandom = ExamRecordCacheUtil.getNoFaceCountErrorRandom(recordId);
-                                    if (Objects.isNull(noFaceRandom)) {
-                                        noFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                        ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId, noFaceRandom);
-                                    }
-                                    ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId,
-                                            new AtomicInteger(ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).incrementAndGet()));
-                                    warningDto.setRandom(noFaceRandom);
-                                    faceVerifyHistoryService
-                                            .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
-                                                    noFaceRandom);
-                                    Integer count = ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).get();
-                                    if (count > teConfig.getNoFaceCountError()) {
-                                        ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId,
-                                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                        ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId, new AtomicInteger(0));
-                                        warningService.faceCountError(warningDto);
-                                    }
-                                    break;
-                                } finally {
-                                    if (Objects.nonNull(recordId)) {
-                                        redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_VERIFY_PREFIX + recordId);
-                                    }
-                                }
-                            } else {
-                                try {
-                                    Thread.sleep(500);
-                                } catch (InterruptedException e) {
-                                    e.printStackTrace();
-                                }
-                            }
+                        String noFaceRandom = ExamRecordCacheUtil.getNoFaceCountErrorRandom(recordId);
+                        if (Objects.isNull(noFaceRandom)) {
+                            noFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                            ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId, noFaceRandom);
                         }
-                        if (!lock) {
-                            tgErrorService.saveExamTgError(recordId, "faceVerifyFaceCountError");
+                        ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId,
+                                new AtomicInteger(ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).incrementAndGet()));
+                        warningDto.setRandom(noFaceRandom);
+                        faceVerifyHistoryService
+                                .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
+                                        noFaceRandom);
+                        Integer count = ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).get();
+                        if (count > teConfig.getNoFaceCountError()) {
+                            ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId,
+                                    String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                            ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId, new AtomicInteger(0));
+                            warningService.faceCountError(warningDto);
                         }
                     }
                 } else if (Objects.equals(VerifyExceptionEnum.FACE_COMPARE_ERROR, warningEnum)) {//人脸比对异常
-                    boolean lock = false;
-                    for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                        lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_COMPARE_VERIFY_PREFIX + recordId,
-                                SystemConstant.REDIS_CACHE_TIME_OUT);
-                        if (lock) {
-                            try {
-                                String faceCompareErrorRandom = ExamRecordCacheUtil.getFaceCompareErrorRandom(recordId);
-                                if (Objects.isNull(faceCompareErrorRandom)) {
-                                    faceCompareErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                    ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId, faceCompareErrorRandom);
-                                }
-                                ExamRecordCacheUtil
-                                        .setFaceCompareErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).incrementAndGet()));
-                                warningDto.setRandom(faceCompareErrorRandom);
-                                faceVerifyHistoryService
-                                        .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
-                                                faceCompareErrorRandom);
-                                Integer count = ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).get();
-                                if (count > teConfig.getTotalFaceCompareErrorCount()) {
-                                    ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId,
-                                            String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                    ExamRecordCacheUtil.setFaceCompareErrorNum(recordId, new AtomicInteger(0));
-                                    warningService.faceCompareError(warningDto);
-                                }
-                                break;
-                            } finally {
-                                if (Objects.nonNull(recordId)) {
-                                    redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_COMPARE_VERIFY_PREFIX + recordId);
-                                }
-                            }
-                        } else {
-                            try {
-                                Thread.sleep(500);
-                            } catch (InterruptedException e) {
-                                e.printStackTrace();
-                            }
-                        }
+                    String faceCompareErrorRandom = ExamRecordCacheUtil.getFaceCompareErrorRandom(recordId);
+                    if (Objects.isNull(faceCompareErrorRandom)) {
+                        faceCompareErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                        ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId, faceCompareErrorRandom);
                     }
-                    if (!lock) {
-                        tgErrorService.saveExamTgError(recordId, "faceVerifyFaceCompareError");
+                    ExamRecordCacheUtil
+                            .setFaceCompareErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).incrementAndGet()));
+                    warningDto.setRandom(faceCompareErrorRandom);
+                    faceVerifyHistoryService
+                            .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
+                                    faceCompareErrorRandom);
+                    Integer count = ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).get();
+                    if (count > teConfig.getTotalFaceCompareErrorCount()) {
+                        ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId,
+                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                        ExamRecordCacheUtil.setFaceCompareErrorNum(recordId, new AtomicInteger(0));
+                        warningService.faceCompareError(warningDto);
                     }
                 } else if (Objects.equals(VerifyExceptionEnum.EYE_CLOSE_ERROR, warningEnum)) {//闭眼检测异常
-                    boolean lock = false;
-                    for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                        lock = redisUtil.lock(SystemConstant.REDIS_LOCK_EYE_CLOSE_VERIFY_PREFIX + recordId,
-                                SystemConstant.REDIS_CACHE_TIME_OUT);
-                        if (lock) {
-                            try {
-                                String eyeCloseErrorRandom = ExamRecordCacheUtil.getEyeCloseErrorRandom(recordId);
-                                if (Objects.isNull(eyeCloseErrorRandom)) {
-                                    eyeCloseErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                    ExamRecordCacheUtil.setEyeCloseErrorRandom(recordId, eyeCloseErrorRandom);
-                                }
-                                ExamRecordCacheUtil
-                                        .setEyeCloseErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getEyeCloseErrorNum(recordId).incrementAndGet()));
-                                warningDto.setRandom(eyeCloseErrorRandom);
-                                faceVerifyHistoryService
-                                        .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
-                                                eyeCloseErrorRandom);
-                                Integer count = ExamRecordCacheUtil.getEyeCloseErrorNum(recordId).get();
-                                if (count > teConfig.getTotalEyeCloseErrorCount()) {
-                                    ExamRecordCacheUtil.setEyeCloseErrorRandom(recordId,
-                                            String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                    ExamRecordCacheUtil.setEyeCloseErrorNum(recordId, new AtomicInteger(0));
-                                    warningService.eyeCloseError(warningDto);
-                                }
-                                break;
-                            } finally {
-                                if (Objects.nonNull(recordId)) {
-                                    redisUtil.releaseLock(SystemConstant.REDIS_LOCK_EYE_CLOSE_VERIFY_PREFIX + recordId);
-                                }
-                            }
-                        } else {
-                            try {
-                                Thread.sleep(500);
-                            } catch (InterruptedException e) {
-                                e.printStackTrace();
-                            }
-                        }
+                    String eyeCloseErrorRandom = ExamRecordCacheUtil.getEyeCloseErrorRandom(recordId);
+                    if (Objects.isNull(eyeCloseErrorRandom)) {
+                        eyeCloseErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                        ExamRecordCacheUtil.setEyeCloseErrorRandom(recordId, eyeCloseErrorRandom);
                     }
-                    if (!lock) {
-                        tgErrorService.saveExamTgError(recordId, "faceVerifyEyeCloseError");
+                    ExamRecordCacheUtil
+                            .setEyeCloseErrorNum(recordId, new AtomicInteger(ExamRecordCacheUtil.getEyeCloseErrorNum(recordId).incrementAndGet()));
+                    warningDto.setRandom(eyeCloseErrorRandom);
+                    faceVerifyHistoryService
+                            .save(id, recordId, type, photoUrl, faceCount, similarity, realness, time, exception,
+                                    eyeCloseErrorRandom);
+                    Integer count = ExamRecordCacheUtil.getEyeCloseErrorNum(recordId).get();
+                    if (count > teConfig.getTotalEyeCloseErrorCount()) {
+                        ExamRecordCacheUtil.setEyeCloseErrorRandom(recordId,
+                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                        ExamRecordCacheUtil.setEyeCloseErrorNum(recordId, new AtomicInteger(0));
+                        warningService.eyeCloseError(warningDto);
                     }
                 }
             }
@@ -651,127 +533,64 @@ public class MqLogicServiceImpl implements MqLogicService {
                         WarningDto warningDto = new WarningDto(warningEnum, faceCount, null, recordId,
                                 String.valueOf(jsonObject.get("photoUrl")));
                         if (faceCount > 1) {//多张人脸
-                            boolean lock = false;
-                            for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                                lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_MULTIPLE_VERIFY_PREFIX + recordId,
-                                        SystemConstant.REDIS_CACHE_TIME_OUT);
-                                if (lock) {
-                                    try {
-                                        String multipleFaceRandom = ExamRecordCacheUtil.getMultipleFaceCountErrorRandom(recordId);
-                                        if (Objects.isNull(multipleFaceRandom)) {
-                                            multipleFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                            ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId, multipleFaceRandom);
-                                        }
-                                        ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId,
-                                                new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
-                                        warningDto.setRandom(multipleFaceRandom);
-                                        livenessVerifyHistoryService
-                                                .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
-                                                        multipleFaceRandom);
-                                        Integer count = ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).get();
-                                        if (count > teConfig.getMultipleFaceCountError()) {
-                                            ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId,
-                                                    String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                            ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId, new AtomicInteger(0));
-                                            warningService.faceCountError(warningDto);
-                                        }
-                                        break;
-                                    } finally {
-                                        if (Objects.nonNull(recordId)) {
-                                            redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_MULTIPLE_VERIFY_PREFIX + recordId);
-                                        }
-                                    }
-                                } else {
-                                    try {
-                                        Thread.sleep(500);
-                                    } catch (InterruptedException e) {
-                                        e.printStackTrace();
-                                    }
-                                }
+                            String multipleFaceRandom = ExamRecordCacheUtil.getMultipleFaceCountErrorRandom(recordId);
+                            if (Objects.isNull(multipleFaceRandom)) {
+                                multipleFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                                ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId, multipleFaceRandom);
                             }
-                            if (!lock) {
-                                tgErrorService.saveExamTgError(recordId, "livenessVerifyMultipleFaceCountError");
+                            ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId,
+                                    new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
+                            warningDto.setRandom(multipleFaceRandom);
+                            livenessVerifyHistoryService
+                                    .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
+                                            multipleFaceRandom);
+                            Integer count = ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).get();
+                            if (count > teConfig.getMultipleFaceCountError()) {
+                                ExamRecordCacheUtil.setMultipleFaceCountErrorRandom(recordId,
+                                        String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                                ExamRecordCacheUtil.setMultipleFaceCountErrorNum(recordId, new AtomicInteger(0));
+                                warningService.faceCountError(warningDto);
                             }
                         } else if (faceCount <= 0) {
-                            boolean lock = false;
-                            for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                                lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_VERIFY_PREFIX + recordId,
-                                        SystemConstant.REDIS_CACHE_TIME_OUT);
-                                if (lock) {
-                                    try {
-                                        String noFaceRandom = ExamRecordCacheUtil.getNoFaceCountErrorRandom(recordId);
-                                        if (Objects.isNull(noFaceRandom)) {
-                                            noFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                            ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId, noFaceRandom);
-                                        }
-                                        ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId,
-                                                new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
-                                        warningDto.setRandom(noFaceRandom);
-                                        livenessVerifyHistoryService
-                                                .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
-                                                        noFaceRandom);
-                                        Integer count = ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).get();
-                                        if (count > teConfig.getNoFaceCountError()) {
-                                            ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId,
-                                                    String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                            ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId, new AtomicInteger(0));
-                                            warningService.faceCountError(warningDto);
-                                        }
-                                        break;
-                                    } finally {
-                                        if (Objects.nonNull(recordId)) {
-                                            redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_VERIFY_PREFIX + recordId);
-                                        }
-                                    }
-                                } else {
-                                    try {
-                                        Thread.sleep(500);
-                                    } catch (InterruptedException e) {
-                                        e.printStackTrace();
-                                    }
-                                }
+                            String noFaceRandom = ExamRecordCacheUtil.getNoFaceCountErrorRandom(recordId);
+                            if (Objects.isNull(noFaceRandom)) {
+                                noFaceRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                                ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId, noFaceRandom);
                             }
-                            if (!lock) {
-                                tgErrorService.saveExamTgError(recordId, "livenessVerifyFaceCountError");
+                            ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId,
+                                    new AtomicInteger(ExamRecordCacheUtil.getMultipleFaceCountErrorNum(recordId).incrementAndGet()));
+                            warningDto.setRandom(noFaceRandom);
+                            livenessVerifyHistoryService
+                                    .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
+                                            noFaceRandom);
+                            Integer count = ExamRecordCacheUtil.getNoFaceCountErrorNum(recordId).get();
+                            if (count > teConfig.getNoFaceCountError()) {
+                                ExamRecordCacheUtil.setNoFaceCountErrorRandom(recordId,
+                                        String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                                ExamRecordCacheUtil.setNoFaceCountErrorNum(recordId, new AtomicInteger(0));
+                                warningService.faceCountError(warningDto);
                             }
                         }
                     } else if (Objects.equals(VerifyExceptionEnum.FACE_COMPARE_ERROR, warningEnum)) {//人脸比对异常
-                        boolean lock = false;
-                        for (int k = 0; k < SystemConstant.MAX_EXAM_STATUS_COUNT; k++) {
-                            lock = redisUtil.lock(SystemConstant.REDIS_LOCK_FACE_COMPARE_VERIFY_PREFIX + recordId,
-                                    SystemConstant.REDIS_CACHE_TIME_OUT);
-                            if (lock) {
-                                try {
-                                    WarningDto warningDto = new WarningDto(warningEnum, null, null, recordId,
-                                            String.valueOf(jsonObject.get("photoUrl")));
-                                    String faceCompareErrorRandom = ExamRecordCacheUtil.getFaceCompareErrorRandom(recordId);
-                                    if (Objects.isNull(faceCompareErrorRandom)) {
-                                        faceCompareErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
-                                        ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId, faceCompareErrorRandom);
-                                    }
-                                    ExamRecordCacheUtil.setFaceCompareErrorNum(recordId,
-                                            new AtomicInteger(ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).incrementAndGet()));
-                                    warningDto.setRandom(faceCompareErrorRandom);
-                                    livenessVerifyHistoryService
-                                            .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
-                                                    faceCompareErrorRandom);
-                                    Integer count = ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).get();
-                                    if (count > teConfig.getTotalFaceCompareErrorCount()) {
-                                        ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId,
-                                                String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
-                                        ExamRecordCacheUtil.setFaceCompareErrorNum(recordId, new AtomicInteger(0));
-                                        warningService.faceCompareError(warningDto);
-                                    }
-                                    break;
-                                } finally {
-                                    if (Objects.nonNull(recordId)) {
-                                        redisUtil.releaseLock(SystemConstant.REDIS_LOCK_FACE_COMPARE_VERIFY_PREFIX + recordId);
-                                    }
-                                }
-                            }
+                        WarningDto warningDto = new WarningDto(warningEnum, null, null, recordId,
+                                String.valueOf(jsonObject.get("photoUrl")));
+                        String faceCompareErrorRandom = ExamRecordCacheUtil.getFaceCompareErrorRandom(recordId);
+                        if (Objects.isNull(faceCompareErrorRandom)) {
+                            faceCompareErrorRandom = String.valueOf(UUID.randomUUID()).replaceAll("-", "");
+                            ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId, faceCompareErrorRandom);
                         }
-                        if (!lock) {
-                            tgErrorService.saveExamTgError(recordId, "livenessVerifyFaceCompareError");
+                        ExamRecordCacheUtil.setFaceCompareErrorNum(recordId,
+                                new AtomicInteger(ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).incrementAndGet()));
+                        warningDto.setRandom(faceCompareErrorRandom);
+                        livenessVerifyHistoryService
+                                .save(id, recordId, type, actions, retry, startTime, finishTime, exception,
+                                        faceCompareErrorRandom);
+                        Integer count = ExamRecordCacheUtil.getFaceCompareErrorNum(recordId).get();
+                        if (count > teConfig.getTotalFaceCompareErrorCount()) {
+                            ExamRecordCacheUtil.setFaceCompareErrorRandom(recordId,
+                                    String.valueOf(UUID.randomUUID()).replaceAll("-", ""));
+                            ExamRecordCacheUtil.setFaceCompareErrorNum(recordId, new AtomicInteger(0));
+                            warningService.faceCompareError(warningDto);
                         }
                     }
                 }