使用Java和Zookeeper实现分布式协调

使用Java和Zookeeper实现分布式协调

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

在分布式系统中，多个节点需要进行协调以实现共同目标，例如分布式锁、领导选举和配置管理等。Zookeeper是一个分布式协调服务，专为这些任务设计。本文将介绍如何使用Java和Zookeeper实现分布式协调，涵盖Zookeeper的基本概念、安装配置及典型应用示例。

Zookeeper基本概念

Zookeeper是一个高可用的分布式协调服务，主要特性包括：

1. 文件系统数据模型：数据存储在一个层次化的节点树中，类似于文件系统。
2. 临时节点和持久节点：支持两种节点类型，前者会在客户端会话结束时自动删除，后者则会持久保存。
3. 原子性和顺序一致性：所有更新操作是原子的，所有客户端都能看到相同的视图。
4. 监视器（Watchers）机制：客户端可以在节点上设置监视器，当节点变化时会收到通知。

Zookeeper安装和配置

1. 下载Zookeeper：

   wget https://downloads.apache.org/zookeeper/zookeeper-3.6.3/apache-zookeeper-3.6.3-bin.tar.gz
   tar -xzf apache-zookeeper-3.6.3-bin.tar.gz
   cd apache-zookeeper-3.6.3-bin
   

2. 配置Zookeeper：
   在conf目录下创建zoo.cfg文件，内容如下：

   tickTime=2000
   dataDir=/var/lib/zookeeper
   clientPort=2181
   initLimit=5
   syncLimit=2
   server.1=localhost:2888:3888
   

3. 启动Zookeeper：

   bin/zkServer.sh start
   

Java客户端示例

为了与Zookeeper交互，通常使用Zookeeper Java客户端库。以下示例展示了如何使用Java和Zookeeper实现分布式锁。

引入依赖

在pom.xml文件中添加Zookeeper客户端依赖：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.6.3</version>
</dependency>

分布式锁实现

1. 分布式锁类

package cn.juwatech.distributed;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class DistributedLock {

    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String LOCK_ROOT = "/locks";
    private String lockId;
    private ZooKeeper zk;

    public DistributedLock() throws IOException, InterruptedException, KeeperException {
        this.zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {});
        Stat stat = zk.exists(LOCK_ROOT, false);
        if (stat == null) {
            zk.create(LOCK_ROOT, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    public void acquireLock(String lockName) throws KeeperException, InterruptedException {
        String lockPath = LOCK_ROOT + "/" + lockName + "_lock_";
        this.lockId = zk.create(lockPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        List<String> lockNodes = zk.getChildren(LOCK_ROOT, false);
        Collections.sort(lockNodes);
        String smallestNode = LOCK_ROOT + "/" + lockNodes.get(0);

        if (this.lockId.equals(smallestNode)) {
            return;
        }

        String watchNode = null;
        for (String node : lockNodes) {
            String nodePath = LOCK_ROOT + "/" + node;
            if (nodePath.compareTo(this.lockId) < 0) {
                watchNode = nodePath;
            } else {
                break;
            }
        }

        CountDownLatch latch = new CountDownLatch(1);
        Stat stat = zk.exists(watchNode, event -> {
            if (event.getType() == Watcher.Event.EventType.NodeDeleted) {
                latch.countDown();
            }
        });

        if (stat != null) {
            latch.await();
        }
    }

    public void releaseLock() throws KeeperException, InterruptedException {
        zk.delete(this.lockId, -1);
    }
}

2. 使用分布式锁

package cn.juwatech.distributed;

import org.apache.zookeeper.KeeperException;

public class DistributedLockExample {

    public static void main(String[] args) {
        try {
            DistributedLock lock = new DistributedLock();
            lock.acquireLock("my_lock");

            // 进行业务逻辑处理
            System.out.println("Acquired lock and processing critical section.");

            lock.releaseLock();
            System.out.println("Released lock.");

        } catch (IOException | KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

领导选举

Zookeeper的临时顺序节点可以用来实现领导选举。以下示例展示了如何使用Zookeeper进行领导选举。

1. 领导选举类

package cn.juwatech.election;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class LeaderElection implements Watcher {

    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String ELECTION_ROOT = "/election";
    private ZooKeeper zk;
    private String currentZnode;

    public LeaderElection() throws IOException, KeeperException, InterruptedException {
        this.zk = new ZooKeeper(ZK_ADDRESS, 3000, this);
        Stat stat = zk.exists(ELECTION_ROOT, false);
        if (stat == null) {
            zk.create(ELECTION_ROOT, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    public void volunteerForLeadership() throws KeeperException, InterruptedException {
        String znodePrefix = ELECTION_ROOT + "/c_";
        this.currentZnode = zk.create(znodePrefix, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    }

    public void reelectLeader() throws KeeperException, InterruptedException {
        List<String> children = zk.getChildren(ELECTION_ROOT, false);
        Collections.sort(children);
        String smallestChild = children.get(0);

        if (currentZnode.endsWith(smallestChild)) {
            System.out.println("I am the leader: " + currentZnode);
            return;
        }

        int predecessorIndex = Collections.binarySearch(children, currentZnode.substring(currentZnode.lastIndexOf('/') + 1)) - 1;
        String predecessorZnode = children.get(predecessorIndex);

        CountDownLatch latch = new CountDownLatch(1);
        Stat stat = zk.exists(ELECTION_ROOT + "/" + predecessorZnode, event -> {
            if (event.getType() == Event.EventType.NodeDeleted) {
                latch.countDown();
            }
        });

        if (stat != null) {
            latch.await();
            reelectLeader();
        }
    }

    @Override
    public void process(WatchedEvent event) {
    }

    public static void main(String[] args) {
        try {
            LeaderElection election = new LeaderElection();
            election.volunteerForLeadership();
            election.reelectLeader();
        } catch (IOException | KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结

本文详细介绍了如何使用Java和Zookeeper实现分布式协调，涵盖了分布式锁和领导选举的具体实现方法。通过Zookeeper的强一致性和高可用性特性，我们可以简化分布式系统中的协调任务，实现高效可靠的分布式应用。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！