国产疯狂伦交大片,国内夫妇交换自拍视频,国产成人A∨麻豆精品

來自公眾號：非科班的科班
作者：黎杜

前言

標題使用最近異常火熱的微信拍一拍的方式命名，最近拍一拍的玩法被各位網友玩壞了，出現了各種版本的拍一拍。

比如：下面的這個版本是不是似曾相識的感覺，曾幾何時你也曾有這種沖動的想法，但是奈于生活，你不得不把這股沖動埋在心底，畢竟沖動是魔鬼。

image

還有比較重口味的，有點哭笑不得，這網友的腦洞真大，要是能把這些心思放在學習和事業上，必是成大事之人，不得不佩服，假如你在吃飯，千萬別打我。

image

不得不說拍一拍有點東西，好了，水話就說那么一兩句，在開始真正的分布式鎖講解之前，先來個人的分析一下拍一拍的戰略動機。

對于老板和一個公司來說，公司付出的每一個商品都是有商用價值的，老板不會把沒有商用的價值功能和產品創造出來。

對于拍一拍這個功能，我想是一個引導性的戰略思維，對于這個拍一拍新功能，很多網友都會躍躍欲試，不經意間就會嘗試，雙擊別人的頭像進行拍一拍。

那么這個雙擊的動作可能將來微信服務于某項功能而做的準備，待微信的用戶習慣了雙擊操作，微信對于后面的這類操作的功能的推廣會變得更加容易。

好了，不能再深究下去了，要是被小馬哥看到，估計小馬哥就要拍一拍我了，這個純屬個人觀點，不代表官方的觀點，下面開始我們的分布式鎖的講解。

分布式鎖簡介

分布式鎖的實現方式有以下三種方式：「數據庫分布式鎖、Redis實現分布式鎖、ZooKeeper實現分布式鎖」。

為什么需要分布式鎖呢？在很久以前，用戶全體不大的時候，單體應用就可以足夠滿足用戶的所有請求，當用戶增加的時候，出現了一定的并發度，可以使用簡單的鎖機制來協調并發的共享資源的獲取。

但是，隨著業務的增大，用戶數量的增加，為了滿足業務的高效性，集群的出現，簡單的鎖機制已經不能夠滿足協調多個應用之間的共享資源了，于是就出現了分布式鎖。

分布式鎖是協調集群中多應用之間的共享資源的獲取的一種方式，可以說它是一種約束、規則。

那么對于一個分布式系統中分布式鎖應該滿足什么條件呢？也就是它應該具備怎樣的約束、規則，下面是我總結的分布式鎖至少擁有的幾個規則。

1.「鎖的互斥性」：在分布式集群應用中，共享資源的鎖在同一時間只能被一個對象獲取。2. 「可重入」：為了避免死鎖，這把鎖是可以重入的，并且可以設置超時。3. 「高效的加鎖和解鎖」：能夠高效的加鎖和解鎖，獲取鎖和釋放鎖的性能也好。4. 「阻塞、公平」：可以根據業務的需要，考慮是使用阻塞、還是非阻塞，公平還是非公平的鎖。

一個分布式鎖能夠具備上面的幾種條件，應該來說是比較好的分布式鎖了，但是現實中沒有十全十美的鎖，對于不同的分布式鎖，沒有最好，只能說那種場景更加適合。

下面我們詳細的聊一聊上面說的三種分布式鎖的實現原理，先來看看數據庫的分布式鎖。

數據庫分布式鎖

在數據庫的分布式鎖的實現中，分為「悲觀鎖和樂觀鎖」，「悲觀鎖的實現依賴于數據庫自身的鎖機制實現」。

若是要測試數據庫的悲觀的分布式鎖，可以執行下面的sql：select … where … for update （排他鎖），注意：where 后面的查詢條件要走索引，若是沒有走索引，會使用全表掃描，鎖全表。

當一個數據庫表被加上了排它鎖，其它的客戶端是不能夠再對加鎖的數據行加任何的鎖，只能等待當前持有鎖的釋放鎖。

全表掃描對于測試就沒有太大意義了，where后面的條件是否走索引，要注意自己的索引的使用方式是否正確，并且還取決于「mysql優化器」。

