1. 开局

在多线程环境中，经常会碰到需要加锁的情况，由于现在的系统基本都是集群分布式部署，JVM的lock已经不能满足分布式要求，分布式锁就这样产生了。。。

百度一下，网上有很多分布式锁的方案或者例子，琳琅满目，看了之后不知所措，总体来说有以下几种：

基于数据库

基于zookeeper

基于redis

基于memcached

各有优缺点和实现难度，这里就不一一分析。本文主要是基于redis的setnx实现分布式锁，比较简单有一定的局限性，欢迎大家提出意见建议！

2. 加锁过程

执行redis的setnx，只有key不存在才能set成功(实际使用的是set(key, value, "NX", "EX", seconds)，redis较新版本支持)

如果set成功(同时也设置了key的过期时间)，则表示加锁成功

如果set失败，则每次sleep(x)毫秒后不断尝试，直到成功或者超时

3. 释放过程

判断加锁是否成功

如果成功，则执行redis的del删除

4. 问题思考

加锁时，锁的redis key过期时间多长合适？

需要根据业务执行的时间长度来评估，默认30秒满足绝大部分需求，支持动态修改

加锁时，重试超时时间多长合适？本文设置的是过期时间的1.2倍，目的是在最坏的情况下等待锁过期后，尽量保证获取到锁，否则抛出超时异常。这个设置不完全合理

加锁时，重试的sleep时间多长合适？本文采用的是随机[50-300)毫秒，避免出现大量线程同时竞争，目的是错峰吧

释放时，如何避免释放了其他线程的锁(A获取锁后由于挂起导致锁到期自动释放；此时B获取到锁，而A又恢复运行释放了B的锁)？在初始化锁时生个一个唯一字符串，作为redis锁的value；value一致时表明是自己的锁，可以释放

5. 上代码！

用法

RedisLock lock = new RedisLock(redisHelper, lockKey);

try {

// 执行加锁，防止并发问题

lock.tryLock();

// do somethings

doSomethings()

}

finally {

// 释放锁

lock.release();

}

RedisLock实现(注：依赖RedisHepler类，仅仅是对jedis的一层封装，可自行实现)

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

* RedisLock

*

* @version 2017-9-21上午11:56:27

* @author xiaoyun.zeng

*/

public class RedisLock {

private Logger logger = LoggerFactory.getLogger(getClass());

/**

* key前缀

*/

private static final String PREFIX = "lock:";

/**

* 操作redis的工具类

*/

private RedisHelper redisHelper;

/**

* redis key

*/

private String redisKey = null;

/**

* redis value

*/

private String redisValue = null;

/**

* 锁的过期时间(秒)，默认30秒，防止线程获取锁后挂掉无法释放锁

*/

private int lockExpire = 30;

/**

* 尝试加锁超时时间(毫秒)，默认为expire的1.2倍

*/

private int tryTimeout = lockExpire * 1200;

/**

* 尝试加锁次数计数器

*/

private long tryCounter = 0;

/**

* 加锁成功标记

*/

private boolean success = false;

private long startMillis = 0;

private long expendMillis = 0;

/**

* RedisLock

*

* @param redisHelper

* @param lockKey

*/

public RedisLock(RedisHelper redisHelper, String lockKey) {

this.redisHelper = redisHelper;

this.redisKey = PREFIX + lockKey;

// 生成redis value，用于释放锁时比对是否属于自己的锁

// 生成规则 lockKey+时间戳+随机数，避免重复

// 乐观地认为：

// 1、同一毫秒内，随机数相同的概率极小

// 2、释放非自己线程锁的几率极小(release方法有说明这种情况)

this.redisValue = lockKey + "-" + System.currentTimeMillis() + "-" + this.random(10000);

}

/**

* RedisLock

*

* @param redisHelper

* @param lockKey

* @param expire

*/

public RedisLock(RedisHelper redisHelper, String lockKey, int lockExpire) {

this(redisHelper, lockKey);

// 过期时间

this.lockExpire = lockExpire;

// 超时时间(毫秒)，默认为expire的1.2倍

this.tryTimeout = lockExpire * 1200;

}

/**

* 尝试加锁

*

* 尝试加锁的过程将会一直阻塞下去，直到加锁成功或超时

*

* @version 2017-9-21下午12:00:07

* @author xiaoyun.zeng

* @return

*/

public void tryLock() throws RuntimeException {

startMillis = System.currentTimeMillis();

// 首次直接请求加锁

if (!lock()) {

do {

// 超时判断，避免永远获取不到锁的情况下，一直尝试

// 超时抛出runtime异常

if (System.currentTimeMillis() - startMillis >= tryTimeout) {

throw new RuntimeException("尝试加锁超时" + tryTimeout + "ms");

}

// 随机休眠[50-300)毫秒

// 避免出现大量线程同时竞争

try {

Thread.sleep(this.random(250) + 50);

}

catch (InterruptedException e) {

// 出现异常直接抛出

throw new RuntimeException(e);

}

}

while (!lock());

}

}

/**

* 释放锁

*

* @version 2017-9-21下午12:00:21

* @author xiaoyun.zeng

* @param lockKey

*/

public void release() {

// 加锁成功才执行释放

if (success) {

// 释放前，检查redis value是否一致

// 避免A获取锁后由于挂起导致锁到期自动释放

// 此时B获取到锁，而A又恢复运行释放了B的锁

String value = redisHelper.get(redisKey);

if (redisValue.equals(value)) {

redisHelper.del(redisKey);

logger.debug("已释放锁：{}", redisValue);

}

}

}

/**

* 加锁

*

* @version 2017-9-21下午6:25:58

* @author xiaoyun.zeng

* @param key

* @param value

* @param lockExpire

* @return

*/

private boolean lock() {

// 加锁计数器+1

tryCounter++;

// 调用redis setnx完成加锁，返回true表示加锁成功，否则失败

success = redisHelper.setNx(redisKey, redisValue, lockExpire);

// 计算总耗时

expendMillis = System.currentTimeMillis() - startMillis;

// 记录日志

if (success) {

logger.debug("加锁成功：尝试{}次，耗时{}ms，{}", tryCounter, expendMillis, redisValue);

}

return success;

}

/**

* 产生随机数

*

* @version 2017-9-22上午10:05:52

* @author xiaoyun.zeng

* @param max

* @return

*/

private int random(int max) {

return (int) (Math.random() * max);

}

}

