Zookeeper源码解析之选举机制

最新推荐文章于 2024-07-15 20:47:10 发布
最新推荐文章于 2024-07-15 20:47:10 发布
阅读量428 收藏 3
点赞数 1
分类专栏： Zookeeper 分布式架构 java 文章标签： 分布式 zookeeper java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kwxyzk/article/details/107566631
版权

Zookeeper源码解析之选举机制

ZooKeeper 的使用一般来说都是集群的，ZooKeeper 的集群状态所示，集群部署时要选举出一台服务作为整个集群的领导者
Zookeeper集群架构图

选举机制中的概念:

服务id :sid（id）,服务的标识

服务器中存放的最大数据ID ： zxid

选举/投票纪元：epoch，即第几轮选举

Server状态——选举状态：

  • LOOKING：竞选状态。
  • FOLLOWING：随从状态，同步leader状态，参与投票。
  • OBSERVING：观察状态,同步leader状态，不参与投票。
  • LEADING：领导者状态。

选举流程

  1. 首先开始选举阶段，每个Server读取自身的sid，zxid，epoch(选举纪元，即第几轮选举)。
  2. 发送投票信息
    1. 首先，每个Server第一轮都会投票给自己。
    2. 投票信息包含 ：所选举leader sid，zxid，epoch。epoch会随着选举轮数的增加而递增。
  3. 接收投票信息
    1. 如果服务器B接收到服务器A的数据（服务器A处于选举状态(LOOKING 状态)
      1. 首先，判断逻辑时钟值：
        • 如果发送过来的投票纪元epoch大于目前的服务自己的投票纪元。首先，更新本服务投票纪元，同时清空本服务投票纪元内收集到的来自其他server的选举数据。然后，判断是否需要更新当前自己的选举leader sid。判断规则：先比较epoch,大的胜出，再比较zxid，zxid大的胜出，再比较sid，sid大的胜出；然后再将自身最新的选举结果(也就是上面提到的三种数据（leader id，zxid，epoch）广播给其他server)
        • 如果发送过来的投票纪元epoch小于目前的投票纪元。说明对方server在一个相对较早的投票纪元中，则只需要将本机的三种数据（leader sid，zxid，epoch）发送给对方。
        • 如果发送过来的投票纪元epoch等于目前的投票纪元。再根据上述判断规则来选举出leader ，然后再将自身最新的选举结果(leader sid，zxid，epoch）广播给其他server。
      2. 其次，判断服务器是不是已经收集到了所有服务器的选举状态：若是，根据选举结果设置自己的角色(FOLLOWING还是LEADER)，退出选举过程就是了。
        最后，若没有收到没有收集到所有服务器的选举状态：也可以判断一下根据以上过程之后最新的选举leader是不是得到了超过半数以上服务器的支持,如果是,那么尝试在200ms内接收一下数据,如果没有新的数据到来,说明大家都已经默认了这个结果,同样也设置角色退出选举过程。
    2. 如果所接收服务器A处在其它状态（FOLLOWING或者LEADING）
      1. 投票纪元epoch等于目前的投票纪元，将该数据保存到recvset。此时Server已经处于LEADING状态，说明此时这个server已经投票选出结果。若此时这个接收服务器宣称自己是leader, 那么将判断是不是有半数以上的服务器选举它，如果是则设置选举状态退出选举过程。
      2. 否则这是一条与当前投票纪元不符合的投票，那么说明在另一个选举过程中已经有了选举结果，于是将该选举结果加入到outofelection集合中，再根据outofelection来判断是否可以结束选举,如果可以结束则先保存投票纪元，设置选举状态，退出选举过程。

上边就是Zookeeper 的大概选举流程
选举过程

选举源码

下边我们看一下 Zookeeper 的选举流程在代码中是如何实现，目前新版的的 Zookeeper 中只保留一个选举算法，FastLeaderElection:

    public Vote lookForLeader() throws InterruptedException {
        try {
            self.jmxLeaderElectionBean = new LeaderElectionBean();
            MBeanRegistry.getInstance().register(self.jmxLeaderElectionBean, self.jmxLocalPeerBean);
        } catch (Exception e) {
            LOG.warn("Failed to register with JMX", e);
            self.jmxLeaderElectionBean = null;
        }

        self.start_fle = Time.currentElapsedTime();
        try {
            //当前选举纪元 leader 的选票保存
            Map<Long, Vote> recvset = new HashMap<Long, Vote>();

            //过期选举纪元 leander 的选票保存
            Map<Long, Vote> outofelection = new HashMap<Long, Vote>();
            int notTimeout = minNotificationInterval;
            synchronized (this) {
                logicalclock.incrementAndGet();//增加当前服务选举纪元
                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());//投票自己做leader
            }
            sendNotifications();//向集群广播自己的投票
            SyncedLearnerTracker voteSet;

             //循环直到选出一个leader
            while ((self.getPeerState() == ServerState.LOOKING) && (!stop)) {
                //从接受到的投票中取出一个投票
                Notification n = recvqueue.poll(notTimeout, TimeUnit.MILLISECONDS);

                 //则发送更多投票信息，否则处理新的投票信息.
                if (n == null) {
                    if (manager.haveDelivered()) {
                        sendNotifications(); //广播自己的投票
                    } else {
                        manager.connectAll();//重新连接集群投票连接
                    }

                    //超时时间
                    int tmpTimeOut = notTimeout * 2;
                    notTimeout = Math.min(tmpTimeOut, maxNotificationInterval);
                    LOG.info("Notification time out: {}", notTimeout);
                } else if (validVoter(n.sid) && validVoter(n.leader)) {//sid是否在可参与投票选举对象内
                     //仅当投票来自当前或下一个纪元时才继续进行
                    switch (n.state) {
                    case LOOKING:
                        if (getInitLastLoggedZxid() == -1) {
                            LOG.debug("Ignoring notification as our zxid is -1");
                            break;
                        }
                        if (n.zxid == -1) {
                            LOG.debug("Ignoring notification from member with -1 zxid {}", n.sid);
                            break;
                        }
                        //如果投票信息中的投票纪元大于当前服务的投票纪元，则将服务纪元更新为投票信息中的纪元，并选出自己的投票投出 
                        if (n.electionEpoch > logicalclock.get()) {
                            logicalclock.set(n.electionEpoch);
                            recvset.clear();
                            //totalOrderPredicate leader选票比拼
                            //判断规则：先比较epoch,大的胜出，再比较zxid，zxid大的胜出，再比较sid，sid大的胜出    
                            if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, getInitId(), getInitLastLoggedZxid(), getPeerEpoch())) {
                                updateProposal(n.leader, n.zxid, n.peerEpoch);//将收到的投票信息中的投票服务作为自己的leader投票
                            } else {
                                //继续坚持自己作为leader
                                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
                            }
                            sendNotifications();//广播自己的投票
                        } else if (n.electionEpoch < logicalclock.get()) { //如果当前投票信息中的投票纪元过期，则重新获取下一个的投票
                                LOG.debug(
                                    "Notification election epoch is smaller than logicalclock. n.electionEpoch = 0x{}, logicalclock=0x{}",
                                    Long.toHexString(n.electionEpoch),
                                    Long.toHexString(logicalclock.get()));
                            break;
                        } else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, proposedLeader, proposedZxid, proposedEpoch)) {//同纪元比拼
                            //如果投票中的服务胜出
                            updateProposal(n.leader, n.zxid, n.peerEpoch);//将收到的投票信息中的投票服务作为自己选举的leader投票
                            sendNotifications();//广播自己的投票
                        }

                        LOG.debug(
                            "Adding vote: from={}, proposed leader={}, proposed zxid=0x{}, proposed election epoch=0x{}",
                            n.sid,
                            n.leader,
                            Long.toHexString(n.zxid),
                            Long.toHexString(n.electionEpoch));

                        // 保存收到的投票
                        recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));
                        //获取集群内的所有投票信息
                        voteSet = getVoteTracker(recvset, new Vote(proposedLeader, proposedZxid, logicalclock.get(), proposedEpoch));

                        if (voteSet.hasAllQuorums()) {//是否收到所有的投票确认

                            // 在超时时间内等待投票
                            while ((n = recvqueue.poll(finalizeWait, TimeUnit.MILLISECONDS)) != null) {
                                if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, proposedLeader, proposedZxid, proposedEpoch)) {
                                    recvqueue.put(n);//将收到的投票信息放入收到的投票队列中重新处理
                                    break;
                                }
                            }
                             //超时时间(200ms)内未收到新的投票，则投票结束
                            if (n == null) {
                                setPeerState(proposedLeader, voteSet);//判断当前服务在投票结束后的服务状态
                                Vote endVote = new Vote(proposedLeader, proposedZxid, logicalclock.get(), proposedEpoch);
                                leaveInstance(endVote);
                                return endVote; //返回并发送leanding状态的投票
                            }
                        }
                        break;
                    case OBSERVING:
                        LOG.debug("Notification from observer: {}", n.sid);
                        break;
                    case FOLLOWING:
                    case LEADING:
                        //通过服务器和投票在同一个投票纪元
                        if (n.electionEpoch == logicalclock.get()) {
                            recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch, n.state));//保存收到的投票
                            //获取收到的投票信息，由于判断是否可以结束投票
                            voteSet = getVoteTracker(recvset, new Vote(n.version, n.leader, n.zxid, n.electionEpoch, n.peerEpoch, n.state));
                            if (voteSet.hasAllQuorums() && checkLeader(recvset, n.leader, n.electionEpoch)) {
                                setPeerState(n.leader, voteSet);//判断当前服务在投票结束后的服务状态
                                Vote endVote = new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch);
                                leaveInstance(endVote);
                                return endVote; /返回并发送leanding状态的投票
                            }
                        }

                        //如果投票不再同一个纪元
                        outofelection.put(n.sid, new Vote(n.version, n.leader, n.zxid, n.electionEpoch, n.peerEpoch, n.state));
                        //获取收到的投票信息，由于判断是否可以结束投票
                        voteSet = getVoteTracker(outofelection, new Vote(n.version, n.leader, n.zxid, n.electionEpoch, n.peerEpoch, n.state));
                        //是否收到所有的投票确认返回，和当前投票和自己的收到的投票是否都认投票中的leader
                        if (voteSet.hasAllQuorums() && checkLeader(outofelection, n.leader, n.electionEpoch)) {
                            synchronized (this) {
                                logicalclock.set(n.electionEpoch);
                                setPeerState(n.leader, voteSet);
                            }
                            Vote endVote = new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch);
                            leaveInstance(endVote);
                            return endVote;//返回leader的投票
                        }
                        break;
                    default:
                        LOG.warn("Notification state unrecoginized: {} (n.state), {}(n.sid)", n.state, n.sid);
                        break;
                    }
                } else {
                    if (!validVoter(n.leader)) {
                        LOG.warn("Ignoring notification for non-cluster member sid {} from sid {}", n.leader, n.sid);
                    }
                    if (!validVoter(n.sid)) {
                        LOG.warn("Ignoring notification for sid {} from non-quorum member sid {}", n.leader, n.sid);
                    }
                }
            }
            return null;
        } finally {
            try {
                if (self.jmxLeaderElectionBean != null) {
                    MBeanRegistry.getInstance().unregister(self.jmxLeaderElectionBean);
                }
            } catch (Exception e) {
                LOG.warn("Failed to unregister with JMX", e);
            }
            self.jmxLeaderElectionBean = null;
            LOG.debug("Number of connection processing threads: {}", manager.getConnectionThreadCount());
        }
    }

    private void setPeerState(long proposedLeader, SyncedLearnerTracker voteSet) {
        //如果当前选举的对象是自己，则设置自己状态为LEADING，否则根据服务配置判断服务状态为FOLLOWING或者OBSERVING
        ServerState ss = (proposedLeader == self.getId()) ? ServerState.LEADING : learningState();
        self.setPeerState(ss);
        if (ss == ServerState.LEADING) {//如果自己是LEADING
            leadingVoteSet = voteSet;//保存LEADING的投票信息
        }
    }

