Redis实战2-商铺缓存、优惠券秒杀

2.商户查询缓存

2.1什么是缓存

缓存就是数据交换的缓冲区，是存贮数据的临时地方，一般读写性能高。

缓存的作用：降低后端负载、提高读写效率、降低响应时间
缓存的成本：数据一致性成本、代码维护成本、运维成本

2.2添加Redis缓存

实现代码

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id) {
        //1.根据id在redis中查询缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY);
        //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        if(shop == null){
            return Result.fail("店铺不存在");
        }
        //5.存在写入reids
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY,JSONUtil.toJsonStr(shop));
        return Result.ok(shop);
    }
}

2.3缓存更新策略

业务场景：

• 低一致性需求：使用内存淘汰机制。例如商铺类型的查询缓存
• 高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存。

2.3.1 主动更新策略

操作缓存和数据库时有三个问题要考虑：
1.删除缓存还是更新缓存？

• 更新缓存：每次更新数据库都删除缓存，无效写操作较多
• 删除缓存：更新数据库时让缓存失效，查询时再更新缓存 √
  2.如何保证缓存与数据库的操作的同时成功或失败？
• 单体系统，将缓存与数据库操作放在一个事务
• 分布式系统，利用TCC等分布式事务方案
  3.先操作缓存还是先操作数据库？
• 先删除缓存，再操作数据库
• 先操作数据库，再删除缓存
  正常情况下
  异常情况
  线程一删除缓存10后在更新数据20操作时，线程二读取缓存未命中，查询数据库得到10，写入缓存10，线程一更新操作完成后数据库为20，数据库数据和缓存不一致（发送的情况高）
  
  正常情况
  
  异常情况
  缓存失效，线程一查询未命中，查询数据库10后，写入数据库。在写入数据库的过程，线程二修改数据库20，然后删除缓存，线程一写入缓存10，与数据库20不一致
  发送概率低
  条件：1.刚好缓存失效2.恰好失效后，读数据要写缓存（微秒级）的过程中又突然来一个线程更新数据库（相对慢）
  所以方案二胜出
  
  缓存更新策略的最佳实践方案：
  1.低一致性需求：使用Redis自带的内存淘汰机制
  2.高一致性需求：主动更新，并以超时剔除作为兜底方案
• 读操作：
  • 缓存命中则直接返回
  • 缓存未命中则查询数据库，并写入缓存，设定超时时间
    写操作：
• 先写数据库，然后再删除缓存
• 要确保数据库与缓存操作的原子性
  案例：给查询商铺的缓存添加超时剔除和主动更新策略
  修改ShopServiceImpl中的queryById，写入redis的同时添加过期时间

        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

修改ShopController中的updataShop

 @Override
    @Transactional
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺id不能为空");
        }
        //1.更新数据库
        updateById(shop);
        //2.删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok() ;
    }

2.4缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。
常见的解决方案有两种：

• 缓存空对象
  • 优点：实现简单，维护方便
  • 缺点：
    • 额外的内存消耗
    • 可能造成短期的不一致
• 布隆过滤
  • 优点：内存占用少，没有多余的key
  • 缺点：
    • 实现复杂
    • 存在误判可能
      
      修改流程
      
      修改代码

