实现分布式锁的几种方式:
基于数据库实现分布式锁;
基于缓存(Redis等)实现分布式锁;
基于Zookeeper实现分布式锁
今天要写的是使用Zookeeper的方式
使用Zookeeper实现分布式锁的思想是:我在加锁的时候,插入一个节点,当把锁释放的时候,就把节点删除。为了提高效率,使用的是临时顺序节点,每次只监听比自己临近小的节点是否删除
准备:安装zookeepr,pom加依赖
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.12</version>
</dependency>
<dependency>
<groupId>com.101tec</groupId>
<artifactId>zkclient</artifactId>
<version>0.10</version>
</dependency>
代码是看网易云课堂公开课学来的,然后有些变化,解决了一个bug,还可重入性
新lock代码
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.exception.ZkMarshallingError;
import org.I0Itec.zkclient.exception.ZkNodeExistsException;
import org.I0Itec.zkclient.serialize.ZkSerializer;
import java.io.UnsupportedEncodingException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class MyZookeeperLock implements Lock {
private String lockPath;
private ZkClient zkClient;
//保存当前节点
public static Map<Thread, String> threadMap = new ConcurrentHashMap<>();
//记录要监听的节点
public static Map<Thread, String> beforeThreadMap = new ConcurrentHashMap<>();
//锁的层数
public static Map<Thread, Integer> deepNumMap = new ConcurrentHashMap<>();
public MyZookeeperLock(String lockPath) {
super();
this.lockPath = lockPath;
zkClient = new ZkClient("127.0.0.1:2181");
zkClient.setZkSerializer(new ZkSerializer() {
@Override
public Object deserialize(byte[] bytes) throws ZkMarshallingError {
try {
return new String(bytes, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
throw new ZkMarshallingError(e);
}
}
@Override
public byte[] serialize(Object obj) throws ZkMarshallingError {
try {
return String.valueOf(obj).getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
throw new ZkMarshallingError(e);
}
}
});
if (!this.zkClient.exists(lockPath)) {
try {
//创建父节点
this.zkClient.createPersistent(lockPath);
} catch (ZkNodeExistsException e) {
}
}
}
@Override
public void lock() {
//不知道是第几次进,保存层数
Integer deep = deepNumMap.get(Thread.currentThread());
if (deep == null) {
deepNumMap.put(Thread.currentThread(), 1);
} else {
deepNumMap.put(Thread.currentThread(), deep + 1);
}
while (!tryLock()) {
//没拿到锁的时候,就去等待
waitForLock();
}
}
private void waitForLock() {
CountDownLatch countDownLatch = new CountDownLatch(1);
//监听
IZkDataListener listener = new IZkDataListener() {
@Override
public void handleDataChange(String s, Object o) throws Exception {
}
@Override
public void handleDataDeleted(String s) throws Exception {
//监听的节点被删除时,执行
//System.out.println("----监听节点被删除");
countDownLatch.countDown();
}
};
//找到我要监听的节点
String beforePath = beforeThreadMap.get(Thread.currentThread());
//开始监听
zkClient.subscribeDataChanges(beforePath, listener);
if (this.zkClient.exists(beforePath)) {
try {
//走到这,说明被执行了
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//结束监听
zkClient.unsubscribeDataChanges(beforePath, listener);
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
String currentPath = threadMap.get(Thread.currentThread());
if (currentPath == null) {
//新增一个顺序节点
currentPath = this.zkClient.createEphemeralSequential(lockPath + "/", "zk");
threadMap.put(Thread.currentThread(), currentPath);
}
//找到所有的节点
List<String> chilren = this.zkClient.getChildren(lockPath);
Collections.sort(chilren);
//判断自己是不是排在最前面
if (currentPath.equals(lockPath + "/" + chilren.get(0))) {
//排在最前面,我拿到锁了
return true;
} else {
//没有排在最前面,找到我要等谁
int curIndex = chilren.indexOf(currentPath.substring(lockPath.length() + 1));
String beforePath = lockPath + "/" + chilren.get(curIndex - 1);
beforeThreadMap.put(Thread.currentThread(), beforePath);
}
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
//判断层级
Integer deep = deepNumMap.get(Thread.currentThread());
if (deep == null) {
System.out.println("出问题了");
return;
}
deep--;
if (deep == 0) {
deepNumMap.remove(Thread.currentThread());
} else {
deepNumMap.put(Thread.currentThread(), deep);
//说明没有彻底出去
return;
}
//说明锁彻底结束了
String currentPath = threadMap.get(Thread.currentThread());
if (currentPath == null) {
System.out.println("出问题");
}
//移除这些没必要的
threadMap.remove(Thread.currentThread());
beforeThreadMap.remove(Thread.currentThread());
//删除节点
this.zkClient.delete(currentPath);
}
@Override
public Condition newCondition() {
return null;
}
}
service代码
public interface OrderService {
String getCode();
}
import java.util.concurrent.locks.Lock;
public class OrderServiceZKImpl implements OrderService {
//Lock lock = new ReentrantLock();
Lock lock = new MyZookeeperLock("/order");
static CodeUtil codeUtil = new CodeUtil();
@Override
public String getCode() {
//System.out.println("进入service" + Thread.currentThread());
//两次是测试是否可重入
try {
lock.lock();
try {
lock.lock();
} finally {
lock.unlock();
}
return codeUtil.getCode("2020-0220-");
} finally {
lock.unlock();
}
}
}
CodeUtil的代码
public class CodeUtil {
public int code = 0;
public String getCode(String s) {
return s + toSix(code++);
}
private String toSix(Integer code) {
String result = code.toString();
while (result.length() < 6) {
result = "0" + result;
}
return result;
}
}
测试类
public class Test {
public static void main(String[] args) {
deleteAll();
int num = 10;
int kk = 5;
CyclicBarrier CyclicBarrier = new CyclicBarrier(num * kk);
for (int i = 0; i < num; i++) {
OrderService OrderService = new OrderServiceZKImpl();
for (int j = 0; j < kk; j++) {
new Thread(() -> {
System.out.println("准备");
try {
CyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(OrderService.getCode());
}).start();
}
}
}
}
CodeUtil的方法,为了保证所有的code不重复,暂时想到几个办法,1、只启动一个服务,2、利用雪花算法,code里包含每个服务特有的编号
ps:1、在测试的时候,被一个问题困扰了,很久,莫名其妙不能删除节点了,发现是服务根本没有被删除,在idea里结束的进行,在后头继续执行,把任务管理器里的删除了,才彻底删除
2、我这代码只是我自己的实现,肯定是有很多问题的
3、要用ConcurrentHashMap而不是HashMap
4、使用ThreadLocal代替ConcurrentHashMap,参考:ThreadLocal的实际运用