2. 程式人生 > >SpringMVC+Redis實現分散式鎖實現秒殺功能

SpringMVC+Redis實現分散式鎖實現秒殺功能

阿新 • • 發佈：2019-01-31

1.實現分散式鎖的幾種方案
1.Redis實現 (推薦)
2.Zookeeper實現
3.資料庫實現
Redis實現分散式鎖
*
* 在叢集等多伺服器中經常使用到同步處理一下業務，這是普通的事務是滿足不了業務需求，需要分散式鎖
*
* 分散式鎖的常用3種實現：
* 0.資料庫樂觀鎖實現
* 1.Redis實現 — 使用redis的setnx()、get()、getset()方法，用於分散式鎖，解決死鎖問題
* 2.Zookeeper實現
* 參考：

http://surlymo.iteye.com/blog/2082684
* http://www.jb51.net/article/103617.htm
* http://www.hollischuang.com/archives/1716?utm_source=tuicool&utm_medium=referral
* 1、實現原理：
基於zookeeper瞬時有序節點實現的分散式鎖，其主要邏輯如下（該圖來自於IBM網站）。大致思想即為：每個客戶端對某個功能加鎖時，在zookeeper上的與該功能對應的指定節點的目錄下，生成一個唯一的瞬時有序節點。判斷是否獲取鎖的方式很簡單，只需要判斷有序節點中序號最小的一個。當釋放鎖的時候，只需將這個瞬時節點刪除即可。同時，其可以避免服務宕機導致的鎖無法釋放，而產生的死鎖問題。
2、優點
鎖安全性高，zk可持久化
3、缺點
效能開銷比較高。因為其需要動態產生、銷燬瞬時節點來實現鎖功能。
4、實現
可以直接採用zookeeper第三方庫curator即可方便地實現分散式鎖
*
* Redis實現分散式鎖的原理：
* 1.通過setnx(lock_timeout)實現，如果設定了鎖返回1， 已經有值沒有設定成功返回0
* 2.死鎖問題：通過實踐來判斷是否過期，如果已經過期，獲取到過期時間get(lockKey)，然後getset(lock_timeout)判斷是否和get相同，
* 相同則證明已經加鎖成功，因為可能導致多執行緒同時執行getset(lock_timeout)方法，這可能導致多執行緒都只需getset後，對於判斷加鎖成功的執行緒，
* 再加expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS)過期時間，防止多個執行緒同時疊加時間，導致鎖時效時間翻倍
* 3.針對叢集伺服器時間不一致問題，可以呼叫redis的time()獲取當前時間
2.Redis分分散式鎖的程式碼實現
1.定義鎖介面

/**
 * @Description: Redis分散式鎖介面
 * @Author: fxb
 * @CreateDate: 2018/3/29 15:43
 * @Version: 1.0
 */
public interface RedisLockService {
    /**
     * 加鎖成功，返回加鎖時間
     * @param lockKey
     * @param threadName
     * @return
     */
    public Long  lock(String lockKey);

    /**
     * 解鎖， 需要更新加鎖時間，判斷是否有許可權
     * @param
 
 lockKey
     * @param lockValue
     * @param threadName
     */
    public void unlock(String lockKey, long lockValue);

    /**
     * 多伺服器叢集，使用下面的方法，代替System.currentTimeMillis()，獲取redis時間，避免多服務的時間不一致問題！！！
     * @return
     */
    public long currtTimeForRedis();
}

2、實現鎖實現

package com.jason.mrht.service.websrv.impl;

import com.jason.mrht.service.websrv.RedisLockService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @author fxb
 * @date 2018/3/29 15:43
 */
@Service
public class RedisLockServiceImpl extends BaseWebSrvService implements RedisLockService {

    /**
     * 加鎖超時時間，單位毫秒， 即：加鎖時間內執行完操作，如果未完成會有並發現象
     */
    private static final long LOCK_TIMEOUT = 5 * 1000;

    private static final Logger LOG = LoggerFactory.getLogger(RedisLockServiceImpl.class);

