redis哨兵模式使用lua脚本实现分布式锁

最新推荐文章于 2024-07-29 13:42:38 发布

Mr_Smile2014

最新推荐文章于 2024-07-29 13:42:38 发布

阅读量4.5k

点赞数 1

分类专栏： redis 文章标签： lua java redis

本文链接：https://blog.csdn.net/Mr_Smile2014/article/details/73849573

版权

redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

spring redis和redis包在设置key值的时候，都是先调用setnx设置值，成功就返回1，然后通过Expire设置超时时间，这样会出现一个

问题假如setnx成功，但是expire的时候，失败了，那么该值就会一直存在，这样会造成大的问题，这个问题怎么解决呢？

我们可以通过redis lua脚本，让设置值和设置超时时间在redis服务端一次执行，就不会造成前面描述的问题。

下面是实现分布式锁的代码，采用的哨兵模式：

redis锁类代码：

package com.XXX.util.redis;

import java.util.Random;

import org.apache.log4j.Logger;

import com.XXX.util.Configure;

public class RedisLock {
	private Logger log = Logger.getLogger(RedisLock.class);

	public RedisLock() {

	}
	
	public RedisLock(String suffix) {
		this.key = this.key + ":" + suffix;
	}

	private static final Configure INS = Configure.getInstans();

	/**
	 *  默认超时时间（秒） 
	 *  超时会抛弃当前锁里的所有线程
	 *  必要时需要补偿机制
	 */
	public static final long DEFAULT_TIMEOUT = Long.parseLong(INS.getValue("DEFAULT_TIMEOUT")) * 1000L;
	/**
	 *  锁的超时时间（秒），过期删除 
	 */
	public static final int LOCK_TIMEOUT = Integer.parseInt(INS.getValue("LOCK_TIMEOUT"));
	
	private static final long ONE_MILLI_NANOS = 1000000L;
	private static final long  NANOS_TIMEOUT = DEFAULT_TIMEOUT * ONE_MILLI_NANOS;
	
	// 锁状态标志
	private boolean locked = false;
	// 加锁标志
	private static final String LOCKED = "TRUE";
	
	private String key = "LOCK";
	private RedisUtil redisUtil = RedisUtil.getInstance();
	
	public static void test() {
		
	}
	
	private static final Random RANDOM = new Random();
	
	public boolean lock() {
		long nano = System.nanoTime();
		try {
			while ((System.nanoTime() - nano) < NANOS_TIMEOUT) {
				if(redisUtil.setnxAndExpire(key, LOCKED, LOCK_TIMEOUT)) {
					locked = true;

					log.info("RedisLock lock : Get Lock key=" + key);

					return locked;
				}
				// 短暂休眠，nano避免出现活锁
				Thread.sleep(5, RANDOM.nextInt(500));
			}
		} catch (Exception e) {
			log.error("RedisLock lock Get Lock Fail", e);
		}
		return false;
	}

	// 无论是否加锁成功，必须调用
	public void unlock() {
		if (locked) {
			redisUtil.del(key);
			log.info("RedisLock unlock : Del Lock key=" + key);
		}
	}

    public static void main(String[] args) {
	    for(int i =0 ;i<100;i++){
            RedisLock lock = new RedisLock("test1");
            boolean lock1 = lock.lock();
            System.out.println(lock1+""+i);
        }
    }
}

RedisUtil 工具类代码：

package com.XXX.util.redis;
import java.util.HashSet;
import java.util.Set;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.LoggerFactory;
import com.XXX.util.Configure;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;
public class RedisUtil {
	private static org.slf4j.Logger log = LoggerFactory.getLogger(RedisUtil.class);
	private static final String Sentinel = "sentinel";

	private static Configure INS = Configure.getInstans();

	private static final String RedisModel = INS.getValue("redis.model");
	private static final String SentinelsURL = INS.getValue("sentinel.urls");
	private static final String RedisMaster = INS.getValue("redis.master");
	private static final String RedisPassword = INS.getValue("redis.password");

