烈冬-冰夏
烈冬-冰夏

zookeeper源码浅析（二）之Leader选择

1.入口函数QuorumPeerMain主线程启动
Quorumpeermain.runfromconfig()代码
  1. public void runFromConfig(QuorumPeerConfig config) throws IOException {    
  2.       ......    
  3.       
  4.       LOG.info("Starting quorum peer");    
  5.       try {    
  6.         //对client提供读写的server，一般是2181端口    
  7.           ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory();    
  8.           cnxnFactory.configure(config.getClientPortAddress(),    
  9.                                 config.getMaxClientCnxns());    
  10.         //zk的逻辑主线程，负责选举，投票等    
  11.           quorumPeer = new QuorumPeer();    
  12.           quorumPeer.setClientPortAddress(config.getClientPortAddress());    
  13.           quorumPeer.setTxnFactory(new FileTxnSnapLog(    
  14.                       new File(config.getDataLogDir()),    
  15.                       new File(config.getDataDir())));    
  16.         //集群机器地址    
  17.           quorumPeer.setQuorumPeers(config.getServers());    
  18.           quorumPeer.setElectionType(config.getElectionAlg());    
  19.         //本机的集群编号    
  20.           quorumPeer.setMyid(config.getServerId());    
  21.           quorumPeer.setTickTime(config.getTickTime());    
  22.           quorumPeer.setMinSessionTimeout(config.getMinSessionTimeout());    
  23.           quorumPeer.setMaxSessionTimeout(config.getMaxSessionTimeout());    
  24.           quorumPeer.setInitLimit(config.getInitLimit());    
  25.           quorumPeer.setSyncLimit(config.getSyncLimit());    
  26.         //投票决定方式，默认超过半数就通过    
  27.           quorumPeer.setQuorumVerifier(config.getQuorumVerifier());    
  28.           quorumPeer.setCnxnFactory(cnxnFactory);    
  29.           quorumPeer.setZKDatabase(new ZKDatabase(quorumPeer.getTxnFactory()));    
  30.           quorumPeer.setLearnerType(config.getPeerType());    
  31.         //启动主线程    
  32.           quorumPeer.start();    
  33.           quorumPeer.join();    
  34.       } catch (InterruptedException e) {    
  35.           // warn, but generally this is ok    
  36.           LOG.warn("Quorum Peer interrupted", e);    
  37.       }    
  38.     }    

 2.QuorumPeer复写Thread.start方法，启动

Quorumpeer.start()代码
  1.  @Override    
  2.    public synchronized void start() {    
  3. //恢复DB，从zxid中回复epoch变量，代表投票轮数    
  4.        loadDataBase();    
  5. //启动针对client的IO线程    
  6.        cnxnFactory.start();    
  7. //选举初始化，主要是从配置获取选举类型            
  8.        startLeaderElection();    
  9. //启动    
  10.        super.start();    
  11.    }    

  3.通过QuorumPeer.loadDataBase()加载数据，初始化zkDb、currentEpoch、acceptedEpoch。

Quorumpeer.loaddatabase()代码
  1. private void loadDataBase() {  
  2.         try {  
  3.             //从本地文件恢复db   
  4.             zkDb.loadDataBase();  
  5.   
  6.             // load the epochs  
  7.             //从最新的zxid恢复epoch变量，zxid64位，前32位是epoch值，后32位是zxid   
  8.             long lastProcessedZxid = zkDb.getDataTree().lastProcessedZxid;  
  9.             long epochOfZxid = ZxidUtils.getEpochFromZxid(lastProcessedZxid);  
  10.             try {  
  11.                 currentEpoch = readLongFromFile(CURRENT_EPOCH_FILENAME);  
  12.             } catch(FileNotFoundException e) {  
  13.                 .....  
  14.             }  
  15.             if (epochOfZxid > currentEpoch) {  
  16.                 throw new IOException("The current epoch, " + ZxidUtils.zxidToString(currentEpoch) + ", is older than the last zxid, " + lastProcessedZxid);  
  17.             }  
  18.             try {  
  19.                 acceptedEpoch = readLongFromFile(ACCEPTED_EPOCH_FILENAME);  
  20.             } catch(FileNotFoundException e) {  
  21.                 .....  
  22.             }  
  23.             if (acceptedEpoch < currentEpoch) {  
  24.                 throw new IOException("The current epoch, " + ZxidUtils.zxidToString(currentEpoch) + " is less than the accepted epoch, " + ZxidUtils.zxidToString(acceptedEpoch));  
  25.             }  
  26.         } catch(IOException ie) {  
  27.            .....  
  28.         }  
  29.     }  

 4.通过QuorumPeer.startLeaderElection()初始化electionAlg、currentVote。

Quorumpeer.startleaderelection()代码
  1. synchronized public void startLeaderElection() {  
  2.         try {  
  3.                 //先投自己    
  4.             currentVote = new Vote(myid, getLastLoggedZxid(), getCurrentEpoch());  
  5.         } catch(IOException e) {  
  6.             RuntimeException re = new RuntimeException(e.getMessage());  
  7.             re.setStackTrace(e.getStackTrace());  
  8.             throw re;  
  9.         }  
  10.         //从配置中拿自己的选举地址    
  11.         for (QuorumServer p : getView().values()) {  
  12.             if (p.id == myid) {  
  13.                 myQuorumAddr = p.addr;  
  14.                 break;  
  15.             }  
  16.         }  
  17.         .....  
  18.         this.electionAlg = createElectionAlgorithm(electionType);  
  19.     }  

 5.获取选举算法，默认为FastLeaderElection算法。从3.4.0版本开始，zookeeper废弃了0,1,2三种算法。

Quorumpeer.createelectionalgorithm()代码
  1. protected Election createElectionAlgorithm(int electionAlgorithm){  
  2.         Election le=null;  
  3.                   
  4.         //TODO: use a factory rather than a switch  
  5.         switch (electionAlgorithm) {  
  6.         case 0:  
  7.             le = new LeaderElection(this);  
  8.             break;  
  9.         case 1:  
  10.             le = new AuthFastLeaderElection(this);  
  11.             break;  
  12.         case 2:  
  13.             le = new AuthFastLeaderElection(this, true);  
  14.             break;  
  15.         case 3:  
  16.             //leader选举IO负责类    
  17.             qcm = new QuorumCnxManager(this);  
  18.             QuorumCnxManager.Listener listener = qcm.listener;  
  19.             //启动已绑定配置的选举端口的选举线程，等待集群其他机器连接    
  20.             //例如配置文件中配置了server.1=hadoop1:2888:3888则server.1的选举端口为3888,2888是其leader和其他服务器交换信息的端口  
  21.             //配置文件详见QuorumPeerConfig.parseProperties()方法  
  22.             if(listener != null){  
  23.                 listener.start();  
  24.                 //基于TCP的选举算法  
  25.                 le = new FastLeaderElection(this, qcm);  
  26.             } else {  
  27.                 LOG.error("Null listener when initializing cnx manager");  
  28.             }  
  29.             break;  
  30.         default:  
  31.             assert false;  
  32.         }  
  33.         return le;  
  34.     }  
