2024年Java最全Day377，2024Java大厂面试集合

最后

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

---

4.4 测试

---

• 在 Linux 命令行上操作增加减少服务器

• 启动 DistributeClient 客户端

• 在 hadoop102 上 zk 的客户端/servers 目录上创建临时带序号节点

create -e -s /servers/hadoop102 “hadoop102”

create -e -s /servers/hadoop103 “hadoop103”

• 观察 Idea 控制台变化

[hadoop102, hadoop103]

• 执行删除操作

delete /servers/hadoop1020000000000

• 观察 Idea 控制台变化

[hadoop103]

• 在 Idea 上操作增加减少服务器

• 启动 DistributeClient 客户端（如果已经启动过，不需要重启）

• 启动 DistributeServer 服务

• ①点击 Edit Configurations…

• ②在弹出的窗口中（Program arguments）输入想启动的主机，例如，hadoop102

• ③ 回 到 DistributeServer 的 main 方 法 ， 右 键 ， 在 弹 出 的 窗 口 中 点 击 Run“DistributeServer.main()”

• ④观察 DistributeServer 控制台，提示 hadoop102 is working

• ⑤观察 DistributeClient 控制台，提示 hadoop102 已经上线

---

ZooKeeper 分布式锁案例

==========================================================================

什么叫做分布式锁呢？

比如说"进程 1"在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。

---

5.1 原生 Zookeeper 实现 分布式锁案例

---

1） 分布式锁实现

package com.achang.lock2;

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.concurrent.CountDownLatch;

public class DistributedLock {

// zookeeper server 列表

private String connectString = “hadoop102:2181,hadoop103:2181,hadoop104:2181”;

// 超时时间

private int sessionTimeout = 2000;

private ZooKeeper zk;

private String rootNode = “locks”;

private String subNode = “seq-”;

// 当前 client 等待的子节点

private String waitPath;

//ZooKeeper 连接

private CountDownLatch connectLatch = new CountDownLatch(1);

//ZooKeeper 节点等待

private CountDownLatch waitLatch = new CountDownLatch(1);

// 当前 client 创建的子节点

private String currentNode;

// 和 zk 服务建立连接，并创建根节点

public DistributedLock() throws IOException,InterruptedException, KeeperException {

zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {

@Override

public void process(WatchedEvent event) {

// 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程

if (event.getState() == Event.KeeperState.SyncConnected) {

connectLatch.countDown();

}

// 发生了 waitPath 的删除事件

if (event.getType() == Event.EventType.NodeDeleted && event.getPath().equals(waitPath)){

waitLatch.countDown();

}

}

});

// 等待连接建立

connectLatch.await();

//获取根节点状态

Stat stat = zk.exists(“/” + rootNode, false);

//如果根节点不存在，则创建根节点，根节点类型为永久节点

if (stat == null) {

System.out.println(“根节点不存在”);

zk.create(“/” + rootNode, new byte[0],ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

}

}

// 加锁方法

public void zkLock() {

try {

//在根节点下创建临时顺序节点，返回值为创建的节点路径

currentNode = zk.create(“/” + rootNode + “/” + subNode,null,ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);

// wait 一小会, 让结果更清晰一些

Thread.sleep(10);

// 注意, 没有必要监听"/locks"的子节点的变化情况

List childrenNodes = zk.getChildren(“/” + rootNode, false);

// 列表中只有一个子节点, 那肯定就是 currentNode , 说明client 获得锁

if (childrenNodes.size() == 1) {

return;

} else {

//对根节点下的所有临时顺序节点进行从小到大排序

Collections.sort(childrenNodes);

//当前节点名称

String thisNode = currentNode.substring((“/” + rootNode + “/”).length());

//获取当前节点的位置

int index = childrenNodes.indexOf(thisNode);

if (index == -1) {

System.out.println(“数据异常”);

} else if (index == 0) {

// index == 0, 说明 thisNode 在列表中最小, 当前client 获得锁

return;

} else {

// 获得排名比 currentNode 前 1 位的节点

this.waitPath = “/” + rootNode + “/” + childrenNodes.get(index - 1);

// 在 waitPath 上注册监听器, 当 waitPath 被删除时,zookeeper 会回调监听器的 process 方法

zk.getData(waitPath, true, new Stat());

//进入等待锁状态

waitLatch.await();

return;

}

}

} catch (KeeperException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 解锁方法

public void zkUnlock() {

try {

zk.delete(this.currentNode, -1);

} catch (InterruptedException | KeeperException e) {

e.printStackTrace();

}

}

}

2）分布式锁 测试

• 创建两个线程

package com.achang.lock2;

import org.apache.zookeeper.KeeperException;

import java.io.IOException;

public class DistributedLockTest {

public static void main(String[] args) throws

InterruptedException, IOException, KeeperException {

// 创建分布式锁 1

final DistributedLock lock1 = new DistributedLock();

// 创建分布式锁 2

final DistributedLock lock2 = new DistributedLock();

new Thread(new Runnable() {

@Override

public void run() {

// 获取锁对象

try {

lock1.zkLock();

System.out.println(“线程 1 获取锁”);

Thread.sleep(5 * 1000);

lock1.zkUnlock();

System.out.println(“线程 1 释放锁”);

} catch (Exception e) {

e.printStackTrace();

}

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

// 获取锁对象

try {

lock2.zkLock();

System.out.println(“线程 2 获取锁”);

Thread.sleep(5 * 1000);

lock2.zkUnlock();

System.out.println(“线程 2 释放锁”);

} catch (Exception e) {

e.printStackTrace();

}

}

}).start();

}

}

• 观察控制台变化

• 线程 1 获取锁

• 线程 1 释放锁

• 线程 2 获取锁

• 线程 2 释放锁

---

5.2Curator 框架实现分布式锁案例

---

1）原生的 Java API 开发存在的问题

• （1）会话连接是异步的，需要自己去处理。比如使用 CountDownLatch

• （2）Watch 需要重复注册，不然就不能生效

• （3）开发的复杂性还是比较高的

• （4）不支持多节点删除和创建。需要自己去递归

---

2）Curator 是一个专门解决分布式锁的框架，解决了原生Java API

详情请查看官方文档：https://curator.apache.org/index.html

---

3 ）Curator 案例实操

• （1）添加依赖

org.apache.curator

curator-framework

4.3.0

org.apache.curator

curator-recipes

4.3.0

org.apache.curator

curator-client

4.3.0

• （2）代码实现

package com.achang.lock;

import org.apache.curator.RetryPolicy;

import org.apache.curator.framework.CuratorFramework;

import org.apache.curator.framework.CuratorFrameworkFactory;

import org.apache.curator.framework.recipes.locks.InterProcessLock;

import org.apache.curator.framework.recipes.locks.InterProcessMutex;

import org.apache.curator.retry.ExponentialBackoffRetry;

public class CuratorLockTest {

private String rootNode = “/locks”;

// zookeeper server 列表

private String connectString = “hadoop102:2181,hadoop103:2181,hadoop104:2181”;

// connection 超时时间

private int connectionTimeout = 2000;

// session 超时时间

private int sessionTimeout = 2000;

public static void main(String[] args) {

new CuratorLockTest().test();

}

// 测试

private void test() {

// 创建分布式锁 1

final InterProcessLock lock1 = new InterProcessMutex(getCuratorFramework(),rootNode);

// 创建分布式锁 2

final InterProcessLock lock2 = new InterProcessMutex(getCuratorFramework(),rootNode);

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() {

// 获取锁对象

最后

Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

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() {

// 获取锁对象

最后

Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。
[外链图片转存中…(img-2DG623fh-1714850662233)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取