• [Redis] Redis实战

    ✨✨个人主页:沫洺的主页

    📚📚系列专栏: 📖 JavaWeb专栏📖 JavaSE专栏 📖 Java基础专栏📖vue3专栏 

                               📖MyBatis专栏📖Spring专栏📖SpringMVC专栏📖SpringBoot专栏

                               📖Docker专栏📖Reids专栏📖MQ专栏📖SpringCloud专栏     

    💖💖如果文章对你有所帮助请留下三连✨✨

    💌RedisTemplate使用Scan 

    1. @SpringBootTest
    2. public class AppTests_Scan {
    3.  
    4.     @Resource(name = "redisTemplate")
    5.     private ValueOperations valueOperations;
    6.  
    7.     @Autowired
    8.     private StringRedisTemplate stringRedisTemplate;
    9.  
    10.     @Test
    11.     void test1() {
    12.         for (int i =1 ;i<11;i++){
    13.             User user = User.builder().name(i+"号张").age(18).build();
    14.             valueOperations.set("user."+i,user);
    15.         }
    16.     }
    17.     
    18. }

    原生的scan用法

    RedisTemplate使用Scan 

    1. @SpringBootTest
    2. public class AppTests_Scan {
    3.  
    4.     @Resource(name = "redisTemplate")
    5.     private ValueOperations valueOperations;
    6.  
    7.     @Autowired
    8.     private StringRedisTemplate stringRedisTemplate;
    9.  
    10.     @Test
    11.     void test1() {
    12.         for (int i =1 ;i<11;i++){
    13.             User user = User.builder().name(i+"号张").age(18).build();
    14.             valueOperations.set("user."+i,user);
    15.         }
    16.     }
    17.     @Test
    18.     void test2(){
    19.         //迭代扫描,指定模糊匹配,预想数量
    20.         ScanOptions scanOptions = ScanOptions.scanOptions().match("user.*").count(3).build();
    21.         //获取游标
    22.         Cursor cursor = stringRedisTemplate.scan(scanOptions);
    23.         while (cursor.hasNext()){
    24.             //获取游标id
    25.             System.out.println(cursor.getCursorId());
    26.             System.out.println(cursor.next());
    27.         }
    28.         cursor.close();
    29.     }
    30. }

    💌模拟多线程并发使用Decrby 

    模拟高并发场景线上购物,多个用户(线程)同时选购某产品,提示库存信息

    先初始化产品库存

    1. @SpringBootTest
    2. class AppTests_DecrBy {
    3.  
    4.     @Resource(name = "redisTemplate")
    5.     private ValueOperations valueOperations;
    6.  
    7.     @Autowired
    8.     private StringRedisTemplate stringRedisTemplate;
    9.     //定义一个产品
    10.     private final static String productKey = "product01";
    11.  
    12.     @Test
    13.     void test1() {
    14.         //设置初始化库存5个
    15.         valueOperations.set(productKey, 5);
    16.     }
    17. }

    不考虑并发的情况下

    1.     @Test
    2.     void test2() throws InterruptedException {
    3.         //获取线程池
    4.         ExecutorService executorService = Executors.newCachedThreadPool();
    5.         //模拟开启10个线程
    6.         for (int i = 1; i <= 10; i++) {
    7.             //开启线程执行
    8.             executorService.execute(() -> {
    9.                 //获取库存
    10.                 Integer qty = valueOperations.get(productKey);
    11.                 //如果库存充足,产品数量就减一
    12.                 if (qty > 0) {
    13.                     qty = qty - 1;
    14.                     //重新设置库存
    15.                     valueOperations.set(productKey, qty);
    16.                     System.out.println(Thread.currentThread().getName() + " 库存充足");
    17.                 } else {
    18.                     System.out.println(Thread.currentThread().getName() + " 库存不足");
    19.                 }
    20.             });
    21.         }
    22.         //防止主线程停止,导致模拟线程不执行
    23.         Thread.sleep(60 * 1000);
    24.     }

    出现问题,明明库存只有5个,10个用户却都提示库存充足

    考虑高并发的情况下 

    使用decrement来保证原子性,解决高并发问题

    1.     @Test
    2.     void test3() throws InterruptedException {
    3.         //获取线程池
    4.         ExecutorService executorService = Executors.newCachedThreadPool();
    5.         //模拟开启10个线程
    6.         for (int i = 1; i <= 10; i++) {
    7.             //开启线程执行
    8.             executorService.execute(() -> {
    9.                 //获取库存
    10.                 Long qty = valueOperations.decrement(productKey, 1);
    11.                 if (qty >= 0) {
    12.                     System.out.println(Thread.currentThread().getName() + " 库存充足");
    13.                 } else {
    14.                     System.out.println(Thread.currentThread().getName() + " 库存不足");
    15.                 }
    16.             });
    17.         }
    18.         //防止主线程停止,导致模拟线程不执行
    19.         Thread.sleep(60 * 1000);
    20.     }

    解决了并发问题但是出现了新的问题,库存量为负数不合理(意思就是某个线程在执行删减库存时,其他线程也在同一时刻去执行,没有保障redis原子性问题)

    有一种解决办法就是通过加锁synchronized来解决,但是响应能力就会大幅降低,也就失去了redis高性能的意义

    所以最好的解决方式就是通过EVAL命令执行Lua脚本来解决这类问题

    💌模拟多线程并发获取分布式锁SetNX

    模拟某一个产品的出入库单据只能一个人(线程)操作的场景(分布式锁),当有人操作时,其他人只能等待该人操作结束之后进行操作

    1. @SpringBootTest
    2. @Slf4j
    3. class AppTests_SetNx {
    4.  
    5.     @Resource(name = "redisTemplate")
    6.     private ValueOperations valueOperations;
    7.  
    8.     @Autowired
    9.     private StringRedisTemplate stringRedisTemplate;
    10.     //定义一个产品
    11.     private final static String productKey = "product01";
    12.     //定义锁
    13.     private final static String lockKey = "lock.1";
    14.  
    15.     //业务
    16.     private void doing(){
    17.         while (true){
    18.             //设置锁
    19.             Boolean b = valueOperations.setIfAbsent(lockKey, 1);
    20.             if(b){
    21.                 log.info(Thread.currentThread().getName() + " 获取到分布式锁");
    22.                 //业务代码开始
    23.                 ThreadUtil.sleep(3000);//模拟执行业务操作用时
    24.                 //业务代码结束
    25.                 stringRedisTemplate.delete(lockKey);
    26.                 log.info(Thread.currentThread().getName() + " 释放分布式锁");
    27.                 break;
    28.  
    29.             } else {
    30.                 //log.info(Thread.currentThread().getName() + " 没有获取到分布式锁,开始睡眠");
    31.                 ThreadUtil.sleep(2000);
    32.             }
    33.         }
    34.     }
    35.  
    36.     @Test
    37.     void test1() {
    38.         //设置初始化库存5个
    39.         valueOperations.set(productKey, 0);
    40.     }
    41.  
    42.     @Test
    43.     void test2() throws InterruptedException {
    44.         //获取线程池
    45.         ExecutorService executorService = Executors.newCachedThreadPool();
    46.         //模拟开启10个线程
    47.         for (int i = 1; i <= 10; i++) {
    48.             //开启线程执行
    49.             executorService.execute(this::doing);
    50.         }
    51.         //防止主线程停止,导致模拟线程不执行
    52.         Thread.sleep(60 * 1000);
    53.     }
    54.  
    55. }

    使用分布式锁模拟用户下单操作,防止恶意并发(一般来说用户下单产品操作时间最少也需要几秒的时间,这里预设5秒),也就是说5秒内只允许下单成功一次,也就解决了恶意并发的问题

    1.     @Test
    2.     void test3() throws InterruptedException {
    3.         String user = "用户1";
    4.         //获取线程池
    5.         ExecutorService executorService = Executors.newCachedThreadPool();
    6.         //模拟开启10个线程
    7.         for (int i = 1; i <= 10; i++) {
    8.             //开启线程执行
    9.             executorService.execute(() -> {
    10.                 Boolean b = valueOperations.setIfAbsent("lock." + user, 1, 5, TimeUnit.SECONDS);
    11.                 if (b) {
    12.                     //下单
    13.                     log.info("{} 下单成功", Thread.currentThread().getName());
    14.                 } else {
    15.                     log.info("{} 稍后再试", Thread.currentThread().getName());
    16.                 }
    17.             });
    18.         }
    19.         //防止主线程停止,导致模拟线程不执行
    20.         Thread.sleep(60 * 1000);
    21.     }

    💌模拟多线程并发访问

    在网关设置防止恶意并发访问,将用户ip作为key,只允许用户ip在短时间内访问2次

    1. package com.moming;
    2.  
    3. import cn.hutool.core.date.DateUtil;
    4. import cn.hutool.core.thread.ThreadUtil;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.junit.jupiter.api.Test;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.boot.test.context.SpringBootTest;
    9. import org.springframework.data.redis.core.StringRedisTemplate;
    10. import org.springframework.data.redis.core.ValueOperations;
    11.  
    12. import javax.annotation.Resource;
    13. import java.util.concurrent.ExecutorService;
    14. import java.util.concurrent.Executors;
    15. import java.util.concurrent.TimeUnit;
    16.  
    17. @SpringBootTest
    18. @Slf4j
    19. class AppTests_Increment {
    20.  
    21.     @Resource(name = "redisTemplate")
    22.     private ValueOperations valueOperations;
    23.  
    24.     @Autowired
    25.     private StringRedisTemplate stringRedisTemplate;
    26.  
    27.     @Test
    28.     void test4() throws InterruptedException {
    29.         //模拟用户ip
    30.         String userIp = "127.0.0.1";
    31.         //获取线程池
    32.         ExecutorService executorService = Executors.newCachedThreadPool();
    33.         //模拟开启10个线程
    34.         for (int i = 1; i <= 10; i++) {
    35.             //开启线程执行
    36.             executorService.execute(() -> {
    37.                 String seconds = DateUtil.format(DateUtil.date(), "yyyyMMddHHmmss");
    38.  
    39.                 String key = seconds + userIp;
    40.  
    41.                 Long count = valueOperations.increment(key, 1);
    42.  
    43.                 if(count>2){
    44.                     //下单
    45.                     log.info("{} 超过请求次数",Thread.currentThread().getName());
    46.                 } else  {
    47.                     log.info("{} 请求正常",Thread.currentThread().getName());
    48.                 }
    49.             });
    50.         }
    51.         //防止主线程停止,导致模拟线程不执行
    52.         Thread.sleep(60 * 1000);
    53.     }
    54.  
    55. }

    💌BitMap模拟在线统计 

    模拟某线上活动要举办3天,参与活动的人员可以线上签到,后台通过3天人员的签到情况,统计信息

    1. 3天满勤人数: 三天都签到才算一位
    2. 3天活跃人数: 任何一天签到都算一位 
    1. @SpringBootTest
    2. class AppTests_BitMap {
    3.  
    4.     @Autowired
    5.     private StringRedisTemplate stringRedisTemplate;
    6.  
    7.     @Test
    8.     public void test2() {
    9.         //2022111 20221112 20221113 三天活动
    10.         //张三 1, 李四 2, 王五:3
    11.         //满勤人数,1人
    12.         //活跃人数,3人
    13.         stringRedisTemplate.opsForValue().setBit("20221111",1,true);
    14.         stringRedisTemplate.opsForValue().setBit("20221112",2,true);
    15.         stringRedisTemplate.opsForValue().setBit("20221112",2,true);
    16.         stringRedisTemplate.opsForValue().setBit("20221111",3,true);
    17.         stringRedisTemplate.opsForValue().setBit("20221112",3,true);
    18.         stringRedisTemplate.opsForValue().setBit("20221113",3,true);
    19.         //RedisStringCommands.BitOperation.AND 满勤人数
    20.         //RedisStringCommands.BitOperation.OR 活跃人数
    21.         RedisCallback callback1 = connection -> {
    22.             connection.bitOp(RedisStringCommands.BitOperation.OR,
    23.                     "人数统计".getBytes(StandardCharsets.UTF_8),
    24.                     "20221111".getBytes(StandardCharsets.UTF_8),
    25.                     "20221112".getBytes(StandardCharsets.UTF_8),
    26.                     "20221113".getBytes(StandardCharsets.UTF_8)
    27.             );
    28.             Long count = connection.bitCount("人数统计".getBytes(StandardCharsets.UTF_8));
    29.             return count;
    30.         };
    31.         Long count1 = stringRedisTemplate.execute(callback1);
    32.         System.out.println(count1);
    33.     }
    34. }

    RedisStringCommands.BitOperation.AND 满勤人数

    RedisStringCommands.BitOperation.OR 活跃人数

  • 相关阅读:
    MyBatis与Spring的集成
    kindediter富文本内容导出html文件
    基于Restful的WebService
    oracle 同一张表同时insert多条数据 mysql 同一张表同时insert多条数据
    SpringBoot集成JWT（极简版）：
    c++day3
    通过python股票接口把数据导入Mysql数据库
    力扣 739. 每日温度
    什么是冲突域，什么是广播域？区别又是什么
    core sound driver详解
  • 原文地址：https://blog.csdn.net/HeyVIrBbox/article/details/127794810