分布式系列教程（19） -基于Redis实现分布式锁

江南才子

　　
1.引言
　　我们知道实现分布式锁一般有几种实现方式：

数据库乐观锁

基于Zookeeper的分布式锁

基于Redis的分布式锁

　　在之前的章节《分布式协调工具Zookeeper（分布式锁实现）》中，已经实现了基于Zookeeper实现分布式锁，阅读本文之前可以去逛逛看看。
　　基于Zookeeper的分布式锁原理： 每个客户端对某个功能加锁时，在zookeeper上的与该功能对应的指定节点的目录下，生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。（优点：锁安全性高，zk可持久化）
1.1 三种分布式锁对比
　　上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

　　从理解的难易程度角度（从低到高）: 数据库 > 缓存 > Zookeeper
　　从实现的复杂性角度（从低到高）: Zookeeper >= 缓存 > 数据库
　　从性能角度（从高到低）:缓存 > Zookeeper >= 数据库
　　从可靠性角度（从高到低）: Zookeeper > 缓存 > 数据库

1.2 Redis实现分布式锁与Zookeeper实现分布式锁区别
　　1.使用redis实现分布式锁

redis中的set nx 命令，当key不存在时，才能在redis中将key添加成功，利用该属性可以实现分布式锁，并且redis对于key有失效时间，可以控制当某个客户端加锁成功之后挂掉，导致阻塞的问题。

　　2.使用Zookeeper实现分布式锁

多个客户端在Zookeeper上创建一个相同的临时节点，因为临时节点只能允许一个客户端创建成功，那么只要任意一个客户端创建节点成功，谁就成功的获取到锁，当释放锁后，其他客户端同样道理在创建Zookeeper节点。

　　现在开始讲解第三种方式，基于Redis实现分布式锁。

2.基于Redis实现分布式锁
　　先来熟悉几个Redis的命令，使用Redis实现分布式锁的时候，主要使用到这三个命令：

SETNX ：SETNX key val当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。
Expire ：expire key timeout 为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。
Delete ：删除key

　　实现原理：使用的是jedis来连接Redis。
　　实现思路:

获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

2.1 代码实现
　　1.添加maven依赖：

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>

　　2.LockRedis:

public class LockRedis {
// redis线程池
private JedisPool jedisPool;
// 同时在redis上创建相同的一个key 相同key 名称
private String redislockKey = "redis_lock";
public LockRedis(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
// redis 以key （redislockKey） 和value（随机不能够重复数字 锁的id）方式进行存储
// redis实现分布式锁 有两个超时 时间问题
/**
 * 两个超时时间含义：<br>
 * 1.在获取锁之前的超时时间----在尝试获取锁的时候，如果在规定的时间内还没有获取锁，直接放弃。<br>
 * 2.在获取锁之后的超时时间---当获取锁成功之后，对应的key 有对应有效期，对应的key 在规定时间内进行失效
 */
/**
 * acquireTimeout
 * 
 * @param acquireTimeout
 *      在获取锁之前的超时时间
 * @param timeOut
 *      在获取锁之后的超时时间
 */
// 基于redis实现分布式锁代码思路 核心方法 获取锁 、释放锁
public String getRedisLock(Long acquireTimeout, Long timeOut) {
Jedis conn = null;
try {
// 1.建立redis连接
conn = jedisPool.getResource();
// 2.定义 redis 对应key 的value值( uuid) 作用 释放锁 随机生成value
String identifierValue = UUID.randomUUID().toString();
// 3.定义在获取锁之后的超时时间
int expireLock = (int) (timeOut / 1000);// 以秒为单位
// 4.定义在获取锁之前的超时时间
// 5.使用循环机制 如果没有获取到锁，要在规定acquireTimeout时间 保证重复进行尝试获取锁（乐观锁）
// 使用循环方式重试的获取锁
Long endTime = System.currentTimeMillis() + acquireTimeout;
while (System.currentTimeMillis() < endTime) {
// 获取锁
// 6.使用setnx命令插入对应的redislockKey ，如果返回为1 成功获取锁
if (conn.setnx(redislockKey, identifierValue) == 1) {
// 设置对应key的有效期
conn.expire(redislockKey, expireLock);
return identifierValue;
}
// 获取锁之后，还要设置锁的超时时间 目的是为了防止死锁
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.close();
}
}
return null;
}
// 如果直接使用 conn.del(redislockKey); 保证对应是自己的创建redislockKey 删除对应自己的。
// 释放redis锁
public void unRedisLock(String identifierValue) {
Jedis conn = null;
// 1.建立redis连接
conn = jedisPool.getResource();
try {
// 如果该锁的id 等于identifierValue 是同一把锁情况才可以删除
if (conn.get(redislockKey).equals(identifierValue)) {
System.out.println("释放锁..." + Thread.currentThread().getName() + ",identifierValue:" + identifierValue);
conn.del(redislockKey);
}
} catch (Exception e)
{
} finally {
if (conn != null) {
conn.close();
}
}
// 释放锁有两种 key自动有有效期
// 整个程序执行完毕情况下，删除对应key
}
}

　　3.LockService

public class LockService {
  private static JedisPool pool = null;
  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, "192.168.162.131", 9001, 3000);
  }
  private LockRedis lockRedis = new LockRedis(pool);

  // 演示redis实现分布式锁
  public void seckill() throws InterruptedException {
    // 1.获取锁
    String identifierValue = lockRedis.getRedisLock(5000l, 5000l);
    if (identifierValue == null) {
      System.out.println(Thread.currentThread().getName() + ",!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!");
      return;
    }
    System.out.println(Thread.currentThread().getName() + ",获取锁成功,锁的id:" + identifierValue + ",正常执行业务了逻辑\n");
    Thread.sleep(100);
    // 2.释放锁
    lockRedis.unRedisLock(identifierValue);
  }
}

