zookeeper高级
zookeepper是什么
简答的说，zookeeper是一个分布式协调工具
zookeepper能做什么
1.分布式锁（也可以使用redis、数据库，但是推荐zookeeper）
2.负载均衡
3.命名服务（注册中心（））
4.分布式通知/协调Wtcher事件通知
5.发布订阅 Wtcher事件通知
6.集群环境选举Master redis 哨兵机制
zookeepper实现分布式锁原理
1.zookeeper数据的存储结构
zookeeper存储结构类似于xml的树状结构
2.zookeeper分布式锁实现原理是 zk临时节点+事件通知
临时节点：断开连接即可自动删除临时节点
（1）使用zk创建临时节点
（2）谁能创建成功谁就能拿到锁，其他服务没有创建节点成功，就等待。
其他服务使用事件监听获取节点通知，如果节点已经被删除，就可以获取锁资源
zookeepper实现分布式锁例子
<dependencies>
<dependency>
<groupId>com.101tec</groupId>
<artifactId>zkclient</artifactId>
<version>0.10</version>
</dependency>
</dependencies>
public interface Lock {
//获取到锁的资源
public void getLock();
// 释放锁
public void unLock();
}
//生成订单号规则 使用时间戳+业务id
public class OrderNumGenerator {
// 业务ID
private static int count = 0;
// 生成订单号
public String getNumber() {
try {
Thread.sleep(200);
} catch (Exception e) {
// TODO: handle exception
}
SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
return simpt.format(new Date()) + "-" + ++count;
}
}
//将重复代码写入子类中..
public abstract class ZookeeperAbstractLock implements Lock {
// zk连接地址
private static final String CONNECTSTRING = "127.0.0.1:2181";
// 创建zk连接
protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
protected static final String PATH = "/lock";
public void getLock() {
if (tryLock()) {
System.out.println("##获取lock锁的资源####");
} else {
// 等待
waitLock();
// 重新获取锁资源
getLock();
}
}
// 获取锁资源
abstract boolean tryLock();
// 等待
abstract void waitLock();
public void unLock() {
if (zkClient != null) {
zkClient.close();
System.out.println("释放锁资源...");
}
}
}
public class ZookeeperDistrbuteLock extends ZookeeperAbstractLock {
private CountDownLatch countDownLatch = null;
@Override
boolean tryLock() {
try {
zkClient.createEphemeral(PATH);
return true;
} catch (Exception e) {
// e.printStackTrace();
return false;
}
}
@Override
void waitLock() {
IZkDataListener izkDataListener = new IZkDataListener() {
public void handleDataDeleted(String path) throws Exception {
// 唤醒被等待的线程
if (countDownLatch != null) {
countDownLatch.countDown();
}
}
public void handleDataChange(String path, Object data) throws Exception {
}
};
// 注册事件
zkClient.subscribeDataChanges(PATH, izkDataListener);
if (zkClient.exists(PATH)) {
countDownLatch = new CountDownLatch(1);
try {
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
// 删除监听
zkClient.unsubscribeDataChanges(PATH, izkDataListener);
}
}
public class OrderService implements Runnable {
private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
// 使用lock锁
// private java.util.concurrent.locks.Lock lock = new ReentrantLock();
private Lock lock = new ZookeeperDistrbuteLock();
public void run() {
getNumber();
}
public void getNumber() {
try {
lock.getLock();
String number = orderNumGenerator.getNumber();
System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unLock();
}
}
public static void main(String[] args) {
System.out.println("####生成唯一订单号###");
// OrderService orderService = new OrderService();
for (int i = 0; i < 100; i++) {
new Thread( new OrderService()).start();
}
}
}
zookeeper实现负载均衡
实现思路
使用Zookeeper实现负载均衡原理，服务器端将启动的服务注册到，zk注册中心上，采用临时节点。客户端从zk节点上获取最新服务节点信息，本地使用负载均衡算法，随机分配服务器。
轮询机制采用取模算法实现
zookeeper实现负载均衡 例子
//ServerHandler
public class ServerHandler implements Runnable {
private Socket socket;
public ServerHandler(Socket socket) {
this.socket = socket;
}
public void run() {
BufferedReader in = null;
PrintWriter out = null;
try {
in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
out = new PrintWriter(this.socket.getOutputStream(), true);
String body = null;
while (true) {
body = in.readLine();
if (body == null)
break;
System.out.println("Receive : " + body);
out.println("Hello, " + body);
}
} catch (Exception e) {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (out != null) {
out.close();
}
if (this.socket != null) {
try {
this.socket.close();
} catch (IOException e1) {
e1.printStackTrace();
}
this.socket = null;
}
}
}
}
public class ZkServerClient {
// 获取所有的服务地址
public static List<String> listServer = new ArrayList<String>();
public static void main(String[] args) {
initServer();
ZkServerClient client = new ZkServerClient();
BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String name;
try {
name = console.readLine();
if ("exit".equals(name)) {
System.exit(0);
}
client.send(name);
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 注册所有server
public static void initServer() {
listServer.clear();
// 从zk获取最新获取的注册服务连接
final String memberServerPath = "/member";
final ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
// 获当前下子节点
List<String> children = zkClient.getChildren(memberServerPath);
listServer.clear();
for (String p : children) {
// 读取子节点value值
listServer.add((String) zkClient.readData(memberServerPath + "/" + p));
}
System.out.println("最新服务信息listServer:" + listServer.toString());
// 订阅子节点事件
zkClient.subscribeChildChanges(memberServerPath, new IZkChildListener() {
// 子节点发生变化
public void handleChildChange(String parentPath, List<String> childrens) throws Exception {
listServer.clear();
for (String subP : childrens) {
// 读取子节点value值
listServer.add((String) zkClient.readData(memberServerPath + "/" + subP));
}
}
});
}
// 服务调用次数
private static int count = 1;
// 会员服务集群数量，实际开发中不要写死，
private static int memberServerCount = 2;
// 获取当前server信息
public static String getServer() {
String serverName = listServer.get(count % memberServerCount);
++count;
return serverName;
}
public void send(String name) {
String server = ZkServerClient.getServer();
String[] cfg = server.split(":");
Socket socket = null;
BufferedReader in = null;
PrintWriter out = null;
try {
socket = new Socket(cfg[0], Integer.parseInt(cfg[1]));
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
out.println(name);
while (true) {
String resp = in.readLine();
if (resp == null)
break;
else if (resp.length() > 0) {
System.out.println("Receive : " + resp);
break;
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
out.close();
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//##ServerScoekt服务端
public class ZkServerScoekt implements Runnable {
private int port = 18081;
public static void main(String[] args) throws IOException {
int port = 18081;
ZkServerScoekt server = new ZkServerScoekt(port);
Thread thread = new Thread(server);
thread.start();
}
public ZkServerScoekt(int port) {
this.port = port;
}
// 将服务信息注册到注册中心上去
public void regServer() {
ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
String path = "/member/server-" + port;
if (zkClient.exists(path)) {
zkClient.delete(path);
}
String value="127.0.0.1:" + port;
zkClient.createEphemeral(path, "127.0.0.1:" + port);
System.out.println("##服务注册成功###"+value);
}
public void run() {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(port);
regServer();
System.out.println("Server start port:" + port);
Socket socket = null;
while (true) {
socket = serverSocket.accept();
new Thread(new ServerHandler(socket)).start();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (serverSocket != null) {
serverSocket.close();
}
} catch (Exception e2) {
}
}
}
}
zookeeper实现选举策略
思路
右边三台主机会尝试创建master节点，谁创建成功了，就是master，向外提供。其他两台就是slave。
所有slave必须关注master的删除事件（临时节点，如果服务器宕机了，Zookeeper会自动把master节点删除）。如果master宕机了，会进行新一轮的master选举。
扫一扫
2877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
