在分佈式系統下,使用Java中的synchronized或者Lock已經不能滿足需求了。關於分佈式鎖的實現,我們可以利用MySQL的唯一索引去實現,也可以利用Redis的SETNX,同樣也可以使用Zookeeper的節點唯一路徑去實現。
(1)線程先去/locks
路徑下面創建一個帶序號的臨時節點。
(2)判斷自己創建的這個節點是不是/locks
路徑下序號最小的節點,如果是,則獲取鎖;如果不是,則監聽自己的前一個節點。
(3)獲取到鎖後,處理自己的業務邏輯,然後刪除自己創建的節點。監聽它的後一個節點收到通知後,執行步驟(2)
上面的過程是不是跟AQS的同步隊列有點像,判斷自己是不是隊列的頭結點,如果是就去獲取鎖,不是就等待。
1、原生Zookeeper代碼實現分佈式鎖
按照上面的思路,我們可以很快的使用zookeeper相關的api實現分佈式鎖。
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 =
"192.168.1.128:2181,192.168.1.129:2181,192.168.1.130: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<String> 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();
}
}
}
通過在zookeeper中創建帶序號的臨時節點,然後判斷當前線程創建的臨時節點序號是不是最小的,如果是則獲得鎖,否則監聽前一節點。
爲什麼要創建臨時節點,就是怕創建完後,zookeeper服務器又掛了,這時候如果是永久節點,那麼就會死鎖了。而臨時節點在關閉服務器後就會被刪除。
這裏使用CountDownLatch
在監聽節點的時候進行await
。節點發生變化時,會調用process
方法,在process
方法中進行countDown
。
進行測試
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 釋放鎖
2、使用Curator框架實現分佈式鎖
使用原生API存在的問題
- 會話連接是異步的,需要自己去處理。比如使用 CountDownLatch
- Watch 需要重複註冊,不然就不能生效
- 開發的複雜性比較高
- 不支持多節點刪除和創建。需要自己去遞歸
基於以上,一般實際開發都是用Curator去實現,畢竟別人的輪子又大又安全,何必自己搞個破破爛爛的輪子上路呢。
Curator主要實現了下面四種鎖
- InterProcessMutex:分佈式可重入排它鎖
- InterProcessSemaphoreMutex:分佈式排它鎖
- InterProcessReadWriteLock:分佈式讀寫鎖
- InterProcessMultiLock:將多個鎖作爲單個實體管理的容器
首先需要在項目中添加依賴
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-client</artifactId>
<version>4.3.0</version>
</dependency
然後實現即可
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 =
"192.168.1.128:2181,192.168.1.129:2181,192.168.1.130: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() {
// 獲取鎖對象
try {
lock2.acquire();
System.out.println("線程 2 獲取鎖");
// 測試鎖重入
lock2.acquire();
System.out.println("線程 2 再次獲取鎖");
Thread.sleep(5 * 1000);
lock2.release();
System.out.println("線程 2 釋放鎖");
lock2.release();
System.out.println("線程 2 再次釋放鎖");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
// 分佈式鎖初始化
public CuratorFramework getCuratorFramework (){
//重試策略,初試時間 3 秒,重試 3 次
RetryPolicy policy = new ExponentialBackoffRetry(3000, 3);
//通過工廠創建 Curator
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString(connectString)
.connectionTimeoutMs(connectionTimeout)
.sessionTimeoutMs(sessionTimeout)
.retryPolicy(policy).build();
//開啓連接
client.start();
System.out.println("zookeeper 初始化完成...");
return client;
}
}
查看控制檯輸出
線程 1 獲取鎖
線程 1 再次獲取鎖
線程 1 釋放鎖
線程 1 再次釋放鎖
線程 2 獲取鎖
線程 2 再次獲取鎖
線程 2 釋放鎖
線程 2 再次釋放鎖