Redis实战篇(二)

news2024/12/29 10:35:18

三、优惠卷秒杀

3.1 全局唯一ID

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

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

  • id的规律性太明显

  • 受单表数据量的限制

场景分析一:如果我们的id具有太明显的规则,用户或者说商业对手很容易猜测出来我们的一些敏感信息,比如商城在一天时间内,卖出了多少单,这明显不合适。

场景分析二:随着我们商城规模越来越大,mysql的单表的容量不宜超过500W,数据量过大之后,我们要进行拆库拆表,但拆分表了之后,他们从逻辑上讲他们是同一张表,所以他们的id是不能一样的, 于是乎我们需要保证id的唯一性。

全局ID生成器,是一种在分布式系统下用来生成全局唯一ID的工具,一般要满足下列特性:

为了增加ID的安全性,可以不直接使用Redis自增的数值,而是拼接一些其它信息:

  • ID的组成部分:符号位:1bit,永远为0
  • 时间戳:31bit,以秒为单位,可以使用69年
  • 序列号:32bit,秒内的计数器,支持每秒产生2^32个不同ID

3.2 Redis实现全局唯一Id

@Component
public class RedisIdWorker {
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int COUNT_BITS = 32;
​
    private StringRedisTemplate stringRedisTemplate;
​
    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
​
    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.拼接并返回
        return timestamp << COUNT_BITS | count;
    }
}

在测试类中进行测试

知识小贴士:关于countdownlatch

countdownlatch名为信号枪:主要的作用是同步协调在多线程的等待与唤醒问题

我们如果没有CountDownLatch ,那么由于程序是异步的,当异步程序没有执行完时,主线程就已经执行完了,然后我们期望的是分线程全部走完之后,主线程再走,所以我们此时需要使用到CountDownLatch

CountDownLatch 中有两个最重要的方法

  • countDown
  • await

await 方法 是阻塞方法,我们担心分线程没有执行完时,main线程就先执行,所以使用await可以让main线程阻塞,那么什么时候main线程不再阻塞呢?当CountDownLatch 内部维护的 变量变为0时,就不再阻塞,直接放行,那么什么时候CountDownLatch 维护的变量变为0 呢,我们只需要调用一次countDown ,内部变量就减少1,我们让分线程和变量绑定, 执行完一个分线程就减少一个变量,当分线程全部走完,CountDownLatch 维护的变量就是0,此时await就不再阻塞,统计出来的时间也就是所有分线程执行完后的时间。

@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();
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }
    latch.await();
    long end = System.currentTimeMillis();
    System.out.println("time = " + (end - begin));
}

3.3 添加优惠卷

每个店铺都可以发布优惠券,分为平价券和特价券。平价券可以任意购买,而特价券需要秒杀抢购:

tb_voucher:优惠券的基本信息,优惠金额、使用规则等

tb_seckill_voucher:优惠券的库存、开始抢购时间,结束抢购时间。特价优惠券才需要填写这些信息

平价卷由于优惠力度并不是很大,所以是可以任意领取

而代金券由于优惠力度大,所以像第二种券,就得限制数量,从表结构上也能看出,特价卷除了具有优惠卷的基本信息以外,还具有库存,抢购时间,结束时间等字段

新增普通卷代码: VoucherController

@PostMapping
public Result addVoucher(@RequestBody Voucher voucher) {
    voucherService.save(voucher);
    return Result.ok(voucher.getId());
}

新增秒杀卷代码:

VoucherController

@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
    voucherService.addSeckillVoucher(voucher);
    return Result.ok(voucher.getId());
}

VoucherServiceImpl

@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);
    // 保存秒杀库存到Redis中
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
}

3.4 实现秒杀下单

下单核心思路:当我们点击抢购时,会触发右侧的请求,我们只需要编写对应的controller即可

下单核心逻辑分析:

当用户开始进行下单,我们应当去查询优惠卷信息,查询到优惠卷信息,判断秒杀是否开始或结束,如果尚未开始或已经结束则无法下单,如果时间充足,则进一步判断库存是否足够,不足则无法下单,如果两者都满足,则扣减库存,创建订单,然后返回订单id,如果有一个条件不满足则直接结束。

VoucherOrderServiceImpl

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

3.5 库存超卖问题分析

有关超卖问题分析:在我们原有代码中是这么写的,这么写是存在线程安全问题的

 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("库存不足!");
    }

为什么会有线程安全:假设线程1过来查询库存,判断出来库存大于1,正准备去扣减库存,但是还没有来得及去扣减,此时线程2过来,线程2也去查询库存,发现这个数量一定也大于1,那么这两个线程都会去扣减库存,最终多个线程相当于一起去扣减库存,此时就会出现库存的超卖问题。

超卖问题是典型的多线程安全问题,针对这一问题的常见解决方案就是加锁:而对于加锁,我们通常有如下图所示的两种解决方案:

悲观锁:悲观锁可以实现对于数据的串行化执行,比如 syn,lock 都是悲观锁的代表。同时,悲观锁中又可以再细分为公平锁,非公平锁,可重入锁,等等。

乐观锁:乐观锁会有一个版本号,每次操作数据会对版本号+1,再提交回数据时,会去校验是否比之前的版本大1 ,如果大1 ,则进行操作成功,这套机制的核心逻辑在于,如果在操作过程中,版本号只比原来大1 ,那么就意味着操作过程中没有其它线程对数据进行过修改,他的操作就是安全的,如果不大1,则数据被修改过,当然乐观锁还有一些变种的处理方式比如 cas,cas是乐观锁的典型代表。

3.6 乐观锁解决超卖问题

3.6.1 版本号法解决超卖问题

首先,需要在数据库的表中加一个版本号字段,在操作时,首先对版本号进行+1 操作,然后要求version 如果是1 的情况下,才能操作,那么第一个线程在操作后,数据库中的version变成了2,但是他自己满足version=1 ,所以没有问题,此时线程2执行,线程2 最后也需要加上条件version =1 ,但是现在由于线程1已经操作过了,所以线程2,操作时就不满足version=1 的条件了,所以线程2无法执行成功

3.6.2 cas法解决超卖问题

项目中采用的CAS法解决的超卖问题。此处的CAS法好像是变化过的

修改代码方案一

VoucherOrderServiceImpl 在扣减库存时,改为:

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个线程同时都拿到了100的库存,然后大家一起去进行扣减,但是100个人中只有1个人能扣减成功,其他的人在处理时,他们在扣减时,库存已经被修改过了,所以此时其他线程都会失败

修改代码方案二

之前的方式要修改前后都保持一致,但是这样我们分析过,成功的概率太低,所以我们的乐观锁需要变一下,改成 stock 大于 0 即可

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

3.7 优惠券秒杀:一人一单

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

现在的问题在于:

优惠卷是为了引流,但是目前的情况是,一个人可以无限制的抢这个优惠卷,所以我们应当增加一层逻辑,让一个用户只能下一个单,而不是让一个用户下多个单

具体操作逻辑如下:比如时间是否充足,如果时间充足,则进一步判断库存是否足够,然后再根据优惠卷id和用户id查询是否已经下过这个订单,如果下过这个订单,则不再下单,否则进行下单

初步代码:增加一人一单逻辑

在 VoucherOrderServiceImpl 中添加 seckillVoucher 方法


@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.一人一单
    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 = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId).update();
    if (!success) {
        //扣减库存
        return Result.fail("库存不足!");
    }
    //7.创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 7.1.订单id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
​
    voucherOrder.setUserId(userId);
    // 7.3.代金券id
    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);
​
    return Result.ok(orderId);
​
}

存在问题:上述代码中存在线程安全问题,并发过来,查询数据库,都不存在订单,会导致一个订单重复插入数据库,所以我们还是需要加锁,但是乐观锁适合更新数据,而现在是插入数据,所以我们需要使用悲观锁操作

        首先初始方案是抽取上述 seckillVoucher 方法中第五步及第五步之后的逻辑,封装成一个createVoucherOrder 方法,并在 seckillVoucher 方法中将抽取的代码替换为如下代码进行调用。

