Redis分布式锁及4种常见实现方法

CREATE TABLE `method_lock` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `method_name` varchar(64) NOT NULL COMMENT '锁定的法子名',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uidx_method_name` (`method_name`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='锁定外的办法';

INSERT INTO method_lock (method_name) VALUES ('methodName');

delete from method_lock where method_name ='methodName';

setnx [key] [value] 
expire [key] 30

# 铺排某个 key 的值并安排几许毫秒或者秒 逾期
set <key> <value> PX <几何毫秒> NX
或者
set <key> <value> EX <几许秒> NX
# 配置一个键为lock，值为thread，ex透露表现以秒为单元，px以微秒为单元，nx默示没有具有该key的时辰才气铺排
set lock thread1 nx ex 10

	public boolean tryLock(long timeoutSec) {
        // 猎取线程标识,ID_PREFIX为
        String threadId = ID_PREFIX +  Thread.currentThread().getId();
        // 猎取锁,name为自界说的营业名称
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

# 将对于应的键增除了便可
del [key]

	public void unlock() {
        // 猎取线程标识
        String threadId = ID_PREFIX +  Thread.currentThread().getId();
        // 猎取锁外的标识
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 判定标识能否一致
        if (threadId.equals(id)) {
            // 开释锁
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }

redis.call('号令名称','key','其他参数',...)

redis.call('set','name','jack')

# script剧本语句；numkeys剧本必要的key范例的参数个数
eval script numkeys key [key ...] arg [arg ...]

eval "return redis.call('set', 'name', 'Jack')" 0

eval "return redis.call('set', KEYS[1], ARGV[1])" 1 name Jack

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

import cn.hutool.core.lang.UUID;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

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

public class SimpleRedisLock {
    private String name;
    private StringRedisTemplate stringRedisTemplate;
    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
    // 添载剧本
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        // 添载工程resourcecs高的unlock.lua文件
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }
    
    public boolean tryLock(long timeoutSec) {
        // 猎取线程标识
        String threadId = ID_PREFIX +  Thread.currentThread().getId();
        // 猎取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    public void unlock() {
        // 挪用Lua剧本
        stringRedisTemplate.execute(UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX +  Thread.currentThread().getId());
    }
}

	/**
	* 营业service导进
	*/
	@Resource
    private RedissonClient redissonClient;

	/** 
	* 营业法子内
	*/
	SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
	// 建立锁东西
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    // 测验考试猎取锁
    boolean isLock = lock.tryLock();
    // 鉴定能否顺利
    if (!isLock) {
    	// 猎取失落败
        return Result.fail("没有容许频频高双");
    }
	try {
    	// 需求锁执止的营业代码部份
    } finally {
        // 开释锁
        lock.unlock();
    }

func main() {
    config := clientv3.Config{
        Endpoints:   []string{"xxx.xxx.xxx.xxx:两379"},
        DialTimeout: 5 * time.Second,
    }
 
    // 猎取客户端联接
    client, err := clientv3.New(config)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 1. 上锁（建立租约，自觉续租，拿着租约往抢占一个key ）
    // 用于申请租约
    lease := clientv3.NewLease(client)
 
    // 申请一个10s的租约
    leaseGrantResp, err := lease.Grant(context.TODO(), 10) //10s
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 拿到租约的id
    leaseID := leaseGrantResp.ID
 
    // 筹备一个用于消除续租的context
    ctx, cancelFunc := context.WithCancel(context.TODO())
 
    // 确保函数退没后，主动续租会结束
    defer cancelFunc()
        // 确保函数退没后，租约会掉效
    defer lease.Revoke(context.TODO(), leaseID)
 
    // 自觉续租
    keepRespChan, err := lease.KeepAlive(ctx, leaseID)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 措置续租应对的协程
    go func() {
        select {
        case keepResp := <-keepRespChan:
            if keepRespChan == nil {
                fmt.Println("lease has expired")
                goto END
            } else {
                // 每一秒会续租一次
                fmt.Println("支到自发续租应对", keepResp.ID)
            }
        }
    END:
    }()
 
    // if key 没有具有，then摆设它，else抢锁掉败
    kv := clientv3.NewKV(client)
    // 建立事务
    txn := kv.Txn(context.TODO())
    // 若何key没有具有
    txn.If(clientv3.Compare(clientv3.CreateRevision("/cron/lock/job7"), "=", 0)).
        Then(clientv3.OpPut("/cron/jobs/job7", "", clientv3.WithLease(leaseID))).
        Else(clientv3.OpGet("/cron/jobs/job7")) //如何key具有
 
    // 提交事务
    txnResp, err := txn.Co妹妹it()
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 断定能否抢到了锁
    if !txnResp.Succeeded {
        fmt.Println("锁被占用了：", string(txnResp.Responses[0].GetResponseRange().Kvs[0].Value))
        return
    }
 
    // 两. 措置营业（锁内，很保险）
 
    fmt.Println("处置工作")
    time.Sleep(5 * time.Second)
 
    // 3. 开释锁（撤销自觉续租，开释租约）
    // defer会撤销续租，开释锁
}