public Result queryById(Long id) {
        //1.根据id在redis中查询缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //命中的是否是空值
        if(shopJson != null){
            //返回一个错误信息
            return Result.fail("店铺不存在");
        }
        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        if(shop == null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }
        //5.存在写入reids
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

缓存穿透产生的原因是什么

• 用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求，给数据库带来巨大压力
  缓存穿透的解决方案有哪些？
• 缓存null值
• 布隆过滤
• 增强id的复杂度，避免被猜测id规律
• 做好数据的基础格式效验
• 加强用户权限效验

2.5缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力
解决方案：

• 给不同的key的TTL添加随机值
• 利用Redis集群提高服务的可用性
• 给缓存业务添加降级限流策略
• 给业务添加多级缓存

2.6缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击
常见的解决方案有两种：

• 互斥锁
• 逻辑过期
  
  
  利用互斥锁方式解决缓存击穿问题
  需求：修改根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题
  
  代码

public Shop queryWithNutex(Long id){
        //1.根据id在redis中查询缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //命中的是否是空值
        if(shopJson != null){
            //返回一个错误信息
            return null;
        }
        //4.实现缓存重建
        //4.1获取互斥锁
        String lockKey = "lock:shop" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            //4.2判断是否获取成功
            if(!isLock){
                //4.3失败，则休眠并重试
                Thread.sleep(50);
                queryWithNutex(id);
            }
            //4.4.成功，根据id查询数据库
            shop = getById(id);
            //5.不存在，返回错误
            if(shop == null){
                //将空值写入redis
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //6.存在写入reids
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
            //7.释放互斥锁
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            unlock(lockKey);
        }
        return shop;
    }
 private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }

基于逻辑过期方式解决缓存击穿问题

给原本的实体类增加逻辑过期时间字段
第一种

@Data
public class RedisData {
    private LocalDateTime expireTime;
}

Shop实体类继承RedisData（还是改变了元代码）
第二种定义一个Object用来存放Shop信息，还可以存放其他类型

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

2.7缓存工具封装

在util包下创建一个CacheClient工具类

@Slf4j
@Component
public class CacheClient {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time, unit);
    }
    public void setWithLogicalExpire(String key, Object value,Long time, TimeUnit unit){
        //设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));

        //写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
    }
    public <R,ID> R queryWithPassThrough(String keyPrefix ,  ID id, Class<R> type, Function<ID,R> dbFallback,
                                         Long time, TimeUnit unit){
        String key = keyPrefix + id;
        //1.根据id在redis中查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if(StrUtil.isNotBlank(json)){
            //3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        //命中的是否是空值
        if(json != null){
            //返回一个错误信息
            return null;
        }
        //4.不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        if(r == null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //5.存在写入reids
        this.set(key,r,time,unit);
        return r;
    }
    private static final ExecutorService CACHE_REBUILD_EXCUTOR = Executors.newFixedThreadPool(10);
    public <R,ID> R queryWithLogicExpire(String keyPrefix,ID id,Class<R> type, Function<ID ,
            R> dbFallback,Long time, TimeUnit unit){
        String key = keyPrefix + id;
        //1.根据id在redis中查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if(StrUtil.isBlank(json)){
            //3.不存在，直接返回null
            return null;
        }
        //4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r =  JSONUtil.toBean((JSONObject) redisData.getData(),type);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            //5.1未过期，直接返回店铺信息
            return r;
        }
        //5.2已过期，需要缓存重建
        //6.重建缓存
        //6.1获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        //6.2判断是否获取成功
        if(isLock){
            //6.3成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXCUTOR.submit(() -> {
                try {
                    // 重建缓存
                    //1.查询数据库
                    R r1 = dbFallback.apply(id);
                    //2.写入redis
                    this.setWithLogicalExpire(key,r1,time,unit);

                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放锁
                    unlock(lockKey);
                }
            });
        }
        //6.4返回过期的商铺信息
        return r;
    }
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
}

  public Result queryById(Long id) {
        //缓存穿透
        //Shop shop = queryWithPassThrough(id);
//        Shop shop = cacheClient.
//                queryWithPassThrough(CACHE_SHOP_KEY,id,Shop.class,
//                this::getById,CACHE_SHOP_TTL,TimeUnit.MINUTES
//                );
        //互斥锁解决缓存击穿
        //Shop shop= queryWithNutex(id);

        //逻辑过期解决缓存击穿
        //Shop shop = queryWithLogicExpire(id);
        Shop shop = cacheClient.queryWithLogicExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);

3. 优惠券秒杀

3.1全局唯一ID

每个店铺都可以发布优惠券：

