2. 程式人生 > >分散式系統筆記:利用zookeeper實現分散式leader節點選舉

分散式系統筆記:利用zookeeper實現分散式leader節點選舉

阿新 • • 發佈：2019-02-05

利用zookeeper實現分散式leader節點選舉

依賴原理

  • 在ZK中新增基本節點，路徑程式定義，節點型別為持久節點(PERSISTENT)。
  • 對需要競選leader的每個程序，在ZK中分別新增基本節點的子節點，型別為臨時自編號節點(EPHEMERAL_SEQUENTIAL)，並儲存建立返回的實際節點路徑。
  • 通過delete方式刪除本程序建立的子節點，可以作為退出leader狀態的方式。
  • 基本節點的子節點型別為臨時自編號節點(EPHEMERAL_SEQUENTIAL)，當程序與ZK連線中斷後，ZK會自動將該節點刪除，確保了斷連之後其他程序對leader的選舉。
  • 由於ZK自編號產生的路徑是遞增的，因此可以通過判斷基本節點的子節點中最小路徑數字編號的節點是否是本程序新建的節點來判斷是否獲得leader地位。

原理圖示

利用zk實現的分散式leader節點選舉實現原理如下：

若干程序分別嘗試競選leader，情況如下：
- (1)8個程序分別在ZK基本節點下建立臨時自編號節點，獲取建立成功後的實際路徑
- (2)在基本節點子節點列表中，判斷本程序建立節點編號是否為最小
- (3)最小編號程序獲得leader地位
這裡寫圖片描述

leader程式異常退出或者伺服器異常導致leader程序無法執行leader功能：
- (1)程序將ZK中對應的臨時節點刪除，此時基本節點下路徑最小的子節點將獲得leader地位
- (2)程序由於網路或其他原因與ZK斷開了連線，ZK自動將其對應的臨時節點刪除
- (3)新出現的程序加入leader競選，在ZK下建立臨時節點，排隊等待
這裡寫圖片描述

方案一 ：父節點監聽方式

實現原理

程式流程圖如下：

這裡寫圖片描述

實現程式碼

package xuyihao.zktest.server.zk.leader;

import org.apache.zookeeper.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 基於zk的分散式leader節點選舉
 * <pre>
 *     方案一：父節點監聽方式
 *
 *     實現思路：監聽父節點狀態
 *     1.在父節點(持久化)下建立臨時節點，實際建立的節點路徑會根據數量進行自增(ZK自編號方式建立節點)。
 *     2.建立節點成功後，獲取父節點下的子節點列表，判斷本執行緒的路徑字尾編號是否是所有子節點中最小的，若是則成為leader，反之監聽父節點變動狀態(通過getChildren()方法註冊watcher)
 *     3.當父節點狀態變動(主要是子節點列表變動)後watcher會接收到通知，這時判斷父節點下的子節點的排序狀態，若滿足本執行緒的路徑字尾編號最小則成為leader，反之繼續註冊watcher監聽父節點狀態
 * </pre>
 * <p>
 * Created by xuyh at 2017/11/24 9:19.
 */
 

public class ZKLeader {
    private static ZKLeader zkLeader;
    private Logger logger = LoggerFactory.getLogger(ZKLeader.class);
    private final static String BASE_NODE_PATH = "/ZKLeader_Leader";
    private final static String NODE_PATH = "host_process_no_";
    private String finalNodePath;

    //是否是主節點標誌位
    private boolean leader = false;

    private String host = "127.0.0.1";
    private String port = "2181";
    private ZooKeeper zooKeeper;
    private FatherWatcher fatherWatcher;

    //是否連線成功標誌位
    private boolean connected = false;

    public static ZKLeader create(String host, String port) {
        ZKLeader zkLeader = new ZKLeader(host, port);
        zkLeader.connectZookeeper();
        return zkLeader;
    }

    public boolean leader() {
        return leader;
    }

    public void close() {
        disconnectZooKeeper();
    }

    private ZKLeader(String host, String port) {
        this.host = host;
        this.port = port;
        this.fatherWatcher = new FatherWatcher(this);
    }

