原文：http://liaoke0123.iteye.com/blog/2375469

利用redis實現分布式鎖，網上搜索的大部分是使用java jedis實現的。

redis官方推薦的分布式鎖實現為redisson http://ifeve.com/redis-lock/

以下為spring boot實現分布式鎖的步驟

項目pom中需要添加官方依賴 我是1.8JDK固為

1. <!-- redisson -->
2. <dependency>
3. <groupId>org.redisson</groupId>
4. <artifactId>redisson</artifactId>
5. <version>3.4.2</version>
6. </dependency>

定義一個分布式鎖的回調類

1. package com.example.demo.redis2;
3. /**
4. * 分布式鎖回調接口
5. *
6. * @author lk
7. */
8. public interface DistributedLockCallback<T> {
10. /**
11. * 調用者必須在此方法中實現需要加分布式鎖的業務邏輯
12. *
13. * @return
14. */
15. public T process();
17. /**
18. * 得到分布式鎖名稱
19. *
20. * @return
21. */
22. public String getLockName();
23. }

分布式鎖操作模板

1. package com.example.demo.redis2;
2. import java.util.concurrent.TimeUnit;
4. /**
5. * 分布式鎖操作模板
6. *
7. * @author lk
8. */
9. public interface DistributedLockTemplate {
10. /**
11. * 使用分布式鎖，使用鎖默認超時時間。
12. *
13. * @param callback
14. * @return
15. */
16. public <T> T lock(DistributedLockCallback<T> callback);
18. /**
19. * 使用分布式鎖。自定義鎖的超時時間
20. *
21. * @param callback
22. * @param leaseTime 鎖超時時間。超時後自動釋放鎖。
23. * @param timeUnit
24. * @return
25. */
26. public <T> T lock(DistributedLockCallback<T> callback, long leaseTime, TimeUnit timeUnit);
27. }

使用redisson最簡單的Single instance mode實現分布式鎖模板接口

1. package com.example.demo.redis2;
3. import org.redisson.api.RLock;
4. import org.redisson.api.RedissonClient;
6. import java.util.concurrent.TimeUnit;
8. /**
9. * Single Instance mode 分布式鎖模板
10. *
11. * @author lk
12. */
13. public class SingleDistributedLockTemplate implements DistributedLockTemplate {
14. private static final long DEFAULT_TIMEOUT = 5;
15. private static final TimeUnit DEFAULT_TIME_UNIT = TimeUnit.SECONDS;
17. private RedissonClient redisson;
19. public SingleDistributedLockTemplate() {
20. }
22. public SingleDistributedLockTemplate(RedissonClient redisson) {
23. this.redisson = redisson;
24. }
26. @Override
27. public <T> T lock(DistributedLockCallback<T> callback) {
28. return lock(callback, DEFAULT_TIMEOUT, DEFAULT_TIME_UNIT);
29. }
31. @Override
32. public <T> T lock(DistributedLockCallback<T> callback, long leaseTime, TimeUnit timeUnit) {
33. RLock lock = null;
34. try {
35. lock = redisson.getLock(callback.getLockName());
36. lock.lock(leaseTime, timeUnit);
37. return callback.process();
38. } finally {
39. if (lock != null) {
40. lock.unlock();
41. }
42. }
43. }
45. public void setRedisson(RedissonClient redisson) {
46. this.redisson = redisson;
47. }
49. }

創建可以被spring管理的 Bean

1. package com.example.demo.redis2;
3. import java.io.IOException;
4. import java.io.InputStream;
6. import javax.annotation.PostConstruct;
7. import javax.annotation.PreDestroy;
9. import org.apache.log4j.Logger;
10. import org.redisson.Redisson;
11. import org.redisson.api.RedissonClient;
12. import org.redisson.config.Config;
13. import org.springframework.beans.factory.FactoryBean;
15. /**
16. * 創建分布式鎖模板實例的工廠Bean
17. *
18. * @author lk
19. */
20. public class DistributedLockFactoryBean implements FactoryBean<DistributedLockTemplate> {
21. private Logger logger = Logger.getLogger(DistributedLockFactoryBean.class);
23. private LockInstanceMode mode;
25. private DistributedLockTemplate distributedLockTemplate;
27. private RedissonClient redisson;
29. @PostConstruct
30. public void init() {
31. String ip = "127.0.0.1";
32. String port = "6379";
33. Config config=new Config();
34. config.useSingleServer().setAddress(ip+":"+port);
35. redisson=Redisson.create(config);
36. System.out.println("成功連接Redis Server"+"\t"+"連接"+ip+":"+port+"服務器");
37. }
39. @PreDestroy
40. public void destroy() {
41. logger.debug("銷毀分布式鎖模板");
42. redisson.shutdown();
43. }
45. @Override
46. public DistributedLockTemplate getObject() throws Exception {
47. switch (mode) {
48. case SINGLE:
49. distributedLockTemplate = new SingleDistributedLockTemplate(redisson);
50. break;
51. }
52. return distributedLockTemplate;
53. }
55. @Override
56. public Class<?> getObjectType() {
57. return DistributedLockTemplate.class;
58. }
60. @Override
61. public boolean isSingleton() {
62. return true;
63. }
65. public void setMode(String mode) {
66. if (mode==null||mode.length()<=0||mode.equals("")) {
67. throw new IllegalArgumentException("未找到dlm.redisson.mode配置項");
68. }
69. this.mode = LockInstanceMode.parse(mode);
70. if (this.mode == null) {
71. throw new IllegalArgumentException("不支持的分布式鎖模式");
72. }
73. }
75. private enum LockInstanceMode {
76. SINGLE;
77. public static LockInstanceMode parse(String name) {
78. for (LockInstanceMode modeIns : LockInstanceMode.values()) {
79. if (modeIns.name().equals(name.toUpperCase())) {
80. return modeIns;
81. }
82. }
83. return null;
84. }
85. }
86. }

