Redis分布式锁在实际项目中使用的样例

其他 2021-01-25 10:15:37 阅读次数: 0

目录

1.pom文件添加依赖：

2.redis锁编码

3.redis客户端操作编码：

4.使用redis锁代码：

直接上代码：

1.pom文件添加依赖：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.20.RELEASE</version>
</dependency>

2.redis锁编码

package com.aep.aep.wcpservice.util;


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
 * Explain:Redis分布式锁
 */
@Component
@Slf4j
public class RedisLock {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 加锁
     * @param key 唯一标志
     * @param value  当前时间+超时时间 也就是时间戳
     * @return
     */
    public boolean lock(String key,String value){
        if(stringRedisTemplate.opsForValue().setIfAbsent(key,value)){//对应setnx命令
            //可以成功设置,也就是key不存在
            return true;
        }

        //判断锁超时 - 防止原来的操作异常，没有运行解锁操作  防止死锁
        String currentValue = stringRedisTemplate.opsForValue().get(key);
        //如果锁过期
        if(!StringUtils.isEmpty(currentValue) && Long.parseLong(currentValue) < System.currentTimeMillis()){//currentValue不为空且小于当前时间
            //获取上一个锁的时间value
            String oldValue =stringRedisTemplate.opsForValue().getAndSet(key,value);//对应getset，如果key存在

            //假设两个线程同时进来这里，因为key被占用了，而且锁过期了。获取的值currentValue=A(get取的旧的值肯定是一样的),两个线程的value都是B,key都是K.锁时间已经过期了。
            //而这里面的getAndSet一次只会一个执行，也就是一个执行之后，上一个的value已经变成了B。只有一个线程获取的上一个值会是A，另一个线程拿到的值是B。
            if(!StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue) ){
                //oldValue不为空且oldValue等于currentValue，也就是校验是不是上个对应的商品时间戳，也是防止并发
                return true;
            }
        }
        return false;
    }


    /**
     * 解锁
     * @param key
     * @param value
     */
    public void unlock(String key,String value){
        try {
            String currentValue = stringRedisTemplate.opsForValue().get(key);
            if(!StringUtils.isEmpty(currentValue) && currentValue.equals(value) ){
                stringRedisTemplate.opsForValue().getOperations().delete(key);//删除key
            }
        } catch (Exception e) {
            log.error("[Redis分布式锁] 解锁出现异常了，{}",e);
        }
    }
}

3.redis客户端操作编码：

package com.aep.aep.wcpservice.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Component;

import java.util.Set;
import java.util.concurrent.TimeUnit;


@Slf4j
@Component
public class RedisClient {

  @Autowired
  private StringRedisTemplate template;

  /**
   * 插入键值对
   * @param key   键
   * @param value 值
   */
  public void set(String key, String value) {
    ValueOperations<String, String> ops = template.opsForValue();
    ops.set(key, value);
  }

  /**
   * 插入键值对并设置超时时间
   * @param key    键
   * @param value  值
   * @param time 过期时间, 单位 秒
   */
  public void set(String key, String value, long time) {
    if (time < 1) {
      log.error("过期时间不能小于1");
      return;
    }
    template.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  }

  /**
   * 获取值
   * @param key 键
   * @return 值
   */
  public String get(String key) {
    ValueOperations<String, String> ops = template.opsForValue();
    return ops.get(key);
  }