    private boolean connectZookeeper() {
        try {
            zooKeeper = new ZooKeeper(host + ":" + port, 60000, event -> {
                if (event.getState() == Watcher.Event.KeeperState.AuthFailed) {
                    leader = false;
                } else if (event.getState() == Watcher.Event.KeeperState.Disconnected) {
                    leader = false;
                } else if (event.getState() == Watcher.Event.KeeperState.Expired) {
                    leader = false;
                } else {
                    if (event.getType() == Watcher.Event.EventType.None) {//說明連線成功了
                        connected = true;
                    }
                }
            });

            int i = 1;
            while (!connected) {//等待非同步連線成功,超過時間30s則退出等待
                if (i == 100)
                    break;
                Thread.sleep(300);
                i++;
            }

            if (connected) {
                if (zooKeeper.exists(BASE_NODE_PATH, false) == null) {//建立父節點
                    zooKeeper.create(BASE_NODE_PATH, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }
                //建立子節點
                finalNodePath = zooKeeper.create(BASE_NODE_PATH + "/" + NODE_PATH, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

                //檢查一次是否是主節點
                checkLeader();
            } else {
                logger.warn("Connect zookeeper failed. Time consumes 30 s");
                return false;
            }
        } catch (Exception e) {
            logger.warn(e.getMessage(), e);
            return false;
        }
        return true;
    }

    private boolean disconnectZooKeeper() {
        if (zooKeeper == null)
            return false;
        try {
            connected = false;
            leader = false;
            zooKeeper.close();
        } catch (Exception e) {
            logger.warn(String.format("ZK disconnect failed. [%s]", e.getMessage()), e);
        }
        return true;
    }

    private void checkLeader() {
        if (!connected)
            return;
        try {
            //獲取子節點列表同時再次註冊監聽
            List<String> childrenList = zooKeeper.getChildren(BASE_NODE_PATH, fatherWatcher);

            if (judgePathNumMin(childrenList)) {
                leader = true;
            }
        } catch (Exception e) {
            logger.warn(e.getMessage(), e);
        }
    }

    private boolean judgePathNumMin(List<String> paths) {
        if (paths.isEmpty())
            return true;
        if (paths.size() >= 2) {
            //對無序狀態的path列表按照編號升序排序
            paths.sort((str1, str2) -> {
                int num1;
                int num2;
                String string1 = str1.substring(NODE_PATH.length(), str1.length());
                String string2 = str2.substring(NODE_PATH.length(), str2.length());
                num1 = Integer.parseInt(string1);
                num2 = Integer.parseInt(string2);
                if (num1 > num2) {
                    return 1;
                } else if (num1 < num2) {
                    return -1;
                } else {
                    return 0;
                }
            });
        }

        String minId = paths.get(0);
        return finalNodePath.equals(BASE_NODE_PATH + "/" + minId);
    }


    private class FatherWatcher implements Watcher {
        private ZKLeader context;

        FatherWatcher(ZKLeader context) {
            this.context = context;
        }

        @Override
        public void process(WatchedEvent event) {
            if (event.getType() == Event.EventType.NodeChildrenChanged) {//子節點有變化
                context.checkLeader();
            }
        }
    }
}

測試

測試程式

private void zkLeaderOneTestWithMultiThread() throws Exception {
    List<LeaderOneThread> leaderOneThreads = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        leaderOneThreads.add(new LeaderOneThread(ZKLeader.create("127.0.0.1", "2181"), i));
    }
    leaderOneThreads.forEach(LeaderOneThread::start);

    //執行緒0斷連
    Thread.sleep(20000);
    leaderOneThreads.get(0).getZkLeader().close();
    Thread.sleep(2000);
    System.out.println(String.format("執行緒: [%s] 斷開連線", 0));

    //執行緒1斷連
    Thread.sleep(20000);
    leaderOneThreads.get(1).getZkLeader().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 1));

    //執行緒3斷連
    Thread.sleep(20000);
    leaderOneThreads.get(3).getZkLeader().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 3));

    //執行緒4斷連
    Thread.sleep(20000);
    leaderOneThreads.get(4).getZkLeader().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 4));

    //執行緒2斷連
    Thread.sleep(20000);
    leaderOneThreads.get(2).getZkLeader().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 2));

    Thread.sleep(60000);
}

private class LeaderOneThread extends Thread {
    private ZKLeader zkLeader;
    private int threadNum;

    public ZKLeader getZkLeader() {
        return zkLeader;
    }

    LeaderOneThread(ZKLeader zkLeader, int threadNum) {
        this.zkLeader = zkLeader;
        this.threadNum = threadNum;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Date dt = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String currentTime = sdf.format(dt);
            if (zkLeader.leader()) {
                System.out.println(String.format("[%s] 執行緒: [%s] 是主節點", currentTime, threadNum));
            }
        }
    }
}