6. FastLeaderElection初始化
Fastleaderelection.starter()代码
  1. private void starter(QuorumPeer self, QuorumCnxManager manager) {  
  2.        this.self = self;  
  3.        proposedLeader = -1;  
  4.        proposedZxid = -1;  
  5.        //业务层发送队列，业务对象ToSend    
  6.        sendqueue = new LinkedBlockingQueue();  
  7.     //业务层接受队列，业务对象Notificataion    
  8.        recvqueue = new LinkedBlockingQueue();  
  9.     //Messenger包含WorkerSender和WorkerReceiver线程  
  10.     //WorkerSender业务层发送线程，将消息发给IO负责类QuorumCnxManager  
  11.     //WorkerReceiver业务层接受线程，从IO负责类QuorumCnxManager接受消息    
  12.        this.messenger = new Messenger(manager);  
  13.    }  
7.QuorumPeer线程启动
Quorumpeer.run()代码
  1. @Override  
  2.     public void run() {  
  3.         .....  
  4.         try {  
  5.             /*  
  6.              * Main loop  
  7.              */  
  8.             while (running) {  
  9.                 switch (getPeerState()) {  
  10.                 //如果状态是LOOKING，则进入选举流程    
  11.                 case LOOKING:  
  12.                     LOG.info("LOOKING");  
  13.                         .....  
  14.                         try {  
  15.                             roZkMgr.start();  
  16.                             //选举算法开始选举   
  17.                             setCurrentVote(makeLEStrategy().lookForLeader());  
  18.                         } catch (Exception e) {  
  19.                             LOG.warn("Unexpected exception",e);  
  20.                             setPeerState(ServerState.LOOKING);  
  21.                         } finally {  
  22.                             // If the thread is in the the grace period, interrupt  
  23.                             // to come out of waiting.  
  24.                             roZkMgr.interrupt();  
  25.                             roZk.shutdown();  
  26.                         }  
  27.                     } else {  
  28.                         try {  
  29.                             setCurrentVote(makeLEStrategy().lookForLeader());  
  30.                         } catch (Exception e) {  
  31.                             LOG.warn("Unexpected exception", e);  
  32.                             setPeerState(ServerState.LOOKING);  
  33.                         }  
  34.                     }  
  35.                     break;  
  36.                 //当选举完成会改变相应的状态，并创建相应的对象                      
  37.                 case OBSERVING:  
  38.                     try {  
  39.                         LOG.info("OBSERVING");  
  40.                         setObserver(makeObserver(logFactory));  
  41.                         observer.observeLeader();  
  42.                     } catch (Exception e) {  
  43.                         LOG.warn("Unexpected exception",e );                          
  44.                     } finally {  
  45.                         observer.shutdown();  
  46.                         setObserver(null);  
  47.                         setPeerState(ServerState.LOOKING);  
  48.                     }  
  49.                     break;  
  50.                 case FOLLOWING:  
  51.                     try {  
  52.                         LOG.info("FOLLOWING");  
  53.                         setFollower(makeFollower(logFactory));  
  54.                         follower.followLeader();  
  55.                     } catch (Exception e) {  
  56.                         LOG.warn("Unexpected exception",e);  
  57.                     } finally {  
  58.                         follower.shutdown();  
  59.                         setFollower(null);  
  60.                         setPeerState(ServerState.LOOKING);  
  61.                     }  
  62.                     break;  
  63.                 case LEADING:  
  64.                     LOG.info("LEADING");  
  65.                     try {  
  66.                         setLeader(makeLeader(logFactory));  
  67.                         leader.lead();  
  68.                         setLeader(null);  
  69.                     } catch (Exception e) {  
  70.                         LOG.warn("Unexpected exception",e);  
  71.                     } finally {  
  72.                         if (leader != null) {  
  73.                             leader.shutdown("Forcing shutdown");  
  74.                             setLeader(null);  
  75.                         }  
  76.                         setPeerState(ServerState.LOOKING);  
  77.                     }  
  78.                     break;  
  79.                 }  
  80.             }  
  81.         } finally {  
  82.           .....  
  83.         }  
  84.     }  

 8.FastLeaderElection的选举流程