配置進spring boot中

1. package com.example.demo.redis2;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
6. /**
7. * Created by LiaoKe on 2017/5/22.
8. */
9. @Configuration
10. public class BeanConfig {
12. @Bean
13. public DistributedLockFactoryBean distributeLockTemplate(){
14. DistributedLockFactoryBean d = new DistributedLockFactoryBean();
15. d.setMode("SINGLE");
16. return d;
17. }
18. }

目前為止已經可以使用。

為了驗證鎖是否成功，我做了如下例子。

首先建立了一個數據庫實體（使用的JPA），模擬被購買的商品數量，當被購買後，num+1

在高並發環境下，這必定會有問題，因為在查詢之後的設值，存在對同一數據庫源的操作。

1. package com.example.demo.redis2.entity;
3. import org.hibernate.annotations.GenericGenerator;
5. import javax.persistence.Entity;
6. import javax.persistence.GeneratedValue;
7. import javax.persistence.Id;
9. /**
10. * 測試類實體
11. * Created by LiaoKe on 2017/5/22.
12. */
13. @Entity
14. public class TestEntity {
15. @Id
16. @GeneratedValue(generator = "system-uuid")
17. @GenericGenerator(name = "system-uuid", strategy = "uuid")
18. private String id;
19. private Integer num;
21. public String getId() {
22. return id;
23. }
25. public void setId(String id) {
26. this.id = id;
27. }
29. public Integer getNum() {
30. return num;
31. }
33. public void setNum(Integer num) {
34. this.num = num;
35. }
36. }

具體數據庫操作，加鎖和不加鎖的操作，要註意我使用了@Async，異步任務註解，我沒有配置線程池信息，使用的默認線程池。

1. package com.example.demo.redis2.service;
3. import com.example.demo.redis2.DistributedLockCallback;
4. import com.example.demo.redis2.DistributedLockTemplate;
5. import com.example.demo.redis2.dao.TestEntityRepository;
6. import com.example.demo.redis2.entity.TestEntity;
7. import org.springframework.scheduling.annotation.Async;
8. import org.springframework.stereotype.Service;
10. import javax.annotation.Resource;
12. /**
13. * Created by LiaoKe on 2017/5/22.
14. */
15. @Service
16. public class AsyncService {
18. @Resource
19. TestEntityRepository ts;
22. @Resource
23. DistributedLockTemplate distributedLockTemplate;
25. /**
26. * 加鎖
27. */
28. @Async
29. public void addAsync(){
30. distributedLockTemplate.lock(new DistributedLockCallback<Object>(){
31. @Override
32. public Object process() {
33. add();
34. return null;
35. }
37. @Override
38. public String getLockName() {
39. return "MyLock";
40. }
41. });
42. }
44. /**
45. * 未加鎖
46. */
47. @Async
48. public void addNoAsync(){
49. add();
50. }
52. /**
53. * 測試異步方法
54. * 在不加分布式鎖的情況下
55. * num數目會混亂
56. */
57. @Async
58. private void add(){
59. if(ts.findAll().size()==0){
60. TestEntity t = new TestEntity();
61. t.setNum(1);
62. ts.saveAndFlush(t);
63. }else{
64. TestEntity dbt = ts.findAll().get(0);
65. dbt.setNum(dbt.getNum()+1);
66. ts.saveAndFlush(dbt);
67. }
68. }
71. }

最後為了測試簡單跑了兩個接口

1. package com.example.demo;
3. import com.example.demo.redis2.DistributedLockTemplate;
4. import com.example.demo.redis2.service.AsyncService;
5. import oracle.jrockit.jfr.StringConstantPool;
6. import org.springframework.boot.SpringApplication;
7. import org.springframework.boot.autoconfigure.SpringBootApplication;
8. import org.springframework.context.annotation.Bean;
9. import org.springframework.scheduling.annotation.EnableAsync;
10. import org.springframework.stereotype.Controller;
11. import org.springframework.web.bind.annotation.GetMapping;
12. import org.springframework.web.bind.annotation.RestController;
14. import javax.annotation.Resource;
16. @SpringBootApplication
17. @RestController
18. @EnableAsync
19. public class DemoApplication {
21. public static void main(String[] args) {
22. SpringApplication.run(DemoApplication.class, args);
23. }
26. @Resource
27. AsyncService as;
30. @GetMapping("")
31. public void test(){
32. for(int i = 0 ;i<10000;i++){
33. as.addNoAsync();
34. }
35. }
37. @GetMapping("lock")
38. public void test2(){
39. for(int i = 0 ;i<10000;i++){
40. as.addAsync();
41. }
42. }
43. }

訪問localhost:8888 及 localhost:8888/lock

在不加鎖的情況下

數據庫已經爆炸了

最後得到的數據奇奇怪怪

使用加鎖後的訪問

可以看到庫存增加絕對正確。

此處並未使用任何數據庫鎖，並且基於redis，可在不同的網絡節點實現上鎖。

這只是簡單的實現，在真正的生產環境中，還要註意許多問題，超時和放鎖時機需要好好研究，在此不便貼真正項目代碼。

參考博客：http://layznet.iteye.com/blog/2307179 感謝作者

spring boot 利用redisson實現redis的分布式鎖