分布式加锁

在高并发的条件下许多地方都要用到分布式加锁, 传统的单体架构加锁synchronized, 以及无法满足多节点集群的模式了, 所以目前比较主流的应该用到第三方中间件来实现分布式加锁.

Redis的setNX加锁

命令格式

SETNX key value

将 key 的值设为 value，当且仅当 key 不存在。 
若给定的 key 已经存在，则 SETNX 不做任何动作。 
SETNX 是SET if Not eXists的简写。

返回值

返回整数，具体为 
1，当 key 的值被设置 
0，当 key 的值没被设置

例子

redis> SETNX mykey “hello” 
(integer) 1 
redis> SETNX mykey “hello” 
(integer) 0 
redis> GET mykey 
“hello” 
redis>

实现1  StringRedisTemplate

　　　　　　这个是基于setnx的一种实现, 不同的是加锁的结果返回的是布尔值, 在高级版中可以在加锁的同时设置超时时间, 有效避免死锁的问题.

　　　　　　

依赖

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

代码

        AccessToken oToken = null;
        StringRedisTemplate redisTemplate = new StringRedisTemplate();

        boolean lockFlag = redisTemplate.opsForValue().setIfAbsent("access_token_" + appId, appSecrete, 15L, TimeUnit.SECONDS);
        if (lockFlag) {
            logger.info("加锁成功, 开始获取最新的token");
            try {
                oToken = weixinUtil.getAccessToken_for_dist(appId, appSecrete);
            } finally {
                redisTemplate.delete("access_token_" + appId);
                logger.info("解锁成功.");
            }
        } else {
            logger.info("加锁失败, 返回旧的token");
        }    

注意事项:

　　由于想实现加锁的同时设置超时时间, 需要spring-redis-data的版本达到2.1以上, 这就需要jedis的版本至少达到目前最新的2.9, 而且springboot的版本也需要达到2.0以上.

　　如果springboot版本达不到要求, 则会报如下的错:

2019-06-06 10:45:15.697 [main] ERROR org.springframework.boot.SpringApplication - Application startup failed
java.lang.NoSuchMethodError: org.springframework.data.repository.config.RepositoryConfigurationSource.getAttribute(Ljava/lang/String;)Ljava/util/Optional;
    at org.springframework.data.redis.repository.configuration.RedisRepositoryConfigurationExtension.registerBeansForRoot(RedisRepositoryConfigurationExtension.java:88)
    at org.springframework.data.repository.config.RepositoryConfigurationDelegate.registerRepositoriesIn(RepositoryConfigurationDelegate.java:116)
    at org.springframework.boot.autoconfigure.data.AbstractRepositoryConfigurationSourceSupport.registerBeanDefinitions(AbstractRepositoryConfigurationSourceSupport.java:59)
    at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsFromRegistrars(ConfigurationClassBeanDefinitionReader.java:359)
    at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass(ConfigurationClassBeanDefinitionReader.java:143)
    at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(ConfigurationClassBeanDefinitionReader.java:116)

实现2.RedisTemplate

　　　　　　　　这个也是用spring-data-redis. 不过用的是低版本, 不支持加锁的同时设置超时时间, 但是我们能用其它方式实现加锁并且不会因为未设置超时时间而导致死锁,

　　　　　　实现思路:　　　　

　　　　　　　　　　　　　　　* 主要是使用了redis 的setnx命令,缓存了锁.
　　　　　　　　　　　　* reids缓存的key是锁的key,所有的共享, value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间)
　　　　　　　　　　　　* 执行过程:
　　　　　　　　　　　　* 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁
　　　　　　　　　　　　* 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值

依赖

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

 这个是1.0以上的版本, 对jedis和springboot的版本没有上面那种实现方式那么严格, springboot1.0以上就行.

代码

　　加锁实现类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

/**
 * @auhtor 
 * @date 2019/6/6 14:28
 */
@Component
public class RedisLock {

    private static Logger logger = LoggerFactory.getLogger(RedisLock.class);
    @Autowired
    private RedisTemplate redisTemplate;
    //延迟100毫秒再次尝试访问
    private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;

    /**
     * 锁超时时间，防止线程在入锁以后，无限的执行等待
     */
    private int expireMsecs = 60 * 1000;

    /**
     * 锁等待时间，防止线程饥饿
     */
    private int timeoutMsecs = 10 * 1000;

