redis 數據庫

Redis 簡介

redis是一個key-value存儲系統。和Memcached相似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操做，並且這些操做都是原子性的。在此基礎上，redis支持各類不一樣方式的排序。與memcached同樣，爲了保證效率，數據都是緩存在內存中。區別的是redis會週期性的把更新的數據寫入磁盤或者把修改操做寫入追加的記錄文件，而且在此基礎上實現了master-slave(主從)同步。

 

*咱們把這種要麼一塊兒成功，要麼一塊兒失敗的操做叫原子性操做。若是把一個事務可看做是一個程序,它要麼完整的被執行,要麼徹底不執行。這種特性就叫原子性。

 

Redis 安裝

http://www.runoob.com/redis/redis-install.html

 

Redis 操做

String操做，redis中的String在在內存中按照一個name對應一個value來存儲。如圖：

set(name, value, ex=None, px=None, nx=False, xx=False)

1 2 3 4 5 6

在Redis中設置值，默認，不存在則建立，存在則修改 參數：    ex，過時時間（秒）    px，過時時間（毫秒）    nx，若是設置爲True，則只有name不存在時，當前set操做才執行    xx，若是設置爲True，則只有name存在時，崗前set操做才執行

setnx(name, value)

1	設置值，只有name不存在時，執行設置操做（添加）

setex(name, value, time)

1 2 3

# 設置值 # 參數：     # time，過時時間（數字秒 或 timedelta對象）

psetex(name, time_ms, value)

1 2 3

# 設置值 # 參數：     # time_ms，過時時間（數字毫秒 或 timedelta對象）

mset(*args, **kwargs)

1 2 3 4 5

批量設置值 如：     mset(k1='v1', k2='v2')     或     mget({'k1': 'v1', 'k2': 'v2'})

get(name)

1

獲取值

mget(keys, *args)

1 2 3 4 5

批量獲取 如：     mget('ylr', 'wupeiqi')     或     r.mget(['ylr', 'wupeiqi'])

getset(name, value)

1	設置新值並獲取原來的值

getrange(key, start, end)

1 2 3 4 5 6

# 獲取子序列（根據字節獲取，非字符） # 參數：     # name，Redis 的 name     # start，起始位置（字節）     # end，結束位置（字節） # 如： "武沛齊" ，0-3表示 "武"

setrange(name, offset, value)

1 2 3 4

# 修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加） # 參數：     # offset，字符串的索引，字節（一個漢字三個字節）     # value，要設置的值

setbit(name, offset, value)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# 對name對應值的二進制表示的位進行操做   # 參數：     # name，redis的name     # offset，位的索引（將值變換成二進制後再進行索引）     # value，值只能是 1 或 0   # 注：若是在Redis中有一個對應： n1 = "foo"，         那麼字符串foo的二進制表示爲：01100110 01101111 01101111     因此，若是執行 setbit('n1', 7, 1)，則就會將第7位設置爲1，         那麼最終二進制則變成 01100111 01101111 01101111，即："goo"   # 擴展，轉換二進制表示：       # source = "武沛齊"     source = "foo"       for i in source:         num = ord(i)         print bin(num).replace('b','')       特別的，若是source是漢字 "武沛齊"怎麼辦？     答：對於utf-8，每個漢字佔 3 個字節，那麼 "武沛齊" 則有 9個字節        對於漢字，for循環時候會按照 字節 迭代，那麼在迭代時，將每個字節轉換 十進制數，而後再將十進制數轉換成二進制         11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000         -------------------------- ----------------------------- -----------------------------                     武                         沛                           齊

getbit(name, offset)

1	# 獲取name對應的值的二進制表示中的某位的值 （0或1）

bitcount(key, start=None, end=None)

1 2 3 4 5

# 獲取name對應的值的二進制表示中 1 的個數 # 參數：     # key，Redis的name     # start，位起始位置     # end，位結束位置

bitop(operation, dest, *keys)

1 2 3 4 5 6 7 8 9 10

# 獲取多個值，並將值作位運算，將最後的結果保存至新的name對應的值   # 參數：     # operation,AND（並） 、 OR（或） 、 NOT（非） 、 XOR（異或）     # dest, 新的Redis的name     # *keys,要查找的Redis的name   # 如：     bitop("AND", 'new_name', 'n1', 'n2', 'n3')     # 獲取Redis中n1,n2,n3對應的值，而後講全部的值作位運算（求並集），而後將結果保存 new_name 對應的值中

