//借鉴AQS的实现,使用模板方法
public abstract class AbstractLock implements Lock {
private static final Unsafe unsafe = getUnsafe();
private static long stateOffset;
//同步状态
private volatile int state;
public static final Unsafe getUnsafe() {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
Unsafe unsafe = (Unsafe) field.get(null);
stateOffset = unsafe.objectFieldOffset
(AbstractLock.class.getDeclaredField("state"));
return unsafe;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
//释放锁
protected boolean tryUnLock() {
throw new UnsupportedOperationException();
}
//唤醒
protected void notifyLock() {
throw new UnsupportedOperationException();
}
public final void unlock() {
if (tryUnLock()) {
//线程唤醒
notifyLock();
}
}
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
//CAS,借鉴AtomicInteger实现
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
}
//分布式锁第一种实现:进程之间都通过监听同一个节点实现,这种容易引起羊群效应
public class ZkLock extends AbstractLock {
private static final String PATH = "/lock";
private static final ZkClient zkClient = ZkConnection.getConnection();
private static final Lock lock = new ReentrantLock();
public void lock() {
//首先保证进程内线程的安全
lock.lock();
//获取分布式锁
createNode();
}
@Override
public boolean tryUnLock() {
if (getState() == 0) {
throw new RuntimeException("释放锁失败!");
}
try {
return zkClient.delete(PATH);
} catch (Exception e) {
return false;
}
}
@Override
public void notifyLock() {
setState(0);
lock.unlock();
}
//创建节点
public boolean createNode() {
try {
//创建的zk节点作为分布式锁
zkClient.createEphemeral(PATH);
//监听节点
zkClient.subscribeDataChanges(PATH, new IZkDataListener() {
public void handleDataChange(String s, Object o) {
}
//释放锁的时候唤醒其他线程
public void handleDataDeleted(String s) {
notifyLock();
}
});
if (compareAndSet(0, 1)) {
return true;
}
} catch (Exception e) {
return false;
}
return false;
}
}
测试
public class OrderNumGenerator {
private OrderNumGenerator() {
}
//全局订单id
public static int count = 0;
//生成订单ID
public static String getNumber() {
SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
return simpt.format(new Date()) + "-" + (++count);
}
}
//zk连接
public class ZkConnection {
// zk连接地址
private static final String CONNECTSTRING = "127.0.0.1:2181";
private static final int connectionTimeout = 50000;
private static final int sessionTimeout = 50000;
private ZkConnection() {
}
private static class ZkConnectionBuilder {
private final static ZkClient zkConnection = new ZkClient(CONNECTSTRING, sessionTimeout, connectionTimeout);
}
public static final ZkClient getConnection() {
return ZkConnectionBuilder.zkConnection;
}
}
//订单生成--模拟并发
public class OrderService implements Runnable {
public Lock lock = new ZkLock();
public void run() {
try {
lock.lock();
String number = OrderNumGenerator.getNumber();
System.out.println("获取订单号...." + number);
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(new OrderService()).start();
}
}
}