Zookeeper小结

最新推荐文章于 2022-05-09 22:37:20 发布

动次打次大铁锤

最新推荐文章于 2022-05-09 22:37:20 发布

阅读量211

点赞数

文章标签：分布式 zookeeper 锁

本文链接：https://blog.csdn.net/baidu_35249394/article/details/97787788

版权

Zookeeper

zookeeper解决的问题

zookeeper分布锁
zookeeper监控集群

CAP理论：高可用、容错性、一致性最多取其二

BASE理论：B基本可用、弱状态、最终一致性

zookeeper功能：Dubbo服务治理框架

发布订阅：redis mq
负载均衡：nginx apche httpd
命名服务：
分布式协调通知
集群管理：
Master选举：主从结构
分布式锁：redis
分布式队列

高可用和一致性取舍问题

分布式事务强一致性：2PC（二阶段提交） 3PC（3阶段提交）

不论是二阶段（强一致性）提交还是三阶段提交本质是尽可能晚提交（在事务提交前完成其他所有工作）。提交阶段耗时较短出现错误概率低。

2PC ]

二阶段缺点：

同步阻塞：执行过程中所有节点参与者事务阻塞。譬如使用锁进行隔离性操作时事务没提交占用锁资源并发量很差。
单点故障：协调者过于重要，协调者出现故障参与者一直阻塞。即使重新选举也没法解决问题
数据不一致：协调者向参与者发送commit请求后，出现网络故障，部分参与者执行commit操作，部分为接收到无法进行事务提交。整个系统出现数据不一致问题。
无法确定问题：commit后协调者和参与者同时宕机，此条事务状态不可控。即使重新选出协调者也无法确定事务是否被执行。
过于保守：缺乏有效容错机制，任何一个节点的失败会导致整个事务提交失败回滚。

JTA（java里面的分布式事务编程接口规范-JTA） JBOSS（天生支持分布式）

三阶段特点:

3PC

cancommit：询问所有人，根据返回结果决定是否可以执行操作。
precommit：预执行，如果超时默认执行失败
docommit：即使超时也会执行

解决了单点故障问题引发问题，减少阻塞发生。根据定时器，没有接收到协调者的信息默认执行commit，可能造成数据不一致问题。（其他参与者可能执行了abort）

高可用性集群服务拆分：主从结构->MASTER选举节点数据不一致

PAXOS算法：zookeeper核心原理对多个分布式线程数据达成一致的算法

NWR策略 N:数据分片 W:Write 至少由W份数据写入成功 R:Read 至少有R份数据读取成功。不要求数据强一致性解决读写均衡的一种方式。Read Only Write All 本质上释放了写模式的压力转给读模式。一般情况要求W+R>N。保证不存在一个数据同时存在读写，一般读写超过N/2就返回结果成功，后续数据同步更新操作由系统后台运行。

ZOOKEEPER保证

顺序一致性
原子性
单一视图
可靠性
实时性

zookeeper本身就是个分布式系统单点故障？

一般部署奇数个zk服务器服务器宕机数量节点总数不变若部署5个3个宕机失败若6个3个宕机失败 so//

Zab

zk只有一个master 多个slaver

Zab（Zookeeper Atomic Broadcast)：解决事务一致性问题zk使用ZAB协议。专门用来设计支持崩溃回复和原子广播的协议。

Zookeeper使用主备模式保证数据一致性：

在这里插入图片描述

客户端将信息写入主进程（leader）中然后由leader将数据备份到follower中

复制过程同2PC类似，只要由一般备份返回ACK即可执行提交。

Zookeeper的两种模式

消息广播
崩溃回复

消息广播

ZAB 协议的消息广播过程使用的是一个原子广播协议，类似一个 二阶段提交过程。对于客户端发送的写请求，全部由 Leader 接收，Leader 将请求封装成一个事务 Proposal，将其发送给所有 Follwer ，然后，根据所有 Follwer 的反馈，如果超过半数成功响应，则执行 commit 操作（先提交自己，再发送 commit 给所有 Follwer）。

注意细节

Leader 在收到客户端请求之后，会将这个请求封装成一个事务，并给这个事务分配一个全局递增的唯一 ID，称为事务ID（ZXID），ZAB 兮协议需要保证事务的顺序，因此必须将每一个事务按照 ZXID 进行先后排序然后处理。
在 Leader 和 Follwer 之间还有一个消息队列，用来解耦他们之间的耦合，解除同步阻塞。HOW?
zookeeper集群中为保证任何所有进程能够有序的顺序执行，只能是 Leader 服务器接受写请求，即使是 Follower 服务器接受到客户端的请求，也会转发到 Leader 服务器进行处理。
实际上，这是一种简化版本的 2PC，不能解决单点问题。等会我们会讲述 ZAB 如何解决单点问题（即 Leader 崩溃问题）。

崩溃恢复

当leader失去与过半的follower联系，进入崩溃回复模式。ZAB协议定义了两个原则：

