在喧嚣之外 孤单 戒掉 廉价的浪漫
全局唯一ID生成
每个店铺都可以发布优惠券，当用户抢购时，就会生成订单并保存到tb_voucher_order这张表中。
而订单表如果使用数据库自增ID就存在一些问题：
-
id的规律性太明显
-
如果我们的id具有太明显的规则，用户或者说商业对手很容易猜测出来我们的一些敏感信息，比如商城在一天时间内，卖出了多少单，这明显不合适。
-
-
受单表数据量的限制
-
随着我们商城规模越来越大，mysql的单表的容量不宜超过500W，数据量过大之后，我们要进行拆库拆表，但拆分表了之后，他们从逻辑上讲他们是同一张表，所以他们的id是不能一样的， 于是乎我们需要保证id的唯一性。
-
全局唯一ID生成需要满足的特性：
为了增加ID的安全性，不要直接使用Redis自增的数值，而是拼接一些其它信息。
在实际开发中：
-
ID的组成部分：符号位：1bit，永远为0。
-
时间戳：31bit，以秒为单位，可以使用69年。
-
序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID。
唯一ID生成工具类
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
/**
* @Description 全局唯一Id生成器
* @Author LH
* @Date 2022/11/17 14:06
**/
@Component
public class RedisIdWorker {
/**
* 开始时间戳
* 2022-01-01 00:00:00
*/
private static final long BEGIN_TIMESTAMP = 1640966400L;
/**
* 拼接序列号的位数
*/
private static final int COUNT_BITS = 32;
@Resource
private StringRedisTemplate stringRedisTemplate;
/**
* 生成唯一id
*
* @param keyPrefix 业务前缀key
* @return id
*/
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 redis自增长
Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
// 3. 拼接唯一id返回
return timeStamp << COUNT_BITS | count;
}
}
测试
@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);
}
latch.countDown();
};
long begin = System.currentTimeMillis();
for (int i = 0; i < 300; i++) {
es.submit(task);
}
latch.await();
long end = System.currentTimeMillis();
System.out.println("time = " + (end - begin));
}
countdownlatch
countdownlatch名为信号枪：主要的作用是同步协调在多线程的等待于唤醒问题。
由于程序是异步的，当异步程序没有执行完时，主线程就已经执行完了，然后我们期望的是分线程全部走完之后，主线程再走，所以我们此时需要使用到CountDownLatch。
CountDownLatch 中有两个主要方法：
-
countDown
-
await
await 方法 是阻塞方法，我们担心分线程没有执行完时，main线程就先执行，所以使用await可以让main线程阻塞，那么什么时候main线程不再阻塞呢？当CountDownLatch 内部维护的 变量变为0时，就不再阻塞，直接放行，那么什么时候CountDownLatch 维护的变量变为0 呢，我们只需要调用一次countDown ，内部变量就减少1，我们让分线程和变量绑定， 执行完一个分线程就减少一个变量，当分线程全部走完，CountDownLatch 维护的变量就是0，此时await就不再阻塞，统计出来的时间也就是所有分线程执行完后的时间。
常见的唯一ID生成策略
-
UUID
-
Redis自增
-
snowflake算法
-
数据库自增
-
redis自增ID策略
优惠劵的秒杀下单
正常的下单流程需要判断两点：
-
秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
-
库存是否充足，不足则无法下单
在多线程的情况下，会出现库存超卖问题
库存超卖问题的解决方案
超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：而对于加锁，我们通常有两种解决方案：
乐观锁的关键是，查询时不加锁，在进行数据更新时再进行一次判断。
乐观锁的使用：
乐观锁：会有一个版本号version，每次操作数据会对版本号+1，再提交回数据时，会去校验是否比之前的版本大1 ，如果大1 ，则进行操作成功，这套机制的核心逻辑在于，如果在操作过程中，版本号只比原来大1 ，那么就意味着操作过程中没有人对他进行过修改，他的操作就是安全的，如果不大1，则数据被修改过。
乐观锁解决超卖问题
关键代码
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1")
.eq("voucher_id", voucherId).update().gt("stock",0);
先查询库存信息，这时候不加锁，在进行库存更新时，在更新语句中判断库存值是否大于0。
超卖问题总结：
-
悲观锁：添加同步锁，让线程串行执行
-
优点：简单粗暴
-
缺点：性能一般
-
-
乐观锁：不加锁，在更新时判断是否有其它线程在修改
-
优点：性能好
-
缺点：存在成功率低的问题（如：在使用乐观锁过程中假设100个线程同时都拿到了100的库存，然后大家一起去进行扣减，但是100个人中只有1个人能扣减成功，其他的人在处理时，他们在扣减时，库存已经被修改过了，所以此时其他线程都会失败 ）
-
优惠券秒杀 - 一人一单
需求：要求同一个优惠券，一个用户只能下一单
代码示例
<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);
}
}
@Override
public Result seckillVoucherById(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, userId);
}
}
/**
* 实现一人一单, 关键在于 事务提交之前锁是否释放
* 在多线程的情况下，如果当前方法事务没有提交，但是锁已经释放会出现问题
*
* @param voucherId 消费券id
* @return 订单号
*/
@Transactional
public Result createVoucherOrder(Long voucherId, Long userId) {
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
// 5. 判断是否存在
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();
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
voucherOrder.setUserId(userId);
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);
// 8.返回订单id
return Result.ok(orderId);
}
重点：方法被spring的事务控制，如果你在方法内部加锁，可能会导致当前方法事务还没有提交，但是锁已经释放也会导致问题，所以我们选择将当前方法整体包裹起来，确保事务不会出现问题。
集群环境下的并发问题
在集群模式下，由于现在我们部署了多个tomcat，每个tomcat都有一个属于自己的jvm，那么假设在服务器A的tomcat内部，有两个线程，这两个线程由于使用的是同一份代码，那么他们的锁对象是同一个，是可以实现互斥的。
但是如果现在是服务器B的tomcat内部，又有两个线程，但是他们的锁对象写的虽然和服务器A一样，但是锁对象却不是同一个，所以线程3和线程4可以实现互斥，但是却无法和线程1和线程2实现互斥，这就是 集群环境下，syn锁失效的原因，在这种情况下，我们就需要使用分布式锁来解决这个问题。
标签：实战,return,Redis,ID,voucherId,秒杀,voucher,线程,id From： https://www.cnblogs.com/l12138h/p/16902698.html