Zookeeper从入门到入土
一、Zookeeper入门
1. 概述
Zookeeper是一个开源的分布式的，为分布式框架提供协调服务的Apache项目。
2. Zookeeper工作机制
Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。
3. Zookeeper特点
- Zookeeper：一个领导者（leader），多个跟随者（Follower）组成的集群。
- 集群中只要半数以上（不包含半数）节点存活，Zookeeper集群就能正常服务。所以Zookeeper适合安装奇数台服务器。
- 全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。
- 更新请求顺序执行，来自同一个Client的更新请求按其发送顺序依次执行。
- 数据更新原子性，一次数据更新要么成功，要么失败。
- 实时性：在一定时间范围内，Client能读到最新数据。
4. 数据结构
Zookeeper数据模型的结构与Unix文件系统很类似，整体上可以看作是一个书，每个节点称做一个ZNode。每一个Znode默认能够存储1MB的数据，每个ZNode都可以通过其路径唯一标识。
5.应用场景
-
统一命名服务：在分布式环境下，经常需要对应用/服务进行统一命名，便于识别。例如：IP不容易记住，而域名容易记住。
-
统一配置管理：分布式环境下，配置文件同步非常常见。一般要求一个集群中，所有节点的配置信息是一致的，比如Kafka集群。对配置文件修改后，希望能够快速同步到各个节点上。配置管理可交由Zookeeper实现：可将配置信息写入Zookeeper上的一个ZNode，各个客户端服务器监听这个ZNode，一旦ZNode中的数据被修改，Zookeeper将通知各个客户端服务器。
-
统一集群管理：分布式环境中，实时掌握每个节点的状态是必要的，可根据节点实时状态做出一些调整。Zookeeper可以实现实时监控节点状态变化，可将节点信息写入Zookeeper上的一个ZNode，监听这个ZNode可获取它的实时状态变化。
-
服务器节点动态上下线：客户端能实时洞察到服务器上下线的变化。
-
软负载均衡：在Zookeeper中记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户端请求。
二、Zookeeper本地安装与配置
1. 下载地址
2. Linux下的zookeeper安装
- 将下载好的zookeeper压缩包上传至linux中，这里是放入了我们新建的software文件夹下，然后进行解压
解压命令：tar -zxvf + 压缩包
- 修改解压后的包名
mv apache-zookeeper-3.5.7-bin zookeeper-3.5.7
- 修改conf目录下的zoo_sample.cfg文件名
mv zoo_sample.cfg zoo.cfg
- 修改zoo.cfg中的dataDir配置
datair=/software/zookeeper-3.5.7/zkData
3. zookeeper的启动和关闭
1. 服务端的启动和关闭
在bin目录下有个文件叫做zkServer.sh。我们在bin目录外然后通过命令：bin/zkServer.sh start 来启动。 然后可以动过命令 jps -l 来查看启动情况。如何关闭服务呢？可以通过命令：/bin/zkServer.sh stop 来关闭服务。
2. 客户端的启动和关闭
在bin目录下有个文件叫做zkCli.sh。我们在bin目录外然后通过命令：bin/zkCli.sh就可直接启动。然后就进去了客户端。然后可以通过命令：quit来推出客户端。
3. 查看zookeeper的状态
可以通过命令：bin/zkServer.sh status 来查看zookeeper的状态。
3. zookeeper中的配置文件zoo.cfg 的参数配置解析
- tickTime = 2000:通信心跳时间，Zookeeper服务器与客户端心跳时间，单位为毫秒。
- initLimit = 10： 表示是个心跳，在初始化是，经过二十个心跳（这里就是2000*10 = 20秒）还没有建立相关的链接，认为这次的通信失败。
- syncLimit = 5 ：表示通信的过程中，如果时间超过五个心跳，还没有重新建立连接，就认为该通信异常，会从服务器列表中删除。
- dataDir：保存的zookeeper中的数据。注意：默认是tmp目录，容易被linux系统定期删除，所以一般不用默认的tmp目录。
- clientProt = 2181：客户端连接端口，通常不做修改。
三、Zookeeper集群操作
1. 集群安装
- 在三台服务器，Linux01,Linux02,Linux03 上都部署Zookeeper。
- 在各个服务器解压Zookeeper安装包到/opt/mudule目录下。（放在哪个目录看个人），然后修改apache-zookeeper-3.5.7-bin 名称为zookeeper-3.5.7
- 配置服务器编号：在/opt/module/zookeeper-3.5.7/这个目录下创建zkData，然后再zkData目录里创建myid文件，在文件中添加与server对应的编号（不如服务器Linux01,，则编号为1，另外俩个就是2和3。同时也要注意上下不能空行，左右不能空格，而且最好在linux中创建该文件，防止用其他软甲出现乱码情况）
- 配置zoo.cfg文件：在/opt/module/zookeeper-3.5.7/conf这个目录下zoo_sample.cfg该名为zoo.cfg。然后打开改文件，修改数据存储路径 -> dataDir = /opt/mudule/zookeeper-3.5.7/zkData，而后增加配置信息：server.1=192.168.187.127:2888:3888
server.2=192.168.187.128:2888:3888
server.3=192.168.187.129:2888:3888
配置参数解读参数解读 server.A = B:C:D
A：A是一个数字，表示是第几号服务器。集群模式下配置一个文件myid，这个文件在dataDir目录下，这个文件里面有一个数据就是A的值。Zookeeper启动时读取此文件，拿到里面的数据与zoo.cfg里的配置信息比较从而判断到底是哪个server。
B：这个是服务器的地址
C：是这个服务器Follower与集群中的Leader服务器交换信息的端口。
D：集群中的Leader服务器挂了，需要一个端口号来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。
2. Zookeeper的选举机制
1. 第一次启动
假设一共有五台服务器。
- 服务器01启动，发起一次选举。服务器01投自己一票。此时服务器01票数为一票，不够半数以上（3票），选举无法完成。服务器01状态保持为LOOKING.
- 服务器02启动，在发起一次选举。服务器01和02分别投自己一票并交换选票信息。此时服务器01发现服务器02的myid比自己目前投票选举的（服务器01）大，更改选票为推举服务器02.此时服务器01票数0票，服务器02票数2票。没有半数以上结果，选举无法完成，服务器01,02状态保持为LOOKING。
- 服务器03动，发起一次选举，此时服务器01,02都会更改选票为服务器03.此次投票结果：服务器01位0票，服务器02为0票，服务器03位3票。此时服务器03的票数已经超过半数，服务器03当选为Leader，服务器01,02更改状态为FOLLOWING，服务器03状态更改为LEADING。
- 服务器4启动，发起一次选举。此时服务器01,02，03已经不是LOOKING状态，不会更改选票信息。交换选票信息结果：服务器03为3票，服务器04位1票。此时服务器4服从多数，更改选票信息为服务器3，并更改状态为FOLLOWING.。
- 服务器05启动，同04一样动FOLLOWING。
2. 非第一次启动（集群正常运行过程中出现服务器挂了）
- 当Zookeeper集群中的一台服务器出现以下俩种情况之一时，就会开始进入Leader选举：
（1）服务器初始化动。
（2）服务器运行期间无法和Leader保持连接。 - 而当一台机器进入Leader选举流程时，当前集群也可能会处于以下俩种状态：
（1）集群中本来就已经存在一个Leader。对于第一种已经存在Leader的情况，机器试 图去选举Leader时，会被告知当前服务器的Leader信息，对于该机器来说，仅仅需要和Leader机器建立连接，并进行状态同步即可。
（2）集群中确实不存在Leader，假设Zookeeper由5台服务器组成，SID分别为1,2，3,4，5，ZXID分别为8,8，8,7,7，并且此时SID为3的服务器是Leader。某一时刻，3和5服务器出现故障，因此开始进行Leader选举。SID为1,2，4的机器投票情况：1（EPOCH:1 ZXID:8 SID:1），2（EPOCH:1 ZXID:8 SID:2），4（EPOCH:1 ZXID:7 SID:4），而选举Leader的规则是：！EPOCH大的直接胜出 -> EPOCH相同，事务id大的胜出 -> 事务id相同，服务器id大的胜出
SID：服务器ID，用来唯一标识一台Zookeeper集群中的机器，每台机器不能重复，和myid一致。
ZXID：事务ID。ZXID是一个事务ID，用来标识一次服务器状态的变更。在某一时刻，集群中的每台机器的ZXID值都不一定完全一致，这和Zookeeper服务器对于客户端“更新请求*的处理逻辑有关
Epoch：每个Leader任期的代号。没有Leader是同一轮投票过程中的逻辑时钟值是相同的。没投完一次票这个数据就会增加。
3. Zookeeper集群启动停止脚本脚本
如果服务器太多，需要一台一台的启动和关闭会比较麻烦，建立一个后缀名为sh的文件
#!/bin/bash
case $1 in
"start"){
for i in hadoop102 hadoop103 hadoop104
do
echo ---------- zookeeper $i 启动 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh
start"
done
};;
"stop"){
for i in hadoop102 hadoop103 hadoop104
do
echo ---------- zookeeper $i 停止 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh
stop"
done
};;
"status"){
for i in hadoop102 hadoop103 hadoop104
do
echo ---------- zookeeper $i 状态 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh
status"
done
};;
esac
4. Zookeeper客户端命令
| 命令 | 功能 |
|---|---|
| help | 显示所有操作命令 |
| ls path | 使用 ls 命令来查看当前 znode 的子节点 [可监听] ，-w 监听子节点变化，-s 附加次级信息 |
| create | 普通创建 |
| -s | 含有序列 |
| -e | 临时（重启或者超时消失） |
| get path | 获得节点的值 [可监听] ，-w 监听节点内容变化 |
| -s | 附加次级信息 |
| set | 设置节点的具体值 |
| stat | 查看节点状态 |
| stat | 查看节点状态 |
| delete | 删除节点 |
| deleteall | 递归删除节点 |
| ls / | 查看当前znode包含的信息 |
| ls -s / | 查看当前数据节点详细信息 |
| get -s /xx | 获取xx节点下的值 |
| create | 创建不带序号的节点 |
| create -s | 创建带序号的节点 |
| quit | 退出客户端 |
| delete | 删除节点（只有一个节点可以同这个删除命令） |
| deleteall | 删除节点（很多个节点可以用这个删除命令） |
节点详细信息参数解析：
| czxid | 创建节点的事务 zxid，每次修改 ZooKeeper 状态都会产生一个 ZooKeeper 事务 ID。事务 ID 是 ZooKeeper 中所有修改总的次序。每次修改都有唯一的 zxid，如果 zxid1 小于 zxid2，那么 zxid1 在 zxid2 之前发生。 |
|---|---|
| ctime | znode 被创建的毫秒数（从 1970 年开始） |
| mzxid | znode 最后更新的事务 zxid |
| mtime | znode 最后修改的毫秒数（从 1970 年开始） |
| pZxid | znode 最后更新的子节点 zxid |
| cversion | znode 子节点变化号，znode 子节点修改次数 |
| dataversion | znode 数据变化号 |
| aclVersion | znode 访问控制列表的变化号 |
| ephemeralOwner | 如果是临时节点，这个是 znode 拥有者的 session id。如果不是临时节点则是 0 |
| dataLength | znode 的数据长度 |
| numChildren | znode 子节点数量 |
4. Zookeeper节点类型
注：创建带序号的几点后面会自增：
注：通过create ，create -s 创建的节点不是临时节点，quit退出客户端 后节点还会保存。
可通过增加 -e 创建临时节点。临时节点不带序号-e
临时节点带序号-e -s
如果退出客户端，这些短暂节点将会被清除
如果修改节点的值，通过set key value即可
5. Zookeeper监听器
1. 监听器原理
监听器是注册一次监听一次，主要监听节点值的变化还有路径的变化，在一个服务器中通过修改其值或者路径，在另一个服务器中进行监听，通过在zookeeper客户端内命令get
-w + 节点值 来进行监听节点值的变化，如果是路径的变化，在另一个服务器中进行ls -w +路径进行监听。
2. 客户端代码操作
- 创建Maven工程
- 在pom文件中添加如下依赖：
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>RELEASE</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.5.7</version>
</dependency>
</dependencies>
- resource资源配置文件中配置如下文件：
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c]
1. %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c]
2. %m%n
- 客户端代码的生成：
（1）、监听节点
/**
* connectString 注意: 逗号左右不能空格
*
* sessionTimeout 设置超时时间
*/
private String connectString = "192.168.187.129:2181,192.168.187.128:2181";
private int sessionTimeout = 60000;
private ZooKeeper zkClient;
@Before
public void init() throws IOException {
zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent watchedEvent) {
});
}
}
注：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss for /XXX 初始化出现该错误是，可能是因为：
1）查看是不是关闭了Linux的防火墙
2）代码中的请求时间，要大于zookeeper里面配置的延迟时间
3）以上还是不同，请在配置一下电脑的host，把ip换成域名来创建访问
（2）、创建新的节点
public class ZkClient {
/**
* connectString 注意: 逗号左右不能空格
* <p>
* sessionTimeout 设置超时时间
*/
private String connectString = "192.168.187.129:2181,192.168.187.128:2181";
private int sessionTimeout = 60000;
private ZooKeeper zkClient;
@Test
@Before
public void init() throws IOException {
zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
}
});
}
@Test
public void create() throws KeeperException, InterruptedException {
/**
*
* 第一个参数是路径
* 第二个参数是数据，要求是字节类型，需要用getBytes()
* 第三个参数是权限，Ids.OPEN_ACL_UNSAFE允许所有人进行访问
* 第四个参数是创建节点的类型
*/
String nodeCreated = zkClient.create("/atguigu", "ss.avi".getBytes(),
ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
}
（3）、获取子节点并监听其变化
@Test
public void getChildren() throws KeeperException, InterruptedException {
/**
* 第一个参数：监听路径 （/:表示根目录下所有节点的集合）
* 第二个参数：true 表示使用我们自定义的监听器，即初始化方法中init（）方法中的new Watch（）监听器
* 注：getChildren 注册一次只能监听一次
*/
List<String> children = zkClient.getChildren("/", true);
for (String child : children) {
System.out.println("getChildren----------");
System.out.println(child);
System.out.println("getChildren----------");
}
}
（4）、判断节点是否存在
@Test
public void exit() throws KeeperException, InterruptedException {
Stat exists = zkClient.exists("/atguigu", false);
System.out.println(exists == null? "not exist" :"exist");
}
3. 写数据原理
- 客户端发送数据给Leader时：客户端给服务器的leader发送写请求，写完数据后给手下发送写请求，手下写完发送给leader，超过半票以上都写了则发回给客户端。之后leader在给其他手下让他们写，写完在发数据给leader
- 发送给follwer时：客户端给手下发送写的请求，手下给leader发送写的请求，写完后，给手下发送写的请求，手下写完后给leader发送确认，超过半票，leader确认后，发给刻划断，之后leader在发送写请求给其他手下
四、服务器动态上下线
1. 原理
服务器上线其实就是服务器启动时取创建注册信息（就是客户端去规定的路径下去创建临时节点，然后监听器监听改路径下节点的变化），上线则节点值增加，下线则节点值减少
2. 服务器代码
- 获取zookeeper集群的连接，通过zookeeper的构造函数ZooKeeper(connectString, sessionTimeout, new Watcher(){})
- 将其服务注册到zookeeper集群中，具体通过create的函数，通过获取每个服务器名字、其值、权限、节点类型
- 执行该函数通过延迟函数
package com.atguigu.case1;
import org.apache.zookeeper.*;
import java.io.IOException;
public class DistributeServer {
private String connectString = "192.168.187.129:2181,192.168.187.128:2181";
private int sessionTimeout = 60000;
private ZooKeeper zkClient;
public static void main(String[] args) throws KeeperException, InterruptedException {
/**
* 1. 获取zookeeper连接
*/
DistributeServer server = new DistributeServer();
server.getConnection();
/**
* 2. 注册服务器到zookeeper集群
*/
server.regist(args[0]);
/**
* 3. 启动业务逻辑
*/
server.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void getConnection(){
try {
zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
private void regist(String hostName) throws KeeperException, InterruptedException {
/**
* CreateMode.EPHEMERAL_SEQUENTIAL 创建临时 + 序列号的节点
*/
String create = zkClient.create("/servers/"+hostName,hostName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(hostName + "is online");
}
}
2. 客户端代码
- 获取zookeeper集群的连接，通过zookeeper的构造函数ZooKeeper(connectString, sessionTimeout, new Watcher(){})
- 客户端通过监听每个节点，具体监听通过getChildren函数，获取其节点位置，以及是否使用初始化的监听函数，true为使用。获取到的都是以列表存在，输出的时候通过遍历实现，输出的还是一些数组格式。将这些数组都封装到一个列表中，最后统一输出列表即可
- 执行该函数通过延迟函数
因为注册的时候记录一次
所以在初始化的时候，将其注册放在初始化内部getServerList();
package com.atguigu.case1;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class DistributeClient {
private String connectString = "192.168.187.129:2181,192.168.187.128:2181";
private int sessionTimeout = 100000;
private ZooKeeper zkClient;
public static void main(String[] args) throws KeeperException, InterruptedException {
/**
* 1. 获取zk连接
*/
DistributeClient client = new DistributeClient();
client.getConnection();
/**
* 2. 监听/server下面子节点的增加和删除
*/
client.getServerList();
/**
* 3. 业务逻辑
*/
client.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void getServerList() throws KeeperException, InterruptedException {
List<String> children = zkClient.getChildren("/servers", true);
ArrayList<String> servers = new ArrayList<String>();
for (String child : children) {
byte[] data = zkClient.getData("/servers" + child, false, null);
servers.add(new String(data));
}
System.out.println(servers);
}
private void getConnection(){
try {
zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
try {
/**
* 防止监听一次后不再监听了
*/
getServerList();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
}
五、分布式锁
1. 原生zookeeper分布式锁
package com.atguigu.case2;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CountDownLatch;
public class DistributedLock {
private String connectString = "192.168.187.129:2181,192.168.187.128:2181";
private int sessionTimeout = 100000;
private ZooKeeper zkClient;
private String waitPath;
private CountDownLatch connectLatch = new CountDownLatch(1);
private CountDownLatch waitLatch = new CountDownLatch(1);
private String currentMode;
public DistributedLock() throws IOException, InterruptedException, KeeperException {
/**
* 获取连接
*/
zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent watchedEvent) {
/**
* connectLath 若果连接上zk，可以释放
*/
if (watchedEvent.getState() == Event.KeeperState.SyncConnected){
connectLatch.countDown();
}
/**
* waitLatch 需要释放
*/
if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)){
waitLatch.countDown();
}
}
});
/**
* 等待zk正常连接后，往下走程序
*/
connectLatch.await();
/**
* 保证根节点/locks存在
*/
Stat stat = zkClient.exists("/locks", false);
if (Objects.isNull(stat)){
zkClient.create("/locks","locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
}
}
/**
* 对zk加锁
*/
public void zkLock(){
/**
*
* 1. 创建对应的临时带序号节点
*
* 2. 判断创建节点是否是最小的序号节点，如果是则获取到锁，如果不是，则监听他序号前一个节点
*
*/
try {
currentMode = zkClient.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
List<String> children = zkClient.getChildren("/locks", false);
/**
* 如果children只有一个节点，那就直接 获取值，如果有多个节点，需要判断，谁最小
*/
if (children.size() == 1){
return;
}else {
Collections.sort(children);
/**
* 获取节点名称 seq-000000
*/
String thisNode = currentMode.substring("/locks".length());
/**
* 通过seq-000000获取该节点在children集合的位置
*/
int index = children.indexOf(thisNode);
if (index == -1){
System.out.println("数据异常");
}else if (index == 0){
/**
* 当前节点就是序号最小的排在最前面的节点，直接返回上锁
*/
return;
}else {
/**
* 需要监听 他前一个节点变化
*/
waitPath = "/locks/" + children.get(index -1);
zkClient.getData(waitPath,true,null);
/**
* 等待监听
*/
waitLatch.await();
return;
}
}
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 对zk解锁
*/
public void unZkLock(){
/**
* 删除节点
*/
try {
zkClient.delete(currentMode,-1);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
}
}
2. 利用curator实现zookeeper分布式锁
原生的zookeeper分布式锁实现有如下问题：
- 会话连接是异步的，需要自己去处理。比如使用CountDownLatch
- Watch 需要重复注册，不然就不能生效
- 开发的复杂性还是比较高的
- 不支持多节点删除和创建。需要自己去递归
curator可以解决上面的问题
添加curator依赖：
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-client</artifactId>
<version>4.3.0</version>
</dependency>
编程实现代码如下：
public class CuratorLockTest {
public static void main(String[] args) {
// 创建分布式锁1
InterProcessMutex lock1 = new InterProcessMutex(getCuratorFramework(), "/locks");
// 创建分布式锁2
InterProcessMutex lock2 = new InterProcessMutex(getCuratorFramework(), "/locks");
new Thread(new Runnable() {
@Override
public void run() {
try {
lock1.acquire();
System.out.println("线程1 获取到锁");
lock1.acquire();
System.out.println("线程1 再次获取到锁");
Thread.sleep(5 * 1000);
lock1.release();
System.out.println("线程1 释放锁");
lock1.release();
System.out.println("线程1 再次释放锁");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
try {
lock2.acquire();
System.out.println("线程2 获取到锁");
lock2.acquire();
System.out.println("线程2 再次获取到锁");
Thread.sleep(5 * 1000);
lock2.release();
System.out.println("线程2 释放锁");
lock2.release();
System.out.println("线程2 再次释放锁");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
private static CuratorFramework getCuratorFramework() {
ExponentialBackoffRetry policy = new ExponentialBackoffRetry(3000, 3);
CuratorFramework client = CuratorFrameworkFactory.builder().connectString("hadoop102:2181,hadoop103:2181,hadoop104:2181")
.connectionTimeoutMs(2000)
.sessionTimeoutMs(2000)
.retryPolicy(policy).build();
// 启动客户端
client.start();
System.out.println("zookeeper 启动成功");
return client;
}
}
六、总结企业面试
企业中常考的面试有选举机制、集群安装以及常用命令
选举机制
半数机制，超过半数的投票通过，即通过。
（1）第一次启动选举规则：
投票过半数时，服务器 id 大的胜出
（2）第二次启动选举规则：
①EPOCH 大的直接胜出
②EPOCH 相同，事务 id 大的胜出
③事务 id 相同，服务器 id 大的胜出
集群安装
安装奇数台
服务器台数多：好处，提高可靠性；坏处：提高通信延时
常用命令
ls、get、create、delete
8782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