Fastleaderelection.lookforleader()代码
  1. public Vote lookForLeader() throws InterruptedException {  
  2.        .....  
  3.        try {  
  4.         //收到的投票    
  5.            HashMap recvset = new HashMap();  
  6.   
  7.            HashMap outofelection = new HashMap();  
  8.   
  9.            int notTimeout = finalizeWait;  
  10.   
  11.            synchronized(this){  
  12.                logicalclock++;  
  13.             //先投给自己    
  14.                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());  
  15.            }  
  16.   
  17.            LOG.info("New election. My id =  " + self.getId() +  
  18.                    ", proposed zxid=0x" + Long.toHexString(proposedZxid));  
  19.         //发送投票，包括发给自己         
  20.            sendNotifications();  
  21.   
  22.            /*  
  23.             * Loop in which we exchange notifications until we find a leader  
  24.             */  
  25.            //主循环，直到选出leader    
  26.            while ((self.getPeerState() == ServerState.LOOKING) &&  
  27.                    (!stop)){  
  28.                /*  
  29.                 * Remove next notification from queue, times out after 2 times  
  30.                 * the termination time  
  31.                 */  
  32.             //从IO线程里拿到投票消息，自己的投票也在这里处理     
  33.                Notification n = recvqueue.poll(notTimeout,  
  34.                        TimeUnit.MILLISECONDS);  
  35.   
  36.                /*  
  37.                 * Sends more notifications if haven't received enough.  
  38.                 * Otherwise processes new notification.  
  39.                 */  
  40.             //如果空闲     
  41.                if(n == null){  
  42.                 //消息发完了，继续发送，一直到选出leader为止    
  43.                    if(manager.haveDelivered()){  
  44.                        sendNotifications();  
  45.                    } else {  
  46.                     //消息还在，可能其他server还没启动，尝试连接     
  47.                        manager.connectAll();  
  48.                    }  
  49.   
  50.                    /*  
  51.                     * Exponential backoff  
  52.                     */  
  53.                  //延长超时时间    
  54.                    int tmpTimeOut = notTimeout*2;  
  55.                    notTimeout = (tmpTimeOut < maxNotificationInterval?  
  56.                            tmpTimeOut : maxNotificationInterval);  
  57.                    LOG.info("Notification time out: " + notTimeout);  
  58.                }  
  59.             //收到了投票消息    
  60.                else if(self.getVotingView().containsKey(n.sid)) {  
  61.                    /*  
  62.                     * Only proceed if the vote comes from a replica in the  
  63.                     * voting view.  
  64.                     */  
  65.                    switch (n.state) {  
  66.                 //LOOKING消息，则    
  67.                    case LOOKING:  
  68.                     //检查下收到的这张选票是否可以胜出，依次比较选举轮数epoch，事务zxid，服务器编号server id  
  69.                        // If notification > current, replace and send messages out  
  70.                        if (n.electionEpoch > logicalclock) {  
  71.                            logicalclock = n.electionEpoch;  
  72.                            recvset.clear();  
  73.                            if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,  
  74.                                    getInitId(), getInitLastLoggedZxid(), getPeerEpoch())) {  
  75.                                updateProposal(n.leader, n.zxid, n.peerEpoch);  
  76.                            } else {  
  77.                                updateProposal(getInitId(),  
  78.                                        getInitLastLoggedZxid(),  
  79.                                        getPeerEpoch());  
  80.                            }  
  81.                            sendNotifications();  
  82.                        } else if (n.electionEpoch < logicalclock) {  
  83.                            if(LOG.isDebugEnabled()){  
  84.                                LOG.debug("Notification election epoch is smaller than logicalclock. n.electionEpoch = 0x"  
  85.                                        + Long.toHexString(n.electionEpoch)  
  86.                                        + ", logicalclock=0x" + Long.toHexString(logicalclock));  
  87.                            }  
  88.                            break;  
  89.                        } else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,  
  90.                                proposedLeader, proposedZxid, proposedEpoch)) {  
  91.                         //胜出了，就把自己的投票修改为对方的，然后广播消息    
  92.                            updateProposal(n.leader, n.zxid, n.peerEpoch);  
  93.                            sendNotifications();  
  94.                        }  
  95.                        .....  
  96.                     //添加到本机投票集合，用来做选举终结判断   
  97.                        recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));  
  98.                     //选举是否结束，默认算法是超过半数server同意    
  99.                        if (termPredicate(recvset,  
  100.                                new Vote(proposedLeader, proposedZxid,  
  101.                                        logicalclock, proposedEpoch))) {  
  102.   
  103.                            // Verify if there is any change in the proposed leader  
  104.                            while((n = recvqueue.poll(finalizeWait,  
  105.                                    TimeUnit.MILLISECONDS)) != null){  
  106.                                if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,  
  107.                                        proposedLeader, proposedZxid, proposedEpoch)){  
  108.                                    recvqueue.put(n);  
  109.                                    break;  
  110.                                }  
  111.                            }  
  112.   
  113.                            /*  
  114.                             * This predicate is true once we don't read any new  
  115.                             * relevant message from the reception queue  
  116.                             */  
  117.                            if (n == null) {  
  118.                             //修改状态，LEADING or FOLLOWING    
  119.                                self.setPeerState((proposedLeader == self.getId()) ?  
  120.                                        ServerState.LEADING: learningState());  
  121.                             //返回最终的选票结果   
  122.                                Vote endVote = new Vote(proposedLeader,  
  123.                                        proposedZxid, proposedEpoch);  
  124.                                leaveInstance(endVote);  
  125.                                return endVote;  
  126.                            }  
  127.                        }  
  128.                        break;  
  129.                 //OBSERVING机器不参数选举        
  130.                    case OBSERVING:  
  131.                        LOG.debug("Notification from observer: " + n.sid);  
  132.                        break;  
  133.                 //这2种需要参与选举       
  134.                    case FOLLOWING:  
  135.                    case LEADING:  
  136.                        /*  
  137.                         * Consider all notifications from the same epoch  
  138.                         * together.  
  139.                         */  
  140.                        if(n.electionEpoch == logicalclock){  
  141.                          //同样需要加入到本机的投票集合   
  142.                            recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));  
  143.                          //投票是否结束，如果结束，再确认LEADER是否有效    
  144.                          //如果结束，修改自己的状态并返回投票结果   
  145.                            if(termPredicate(recvset, new Vote(n.leader,  
  146.                                            n.zxid, n.electionEpoch, n.peerEpoch, n.state))  
  147.                                            && checkLeader(outofelection, n.leader, n.electionEpoch)) {  
  148.                                self.setPeerState((n.leader == self.getId()) ?  
  149.                                        ServerState.LEADING: learningState());  
  150.   
  151.                                Vote endVote = new Vote(n.leader, n.zxid, n.peerEpoch);  
  152.                                leaveInstance(endVote);  
  153.                                return endVote;  
  154.                            }  
  155.                        }  
  156.   
  157.                        /**  
  158.                         * Before joining an established ensemble, verify that  
  159.                         * a majority are following the same leader.  
  160.                         */  
  161.                        outofelection.put(n.sid, new Vote(n.leader, n.zxid,  
  162.                                n.electionEpoch, n.peerEpoch, n.state));  
  163.                        if (termPredicate(outofelection, new Vote(n.leader,  
  164.                                n.zxid, n.electionEpoch, n.peerEpoch, n.state))  
  165.                                && checkLeader(outofelection, n.leader, n.electionEpoch)) {  
  166.                            synchronized(this){  
  167.                                logicalclock = n.electionEpoch;  
  168.                                self.setPeerState((n.leader == self.getId()) ?  
  169.                                        ServerState.LEADING: learningState());  
  170.                            }  
  171.                            Vote endVote = new Vote(n.leader, n.zxid, n.peerEpoch);  
  172.                            leaveInstance(endVote);  
  173.                            return endVote;  
  174.                        }  
  175.                        break;  
  176.                    default:  
  177.                        LOG.warn("Notification state unrecoginized: " + n.state  
  178.                              + " (n.state), " + n.sid + " (n.sid)");  
  179.                        break;  
  180.                    }  
  181.                } else {  
  182.                    LOG.warn("Ignoring notification from non-cluster member " + n.sid);  
  183.                }  
  184.            }  
  185.            return null;  
  186.        } finally {  
  187.            try {  
  188.                if(self.jmxLeaderElectionBean != null){  
  189.                    MBeanRegistry.getInstance().unregister(  
  190.                            self.jmxLeaderElectionBean);  
  191.                }  
  192.            } catch (Exception e) {  
  193.                LOG.warn("Failed to unregister with JMX", e);  
  194.            }  
  195.            self.jmxLeaderElectionBean = null;  
  196.        }  
  197.    }  

 9.选举消息发送