結果:

[2017-11-30 17:05:02] 執行緒: [0] 是主節點
[2017-11-30 17:05:07] 執行緒: [0] 是主節點
[2017-11-30 17:05:12] 執行緒: [0] 是主節點
執行緒: [0] 斷開連線
[2017-11-30 17:05:22] 執行緒: [1] 是主節點
[2017-11-30 17:05:27] 執行緒: [1] 是主節點
[2017-11-30 17:05:32] 執行緒: [1] 是主節點
[2017-11-30 17:05:37] 執行緒: [1] 是主節點
執行緒: [1] 斷開連線
[2017-11-30 17:05:42] 執行緒: [2] 是主節點
[2017-11-30 17:05:47] 執行緒: [2] 是主節點
[2017-11-30 17:05:52] 執行緒: [2] 是主節點
[2017-11-30 17:05:57] 執行緒: [2] 是主節點
執行緒: [3] 斷開連線
[2017-11-30 17:06:02] 執行緒: [2] 是主節點
[2017-11-30 17:06:07] 執行緒: [2] 是主節點
[2017-11-30 17:06:12] 執行緒: [2] 是主節點
[2017-11-30 17:06:17] 執行緒: [2] 是主節點
執行緒: [4] 斷開連線
[2017-11-30 17:06:22] 執行緒: [2] 是主節點
[2017-11-30 17:06:27] 執行緒: [2] 是主節點
[2017-11-30 17:06:32] 執行緒: [2] 是主節點
[2017-11-30 17:06:37] 執行緒: [2] 是主節點
執行緒: [2] 斷開連線
[2017-11-30 17:06:42] 執行緒: [5] 是主節點
[2017-11-30 17:06:47] 執行緒: [5] 是主節點
[2017-11-30 17:06:52] 執行緒: [5] 是主節點
[2017-11-30 17:06:57] 執行緒: [5] 是主節點
[2017-11-30 17:07:02] 執行緒: [5] 是主節點
[2017-11-30 17:07:07] 執行緒: [5] 是主節點
[2017-11-30 17:07:12] 執行緒: [5] 是主節點
[2017-11-30 17:07:17] 執行緒: [5] 是主節點
[2017-11-30 17:07:22] 執行緒: [5] 是主節點
[2017-11-30 17:07:27] 執行緒: [5] 是主節點
[2017-11-30 17:07:32] 執行緒: [5] 是主節點
[2017-11-30 17:07:37] 執行緒: [5] 是主節點

方案一優劣

優點

  • 實現對父節點變動狀態(主要是子節點列表變化)的監聽
  • 當子節點列表出現變化後，ZK通知監聽的各個程序，各個程序查詢子節點狀態
  • 對父節點進行監聽，實現起來相對簡單

劣勢

  • 每個程序都監聽父節點狀態，即父節點出現變動(主要是子節點列表變化)後，ZK伺服器需要通知到所有註冊監聽的程序，網路消耗和資源浪費比較大

方案三 ：子節點監聽方式

實現原理

程式流程圖如下：

這裡寫圖片描述

實現程式碼

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * Created by xuyh at 2017/11/30 14:40.
 * <p>
 * **最優方案**
 * <pre>
 *     方案三：子節點監聽方式
 *
 *     實現思路：監聽子節點狀態
 *     1.在父節點(持久化)下建立臨時節點，實際建立的節點路徑會根據數量進行自增(ZK自編號方式建立節點)。
 *     2.建立節點成功後，首先獲取父節點下的子節點列表，判斷本執行緒的路徑字尾編號是否是所有子節點中最小的，若是則成為leader，反之監聽本節點前一個節點(路徑排序為本節點路徑數字減一的節點)變動狀態(通過getData()方法註冊watcher)
 *     3.當監聽物件狀態變動(節點刪除狀態)後watcher會接收到通知，這時再次判斷父節點下的子節點的排序狀態，若滿足本執行緒的路徑字尾編號最小則成為leader，反之繼續註冊watcher監聽前一個節點狀態
 */
public class ZKLeaderTwo {
    private static ZKLeaderTwo zkLeaderTwo;
    private Logger logger = LoggerFactory.getLogger(ZKLeader.class);
    private final static String BASE_NODE_PATH = "/ZKLeader_Leader";
    private final static String NODE_PATH = "host_process_no_";
    private String finalNodePath;

