第 5 章 Redis
第 5 章 Redis
1、Redis 6.0.8
1.1、Redis 6.0.8 版本
官網地址
官網地址：https://redis.io/
中文官網地址：http://www.redis.cn/
為什么要使用 Redis 6.0.8
Redis突然發布了緊急版本 6.0.8 ，之前消息稱 6.0.7 被稱作最后一個 6.x 版本，但 Redis 團隊表示 6.0.8 版本升級迫切性等級為高：任何將 Redis 6.0.7 與 Sentinel 或 CONFIG REWRITE 命令配合使用的人都會受到影響，應盡快升級。
從官方給出的信息來看，估計是出現了Bug，具體更新的內容如下：
1、Bug修復
2、新功能
3、模塊化API
添加RedisModule_ThreadSafeContextTryLock。
1.2、安裝 Redis 6.0.8
參考資料
在 Linux 下安裝 Redis 6.0.8 版本
1、查看 gcc 版本
由于 redis 是用 C 語言開發，安裝之前必先確認是否安裝 gcc 環境（gcc -v），如果沒有安裝，執行以下命令進行安裝，我本機版本為 4.8.5，很明顯不符合 redis 6.0.8 版本的要求
注意：當你下載redis最新版本6.0.8的時候會發現make的時候會報錯，簡單來說就是最新版的redis用到了c11 ，你的系統gcc版本低了，系統自帶gcc版本是4.8.5，只需要更新下gcc到5.4以上即可，同時編譯redis時帶上gcc版本的使用參數，不影響系統自帶gcc！
[heygo@localhost redis-6.0.8]$ gcc -v 使用內建 specs。 COLLECT_GCC=gcc COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/lto-wrapper 目標：x86_64-redhat-linux 配置為：../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-linker-hash-style=gnu --enable-languages=c,c++,objc,obj-c++,java,fortran,ada,go,lto --enable-plugin --enable-initfini-array --disable-libgcj --with-isl=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/isl-install --with-cloog=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/cloog-install --enable-gnu-indirect-function --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux 線程模型：posix gcc 版本 4.8.5 20150623 (Red Hat 4.8.5-44) (GCC)2、安裝 gcc 環境
使用 yum 更新 gcc，依次執行如下指令即可
yum -y install centos-release-scl yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils scl enable devtoolset-9 bash安裝后再次使用 gcc -v 查看本機 gcc 版本
[heygo@localhost redis-6.0.8]$ gcc -v Using built-in specs. COLLECT_GCC=gcc COLLECT_LTO_WRAPPER=/opt/rh/devtoolset-9/root/usr/libexec/gcc/x86_64-redhat-linux/9/lto-wrapper Target: x86_64-redhat-linux Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/opt/rh/devtoolset-9/root/usr --mandir=/opt/rh/devtoolset-9/root/usr/share/man --infodir=/opt/rh/devtoolset-9/root/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --with-default-libstdcxx-abi=gcc4-compatible --enable-plugin --enable-initfini-array --with-isl=/builddir/build/BUILD/gcc-9.3.1-20200408/obj-x86_64-redhat-linux/isl-install --disable-libmpx --enable-gnu-indirect-function --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux Thread model: posix gcc version 9.3.1 20200408 (Red Hat 9.3.1-2) (GCC)3、下載并解壓安裝包
使用 wget 命令下載 .tar.gz 壓縮包（我的天，太慢了，下次找鏡像），并使用 tar 指令將其解壓
wget http://download.redis.io/releases/redis-6.0.8.tar.gz tar -zxvf redis-6.0.8.tar.gz4、執行編譯
下載以及解壓的 Redis 安裝包位置如圖所示
cd 切換到 redis 解壓目錄下，執行編譯
cd redis-6.0.8/ make5、安裝 redis
將 redis 安裝到指定目錄
make install PREFIX=/usr/local/redis測試安裝是否成功
切換到 redis 安裝目錄下
cd /usr/local/redis/bin/啟動 redis 服務端
./redis-server通過 redis 客戶端連接 redis 服務端
./redis-cli -h 127.0.0.1 -p 6379能夠通過客戶端連接工具連接上 redis 服務器，則說明安裝成功
查看 redis 版本
1、在 Linux 命令行下：在 redis 安裝目錄下執行 redis-server -version 命令
2、在 redis 命令行下：執行 info 命令
1.3、安裝后的配置
設置 redis 服務后臺運行
從 redis 的源碼目錄中復制 redis.conf 到 redis 的安裝目錄
cp redis-6.0.8/redis.conf /usr/local/redis/bin/使用 vim 編輯器編輯 redis.conf 配置文件
vim /usr/local/redis/bin/redis.conf修改 redis.conf 文件，把 daemonize no 改為 daemonize yes
設置 redis 開機自啟動
使用 vim 編輯 /etc/systemd/system/redis.service 配置文件
vim /etc/systemd/system/redis.service添加如下配置：
[Unit] Description=redis-server After=network.target[Service] Type=forking ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/bin/redis.conf PrivateTmp=true[Install] WantedBy=multi-user.target1.4、Redis 命令大全
官網命令大全
直接搜索即可
注：命令不區分大小寫，而key是區分大小寫的，可使用 help @類型名詞 查看
2、Redis 基本數據類型
2.1、8 大類型
以前是 5 種數據類型，現在是 8 種啦~
2.2、string
獲取/設置單個值
設置：SET key value
獲取：SET key
注意事項：執行 redis 指令可能會出現如下錯誤：(error) MISCONF Redis is configured to save RDB snapshots, but it is currently not able to persist on disk. Commands that may modify the data set are disabled, because this instance is configured to report errors during writes if RDB snapshotting fails (stop-writes-on-bgsave-error option). Please check the Redis logs for details about the RDB error.
原因分析：究其原因是因為強制把 redis 快照關閉了導致不能持久化的問題，在網上查了一些相關解決方案，通過 stop-writes-on-bgsave-error 值設置為 no 即可避免這種問題。
解決方案一：通過 redis 命令行修改，在 redis 命令行執行 config set stop-writes-on-bgsave-error no 指令
解決方案二：直接修改 redis.conf 配置文件，使用 vim 編輯器打開 redis-server 配置的 redis.conf 文件，然后使用快捷匹配模式：/stop-writes-on-bgsave-error 定位到 stop-writes-on-bgsave-error 字符串所在位置，接著把后面的 yes 設置為 no 即可。
同時設置/獲取多個鍵值
設置：MSET key value [key value ....]
獲取：MGET key [key ....]
數值增減
遞增數字：INCR key
增加指定的整數：INCRBY key increment
遞減數值：DECR key
減少指定的整數：DECRBY key decrement
獲取字符串長度
字符串長度：STRLEN key
分布式鎖
設置分布式鎖：set key value [Ex seconds][PX milliseconds][NX|XX]
參數解釋：
應用場景
1、商品編號、訂單號采用 INCR 命令生成
2、文章閱讀量、點贊數和在看數
2.3、hash
獲取/設置單個字段值
redis 中的 hash 類似于 java 中的 Map<String,Map<Object,object>> 數據結構，即以字符串為 key，以 Map 對象為 value
添加一個 hash 對象：HSET key field value
獲取 hash 對象的字段值：HGET key field
同時設置/獲取多個字段值
添加多個 hash 對象：HMSET key field value [field value ...]
獲取多個 hash 對象的字段值：HMGET key field [field ....]
獲取所有字段值
獲取 key 所對應所有的 hash 對象：HGETALL key
獲取某個 key 內的全部數量
獲取 key 對應的所有 hash 對象個數：HLEN key
判斷是否存在
判斷字段名為 field 的 hash 對象是否存在：HEXISTS key field
刪除一個 key
刪除一個 hash 對象：HDEL key
數值增減
如何 key 和 field 不存在，則初始值為 0，否則在之前的數值上遞增：HINCRBY key field increment
應用場景
購物車早期版本，可在小中廠項目中使用
2.4、list
與其說 list 是個集合，還不如說 list 是個雙端隊列
添加元素 & 查看列表
刪除元素
獲取列表中元素的個數
查看 list 中包含幾個元素：LLEN key
應用場景
微信文章訂閱公眾號
2.5、set
添加元素 & 刪除元素 & 查看元素
判斷元素是否在集合中
判斷指定元素是否在 set 中：SISMEMBER key member
獲取集合中的元素個數
獲取 set 中元素的個數：SCARD key
從集合中隨機彈出元素
集合運算
應用場景
1、微信抽獎小程序
2、微信朋友圈點贊
3、Bilibili 共同關注的好友
共同關注的好友：SINTER 我關注的人 Ta關注的人
4、QQ內推可能認識的人
QQ 共同好友：SINTER 我的好友 Ta的好友
2.6、zset
形象理解 zset：向有序集合中加入一個元素和該元素的分數
添加元素 & 刪除元素 & 獲取元素
獲取元素的分數
獲取指定元素的分數：ZSCORE key member
獲取指定分數范圍的元素
獲取指定分數范圍的元素：ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
獲取集合中元素的數量
獲取集合中元素的數量：ZCARD key
獲得指定分數范圍內的元素個數
獲得指定分數范圍內的元素個數：ZCOUNT key min max
增加某個元素的分數
增加某個元素的分數：ZINCRBY key increment member
按照排名范圍刪除元素
按照排名范圍刪除元素：ZREMRANGEBYRANK key start stop
獲取元素的排名
從小到大：ZRANK key member
從大到小：ZREVRANK key member
應用場景
1、根據商品銷售對商品進行排序顯示
思路:定義商品銷售排行榜(sorted set集合)，key為goods:sellsort，分數為商品銷售數量。
2、抖音熱搜
點擊視頻增加播放量：ZINCRBY hotvcr:20200919 1八佰，ZINCRBY hotvcr:20200919 15 八佰 2 花木蘭
展示當日排行前10條：ZREVRANGE hotvcr:20200919 0 9 WITHSCORES
3、Redis 分布式鎖
面試官：中門來對狙
知道分布式鎖嗎？有哪些實現方案？ 你談談對redis分布式鎖的理解， 刪key的時候有什么問題？
3.1、分布式鎖的面試題
分布式鎖的常見面試題
Redis除了拿來做緩存，你還見過基于Redis的什么用法?
Redis做分布式鎖的時候有需要注意的問題?
如果是Redis是單點部署的，會帶來什么問題? 那你準備怎么解決單點問題呢?
集群模式下，比如主從模式，有沒有什么問題呢?
那你簡單的介紹一下Redlock吧? 你簡歷上寫redisson，你談談
Redis分布式鎖如何續期?看門狗知道嗎?
3.2、搭建超賣工程
3.2.1、CentOS 固定 IP 地址
準備工作：CentOS 固定 IP 設置
前言：本來不想配置，結果睡了一覺起來，CentOS 的 IP 地址就變了
參考資料：
1、設置虛擬機的網絡連接方式為 NAT 模式
2、配置虛擬機 NAT 模式的網絡參數
選擇【編輯】–>【虛擬網絡編輯器】，點擊【更改設置】
選擇【NAT 模式】的 VMnet8
喏，點擊【NAT 設置】查看子網網關（不要改這個設置，我改了就把我自己害慘了。。。）
3、修改 CentOS 網卡對應的配置文件
centos7 的網絡 IP 地址配置文件在 /etc/sysconfig/network-scripts 文件夾下，使用 ifconfig 命令查看當前網卡名稱：ens33
ens33 網卡對應的配置文件為 ifcfg-ens33
使用 vim ifcfg-ens33 指令編輯配置文件，填入如下配置內容（如果有就修改，沒有就新增）
BOOTPROTO=static #開機協議，有dhcp及static； ONBOOT=yes #設置為開機啟動； DNS1=114.114.114.114 #這個是國內的DNS地址，是固定的； IPADDR=192.168.152.233 #你想要設置的固定IP，理論上192.168.2.2-255之間都可以，請自行驗證； NETMASK=255.255.255.0 #子網掩碼，不需要修改； GATEWAY=192.168.152.5 #網關地址完整的配置如下，下次用的時候就可以直接復制粘貼啦
TYPE=Ethernet PROXY_METHOD=none BROWSER_ONLY=no BOOTPROTO=static DEFROUTE=yes IPV4_FAILURE_FATAL=no IPV6INIT=yes IPV6_AUTOCONF=yes IPV6_DEFROUTE=yes IPV6_FAILURE_FATAL=no IPV6_ADDR_GEN_MODE=stable-privacy NAME=ens33 UUID=b15652db-78af-49cc-8f4e-ff601a1d5c5d DEVICE=ens33 ONBOOT=yes DNS1=114.114.114.114 IPADDR=192.168.152.233 NETMASK=255.255.255.0 GATEWAY=192.168.152.24、重啟生效
使用 service network restart 重啟網絡服務，然后使用 ifconfig 命令查看本機 IP 地址，已經變為 192.168.152.233
在 CentOS 中能夠 ping 通 Windows
在 Windows 中也能 ping 通 CentOS
3.2.2、超賣工程測試說明
Redis 分布式鎖測試說明
測試目的：多個服務間保證同一時刻同一時間段內同一用戶只能有一個請求(防止關鍵業務出現并發攻擊)
兩個 Module：boot_redis01 和 boot_redis02
3.2.3、搭建 SpringBoot 工程
搭建 SpringBoot 工程的步驟
boot_redis01 工程
修改 pom.xnl 文件
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.3.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><modelVersion>4.0.0</modelVersion><groupId>com.oneby</groupId><artifactId>boot_redis01</artifactId><version>1.0-SNAPSHOT</version><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!-- https://mvnrepository.com/artifact/redis.clients/jedis --><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.1.0</version></dependency><!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><!-- https://mvnrepository.com/artifact/org.redisson/redisson --><dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.13.4</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>新建 application.properties 配置文件
server.port=1111spring.redis.database=0 spring.redis.host= spring.redis.port=6379 #連接池最大連接數（使用負值表示沒有限制）默認8 spring.redis.lettuce.pool.max-active=8 #連接池最大阻塞等待時間（使用負值表示沒有限制）默認-1 spring.redis.lettuce.pool.max-wait=-1 #連接池中的最大空閑連接默認8 spring.redis.lettuce.pool.max-idle=8 #連接池中的最小空閑連接默認0 spring.redis.lettuce.pool.min-idle=0新建 BootRedis01Application 主啟動類
/*** @ClassName BootRedis01Application* @Description TODO* @Author Oneby* @Date 2021/2/2 18:54* @Version 1.0*/ @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) public class BootRedis01Application {public static void main(String[] args) {SpringApplication.run(BootRedis01Application.class);} }新建 RedisConfig 配置類，用于獲取 RedisTemplate 對象
/*** @ClassName RedisConfig* @Description TODO* @Author Oneby* @Date 2021/2/2 18:55* @Version 1.0*/ @Configuration public class RedisConfig {@Beanpublic RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory){// 新建 RedisTemplate 對象，key 為 String 對象，value 為 Serializable（可序列化的）對象RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();// key 值使用字符串序列化器redisTemplate.setKeySerializer(new StringRedisSerializer());// value 值使用 json 序列化器redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());// 傳入連接工廠redisTemplate.setConnectionFactory(connectionFactory);// 返回 redisTemplate 對象return redisTemplate;}}新建 GoodController 業務類，用于販賣商品
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;}}boot_redis02 工程
boot_redis02 工程的端口號為 2222，其他配置均與 boot_redis01 相同
3.2.4、Demo 工程代碼測試
代碼測試
拋異常：Unable to connect to Redis
啟動 SpringBoot 應用，二話不說直接拋了個異常：org.springframework.data.redis.RedisConnectionFailureException: Unable to connect to Redis; nested exception is org.springframework.data.redis.connection.PoolException: Could not get a resource from the pool; nested exception is io.lettuce.core.RedisConnectionException: Unable to connect to 192.168.152.233:6379，
重點看：Unable to connect to Redis，明明 IP 地址和端口號都配置正確了，還連接不上，就要考慮是防火墻的問題了~
解決問題：關閉 CentOS 防火墻
執行 systemctl stop firewalld.service 命令關閉 CentOS 防火墻，然后使用 systemctl status firewalld.service 查看防火墻狀態，出現 dead 字樣就表示防火墻已經關閉
PS：上面的方法，一旦重啟操作系統，防火墻就自動開啟了，該怎么設置才能永久關閉防火墻呢？使用 systemctl disable firewalld.service 命令可禁用防火墻
再次拋異常：DENIED Redis is running in protected mode because protected mode is enabled
當訪問頁面時，二話不說又直接拋了個異常：io.lettuce.core.RedisConnectionException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface. If you want to connect from external computers to Redis you may adopt one of the following solutions: 1) Just disable protected mode sending the command 'CONFIG SET protected-mode no' from the loopback interface by connecting to Redis from the same host the server is running, however MAKE SURE Redis is not publicly accessible from internet if you do so. Use CONFIG REWRITE to make this change permanent. 2) Alternatively you can just disable the protected mode by editing the Redis configuration file, and setting the protected mode option to 'no', and then restarting the server. 3) If you started the server manually just for testing, restart it with the '--protected-mode no' option. 4) Setup a bind address or an authentication password. NOTE: You only need to do one of the above things in order for the server to start accepting connections from the outside.
Redis protected-mode 是3.2 之后加入的新特性，在 Redis.conf 的注釋中，我們可以了解到，他的具體作用和啟用條件。鏈接 redis 時只能通過本地 localhost（127.0.0.1）這個來鏈接，而不能用網絡 ip（192.168…）這個鏈接，如果用網絡 ip 鏈接會報錯
我們需要去修改 redis.conf 配置文件：將 protected-mode 字段設置為 no，將 bind 字段的配置注釋掉
解決問題：將 protected-mode 字段設置為 no
打開 redis.conf 配置文件，將 protected-mode 字段設置為 no
接著將 bind 字段的配置注釋掉
使用 ps aux | grep redis 命令查找 redis 相關的后臺服務，并使用 kill -9 進程ID 關閉 redis 后臺進程，然后重啟 redis 服務
再再次拋異常：MISCONF Redis is configured to save RDB snapshots, but it is currently not able to persist on disk
當訪問頁面時，二話不說又又直接拋了個異常：io.lettuce.core.RedisCommandExecutionException: MISCONF Redis is configured to save RDB snapshots, but it is currently not able to persist on disk. Commands that may modify the data set are disabled, because this instance is configured to report errors during writes if RDB snapshotting fails (stop-writes-on-bgsave-error option). Please check the Redis logs for details about the RDB error.
嗨呀，好熟悉的異常，這不是之前見到過的嘛~究其原因是因為強制把 redis 快照關閉了導致不能持久化的問題，通過將 stop-writes-on-bgsave-error 字段的值設置為 no 即可避免這種問題。
**解決問題：將 stop-writes-on-bgsave-error 字段的值設置為 no **
打開 redis.conf 配置文件，將 stop-writes-on-bgsave-error 字段的值設置為 no，然后重啟 redis 服務
代碼測試
在 Windows 瀏覽器中訪問 http://192.168.1.6:1111/buy_goods 和 http://192.168.1.6:2222/buy_goods 能得到如下結果
在 CentOS 瀏覽器中訪問 http://192.168.1.6:1111/buy_goods 和 http://192.168.1.6:2222/buy_goods 能得到如下結果
3.3、測試 & 找茬
3.3.1、單機版
1、單機版程序沒加鎖存在什么問題？
問題：單機版程序沒有加鎖，在并發測試下數字不對，會出現超賣現象
解決：加鎖，那么問題又來了，加 synchronized 鎖還是 ReentrantLock 鎖呢？
如何選擇：根據業務需求來選，如果非要搶到鎖不可，就使用 synchronized 鎖；如果可以暫時放棄鎖，等會再來強，就使用 ReentrantLock 鎖
2.0 版本的代碼：使用 synchronized 鎖保證單機版程序在并發下的安全性
Ctrl + Alt + T ，用 synchronized 鎖將方法體中的代碼包裹起來
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 2.0*/ @RestController public class GoodController {@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {synchronized (this) {// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;}}}注意事項
在單機環境下，可以使用 synchronized 鎖或 Lock 鎖來實現。
但是在分布式系統中，因為競爭的線程可能不在同一個節點上（同一個 jvm 中），所以需要一個讓所有進程都能訪問到的鎖來實現，比如 redis 或者 zookeeper 來構建;
不同進程 jvm 層面的鎖就不管用了，那么可以利用第三方的一個組件，來獲取鎖，未獲取到鎖，則阻塞當前想要運行的線程
3.3.2、分布式版
2、分布式部署之后，單機版的鎖失效
問題：
分布式部署之后，單機版的鎖失效，單機版的鎖還是會導致超賣現象，這時就需要需要分布式鎖
如下，在我們的兩個微服務之上，擋了一個 nginx 服務器，用于實現負載均衡的功能
安裝 nginx
哈哈，我還沒學過 nginx，那就現學現賣一波吧，參考資料：CentOS7安裝nginx、centOS7安裝nginx及nginx配置
1、安裝 gcc
安裝 nginx 需要先將官網下載的源碼進行編譯，編譯依賴 gcc 環境，如果沒有 gcc 環境，則需要安裝：
yum install gcc-c++2、PCRE pcre-devel 安裝
PCRE（Perl Compatible Regular Expressions）是一個 Perl 庫，包括 perl 兼容的正則表達式庫。nginx 的 http 模塊使用 pcre 來解析正則表達式，所以需要在 linux 上安裝 pcre 庫，pcre-devel 是使用 pcre 開發的一個二次開發庫。nginx也需要此庫。安裝命令為：
yum install -y pcre pcre-devel3、zlib 安裝
zlib 庫提供了很多種壓縮和解壓縮的方式， nginx 使用 zlib 對 http 包的內容進行 gzip ，所以需要在 CentOS 上安裝 zlib 庫。
yum install -y zlib zlib-devel4、OpenSSL 安裝
OpenSSL 是一個強大的安全套接字層密碼庫，囊括主要的密碼算法、常用的密鑰和證書封裝管理功能及 SSL 協議，并提供豐富的應用程序供測試或其它目的使用。nginx 不僅支持 http 協議，還支持 https（即在ssl協議上傳輸http），所以需要在 Centos 安裝 OpenSSL 庫。
5、下載 nginx 安裝包
使用 wget 命令下載 nginx 安裝包，確保系統已經安裝了wget，如果沒有安裝，執行 yum install wget 安裝
wget -c https://nginx.org/download/nginx-1.12.0.tar.gz6、解壓安裝包
使用 tar -zxvf 指令解壓下載好的安裝包，并進入解壓后的目錄
tar -zxvf nginx-1.12.0.tar.gz cd nginx-1.12.07、配置 nginx
其實在 nginx-1.12.0 版本中你就不需要去配置相關東西，默認就可以了。當然，如果你要自己配置目錄也是可以的。我這里采用默認配置，在 nginx 安裝包目錄下執行如下指令：
./configure執行完 ./configure 命令之后會生成 Makefile 文件，我們編譯安裝程序就需要它
8、編譯 & 安裝
make 和 make install 打一套
make make install9、查看 nginx 安裝目錄
使用 whereis nginx 命令查看 nginx 的默認安裝目錄
啟動 nginx
首先進入 nginx 安裝目錄下的可執行文件存放的目錄
cd /usr/local/nginx/sbin/啟動 nginx
./nginx # 啟動 nginx 服務器 ./nginx -s stop # 此方式相當于先查出nginx進程id再使用kill命令強制殺掉進程。 ./nginx -s quit # 此方式停止步驟是待nginx進程處理任務完畢進行停止。 ./nginx -s reload # 重啟nginx服務訪問 http://localhost/（nginx 默認是 80 端口），如出現如下頁面則說明啟動成功
nginx 的其他細節
查詢 nginx 進程：
ps aux|grep nginx**重啟 nginx **
1、先停止再啟動（推薦）：
對 nginx 進行重啟相當于先停止再啟動，即先執行停止命令再執行啟動命令。如下：
./nginx -s quit ./nginx2、重新加載配置文件：
當 nginx 的配置文件 nginx.conf 修改后，要想讓配置生效需要重啟 nginx，使用-s reload 可以不用停止 nginx 服務，即可將配置信息在 nginx 中生效，如下：
./nginx -s reload指定啟動配置文件
在 nginx 命令后帶上 -c 參數，并跟上配置文件的路徑即可
/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.confnginx 配置負載均衡
1、編寫配置文件
首先進入 /usr/local/nginx/conf/，該文件中包含 nginx 的配置文件：nginx.conf
cd /usr/local/nginx/conf/使用 vim nginx.conf 命令編輯配置文件
#gzip on;upstream mynginx{server 192.168.1.6:1111 weight=1;server 192.168.1.6:2222 weight=1;}server {listen 80;server_name localhost;#charset koi8-r;#access_log logs/host.access.log main;location / {#root html;proxy_pass http://mynginx;index index.html index.htm;}#error_page 404 /404.html;# redirect server error pages to the static page /50x.html#error_page 500 502 503 504 /50x.html;location = /50x.html {root html;}# ...2、重啟 nginx 服務
執行 ./nginx -s reload 命令重啟 nginx 服務
3、訪問 nginx
訪問 http://192.168.152.233/buy_goods 網址能夠得到如下代碼，我們在 nginx 配置的權重相等，默認是輪詢訪問
使用 jmeter 進行壓測
1、jmeter 下載地址
jmeter 官網：這下載速度到猴年馬月才能下載完成
清華大學鏡像：推薦下載地址~~~
2、配置 jmeter
點擊【bin】目錄下的【jmeter.bat】批處理腳本啟動 jmeter
在【Test Plan】上右擊，選擇【Add】–>【Threads】–>【Thread Group】，添加線程組
設置如下四個參數
在線程組之上右擊，選擇【Add】–>【Sampler】–>【HTTP Request】，添加 HTTP 請求
設置如下三個參數
保存此 HTTP Request 后才能進行壓測
點擊【Start】按鈕開始進行壓測
3、壓測結果
可以看到，相同的商品被出售兩次，出現超賣現象
3.0 版本的代碼：使用 redis 分布式鎖
1、SET 命令
Redis具有極高的性能，且其命令對分布式鎖支持友好，借助 SET 命令即可實現加鎖處理
The SET command supports a set of options that modify its behavior:
2、在代碼中使用分布式鎖
使用當前請求的 UUID + 線程名作為分布式鎖的 value，執行 stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value) 方法嘗試搶占鎖，如果搶占失敗，則返回值為 false；如果搶占成功，則返回值為 true。最后記得調用 stringRedisTemplate.delete(REDIS_LOCK_KEY) 方法釋放分布式鎖
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 2.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString()+Thread.currentThread().getName();// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value);// 搶鎖失敗if(lockFlag == false){return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);stringRedisTemplate.delete(REDIS_LOCK_KEY); // 釋放分布式鎖return retStr;}}3、代碼測試
加上分布式鎖之后，解決了超賣現象
3.3.3、finally 版
存在的問題
如果代碼在執行的過程中出現異常，那么就可能無法釋放鎖，因此必須要在代碼層面加上 finally 代碼塊，保證鎖的釋放
4.0 版本的代碼：保證鎖的釋放
加入 finally 代碼塊，保證鎖的釋放
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {stringRedisTemplate.delete(REDIS_LOCK_KEY); // 釋放分布式鎖}}}3.3.4、過期時間版
存在的問題
假設部署了微服務 jar 包的服務器掛了，代碼層面根本沒有走到 finally 這塊，也沒辦法保證解鎖。這個 key 沒有被刪除，其他微服務就一直搶不到鎖，因此我們需要加入一個過期時間限定的 key
5.0 版本的代碼：設置帶過期時間的 key
執行 stringRedisTemplate.expire(REDIS_LOCK_KEY, 10L, TimeUnit.SECONDS); 方法為分布式鎖設置過期時間，保證鎖的釋放
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value);// 設置過期時間為 10sstringRedisTemplate.expire(REDIS_LOCK_KEY, 10L, TimeUnit.SECONDS);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {stringRedisTemplate.delete(REDIS_LOCK_KEY); // 釋放分布式鎖}}}3.3.5、加鎖原子版
存在的問題
加鎖與設置過期時間的操作分開了，假設服務器剛剛執行了加鎖操作，然后宕機了，也沒辦法保證解鎖。
6.0 版本的代碼：保證加鎖和設置過期時間為原子操作
使用 stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10L, TimeUnit.SECONDS) 方法，在加鎖的同時設置過期時間，保證這兩個操作的原子性
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖，同時加上過期時間保證原子性Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10L, TimeUnit.SECONDS);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {stringRedisTemplate.delete(REDIS_LOCK_KEY); // 釋放分布式鎖}}}3.3.6、動自己奶酪版
存在的問題
張冠李戴，刪除了別人的鎖：我們無法保證一個業務的執行時間，有可能是 10s，有可能是 20s，也有可能更長。因為執行業務的時候可能會調用其他服務，我們并不能保證其他服務的調用時間。如果設置的鎖過期了，當前業務還正在執行，那么就有可能出現超賣問題，并且還有可能出現當前業務執行完成后，釋放了其他業務的鎖
如下圖，假設進程 A 在 T2 時刻設置了一把過期時間為 30s 的鎖，在 T5 時刻該鎖過期被釋放，在 T5 和 T6 期間，Test 這把鎖已經失效了，并不能保證進程 A 業務的原子性了。于是進程 B 在 T6 時刻能夠獲取 Test 這把鎖，但是進程 A 在 T7 時刻刪除了進程 B 加的鎖，進程 B 在 T8 時刻刪除鎖的時候就蒙蔽了，我 TM 鎖呢？
7.0 版本的代碼：只允許刪除自己的鎖，不允許刪除別人的鎖
在釋放鎖之前，執行 value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY)) 方法判斷是否為自己加的鎖
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖，同時加上過期時間保證原子性Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10L, TimeUnit.SECONDS);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {// 判斷是否是自己加的鎖if(value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY))){stringRedisTemplate.delete(REDIS_LOCK_KEY); // 釋放分布式鎖}}}}3.3.7、解鎖原子版
存在的問題
在 finally 代碼塊中的判斷與刪除并不是原子操作，假設執行 if 判斷的時候，這把鎖還是屬于當前業務，但是有可能剛執行完 if 判斷，這把鎖就被其他業務給釋放了，還是會出現誤刪鎖的情況
try {// ... } finally {// 判斷加鎖與解鎖是不是同一個客戶端if (value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY))){// 若在此時，這把鎖突然不是這個客戶端的，則會誤解鎖stringRedisTemplate.delete(REDIS_LOCK_KEY);//釋放鎖} }8.1 版本的代碼：使用 redis 自身事務保證原子性操作
redis 事務相關命令復習
1、事務介紹
2、相關命令
演示事務的使用
ClienA 使用 MULTI 命令開啟一個事務，并執行 SET lock 1 命令，當開啟事務之后，執行命令返回 QUEUED，表示已經將該命令壓入隊列
ClientB 執行 SET lock 2 命令將 lock 的值設置為 2
ClientA 執行 EXEC 命令提交事務，執行 get lock 命令獲取到 lock 的值為 1（ClientB 雖然加塞，但不影響 ClientA 的事務，但這不是我們想要的效果）
演示 WATCH 的使用
ClientA 先使用 WATCH lock 命令見監視 lock 這把鎖，然后使用 MULTI 命令開啟事務修改 lock 的值
ClientB 執行 set lock 4 命令將 lock 的值修改為 4
ClientA 執行 EXEC 命令提交事務，發現命令的返回值為 nil，表示事務執行失敗，使用 GET lock 獲取 lock 變量的值為 4（修改失敗），WATCH 之后記得使用 UNWATCH 解除監視
代碼
開啟事務不斷監視 REDIS_LOCK_KEY 這把鎖有沒有被別人動過，如果已經被別人動過了，那么繼續重新執行刪除操作，否則就解除監視
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖，同時加上過期時間保證原子性Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10L, TimeUnit.SECONDS);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {while (true) {//加事務，樂觀鎖stringRedisTemplate.watch(REDIS_LOCK_KEY);// 判斷是否是自己加的鎖if (value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY))) {// 開啟事務stringRedisTemplate.setEnableTransactionSupport(true);stringRedisTemplate.multi();stringRedisTemplate.delete(REDIS_LOCK_KEY);// 判斷事務是否執行成功，如果等于 null，就是沒有刪掉，刪除失敗，再回去 while 循環那再重新執行刪除List<Object> list = stringRedisTemplate.exec();if (list == null) {continue;}}//如果刪除成功，釋放監控器，并且 break 跳出當前循環stringRedisTemplate.unwatch();break;}}}}8.1 版本的代碼：使用 lua 腳本保證原子性操作
lua 腳本
redis 可以通過 eval 命令保證代碼執行的原子性
代碼
1、RedisUtils 工具類
getJedis() 方法用于從 jedisPool 中獲取一個連接塊對象
/*** @ClassName RedisUtils* @Description TODO* @Author Oneby* @Date 2021/2/4 17:41* @Version 1.0*/ public class RedisUtils {private static JedisPool jedisPool;private static String hostAddr = "192.168.152.233";static {JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();jedisPoolConfig.setMaxTotal(20);jedisPoolConfig.setMaxIdle(10);jedisPool = new JedisPool(jedisPoolConfig, hostAddr, 6379, 100000);}public static Jedis getJedis() throws Exception {if (null != jedisPool) {return jedisPool.getResource();}throw new Exception("Jedispool is not ok");}}2、使用 lua 腳本保證解鎖操作的原子性
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@GetMapping("/buy_goods")public String buy_Goods() throws Exception {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();try {// setIfAbsent() 就相當于 setnx，如果不存在就新建鎖，同時加上過期時間保證原子性Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10L, TimeUnit.SECONDS);// 搶鎖失敗if (lockFlag == false) {return "搶鎖失敗 o(╥﹏╥)o";}// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {// 獲取連接對象Jedis jedis = RedisUtils.getJedis();// lua 腳本，摘自官網String script = "if redis.call('get', KEYS[1]) == ARGV[1]" + "then "+ "return redis.call('del', KEYS[1])" + "else " + " return 0 " + "end";try {// 執行 lua 腳本Object result = jedis.eval(script, Collections.singletonList(REDIS_LOCK_KEY), Collections.singletonList(value));// 獲取 lua 腳本的執行結果if ("1".equals(result.toString())) {System.out.println("------del REDIS_LOCK_KEY success");} else {System.out.println("------del REDIS_LOCK_KEY error");}} finally {// 關閉鏈接if (null != jedis) {jedis.close();}}}}}3、代碼測試
使用 lua 腳本可以防止別人動我們自己的鎖~~~
3.3.8、自動續期版
存在的問題
前面已經講過了：我們無法保證一個業務的執行時間，有可能是 10s，有可能是 20s，也有可能更長。因為執行業務的時候可能會調用其他服務，我們并不能保證其他服務的調用時間。如果設置的鎖過期了，當前業務還正在執行，那么之前設置的鎖就失效了，就有可能出現超賣問題。
因此我們需要確保 redisLock 過期時間大于業務執行時間的問題，即面臨如何對 Redis 分布式鎖進行續期的問題
redis 與 zookeeper 在 CAP 方面的對比
redis
redis 異步復制造成的鎖丟失， 比如：主節點沒來的及把剛剛 set 進來這條數據給從節點，就掛了，那么主節點和從節點的數據就不一致。此時如果集群模式下，就得上 Redisson 來解決
zookeeper
zookeeper 保持強一致性原則，對于集群中所有節點來說，要么同時更新成功，要么失敗，因此使用 zookeeper 集群并不存在主從節點數據丟失的問題，但丟失了速度方面的性能
9.0 版本的代碼：使用 Redisson 實現自動續期功能
redis 集群環境下，我們自己寫的也不OK，直接上 RedLock 之 Redisson 落地實現
代碼實現
1、注入 Redisson 對象
在 RedisConfig 配置類中注入 Redisson 對象
/*** @ClassName RedisConfig* @Description TODO* @Author Oneby* @Date 2021/2/2 18:55* @Version 1.0*/ @Configuration public class RedisConfig {@Value("${spring.redis.host}")private String redisHost;@Beanpublic RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory) {// 新建 RedisTemplate 對象，key 為 String 對象，value 為 Serializable（可序列化的）對象RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();// key 值使用字符串序列化器redisTemplate.setKeySerializer(new StringRedisSerializer());// value 值使用 json 序列化器redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());// 傳入連接工廠redisTemplate.setConnectionFactory(connectionFactory);// 返回 redisTemplate 對象return redisTemplate;}@Beanpublic Redisson redisson() {Config config = new Config();config.useSingleServer().setAddress("redis://" + redisHost + ":6379").setDatabase(0);return (Redisson) Redisson.create(config);}}2、業務邏輯
直接 redissonLock.lock()、redissonLock.unlock() 完事兒，這尼瑪就是 juc 版本的 redis 分布式鎖啊
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@Autowiredprivate Redisson redisson;@GetMapping("/buy_goods")public String buy_Goods() throws Exception {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();// 獲取鎖RLock redissonLock = redisson.getLock(REDIS_LOCK_KEY);// 上鎖redissonLock.lock();try {// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {// 解鎖redissonLock.unlock();}}}代碼測試
沒有出現超賣現象（但我用的是個假的 nginx？？？）
9.1 版本的代碼：Bug 的完善
問題
陽哥說在超高并發的情況下，可能會拋出如下異常，原因是解鎖 lock 的線程并不是當前線程，啥意思？？？
代碼
在釋放鎖之前加一個判斷：還在持有鎖的狀態，并且是當前線程持有的鎖再解鎖
/*** @ClassName GoodController* @Description TODO* @Author Oneby* @Date 2021/2/2 18:59* @Version 1.0*/ @RestController public class GoodController {private static final String REDIS_LOCK_KEY = "lockOneby";@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Value("${server.port}")private String serverPort;@Autowiredprivate Redisson redisson;@GetMapping("/buy_goods")public String buy_Goods() throws Exception {// 當前請求的 UUID + 線程名String value = UUID.randomUUID().toString() + Thread.currentThread().getName();// 獲取鎖RLock redissonLock = redisson.getLock(REDIS_LOCK_KEY);// 上鎖redissonLock.lock();try {// 從 redis 中獲取商品的剩余數量String result = stringRedisTemplate.opsForValue().get("goods:001");int goodsNumber = result == null ? 0 : Integer.parseInt(result);String retStr = null;// 商品數量大于零才能出售if (goodsNumber > 0) {int realNumber = goodsNumber - 1;stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");retStr = "你已經成功秒殺商品，此時還剩余：" + realNumber + "件" + "\t 服務器端口: " + serverPort;} else {retStr = "商品已經售罄/活動結束/調用超時，歡迎下次光臨" + "\t 服務器端口: " + serverPort;}System.out.println(retStr);return retStr;} finally {// 還在持有鎖的狀態，并且是當前線程持有的鎖再解鎖if (redissonLock.isLocked() && redissonLock.isHeldByCurrentThread()){redissonLock.unlock();}}}}3.4、分布式鎖總結
回顧測試 & 找茬的步驟
4、Redis 緩存淘汰策略
4.1、緩存淘汰策略的面試題
Redis 緩存淘汰策略相關的面試題
4.2、redis 內存滿了怎么辦
redis 默認內存多少？在哪里查看? 如何設置修改?
1、如何查看 redis 最大占用內存
在 redis.conf 配置文件中有一個，輸入 :set nu 顯示行號，大約在 800 多行有一個 maxmemory 字段，用預設值 redis 的最大占用內存
2、redis 會占用物理機器多少內存？
如果不設置最大內存大小或者設置最大內存大小為 0，在 64 位操作系統下不限制內存大小，在32位操作系統下最多使用 3GB 內存
3、一般生產上如何配置 redis 的內存
一般推薦Redis設置內存為最大物理內存的四分之三，也就是 0.75
4、如何修改 redis 內存設置
通過修改文件配置（永久生效）：修改 maxmemory 字段，單位為字節
通過命令修改（重啟失效）：config set maxmemory 104857600 設置 redis 最大占用內存為 100MB，config get maxmemory 獲取 redis 最大占用內存
5、通過命令查看 redis 內存使用情況?
通過 info 指令可以查看 redis 內存使用情況：used_memory_human 表示實際已經占用的內存，maxmemory 表示 redis 最大占用內存
如果把 redis 內存打滿了會發生什么? 如果 redis 內存使用超出了設置的最大值會怎樣?
修改配置，故意把最大內存設置為 1byte，再通過 set k1 v1 命令下 redis 中寫入數據，redis 將會報錯：(error) OOM command not allowed when used memory > ‘maxmemory’
總結 & 結論
如果設置了 maxmemory 的選項，假如 redis 內存使用達到上限，并且 key 都沒有加上過期時間，就會導致數據寫爆 redis 內存。
為了避免類似情況，于是引出下一部分的內存淘汰策略
4.3、redis 緩存淘汰策略
redis 如何刪除設置了過期時間的 key
1、redis過期鍵的刪除策略
如果一個鍵是過期的，那它到了過期時間之后是不是馬上就從內存中被被刪除呢？如果回答是，那么面試官就會問你：自己走還是我送你？那么過期后到底什么時候被刪除呢？edis 如何操作的呢？
通過查看 redis 配置文件可知，默認淘汰策略是【noeviction（Don’t evict anything, just return an error on write operations.）】，如果 redis 內存被寫爆了，直接返回 error
redis 對于過期 key 的三種不同刪除策略
1、定時刪除
立即刪除能保證內存中數據的最大新鮮度，因為它保證過期鍵值會在過期后馬上被刪除，其所占用的內存也會隨之釋放。但是立即刪除對 CPU 是最不友好的。因為刪除操作會占用 CPU 的時間，如果剛好碰上了 CPU 很忙的時候，比如正在做交集或排序等計算的時候，就會給 CPU 造成額外的壓力，讓 CPU 心累，時時需要刪除，忙死。。。。。。
這會產生大量的性能消耗，同時也會影響數據的讀取操作。
總結：定時刪除對 CPU 不友好，但對 memory 友好，用處理器性能換取存儲空間（拿時間換空間）
2、惰性刪除
惰性刪除的策略剛好和定時刪除相反，惰性刪除在數據到達過期時間后不做處理，等下次訪問該數據時發現已過期，并將其刪除，并返回不存在。
使用惰性刪除訪問數據的特點：訪問一個數據，如果發現其在過期時間之內，則返回改數據；如果發現已經過了過期時間，則將其刪除，并返回不存在
如果一個鍵已經過期，而這個鍵又仍然保留在數據庫中，那么只要這個過期鍵不被刪除，它所占用的內存就不會釋放。因此惰性刪除策略的缺點是：它對內存是最不友好的。
在使用惰性刪除策略時，如果數據庫中有非常多的過期鍵，而這些過期鍵又恰好沒有被訪問到的話，那么它們也許永遠也不會被刪除（除非用戶手動執行 FLUSHDB），我們甚至可以將這種情況看作是一種內存泄漏——無用的垃圾數據占用了大量的內存，而服務器卻不會自己去釋放它們，這對于運行狀態非常依賴于內存的 redis 服務器來說，肯定不是一個好消息
總結：惰性刪除對 memory 不友好，但對 CPU 友好，用存儲空間換取處理器性能（拿空間換時間）
3、定期刪除
折中方案：定期刪除
上面兩種刪除策略都走極端，因此引出我們的定期刪除策略。
定期刪除策略是前兩種策略的折中：定期刪除策略每隔一段時間執行一次刪除過期鍵操作，并通過限制刪除操作執行的時長和頻率來減少刪除操作對 CPU 時間的影響。其做法為：周期性輪詢 redis 庫中的時效性數據，采用隨機抽取的策略，利用過期數據占比的方式控制刪除頻度。
定期刪除的特點
特點1：CPU 性能占用設置有峰值，檢測頻度可自定義設置
特點2：內存壓力不是很大，長期占用內存的冷數據會被持續清理
總結：周期性抽查存儲空間（隨機抽查，重點抽查)
定期刪除的舉例
redis 默認每間隔 100ms 檢查是否有過期的 key，如果有過期 key 則刪除。注意：redis 不是每隔100ms 將所有的 key 檢查一次而是隨機抽取進行檢查（如果每隔 100ms，全部 key 進行檢查，redis 直接進去ICU）。因此，如果只采用定期刪除策略，會導致很多 key 到時間沒有刪除。
定期刪除的難點
定期刪除策略的難點是確定刪除操作執行的時長和頻率：redis 不可能時時刻刻遍歷所有被設置了生存時間的 key，來檢測數據是否已經到達過期時間，然后對它進行刪除。
如果刪除操作執行得太頻繁，或者執行的時間太長，定期刪除策略就會退化成定時刪除策略，以至于將 CPU 時間過多地消耗在刪除過期鍵上面。
如果刪除操作執行得太少，或者執行的時間太短，定期刪除策略又會和惰性刪除束略一樣，出現浪費內存的情況。
因此，如果采用定期刪除策略的話，服務器必須根據情況，合理地設置刪除操作的執行時長和執行頻率。
總結
惰性刪除和定期刪除都存在數據沒有被抽到的情況，如果這些數據已經到了過期時間，沒有任何作用，這會導致大量過期的 key 堆積在內存中，導致 redis 內存空間緊張或者很快耗盡
因此必須要有一個更好的兜底方案，接下來引出 redis 內存淘汰策略
redis 6.0.8 版本的內存淘汰策略有哪些？
8 種內存淘汰策略
總結
如何配置 redis 的內存淘汰策略
通過修改文件配置（永久生效）：配置 maxmemory-policy 字段
通過命令修改（重啟失效）：config set maxmemory-policy allkeys-lru 命令設置內存淘汰策略，config get maxmemory-policy 命令獲取當前采用的內存淘汰策略
5、redis LRU 算法
5.1、LRU 算法簡介
LRU 算法的簡介
LRU 是 Least Recently Used 的縮寫，即最近最少使用，是一種常用的頁面置換算法，每次選擇最近最久未使用的頁面予以淘汰
5.2、LRU 算法題來源
146. LRU 緩存機制
運用你所掌握的數據結構，設計和實現一個 LRU (最近最少使用) 緩存機制 。
實現 LRUCache 類：
進階：你是否可以在 O(1) 時間復雜度內完成這兩種操作？
示例：
輸入 ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]] 輸出 [null, null, null, 1, null, -1, null, -1, 3, 4]解釋 LRUCache lRUCache = new LRUCache(2); lRUCache.put(1, 1); // 緩存是 {1=1} lRUCache.put(2, 2); // 緩存是 {1=1, 2=2} lRUCache.get(1); // 返回 1 lRUCache.put(3, 3); // 該操作會使得關鍵字 2 作廢，緩存是 {1=1, 3=3} lRUCache.get(2); // 返回 -1 (未找到) lRUCache.put(4, 4); // 該操作會使得關鍵字 1 作廢，緩存是 {4=4, 3=3} lRUCache.get(1); // 返回 -1 (未找到) lRUCache.get(3); // 返回 3 lRUCache.get(4); // 返回 45.3、LRU 算法設計思想
查找和插入的時間復雜度為 O(1)，HashMap 沒得跑了，但是 HashMap 是無序的集合，怎么樣將其改造為有序集合呢？答案就是在各個 Node 節點之間增加 prev 指針和 next 指針，構成雙向鏈表
LRU 的算法核心是哈希鏈表，本質就是 HashMap+DoubleLinkedList 時間復雜度是O(1)，哈希表+雙向鏈表的結合體，下面這幅動圖完美詮釋了 HashMap+DoubleLinkedList 的工作原理
5.4、LRU 算法編碼實現
1、借助 JDK 自帶的 LinkedHashMap
LinkedHashMap 的注釋中寫明了： LinkedHashMap 非常適合用來構建 LRU 緩存
LRU 代碼
通過繼承 LinkedHashMap，重寫 boolean removeEldestEntry(Map.Entry<K, V> eldest) 方法就完事了。。。
/*** @ClassName LRUCacheDemo* @Description TODO* @Author Oneby* @Date 2021/2/7 16:26* @Version 1.0*/ public class LRUCacheDemo<K, V> extends LinkedHashMap<K, V> {// 緩存容量private int capacity;public LRUCacheDemo(int capacity) {// accessOrder：the ordering mode. true for access-order；false for insertion-ordersuper(capacity, 0.75F, true);this.capacity = capacity;}// 用于判斷是否需要刪除最近最久未使用的節點@Overrideprotected boolean removeEldestEntry(Map.Entry<K, V> eldest) {return super.size() > capacity;}public static void main(String[] args) {LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);lruCacheDemo.put(1, "a");lruCacheDemo.put(2, "b");lruCacheDemo.put(3, "c");System.out.println(lruCacheDemo.keySet());lruCacheDemo.put(4, "d");System.out.println(lruCacheDemo.keySet());lruCacheDemo.put(3, "c");System.out.println(lruCacheDemo.keySet());lruCacheDemo.put(3, "c");System.out.println(lruCacheDemo.keySet());lruCacheDemo.put(3, "c");System.out.println(lruCacheDemo.keySet());lruCacheDemo.put(5, "x");System.out.println(lruCacheDemo.keySet());}}為何要重寫 boolean removeEldestEntry(Map.Entry<K, V> eldest) 方法
先來看看 LinkedHashMap 中的 boolean removeEldestEntry(Map.Entry<K, V> eldest) 方法，直接 return false，緩存爆就爆，反正就是不會刪除 EldestEntry
/*** Returns <tt>true</tt> if this map should remove its eldest entry.* This method is invoked by <tt>put</tt> and <tt>putAll</tt> after* inserting a new entry into the map. It provides the implementor* with the opportunity to remove the eldest entry each time a new one* is added. This is useful if the map represents a cache: it allows* the map to reduce memory consumption by deleting stale entries.*/ protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {return false; }boolean removeEldestEntry(Map.Entry<K, V> eldest) 方法在 void afterNodeInsertion(boolean evict) 方法中被調用，只有當 boolean removeEldestEntry(Map.Entry<K, V> eldest) 方法返回 true 時，才能夠刪除 EldestEntry
因此我們重寫之后的判斷條件為：如果 LinkedHashMap 中存儲的元素個數已經大于緩存容量 capacity，則返回 true，表示允許刪除 EldestEntry；否則返回 false，表示無需刪除 EldestEntry
// 用于判斷是否需要刪除最近最久未使用的節點 @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {return super.size() > capacity; }舉例說明構造函數中的 accessOrder 的含義
構造函數中的 accessOrder 字段
在 LRUCacheDemo 的構造方法中，我們調用了 LinkedHashMap 的構造方法，其中有一個字段為 accessOrder
accessOrder = true 和 accessOrder = false 的情況
當 accessOrder = true 時，每次使用 key 時（put 或者 get 時），都將 key 對應的數據移動到隊尾（右邊），表示最近經常使用；當 accessOrder = false 時，key 的順序為插入雙向鏈表時的順序
LinkedHashMap 的 put() 方法
LinkedHashMap 的 put() 方法其實就是 HashMap 的 put() 方法，我就奇了怪了，LinkedHashMap 就是 HashMap？？？其實并不是。。。
在 putval() 方法的調用了兩個方法：afterNodeAccess(e) 方法和 afterNodeInsertion(evict) 方法，這兩個方法就是專門針對于 LinkedHashMap 寫的方法
在 HashMap 中這些方法均為空實現的方法，沒有任何代碼邏輯，需要推遲到子類 LinkedHashMap 中去實現，等等，聽著好像有點耳熟，這不就是模板方法設計模式嘛~
在 LinkedHashMap 的 void afterNodeAccess(Node<K,V> e) 方法中：如果設置了 accessOrder = true 時，則每次使用 key 時（put 或者 get 時），都將 key 對應的數據移動到隊尾（右邊），表示這是最近經常使用的節點
在 LinkedHashMap 的 void afterNodeInsertion(boolean evict) 方法中：如果頭指針不為空并且當前需要刪除老節點，則執行 removeNode(hash(key), key, null, false, true) 方法刪除 EldestEntry（若 accessOrder = true 時，EldestEntry 表示最近最少使用的數據，若 accessOrder = false 時，EldestEntry 表示最先插入鏈表的節點）
LinkedHashMap 的 get() 方法
在 LinkedHashMap 的 get() 方法中：若 accessOrder = true 時，則每次 get(key) 之后都會將 key 對應的數據移動至雙向鏈表的尾部
LinkedHashMap 中如何構造雙向鏈表？
Entry<K,V> 繼承了 HashMap.Node<K,V>，并且有 Entry<K,V> before, after; 兩個字段，這不就是雙線鏈表的標配嘛
在 LinkedHashMap 中定義了 head 和 tail ，分別指向雙向鏈表的頭部和尾部，人家注釋中也說了，head 用于指向雙向鏈表中最老的節點，tail 用于指向最年輕的節點，至于最老和最年輕的定義，就得看 accessOrder 字段的值了：如果 accessOrder = true，那么最老的節點就是最久沒有被使用過的節點，最年輕的節點就是最近被剛被使用過的節點；如果 accessOrder = true，那么最老的節點就是鏈表頭部的節點，最年輕的節點就是鏈表尾部的節點
2、完全自己手寫
依葫蘆畫瓢，先定義 Node 類作為數據的承載體
// 1.構造一個node節點作為數據載體 class Node<K, V> {K key;V value;Node<K, V> prev;Node<K, V> next;public Node() {this.prev = this.next = null;}public Node(K key, V value) {this.key = key;this.value = value;this.prev = this.next = null;} }定義雙向鏈表，里面存放的就是 Node 對象，Node 節點之間通過 prev 和 next 指針連接起來
// 2.構建一個虛擬的雙向鏈表,,里面存放的就是我們的Node class DoubleLinkedList<K, V> {Node<K, V> head;Node<K, V> tail;public DoubleLinkedList() {head = new Node<>();tail = new Node<>();head.next = tail;tail.prev = head;}// 3.添加到頭public void addHead(Node<K, V> node) {node.next = head.next;node.prev = head;head.next.prev = node;head.next = node;}// 4.刪除節點public void removeNode(Node<K, V> node) {node.next.prev = node.prev;node.prev.next = node.next;node.prev = null;node.next = null;}// 5.獲得最后一個節點public Node getLast() {return tail.prev;} }通過 HashMap 和 DoubleLinkedList 構建 LinkedHashMap，我們這里可是將最近最常使用的節點放在了雙向鏈表的頭部（和 LinkedHashMap 不同哦）
private int cacheSize; Map<Integer, Node<Integer, Integer>> map; DoubleLinkedList<Integer, Integer> doubleLinkedList;public LRUCacheDemo(int cacheSize) {this.cacheSize = cacheSize;//坑位map = new HashMap<>();//查找doubleLinkedList = new DoubleLinkedList<>(); }public int get(int key) {if (!map.containsKey(key)) {return -1;}Node<Integer, Integer> node = map.get(key);doubleLinkedList.removeNode(node);doubleLinkedList.addHead(node);return node.value; }public void put(int key, int value) {if (map.containsKey(key)) { //updateNode<Integer, Integer> node = map.get(key);node.value = value;map.put(key, node);doubleLinkedList.removeNode(node);doubleLinkedList.addHead(node);} else {if (map.size() == cacheSize) //坑位滿了{Node<Integer, Integer> lastNode = doubleLinkedList.getLast();map.remove(lastNode.key);doubleLinkedList.removeNode(lastNode);}//新增一個Node<Integer, Integer> newNode = new Node<>(key, value);map.put(key, newNode);doubleLinkedList.addHead(newNode);} }測試 LRUCacheDemo
public static void main(String[] args) {LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);lruCacheDemo.put(1, 1);lruCacheDemo.put(2, 2);lruCacheDemo.put(3, 3);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(4, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(5, 1);System.out.println(lruCacheDemo.map.keySet());}測試結果：這個順序是不對滴，因為這是 HashMap 中 key 的順序，并不是 DoubleLinkedList 中 key 的順序，但至少可以說明最近最少使用的數據已經被刪除了~~~
全部代碼
public class LRUCacheDemo {// map 負責查找，構建一個虛擬的雙向鏈表，它里面裝的就是一個個 Node 節點，作為數據載體// 1.構造一個node節點作為數據載體class Node<K, V> {K key;V value;Node<K, V> prev;Node<K, V> next;public Node() {this.prev = this.next = null;}public Node(K key, V value) {this.key = key;this.value = value;this.prev = this.next = null;}}// 2.構建一個虛擬的雙向鏈表,,里面安放的就是我們的Nodeclass DoubleLinkedList<K, V> {Node<K, V> head;Node<K, V> tail;public DoubleLinkedList() {head = new Node<>();tail = new Node<>();head.next = tail;tail.prev = head;}// 3.添加到頭public void addHead(Node<K, V> node) {node.next = head.next;node.prev = head;head.next.prev = node;head.next = node;}// 4.刪除節點public void removeNode(Node<K, V> node) {node.next.prev = node.prev;node.prev.next = node.next;node.prev = null;node.next = null;}// 5.獲得最后一個節點public Node getLast() {return tail.prev;}}private int cacheSize;Map<Integer, Node<Integer, Integer>> map;DoubleLinkedList<Integer, Integer> doubleLinkedList;public LRUCacheDemo(int cacheSize) {this.cacheSize = cacheSize;//坑位map = new HashMap<>();//查找doubleLinkedList = new DoubleLinkedList<>();}public int get(int key) {if (!map.containsKey(key)) {return -1;}Node<Integer, Integer> node = map.get(key);doubleLinkedList.removeNode(node);doubleLinkedList.addHead(node);return node.value;}public void put(int key, int value) {if (map.containsKey(key)) { //updateNode<Integer, Integer> node = map.get(key);node.value = value;map.put(key, node);doubleLinkedList.removeNode(node);doubleLinkedList.addHead(node);} else {if (map.size() == cacheSize) //坑位滿了{Node<Integer, Integer> lastNode = doubleLinkedList.getLast();map.remove(lastNode.key);doubleLinkedList.removeNode(lastNode);}//新增一個Node<Integer, Integer> newNode = new Node<>(key, value);map.put(key, newNode);doubleLinkedList.addHead(newNode);}}public static void main(String[] args) {LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);lruCacheDemo.put(1, 1);lruCacheDemo.put(2, 2);lruCacheDemo.put(3, 3);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(4, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(3, 1);System.out.println(lruCacheDemo.map.keySet());lruCacheDemo.put(5, 1);System.out.println(lruCacheDemo.map.keySet());} }圖解雙向隊列
DoubleLinkedList 雙向鏈表的初始化
雙向鏈表插入節點
雙向鏈表刪除節點
總結
以上是生活随笔為你收集整理的第 5 章 Redis的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： JSP基础知识总结一
- 下一篇： New Empirical Tracea