生产级Redis 高并发分布式锁实战1:高并发分布式锁如何实现()

高并发场景:秒杀商品。

秒杀一般出现在商城的促销活动中,指定了一定数量(比如:1000个)的商品(比如:手机),以极低的价格(比如:0.1元),让大量用户参与活动,但只有极少数用户能够购买成功.

示例代码

@RestController
public class IndexController {
    
    @autowired
    private Redisson redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate
    
    @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));  // jedis.get("stock")
        
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");  // jedis.set(key,value)
            
            System.out.print("======商品扣减成功,剩余库存:"+ realStock);
            
        } else {
            System.out.print("======商品扣减失败======");
        }
        
        return "---=== end ===---";
    }
    
    
    
}

问题

问题

假设10个线程同时扣减1000个商品,应该剩余990 个商品,但实际扣减剩余999个,发生超卖问题。

  • 解决方案

加锁。synchronized(this)

jdk 内置锁在分布式环境下并不能保证成功。

模拟高并发场景,部署测试环境。

可用jMeter 工具进行压力测试。

添加ThreadGroup,并在栏目下添加 Http Request。配置并发计划。
可选择添加Aggregate Report 报告。

完整代码:


 @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        synchronized(this){
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        
            if(stock > 0){
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock",realStock + "");
                
                System.out.print("======商品扣减成功,剩余库存:"+ realStock);
                
            } else {
                System.out.print("======商品扣减失败======");
            }
            
        }
        return "---=== end ===---";
    }

启动多台服务器,测试日志结果可知,发生超卖问题。

添加分布式锁

redis 命令setnx key value

setnx 是“set if not exists” 的缩写。

含义是:

含义是:

  • 将key 的值设为value, 当且仅当key 不存在。
  • 若给定的key 已经存在,则setnx 不做任何操作。

注:加锁完成后,要删除锁。

完整代码:

    String lockKey = "lock:product_100";
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock,"amumu")

    if (!result){
        return "---=== error_code ---===";
    }
    
    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));

    if(stock > 0){
        int realStock = stock - 1;
        stringRedisTemplate.opsForValue().set("stock",realStock + "");
        
        System.out.print("======商品扣减成功,剩余库存:"+ realStock);
        
    } else {
        System.out.print("======商品扣减失败======");
    }
    
    stringRedisTemplate.delete(lockkey);
    return "---=== end ===---";

分布式锁下的原子性问题优化

发现问题

  • 在set过程中程序异常,则程序无法继续执行,造成死锁。
//获取异常并抛异常
try{
    
} finally{
    
}
  • 在set 过程中,系统宕机,或系统重启。
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,"ammumu");


//添加过期时间
stringRedisTemplate.expire(lockkey,10,TimeUnit.SECONDS);

上述代码执行过程中,程序异常情况下也会导致系统宕机,发生原子性问题,

Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,"amumu",10, TimeUnit.SECONDS);

分布式锁的失效情况优化

  • 假设 10s 的过期时间。

假设多个请求,每个程序执行超过10s, 此时锁已过期。此时程序执行删除锁,导致此时锁失效。

分析问题:加锁过程,被其他线程执行删锁。

解决方案:加上锁标识,删除时判断是否是同一标识。

String clientId = UUID.randomUUID().toString();
// 加上cliendId 锁标识
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,clientId, 10, TimeUnits.SECONDS);



//删除锁时,进行判断
if(clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
    stringRedisTemplate.delete(lockkey);
}

  • 假设执行删除锁前,锁快过期未过期。下一个并发线程执行加锁操作,此时上一个并发线程,执行了删除操作。锁依然会失效。

解决方案:锁续命。如redisson

参考:github.com/redisson/redisson

每隔10s 检查是否还持有锁,如果持有,则延长30s锁的时间

参考:redis lua 脚本

RLock redissonLock = redisson.getLock(lock); // 获取锁对象
redissonLock.lock(); // 加锁 相当于 setIfAbsent(lockkey,"amumu",10, TimeUnit.SECONDS);


redissonLock.unlock();