    //是否是主節點標誌位
    private boolean leader = false;

    private String host = "127.0.0.1";
    private String port = "2181";
    private ZooKeeper zooKeeper;
    private PreviousNodeWatcher previousNodeWatcher;

    //是否連線成功標誌位
    private boolean connected = false;

    public static ZKLeaderTwo create(String host, String port) {
        ZKLeaderTwo zkLeaderTwo = new ZKLeaderTwo(host, port);
        zkLeaderTwo.connectZookeeper();
        return zkLeaderTwo;
    }

    public boolean leader() {
        return leader;
    }

    public void close() {
        disconnectZooKeeper();
    }

    private ZKLeaderTwo(String host, String port) {
        this.host = host;
        this.port = port;
        this.previousNodeWatcher = new PreviousNodeWatcher(this);
    }

    private boolean connectZookeeper() {
        try {
            zooKeeper = new ZooKeeper(host + ":" + port, 60000, event -> {
                if (event.getState() == Watcher.Event.KeeperState.AuthFailed) {
                    leader = false;
                } else if (event.getState() == Watcher.Event.KeeperState.Disconnected) {
                    leader = false;
                } else if (event.getState() == Watcher.Event.KeeperState.Expired) {
                    leader = false;
                } else {
                    if (event.getType() == Watcher.Event.EventType.None) {//說明連線成功了
                        connected = true;
                    }
                }
            });

            int i = 1;
            while (!connected) {//等待非同步連線成功,超過時間30s則退出等待
                if (i == 100)
                    break;
                Thread.sleep(300);
                i++;
            }

            if (connected) {
                if (zooKeeper.exists(BASE_NODE_PATH, false) == null) {//建立父節點
                    zooKeeper.create(BASE_NODE_PATH, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }
                //建立子節點
                finalNodePath = zooKeeper.create(BASE_NODE_PATH + "/" + NODE_PATH, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

                //檢查一次是否是主節點
                checkLeader();
            } else {
                logger.warn("Connect zookeeper failed. Time consumes 30 s");
                return false;
            }
        } catch (Exception e) {
            logger.warn(e.getMessage(), e);
            return false;
        }
        return true;
    }

    private boolean disconnectZooKeeper() {
        if (zooKeeper == null)
            return false;
        try {
            zooKeeper.close();
            connected = false;
            leader = false;
        } catch (Exception e) {
            logger.warn(String.format("ZK disconnect failed. [%s]", e.getMessage()), e);
        }
        return true;
    }

    private void checkLeader() {
        if (!connected)
            return;
        try {
            //獲取子節點列表，若沒有成為leader，註冊監聽，監聽物件應當是比本節點路徑編號小一(或者排在前面一位)的節點
            List<String> childrenList = zooKeeper.getChildren(BASE_NODE_PATH, false);

            if (judgePathNumMin(childrenList)) {
                leader = true;//成為leader
            } else {
                watchPreviousNode(childrenList);
            }
        } catch (Exception e) {
            logger.warn(e.getMessage(), e);
        }
    }

    private boolean judgePathNumMin(List<String> paths) {
        if (paths.isEmpty())
            return true;
        if (paths.size() >= 2) {
            //對無序狀態的path列表按照編號升序排序
            paths.sort((str1, str2) -> {
                int num1;
                int num2;
                String string1 = str1.substring(NODE_PATH.length(), str1.length());
                String string2 = str2.substring(NODE_PATH.length(), str2.length());
                num1 = Integer.parseInt(string1);
                num2 = Integer.parseInt(string2);
                if (num1 > num2) {
                    return 1;
                } else if (num1 < num2) {
                    return -1;
                } else {
                    return 0;
                }
            });
        }

        String minId = paths.get(0);
        return finalNodePath.equals(BASE_NODE_PATH + "/" + minId);
    }

    private void watchPreviousNode(List<String> paths) {
        if (paths.isEmpty() || paths.size() == 1) {
            return;
        }
        int currentNodeIndex = paths.indexOf(finalNodePath.substring((BASE_NODE_PATH + "/").length(), finalNodePath.length()));
        String previousNodePath = BASE_NODE_PATH + "/" + paths.get(currentNodeIndex - 1);
        //通過getData方法再次註冊watcher
        try {
            zooKeeper.getData(previousNodePath, previousNodeWatcher, new Stat());
        } catch (Exception e) {
            logger.warn(String.format("Previous node watcher register failed! message: [%s]", e.getMessage()), e);
        }
    }

    private class PreviousNodeWatcher implements Watcher {
        private ZKLeaderTwo context;

        PreviousNodeWatcher(ZKLeaderTwo context) {
            this.context = context;
        }

        @Override
        public void process(WatchedEvent event) {
            //節點被刪除了，說明這個節點放棄了leader
            if (event.getType() == Event.EventType.NodeDeleted) {
                context.checkLeader();
            }
        }
    }
}

測試

測試程式

private void zkLeaderTwoTestWithMultiThread() throws Exception {
    List<LeaderTwoThread> leaderTwoThreads = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        leaderTwoThreads.add(new LeaderTwoThread(ZKLeaderTwo.create("127.0.0.1", "2181"), i));
    }
    leaderTwoThreads.forEach(LeaderTwoThread::start);

    //執行緒0斷連
    Thread.sleep(20000);
    leaderTwoThreads.get(0).getZkLeaderTwo().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 0));

    //執行緒1斷連
    Thread.sleep(20000);
    leaderTwoThreads.get(1).getZkLeaderTwo().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 1));

    //執行緒3斷連
    Thread.sleep(20000);
    leaderTwoThreads.get(3).getZkLeaderTwo().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 3));

    //執行緒4斷連
    Thread.sleep(20000);
    leaderTwoThreads.get(4).getZkLeaderTwo().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 4));

    //執行緒2斷連
    Thread.sleep(20000);
    leaderTwoThreads.get(2).getZkLeaderTwo().close();
    System.out.println(String.format("執行緒: [%s] 斷開連線", 2));

    Thread.sleep(60000);
}

