基于ZooKeeper实现分布式锁
- Zookeeper的简洁与作用
- Zookeeper分布式锁的实现流程和原理
- Springboot整合Zookeeper
本章基于ZooKeeper的临时节点和Watcher机制实现分布式锁，包括其实现流程与底层的执行原理，并以前文所用的的
用户重复提交注册信息 为案例，配以实际的代码进行实战
Zookeeper的简洁与作用
Zookeeper是雅虎设计的用于开发一个通用的，无单点问题的分布式协调框架，采用统一的协调管理方式更好管理各个子系统，从而让开发者将更多的精力集中在业务管理上。最终的分布式系统看上去就像一个很大型的动物园，而这个中间件则正好来协调管理各个子系统，Zookeeper因此得名。
除此之外，Zookeeper还是一种典型的保证分布式数据一致的解决方案，应用程序可以基于Zookeeper实现诸如数据发布，负载均衡，命名服务，分布式协调与通知，集群管理，分布式锁和分布式队列等功能。在实际的业务中有广泛的应用。
**统一配置管理：**指的是可以把子系统都需要的配置文件抽取出来，并将其统一到Zookeeper的ZNode节点中进行共享。
**统一命名服务：**指的是存放在每个节点上的资源进行命名，各个子系统便可以通过名字获取节点上的相应资源。
**集群管理：**通过动态地感知节点的增加，删除，从而保证集群下相关节点主、副数据的一致性。
**分布式锁：**这可以算是Zookeeper提供外部应用的一个重大功能，它主要通过创建于共享资源相关的“临时顺序节点”与“动态Watcher监听机制”，从而控制多线程对共享资源的访问，而这也可以看做是Zookeeper拥有诸多特定的根本原因。
但是Zookeeper的典型应用场景就是担当“服务注册和服务消费者的注册中心”，服务生产者将服务注册到Zookeeper中心，服务的消费者在进行服务调用时现在Zookeeper中查找服务，获取服务的相关信息后，再调用服务生产者提供的接口，在分布式服务调度框架Dubbo的基础框架中，Zookeeper就担任了注册中心这一角色。
Zookeeper分布式锁的实现流程和原理
前面说到，Zookeeper可以通过创建于共享资源相关的“顺序临时节点”，并提供“Watcher动态监听机制”，控制多线程对共享资源的访问，实现流程图如下
图上可以看出，创建顺序临时节点Znode以及Watcher监听动态节点的增删，从而判断当前线程是否能够获取锁。重要的就是节点和Watcher监听器
节点这里的节点分为两种类型，第一种是服务器集群，称之为服务器节点，第二种是数据模型中的数据单元，称之为数据节点，就是Znode,如上图所示。
Zoopeeker将所有数据存储在内存中，最终构成的数据模型可以看做一棵树,由“/”进行分割，分割之后每个分支为路径，每个路径对应一个节点，例如/Znode1/node1,每个节点都会保存自己的数据内容以及一些属性信息，在Zookeeper中，Znode可以分成持久化节点和临时节点两种类型。
持久化节点指的是Znode被创建了，除非主动移除这个Znode,否则将会一直存在Zookeeper上，临时节点不一样，它的生命周期是和客户端的会话绑定在一起的，一旦客户端的会话失败，那么这个客户端创建的所有临时节点都会移除，除此之外，Zookeeper创建的临时节点Znode可以带上一个整型的数字，这个特性可以用来创建一系列带有顺序序号的临时Znode。Watcher监听器指的是“事件监听器”，Zookeeper允许用户在指定的Znode上注册监听事件，故而该节点会触发一些特定的事件，Zookeeper的服务端会将事件通知到感兴趣的客户端上，从而让客户端采取相应的措施，这种机制就是Zookeeper实现分布式协调服务的重要性。
Springboot整合Zookeeper
导入POM
<!--zookeeper-->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.6</version>
<exclusions>
<exclusion>
<artifactId>slf4j-log4j12</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>2.10.0</version>
</dependency>package com.learn.boot.config;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.framework.api.CuratorEventType;
import org.apache.curator.framework.api.CuratorListener;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.WatchedEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
/**
* 使用CuratorFramework api管理分布式锁
*/
@Configuration
public class CuratorFrameworkConfig {
@Autowired
private Environment env;
@Bean
public CuratorFramework curatorFramework(){
// ExponentialBackoffRetry是种重连策略，每次重连的间隔会越来越长,1000毫秒是初始化的间隔时间,3代表尝试重连次数。
ExponentialBackoffRetry retry = new ExponentialBackoffRetry(1000, 3);
// 创建client
CuratorFramework curatorFramework = CuratorFrameworkFactory.newClient(env.getProperty("zookeeper.address"), retry);
// 添加watched 监听器
curatorFramework.getCuratorListenable().addListener(new CuratorListener() {
@Override
public void eventReceived(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
CuratorEventType type = curatorEvent.getType();
if(type == CuratorEventType.WATCHED){
WatchedEvent watchedEvent = curatorEvent.getWatchedEvent();
String path = watchedEvent.getPath();
System.out.println(watchedEvent.getType()+" -- "+ path);
// 重新设置改节点监听
if(null != path){
curatorFramework.checkExists().watched().forPath(path);
}
}
}
});
curatorFramework.start();
return curatorFramework;
}
}/**
* 使用CuratorFramework实现分布式锁，在CuratorFrameworkConfig重写了
*/
@Autowired
private CuratorFramework curatorFramework;
@RequestMapping("/zkLogin")
public ResultVo zkLogin(@RequestBody UserLoginDto model, BindingResult bindingResult) {
// 这里创建一个根节点不要动
String lockName = "/lock/test";
log.info("============={} 线程访问开始=========lockName:{}",Thread.currentThread().getName(),lockName);
// TODO 获取分布式锁
InterProcessSemaphoreMutex lock = new InterProcessSemaphoreMutex (curatorFramework, lockName);
try {
if (lock.acquire(0L, TimeUnit.SECONDS)) {
log.info("线程:{}，获取到了锁",Thread.currentThread().getName());
//TODO 获得锁之后可以进行相应的处理
log.info("======获得锁后进行相应的操作======" + Thread.currentThread().getName());
UserReg userReg = userRegMapper.selectByUserName(model.getUserName());
if (userReg == null) {
UserReg insertUserReg = new UserReg(){
{
setCreateTime(new Date());
setPassword(model.getPassword());
setUserName(model.getUserName());
}
};
userRegMapper.insertSelective(insertUserReg);
log.info("{}注册成功",model.getUserName());
return ResultVo.success("注册成功");
}
}
}catch (Exception ex) {
log.info("错误信息：{}",ex.getMessage());
}finally {
try {
lock.release();
log.info("=========lockName:{}==============={}释放了锁",lockName,Thread.currentThread().getName());
} catch (Exception e) {
log.info("错误信息：{}",e.getMessage());
}
}
return null;
}效果还是不错的
