Redis學習筆記

時間 2019-12-08

標籤 redis 學習筆記欄目 Redis 简体版

原文原文鏈接

1.什麼是Redis

Redis 是一個開源的使用C語言編寫，支持網絡，可基於內存可持久化的日誌型、高性能的Key-Value數據庫，並支持多語言的API調用。它一般被成爲數據結構服務器，由於Value值能夠是多種數據類型(字符串(String)、集合(set)、列表(list)、哈希(Map)、有序集合(sorted set))等類型。php

Redis的特色：html

Redis支持數據持久化存儲，能夠將內存保存的數據持久化的存放到磁盤中，重啓的時候能夠在次的加載使用。
Redis不只僅支持Key-Value類型的數據，還支持字符串(String)、集合(set)、列表(list)、哈希(Map)、有序集合(sorted set)等多種數據類型。
Redis支持主從模式，即master-slave模式的主從模型。

Redis的優勢：java

性能極高 (Redis能讀的速度是110000次/s，寫的速度是81000次/s)。
支持豐富的數據類型 (Redis支持二進制案例的字符串(String)、集合(set)、列表(list)、哈希(Map)、有序集合(sorted set)等多種數據類型)。
可用於緩存、消息、按key設置過時時間，過時自動刪除。
支持事務，操做都是原子性，所謂的原子性就是對數據的更改要麼所有執行，要麼所有不執行。
支持分佈式讀寫分離模式。

2.安裝Redis(Linux)

2.1 下載Redis：python

下載Redis安裝包(下載地址:http://download.redis.io/releases/)c++

wget http://download.redis.io/releases/redis-4.0.8.tar.gz

2.2 安裝Redis：程序員

解壓、編譯(編譯的時候須要gcc的依賴在安裝以前必定保證gcc是安裝好的，可使用yum -y install gcc 安裝)redis

[root@BrianZhu ~]# tar zxf redis-4.0.8.tar.gz 
[root@BrianZhu ~]# cd redis-4.0.8/
[root@BrianZhu redis-4.0.8]# make

2.3 啓動Redis：算法

二進制文件是編譯完成後在src目錄下，經過下面的命令啓動Redis服務：mongodb

[root@BrianZhu redis-4.0.8]# src/redis-server

看到下面的圖片表示啓動成功：數據庫

這裏的啓動方式，是讓Redis在前臺啓動，咱們不退出Redis終端就會一直這樣顯示，當咱們關掉終端Redis的進程也就退出了，爲了解決這個問題咱們要把Redis放到後臺啓動，使用下面的方法:

[root@BrianZhu redis-4.0.8]# nohup src/redis-server &

檢查Redis啓動狀態：

[root@BrianZhu redis-4.0.8]# netstat -lntup | grep redis
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      47592/src/redis-ser 
tcp6       0      0 :::6379                 :::*                    LISTEN      47592/src/redis-ser

注：redis-server默認啓動的端口是6379端口，默認沒有密碼

在啓動的時候Redis調用的是配置文件redis.conf文件(文件路徑在解壓後redis目錄下面)

[root@BrianZhu redis-4.0.8]# pwd
/root/redis-4.0.8
[root@BrianZhu redis-4.0.8]# ll | grep redis.conf
-rw-rw-r--  1 root root  58353 Feb  3 00:39 redis.conf

若是咱們自定義的這個文件的路徑，也能夠指定這個文件的路徑進行啓動：

[root@BrianZhu redis-4.0.8]# nohup src/redis-server ~/redis-4.0.8/redis.conf &

2.4 啓動Redis客戶端而且驗證：

咱們可使用內置的客戶端命令redis-cli進行使用：

[root@BrianZhu redis-4.0.8]# src/redis-cli 
127.0.0.1:6379> 　　　　　　　　　　　　　　　　　　　　# 已經啓動Redis客戶端

驗證(一個簡單的使用)：

[root@BrianZhu redis-4.0.8]# src/redis-cli 
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set var "Hello World"
OK
127.0.0.1:6379> get var
"Hello World"
127.0.0.1:6379>

退出客戶端終端:

[root@BrianZhu redis-4.0.8]# src/redis-cli 
127.0.0.1:6379> quit
[root@BrianZhu redis-4.0.8]# src/redis-cli 
127.0.0.1:6379> exit

2.5 中止Redis:

咱們可使用內置的語法命令 redis-cli shutdown 來關閉Redis:

[root@BrianZhu redis-4.0.8]# src/redis-cli shutdown

具體操做以下:

[root@BrianZhu redis-4.0.8]# netstat -lntup | grep redis
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      47592/src/redis-ser 
tcp6       0      0 :::6379                 :::*                    LISTEN      47592/src/redis-ser 
[root@BrianZhu redis-4.0.8]# src/redis-cli shutdown
[1]+  Done                    nohup src/redis-server
[root@BrianZhu redis-4.0.8]# netstat -lntup | grep redis
[root@BrianZhu redis-4.0.8]#

注：若是是設置上密碼後，單純的使用redis-cli是關不掉的，必須加上IP、Port、Passwd

[root@BrianZhu redis-4.0.8]# src/redis-cli -h 192.168.31.1 -p 6379 -a 123456 shutdown

3.設置密碼，遠程鏈接

3.1設置Redis密碼:

redis沒有實現訪問控制這個功能，可是它提供了一個輕量級的認證方式，能夠編輯redis.conf配置來啓用認證。

有兩種設置密碼的方式：

修改配置文件，須要重啓redis：在配置文件中有個參數： requirepass 這個就是配置redis訪問密碼的參數(500行左右)；好比 requirepass test123 ； 注:( redis的查詢速度是很是快的，外部用戶一秒內能夠嘗試多大150K個密碼；因此密碼要儘可能長（對於DBA 沒有必要必須記住密碼)

使用內置的語法命令設置密碼，不重啓Redis設置密碼：

[root@BrianZhu redis-4.0.8]# src/redis-cli 
設置密碼
127.0.0.1:6379> config set requirepass test123
OK
查詢密碼：
redis 127.0.0.1:6379> config get requirepass
(error) ERR operation not permitted

密碼驗證：
redis 127.0.0.1:6379> auth test123
OK
再次查詢：
redis 127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "test123"

注：若是配置文件中沒添加密碼那麼redis重啓後，密碼失效；

3.2 遠程鏈接Redis:

遠程鏈接也是有兩種方式：

登陸的時候加上密碼驗證：

[root@BrianZhu redis-4.0.8]# src/redis-cli -p 6379 -a test123
127.0.0.1:6379> CONFIG GET requirepass
1) "requirepass"
2) "test123"
127.0.0.1:6379>

