基于redis的分布式锁

什么是分布式锁

为了防止分布式系统中的多个进程之间相互干扰，我们需要一种分布式协调技术来对这些进程进行调度。而这个分布式协调技术的核心就是来实现这个分布式锁。

分布式锁应该具备哪些条件

• 在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行
• 高可用的获取锁与释放锁
• 高性能的获取锁与释放锁
• 具备可重入特性（可理解为重新进入，由多于一个任务并发使用，而不必担心数据错误）
• 具备锁失效机制，防止死锁
• 具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败

试验高并发场景

  @RestController
@RequestMapping("/order")
@AllArgsConstructor
public class OrderController {

    private static ReentrantLock lock = new ReentrantLock();

    private StringRedisTemplate redisTemplate;

    @GetMapping("/reduce_order")
    public String executor() {
        reduceOrder();
        return "end";
    }

    public void reduceOrder() {
        String productKey = "order";
        try {
                lock.lock();
            int order = Integer.parseInt(Objects.requireNonNull(redisTemplate.opsForValue().get(productKey)));
            if (order > 0) {
                int realorder = order - 1;
                redisTemplate.opsForValue().set(productKey, String.valueOf(realorder));
                System.out.println("订单数-1,剩余订单数量:" + realorder);
            } else {
                System.out.println("库存数不足，请及时补充订单");
            }
        } catch (Exception e) {
            System.out.println("订单扣除失败");
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

上述代码只是简单一个模拟扣除订单的方法,如果多个进程同时运行时候就会出现订单重复扣减的问题,redis中设置了订单数为50

使用jmeter测试

1.我们使用nginx

做转发项目8081和8082端口

• 启动项目8081和8082端口

  
  image
• 使用nginx 做转发8081和8082端口

redis配置

user  nginx;
worker_processes  1;

events {
  worker_connections  1024;
}

http {
  include       mime.types;
  default_type  application/octet-stream;

  sendfile        on;

  keepalive_timeout  65;

  upstream myapp1 {
     # 换成主机ip
      server 10.8.162.22:8081 weight=10;
      server 10.8.162.22:8082 weight=10;
  }

  server {
      listen 80;
      location / {
          proxy_pass http://myapp1;
          index index.jsp index.html index.htm;
      }
  }
}

2.下载jmeter

3.启动并配置jmeter

启动jmeter
添加线程组
添加Http请求用例
配置jmeter

4.运行jmeter,查看结果

执行 8081端口 8082端口

从结果中很明显看出进程1-8081 和进程2-8082明显重复扣除订单

分布式锁就是防止这种情况发生

redis分布式锁的原理

当一个线程执行 setnx 返回 1，说明 key 原本不存在，该线程成功得到了锁；当一个线程执行 setnx 返回 0，说明 key 已经存在，该线程抢锁失败。

1.redis核心要素

• 加锁 setnx

（1 成功获取锁 0 已有锁 加锁失败）

• 解锁

直接删除即可

• 锁超时

（expire设置超时时间）

2.分布锁问题

• 如何保证原子性

只设置key值还没在设置超时时间的时候挂了 （redis lua脚本[同时成功，同时失败])

• 误删锁

(给每个锁相应的id)

• 业务执行时间大于锁的超时间，业务没执行完,锁消失了（续命）

守护线程，锁快超时的时候重制超时时间while循环

代码如下

    public void reduceOrder() {
        String localKey = "product_001";
        String productKey = "order";
        String clientId = UUID.randomUUID().toString(); // 锁id
        try {
            lock.lock();
            //redis 加锁 setnx  设置超时时间
            Boolean result = redisTemplate.opsForValue().setIfAbsent(localKey, clientId, 10, TimeUnit.SECONDS);

            if (!result) { //true               System.out.println("正在抢货中.....");
                return;
            }

            int order = Integer.parseInt(Objects.requireNonNull(redisTemplate.opsForValue().get(productKey)));
            if (order > 0) {
                int realorder = order - 1;
                redisTemplate.opsForValue().set(productKey, String.valueOf(realorder));
                System.out.println("订单数-1,剩余订单数量:" + realorder);
            } else {
                System.out.println("库存数不足，请及时补充订单");
            }
        } catch (Exception e) {
            System.out.println("订单扣除失败");
            e.printStackTrace();
        } finally {
            //解锁 判断是否对应id 解决误删锁
            //在判断的时候可能挂了  应使用lua脚本保证原子行
            if (clientId.equals(redisTemplate.opsForValue().get(localKey))) {
                redisTemplate.delete(localKey);
            }
//            System.out.println("解锁成功");
            lock.unlock();
        }
    }

//    }
}

上述代码中没有体现到lua脚本和守护线程（还有可重入锁的问题）,后面会直接使用Redission

重新执行jmeter进行测试 测试结果

8081 8082

合计50个订单,没有重复扣除