redis实战---分布式锁--实战篇

  # 定义 upstream 池
    upstream backend {
        server 127.0.0.1:8000;
        server 127.0.0.1:8001;
    }
      location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    } 

@RestController
@RequestMapping("/test")
public class IndexController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping("lock")
    public  String deductStock() {
        //写死一个固定的商品id，作为我们被秒杀的商品
        String lockKey="lock:product:101";
        //uuid,防止删除其他人加的锁
        String clientId = UUID.randomUUID().toString();
        //进行加锁，设置过期时间为10s 注意代码的原子性
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey,clientId,10, TimeUnit.SECONDS);
        //如果加锁失败,返回错误，秒未成功
        if(!result){
            return "error_code";
        }
        try {
            // 获取当前库存
            String stock1 = stringRedisTemplate.opsForValue().get("stock");
            if( stock1 == null){
                System.out.println("秒杀未开始");
                return "end";
            }
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if (stock > 0) {
                // 扣减库存
                int realStock = stock - 1;
                // 更新库存
                stringRedisTemplate.opsForValue().set("stock", realStock + "");
                System.out.println("扣减成功，剩余的库存为：" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            //如果是自己加的锁就自己删掉
            if(clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
                stringRedisTemplate.delete(lockKey);
            }
        }
        return "end";
    }
}

<!--        redisson依赖-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.15.5</version>
        </dependency>

@Autowired
    private RedissonClient redissonClient;
    @GetMapping("lock1")
    public  String deductStock1() {
        //写死一个固定的商品id，作为我们被秒杀的商品
        String lockKey="lock:product:101";
        //获取锁对象
        RLock lock = redissonClient.getLock(lockKey);
        //加锁，使用lock方法，锁将会自动续命
        lock.lock();
        try {
            // 获取当前库存
            String stock1 = stringRedisTemplate.opsForValue().get("stock");
            if( stock1 == null){
                System.out.println("秒杀未开始");
                return "end";
            }
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if (stock > 0) {
                // 扣减库存
                int realStock = stock - 1;
                // 更新库存
                stringRedisTemplate.opsForValue().set("stock", realStock + "");
                System.out.println("扣减成功，剩余的库存为：" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
            return "end";
        }finally {
            //释放锁
            lock.unlock();
        }
    }

private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
    // 获取当前线程ID
    long threadId = Thread.currentThread().getId();
    // 尝试获取锁，获取到了则返回null，否则返回锁的剩余过期时间
    Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
    // 如果返回null，说明锁已经被当前线程获取，直接返回
    if (ttl == null) {
        return;
    }
    // 创建一个订阅对象
    RFuture<RedissonLockEntry> future = subscribe(threadId);
    // 如果可中断，则中断等待
    if (interruptibly) {
        commandExecutor.syncSubscriptionInterrupted(future);
    } else {
        // 否则一直等待
        commandExecutor.syncSubscription(future);
    }
    try {
        while (true) {
            // 再次尝试获取锁，获取到了则返回null，否则返回锁的剩余过期时间
            ttl = tryAcquire(-1, leaseTime, unit, threadId);
            // 如果返回null，说明锁已经被当前线程获取，跳出循环
            if (ttl == null) {
                break;
            }
            // 如果锁剩余过期时间大于等于0，则等待指定时间
            if (ttl >= 0) {
                try {
                    // 等待指定时间后再次尝试获取锁
                    future.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    // 如果是可中断的，则抛出异常
                    if (interruptibly) {
                        throw e;
                    }
                    // 否则继续等待
                    future.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                }
            } else {
                // 否则一直等待直到获取到锁
                if (interruptibly) {
                    future.getNow().getLatch().acquire();
                } else {
                    future.getNow().getLatch().acquireUninterruptibly();
                }
            }
        }
    } finally {
        // 取消订阅
        unsubscribe(future, threadId);
    }
}