緩存解決併發問題

1.如何解決高併發

1.1 高併發詳情頁處理

加服務器做集羣，使用nginx做負載均衡
使用緩存，減少數據庫的IO操作
限流、熔斷、降級

1.2 緩存使用的思路

連接緩存
查詢緩存
如果緩存中沒有，查詢mysql
mysql查詢結果存入redis

1.3 數據存儲策略

企業中的存儲策略（核心就是，設計key）

數據對象名：數據對象id：對象屬性

User:123:passpword

User:123:username

Sku:108:info

1.4 思考:緩存問題

緩存穿透
緩存擊穿
緩存雪崩
緩存數據和數據庫同步的問題
緩存key的過期時間
使用redis實現分佈式鎖
分佈式鎖另一種 redisson框架

2.springboot整合redis

2.1 數據類型

Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

2.2 緩存redis整合

spring工廠式整合方式.

【設計模式：工廠模式】

2.2.1 加入依賴

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

2.2.2 寫一個reids的工具類(用來將redis的池初始化到spring容器中)

public class RedisUtil {
    private  JedisPool jedisPool;
    public void initPool(String host,int port ,int database){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(30);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMaxWaitMillis(10*1000);
        poolConfig.setTestOnBorrow(true);
        jedisPool=new JedisPool(poolConfig,host,port,20*1000);
    }
    public Jedis getJedis(){
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }
}

2.2.3 寫一個spring整合redis的配置類

將redis的鏈接池創建到spring的容器中

@Configuration
public class RedisConfig {
    //讀取配置文件中的redis的ip地址
    @Value("${spring.redis.host:disabled}")
    private String host = “192.168.222.20”;
    @Value("${spring.redis.port:0}")
    private int port = “6179”;
    @Value("${spring.redis.database:0}")
    private int database;
    
    @Bean
    public RedisUtil getRedisUtil(){
        if(host.equals("disabled")){
            return null;
        }
        RedisUtil redisUtil=new RedisUtil();
        redisUtil.initPool(host,port,database);
        return redisUtil;
    }
}

@ComponentScan(value = {"com.atguigu.gmall.config"})
//記得要注入到spring容器中

2.3.4 補充:

springboot整合redis

1.導入jar包依賴

<!-- springboot整合redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.加入redis配置

#redis
# Redis數據庫索引（默認爲0）
spring.redis.database=0
# Redis服務器地址
spring.redis.host=192.168.3.159
# Redis服務器連接端口
spring.redis.port=6379
# Redis服務器連接密碼（默認爲空）
spring.redis.password=
# 連接池最大連接數（使用負值表示沒有限制）
spring.redis.pool.max-active=2000
# 連接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.pool.max-wait=6000
# 連接池中的最大空閒連接
spring.redis.pool.max-idle=300
# 連接池中的最小空閒連接
spring.redis.pool.min-idle=100
# 連接超時時間（毫秒）
spring.redis.timeout=30000

3.RedisUtils

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

//TODO 不用寫Redisconfig配置類   

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /*
     * 指定緩存失效時間
     * @param key 鍵
     * @param time 時間(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根據key 獲取過期時間
     *
     * @param key 鍵 不能爲null
     * @return 時間(秒) 返回0代表爲永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 53
     * 判斷key是否存在
     * 54
     *
     * @param key 鍵
     *            55
     * @return true 存在 false不存在
     * 56
     */

    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 刪除緩存
     *
     * @param key 可以傳一個值 或多個
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