当用户抢购时，就会生成订单并保存到tb_vocher_order表中，而订单表如果使用数据库自增ID就存在一些问题：

• id的规律太明显
• 表单数据量的限制
  全局ID生成器，是一种在分布式系统下用来生成全局唯一的ID的工具，一般满足下列特性：
  
  为了增加ID的安全性，我们可以不直接使用Redis自增的数值，而是拼接一些其它信息：
  
  在工具包中新增RedisIdWorder

@Component
public class RedisIdWorker {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号位数
     */
    private static final int COUNT_BITS = 32;

    public long nextId(String keyPrefix){
        //1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long newSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = newSecond - BEGIN_TIMESTAMP;
        //2.生成序列号
        //2.1或者当前日期，精确到天
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        //2.2自增长
        long count = stringRedisTemplate.opsForValue().increment("icr" + keyPrefix + ":" + date);
        //3.拼接并返回
        return timestamp << COUNT_BITS | count;
    }
}

测试

 @Resource
    private RedisIdWorker redisIdWorker;

    private ExecutorService es = Executors.newFixedThreadPool(500);

    @Test
    void testIdWorker() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(300);
        Runnable task = () -> {
            for (int i = 0;i < 100; i++){
                long id = redisIdWorker.nextId("order");
                System.out.println("id = " + id);
            }
            latch.countDown();
        };
        long begin = System.currentTimeMillis();
        System.out.println();
        for(int i = 0; i < 300; i++){
            es.submit(task);
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    }

全局唯一ID生成策略：

• UUID
• Redis自增
• snowflake算法
• 数据库自增
  Redis自增ID策略:
• 每天一个key,方便统计订单量
• ID构造是时间戳+计数器

3.2实现优惠券秒杀下单

秒杀是否开始或结束，如果尚未开始或者已经结束则无法下单
库存是否充足

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
    @Resource
    private RedisIdWorker redisIdWorker;
    @Resource
    private ISeckillVoucherService iSeckillVoucherService;
    @Transactional
    @Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询优惠券
        SeckillVoucher voucher = iSeckillVoucherService.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 = iSeckillVoucherService.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);
    }
}

3.3超卖问题

正常情况

交叉执行

超卖问题就是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁

乐观锁
乐观锁的关键是判断之前查询得到的数据是否有被修改过，常见的方式有两种:


CAS

 boolean success = iSeckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id",voucherId).eq("stock",voucher.getStock())
                .update();

问题：并发请求下，在相同更改的线程里只有一个成功，其他失败，失败率高
更改：不再判断库存是否和第一次查询时相等，只要判断库存大于零

                .eq("voucher_id",voucherId).gt("stock",0)

超卖的线程安全问题，解决方案有哪些
1.悲观锁：添加同步锁，让线程串行执行

• 优点：简单粗暴
• 缺点：性能一般
  2.乐观锁：不加锁，在更新时判断是否有其他线程在修改
• 优点：性能好
• 缺点：存在成功率低

3.4一人一单

需求：修改秒杀业务，要求同一个优惠券，一个用户只能下一单

修改代码

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
    @Resource
    private RedisIdWorker redisIdWorker;
    @Resource
    private ISeckillVoucherService iSeckillVoucherService;
    @Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询优惠券
        SeckillVoucher voucher = iSeckillVoucherService.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("库存不足");
        }
        Long userId = UserHolder.getUser().getId();
        synchronized (userId.toString().intern()) {
            //获取代理对象
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }
    @Transactional
    public  Result createVoucherOrder(Long voucherId) {
        //5.一人一单
        Long userId = UserHolder.getUser().getId();
            //5.1查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
            //5.2判断是否存在
            if (count > 0) {
                //该用户下过单
                return Result.fail("同一个用户不能重复下单!");
            }
            //6.扣减库存
            boolean success = iSeckillVoucherService.update()
                    .setSql("stock = stock - 1")
                    .eq("voucher_id", voucherId).gt("stock", 0)
                    .update();
            if (!success) {
                return Result.fail("库存不足");
            }
            //7.创建订单
            VoucherOrder voucherOrder = new VoucherOrder();
            //7.1订单id
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            //7.2用户id
            voucherOrder.setUserId(userId);
            //7.3代金券id
            voucherOrder.setVoucherId(voucherId);
            save(voucherOrder);
            //8.返回订单id
            return Result.ok(orderId);
        }
}

