日韩高清熟女岛国av,91日本在线播放

在分布式系統(tǒng)下，使用Java中的synchronized或者Lock已經(jīng)不能滿足需求了。關(guān)于分布式鎖的實(shí)現(xiàn)，我們可以利用MySQL的唯一索引去實(shí)現(xiàn)，也可以利用Redis的SETNX，同樣也可以使用Zookeeper的節(jié)點(diǎn)唯一路徑去實(shí)現(xiàn)。

image-20211205225817850.png

（1）線程先去/locks路徑下面創(chuàng)建一個(gè)帶序號(hào)的臨時(shí)節(jié)點(diǎn)。

（2）判斷自己創(chuàng)建的這個(gè)節(jié)點(diǎn)是不是/locks路徑下序號(hào)最小的節(jié)點(diǎn)，如果是，則獲取鎖；如果不是，則監(jiān)聽(tīng)自己的前一個(gè)節(jié)點(diǎn)。

（3）獲取到鎖后，處理自己的業(yè)務(wù)邏輯，然后刪除自己創(chuàng)建的節(jié)點(diǎn)。監(jiān)聽(tīng)它的后一個(gè)節(jié)點(diǎn)收到通知后，執(zhí)行步驟（2）

上面的過(guò)程是不是跟AQS的同步隊(duì)列有點(diǎn)像，判斷自己是不是隊(duì)列的頭結(jié)點(diǎn)，如果是就去獲取鎖，不是就等待。

1、原生Zookeeper代碼實(shí)現(xiàn)分布式鎖