Long userId = UserHolder.getUser().getId();
return createVoucherOrder(voucherId);

同时为了解决线程安全问题,需要在createVoucherOrder 方法上添加一把 synchronized 锁

@Transactional
public synchronized 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 = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and 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);
​
        // 7.返回订单id
        return Result.ok(orderId);
}

但是这样添加锁,锁的粒度太粗了,在使用锁过程中,控制 锁粒度 是一个非常重要的事情,因为如果锁的粒度太大,会导致每个线程进来都会锁住,所以我们需要去控制锁的粒度,以上这段代码需要修改为:

@Transactional
public  Result createVoucherOrder(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        synchronized(userId.toString().intern()){
         // 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 = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and 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);
​
        // 7.返回订单id
        return Result.ok(orderId);
    }
}

注意:intern() 这个方法是从常量池中拿到数据,如果我们直接使用userId.toString() 他拿到的对象实际上是不同的对象,new出来的对象,我们使用锁必须保证锁必须是同一把,所以我们需要使用intern()方法

但是以上代码还是存在问题,问题的原因在于当前方法被 spring 的事务控制,如果你在方法内部加锁,可能会导致当前方法事务还没有提交,但是锁已经释放也会导致问题,所以我们选择将当前方法整体包裹起来,确保事务不会出现问题:如下: 

在 seckillVoucher 方法中,进行如下所示的修改,这样就能保证事务的特性,同时也控制了锁的粒度

Long userId = UserHolder.getUser().getId();
synchronized (userId.toString().intern()) { 
    return this.createVoucherOrder(voucherId);
}

但是以上做法依然有问题,因为你调用的方法,其实是this.的方式调用的,事务想要生效,还得利用代理来生效,所以这个地方,我们需要获得原始的事务对象, 来操作事务

//锁解决单体项目中的并发安全
Long userId = UserHolder.getUser().getId();
//intern()方法保证每次请求与字符串userId.toString()对应的对象地址是同一个
synchronized (userId.toString().intern()) {  
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
}

最终代码如下所示,注意此代码中加的锁只能在单体项目中解决并发安全问题:

VoucherOrderServiceImpl

 @Override
    public Result seckillVoucher(Long voucherId) {
        //1.查询秒杀优惠券信息
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);

        //2.判断秒杀是否已经开始
        LocalDateTime endTime = seckillVoucher.getEndTime();
        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();
        //intern()方法保证每次请求与字符串userId.toString()对应的对象地址是同一个
        synchronized (userId.toString().intern()) {  
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }

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

        //6.库存减一,此处应用到了乐观锁解决超卖问题
        boolean sussess = iSeckillVoucherService.update()
                          .setSql("stock = stock - 1")
                          .eq("voucher_id", voucherId).gt("stock", 0).update();
        if (!sussess) {
            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);
    }

3.8 集群环境下的并发问题

通过加锁可以解决在单机情况下的一人一单安全问题,但是在集群模式下就不行了。

1.在集群模式下测试锁的有效性

第一步:我们将服务以debug的方式启动两份,端口分别为8081和8082:

第二步:然后修改nginx的conf目录下的nginx.conf文件,配置反向代理和负载均衡:

第三步:对 synchronized 内的代码打上断点,并在postman中用同一个用户分别向二个服务器发送请求,会发现这二个请求都能进入到锁内部。因此,上述加的锁在分布式环境或集群模式下无效。

2.有关锁失效原因分析

        由于现在我们部署了多个tomcat,每个tomcat都有一个属于自己的jvm,那么假设在服务器A的tomcat内部,有两个线程,这两个线程由于使用的是同一份代码,那么他们的锁对象是同一个,是可以实现互斥的,但是如果现在是服务器B的tomcat内部,又有两个线程,但是他们的锁对象写的虽然和服务器A一样,但是锁对象却不是同一个,所以线程3和线程4可以实现互斥,但是却无法和线程1和线程2实现互斥,这就是 集群环境下,syn锁失效的原因,在这种情况下,我们就需要使用分布式锁来解决这个问题。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/706170.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