Fastleaderelection.sendnotifications()代码
  1. private void sendNotifications() {  
  2.        //循环发送    
  3.        for (QuorumServer server : self.getVotingView().values()) {  
  4.            long sid = server.id;  
  5.            //消息实体    
  6.            ToSend notmsg = new ToSend(ToSend.mType.notification,  
  7.                    proposedLeader,  
  8.                    proposedZxid,  
  9.                    logicalclock,  
  10.                    QuorumPeer.ServerState.LOOKING,  
  11.                    sid,  
  12.                    proposedEpoch);  
  13.            .....  
  14.            //添加到业务的发送队列，该队列会被WorkerSender消费    
  15.            sendqueue.offer(notmsg);  
  16.        }  
  17.    }  

 10.WorkerSender消费

Fastleaderelection.messenger.workersender.run()代码
  1. public void run() {  
  2.                while (!stop) {  
  3.                    try {  
  4.                        ToSend m = sendqueue.poll(3000, TimeUnit.MILLISECONDS);  
  5.                        if(m == null) continue;  
  6.   
  7.                        process(m);  
  8.                    } catch (InterruptedException e) {  
  9.                        break;  
  10.                    }  
  11.                }  
  12.                LOG.info("WorkerSender is down");  
  13.            }  
Fastleaderelection.messenger.workersender.process()代码
  1. private void process(ToSend m) {  
  2.                byte requestBytes[] = new byte[36];  
  3.                ByteBuffer requestBuffer = ByteBuffer.wrap(requestBytes);  
  4.   
  5.                /*  
  6.                 * Building notification packet to send  
  7.                 */  
  8.   
  9.                requestBuffer.clear();  
  10.                requestBuffer.putInt(m.state.ordinal());  
  11.                requestBuffer.putLong(m.leader);  
  12.                requestBuffer.putLong(m.zxid);  
  13.                requestBuffer.putLong(m.electionEpoch);  
  14.                requestBuffer.putLong(m.peerEpoch);  
  15.                //CnxManager这个IO负责类发送消息   
  16.                manager.toSend(m.sid, requestBuffer);  
  17.            }  

 11.QuorumCnxManager具体发送

Quorumcnxmanager.tosend()代码
  1. public void toSend(Long sid, ByteBuffer b) {  
  2.        /*  
  3.         * If sending message to myself, then simply enqueue it (loopback).  
  4.         */  
  5.      //如果是自己，不走网络，直接添加到本地接受队列    
  6.        if (self.getId() == sid) {  
  7.             b.position(0);  
  8.             addToRecvQueue(new Message(b.duplicate(), sid));  
  9.            /*  
  10.             * Otherwise send to the corresponding thread to send.  
  11.             */  
  12.     //否则，先添加到发送队列，然后尝试连接，连接成功则给每台server启动发送和接受线程    
  13.        } else {  
  14.             /*  
  15.              * Start a new connection if doesn't have one already.  
  16.              */  
  17.             if (!queueSendMap.containsKey(sid)) {  
  18.                 ArrayBlockingQueue bq = new ArrayBlockingQueue(  
  19.                         SEND_CAPACITY);  
  20.                 queueSendMap.put(sid, bq);  
  21.                 addToSendQueue(bq, b);  
  22.   
  23.             } else {  
  24.                 ArrayBlockingQueue bq = queueSendMap.get(sid);  
  25.                 if(bq != null){  
  26.                     addToSendQueue(bq, b);  
  27.                 } else {  
  28.                     LOG.error("No queue for server " + sid);  
  29.                 }  
  30.             }  
  31.             connectOne(sid);  
  32.                  
  33.        }  
  34.    }  

 11.尝试连接过程

Quorumcnxmanager.connectone()代码
  1. synchronized void connectOne(long sid){  
  2.        if (senderWorkerMap.get(sid) == null){  
  3.            InetSocketAddress electionAddr;  
  4.            if (self.quorumPeers.containsKey(sid)) {  
  5.             //对方的选举地址  
  6.                electionAddr = self.quorumPeers.get(sid).electionAddr;  
  7.            } else {  
  8.                LOG.warn("Invalid server id: " + sid);  
  9.                return;  
  10.            }  
  11.            try {  
  12.             .....  
  13.             //同步IO连接    
  14.                Socket sock = new Socket();  
  15.                setSockOpts(sock);  
  16.                sock.connect(self.getView().get(sid).electionAddr, cnxTO);  
  17.                if (LOG.isDebugEnabled()) {  
  18.                    LOG.debug("Connected to server " + sid);  
  19.                }  
  20.             //连上了，初始化IO线程    
  21.                initiateConnection(sock, sid);  
  22.            } catch (UnresolvedAddressException e) {  
  23.              .....  
  24.            }  
  25.        } else {  
  26.            LOG.debug("There is a connection already for server " + sid);  
  27.        }  
  28.    }  
Quorumcnxmanager.initiateconnection()代码
  1. public boolean initiateConnection(Socket sock, Long sid) {  
  2.         DataOutputStream dout = null;  
  3.         try {  
  4.             // Sending id and challenge  
  5.             dout = new DataOutputStream(sock.getOutputStream());  
  6.             dout.writeLong(self.getId());  
  7.             dout.flush();  
  8.         } catch (IOException e) {  
  9.             LOG.warn("Ignoring exception reading or writing challenge: ", e);  
  10.             closeSocket(sock);  
  11.             return false;  
  12.         }  
  13.           
  14.         // If lost the challenge, then drop the new connection  
  15.         //只允许sid大的主动连接sid小的  
  16.         if (sid > self.getId()) {  
  17.             LOG.info("Have smaller server identifier, so dropping the " +  
  18.                      "connection: (" + sid + ", " + self.getId() + ")");  
  19.             closeSocket(sock);  
  20.             // Otherwise proceed with the connection  
  21.         } else {  
  22.             SendWorker sw = new SendWorker(sock, sid);  
  23.             RecvWorker rw = new RecvWorker(sock, sid, sw);  
  24.             sw.setRecv(rw);  
  25.   
  26.             SendWorker vsw = senderWorkerMap.get(sid);  
  27.               
  28.             if(vsw != null)  
  29.                 vsw.finish();  
  30.               
  31.             senderWorkerMap.put(sid, sw);  
  32.             if (!queueSendMap.containsKey(sid)) {  
  33.                 queueSendMap.put(sid, new ArrayBlockingQueue(  
  34.                         SEND_CAPACITY));  
  35.             }  
  36.               
  37.             sw.start();  
  38.             rw.start();  
  39.               
  40.             return true;      
  41.               
  42.         }  
  43.         return false;  
  44.     }  

 12.QuorumCnxManager.Listener主循环接收连接

