一、简介
锁的概念,在Java日常开发和面试中,都是个很重要的知识点。锁能很好的控制生产数据的安全性,比如商品的数量超卖问题等。传统的做法中,可以直接利用数据库锁(行锁或者表锁)来进行数据访问控制。随着请求量逐步变多的情况下,将压力怼到数据库上会对其性能产生极大影响。这时候,单体应用中可以利用JVM锁,在程序层面进行访问的控制,将压力前移,对数据库友好。当请求量再进一步变多,这时候一般会考虑集群分布式去处理,不断的加机器来抗压。这时候,JVM锁就不能很好的控制压力了,同一时刻还是会有大量请求怼到数据库上,这时就需要提升为分布式锁去控制了,将压力继续停留在程序层面。
Java的面向接口编程,可以很好很快的去切换实现而不需要动业务代码部分。下面,基于Lock接口去使用锁。
zookeeper的集群搭建:https://www.cnblogs.com/eric-fang/p/9283904.html
二、JVM锁
基于ReentrantLock实现锁控制,业务控制层service部分代码如下,用 lock 锁去控制并发访问
package com.cfang.service;
import java.sql.Time;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import com.cfang.dao.ProductDao;
import lombok.extern.slf4j.Slf4j;
@Service
@Slf4j
@Scope("prototype")
public class ProductWithLockService {
private Lock lock = new ReentrantLock();
@Autowired
private ProductDao productDao;
@Transactional
public boolean buy(String userName, String productname, int number) {
boolean result = false;
try {
lock.lock();
// TimeUnit.SECONDS.sleep(1);
log.info("用户{}欲购买{}个{}", userName, number, productname);
int stock = productDao.getStock(productname);
log.info("{} 查询数量{}...", userName, stock);
if(stock < number) {
log.warn("库存不足...");
return false;
}
result = productDao.buy(userName, productname, number);
} catch (Exception e) {
} finally {
log.info("{} 释放锁...", userName);
lock.unlock();
}
log.info("{}购买结果,{}",userName, result);
return result;
}
}
在单体应用中,这样子使用是可以的,但是当应用部署多套的时候,那么,就不能很好的保障并发控制了,同一时刻的请求可能会大量打到数据库上。所以,这就引入下面的分布式锁去控制了。
三、基于ZooKeeper的分布式锁
首先,锁获取释放的工具类:
package com.cfang.zkLockUtil;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.exception.ZkNodeExistsException;
import org.apache.commons.lang3.StringUtils;
import com.cfang.zkClient.MyZkSerializer;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ZkLockUtil implements Lock{
private String znode;
private ZkClient zkClient;
public ZkLockUtil(String znode) {
if(StringUtils.isBlank(znode)) {
throw new IllegalArgumentException("锁节点znode不能为空字符串");
}
this.znode = znode;
this.zkClient = new ZkClient("111.231.51.200:2181,111.231.51.200:2182,111.231.51.200:2183");
this.zkClient.setZkSerializer(new MyZkSerializer());
}
@Override
public void lock() {
if(!tryLock()) { //抢锁失败
// 阻塞等待锁节点的释放
waitLock();
//递归调用,重新尝试去抢占锁
lock();
}
}
private void waitLock() {
CountDownLatch latch = new CountDownLatch(1);
// 注册监听znode锁节点变化,当删除的时候,说明锁被释放
IZkDataListener listener = new IZkDataListener() {
@Override
public void handleDataDeleted(String dataPath) throws Exception {
log.info("znode节点被删除,锁释放...");
latch.countDown();
}
@Override
public void handleDataChange(String dataPath, Object data) throws Exception {
}
};
this.zkClient.subscribeDataChanges(this.znode, listener);
try {
// 阻塞等待锁znode节点的删除释放
if(this.zkClient.exists(znode)) {
latch.await();
}
} catch (Exception e) {
}
//取消znode节点监听
this.zkClient.unsubscribeDataChanges(this.znode, listener);
}
@Override
public boolean tryLock() {
boolean result = false;
try {
this.zkClient.createEphemeral(znode); //创建临时节点
result = true;
} catch (ZkNodeExistsException e) {
log.warn("锁节点znode已存在,抢占失败...");
result = false;
} catch (Exception e) {
log.warn("创建锁节点znode异常,{}...", e.getMessage());
}
return result;
}
@Override
public void unlock() {
zkClient.delete(znode);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// TODO Auto-generated method stub
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {
// TODO Auto-generated method stub
}
@Override
public Condition newCondition() {
// TODO Auto-generated method stub
return null;
}
}
业务控制service中,就是将基本的JVM锁的service中,Lock的实现更换即可:
private Lock lock = new ZkLockUtil("/p1node");
当程序运行中,所有的请求会去争抢创建zk节点,谁创建成功,则就获得锁资源,继续执行业务代码。其他所有线程基于递归等待,等待zk节点的删除,然后再去尝试争抢创建。达到控制并发的目的。
但是,这种但是有个不好的地方,也就是,当一个锁释放后,所有的线程都会一下子全去争抢,每次都是轮回这样哄抢的过程,会有一定的压力,也不必如此。所以,下面基于zk永久节点下临时顺序节点做点改善,每个线程节点,只需要关注前面一个节点变化即可,不需要造成哄抢事件。
四、ZooKeeper的分布式锁提高版
锁获取释放的工具类:
package com.cfang.zkLockUtil;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.apache.commons.lang3.StringUtils;
import com.cfang.zkClient.MyZkSerializer;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ZKLockImproveUtil implements Lock{
private String znode;
private ZkClient zkClient;
private ThreadLocal<String> currentNode = new ThreadLocal<String>(); //当前节点
private ThreadLocal<String> beforeNode = new ThreadLocal<String>(); //前一个节点
public ZKLockImproveUtil(String znode) {
if(StringUtils.isBlank(znode)) {
throw new IllegalArgumentException("锁节点znode不能为空字符串");
}
this.znode = znode;
this.zkClient = new ZkClient("111.231.51.200:2181,111.231.51.200:2182,111.231.51.200:2183");
this.zkClient.setZkSerializer(new MyZkSerializer());
try {
if(!this.zkClient.exists(znode)) {
this.zkClient.createPersistent(znode, true); // true是否创建层级目录
}
} catch (Exception e) {
}
}
@Override
public void lock() {
if(!tryLock()) {
waitLock();
lock();
}
}
private void waitLock() {
CountDownLatch latch = new CountDownLatch(1);
IZkDataListener listener = new IZkDataListener() {
@Override
public void handleDataDeleted(String dataPath) throws Exception {
log.info("{}节点删除,锁释放...", dataPath);
latch.countDown();
}
@Override
public void handleDataChange(String dataPath, Object data) throws Exception {
}
};
this.zkClient.subscribeDataChanges(beforeNode.get(), listener);
try {
if(this.zkClient.exists(beforeNode.get())) {
latch.await();
}
} catch (Exception e) {
}
this.zkClient.unsubscribeDataChanges(beforeNode.get(), listener);
}
@Override
public boolean tryLock() {
boolean result = false;
// 创建顺序临时节点
if(null == currentNode.get() || !this.zkClient.exists(currentNode.get())) {
String enode = this.zkClient.createEphemeralSequential(znode + "/", "zk-locked");
this.currentNode.set(enode);
}
// 获取znode节点下的所有子节点
List<String> list = this.zkClient.getChildren(znode);
Collections.sort(list);
/**
* 如果当前节点是第一个的话,则是为获取锁,继续执行
* 不是头结点的话,则去查询其前面一个节点,然后准备监听前一个节点的删除释放操作
*/
if(currentNode.get().equals(this.znode + "/" + list.get(0))) {
log.info("{}节点为头结点,获得锁...", currentNode.get());
result = true;
} else {
int currentIndex = list.indexOf(currentNode.get().substring(this.znode.length() + 1));
String bnode = this.znode + "/" + list.get(currentIndex - 1);
this.beforeNode.set(bnode);
}
return result;
}
@Override
public void unlock() {
if(null != this.currentNode) {
this.zkClient.delete(currentNode.get());
this.currentNode.set(null);
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// TODO Auto-generated method stub
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {
// TODO Auto-generated method stub
}
@Override
public Condition newCondition() {
// TODO Auto-generated method stub
return null;
}
}
service中更换实现:
private Lock lock = new ZKLockImproveUtil("/pnode");
五、小结
主要是学习测试使用,并未考虑到生产实际的问题,比如 如果业务处理中假死状态,导致zk不释放锁,那么就会导致死锁问题(可以对锁节点来个有效期处理)。
上述为部分代码片段,整体工程可以在github上获取,地址:https://github.com/qiuhan00/zkLock