排它鎖是基于InnoDB存儲引擎的，在執行操作的時候，在sql中加入for update，可以給數據行加上排它鎖。

在代碼的代碼的層面上使用connection.commit();，便可以釋放鎖，但是數據庫復雜的加鎖和解鎖、事務等一系列消耗性能的操作，終歸是無法抗高并發。

數據庫樂觀鎖的方式實現分布式鎖是基于「版本號控制」的方式實現，類似于「CAS的思想」，它認為操作的過程并不會存在并發的情況，只有在update version的時候才會去比較。

樂觀鎖的方式并沒有鎖的等待，不會因為所等待而消耗資源，下面來測試一下樂觀鎖的方式實現的分布式鎖。

樂觀鎖的方式實現分布式鎖要基于數據庫表的方式進行實現，我們認為在數據庫表中成功存儲該某方法的線程獲取到該方法的鎖，才能操作該方法。

首先要創建一個表用于儲存各個線程操作方法的對應該關系表LOCK：

CREATE TABLE `LOCK` ( 
`ID` int PRIMARY KEY NOT NULL AUTO_INCREMENT,  
`METHODNAME` varchar(64) NOT NULL DEFAULT '',
`DESCRIPTION` varchar(1024) NOT NULL DEFAULT '',  
`TIME` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,  
UNIQUE KEY `UNIQUEMETHODNAME` (`METHODNAME`) USING BTREE ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

該表是存儲某個方法的是否已經被鎖定的信息，若是被鎖定則無法獲取到該方法的鎖，這里注意的是使用UNIQUE KEY唯一約束，表示該方法布恩那個夠被第二個線程同時持有。

當你要獲取鎖的時候，通過執行下面的sql來嘗試獲取鎖：insert into LOCK(METHODNAME,DESCRIPTION) values (‘getLock’,‘獲取鎖’) ;來獲取鎖。

這條sql執行的結果有兩種成功和失敗，成功說明該方法還沒有被某個線程所持有，失敗則表明數據庫中已經存在該條數據，該方法的鎖已經被某個線程所持有。

當你需要釋放鎖的時候，可以通過執行這條sql：delete from LOCK where METHODNAME='getLock';來釋放鎖。

樂觀鎖實現方式還是存在很多問題的，一個是「并發性能問題」，再者「不可重入」以及「沒有自動失效的功能」、「非公平鎖」，只要當前的庫表中已經存在該信息，執行插入就會失敗。

其實，對于上面的問題基于數據庫也可以解決，比如：不可重復，你可以「增加字段保存當前線程的信息以及可重復的次數」，只要是再判斷是當前線程，可重復的次數就會+1，每次執行釋放鎖就會-1，直到為0。

「沒有失效的功能，可以增加一個字段存儲最后的失效時間」，根據這個字段判斷當前時間是否大于存儲的失效時間，若是大于則表明，該方法的索索已經可以被釋放。

「非公平鎖可以增加一個中間表的形式，作為一個排隊隊列」，競爭的線程都會按照時間存儲于這個中間表，當要某個線程嘗試獲取某個方法的鎖的時候，檢查中間表中是否已經存在等待的隊列。

每次都只要獲取中間表中最小的時間的鎖，也實現公平的排隊等候的效果，所有的問題總是有解決的思路。

上面就是兩種基于數據庫實現分布式鎖的方式，但是，數據庫實現分布式鎖的方式只作為學習的例子，實際中不會使用它作為實現分布式鎖，重要的是學習解決問題的思路和思想。

Redis實現的分布式鎖

之前講了一篇Redis事務的文章，很多讀者Redis事務有啥用，主要是因為Redis的事務并沒有Mysql的事務那么強大，所以一般的公司一般確實是用不到。

這里就來說一說Redis事務的一個實際用途，它可以用來實現一個簡單的秒殺系統的庫存扣減，下面我們就來進行代碼的實現。

（1）首先使用線程池初始化5000個客戶端。

public static void intitClients() {
 ExecutorService threadPool= Executors.newCachedThreadPool();
 for (int i = 0; i < 5000; i++) {
  threadPool.execute(new Client(i));
 }
 threadPool.shutdown();

 while(true){ 
         if(threadPool.isTerminated()){  
             break;  
         }  
     }  
}

（2）接著初始化商品的庫存數為1000。

public static void initPrductNum() {
  Jedis jedis = RedisUtil.getInstance().getJedis();
  jedisUtils.set("produce", "1000");// 初始化商品庫存數
  RedisUtil.returnResource(jedis);// 返還數據庫連接
 }
}