完整代码:

    @autowired
    private Redisson redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate
    
    @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        String lockKey = "lock:product_101";
        
        RLock redissonLock = redisson.getLock(lockKey);
        redissonLock.lock(); // 加锁
        
        try{
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        
            if(stock > 0){
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock",realStock + "");
                
                System.out.print("======商品扣减成功,剩余库存:"+ realStock);
                
            } else {
                System.out.print("======商品扣减失败======");
            }
        }finally{
            redissonLock.unlock();
        }
        
        
        return "---=== end ===---";
    }

锁续命业务优化

  • 问题1 :线程1 加锁,此时未同步给从结点,主结点挂了。此时从结点很可能会被选为主结点。这时一个线程3,同时请求此操作,此时线程3 操作新选为主结点redis 加锁,此时程序继续执行,执行有并发安全问题的代码。
  • 问题2 :redis 语义上,是把高并发场景下的问题串行化了,这当然不会有并发问题,但是对整个系统的性能有影响。当然redis 的性能已经是非常不错了。
  • 问题3:redissonLock.unLock() 底层默认的是非公平的抢锁机制,while 循环尝试去加锁。

redis 与 zookeeper 分布式集群方案对比

根据CAP 理论:
redis 集群更多是保证AP, 即可用性。

zookeeper 集群更多是保证CP, 即一致性,ZAB写数据机制保证,不会有锁丢失的问题。

redlock 实解决redis 集群环境锁丢失问题

redlock 实解决redis 集群环境锁丢失问题

想用redis 的高性能,但是又不想丢失锁,有很多方法。

比如 Redlock 实现。

java client 加锁三个以上的锁,超过半数redis 节点加锁成功才算加锁成功。

  • 问题:千万不要用从节点。要保证集群高可用,多加几个节点。
  • 问题:持久化。一般用aof 做持久化,假设设置1s 持久化一次。
    这样就设置一个key,设置2个key 时系统宕机或重启。client2 执行请求,key3 加锁成功,key2 重启后加锁成功,则加锁成功。系统继续执行的是并发安全问题的代码。如果用时时持久化设置,则性能会大大降低,还不如用zookeeper.

高并发分布式锁如何实现

分段加锁逻辑。

未完待续
by: 一只阿木木

————————

高并发场景:秒杀商品。

秒杀一般出现在商城的促销活动中,指定了一定数量(比如:1000个)的商品(比如:手机),以极低的价格(比如:0.1元),让大量用户参与活动,但只有极少数用户能够购买成功.

示例代码

@RestController
public class IndexController {
    
    @autowired
    private Redisson redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate
    
    @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));  // jedis.get("stock")
        
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");  // jedis.set(key,value)
            
            System.out.print("======商品扣减成功,剩余库存:"+ realStock);
            
        } else {
            System.out.print("======商品扣减失败======");
        }
        
        return "---=== end ===---";
    }
    
    
    
}

问题

问题

假设10个线程同时扣减1000个商品,应该剩余990 个商品,但实际扣减剩余999个,发生超卖问题。

  • 解决方案

加锁。synchronized(this)

jdk 内置锁在分布式环境下并不能保证成功。

模拟高并发场景,部署测试环境。

可用jMeter 工具进行压力测试。

添加ThreadGroup,并在栏目下添加 Http Request。配置并发计划。
可选择添加Aggregate Report 报告。

完整代码:


 @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        synchronized(this){
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        
            if(stock > 0){
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock",realStock + "");
                
                System.out.print("======商品扣减成功,剩余库存:"+ realStock);
                
            } else {
                System.out.print("======商品扣减失败======");
            }
            
        }
        return "---=== end ===---";
    }

启动多台服务器,测试日志结果可知,发生超卖问题。

添加分布式锁

redis 命令setnx key value

setnx 是“set if not exists” 的缩写。

含义是:

含义是:

  • 将key 的值设为value, 当且仅当key 不存在。
  • 若给定的key 已经存在,则setnx 不做任何操作。

注:加锁完成后,要删除锁。

完整代码:

    String lockKey = "lock:product_100";
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock,"amumu")

    if (!result){
        return "---=== error_code ---===";
    }
    
    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));

    if(stock > 0){
        int realStock = stock - 1;
        stringRedisTemplate.opsForValue().set("stock",realStock + "");
        
        System.out.print("======商品扣减成功,剩余库存:"+ realStock);
        
    } else {
        System.out.print("======商品扣减失败======");
    }
    
    stringRedisTemplate.delete(lockkey);
    return "---=== end ===---";

