redis原理及使用

我的總結：

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

Redis的優勢:

性能極高 – Redis能支持超過 100K+ 每秒的讀寫頻率。
豐富的數據類型 – Redis支持二進制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 數據類型操做。
原子 – Redis的全部操做都是原子性的，同時Redis還支持對幾個操做全並後的原子性執行。
豐富的特性 – Redis還支持 publish/subscribe, 通知, key 過時等等特性。

下面是官方的bench-mark數據：
測試完成了50個併發執行100000個請求。
設置和獲取的值是一個256字節字符串。
Linux box是運行Linux 2.6,這是X3320 Xeon 2.5 ghz。
文本執行使用loopback接口(127.0.0.1)。
結果:寫的速度是110000次/s,讀的速度是81000次/s 。

===================redis使用說明:
1.cmd中啓動
D:\Redis>redis-server.exe redis.conf
2.執行命令：
D:\Redis>redis-cli.exe -h 172.16.147.121 -p 6379
3.設置數值：
redis 172.16.147.121:6379> set city Shanghai
4.獲取數值：
redis 172.16.147.121:6379> get city
====================
using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace redis
{
    public partial class Form1 : Form
    {
        RedisClient redisClient = null;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            redisClient = new RedisClient("localhost", 6379);//redis服務IP和端口
        }

        private void button2_Click(object sender, EventArgs e)
        {
            redisClient.Add<string>("name", "郭澤峯");
        }

        private void button3_Click(object sender, EventArgs e)
        {
            MessageBox.Show(redisClient.Get<string>("name"));
        }
    }
}

==========jedis:
  //鏈接redis服務器，192.168.0.100:6379
 19         jedis = new Jedis("192.168.0.100", 6379);
 20         //權限認證
 21         jedis.auth("admin");  
  jedis.set("name","xinxin");//向key-->name中放入了value-->xinxin  
 31         System.out.println(jedis.get("name"));//執行結果：xinxin  
===主從監視器：sentinels

  JedisPoolConfig poolConfig = new JedisPoolConfig();
12         String masterName = "mymaster";
13         Set<String> sentinels = new HashSet<String>();
14         sentinels.add("192.168.1.97:26379");
15         sentinels.add("192.168.1.96:26379");
16         JedisSentinelPool jedisSentinelPool = new JedisSentinelPool(masterName, sentinels, poolConfig);
17         HostAndPort currentHostMaster = jedisSentinelPool.getCurrentHostMaster();
18         System.out.println(currentHostMaster.getHost()+"--"+currentHostMaster.getPort());//獲取主節點的信息
19         Jedis resource = jedisSentinelPool.getResource();
20         String value = resource.get("a");
21         System.out.println(value);//得到鍵a對應的value值
22         resource.close();
23     }

================
JedisPoolConfig poolConfig = new JedisPoolConfig();
12         Set<HostAndPort> nodes = new HashSet<HostAndPort>();
13         HostAndPort hostAndPort = new HostAndPort("192.168.1.99", 7000);
14         HostAndPort hostAndPort1 = new HostAndPort("192.168.1.99", 7001);
15         HostAndPort hostAndPort2 = new HostAndPort("192.168.1.99", 7002);
16         HostAndPort hostAndPort3 = new HostAndPort("192.168.1.99", 7003);
17         HostAndPort hostAndPort4 = new HostAndPort("192.168.1.99", 7004);
18         HostAndPort hostAndPort5 = new HostAndPort("192.168.1.99", 7005);
19         nodes.add(hostAndPort);
20         nodes.add(hostAndPort1);
21         nodes.add(hostAndPort2);
22         nodes.add(hostAndPort3);
23         nodes.add(hostAndPort4);
24         nodes.add(hostAndPort5);
25         JedisCluster jedisCluster = new JedisCluster(nodes, poolConfig);//JedisCluster中默認分裝好了鏈接池.
26         //redis內部會建立鏈接池，從鏈接池中獲取鏈接使用，而後再把鏈接返回給鏈接池
27         String string = jedisCluster.get("a");
28         System.out.println(string);            
=======================================

　　

reids存儲類型：string list hash set sortedset.
高速緩存數據庫。
緩存，數據緩存，頁面緩存。

====redis優：

1.支持多數據類型，
2.支持主從模式
3.支持持久化
4.單個value限制是1GB，memcached爲1M數據。

=================

redis能夠作存儲。

redis-server ./redis.conf 打開redis。
./redis-cli -h 172.17.5.20 -p 6379
10: 讓redis之後臺進程的形式運行
編輯conf配置文件,修改以下內容；

daemonize yes

==命令:
set key value；
del key1 key2 ... Keyn
rename key newkey（newkey已存在則會被覆蓋）
renamenx key newkey (不存在才改變)返回0 失敗

keys *

