一、Redis实现分布式锁概念
1.1、涉及到的常用命令
（1）SETNX
作用1：SETNX key val ：当且仅当key不存在时，set一个key为val的字符串，返回1（如果存入key成功返回1）；若key已经存在，则什么都不做，返回0。
set命令和setnx命令区别：
set返回OK，可以覆盖value;
setnx，如果key存在不会进行覆盖，返回结果是0
（2）Expire
expire key timeout
为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。
（3）Delete
delete key
删除key。在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。
1.2、实现原理
多个客户端（JVM），使用setnx命令方式，同时在redis上创建相同的一个key，因为redis key不能允许重复的唯一的，只要谁能够创建key成功，谁就能获取到锁，没有创建key成功，就会进行等待。
核心实现思路：多个服务器中，只能保证一个JVM进行做操作
（1）获取锁的时候：使用setnx加锁，并使用expire命令为锁添加一个超时时间。超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过这个值在释放锁的时候进行判断；
（2）获取锁的时候：还设置一个获取锁的超时时间，若超过这个时间则放弃获取锁；
（3）释放锁的时候：通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。
1.3、Redis实现分布式锁与Zookeeper实现分布式锁区别
相同点：在集群环境下，保证只允许有一个JVM进行执行程序
（1）技术角度不同：redis是nosql主要特点是缓存，ZK是分布式协调工具，主要用于分布式解决方案
（2）实现思路不同：核心都是获取锁、释放锁、死锁，但是他们实现思路不同
获取锁：ZK方面，多个客户端（也叫多个JVM）会在ZK上创建同一个临时节点，因为ZK节点命名路径保持唯一，只要谁创建成功谁就能获取到锁；Redis方面，多个客户端会在redis中使用setnx命令创建相同一个key，因为redis的key保证唯一，只要谁能先创建成功谁就获取锁。
释放锁：ZK方面，直接关闭临时节点session会话连接，因为临时节点生命周期与session会话是绑定一块的，如果session会话连接关闭，该临时节点也会被删除，这时候其他客户端使用事件监听，如果该临时节点被删除重新进入到获取锁的步骤；
Redis方面，释放锁时为了确保锁一致性问题，在删除redis的key的时候需要判断同一个锁的id，才能删除（不能删错）。
死锁（死锁是相同的思路）：ZK使用会话有效期方式解决死锁现象，Redis也是设置有效期解决死锁。
（3）性能不同：因为redis是nosql数据库，相对比来说redis性能要好点。
（4）可靠性不同：因为redis有效期不好控制，拿到锁之后再设置有效期，可能会产生有效期延迟；ZK先天性自带有效期功能，会话关闭就释放锁，ZK采用临时节点方式会更可靠。
最大的区别就是释放锁的区别，ZK可以通过事件通知释放锁。
1.4、一些常见疑惑
如何释放锁？
在执行完操作的时候，删除对应的key，每个对应的key有自己的有效期。
有效期的目的?
为了防止死锁现象
如何防止死锁？
设置session有效期
使用场景？
分布式系统中，比如抢购某一资源，这时候使用分布式锁可以很好的控制资源。
redis使用分布式锁中会遇到的问题？
（1）两个超时时间：
在获取锁之前的超时时间： 在尝试获取锁的时候，如果在规定时间内还没有获取到锁，直接放弃；
在获取锁之后的超时时间：获取锁之后，对应的key 有对应的有效期的，对应的key在 规定时间内进行失效。
二、实现的核心代码
下面是一种简单实现，并没有考虑太多的其他问题，主要是思想：
2.1、Maven依赖信息
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
2.2、LockRedis
public class LockRedis {
//redis线程池
private JedisPool jedisPool;
public LockRedis(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
/**
* redis 获取锁方法
* @param lockKey
* 锁的key<br>
* @param acquireTimeout
* 在没有上锁之前,获取锁的超时时间<br>
* @param timeOut
* 上锁成功后,锁的超时时间<br>
* @return
*/
public String lockWithTimeout(String lockKey, Long acquireTimeout, Long timeOut) {
Jedis conn = null;
String retIdentifierValue = null;
try {
// 1.建立redis连接
conn = jedisPool.getResource();
// 2.随机生成一个value
String identifierValue = UUID.randomUUID().toString();
// 3.定义锁的名称
String lockName = "redis_lock" + lockKey;
// 4.定义上锁成功之后,锁的超时时间
int expireLock = (int) (timeOut / 1000);//timeOut 一般以秒为单位，所以除1000
// 5.定义在没有获取锁之前,锁的超时时间
Long endTime = System.currentTimeMillis() + acquireTimeout;
//这个where是核心，通过循环方式重试获取锁
while (System.currentTimeMillis() < endTime) {//如果系统时间小于锁超时时间
//获取锁
// 6.使用setnx方法设置锁值
if (conn.setnx(lockName, identifierValue) == 1) {
// 7.判断返回结果如果为1,则可以成功获取锁,并且设置锁的超时时间
conn.expire(lockName, expireLock);
retIdentifierValue = identifierValue;
return retIdentifierValue;
}
// 8.否则情况下继续循环等待
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.close();
}
}
return retIdentifierValue;
}
/**
* 释放锁方法
*
* @return
*/
public boolean releaseLock(String lockKey, String identifier) {
Jedis conn = null;
boolean flag = false;
try {
// 1.建立redis连接
conn = jedisPool.getResource();
// 2.定义锁的名称
String lockName = "redis_lock" + lockKey;
// 3.如果value与redis中一直直接删除，否则等待超时
if (identifier.equals(conn.get(lockName))) {
conn.del(lockName);
System.out.println(identifier + "解锁成功......");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.close();
}
}
return flag;
}
}
LockService ：
释放锁的时候有两种方式：
（1）key自动有效期结束
（2）整个程序执行完毕情况下，删除对应key——这种方式是不行的，比如a上的锁就只能删除a的不能删除b的（删除时只能删除自己的，不能删除别人的）
public class LockService {
private static JedisPool pool = null;
//下面的就是redis连接代码（当然不是Springcloud方式的）
static {
JedisPoolConfig config = new JedisPoolConfig();
// 设置最大连接数
config.setMaxTotal(200);
// 设置最大空闲数
config.setMaxIdle(8);
// 设置最大等待时间
config.setMaxWaitMillis(1000 * 100);
// 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的
config.setTestOnBorrow(true);
pool = new JedisPool(config, "39.107.69.43", 6379, 3000);
}
//创建一个lock锁
LockRedis lockRedis = new LockRedis(pool);
public void seckill() {
String identifier = lockRedis.lockWithTimeout("xxx", 5000l, 5000l);
if (StringUtils.isEmpty(identifier)) {
// 获取锁失败
System.out.println(Thread.currentThread().getName() + ",获取锁失败，原因时间超时!!!");
return;
}
System.out.println(Thread.currentThread().getName() + "获取锁成功,锁id identifier:" + identifier + "，执行业务逻辑");
try {
Thread.sleep(30);
} catch (Exception e) {
}
// 释放锁
boolean releaseLock = lockRedis.releaseLock("xxx", identifier);
if (releaseLock) {
System.out.println(Thread.currentThread().getName() + "释放锁成功,锁id identifier:" + identifier);
}
}
}
释放锁也可以这样：
key中取到锁的id只要等于传入的值，就是同一把锁，这时就可以删除同一把锁
ThreadRedis ：
class ThreadRedis extends Thread {
private LockService lockService;
public ThreadRedis(LockService lockService) {
this.lockService = lockService;
}
@Override
public void run() {
lockService.seckill();
}
}
public class Test001 {
public static void main(String[] args) {
LockService lockService = new LockService();
for (int i = 0; i < 50; i++) {
ThreadRedis threadRedis = new ThreadRedis(lockService);
threadRedis.start();
}
}
}