//============================String=============================

    /**
     * 普通緩存獲取
     *
     * @param key 鍵
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通緩存放入
     *
     * @param key   鍵
     * @param value 值
     * @return true成功 false失敗
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通緩存放入並設置時間
     *
     * @param key   鍵
     * @param value 值
     * @param time  時間(秒) time要大於0 如果time小於等於0 將設置無限期
     * @return true成功 false 失敗
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 遞增
     *
     * @param key   鍵
     * @param delta 要增加幾(大於0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("遞增因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 遞減
     *
     * @param key   鍵
     * @param delta 要減少幾(小於0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("遞減因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  鍵 不能爲null
     * @param item 項 不能爲null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 獲取hashKey對應的所有鍵值
     *
     * @param key 鍵
     * @return 對應的多個鍵值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 鍵
     * @param map 對應多個鍵值
     * @return true 成功 false 失敗
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 並設置時間
     *
     * @param key  鍵
     * @param map  對應多個鍵值
     * @param time 時間(秒)
     * @return true成功 false失敗
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一張hash表中放入數據,如果不存在將創建
     *
     * @param key   鍵
     * @param item  項
     * @param value 值
     * @return true 成功 false失敗
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一張hash表中放入數據,如果不存在將創建
     *
     * @param key   鍵
     * @param item  項
     * @param value 值
     * @param time  時間(秒) 注意:如果已存在的hash表有時間,這裏將會替換原有的時間
     * @return true 成功 false失敗
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 刪除hash表中的值
     *
     * @param key  鍵 不能爲null
     * @param item 項 可以使多個 不能爲null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判斷hash表中是否有該項的值
     *
     * @param key  鍵 不能爲null
     * @param item 項 不能爲null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash遞增 如果不存在,就會創建一個 並把新增後的值返回
     *
     * @param key  鍵
     * @param item 項
     * @param by   要增加幾(大於0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash遞減
     *
     * @param key  鍵
     * @param item 項
     * @param by   要減少記(小於0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根據key獲取Set中的所有值
     *
     * @param key 鍵
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根據value從一個set中查詢,是否存在
     *
     * @param key   鍵
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將數據放入set緩存
     *
     * @param key    鍵
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 將set數據放入緩存
     *
     * @param key    鍵
     * @param time   時間(秒)
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 獲取set緩存的長度
     *
     * @param key 鍵
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值爲value的
     *
     * @param key    鍵
     * @param values 值 可以是多個
     * @return 移除的個數
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 獲取list緩存的內容
     *
     * @param key   鍵
     * @param start 開始
     * @param end   結束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 獲取list緩存的長度
     *
     * @param key 鍵
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通過索引 獲取list中的值
     *
     * @param key   鍵
     * @param index 索引 index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 將list放入緩存
     *
     * @param key   鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     *
     * @param key   鍵
     * @param value 值
     * @param time  時間(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     *
     * @param key   鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     *
     * @param key   鍵
     * @param value 值
     * @param time  時間(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根據索引修改list中的某條數據
     *
     * @param key   鍵
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N個值爲value
     *
     * @param key   鍵
     * @param count 移除多少個
     * @param value 值
     * @return 移除的個數
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

3、緩存問題

3.1 緩存穿透

是利用redis和mysql機制(redis緩存一旦不存在，就訪問mysql),直接繞過緩存訪問mysql，而直到的db請求壓力.一般在代碼中防止該現象發生。

穿透:利用不存在的key,繞過redis直接攻擊db ----將空值存入到redis

@Autowired
RedisUtil redisUtil;

@Override
public PmsSkuInfo findSkuInfo(String skuId) { 
    //TODO SkuServiceImpl : 記得處理數據同步問題。
        PmsSkuInfo pmsSkuInfo = null;
        //連接緩存
        Jedis jedis = redisUtil.getJedis();
        //查詢緩存
        String skuKey = "sku:"+skuId+":info";  //TODO 寫在常量類中，或者配置文件中
        String skuJson = jedis.get(skuKey);
        if(StringUtils.isNotBlank(skuJson)){
            pmsSkuInfo = JSON.parseObject(skuJson,PmsSkuInfo.class);
            return pmsSkuInfo;
        }

        //mysql查詢結果存入redis中 --------------------
        String lockKey = "sku:"+skuId+":lock";
        //設置分佈式鎖   如果不加過期時間會出現死鎖現象
        String ok = jedis.set(lockKey, "1", "nx", "px", 10*1000/*拿到鎖的線程有10s過期時間*/);
        if(StringUtils.isNotBlank(ok)&&ok.equals("OK")){
            //設置成功，有權在10秒的過期時間內訪問數據
            pmsSkuInfo = getSkuInfoFromDb(skuId);
            if(pmsSkuInfo !=null){
                jedis.set(skuKey,JSON.toJSONString(pmsSkuInfo));
            }else{
                //數據庫中不存在該sku
                //爲了防止緩存穿透，將null 或者空字符串設置給redis
                jedis.setex(skuKey,60*3,JSON.toJSONString(""));

            }
            //TODO 從數據庫查詢到了數據 和沒有查詢到數據 之後需要釋放鎖釋放鎖
            jedis.del(lockKey);

        }else{
            //設置失敗  自旋:該線程在睡眠幾秒後，重寫嘗試訪問。
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //TODO 注意這裏的return ,如果不加return,程序會重新開啓一個線程，和當前線程沒有關係。
            //return 一種結束方法  另一種返回
           return findSkuInfo(skuId);

        }
      //--------------------------------------------
        jedis.close();
        return pmsSkuInfo;
}