Quorumcnxmanager.listener.run()代码
  1. @Override  
  2.        public void run() {  
  3.            int numRetries = 0;  
  4.            while((!shutdown) && (numRetries < 3)){  
  5.                try {  
  6.                    ss = new ServerSocket();  
  7.                    ss.setReuseAddress(true);  
  8.                    int port = self.quorumPeers.get(self.getId()).electionAddr  
  9.                            .getPort();  
  10.                    InetSocketAddress addr = new InetSocketAddress(port);  
  11.                    LOG.info("My election bind port: " + addr.toString());  
  12.                    setName(self.quorumPeers.get(self.getId()).electionAddr  
  13.                            .toString());  
  14.                    ss.bind(addr);  
  15.                    while (!shutdown) {  
  16.                        Socket client = ss.accept();  
  17.                        setSockOpts(client);  
  18.                        LOG.info("Received connection request "  
  19.                                + client.getRemoteSocketAddress());  
  20.                        receiveConnection(client);  
  21.                        numRetries = 0;  
  22.                    }  
  23.                } catch (IOException e) {  
  24.                   .....  
  25.                }  
  26.            }  
  27.           .....  
  28.        }  
Quorumcnxmanager.listener.receiveconnection()代码
  1. public boolean receiveConnection(Socket sock) {  
  2.         Long sid = null;  
  3.           
  4.         try {  
  5.             // Read server id  
  6.             //读server id    
  7.             DataInputStream din = new DataInputStream(sock.getInputStream());  
  8.             sid = din.readLong();    
  9.             .....  
  10.         } catch (IOException e) {  
  11.             .....  
  12.         }  
  13.           
  14.         //If wins the challenge, then close the new connection.  
  15.         //如果对方id比我小，则关闭连接，只允许大id的server连接小id的server   
  16.         if (sid < self.getId()) {  
  17.             /*  
  18.              * This replica might still believe that the connection to sid is  
  19.              * up, so we have to shut down the workers before trying to open a  
  20.              * new connection.  
  21.              */  
  22.             SendWorker sw = senderWorkerMap.get(sid);  
  23.             if (sw != null) {  
  24.                 sw.finish();  
  25.             }  
  26.   
  27.             /*  
  28.              * Now we start a new connection  
  29.              */  
  30.             LOG.debug("Create new connection to server: " + sid);  
  31.             closeSocket(sock);  
  32.             connectOne(sid);  
  33.   
  34.             // Otherwise start worker threads to receive data.  
  35.         //如果对方id比我大，允许连接，并初始化单独的IO线程    
  36.         } else {  
  37.             SendWorker sw = new SendWorker(sock, sid);  
  38.             RecvWorker rw = new RecvWorker(sock, sid, sw);  
  39.             sw.setRecv(rw);  
  40.   
  41.             SendWorker vsw = senderWorkerMap.get(sid);  
  42.               
  43.             if(vsw != null)  
  44.                 vsw.finish();  
  45.               
  46.             senderWorkerMap.put(sid, sw);  
  47.               
  48.             if (!queueSendMap.containsKey(sid)) {  
  49.                 queueSendMap.put(sid, new ArrayBlockingQueue(  
  50.                         SEND_CAPACITY));  
  51.             }  
  52.               
  53.             sw.start();  
  54.             rw.start();  
  55.               
  56.             return true;      
  57.         }  
  58.         return false;  
  59.     }  

 13.IO发送线程SendWorker启动，开始发送选举消息

Quorumcnxmanager.sendworker.run()代码
  1. @Override  
  2.         public void run() {  
  3.             .....  
  4.             try {  
  5.                 while (running && !shutdown && sock != null) {  
  6.   
  7.                     ByteBuffer b = null;  
  8.                     try {  
  9.                         //每个server一个发送队列    
  10.                         ArrayBlockingQueue bq = queueSendMap  
  11.                                 .get(sid);  
  12.                         if (bq != null) {  
  13.                             //拿消息    
  14.                             b = pollSendQueue(bq, 1000, TimeUnit.MILLISECONDS);  
  15.                         } else {  
  16.                             LOG.error("No queue of incoming messages for " +  
  17.                                       "server " + sid);  
  18.                             break;  
  19.                         }  
  20.   
  21.                         if(b != null){  
  22.                             //发消息    
  23.                             lastMessageSent.put(sid, b);  
  24.                             send(b);  
  25.                         }  
  26.                     } catch (InterruptedException e) {  
  27.                        .....  
  28.                     }  
  29.                 }  
  30.             } catch (Exception e) {  
  31.                 .....  
  32.             }  
  33.             this.finish();  
  34.             LOG.warn("Send worker leaving thread");  
  35.         }  
  36.     }  

 14. IO接收线程RecvWorker启动，开始发送选举消息

Quorumcnxmanager.recvworker.run()代码
  1. @Override  
  2.        public void run() {  
  3.            threadCnt.incrementAndGet();  
  4.            try {  
  5.                while (running && !shutdown && sock != null) {  
  6.                    /**  
  7.                     * Reads the first int to determine the length of the  
  8.                     * message  
  9.                     */  
  10.                  //包的长度   
  11.                    int length = din.readInt();  
  12.                    if (length <= 0 || length > PACKETMAXSIZE) {  
  13.                        throw new IOException(  
  14.                                "Received packet with invalid packet: "  
  15.                                        + length);  
  16.                    }  
  17.                    /**  
  18.                     * Allocates a new ByteBuffer to receive the message  
  19.                     */  
  20.                  //读到内存   
  21.                    byte[] msgArray = new byte[length];  
  22.                    din.readFully(msgArray, 0, length);  
  23.                    ByteBuffer message = ByteBuffer.wrap(msgArray);  
  24.                 //添加到接收队列，后续业务层的接收线程WorkerReceiver会来拿消息    
  25.                    addToRecvQueue(new Message(message.duplicate(), sid));  
  26.                }  
  27.            } catch (Exception e) {  
  28.               .....  
  29.            } finally {  
  30.                LOG.warn("Interrupting SendWorker");  
  31.                sw.finish();  
  32.                if (sock != null) {  
  33.                    closeSocket(sock);  
  34.                }  
  35.            }  
  36.        }  

 15.业务层的接受线程WorkerReceiver取得消息