keys s* 模糊查詢；
keys sit[ey] e後者
有3個通配符 *, ? ,[]
*: 通配任意多個字符
?: 通配單個字符
[]: 通配括號內的某1個字符

redis默認建立16個數據庫:(0-15)
---databases 16 默認16個數據庫

select 1 選擇1號數據庫。
select 0 選擇2號數據庫
---移動一個key到2號數據庫。
move cc 2
----默認有效期：永久，但也能夠設置有效期。

--
randomkey 返回隨機key
exists key
判斷key是否存在,返回1/0
type key
返回key存儲的值的類型
有string,link,set,order set, hash

----查詢有效期:
ttl key (-1:永久)（-2：不存在）（生命週期，以秒爲單位）

expire key 10 設置10,10秒後消失。

---設置毫秒爲生命週期：
pexpire key 毫秒數, 設置生命週期
pttl key, 以毫秒返回生命週期
---
persist key
做用: 把指定key置爲永久有效

==============字符串操做相關：

set key val 返回nil 失敗。

set key value [ex 秒數] / [px 毫秒數] [nx] /[xx]

如: set a 1 ex 10 , 10秒有效
Set a 1 px 9000 , 9秒有效
注: 若是ex,px同時寫,之後面的有效期爲準
如 set a 1 ex 100 px 9000, 實際有效期是9000毫秒

nx: 表示key不存在時,執行操做
xx: 表示key存在時,執行操做

-----
mset multi set , 一次性設置多個鍵值:

例: mset key1 v1 key2 v2 ....
mget key1 key2 ..keyn
做用:獲取多個key的值

---
flushdb 清空

----偏移:s
setrange key offset value

好比 hellow setrange key offset 2 xx hexxow 就是從索引2開始替換，把xx填充並替換原來的.
-----
append key value
做用: 把value追加到key的原值上
--
'chinese'
getrange title 0 3 返回chin
----
getset key newvalue
做用: 獲取並返回舊值,設置新值
--
incr key
做用: 指定的key的值加1,並返回加1後的值

---秒殺活動，好比1000部手機，1000個併發後，利用1000 decre ,以後用戶獲取資格，而後經過隊列去下單。
---一次性增加number.
incrby key number
decrby key number
---增加浮點數
incrbyfloat key floatnumber
incrbyfloat age 3.5
---操做位（能夠將大寫變小寫，差32位）
setbit key offset value
getbit key offset

=================link相關：鏈表：(l:頭，r:尾)
lpush key value value2 value3, 注意：若是是lpush，順序是倒序的。
做用: 把值插入到連接頭部

rpop key
做用: 返回並刪除鏈表尾元素

rpush,lpop: 不解釋

lrange key start stop
做用: 返回鏈表中[start ,stop]中的元素
規律: 左數從0開始,右數從-1開始
===
lrem key count value
lrem key count value
做用: 從key鏈表中刪除 value值
注: 刪除count的絕對值個value後結束
Count>0 從表頭刪除
Count<0 從表尾刪除

lrem key -2 a 從尾部刪除兩個a

-----------

ltrim key start stop
做用: 剪切key對應的連接,切[start,stop]一段,並把該段從新賦給key
lindex key index
做用: 返回index索引上的值,
如 lindex key 2
llen key
做用:計算連接表的元素個數
linsert key after|before search value
做用: 在key鏈表中尋找’search’,並在search值以前|以後,.插入value
注: 一旦找到一個search後,命令就結束了,所以不會插入多個value
好比：12345
linsert key before 3 0
120345

找不到返回-1；
--若果有多個，那隻會插入第一個，就結束了。

----（source和dest是兩個link）,這個操做時原子性的。******************

rpoplpush source dest 返回移動的值。
做用: 把source的尾部拿出,放在dest的頭部,
---
這個頗有用，能夠用作安全隊列:
好比有兩個鏈表，消費鏈表link 和備份鏈表bak
1.咱們把消費訂單存入link,
2.進行業務操做的時候，利用rpoplpush,拿處處理的訂單編號進行處理，一旦成功，咱們就把bak中刪除（lpop bak），若是失敗，咱們繼續從bak取出進行處理(rpop bak)--逐個處理錯誤item。

-----
brpop ,blpop key timeout
做用:等待彈出key的尾/頭元素,
Timeout爲等待超時時間
若是timeout爲0,則一直等待

場景: 長輪詢Ajax,在線聊天時,可以用到

====若是統計1億用戶周活躍數，好比一週登陸4次的用戶，咱們就能夠利用redis 位操做來實現：
用戶登陸1，未登陸0.userid獲得位的索引，
setbit mon=1000000000000001
setbit mon 3 1 將3用戶設置爲登陸
.
.
.
每週都會產生一個1億的位，
最後統計：
bittop add mon fe thr 累加獲得一個數字，拿這個數字判斷第幾個位就能夠獲得登陸次數；