登陸之後在使用auth進行驗證

[root@BrianZhu redis-4.0.8]# src/redis-cli 
127.0.0.1:6379> CONFIG GET requirepass
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth test123
OK
127.0.0.1:6379> CONFIG GET requirepass
1) "requirepass"
2) "test123"
127.0.0.1:6379>

注：AUTH命令跟其餘redis命令同樣，是沒有加密的；阻止不了攻擊者在網絡上竊取你的密碼；認證層的目標是提供多一層的保護。若是防火牆或者用來保護redis的系統防護外部攻擊失敗的話，外部用戶若是沒有經過密碼認證仍是沒法訪問redis的。

4.Redis的數據類型

Redis支持五種數據類型：

字符串(String)
集合(set)
列表(list)
哈希(Map)
有序集合(sorted set)

4.1 字符串(String):

是Redis最基本的數據類型，能夠理解成與Memcached同樣的類型，一個Key對應一個Value。
二進制安全的。意思就是Redis的String能夠包含任何數據，由於他是以二進制的方式存儲的。
一個鍵最大存儲512MB。

經常使用字符串命令具體操做以下：

127.0.0.1:6379> set name "Brian Zhu"
OK

SET key value (給key賦值)

127.0.0.1:6379> get name
"Brian Zhu"

GET key （獲取指定 key 的值）

127.0.0.1:6379> GETRANGE name 0 6
"Brian Z"
127.0.0.1:6379> GETRANGE name 0 -1
"Brian Zhu"

GETRANGE key start end (返回 key 中字符串值的子字符)

127.0.0.1:6379> GETSET name "Brian"
"Brian Zhu"

GETSET key value (將給定 key 的值設爲 value ，並返回 key 的舊值(old value))

127.0.0.1:6379> GETBIT name 1
(integer) 1
127.0.0.1:6379> GETBIT name 3
(integer) 0
127.0.0.1:6379> GETBIT oo 1    # oo這個key不存在
(integer) 0
 
# 當偏移量 OFFSET 比字符串值的長度大，或者 key 不存在時，返回 0 。

GETBIT key offset (對 key 所儲存的字符串值，獲取指定偏移量上的位(bit))

127.0.0.1:6379> MGET name
1) "Brian"
127.0.0.1:6379> mget name keys 
1) "Brian"
2) "hello world"
127.0.0.1:6379> mget name keys oo
1) "Brian"
2) "hello world"
3) (nil)

# 沒有的變量返回nil

MGET key1 [key2..] (獲取全部(一個或多個)給定 key 的值)

127.0.0.1:6379> SETBIT name 10086 1
(integer) 0
127.0.0.1:6379> GETBIT name 10086
(integer) 1
127.0.0.1:6379> GETBIT name 100   # 默認被初始爲0
(integer) 0

SETBIT key offset value(對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit))

127.0.0.1:6379> SETEX test 60 brian
OK
127.0.0.1:6379> TTL test
(integer) 54
127.0.0.1:6379> GET test
"brian"
127.0.0.1:6379> TTL test
(integer) -2
127.0.0.1:6379> GET test
(nil)

#  設置時間過時，key對應的value也將過時

SETEX key seconds value (將值 value 關聯到 key ，並將 key 的過時時間設爲 seconds (以秒爲單位))

127.0.0.1:6379> EXISTS job     # 查看job是否存在
(integer) 0 
127.0.0.1:6379> SETNX job "hahaha"   # 設置job
(integer) 1  
127.0.0.1:6379> SETNX job "nidaye"    # 覆蓋job失敗
(integer) 0
127.0.0.1:6379> GET job                   # 查看job值仍是原來的值
"hahaha"

SETNX key value (只有在 key 不存在時設置 key 的值)

127.0.0.1:6379> GET job
"hahaha"
127.0.0.1:6379> SETRANGE job 2 "nidaye"  
(integer) 8
127.0.0.1:6379> GET job
"hanidaye"

SETRANGE key offset value(用 value 參數覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始)

127.0.0.1:6379> GET job
"hanidaye"
127.0.0.1:6379> STRLEN job
(integer) 8

STRLEN key(返回 key 所儲存的字符串值的長度)

127.0.0.1:6379> mset key1 brian key2 18
OK
127.0.0.1:6379> get key1
"brian"
127.0.0.1:6379> get key2
"18"

MSET key value [key value ...](同時設置一個或多個 key-value 對)

127.0.0.1:6379> MSETNX key1 brian key2 19    # key1 和key2存在建立失敗
(integer) 0
127.0.0.1:6379> MSETNX key3 jack key4 19
(integer) 1
127.0.0.1:6379> GET key3
"jack"
127.0.0.1:6379> GET key4
"19"

MSETNX key value [key value ...] (同時設置一個或多個 key-value 對，當且僅當全部給定 key 都不存在)

127.0.0.1:6379> PSETEX test1 10000 "100000000"
OK
127.0.0.1:6379> PTTL test1
(integer) 8092
127.0.0.1:6379> GET test1
"100000000"
127.0.0.1:6379> PTTL test1
(integer) -2
127.0.0.1:6379> GET test1
(nil)