（3）最后是庫存扣減的每條線程的處理邏輯。

/**
 * 顧客線程
 * 
 *
 */
class client implements Runnable {
 Jedis jedis = null;
 String key = "produce"; // 商品數量的主鍵
 String name;

 public ClientThread(int num) {
  name= "編號=" + num;
 }

 public void run() {

  while (true) {
   jedis = RedisUtil.getInstance().getJedis();
   try {
    jedis.watch(key);
    int num= Integer.parseInt(jedis.get(key));// 當前商品個數
    if (num> 0) {
     Transaction ts= jedis.multi(); // 開始事務
     ts.set(key, String.valueOf(num - 1)); // 庫存扣減
     List<Object> result = ts.exec(); // 執行事務
     if (result == null || result.isEmpty()) {
      System.out.println("抱歉，您搶購失敗，請再次重試");
     } else {
      System.out.println("恭喜您，搶購成功");
      break;
     }
    } else {
     System.out.println("抱歉，商品已經賣完");
     break;
    }
   } catch (Exception e) {
    e.printStackTrace();
   } finally {
    jedis.unwatch(); // 解除被監視的key
    RedisUtil.returnResource(jedis);
   }
  }
 }
}

在代碼的實現中有一個重要的點就是「商品的數據量被watch了」，當前的客戶端只要發現數量被改變就會搶購失敗，然后不斷的自旋進行搶購。

這個是基于Redis事務實現的簡單的秒殺系統，Redis事務中的watch命令有點類似樂觀鎖的機制，只要發現商品數量被修改，就執行失敗。

Redis實現分布式鎖的第二種方式，可以使用setnx、getset、expire、del這四個命令來實現。

setnx：命令表示如果key不存在，就會執行set命令，若是key已經存在，不會執行任何操作。
getset：將key設置為給定的value值，并返回原來的舊value值，若是key不存在就會返回返回nil 。
expire：設置key生存時間，當當前時間超出了給定的時間，就會自動刪除key。
del：刪除key，它可以刪除多個key，語法如下：DEL key [key …]，若是key不存在直接忽略。

下面通過一個代碼案例是實現以下這個命令的操作方式：

public void redis(Produce produce) {
        long timeout= 10000L; // 超時時間
        Long result= RedisUtil.setnx(produce.getId(), String.valueOf(System.currentTimeMillis() + timeout));
        if (result!= null && result.intValue() == 1) { // 返回1表示成功獲取到鎖
         RedisUtil.expire(produce.getId(), 10);//有效期為5秒，防止死鎖
         //執行業務操作
         ......
         //執行完業務后，釋放鎖
         RedisUtil.del(produce.getId());
        } else {
           System.println.out("沒有獲取到鎖")
        }
    }

在線程A通過setnx方法嘗試去獲取到produce對象的鎖，若是獲取成功就會返回1，獲取不成功，說明當前對象的鎖已經被其它線程鎖持有。

獲取鎖成功后并設置key的生存時間，能夠有效的防止出現死鎖，最后就是通過del來實現刪除key，這樣其它的線程就也可以獲取到這個對象的鎖。

執行的邏輯很簡單，但是簡單的同時也會出現問題，比如你在執行完setnx成功后設置生存時間不生效，此時服務器宕機，那么key就會一直存在Redis中。

當然解決的辦法，你可以在服務器destroy函數里面再次執行：

RedisUtil.del(produce.getId());

或者通過「定時任務檢查是否有設置生存時間」，沒有的話都會統一進行設置生存時間。

還有比較好的解決方案就是，在上面的執行邏輯里面，若是沒有獲取到鎖再次進行key的生存時間：

