本章学习需要先安装 zookeeper。安装教程在另一篇博客:
https://blog.csdn.net/weixin_41622183/article/details/90714190
什么是分布式锁
以前在项目较小时,单机即可处理很多业务。但随着用户增长,单机已经无法满足当今业务。解决方案可能是上集群,但是在多个 JVM 中都有同一个变量。假设多个请求分到不同的 JVM 中,都对变量进行修改,这就造成变量可能会的不正确。
为了防止分布式系统中的多个进程之间相互干扰,需要一个分布式协调技术,这个技术便是分布式锁。
分布式锁和我们平常使用的锁类似
- 排他,只允许一个线程占用
- 可重入性,不可重入会造成死锁
- 具备失效机制,万一执行过程崩溃,也会有自动过期机制
zookeeper 分布式锁原理
zookeeper 实现分布式锁是基于 zookeeper 数据存储结构,zookeeper 的数据存储结构类似于一棵树。其中的节点叫 Znode。
Znode 有四种类型,分别为 持久节点(PERSISTENT)、持久节点顺序节点(PERSISTENT_SEQUENTIAL) 、临时节点(EPHEMERAL)、临时顺序节点(EPHEMERAL_SEQUENTIAL)。
而 zookeeper 实现分布式锁原理是依据临时顺序节点(EPHEMERAL_SEQUENTIAL) 来实现的。下面我们来学习一个 zookeeper 是如何利用临时顺序节点实现分布式锁的。
首先,我们创建一个持久节点 Lock,当客户端想要拿到锁时,需要创建一个临时节点 lock1。
这样,client-1 创建了临时节点 lock1 并拿到了锁。这时,假设又来了个 client-2 想要拿锁。
client-2 也在 Lock 下创建了临时节点 lock2,遍历 Lock 判断自己的 lock-2 前面是否前面是否还要节点,如果没有,说明自己是第一个,就顺利拿锁。如果有则表明锁被人拿了,client-2 将会注册一个 Watcher 去监听 lock1 是否存在。
这时,又来了一个 client-3 想要拿锁,在 Lock 下创建了一个 lock3 节点,结果也发现自己不是最前面的一个。便会注册一个 Watcher 去监听上一个节点,也就是 lock2 判断其是存在。
client-1 的业务执行完毕,可以释放锁了。执行完毕后,client-1 调用节点删除的指令,将临时节点 lock1 删除。
由于 client-2 一直在监听着 lock1,当 lock1 释放锁删除节点后,顺理成章的拿到了锁。而 lock3 还在监听着 lock2,等着它释放锁。
上面是正常业务执行完毕的情况下释放锁。假设,执行到中途,客户端崩溃了,与 zookeeper 断开了连接,又会如何呢?
临时节点的特性:仅当创建者会话有效时才得以保存,如果客户端崩溃了,那创建的会话是无效的,那样与客户端相关联的节点也会被删除。
监听 lock2 的客户端 client-3 发现节点 lock2 被删除,那样他也可以拿到锁了。
最后,client-3 也释放锁,整个分布式锁原理就这样结束了。
使用 zookeeper 实现分布式锁
学习完了 zookeeper 分布式锁原理,下面们我们来使用 zookeeper 实现实现实现分布式锁。为了快速示例,这里使用 springboot 来进行编写。
依赖包
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>2.8.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>2.8.0</version>
</dependency>
yml 配置文件
# zookeeper 地址
zookeeper.server = 192.168.79.128:2181,192.168.79.128:2182,192.168.79.128:2183
#锁文件路径
zookeeper.lockPath=/springboot/test
#重试间隔时间
zookeeper.elapsedTimeMs=5000
# session超时时间
zookeeper.sessionTimeoutMs=60000
#重试次数
zookeeper.retryCount=5
# 连接超时时间
zookeeper.connectionTimeoutMs=5000
zookeeper 配置
/**
* @author Gentle
* @date 2019/05/29 : 20:37
*/
@Component
@ConfigurationProperties(prefix = "zookeeper")
@Data
public class ZookeeperProperties {
/**
* zookeeper 地址:ip
*/
private String server;
/**
* 加锁路径
*/
private String lockPath;
/**
* session超时时间
*/
private Integer sessionTimeoutMs;
/**
* 连接超时时间
*/
private Integer connectionTimeoutMs;
/**
* 重试次数
*/
private Integer retryCount;
/**
* 重试间隔时间
*/
private Integer elapsedTimeMs;
}
/**
* @author Gentle
* @date 2019/05/29 : 20:43
*/
@Component
public class ZookeeperConfig {
@Autowired
ZookeeperProperties zookeeperProperties;
/**
* 配置 Zookeeper 客户端,构建连接
* @return CuratorFramework 对象
*/
@Bean
public CuratorFramework curatorFramework() {
CuratorFramework curatorFramework = CuratorFrameworkFactory.newClient(
zookeeperProperties.getServer(),
zookeeperProperties.getSessionTimeoutMs(),
zookeeperProperties.getConnectionTimeoutMs(),
new RetryNTimes(zookeeperProperties.getRetryCount(), zookeeperProperties.getElapsedTimeMs()));
curatorFramework.start();
return curatorFramework;
}
/**
* @param curatorFramework 分布式锁对象
* @return
*/
@Bean
public InterProcessMutex interProcessMutex(CuratorFramework curatorFramework){
return new InterProcessMutex(curatorFramework,zookeeperProperties.getLockPath());
}
}
笔者编写了一个注解的方式进行解耦。
/**
* 分布式做注解
* @author Gentle
* @date 2019/05/30 : 17:53
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LockAnnotation {
/**
* @return 锁等待时间
*/
long time() default 20;
/**
* 时间类型 可选秒,毫秒,时等
* @return
*/
TimeUnit util() default TimeUnit.SECONDS;
}
AOP 拦截器
/**
* 分布式锁注解
* @author Gentle
* @date 2019/05/30 : 17:48
*/
@Aspect
@Order(5)
@Component
public class LockIntercept {
@Autowired
private InterProcessMutex interProcessMutex;
@Around("@annotation(lockAnnotation)")
public void lockHandler(ProceedingJoinPoint joinPoint, LockAnnotation lockAnnotation ){
//判断是否拿到锁
boolean acquire=false;
try {
//自定义时间
acquire = interProcessMutex.acquire(lockAnnotation.time(), lockAnnotation.util());
//拿锁成功则进行业务
if (acquire){
Object proceed = joinPoint.proceed();
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}finally {
//拿到锁的才进行释放
if (acquire){
try {
interProcessMutex.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
业务接口和实现类
这里的业务仅仅只做一个计数。
/**
* @author Gentle
* @date 2019/05/29 : 23:57
*/
public interface ZookeeperLockService {
/**
* 业务
* @return
* @throws Exception
*/
Boolean lockAcquireTimeOut() throws Exception;
}
/**
* @author Gentle
* @date 2019/05/29 : 23:57
*/
@Service
public class ZookeeperLockServiceImpl implements ZookeeperLockService {
@Autowired
CuratorFramework curatorFramework;
/**
* 计数
*/
int a =0;
/**
* 计数业务
* @return false
*/
@Override
//分布式锁注解
@LockAnnotation
public Boolean lockAcquireTimeOut() {
System.out.println(a++);
return false;
}
}
测试类
import com.gentle.service.ZookeeperLockService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
@RunWith(SpringRunner.class)
@SpringBootTest
public class GentleApplicationTests {
@Autowired
ZookeeperLockService zookeeperLockService;
/**
* 200 个线程测试分布式锁
* @throws InterruptedException
*/
@Test
public void contextLoads() throws InterruptedException {
//闭锁
CountDownLatch countDownLatch = new CountDownLatch(200);
ExecutorService executorService = Executors.newCachedThreadPool();
//200 个线程进行测试
for (int i = 0; i <200; i++) {
executorService.submit(() -> {
try {
//调用业务
zookeeperLockService.lockAcquireTimeOut();
} catch (Exception e) {
e.printStackTrace();
}
countDownLatch.countDown();
}
);
}
//等待完成
countDownLatch.await();
}
}
测试结果:
代码已经提交至 Gitee。
Gitee:
https://gitee.com/reway_wen/springboot-learn/tree/master/zookeeper-lock-demo
GitHub 较为凌乱,更新完毕后会在修改!
总结:
zookeeper 分布式锁相对来说还是比较简单的,可能在性能方面比 Redis 实现的分布式锁要差一些(频繁创建和删除节点),但胜在 zookeeper 的实现比较简单。当然,我们也学习了 zookeeper 实现分布式锁的原理,这一点很重要–面试经常问。
有兴趣的同学可以关注公众号,一起干起来!