Redis 分布式锁

一、描述

　　一套系统，集群部署，高并发时，访问同一个业务方法，该业务涉及到数据的安全性、准确性，只允许单线程操作，这个时候就需要分布式锁来实现。

　　redis实现分布式锁可以采用ValueOperations.setIfAbsent(key, value)或RedisConnection.setNX(key, value)方法

　　ValueOperations.setIfAbsent(key, value)封装了RedisConnection.setNX(key, value)

　　该方法用意：

　　　　并发或非并发都只允许一个插入成功。

　　　　如果key存在，插入值失败，返回false，可以循环执行，直至成功或超时。

　　　　如果key不存，插入值成功，返回true，业务逻辑处理结束后，将key删除。

二、实现（SpringBoot集成redis）

　　1.定义结果类

package com.sze.redis.lock;

/**
 * <br>类 名: LockInfo 
 * <br>描 述: 加锁、释放锁的返回信息
 * <br>作 者: shizhenwei 
 * <br>创 建: 2018年9月10日 
 * <br>版 本: v1.0.0 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
public class LockInfo {
    private boolean success;
    private String key;
    private String value;
    private String description;
    
    public LockInfo(boolean success, String key, String value) {
        super();
        this.success = success;
        this.key = key;
        this.value = value;
    }
    
    public LockInfo(boolean success, String key, String value, String description) {
        super();
        this.success = success;
        this.key = key;
        this.value = value;
        this.description = description;
    }
    
    public boolean isSuccess() {
        return success;
    }
    public void setSuccess(boolean success) {
        this.success = success;
    }
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

 

　　2.定义接口

package com.sze.redis.lock;

public interface RedisLockManager {
    public static final String ID = "RedisLockManager";
    
    /**
     * <br>描 述: 添加一把锁
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     * @param key 锁的唯一标识
     * @param value 给该key设置一个值，建议使用sessionId,这样你可以通过自己的sessionId删除释放自己的锁
     * @param addTimeOut 添加锁的过程的超时时长，即 时间内  锁没有添加上视为失败 单位毫秒
     * @param lockTimeOut 添加锁成功后，该锁的有效时长，即 超过该时长 锁自动放弃 单位毫秒         建议 大于 真实业务逻辑处理时长
     * @return
     */
    LockInfo addlock(String key,String value,int addTimeOut,int lockTimeOut);

    
    /**
     * <br>描 述:    放弃 释放锁
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     * @param key 锁的唯一标识
     * @param value 校验值是否正确，正确则允许释放
     * @return
     */
    LockInfo freeLock(String key,String value);
    
    /**
     * <br>描 述: 强制占有一把锁，如果这把锁之前有线程占有，可能会出现高并发导致的数据错误
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     * @param key 锁的唯一标识
     * @param value 给该key设置一个值，建议使用sessionId,这样你可以通过自己的sessionId删除释放自己的锁
     * @param lockTimeOut 添加锁成功后，该锁的有效时长，即 超过该时长 锁自动放弃 单位毫秒        建议 大于 真实业务逻辑处理时长
     * @return
     */
    LockInfo enforceAddlock(String key,String value,int lockTimeOut);
    
    
    /**
     * <br>描 述:    强制 放弃 释放锁，如果这把锁之前有线程占有，释放后，有可能会出现高并发导致的数据错误
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     * @param key 锁的唯一标识
     * @return
     */
    LockInfo enForceFreeLock(String key);
}

 

　　3.实现类

package com.sze.redis.lock;

import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service(RedisLockManager.ID)
public class RedisLockManagerImpl implements RedisLockManager {
    
    @Autowired
    private StringRedisTemplate redisTampate;
    
    private ValueOperations<String, String> stringRedis;
    
    /**
     * <br>描 述: 初始化时赋值
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     */
    @PostConstruct
    private void init(){
        stringRedis = redisTampate.opsForValue();
    }
    
    /**
     * 添加分布式锁
     * key 建议全局常量定义
     * value 建议使用sessionId
     * addTimeOut 毫秒
     * lockTimeOut 毫秒 建议大于 真实业务逻辑处理时长
     * 详解见接口注解
     */
    @Override
    public LockInfo addlock(String key, String value, int addTimeOut, int lockTimeOut) {
        //StringUtils是spring framework自带的工具类，功能还是挺齐全的，建议开发中使用该类或者继承、copy其类
        if(!StringUtils.hasText(key) || !StringUtils.hasText(value)){
            return new LockInfo(false, key, value,"key和value不能为空");
        }
        
        if(addTimeOut<100 || lockTimeOut<100){
            return new LockInfo(false, key, value,"addTimeOut和lockTimeOut不能小于100毫秒");
        }
        
        //setIfAbsent执行的底层的RedisConnection.setNX方法，分布式锁的判定也是通过该方法
        Boolean b = stringRedis.setIfAbsent(key, value);//该key有值，返回false,意为该key在被其他分布式锁定占用
        if(b){
            //获取到锁
            redisTampate.expire(key, lockTimeOut, TimeUnit.MILLISECONDS);//设置锁的有效时长
            return new LockInfo(true, key, value,"锁添加成功");        
        }else{
            //循环获取锁，直到获取到，或者超市
            long timeOut = System.currentTimeMillis()+addTimeOut;
            while(System.currentTimeMillis()<timeOut){
                try {
                    //之所以设置睡眠，目的为了降低jvm压力
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    return new LockInfo(false, key, value,"线程异常");
                }
                //setIfAbsent执行的底层的RedisConnection.setNX方法，分布式锁的判定也是通过该方法
                Boolean b2 = stringRedis.setIfAbsent(key, value);
                if(b2){
                    redisTampate.expire(key, lockTimeOut, TimeUnit.MILLISECONDS);//设置锁的有效时长
                    return new LockInfo(true, key, value,"锁添加成功，之前有线程在占用");
                }
            }
            return new LockInfo(false, key, value,"锁正在被其他线程持续占用中，获取锁的请求超时");
        }
    }
    
