设计一个支持高并发的分布式锁，商品维度

        try {
            Boolean product = redisTemplate.opsForValue().setIfAbsent("product-test001", "1", 11, TimeUnit.SECONDS);
            if (null == product) {
                // 自旋
                while (true) {
                    System.out.println("自旋开始" + Thread.currentThread().getName());
                    Thread.sleep(4000L);
                    // 加锁成功
                    if (null != redisTemplate.opsForValue().setIfAbsent("product-test001", "1", 11, TimeUnit.SECONDS)) {
                        // 扣减库存
                        System.out.println("自旋扣减库存开始" + Thread.currentThread().getName());
                        Thread.sleep(10000L);
                        System.out.println("自旋扣减库存成功" + Thread.currentThread().getName());
                        break;
                    }
                }
            }
            // 扣减库存 模拟扣减库存
            Thread.sleep(10000L);
        } finally {
            // 防止异常情况 必须释放锁
            redisTemplate.delete("product-test001");
        }


自旋开始http-nio-8081-exec-1
自旋开始http-nio-8081-exec-4
自旋开始http-nio-8081-exec-1
自旋开始http-nio-8081-exec-4
自旋开始http-nio-8081-exec-1
自旋扣减库存开始http-nio-8081-exec-4
自旋开始http-nio-8081-exec-1
自旋开始http-nio-8081-exec-1
自旋扣减库存成功http-nio-8081-exec-4
自旋开始http-nio-8081-exec-1
自旋扣减库存开始http-nio-8081-exec-1
自旋扣减库存成功http-nio-8081-exec-1

看上去好像没有什么问题 

场景1.在整个代码块中发生异常了，就比如第一个setNx的时候超时了，可能有很多原因比如大的bigkey、比如很多很多的请求突然打到web，那么这个时候就会发生直接去finally ，释放了锁。那么在后续购买商品的请求访问时，锁失效 !

解决思路：使用线程的value进行比较，只有是本线程的加锁的才能释放。

那么这个时候又有一个问题，假设这个线程因为操作库存某些问题导致死了，那程序不就也死了？

设置了redis的超时时间，假设这个商品不能扣减库存了，那也就这10秒不能操作，互联网公司的业务完全能接受。

 

        String threadId = String.valueOf(Thread.currentThread().getId());
        try {
            // 获取库存数量 40
            Boolean product = redisTemplate.opsForValue().setIfAbsent("product-test001", threadId, 11, TimeUnit.SECONDS);
            if (null == product) {
                // 自旋
                while (true) {
                    System.out.println("自旋开始" + Thread.currentThread().getName());
                    Thread.sleep(4000L);
                    // 加锁成功
                    if (null != redisTemplate.opsForValue().setIfAbsent("product-test001",threadId, 11, TimeUnit.SECONDS)) {
                        // 扣减库存
                        System.out.println("自旋扣减库存开始" + Thread.currentThread().getName());
                        Thread.sleep(10000L);
                        System.out.println("自旋扣减库存成功" + Thread.currentThread().getName());
                        break;
                    }
                }
            }
            // 扣减库存 模拟扣减库存
            Thread.sleep(10000L);
        } finally {
            if(threadId.equals(redisTemplate.opsForValue().get("product-test001"))){
                // 防止异常情况 必须释放锁
                redisTemplate.delete("product-test001");
            }
        }

 

 

因为这款商品是爆品所以导致一旦开启会有超高并发的可能存在，这个时候就会对redis的压力非常大，怎么设计？

使用分段锁思想，比如将product_test1分成product_test1_001，product_test1_002，...，product_test1_100 根据某种规则让他坐落在集群的不同的槽位中 ，假设有10个集群节点那么，16384/10 尽量坐落在不同的节点，可以大幅度提高redis的吞吐量。