private class LeaderTwoThread extends Thread {
    private ZKLeaderTwo zkLeaderTwo;
    private int threadNum;

    public ZKLeaderTwo getZkLeaderTwo() {
        return zkLeaderTwo;
    }

    LeaderTwoThread(ZKLeaderTwo zkLeaderTwo, int threadNum) {
        this.zkLeaderTwo = zkLeaderTwo;
        this.threadNum = threadNum;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Date dt = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String currentTime = sdf.format(dt);
            if (zkLeaderTwo.leader()) {
                System.out.println(String.format("[%s] 執行緒: [%s] 是主節點", currentTime, threadNum));
            }
        }
    }
}

結果:

[2017-11-30 16:47:41] 執行緒: [0] 是主節點
[2017-11-30 16:47:46] 執行緒: [0] 是主節點
[2017-11-30 16:47:51] 執行緒: [0] 是主節點
[2017-11-30 16:47:56] 執行緒: [0] 是主節點
執行緒: [0] 斷開連線
[2017-11-30 16:48:01] 執行緒: [1] 是主節點
[2017-11-30 16:48:06] 執行緒: [1] 是主節點
[2017-11-30 16:48:11] 執行緒: [1] 是主節點
[2017-11-30 16:48:16] 執行緒: [1] 是主節點
執行緒: [1] 斷開連線
[2017-11-30 16:48:21] 執行緒: [2] 是主節點
[2017-11-30 16:48:26] 執行緒: [2] 是主節點
[2017-11-30 16:48:31] 執行緒: [2] 是主節點
[2017-11-30 16:48:36] 執行緒: [2] 是主節點
執行緒: [3] 斷開連線
[2017-11-30 16:48:41] 執行緒: [2] 是主節點
[2017-11-30 16:48:46] 執行緒: [2] 是主節點
[2017-11-30 16:48:51] 執行緒: [2] 是主節點
[2017-11-30 16:48:56] 執行緒: [2] 是主節點
執行緒: [4] 斷開連線
[2017-11-30 16:49:01] 執行緒: [2] 是主節點
[2017-11-30 16:49:06] 執行緒: [2] 是主節點
[2017-11-30 16:49:11] 執行緒: [2] 是主節點
[2017-11-30 16:49:16] 執行緒: [2] 是主節點
執行緒: [2] 斷開連線
[2017-11-30 16:49:21] 執行緒: [5] 是主節點
[2017-11-30 16:49:26] 執行緒: [5] 是主節點
[2017-11-30 16:49:31] 執行緒: [5] 是主節點
[2017-11-30 16:49:36] 執行緒: [5] 是主節點
[2017-11-30 16:49:41] 執行緒: [5] 是主節點
[2017-11-30 16:49:46] 執行緒: [5] 是主節點
[2017-11-30 16:49:51] 執行緒: [5] 是主節點
[2017-11-30 16:49:56] 執行緒: [5] 是主節點
[2017-11-30 16:50:01] 執行緒: [5] 是主節點
[2017-11-30 16:50:06] 執行緒: [5] 是主節點
[2017-11-30 16:50:11] 執行緒: [5] 是主節點
[2017-11-30 16:50:16] 執行緒: [5] 是主節點

