Redis实现简单版本分布式锁

最新推荐文章于 2025-06-26 22:23:49 发布

原创最新推荐文章于 2025-06-26 22:23:49 发布 · 3.2k 阅读

1 ·

CC 4.0 BY-SA版权

架构设计同时被 2 个专栏收录

27 篇文章

订阅专栏

Nosql

9 篇文章

订阅专栏

本文介绍了一种基于Redis的分布式锁的实现方式，包括自定义RedisLock类及其使用方法，并通过测试代码验证了单线程及多线程下锁的有效性。

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

原理：

执行时获得指定名称key是否存在，如果存在不能获得key，如果不存在为该key赋值，然后设置失效时间；

解锁的逻辑即删除该key。

1.自定义类

package com.xxx.cloud.assets.redis.lock;

import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

/**
 * 每次使用时，要new一个新的lock使用
 */

public class RedisLock {
    // 锁名称
    private String lockName; 

    // 锁超时时间
    private long time;

    private static final String KEY_PREFIX = "BusinessName:lock:";

    private long randomValue;

    private DefaultRedisScript redisScript;

    private RedisTemplate redisTemplate;

    private boolean locked;

    private RedisLock(String lockName, long time, RedisTemplate redisTemplate, DefaultRedisScript redisScript) {
        this.lockName = KEY_PREFIX + lockName;
        this.time = time;
        this.redisTemplate = redisTemplate;
        this.redisScript = redisScript;
        this.randomValue = UUID.randomUUID().getLeastSignificantBits();
    }

    public static RedisLock NewRedisLock(String lockName, long time, RedisTemplate redisTemplate,
            DefaultRedisScript redisScript) {
        return new RedisLock(lockName, time, redisTemplate, redisScript);
    }

    public boolean tryLock() {
        boolean success = redisTemplate.opsForValue().setIfAbsent(lockName, randomValue);
        // setIfAbsent对应redis的setNX方法
        
        locked = success;
        if (success) {
            redisTemplate.expire(lockName, time, TimeUnit.SECONDS);
        }
        return success;
    }

    public void unLock() {
        if(locked){
            redisTemplate.execute(redisScript, Collections.singletonList(lockName), randomValue);
        }

    }

}

2.测试代码

package com.xxx.cloud.assets.service;

import com.xxx.cloud.assets.redis.lock.RedisLock;
import com.xxx.cloud.assets.test.TestBase;
import org.junit.Test;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import javax.annotation.Resource;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TestRedisLock extends TestBase {

    @Resource(name = "redisTemplate")
    private RedisTemplate redisTemplate;

    @Resource(name = "dellockScript")
    private DefaultRedisScript dellockScript;

    @Test
    public void testRedisLock() throws InterruptedException {
        RedisLock lock = RedisLock.NewRedisLock("test",1000,redisTemplate,dellockScript);
        try {
            boolean success = lock.tryLock();
            System.out.println(success);
        }finally {
            lock.unLock();
        }
    }

    @Test
    public void testMulRedisLock() throws InterruptedException {
        final RedisLock lock1 = RedisLock.NewRedisLock("test",1000,redisTemplate,dellockScript);
        final RedisLock lock2 = RedisLock.NewRedisLock("test",1000,redisTemplate,dellockScript);
        Runnable task1 = new Runnable() {
            @Override public void run() {
                try {
                    boolean success = lock1.tryLock();
                    System.out.println("task1" + success);
                    TimeUnit.SECONDS.sleep(10);
                }catch (Exception e){
                    e.printStackTrace();
                }
                finally {
                    lock1.unLock();
                }
            }
        };

        Runnable task2 = new Runnable() {
            @Override public void run() {
                try {
                    boolean success = lock2.tryLock();
                    System.out.println("task2"+success);
                    TimeUnit.SECONDS.sleep(10);
                }catch (Exception e){
                    e.printStackTrace();
                }
                finally {
                    lock2.unLock();
                }
            }
        };

        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(task1);
        executorService.submit(task2);
        TimeUnit.SECONDS.sleep(15);
    }
}

3.spring中部分配置

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
		<property name="defaultSerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
</bean>

<bean id="dellockScript" class="org.springframework.data.redis.core.script.DefaultRedisScript">
		<property name="location" value="classpath:database/dellock.lua" />
		<property name="resultType" value="java.lang.Boolean" />
</bean>

4.dellock.lua脚本(也可用代码逻辑替代)

if redis.call("get",KEYS[1]) == ARGV[1] then
	return redis.call("del",KEYS[1])
else
	return 0
end