3.2 緩存擊穿

是某一個熱點key在高併發訪問的情況下，突然失效，導致大量的併發打進mysql數據庫的情況

解決:Redis分佈式鎖。

擊穿:熱點key失效，大量的併發打進mysql數據庫。----分佈式鎖

3.3 緩存雪崩

緩存時採用了相同的過期時間，導致緩存在某一時刻同時失效，導致的db崩潰

解決：設置不同的緩存失效時間

雪崩：很多key集體失效，導致數據庫負載過重宕機。----設置不同的緩存失效時間

3.4 區別

共同點：緩存失效,直接打進mysql。

不同的:

穿透:利用不存在的key,繞過redis直接攻擊db ----將空值存入到redis
擊穿:熱點key失效。----分佈式鎖
雪崩：很多key集體失效，導致數據庫負載過重宕機。----設置不同的緩存失效時間

緩存失效，使用分佈式鎖，限制對mysql請求。

4.分佈式鎖

第一種分佈式鎖:Redis自帶一個分佈式鎖,set ex nx
第二種分佈式鎖:redisson 一個redis的帶有juc的lock功能的客戶端的實現(既有jedis的功能，又有juc的鎖功能)

核心:節點唯一,zk分佈式鎖也是這個原理

4.1 Redis分佈式鎖

redis命令參考

setnx命令,只在鍵不存在時，纔對鍵進行設置操作

setnx ----上鎖，那麼什麼時候釋放鎖了。

set sku:107:info 1 px 1000 nx

sku:107:info表示key

1表示value

px:設置過期時間，單位爲毫秒 , 1000ms

刪除key:del sku:107:info