------set:

集合 set 相關命令

集合的性質: 惟一性,無序性,肯定性

注: 在string和link的命令中,能夠經過range 來訪問string中的某幾個字符或某幾個元素
但,由於集合的無序性,沒法經過下標或範圍來訪問部分元素.
所以想看元素,要麼隨機先一個,要麼全選.
smembers key
做用: 返回集中中全部的元素
srem value1 value2
做用: 刪除集合中集爲 value1 value2的元素
返回值: 忽略不存在的元素後,真正刪除掉的元素的個數
srandmember key (不刪除)
做用: 返回集合key中,隨機的1個元素.
spop key
做用: 返回並刪除集合中key中1個隨機元素
隨機--體現了無序性

sismember key value
做用: 判斷value是否在key集合中
是返回1,否返回0
scard key
做用: 返回集合中元素的個數

move source dest value
做用:把source中的value刪除,並添加到dest集合中
sinter key1 key2 key3
做用: 求出key1 key2 key3 三個集合中的交集,並返回
sinterstore dest key1 key2 key3
做用: 求出key1 key2 key3 三個集合中的交集,並賦給dest

suion key1 key2.. Keyn
做用: 求出key1 key2 keyn的並集,並返回

sdiff key1 key2 key3
做用: 求出key1與key2 key3的差集
即key1-key2-key3

==================有序set:添加權重score來排序:
order set 有序集合
zadd key score1 value1 score2 value2 ..
添加元素

redis 127.0.0.1:6379> zadd stu 18 lily 19 hmm 20 lilei 21 lilei
(integer) 3

-------------------------

---排名start到排名stop（數字位第幾名，區分）
ZRANGE key start stop [WITHSCORES]
把集合排序後,返回名次[start,stop]的元素
默認是升續排列

--
zrangebyscore key min max [withscores] limit offset N
做用: 集合(升續)排序後,取score在[min,max]內的元素,
並跳過 offset個, 取出N個
zrangebyscore stu 3 12 limit 1 2 withscores
---withscores 把score也當成item打印出來:

---查詢名次:(升序)
rank key member
查詢member的排名(升續 0名開始)
---降序查詢名次：
zrevrank key memeber
--------------
zrem key value1 value2 ..
做用: 刪除集合中的元素

zremrangebyscore key min max
做用: 按照socre來刪除元素,刪除score在[min,max]之間的
redis 127.0.0.1:6379> zremrangebyscore stu 4 10
zremrangebyrank key start end
做用: 按排名刪除元素,刪除名次在[start,end]之間的
redis 127.0.0.1:6379> zremrangebyrank stu 0 1
----
zremrangebyrank key start end
做用: 按排名刪除元素,刪除名次在[start,end]之間的
redis 127.0.0.1:6379> zremrangebyrank stu 0 1
---
zcard key
返回元素個數

zcount key min max
返回[min,max] 區間內元素的數量

---------------切記[min,max]，中括號也包括min和max的。

------numkeys：待求交集的數量，好比求key1和key2的交集則numkeys爲2；
zinterstore destination numkeys key1 [key2 ...]
[WEIGHTS weight [weight ...]]
[AGGREGATE SUM|MIN|MAX]
求key1,key2的交集,key1,key2的權重分別是 weight1,weight2
聚合方法用: sum |min|max
聚合的結果,保存在dest集合內
注意: weights ,aggregate如何理解?
答: 若是有交集, 交集元素又有socre,score怎麼處理?
Aggregate sum->score相加 , min 求最小score, max 最大score

另: 能夠經過weigth設置不一樣key的權重, 交集時,socre * weights

-----------------------------Hash 哈希數據類型相關命令
hset key field value
做用: 把key中 filed域的值設爲value
注:若是沒有field域,直接添加,若是有,則覆蓋原field域的值

----多個:

hmset key field1 value1 [field2 value2 field3 value3 ......fieldn valuen]
hmget key field1 field2 fieldN
做用: 返回key中field1 field2 fieldN域的值
hgetall key
做用:返回key中,全部域與其值
hdel key field
做用: 刪除key中 field域
hlen key
做用: 返回key中元素的數量
hexists key field
做用: 判斷key中有沒有field域

------讓值增長小數點。
hinrby key field value
做用: 是把key中的field域的值增加整型值value
hinrby float key field value
做用: 是把key中的field域的值增加浮點值value
hkeys key
做用: 返回key中全部的field
kvals key
做用: 返回key中全部的value

====
Redis 中的事務

Redis支持簡單的事務

Redis與 mysql事務的對比

Mysql Redis
開啓 start transaction muitl
語句 普通sql 普通命令
失敗 rollback 回滾 discard 取消
成功 commit exec