按照上面的思路，我們可以很快的使用zookeeper相關(guān)的api實(shí)現(xiàn)分布式鎖。

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";
     // 超時(shí)時(shí)間
     private int sessionTimeout = 2000;
     private ZooKeeper zk;
     private String rootNode = "locks";
     private String subNode = "seq-";
     // 當(dāng)前 client 等待的子節(jié)點(diǎn)
     private String waitPath;
     // ZooKeeper 連接等待
     private CountDownLatch connectLatch = new CountDownLatch(1);
     // ZooKeeper 節(jié)點(diǎn)等待
     private CountDownLatch waitLatch = new CountDownLatch(1);
     // 當(dāng)前 client 創(chuàng)建的子節(jié)點(diǎn)
     private String currentNode;
    
     // 和 zk 服務(wù)建立連接，并創(chuàng)建根節(jié)點(diǎn)
     public DistributedLock() throws IOException, InterruptedException, KeeperException {
        zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 連接建立時(shí), 打開(kāi) latch, 喚醒 wait 在該 latch 上的線程
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    connectLatch.countDown();
                }
                // 發(fā)生了 waitPath 的刪除事件
                if (event.getType() == Event.EventType.NodeDeleted &&                                                  
                                      event.getPath().equals(waitPath)) {
                    waitLatch.countDown();
                }
            }
        });
 
        // 等待連接建立
        connectLatch.await();
        //獲取根節(jié)點(diǎn)狀態(tài)
        Stat stat = zk.exists("/" + rootNode, false);
        //如果根節(jié)點(diǎn)不存在，則創(chuàng)建根節(jié)點(diǎn)，根節(jié)點(diǎn)類型為永久節(jié)點(diǎn)
        if (stat == null) {
            System.out.println("根節(jié)點(diǎn)不存在");
            zk.create("/" + rootNode, new byte[0], 
                 ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }
    
    // 加鎖方法
    public void zkLock() {
        try {
            //在根節(jié)點(diǎn)下創(chuàng)建臨時(shí)順序節(jié)點(diǎn)，返回值為創(chuàng)建的節(jié)點(diǎn)路徑
            currentNode = zk.create("/" + rootNode + "/" + subNode, null,                                               ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
            // wait 一小會(huì), 讓結(jié)果更清晰一些
            Thread.sleep(10);
            // 注意, 沒(méi)有必要監(jiān)聽(tīng)"/locks"的子節(jié)點(diǎn)的變化情況
            List<String> childrenNodes = zk.getChildren("/" + rootNode, false);
            // 列表中只有一個(gè)子節(jié)點(diǎn), 那肯定就是 currentNode , 說(shuō)明client 獲得鎖
            if (childrenNodes.size() == 1) {
                return;
            } else {
                //對(duì)根節(jié)點(diǎn)下的所有臨時(shí)順序節(jié)點(diǎn)進(jìn)行從小到大排序
                Collections.sort(childrenNodes);
                //當(dāng)前節(jié)點(diǎn)名稱
                String thisNode = currentNode.substring(("/" + rootNode + "/").length());
                //獲取當(dāng)前節(jié)點(diǎn)的位置
                int index = childrenNodes.indexOf(thisNode);
                if (index == -1) {
                    System.out.println("數(shù)據(jù)異常");
                } else if (index == 0) {
                    // index == 0, 說(shuō)明 thisNode 在列表中最小, 當(dāng)前client 獲得鎖
                    return;
                } else {
                    // 獲得排名比 currentNode 前 1 位的節(jié)點(diǎn)
                    this.waitPath = "/" + rootNode + "/" + childrenNodes.get(index - 1);
                    // 在 waitPath 上注冊(cè)監(jiān)聽(tīng)器, 當(dāng) waitPath 被刪除時(shí), zookeeper 會(huì)回調(diào)監(jiān)聽(tīng)器的 process 方法
                    zk.getData(waitPath, true, new Stat());
                    //進(jìn)入等待鎖狀態(tài)
                    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();
        }
    } 
}

通過(guò)在zookeeper中創(chuàng)建帶序號(hào)的臨時(shí)節(jié)點(diǎn)，然后判斷當(dāng)前線程創(chuàng)建的臨時(shí)節(jié)點(diǎn)序號(hào)是不是最小的，如果是則獲得鎖，否則監(jiān)聽(tīng)前一節(jié)點(diǎn)。

為什么要?jiǎng)?chuàng)建臨時(shí)節(jié)點(diǎn)，就是怕創(chuàng)建完后，zookeeper服務(wù)器又掛了，這時(shí)候如果是永久節(jié)點(diǎn)，那么就會(huì)死鎖了。而臨時(shí)節(jié)點(diǎn)在關(guān)閉服務(wù)器后就會(huì)被刪除。

這里使用CountDownLatch在監(jiān)聽(tīng)節(jié)點(diǎn)的時(shí)候進(jìn)行await。節(jié)點(diǎn)發(fā)生變化時(shí)，會(huì)調(diào)用process方法，在process方法中進(jìn)行countDown。

進(jìn)行測(cè)試

import org.apache.zookeeper.KeeperException;
import java.io.IOException;

public class DistributedLockTest {
    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {
        // 創(chuàng)建分布式鎖 1
        final DistributedLock lock1 = new DistributedLock();
        // 創(chuàng)建分布式鎖 2
        final DistributedLock lock2 = new DistributedLock();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 獲取鎖對(duì)象
                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() {
                // 獲取鎖對(duì)象
                try {
                    lock2.zkLock();
                    System.out.println("線程 2 獲取鎖");
                    Thread.sleep(5 * 1000);
                    lock2.zkUnlock();
                    System.out.println("線程 2 釋放鎖");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    } 
}

創(chuàng)建兩個(gè)線程進(jìn)行測(cè)試，看控制打印輸出

線程 1 獲取鎖
線程 1 釋放鎖
線程 2 獲取鎖
線程 2 釋放鎖

2、使用Curator框架實(shí)現(xiàn)分布式鎖

官方文檔

使用原生API存在的問(wèn)題

會(huì)話連接是異步的，需要自己去處理。比如使用 CountDownLatch
Watch 需要重復(fù)注冊(cè)，不然就不能生效
開(kāi)發(fā)的復(fù)雜性比較高
不支持多節(jié)點(diǎn)刪除和創(chuàng)建。需要自己去遞歸

基于以上，一般實(shí)際開(kāi)發(fā)都是用Curator去實(shí)現(xiàn)，畢竟別人的輪子又大又安全，何必自己搞個(gè)破破爛爛的輪子上路呢。

Curator主要實(shí)現(xiàn)了下面四種鎖

InterProcessMutex：分布式可重入排它鎖
InterProcessSemaphoreMutex：分布式排它鎖
InterProcessReadWriteLock：分布式讀寫(xiě)鎖
InterProcessMultiLock：將多個(gè)鎖作為單個(gè)實(shí)體管理的容器

首先需要在項(xiàng)目中添加依賴

<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

然后實(shí)現(xiàn)即可

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 超時(shí)時(shí)間
    private int connectionTimeout = 2000;
    // session 超時(shí)時(shí)間
    private int sessionTimeout = 2000;
 
    public static void main(String[] args) {
        new CuratorLockTest().test();
    }
    
    // 測(cè)試
    private void test() {
        // 創(chuàng)建分布式鎖 1
        final InterProcessLock lock1 = new InterProcessMutex(getCuratorFramework(), rootNode);
        // 創(chuàng)建分布式鎖 2
        final InterProcessLock lock2 = new InterProcessMutex(getCuratorFramework(), rootNode);
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 獲取鎖對(duì)象
                try {
                    lock1.acquire();
                    System.out.println("線程 1 獲取鎖");
                    // 測(cè)試鎖重入
                    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() {
                // 獲取鎖對(duì)象
                try {
                    lock2.acquire();
                    System.out.println("線程 2 獲取鎖");
                    // 測(cè)試鎖重入
                    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 (){
        //重試策略，初試時(shí)間 3 秒，重試 3 次
        RetryPolicy policy = new ExponentialBackoffRetry(3000, 3);
        //通過(guò)工廠創(chuàng)建 Curator
        CuratorFramework client = CuratorFrameworkFactory.builder()
                                                .connectString(connectString)
                                                .connectionTimeoutMs(connectionTimeout)
                                                .sessionTimeoutMs(sessionTimeout)
                                                .retryPolicy(policy).build();
        //開(kāi)啟連接
        client.start();
        System.out.println("zookeeper 初始化完成...");
        return client;
    } 
}

查看控制臺(tái)輸出

線程 1 獲取鎖
線程 1 再次獲取鎖
線程 1 釋放鎖
線程 1 再次釋放鎖
線程 2 獲取鎖
線程 2 再次獲取鎖
線程 2 釋放鎖
線程 2 再次釋放鎖

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Zookeeper + Curator實(shí)現(xiàn)分布式鎖

Zookeeper + Curator實(shí)現(xiàn)分布式鎖

1、原生Zookeeper代碼實(shí)現(xiàn)分布式鎖

2、使用Curator框架實(shí)現(xiàn)分布式鎖

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Zookeeper + Curator實(shí)現(xiàn)分布式鎖

1、原生Zookeeper代碼實(shí)現(xiàn)分布式鎖

2、使用Curator框架實(shí)現(xiàn)分布式鎖

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

1、原生Zookeeper代碼實(shí)現(xiàn)分布式鎖

2、使用Curator框架實(shí)現(xiàn)分布式鎖