Redisson distributed lock integrated with @Scheduled doesn‘t guarantee a single job execution

最新推荐文章于 2024-04-10 18:49:02 发布

w1047667241

最新推荐文章于 2024-04-10 18:49:02 发布

阅读量207

点赞数

分类专栏： spring java 文章标签： java spring boot 开发语言

本文链接：https://blog.csdn.net/w1047667241/article/details/123074917

版权

java 同时被 2 个专栏收录

20 篇文章

订阅专栏

spring

12 篇文章

订阅专栏

本文探讨了如何在使用Redisson分布式锁配合Spring @Scheduled时确保单个任务的唯一执行。通过示例和建议，讨论了强制等待锁超时的重要性，并寻求其他解决方案以提高并发控制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Redisson distributed lock integrated with @Scheduled doesn’t guarantee a single scheduled job execution at the same time

Here is a example below:
Thread.sleep(10000); // 如果不加改行代码，则该方法执行时间很短，比如 1ms ，那么其他线程也是有机会重复执行的 。
因此，要想保证只有1个scheduled task 被执行，必须保证在其他线程获取锁失败，比如超时失败，或者其他的条件失败。
故：可以强制在方法末尾必须加上 Thread.sleep(10000);，保证锁超时。
小伙伴们还有其他方法吗？

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = CameraApplication.class)
@Slf4j
public class RedissonTests {
    @Resource
    RedissonClient redissonClient;
    @Resource
    ExecutorService executorService;

    @Test
    public void testLock() {
        try {
            //Simulating cluster timer tasks with multiple threads
            for (int i = 1; i <= 5; i++) {
                int id = i;
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        RLock rLock = redissonClient.getLock("testLock");
                        try {
                            log.info(id + " Request Lock");
                            //Attempt to lock, wait up to 5 seconds, unlock automatically 10 seconds after lock
                            boolean lockRes = rLock.tryLock(5, 10, TimeUnit.SECONDS);
                            if (lockRes) {
                                try {
                                    log.info(id + " Application Successful,Processing business logic");
                                    Thread.sleep(10000); // 必须强制等待保证锁超时 ，那么 其他线程也就没机会重复执行了
                                } finally {
                                    //Is it locked and whether the current thread has acquired a lock
                                    if (rLock.isLocked() && rLock.isHeldByCurrentThread()) {
                                        rLock.unlock();
                                        log.info(id + " Release lock");
                                    }
                                }
                            } else {
                                log.info(id + " Failed to apply for lock=" + lockRes);
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
            Thread.sleep(500000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}