PSETEX key milliseconds value(這個命令和SETEX命令類似,但它以毫秒爲單位設置 key的生存時間,而不是像 SETEX 命令那樣,以秒爲單位)

127.0.0.1:6379> SET number 100
OK
127.0.0.1:6379> INCR number
(integer) 101
127.0.0.1:6379> get number
"101"

INCR key(將 key 中儲存的數字值增一)

127.0.0.1:6379> GET number
"101"
127.0.0.1:6379> INCRBY number 100
(integer) 201
127.0.0.1:6379> GET number
"201"

INCRBY key increment(將 key 所儲存的值加上給定的增量值（increment)

127.0.0.1:6379> GET number
"201"
127.0.0.1:6379> INCRBYFLOAT number 100.9999
"301.99990000000000001"
127.0.0.1:6379> GET number
"301.99990000000000001"

INCRBYFLOAT key increment(將 key 所儲存的值加上給定的浮點增量值（increment)

127.0.0.1:6379> GET number
"100"
127.0.0.1:6379> DECR number
(integer) 99
127.0.0.1:6379> GET number
"99"

DECR key(將 key 中儲存的數字值減一)

127.0.0.1:6379> GET number
"99"
127.0.0.1:6379> DECRBY number 10
(integer) 89
127.0.0.1:6379> GET number
"89"

DECRBY key decrement(key 所儲存的值減去給定的減量值（decrement)

127.0.0.1:6379> GET job
"hanidaye"
127.0.0.1:6379> APPEND job "niyade"
(integer) 14
127.0.0.1:6379> GET job
"hanidayeniyade"
127.0.0.1:6379> APPEND ll poip
(integer) 4
127.0.0.1:6379> GET ll
"poip"

APPEND key value(若是key已經存在而且是一個字符串,APPEND命令將指定value追加到改key原來的值(value)的末尾,key不存在則添加key)

4.2 集合(Set):

Redis 的 Set 是 String 類型的無序集合。集合成員是惟一的，這就意味着集合中不能出現重複的數據。
Redis 中集合是經過哈希表實現的，因此添加，刪除，查找的複雜度都是 O(1)。
集合中最大的成員數爲 2^{32 - 1} (4294967295, 每一個集合可存儲40多億個成員)。

經常使用集合命令具體操做以下：

127.0.0.1:6379> SADD myset "hello"
(integer) 1
127.0.0.1:6379> SADD myset "foo"
(integer) 1
127.0.0.1:6379>  SADD myset "hello"
(integer) 0
127.0.0.1:6379> SMEMBERS myset
1) "foo"
2) "hello"

SADD key member1 [member2] (向集合添加一個或多個成員)

127.0.0.1:6379> SCARD myset
(integer) 2

SCARD key (獲取集合的成員數)

127.0.0.1:6379> SMEMBERS myset
1) "foo"
2) "hello"
127.0.0.1:6379> SMEMBERS brian
1) "foo"
2) "fo"
3) "nihao"
127.0.0.1:6379> SDIFF myset brian
1) "hello"

SDIFF key1 [key2] (返回給定全部集合的差集)

127.0.0.1:6379> SMEMBERS myset
1) "foo"
2) "hello"
127.0.0.1:6379> SMEMBERS brian
1) "foo"
2) "fo"
3) "nihao"
127.0.0.1:6379> SINTER myset brian
1) "foo"

SINTER key1 [key2] (返回給定全部集合的交集)

127.0.0.1:6379> SDIFFSTORE myset2 brian myset
(integer) 2
127.0.0.1:6379> SMEMBERS myset2
1) "fo"
2) "nihao"

SDIFFSTORE destination key1 [key2] (返回給定全部集合的差集並存儲在 destination 中)

127.0.0.1:6379> SINTERSTORE myset3 brian myset
(integer) 1
127.0.0.1:6379> SMEMBERS myset3
1) "foo"

SINTERSTORE destination key1 [key2] (返回給定全部集合的交集並存儲在 destination 中)

127.0.0.1:6379> SISMEMBER brian fo   # 存在
(integer) 1
127.0.0.1:6379> SISMEMBER brian do  # 不存在
(integer) 0

SISMEMBER key member (判斷 member 元素是不是集合 key 的成員)

127.0.0.1:6379> SMEMBERS myset3
1) "foo"
127.0.0.1:6379> SMEMBERS myset
1) "foo"
2) "hello"

SMEMBERS key (返回集合中的全部成員)

127.0.0.1:6379> SMOVE myset foo foo
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "hello"
127.0.0.1:6379> SMEMBERS foo
1) "foo"

SMOVE source destination member (將 member 元素從 source 集合移動到 destination 集合)

127.0.0.1:6379> SMEMBERS brian
1) "foo"
2) "fo"
3) "nihao"
127.0.0.1:6379> SPOP brian
"nihao"
127.0.0.1:6379> SMEMBERS brian
1) "foo"
2) "fo"

SPOP key (移除並返回集合中的一個隨機元素)

127.0.0.1:6379> SRANDMEMBER brian
"foo"
127.0.0.1:6379> SRANDMEMBER brian
"foo"
127.0.0.1:6379> SRANDMEMBER brian
"fo"

SRANDMEMBER key [count] (返回集合中一個或多個隨機數)

127.0.0.1:6379> SMEMBERS brian
1) "fo"
2) "wwwwwww"
3) "a"
4) "hhahaha"
5) "foo"
6) "d"
7) "b"
8) "c"
127.0.0.1:6379> 
127.0.0.1:6379> SREM brian wwwwwww d
(integer) 2
127.0.0.1:6379> SMEMBERS brian
1) "fo"
2) "a"
3) "hhahaha"
4) "foo"
5) "b"
6) "c"

SREM key member1 [member2] (移除集合中一個或多個成員)