注: rollback與discard 的區別
若是已經成功執行了2條語句, 第3條語句出錯.
Rollback後,前2條的語句影響消失.
Discard只是結束本次事務,前2條語句形成的影響仍然還在
====原理：
muitl,s原理先放到queued隊列中，exec以後再執行。
放入隊列中時，只是檢查語法的正確性，並無檢查類型啊（不如在數字上累加字母），
Exec以後,會執行正確的語句,並跳過有不適當的語句.根本不會回滾。
=====

注:
在mutil後面的語句中, 語句出錯可能有2種狀況
1: 語法就有問題,
這種,exec時,報錯, 全部語句得不到執行

2: 語法自己沒錯,但適用對象有問題. 好比 zadd 操做list對象
Exec以後,會執行正確的語句,並跳過有不適當的語句.

(若是zadd操做list這種事怎麼避免? 這一點,由程序員負責)

思考:
我正在買票
Ticket -1 , money -100
而票只有1張, 若是在我multi以後,和exec以前, 票被別人買了---即ticket變成0了.
我該如何觀察這種情景,並再也不提交

悲觀的想法:
世界充滿危險,確定有人和我搶, 給 ticket上鎖, 只有我能操做. [悲觀鎖]

樂觀的想法:
沒有那麼人和我搶,所以,我只須要注意,
--有沒有人更改ticket的值就能夠了 [樂觀鎖]

Redis的事務中,啓用的是樂觀鎖,只負責監測key沒有被改動.
具體的命令---- watch命令
例:
redis 127.0.0.1:6379> watch ticket
OK
redis 127.0.0.1:6379> multi
OK
redis 127.0.0.1:6379> decr ticket
QUEUED
redis 127.0.0.1:6379> decrby money 100
QUEUED
redis 127.0.0.1:6379> exec
(nil) // 返回nil,說明監視的ticket已經改變了,事務就取消了.
redis 127.0.0.1:6379> get ticket
"0"
redis 127.0.0.1:6379> get money
"200"

watch 能夠監視多個key,只要有一個變化，就取消事務
watch key1 key2 ... keyN
做用:監聽key1 key2..keyN有沒有變化,若是有變, 則事務取消

unwatch
做用: 取消全部watch監聽

=======================
使用辦法:
訂閱端: Subscribe 頻道名稱
發佈端: publish 頻道名稱 發佈內容
客戶端例子:
redis 127.0.0.1:6379> subscribe news
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "news"
3) (integer) 1
1) "message"
2) "news"
3) "good good study"
1) "message"
2) "news"
3) "day day up"
服務端例子:
redis 127.0.0.1:6379> publish news 'good good study'
(integer) 1
redis 127.0.0.1:6379> publish news 'day day up'
(integer) 1

=========

Redis持久化配置

Redis的持久化有2種方式 1快照（rdb） 2是日誌

Rdb快照的配置選項:（rdbdump）:優點，由於是快照，因此恢復速度至關快。
(原理:每隔n分鐘或N次寫入後從內存dump數據造成rdb文件壓縮，放至到目錄上。)

save 900 1 // 900內,有1條寫入,則產生快照
save 300 1000 // 若是300秒內有1000次寫入,則產生快照
save 60 10000 // 若是60秒內有10000次寫入,則產生快照

(這3個選項都屏蔽,則rdb禁用)
---時間和更改頻率來造成梯形的dump方案。

新版本由新的進程導出版本.

stop-writes-on-bgsave-error yes // 後臺備份進程出錯時,主進程停不中止寫入? (rdb的導入進程出錯了，redis中止寫入)

rdbcompression yes // 導出的rdb文件是否壓縮

Rdbchecksum yes // 導入rbd恢復時數據時,要不要檢驗rdb的完整性:

dbfilename dump.rdb //導出來的rdb文件名

dir ./ //rdb的放置路徑

-------保存條件：1分鐘，5分鐘，15分鐘才保存，因此不在裏面作的修改，斷電等
故障都會丟失。

-------rdb的缺點，時間間隔內容易形成數據丟失。

---爲了更精準，新版本增長了aof日誌持久化。以下：是（append）

Aof 的配置 主要是 only append file.

 

--rdb原理，rdb導出進程，根據配置導出rdb的條件設置，按期的導出rdb快照，容易丟失，但恢復快照比較快
--aof原理，每執行一個命令，aof進程都會將命令記錄到txt文檔中。
寫txt會嚴重拖慢redis。

appendonly no # 是否打開 aof日誌功能(yes:打開)

appendfsync always # 每1個命令,都當即同步到aof. 安全,速度慢
appendfsync everysec # 折衷方案,每秒寫1次-----最佳方案***************8
appendfsync no # 寫入工做交給操做系統,由操做系統判斷緩衝區大小,統一寫入到aof. 同步頻率低,速度快,