  /**
   * 判断key是否存在
   * @return true存在 false不存在
   */
  public boolean hasKey(String key) {
    try {
      return template.hasKey(key);
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**------------------zSet相关操作--------------------------------*/

  /**
   * 添加元素,有序集合是按照元素的score值由小到大排列
   *
   * @param key
   * @param value
   * @param score
   * @return
   */
  public Boolean zAdd(String key, String value, double score) {
    return template.opsForZSet().add(key, value, score);
  }

  /**
   *
   * @param key
   * @param values
   * @return
   */
  public Long zAdd(String key, Set<TypedTuple<String>> values) {
    return template.opsForZSet().add(key, values);
  }

  /**
   *
   * @param key
   * @param values
   * @return
   */
  public Long zRemove(String key, Object... values) {
    return template.opsForZSet().remove(key, values);
  }

  /**
   * 增加元素的score值，并返回增加后的值
   *
   * @param key
   * @param value
   * @param delta
   * @return
   */
  public Double zIncrementScore(String key, String value, double delta) {
    return template.opsForZSet().incrementScore(key, value, delta);
  }

  /**
   * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
   *
   * @param key
   * @param value
   * @return 0表示第一位
   */
  public Long zRank(String key, Object value) {
    return template.opsForZSet().rank(key, value);
  }

  /**
   * 返回元素在集合的排名,按元素的score值由大到小排列
   *
   * @param key
   * @param value
   * @return
   */
  public Long zReverseRank(String key, Object value) {
    return template.opsForZSet().reverseRank(key, value);
  }

  /**
   * 获取集合的元素, 从小到大排序
   *
   * @param key
   * @param start
   *            开始位置
   * @param end
   *            结束位置, -1查询所有
   * @return
   */
  public Set<String> zRange(String key, long start, long end) {
    return template.opsForZSet().range(key, start, end);
  }

  /**
   * 获取集合元素, 并且把score值也获取
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<TypedTuple<String>> zRangeWithScores(String key, long start,  long end) {
    return template.opsForZSet().rangeWithScores(key, start, end);
  }

  /**
   * 根据Score值查询集合元素
   *
   * @param key
   * @param min
   *            最小值
   * @param max
   *            最大值
   * @return
   */
  public Set<String> zRangeByScore(String key, double min, double max) {
    return template.opsForZSet().rangeByScore(key, min, max);
  }

  /**
   * 根据Score值查询集合元素, 从小到大排序
   *
   * @param key
   * @param min
   *            最小值
   * @param max
   *            最大值
   * @return
   */
  public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,double min, double max) {
    return template.opsForZSet().rangeByScoreWithScores(key, min, max);
  }

  /**
   *
   * @param key
   * @param min
   * @param max
   * @param start
   * @param end
   * @return
   */
  public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,double min, double max, long start, long end) {
    return template.opsForZSet().rangeByScoreWithScores(key, min, max,
            start, end);
  }

  /**
   * 获取集合的元素, 从大到小排序
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<String> zReverseRange(String key, long start, long end) {
    return template.opsForZSet().reverseRange(key, start, end);
  }

  /**
   * 获取集合的元素, 从大到小排序, 并返回score值
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<TypedTuple<String>> zReverseRangeWithScores(String key, long start, long end) {
    return template.opsForZSet().reverseRangeWithScores(key, start,
            end);
  }

  /**
   * 根据Score值查询集合元素, 从大到小排序
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<String> zReverseRangeByScore(String key, double min,double max) {
    return template.opsForZSet().reverseRangeByScore(key, min, max);
  }

  /**
   * 根据Score值查询集合元素, 从大到小排序
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
          String key, double min, double max) {
    return template.opsForZSet().reverseRangeByScoreWithScores(key,
            min, max);
  }

  /**
   *
   * @param key
   * @param min
   * @param max
   * @param start
   * @param end
   * @return
   */
  public Set<String> zReverseRangeByScore(String key, double min,double max, long start, long end) {
    return template.opsForZSet().reverseRangeByScore(key, min, max,
            start, end);
  }

  /**
   * 根据score值获取集合元素数量
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Long zCount(String key, double min, double max) {
    return template.opsForZSet().count(key, min, max);
  }

  /**
   * 获取集合大小
   *
   * @param key
   * @return
   */
  public Long zSize(String key) {
    return template.opsForZSet().size(key);
  }

  /**
   * 获取集合大小
   *
   * @param key
   * @return
   */
  public Long zZCard(String key) {
    return template.opsForZSet().zCard(key);
  }

  /**
   * 获取集合中value元素的score值
   *
   * @param key
   * @param value
   * @return
   */
  public Double zScore(String key, Object value) {
    return template.opsForZSet().score(key, value);
  }

  /**
   * 移除指定索引位置的成员
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Long zRemoveRange(String key, long start, long end) {
    return template.opsForZSet().removeRange(key, start, end);
  }

  /**
   * 根据指定的score值的范围来移除成员
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Long zRemoveRangeByScore(String key, double min, double max) {
    return template.opsForZSet().removeRangeByScore(key, min, max);
  }

  /**
   * 获取key和otherKey的并集并存储在destKey中
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long zUnionAndStore(String key, String otherKey, String destKey) {
    return template.opsForZSet().unionAndStore(key, otherKey, destKey);
  }

  /**
   * 交集
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long zIntersectAndStore(String key, String otherKey,
                                 String destKey) {
    return template.opsForZSet().intersectAndStore(key, otherKey,
            destKey);
  }


}

4.使用redis锁代码：

场景1说明：

多线程定时延时任务

package com.aep.aep.wcpservice.service.pm.impl;

import com.aep.aep.wcpapi.dto.pm.PmDelayDownReq;
import com.aep.aep.wcpapi.response.DtoRespCode;
import com.aep.aep.wcpapi.response.DtoResponse;
import com.aep.aep.wcpservice.common.constants.requirement.Constants;
import com.aep.aep.wcpservice.entity.pm.PmProdAudit;
import com.aep.aep.wcpservice.entity.pm.PmProduct;
import com.aep.aep.wcpservice.mapper.pm.PmProdAuditMapper;
import com.aep.aep.wcpservice.mapper.pm.PmProductMapper;
import com.aep.aep.wcpservice.util.RedisClient;
import com.aep.aep.wcpservice.util.RedisLock;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.Set;

/**
 * @Author ：yangshilei
 * @Date ：2020/5/19 17:58
 * @Description：
 */
@Slf4j
@Component
public class PmDelayOffProdTask implements Runnable{

