Redis实现全局唯一id

public class RedisIdWorker {

    private StringRedisTemplate stringRedisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    //开始时间戳
    private static final long BEGIN_TIMESTAMP = 1640995200L;//2022.01.01 00:00:00

    //序列号位数
    private static final int COUNT_BITS = 32;

    public long nextId(String keyPrefix){
        //生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timeStamp = nowSecond-BEGIN_TIMESTAMP;

        //2.生成序列号
        //2.1.获取当前时间，精确到天  每天一个key,方便统计每天的大小
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        //2.2 利用redis的自增长
        Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        //拼接并返回
        return timeStamp << COUNT_BITS | count;
    }
}

实现优惠卷秒杀的下单功能

下单时需要判断两点：

* 秒杀是否开始或结束，如果尚未开始或已经结束则无法下单

* 库存是否充足，不足则无法下单。

未考虑高并发

public Result seckillVoucher(Long voucherId) {
        //1.查询优惠卷
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2.判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //3.判断秒杀是否已经结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("秒杀已经结束！");
        }
        //4.判断库存是否充足
        if (voucher.getStock()<1){
            //库存不足
            return Result.fail("库存不足！");
        }
        //5.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock -1")
                .eq("voucher_id", voucherId).update();
        if (!success){
            //库存不足
            return Result.fail("库存不足！");
        }
        //6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2.用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //6.3.代金卷id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        //7.返回订单id
        return Result.ok(orderId);
    }

乐观锁解决超卖问题

//5.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock -1")
                .eq("voucher_id", voucherId).gt("stock",0)//where voucher_id = ? and stock>0
                .update();

这里我们判断stock>0,就是不管是否有线程安全问题，只要有票就会把票买了。只有没票了才会考虑线程安全问题。

卖票一人一单问题

 @Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询优惠卷
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2.判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //3.判断秒杀是否已经结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("秒杀已经结束！");
        }
        //4.判断库存是否充足
        Integer stock = voucher.getStock();
        if (stock<1){
            //库存不足
            return Result.fail("库存不足！");
        }

        //一人一单
        Long userId = UserHolder.getUser().getId();
        //查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        //判断是否存在
        if (count>0){
            //用户已经购买过了
            return Result.fail("用户已经买过了！");
        }

        //5.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock -1")
                .eq("voucher_id", voucherId).gt("stock",0)//where voucher_id = ? and stock>0
                .update();
        if (!success){
            //库存不足
            return Result.fail("库存不足！");
        }

        //6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2.用户id
        voucherOrder.setUserId(userId);
        //6.3.代金卷id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        //7.返回订单id
        return Result.ok(orderId);
    }

考虑线程安全问题

 @Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询优惠卷
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2.判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        //3.判断秒杀是否已经结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("秒杀已经结束！");
        }
        //4.判断库存是否充足
        Integer stock = voucher.getStock();
        if (stock<1){
            //库存不足
            return Result.fail("库存不足！");
        }

        //7.返回订单id
        Long userId = UserHolder.getUser().getId();
        synchronized (userId.toString().intern()){//这里我们用intern方法是因为toString方法底层是new了一个新的string对象，我们为了确保同一个用户锁的是同一个对象，intern方法是如果值在常量池中存在了就用常量池中的那个对象。
            //获取代理对象  为什么要用代理对象呢？因为createVoucherOrder这个方法要想事务生效就必须使用代理对象调用而不能是this。因为@Transactional注解底层是通过代理对象来处理的，如果使用this就跳过了代理对象，事务就失效了。
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }

    @Transactional
    public Result createVoucherOrder(Long voucherId){
        //一人一单
        Long userId = UserHolder.getUser().getId();
        //查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        //判断是否存在
        if (count>0){
            //用户已经购买过了
            return Result.fail("用户已经买过了！");
        }

        //5.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock -1")
                .eq("voucher_id", voucherId).gt("stock",0)//where voucher_id = ? and stock>0
                .update();
        if (!success){
            //库存不足
            return Result.fail("库存不足！");
        }

        //6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2.用户id
        voucherOrder.setUserId(userId);
        //6.3.代金卷id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        //7.返回订单id
        return Result.ok(orderId);
    }

要使用代理对象需要在启动类上暴露代理对象

卖票在集群下存在的问题

因为是在集群下，所以就会有把这一个项目部署到多台机器上，这也会导致每个机器都有自己的JVM,我们前面synchronized锁的是当前JVM下常量池中的userId对象。所以在集群下，就会失效。

分布式锁

满足分布式系统或集群模式下多进程可见互斥的锁

基于redis的分布式锁

自定义的redis锁

//获取锁对象
        SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        //获取锁
        boolean isLock = lock.tryLock(1200);
        //判断是否获取锁成功
        if (!isLock){
            //获取锁失败
            return Result.fail("一个人只能下一单！");
        }
        try{
            //获取代理对象
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }finally {
            //释放锁
            lock.unlock();
        }

public class SimpleRedisLock implements ILock {

    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID(true) + "-";//使用UUID来解决集群下线程id在不同JVM下重复问题。

    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);//为了防止在拆箱时，success如果为null，拆箱的话就会空指针异常。
    }

    @Override
    public void unlock() {
        //获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁中的标识
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        //判断标识是否一致
        if (threadId.equals(id)){
            //释放锁
            stringRedisTemplate.delete(KEY_PREFIX+name);
        }
    }
}

存在的问题

当我们当我们判断锁标识一致后要去释放锁的时候却发生了阻塞，结果锁又超时释放了，然后阻塞结束后就直接释放锁了。

所以我们要确保判断锁标识和释放锁是一个原子操作。

使用lua脚本来保证原子性。

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

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID(true) + "-";//使用UUID来解决集群下线程id在不同JVM下重复问题。 
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    static{
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }

    @Override
    public void unlock() {
        //调用lua脚本
        stringRedisTemplate.execute(UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX+Thread.currentThread().getId());
    }

该锁是自己写的，仍然有缺陷：不可重入，不能重试

所以下篇文章介绍使用redission