no-appendfsync-on-rewrite yes: # 正在導出rdb快照的過程當中,要不要中止同步aof
auto-aof-rewrite-percentage 100 #aof文件大小比起上次重寫時的大小,增加率100%時,重寫
auto-aof-rewrite-min-size 64mb #aof文件,至少超過64M時,重寫
===
注: 在dump rdb過程當中,aof若是中止同步,會不會丟失?
答: 不會,全部的操做緩存在內存的隊列裏, dump完成後,統一操做.
注: aof重寫是指什麼?

答: aof重寫是指把內存中的數據,逆化成命令,寫入到.aof日誌裏.
以解決 aof日誌過大的問題.（由於對同一key value操做的步驟比較多，日誌比較多，但內存中就有一個最終的狀態，因此重寫成簡單一次性命令
好比最終set key value.下降文件的大小。
）
auto-aof-rewrite-percentage 100 #aof文件大小比起上次重寫時的大小,增加率100%時,重寫
auto-aof-rewrite-min-size 64mb #aof文件,至少超過64M時,重寫

問: 若是rdb文件,和aof文件都存在,優先用誰來恢復數據?
答: aof
問: 2種是否能夠同時用?
答: 能夠,並且推薦這麼作
問: 恢復時rdb和aof哪一個恢復的快
答: rdb快,由於其是數據的內存映射,直接載入到內存,而aof是命令,須要逐條執行

----redis兩種持久化同時配置，最終，可能會丟失1s的數據。

====================redis集羣：
集羣優勢:
1.主從備份，防止主機宕機。
2.讀寫分離，分擔master的任務。
3.任務分離，分擔工做與計算。
----
方案：
1.master下面有兩個孩子，兩個孩子直接指向master(樹).
2.線性，第一個孩子指向master,第二個孩子指向第一個孩子.

原理：
主從通訊：slave啓動以後連接master,slave發出同步命令，save拿到dump出的rdb
快照，以後再拿緩衝aof隊列中的日誌數據進行數據填充。

---master配置:
1.關閉rdb快照（備份工做交給slave）
2.能夠開啓aof

slave配置：
1.聲明slave-of (slave-of localhsot 6379)
2.若是master有密碼，slave也要有密碼
3.打開rdb快照
4.配置是否只讀[salve-read-only]

---主;
passwordrequire 密碼
--slave
masterauth 密碼

=============主從缺點：
每次slave斷開後，不管是主動斷開仍是網絡故障，再連接master,
都要master所有dump導出rdb再aof.
因此，啓動slave要一個一個啓動，且有時間間隔。要否則
master主IO劇增。

============
redis 服務器端命令
redis 127.0.0.1:6380> time ,顯示服務器時間 , 時間戳(秒), 微秒數
1) "1375270361"
2) "504511"

redis 127.0.0.1:6380> dbsize // 當前數據庫的key的數量 當前庫，並非當前服務器
(integer) 2
redis 127.0.0.1:6380> select 2 //選擇庫：
OK
redis 127.0.0.1:6380[2]> dbsize
(integer) 0
redis 127.0.0.1:6380[2]>

BGREWRITEAOF 後臺進程重寫AOF
BGSAVE 後臺保存rdb快照—後臺單起一個進程。
SAVE 保存rdb快照----當前進程，須要等待。
LASTSAVE 上次保存時間

Slaveof master-Host port , 把當前實例設爲master的slave

Flushall 清空全部庫全部鍵
Flushdb 清空當前庫全部鍵---n號數據庫
Showdown [save/nosave]

注: 若是不當心運行了flushall, 當即 shutdown nosave ,關閉服務器（shutdown會重寫aof，因此加上nosave）
而後 手工編輯aof文件, 去掉文件中的 「flushall 」相關行, 而後開啓服務器,就能夠導入回原來數據.

若是,flushall以後,系統剛好bgrewriteaof了,那麼aof就清空了,數據丟失.

Slowlog 顯示慢查詢
注:多慢才叫慢?
答: 由slowlog-log-slower-than 10000 ,來指定,(單位是微秒)

服務器儲存多少條慢查詢的記錄?
答: 由 slowlog-max-len 128 ,來作限制

Info [Replication/CPU/Memory..]
查看redis服務器的信息

Config get 配置項
Config set 配置項 值 (特殊的選項,不容許用此命令設置,如slave-of, 須要用單獨的slaveof命令來設置)

Redis運維時須要注意的參數
1: 內存
# Memory
used_memory:859192 數據結構的空間
used_memory_rss:7634944 實佔空間
mem_fragmentation_ratio:8.89 前2者的比例,1.N爲佳,若是此值過大,說明redis的內存的碎片化嚴重,能夠導出再導入一次.
2: 主從複製
# Replication
role:slave
master_host:192.168.1.128
master_port:6379
master_link_status:up

3:持久化
# Persistence
rdb_changes_since_last_save:0
rdb_last_save_time:1375224063

