分布式锁的实现(基于Redis)
参考:http://www.jb51.net/article/75439.htm
http://www.linuxidc.com/Linux/2015-01/111827.htm
http://www.tuicool.com/articles/6juqmm7
方式一: 基于第三方类库 redssion
1.安装redis
安装redssion的锁服务队redis的版本有要求，要求必须高于2.6版本。关于redis的安装，请参考redis安装。
2.redssion库
redssion的库添加的pom文件中去。
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>2.1.0</version>
</dependency>
3.测试例子
Config config = new Config();
config.useSingleServer().setAddress("ipaddress:6379");
Redisson redisson = Redisson.create(config);
for(int i=0;i<5;i++){
RLock lock = redisson.getLock("testLock");
lock.lock(10, TimeUnit.SECONDS);//10s超时
logger.info("the lock client id is client{}",i);
Thread.sleep(1000);
logger.info("client{} unlock",i);
lock.unlock();
}
4.参考
redisson
方式二: 自定义代码实现
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
/**
* redis实现的分布式锁
*/
public final class Lock {
private static final String LOCK = "redis:lock:%s";
private static final int EXPIRE = 20 * 60;//20分钟
private static final Logger logger = LoggerFactory.getLogger(Lock.class);
private Lock() {
}
public static Lock getLock() {
return new Lock();
}
/**
* 获得锁,超时退出
* @param id
* @param timeout 超时时间(ms)
* @return
*/
public boolean lock(String id, int timeout) {
//这里的Jedis实际上是个代理。代理类JedisCallback，JedisFactoryBean
Jedis jedisProxy = JedisProxy.create();
long lock = 0;
long start = System.currentTimeMillis();
while (lock != 1) {
long now = System.currentTimeMillis();
//判断超时
if (timeout > 0 && now > start + timeout) {
return false;
}
long timestamp = now + EXPIRE * 1000 + 1;
try {
String key = String.format(LOCK, id);
lock = jedisProxy.setnx(key, String.valueOf(timestamp));
if (lock == 1) {
logger.info("设置redis锁key成功，lock key=" + key);
jedisProxy.expire(key, EXPIRE);
logger.info("设置redis锁key过期时间成功，lock key=" + key);
} else {
String s = jedisProxy.get(key);
Long lastLockTime = Long.parseLong(s);
//一个项目部署多个服务，锁可能已经被相同定时任务的其他进程获得，则直接返回false
if (jedisProxy.ttl(key)!=-1&&lastLockTime > System.currentTimeMillis()){
logger.info("redis锁已经被其他服务获得，lock key=" + key);
return false;
}
/**
* 如果上次锁定的时间已经过期，则清除key锁，以便定时任务能够启动
* 造成未能释放的原因主要是jedis.expire(key, EXPIRE);失败
* 或者是获取锁之后，由于程序错误或网络错误，unlock未被成功调用
*/
if (jedisProxy.ttl(key)==-1||lastLockTime < System.currentTimeMillis()) {
jedisProxy.del(key);
continue;
}
// this.wait(100);
Thread.sleep(100);
}
} catch (Exception e) {
logger.error("从redis获取定时任务锁错误,key="+String.format(LOCK, id), e);
return false;
}
}
return true;
}
/**
* 释放锁
* @param id
*/
public void unLock(String id) {
//这里的Jedis实际上是个代理。代理类JedisCallback，JedisFactoryBean
Jedis jedisProxy = JedisProxy.create();
String key = String.format(LOCK, id);
jedisProxy.del(key);
}
}
JedisProxy类
/**
* Jedis代理
*/
@Component
public class JedisProxy implements ApplicationContextAware {
private static volatile ApplicationContext ac;
/**
* 创建Jedis 代理
*
* @return
*/
public static Jedis create() {
return ac.getBean(Jedis.class);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
if (ac != null) {
return;
}
synchronized (JedisProxy.class) {
if (ac != null) {
return;
}
ac = applicationContext;
}
}
}
)