strlen(name)

1	# 返回name對應值的字節長度（一個漢字3個字節）

incr(self, name, amount=1)

1 2 3 4 5 6 7

# 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。   # 參數：     # name,Redis的name     # amount,自增數（必須是整數）   # 注：同incrby

incrbyfloat(self, name, amount=1.0)

1 2 3 4 5

# 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。   # 參數：     # name,Redis的name     # amount,自增數（浮點型）

decr(self, name, amount=1)

1 2 3 4 5

# 自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。   # 參數：     # name,Redis的name     # amount,自減數（整數）

append(key, value)

1 2 3 4 5

# 在redis name對應的值後面追加內容   # 參數：     key, redis的name     value, 要追加的字符串

　　

Hash操做，redis中Hash在內存中的存儲格式以下圖：

hset(name, key, value)

1 2 3 4 5 6 7 8 9

# name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）   # 參數：     # name，redis的name     # key，name對應的hash中的key     # value，name對應的hash中的value   # 注：     # hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）

hmset(name, mapping)

1 2 3 4 5 6 7 8

# 在name對應的hash中批量設置鍵值對   # 參數：     # name，redis的name     # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}   # 如：     # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

1	# 在name對應的hash中獲取根據key獲取value

hmget(name, keys, *args)

1 2 3 4 5 6 7 8 9 10 11

# 在name對應的hash中獲取多個key的值   # 參數：     # name，reids對應的name     # keys，要獲取key集合，如：['k1', 'k2', 'k3']     # *args，要獲取的key，如：k1,k2,k3   # 如：     # r.mget('xx', ['k1', 'k2'])     # 或     # print r.hmget('xx', 'k1', 'k2')

hgetall(name)

1	獲取name對應hash的全部鍵值

hlen(name)

1	# 獲取name對應的hash中鍵值對的個數

hkeys(name)

1	# 獲取name對應的hash中全部的key的值

hvals(name)

1	# 獲取name對應的hash中全部的value的值

hexists(name, key)

1	# 檢查name對應的hash是否存在當前傳入的key

hdel(name,*keys)

1	# 將name對應的hash中指定key的鍵值對刪除

hincrby(name, key, amount=1)

1 2 3 4 5

# 自增name對應的hash中的指定key的值，不存在則建立key=amount # 參數：     # name，redis中的name     # key， hash對應的key     # amount，自增數（整數）

hincrbyfloat(name, key, amount=1.0)

1 2 3 4 5 6 7 8

# 自增name對應的hash中的指定key的值，不存在則建立key=amount   # 參數：     # name，redis中的name     # key， hash對應的key     # amount，自增數（浮點數）   # 自增name對應的hash中的指定key的值，不存在則建立key=amount

hscan(name, cursor=0, match=None, count=None)

1 2 3 4 5 6 7 8 9 10 11 12 13

# 增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆   # 參數：     # name，redis的name     # cursor，遊標（基於遊標分批取獲取數據）     # match，匹配指定key，默認None 表示全部的key     # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數   # 如：     # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)     # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)     # ...     # 直到返回值cursor的值爲0時，表示數據已經經過分片獲取完畢

hscan_iter(name, match=None, count=None)

1 2 3 4 5 6 7 8 9

# 利用yield封裝hscan建立生成器，實現分批去redis中獲取數據   # 參數：     # match，匹配指定key，默認None 表示全部的key     # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數   # 如：     # for item in r.hscan_iter('xx'):     #     print item

　　

List操做，redis中的List在在內存中按照一個name對應一個List來存儲。如圖：

lpush(name,values)

1 2 3 4 5 6 7 8

# 在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊   # 如：     # r.lpush('oo', 11,22,33)     # 保存順序爲: 33,22,11   # 擴展：     # rpush(name, values) 表示從右向左操做

lpushx(name,value)

1 2 3 4

# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊   # 更多：     # rpushx(name, value) 表示從右向左操做

llen(name)

1	# name對應的list元素的個數

linsert(name, where, refvalue, value))

1 2 3 4 5 6 7

# 在name對應的列表的某一個值前或後插入一個新值   # 參數：     # name，redis的name     # where，BEFORE或AFTER     # refvalue，標杆值，即：在它先後插入數據     # value，要插入的數據

r.lset(name, index, value)

1 2 3 4 5 6

# 對name對應的list中的某一個索引位置從新賦值   # 參數：     # name，redis的name     # index，list的索引位置     # value，要設置的值