上边是投票的主流程处理，但不是全部的投票处理逻辑，有部分投票的接受判断在接收到投票消息响应的时候处理，但是投票的发送和接受使用多线程处理，下边我们看看投票的通信处理，主要看跟投票逻辑相关的内容，其他不相关内容忽略：


protected class Messenger {
    Messenger(QuorumCnxManager manager) {
                this.ws = new WorkerSender(manager);
                this.wsThread = new Thread(this.ws, "WorkerSender[myid=" + self.getId() + "]");
                this.wsThread.setDaemon(true);
                this.wr = new WorkerReceiver(manager);
                this.wrThread = new Thread(this.wr, "WorkerReceiver[myid=" + self.getId() + "]");
                this.wrThread.setDaemon(true);
            }

    /**
     * 投票消息接受线程
     */
    class WorkerReceiver extends ZooKeeperThread {
        volatile boolean stop;
        QuorumCnxManager manager;
        WorkerReceiver(QuorumCnxManager manager) {
            super("WorkerReceiver");
            this.stop = false;
            this.manager = manager;
        }
        public void run() {
            Message response;
            while (!stop) {
                try {
                    response = manager.pollRecvQueue(3000, TimeUnit.MILLISECONDS);
                    //response 的解析和验证
                    //……
                    
                     //如果是没有资格参与投票选举的服务器，如observer，发送自己的投票
                    if (!validVoter(response.sid)) {
                        Vote current = self.getCurrentVote();
                        QuorumVerifier qv = self.getQuorumVerifier();
                        ToSend notmsg = new ToSend(
                            ToSend.mType.notification,
                            current.getId(),
                            current.getZxid(),
                            logicalclock.get(),
                            self.getPeerState(),
                            response.sid,
                            current.getPeerEpoch(),
                            qv.toString().getBytes());

                        sendqueue.offer(notmsg);
                    } else {
                        // 收到一个新的投票消息
                        LOG.debug("Receive new notification message. My id = {}", self.getId());
                        // 投票消息服务的判断
                        QuorumPeer.ServerState ackstate = QuorumPeer.ServerState.LOOKING;
                        switch (rstate) {
                        case 0:
                            ackstate = QuorumPeer.ServerState.LOOKING;
                            break;
                        case 1:
                            ackstate = QuorumPeer.ServerState.FOLLOWING;
                            break;
                        case 2:
                            ackstate = QuorumPeer.ServerState.LEADING;
                            break;
                        case 3:
                            ackstate = QuorumPeer.ServerState.OBSERVING;
                            break;
                        default:
                            continue;
                        }

                        n.leader = rleader;
                        n.zxid = rzxid;
                        n.electionEpoch = relectionEpoch;
                        n.state = ackstate;
                        n.sid = response.sid;
                        n.peerEpoch = rpeerepoch;
                        n.version = version;
                        n.qv = rqv;
                        //……

                        //如果自己服务状态为looking
                        if (self.getPeerState() == QuorumPeer.ServerState.LOOKING) {
                            recvqueue.offer(n);//接受投票
                             //如果发送投票的服务处在looking状态，则向它响应自己的选举投票
                            if ((ackstate == QuorumPeer.ServerState.LOOKING)
                                && (n.electionEpoch < logicalclock.get())) {
                                Vote v = getVote();
                                QuorumVerifier qv = self.getQuorumVerifier();
                                ToSend notmsg = new ToSend(
                                    ToSend.mType.notification,
                                    v.getId(),
                                    v.getZxid(),
                                    logicalclock.get(),
                                    self.getPeerState(),
                                    response.sid,
                                    v.getPeerEpoch(),
                                    qv.toString().getBytes());
                                sendqueue.offer(notmsg);
                            }
                        } else {
                             //如果当前服务不是looking状态，但它还得向发送投票的服务响应，响应当前集群选出的leader对象
                            Vote current = self.getCurrentVote();
                            if (ackstate == QuorumPeer.ServerState.LOOKING) {
                                if (self.leader != null) {
                                    if (leadingVoteSet != null) {
                                        self.leader.setLeadingVoteSet(leadingVoteSet);
                                        leadingVoteSet = null;
                                    }
                                    self.leader.reportLookingSid(response.sid);
                                }
                                QuorumVerifier qv = self.getQuorumVerifier();
                                ToSend notmsg = new ToSend(
                                    ToSend.mType.notification,
                                    current.getId(),
                                    current.getZxid(),
                                    current.getElectionEpoch(),
                                    self.getPeerState(),
                                    response.sid,
                                    current.getPeerEpoch(),
                                    qv.toString().getBytes());
                                sendqueue.offer(notmsg);
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    LOG.warn("Interrupted Exception while waiting for new message", e);
                }
            }
            LOG.info("WorkerReceiver is down");
        }

    }
    
    //发送线程
    class WorkerSender extends ZooKeeperThread {
        //比较简单，不做介绍
    }
}
kwxyzk
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【zookeeper】zookeeper 选举 源码解读
九师兄
02-01 2602
文章目录1.概述2. startLeaderElection2.1 createElectionAlgorithm2.2 createCnxnManager2.3 listener.start3.创建选举算法FastLeaderElection3.1 starter4.开始选举 super.start 1.概述 今天除夕夜，卷了 一整天，这是我第七个年头除夕夜还在学，今天卷到跨年夜。 视频：zookeeper 源码解读 上一篇文章：【zookeeper】zookeeper 启动 源码解读 2. star
Zookeeper 源码解析
程序员光剑
08-04 728
Zookeeper是一个开源的分布式协调服务，它是一个高性能、高可用、且易于使用的分布式协调系统，被业界广泛应用在Apache Hadoop、HBase、Kafka等开源系统中。其主要功能包括配置管理、命名服务、集群管理、分布式锁、分布式队列等。Zookeeper是一个独立的Server，无单独的客户端，需要通过API与其他组件进行交互，比如各个节点的角色协商、状态同步等。本文将带领读者阅读Zookeeper的代码并结合自己的理解，分析Zookeeper的运行机制、原理及内部实现。
Zookeeper源码分析之leader选举
热门推荐
数据之路
12-10 3万+
zookeeper默认选举算法为FastLeaderElection.java,其主要方法为FastLeaderElection.lookForLeader,选举的结果保存在类Vote中源码分析LOOKING 转载请注明原文链接：http://blog.csdn.net/odailidong/article/details/41855613
Zookeeper源码学习
最新发布
Deep Water Slow
07-15 746
当选举结束后，每个节点都需要根据自己的角色更新自己的状态。选举出的Leader更新自己的状态为Leader，其它节点更新自己状态为Follower。（3） COMMIT Leader的zxid比Follower的zxid大，发送Proposal给Follower提交执行。（2）当Leader第二种Follower的状态了，就确定需要做何种方式的数据同步DIFF、TRUNC、SNAP。（2）TRUNC Follower的zxid比Leader的zxid大，所以Follower要回滚。
Zookeeper选举机制
tangguoxing000的博客
11-24 782
部分转载于：https://blog.csdn.net/caohongshuang/article/details/84653941 Zookeeper为了保证各节点的协同工作，在工作时需要一个Leader角色，而Zookeerper默认采用FastLeaderElection算法，且投票数大于半数则胜出的机制。 一、相关概念 1、Serverid：服务器ID 这是在配置集群时设置的myid参数文件，比如有三台服务器，编号分别是1,2,3，分别表示为服务器1、服务器2、服务器3 编号越大...
Zookeeper学习----Zookeeper选举源码解析
https://juejin.cn/user/4248168663101239/posts
07-26 858
Zookeeper选举源码解析一. Zookeeper选举机制——第一次启动二. Zookeeper选举机制——非第一次启动三. Zookeeper选举源码解析①. 选举准备1. startLeaderElection()选举准备2. createElectionAlgorithm()创建选举算法实例3. 创建 QuorumCnxnManager，负责选举过程中的所有网络通信4. 启动监听线程listener.start()5. 准备开始选举6. 创建各种队列②. 选举执行1. super.start()
Zookeeper leader选举源码分析(超详细)
twx843571091的博客
08-31 1445
在开始分析选举的原理之前，先了解几个重要的参数比如有三台服务器，编号分别是 1,2,3。编号越大在选择算法中的权重越大。值越大说明数据越新，在选举算法中的权重也越大或者叫投票的次数，同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加，然后与接收到的其它服务器返回的投票信息中的数值相比，根据不同的值做出不同的判断。LOOKING，竞选状态。FOLLOWING，随从状态，同步 leader 状态，参与投票。OBSERVING，观察状态,同步 leader 状态，不参与投票。.........
zookeeper选举机制
xxydzyr的博客
06-23 1716
zookeeper选举机制 zookeeper 默认的算法是 FastLeaderElection，采用投票数大于半数则胜出的逻辑。 相关内容： Zab协议 、数据可以两阶段提交协议 1. 与选举相关的概念 服务器 ID ​ 比如有三台服务器，编号分别是 1,2,3。 ​ 编号越大在选择算法中的权重越大。 选举状态 ​ LOOKING，竞选状态。 ​ FOLLOWING，随从状态，同步 leade...
ZooKeeper源码解析——学习ApacheZookeeper原理，掌握其核心组件的数据模型、监听通知机制等
程序员光剑
07-31 1825
随着互联网的飞速发展，各种信息数据越来越多，数据的存储也越来越依赖于分布式文件系统或NoSQL数据库。而传统的单机数据库往往不具备弹性可扩展性和高可用容错能力，在面对海量数据时难免会遇到性能瓶颈。为了解决这一问题，人们又提出了分布式文件系统或NoSQL数据库，但这类数据库通常都采用Master-Slave模式，需要一个单点的协调者（Master）负责全局管理，并且不具备水平扩展能力。因此，当数据量达到一定规模后，仍然会面临如何横向扩展的问题。
zookeeper源码
04-20
《深入剖析Zookeeper源码》 Zookeeper，作为分布式协调服务的典范，广泛应用于大数据、云计算等领域的系统架构中。其稳定、高效的设计理念和强大的功能特性，使其在分布式环境中扮演着不可或缺的角色。本文将围绕...
Zookeeper的领导者选举机制解析
yasin的技术博客
07-05 2682
什么是领导者选举 Zookeeper作为一个分布式中间件，为了提高自身的可用性，其内部是多节点以集群模式部署的，官网上的架构图放在下方 根据官网的介绍，每一个Server节点都保存着其他节点的信息，即节点间保持信息互通；只有当集群中大多数节点可用时，整个集群才可用。 集群中的节点有以下几个状态： LEADER 领导者，集群中有且仅存在一个；其负责集群中其他节点的探活，以及不停地同步最新数据给其他节点 FOLLOWING 跟随者，就是集群中负责工作的小弟 OBSERVER 观察者，这个节点作用和FOLLO
ZooKeeper领导者选举源码分析
Hilite的博客
03-06 1794
前言： 大家都知道领导者选举有四种算法，其中三种已经被弃用了，所以本文只针对快速领导者选举算法进行讲解，通过阐述ZooKeeper（下文简称zk）领导者选举原理及源码阅读，带大家由浅入深的了解zk领导者选举原理。 正文： 一、领导者选举原理 大家在平时生活中肯定碰到过不少关于投票选举的事情，能对于你选择造成影响的主要因素无外乎两个： 1：你跟别人的人际关系。 ...
Zookeeper源码分析（2）- zookeeper的选举流程
vinowan的专栏
03-26 2215
发起选举流程有两种情况： server刚启动的时候，server的状态初始化为LOOKING状态 server发生异常，切换到LOOKING状态 server有4中状态 LOOKING：初始状态，表示在选举leader FOLLOWING：跟随leader的角色，参与投票 LEADING：集群的leader OBSERVING：不参与投票，只是同步状态
Zookeeper（三）leader的选举及源码分析
qq_35599414的博客
09-17 409
在讲源码前先做一些知识铺垫：zookeeper的一致性： 一致性可以抽象为为了达到——多数一致认为的结果，也就是要实现多方都认可的结果 例：数据一致性：则需要各个机器达到数据同步的结果 master选举：则需要选举出一个leader的结果 分布式锁：则需要只有一个人占用资源锁的结果 (zk中的过半数投票则表示成功，数据同步时也要投票，后面的机器会陆续同步，但这不是最终一致性) zk该中间件提供了分布式锁、master选举、注册中心等服务（都是依赖zk的节点特性+w...
Zookeeper源码解析（一）之持久化
凤瓦力
02-13 233
Zookeeper的持久化就是将内存中的数据保存到磁盘上，防止数据丢失。 持久化主要分为两种 事务日志 数据快照 事务日志 事务日志主要是将每个事务操作先日志文件里，再进行实际的事务操作。这种先写日志后操作的方式被称为“write-ahead log”，这种机制被广泛使用的各种场景，比如Mysql的redo log，hdfs的editlog等等。有些是只先写元数据，有些是写数据本身。这种机制...
Zookeeper源码分析（三）-Leader的选举
10-09 1865
Zookeeper在源码中选举可分为两步 1.startLeaderElection();//创建选举算法 synchronized public void startLeaderElection() { try { //创建一个投票自己的投票对象 currentVote = new Vote(myid, getLastLogg
ZooKeeper源码解析:Leader选举
u012957549的博客
03-21 345
Leader选举又称为master选举是zookeeper中最为经典的应用场景了。那为什么需要leader 选举呢。 ZooKeeper需要在所有的服务(可理解为服务器)中选举出一个Leader，然后让这个Leader来负责管理集群。此时，集群中的其他服务器则成了此Leader的follower。并且，当Leader出现故障的时候，ZooKeeper要能够快速地在Follower中选举出下一个Le...
深入解析Zookeeper的FastLeaderElection选举机制
"本文深入解析了Zookeeper的选举机制，特别是其FastLeaderElection算法，以及涉及的关键概念和流程。" Zookeeper是一个分布式协调服务，它在分布式环境中扮演着重要的角色，确保数据的一致性和高可用性。Zookeeper...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值