    /**
     * 释放分布式锁
     * key 建议全局常量定义
     * value 建议使用sessionId
     * 详解见接口注解
     */
    @Override
    public LockInfo freeLock(String key, String value) {
        //StringUtils是spring framework自带的工具类，功能还是挺齐全的，建议开发中使用该类或者继承、copy其类
        if(!StringUtils.hasText(key) || !StringUtils.hasText(value)){
            return new LockInfo(false, key, value,"key和value不能为空");
        }
        if(value.equals(stringRedis.get(key))){
            redisTampate.delete(key);
            return new LockInfo(true, key, value,"锁释放成功");
        }else{
            return new LockInfo(false, key, value,"value不对，无权释放锁");
        }
    }
    
    
    /**
     * 强制添加分布式锁
     * key 建议全局常量定义
     * value 建议使用sessionId
     * lockTimeOut 毫秒 建议大于 真实业务逻辑处理时长
     * 详解见接口注解
     */
    @Override
    public LockInfo enforceAddlock(String key, String value,int lockTimeOut) {
        //StringUtils是spring framework自带的工具类，功能还是挺齐全的，建议开发中使用该类或者继承、copy其类
        if(!StringUtils.hasText(key) || !StringUtils.hasText(value)){
            return new LockInfo(false, key, value,"key和value不能为空");
        }
        
        if(lockTimeOut<100){
            return new LockInfo(false, key, value,"addTimeOut和lockTimeOut不能小于100毫秒");
        }
        stringRedis.set(key, value, lockTimeOut, TimeUnit.MILLISECONDS);
        return new LockInfo(true, key, value,"锁强制添加成功");
    }
    
    /**
     * 强制释放分布式锁
     * key 建议全局常量定义
     * 详解见接口注解
     */
    @Override
    public LockInfo enForceFreeLock(String key) {
        //StringUtils是spring framework自带的工具类，功能还是挺齐全的，建议开发中使用该类或者继承、copy其类
        if(!StringUtils.hasText(key)){
            return new LockInfo(false, key, null,"key不能为空");
        }
        redisTampate.delete(key);
        return new LockInfo(true, key, null,"锁释放成功");
    }
}

 

　　4.定义常量类

package com.sze.redis.lock;

/**
 * <br>类 名: LockConstants 
 * <br>描 述: 各个流程需要获取锁，释放锁的key、获取锁的超时时长（毫秒）、拿到锁后的超时时长（毫秒）
 * <br>作 者: shizhenwei 
 * <br>创 建: 2018年9月10日 
 * <br>版 本: v1.0.0 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
public class LockConstants {
    //默认key
    public static final String DEFAULT_KEY = "DEFAULT_KEY";
    //添加锁时的默认时长，即 开始——添加锁成功的超时时长
    public static final long DEFAULT_ADDTIME = 3_000;
    //锁添加成功后的有效时长，即 该时长过后，锁自动放弃
    public static final long DEFAULT_LOCKTIME = 3_000;
    
    
    //购买流程——锁——key,分布式多应用，高并发时，获取该key的所
    public static final String BUY_DINGJIE_KEY = "BUY_DINGJIE_KEY";
    
    //获取购买流程锁时的超时长
    public static final int BUY_DINGJIE_ADDTIME = 10_000;
    
    //获取到购买流程锁后的有效时长
    public static final int BUY_DINGJIE_LOCKTIME = 10_000;
}

　　

　　5.测试类——模拟多线程

package com.sze.redis.lock;

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.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisLockManagerTest {
    
    @Autowired
    private RedisLockManager redisLockManager;
    
    /**
     * <br>描 述: 购买丁洁
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     */
    public void buy(){
        //这个value值，建议使用sessionId,这里为了测试，使用了一个妹子的名字
        //先取得锁
        LockInfo lockInfo = redisLockManager.addlock(LockConstants.BUY_DINGJIE_KEY, "丁洁", LockConstants.BUY_DINGJIE_ADDTIME, LockConstants.BUY_DINGJIE_LOCKTIME);
        //处理业务
        if(lockInfo.isSuccess()){
            //成功业务
            System.out.println("============"+Thread.currentThread().getName()+"===========");
            System.out.println(lockInfo.getDescription());
            System.out.println("开始购买丁洁业务。。。");
            System.out.println("购买丁洁业务结束。。。");
            //释放锁
            LockInfo lockInfo2 = redisLockManager.freeLock(LockConstants.BUY_DINGJIE_KEY, "丁洁");
            System.out.println(lockInfo2.getDescription());
        }else{
            //失败业务
            System.out.println("============"+Thread.currentThread().getName()+"===========");
            System.out.println(lockInfo.getDescription());
            System.out.println("购买丁洁业务失败。。。");
        }
    }
    
    @Test
    public void test(){
        //测试前先把锁释放掉
        redisLockManager.enForceFreeLock(LockConstants.BUY_DINGJIE_KEY);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                 buy();
            }
        },"线程1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                 buy();
            }
        },"线程2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                 buy();
            }
        },"线程3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                 buy();
            }
        },"线程4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t1.run();
        t2.run();
        t3.run();
        t4.run();
    }
    
}

　　

　　6.输出结果

　注：关于SpringBoot集成redis，参考：https://www.cnblogs.com/zwcry/p/9633184.html