127.0.0.1:6379> SMEMBERS myset
1) "foo"
2) "a"
3) "c"
4) "hello"
127.0.0.1:6379> SMEMBERS brian
1) "fo"
2) "a"
3) "hhahaha"
4) "foo"
5) "b"
6) "c"
127.0.0.1:6379> SUNION brian myset
1) "fo"
2) "a"
3) "hello"
4) "hhahaha"
5) "foo"
6) "b"
7) "c"

SUNION key1 [key2] (返回全部給定集合的並集)

127.0.0.1:6379> SUNIONSTORE mysets brian myset
(integer) 7
127.0.0.1:6379> SMEMBERS mysets
1) "fo"
2) "a"
3) "hello"
4) "hhahaha"
5) "foo"
6) "b"
7) "c"

SUNIONSTORE destination key1 [key2] (全部給定集合的並集存儲在 destination 集合中)

4.3 列表(List):

Redis列表是簡單的字符串列表，按照插入順序排序。你能夠添加一個元素到列表的頭部（左邊）或者尾部（右邊）
一個列表最多能夠包含 2³² - 1 個元素 (4294967295, 每一個列表超過40億個元素)

經常使用列表命令具體操做以下：

127.0.0.1:6379> LPUSH mylist "hello"
(integer) 1
127.0.0.1:6379> LPUSH mylist "hello" "world"
(integer) 3

LPUSH key value1 [value2] (將一個或多個值插入到列表頭部)

127.0.0.1:6379> LRANGE mylist 0 -1
1) "world"
2) "hello"
3) "hello"
127.0.0.1:6379> LRANGE mylist 0 3
1) "world"
2) "hello"
3) "hello"
127.0.0.1:6379> LRANGE mylist 0 4
1) "world"
2) "hello"
3) "hello"
127.0.0.1:6379> LRANGE mylist 0 1
1) "world"
2) "hello"

LRANGE key start stop (獲取列表指定範圍內的元素)

127.0.0.1:6379> LPUSHX mylist nihao
(integer) 4
127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "world"
3) "hello"
4) "hello"

LPUSHX key value (將一個值插入到已存在的列表頭部)

127.0.0.1:6379> LREM mylist -2 hello
(integer) 2
127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "world"

LREM key count value (移除列表元素)

127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "world"
127.0.0.1:6379> LSET mylist 1 hahaha
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "hahaha"

LSET key index value (經過索引設置列表元素的值)

127.0.0.1:6379> RPOP mylist
"hahaha"

RPOP key (移除並獲取列表最後一個元素)

127.0.0.1:6379> RPOPLPUSH mylist mylist2
"dd"
127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "aa"
3) "bb"
4) "cc"
127.0.0.1:6379> LRANGE mylist2 0 -1
1) "dd"

RPOPLPUSH source destination (移除列表的最後一個元素，並將該元素添加到另外一個列表並返回)

127.0.0.1:6379> RPUSH mylist "aa" "bb" "cc" "dd"
(integer) 5
127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "aa"
3) "bb"
4) "cc"
5) "dd"

RPUSH key value1 [value2] (在列表中添加一個或多個值)

127.0.0.1:6379> RPUSHX mylist2 "nihaoya"
(integer) 2
127.0.0.1:6379> LRANGE mylist2 0 -1
1) "dd"
2) "nihaoya"

RPUSHX key value (爲已存在的列表添加值)

127.0.0.1:6379> LRANGE mylist 0 -1
1) "nihao"
2) "aa"
3) "bb"
4) "cc"
127.0.0.1:6379> LPOP mylist
"nihao"
127.0.0.1:6379> LRANGE mylist 0 -1
1) "aa"
2) "bb"
3) "cc"

LPOP key (移出並獲取列表的第一個元素)

127.0.0.1:6379> LRANGE mylist 0 -1
1) "aa"
2) "bb"
3) "cc"
127.0.0.1:6379> LLEN mylist
(integer) 3

LLEN key (獲取列表長度)

127.0.0.1:6379> LRANGE mylist 0 -1
1) "aa"
2) "bb"
3) "cc"
127.0.0.1:6379> LINDEX mylist 2
"cc"

LINDEX key index (經過索引獲取列表中的元素)

4.4 哈希(Map):

是一個鍵值對的集合
是一個String類型的field和value的映射表，hash特別適合用於存儲對象
Redis 中每一個 hash 能夠存儲 2³² - 1 鍵值對（40多億）

經常使用哈希命令具體操做以下：

127.0.0.1:6379> HSET test2 name jack
(integer) 1

HSET key field value(將哈希表 key 中的字段 field 的值設爲 value)

127.0.0.1:6379> HGET test2 name
"jack"

HGET key field (獲取存儲在哈希表中指定字段的值)

127.0.0.1:6379> HMSET names one brian two jack
OK

HMSET key field1 value1 [field2 value2 ] (同時將多個 field-value (域-值)對設置到哈希表 key 中)

127.0.0.1:6379> HMGET names one two
1) "brian"
2) "jack"

HMGET key field1 [field2] (獲取全部給定字段的值)

127.0.0.1:6379> HDEL names two
(integer) 1
127.0.0.1:6379> HGET name two
(error) WRONGTYPE Operation against a key holding the wrong kind of value

HDEL key field1 [field2] (刪除一個或多個哈希表字段)

127.0.0.1:6379> HEXISTS names two    # 不存在
(integer) 0  
127.0.0.1:6379> HEXISTS names one    # 存在
(integer) 1

HEXISTS key field (查看哈希表 key 中，指定的字段是否存在)

127.0.0.1:6379> HGETALL names
1) "one"                  # 哈希表key
2) "brian"                # key對應的值

HGETALL key (獲取在哈希表中指定 key 的全部字段和值)

127.0.0.1:6379> HSET ages one 100
(integer) 1
127.0.0.1:6379> HINCRBY ages one 10
(integer) 110
127.0.0.1:6379> HGET ages one
"110"

