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:2379"},
        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.commit()
    if err != nil {
        fmt.println(err)
        return
    }
 
    // 判断是否抢到了锁
    if !txnresp.succeeded {
        fmt.println("锁被占用了：", string(txnresp.responses[0].getresponserange().kvs[0].value))
        return
    }
 
    // 2. 处理业务（锁内，很安全）
 
    fmt.println("处理任务")
    time.sleep(5 * time.second)
 
    // 3. 释放锁（取消自动续租，释放租约）
    // defer会取消续租，释放锁
}