Fastleaderelection.messenger.workerreceiver.run()代码
  1. public void run() {  
  2.   
  3.                 Message response;  
  4.                 while (!stop) {  
  5.                     // Sleeps on receive  
  6.                     try{  
  7.                         //从QuorumCnxManager取得数据    
  8.                         response = manager.pollRecvQueue(3000, TimeUnit.MILLISECONDS);  
  9.                         if(response == null) continue;  
  10.   
  11.                         /*  
  12.                          * If it is from an observer, respond right away.  
  13.                          * Note that the following predicate assumes that  
  14.                          * if a server is not a follower, then it must be  
  15.                          * an observer. If we ever have any other type of  
  16.                          * learner in the future, we'll have to change the  
  17.                          * way we check for observers.  
  18.                          */  
  19.                         //如果是Observer，则返回当前选举结果     
  20.                         if(!self.getVotingView().containsKey(response.sid)){  
  21.                             Vote current = self.getCurrentVote();  
  22.                             ToSend notmsg = new ToSend(ToSend.mType.notification,  
  23.                                     current.getId(),  
  24.                                     current.getZxid(),  
  25.                                     logicalclock,  
  26.                                     self.getPeerState(),  
  27.                                     response.sid,  
  28.                                     current.getPeerEpoch());  
  29.   
  30.                             sendqueue.offer(notmsg);  
  31.                         } else {  
  32.                             // Receive new message  
  33.                             .....  
  34.   
  35.                             /*  
  36.                              * We check for 28 bytes for backward compatibility  
  37.                              */  
  38.                             if (response.buffer.capacity() < 28) {  
  39.                                 LOG.error("Got a short response: "  
  40.                                         + response.buffer.capacity());  
  41.                                 continue;  
  42.                             }  
  43.                             boolean backCompatibility = (response.buffer.capacity() == 28);  
  44.                             response.buffer.clear();  
  45.   
  46.                             // State of peer that sent this message  
  47.                             //对方节点状态    
  48.                             QuorumPeer.ServerState ackstate = QuorumPeer.ServerState.LOOKING;  
  49.                             switch (response.buffer.getInt()) {  
  50.                             case 0:  
  51.                                 ackstate = QuorumPeer.ServerState.LOOKING;  
  52.                                 break;  
  53.                             case 1:  
  54.                                 ackstate = QuorumPeer.ServerState.FOLLOWING;  
  55.                                 break;  
  56.                             case 2:  
  57.                                 ackstate = QuorumPeer.ServerState.LEADING;  
  58.                                 break;  
  59.                             case 3:  
  60.                                 ackstate = QuorumPeer.ServerState.OBSERVING;  
  61.                                 break;  
  62.                             }  
  63.   
  64.                             // Instantiate Notification and set its attributes  
  65.                             //初始化Notification对象    
  66.                             Notification n = new Notification();  
  67.                             n.leader = response.buffer.getLong();  
  68.                             n.zxid = response.buffer.getLong();  
  69.                             n.electionEpoch = response.buffer.getLong();  
  70.                             n.state = ackstate;  
  71.                             n.sid = response.sid;  
  72.                             if(!backCompatibility){  
  73.                                 n.peerEpoch = response.buffer.getLong();  
  74.                             } else {  
  75.                                 if(LOG.isInfoEnabled()){  
  76.                                     LOG.info("Backward compatibility mode, server id=" + n.sid);  
  77.                                 }  
  78.                                 n.peerEpoch = ZxidUtils.getEpochFromZxid(n.zxid);  
  79.                             }  
  80.                             .....  
  81.                             /*  
  82.                              * If this server is looking, then send proposed leader  
  83.                              */  
  84.                             //如果自己也在LOOKING，则放入业务接收队列，选举主线程会消费该消息    
  85.                             if(self.getPeerState() == QuorumPeer.ServerState.LOOKING){  
  86.                                 recvqueue.offer(n);  
  87.   
  88.                                 /*  
  89.                                  * Send a notification back if the peer that sent this  
  90.                                  * message is also looking and its logical clock is  
  91.                                  * lagging behind.  
  92.                                  */  
  93.                                 if((ackstate == QuorumPeer.ServerState.LOOKING)  
  94.                                         && (n.electionEpoch < logicalclock)){  
  95.                                     Vote v = getVote();  
  96.                                     ToSend notmsg = new ToSend(ToSend.mType.notification,  
  97.                                             v.getId(),  
  98.                                             v.getZxid(),  
  99.                                             logicalclock,  
  100.                                             self.getPeerState(),  
  101.                                             response.sid,  
  102.                                             v.getPeerEpoch());  
  103.                                     sendqueue.offer(notmsg);  
  104.                                 }  
  105.                             } else {  
  106.                                 /*  
  107.                                  * If this server is not looking, but the one that sent the ack  
  108.                                  * is looking, then send back what it believes to be the leader.  
  109.                                  */  
  110.                                  //如果自己不在选举中，而对方server在LOOKING中，则向其发送当前的选举结果，当有server加入一个essemble时有用   
  111.                                 Vote current = self.getCurrentVote();  
  112.                                 if(ackstate == QuorumPeer.ServerState.LOOKING){  
  113.                                     if(LOG.isDebugEnabled()){  
  114.                                         LOG.debug("Sending new notification. My id =  " +  
  115.                                                 self.getId() + " recipient=" +  
  116.                                                 response.sid + " zxid=0x" +  
  117.                                                 Long.toHexString(current.getZxid()) +  
  118.                                                 " leader=" + current.getId());  
  119.                                     }  
  120.                                     ToSend notmsg = new ToSend(  
  121.                                             ToSend.mType.notification,  
  122.                                             current.getId(),  
  123.                                             current.getZxid(),  
  124.                                             logicalclock,  
  125.                                             self.getPeerState(),  
  126.                                             response.sid,  
  127.                                             current.getPeerEpoch());  
  128.                                     sendqueue.offer(notmsg);  
  129.                                 }  
  130.                             }  
  131.                         }  
  132.                     } catch (InterruptedException e) {  
  133.                        .....  
  134.                     }  
  135.                 }  
  136.                 LOG.info("WorkerReceiver is down");  
  137.             }  
  138.         }  

   

Leader选举小结
 1.server启动时默认选举自己，并向整个集群广播
 2.收到消息时，通过3层判断：选举轮数，zxid，server id大小判断是否同意对方，如果同意，则修改自己的选票，并向集群广播
 3.QuorumCnxManager负责IO处理，每2个server建立一个连接，只允许id大的server连id小的server，每个server启动单独的读写线程处理，使用阻塞IO
 4.默认超过半数机器同意时，则选举成功，修改自身状态为LEADING或FOLLOWING
 5.Obserer机器不参与选举

