Redis---------实现商品秒杀业务，包括唯一ID，超卖问题，分布式锁

订单ID必须是唯一

唯一ID构成：

代码生成唯一ID：


import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;//基于redis自增长的生成策略
@Component
public class RedisUUID {//起始时间时间秒数private static final long BEGIN_TIMESTAMP=1640995200L;//使用Redis自增策略private StringRedisTemplate stringRedisTemplate;public RedisUUID(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}//参数是业务的类型public long nextid(String keyType){//1，生成时间戳LocalDateTime now = LocalDateTime.now();long nowsecend = now.toEpochSecond(ZoneOffset.UTC);//当前时间的秒数减去起始时间的秒数得到时间戳long nowtime_stamp = nowsecend - BEGIN_TIMESTAMP;//2，生成序列号String nowdate = now.format(DateTimeFormatter.ofPattern("yyyy:mm:dd"));//使得每天都会生成新的一轮IDlong count = stringRedisTemplate.opsForValue().increment("icr:" + keyType + ":" + nowdate);//3，拼接返回return nowtime_stamp << 32 | count;}
}

商品下单操作

业务逻辑：

思路:主要是要了解以及掌握整个业务的流程:①先看商品是不是在秒杀的时间范围内②然后还要去看库存中是否还有该商品③如果有的话就扣减库存④然后就会生成订单，订单ID为唯一ID⑤把订单写入数据库中，再返回数据给前端

代码实现：

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisUUID redisUUID;@Override@Transactionalpublic Result seckillVoucher(Long voucherId) {//1,查询商品的信息SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2，看是否在秒杀时间范围内if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("尚未开始！");}if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("已经结束啦！");}//3，再看库存是否还有if (voucher.getStock()<1) {return Result.fail("库存不足!");}//4，如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).update();if (!sucess) {return Result.fail("库存不足！");}//5，然后就创建订单信息VoucherOrder voucherOrder = new VoucherOrder();//5.1，订单id----id生成器long order = redisUUID.nextid("order");voucherOrder.setVoucherId(order);//5.2，用户idLong id = UserHolder.getUser().getId();voucherOrder.setUserId(id);//5.3，商品idvoucherOrder.setVoucherId(voucherId);//6，保存进数据库save(voucherOrder);//7，返回数据return Result.ok(order);}
}

库存超卖问题

先看看什么是库存超卖问题:

正常情况:

但是涉及到高并发的时候一定会出问题:

所以我们要想办法去解决这个问题，锁！！！

悲观锁认为一定发生并发问题，所以每一次操作都会加锁，是线程串行进行，不会出现并发问题，但是这样的话就导致性能降低，所以我们使用乐观锁，乐观锁是先让你操作，等你要修改数据库的时候再判断与你查到的数据是否是一样，如果是一样的才可以修改，否则不可以减库存。

乐观锁的两种实现判断法：

第一种:版本号法，就是通过查询两次版本号来判断是否被修改过库存

第二种:CAS法，是在版本号法上做的改进方法，既然要判断两次版本是否相同，为啥不判断库存量是否相同呢，所以CSA法就是去判断前后两次查询到的库存量是否一样，如果一样就可以改

用乐观锁CAS法来解决超卖问题：

//4，如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update();if (!sucess) {return Result.fail("库存不足！");}

但是这样任然还不能解决超卖问题，因为如果两个线程同时来查到100,线程1做完修改还剩99,线程2查到不是100就会不执行修改，这样也会有问题，所以又要进行改进策略

 //4，如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock",0).update();if (!sucess) {return Result.fail("库存不足！");}

一人一单问题

使用悲观锁处理单体服务下的多线程问题：

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisUUID redisUUID;@Overridepublic Result seckillVoucher(Long voucherId) {//1,查询商品的信息SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2，看是否在秒杀时间范围内if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("尚未开始！");}if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("已经结束啦！");}//3，再看库存是否还有if (voucher.getStock()<1) {return Result.fail("库存不足!");}//实现单体服务下的一人一单的多线程安全问题Long id = UserHolder.getUser().getId();//先获取锁，再提交事务，保证线程安全synchronized (id.toString().intern()){//获得Spring的代理对象(事务)IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}}@Transactionalpublic Result createVoucherOrder(Long voucherId) {//一人一单问题Long id = UserHolder.getUser().getId();Integer count = query().eq("user_id", id).eq("voucher_id", voucherId).count();if(count > 0){return Result.fail("你已经购买过！");}//4，如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock",0).update();if (!sucess) {return Result.fail("库存不足！");}//5，然后就创建订单信息VoucherOrder voucherOrder = new VoucherOrder();//5.1，订单id----id生成器long order = redisUUID.nextid("order");voucherOrder.setVoucherId(order);//5.2，用户idvoucherOrder.setUserId(id);//5.3，商品idvoucherOrder.setVoucherId(voucherId);//6，保存进数据库save(voucherOrder);//7，返回数据return Result.ok(order);}
}

添加依赖：

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

在启动类上添加：

@EnableAspectJAutoProxy(exposeProxy = true)

分布式集群模式下的多线程问题：

当我们是处理分布式集群模式下，两个JVM不是共用一把锁，导致每个JVM都有自己的锁导致我们之前的锁锁不住，每个JVM都有一个线程会获得锁。

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

基于Redis实现分布式锁：

创建锁对象：

import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;public class SimpleRedisLock implements ILock{private String name;private StringRedisTemplate stringRedisTemplate;private static final  String KEY_PREFXY="lock:";public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {this.name = name;this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean trylock(long timeoutSec) {//获取线程ID作为标识long ThreadId = Thread.currentThread().getId();//获取锁Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId + "", timeoutSec, TimeUnit.MINUTES);//避免空指针return Boolean.TRUE.equals(success);}@Overridepublic void unlock() {stringRedisTemplate.delete(KEY_PREFXY + name);}
}

代码实现Redis分布式锁的应用：

①先创建锁的对象，然后先是去获取锁②没有获取到锁就直接返回错误③获取到锁就可以进行对数据库的操作④操作完之后进行释放锁

Long id = UserHolder.getUser().getId();//创建锁对象SimpleRedisLock simpleRedisLock = new SimpleRedisLock("order" + id, stringRedisTemplate);//获取锁boolean trylock = simpleRedisLock.trylock(1200);//判断是否获得锁成功if (!trylock) {//获取锁失败return Result.fail("不允许重复下单！");}//获得Spring的代理对象(事务)try {IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);} finally {//释放锁simpleRedisLock.unlock();}

但是就上面的处理还不够严谨，因为如果一个线程发生阻塞的话，其他线程可能会获得锁并且释放锁，导致锁误删问题，

解决锁误删问题：

import cn.hutool.core.lang.UUID;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;public class SimpleRedisLock implements ILock{private String name;private StringRedisTemplate stringRedisTemplate;private static final  String KEY_PREFXY="lock:";//得到一个唯一锁的标识private static final  String ID_PREFXY= UUID.randomUUID(true)+"-";public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {this.name = name;this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean trylock(long timeoutSec) {//获取线程标识String ThreadId = ID_PREFXY+Thread.currentThread().getId();//获取锁Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId, timeoutSec, TimeUnit.MINUTES);//避免空指针return Boolean.TRUE.equals(success);}@Overridepublic void unlock() {//获取线程标识String ThreadId = ID_PREFXY+Thread.currentThread().getId();//判断要来修改的进程跟锁的标识是否一致String s = stringRedisTemplate.opsForValue().get(KEY_PREFXY + name);if(ThreadId.equals(s)){//释放锁stringRedisTemplate.delete(KEY_PREFXY + name);}}
}