HINCRBY key field increment (爲哈希表 key 中的指定字段的整數值加上增量 increment)

127.0.0.1:6379> HGET ages one
"110"
127.0.0.1:6379> HINCRBYFLOAT ages one 10.98
"120.98"
127.0.0.1:6379> HGET ages one
"120.98"

HINCRBYFLOAT key field increment (爲哈希表 key 中的指定字段的浮點數值加上增量 increment)

127.0.0.1:6379> HMSET ages one 100 two aini three aini100
OK
127.0.0.1:6379> HKEYS ages
1) "one"
2) "two"
3) "three"

HKEYS key (獲取全部哈希表中的字段)

127.0.0.1:6379> HLEN ages
(integer) 3

HLEN key (獲取哈希表中字段的數量)

127.0.0.1:6379> HSETNX ages one "1000"    # 存在沒法建立
(integer) 0
127.0.0.1:6379> HSETNX ages frou "youyouyou"   # 不存在建立
(integer) 1
127.0.0.1:6379> HGET ages one
"100"
127.0.0.1:6379> HGET ages frou
"youyouyou"

HSETNX key field value (只有在字段 field 不存在時，設置哈希表字段的值)

127.0.0.1:6379> HVALS ages
1) "100"
2) "aini"
3) "aini100"
4) "youyouyou"

HVALS key(獲取哈希表中全部值)

4.5 有序集合(Sorted set):

Redis 有序集合和集合同樣也是string類型元素的集合,且不容許重複的成員。
不一樣的是每一個元素都會關聯一個double類型的分數。redis正是經過分數來爲集合中的成員進行從小到大的排序。
有序集合的成員是惟一的,但分數(score)卻能夠重複。
集合是經過哈希表實現的，因此添加，刪除，查找的複雜度都是O(1).
集合中最大的成員數爲 2^{32 - 1} (4294967295, 每一個集合可存儲40多億個成員)。

經常使用有序集合命令具體操做以下：

127.0.0.1:6379> ZADD myzset 1 "one"
(integer) 1
127.0.0.1:6379> ZADD myzset 1 "uno"
(integer) 1
127.0.0.1:6379> ZADD myzset 2 "two" 3 "three"
(integer) 2
127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "uno"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"

ZADD key score1 member1 [score2 member2] (向有序集合添加一個或多個成員，或者更新已存在成員的分數)

127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "uno"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"
127.0.0.1:6379> ZCARD myzset
(integer) 4

ZCARD key (獲取有序集合的成員數)

127.0.0.1:6379> ZADD myzset 1 "hello"
(integer) 1
127.0.0.1:6379> ZADD myzset 1 "foo"
(integer) 1
127.0.0.1:6379> ZADD myzset 2 "world" 3 "bar"
(integer) 2
127.0.0.1:6379>  ZCOUNT myzset 1 3
(integer) 8

ZCOUNT key min max (計算在有序集合中指定區間分數的成員數)

127.0.0.1:6379> ZADD myzset1 1 "one"
(integer) 1
127.0.0.1:6379> ZADD myzset1 2 "two"
(integer) 1
127.0.0.1:6379> ZINCRBY myzset1 2 "one"
"3"
127.0.0.1:6379> ZRANGE myzset1 0 -1 WITHSCORES
1) "two"
2) "2"
3) "one"
4) "3"

ZINCRBY key increment member (有序集合中對指定成員的分數加上增量 increment)

# 有序集 mid_test
redis 127.0.0.1:6379> ZADD mid_test 70 "Li Lei"
(integer) 1
redis 127.0.0.1:6379> ZADD mid_test 70 "Han Meimei"
(integer) 1
redis 127.0.0.1:6379> ZADD mid_test 99.5 "Tom"
(integer) 1

# 另外一個有序集 fin_test
redis 127.0.0.1:6379> ZADD fin_test 88 "Li Lei"
(integer) 1
redis 127.0.0.1:6379> ZADD fin_test 75 "Han Meimei"
(integer) 1
redis 127.0.0.1:6379> ZADD fin_test 99.5 "Tom"
(integer) 1

# 交集
redis 127.0.0.1:6379> ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3

# 顯示有序集內全部成員及其分數值
redis 127.0.0.1:6379> ZRANGE sum_point 0 -1 WITHSCORES     
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"

ZINTERSTORE destination numkeys key [key ...] (計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中)

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e
(integer) 5
redis 127.0.0.1:6379> ZADD myzset 0 f 0 g
(integer) 2
redis 127.0.0.1:6379> ZLEXCOUNT myzset - +
(integer) 7
redis 127.0.0.1:6379> ZLEXCOUNT myzset [b [f
(integer) 5

ZLEXCOUNT key min max

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES             # 顯示整個有序集成員
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis 127.0.0.1:6379> ZRANGE salary 1 2 WITHSCORES              # 顯示有序集下標區間 1 至 2 的成員
1) "tom"
2) "5000"
3) "boss"
4) "10086"

redis 127.0.0.1:6379> ZRANGE salary 0 200000 WITHSCORES         # 測試 end 下標超出最大下標時的狀況
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis > ZRANGE salary 200000 3000000 WITHSCORES                  # 測試當給定區間不存在於有序集時的狀況
(empty list or set)

ZRANGE key start stop [WITHSCORES] (經過索引區間返回有序集合成指定區間內的成員)

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis 127.0.0.1:6379> ZRANGEBYLEX myzset - [c
1) "a"
2) "b"
3) "c"
redis 127.0.0.1:6379> ZRANGEBYLEX myzset - (c
1) "a"
2) "b"
redis 127.0.0.1:6379> ZRANGEBYLEX myzset [aaa (g
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"

ZRANGEBYLEX key min max [LIMIT offset count] (經過字典區間返回有序集合的成員)

redis 127.0.0.1:6379> ZADD salary 2500 jack                        # 測試數據
(integer) 0
redis 127.0.0.1:6379> ZADD salary 5000 tom
(integer) 0
redis 127.0.0.1:6379> ZADD salary 12000 peter
(integer) 0

redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf               # 顯示整個有序集
1) "jack"
2) "tom"
3) "peter"

redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 顯示整個有序集及成員的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"

redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 顯示工資 <=5000 的全部成員
1) "jack"
2) "2500"
3) "tom"
4) "5000"

redis 127.0.0.1:6379> ZRANGEBYSCORE salary (5000 400000            # 顯示工資大於 5000 小於等於 400000 的成員
1) "peter"

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT] (經過分數返回有序集合指定區間內的成員)

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES        # 顯示全部成員及其 score 值
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

redis 127.0.0.1:6379> ZRANK salary tom                     # 顯示 tom 的薪水排名，第二
(integer) 1

ZRANK key member (返回有序集合中指定成員的索引)

# 測試數據

redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"


# 移除單個元素

redis 127.0.0.1:6379> ZREM page_rank google.com
(integer) 1

redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"


# 移除多個元素

redis 127.0.0.1:6379> ZREM page_rank baidu.com bing.com
(integer) 2

redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)


# 移除不存在元素

redis 127.0.0.1:6379> ZREM page_rank non-exists-element
(integer) 0

ZREM key member [member ...] (移除有序集合中的一個或多個成員)

redis 127.0.0.1:6379> ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
(integer) 5
redis 127.0.0.1:6379> ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
(integer) 5
redis 127.0.0.1:6379> ZRANGE myzset 0 -1
1) "ALPHA"
 2) "aaaa"
 3) "alpha"
 4) "b"
 5) "c"
 6) "d"
 7) "e"
 8) "foo"
 9) "zap"
10) "zip"
redis 127.0.0.1:6379> ZREMRANGEBYLEX myzset [alpha [omega
(integer) 6
redis 127.0.0.1:6379> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "zap"
4) "zip"

ZREMRANGEBYLEX key min max (移除有序集合中給定的字典區間的全部成員)

redis 127.0.0.1:6379> ZADD salary 2000 jack
(integer) 1
redis 127.0.0.1:6379> ZADD salary 5000 tom
(integer) 1
redis 127.0.0.1:6379> ZADD salary 3500 peter
(integer) 1

redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下標 0 至 1 區間內的成員
(integer) 2

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一個成員
1) "tom"
2) "5000"

ZREMRANGEBYRANK key start stop (移除有序集合中給定的排名區間的全部成員)

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES          # 顯示有序集內全部成員及其 score 值
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis 127.0.0.1:6379> ZREMRANGEBYSCORE salary 1500 3500      # 移除全部薪水在 1500 到 3500 內的員工
(integer) 2

redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成員
1) "jack"
2) "5000"

ZREMRANGEBYSCORE key min max (移除有序集合中給定的分數區間的全部成員)

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES        # 遞增排列
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

redis 127.0.0.1:6379> ZREVRANGE salary 0 -1 WITHSCORES     # 遞減排列
1) "jack"
2) "5000"
3) "tom"
4) "4000"
5) "peter"
6) "3500"

ZREVRANGE key start stop [WITHSCORES] (返回有序集中指定區間內的成員，經過索引，分數從高到底)

redis 127.0.0.1:6379> ZADD salary 10086 jack
(integer) 1
redis > ZADD salary 5000 tom
(integer) 1
redis 127.0.0.1:6379> ZADD salary 7500 peter
(integer) 1
redis 127.0.0.1:6379> ZADD salary 3500 joe
(integer) 1

redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列全部成員
1) "jack"
2) "peter"
3) "tom"
4) "joe"

redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介於 10000 和 2000 之間的成員
1) "peter"
2) "tom"
3) "joe"

ZREVRANGEBYSCORE key max min [WITHSCORES] (返回有序集中指定分數區間內的成員，分數從高到低排序)

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 測試數據
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"

redis 127.0.0.1:6379> ZREVRANK salary peter     # peter 的工資排第二
(integer) 1

redis 127.0.0.1:6379> ZREVRANK salary tom       # tom 的工資最高
(integer) 0

ZREVRANK key member (返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序)

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 測試數據
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis 127.0.0.1:6379> ZSCORE salary peter              # 注意返回值是字符串
"3500"

ZSCORE key member (返回有序集中，成員的分數值)

redis 127.0.0.1:6379> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"

redis 127.0.0.1:6379> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"

redis 127.0.0.1:6379> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司決定加薪。。。除了程序員。。。
(integer) 6

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
7) "herry"
8) "6000"
9) "mary"
10) "10500"
11) "bob"
12) "12000"

ZUNIONSTORE destination numkeys key [key ...] (計算給定的一個或多個有序集的並集，並存儲在新的 key 中)

5.Redis的發佈訂閱

Redis 發佈訂閱(pub/sub)是一種消息通訊模式：發送者(pub)發送消息，訂閱者(sub)接收消息。
Redis 客戶端能夠訂閱任意數量的頻道。

下圖展現了頻道 channel1 ，以及訂閱這個頻道的三個客戶端 —— client2 、 client5 和 client1 之間的關係：

當有新消息經過 PUBLISH 命令發送給頻道 channel1 時，這個消息就會被髮送給訂閱它的三個客戶端：

具體實例：

建立訂閱頻道名爲 redisChat:

127.0.0.1:6379> SUBSCRIBE redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1

如今，咱們先從新開啓個 redis 客戶端，而後在同一個頻道 redisChat 發佈兩次消息，訂閱者就能接收到消息。　

# 發佈的兩次消息
127.0.0.1:6379> PUBLISH redisChat "hello world"
(integer) 1
127.0.0.1:6379> PUBLISH redisChat "Nice to meet you"
(integer) 1


