• Redis 分布式锁

    ce分布式锁原理：占用公共访问的地方redis或mysql,先到先得，后到要等。

     * 1.双写模式：修改数据库数据同时，也修改redis缓存数据，存在问题，网络交互或者cpu处理速度的差异，并发修改会产生脏数据

    * 2.失效模式：修改数据同时删除缓存数据，等待下次主动查询更新缓存

    * 思考：如何保证缓存数据与数据库同步，保持一致？要加读写锁；缓存数据本就不应该是实时性，一致性超高的，要求实时性，一致性超高的数据，直接去查数据，简化系统。

    1. package com.hmdp.utils;
    2.  
    3. import com.fasterxml.jackson.core.type.TypeReference;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.apache.commons.lang3.StringUtils;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.beans.factory.annotation.Value;
    8. import org.springframework.cloud.context.config.annotation.RefreshScope;
    9. import org.springframework.data.redis.core.BoundValueOperations;
    10. import org.springframework.data.redis.core.StringRedisTemplate;
    11. import org.springframework.data.redis.core.script.DefaultRedisScript;
    12. import org.springframework.stereotype.Component;
    13.  
    14. import java.time.LocalDateTime;
    15. import java.util.Collections;
    16. import java.util.Map;
    17. import java.util.UUID;
    18. import java.util.concurrent.TimeUnit;
    19. import java.util.function.Function;
    20.  
    21. /**
    22.  * User: ldj
    23.  * Date: 2022/9/3
    24.  * Time: 16:55
    25.  * Description: Redis分布锁工具类,目前没有做续机,所以过期时间调大一点，确保业务执行完成
    26.  * 定时任务进行锁续命
    27.  */
    28. @Slf4j
    29. @Component
    30. @RefreshScope
    31. public class RedisUtil {
    32.  
    33.     private static Integer shortTime;
    34.     private static Long expiredTime;
    35.  
    36.     private static StringRedisTemplate stringRedisTemplate;
    37.  
    38.     @Value("${redis.lock.expiredTime:60}")
    39.     public void setExpiredTime(Long expiredTime) {
    40.         RedisUtil.expiredTime = expiredTime;
    41.     }
    42.  
    43.     @Value("${redis.lock.shortTime:10}")
    44.     public void setExpiredTime(Integer shortTime) {
    45.         RedisUtil.shortTime = shortTime;
    46.     }
    47.  
    48.     @Autowired
    49.     public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
    50.         RedisUtil.stringRedisTemplate = stringRedisTemplate;
    51.     }
    52.  
    53.     //避免因线程1执行业务很长，lock1过期了，线程2进来创建lock2，当线程2执行到一半时，线程1执行完业务释放锁是lock2
    54.     private static String uuid;
    55.  
    56.     //获取锁+设置过期时间 原子性
    57.     public static Boolean getLock() {
    58.         uuid = UUID.randomUUID().toString().replaceAll("-", "");
    59.         Boolean isLock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid, expiredTime, TimeUnit.SECONDS);
    60.         if (isLock != null && isLock) {
    61.             log.info("[Redis] 添加锁成功 releaseUuid:[{}]", uuid);
    62.             return true;
    63.         } else {
    64.             log.warn("[Redis] 添加锁失败!");
    65.             return false;
    66.         }
    67.     }
    68.  
    69.     //释放锁+获取对比值  原子性
    70.     public static void releaseLock() {
    71.         String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
    72.         Long flag = stringRedisTemplate.execute(new DefaultRedisScript(luaScript, Long.class), Collections.singletonList("lock"), uuid);
    73.         if (flag != null && flag == 1) {
    74.             log.info("[Redis] 释放锁成功 releaseUuid:[{}]", uuid);
    75.         } else {
    76.             log.warn("[Redis] 释放锁失败!");
    77.         }
    78.     }
    79.  
    80.     //设置等待重试时间
    81.     public static void waite(Long waitTime) {
    82.         try {
    83.             TimeUnit.MILLISECONDS.sleep(waitTime);
    84.         } catch (InterruptedException e) {
    85.             log.error("等待异常", e);
    86.         }
    87.     }
    88.  
    89.     //删除key
    90.     public static Boolean removeKey(String key) {
    91.         return stringRedisTemplate.delete(key);
    92.     }
    93.  
    94.     public static void put(String redisKey, Object object, Integer expireTime) {
    95.         if (expireTime != null) {
    96.             stringRedisTemplate.opsForValue().set(redisKey, JacksonUtil.writeValueAsString(object), expireTime, TimeUnit.MINUTES);
    97.         }
    98.         stringRedisTemplate.opsForValue().set(redisKey, JacksonUtil.writeValueAsString(object));
    99.     }
    100.  
    101.     public static void putWithLogicalExpire(String redisKey, Object object, Integer time) {
    102.         RedisData redisData = new RedisData();
    103.         redisData.setData(object);
    104.         redisData.setExpireTime(LocalDateTime.now().plusMinutes(time));
    105.         stringRedisTemplate.opsForValue().set(redisKey, JacksonUtil.writeValueAsString(redisData));
    106.     }
    107.  
    108.     public static  T getValue(String key, Class classType) {
    109.         String context = stringRedisTemplate.opsForValue().get(key);
    110.         if (StringUtils.isBlank(context)) {
    111.             return null;
    112.         }
    113.         return JacksonUtil.readValue(context, classType);
    114.     }
    115.  
    116.     public static  T getValue(String key, TypeReference valueTypeRef) {
    117.         String context = stringRedisTemplate.opsForValue().get(key);
    118.         if (StringUtils.isBlank(context)) {
    119.             return null;
    120.         }
    121.         return JacksonUtil.readValue(context, valueTypeRef);
    122.     }
    123.  
    124.     public static  R queryAndSet(String key, long expiredTime, Map map, TypeReference valueTypeRef, Function, R> callback) {
    125.         BoundValueOperations operations = stringRedisTemplate.boundValueOps(key);
    126.         String context = operations.get();
    127.         if (StringUtils.isNotBlank(context)) {
    128.             return JacksonUtil.readValue(context, valueTypeRef);
    129.         }
    130.  
    131.         // ""或" "
    132.         if (context != null) {
    133.             return null;
    134.         }
    135.  
    136.         //如果为null
    137.         Boolean lock = RedisUtil.getLock();
    138.         if (lock) {
    139.             try {
    140.                 R r = callback.apply(map);
    141.                 if (r == null) {
    142.                     operations.set("", shortTime, TimeUnit.SECONDS);
    143.                     return null;
    144.                 }
    145.                 operations.set(JacksonUtil.writeValueAsString(r), expiredTime, TimeUnit.MINUTES);
    146.                 return r;
    147.             } catch (Exception e) {
    148.                 log.error(e.getMessage());
    149.             } finally {
    150.                 RedisUtil.releaseLock();
    151.             }
    152.         }
    153.         //抢不到锁,重试
    154.         return queryAndSet(key, expiredTime, map, valueTypeRef, callback);
    155.     }
    156.  
    157. }

     改进 能获取多个分布式锁:

    1. package com.tulin.lock.utils;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.data.redis.core.script.DefaultRedisScript;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import java.time.LocalDateTime;
    11. import java.time.ZoneOffset;
    12. import java.time.format.DateTimeFormatter;
    13. import java.util.Collections;
    14. import java.util.UUID;
    15. import java.util.concurrent.TimeUnit;
    16.  
    17. /**
    18.  * User: ldj
    19.  * Date: 2022/10/19
    20.  * Time: 14:54
    21.  * Description: No Description
    22.  */
    23. @Slf4j
    24. @Component
    25. public class RedisDistributedLockUtil {
    26.  
    27.     private static final String LOCK_PREFIX = "look:";
    28.     private static final Integer LEFT_SHIFT_BITS = 32;
    29.     private static final Long BEGIN_TIMESTAMP = 1672531200L;
    30.  
    31.     private static Long expiredTime;
    32.     private static StringRedisTemplate stringRedisTemplate;
    33.  
    34.     @Value("${redis.lock.expiredTime:60}")
    35.     public void setExpiredTime(Long expiredTime) {
    36.         RedisDistributedLockUtil.expiredTime = expiredTime;
    37.     }
    38.  
    39.     @Autowired
    40.     public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
    41.         RedisDistributedLockUtil.stringRedisTemplate = stringRedisTemplate;
    42.     }
    43.  
    44.     //避免因线程1执行业务很长，lock1过期了，线程2进来创建lock2，当线程2执行到一半时，线程1执行完业务释放锁是lock2
    45.     private static String uuid;
    46.  
    47.     //获取锁+设置过期时间 原子性
    48.     public static Boolean getLock(String lockName) {
    49.         uuid = UUID.randomUUID().toString().replaceAll("-", "");
    50.         Boolean isLock = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_PREFIX + lockName, uuid, expiredTime, TimeUnit.SECONDS);
    51.         if (isLock != null && isLock) {
    52.             log.info("[Redis] 添加锁成功 lockName:[{}],releaseUuid:[{}]", lockName, uuid);
    53.             return true;
    54.         } else {
    55.             log.warn("[Redis] 添加锁失败! lockName:[{}]", lockName);
    56.             return false;
    57.         }
    58.     }
    59.  
    60.     //释放锁+获取对比值  原子性
    61.     public static void releaseLock(String lockName) {
    62.         String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
    63.         Long flag = stringRedisTemplate.execute(new DefaultRedisScript(luaScript, Long.class), Collections.singletonList(LOCK_PREFIX + lockName), uuid);
    64.         if (flag != null && flag == 1) {
    65.             log.info("[Redis] 释放锁成功  lockName:[{}],releaseUuid:[{}]", lockName, uuid);
    66.         } else {
    67.             log.warn("[Redis] 释放锁失败! lockName:[{}]", lockName);
    68.         }
    69.     }
    70.  
    71.     //设置等待重试时间
    72.     public static void waite(Long waitTime) {
    73.         try {
    74.             TimeUnit.MILLISECONDS.sleep(waitTime);
    75.         } catch (InterruptedException e) {
    76.             log.error("等待异常", e);
    77.         }
    78.     }
    79.  
    80.     public static long getGlobalId(String prefix) {
    81.         //生成时间戳
    82.         LocalDateTime now = LocalDateTime.now();
    83.         long nowSeconds = now.toEpochSecond(ZoneOffset.UTC);
    84.         long timestamp = nowSeconds - BEGIN_TIMESTAMP;
    85.         //生成32位id
    86.         String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
    87.         Long increment = stringRedisTemplate.opsForValue().increment(prefix + ":" + date);
    88.         //拼接时间戳 或运算同时为0才是0,有1肯定是1
    89.         if (increment == null) {
    90.             return 0L;
    91.         }
    92.         return timestamp << LEFT_SHIFT_BITS | increment;
    93.     }
    94.  
    95. }

    测试类 

    1.     @Test
    2.     public void test4() {
    3.         Boolean lock = RedisUtil.getLock();
    4.         System.out.println(lock);
    5.     }
    6.  
    7.     @Test
    8.     public void test5() {
    9.         RedisUtil.releaseLock();
    10.     }
    11.  
    12.     @Test
    13.     public void test6() {
    14.         Boolean lock = RedisUtil.getLock();
    15.         System.out.println(lock);
    16.         RedisUtil.releaseLock();
    17.     }

    1. /**
    2.      * 2.从数据库获取数据并封装，加Redis锁、
    3.      * 加锁和设置过期时间是原子操作，避免因业务代码出现异常导致死锁
    4.      * 获取值对比和删除锁是原子操作，避免因与redis网络交互完数据，key恰好过期,删掉别的线程的锁 使用lua脚本操作解锁
    5.      */
    6.     public Map> getDataWithRedisLock() {
    7.         //1.加锁成功（加过期时间）->执行业务->释放锁
    8.         Boolean lock = RedisUtil.getLock();
    9.         if (lock != null && lock) {
    10.             Map> dataFromDb;
    11.             try {
    12.                 dataFromDb = this.getDataFromDb();
    13.             } finally {
    14.                 RedisUtil.deleteLock();
    15.             }
    16.  
    17.             return dataFromDb;
    18.         } else {
    19.             //2.加锁失败->休眠3秒后重试加锁
    20.             RedisUtil.waite(3);
    21.             return this.getDataWithRedisLock();
    22.         }
    23.     }
    1.     @GetMapping("/{id}")
    2.     public Result queryAndSetTest(@PathVariable("id") Long id) {
    3.         String redisKey = RedisConstant.REDIS_SHOP_DOUBLE_PREFIX + id;
    4.         Map map = new HashMap<>();
    5.         map.put("id", id);
    6.         Shop shop = RedisUtil.queryAndSet(redisKey, 30, map, new TypeReference() {
    7.         }, invoke -> shopService.lambdaQuery().eq(Shop::getId, invoke.get("id")).one());
    8.  
    9.         if (shop == null) {
    10.             return Result.fail("404:店铺不存在!");
    11.         }
    12.         return Result.ok(shop);
    13.     }

  • 相关阅读:
    国产内存强势崛起，光威龙武挑战D5内存24×2新标杆
    互联网公司的组织结构与产品经理岗位职责是什么？
    阿里的三个「价值支点」
    一文能读懂车载与Android的关系
    什么是软件测试？
    我的驾照考试笔记（2）
    MySQL关于between and 和 大于等于＞= 小于等于＜= 区别
    类EMD的“信号分解方法”及MATLAB实现（第九篇）——小波包变换（WPT）/小波包分解（WPD）
    为什么 C# 访问 null 字段会抛异常？
    Node.js与npm版本比对
  • 原文地址：https://blog.csdn.net/dj1955/article/details/126680609