释放双眼，带上耳机，听听看~！
一、简介
一般来说，对数据进行加锁时，程序先通过acquire获取锁来对数据进行排他访问，然后对数据进行一些列的操作，最后需要释放锁。Redis 本身用 watch命令进行了加锁，这个锁是乐观锁。使用 watch命令对于频繁访问的键会引起性能的问题。
二、redis命令介绍
- SETNX命令（SET if Not eXists）
当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，并返回0。
- SETEX命令
设置超时时间
- GET命令
返回 key 所关联的字符串值，如果 key 不存在那么返回特殊值 nil 。
- DEL命令
删除给定的一个或多个 key ,不存在的 key 会被忽略。
三、实现思路
由于redis的setnx命令天生就适合用来实现锁的功能，这个命令只有在键不存在的情况下为键设置值。获取锁之后，其他程序再设置值就会失败，即获取不到锁。获取锁失败。只需不断的尝试获取锁，直到成功获取锁，或者到设置的超时时间为止。
另外为了防治死锁，即某个程序获取锁之后，程序出错，没有释放，其他程序无法获取锁，从而导致整个分布式系统无法获取锁而导致一系列问题，甚至导致系统无法正常运行。这时需要给锁设置一个超时时间，即setex命令，锁超时后，从而其它程序就可以获取锁了。
四、编码实现
本文采用springboot结合redis 取实现的，所以你需要装一个redis。
-
首先引入创建springboot工程，引入redis 。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2 <groupId>org.springframework.boot</groupId>
3 <artifactId>spring-boot-starter-test</artifactId>
4 <scope>test</scope>
5 </dependency>
6
7 <!-- 开启web-->
8 <dependency>
9 <groupId>org.springframework.boot</groupId>
10 <artifactId>spring-boot-starter-web</artifactId>
11 </dependency>
12
13 <!-- redis-->
14 <dependency>
15 <groupId>org.springframework.boot</groupId>
16 <artifactId>spring-boot-starter-data-redis</artifactId>
17 </dependency>
18
19
20
21
2.创建一个锁类
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2/**
3 * 全局锁，包括锁的名称
4 * Created by fangzhipeng on 2017/4/1.
5 */
6public class Lock {
7 private String name;
8 private String value;
9
10 public Lock(String name, String value) {
11 this.name = name;
12 this.value = value;
13 }
14
15 public String getName() {
16 return name;
17 }
18
19 public String getValue() {
20 return value;
21 }
22
23}
24
25
26
3.创建分布式锁的具体方法,思路已经说清楚了，代码注释也写好了，就不讲解了。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
2import org.slf4j.Logger;
3import org.slf4j.LoggerFactory;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.data.redis.core.StringRedisTemplate;
6import org.springframework.data.redis.core.ValueOperations;
7import org.springframework.stereotype.Component;
8
9import java.util.concurrent.TimeUnit;
10
11/**
12 * Created by fangzhipeng on 2017/4/1.
13 */
14@Component
15public class DistributedLockHandler {
16
17 private static final Logger logger = LoggerFactory.getLogger(DistributedLockHandler.class);
18 private final static long LOCK_EXPIRE = 30 * 1000L;//单个业务持有锁的时间30s，防止死锁
19 private final static long LOCK_TRY_INTERVAL = 30L;//默认30ms尝试一次
20 private final static long LOCK_TRY_TIMEOUT = 20 * 1000L;//默认尝试20s
21
22 @Autowired
23 private StringRedisTemplate template;
24
25 /**
26 * 尝试获取全局锁
27 *
28 * @param lock 锁的名称
29 * @return true 获取成功，false获取失败
30 */
31 public boolean tryLock(Lock lock) {
32 return getLock(lock, LOCK_TRY_TIMEOUT, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
33 }
34
35 /**
36 * 尝试获取全局锁
37 *
38 * @param lock 锁的名称
39 * @param timeout 获取超时时间 单位ms
40 * @return true 获取成功，false获取失败
41 */
42 public boolean tryLock(Lock lock, long timeout) {
43 return getLock(lock, timeout, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
44 }
45
46 /**
47 * 尝试获取全局锁
48 *
49 * @param lock 锁的名称
50 * @param timeout 获取锁的超时时间
51 * @param tryInterval 多少毫秒尝试获取一次
52 * @return true 获取成功，false获取失败
53 */
54 public boolean tryLock(Lock lock, long timeout, long tryInterval) {
55 return getLock(lock, timeout, tryInterval, LOCK_EXPIRE);
56 }
57
58 /**
59 * 尝试获取全局锁
60 *
61 * @param lock 锁的名称
62 * @param timeout 获取锁的超时时间
63 * @param tryInterval 多少毫秒尝试获取一次
64 * @param lockExpireTime 锁的过期
65 * @return true 获取成功，false获取失败
66 */
67 public boolean tryLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
68 return getLock(lock, timeout, tryInterval, lockExpireTime);
69 }
70
71
72 /**
73 * 操作redis获取全局锁
74 *
75 * @param lock 锁的名称
76 * @param timeout 获取的超时时间
77 * @param tryInterval 多少ms尝试一次
78 * @param lockExpireTime 获取成功后锁的过期时间
79 * @return true 获取成功，false获取失败
80 */
81 public boolean getLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
82 try {
83 if (StringUtils.isEmpty(lock.getName()) || StringUtils.isEmpty(lock.getValue())) {
84 return false;
85 }
86 long startTime = System.currentTimeMillis();
87 do{
88 if (!template.hasKey(lock.getName())) {
89 ValueOperations<String, String> ops = template.opsForValue();
90 ops.set(lock.getName(), lock.getValue(), lockExpireTime, TimeUnit.MILLISECONDS);
91 return true;
92 } else {//存在锁
93 logger.debug("lock is exist!！！");
94 }
95 if (System.currentTimeMillis() - startTime > timeout) {//尝试超过了设定值之后直接跳出循环
96 return false;
97 }
98 Thread.sleep(tryInterval);
99 }
100 while (template.hasKey(lock.getName())) ;
101 } catch (InterruptedException e) {
102 logger.error(e.getMessage());
103 return false;
104 }
105 return false;
106 }
107
108 /**
109 * 释放锁
110 */
111 public void releaseLock(Lock lock) {
112 if (!StringUtils.isEmpty(lock.getName())) {
113 template.delete(lock.getName());
114 }
115 }
116
117}
118
119
120
121
4.用法：
2
3
4
5
6
7
8
9
2DistributedLockHandler distributedLockHandler;
3Lock lock=new Lock("lockk","sssssssss);
4if(distributedLockHandler.tryLock(lock){
5 doSomething();
6 distributedLockHandler.releaseLock();
7}
8
9
五、注意点
在使用全局锁时为了防止死锁采用 setex命令，这种命令需要根据具体的业务具体设置锁的超时时间。另外一个就是锁的粒度性。比如在redis实战中有个案列，为了实现买卖市场交易的功能，把整个交易市场都锁住了，导致了性能不足的情况，改进方案只对买卖的商品进行加锁而不是整个市场。
六、参考资料
Josiah.L 《reids in action》