# 訂閱者接收到的信息
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
1) "message"
2) "redisChat"
3) "hello world"
1) "message"
2) "redisChat"
3) "Nice to meet you"

6.Redis的HyperLogLog

Redis HyperLogLog是用來作基數統計的算法。
優勢是：在輸入元素的數量或者體積很是很是大時，計算基數所需的空間老是固定的、而且是很小的。
在 Redis 裏面，每一個 HyperLogLog 鍵只須要花費 12 KB 內存，就能夠計算接近 2^64 個不一樣元素的基數。這和計算基數時，元素越多耗費內存就越多的集合造成鮮明對比。

注：由於HyperLogLog只會根據輸入元素來計算基數，而不會存儲輸入元素自己，所以不會返回輸入的各個元素。

基數是什麼？

　　對於["abc", "abc", "2", "3"]，基數是["abc", "2", "3"]，個數是3.

具體實例以下：

127.0.0.1:6379> pfadd jsh redis
(integer) 1
127.0.0.1:6379> pfadd jsh redis
(integer) 0
127.0.0.1:6379> pfadd jsh mongodb
(integer) 1
127.0.0.1:6379> pfadd jsh rabbitmq
(integer) 1
127.0.0.1:6379> pfcount jsh
(integer) 3
127.0.0.1:6379> pfadd jsh2 redis
(integer) 1
127.0.0.1:6379> pfadd jsh2 a
(integer) 1
127.0.0.1:6379> pfcount jsh2
(integer) 2

127.0.0.1:6379> pfmerge jsh jsh2
OK
127.0.0.1:6379> pfcount jsh
(integer) 4
127.0.0.1:6379> pfcount jsh2
(integer) 2

注：

pfadd key ele [ele2 ...]：添加指定元素到HyperLogLog中。
pfcount key: 返回給定HyperLogLog的基數估算值。
pfmerge destkey srckey [srckey2....]：講多個HyperLogLog合併到一個第一個HyperLogLog中。

7.Redis的事務

Redis 事務能夠一次執行多個命令，而且帶有如下兩個重要的保證：

批量操做在發送 EXEC 命令前被放入隊列緩存。
收到 EXEC 命令後進入事務執行，事務中任意命令執行失敗，其他的命令依然被執行。
在事務執行過程，其餘客戶端提交的命令請求不會插入到事務執行命令序列中。

一個事務從開始到執行會經歷如下三個階段：

開始事務
命令入隊
執行事務

如下是一個事務的例子，它先以 MULTI 開始一個事務，而後將多個命令入隊到事務中，最後由 EXEC 命令觸發事務，一併執行事務中的全部命令：

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> SET qq-name "python love you"
QUEUED
127.0.0.1:6379> GET qq-name
QUEUED
127.0.0.1:6379> SADD tag "java" "php" "c++"
QUEUED
127.0.0.1:6379> SMEMBERS tag
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) "python love you"
3) (integer) 3
4) 1) "c++"
   2) "java"
   3) "php"

單個 Redis 命令的執行是原子性的，但 Redis 沒有在事務上增長任何維持原子性的機制，因此 Redis 事務的執行並非原子性的。

事務能夠理解爲一個打包的批量執行腳本，但批量指令並不是原子化的操做，中間某條指令的失敗不會致使前面已作指令的回滾，也不會形成後續的指令不作。

好比：

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> SET a aaa
QUEUED
127.0.0.1:6379> SET b bbb
QUEUED
127.0.0.1:6379> SET c ccc
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) OK
3) OK

注：若是在 set b bbb 處失敗，set a 已成功不會回滾，set c 還會繼續執行。　

redis 事務的相關命令：

DISCARD ：取消事務，放棄執行事務塊內的全部命令。
EXEC ：執行全部事務塊內的命令。
MULTI ：標記一個事務塊的開始。
UNWATCH ：取消 WATCH 命令對全部 key 的監視。
WATCH key [key ...] ：監視一個(或多個) key ，若是在事務執行以前這個(或這些) key 被其餘命令所改動，那麼事務將被打斷。

8.Redis的腳本

Redis 腳本使用 Lua 解釋器來執行腳本。執行腳本的經常使用命令爲 EVAL。基本語法：

EVAL script numkeys key [key ...] arg [arg ...]

具體實例：

127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first seconde
1) "key1"
2) "key2"
3) "first"
4) "seconde"

9.Redis的數據備份與恢復

9.1 備份數據：

Redis SAVE 命令用於建立當前數據庫的備份

語法：

127.0.0.1:6379> SAVE

具體實例：

127.0.0.1:6379> SAVE
OK
127.0.0.1:6379>

注：該命令將在 redis 安裝目錄中建立dump.rdb文件

9.2 恢復數據：

若是須要恢復數據，只需將備份文件 (dump.rdb) 移動到 redis 安裝目錄並啓動服務便可。獲取 redis 目錄可使用 CONFIG 命令，以下所示：

127.0.0.1:6379> CONFIG GET dir
1) "dir"
2) "/root/redis-4.0.8"
127.0.0.1:6379>

以上命令 CONFIG GET dir 輸出的 redis 安裝目錄爲：/root/redis-4.0.8

9.3 後臺執行備份：

建立 redis 備份文件也可使用命令 BGSAVE，該命令在後臺執行。

127.0.0.1:6379> BGSAVE
Background saving started
127.0.0.1:6379>

10.Redis數據庫操做

Redis中，一共有16個數據庫，分別是0~15，通常狀況下，進入數據庫默認編號是0

若是咱們要進入指定數據庫，能夠用select語句：

切換到編號爲6的數據庫：

127.0.0.1:6379> SELECT 6
OK
127.0.0.1:6379[6]>

查看數據庫中全部的鍵值：