问题：
原本在方法中调用createVoucherOrder会出现事务失效

//调用的createVoucherOrder的事务失效
this.createVoucherOrder(voucherId);

方法：
1.获取代理对象，用代理对象调用

 //获取代理对象
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);

2.引入相关依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

3.启动类上开启注解

@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.hmdp.mapper")
@SpringBootApplication
public class HmDianPingApplication {

    public static void main(String[] args) {
        SpringApplication.run(HmDianPingApplication.class, args);
    }
}

一人一单并发安全问题
理想状态

集群模式下synchronized失效了，synchronized只能保证单个JVM多个线程的互斥

3.5分布式锁

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

3.5.1分布式锁的实现

分布式锁的核心是实现多进程之间互斥，而满足这一点的方式有很多，常见的有三种：

基于Redis的分布式锁
实现分布式锁时需要实现的两个基本方法：

• 获取锁：
  - 互斥：确保只能有一个线程获取锁
  - 非阻塞：尝试一次，成功返回true，失败返回false

#添加锁利用setnx的互斥特性
SETNX lock thread1
EXPIRE lock 10
#万一在设置时间前服务宕机，超时时间设置失败。为了确保同时，使用一条指令设置锁和过期时间
SET lock thread1 ex 10 nx

• 释放锁
  - 手动释放
  - 超时释放：获取锁时添加一个超时时间

DEL key

需求：定义一个类，实现下面接口，利用Redis实现分布式锁功能。

public interface ILock {

    /**
     * 尝试获取锁
     * @param timeoutSec 锁持有的超时时间，过期后自动释放
     * @return true代表获取锁成功；false代表获取锁失败
     */

    boolean tryLock(long timeoutSec);
    /**
     * 释放锁
     */
    void 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:";

    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        long threadId = Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }
    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

修改原本业务代码

 Long userId = UserHolder.getUser().getId();
        //创建锁对象
        SimpleRedisLock lock = new SimpleRedisLock("ooder" + 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();
        }

上述问题
线程一获取锁后发生业务堵塞，时间超过的设置的过期时间，超时释放，让线程二获取锁执行业务，这时线程一的业务完成，释放锁，释放的是线程二的锁
解决：在释放锁之前判断锁的标识是否一致

需求：修改之前的分布式锁实现，满足：
1.获取锁时存入线程标示(可以用UUID表示)
2.释放锁时先获取锁中的线程标示，判断是否与当前线程标示是否一致

• 如果一致则释放锁
• 如果不一致则不释放锁
  

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().toString(true) + "-";

    @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);
    }
    @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);
        }
    }
}

(判断锁标示是否一致和释放锁是两个步骤）在线程一判断是自己的锁标示后，准备释放锁时发生了堵塞，线程二获取锁执行业务，线程一结束堵塞后，删除的是线程二的锁

Redis的Lua脚本
在一个脚本中编写多个指令，确保多条指令执行的原子性。


如果脚本中的key、value不想写死，可以作为参数传递。key类型参数会放到KEYS数组，其他参数会放入ARGV数组，在脚本中可以从KEYS和ARGB数组获取这些参数：

释放锁的业务流程：
1.获取锁中的线程标识
2.判断是否与指定的标示（当前线程标示）一致
3.如果一致则释放锁（删除）
4.如果不一致则什么也不做
如果用Lua脚本来标示是这样的：

再次改进Lua脚本实现分布式锁
需求：基于Lua脚本实现分布式锁的释放锁逻辑

基于Redis的分布式锁实现思路：

• 利用set nx ex 获取锁，并设置过期时间，保存线程标示
• 释放锁时先判断线程标示是否与自己一致，一致则删除锁
  特性
• 利用set nex满足互斥性
• 利用set ex保证故障时依然能释放，避免死锁，提高安全性
• 利用Redis集群保证高可用和高并发特性

3.5.2基于Redis的分布式锁优化

基于set nx实现的分布式存在下面的问题：
Redisson入门
1.引依赖

<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.6</version>
        </dependency>

2.配置Redisson客服端：

@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient redissonClient(){
        //配置类
        Config config = new Config();
        config.useSingleServer().setAddress("redis://106.55.251.245:6379").setPassword("123321");
        return Redisson.create(config);
    }
}

