Chaque magasin peut publier des coupons :
Lorsqu'un utilisateur se précipite pour acheter, une commande sera générée et enregistrée dans la table tb_voucher_order If. la table de commande utilise un ID d'auto-incrémentation de base de données, il y aura quelques problèmes :
La régularité de l'ID est trop évidente
Limité par la quantité de données dans une seule table
Donc le principal La clé de la table tb_voucher_order ne peut pas utiliser un identifiant à incrémentation automatique :
create table tb_voucher_order
(
id bigint not null comment '主键'
primary key,
user_id bigint unsigned not null comment '下单的用户id',
voucher_id bigint unsigned not null comment '购买的代金券id',
pay_type tinyint(1) unsigned default 1 not null comment '支付方式 1：余额支付；2：支付宝；3：微信',
status tinyint(1) unsigned default 1 not null comment '订单状态，1：未支付；2：已支付；3：已核销；4：已取消；5：退款中；6：已退款',
create_time timestamp default CURRENT_TIMESTAMP not null comment '下单时间',
pay_time timestamp null comment '支付时间',
use_time timestamp null comment '核销时间',
refund_time timestamp null comment '退款时间',
update_time timestamp default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '更新时间'
);Global ID Generator est un outil utilisé pour générer des identifiants globalement uniques dans les systèmes distribués :
Afin de. augmente la sécurité de l'ID, nous ne pouvons pas l'utiliser directement Redis incrémente automatiquement la valeur, mais fusionne d'autres informations :
Composant D :
Bit de signe : 1 bit, toujours 0, indiquant un nombre positif
Horodatage : 31 bits, en secondes En tant qu'unité, il peut être utilisé pendant 69 ans
Numéro de série : 32 bits, compteur en secondes, prend en charge la génération de 2 ^ 32 identifiants différents par seconde
Écrivez le code du générateur d'identifiant global :
@Component
public class RedisIdWorker {
/**
* 开始时间戳，以2022.1.1为基准计算时间差
*/
private static final long BEGIN_TIMESTAMP = 1640995200L;
/**
* 序列号的位数
*/
private static final int COUNT_BITS = 32;
private StringRedisTemplate stringRedisTemplate;
public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
/**
* 生成带有业务前缀的redis自增id
* @param keyPrefix
* @return
*/
public long nextId(String keyPrefix) {
// 1.生成时间戳
LocalDateTime now = LocalDateTime.now();
long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
long timestamp = nowSecond - 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.拼接并返回
// 用于是数字类型的拼接，所以不能像拼接字符串那样处理，而是通过位运算将高32位存 符号位+时间戳，低32位存 序列号
return timestamp << COUNT_BITS | count;
}
public static void main(String[] args) {
LocalDateTime time = LocalDateTime.of(2022, 1, 1, 0, 0, 0);
long second = time.toEpochSecond(ZoneOffset.UTC);
System.out.println(second);// 1640995200
}
}Test du générateur d'identifiant global :
@SpringBootTest
class HmDianPingApplicationTests {
@Resource
private RedisIdWorker redisIdWorker;
private ExecutorService executorService = Executors.newFixedThreadPool(500);
@Test
void testIdWorker() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(300);
// 每个线程生成100个id
Runnable task = () -> {
for (int i = 0; i < 100; i++) {
long id = redisIdWorker.nextId("order");
System.out.println("id = " + id);
}
latch.countDown();
};
// 300个线程
long begin = System.currentTimeMillis();
for (int i = 0; i < 300; i++) {
executorService.submit(task);
}
latch.await();
long end = System.currentTimeMillis();
System.out.println("time = " + (end - begin));
}
}Résultats du test :
Incrémentation automatique Redis
Algorithme de flocon de neige (flocon de neige)
Incrémentation automatique de la base de données (créez une table séparée pour stocker l'ID d'incrémentation automatique et attribuez-le à la table après la division de la sous-base de données en tableaux)
3. Stratégie d'identification à incrémentation automatique Redis
La structure de l'ID à augmentation automatique : horodatage + compteur
2. Mettre en œuvre la commande de vente instantanée de coupon
tb_voucher : informations de base sur le coupon, montant de la remise, règles d'utilisation, etc. Le tableau tb_voucher est un coupon normal ou un coupon de vente flash)
tb_seckill_voucher : inventaire des coupons, heure de début et heure de fin (ces informations sont requises pour les coupons de vente flash). En même temps, les coupons de sécurité contiennent les informations de base des coupons ordinaires). (l'identifiant de clé primaire de la table des coupons de sécurité tb_seckill_voucher L'identifiant de la table des coupons ordinaires tb_voucher est lié)
create table tb_voucher
(
id bigint unsigned auto_increment comment '主键'
primary key,
shop_id bigint unsigned null comment '商铺id',
title varchar(255) not null comment '代金券标题',
sub_title varchar(255) null comment '副标题',
rules varchar(1024) null comment '使用规则',
pay_value bigint(10) unsigned not null comment '支付金额，单位是分。例如200代表2元',
actual_value bigint(10) not null comment '抵扣金额，单位是分。例如200代表2元',
type tinyint(1) unsigned default 0 not null comment '0,普通券；1,秒杀券',
status tinyint(1) unsigned default 1 not null comment '1,上架; 2,下架; 3,过期',
create_time timestamp default CURRENT_TIMESTAMP not null comment '创建时间',
update_time timestamp default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '更新时间'
);create table tb_seckill_voucher
(
voucher_id bigint unsigned not null comment '关联的优惠券的id'
primary key,
stock int(8) not null comment '库存',
create_time timestamp default CURRENT_TIMESTAMP not null comment '创建时间',
begin_time timestamp default CURRENT_TIMESTAMP not null comment '生效时间',
end_time timestamp default CURRENT_TIMESTAMP not null comment '失效时间',
update_time timestamp default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '更新时间'
)
comment '秒杀优惠券表，与优惠券是一对一关系';2 Écrivez l'interface pour ajouter des coupons de vente flash
@RestController
@RequestMapping("/voucher")
public class VoucherController {
@Resource
private IVoucherService voucherService;
/**
* 新增秒杀券
* @param voucher 优惠券信息，包含秒杀信息
* @return 优惠券id
*/
@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
voucherService.addSeckillVoucher(voucher);
return Result.ok(voucher.getId());
}
}@Service
public class VoucherServiceImpl extends ServiceImpl<VoucherMapper, Voucher> implements IVoucherService {
@Resource
private ISeckillVoucherService seckillVoucherService;
@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
// 保存优惠券
save(voucher);
// 保存秒杀信息
SeckillVoucher seckillVoucher = new SeckillVoucher();
seckillVoucher.setVoucherId(voucher.getId());
seckillVoucher.setStock(voucher.getStock());
seckillVoucher.setBeginTime(voucher.getBeginTime());
seckillVoucher.setEndTime(voucher.getEndTime());
seckillVoucherService.save(seckillVoucher);
}
}Ajout de test. :
Résultat du test :
3. Pour réaliser une commande de vente flash
Lorsque vous passez une commande, vous devez juger deux points : 
Que le flash la vente a commencé ou s'est terminée Si elle n'a pas commencé ou s'est terminée, vous ne pouvez pas passer de commande
Inventaire Si c'est suffisant, vous ne pouvez pas passer de commande si ce n'est pas suffisant
Code principal : 
@RestController
@RequestMapping("/voucher-order")
public class VoucherOrderController {
@Resource
private IVoucherOrderService voucherOrderService;
@PostMapping("seckill/{id}")
public Result seckillVoucher(@PathVariable("id") Long voucherId) {
return voucherOrderService.seckillVoucher(voucherId);
}
}@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisIdWorker redisIdWorker;
@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.判断库存是否充足
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);
return Result.ok(orderId);
}
}Test simple de réussite instantanée :
Déduction d'inventaire réussie : 
Quatre problèmes de super vente
Quand il y a un grand nombre de demandes accédant en même temps le temps, le problème de survente se produira
超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：
乐观锁的关键是判断之前查询得到的数据是否有被修改过，常见的方式有两种：
（1）版本号法
（2）CAS法
用库存代替了版本号，可以少加一个字段
扣库存时，与查询时的库存比较，没被修改则可以扣减库存
乐观锁方式，通过CAS判断前后库存是否一致，解决超卖问题：
// 之前的代码
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1")
.eq("voucher_id", voucherId).update();
// 乐观锁方式，通过CAS判断前后库存是否一致，解决超卖问题
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1") // set stock = stock -1
.eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update(); // where id = ？ and stock = ?又出现新的问题：
假设100个线程同时请求，但通过CAS判断后，只有一个线程能扣减库存成功，其余99个线程全部失败
此时，库存剩余99，但是实际业务可以满足其余99个线程扣减库存
虽然能解决超卖问题，但是设计不合理
所以为了解决失败率高的问题，需要进一步改进：
通过CAS 不再 判断前后库存是否一致，而是判断库存是否大于0
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1")
.eq("voucher_id", voucherId).gt("stock",0).update(); // where id = ? and stock > 0超卖这样的线程安全问题，解决方案有哪些？
（1）悲观锁：添加同步锁，让线程串行执行
优点：简单粗暴
缺点：性能一般
（2）乐观锁：不加锁，在更新时判断是否有其它线程在修改
优点：性能相对悲观锁好（但是仍然需要同时查数据库，影响性能）
缺点：存在成功率低的问题（可以采用分段锁方式提高成功率）
需求：修改秒杀业务，要求同一个优惠券，一个用户只能下一单
在扣减库存之前，加上一人一单的逻辑：
// 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("用户已经购买过一次！");
}此处仍会出现并发问题，当同一用户模拟大量请求同时查询是否下过单时，如果正好都查询出count为0，就会跳过判断继续执行扣减库存的逻辑，此时就会出现一人下多单的问题
解决方法：
由于是判断查询的数据是否存在，而不是像之前判断查询的数据是否修改过
所以这里只能加悲观锁
首先将一人一单之后的逻辑全部加锁，所以将一人一单之后的逻辑抽取出一个方法进行加锁，public Result createVoucherOrder(Long voucherId)
如果直接在方法上加锁，则锁的是this对象，锁的对象粒度过大，就算是不同的人执行都会阻塞住，影响性能，public synchronized Result createVoucherOrder(Long voucherId)
所以将锁的对象改为userId，但是不能直接使用synchronized (userId)，因为每次执行Long userId = UserHolder.getUser().getId();虽然值一样，但是对象不同，因此需要这样加锁 synchronized (userId.toString().intern())，intern()表示每次从字符串常量池中获取，这样值相同时，对象也相同
为了防止事务还没提交就释放锁的问题，则不能将锁加在createVoucherOrder方法内部，例如：
@Transactional
public Result createVoucherOrder(Long voucherId) {
synchronized (userId.toString().intern()) {
。。。
}
}而是需要等事务提交完再释放锁，例如：
synchronized (userId.toString().intern()) {
// 获取代理对象（事务）
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
}由于只有一人一单之后的逻辑涉及到修改数据库，所以只需对该方法加事务
@Transactional
public Result createVoucherOrder(Long voucherId)
由于只对createVoucherOrder方法加了事务，而该方法是在seckillVoucher方法中被调用，seckillVoucher方法又没有加事务，为了防止事务失效，则不能直接在seckillVoucher方法调用createVoucherOrder方法，例如：
@Override
public Result seckillVoucher(Long voucherId) {
。。。。
synchronized (userId.toString().intern()) {
return this.createVoucherOrder(voucherId);
}
}而是需要通过代理对象调用createVoucherOrder方法，因为@Transactional事务注解的原理是通过获取代理对象执行目标对象的方法，进行AOP操作，所以需要这样：
@Override
public Result seckillVoucher(Long voucherId) {
。。。。
// 获取代理对象（事务）
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
}并且还要引入依赖：
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>还要开启注解暴露出代理对象：
@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.hmdp.mapper")
@SpringBootApplication
public class HmDianPingApplication {
public static void main(String[] args) {
SpringApplication.run(HmDianPingApplication.class, args);
}
}完整VoucherOrderServiceImpl代码：
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
