Redis 分布式锁实现

最新推荐文章于 2024-04-22 23:02:22 发布

竹林幽深

最新推荐文章于 2024-04-22 23:02:22 发布

阅读量444

点赞数

分类专栏： java redis 文章标签：分布式 memcached

java 同时被 2 个专栏收录

644 篇文章 7 订阅

订阅专栏

redis

9 篇文章 0 订阅

订阅专栏

原文地址：http://blog.csdn.net/zhu_tianwei/article/details/44927331

Redis是一个key-value存储系统。和Memcached类似，但是解决了断电后数据完全丢失的情况，而且她支持更多无化的value类型，除了和string外，还支持lists（链表）、sets（集合）和zsets（有序集合）几种数据类型。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

下面我们以redis为基础设计分布式锁。

1.锁接口定义

[java] view plain copy print ?

package cn.slimsmart.redis.demo.lock;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
*锁接口定义
*/
public interface IRedisLockHandler {
/**
* 获取锁如果锁可用立即返回true，否则返回false
* @param key
* @return
*/
boolean tryLock(String key);
/**
* 锁在给定的等待时间内空闲，则获取锁成功返回true，否则返回false
* @param key
* @param timeout
* @param unit
* @return
*/
boolean tryLock(String key, long timeout, TimeUnit unit);
/**
* 如果锁空闲立即返回获取失败一直等待
* @param key
*/
void lock(String key);
/**
* 批量获取锁如果全部获取立即返回true, 部分获取失败返回false
* @param keyList
* @return
*/
boolean tryLock(List<String> keyList);
/**
* 锁在给定的等待时间内空闲，则获取锁成功返回true，否则返回false
* @param keyList
* @param timeout
* @param unit
* @return
*/
boolean tryLock(List<String> keyList, long timeout, TimeUnit unit);
/**
* 释放锁
* @param key
*/
void unLock(String key);
/**
* 批量释放锁
* @param keyList
*/
void unLock(List<String> keyList);
}

2.锁接口实现

[java] view plain copy print ?

