使用zk的分布式锁实现高可用（curator的框架的使用）

引读：实现服务的高可用是防止单点故障的最好方式，因此许多大数据框架包括hadoop，spark都有ha机制，那么实现高可用的方式有许多，但是于我而言，最核心的方式其实就是分布式锁的运用。

正题：使用curatorFramework是实现分布式锁的一个比较好的框架，是apache的顶级项目，内部提供了几种锁，包括可重入和非可重入等，适合不同的场景。这次我们介绍一下比较常用的可重入锁的设计高可用的方案。

设计架构：启动一个调度线程进行锁的争抢，每次调度线程抢到锁之后，判断自己是否持有锁，如果未持有则尝试抢占分布式锁，抢到之后执行相应的逻辑，比如说启动一个新的线程执行任务，或者通过线程池的方式启动线程（这样便于管理，能够及时关闭线程池，避免频繁的启停线程）。

上代码：

// 模拟为其中一台机器test（因为高可用是基于多台机器的服务之间的）
public class test2 {
    // 这个是CuratorFramework（不熟悉的可以先了解一下，其实就是zk的客户端上封装多一层）
    private static CuratorFramework curatorFramework;
    // 这个就是分布式锁（可重入的，其他几款锁可以去了解一下）
    private static InterProcessMutex lock ;
    // 通过静态代码块创建该zk客户端
    static {
        curatorFramework = CuratorFrameworkFactory.builder().
        		// zk的ip：host
                connectString("localhost:2181").
                // 会话的超时时间（每一个临时节点其实都是一个会话，当zk没有返回心跳给server超过5s时，会断开连接）
                sessionTimeoutMs(5000).
                // 这个是zk重连的机制，3次，每次1s
                retryPolicy(new ExponentialBackoffRetry
                        (1000, 3)).
                connectionTimeoutMs(4000).build();
        curatorFramework.start(); //表示启动.
        // 创建分布式锁，指定一个节点的路径
        lock = new InterProcessMutex(curatorFramework, "/locks");
    }

    private AtomicInteger count = new AtomicInteger(0);
    // 这个是让线程池创建的线程为守护线程，主线程结束，守护线程也结束
    ThreadFactory threadFactory = new ThreadFactoryBuilder()
            .setDaemon(true)
            .setNameFormat("scheduler-2")
            .build();
    // 这个是最外层的调度线程池，每隔一段时间去抢锁的         
    ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    // 这个是执行业务逻辑的，比如业务代码的心跳线程，清理线程
    ScheduledExecutorService businessPool = Executors.newScheduledThreadPool(1, threadFactory);

	// 方法执行的main线程
    public static void main(String[] args) {
        test2 lock = new test2();
        lock.init();

    }
    
    public void init() {
    	// 启动调度线程去抢锁，初始化的时间为2s，而后都是10s为间隔抢锁
        pool.scheduleAtFixedRate(() -> {
            checkLock();

        }, 2,10, TimeUnit.SECONDS);
        // 这个是监听线程，监听和server之间的连接状态
        curatorFramework.getConnectionStateListenable()
                .addListener(
                        new ConnectionStateListener() {
                            @Override
                            public void stateChanged(
                                    CuratorFramework client, ConnectionState newState) { // 当状态发生变化时通知监听者
                                System.out.println("CuratorFramework state changed: " + newState);
                                if (newState == ConnectionState.LOST) {
                                    System.out.println("连接不上");
                                    // 当连接断开时，进行的业务处理
                                }
                            }
                        });

    }

	// 检查是否抢到锁的逻辑
    public void checkLock() {

        count.incrementAndGet();
        System.out.println("调度第 " + count.get() + "次");
        try {
            System.out.println("master-2" + "->尝试抢占锁");
            try {
                // 这个是锁自带的方法，判断锁是否被当前进程抢到，由于是不同机器间的不同锁同时去抢，我们有必要做一下这个逻辑
                if(!lock.isAcquiredInThisProcess()) {
                	// 支持带超时时间的抢占锁
                    boolean acquire = lock.acquire(2, TimeUnit.SECONDS);
                    // 如果没有抢到锁
                    if (!acquire) {
                        System.out.println("master-2" + "->抢锁超时");
                    }
                    // 抢到锁之后做的逻辑 
                    else {
                        System.out.println("master-2" + "->获取锁成功");
                        try {
                            // 业务逻辑
                            System.out.println("thread: master-2 \n执行master启动逻辑");
                            // 这里是启动调度线程，只能执行一次，不允许最外层的调度线程池多次调用这个调度线程，会导致延迟队列积压，这也是我们一开始为什么要加一个lock.isAcquiredInThisProcess()的原因，如果没加，那我们每次抢到锁之后，都会调度一次，但其实我们只需要执行一次（因为其实这个线程池是起的异步的线程执行任务，启动一次之后，最外层的调度线程执行完毕抢锁之后，就轮到这个业务的调度线程执行）
                            businessPool.scheduleAtFixedRate(() -> {
                                System.out.println("cool");
                            }, 0, 3, TimeUnit.SECONDS);
                            System.out.println("任务正常执行");
                        } catch (Exception e) {
                            System.out.println("任务有异常");
                            // 出现异常释放锁，这里设计也是因为避免这把锁来回被多个机器之间切换抢占，当第一台机器拿到这把锁之后，只要不发生异常的情况 ，就一直持有这把锁。
                            lock.release();
                            // 关闭业务调度线程池
                            businessPool.shutdown();
                            System.out.println("master-2 释放锁成功");
                            e.printStackTrace();
                        } 
                    }
                }

            } catch (Exception e) {
                System.out.println("出现异常了");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试：启动多个test进程
模拟第一个机器

模拟第二个机器

done～