public void redis(Produce produce) {
        long timeout= 10000L; // 超時時間
        Long result= RedisUtil.setnx(produce.getId(), String.valueOf(System.currentTimeMillis() + timeout));
        if (result!= null && result.intValue() == 1) { // 返回1表示成功獲取到鎖
         RedisUtil.expire(produce.getId(), 10);//有效期為10秒，防止死鎖
         //執行業務操作
         ......
         //執行完業務后，釋放鎖
         RedisUtil.del(produce.getId());
        } else {
            String value= RedisUtil.get(produce.getId());
            // 存在該key，并且已經超時
            if (value!= null && System.currentTimeMillis() > Long.parseLong(value)) {
                String result = RedisUtil.getSet(produce.getId(), String.valueOf(System.currentTimeMillis() + timeout)); 
                if (result == null || (result != null && StringUtils.equals(value, result))) {
                     RedisUtil.expire(produce.getId(), 10);//有效期為10秒，防止死鎖
           //執行業務操作
           ......
           //執行完業務后，釋放鎖
           RedisUtil.del(produce.getId());
                } else {
                    System.println("沒有獲取到鎖")
                }
            } else {
                System.println("沒有獲取到鎖")
            }
        }
    }

這里對上面的代碼進行了改進，在獲取setnx失敗的時候，再次重新判斷該key的鎖時間是否失效或者不存在，并重新設置生存的時間，避免出現死鎖的情況。

第三種Redis實現分布式鎖，可以使用Redisson來實現，它的實現簡單，已經幫我們封裝好了，屏蔽了底層復雜的實現邏輯。

先來一個Redisson的原理圖，后面會對這個原理圖進行詳細的介紹：

image

我們在實際的項目中要使用它，只需要引入它的依賴，然后執行下面的代碼：

RLock lock = redisson.getLock("lockName");
lock.locl();
lock.unlock();

并且它還支持「Redis單實例、Redis哨兵、redis cluster、redis master-slave」等各種部署架構，都給你完美的實現，不用自己再次擰螺絲。

但是，crud的同時還是要學習一下它的底層的實現原理，下面我們來了解下一下，對于一個分布式的鎖的框架主要的學習分為下面的5個點：

加鎖機制
解鎖機制
生存時間延長機制
可重入加鎖機制
鎖釋放機制

只要掌握一個框架的這五個大點，基本這個框架的核心思想就已經掌握了，若是要你去實現一個鎖機制框架，就會有大體的一個思路。

Redisson中的加鎖機制是通過lua腳本進行實現，Redisson首先會通過「hash算法」，選擇redis cluster集群中的一個節點，接著會把一個lua腳本發送到Redis中。

它底層實現的lua腳本如下：

returncommandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
 "if (redis.call('exists', KEYS[1]) == 0) then " +
       "redis.call('hset', KEYS[1], ARGV[2], 1); " +
       "redis.call('pexpire', KEYS[1], ARGV[1]); " +
       "return nil; " +
   "end; " +
   "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
       "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
       "redis.call('pexpire', KEYS[1], ARGV[1]); " +
       "return nil; " +
   "end; " +
   "return redis.call('pttl', KEYS[1]);",
     Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));

「redis.call()的第一個參數表示要執行的命令，KEYS[1]表示要加鎖的key值，ARGV[1]表示key的生存時間，默認時30秒，ARGV[2]表示加鎖的客戶端的ID。」

比如第一行中redis.call('exists', KEYS[1]) == 0) 表示執行exists命令判斷Redis中是否含有KEYS[1]，這個還是比較好理解的。

lua腳本中封裝了要執行的業務邏輯代碼，它能夠保證執行業務代碼的原子性，它通過hset lockName命令完成加鎖。

若是第一個客戶端已經通過hset命令成功加鎖，當第二個客戶端繼續執行lua腳本時，會發現鎖已經被占用，就會通過pttl myLock返回第一個客戶端的持鎖生存時間。

若是還有生存時間，表示第一個客戶端會繼續持有鎖，那么第二個客戶端就會不停的自旋嘗試去獲取鎖。

假如第一個客戶端持有鎖的時間快到期了，想繼續持有鎖，可以給它啟動一個watch dog看門狗，他是一個后臺線程會每隔10秒檢查一次，可以不斷的延長持有鎖的時間。

Redisson中可重入鎖的實現是通過incrby lockName來實現，「重入一個計數就會+1，釋放一次鎖計數就會-1」。