4: fork耗時
#Status
latest_fork_usec:936 上次導出rdb快照,持久化花費微秒
注意: 若是某實例有10G內容,導出須要2分鐘,
每分鐘寫入10000次,致使不斷的rdb導出,磁盤始處於高IO狀態.

5: 慢日誌
config get/set slowlog-log-slower-than
CONFIG get/SET slowlog-max-len
slowlog get N 獲取慢日誌

運行時更改master-slave

修改一臺slave(設爲A)爲new master
1) 命令該服務不作其餘redis服務的slave
命令: slaveof no one
2) 修改其readonly爲yes
命令：config set slave-read-only no
config get slave-read-only

其餘的slave再指向new master A
1) 命令該服務爲new master A的slave
命令格式 slaveof IP port

====

quit //關閉客戶端.

==redis複製

save一下:

rdb文件複製，後配置redis.conf文件 rdb文件路徑指向，重啓就能夠了.
注意：複製的時候，必定保證reb文件不被佔用，停掉redis.

-------------copy bin下面sentinel.conf.

sentinel主要是監控主從redis是否運行正常，不正常切換主從.

sentinel監控主從原理：監控主redis,若是不迴應出現問題，就會將slave設爲master.
其餘slave指向它。

Sentinel不斷與master通訊,獲取master的slave信息.
監聽master與slave的狀態
若是某slave失效,直接通知master去除該slave.

若是master失效,,是按照slave優先級(可配置), 選取1個slave作 new master
,把其餘slave--> new master

疑問: sentinel與master通訊,若是某次由於master IO操做頻繁,致使超時,
此時,認爲master失效,很武斷.
解決: sentnel容許多個實例看守1個master, 當N臺(N可設置)sentinel都認爲master失效,才正式失效.

Sentinel選項配置
port 26379 # 端口
sentinel monitor mymaster 127.0.0.1 6379 2 ,
給主機起的名字(不重便可),
當2個sentinel實例都認爲master失效時,正式失效

sentinel down-after-milliseconds mymaster 30000 多少毫秒後鏈接不到master認爲斷開
sentinel can-failover mymaster yes #是否容許sentinel修改slave->master. 如爲no,則只能監控,無權修改./
sentinel parallel-syncs mymaster 1 , 一次性修改幾個slave指向新的new master.（一次性都指向，會
形成masterd umprdb和aof日誌文件io讀寫，因此一臺一臺改）
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh ,# 在從新配置new master,new slave過程,能夠觸發的腳本

啓動:./redis-server ./sentinel.conf --sentinel

==========
Redis key 設計技巧

1: 把表名轉換爲key前綴 如, tag:
2: 第2段放置用於區分區key的字段--對應mysql中的主鍵的列名,如userid
3: 第3段放置主鍵值,如2,3,4...., a , b ,c
4: 第4段,寫要存儲的列名

用戶表 user , 轉換爲key-value存儲
userid username passworde email
9 Lisi 1111111 lisi@163.com

set user:userid:9:username lisi
set user:userid:9:password 111111
set user:userid:9:email lisi@163.com

keys user:userid:9*

2 注意:
在關係型數據中,除主鍵外,還有可能其餘列也步驟查詢,
如上表中, username 也是極頻繁查詢的,每每這種列也是加了索引的.

轉換到k-v數據中,則也要相應的生成一條按照該列爲主的key-value
Set user:username:lisi:uid 9

這樣,咱們能夠根據username:lisi:uid ,查出userid=9,
再查user:9:password/email ...

完成了根據用戶名來查詢用戶信息

====================新版集羣：

=======redis集羣：設置配置文件:
daemonize yes # redis默認不是後臺啓動，這裏修改爲後臺啓動
cluster-enabled yes # 容許redis支持集羣模式
cluster-config-file nodes.conf # 節點配置文件
cluster-node-timeout 15000 # 節點超時毫秒
appendonly yes
注意：6個節點下的redis.conf都須要修改，能夠修改一個以後拷貝過去。
而後6個節點執行
make
make install
啓動實例
在6個節點分別執行redis-server redis.conf，在6個節點上啓動6個redis的實例
搭建redis集羣（在其中一個節點操做就能夠了）
依賴於ruby環境，首先安裝ruby （yum install ruby）
sudo apt-get install ruby
sudo apt-get install rubygem

---下載不下來能夠用以下L
tar xvzf rubygems-1.3.4.tgz
cd rubygems-1.3.4
sudo ruby setup.rb 便可

接下去須要安裝ruby的redis api，gem install redis，這個地方試過各類方法（切換爲taobao的鏡像源）都不能夠，因此咱們這邊去官網下載一個，而後手動安裝。
wget https://rubygems.global.ssl.fastly.net/gems/redis-3.2.2.gem

sudo gem install -l ./redis-3.2.2.gem

必定要安裝 redis-3.2.2.gem,千萬別忘了gzf;