　　4.ThreadRedis

public class ThreadRedis extends Thread {
private LockService lockService;
public ThreadRedis(LockService lockService) {
this.lockService = lockService;
}
@Override
public void run() {
try {
lockService.seckill();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

　　5.测试：

public class Test {
public static void main(String[] args) {
LockService lockService = new LockService();
for (int i = 0; i < 50; i++) {
new ThreadRedis(lockService).start();
}
}
}

　　运行结果：

transport: 'socket'
Thread-37,获取锁成功,锁的id:564541d4-9bb2-4e5c-9aac-187d03e2b98a,正常执行业务了逻辑
释放锁...Thread-37,identifierValue:564541d4-9bb2-4e5c-9aac-187d03e2b98a
Thread-19,获取锁成功,锁的id:e0126c82-82a6-4a80-92f0-c3ab8e21d66b,正常执行业务了逻辑
释放锁...Thread-19,identifierValue:e0126c82-82a6-4a80-92f0-c3ab8e21d66b
Thread-18,获取锁成功,锁的id:cb3bc39d-1f6b-40fe-b644-1e87f4fde388,正常执行业务了逻辑
释放锁...Thread-18,identifierValue:cb3bc39d-1f6b-40fe-b644-1e87f4fde388
Thread-5,获取锁成功,锁的id:459cc932-7344-4353-88ff-5e95898d6f2f,正常执行业务了逻辑
释放锁...Thread-5,identifierValue:459cc932-7344-4353-88ff-5e95898d6f2f
Thread-24,获取锁成功,锁的id:172b5bb5-708c-47b8-80ba-0717d3984867,正常执行业务了逻辑
释放锁...Thread-24,identifierValue:172b5bb5-708c-47b8-80ba-0717d3984867
Thread-13,获取锁成功,锁的id:d96e7150-ecac-4551-a7db-afc5f697d1ed,正常执行业务了逻辑
释放锁...Thread-13,identifierValue:d96e7150-ecac-4551-a7db-afc5f697d1ed
Thread-33,获取锁成功,锁的id:11d104dd-a81f-4c2e-ba7f-0a9bbabdc660,正常执行业务了逻辑
释放锁...Thread-33,identifierValue:11d104dd-a81f-4c2e-ba7f-0a9bbabdc660
Thread-15,获取锁成功,锁的id:80f861eb-e227-4610-83c4-32a455b9673b,正常执行业务了逻辑
释放锁...Thread-15,identifierValue:80f861eb-e227-4610-83c4-32a455b9673b
Thread-52,获取锁成功,锁的id:18e5a751-5053-49e9-b578-413a8ac9bc1f,正常执行业务了逻辑
释放锁...Thread-52,identifierValue:18e5a751-5053-49e9-b578-413a8ac9bc1f
Thread-28,获取锁成功,锁的id:d1ae2a65-a2cb-42f7-9f61-0317fe420c52,正常执行业务了逻辑
释放锁...Thread-28,identifierValue:d1ae2a65-a2cb-42f7-9f61-0317fe420c52
Thread-39,获取锁成功,锁的id:c21a2461-5e26-40a1-8c8d-157de8138926,正常执行业务了逻辑
释放锁...Thread-39,identifierValue:c21a2461-5e26-40a1-8c8d-157de8138926
Thread-10,获取锁成功,锁的id:1652cb21-9647-4dfd-accb-0329dd19888e,正常执行业务了逻辑
释放锁...Thread-10,identifierValue:1652cb21-9647-4dfd-accb-0329dd19888e
Thread-36,获取锁成功,锁的id:9c984e0a-39b8-4ce7-89fa-8fb0e6da16df,正常执行业务了逻辑
释放锁...Thread-36,identifierValue:9c984e0a-39b8-4ce7-89fa-8fb0e6da16df
Thread-35,获取锁成功,锁的id:4f483414-e697-4259-937c-b574795a0bfa,正常执行业务了逻辑
释放锁...Thread-35,identifierValue:4f483414-e697-4259-937c-b574795a0bfa
Thread-6,获取锁成功,锁的id:03180ef6-c2fa-49ec-bf2a-af92430047a0,正常执行业务了逻辑
释放锁...Thread-6,identifierValue:03180ef6-c2fa-49ec-bf2a-af92430047a0
Thread-14,获取锁成功,锁的id:9f6e570a-41be-4a37-a70d-8185f34ababa,正常执行业务了逻辑
释放锁...Thread-14,identifierValue:9f6e570a-41be-4a37-a70d-8185f34ababa
Thread-47,获取锁成功,锁的id:1605d09d-520b-4509-a957-e32a82a1af60,正常执行业务了逻辑
释放锁...Thread-47,identifierValue:1605d09d-520b-4509-a957-e32a82a1af60
Thread-21,获取锁成功,锁的id:492c56f7-1db2-474a-88ae-3d99076b656b,正常执行业务了逻辑
释放锁...Thread-21,identifierValue:492c56f7-1db2-474a-88ae-3d99076b656b
Thread-22,获取锁成功,锁的id:3b7bfffb-6942-444f-8e0d-3c092373224f,正常执行业务了逻辑
释放锁...Thread-22,identifierValue:3b7bfffb-6942-444f-8e0d-3c092373224f
Thread-38,获取锁成功,锁的id:d6f9e2cf-9b6b-4d1e-85e8-389798c3d235,正常执行业务了逻辑
释放锁...Thread-38,identifierValue:d6f9e2cf-9b6b-4d1e-85e8-389798c3d235
Thread-50,获取锁成功,锁的id:9b3dde3a-2fbd-49bb-b0ae-e5c93f9a4db0,正常执行业务了逻辑
释放锁...Thread-50,identifierValue:9b3dde3a-2fbd-49bb-b0ae-e5c93f9a4db0
Thread-4,获取锁成功,锁的id:0718f907-0cec-4a63-a85f-c36db85ccf6e,正常执行业务了逻辑
释放锁...Thread-4,identifierValue:0718f907-0cec-4a63-a85f-c36db85ccf6e
Thread-30,获取锁成功,锁的id:da269c5f-0cf4-42d1-b254-d3ff24fafc1f,正常执行业务了逻辑
释放锁...Thread-30,identifierValue:da269c5f-0cf4-42d1-b254-d3ff24fafc1f
Thread-26,获取锁成功,锁的id:b125cb58-6a91-46c0-8dd4-b0cc5a0e20f6,正常执行业务了逻辑
释放锁...Thread-26,identifierValue:b125cb58-6a91-46c0-8dd4-b0cc5a0e20f6
Thread-40,获取锁成功,锁的id:d087f80a-c17e-4781-a261-de2a2ad2af82,正常执行业务了逻辑
释放锁...Thread-40,identifierValue:d087f80a-c17e-4781-a261-de2a2ad2af82
Thread-51,获取锁成功,锁的id:5b02ab8a-bf27-49f9-9567-c038f9db6a3d,正常执行业务了逻辑
释放锁...Thread-51,identifierValue:5b02ab8a-bf27-49f9-9567-c038f9db6a3d
Thread-31,获取锁成功,锁的id:07d7e726-3c3b-4369-b42d-e9da463b1acb,正常执行业务了逻辑
释放锁...Thread-31,identifierValue:07d7e726-3c3b-4369-b42d-e9da463b1acb
Thread-49,获取锁成功,锁的id:9e815f11-e737-4d53-a183-d9c2c2c19423,正常执行业务了逻辑
释放锁...Thread-49,identifierValue:9e815f11-e737-4d53-a183-d9c2c2c19423
Thread-44,获取锁成功,锁的id:f4401cc2-0722-4dff-b12e-cafc5b05915f,正常执行业务了逻辑
释放锁...Thread-44,identifierValue:f4401cc2-0722-4dff-b12e-cafc5b05915f
Thread-43,获取锁成功,锁的id:e5963112-74cb-4890-b97d-09132bd71726,正常执行业务了逻辑
释放锁...Thread-43,identifierValue:e5963112-74cb-4890-b97d-09132bd71726
Thread-42,获取锁成功,锁的id:11a06537-e577-48e9-bc14-7b9b6e64eb2d,正常执行业务了逻辑
释放锁...Thread-42,identifierValue:11a06537-e577-48e9-bc14-7b9b6e64eb2d
Thread-27,获取锁成功,锁的id:1edf0b7b-2f33-4319-a7dd-de5782ac1b7c,正常执行业务了逻辑
释放锁...Thread-27,identifierValue:1edf0b7b-2f33-4319-a7dd-de5782ac1b7c
Thread-29,获取锁成功,锁的id:c2c17420-b524-4c70-afd9-5bb6624425a5,正常执行业务了逻辑
释放锁...Thread-29,identifierValue:c2c17420-b524-4c70-afd9-5bb6624425a5
Thread-16,获取锁成功,锁的id:6168e8af-e4bd-438f-9f76-af721ca7d2b3,正常执行业务了逻辑
释放锁...Thread-16,identifierValue:6168e8af-e4bd-438f-9f76-af721ca7d2b3
Thread-46,获取锁成功,锁的id:fefd6988-04fb-4815-b25b-cceda0cb647e,正常执行业务了逻辑
释放锁...Thread-46,identifierValue:fefd6988-04fb-4815-b25b-cceda0cb647e
Thread-45,获取锁成功,锁的id:ceed34f2-2bb8-42a8-b3c9-a054639c54bc,正常执行业务了逻辑
Thread-11,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-25,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-3,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-17,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-32,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-8,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-41,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-9,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-7,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-34,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-48,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-12,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-20,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
Thread-23,!!!!!!!!获取锁失败，获取锁时间超时!!!!!!!!
释放锁...Thread-45,identifierValue:ceed34f2-2bb8-42a8-b3c9-a054639c54bc

　　在分布式环境中，对资源进行上锁有时候是很重要的，比如抢购某一资源，这时候使用分布式锁就可以很好地控制资源。
　　当然，在具体使用中，还需要考虑很多因素，比如超时时间的选取，获取锁时间的选取对并发量都有很大的影响，上述实现的分布式锁也只是一种简单的实现，主要是一种思想。

总结

[NoSQL] 分布式系列教程（19） -基于Redis实现分布式锁

相关帖子

wps怎么设置文字框文字框设置方法

怎么用U盘重装Win11系统 U盘重装Win11系统操作方法

word文档操作痕迹的查看方法

Mysql8导入数据到Mysql5.7的实现步骤

了解下Foundation 按钮组

风冷散热器怎么看好坏？

javascript怎么实现窗口置顶

JavaScript怎样实现点击出现图片效果

使用原生querySelectorAll和forEach来实现点击切换

免插件、DZ内置JS轻松实现外链访问二次确认对话提示框

江南才子 LV4