A. 追蹤Redis Sentinel的CPU佔有率長期接近100%的問題 二
在 《追蹤Redis Sentinel的CPU佔有率長期接近100%的問題》 一文中，通過結合Redis Sentinel的源碼，發現由於出現了"Too many open files"問題，致使Sentinel的acceptTcpHandler事件處理函數會被頻繁並快速調用，最終導致了CPU長期接近100%的現象。但對於為什麼會出現「Too many open files」這個問題，本文將在上一篇的基礎上，繼續探討和分析。
「Too many open files」這個錯誤其實很常見，想必大家早已對其有一定的了解，這里打算再簡單的介紹一下。
很明顯，「Too many open files」即說明打開的文件（包括socket）數量過多，已經超出了系統設定給某個進程最大的文件描述符的個數，超過後即無法繼續打開新的文件，並且報這個錯誤。
首先，我們需要了解有關open files的基本知識。詳細的概念大家可以谷歌，網上也有各種各樣的解決辦法，這里只對open files做簡單的介紹和總結。
我們在linux上運行ulimit -a 後，出現：
如圖open files的個數為1024，很明顯這個值太小了（linux默認即為1024），當進程耗盡1024個文件或socket後，就會出現「Too many open files」錯誤。現實生產環境中這個值很容易達到，所以一般都會進行相應修改。
最簡單的修改方式是ulimit -n 65535，但這樣重啟系統後又會恢復。永久生效的方法是修改/etc/security/limits.conf 文件，在最後加入：
修改完成後，重啟系統或者運行sysctl -p使之生效。
soft 和hard，表示對進程所能打開的文件描述符個數限制，其概念為：
他們的區別就是軟限制可以在程序的進程中自行改變(突破限制)，而硬限制則不行(除非程序進程有root許可權)。
上面的規則大家最好自己嘗試一下，以增加印象。
重啟後，運行ulimit -a，可以看到open files 的值改變為：
簡單介紹完open files，我們再來了解下file-max。這個參數相信有很多人經常與ulimit中的open files混淆，他們的區別我們必須了解。
file-max 從字面意思就可以看出是文件的最大個數，運行cat /proc/sys/fs/file-max，可以看到：
這表示當前系統所有進程一共可以打開的文件數量為387311。請務必注意」系統所有進程"這幾個字。
運行 vim /etc/sysctl.conf ，有時候你會看到類似：fs.file-max = 8192。出現這個則表示用戶手動設置了這個值，沒有則系統會有其默認值。手動設置的話，只需要在sysctl.conf 中加上上述語句即可。
回到ulimit中的open files，它與file-max的區別就是：opem filese表示當前shell以及由它啟動的進程的文件描述符的限制，也就是說ulimit中設置的open files，只是當前shell及其子進程的文件描述符的限定。是否清楚？可以簡單的理解為：
好了，對於 file-max與open files的簡單介紹到此為止。現在的問題就是，「Too many open files」到底是碰到哪個設置的雷區造成的。
結合上一篇，我們知道sentinel主要在執行accept函數時出現了「Too many open files」錯誤，熟悉accept這個系統調用的朋友很清楚，accept會接收客戶端的請求，成功的話會建立連接，並返回新的socket描述符。所以，我們確定這里的「Too many open files」指的即是socket的數目過多。
我們猜測，是否是有大量的Jedis連接同時存在，耗盡伺服器的socket資源，導致新的連接請求無法建立。所以，我們查看一下sentinel伺服器的TCP連接，運行：netstat -anp | grep 26379，得到：
由上圖可以發現，有非常多處於ESTABLISHED狀態的TCP連接，運行 netstat -anp | grep 118:26379 | wc -l查看他們的個數：
可以看到，Sentinel同時維持了4071個TCP連接，而且過了很久之後，仍然是這么多，不會有大幅變化。
這時，也許你會想到，是否因為系統文件描述符的限制導致Sentinel無法建立更多的Socket，從而產生「Too many open files」的錯誤。所以，馬上在Sentinel伺服器上運行cat /proc/sys/fs/file-max，發現：
這個值很大，看似一切正常。繼續運行sudo cat /proc/5515/limits，發現：
看到上圖，我們似乎發現了端倪，這里的hard和soft都是4096，與前面的4072比較接近。為什麼會這么低？我們繼續查看一下ulimit，運行ulimit -a ：
可以看到，ulimit中open files 的設置為64000，為什麼會不一致？按理說sentinel應該最大有64000+的open files。
對於這個矛盾，一開始我怎麼也想不明白。最後我推測：應該是在最早啟動sentinel啟動的時候，系統的設置為4096，sentinel啟動之後，又在某個時間又改為64000，而sentinel進程確保持原有設置，從而導致很快達到限制。
我馬上查看了進程的啟動時間，運行ps -eo pid,lstart,etime | grep 5515：
發現進程啟動於2015年12月2日，接著再次運行 ll /etc/security/limits.conf：
發現確實在2016年4月改動過， 然後我咨詢了運維人員，他們告知我，確實改動過，但由多少改動到多少，他們也忘了。。。
為了了解Sentinel啟動時的狀況，緊接著查看了Sentinel的日誌，下面是Sentinel啟動時列印的畫面：
上圖說明了進程是2015年12月2日啟動的，特別注意最開頭的幾行，非常關鍵：
這幾句的意思是：
問題很清楚了，redis sentinel最大可以支持10000個客戶端，也就是10032個文件描述符，但由於當前被人為限制到4096 了，所以，自動降低了標准。
因此，我猜測，最早open files的限制為4096時，Sentinel已經啟動了，只要進程啟動，改多少都沒有用。很明顯，在生產環境上，4096個連接請求很快就會達到。
接著，我繼續查看了Sentinel的配置文件，如下圖所示：
上圖中， 「Generated by CONFIG REWRITE」之前的都是是人工配置，其後為Sentinel自動重寫的配置。
熟悉Redis的朋友都知道。Sentinel可能會對其配置文件進行更新重寫：
我們很快注意到了maxclients 4064這個配置項，此時我很迷惑。我們知道，在Sentinel中是無法手動運行config set命令的，那這個4096必然不是來自於人工配置，Sentinel為什麼要自動重寫4064這個值。其實，仔細發現，這里Sentinel限制了最多4064個連接，加上32個預留，剛好為4096。
於是，綜上，我猜測，Sentinel在啟動的時候發現自己的10032個open files的預期與事實設置的4096不符，所以被迫遵守4096，減去預留的32，最終maxclients 只有4064，並且之後因為某些原因重寫了配置，所以輸出了這個值。
好吧，我的一貫作風，先猜測，再讓源碼說話。
我們可以通過異常信息定位異常所處源碼，所以我搜索了前面提到的Sentinel在啟動時列印的關於maxclients 的日誌信息中的文本，如「You requested maxclients of ...」。
這個異常出現在adjustOpenFilesLimit函數,通過函數名可以清楚它的作用，然後發現它的調用鏈只是：
``main()->initServer()->adjustOpenFilesLimit()```
所以，可以確定，在Sentinel伺服器啟動並進行初始化的時候，會調用adjustOpenFilesLimit函數對open files個數進行調整。調整策略是什麼呢？我們查看源碼：
在第1行中，REDIS_MIN_RESERVED_FDS即預留的32，是Sentinel保留的用於額外的的操作，如listening sockets, log files 等。同時，這里讀取了server.maxclients的值，看來server.maxclients具有初始化值，通過經過定位源碼，發現調用鏈：
即Sentinel在啟動時，調用initServerConfig()初始化配置，執行了server.maxclients = REDIS_MAX_CLIENTS（REDIS_MAX_CLIENTS為10000），所以server.maxclients就有了初始值10000。
回到adjustOpenFilesLimit()函數，adjustOpenFilesLimit最終目的就是得到適合的soft，並存在server.maxclients中，因為該函數比較重要，下面專門作出解釋：
1 先得到maxfiles的初始值，即Sentinel的期望10032
2 然後獲取進程當前的soft和hard，並存入limit ，即執行getrlimit(RLIMIT_NOFILE,&limit) ：
調整過程為：
1 先用oldlimit變數保存進程當前的soft的值（如4096）
2 然後，判斷oldlimit<maxfiles ，如果真，表示當前soft達不到你要求，需要調整。調整的時候，策略是從最大值往下嘗試，以逐步獲得Sentinel能申請到的最大soft。
嘗試過程為：
1 首先f保存要嘗試的soft值，初始值為maxfiles （10032），即從10032開始調整。
2 然後開始一個循環判斷，只要f大於oldlimit，就執行一次setrlimit(RLIMIT_NOFILE,&limit) ，然後f減16：
這樣，用這種一步一步嘗試的方法，最終可用得到了Sentiel能獲得的最大的soft值，最後減去32再保存在server.maxclients中。
另外，當得到Sentinel能獲得的最合適的soft值f後，還要判斷f與oldlimit（系統最初的soft限制，假設為4096），原因如下：
也許會直到f==4096才設置成功，但也會出現f<4096的情況，這是因為跨度為16，最後一不小心就減多了，但最後的soft值不應該比4096還小。所以，f=oldlimit就是這個意思。
最後，還有一個判斷：
上面的過程我們用簡單的表示為：
adjustOpenFilesLimit()的分析到此結束。但有一點一定要明確，adjustOpenFilesLimit()只會在Sentinel初始化的時候執行一次，目的就是將最合適的soft保存到了server.maxclients （第xx行），以後不會再調用。這樣，一旦設置了server.maxclients ，只要Sentinel不重啟，這個值就不會變化，這也就解釋了為什麼Sentinel啟動之後再改變open files沒有效果的原因了。
那什麼時候發生了重寫呢？即「Generated by CONFIG REWRITE」這句話什麼時候會輸出？接著上面，我又在源碼里搜索了「Generated by CONFIG REWRITE」這句話，發現了常量REDIS_CONFIG_REWRITE_SIGNATURE，通過它繼而發現如下調用鏈：
上面的調用鏈中，*表示有很多地方會調用sentinelFlushConfig()。
什麼時候調用sentinelFlushConfig()呢？經過查找，發現有很多條件都可以觸發sentinelFlushConfig函數的調用，包括Leader選舉、故障轉移、使用Sentinel set 設置命令、Sentinel處理info信息等等。
而sentinelFlushConfig()則會利用rewriteConfig()，針對具體的配置項，分別進行重寫，最終將Sentinel所有的狀態持久化到了配置文件中。如下所示，在rewriteConfig()中，可以看到非常多的重寫類型， 這些重寫類型都是與redis的各個配置選項一一對應的：
當然，我們只需要找到其中關於max clients的重寫即可，所以在該函數中，我們找到了調用：
可以看到，該函數傳入了Sentinel當前的server.maxclients（已經在啟動時調整過了，前面分析過），以及默認的REDIS_MAX_CLIENTS即10032。該函數作用就是將當前的server.maxclients的值重寫到配置文件中去。什麼時候重寫呢，即當默認值與當前值不同的時候（也就是force==true的時候），具體可以查看其源碼，篇幅限制我們不做詳細介紹。
通過前面一大堆的分析，我們可以得出結論：
講到這里，還有一個問題就是，為什麼Sentinel伺服器會長期持有4000多個Established狀態的TCP連接而不釋放。按目前生產環境的規模，正常情況下業務客戶端使用的Jedis建立的TCP連接不應該有這么多。
經過查看，發現Sentinel上的很多連接在對應的客戶端中並沒有存在。如紅框所示IP10.X.X.74上：
總計有992個連接：
而實際上在10.X.X.74上，只有5個與Sentinel的連接長期存在：
也就是說，在Sentinel中有大量的連接是無效的，客戶端並沒有持有，Sentinel一直沒有釋放。這個問題， 就涉及到了TCP保活的相關知識。
我們首先要了解，操作系統通常會自身提供TCP的keepalive機制，如在linux默認配置下，運行sysctl -a |grep keep，會看到如下信息：
上面表示如果連接的空閑時間超過 7200 秒（2 小時），Linux 就發送保持活動的探測包。每隔75秒發一次，總共發9次，如果9次都失敗的話，表示連接失效。
TCP提供這種機制幫助我們判斷對端是否存活，當TCP檢測到對端不可用時，會出錯並通知上層進行處理。keepalive機制默認是關閉的，應用程序需要使用SO_KEEPALIVE進行啟用。
了解到這個知識之後，我們開始分析。在Redis的源碼中，發現有如下調用鏈：
還記得acceptTcpHandler嗎，acceptTcpHandler是TCP連接的事件處理器，當它為客戶端成功創建了TCP連接後，會通過調用createClient函數為每個連接（fd）創建一個redisClient 實例，這個redisClient 與客戶端是一一對應的。並且，還會設置一些TCP選項，如下所示。
如果用戶在Redis中沒有手動配置tcpkeepalive的話，server.tcpkeepalive = REDIS_DEFAULT_TCP_KEEPALIVE，默認為0。
由第x-x行我們可以明確，Redis伺服器與客戶端的連接默認是關閉保活機制的,因為只有當server.tcpkeepalive不為0（修改配置文件或config set）時，才能調用anetKeepAlive方法設置TCP的keepalive選項。
我們知道，Sentinel是特殊模式的Redis，我們無法使用config set命令去修改其配置，包括tcpkeepalive 參數。所以，當Sentinel啟動後，Sentinel也使用默認的tcpkeepalive ==0這個設置，不會啟用tcpkeepalive ，與客戶端的TCP連接都沒有保活機制。也就是說，Sentinel不會主動去釋放連接,哪怕是失效連接。
但是，TCP連接是雙向的，Sentinel無法處理失效連接，那Jedis客戶端呢？它是否可以主動斷掉連接？我們定位到了Jedis建立連接的函數connect()，如下所示：
由第x行可以看到，Jedis啟用了TCP的keepalive機制，並且沒有設置其他keepalive相關選項。也就是說，Jedis客戶端會採用linux默認的TCP keepalive機制，每隔7200秒去探測連接的情況。這樣，即使與Sentinel的連接出問題，Jedis客戶端也能主動釋放掉，雖然時間有點久。
但是，實際上，如前面所示，Sentinel伺服器上有很多失效連接持續保持，為什麼會有這種現象？
對於上面的問題，能想到的原因就是，在Jedis去主動釋放掉TCP連接前，該連接被強制斷掉，沒有進行完整的四次揮手的過程。而Sentinel卻因為沒有保活機制，沒有感知到這個動作，導致其一直保持這個連接。
能幹掉連接的元兇，馬上想到了防火牆，於是我又詢問了運維，結果，他們告知了我一個噩耗：
目前，生產環境上防火牆的設置是主動斷掉超過10分鍾沒有數據交換的TCP連接。
好吧，繞了一大圈，至此，問題已經很清楚了。
終於，我們得出了結論：
有了前面的分析，其實解決辦法很簡單：
關於「追蹤Redis Sentinel的CPU佔有率長期接近100%的問題」到此就結束了，在寫這兩篇博文的時候，我收貨了很多自己沒有掌握的知識和技巧。現在覺得，寫博文真的是一件值得堅持和認真對待的事情，早應該開始。不要問我為什麼，當你嘗試之後，也就和我一樣明白了。
這兩篇文章的分析過程肯定有疏漏和不足之處，個人能力有限，希望大家能夠理解，並多多指教，非常感謝！我會繼續進步！
前面提到過，在每個客戶端上，都可以發現5個正常的TCP連接，他們是什麼呢？讓我們重新回到Jedis。
在《追蹤Redis Sentinel的CPU佔有率長期接近100%的問題 一》中，我們提到Jedis SentinelPool會為每一個Sentinel建立一個MasterListener線程，該線程用來監聽主從切換，保證客戶端的Jedis句柄始終對應在Master上。在這里，即會有5個MasterListener來對應5個Sentinel。
其實，MasterListener的監聽功能根據Redis的pub sub功能實現的。MasterListener線程會去訂閱+switch-master消息，該消息會在master節點地址改變時產生，一旦產生，MasterListener就重新初始化連接池，保證客戶端使用的jedis句柄始終關聯到Master上。
如下所示為MasterListener的線程函數，它會在一個無限循環中不斷的創建Jedis句柄，利用該句柄去訂閱+switch-master消息，只要發生了主從切換，就會觸發onMessage。
如何實現訂閱功能呢，我們需要查看subscribe函數的底層實現，它實際使用client.setTimeoutInfinite()->connect建立了一個TCP連接，然後使用JedisPubSub的proceed方法去訂閱頻道，並且無限循環的讀取訂閱的信息。
在procee的方法中，實際先通過subscribe訂閱頻道，然後調用process方法讀取訂閱信息。
其實，subscribe函數就是簡單的向伺服器發送了一個SUBSCRIBE命令。
而process函數，篇幅較長，此處省略，其主要功能就是以無限循環的方式不斷地讀取訂閱信息
綜上，MasterListener線程會向Sentinel創建+switch-master頻道的TCP訂閱連接，並且會do while循環讀取該頻道信息。如果訂閱或讀取過程中出現Tcp連接異常，則釋放Jedis句柄，然後等待5000ms 後重新創建Jedis句柄進行訂閱。當然，這個過程會在一個循環之中。
至此，也就解釋了為何每個業務客戶端伺服器和Sentinel伺服器上，都有5個長期保持的、狀態正常的TCP連接的原因了。
B. redis cpu使用率怎麼查看
只需在同一台機器上啟動Redis的多個實例，將其當作不同的伺服器即可。
單一的實例在某些時候可能是不夠用的，所以如果想使用多個CPU，這就需要開始思考早期的一些數據段。
這里需要注意的是，使用Redis Pipelining在Linux系統上運行，每秒可以提供500K的請求，因此，如果應用程序主要使用O（N）或O（log（N））命令，會消耗更多的CPU。
注意
Redis
Pipelining用於解決因客戶端和伺服器的網路延遲而造成的請求延遲。
這一功能其實很早就有，即使較早版本的Redis，也能使用這個功能。
此功能可以將一系列請求連續發送到Server端，不必等待Server端的返回信息，而Server端會將請求放進一個有序的管道中，執行完成後，再一次性將返回值發送回來。
C. 京東面試官：Redis 這些我必問
緩存好處：高性能 + 高並發
資料庫查詢耗費了800ms，其他用戶對同一個數據再次查詢 ，假設該數據在10分鍾以內沒有變化過，並且 10 分鍾之內有 1000 個用戶 都查詢了同一數據，10 分鍾之內，那 1000 每個用戶，每個人查詢這個數據都感覺很慢 800ms
比如 ：某個商品信息，在 一天之內都不會改變，但是這個商品每次查詢一次都要耗費2s，一天之內被瀏覽 100W次
mysql 單機也就 2000qps,緩存單機輕松幾萬幾十萬qps,單機 承載並發量是 mysql 單機的幾十倍。
在中午高峰期，有 100W 個用戶訪問系統 A，每秒有 4000 個請求去查詢資料庫，資料庫承載每秒 4000 個請求會宕機，加上緩存後，可以 3000 個請求走緩存 ，1000 個請求走資料庫。
緩存是走內存的，內存天然可以支撐4w/s的請求，資料庫（基於磁碟）一般建議並發請求不要超過 2000/s
redis 單線程 ，memcached 多線程
redis 是單線程 nio 非同步線程模型
一個線程+一個隊列
redis 基於 reactor 模式開發了網路事件處理器，這個處理器叫做文件事件處理器，file event handler，這個文件事件處理器是單線程的，所以redis 是單線程的模型，採用 io多路復用機制同時監聽多個 socket,根據socket上的事件來選擇對應的事件處理器來處理這個事件。
文件事件處理器包含：多個 socket,io多路復用程序，文件事件分派器，事件處理器（命令請求處理器、命令恢復處理器、連接應答處理器）
文件事件處理器是單線程的，通過 io 多路復用機制監聽多個 socket，實現高性能和線程模型簡單性
被監聽的 socket 准備好執行 accept,read,write,close等操作的時候，會產生對應的文件事件，調用之前關聯好的時間處理器處理
多個 socket並發操作，產生不同的文件事件，i/o多路復用會監聽多個socket，將這些 socket放入一個隊列中排隊。事件分派器從隊列中取出socket給對應事件處理器。
一個socket時間處理完後，事件分派器才能從隊列中拿到下一個socket，給對應事件處理器來處理。
文件事件：
AE_READABLE 對應 socket變得可讀（客戶端對redis執行 write操作）
AE_WRITABLE 對應 socket 變得可寫（客戶端對 redis執行 read操作）
I/O 多路復用可以同時監聽AE_REABLE和 AE_WRITABLE ，如果同時達到則優先處理 AE_REABLE 時間
文件事件處理器：
連接應答處理器 對應 客戶端要連接 redis
命令請求處理器 對應 客戶端寫數據到 redis
命令回復處理器 對應 客戶端從 redis 讀數據
流程：
一秒鍾可以處理幾萬個請求
普通的 set,get kv緩存
類型 map結構，比如一個對象（沒有嵌套對象）緩存到 redis裡面，然後讀寫緩存的時候，可以直接操作hash的欄位（比如把 age 改成 21，其他的不變）
key=150
value = {
}
有序列表 ，元素可以重復
可以通過 list 存儲一些列表型數據結構，類似粉絲列表，文章評論列表。
例如：微信大 V的粉絲，可以以 list 的格式放在 redis 里去緩存
key=某大 V value=[zhangsan,lisi,wangwu]
比如 lrange 可以從某個元素開始讀取多少個元素，可以基於 list 實現分頁查詢功能，基於 redis實現高性能分頁，類似微博下來不斷分頁東西。
可以搞個簡單的消息隊列，從 list頭懟進去（lpush），list尾巴出來 (brpop)
無序集合，自動去重
需要對一些數據快速全局去重，（當然也可以基於 HashSet，但是單機）
基於 set 玩差集、並集、交集的操作。比如：2 個人的粉絲列表整一個交集，看看 2 個人的共同好友是誰？
把 2 個大 V 的粉絲都放在 2 個 set中，對 2 個 set做交集（sinter）
排序的 set，去重但是可以排序，寫進去的時候給一個分數，自動根據分數排序
排行榜：
zadd board score username
例如：
zadd board 85 zhangsan
zadd board 72 wangwu
zadd board 96 lis
zadd board 62 zhaoliu
自動排序為：
96 lisi
85 zhangsan
72 wangwu
62 zhaoliu
獲取排名前 3 的用戶 ： zrevrange board 0 3
96 lisi
85 zhangsan
72 wangwu
查看zhaoliu的排行 ：zrank board zhaoliu 返回 4
內存是寶貴的，磁碟是廉價的
給key設置過期時間後，redis對這批key是定期刪除+惰性刪除
定期刪除：
redis 默認每隔 100ms隨機抽取一些設置了過期時間的 key，檢查其是否過期了，如果過期就刪除。
注意：redis是每隔100ms隨機抽取一些 key來檢查和刪除，而不是遍歷所有的設置過期時間的key（否則CPU 負載會很高，消耗在檢查過期 key 上）
惰性刪除：
獲取某個key的時候， redis 會檢查一下，這個key如果設置了過期時間那麼是否過期，如果過期了則刪除。
如果定期刪除漏掉了許多過期key，然後你也沒及時去查，也沒走惰性刪除，如果大量過期的key堆積在內存里，導致 redis 內存塊耗盡，則走內存淘汰機制。
內存淘汰策略：
LRU 演算法：
緩存架構（多級緩存架構、熱點緩存）
redis 高並發瓶頸在單機，讀寫分離，一般是支撐讀高並發，寫請求少，也就 一秒一兩千，大量請求讀，一秒鍾二十萬次。
一主多從，主負責寫，將數據同步復制到其他 slave節點，從節點負責讀，所有讀的請求全部走從節點。主要是解決讀高並發。、
主從架構->讀寫分離->支撐10W+讀QPS架構
master->slave 復制，是非同步的
核心機制：
master持久化對主從架構的意義：
如果開啟了主從架構，一定要開啟 master node的持久化，不然 master宕機重啟數據是空的，一經復制，slave的數據也丟了
主從復制原理：
第一次啟動或者斷開重連情況：
正常情況下：
master 來一條數據，就非同步給 slave
全年 99.99%的時間，都是出於可用的狀態，那麼就可以稱為高可用性
redis 高可用架構叫故障轉移，failover，也可以叫做主備切換，切換的時間不可用，但是整體高可用。
sentinal node(哨兵)
作用：
quorum = 1 （代表哨兵最低個數可以嘗試故障轉移，選舉執行的哨兵）
master 宕機，只有 S2 存活，因為 quorum =1 可以嘗試故障轉移，但是沒達到 majority =2 （最低允許執行故障轉移的哨兵存活數）的標准，無法執行故障轉移
如果 M1 宕機了，S2,S3 認為 master宕機，選舉一個執行故障轉移，因為 3 個哨兵的 majority = 2，所以可以執行故障轉移
丟數據：
解決方案：
sdown 主觀宕機，哨兵覺得一個 master 宕機（ping 超過了 is-master-down-after-milliseconds毫秒數）
odown 客觀宕機，quorum數量的哨兵都覺得 master宕機
哨兵互相感知通過 redis的 pub/sub系統，每隔 2 秒往同一個 channel里發消息（自己的 host,ip,runid），其他哨兵可以消費這個消息
以及同步交換master的監控信息。
哨兵確保其他slave修改master信息為新選舉的master
當一個 master被認為 odown && marjority哨兵都同意，那麼某個哨兵會執行主備切換，選舉一個slave成為master（考慮 1. 跟master斷開連接的時長 2. slave 優先順序 3.復制 offset 4. runid）
選舉演算法：
quorum 數量哨兵認為odown->選舉一個哨兵切換->獲得 majority哨兵的授權（quorum majority 需要 majority個哨兵授權，quorum >= majority 需要 quorum 哨兵授權）
第一個選舉出來的哨兵切換失敗了，其他哨兵等待 failover-time之後，重新拿confiuration epoch做為新的version 切換，保證拿到最新配置，用於 configuration傳播（通過 pu/sub消息機制，其他哨兵對比 version 新舊更新 master配置）
高並發：主從架構
高容量：Redis集群，支持每秒幾十萬的讀寫並發
高可用：主從+哨兵
持久化的意義在於故障恢復數據備份（到其他伺服器）+故障恢復（遇到災難，機房斷電，電纜被切）
AOF 只有一個，Redis 中的數據是有一定限量的，內存大小是一定的,AOF 是存放寫命令的，當大到一定的時候，AOF 做 rewrite 操作，就會基於當時 redis 內存中的數據，來重新構造一個更小的 AOF 文件，然後將舊的膨脹很大的文件給刪掉，AOF 文件一直會被限制在和Redis內存中一樣的數據。AOF同步間隔比 RDB 小，數據更完整
優點：
缺點：
AOF 存放的指令日誌，數據恢復的時候，需要回放執行所有指令日誌，RDB 就是一份數據文件，直接載入到內存中。
優點：
缺點：
AOF 來保證數據不丟失，RDB 做不同時間的冷備
支持 N 個 Redis master node,每個 master node掛載多個 slave node
多master + 讀寫分離 + 高可用
數據量很少，高並發 -> replication + sentinal 集群
海量數據 + 高並發 + 高可用 -> redis cluster
hash演算法->一致性 hash 演算法-> redis cluster->hash slot演算法
redis cluster :自動對數據進行分片，每個 master 上放一部分數據，提供內置的高可用支持，部分master不可用時，還是可以繼續工作
cluster bus 通過 16379進行通信，故障檢測，配置更新，故障轉移授權，另外一種二進制協議，主要用於節點間進行高效數據交換，佔用更少的網路帶寬和處理時間
key進行hash，然後對節點數量取模，最大問題只有任意一個 master 宕機，大量數據就要根據新的節點數取模，會導致大量緩存失效。
key進行hash，對應圓環上一個點，順時針尋找距離最近的一個點。保證任何一個 master 宕機，只受 master 宕機那台影響，其他節點不受影響，此時會瞬間去查資料庫。
緩存熱點問題：
可能集中在某個 hash區間內的值特別多，那麼會導致大量的數據都湧入同一個 master 內，造成 master的熱點問題，性能出現瓶頸。
解決方法：
給每個 master 都做了均勻分布的虛擬節點，這樣每個區間內大量數據都會均勻的分布到不同節點內，而不是順時針全部湧入到同一個節點中。
redis cluster 有固定 16384 個 hash slot,對每個key計算 CRC16 值，然後對16384取模，可以獲取 key對應的 hash slot
redis cluster 中每個 master 都會持有部分 slot ,當一台 master 宕機時候，會最快速度遷移 hash slot到可用的機器上（只會短暫的訪問不到）
走同一個 hash slot 通過 hash tag實現
集群元數據：包括 hashslot->node之間的映射表關系，master->slave之間的關系，故障的信息
集群元數據集中式存儲（storm），底層基於zookeeper（分布式協調中間件）集群所有元數據的維護。好處：元數據的更新和讀取，時效性好，一旦變更，其他節點立刻可以感知。缺點：所有元數據的更新壓力全部集中在一個地方，可能會導致元數據的存儲有壓力。
goosip: 好處：元數據的更新比較分散，有一定的延時，降低了壓力。缺點：更新有延時，集群的一些操作會滯後。（reshared操作時configuration error）
自己提供服務的埠號+ 10000 ，每隔一段時間就會往另外幾個節點發送ping消息，同時其他幾點接收到ping之後返回pong
故障信息，節點的增加和移除， hash slot 信息
meet:某個節點發送 meet給新加入的節點，讓新節點加入集群中，然後新節點就會開始於其他節點進行通信
ping:每個節點都會頻繁給其他節點發送ping，其中包含自己的狀態還有自己維護的集群元數據，互相通過ping交換元數據
ping:返回ping和meet，包含自己的狀態和其他信息
fail:某個節點判斷另一個節點fail之後，就發送 fail 給其他節點，通知其他節點，指定的節點宕機了
ping 很頻繁，且攜帶元數據，會加重網路負擔
每個節點每秒會執行 10 次 ping，每次選擇 5 個最久沒有通信的其他節點
當如果發現某個節點通信延遲達到了 cluster_node_timeout /2 ，那麼立即發送 ping， 避免數據交換延遲過長，落後時間太長（2 個節點之間 10 分鍾沒有交換數據，整個集群處於嚴重的元數據不一致的情況）。
每次ping，一個是帶上自己的節點信息，還有就是帶上1/10其他節點的信息，發送出去，進行數據交換
至少包含 3 個其他節點信息，最多包含總節點-2 個其他節點的信息
客戶端發送到任意一個redis實例發送命令，每個redis實例接受到命令後，都會計算key對應的hash slot，如果在本地就本地處理，否則返回moved給客戶端，讓客戶端進行重定向 （redis-cli -c）
通過tag指定key對應的slot,同一個 tag 下的 key，都會在一個 hash slot中，比如 set key1:{100} 和 set key2:{100}
本地維護一份hashslot->node的映射表。
JedisCluster 初始化的時候，隨機選擇一個 node，初始化 hashslot->node 映射表，同時為每個節點創建一個JedisPool連接池，每次基於JedisCluster執行操作，首先JedisCluster都會在本地計算key的hashslot，然後再本地映射表中找到對應的節點，如果發現對應的節點返回moved，那麼利用該節點的元數據，更新 hashslot->node映射表（重試超過 5 次報錯）
hash slot正在遷移，那麼會返回ask 重定向給jedis,jedis 接受到ask重定向之後，，會重定向到目標節點去執行
判斷節點宕機：
如果一個節點認為另外一個節點宕機了， 就是pfail,主觀宕機
如果多個節點都認為另外一個節點宕機了，那麼就是fail，客觀宕機（跟哨兵原理一樣）
在cluster-node-timeout內，某個節點一直沒有返回 pong,那麼就被認為是 pfail
如果一個節點認為某個節點pfail了，那麼會在gossip消息中，ping給其他節點，如果超過半數的節點認為pfail了，那麼就會變成fail。
從節點過濾：
對宕機的 mster node ，從其所有的 slave node中，選擇一個切換成 master node
檢查每個 slave node與master node斷開連接的時間，如果超過了cluster-node-timeout * cluster-slave-validity-factor，那麼就沒資格切換成 master（和哨兵一致）
從節點選舉：
每個從節點，根據自己對 master 復制數據的 offset，設置一個選舉時間，offset越大（復制數據越多）的從節點，選舉時間越靠前，所有的 master node 開始投票，給要進行選舉的 slave進行投票，如果大部分 master node(N/2 +1) 都投票給某個從節點，那麼選舉通過，從節點執行主備切換，從節點切換成主節點
總結：和哨兵很像，直接集成了 replication 和 sentinal
方案：
事前：保證 redis 集群高可用性 （主從+哨兵或 redis cluster），避免全盤崩潰
事中：本地 ehcache 緩存 + hystrix 限流（保護資料庫） & 降級，避免 MySQL被打死
事後： redis持久化，快速恢復緩存數據，繼續分流高並發請求
限制組件每秒就 2000 個請求通過限流組件進入資料庫，剩餘的 3000 個請求走降級，返回一些默認 的值，或者友情提示
好處 ：
4000 個請求黑客攻擊請求資料庫里沒有的數據
解決方案：把黑客查資料庫中不存在的數據的值，寫到緩存中，比如： set -999 UNKNOWN
讀的時候，先讀緩存，緩存沒有，就讀資料庫，然後取出數據後放入緩存，同時返回響應
更新的時候，刪除緩存，更新資料庫
為什麼不更新緩存：
更新緩存代價太高（更新 20 次，只讀 1 次），lazy思想，需要的時候再計算，不需要的時候不計算
方案：先刪除緩存，再修改資料庫
方案：寫，讀路由到相同的一個內存隊列（唯一標識，hash，取模）里，更新和讀操作進行串列化（後台線程非同步執行隊列串列化操作），（隊列里只放一個更新查詢操作即可，多餘的過濾掉，內存隊列里沒有該數據更新操作，直接返回 ）有該數據更新操作則輪詢取緩存值，超時取不到緩存值，直接取一次資料庫的舊值
TP 99 意思是99%的請求可以在200ms內返回
注意點：多個商品的更新操作都積壓在一個隊列裡面（太多操作積壓只能增加機器），導致讀請求發生大量的超時，導致大量的讀請求走資料庫
一秒 500 寫操作，每200ms，100 個寫操作，20 個內存隊列，每個隊列積壓 5 個寫操作，一般在20ms完成
方案：分布式鎖 + 時間戳比較
10台機器，5 主 5 從，每個節點QPS 5W ，一共 25W QPS（Redis cluster 32G + 8 核 ，Redis 進程不超過 10G）總內存 50g，每條數據10kb，10W 條數據1g，200W 條數據 20G，佔用總內存不到50%，目前高峰期 3500 QPS
作者： mousycoder
D. redis cpu綁定
1.啟動時綁定
taskset -c 0 /usr/local/bin/redis-server /etc/redis/redis.conf
2.運行中綁定
3.redis cpu綁定查看
E. redis 線上問題排查思路總結
日常我們使用redis 緩存時，經常會遇到各種各樣的問題，其中redis 偶發性連接超時，是經常遇到的一個問題，下面介紹一下我們之前是如何處理的這個問題。
1、redis 服務監控
通過監控工具，首先排查一下redis 服務端是否是超時，可以從伺服器cpu ，內存使用情況，qps等判斷server 端是否超時。如果server 側沒有問題，就需要排查客戶端。如果server 側存在問題，就需要排查伺服器哪裡出了問題，單機性能使用率太高是否可以升級成哨兵模式或者高可用集群模式。
2、redis 客戶端排查
首先查看業務日誌，查看一下redis 使用情況是否是存在連接數占滿或者創建失敗的異常，如果存在，在客戶端伺服器，使用top 指令，查看使用率高的線程，然後jstack pid,查看當前線程的使用情況。如果出現大量的線程狀態顯示time_waiting 或者waiting 。則表示連接數一直沒有釋放，可以通過調整客戶端配置的redis 連接池參數，比如配置max連接數和min連接數，time_out超時時間等等。
3、redis 熱key排查
排查redis 熱key,騰訊雲或者阿里雲伺服器可以使用監控熱key的工具。redis 4.0 以後，提供了—hotkey 指令，可以通過熱key 指令來監控熱key。如果發現異常熱key,比如spring-redis-session的熱key,存儲的是一段時間戳，並且訪問率非常高，qps 幾十萬/s。這時候需要考慮熱key是否對業務產生影響，可以通過配置spring.session.store-type=none，關閉存儲redis.這時候熱key訪問量下降，業務key 可以正常訪問。
通過以上方式，排查生產中遇到的redis 連接問題，可以排查線上遇到的問題，基本都可以解決掉。
F. 如何實現高可用的 redis 集群
Redis 因具有豐富的數據結構和超高的性能以及簡單的協議，使其能夠很好的作為資料庫的上游緩存層。但在大規模的 Redis 使用過程中，會受限於多個方面：單機內存有限、帶寬壓力、單點問題、不能動態擴容等。
基於以上， Redis 集群方案顯得尤為重要。通常有 3 個途徑：官方 Redis Cluster ；通過 Proxy 分片；客戶端分片 (Smart Client) 。以上三種方案各有利弊。
Redis Cluster( 官方 ) ：雖然正式版發布已經有一年多的時間，但還缺乏最佳實踐；對協議進行了較大修改，導致主流客戶端也並非都已支持，部分支持的客戶端也沒有經過大規模生產環境的驗證；無中心化設計使整個系統高度耦合，導致很難對業務進行無痛的升級。
Proxy ：現在很多主流的 Redis 集群都會使用 Proxy 方式，例如早已開源的 Codis 。這種方案有很多優點，因為支持原聲 redis 協議，所以客戶端不需要升級，對業務比較友好。並且升級相對平滑，可以起多個 Proxy 後，逐個進行升級。但是缺點是，因為會多一次跳轉，平均會有 30% 左右的性能開銷。而且因為原生客戶端是無法一次綁定多個 Proxy ，連接的 Proxy 如果掛了還是需要人工參與。除非類似 Smart Client 一樣封裝原有客戶端，支持重連到其他 Proxy ，但這也就帶來了客戶端分片方式的一些缺點。並且雖然 Proxy 可以使用多個，並且可以動態增加 proxy 增加性能，但是所有客戶端都是共用所有 proxy ，那麼一些異常的服務有可能影響到其他服務。為每個服務獨立搭建 proxy ，也會給部署帶來額外的工作。
而我們選擇了第三種方案，客戶端分片 (Smart Client) 。客戶端分片相比 Proxy 擁有更好的性能，及更低的延遲。當然也有缺點，就是升級需要重啟客戶端，而且我們需要維護多個語言的版本，但我們更愛高性能。
下面我們來介紹一下我們的Redis集群：
概貌：
如圖0所示，
我們的 Redis 集群一共由四個角色組成:
Zookeeper ：保存所有 redis 集群的實例地址， redis 實例按照約定在特定路徑寫入自身地址，客戶端根據這個約定查找 redis 實例地址，進行讀寫。
Redis 實例：我們修改了 redis 源碼，當 redis 啟動或主從切換時，按照約定自動把地址寫到 zookeeper 特定路徑上。
Sentinel ： redis 自帶的主從切換工具，我們通過 sentinel 實現集群高可用。
客戶端（ Smart Client ）：客戶端通過約定查找 redis 實例在 ZooKeeper 中寫入的地址。並且根據集群的 group 數，進行一致性哈希計算，確定 key 唯一落入的 group ，隨後對這個 group 的主庫進行操作。客戶端會在Z ooKeeper 設置監視，當某個 group 的主庫發生變化時，Z ooKeeper 會主動通知客戶端，客戶端會更新對應 group 的最新主庫。
我們的Redis 集群是以業務為單位進行劃分的，不同業務使用不同集群（即業務和集群是一對一關系）。一個 Redis 集群會由多個 group 組成 ( 一個 group 由一個主從對 redis 實例組成 ) 。即 group 越多，可以部署在更多的機器上，可利用的內存、帶寬也會更多。在圖0中，這個業務使用的 redis 集群由 2 個 group 組成，每個 group 由一對主從實例組成。
Failover
如圖1所示，
當 redis 啟動時，會 把自己的 IP:Port 寫入到 ZooKeeper 中。其中的 主實例模式啟動時會在 /redis/ 業務名 / 組名 永久節點寫入自己的 IP:Port （如果節點不存在則創建）。由 主模式 變成 從模式 時，會創建 /redis/ 業務名 / 組名 /slaves/ip:port 臨時節 點，並寫入自己的 IP:Port （如果相同節點已經存在，則先刪除，再創建）。而從實例 模式 啟動時會創建 /redis/ 業務名 / 組名 /slaves/ip:port 臨時節點，並寫入自己的 ip:port （如果相同節點已經存在，則先刪除，再創建）。由 從模式 變成 主模式 時，先刪除 /redis/ 業務名 / 組名 /slaves/ip:port 臨時節點，並在 /redis/ 業務名 / 組名 永久節點寫入自己的 IP:Port 。
ZooKeeper 會一直保存當前有效的 主從實例 IP:Port 信息。至於主從自動切換過程，使用 redis 自帶的 sentinel 實現，現設置為超過 30s 主 server 無響應，則由 sentinel 進行主從實例的切換，切換後就會觸發以主、從實例通過以上提到的一系列動作，從而完成最終的切換。
而客戶端側通過給定業務名下的所有 groupName 進行一致性哈希計算，確定 key 落入哪個組。 客戶端啟動時，會從 ZooKeeper 獲取指定業務名下所有 group 的 主從 IP:Port ，並在 ZooKeeper 中設置監視（監視的作用是當 ZooKeeper 的節點發生變化時，會主動通知客戶端）。若客戶端從 Zookeeper 收到節點變化通知，會重新獲取最新的 主從 I:Port ，並重新設置監視（ ZooKeeper 監視是一次性的）。通過此方法，客戶端可以實時獲知當前可訪問最新的 主從 IP:Port 信息。
因為我們的所有 redis 實例信息都按照約定保存在 ZooKeeper 上，所以不需要針對每個實例部署監控，我們編寫了一個可以自動通過 ZooKeeper 獲取所有 redis 實例信息，並且監控 cpu 、 qps 、內存、主從延遲、主從切換、連接數等的工具。
發展：
現在 redis 集群在某些業務內存需求超過預期很多後，無法通過動態擴容進行擴展。所以我們正在做動態擴容的支持。原先的客戶端我們是通過一致性哈希進行 key 的
路由策略，但這種方式在動態擴容時會略顯復雜，所以我們決定採用實現起來相對簡單的預分片方式。一致性哈希的好處是可以無限擴容，而預分片則不是。預分片
時我們會在初始化階段指定一個集群的所有分片數量，這個數量一旦指定就不能再做改變，這個預分片數量就是後續可以擴容到最大的 redis 實例數。假設預分片 128 個 slot ，每個實例 10G 也可以達到 TB 級別的集群，對於未來數據增長很大的集群我們可以預分片 1024 ，基本可以滿足所有大容量內存需求了。
原先我們的 redis 集群有四種角色， Smart Client, redis ， sentinel ， ZooKeeper 。為了支持動態擴容，我們增加了一個角色， redis_cluster_manager （以下簡稱 manager ），用於管理 redis 集群。主要工作是初始化集群（即預分片），增加實例後負責修改Z ooKeeper 狀態，待客戶端做好准備後遷移數據到新增實例上。為了盡量減少數據遷移期間對現性能帶來的影響，我們每次只會遷移一個分片的數據，待遷移完成，再進行下一個分片的遷移。
如圖2所示
相比原先的方案，多了 slots 、M anager Lock 、 clients 、M igrating Clients 節點。
Slots: 所有分片會把自身信息寫入到 slots 節點下面。 Manager 在初始化集群時，根據設置的分片數，以及集群下的 group 數，進行預分片操作，把所有分片均勻分配給已有 group 。分片的信息由一個 json 串組成，記錄有分片的狀態 (stats) ，當前擁有此分片的 group(src) ，需要遷移到的 group(dst) 。分片的狀態一共有三種： online 、 pre_migrate 、 migrating 。
Online 指這個分片處於正常狀態，這時 dst 是空值，客戶端根據 src 的 group 進行讀寫。
Pre_migrate 是指這個分片被 manager 標記為需要遷移，此時 dst 仍然為空， manager 在等所有 client 都已經准備就緒，因為 ZooKeeper 回掉所有客戶端有時間差，所以如果某些 client 沒有準備就緒的時候 manager 進行了數據遷移，那麼就會有數據丟失。
Migrating 是 manager 確認了所有客戶端都已經做好遷移准備後，在 dst 寫入此分片需要遷移的目標 group 。待遷移完成，會在 src 寫入目標 group_name ， dst 設為空， stats 設為 online 。
Manager Lock： 因為我們是每次只允許遷移一個 slot ，所以不允許超過一個 manager 操作一個集群。所以 manager 在操作集群前，會在M anager Lock 下注冊臨時節點，代表這個集群已經有 manager 在操作了，這樣其他 manager 想要操作這個集群時就會自動退出。
Clients 和M igrating Clients 是為了讓 manager 知道客戶端是否已經准備就緒的節點。客戶端通過 uid 代表自己，格式是 客戶端語言 _ 主機名 _pid 。當集群沒有進行遷移，即所有分片都是 online 的時候，客戶端會在 clients 下創建 uid 的臨時節點。
當某個 slot 從 online 變成 pre_migrate 後，客戶端會刪除 clients 下的 uid 臨時節點，然後在M igrating Clients 創建 uid 臨時節點。注意，因為需要保證數據不丟失，從 pre_migrate 到 migrating 期間，這個 slot 是被鎖定的，即所有對這個 slot 的讀寫都會被阻塞。所以 mananger 會最多等待 10s ，確認所有客戶端都已經切換到准備就緒狀態，如果發現某個客戶端一直未准備就緒，那麼 mananger 會放棄此次遷移，把 slot 狀態由 pre_migrate 改為 online 。如果客戶端發現 slot 狀態由 pre_migrate 變成 online 了，那麼會刪除 migrating_clients 下的 uid 節點，在 clients 下重新創建 uid 節點。還需要注意的一點是，有可能一個客戶剛啟動，並且正在往 clients 下創建 uid 節點，但是因為網路延遲還沒創建完成，導致 manager 未確認到這個 client 是否准備就緒，所以 mananger 把 slot 改為 pre_migrate 後會等待 1s 再確認所有客戶端是否准備就緒。
如果 Manager 看到 clients 下已經沒有客戶端的話（都已經准備就緒），會把 slot 狀態改為 migrating 。 Slot 變成 migrating 後，鎖定也隨之解除， manager 會遍歷 src group 的數據，把對應 slot 的數據遷移到 dst group 里。客戶端在 migrating 期間如果有讀寫 migrating slot 的 key ，那麼客戶端會先把這個 key 從 src group 遷移到 dst group ，然後再做讀寫操作。即這期間客戶端性能會有所下降。這也是為什麼每次只遷移一個 slot 的原因。這樣即使只有 128 個分片的集群，在遷移期間受到性能影響的 key 也只有 1/128 ，是可以接受的。
Manager 發現已經把 slot 已經遷移完畢了，會在 src 寫入目標 group_name ， dst 設為空， stats 設為 online 。客戶端也刪除 migrating_clients 下的 uid ，在 clients 下創建 uid 節點。
G. Redis變慢了(八) - 網卡負載過高
如果以上產生性能問題的場景，你都規避掉了，而且Redis也穩定運行了很長時間，但在某個時間點之後開始，訪問Redis開始變慢了，而且一直持續到現在，這種情況是什麼原因導致的？
之前我們就遇到這種問題， 特點就是從某個時間點之後就開始變慢，並且一直持續 。這時你需要檢查一下機器的網卡流量，是否存在網卡流量被跑滿的情況。
網卡負載過高，在網路層和TCP層就會出現數據發送延遲、數據丟包等情況。Redis的高性能除了內存之外，就在於網路IO，請求量突增會導致網卡負載變高。
如果出現這種情況，你需要排查這個機器上的哪個Redis實例的流量過大占滿了網路帶寬，然後確認流量突增是否屬於業務正常情況，如果屬於那就需要及時擴容或遷移實例，避免這個機器的其他實例受到影響。
運維層面，我們需要對機器的各項指標增加監控，包括網路流量，在達到閾值時提前報警，及時與業務確認並擴容。
以上我們總結了Redis中常見的可能導致延遲增大甚至阻塞的場景，這其中既涉及到了業務的使用問題，也涉及到Redis的運維問題。
可見，要想保證Redis高性能的運行，其中涉及到CPU、內存、網路，甚至磁碟的方方面面，其中還包括操作系統的相關特性的使用。
作為開發人員，我們需要了解Redis的運行機制，例如各個命令的執行時間復雜度、數據過期策略、數據淘汰策略等，使用合理的命令，並結合業務場景進行優化。
作為DBA運維人員，需要了解數據持久化、操作系統fork原理、Swap機制等，並對Redis的容量進行合理規劃，預留足夠的機器資源，對機器做好完善的監控，才能保證Redis的穩定運行。
H. 四個大點，搞懂 Redis 到底快在哪裡
現在我們都用高級語言來編程，比如Java、python等。也許你會覺得C語言很古老，但是它真的很有用，畢竟unix系統就是用C實現的，所以C語言是非常貼近操作系統的語言。Redis就是用C語言開發的，所以執行會比較快。
Redis將所有數據放在內存中，非數據同步正常工作中，是不需要從磁碟讀取數據的，0次IO。內存響應時間大約為100納秒，這是Redis速度快的重要基礎。先看看CPU的速度：
拿我的電腦來說，主頻是3.1G，也就是說每秒可以執行3.1*10^9個指令。所以說CPU看世界是非常非常慢的，內存比它慢百倍，磁碟比他慢百萬倍，你說快不快？
借了一張《深入理解計算機系統》的圖，展示了一個典型的存儲器層次結構，在L0層，CPU可以在一個時鍾周期訪問到，基於SRAM的高速緩存春續期，可以在幾個CPU時鍾周期訪問到，然後是基於DRAM的主存，可以在幾十到幾百個時鍾周期訪問到他們。
第一，單線程簡化演算法的實現，並發的數據結構實現不但困難且測試也麻煩。第二，單線程避免了線程切換以及加鎖釋放鎖帶來的消耗，對於服務端開發來說，鎖和線程切換通常是性能殺手。當然了，單線程也會有它的缺點，也是Redis的噩夢： 阻塞。如果執行一個命令過長，那麼會造成其他命令的阻塞，對於Redis是十分致命的 ，所以Redis是面向快速執行場景的資料庫。
除了Redis之外，Node.js也是單線程，Nginx也是單線程，但他們都是伺服器高性能的典範。
在這之前先要說一下傳統的阻塞I/O是如何工作的：當使用read或者write對某一文件描述符（File Descriptor FD）進行讀寫的時候，如果數據沒有收到，那麼該線程會被掛起，直到收到數據。阻塞模型雖然易於理解，但是在需要處理多個客戶端任務的時候，不會使用阻塞模型。
I/O多路復用實際上是指多個連接的**管理可以在同一進程。**多路是指網路連接，復用只是同一個線程。在網路服務中，I/O多路復用起的作用是一次性把多個連接的事件通知業務代碼處理，處理的方式由業務代碼來決定。在I/O多路復用模型中，最重要的函數調用就是I/O 多路復用函數，該方法能同時監控多個文件描述符（fd）的讀寫情況，當其中的某些fd可讀/寫時，該方法就會返回可讀/寫的fd個數。
Redis使用epoll作為I/O多路復用技術的實現，再加上Redis自身的事件處理模型將epoll的read、write、close等都轉換成事件，不在網路I/O上浪費過多的時間。實現對多個FD讀寫的監控，提高性能。
舉個形象的例子吧。比如一個tcp伺服器處理20個客戶端socket。A方案：順序處理，如果第一個socket因為網卡讀數據處理慢了，一阻塞後面都玩蛋去。B方案：每個socket請求都創建一個分身子進程來處理，不說每個進程消耗大量系統資源，光是進程切換就夠操作系統累的了。C方案**（I/O復用模型，epoll） ：將用戶socket對應的fd注冊進epoll（實際上伺服器和操作系統之間傳遞的不是socket的fd而是fd_set的數據結構），然後epoll只告訴哪些需要讀/寫的socket，只需要處理那些活躍的、有變化的socket fd的就好了。這樣，整個過程只在調用epoll的時候才會阻塞，收發客戶消息是不會阻塞的。
:-D 搜索微信號（ID： 芋道源碼 ），可以獲得各種 Java 源碼解析、原理講解、面試題、學習指南。
:-D 並且，回復【 書籍 】後，可以領取筆者推薦的各種 Java 從入門到架構的 100 本書籍。
:-D 並且，回復【 技術群 】後，可以加入專門討論 Java、後端、架構的技術群。
I. Redis常見延遲問題排查手冊！附33條優化建議
Redis作為內存資料庫，擁有非常高的性能，單個實例的QPS能夠達到10W左右。但我們在使用Redis時，經常時不時會出現訪問延遲很大的情況，如果你不知道Redis的內部實現原理，在排查問題時就會一頭霧水。
很多時候，Redis出現訪問延遲變大，都與我們的使用不當或運維不合理導致的。
下面我們就來分析一下Redis在使用過程中，經常會遇到的延遲問題以及如何定位和分析。
如果在使用Redis時，發現訪問延遲突然增大，如何進行排查？
首先，第一步，建議你去查看一下Redis的慢日誌。Redis提供了慢日誌命令的統計功能，我們通過以下設置，就可以查看有哪些命令在執行時延遲比較大。
首先設置Redis的慢日誌閾值，只有超過閾值的命令才會被記錄，這里的單位是微妙，例如設置慢日誌的閾值為5毫秒，同時設置只保留最近1000條慢日誌記錄：
# 命令執行超過5毫秒記錄慢日誌
CONFIG SET slowlog-log-slower-than 5000
# 只保留最近1000條慢日誌
CONFIG SET slowlog-max-len 1000
設置完成之後，所有執行的命令如果延遲大於5毫秒，都會被Redis記錄下來，我們執行SLOWLOG get 5查詢最近5條慢日誌：
127.0.0.1:6379> SLOWLOG get 5
1) 1) (integer) 32693 # 慢日誌ID
2) (integer) 1593763337 # 執行時間
3) (integer) 5299 # 執行耗時(微妙)
4) 1) 'LRANGE' # 具體執行的命令和參數
2) 'user_list_2000'
3) Ɔ'
4) '-1'
2) 1) (integer) 32692
2) (integer) 1593763337
3) (integer) 5044
4) 1) 'GET'
2) 'book_price_1000'
...
通過查看慢日誌記錄，我們就可以知道在什麼時間執行哪些命令比較耗時， 如果你的業務經常使用O(n)以上復雜度的命令， 例如sort、sunion、zunionstore，或者在執行O(n)命令時操作的數據量比較大，這些情況下Redis處理數據時就會很耗時。
如果你的服務請求量並不大，但Redis實例的CPU使用率很高，很有可能是使用了復雜度高的命令導致的。
解決方案就是，不使用這些復雜度較高的命令，並且一次不要獲取太多的數據，每次盡量操作少量的數據，讓Redis可以及時處理返回。
如果查詢慢日誌發現，並不是復雜度較高的命令導致的，例如都是SET、DELETE操作出現在慢日誌記錄中，那麼你就要懷疑是否存在Redis寫入了大key的情況。
Redis在寫入數據時，需要為新的數據分配內存，當從Redis中刪除數據時，它會釋放對應的內存空間。
如果一個key寫入的數據非常大，Redis 在分配內存時也會比較耗時。 同樣的，當刪除這個key的數據時， 釋放內存也會耗時比較久。
你需要檢查你的業務代碼，是否存在寫入大key的情況，需要評估寫入數據量的大小，業務層應該避免一個key存入過大的數據量。
那麼有沒有什麼辦法可以掃描現在Redis中是否存在大key的數據嗎？
Redis也提供了掃描大key的方法：
redis-cli -h $host -p $port --bigkeys -i 0.01
使用上面的命令就可以掃描出整個實例key大小的分布情況，它是以類型維度來展示的。
需要注意的是當我們在線上實例進行大key掃描時，Redis的QPS會突增，為了降低掃描過程中對Redis的影響，我們需要控制掃描的頻率，使用-i參數控制即可，它表示掃描過程中每次掃描的時間間隔，單位是秒。
使用這個命令的原理，其實就是Redis在內部執行scan命令，遍歷所有key，然後針對不同類型的key執行strlen、llen、hlen、scard、zcard來獲取字元串的長度以及容器類型(list/dict/set/zset)的元素個數。
而對於容器類型的key，只能掃描出元素最多的key，但元素最多的key不一定佔用內存最多，這一點需要我們注意下。不過使用這個命令一般我們是可以對整個實例中key的分布情況有比較清晰的了解。
針對大key的問題，Redis官方在4.0版本推出了lazy-free的機制，用於非同步釋放大key的內存，降低對Redis性能的影響。即使這樣，我們也不建議使用大key，大key在集群的遷移過程中，也會影響到遷移的性能，這個後面在介紹集群相關的文章時，會再詳細介紹到。
有時你會發現，平時在使用Redis時沒有延時比較大的情況，但在某個時間點突然出現一波延時，而且 報慢的時間點很有規律，例如某個整點，或者間隔多久就會發生一次。
如果出現這種情況，就需要考慮是否存在大量key集中過期的情況。
如果有大量的key在某個固定時間點集中過期，在這個時間點訪問Redis時，就有可能導致延遲增加。
Redis的過期策略採用主動過期+懶惰過期兩種策略：
注意， Redis的主動過期的定時任務，也是在Redis主線程中執行的 ，也就是說如果在執行主動過期的過程中，出現了需要大量刪除過期key的情況，那麼在業務訪問時，必須等這個過期任務執行結束，才可以處理業務請求。此時就會出現，業務訪問延時增大的問題，最大延遲為25毫秒。
而且這個訪問延遲的情況， 不會記錄在慢日誌里。 慢日誌中 只記錄真正執行某個命令的耗時 ，Redis主動過期策略執行在操作命令之前，如果操作命令耗時達不到慢日誌閾值，它是不會計算在慢日誌統計中的，但我們的業務卻感到了延遲增大。
此時你需要檢查你的業務，是否真的存在集中過期的代碼，一般集中過期使用的命令是expireat或pexpireat命令，在代碼中搜索這個關鍵字就可以了。
如果你的業務確實需要集中過期掉某些key，又不想導致Redis發生抖動，有什麼優化方案？
解決方案是， 在集中過期時增加一個隨機時間，把這些需要過期的key的時間打散即可。
偽代碼可以這么寫：
# 在過期時間點之後的5分鍾內隨機過期掉
redis.expireat(key, expire_time + random(300))
這樣Redis在處理過期時，不會因為集中刪除key導致壓力過大，阻塞主線程。
另外，除了業務使用需要注意此問題之外，還可以通過運維手段來及時發現這種情況。
我們需要對這個指標監控，當在 很短時間內這個指標出現突增 時，需要及時報警出來，然後與業務報慢的時間點對比分析，確認時間是否一致，如果一致，則可以認為確實是因為這個原因導致的延遲增大。
有時我們把Redis當做純緩存使用，就會給實例設置一個內存上限maxmemory，然後開啟LRU淘汰策略。
當實例的內存達到了maxmemory後，你會發現之後的每次寫入新的數據，有可能變慢了。
導致變慢的原因是，當Redis內存達到maxmemory後，每次寫入新的數據之前，必須先踢出一部分數據，讓內存維持在maxmemory之下。
這個踢出舊數據的邏輯也是需要消耗時間的，而具體耗時的長短，要取決於配置的淘汰策略：
具體使用哪種策略，需要根據業務場景來決定。
我們最常使用的一般是allkeys-lru或volatile-lru策略，它們的處理邏輯是，每次從實例中隨機取出一批key（可配置），然後淘汰一個最少訪問的key，之後把剩下的key暫存到一個池子中，繼續隨機取出一批key，並與之前池子中的key比較，再淘汰一個最少訪問的key。以此循環，直到內存降到maxmemory之下。
如果使用的是allkeys-random或volatile-random策略，那麼就會快很多，因為是隨機淘汰，那麼就少了比較key訪問頻率時間的消耗了，隨機拿出一批key後直接淘汰即可，因此這個策略要比上面的LRU策略執行快一些。
但以上這些邏輯都是在訪問Redis時，真正命令執行之前執行的，也就是它會影響我們訪問Redis時執行的命令。
另外，如果此時Redis實例中有存儲大key，那麼在淘汰大key釋放內存時，這個耗時會更加久，延遲更大，這需要我們格外注意。
如果你的業務訪問量非常大，並且必須設置maxmemory限制實例的內存上限，同時面臨淘汰key導致延遲增大的的情況，要想緩解這種情況，除了上面說的避免存儲大key、使用隨機淘汰策略之外，也可以考慮拆分實例的方法來緩解，拆分實例可以把一個實例淘汰key的壓力分攤到多個實例上，可以在一定程度降低延遲。
如果你的Redis開啟了自動生成RDB和AOF重寫功能，那麼有可能在後台生成RDB和AOF重寫時導致Redis的訪問延遲增大，而等這些任務執行完畢後，延遲情況消失。
遇到這種情況，一般就是執行生成RDB和AOF重寫任務導致的。
生成RDB和AOF都需要父進程fork出一個子進程進行數據的持久化，在fork執行過程中，父進程需要拷貝內存頁表給子進程，如果整個實例內存佔用很大，那麼需要拷貝的內存頁表會比較耗時，此過程會消耗大量的CPU資源，在完成fork之前，整個實例會被阻塞住，無法處理任何請求，如果此時CPU資源緊張，那麼fork的時間會更長，甚至達到秒級。這會嚴重影響Redis的性能。
具體原理也可以參考我之前寫的文章：Redis持久化是如何做的？RDB和AOF對比分析。
我們可以執行info命令，查看最後一次fork執行的耗時latest_fork_usec，單位微妙。這個時間就是整個實例阻塞無法處理請求的時間。
除了因為備份的原因生成RDB之外，在 主從節點第一次建立數據同步時 ，主節點也會生成RDB文件給從節點進行一次全量同步，這時也會對Redis產生性能影響。
要想避免這種情況，我們需要規劃好數據備份的周期，建議 在從節點上執行備份，而且最好放在低峰期執行。 如果對於丟失數據不敏感的業務，那麼不建議開啟AOF和AOF重寫功能。
另外，fork的耗時也與系統有關，如果把Redis部署在虛擬機上，那麼這個時間也會增大。所以使用Redis時建議部署在物理機上，降低fork的影響。
很多時候，我們在部署服務時，為了提高性能，降低程序在使用多個CPU時上下文切換的性能損耗，一般會採用進程綁定CPU的操作。
但在使用Redis時，我們不建議這么干，原因如下。
綁定CPU的Redis，在進行數據持久化時，fork出的子進程，子進程會繼承父進程的CPU使用偏好，而此時子進程會消耗大量的CPU資源進行數據持久化，子進程會與主進程發生CPU爭搶，這也會導致主進程的CPU資源不足訪問延遲增大。
所以在部署Redis進程時，如果需要開啟RDB和AOF重寫機制，一定不能進行CPU綁定操作！
上面提到了，當執行AOF文件重寫時會因為fork執行耗時導致Redis延遲增大，除了這個之外，如果開啟AOF機制，設置的策略不合理，也會導致性能問題。
開啟AOF後，Redis會把寫入的命令實時寫入到文件中，但寫入文件的過程是先寫入內存，等內存中的數據超過一定閾值或達到一定時間後，內存中的內容才會被真正寫入到磁碟中。
AOF為了保證文件寫入磁碟的安全性，提供了3種刷盤機制：
當使用第一種機制appendfsync always時，Redis每處理一次寫命令，都會把這個命令寫入磁碟，而且 這個操作是在主線程中執行的。
內存中的的數據寫入磁碟，這個會加重磁碟的IO負擔，操作磁碟成本要比操作內存的代價大得多。如果寫入量很大，那麼每次更新都會寫入磁碟，此時機器的磁碟IO就會非常高，拖慢Redis的性能，因此我們不建議使用這種機制。
與第一種機制對比，appendfsync everysec會每隔1秒刷盤，而appendfsync no取決於操作系統的刷盤時間，安全性不高。因此我們推薦使用appendfsync everysec這種方式，在最壞的情況下，只會丟失1秒的數據，但它能保持較好的訪問性能。
當然，對於有些業務場景，對丟失數據並不敏感，也可以不開啟AOF。
如果你發現Redis突然變得非常慢， 每次訪問的耗時都達到了幾百毫秒甚至秒級 ，那此時就檢查Redis是否使用到了Swap，這種情況下Redis基本上已經無法提供高性能的服務。
我們知道，操作系統提供了Swap機制，目的是為了當內存不足時，可以把一部分內存中的數據換到磁碟上，以達到對內存使用的緩沖。
但當內存中的數據被換到磁碟上後，訪問這些數據就需要從磁碟中讀取，這個速度要比內存慢太多！
尤其是針對Redis這種高性能的內存資料庫來說，如果Redis中的內存被換到磁碟上，對於Redis這種性能極其敏感的資料庫，這個操作時間是無法接受的。
我們需要檢查機器的內存使用情況，確認是否確實是因為內存不足導致使用到了Swap。
如果確實使用到了Swap，要及時整理內存空間，釋放出足夠的內存供Redis使用，然後釋放Redis的Swap，讓Redis重新使用內存。
釋放Redis的Swap過程通常要重啟實例，為了避免重啟實例對業務的影響，一般先進行主從切換，然後釋放舊主節點的Swap，重新啟動服務，待數據同步完成後，再切換回主節點即可。
可見，當Redis使用到Swap後，此時的Redis的高性能基本被廢掉，所以我們需要提前預防這種情況。
我們需要對Redis機器的內存和Swap使用情況進行監控，在內存不足和使用到Swap時及時報警出來，及時進行相應的處理。
如果以上產生性能問題的場景，你都規避掉了，而且Redis也穩定運行了很長時間，但在某個時間點之後開始，訪問Redis開始變慢了，而且一直持續到現在，這種情況是什麼原因導致的？
之前我們就遇到這種問題， 特點就是從某個時間點之後就開始變慢，並且一直持續。 這時你需要檢查一下機器的網卡流量，是否存在網卡流量被跑滿的情況。
網卡負載過高，在網路層和TCP層就會出現數據發送延遲、數據丟包等情況。Redis的高性能除了內存之外，就在於網路IO，請求量突增會導致網卡負載變高。
如果出現這種情況，你需要排查這個機器上的哪個Redis實例的流量過大占滿了網路帶寬，然後確認流量突增是否屬於業務正常情況，如果屬於那就需要及時擴容或遷移實例，避免這個機器的其他實例受到影響。
運維層面，我們需要對機器的各項指標增加監控，包括網路流量，在達到閾值時提前報警，及時與業務確認並擴容。
以上我們總結了Redis中常見的可能導致延遲增大甚至阻塞的場景，這其中既涉及到了業務的使用問題，也涉及到Redis的運維問題。
可見，要想保證Redis高性能的運行，其中涉及到CPU、內存、網路，甚至磁碟的方方面面，其中還包括操作系統的相關特性的使用。
作為開發人員，我們需要了解Redis的運行機制，例如各個命令的執行時間復雜度、數據過期策略、數據淘汰策略等，使用合理的命令，並結合業務場景進行優化。
作為DBA運維人員，需要了解數據持久化、操作系統fork原理、Swap機制等，並對Redis的容量進行合理規劃，預留足夠的機器資源，對機器做好完善的監控，才能保證Redis的穩定運行。
在上文中，主要講解了 Redis 常見的導致變慢的場景以及問題定位和分析，主要是由業務使用不合理和運維不當導致的。
J. 普羅米修斯監控能否監控redis耗時
普羅米修斯（Prometheus）是一個開源的監控系統，可以用於監控各種應用和服務的性能和狀態。
Prometheus 可以通過對應用程序或服務的監控指標進行採集，來監控應用程序或服務的性能和狀態。這些監控指標可以是應用程序或服務的 CPU 利用率、內存使用情況、網路流量等。
因此，如果要監控 Redis 的耗時，可以使用 Prometheus 採集 Redis 的監控指標，包括 Redis 命令的執行時間、網路流量等。這樣，就可以通過 Prometheus 監控 Redis 的性能和狀態，並發現可能的性能瓶頸。
此外，Prometheus 還可以與其他監控工具集成，如 Grafana、Zabbix 等，以提供更為豐富的監控功能。
希望這些信息能幫助您了解 Prometheus 監控 Redis 的情況。