--若是集羣設置密碼，那麼這裏面的也要設置密碼

 

接下去啓動集羣
cd src
./redis-trib.rb create --replicas 1 xxx.xxx.xx.140:6379 xxx.xxx.xx.141:6379 xxx.xxx.xx.143:6379 xxx.xxx.xx.145:6379 xxx.xxx.xx.147:6379 xxx.xxx.xx.148:6379
注意ip修改爲本身的～～
--replicas 1 表示咱們但願爲集羣中的每一個主節點建立一個從節點，因爲sedis的集羣最少須要3個主節點，若是咱們每一個主節點須要一個從節點，那麼最少須要6臺機器（或者說6個實例）。
14五、14七、148這3個將成爲主節點，140、14一、143將依次稱爲主節點的從節點，咱們看命令執行以後的結果：

---
ruby redis-trib.rb create 127.0.0.1:6379 127.0.0.1:6380 127.0.0.1:6381

----reids設置密碼，後masterauth也要設置相同密碼；
requirepass和masterauth都須要設置
--修改這裏的密碼：
/usr/local/share/gems/gems/redis-3.2.2/lib/redis

-------測試集羣:
./redis-cli -c -p 6379
cluster info
cluster nodes
-------密碼測試集羣:
./redis-cli -c -p 6379 -a gzf
========
redis集羣主庫之間是惟一的key,會根據key跳轉到不一樣的master上；

##############sysctl文件###############
[root@redis ~]# echo "vm.overcommit_memory=1" >> /etc/sysctl.confs
[root@redis ~]# sysctl -p
#############kerbel####################
[root@redis ~]# echo never > /sys/kernel/mm/transparent_hugepage/enabled

第一個警告兩個方式解決(overcommit_memory)
1. echo "vm.overcommit_memory=1" > /etc/sysctl.conf 或 vi /etcsysctl.conf , 而後reboot重啓機器
2. echo 1 > /proc/sys/vm/overcommit_memory 不須要啓機器就生

第二個警告解決
1. echo 511 > /proc/sys/net/core/somaxconn

====redis開機啓動:

/root/tools/java/redis-3.0.5/utils/redis_init_script

#大體瀏覽下該啓動腳本，發現redis習慣性用監聽的端口名做爲配置文件等命名，咱們後面也遵循這個約定。
#redis服務器監聽的端口
REDISPORT=6379
#服務端所處位置，在make install後默認存放與`/usr/local/bin/redis-server`，若是未make install則須要修改該路徑，下同。
EXEC=/usr/local/bin/redis-server
#客戶端位置
CLIEXEC=/usr/local/bin/redis-cli
#Redis的PID文件位置
PIDFILE=/var/run/redis_${REDISPORT}.pid
#配置文件位置，須要修改

複製到/
=================
#修改daemonize爲yes，即默認之後臺程序方式運行（還記得前面手動使用&號強制後臺運行嗎）。
daemonize no
#可修改默認監聽端口
port 6379
#修改生成默認日誌文件位置
logfile "/home/futeng/logs/redis.log"
#配置持久化文件存放位置
dir /home/futeng/data/redisData
啓動時指定配置文件
redis-server ./redis.conf
#若是更改了端口，使用`redis-cli`客戶端鏈接時，也須要指定端口，例如：
redis-cli -p 6380
其餘啓停同 直接啓動 方式。配置文件是很是重要的配置工具，隨着使用的逐漸深刻將顯得尤其重要，推薦在一開始就使用配置文件。

chkconfig --add redis 不支持添加以下：

#!/bin/sh
# chkconfig: 2345 90 10
# description: Redis is a persistent key-value database

==========

Redis 官方提供了 redis-trib.rb 這個工具，就在解壓目錄的 src 目錄中，第三步中已將它複製到 /usr/local/bin 目錄中，能夠直接在命令行中使用了。使用下面這個命令便可完成安裝。

redis-trib.rb create --replicas 1 192.168.31.245:7000 192.168.31.245:7001 192.168.31.245:7002 192.168.31.210:7003 192.168.31.210:7004 192.168.31.210:7005
其中，前三個 ip:port 爲第一臺機器的節點，剩下三個爲第二臺機器。

等等，出錯了。這個工具是用 ruby 實現的，因此須要安裝 ruby。安裝命令以下：

yum -y install ruby ruby-devel rubygems rpm-build
gem install redis

簡單說一下原理

redis cluster在設計的時候，就考慮到了去中心化，去中間件，也就是說，集羣中的每一個節點都是平等的關係，都是對等的，每一個節點都保存各自的數據和整個集羣的狀態。
每一個節點都和其餘全部節點鏈接，並且這些鏈接保持活躍，這樣就保證了咱們只須要鏈接集羣中的任意一個節點，就能夠獲取到其餘節點的數據。