ZAB协议确保已经在leader上提交的的事务最终会被服务器所提交。
ZAB协议确保丢弃那些只在leader上提出/复制。但是没被提交的事务。

解决思路：如果有这样的ZAB选举算法：根据zxid，保证选出来的服务器上有当前zxid最大的事务，那么就能保证当前服务器一定有已经成功提交的事务。

数据同步

崩溃恢复之后，在接受客户端新的请求之气那，leader服务器需要确认事务是否都被过半的follwer提交，即是否完成数据同步。当确认所有的有效follower提交数据后将这些服务器添加到可用服务器列表中。如何做：

通过zxid（服务器处理或是丢弃事务）在这里插入图片描述

在 ZAB 协议的事务编号 ZXID 设计中，ZXID 是一个 64 位的数字，其中低 32 位可以看作是一个简单的递增的计数器，针对客户端的每一个事务请求，Leader 都会产生一个新的事务 Proposal 并对该计数器进行 + 1 操作。

高 32 位代表了每代 Leader 的唯一性，低 32 代表了每代 Leader 中事务的唯一性。同时，也能让 Follwer 通过高 32 位识别不同的 Leader。简化了数据恢复流程。

基于这样的策略：当 Follower 链接上 Leader 之后，Leader 服务器会根据自己服务器上最后被提交的 ZXID 和 Follower 上的 ZXID 进行比对，比对结果要么回滚，要么和 Leader 同步。

Zookeeper分布式锁

实现方式：

单节点锁
多节点锁

节点种类：

持久节点（Persistent）,客户端断开连接不删除节点。
持久化顺序节点(Persisident_Sequential)znode天生互斥,断开连接后节点存在，zookeeper给该节点名称进行顺序编号。
临时节点(Ephemeral)，客户端断开连接后该节点被删除
临时顺序节点（EPHEMERAL_SEQUENTIAL）客户端与zookeeper断开连接后，该节点被删除，只是Zookeeper给该节点名称进行顺序编号

加锁方式：创建节点，解锁方式：删除节点。

如果使用永久节点，当获取节点的客户端宕机，其他客户端不能获取锁，产生死锁。采用临时节点相当于增加了一个失效时间。

单节点锁实现方式

（1）、当一个客户端成功创建一个节点，另外一个客户端是无法创建同名的节点（达到互斥的效果）

（2）、我们注册该节点的listener时，如果节点删除（数据修改），会通知其他的客户端，这个时候其他的客户端可以重新去创建该节点（可以认为时拿到锁的客户端释放锁，其他的客户端可以抢锁）

（3）、创建的节点应该时临时节点，这样保证我们在已经拿到锁的客户端挂掉了会自动释放锁

单点锁实现方式

伪代码：

if(!have childnode){
	create node(Ephemeral(临时));
	
}else {
zkClient.subscribeChildChanges("pth",new zkListener)
}

多节点锁的实现方式（在锁释放时所有线程不会和单点一样去抢占，只要按顺序访问前一个节点就好）

某个客户端尝试加锁时，先在该业务节点下，创建一个顺序节点。
创建完成后，获取出该业务节点下的所有子节点，并按照按照节点序号排序
判断第一位的节点是否为自己的节点，是的话，代表获取锁，执行业务操作
不是的话，对排在自己前一位的节点进行监听，客户端挂起
当客户端执行业务完毕后，删除自己的节点，并通知监听自己节点的客户端进行业务操作。

分布式锁代码实现（单节点锁和多节点锁）

抽象类：
import org.I0Itec.zkclient.ZkClient;

/**
* @ClassName AbstractLock
* @Description TODO
* @Author YGuang
* @Date 2019/7/29 17:10
* @Version 1.0
**/


public abstract class AbstractLock {
   public static final String ZK_ADDR = "localhost:2181,localhost:2182,localhost:2183";
   public static final int SESSION_TIMEOUT = 10000;
   //创建ZK
   protected ZkClient zkClient=new ZkClient(ZK_ADDR,SESSION_TIMEOUT);
   public void getlock(){
       String threadName=Thread.currentThread().getName();
       if(tryLock()){
           System.out.println("获取当前" + threadName+ "锁成功");
       }
       else {
           System.out.println("获取锁失败" +
                   threadName+"---");
           waitLock();
           //递归重新获取锁
           getlock();
       }
   }
   public abstract boolean  tryLock();
   public abstract void releaseLock();
   public abstract void waitLock();

}

抽象类实现：
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

import java.util.concurrent.CountDownLatch;

/**
* @ClassName SimpleZklock
* @Description TODO
* @Author YGuang
* @Date 2019/7/29 17:09
* @Version 1.0
**/


public class SimpleZklock extends AbstractLock {
   private static final String NODE_NAME = "/yg";
   //计数器 初始化数是线程个数
   private CountDownLatch countDownLatch;

