本文介绍: 统一命名服务：nginx也可以实现统一配置管理：统一集群管理：服务器动态上下线：软负载均衡：遇到问题：1防火墙未关闭，2配置错误sudo systemctl stop firewalld加到zok.conf中：3.2 选举机制1. 第一次启动3.4 客户端命令行操作3.2.1 命令行语法临时节点：退出客户端以后删除有序节点：可重复，key后自带序号3.2.4 监听器原理分为两种情况：1、请求发送给Leader节点；2、请求发送给Follower节点；
一、入门
1. 概述
2. 特点
3. 数据结构
4. 应用场景
统一命名服务：nginx也可以实现
统一配置管理：
统一集群管理：
服务器动态上下线：
软负载均衡：
二、本地
1.安装
2. 参数解读
三、集群操作
3.1.1 集群安装
遇到问题：1防火墙未关闭，2配置错误
sudo systemctl stop firewalld
加到zok.conf中：
############cluster#################
server.2=192.168.88.130:2888:3888
server.3=192.168.88.131:2888:3888
server.4=192.168.88.132:2888:3888
3.2 选举机制
1. 第一次启动
2. 非第一次启动
3.3 ZK集群启动停止脚本
#!/bin/bash
case $1 in
"start"){
for i in 192.168.88.130 192.168.88.131 192.168.88.132
do
echo -------- zookeeper $i 启动 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh start"
done
}
;;
"stop"){
for i in 192.168.88.130 192.168.88.131 192.168.88.132
do
echo -------- zookeeper $i 停止 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh stop"
done
}
;;
"status"){
for i in 192.168.88.130 192.168.88.131 192.168.88.132
do
echo -------- zookeeper $i 状态 ------------
ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh status"
done
}
;;
esac
3.4 客户端命令行操作
3.2.1 命令行语法
3.2.2 节点类型（持久/短暂/有序号/无序号）
临时节点：退出客户端以后删除
有序节点：可重复，key后自带序号
create /sanguo/shuguo/zhangfei #创建永久无序节点
create -s /sanguo/shuguo/guanyu #创建永久有序节点
create -s -e /sanguo/wuguo/zhouyu1 #创建临时有序节点
create -e /sanguo/wuguo/zhouyu2 #创建临时无序节点
3.2.4 监听器原理
3.3 删除节点
3.5 客户端API操作
3.6 监听节点变化
3.7 判断Znode是否存在
3.8 写数据原理
- Client发送write请求给Leader，Leader收到消息先写
- Leader将write请求转发给下一个Follower节点，Follow收到写入 完成后回一个ack给上一个节点（Leader）
- 大于半数的Leader节点完成写入（共3，完成2），Leader返回给Clinet一个ack表示完成
- Leader继续给其他Follower发送write请求，Follower接收到请求写入，完成后返回ack
2、请求发送给Follower节点；
- Client发送write请求给Follower，Follower收到消息先转发给Leader
- Leader接收到write请求，先执行，然后转发给Follower
- Follower接收到write请求。执行，然后回复一个ack
- 大于半数节点已write，Leader返回一个ack给最先接触到Client的节点（Follower），Follower再返回一个ack给Client
- Leader给剩下的Follower发送write请求，Follower写完回复ack给Leader
四、服务器动态上下线监听案例
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.sql.Array;
import java.util.ArrayList;
import java.util.List;
/**
* 2023年11月24日
* <p>
* case1 服务器动态上下限
* <p>
* 1、获取zk连接
* 2、监听节点
* 3、业务代码（睡觉
*/
public class DistributeClient {
ZooKeeper zooKeeper;
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
DistributeClient zk = new DistributeClient();
zk.connect();
zk.watcherList();
zk.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void watcherList() throws InterruptedException, KeeperException {
List<String> children = zooKeeper.getChildren("/servers", true, null);
ArrayList<String> strings = new ArrayList<String>();
for (String child : children) {
byte[] data = zooKeeper.getData("/servers/" + child, false, null);
strings.add(new String(data));
}
System.out.println(strings);
}
private void connect() throws IOException {
String connectString = "192.168.88.130:2181,192.168.88.131:2181,192.168.88.132:2181";
int sessionTimeout = 300000;
zooKeeper = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
try {
watcherList();
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
}
}
});
}
}
package com.atguigu.case1;
import org.apache.zookeeper.*;
import java.io.IOException;
/**
* case 1
* 服务器动态上下线例子
* <p>
* 1. 创建zk连接
* 2. 注册服务器到zk集群
* 3. 业务代码（睡觉
*/
public class DistributeServer {
ZooKeeper zooKeeper;
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
DistributeServer zk = new DistributeServer();
zk.connect();
zk.register(args[0]);
zk.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void register(String hostName) throws InterruptedException, KeeperException {
zooKeeper.create("/servers/"+hostName, hostName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(hostName + "已注册上");
}
private void connect() throws IOException {
String connectString = "192.168.88.130:2181,192.168.88.131:2181,192.168.88.132:2181";
int sessionTimeout = 3000000;
zooKeeper = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
}
});
}
}
五、ZooKeeper分布式锁案例
package com.atguigu.case2;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* 分布式锁
*/
public class DistributedLock {
public ZooKeeper zooKeeper;
public CountDownLatch connectLatch = new CountDownLatch(1);
public CountDownLatch waitLatch = new CountDownLatch(1);
private String waitPath;
private String currentNode;
DistributedLock() throws IOException, InterruptedException, KeeperException {
//连接zk
String connectString = "192.168.88.130:2181,192.168.88.131:2181,192.168.88.132:2181";
int sessionTimeout = 3000;
zooKeeper = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
//连接完成后释放connectLatch
if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
connectLatch.countDown();
}
//当前锁节点为最小锁时，释放waitLatch
if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)) {
waitLatch.countDown();
}
}
});
//连接完成后继续执行
connectLatch.await();
}
public void lock() throws InterruptedException, KeeperException {
// 检测locks节点是否存在，不存在就建一个
Stat exists = zooKeeper.exists("/locks", false);
if (exists == null){
zooKeeper.create("/locks",null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
//创建锁节点
currentNode = zooKeeper.create("/locks/res-",null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
// 判断是否是头一个，是的话给锁
List<String> locks = zooKeeper.getChildren("/locks", false);
Collections.sort(locks);
//若数组内无值，说明就是第一位可以直接给锁
if (locks.size() == 0){
}else {
//算出创建锁的位置，判断是否是最小的，是的话就给锁，否则对上一个锁进行监听
int location = locks.indexOf(currentNode.substring("/locks/".length()));
if (location == 0){
//最小给锁
}else if (location == -1){
//错误
System.out.println("错误");
}else {
waitPath = locks.get(location - 1);
zooKeeper.getData(waitPath,true,null);
//等待监听
waitLatch.await();
}
}
}
public void unlock() throws InterruptedException, KeeperException {
zooKeeper.delete(currentNode,-1);
}
}
package com.atguigu.case2;
import org.apache.zookeeper.KeeperException;
import java.io.IOException;
public class Client {
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
new Thread(new Runnable() {
public void run() {
try {
DistributedLock distributedLock = new DistributedLock();
distributedLock.lock();
System.out.println("线程1启动，获取锁");
Thread.sleep(5 * 1000);
distributedLock.unlock();
System.out.println("线程1释放锁");
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}).start();
new Thread(new Runnable() {
public void run() {
try {
DistributedLock distributedLock = new DistributedLock();
distributedLock.lock();
System.out.println("线程2启动，获取锁");
Thread.sleep(5 * 1000);
distributedLock.unlock();
System.out.println("线程2释放锁");
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}).start();
}
}
5.1、分布式锁-成熟框架curator
六、企业面试真题
EPOCH：leader任期
原文地址:https://blog.csdn.net/u011005040/article/details/132774202
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.7code.cn/show_19571.html
如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！
声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