	private static final String MaxTotal = INS.getValue("redis.maxTotal");
	private static final String MaxIdle = INS.getValue("redis.maxIdle");
	private static final String MaxWait = INS.getValue("redis.maxWait");
	private static final String MinEvictableIdle = INS.getValue("redis.minEvictableIdle");
	private static final String NumTestsPerEvictionRun = INS.getValue("redis.numTestsPerEvictionRun");
	private static final String TimeBetweenEvictionRunsMillis = INS.getValue("redis.timeBetweenEvictionRunsMillis");
	private static final String BlockWhenExhausted = INS.getValue("redis.blockWhenExhausted");
	//设置锁的lua脚本
	private static final String SETNX_EXPIRE_SCRIPT = "if redis.call('setnx', KEYS[1], KEYS[2]) == 1 then\n"
			+ "return redis.call('expire', KEYS[1], KEYS[3]);\n" + "end\n" + "return nil;";
	private static RedisUtil redisUtil = new RedisUtil();

	private JedisSentinelPool sentinelPool;

	private RedisUtil() {
		if (Sentinel.equals(RedisModel)) {
			initSentinel();
		}

	}
	public static RedisUtil getInstance() {
		return redisUtil;
	}

	private void initSentinel() {
		String[] url = SentinelsURL.split(",");

		Set<String> sentinels = new HashSet<String>();
		for (int i = 0; i < url.length; i++) {
			sentinels.add(url[i]);
		}
		GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
		poolConfig.setMaxTotal(Integer.valueOf(MaxTotal));
		poolConfig.setMaxIdle(Integer.valueOf(MaxIdle));
		poolConfig.setMaxWaitMillis(Long.valueOf(MaxWait));
		poolConfig.setMinEvictableIdleTimeMillis(Long.valueOf(MinEvictableIdle));
		poolConfig.setNumTestsPerEvictionRun(Integer.valueOf(NumTestsPerEvictionRun));
		poolConfig.setTimeBetweenEvictionRunsMillis(Long.valueOf(TimeBetweenEvictionRunsMillis));
		poolConfig.setBlockWhenExhausted(Boolean.valueOf(BlockWhenExhausted));
		poolConfig.setTestOnBorrow(true);
		sentinelPool = StringUtils.isBlank(RedisPassword) ? new JedisSentinelPool(RedisMaster, sentinels, poolConfig)
				: new JedisSentinelPool(RedisMaster, sentinels, poolConfig, RedisPassword);
		
		log.info("init sentinelPool success,the sentinelPool=" + sentinelPool);
	}

	private Jedis getJedis() {
		return getInstance().sentinelPool.getResource();
	}

	/**
	 * setnx带过期时间功能
	 * 
	 * @param key
	 *            键名
	 * @param value
	 *            键值
	 * @param seconds
	 *            单位秒
	 * @see redis.clients.jedis.Jedis#setnx(String, String)
	 * @see redis.clients.jedis.Jedis#expire(String, int)
	 * @return 成功返回true,失败false
	 */
	public boolean setnxAndExpire(String key, String value, int seconds) {
		Jedis redis = null;
		try {
			redis = getJedis();
			Object result = redis.eval(SETNX_EXPIRE_SCRIPT, 3, key, value, seconds + "");
			return result != null;
		} catch (Throwable t) {
			log.error("setnxAndExpire" + t.toString(), t);
			return false;
		} finally {
			close(redis);
		}
	}
	public Long del(String key) {
		Jedis redis = null;
		try {
			redis = getJedis();
			return redis.del(key);
		} catch (Exception t) {
			log.error("删掉key=" + key + "异常"+t.toString(), t);
			return -1l;
		} finally {
			close(redis);
		}
	}

	private void close(Jedis redis) {
		if (redis != null) {
			redis.close();
		}
	}

	@Override
	public String toString() {
		return "RedisUtil [sentinelPool=" + sentinelPool + "]";
	}

	public static void main(String[] args) {
		boolean b = RedisUtil.getInstance().setnxAndExpire("test", "true", 100);
		System.out.println(b);
	}
}

RedisUtil 配置文件：

#redis config
redis.model=sentinel
redis.master=st1
redis.password=
sentinel.urls=192.168.0.13:26379,192.168.0.13:26380,192.168.0.13:26381
redis.maxTotal=50
redis.maxIdle=10
redis.maxWait=20000
redis.minEvictableIdle=300000
redis.numTestsPerEvictionRun=3
redis.timeBetweenEvictionRunsMillis=60000
redis.blockWhenExhausted=true
#秒(s)
DEFAULT_TIMEOUT=30
#秒(s)
LOCK_TIMEOUT=2

pom配置：

<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.6.2</version>
		</dependency>
---------------------------------------------------------------------------版权声明------------------------------------------------------------------------------------------

版权声明：本文为博主原创文章，未经博主允许不得转载。博客地址:http://blog.csdn.net/mr_smile2014