你可能感兴趣的:(zookeeper)

  • 【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
  • Kafka详细解析与应用分析 芊言芊语 kafka分布式
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
  • Kafka 基础与架构理解 StaticKing KAFKAkafka
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
  • hbase介绍 CrazyL- 云计算+大数据hbase
    hbase是一个分布式的、多版本的、面向列的开源数据库hbase利用hadoophdfs作为其文件存储系统，提供高可靠性、高性能、列存储、可伸缩、实时读写、适用于非结构化数据存储的数据库系统hbase利用hadoopmapreduce来处理hbase、中的海量数据hbase利用zookeeper作为分布式系统服务特点：数据量大：一个表可以有上亿行，上百万列（列多时，插入变慢）面向列：面向列（族）的
  • Docker安装Kafka和Kafka-Manager 阿靖哦
    本文介绍如何通过Docker安装kafka与kafka界面管理界面一、拉取zookeeper由于kafka需要依赖于zookeeper，因此这里先运行zookeeper1、拉取镜像dockerpullwurstmeister/zookeeper2、启动dockerrun-d--namezookeeper-p2181:2181-eTZ="Asia/Shanghai"--restartalwayswu
  • 主流行架构 rainbowcheng 架构架构
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
  • 微服务治理：Nacos, Zookeeper, consul, etcd, Eureka等 5 个常用微服务注册工具对比 surfirst 架构微服务zookeeperconsul
    当然！下面是Nacos、Zookeeper、Consul、etcd和Eureka这五个常用的注册中心的详细对比：Nacos：Nacos是由HashiCorp开发的高度可扩展和可靠的服务发现、配置管理和服务网格解决方案。它的架构基于一组服务器代理形成的共识组和与服务器交互的许多客户端代理。主要特点包括：服务发现：服务在Nacos中注册，客户端可以通过DNS或HTTPAPI发现服务及其位置。健康检查：
  • 月度总结 | 2022年03月 | 考研与就业的抉择 | 确定未来走大数据开发路线 「已注销」 个人总结hadoop
    一、时间线梳理3月3日，寻找到同专业的就业伙伴3月5日，着手准备Java八股文，决定先走Java后端路线3月8月，申请到了校图书馆的考研专座，决定暂时放弃就业，先准备考研，买了数学和408的资料书3月9日-3月13日，因疫情原因，宿舍区暂封，这段时间在准备考研，发现内容特别多3月13日-3月19日，大部分时间在刷Hadoop、Zookeeper、Kafka的视频，同时在准备实习的项目3月20日，退
  • 微服务之服务注册与发现：Etcd、Zookeeper、Consul 与 Nacos 比较 陌北v1 微服务etcdzookeeperConsulNacos
    在微服务架构中，服务注册与发现是实现服务动态管理和负载均衡的关键。本文将对四款主流的服务注册与发现工具——Etcd、Zookeeper、Consul、Nacos进行深入对比，从功能、性能、一致性、生态集成、应用场景等多个维度展开分析，帮助您选择最适合的工具。核心概念服务注册：服务实例启动时将自身信息（IP地址、端口、健康状态等）注册到注册中心。服务发现：服务消费者通过注册中心查询所需服务的地址列表
  • Redisson分布式锁实现原理和使用 牧竹子 springboot#redisRedissonredis
    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
  • HBase介绍 mingyu1016 数据库
    概述HBase是一个分布式的、面向列的开源数据库,源于google的一篇论文《bigtable：一个结构化数据的分布式存储系统》。HBase是GoogleBigtable的开源实现，它利用HadoopHDFS作为其文件存储系统，利用HadoopMapReduce来处理HBase中的海量数据，利用Zookeeper作为协同服务。HBase的表结构HBase以表的形式存储数据。表有行和列组成。列划分为
  • K8S学习之PV&&PVC david161
    部署mysql之前我们需要先了解一个概念有状态服务。这是一种特殊的服务，简单的归纳下就是会产生需要持久化的数据，并且有很强的I/O需求，且重启需要依赖上次存储到磁盘的数据。如典型的mysql，kafka，zookeeper等等。在我们有比较优秀的商业存储的前提下，非常推荐使用有状态服务进行部署，计算和存储分离那是相当的爽的。在实际生产中如果没有这种存储，localPV也是不错的选择，当然local
  • 微服务架构下的服务治理实现方案详解 星辰@Sea 系统架构架构微服务云原生
    在微服务架构中，服务治理是确保系统稳定运行、提高服务间通信效率和灵活性的关键环节。它涉及服务的发现、负载均衡、容错、监控等多个方面。本文将深入探讨几种常见的服务治理实现方案：Zookeeper、Nacos、Consul、以及Eureka，分析它们的特点、工作原理及应用场景，帮助开发者根据实际需求选择合适的工具。一、服务治理概述服务治理，简而言之，就是对微服务架构中的服务进行有效管理的过程，包括服务
  • Dubbo 与 Zookeeper 在项目中的应用：原理与实现详解 CopyLower 学习Javadubbozookeeper分布式
    引言在微服务架构日益普及的今天，如何实现服务的高效调用和管理成为了关键问题。Dubbo作为阿里巴巴开源的高性能RPC框架，在分布式服务治理方面具有显著的优势。Zookeeper作为一款分布式协调服务，能够高效地管理和协调服务节点信息。因此，Dubbo与Zookeeper的结合不仅能够提供服务注册与发现机制，还能实现更高效的服务治理。在本文中，我们将深入探讨Dubbo和Zookeeper的原理、如何
  • 搭建Kafka+zookeeper集群调度 krb___ kafka分布式
    前言硬件环境172.18.0.5kafkazk1Kafka+zookeeperKafkaBroker集群172.18.0.6kafkazk2Kafka+zookeeperKafkaBroker集群172.18.0.7kafkazk3Kafka+zookeeperKafkaBroker集群软件环境zookeeper3.5.9资源调度、写作Kafka2.8.0消息通信中间件安装JDK1.8安装搭建zo
  • Kafka和Pulsar深入解析 jasen91 大数据开发kafka分布式
    Kafka多租户：单租户系统数据迁移：依赖MirrorMaker，需要额外维护。市场上也有ConfluentReplicator等供应商工具。分层存储：由供应商提供商业使用。组件依赖：KafkaRaft（KRaft）从Kafka2.8开始处于早期访问模式，允许Kafka在没有ZooKeeper的情况下工作。这对Kafka来说是一个显著的优势，因为它简化了Kafka的体系结构并降低了学习成本。云原生
  • Dubbo服务自动Web化之路 搜狐技术产品小编2023 dubbo前端
    本文字数：6047字预计阅读时间：40分钟01故障出现事情起源于一次故障，2023年12月14日14点26分，大量Dubbo服务报出异常，无法链接zookeeper集群：Session0x0 for serverdubboZk.xxx.com/10.x.x.x:2181, Closingsocketconnection. AttemptingreconnectexceptitisaSessionE
  • Linux系统部署Kafka教学 情书学长 linux学习笔记kafka
    第一步：Zookeeper安装（准备工作）1、解压安装将安装包上传到/opt/software目录下，解压并修改名称tar-zxvfapache-zookeeper-3.5.7-bin.tar.gz-C/opt/module/mvapache-zookeeper-3.5.7-bin/zookeeper2、配置服务器编号1)在/opt/module/zookeeper-3.5.7/这个目录下创建zk
  • dubbo 服务消费原理分析之服务目录 DEARM LINER dubbojava架构后端springboot
    文章目录前言一、RegistryDirectory1、DynamicDirectory2、RegistryProtocol.doCreateInvoker2、RegistryProtocol.subscribe3、ListenerRegistryWrapper.subscribe4、FailbackRegistry.subscribe5、ZookeeperRegistry.doSubscribe6
  • spark启动命令 学不会又听不懂 spark大数据分布式
    hadoop启动：cd/root/toolssstart-dfs.sh，只需在hadoop01上启动stop-dfs.sh日志查看：cat/root/toolss/hadoop/logs/hadoop-root-datanode-hadoop03.outzookeeper启动：cd/root/toolss/zookeeperbin/zkServer.shstart，三台都要启动bin/zkServ
  • zookeeper启动（一） 小园子的小菜 zookeeperzookeeper分布式云原生javajava-zookeeper
    1.zookeeper启动入口在zkServer.sh的启动命令中，我们可以找到zookeeper启动的关键类org.apache.zookeeper.server.quorum.QuorumPeerMainQuorumPeerMain#main我们可以直接看org.apache.zookeeper.server.quorum.QuorumPeerMain中的main方法，从下面的main方法中，
  • 编程常用命令总结 Yellow0523 LinuxBigData大数据
    编程命令大全1.软件环境变量的配置JavaScalaSparkHadoopHive2.大数据软件常用命令Spark基本命令Spark-SQL命令Hive命令HDFS命令YARN命令Zookeeper命令kafka命令Hibench命令MySQL命令3.Linux常用命令Git命令conda命令pip命令查看Linux系统的详细信息查看Linux系统架构(X86还是ARM，两种方法都可)端口号命令L
  • zookeeper+kafka消息队列部署 TBF610218 zookeeperkafka分布式
    消息队列的概念什么是消息队列消息是指在应用间传送的数据消息队列是一种应用间的通信方式解决方法，确保消息的可靠传递专门为消息做缓存的消息队列的特征存储将消息存储在某个类型的缓冲区中，指导目标进读取这些消息或者将其从消息队列中显示移除为止异步消息队列通过缓冲消息可以在应用程序当中公开一定程度的异步性，允许源进程发送消息并在队列当中累积消息，而且目标进程可以挑选消息并进行处理为什么需要消息队列解耦冗余扩
  • Zookeeper 开源客户端Curator处理事件监听 taj3991
    事件监听Zookeeper原生就支持通过注册Watcher来进行事件监听，但是其使用并不是特别方便，需要开发人员反复注册Watcher，比较繁琐。Curator引入了Cache来实现对zookeeper服务端事件的监听，Cache是Curator中对事件的包装，其对事件的监听其实可以近似的看做是一个本地缓存视图和远程Zookeeper视图的对比过程。同时Curator能够自动为开发人员处理反复注册
  • 阿里云服务器Zookeeper单机安装部署（单机伪集群稍后更新） 不减30斤不改名_TC
    首先服务器系统版本配置如下：40e2c9e8ed734139ac1f99197a01dad8.pngzookeeper下载链接：http://mirror.bit.edu.cn/apache/zookeeper/38f2d0f359d7426faf44a6b8047f4a94.pngzookeeper版本很重要，我下载的是3.4.14版本，至于为什么不用新的，后面会讲到。下载后解压放置路径：028
  • ZK springboot整合zookeeper 小P聊技术
    1资源资源信息版本号备注zookeeper3.4.10IP:192.168.51.4springboot2.1.5.RELEASEprettyZoo2.0zookeeper可视化工具zookeeper可视化工具下载springboot-zookeeper-demo源码下载2zookeeper安装需要安装zookeeper，如果未安装，可参考博文：ZKzookeeper单机安装与配置3springb
  • 运维学习————Zookeeper(2) 乆乄 学习
    目录一、zk节点和节点类型1、节点类型2、常用命令1、客户端链接2、常用命令3、权限控制相关命令特性授权格式测试一、zk节点和节点类型1、节点类型1、PERSISTENT--持久化目录节点客户端与zookeeper断开连接后，该节点依旧存在2、PERSISTENT_SEQUENTIAL-目持久化顺序编号录节点客户端与zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进
  • zookeeper原理篇-Zookeeper的数据存储与恢复原理 逐梦々少年
    前言经过前面的一些文章的学习和了解，我们对Zookeeper有了一定的理解，但是无论是节点持久化，还是启动流程中的数据恢复等，我们都没有详细的去了解内部的数据存储和恢复的机制，本篇文章就开始学习Zookeeper的数据存储相关。内存存储zookeeper刚开始的时候，我们就已经知道其结构就像一个内存数据库一样，按照树的结构，能把节点的路径、节点数据以及ACL和节点的数据存储，其核心就是依靠Data
  • springboot-2.3.3+dubbo-2.7.8+nacos-1.3.2+gateway-Hoxton.SR8 qjyn1314 dubbonacosspring-bootjavaspringbootspring后端
    序言：此次介绍的实践是dubbo-2.7.8+nacos-1.3.2+gateway-Hoxton.SR81、升级注册中心，。其目的是项目中要从使用dubbo+zookeeper服务间调用升级为dubbo+nacos服务间调用。第一点可以参考：https://blog.csdn.net/lwb314/article/details/1082338632、升级网关，在升级之前有可能使用的是vue在前
  • Kafka2.8.0集群安装教程 请叫我你好 安装教程kafka
    Kafka2.8.0集群安装教程准备工作node01~node04（四个节点机器，三台也可以），kafka安装node01~~node03启动zookeeper，这里依次启动node131，node132，node133上的zk。（关于zookeeper集群安装请看https://blog.csdn.net/qq_41578037/article/details/123809220）[root@n
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他