分布式锁实战（四）基于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;
    }

效果还是不错的