   @Override
   //创建临时节点如果创建成功，获取锁，创建不成功处理异常
   public boolean tryLock() {
       if (zkClient == null) {
           return false;
       }
       try {
           zkClient.createEphemeral(NODE_NAME);
           return true;
       } catch (Exception e) {
           System.out.println(e + "cant get Lock" + "wait---------------");
           return false;
       }
   }

   @Override
   //释放锁
   public void releaseLock() {
       if (zkClient != null) {
           zkClient.delete(NODE_NAME);
           zkClient.close();
           System.out.println("releaseLock success----------");
       }

   }

   @Override
   //等待锁的过程
   public void waitLock() {
       //创建监听器
       IZkDataListener iZkDataListener = new IZkDataListener() {
           @Override
           public void handleDataChange(String datapath, Object data) throws Exception {
           }

           @Override
           //节点删除被回调
           public void handleDataDeleted(String datapath) throws Exception {
               if (countDownLatch != null) {
                   //给count数减1（默认一个线程已访问？）
                   countDownLatch.countDown();
               }
           }

       };
       zkClient.subscribeDataChanges(NODE_NAME, iZkDataListener);
       if (zkClient.exists(NODE_NAME)) {
           //如果存在阻塞 设置计时器为1
           countDownLatch = new CountDownLatch(1);
           try {
               //阻塞在当前线程直到所被释放 可能会出现死锁？
               countDownLatch.await();
               System.out.println("wait lock"+"-------------");
           } catch (InterruptedException e) {
               e.printStackTrace();

           }
       }
       zkClient.unsubscribeDataChanges(NODE_NAME,iZkDataListener);

   }
}
测试：
/**
* @ClassName LockTest
* @Description TODO
* @Author YGuang
* @Date 2019/7/30 10:08
* @Version 1.0
**/


public class LockTest {
   public static void main(String[] args) {
       for (int i=1;i<10;i++){
            new Thread(()->{
               AbstractLock zkLock=new SimpleZklock();
               zkLock.getlock();
               try {
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               zkLock.releaseLock();
           }).start();
       }

   }
}


多节点代码：
import org.I0Itec.zkclient.IZkDataListener;

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

/**
* @ClassName HighPerformanceLock
* @Description TODO
* @Author YGuang
* @Date 2019/7/30 11:17
* @Version 1.0
**/


public class HighPerformanceLock extends AbstractLock {
   public static final String PATH="/highyg";
   //当前节点路径
   private String currentPath;
   //前一个节点路径
   private String beforePath;
   private CountDownLatch countDownLatch;
   public HighPerformanceLock(){
       //如果不存在父节点，创建持久节点
       if(!zkClient.exists(PATH)){
           zkClient.createPersistent(PATH);
       }
   }
   @Override
   public boolean tryLock() {
       if (null == currentPath || "".equals(currentPath)) {
           //在path下创建临时顺序节点将他赋予curretpath 临时节点没必要使用名字 因为临时节点会在一个线程结束后被释放 多个线程访问时会生成多个对应临时节点。
           currentPath = zkClient.createEphemeralSequential(PATH + "/", "is a lock");
       }
           List <String> children = zkClient.getChildren(PATH);
           Collections.sort(children);
           if (currentPath.equals(PATH + "/" + children.get(0))) {
               //如果是第一个即可
               return true;
           } else {//不是第一个值则获取他前面的节点名称，赋值给beforepath
               int pathlength = PATH.length();
               String midd=currentPath.substring(pathlength+1);
               int index = Collections.binarySearch(children, currentPath.substring(pathlength + 1));
               beforePath = PATH + "/" + children.get(index - 1);
           }

       return false;
   }
   @Override
   public void releaseLock() {
       if (null!=zkClient){
           //释放节点 删除现在持有节点
           zkClient.delete(currentPath);
           System.out.println("release current Lock------------");
           zkClient.close();
       }
   }

   @Override
   public void waitLock() {
       IZkDataListener iZkDataListener=new IZkDataListener() {
           @Override
           public void handleDataChange(String s, Object o) throws Exception {

           }

           @Override
           public void handleDataDeleted(String datapath) throws Exception {
               if(null!=countDownLatch){
                   countDownLatch.countDown();
               }
           }
       };
       zkClient.subscribeDataChanges(beforePath,iZkDataListener);
       if (zkClient.exists(beforePath)){
           countDownLatch=new CountDownLatch(1);
           try {
               countDownLatch.await();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("wai lock ---------");
           zkClient.unsubscribeDataChanges(beforePath,iZkDataListener);
       }


   }
}

动次打次大铁锤

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Zookeeper小结

Zookeeperzookeeper解决的问题zookeeper分布锁zookeeper监控集群CAP理论：高可用、容错性、一致性最多取其二BASE理论：B基本可用、弱状态、最终一致性zookeeper功能：Dubbo服务治理框架发布订阅：redis mq负载均衡：nginx apche httpd命名服务：分布式协调通知集群管理：...
复制链接

扫一扫