学习笔记-分布式锁

1.解决超卖

boolean success = seckillVoucherService.update()
                .setSql("stock=stock-1")
                .eq("voucher_id", voucherId).gt("stock", 0)
                .update();
if (!success) {
            return Result.fail("库存不足");
        }

2.一人一单

Integer count = query().eq("user_id", id).eq("voucher_id", voucherId).count();
        if (count > 0) {
            return Result.fail("每人限购一张");
        }

加锁：解决多个线程并发查询均查询到count=0的情况

Long userId = UserHolder.getuser.getId();
synchironized(userId.toString.intern()){
   //创建代理对象，因为事务只能在代理对象上生效，而不能在当前对象this.createOrder()上生效，所以需要创建代理对象,这个代理对象是IVoucherOrderService的
            //需要添加aspectjweaver依赖，需要暴露代理对象（HmDianPingApplication中添加@EnableAspectJAutoProxy(exposeProxy = true)）
            IVoucherOrderService proxy = (IVoucherOrderService)AopContext.currentProxy();//由sping提供的AopContext.currentProxy()方法获取代理对象
            return proxy.createOrder(voucherId);
}

3.集群下的线程并发安全性问题

一个jvm的监视器只能负责当前jvm中的线程，多集群下会造成数个线程同时进入的情况，因此我们不能使用jvm内部的监视器，需要使用一个多个jvm都可使用的单个锁监视器

可采用的方法有

3.1 Redis的分布式锁

即利用Redis的 setnx的互斥特性
示例：SET lock thread1 EX 10 NX
解释：EX 10 (过期时间10s)， NX（锁不存在时可以执行set，存在则不执行）

为此需要实现两个函数：tryLock和unlock

    public boolean tryLock(long timeoutSec){
        //获取线程标识  UNDO，这里还会出现锁的一些问题，后续会提到
        String threadId = Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue().
                setIfAbsent(LOCK_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        //这里的Boolean.TRUE.equals(success)是为了防止success为null的情况,因为Boolean是包装类，返回boolean类型的时候会自动拆箱，如果success为null，会报空指针异常
        return Boolean.TRUE.equals(success);
    }

    public void unlock(){
        stringRedisTemplate.delete(LOCK_PREFIX + name);
    }

两个方法放到自己定义的类中

public class SimpleRedisLock {
    //锁的名称。不能写死，由调用者提供
    private String name;
    private StringRedisTemplate stringRedisTemplate;
    private static final String LOCK_PREFIX = "lock:";
    
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public boolean tryLock(long timeoutSec){
    }
    public void unlock(){
    }
}

有了这个就可以不使用前面synchironized（）了，如下

Long userId = UserHolder.getUser().getId();
        //创建锁对象
        SimpleRedisLock redisLock = new SimpleRedisLock("seckill:" + userId, stringRedisTemplate);
        //获取锁
        boolean isLock = redisLock.tryLock(1200);
        //判断是否获取锁成功
        if (!isLock) {
            return Result.fail("已达购买上限");
        }
        try {
            IVoucherOrderService proxy = (IVoucherOrderService)AopContext.currentProxy();//由sping提供的AopContext.currentProxy()方法获取代理对象
            return proxy.createOrder(voucherId);
        } finally {
            //释放锁
            redisLock.unlock();
        }

3.2 Redis分布式锁的误删问题

解释：线程A还没走到redisLock.unlock()解锁这一步时，因超时，锁自动释放了。但问题是锁被自动释放后会有其他线程B进行了tryLock()。结果就是A继续走到redisLock.unlock()时其实是unlock了线程B的锁
解决方法，在unlock时进行锁的校对，只允许自己释放自己加的锁
在定义的类中加上

private static final String ID_PREFIX = UUID.randomUUID().toString(true)+ "-";

并把它作为线程标识的前缀

public boolean tryLock(long timeoutSec){
        //获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue().
                setIfAbsent(LOCK_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        //这里的Boolean.TRUE.equals(success)是为了防止success为null的情况,因为Boolean是包装类，返回boolean类型的时候会自动拆箱，如果success为null，会报空指针异常
        return Boolean.TRUE.equals(success);
    }

并在unlock中加入校验

    public void unlock(){
        //获取线程表示
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁中表示
        String id = stringRedisTemplate.opsForValue().get(LOCK_PREFIX + name);
        //判断是否是当前线程持有锁
        if (threadId.equals(id)){
            //释放锁
            stringRedisTemplate.delete(LOCK_PREFIX + name);
        }
        //释放锁
        stringRedisTemplate.delete(LOCK_PREFIX + name);
    }

流程图

3.3 分布式锁的原子性问题

如下所示

public void unlock(){
        //获取线程表示
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁中表示
        String id = stringRedisTemplate.opsForValue().get(LOCK_PREFIX + name);
        //判断是否是当前线程持有锁
        if (threadId.equals(id)){
            //释放锁
            /*
            判断是自己锁后，出现阻塞，没能及时释放
            一段时间后
            锁超时释放
            其他线程获取了锁
            */
            stringRedisTemplate.delete(LOCK_PREFIX + name);//释放了其他线程的锁
        }
        //释放锁
        stringRedisTemplate.delete(LOCK_PREFIX + name);
    }

出现该问题的原因是判断和释放没有原子性
解决：Redis提供了Lua脚本功能，在一个脚本中编写了多条Redis命令，确保多条命令执行时的原子性。
Redis提供的其调用函数

例如，执行set name davi，再执行get name，其脚本如下：

redsi.call('set','name','davi')
local name = redis.call('get','name')
return name

于是unlock逻辑用lua脚本写就如下，KEYS[1]和ARGV[1]相当于参数，上面的’name’,'davi’是写死的参数

-- 比较线程标识与锁中的标识是否一致
if(redis.call('get',KEYS[1]) == ARGV[1]) then
    -- 释放锁
    return redis.call('del',KEYS[1])
end
return 0

上述脚本保存为unlock.lua文件，放入resource中
stringRedisTemplate.execute（）的参数为
RedisScript script, Listkeys, Object…args
意为：脚本，key列表，脚本中的参数ARGV[1]

    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    //静态代码块中对其初始化
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setResultType(Long.class);
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    }
    public boolean tryLock(long timeoutSec){.....}
 
    public void unlock(){
        //调用lua脚本
        stringRedisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(LOCK_PREFIX + name),ID_PREFIX + Thread.currentThread().getId());
    }

4. 我们解决锁问题定义的类的最终版本为

public class SimpleRedisLock {
    //锁的名称。不能写死，由调用者提供
    private String name;
    private StringRedisTemplate stringRedisTemplate;

    private static final String LOCK_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true)+ "-";
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    //静态代码块中对其初始化
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setResultType(Long.class);
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    }

    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(LOCK_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        //这里的Boolean.TRUE.equals(success)是为了防止success为null的情况,因为Boolean是包装类，返回boolean类型的时候会自动拆箱，如果success为null，会报空指针异常
        return Boolean.TRUE.equals(success);
    }
    public void unlock(){
        //调用lua脚本
        stringRedisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(LOCK_PREFIX + name),ID_PREFIX + Thread.currentThread().getId());
    }
}