初学mybatis(二)CRUD操作及配置解析

学习回顾&#xff1a;初学mybatis&#xff08;一&#xff09; 一、namespace 1、将上面案例中的UserMapper接口改名为 UserDao&#xff1b;2、将UserMapper.xml中的namespace改为为UserDao的路径 .3、再次测试 结论&#xff1a; 配置文件中namespace中的名称为对应Mapper接口或…

Python基本操作

前言 啦啦啦&#xff0c;现在开始,打算做一期Python基础教程&#xff0c;欢迎大家来看哦&#xff01; 导读 这期文章真的是Python基础中的基础&#xff0c;相信有一定编程基础的小伙伴们都一定能看懂的… 本文共分为以下几个部分&#xff1a; 数与运算符基本输入输出注释模…

Linux环境安装openJDK

现在越来越多的开发者使用 openJDK &#xff0c;当然这也是一种趋势 官网下载&#xff1a; https://jdk.java.net/java-se-ri/8-MR5这里以 jdk8 为例 配置环境变量 看网上的教程&#xff0c;好多人都推荐去这个官网下载&#xff1a; https://hg.openjdk.org/其实这个是 O…

算法笔记——数组篇

整理一下刷过的题型&#xff0c;持续更新&#xff0c;参照代码随想录 代码随想录数组篇 二分法 力扣相关题目&#xff1a; 704. 二分查找 只适用于排序有序数组&#xff0c;且没有重复元素。主要是有两种写法&#xff0c;二分查找涉及的很多的边界条件&#xff0c;逻辑比较简单…

V-Box智能车载终端-OBUYZN2

1 产品概览 OBUYZN2型智能车载终端&#xff08;以下简称&#xff09;是 型智能车载终端&#xff08;以下简称&#xff09;是 型智能车载终端&#xff08;以下简称&#xff09;是 型智能车载终端&#xff08;以下简称&#xff09;是 组成智能网联 系统 的核心数据交互设备 &…

Java 顶层类(top-level class)的访问控制修饰符

在Java中&#xff0c;处于最外层的类就是顶层类&#xff08;top-level class&#xff09;&#xff0c;类的声明外面再没有其它的类包裹。 顶层类的访问控制修饰符只能是public、或者包访问控制修饰符&#xff08;也就是无访问控制修饰符&#xff09;。 访问控制修饰符访问范围…

用codetyphon开发一个单机版跨平台数据处理小软件

目录 1 前言 2 一种可能的方案 2.1 数据存储使用dbf格式 2.2 用Lazarus或CT开发 2.3 根据外部csv或者excel电子表格快速建表 2.4 用python汇总和审核 3 当前进度 3.1 根据excel电子表格快速自动建表和导入数据 3.2 显示数据 3.3 建立测试数据库 1 前言 现在各种现成的…

Vue天气案例

绑定事件的时候&#xff1a;xxx"yyy" yyy可以写一些简单的语句。 <body><div id"root"><h2>今天天气很{{info}}</h2><button click"changeWether">切换天气</button></div> </body><scr…

HBase-问题

最终理解HBase数据模型的关键在于稀疏、分布式、多维、排序的映射。其中映射map指代非关系型数据库的key-Value结构。 1.怎么理解稀疏&#xff1f; 不同的行有不同的列&#xff0c;这就叫稀疏 有的行有3个列&#xff0c;有的行有2个列&#xff0c;那么2个列的在显示的时候&a…

Unity之穿山甲SDK

SDK版本相关问题官网解答记录: 官网咨询工单地址记录&#xff1a; https://www.csjplatform.com/athena/user-feedback/order/list?identify_keycb790ca553ed7253d29a4dbd4041281b62c449f55d6faaeb4e744370c9b34e38&init_id652798&order_id652798

解决AntvX6的阴影残留