    private static final String PM_DELAY_OFF_PROD = "pm_delay_off_prod";

    @Autowired
    private RedisClient redisClient;
    @Autowired
    private RedisLock lock;

    @Override
    @Transactional
    public void run() {
        log.info("进入延迟下架商品线程");
        // redis排序队列中查找有无到期的数据
        double min = 0D;
        long time = new Date().getTime();
        double max = (double)time;
        Long timestamp = System.currentTimeMillis() + 60000;
        try {
            // redis上锁
            lock.lock("pm_delay_off_task",timestamp.toString());
            String flag = redisClient.get("pm_delay_prod_flag");
            if("true".equals(flag)){
                log.info("有存在的key，结束");
                return;
            }
            redisClient.set("pm_delay_prod_flag","true",60);

            // 具体的业务逻辑代码
            Set<String> prodList =
                    redisClient.zRangeByScore(PM_DELAY_OFF_PROD, min, max);
            if(null != prodList && !prodList.isEmpty()){
                log.info("共有到期下架的商品个数==={}",prodList.size());
                for(String item : prodList){
                    JSONObject jsonObject = JSONObject.parseObject(item);
                    PmDelayDownReq request = JSONObject.toJavaObject(jsonObject, PmDelayDownReq.class);
                    log.info("转成对象==={}",request.toString());

                    // 将商品进行下架操作，后续业务逻辑代码省略
                    ......

                }
                Long aLong = redisClient.zRemoveRangeByScore(PM_DELAY_OFF_PROD, min, max);
                log.info("移除成员个数==={}",aLong);
            }
            log.info("线程执行结束");
        }finally {

            // redis释放锁
            lock.unlock("pm_delay_off_task",timestamp.toString());
        }

    }

   

}

场景2说明：

某分布式部署的项目中，有定时任务，为了防止部署的多个服务同时执行定时任务，给添加了redis分布式锁；

package com.aep.aep.wcpservice.service.pm.impl;

import com.aep.aep.wcpapi.dto.pm.PmAdvanceOrderDto;
import com.aep.aep.wcpapi.dto.pm.PmResult;
import com.aep.aep.wcpservice.mapper.PmAdvanceOrderMapper;
import com.aep.aep.wcpservice.util.RedisClient;
import com.aep.aep.wcpservice.util.RedisLock;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.Date;
import java.util.List;

/**
 * @Author ：yangshilei
 * @Date ：2020/4/15 10:04
 * @Description：
 */
@Slf4j
@Component
public class ScheduledTask {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private RedisLock lock;
    @Autowired
    private RedisClient redisClient;


    @Scheduled(cron  = "0 0/30 * * * ?" )
    @Transactional
    public void pmAdvanceOrder(){
        log.info("进入防疫专区订单状态更新定时任务,每30分钟执行一次");
        Long timestamp = System.currentTimeMillis() + 60000;

        try {
            // 1.生产环境是多服务部署，需要保证只能有一个任务在执行，故加锁。
            lock.lock("pm_advance_order_syn", timestamp.toString());
            String f = redisClient.get("pm_order_syn_flag");
            if("true".equals(f)) {
                return;
            }
            redisClient.set("pm_order_syn_flag","true", 1800);

            // 2.业务逻辑处理代码省略
            
        }finally {
            // 释放锁
            lock.unlock("pm_advance_order_syn", timestamp.toString());
        }
    }



}

以上分布式锁的使用存在一个隐患，就是万一加锁的应用执行到一半突然挂掉了怎么办？

这是在生产中很容易遇到的问题，解决就是建议给锁设置一个超时时间，这个超时时间一定要做好评估，从业务代码执行时长和网关响应超时等设置的响应超时时间角度考虑。

当然，还有一些定时任务，无需考虑网关响应超时等问题，但是，伴随着业务数据的增多，可能执行的时间越来越长，开始时候设置的时间可能已经无法满足后期业务执行时间需求。遇到这种情况，我想到的办法是，不防使用缓存或数据库将每次业务开始到结束的执行时间记录下来，如果大于默认设定的值，就将其作为新的默认值，作为下一次上锁超时时间的依据。

如果有什么更好的办法，也欢迎各位好基友评论补充。

猜你喜欢

转载自blog.csdn.net/qq_37488998/article/details/112709979
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022