r.lrem(name, value, num)

1 2 3 4 5 6 7 8

# 在name對應的list中刪除指定的值   # 參數：     # name，redis的name     # value，要刪除的值     # num，  num=0，刪除列表中全部的指定值；            # num=2,從前到後，刪除2個；            # num=-2,從後向前，刪除2個

lpop(name)

1 2 3 4

# 在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素   # 更多：     # rpop(name) 表示從右向左操做

lindex(name, index)

1	在name對應的列表中根據索引獲取列表元素

lrange(name, start, end)

1 2 3 4 5

# 在name對應的列表分片獲取數據 # 參數：     # name，redis的name     # start，索引的起始位置     # end，索引結束位置

ltrim(name, start, end)

1 2 3 4 5

# 在name對應的列表中移除沒有在start-end索引之間的值 # 參數：     # name，redis的name     # start，索引的起始位置     # end，索引結束位置

rpoplpush(src, dst)

1 2 3 4

# 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊 # 參數：     # src，要取數據的列表的name     # dst，要添加數據的列表的name

blpop(keys, timeout)

1 2 3 4 5 6 7 8

# 將多個列表排列，按照從左到右去pop對應列表的元素   # 參數：     # keys，redis的name的集合     # timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞   # 更多：     # r.brpop(keys, timeout)，從右向左獲取數據

brpoplpush(src, dst, timeout=0)

1 2 3 4 5 6

# 從一個列表的右側移除一個元素並將其添加到另外一個列表的左側   # 參數：     # src，取出並要移除元素的列表對應的name     # dst，要插入元素的列表對應的name     # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞

自定義增量迭代

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# 因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：     # 一、獲取name對應的全部列表     # 二、循環列表 # 可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能：   def list_iter(name):     """     自定義redis列表增量迭代     :param name: redis中的name，即：迭代name對應的列表     :return: yield 返回 列表元素     """     list_count = r.llen(name)     for index in xrange(list_count):         yield r.lindex(name, index)   # 使用 for item in list_iter('pp'):     print item

Set操做，Set集合就是不容許重複的列表

sadd(name,values)

1	# name對應的集合中添加元素

scard(name)

1	獲取name對應的集合中元素個數

sdiff(keys, *args)

1	在第一個name對應的集合中且不在其餘name對應的集合的元素集合

sdiffstore(dest, keys, *args)

1	# 獲取第一個name對應的集合中且不在其餘name對應的集合，再將其新加入到dest對應的集合中

sinter(keys, *args)

1	# 獲取多一個name對應集合的並集

sinterstore(dest, keys, *args)

1	# 獲取多一個name對應集合的並集，再講其加入到dest對應的集合中

sismember(name, value)

1	# 檢查value是不是name對應的集合的成員

smembers(name)

1	# 獲取name對應的集合的全部成員

smove(src, dst, value)

1	# 將某個成員從一個集合中移動到另一個集合

spop(name)

1	# 從集合的右側（尾部）移除一個成員，並將其返回

srandmember(name, numbers)

1	# 從name對應的集合中隨機獲取 numbers 個元素

srem(name, values)

1	# 在name對應的集合中刪除某些值

sunion(keys, *args)

1	# 獲取多一個name對應的集合的並集

sunionstore(dest,keys, *args)

1	# 獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

1	# 同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大

 

有序集合，在集合的基礎上，爲每元素排序；元素的排序須要根據另一個值來進行比較，因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。

zadd(name, *args, **kwargs)

1 2 3 4 5

# 在name對應的有序集合中添加元素 # 如：      # zadd('zz', 'n1', 1, 'n2', 2)      # 或      # zadd('zz', n1=11, n2=22)

zcard(name)

1	# 獲取name對應的有序集合元素的數量

zcount(name, min, max)

1	# 獲取name對應的有序集合中分數 在 [min,max] 之間的個數

zincrby(name, value, amount)

1	# 自增name對應的有序集合的 name 對應的分數

r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# 按照索引範圍獲取name對應的有序集合的元素   # 參數：     # name，redis的name     # start，有序集合索引發始位置（非分數）     # end，有序集合索引結束位置（非分數）     # desc，排序規則，默認按照分數從小到大排序     # withscores，是否獲取元素的分數，默認只獲取元素的值     # score_cast_func，對分數進行數據轉換的函數   # 更多：     # 從大到小排序     # zrevrange(name, start, end, withscores=False, score_cast_func=float)       # 按照分數範圍獲取name對應的有序集合的元素     # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)     # 從大到小排序     # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