Redis 集羣沒有並使用傳統的一致性哈希來分配數據，而是採用另一種叫作哈希槽 (hash slot)的方式來分配的。
redis cluster 默認分配了 16384 個slot，當咱們set一個key 時，會用CRC16算法來取模獲得所屬的slot，而後將這個key 分到哈希槽區間的節點上，
具體算法就是：CRC16(key) % 16384。因此咱們在測試的時候看到set 和 get 的時候，直接跳轉到了7000端口的節點。

Redis 集羣會把數據存在一個 master 節點，而後在這個 master 和其對應的salve 之間進行數據同步。當讀取數據時，也根據一致性哈希算法到對應的 master 節點獲取數據。
只有當一個master 掛掉以後，纔會啓動一個對應的 salve 節點，充當 master 。

須要注意的是：必需要3個或以上的主節點，不然在建立集羣時會失敗，而且當存活的主節點數小於總節點數的一半時，整個集羣就沒法提供服務了。

====================
redis主從複製

redis主從配置比較簡單，基本就是在從節點配置文件加上:slaveof 192.168.33.130 6379
主要是經過master server持久化的rdb文件實現的。master server 先dump出內存快照文件，而後將rdb文件傳給slave server，slave server 根據rdb文件重建內存表。
redis複製過程以下：
一、slave server啓動鏈接到master server以後，salve server主動發送SYNC命令給master server
二、master server接受SYNC命令以後，判斷，是否有正在進行內存快照的子進程，若是有，則等待其結束，不然，fork一個子進程，子進程把內存數據保存爲文件，併發送給slave server
三、master server子進程進程作數據快照時，父進程能夠繼續接收client端請求寫數據，此時，父進程把新寫入的數據放到待發送緩存隊列中
四、slave server 接收內存快照文件以後，清空內存數據，根據接收的快照文件，重建內存表數據結構
五、master server把快照文件發送完畢以後，發送緩存隊列中保存的子進程快照期間改變的數據給slave server，slave server作相同處理，保存數據一致性
六、master server 後續接收的數據，都會經過步驟1創建的鏈接，把數據發送到slave server
須要注意：slave server若是由於網絡或其餘緣由斷與master server的鏈接，當slave server從新鏈接時，須要從新獲取master server的內存快照文件，slave server的數據會自動所有清空，而後再從新創建內存表，這樣會讓slave server 啓動恢復服務比較慢，同時也給master server帶來較大壓力，能夠看出redis的複製沒有增量複製的概念，這是redis主從複製的一個主要弊端，在實際環境中，儘可能規避中途增長從庫
redis2.8以前不支持增量，到2.8以後就支持增量了！

redis cluster（集羣）
redis集羣配置參考個人博文：http://blog.csdn.net/nuli888/article/details/52134117
3.0以後的功能，至少須要3(Master)+3(Slave)才能創建集羣，是無中心的分佈式存儲架構，能夠在多個節點之間進行數據共享，解決了Redis高可用、可擴展等問題。
Redis集羣提供瞭如下兩個好處
一、將數據自動切分(split)到多個節點
二、當集羣中的某一個節點故障時，redis還能夠繼續處理客戶端的請求。
一個 redis 集羣包含 16384 個哈希槽（hash slot），數據庫中的每一個數據都屬於這16384個哈希槽中的一個。集羣使用公式 CRC16(key) % 16384 來計算鍵 key 屬於哪一個槽。集羣中的每個節點負責處理一部分哈希槽。
集羣中的主從複製
集羣中的每一個節點都有1個至N個複製品，其中一個爲主節點，其他的爲從節點，若是主節點下線了，集羣就會把這個主節點的一個從節點設置爲新的主節點，繼續工做。這樣集羣就不會由於一個主節點的下線而沒法正常工做
注意：
一、若是某一個主節點和他全部的從節點都下線的話，redis集羣就會中止工做了。redis集羣不保證數據的強一致性，在特定的狀況下，redis集羣會丟失已經被執行過的寫命令
二、使用異步複製（asynchronous replication）是redis 集羣可能會丟失寫命令的其中一個緣由，有時候因爲網絡緣由，若是網絡斷開時間太長，redis集羣就會啓用新的主節點，以前發給主節點的數據就會丟失。

==========
Redis Cluster功能特色以下：

全部的節點相互鏈接

集羣消息通訊經過集羣總線通訊，，集羣總線端口大小爲客戶端服務端口+10000，這個10000是固定值

節點與節點之間經過二進制協議進行通訊

客戶端和集羣節點之間通訊和一般同樣，經過文本協議進行

集羣節點不會代理查詢

數據按照Slot存儲分佈在多個Redis實例上

集羣節點掛掉會自動故障轉移

能夠相對平滑擴/縮容節點

==========

Redis Cluster採用無中心結構，每一個節點保存數據和整個集羣狀態,每一個節點都和其餘全部節點鏈接。