分布式锁
分布式锁
分布式锁是控制分布式系统或不同系统之间共同访问共享资源的一种锁实现。如果不同的系统或同一个系统的不同主机之间共享了某个资源时，往往通过互斥来防止彼此干扰。
分布锁设计目的
可以保证在分布式部署的应用集群中，同一个方法在同一操作只能被一台机器上的一个线程执行。
锁的设计要求
- 这把锁要是一把可重入锁（避免死锁）
- 这把锁有高可用的获取锁和释放锁功能
- 这把锁获取锁和释放锁的性能要好…
分布式锁实现方案分析
- 获取锁的时候，使用 setnx(SETNX key val:当且仅当 key 不存在时，set 一个 key 为 val 的字符串，返回 1; 若 key 存在，则什么都不做，返回 【0】加锁，锁的 value 值为当前占有锁服务器内网 IP 编号拼接任务标识组成。在释放锁的时候进行判断。并使用 expire 命令为锁添 加一个超时时间，超过该时间则自动释放锁。
- 获取锁的时候调用 setnx， 如果返回 0，则该锁正在被被人使用，返回 1，则成功获取锁。还设置一个获取的超时时间，若超过这个时间则放弃获取锁。 setex (key,value,expire) 过期以秒为单位。
- 释放锁的时候，判断是不是该锁（即 Value 为当前服务器内网 IP 编号拼接任务标识），若是该锁，则执行 delete 进行锁释放
Redis 分布式锁应用
启动类添加注解 @EnableScheduling
1@EnableScheduling
服务器 log 日志打印
引入 logback-spring.xml
application.properties 加入路径引用
1logging.config=classpath:logback-spring.xml
2logging.path=/data/java/weblog/8082
编写任务计划类
1import org.slf4j.Logger;
2import org.slf4j.LoggerFactory;
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.data.redis.core.RedisTemplate;
5import org.springframework.scheduling.annotation.Scheduled;
6import org.springframework.stereotype.Service;
7import java.net.Inet4Address;
8import java.net.InetAddress;
9import java.net.NetworkInterface;
10import java.net.UnknownHostException;
11import java.util.Enumeration;
12
13@Service
14public class LockNxExJob {
15
16 private static final Logger logger = LoggerFactory.getLogger(LockNxExJob.class);
17
18 @Autowired
19 private RedisService redisService;
20 @Autowired
21 private RedisTemplate redisTemplate;
22
23 private static String LOCK_PREFIX = "prefix_";
24
25 // 秒 分 时 日 月 年
26 @Scheduled(cron = "0/10 * * * * *")
27 public void lockJob() {
28 String lock = LOCK_PREFIX + "LockNxExJob";
29 boolean nxRet = false;
30 try{
31
32 //redistemplate setnx操作 返回true代表获取锁成功，false表示获取锁失败。
33 nxRet = redisTemplate.opsForValue().setIfAbsent(lock,getHostIp());
34 Object lockValue = redisService.get(lock);
35
36 //如果获取锁失败：打印出当前占用锁的服务器IP地址
37 if(!nxRet){
38 String value = (String)redisService.get(lock);
39 //日志记录：打印当前占用锁的服务器IP
40 logger.info("get lock fail,lock belong to:{}",value);
41 return;
42 }else{
43 //如果获取锁成功，则设置超时时间
44 redisTemplate.opsForValue().set(lock,getHostIp(),3600);
45
46 //日志记录：获取锁成功
47 logger.info("start lock lockNxExJob success");
48
49 //模拟执行业务消耗的时间
50 Thread.sleep(5000);
51 }
52 }catch (Exception e){
53 logger.error("lock error",e);
54
55 }finally {
56 //如果获取锁成功，则一定会释放锁
57 if(nxRet){
58 logger.info("release lock success");
59 redisService.remove(lock);
60 }
61 }
62 }
63
64 /**
65 * 获取本机内网IP地址方法
66 * @return
67 */
68 private static String getHostIp(){
69 try{
70 Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
71 while (allNetInterfaces.hasMoreElements()){
72 NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
73 Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
74 while (addresses.hasMoreElements()){
75 InetAddress ip = (InetAddress) addresses.nextElement();
76 if (ip != null
77 && ip instanceof Inet4Address
78 && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
79 && ip.getHostAddress().indexOf(":")==-1){
80 return ip.getHostAddress();
81 }
82 }
83 }
84 }catch(Exception e){
85 e.printStackTrace();
86 }
87 return null;
88 }
89
90 public static void main(String[] args) {
91 String localIP = "";
92 try {
93 localIP = getHostIp();
94 } catch (Exception e) {
95 e.printStackTrace();
96 }
97 //获取本机IP
98 System.out.println(localIP);
99 }
100}
启动项目
nohup 的意思是忽略 SIGHUP 信号， 所以当运行 nohup a.jar 的时候， 关闭 shell, 那么 a.jar 进程还是存在的（对 SIGHUP 信号免疫）
1nohup java -jar jar名 &
控制台输出
1start lock lockNxExJob success
2release lock success
3start lock lockNxExJob success
4release lock success
Redis 分布式锁可能出现的问题
- ServerDown 和 Redis Down 发生的时间随机性会分隔 Redis 客户端程序中的 setnx 和 setex 操作，导致其失去了原子性，从而引发被持有锁没有过期时间，分布式系统中其他线程一直处于尝试获取锁的状态。
解决方案一：采用 Lua 脚本
解决方案二：Redis 从 2.6 版本之后支持 setnx、setex 连用的原子性操作接口
Lua 脚本实现分布式锁的原子性
从 Redis 2.6.0 版本开始，通过内置的 Lua 解释器，可以使用 EVAL 命令对 Lua 脚本进行求值。
Redis 使用单个 Lua 解释器去运行所有脚本，并且， Redis 也保证脚本会以原子性(atomic)的方式执行：当某个脚本正在运行的时候，不会有其他脚本或 Redis 命令被执行。这和使用 MULTI / EXEC 包围的事务很类似。在其他别的客户端看来，脚本的效果(effect)要么是不可见的(not visible)，要么就是已完成的(already completed)。
Lua 脚本配置流程
1、在 resource 目录下面新增一个后缀名为。lua 结尾的文件
2、编写 lua 脚本
1local lockKey = KEYS[1]
2local lockValue = KEYS[2]
3
4-- setnx info
5local result_1 = redis.call('SETNX', lockKey, lockValue)
6if result_1 == true
7then
8local result_2= redis.call('SETEX', lockKey,3600, lockValue)
9return result_1
10else
11return result_1
12end
3、传入 lua 脚本的 key 和 arg
4、调用 redisTemplate.execute 方法执行脚本
1import org.slf4j.Logger;
2import org.slf4j.LoggerFactory;
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.core.io.ClassPathResource;
5import org.springframework.data.redis.core.RedisTemplate;
6import org.springframework.data.redis.core.script.DefaultRedisScript;
7import org.springframework.scheduling.annotation.Scheduled;
8import org.springframework.scripting.support.ResourceScriptSource;
9import org.springframework.stereotype.Service;
10import java.net.Inet4Address;
11import java.net.InetAddress;
12import java.net.NetworkInterface;
13import java.util.ArrayList;
14import java.util.Enumeration;
15import java.util.List;
16
17@Service
18public class LuaDistributeLock {
19 private static final Logger logger = LoggerFactory.getLogger(LockNxExJob.class);
20
21 @Autowired
22 private RedisService redisService;
23 @Autowired
24 private RedisTemplate redisTemplate;
25
26 private static String LOCK_PREFIX = "lua_";
27
28 private DefaultRedisScript<Boolean> lockScript;
29
30 @Scheduled(cron = "0/10 * * * * *")
31 public void lockJob() {
32
33 String lock = LOCK_PREFIX + "LockNxExJob";
34
35 boolean luaRet = false;
36 try {
37 luaRet = luaExpress(lock,getHostIp());
38
39 //获取锁失败
40 if (!luaRet) {
41 String value = (String) redisService.genValue(lock);
42 //打印当前占用锁的服务器IP
43 logger.info("lua get lock fail,lock belong to:{}", value);
44 return;
45 } else { //获取锁成功
46 logger.info("lua start lock lockNxExJob success");
47 Thread.sleep(5000);
48 }
49 } catch (Exception e) {
50 logger.error("lock error", e);
51
52 } finally {
53 if (luaRet) {
54 logger.info("release lock success");
55 redisService.remove(lock);
56 }
57 }
58 }
59
60 /**
61 * 获取lua结果
62 * @param key
63 * @param value
64 * @return
65 */
66 public Boolean luaExpress(String key,String value) {
67 //创建操作lua脚本的类
68 lockScript = new DefaultRedisScript<Boolean>();
69 lockScript.setScriptSource(
70 new ResourceScriptSource(new ClassPathResource("add.lua")));
71 lockScript.setResultType(Boolean.class);
72 // 封装参数
73 List<Object> keyList = new ArrayList<Object>();
74 keyList.add(key);
75 keyList.add(value);
76 Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
77 return result;
78 }
79
80 /**
81 * 获取本机内网IP地址方法
82 *
83 * @return
84 */
85 private static String getHostIp() {
86 try {
87 Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
88 while (allNetInterfaces.hasMoreElements()) {
89 NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
90 Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
91 while (addresses.hasMoreElements()) {
92 InetAddress ip = (InetAddress) addresses.nextElement();
93 if (ip != null
94 && ip instanceof Inet4Address
95 && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
96 && ip.getHostAddress().indexOf(":") == -1) {
97 return ip.getHostAddress();
98 }
99 }
100 }
101 } catch (Exception e) {
102 e.printStackTrace();
103 }
104 return null;
105 }
106}
控制台输出
1lua start lock lockNxExJob success
2release lock success
3lua start lock lockNxExJob success
4release lock success
RedisConnection 实现分布式锁
Redis2.6 版本以后才支持，采用 redisTemplate 操作 redisConnection 实现 setnx 和 setex 两个命令连用。
分布式锁优化分析之解锁注意事项
Maven 依赖
1<dependencies>
2 <dependency>
3 <groupId>org.springframework.boot</groupId>
4 <artifactId>spring-boot-starter</artifactId>
5 </dependency>
6
7 <dependency>
8 <groupId>org.springframework.boot</groupId>
9 <artifactId>spring-boot-starter-test</artifactId>
10 <scope>test</scope>
11 </dependency>
12
13 <dependency>
14 <groupId>org.springframework.boot</groupId>
15 <artifactId>spring-boot-starter-web</artifactId>
16 </dependency>
17
18 <dependency>
19 <groupId>org.springframework.boot</groupId>
20 <artifactId>spring-boot-starter-data-redis</artifactId>
21 </dependency>
22
23 <dependency>
24 <groupId>mysql</groupId>
25 <artifactId>mysql-connector-java</artifactId>
26 </dependency>
27 <dependency>
28 <groupId>org.mybatis.spring.boot</groupId>
29 <artifactId>mybatis-spring-boot-starter</artifactId>
30 <version>1.3.0</version>
31 </dependency>
32
33 <dependency>
34 <groupId>org.mybatis.generator</groupId>
35 <artifactId>mybatis-generator-core</artifactId>
36 <scope>test</scope>
37 <version>1.3.2</version>
38 <optional>true</optional>
39 </dependency>
40 <dependency>
41 <groupId>org.springframework.boot</groupId>
42 <artifactId>spring-boot-starter-jdbc</artifactId>
43 </dependency>
44
45 <dependency>
46 <groupId>com.alibaba</groupId>
47 <artifactId>druid</artifactId>
48 <version>1.1.10</version>
49 </dependency>
50
51 <dependency>
52 <groupId>com.alibaba</groupId>
53 <artifactId>fastjson</artifactId>
54 <version>1.2.7</version>
55 </dependency>
56
57 <dependency>
58 <groupId>org.springframework.boot</groupId>
59 <artifactId>spring-boot-starter-cache</artifactId>
60 </dependency>
61
62 <dependency>
63 <groupId>org.springframework.session</groupId>
64 <artifactId>spring-session-data-redis</artifactId>
65 </dependency>
66
67 <dependency>
68 <groupId>org.mybatis.generator</groupId>
69 <artifactId>mybatis-generator-core</artifactId>
70 <scope>test</scope>
71 <version>1.3.2</version>
72 <optional>true</optional>
73 </dependency>
74
75 <dependency>
76 <groupId>commons-io</groupId>
77 <artifactId>commons-io</artifactId>
78 <version>2.5</version>
79 </dependency>
80
81 <dependency>
82 <groupId>org.apache.commons</groupId>
83 <artifactId>commons-lang3</artifactId>
84 <version>3.1</version>
85 </dependency>
86
87 <dependency>
88 <groupId>redis.clients</groupId>
89 <artifactId>jedis</artifactId>
90 <version>2.9.0</version>
91 </dependency>
92 <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
93
94 </dependencies>
添加 unlock.lua
根据同一个 key 下的不同 value 进行判断，value 是持有锁进程的 ip 地址，这样每个进程只能自己释放自己的锁，无法释放不属于自己的锁，从而解决了 ServerA 执行时间超过了锁的过期时间，ServerA 的 finally 中解锁操作，误解锁 ServerB 的锁。
1local lockKey = KEYS[1]
2local lockValue = KEYS[2]
3
4-- get key
5local result_1 = redis.call('get', lockKey)
6if result_1 == lockValue
7then
8local result_2 = redis.call('del', lockKey)
9return result_2
10else
11return false
12end
RedisConnection 实现 setNx 和 setEx 命令的原子性 + 细粒度解锁
1@Component
2public class JedisDistributedLock {
3
4 private final Logger logger = LoggerFactory.getLogger(JedisDistributedLock.class);
5
6 private static String LOCK_PREFIX = "JedisDistributedLock_";
7
8 private DefaultRedisScript<Boolean> lockScript;
9
10 @Resource
11 private RedisTemplate<Object, Object> redisTemplate;
12
13 @Autowired
14 private RedisService redisService;
15
16 public static final String UNLOCK_LUA;
17
18 static {
19 StringBuilder sb = new StringBuilder();
20 sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
21 sb.append("then ");
22 sb.append(" return redis.call(\"del\",KEYS[1]) ");
23 sb.append("else ");
24 sb.append(" return 0 ");
25 sb.append("end ");
26 UNLOCK_LUA = sb.toString();
27 }
28
29 @Scheduled(cron = "0/10 * * * * *")
30 public void lockJob() {
31
32 String lock = LOCK_PREFIX + "JedisNxExJob";
33 boolean lockRet = false;
34 try {
35 lockRet = this.setLock(lock, 600);
36
37 //获取锁失败
38 if (!lockRet) {
39 String value = (String) redisService.genValue(lock);
40 //打印当前占用锁的服务器IP
41 logger.info("jedisLockJob get lock fail,lock belong to:{}", value);
42 return;
43 } else {
44 //获取锁成功
45 logger.info("jedisLockJob start lock lockNxExJob success");
46 Thread.sleep(5000);
47 }
48 } catch (Exception e) {
49 logger.error("jedisLockJob lock error", e);
50
51 } finally {
52 if (lockRet) {
53 logger.info("jedisLockJob release lock success");
54 releaseLock(lock,getHostIp());
55 }
56 }
57 }
58
59 public boolean setLock(String key, long expire) {
60 try {
61 Boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
62 @Override
63 public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
64 return connection.set(key.getBytes(), getHostIp().getBytes(), Expiration.seconds(expire) ,RedisStringCommands.SetOption.ifAbsent());
65 }
66 });
67 return result;
68 } catch (Exception e) {
69 logger.error("set redis occured an exception", e);
70 }
71 return false;
72 }
73
74 public String get(String key) {
75 try {
76 RedisCallback<String> callback = (connection) -> {
77 JedisCommands commands = (JedisCommands) connection.getNativeConnection();
78 return commands.get(key);
79 };
80 String result = redisTemplate.execute(callback);
81 return result;
82 } catch (Exception e) {
83 logger.error("get redis occured an exception", e);
84 }
85 return "";
86 }
87
88 /**
89 * 释放锁操作
90 * @param key
91 * @param value
92 * @return
93 */
94 private boolean releaseLock(String key, String value) {
95 lockScript = new DefaultRedisScript<Boolean>();
96 lockScript.setScriptSource(
97 new ResourceScriptSource(new ClassPathResource("unlock.lua")));
98 lockScript.setResultType(Boolean.class);
99 // 封装参数
100 List<Object> keyList = new ArrayList<Object>();
101 keyList.add(key);
102 keyList.add(value);
103 Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
104 return result;
105 }
106
107 /**
108 * 获取本机内网IP地址方法
109 *
110 * @return
111 */
112 private static String getHostIp() {
113 try {
114 Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
115 while (allNetInterfaces.hasMoreElements()) {
116 NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
117 Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
118 while (addresses.hasMoreElements()) {
119 InetAddress ip = (InetAddress) addresses.nextElement();
120 if (ip != null
121 && ip instanceof Inet4Address
122 && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
123 && ip.getHostAddress().indexOf(":") == -1) {
124 return ip.getHostAddress();
125 }
126 }
127 }
128 } catch (Exception e) {
129 e.printStackTrace();
130 }
131 return null;
132 }
133
134}