value 使用一個唯一值。

  @Autowired
    RedisUtil redisUtil;

    @Override
    public PmsSkuInfo findSkuInfo(String skuId)  {
        //TODO SkuServiceImpl : 記得處理數據同步問題。
        PmsSkuInfo pmsSkuInfo = null;
        //連接緩存
        Jedis jedis = redisUtil.getJedis();
        //查詢緩存
        String skuKey = "sku:"+skuId+":info";  //TODO 寫在常量類中，或者配置文件中
        String skuJson = jedis.get(skuKey);
        if(StringUtils.isNotBlank(skuJson)){
            pmsSkuInfo = JSON.parseObject(skuJson,PmsSkuInfo.class);
            return pmsSkuInfo;
        }
        String token = UUID.randomUUID().toString();// 爲了防止刪除鎖刪除錯誤。
        //mysql查詢結果存入redis中 --------------------
        String lockKey = "sku:"+skuId+":lock";
        //設置分佈式鎖   如果不加過期時間會出現死鎖現象
        String ok = jedis.set(lockKey, token, "nx", "px", 10*1000/*拿到鎖的線程有10s過期時間*/);
        if(StringUtils.isNotBlank(ok)&&ok.equals("OK")){
            //設置成功，有權在10秒的過期時間內訪問數據
            pmsSkuInfo = getSkuInfoFromDb(skuId);
            if(pmsSkuInfo !=null){
                jedis.set(skuKey,JSON.toJSONString(pmsSkuInfo));
            }else{
                //數據庫中不存在該sku
                //爲了防止緩存穿透，將null 或者空字符串設置給redis
                jedis.setex(skuKey,60*3,JSON.toJSONString(""));
            }
            //TODO 從數據庫查詢到了數據 和沒有查詢到數據 之後需要釋放鎖釋放鎖;
            String lockToken = jedis.get(lockKey);
            if(StringUtils.isNotBlank(lockToken)&&lockToken.equals(token)){//TODO 使用鎖的value 唯一值，是爲了在刪除分佈式鎖的時候是刪除的是自己的鎖。

                //TODO 使用lua 腳本，在查詢到key的同時刪除該key，防止高併發下的意外的發生
                String script ="if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                jedis.eval(script, Collections.singletonList("lockKey"),Collections.singletonList(token));

                jedis.del(lockKey); //TODO 執行到132行的時候，鎖過期了。  在get那個token 和刪除鎖有一個時間差。----解決方案lua腳本
            }

        }else{
            //設置失敗  自旋:該線程在睡眠幾秒後，重寫嘗試訪問。
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //TODO 注意這裏的return ,如果不加return,程序會重新開啓一個線程，和當前線程沒有關係。
            //return 一種結束方法  另一種返回
           return findSkuInfo(skuId);

        }
      //--------------------------------------------
        jedis.close();
        return pmsSkuInfo;
    }

4.1.1 問題

問題1 如果在redis中的鎖已經過期了，然後鎖過期的那個請求又執行完畢，回來刪鎖,刪除了其他線程的鎖，怎麼辦？
```
通過鎖的value的唯一性，在刪除的時候，獲取自己當前鎖key對應的value，通過它進行判斷。
```
問題2 如果碰巧在查詢redis鎖還沒刪除的時候，正在網絡傳輸時，鎖過期了怎麼辦？

lua腳本.lockKey
String script ="if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
jedis.eval(script, Collections.singletonList("lockKey"),Collections.singletonList(token));

4.2 分佈式鎖框架

https://github.com/redisson/redisson/wiki/1.-Overview

Redisson是一個在Redis的基礎上實現的java控制redis各種各樣的工具的集合，包括分佈式鎖和多線程。

4.2.1 整合

加入依賴

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.10.5</version>
</dependency>

加入配置

spring.redis.host=192.168.159.130
spring.redis.port=6379

加入配置類

@Configuration
public class GmallRedissonConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://"+host+":"+port);
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }
}

4.2.2 redisson鎖

可重入鎖ReentrantLock

基於Redis的Redisson分佈式可重入鎖RLock Java對象實現了java.util.concurrent.locks.Lock接口。同時還提供了異步（Async）、反射式（Reactive）和RxJava2標準的接口。

Redisson實現了juc的lock鎖，並且可以在分佈式的redis環境下使用

redisson默認給的是重入鎖。

/**
 * 測試Redisson 的Demo
 */
@Controller
public class TestRedissonDemo {

    @Autowired
    RedisUtil redisUtil;

    @Autowired
    RedissonClient redissonClient;
    @RequestMapping("/testRedisson")
    @ResponseBody
    public String testRedisson(){
        RLock lock = redissonClient.getLock("anyLock");//anyLock 鎖的名稱
        lock.lock();
        
        
        lock.unlock();
        
        
      
        return "success";
    }

}

另外Redisson還通過加鎖的方法提供了leaseTime的參數來指定加鎖的時間。超過這個時間後鎖便自動解開了。
// 加鎖以後10秒鐘自動解鎖
// 無需調用unlock方法手動解鎖
lock.lock(10, TimeUnit.SECONDS);

// 嘗試加鎖，最多等待100秒，上鎖以後10秒自動解鎖
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}

1.緩存Redis實戰操作記錄

文章目錄