在单机应用中通过使用synchronized
关键字、JUC
的Lock
来实现线程安全是没问题的,但在分布式环境中就有可能出现问题,因为这些同步机制、锁是不能跨机器的,所以这里介绍的分布式锁就很有必要。
首先创建两个Spring Boot
项目。
pom.xml
(两个项目都一样):
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.kaven</groupId>
<artifactId>distributelock</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>distributelock</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
Jedis
组件(两个项目都一样):
package com.kaven.distributelock.component;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
@Component
public class JedisComponent {
@Bean
public Jedis jedis(){
return new Jedis("localhost",6379);
}
}
项目一接口:
package com.kaven.distributelock.controller;
import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
@RestController
public class NumberController {
private AtomicInteger count = new AtomicInteger(0);
@Resource
private Jedis jedis;
@PutMapping("/number")
public synchronized void subNumber() throws InterruptedException {
Integer number = Integer.parseInt(jedis.get("number"));
Thread.sleep(400);
number-=1;
jedis.set("number" , number.toString());
count.addAndGet(1);
System.out.println(count.get());
}
}
项目二接口:
package com.kaven.distributelock.controller;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
import javax.annotation.Resource;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
@RestController
public class NumberController {
private AtomicInteger count = new AtomicInteger(0);
@Resource
private Jedis jedis;
@PutMapping("/number")
public synchronized void subNumber() throws InterruptedException {
Integer number = Integer.parseInt(jedis.get("number"));
Thread.sleep(1000);
number-=1;
jedis.set("number" , number.toString());
count.addAndGet(1);
System.out.println(count.get());
}
}
启动类(两个项目都一样):
package com.kaven.distributelock;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DistributeLockApplication {
public static void main(String[] args) {
SpringApplication.run(DistributeLockApplication.class, args);
}
}
项目一运行在8080
端口,项目二运行在8081
端口。测试:
从上面几张图可以得知,项目一接口会将number
减100
次,而项目二接口会将number
减50
次,并且都执行成功了,理想情况下redis
里面的number
应该为0
,但实际情况却为86
,如下图所示,所以synchronized
关键字在分布式环境下是不能保障数据同步的(只能单机应用场景的锁,是不能保障分布式环境下数据同步)。
接下来使用Jedis
实现分布式锁(两个项目都一样):
package com.kaven.distributelock.lock;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;
import java.util.Collections;
public class JedisLock {
private static final String LOCK_SUCCESS = "OK";
private static final Long RELEASE_SUCCESS = 1L;
/**
* 尝试获取分布式锁
* @param jedis Redis客户端
* @param lockKey 锁
* @param requestId 请求标识
* @param millisecondsToExpire 超期时间
* @return 是否获取成功
*/
public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, long millisecondsToExpire) {
String result = jedis.set(lockKey,requestId, SetParams.setParams().nx().px(millisecondsToExpire));
if (LOCK_SUCCESS.equals(result)) {
return true;
}
return false;
}
/**
* 释放分布式锁
* @param jedis Redis客户端
* @param lockKey 锁
* @param requestId 请求标识
* @return 是否释放成功
*/
public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
if (RELEASE_SUCCESS.equals(result)) {
return true;
}
return false;
}
}
项目一接口:
package com.kaven.distributelock.controller;
import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
@RestController
public class NumberController {
private AtomicInteger count = new AtomicInteger(0);
@Resource
private Jedis jedis;
@PutMapping("/number")
public void subNumber() throws InterruptedException {
String requestId = UUID.randomUUID().toString();
String LOCKKEY = "LOCKKEY";
if(JedisLock.tryGetDistributedLock(jedis , LOCKKEY , requestId , 3000)){
Integer number = Integer.parseInt(jedis.get("number"));
Thread.sleep(400);
number-=1;
jedis.set("number" , number.toString());
count.addAndGet(1);
System.out.println(count.get());
JedisLock.releaseDistributedLock(jedis , LOCKKEY , requestId);
}
}
}
项目二接口:
package com.kaven.distributelock.controller;
import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
@RestController
public class NumberController {
private AtomicInteger count = new AtomicInteger(0);
@Resource
private Jedis jedis;
@PutMapping("/number")
public void subNumber() throws InterruptedException {
String requestId = UUID.randomUUID().toString();
String LOCKKEY = "LOCKKEY";
if(JedisLock.tryGetDistributedLock(jedis , LOCKKEY , requestId , 3000)){
Integer number = Integer.parseInt(jedis.get("number"));
Thread.sleep(1000);
number-=1;
jedis.set("number" , number.toString());
count.addAndGet(1);
System.out.println(count.get());
JedisLock.releaseDistributedLock(jedis , LOCKKEY , requestId);
}
}
}
将redis
里面的number
变量设置成3000
(字符串),因为没有获取到锁的话,代码就直接跑完了,所以这里让测试次数多一些,项目一接口请求2000
次,项目二接口请求1000
次(因为获取到锁只是少部分)。
同时点击测试。
项目一接口获取到锁34
次。
项目二接口获取到锁218
次。
结果很显然是正确的(34+218=3000-2748
)。Spring Boot
使用Jedis
实现分布式锁就介绍到这里,写博客是博主记录自己的学习过程,如果有错误,请指正,谢谢!