# 由於編號6 中沒有數據 因此先臨時新建幾個
127.0.0.1:6379[6]> SET a 1
OK
127.0.0.1:6379[6]> SET b 2
OK
127.0.0.1:6379[6]> SET c 3
OK
127.0.0.1:6379[6]> KEYS *
1) "b"
2) "a"
3) "c"

返回當前數據庫中全部key的數目:　　dbsize

刪除當前數據庫中的全部key: 　　flushdb

清空全部數據庫中的全部key: 　　flushall

把當前數據庫中的key轉移到指定數據庫：move a aim_db，例：

127.0.0.1:6379[6]> set z qqq
OK
127.0.0.1:6379[6]> MOVE z 0
(integer) 1
127.0.0.1:6379[6]> SELECT 0
OK
127.0.0.1:6379> GEt z
"qqq"

11.Redis管道技術(哈哈還在學習中)

12.Redis分區

分區是分割數據到多個Redis實例的處理過程，所以每一個實例只保存key的一個子集。

12.1 分區的優點：

經過利用多臺計算機內存的和值，容許咱們構造更大的數據庫。
經過多核和多臺計算機，容許咱們擴展計算能力；經過多臺計算機和網絡適配器，容許咱們擴展網絡帶寬。

12.2 分區的劣勢：

涉及多個key的操做一般是不被支持的。舉例來講，當兩個set映射到不一樣的redis實例上時，你就不能對這兩個set執行交集操做。
涉及多個key的redis事務不能使用。
當使用分區時，數據處理較爲複雜，好比你須要處理多個rdb/aof文件，而且從多個實例和主機備份持久化文件。
增長或刪除容量也比較複雜。redis集羣大多數支持在運行時增長、刪除節點的透明數據平衡的能力，可是相似於客戶端分區、代理等其餘系統則不支持這項特性。然而，一種叫作presharding的技術對此是有幫助的。

12.3 分區的類型：

Redis 有兩種類型分區。假設有4個Redis實例 R0，R1，R2，R3，和相似user:1，user:2這樣的表示用戶的多個key，對既定的key有多種不一樣方式來選擇這個key存放在哪一個實例中。也就是說，有不一樣的系統來映射某個key到某個Redis服務。

範圍分區：

　　最簡單的分區方式是按範圍分區，就是映射必定範圍的對象到特定的Redis實例。

　　好比，ID從0到10000的用戶會保存到實例R0，ID從10001到 20000的用戶會保存到R1，以此類推。

　　這種方式是可行的，而且在實際中使用，不足就是要有一個區間範圍到實例的映射表。這個表要被管理，同時還須要各種對象的映射表，一般對Redis來講並不是是好的方法。

哈希分區：

　　另一種分區方法是hash分區。這對任何key都適用，也無需是object_name:這種形式，像下面描述的同樣簡單：

- 用一個hash函數將key轉換爲一個數字，好比使用crc32 hash函數。對key foobar執行crc32(foobar)會輸出相似93024922的整數。
- 對這個整數取模，將其轉化爲0-3之間的數字，就能夠將這個整數映射到4個Redis實例中的一個了。93024922 % 4 = 2，就是說key foobar應該被存到R2實例中。注意：取模操做是取除的餘數，一般在多種編程語言中用%操做符實現。

13.Redis性能測試

Redis 性能測試是經過同時執行多個命令實現的。

語法：

redis-benchmark [option] [option value]

具體實例：

如下實例同時執行 10000 個請求來檢測性能：

[root@BrianZhu redis-4.0.8]# src/redis-benchmark -n 10000  -q
PING_INLINE: 94339.62 requests per second
PING_BULK: 92592.59 requests per second
SET: 91743.12 requests per second
GET: 90090.09 requests per second
INCR: 97087.38 requests per second
LPUSH: 96153.84 requests per second
RPUSH: 96153.84 requests per second
LPOP: 97087.38 requests per second
RPOP: 97087.38 requests per second
SADD: 96153.84 requests per second
HSET: 93457.95 requests per second
SPOP: 97087.38 requests per second
LPUSH (needed to benchmark LRANGE): 94339.62 requests per second
LRANGE_100 (first 100 elements): 95238.10 requests per second
LRANGE_300 (first 300 elements): 95238.10 requests per second
LRANGE_500 (first 450 elements): 96153.84 requests per second
LRANGE_600 (first 600 elements): 78740.16 requests per second
MSET (10 keys): 83333.34 requests per second

14.Redis關閉持久化(單純的作緩存)

數據持久化是Redis不一樣於其餘緩存的一個特性，具備明顯的有點。但如不但願持久化數據，只做爲普通的緩存用，如memcache

方法：

將配置文件中關於save配置信息所有註釋，以下：

#save 900 1  
#save 300 10  
#save 60 10000

或執行操做命令：

CONFIG SET save ""

執行命令後，無需重啓便可生效

15.Redis可視化工具

都到這裏了確定命令都已經玩膩了吧如今來新菜了那就是Redis的可視化工具它的名字叫：RedisDesktopManager 下載地址：https://redisdesktop.com/download

安裝鏈接就很簡單了和windows的其餘軟件同樣下一步下一步就行了軟件是全英文的可是看懂也不須要太好的英文水平其實我就是個英文盲下面就貼幾張圖結束吧

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Redis學習筆記

1.什麼是Redis

2.安裝Redis(Linux)

3.設置密碼，遠程鏈接

4.Redis的數據類型

4.1 字符串(String):

4.2 集合(Set):

4.3 列表(List):

4.4 哈希(Map):

4.5 有序集合(Sorted set):

5.Redis的發佈訂閱

6.Redis的HyperLogLog

7.Redis的事務

8.Redis的腳本

9.Redis的數據備份與恢復

10.Redis數據庫操做

11.Redis管道技術(哈哈 還在學習中)

12.Redis分區

13.Redis性能測試

14.Redis關閉持久化(單純的作緩存)

15.Redis可視化工具

11.Redis管道技術(哈哈還在學習中)