Redis 分布式锁测试

一、前提依赖（除去SpringBoot项目基本依赖外）：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
</dependency>

<!-- 配置使用redis启动器 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 引入阿里fastjson2依赖 -->
<dependency>
   <groupId>com.alibaba.fastjson2</groupId>
   <artifactId>fastjson2</artifactId>
   <version>2.0.42</version>
</dependency>

<!--junit 测试-->
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.13.2</version>
</dependency>

二、我这里用到的实体类（Orderinfo ）：

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
public class Orderinfo implements Serializable {
    private String onum;
    private Integer eid;
    private BigDecimal price;
    private String fromname;
    private String fromaddress;
    private String fromtel;
    private String toname;
    private String toaddress;
    private String totel;
    private String fromcardnum;
    private Integer state;
    private Date createtime;
    private static final long serialVersionUID = 1L;
    public String getOnum() {
        return onum;
    }
    public void setOnum(String onum) {
        this.onum = onum == null ? null : onum.trim();
    }
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public BigDecimal getPrice() {
        return price;
    }
    public void setPrice(BigDecimal price) {
        this.price = price;
    }
    public String getFromname() {
        return fromname;
    }
    public void setFromname(String fromname) {
        this.fromname = fromname == null ? null : fromname.trim();
    }
    public String getFromaddress() {
        return fromaddress;
    }
    public void setFromaddress(String fromaddress) {
        this.fromaddress = fromaddress == null ? null : fromaddress.trim();
    }
    public String getFromtel() {
        return fromtel;
    }
    public void setFromtel(String fromtel) {
        this.fromtel = fromtel == null ? null : fromtel.trim();
    }
    public String getToname() {
        return toname;
    }
    public void setToname(String toname) {
        this.toname = toname == null ? null : toname.trim();
    }
    public String getToaddress() {
        return toaddress;
    }
    public void setToaddress(String toaddress) {
        this.toaddress = toaddress == null ? null : toaddress.trim();
    }
    public String getTotel() {
        return totel;
    }
    public void setTotel(String totel) {
        this.totel = totel == null ? null : totel.trim();
    }
    public String getFromcardnum() {
        return fromcardnum;
    }
    public void setFromcardnum(String fromcardnum) {
        this.fromcardnum = fromcardnum == null ? null : fromcardnum.trim();
    }
    public Integer getState() {
        return state;
    }
    public void setState(Integer state) {
        this.state = state;
    }
    public Date getCreatetime() {
        return createtime;
    }
    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }
}

三、场景-抢单

1. 添加RedisLockUtil：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
@Component
public class RedisLockUtil {
   @Autowired
   private RedisTemplate<String, String> redisTemplate;
   /**
    * 加锁
    * @param key   键
    * @param value 当前时间 + 超时时间
    * @return 是否拿到锁
    */

   public boolean lock(String key, String value) {
      if (redisTemplate.opsForValue().setIfAbsent(key, value)) {
         return true;
      }
      String currentValue = redisTemplate.opsForValue().get(key);
      //如果锁过期
      if (!StringUtils.isEmpty(currentValue)
            && Long.parseLong(currentValue) < System.currentTimeMillis()) {
//设置新值，返回旧值
         String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
         //是否已被别人抢占 比对currentValue 和oldValue 是否一致 确保未被其他人抢占
         return !StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue);
      }
      return false;
   }

   /**
    * 解锁
    *
    * @param key   键
    * @param value 当前时间 + 超时时间
    */
   public void unlock(String key, String value) {
      try {
         String currentValue = redisTemplate.opsForValue().get(key);
         if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {
            redisTemplate.opsForValue().getOperations().delete(key);
         }
      } catch (Exception e) {
         System.out.println("redis解锁异常");
      }
   }
}

2. 新建RedisLockTest类：

import com.alibaba.fastjson2.JSON;
import com.logistics.order.entity.Orderinfo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.ArrayList;
import java.util.List;
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
@Controller
public class RedisLockTest {
    @Autowired
    public StringRedisTemplate stringRedisTemplate;

    @Autowired
    public RedisLockUtil redisLock;

    //模拟入库
    @Test
    public void insertRedis(){

        Orderinfo orderInfo1 = new Orderinfo();
        orderInfo1.setOnum("1");
        orderInfo1.setEid(1);

        Orderinfo orderInfo2 = new Orderinfo();
        orderInfo2.setOnum("2");
        orderInfo2.setEid(2);

        Orderinfo orderInfo3 = new Orderinfo();
        orderInfo3.setOnum("3");
        orderInfo3.setEid(3);

        List<Orderinfo> orderinfoList = new ArrayList<Orderinfo>();
        orderinfoList.add(orderInfo1);
        orderinfoList.add(orderInfo2);
        orderinfoList.add(orderInfo3);

        orderinfoList.forEach(x -> {
            stringRedisTemplate.boundHashOps("order").put(x.getOnum(), JSON.toJSONString(x));
        });

        System.out.println("入库成功。");
    }

    //压测
    @GetMapping("/getOrder")
    public void getOrder(String onum){

        //定义redis锁的key
        String lockkey = "orderkey";

        //定义锁的超时时间 1s
        Long ex = 1000L;
        String valueTimeout = System.currentTimeMillis()+ex+"";

        //判断锁是否加成功
        boolean lock = redisLock.lock(lockkey, valueTimeout);

        if(lock){
            String orderJson = (String)stringRedisTemplate.boundHashOps("order").get(onum);
            Orderinfo order = JSON.parseObject(orderJson, Orderinfo.class);
            System.out.println("订单："+order.getOnum() +" 被抢到。");
            stringRedisTemplate.boundHashOps("order").delete(onum);

            //释放锁
            redisLock.unlock(lockkey,valueTimeout);
        }
    }
}

3. 进入 Redis 的可视化客户端工具内查看添加信息：

4. 模拟抢单：

@GetMapping("/getOrder")
    public void getOrder(String onum){
        //定义redis锁的key
        String lockkey = "orderkey";
        //定义锁的超时时间 1s
        Long ex = 1000L;
        String valueTimeout = System.currentTimeMillis()+ex+"";

        //判断锁是否加成功
        boolean lock = redisLock.lock(lockkey, valueTimeout);
        if(lock){
            String orderJson = (String)stringRedisTemplate.boundHashOps("order").get(onum);
            Orderinfo order = JSON.parseObject(orderJson, Orderinfo.class);
            System.out.println("订单："+order.getOnum() +" 被抢到。");
            stringRedisTemplate.boundHashOps("order").delete(onum);
            //释放锁
            redisLock.unlock(lockkey,valueTimeout);
        }
    }