zrank(name, value)

1 2 3 4

# 獲取某個值在 name對應的有序集合中的排行（從 0 開始）   # 更多：     # zrevrank(name, value)，從大到小排序

zrangebylex(name, min, max, start=None, num=None)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# 當有序集合的全部成員都具備相同的分值時，有序集合的元素會根據成員的 值 （lexicographical ordering）來進行排序，而這個命令則能夠返回給定的有序集合鍵 key 中， 元素的值介於 min 和 max 之間的成員 # 對集合中的每一個成員進行逐個字節的對比（byte-by-byte compare）， 並按照從低到高的順序， 返回排序後的集合成員。 若是兩個字符串有一部份內容是相同的話， 那麼命令會認爲較長的字符串比較短的字符串要大   # 參數：     # name，redis的name     # min，左區間（值）。 + 表示正無限； - 表示負無限； ( 表示開區間； [ 則表示閉區間     # min，右區間（值）     # start，對結果進行分片處理，索引位置     # num，對結果進行分片處理，索引後面的num個元素   # 如：     # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga     # r.zrangebylex('myzset', "-", "[ca") 結果爲：['aa', 'ba', 'ca']   # 更多：     # 從大到小排序     # zrevrangebylex(name, max, min, start=None, num=None)

zrem(name, values)

1 2 3

# 刪除name對應的有序集合中值是values的成員   # 如：zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max)

1	# 根據排行範圍刪除

zremrangebyscore(name, min, max)

1	# 根據分數範圍刪除

zremrangebylex(name, min, max)

1

# 根據值返回刪除

zscore(name, value)

1	# 獲取name對應有序集合中 value 對應的分數

zinterstore(dest, keys, aggregate=None)

1 2	# 獲取兩個有序集合的交集，若是遇到相同值不一樣分數，則按照aggregate進行操做 # aggregate的值爲:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None)

1 2	# 獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做 # aggregate的值爲:  SUM  MIN  MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

1	# 同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做

　　

其餘經常使用操做

delete(*names)

1	# 根據刪除redis中的任意數據類型

exists(name)

1	# 檢測redis的name是否存在

keys(pattern='*')

1 2 3 4 5 6 7

# 根據模型獲取redis的name   # 更多：     # KEYS * 匹配數據庫中全部 key 。     # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。     # KEYS h*llo 匹配 hllo 和 heeeeello 等。     # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

expire(name ,time)

1	# 爲某個redis的某個name設置超時時間

rename(src, dst)

1	# 對redis的name重命名爲

move(name, db))

1# 將redis的某個值移動到指定的db下

randomkey()

1# 隨機獲取一個redis的name（不刪除）

type(name)

1# 獲取name對應值的類型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

1	# 同字符串操做，用於增量迭代獲取key

 

 

4。管道

import redis

pool = redis.ConnectionPool()

r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()

pipe.set('name', 'yuan')
pipe.set('role', '123')

pipe.execute()

發佈訂閱

client

import redis r=redis.Redis() pub=r.pubsub() pub.subscribe("fm104.6") pub.parse_response() while True: print("working....") msg= pub.parse_response() print(msg)

server

import redis redis=redis.Redis() while 1: msg=input(">>>>") redis.publish("fm104.5",msg)

Redis經常使用命令 一、鍵值相關命令
keys *|key*|key???
exists key:確認一個 key 是否存在
del key:刪除一個 key
expire key seconeds:設置一個 key 的過時時間(單位:秒)
move:將當前數據庫中的 key 轉移到其它數據庫中。
persist：移除給定 key 的過時時間
ttl:查看過時還須要多長時間
randomkey：隨機返回命名空間的一個key
renamekey：重命名key
type：返回值類型

二、元務器相關命令
ping:測試鏈接是否存活
echo:在命令行打印一些內容
select：選擇數據庫。Redis 數據庫編號從 0~15，咱們能夠選擇任意一個數據庫來進行數據的存取。
quit：退出鏈接。
dbsize：返回當前數據庫中 key 的數目。
info:獲取服務器的信息和統計。
monitor:實時轉儲收到的請求。
config:獲取服務器配置信息。
flushdb:刪除當前選擇數據庫中的全部 key。
flushall:刪除全部數據庫中的全部 key。
Redis高級使用屬性 一、安全性：設置每次命令以前都要確認密碼|在redis.conf配置文件中修改 requirepass