方案二優劣

優點

  • 實現對子節點變動狀態(排序在本程序對應節點之前的一個節點)的監聽
  • 被監聽子節點變動(刪除)之後，ZK通知本程序執行相應操作，判斷是否成為leader
  • 相對於父節點監聽方式，子節點監聽方式在每一次鎖釋放(或者節點變動)時，ZK僅通知到一個程序的watcher，節省了大量的網路消耗和資源佔用

劣勢

  • 實現方式與程式邏輯較父節點監聽來說比較繁瑣

總結比較

  • 程式複雜度：
    父節點監聽方式 < 子節點監聽方式

  • 網路資源消耗：
    父節點監聽方式 >> 子節點監聽方式

  • 程式可靠性
    父節點監聽方式 < 子節點監聽方式

輕量Zookeeper客戶端實現

github地址：

相關推薦

分散式系統筆記:利用zookeeper實現分散式leader節點選舉

利用zookeeper實現分散式leader節點選舉 依賴原理 在ZK中新增基本節點，路徑程式定義，節點型別為持久節點(PERSISTENT)。 對需要競選leader的每個程序，在ZK中分別新增基本節點的子節點，型別為臨時自編號節點(EPHEMERA

利用zookeeper實現分散式運用伺服器上下線的動態感知-簡單程式

package cn.nyzc.testzk; import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.zookeeper.KeeperException; import

【分散式鎖】06-Zookeeper實現分散式鎖：可重入鎖原始碼分析

前言 前面已經講解了Redis的客戶端Redission是怎麼實現分散式鎖的，大多都深入到原始碼級別。 在分散式系統中，常見的分散式鎖實現方案還有Zookeeper，接下來會深入研究Zookeeper是如何來實現分散式鎖的。 Zookeeper初識 檔案系統 Zookeeper維護一個類似檔案系統的資料結構

分散式學習筆記七：基於zookeeper實現分散式鎖

一、分散式鎖介紹         分散式鎖主要用於在分散式環境中保護跨程序、跨主機、跨網路的共享資源實現互斥訪問，以達到保證資料的一致性。 二、架構介紹     &nb

ZooKeeper分散式鎖簡單實踐 利用Redis實現分散式鎖

寫在最前面 前幾周寫了篇 利用Redis實現分散式鎖 ，今天簡單總結下ZooKeeper實現分散式鎖的過程。其實生產上我只用過Redis或者資料庫的方式，之前還真沒了解過ZooKeeper怎麼實現分散式鎖。這周簡單寫了個小Demo，更堅定了我繼續使用Redis的信心了。 ZooKeep

(轉載)Zookeeper實現分散式應用系統伺服器上下線動態感知

來到一家新公司，要求做zookeeper註冊中心的伺服器上線下線的動態感知。結果把要求看成了zookepper註冊中心的動態感知。哎，好尷尬呀！結果看到這篇文章我才恍然大悟。講的也很細緻！特發表一篇文章做為收藏。 我們現在有一個分散式應用系統提供服務，伺服器有很多臺，伺服器

關於利用MQ實現分散式事務的想法【轉】

轉自：https://www.jianshu.com/p/bafb09954f18   假設：訊息服務不丟訊息 場景 服務A 服務B 服務C 訊息服務Q 虛擬碼 服務A中 transaction{ A本地事務 B.callB(); C.callC(); A本地事務

SpringBoot與Dubbo和Zookeeper實現分散式

今天就來簡單使用Spring Boot與Dubbo及zookeeper整合使用分散式 首先, 先來簡單瞭解一下什麼是Dubbo及zookeeper Zookeeper Zookeeper是一個分散式的,開放原始碼的分散式應用程式協調服務,它是一個為分散式應用提供一致性服務的軟體,提供的功

利用Redisson實現分散式鎖及其底層原理解析

Redis介紹 redis是一個key-value儲存系統。和Memcached類似，它支援儲存的value型別相對更多，包括string(字串)、list(連結串列)、set(集合)、zset(sorted set --有序集合)和hash（雜湊型別）。這些資料型別都支援push/po

利用Redis實現分散式鎖 使用mysql樂觀鎖解決併發問題

寫在最前面 我在之前總結冪等性的時候，寫過一種分散式鎖的實現，可惜當時沒有真正應用過，著實的心虛啊。正好這段時間對這部分實踐了一下，也算是對之前填坑了。 分散式鎖按照網上的結論，大致分為三種：1、資料庫樂觀鎖； 2、基於Redis的分散式鎖；3.、基於ZooKeeper的分散式鎖； 關於樂觀鎖的實現其實

利用Redis實現分散式鎖

為什麼需要分散式鎖？ 在傳統單體應用單機部署的情況下，可以使用Java併發相關的鎖，如ReentrantLcok或synchronized進行互斥控制。但是，隨著業務發展的需要，原單體單機部署的系統，漸漸的被部署在多機器多JVM上同時提供服務，這使得原單機部署情況下的併發控制鎖策略失效了，為了解決這個問

SpringCloud利用Consul實現分散式配置中心

文章目錄 consul介紹 使用consul配置中心 將服務註冊到consul上 推送配置到consul配置中心 效果圖 consul介紹 Consul 是 HashiCorp 公司推出的開源工

C# 基於ZooKeeper實現分散式鎖

主體思路 1. 在locks節點下建立臨時順序節點node_n2. 判斷當前建立的節點是否為locks節點下所有子節點中最小的子節點3. 是則獲取鎖，進行業務處理，否則將節點從小到大排序，監聽當前節點上一個節點的刪除事件4. 事件觸發後回到步驟2進行判斷，直至拿到鎖 程式碼塊分析 建構函

使用redis和zookeeper實現分散式鎖

1.分散式鎖   分散式鎖一般用在分散式系統或者多個應用中，用來控制同一任務是否執行或者任務的執行順序。在專案中，部署了多個tomcat應用，在執行定時任務時就會遇到同一任務可能執行多次的情況，我們可以藉助分散式鎖，保證在同一時間只有一個tomcat應用執行了定時任務。 &nb

第1章 分散式系統概念與ZooKeeper簡介

分散式系統概念與ZooKeeper簡介 1-1 zookeeper簡介 1-2 什麼是分散式系統 1-3 分散式系統的瓶頸以及zk的相關特性 1-1 zookeeper簡介 1-2 什麼是分散式系統

zookeeper實現分散式鎖及 如何避免羊群效應

問題導讀： 1.zookeeper如何實現分散式鎖？ 2.什麼是羊群效應？ 3.zookeeper如何釋放鎖？ 在zookeeper應用場景有關於分散式叢集配置檔案同步問題的描述，設想一下如果有100臺機器同時對同一臺機器上某個檔案進行修改，如何才能保證文字不會被寫亂，這就

zookeeper 實現分散式鎖

 實現互斥鎖 package com.zookeeper.lock; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.uti

【原創】redis庫存操作，分散式鎖的四種實現方式[連載一]--基於zookeeper實現分散式鎖

一、背景 在電商系統中，庫存的概念一定是有的，例如配一些商品的庫存，做商品秒殺活動等，而由於庫存操作頻繁且要求原子性操作，所以絕大多數電商系統都用Redis來實現庫存的加減，最近公司專案做架構升級，以微服務的形式做分散式部署，對庫存的操作也單獨封裝為一個微服務，這樣在高併發情況下，加減庫存時，就會出現超賣等

ZooKeeper完全解析(七) 使用ZooKeeper實現分散式鎖之Java實現

  在上一節中，我們講了使用ZooKeeper來實現分散式鎖的原理，連結為  ZooKeeper完全解析(六) 使用ZooKeeper實現分散式鎖之實現原理 ，這一節我們來講一下如何使用Java來實現分散式鎖：   在實現原理中，我們把使用ZooKeeper實現分散式鎖分成

zookeeper實現分散式鎖

zookeeper介紹 一種提供配置管理、分散式協同以及命名的中心化服務 Zookeeper提供一個多層級的節點名稱空間（節點稱為znode）， 每個節點都用一個以斜槓（/）分隔的路徑表示，而且每個節點都有父節點（根節點除外），非常類似於檔案系統。 例如，/fo