    /**
     * 根据锁的key获取锁的到期时间
     *
     * @param key 锁的key
     * @return 返回锁的value值, 即锁的到期时间
     */
    private String get(final String key) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    byte[] data = connection.get(serializer.serialize(key));
                    connection.close();
                    if (data == null) {
                        return null;
                    }
                    return serializer.deserialize(data);
                }
            });
        } catch (Exception e) {
            logger.error("get redis error, key : {}", key);
        }
        return obj != null ? obj.toString() : null;
    }

    /**
     * 根据key进行加锁, 同时value值存放锁的到期时间
     * @param key   加锁的key
     * @param value 加锁的value, 即锁的到期时间
     * @return 返回加锁的结果
     */
    private boolean setNX(final String key, final String value) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
                    connection.close();
                    return success;
                }
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", key);
        }
        return obj != null ? (Boolean) obj : false;
    }

    /**
     * 替换锁的到期时间,并返回以前的到期时间
     *
     * @param key   加锁的key
     * @param value 锁的到期时间
     * @return 返回锁以前的到期时间
     */
    private String getSet(final String key, final String value) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
                    connection.close();
                    return serializer.deserialize(ret);
                }
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", key);
        }
        return obj != null ? (String) obj : null;
    }

    /**
     * @param lockKey 获取锁的key
     * @return boolean
     * @throws Exception
     */
    public boolean lock(String lockKey){
        int timeout = timeoutMsecs; //默认10秒
        int expiretime = expireMsecs; //默认60秒
        return this.setLock(lockKey, timeout, expiretime);
    }

    /**
     * @param lockKey 获取锁的key
     * @param expireMsecs 锁失效时间
     * @return boolean
     * @throws Exception
     */
    public boolean lock(String lockKey, int expireMsecs){
        int timeout = timeoutMsecs; //默认10秒
        int expiretime = expireMsecs; //默认60秒
        return this.setLock(lockKey, timeout, expiretime);
    }


    /**
     * @param lockKey 获取锁的key
     * @param timeoutMsecs 线程尝试重新获取锁持续时间
     * @param expireMsecs 锁失效时间
     * @return boolean
     * @throws Exception
     */
    public boolean lock(String lockKey,int timeoutMsecs, int expireMsecs){
        int timeout = timeoutMsecs;
        int expiretime = expireMsecs;
        return this.setLock(lockKey, timeout, expiretime);
    }


    /**
     * 获得 lock.
     * 实现思路: 主要是使用了redis 的setnx命令,缓存了锁.
     * reids缓存的key是锁的key,所有的共享, value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间)
     * 执行过程:
     * 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁
     * 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值
     *
     * @return true if lock is acquired, false acquire timeouted
     */
    private boolean setLock(String lockKey, int timeout, int expiretime){
        while (timeout >= 0) {
            long expires = System.currentTimeMillis() + expiretime + 1;
            String expiresStr = String.valueOf(expires); //锁到期时间
            if (this.setNX(lockKey, expiresStr)) {
                // lock acquired
                return true;
            }
            String currentValueStr = this.get(lockKey); //redis里的时间
            if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
                //判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的
                // lock is expired
                String oldValueStr = this.getSet(lockKey, expiresStr);
                //获取上一个锁到期时间，并设置现在的锁到期时间，
                //只有一个线程才能获取上一个线上的设置时间，因为jedis.getSet是同步的
                if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                    //防止误删（覆盖，因为key是相同的）了他人的锁——这里达不到效果，这里值会被覆盖，但是因为什么相差了很少的时间，所以可以接受
                    //[分布式的情况下]:如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
                    // lock acquired
                    return true;
                }
            }
            timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
            /*
                延迟100 毫秒,  这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
                只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足.
                使用随机的等待时间可以一定程度上保证公平性
             */
            try {
                Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
            } catch (Exception e) {
                logger.error("异常日志:", e);
                break;
            }
        }
        return false;
    }


    /**
     * 根据key值释放锁, 先判断是否有锁, 再进行释放锁
     * @param lockKey
     */
    public void unlock(String lockKey) {
        //先判断锁是否存在
        String locked = this.get(lockKey);
        //存在则进行解锁, 删除key
        if (null != locked && !"".equals(locked)) {
            Object del = null;
            try {
                del = redisTemplate.execute(new RedisCallback<Object>() {
                    @Override
                    public Object doInRedis(RedisConnection connection) {
                        StringRedisSerializer serializer = new StringRedisSerializer();
                        Long result = connection.del(serializer.serialize(lockKey));
                        connection.close();
                        return result;
                    }
                });
            } catch (Exception e) {
                logger.error("del redis key error, key : {}", lockKey);
            }
            if (del != null) {
                if ((long)del == 1L) {
                    logger.info("del redis key success!");
                } else {
                    logger.info("del redis key fail, key : {}", lockKey);
                }
            } else {
                logger.info("del redis key fail, key : {}", lockKey);
            }
        } else {
            logger.info("locked is null, key : {}", lockKey);
        }
    }
}

　　

　　测试类

@Service("tokenServiceImpl")
public class TokenServiceImpl extends BaseService {

    @Autowired
    private RedisLock redisLock;

    public ReturnInfoVo<Object> getToken(String appId, String appSecrete) throws Exception {
        logger.info("Enter into TokenServiceImpl.getToken, appId=" + appId + ", appSecret=" + appSecrete);
        ReturnInfoVo<Object> returnInfoVo = this.getReturnInfoVo();

        String tokenString = "";

        AccessToken oToken = null;
        boolean lockFlag = redisLock.lock(appId);
        if (lockFlag) {
            logger.info("加锁成功, 开始获取最新的token");
            try {
                logger.info("从腾讯获取token成功!");
                oToken = new AccessToken();
                oToken.setToken("4sa6d4f6a4f");
                oToken.setExpiresIn(15000);
//                oToken = weixinUtil.getAccessToken_for_dist(appId, appSecrete);
            } finally {
                Thread.sleep(10000);
                redisLock.unlock(appId);
                logger.info("解锁成功.");
            }
        } else {
            logger.info("加锁失败, 返回旧的token");
        }

        // 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
        if(oToken != null) {
            tokenString = JSONObject.toJSONString(oToken);

            logger.info("getToken processing, 获取Token JSON信息 tokenString" + tokenString);

            returnInfoVo.setSuccess(true);
            returnInfoVo.setResult(tokenString);
        } else {
            returnInfoVo.setSuccess(false);
            logger.info("getToken processing, AccessToken is null");
        }

        return returnInfoVo;
    }


}

测试工具可以用apache的 JMeter