    /**
     * 取到鎖加鎖 取不到鎖一直等待直到獲得鎖
     */
    @Override
    public Long lock(final String lockKey) {
        LOG.info("開始執行加鎖");
        //迴圈獲取鎖
        while (true) {
            //鎖時間
            final Long lock_timeout = System.currentTimeMillis() + LOCK_TIMEOUT + 1;
            if (otherCache.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();
                    byte[] value = jdkSerializer.serialize(lock_timeout);
                    return connection.setNX(lockKey.getBytes(), value);
                }
            })) {
                //如果加鎖成功
                LOG.info("加鎖成功++++++++111111111");
                //設定超時時間，釋放記憶體
                otherCache.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
                return lock_timeout;
            } else {
                // redis裡的時間
                Long currt_lock_timeout_Str = (Long) otherCache.opsForValue().get(lockKey);
                //鎖已經失效
                if (currt_lock_timeout_Str != null && currt_lock_timeout_Str < System.currentTimeMillis()) {
                    // 判斷是否為空，不為空的情況下，說明已經失效，如果被其他執行緒設定了值，則第二個條件判斷是無法執行
                    Long old_lock_timeout_Str = (Long) otherCache.opsForValue().getAndSet(lockKey, lock_timeout);
                    // 獲取上一個鎖到期時間，並設定現在的鎖到期時間
                    if (old_lock_timeout_Str != null && old_lock_timeout_Str.equals(currt_lock_timeout_Str)) {
                        // 如過這個時候，多個執行緒恰好都到了這裡，但是隻有一個執行緒的設定值和當前值相同，他才有權利獲取鎖
                        LOG.info("加鎖成功+++++++2222222222");
                        //設定超時時間，釋放記憶體
                        otherCache.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
                        //返回加鎖時間
                        return lock_timeout;
                    }
                }
            }
            try {
                LOG.info("等待加鎖，睡眠100毫秒");
                //睡眠100毫秒
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void unlock(String lockKey, long lockvalue) {
        //正常直接刪除 如果異常關閉判斷加鎖會判斷過期時間
        LOG.info("執行解鎖==========");
        // redis裡的時間
        Long currt_lock_timeout_Str = (Long) otherCache.opsForValue().get(lockKey);
        //如果是加鎖者 則刪除鎖 如果不是則等待自動過期 重新競爭加鎖
        if (currt_lock_timeout_Str != null && currt_lock_timeout_Str == lockvalue) {
            //刪除鍵
            otherCache.delete(lockKey);
            LOG.info("解鎖成功-----------------");
        }
    }

    /**
     * 多伺服器叢集，使用下面的方法，代替System.currentTimeMillis()，獲取redis時間，避免多服務的時間不一致問題！！！
     *
     * @return
     */
    @Override
    public long currtTimeForRedis() {
        return otherCache.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.time();
            }
        });
    }

}

3.分散式鎖驗證

package com.jason.mrht.core.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 測試模組
 * @author bao
 */
@Controller
@RequestMapping("/api/redis")
public class TestController extends BaseController {

    /**
     * 秒殺商品數量10個
     */
    private int goodNum = 10;

    private static final String LOCK_NO = "redis_distribution_lock_no_";

    private static int i = 0;

    private int taskNum = 1000;

    /**
     * redis分散式鎖測試
     * 模擬1000個執行緒同時執行業務，修改資源
     */
    @ResponseBody
    @RequestMapping(value = "/redisLock", method = RequestMethod.GET)
    public String testRedisDistributionLock1() {
        /** task(); */
        for (int i = 0; i < taskNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    task();
                }
            }).start();
        }
        return "OK";
    }

    /**
     * 建立一個redis分散式鎖任務
     */
    private void task() {
        //加鎖時間
        Long lockTime;
        if ((lockTime = serviceTemplate.getRedisLockService().lock((LOCK_NO + 1) + "")) != null) {
            //開始執行任務
            logger.info("當前庫存的數量："+goodNum);
            if (goodNum == 0) {
                logger.info("停止減庫存任務");
            } else {
                goodNum--;
                logger.info("開始減庫存任務");
            }
            logger.info("任務執行中" + (i++));
            // 任務執行完畢 關閉鎖
            serviceTemplate.getRedisLockService().unlock((LOCK_NO + 1) + "", lockTime);
        }
    }

}

4.結果驗證：

  在Controller中模擬了1000個執行緒，通過執行緒池方式提交，每次20個執行緒搶佔分散式鎖，搶到分散式鎖的執行程式碼，沒搶到的等待
  模擬秒殺10個商品1000個人來爭奪

結果
5、模擬使用者的併發請求

package com.jason.mrht.common.utils;

/**
 * @Description: 類作用描述
 * @Author: fxb
 * @CreateDate: 2018/3/29 18:55
 * @Version: 1.0
 */

import com.jason.mrht.common.exception.HttpException;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;