3.使用Redisson的分布式锁

Redisson可重入锁原理


Redis分布式原理：
可重入：利用hash结构记录线程id和重入次数
可重试：利用信号量和PubSub功能实现等待、唤醒、获取锁失败的重试机制
超时续约：利用watchDog，每隔一段时间（releaseTime/3），重置超时时间

Redisson分布式锁主从一致性问题

3.6Redis优化秒杀

改进秒杀业务，提高并发性能
需求：
①新增秒杀优惠券的同时，将优惠券信息保存到Redis中
②基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功

--1.1优惠券id
local voucherId = ARGV[1]
--1.2用户id
local userId = ARGV[2]

--2.数据key
--2.1库存key
local stockKey = 'seckill:stock:' .. voucherId
--2.2订单key
local orderKey = 'seckill:order:' .. voucherId

--3.脚本业务
--3.1判断库存是否充足get stockKey
if(tonumber(redis.call('get', stockKey)) <=0) then
    --3.2库存不足,返回1
    return 1
end
--3.3判断用户是否下单SISMEMBER orderKey userId
if(redis.call('sismember', orderKey,userId) == 1) then
    --3.4存在，说明重复下单，返回2
    return 2
end
--3.5下单（保存用户)sadd orderKey userId
redis.call('sadd', orderKey,userId)

③如果成功，将优惠券id和用户id封装后存入堵塞队列

 @Override
    public Result seckillVoucher(Long voucherId) {
        //获取用户
        Long userId = UserHolder.getUser().getId();
        //1.执行lua脚本
         Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString()
        );
        //2.判断结果是否为0
        int r = result.intValue();
        if(r != 0){
            //2.1不为0，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        //2.2为0，有购买资格，把下单信息保存到阻塞队列
        VoucherOrder voucherOrder = new VoucherOrder();
        //2.3订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //2.4用户id
        voucherOrder.setUserId(userId);
        //2.5代金券id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);
        //2.6放入阻塞队列
        orderTasks.add(voucherOrder);
        //3.获取代理对象
       proxy = (IVoucherOrderService) AopContext.currentProxy();
        //4.返回订单id
        return Result.ok(orderId);
    }

④开启线程任务，不断从堵塞队列中获取信息，实现异步下单功能

  private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

    @PostConstruct
    private void init(){
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }

    private class VoucherOrderHandler implements Runnable{
        @Override
        public void run() {
            while (true){
                try {
                    //1.获取队列中的订单信息
                    VoucherOrder voucherOrder = orderTasks.take();
                    //2.创建订单
                    handleVoucherOrder(voucherOrder);
                } catch (Exception e) {
                    log.error("处理订单异常",e);
                }
            }
        }

    }
    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        //5.一人一单
        Long userId = voucherOrder.getUserId();

            //5.1查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
            //5.2判断是否存在
//            if (count > 1) {
//                //该用户下过单
//                log.error("用户已经购买过一次");
//                return;
//            }
            //6.扣减库存
            boolean success = iSeckillVoucherService.update()
                    .setSql("stock = stock - 1")
                    .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0)
                    .update();
            if (!success) {
                log.error("库存不足");
                return;
            }
            save(voucherOrder);
        }