问题描述&#xff1a;在使用antVX6的过程中&#xff0c;有时候重选渲染会出现阴影残留。 解决&#xff1a; 每次重新渲染画布时&#xff0c;使用 clearCells API清除一下画布即可解决。 ... const graph new Graph({container: document.getElementById("app"),w…

高性能分布式缓存Redis(二) 高级应用

一、持久化原理 持久化 Redis是内存数据库&#xff0c;数据都是存储在内存中&#xff0c;为了避免进程退出导致数据的永久丢失&#xff0c;需要定期将Redis中的数据以某种形式(数据或命令)从内存保存到硬盘&#xff1b;当下次Redis重启时&#xff0c;利用持久化文件实现数据恢…

UE4/5数字人Metahuman与Style3D的使用【一、Style3DAtelier软件制作smd格式衣服并导入ue】

目录 软件和插件下载 安装软件Style3DAtelier 放入插件 布料模拟制作&#xff1a; 导出人物 &#xff1a; 数字人与小白人 Style3D添加衣服&#xff1a; 导入小白人或数字人&#xff1a; 身高修改&#xff1a; uv调整 模拟查看情况&#xff1a; 导出smd格式&#x…

0. 开篇词 —— 风物长宜放眼量

个人简介 我是一名工作了6年的 Java 工程师&#xff0c;日常主要工作就是业务功能开发&#xff0c;但是业余时间喜欢研究一些开源框架和流行的技术。我本人是经典 ORM 框架 MyBatis 的 Contributor&#xff0c;同时也是微服务框架 Nacos 的核心 Contributor 和 gorm 的Contrib…

GPT3学习笔记

GPT-3概述 关于GPT-3的主要事实: 模型分类:GPT-3有8个不同的模型&#xff0c;参数从1.25亿到1750亿不等。 模型大小:最大的GPT-3模型有1750亿参数。这比最大的BERT模型大470倍(3.75亿个参数) 体系结构:GPT-3是一种自回归模型&#xff0c;使用仅有解码器的体系结构。使用下一…

mac ppt设置起始页码

今天发现我的ppt的左边ppt的缩略图的开始页码是从2开始的&#xff0c;觉得很奇怪&#xff0c;这个解决的办法就是 点击ppt->文件->页面设置->页眉和页脚->幻灯片编号

chatgpt赋能python:用Python自动化办公:优化SEO的关键

用Python自动化办公&#xff1a;优化SEO的关键 随着互联网的快速发展和人们对搜索引擎的依赖加深&#xff0c;SEO&#xff08;搜索引擎优化&#xff09;这个概念也逐渐受到人们的关注。SEO可以帮助网站排名更高&#xff0c;吸引更多的访客并提高转化率&#xff0c;成为了许多企…

直接在Notepad++中运行GO语言-(通过NppExec插件)

前提条件&#xff1a; 1.建议阅读文章【直接在Notepad中运行GO语言】&#xff1a; 直接在Notepad中运行GO语言_go语言 notepad_西晋的no1的博客-CSDN博客 2.建议阅读文章【notepad 中安装NppExec插件】&#xff1a; notepad 中安装NppExec插件_西晋的no1的博客-CSDN博客 以下…

九、DockerFile解析

学习参考&#xff1a;尚硅谷Docker实战教程、Docker官网、其他优秀博客(参考过的在文章最后列出) 目录 前言一、DockerFile介绍二、DockerFile构建过程解析2.1 Dockerfile内容基础知识2.2 Docker执行Dockerfile的大致流程2.3 Dockerfile、Docker镜像与Docker容器关系 三、Docke…

基于51单片机的数码管密码锁

基于51单片机的数码管密码锁是一种可以设置密码并通过输入密码来解锁的安全装置。该密码锁使用51单片机作为控制主板&#xff0c;配合数码管显示模块、按键模块和电磁锁等元件实现密码锁的功能。 实现步骤如下&#xff1a; 1. 硬件连接&#xff1a;将51单片机与数码管、按键模…