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

1.引言

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

1. 数据库乐观锁
2. 基于Zookeeper的分布式锁
3. 基于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。

实现思路:

1. 获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
2. 获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
3. 释放锁的时候，通过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

在分布式环境中，对资源进行上锁有时候是很重要的，比如抢购某一资源，这时候使用分布式锁就可以很好地控制资源。

当然，在具体使用中，还需要考虑很多因素，比如超时时间的选取，获取锁时间的选取对并发量都有很大的影响，上述实现的分布式锁也只是一种简单的实现，主要是一种思想。

总结