/**
 * 模擬使用者的併發請求，檢測使用者樂觀鎖的效能問題
 *
 * @author zzg
 * @date 2017-02-10
 */
public class ConcurrentTest {

    final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args){
        //模擬10000人併發請求，使用者錢包
        CountDownLatch latch=new CountDownLatch(1);
        //模擬10000個使用者
        for(int i=0;i<10000;i++){
            AnalogUser analogUser = new AnalogUser("user"+i,"58899dcd-46b0-4b16-82df-bdfd0d953bfb"+i,"1","20.024",latch);
            analogUser.start();
        }
        //計數器減一  所有執行緒釋放 併發訪問。
        latch.countDown();
        System.out.println("所有模擬請求結束  at "+sdf.format(new Date()));

    }

    static class AnalogUser extends Thread{
        //模擬使用者姓名
        String workerName;
        String openId;
        String openType;
        String amount;
        CountDownLatch latch;

        public AnalogUser(String workerName, String openId, String openType, String amount,
                          CountDownLatch latch) {
            super();
            this.workerName = workerName;
            this.openId = openId;
            this.openType = openType;
            this.amount = amount;
            this.latch = latch;
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                latch.await(); //一直阻塞當前執行緒，直到計時器的值為0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            post();//傳送post 請求


        }

        public void post(){
            String result = "";
            System.out.println("模擬使用者： "+workerName+" 開始傳送模擬請求  at "+sdf.format(new Date()));
            try {


            result = HttpUtil.sendGet("http://localhost:8080/api/collect/distribution/redis/lock1",null);
            }catch (HttpException e){

            }
                    //sendPost("http://localhost:8080/Settlement/wallet/walleroptimisticlock.action", "openId="+openId+"&openType="+openType+"&amount="+amount);
            System.out.println("操作結果："+result);
            System.out.println("模擬使用者： "+workerName+" 模擬請求結束  at "+sdf.format(new Date()));

        }
    }

}

相關推薦

SpringMVC+Redis實現分散式鎖實現秒殺功能

1.實現分散式鎖的幾種方案 1.Redis實現 (推薦) 2.Zookeeper實現 3.資料庫實現 Redis實現分散式鎖 * * 在叢集等多伺服器中經常使用到同步處理一下業務，這是普通的事務是滿足不了業務需求，需要分散

dubbo 常用的基於redis的分散式鎖實現

  小弟本著先會用在學習原理的原則 先用了dubbo 現在在實際業務中 因為分散式專案做了叢集，需要用的分散式鎖，就用到了基於redis的分散式鎖，廢話不多說，先來程式碼： package com.tiancaibao.utils; import org.slf4j.Logger

基於 Redis 的分散式鎖實現及踩坑案例

關於分散式鎖的實現，目前常用的方案有以下三類：資料庫樂觀鎖；基於分散式快取實現的鎖服務，典型代表有 Redis 和基於 Redis 的 RedLock；基於分散式一致性演算法實現的鎖服務，典型代表有 ZooKeeper、Chubby 和 ETCD。本場 Chat 將介紹基於

架構師日記——基於redis的分散式鎖實現

很久之前有講過併發程式設計中的鎖 併發程式設計的鎖機制：synchronized和lock 。在單程序的系統中，當存在多個執行緒可以同時改變某個變數時，就需要對變數或程式碼塊做同步，使其在修改這種變數時能夠線性執行消除併發修改變數。而同步的本質是通過鎖來實現的。為了實現多個執行緒在一個時

【redis學習之五】基於redis的分散式鎖實現

    在單個JVM中，我們可以很方便的用sychronized或者reentrantLock在資源競爭時進行加鎖，保證高併發下資料執行緒安全。但是若是分散式環境下，多個JVM同時對一個資源進行競爭時，我們該如何保證執行緒安全呢？分散式鎖便能實現我們的要求。   &n

分散式鎖（一）：基於redis的分散式鎖實現

隨著業務越來越複雜，應用服務都會朝著分散式、叢集方向部署，而分散式CAP原則告訴我們，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分割槽容錯性），三者不可得兼。很多場景中，需要使用分散式事務、分散式鎖等技術來

springboot通過redis實現分散式鎖實現並呼叫