最后，使用完鎖后執行del lockName就可以直接「釋放鎖」，這樣其它的客戶端就可以爭搶到該鎖了。

這就是分布式鎖的開源Redisson框架底層鎖機制的實現原理，我們可以在生產中實現該框架實現分布式鎖的高效使用。

下面通過一個多窗口搶票的例子代碼來實現：

public class SellTicket implements Runnable {
    private int ticketNum = 1000;
    RLock lock = getLock();
    // 獲取鎖 
    private RLock getLock() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        Redisson redisson = (Redisson) Redisson.create(config);
        RLock lock = redisson.getLock("keyName");
        return lock;
    }

    @Override
    public void run() {
        while (ticketNum>0) {
            // 獲取鎖,并設置超時時間
            lock.lock(1, TimeUnit.MINUTES);
            try {
                if (ticketNum> 0) {
                    System.out.println(Thread.currentThread().getName() + "出售第 " + ticketNum-- + " 張票");
                }
            } finally {
                lock.unlock(); // 釋放鎖
            }
        }
    }
}

測試的代碼如下：

public class Test {
    public static void main(String[] args) {
        SellTicket sellTick= new SellTicket();
        // 開啟5五條線程，模擬5個窗口
        for (int i=1; i<=5; i++) {
            new Thread(sellTick, "窗口" + i).start();
        }
    }
}

是不是感覺很簡單，因為多線程競爭共享資源的復雜的過程它在底層都幫你實現了，屏蔽了這些復雜的過程，而你也就成為了優秀的API調用者。

上面就是Redis三種方式實現分布式鎖的方式，基于Redis的實現方式基本都會選擇Redisson的方式進行實現，因為簡單命令，不用自己擰螺絲，開箱即用。

ZK實現的分布式鎖

ZK實現的分布式鎖的原理是基于一個「臨時順序節點」實現的，開始的時候，首先會在ZK中創建一個ParentLock持久化節點。

image

當有client1請求鎖的時候，，就會在ParentLock下創建一個臨時順序節點，如下圖所示：

image

并且，該節點是有序的，在ZK的內部會自動維護一個節點的序號，比如：第一個進來的創建的臨時順序節點叫做xxx-000001，那么第二個就叫做xxx-000002，這里的序號是一次遞增的。

當client1創建完臨時順序節點后，就會檢查ParentLock下面的所有的子節點，會判斷自己前面是否還有節點，此時明顯是沒有的，所以獲取鎖成功。

image

當第二個客戶端client2進來獲取鎖的時候，也會執行相同的邏輯，會先在創建一個臨時的順序節點，并且序號是排在第一個節點的后面：

image

并且第二部也會判斷ParnetLock下面的所有的子節點，看自己是否是第一個，明顯不是，此時就會加鎖失敗。

那么此時client2會創建一個對client1的lock1的監聽（Watcher），用于監聽lock1是否存在，同時client2會進入等待狀態：

image

當client1執行完自己的業務邏輯之后，就會刪除鎖，刪除鎖很簡單，就是把這個lock1給刪除掉：

image

此時就會通知client2：監聽的lock1已經被刪除，鎖被釋放，此時client2創建的lock2也就變成了第一個節點，嘗試獲取所得時候就會獲取鎖成功。

image

這就是ZK分布式鎖的底層實現原理，內容還是挺多的，畢竟分布式鎖要求有一定并發度才會用到，對于一般的用戶群體不大的根本就不會涉及到，所以第一次接觸的肯定也是需要時間吸收的。

總結

三種方案的比較，從不同的角度看這三種實現方式，比較的結果也不一樣：

性能：緩存 > Zookeeper >= 數據庫。
可靠性：Zookeeper > 緩存 > 數據庫

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

分布式鎖（數據庫、Redis、ZK）拍了拍你

分布式鎖（數據庫、Redis、ZK）拍了拍你

前言

分布式鎖簡介

數據庫分布式鎖

Redis實現的分布式鎖

ZK實現的分布式鎖

總結

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

分布式鎖（數據庫、Redis、ZK）拍了拍你

前言

分布式鎖簡介

數據庫分布式鎖

Redis實現的分布式鎖

ZK實現的分布式鎖

總結

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频