6. 测试代码

单元测试：

@RunWith(SpringRunner.class)

@SpringBootTest

public class RedisLockTest {

@Autowired

private RedisHelper redisHelper;

@Test

public void test() {

for (int i = 0; i < 10; i++) {

new Thread(new Runnable() {

@Override

public void run() {

RedisLock lock = new RedisLock(redisHelper, "zxy");

try {

lock.tryLock();

try {

Thread.sleep(2 * 1000);

}

catch (InterruptedException e) {

e.printStackTrace();

}

}

finally {

lock.release();

}

}

}).start();

}

while(true) {

}

}

}

日志输出：

2017/10/12 17:47:28.335 [Thread-8] DEBUG [RedisLock.161] 加锁成功：尝试1次，耗时4ms，zxy-1507801648330-6665

2017/10/12 17:47:30.340 [Thread-8] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648330-6665

2017/10/12 17:47:30.351 [Thread-14] DEBUG [RedisLock.161] 加锁成功：尝试12次，耗时2018ms，zxy-1507801648333-6866

2017/10/12 17:47:32.356 [Thread-14] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648333-6866

2017/10/12 17:47:32.396 [Thread-11] DEBUG [RedisLock.161] 加锁成功：尝试22次，耗时4065ms，zxy-1507801648331-5217

2017/10/12 17:47:34.400 [Thread-11] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648331-5217

2017/10/12 17:47:34.430 [Thread-12] DEBUG [RedisLock.161] 加锁成功：尝试39次，耗时6098ms，zxy-1507801648332-7708

2017/10/12 17:47:36.433 [Thread-12] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648332-7708

2017/10/12 17:47:36.453 [Thread-17] DEBUG [RedisLock.161] 加锁成功：尝试50次，耗时8119ms，zxy-1507801648334-2362

2017/10/12 17:47:38.457 [Thread-17] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648334-2362

2017/10/12 17:47:38.494 [Thread-9] DEBUG [RedisLock.161] 加锁成功：尝试57次，耗时10164ms，zxy-1507801648330-7086

2017/10/12 17:47:40.497 [Thread-9] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648330-7086

2017/10/12 17:47:40.587 [Thread-13] DEBUG [RedisLock.161] 加锁成功：尝试70次，耗时12254ms，zxy-1507801648333-8881

2017/10/12 17:47:42.590 [Thread-13] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648333-8881

2017/10/12 17:47:42.611 [Thread-15] DEBUG [RedisLock.161] 加锁成功：尝试82次，耗时14276ms，zxy-1507801648335-2509

2017/10/12 17:47:44.614 [Thread-15] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648335-2509

2017/10/12 17:47:44.699 [Thread-16] DEBUG [RedisLock.161] 加锁成功：尝试89次，耗时16365ms，zxy-1507801648334-5791

2017/10/12 17:47:46.702 [Thread-16] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648334-5791

2017/10/12 17:47:46.802 [Thread-10] DEBUG [RedisLock.161] 加锁成功：尝试106次，耗时18471ms，zxy-1507801648331-7347

2017/10/12 17:47:48.805 [Thread-10] DEBUG [RedisLock.137] 已释放锁：zxy-1507801648331-7347