import org.springframework.data.redis.core.RedisTemplate; public class RedisLock {     private RedisTemplate redisTemplate;     /**    

基於redis的分散式鎖實現

隨著業務越來越複雜，應用服務都會朝著分散式、叢集方向部署，而分散式CAP原則告訴我們，Consistency（一致性）、 Avai

Redis之分散式鎖實現

點贊再看，養成習慣，微信搜尋【三太子敖丙】關注這個網際網路苟且偷生的工具人。 本文 GitHub https://github.com/JavaFamily 已收錄，有一線大廠面試完整考點、資料以及我的系列文章。 前言 上一章節我提到了基於zk分散式鎖的實現，這章節就來說一下基於Redis的分散式鎖實

Redis分散式鎖 實現秒殺系統 SET命令實現

基於Redis命令：SET key valueNX EX max-lock-time   可適用於redis單機和redis叢集模式 1.SET命令是原子性操作，NX指令保證只要當key不存在時才會設定value 2.設定的value要有唯一性，來確保鎖不會被誤刪(

Redis分散式鎖實現簡單秒殺功能

這版秒殺只是解決瞬間訪問過高伺服器壓力過大,請求速度變慢，大大消耗伺服器效能的問題。 主要就是在高併發秒殺的場景下，很多人訪問時並沒有拿到鎖，所以直接跳過了。這樣就處理了多執行緒併發問題的同時也保證了伺服器的效能的穩定。 接下來我們使用redis的分散式鎖來進行枷鎖處理： 我們可以在進入下單的方法後將核

基於redis分散式鎖實現“秒殺”

最近在專案中遇到了類似“秒殺”的業務場景，在本篇部落格中，我將用一個非常簡單的demo，闡述實現所謂“秒殺”的基本思路。 業務場景 所謂秒殺，從業務角度看，是短時間內多個使用者“爭搶”資源，這裡的資源在大部分秒殺場景裡是商品；將業務抽象，技術角度看，秒殺就是

【Zookeeper】程式設計實戰之Zookeeper分散式鎖實現秒殺

1. Zookeeper簡述    我們要了解一樣技術，首先應該要到它的官網，因為官網的資訊一般都是最準確的，如下圖是Zookeeper官網對它的介紹。    從官網的介紹中，可以總結出，Zookeeper是一個集中式服務，它能夠實現高度可靠的分散式協調，可用於開發和維護開源

php結合redis實現高並發下的搶購、秒殺功能

緩存 使用 fclose rtl global 簡單模擬 解決 fun 非阻塞 搶購、秒殺是如今很常見的一個應用場景，主要需要解決的問題有兩個： 1 高並發對數據庫產生的壓力 2 競爭狀態下如何解決庫存的正確減少（"超賣"問題） 對於第一個問題，已經很容易想到用緩存來處理搶

php+redis實現電商秒殺功能

str 數組 ash 參數設置 *** this 百萬 對數 現在 這一次總結和分享用Redis實現分布式鎖來完成電商的秒殺功能。先扯點個人觀點，之前我看了一篇博文說博客園的文章大部分都是分享代碼，博文裏強調說分享思路比分享代碼更重要（貌似大概是這個意思，若有誤請諒解），

實現基於redis的分散式鎖並整合spring-boot-starter

文章目錄 概述 使用 1.導包 2.寫一個實現鎖功能的service 3.檢查redis的key 4.呼叫（鎖成功） 5.呼叫（鎖失敗） 實現

springboot2結合redis，實現分散式鎖

1.新增Maven依賴 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId>

redis與zk實現分散式鎖

概述 分散式鎖，如果你有多個機器在訪問同一個共享資源， 那麼這個時候，如果你需要加個鎖，讓多個分散式的機器在訪問共享資源的時候序列起來 那麼這個時候，那個鎖，多個不同機器上的服務共享的鎖，就是分散式鎖 分散式鎖當然有很多種不同的實現方案，redis分散式鎖，

【redis】使用redisTemplate優雅地操作redis及使用redis實現分散式鎖

前言: 上篇已經介紹了redis及如何安裝和叢集redis,這篇介紹如何通過工具優雅地操作redis. Long Long ago,程式猿們還在通過jedis來操作著redis,那時候的猿類,一個個累的沒日沒夜,重複的造著輪子,忙得沒時間陪家人,終於有一天猿類的春天來了,spring家族的r

基於Redis實現分散式鎖

背景 在很多網際網路產品應用中，有些場景需要加鎖處理，比如：秒殺，全域性遞增ID，樓層生成等等。大部分的解決方案是基於DB實現的，Redis為單程序單執行緒模式，採用佇列模式將併發訪問變成序列訪問，且多客戶端對Redis的連線並不存在競爭關係。其次Redis提供一些命令SETNX，GETSET，可以方便