package cn.slimsmart.redis.demo.lock;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.exceptions.JedisConnectionException;
/**
* redis 分布式锁实现
*
*/
public class RedisLockHandler implements IRedisLockHandler {
private static final Logger LOGGER = LoggerFactory.getLogger(RedisLockHandler.class);
// 单个锁有效期
private static final int DEFAULT_SINGLE_EXPIRE_TIME = 30;
// 批量锁有效期
private static final int DEFAULT_BATCH_EXPIRE_TIME = 60;
private final JedisPool jedisPool;
/**
* 构造
*/
public RedisLockHandler(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
/**
* 获取锁如果锁可用立即返回true，否则返回false，不等待
*
* @return
*/
@Override
public boolean tryLock(String key) {
return tryLock(key, 0L, null);
}
/**
* 锁在给定的等待时间内空闲，则获取锁成功返回true，否则返回false
*
* @param timeout
* @param unit
* @return
*/
@Override
public boolean tryLock(String key, long timeout, TimeUnit unit) {
Jedis jedis = null;
try {
jedis = getResource();
//系统计时器的当前值，以毫微秒为单位。
long nano = System.nanoTime();
do {
LOGGER.debug("try lock key: " + key);
//将 key 的值设为 value 1成功 0失败
Long i = jedis.setnx(key, key);
if (i == 1) {
//设置过期时间
jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);
LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");
//成功获取锁，返回true
return Boolean.TRUE;
} else { // 存在锁,循环等待锁
if (LOGGER.isDebugEnabled()) {
String desc = jedis.get(key);
LOGGER.debug("key: " + key + " locked by another business：" + desc);
}
}
if (timeout <= 0) {
//没有设置超时时间，直接退出等待
break;
}
Thread.sleep(300);
} while ((System.nanoTime() - nano) < unit.toNanos(timeout));
return Boolean.FALSE;
} catch (JedisConnectionException je) {
LOGGER.error(je.getMessage(), je);
//释放资源
returnBrokenResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
} finally {
returnResource(jedis);
}
return Boolean.FALSE;
}
/**
* 如果锁空闲立即返回获取失败一直等待
*/
@Override
public void lock(String key) {
Jedis jedis = null;
try {
jedis = getResource();
do {
LOGGER.debug("lock key: " + key);
Long i = jedis.setnx(key, key);
if (i == 1) {
jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);
LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");
return;
} else {
if (LOGGER.isDebugEnabled()) {
String desc = jedis.get(key);
LOGGER.debug("key: " + key + " locked by another business：" + desc);
}
}
Thread.sleep(300);
} while (true);
} catch (JedisConnectionException je) {
LOGGER.error(je.getMessage(), je);
returnBrokenResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
} finally {
returnResource(jedis);
}
}
/**
* 释放锁
*/
@Override
public void unLock(String key) {
List<String> list = new ArrayList<String>();
list.add(key);
unLock(list);
}
/**
* 批量获取锁如果全部获取立即返回true, 部分获取失败返回false
*
* @return
*/
@Override
public boolean tryLock(List<String> keyList) {
return tryLock(keyList, 0L, null);
}
/**
* 锁在给定的等待时间内空闲，则获取锁成功返回true，否则返回false
*
* @param timeout
* @param unit
* @return
*/
@Override
public boolean tryLock(List<String> keyList, long timeout, TimeUnit unit) {
Jedis jedis = null;
try {
//需要的锁
List<String> needLocking = new CopyOnWriteArrayList<String>();
//得到的锁
List<String> locked = new CopyOnWriteArrayList<String>();
jedis = getResource();
long nano = System.nanoTime();
do {
// 构建pipeline，批量提交
Pipeline pipeline = jedis.pipelined();
for (String key : keyList) {
needLocking.add(key);
pipeline.setnx(key, key);
}
LOGGER.debug("try lock keys: " + needLocking);
// 提交redis执行计数,批量处理完成返回
List<Object> results = pipeline.syncAndReturnAll();
for (int i = 0; i < results.size(); ++i) {
Long result = (Long) results.get(i);
String key = needLocking.get(i);
if (result == 1) { // setnx成功，获得锁
jedis.expire(key, DEFAULT_BATCH_EXPIRE_TIME);
locked.add(key);
}
}
needLocking.removeAll(locked); // 已锁定资源去除
if (needLocking.size() == 0) { //成功获取全部的锁
return true;
} else {
// 部分资源未能锁住
LOGGER.debug("keys: " + needLocking + " locked by another business：");
}
if (timeout == 0) {
break;
}
Thread.sleep(500);
} while ((System.nanoTime() - nano) < unit.toNanos(timeout));
// 得不到锁，释放锁定的部分对象，并返回失败
if (locked.size() > 0) {
jedis.del(locked.toArray(new String[0]));
}
return false;
} catch (JedisConnectionException je) {
LOGGER.error(je.getMessage(), je);
returnBrokenResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
} finally {
returnResource(jedis);
}
return true;
}
/**
* 批量释放锁
*/
@Override
public void unLock(List<String> keyList) {
List<String> keys = new CopyOnWriteArrayList<String>();
for (String key : keyList) {
keys.add(key);
}
Jedis jedis = null;
try {
jedis = getResource();
jedis.del(keys.toArray(new String[0]));
LOGGER.debug("release lock, keys :" + keys);
} catch (JedisConnectionException je) {
LOGGER.error(je.getMessage(), je);
returnBrokenResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
} finally {
returnResource(jedis);
}
}
/**
* 获取redis客户端
* @return
*/
private Jedis getResource() {
return jedisPool.getResource();
}
/**
* 销毁连接
* @param jedis
*/
private void returnBrokenResource(Jedis jedis) {
if (jedis == null) {
return;
}
try {
//中断链接
jedisPool.returnBrokenResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
}
/**
* 重新初始化对象
* @param jedis
*/
private void returnResource(Jedis jedis) {
if (jedis == null) {
return;
}
try {
jedisPool.returnResource(jedis);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
}
}

3.分布式锁测试

[java] view plain copy print ?

package cn.slimsmart.redis.demo.lock;
import java.util.concurrent.TimeUnit;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisLockMain {
public static void main(String[] args) {
//创建jedis池配置实例
JedisPoolConfig config = new JedisPoolConfig();
//设置池配置项值
config.setMaxTotal(1024);
config.setMaxIdle(200);
config.setMaxWaitMillis(1000);
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
//根据配置实例化jedis池
JedisPool pool = new JedisPool(config,"192.168.100.205", 6379);
IRedisLockHandler lock = new RedisLockHandler(pool);
if(lock.tryLock("abcd",20,TimeUnit.SECONDS)){
System.out.println(" get lock ...");
}else{
System.out.println(" not get lock ...");
}
lock.unLock("abcd");
}
}

关于通过spring aop实现分布式锁，请参考：http://blog.csdn.net/michaelzhaozero/article/details/23746059

竹林幽深

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Redis 分布式锁实现

原文地址：http://blog.csdn.net/zhu_tianwei/article/details/44927331Redis是一个key-value存储系统。和Memcached类似，但是解决了断电后数据完全丢失的情况，而且她支持更多无化的value类型，除了和string外，还支持lists（链表）、sets（集合）和zsets（有序集合）几种数据类型。这些数据类型
复制链接

扫一扫