分布式锁下的原子性问题优化

发现问题

  • 在set过程中程序异常,则程序无法继续执行,造成死锁。
//获取异常并抛异常
try{
    
} finally{
    
}
  • 在set 过程中,系统宕机,或系统重启。
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,"ammumu");


//添加过期时间
stringRedisTemplate.expire(lockkey,10,TimeUnit.SECONDS);

上述代码执行过程中,程序异常情况下也会导致系统宕机,发生原子性问题,

Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,"amumu",10, TimeUnit.SECONDS);

分布式锁的失效情况优化

  • 假设 10s 的过期时间。

假设多个请求,每个程序执行超过10s, 此时锁已过期。此时程序执行删除锁,导致此时锁失效。

分析问题:加锁过程,被其他线程执行删锁。

解决方案:加上锁标识,删除时判断是否是同一标识。

String clientId = UUID.randomUUID().toString();
// 加上cliendId 锁标识
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockkey,clientId, 10, TimeUnits.SECONDS);



//删除锁时,进行判断
if(clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
    stringRedisTemplate.delete(lockkey);
}

  • 假设执行删除锁前,锁快过期未过期。下一个并发线程执行加锁操作,此时上一个并发线程,执行了删除操作。锁依然会失效。

解决方案:锁续命。如redisson

参考:github.com/redisson/redisson

每隔10s 检查是否还持有锁,如果持有,则延长30s锁的时间

参考:redis lua 脚本

RLock redissonLock = redisson.getLock(lock); // 获取锁对象
redissonLock.lock(); // 加锁 相当于 setIfAbsent(lockkey,"amumu",10, TimeUnit.SECONDS);


redissonLock.unlock();

完整代码:

    @autowired
    private Redisson redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate
    
    @RequestMapper("/stock/deduct_stock")
    public String deductStock(){
        
        String lockKey = "lock:product_101";
        
        RLock redissonLock = redisson.getLock(lockKey);
        redissonLock.lock(); // 加锁
        
        try{
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        
            if(stock > 0){
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock",realStock + "");
                
                System.out.print("======商品扣减成功,剩余库存:"+ realStock);
                
            } else {
                System.out.print("======商品扣减失败======");
            }
        }finally{
            redissonLock.unlock();
        }
        
        
        return "---=== end ===---";
    }

锁续命业务优化

  • 问题1 :线程1 加锁,此时未同步给从结点,主结点挂了。此时从结点很可能会被选为主结点。这时一个线程3,同时请求此操作,此时线程3 操作新选为主结点redis 加锁,此时程序继续执行,执行有并发安全问题的代码。
  • 问题2 :redis 语义上,是把高并发场景下的问题串行化了,这当然不会有并发问题,但是对整个系统的性能有影响。当然redis 的性能已经是非常不错了。
  • 问题3:redissonLock.unLock() 底层默认的是非公平的抢锁机制,while 循环尝试去加锁。

redis 与 zookeeper 分布式集群方案对比

根据CAP 理论:
redis 集群更多是保证AP, 即可用性。

zookeeper 集群更多是保证CP, 即一致性,ZAB写数据机制保证,不会有锁丢失的问题。

redlock 实解决redis 集群环境锁丢失问题

redlock 实解决redis 集群环境锁丢失问题

想用redis 的高性能,但是又不想丢失锁,有很多方法。

比如 Redlock 实现。

java client 加锁三个以上的锁,超过半数redis 节点加锁成功才算加锁成功。

  • 问题:千万不要用从节点。要保证集群高可用,多加几个节点。
  • 问题:持久化。一般用aof 做持久化,假设设置1s 持久化一次。
    这样就设置一个key,设置2个key 时系统宕机或重启。client2 执行请求,key3 加锁成功,key2 重启后加锁成功,则加锁成功。系统继续执行的是并发安全问题的代码。如果用时时持久化设置,则性能会大大降低,还不如用zookeeper.

高并发分布式锁如何实现

分段加锁逻辑。

未完待续
by: 一只阿木木