二、主從複製
2.1 特色
(1)master能夠擁有多個slave
(2)多個slave能夠鏈接同一個master外，還能夠鏈接其餘slave
(3)主從複製不會阻塞master，同步數據，master能夠繼續處理client。
(4)提升系統的伸縮性
2.二、搭建過程

三、事務控制
3.1 簡單事務控制
multi-->事務begin
exec-->退出提交
3.2 事務回滾
muliti-->事務begin
discard-->事務回滾

四、持久化
4.1 snapshotting(默認)-快照方式
將數據以快照的方式寫入到二進制文件中，也是dump.rpb。執行save、bgsave的時候會對dump.rpb

保存方式
save：手動存儲、阻塞當前線程，把內存數據存到dump.rpb中。
bgsave:開啓子線程、調用fork操做,後臺將內存數據存到dump.rpb中。
redis.conf中默認設置爲自動bgsave。

缺陷:
假設有client一、client2.
client1執行flushall、把內存數據所有清除。
client2執行的時候，由於以前數據在未知狀況下被清除，這樣就會形成很大的麻煩。
一般狀況下，咱們先把save以前，把相應dump.rpb轉移到其餘目錄下進行保存，利於數據恢復。
4.2 aof(append-only file)-->若是應用要求不能丟失任何修改的話，能夠採用 aof 持久化方式
機制：默認每隔一秒，redis會收到寫命令，把內容追加到appendonnly.aof文件中。
配置redis.conf
appendonly yes //啓用 aof 持久化方式
# appendfsync always //收到寫命令就當即寫入磁盤，最慢，可是保證徹底的持久化
appendfsync everysec //每秒鐘寫入磁盤一次，在性能和持久化方面作了很好的折中
# appendfsync no //徹底依賴 os，性能最好,持久化沒保證
五、發佈及訂閱消息
5.1 訂閱者 subscribe 通道例如tv1/tv2/tv3 psubscribe tv*例如tv開頭的消息都能收到
5.2 發送者 publish tv1 message
5.3 退出訂閱模式：unsubscribe、unpsubscribe

六、Pipeline 批量發送請求
一、普通方式
基於tcp的鏈接方式，每次都要等着回覆才能執行
二、Pipeline方式
多個命令執行完之後，而後把執行結構返回給客戶端。

七、虛擬內存相關配置
vm-enabled yes #開啓 vm 功能
vm-swap-file /tmp/redis.swap #交換出來的 value 保存的文件路徑
vm-max-memory 1000000 #redis 使用的最大內存上限
vm-page-size 32 #每一個頁面的大小 32 個字節
vm-pages 134217728 #最多使用多少頁面
vm-max-threads 4 #用於執行 value 對象換入換出的工做線程數量
Redis 持久化磁盤 IO 方式及其帶來的問題

 

有 Redis 線上運維經驗的人會發現 Redis 在物理內存使用比較多，但尚未超過實際物理內存總容量時就會發生不穩定甚至崩潰的問題，有人認爲是基於快照方式持久化的 fork 系統調用形成內存佔用加倍而致使的，這種觀點是不許確的，由於 fork 調用的 copy-on-write 機制是基於操做系統頁這個單位的，也就是隻有有寫入的髒頁會被複制，可是通常你的系統不會在短期內全部的頁都發生了寫入而致使複製，那麼是什麼緣由致使 Redis 崩潰的呢？

　　答案是 Redis 的持久化使用了 Buffer IO 形成的，所謂 Buffer IO 是指 Redis 對持久化文件的寫入和讀取操做都會使用物理內存的 Page Cache，而大多數數據庫系統會使用 Direct IO 來繞過這層 Page Cache 並自行維護一個數據的 Cache，而當 Redis 的持久化文件過大（尤爲是快照文件），並對其進行讀寫時，磁盤文件中的數據都會被加載到物理內 存中做爲操做系統對該文件的一層 Cache，而這層 Cache 的數據與 Redis 內存中管理的數據實際是重複存儲的，雖然內核在物理內存緊張時會作 Page Cache 的剔除工做，但內核極可能認爲某塊 Page Cache 更重要，而讓你的進程開始 Swap，這時你的系統就會開始出現不穩定或者崩潰了。咱們的經驗是當你的 Redis 物理內存使用超過內存總容量的3/5時就會開始比較危險了。