1. NoSql的入门概述

1.1 入门概述

1.1.1 互联网时代背景下大机遇，为什么用nosql

1.1.1.1 单机Mysql的美好时代

一个网站的访问量一般都不大，而且更多的是静态页面，动态交互类型的网站不多，用单个数据库完全可以轻松应对。

上述架构下，数据存储的瓶颈是什么？
数据量的总大小一个机器放不下时
数据的索引（B+Tree一个机器的内存放不下时
访问量（读写混合一个实例不能承受

1.1.1.2 Memcached(缓存)+MySql+垂直拆分

随着访问量的上升，几乎发部分使用MySQL架构的网站在数据库上都开始出现性能问题，web程序不再仅仅专注在功能上，同时也在追求性能。程序员们开始大量的使用缓存技术来缓解数据库的压力，优化数据库的结构和索引。开始比较流行的是通过文件缓存来缓解数据库压力，但是访问量继续增大的时候，多台web机器通过文件缓存不能共享，大量的小文件缓存也带来了比较高的IO压力。因此，Memcached就成为了一个非常时尚的技术产品。

1.1.1.3 Mysql主从读写分离

由于数据库的写入压力增加，Memcached
只能缓解数据库的读取压力。读写集中在一个数据库上让数据库不堪重负，大部分网站开始使用主从复制技术来达到读写分离，以提高读写性能和读库的可扩展性。Mysql的master-slave模式成为这个时候的网站标配。

1.1.1.4 分表分库+水平拆分+MySql集群

在Memcached的高速缓存，MySQL的主从复制，读写分离的基础之上，这是MySQL的主库的写压力开始出现瓶颈，而数据量的持续猛增，由于MyISAM使用表锁，在高并发下会出现严重的锁问题，大量的高并发MySQL应用开始使用InnoDB
引擎代替MyISQM。

同时开始流行使用分表分库来缓解写压力和数据增长的扩展问题。这个时候，分表分库成了一个热门技术，是面试的热门问题也是业界讨论的热门技术问题。也就是在这个时候，MySQL推出了还不太稳定的表分区，虽然MySQL推出了MySQL Cluster集群，但性能也不能很好满足互联网的要求，只能在高可靠性上提供了非常大的保证。

1.1.1.5 MySql的拓展性瓶颈

MySQL数据库也经常存储一些大文本字段，导致数据库表非常的大，在做数据库恢复的时候就导致非常的慢，不容易快速回复数据库。比如1000万4KB大小的文本就接近40GB的大小，如果能把这些数据从MySQL省去，MySQL将变得非常的小。关系数据库很强大，但是它并不能很好的应付所的应用场景。MySQL的扩展性差（需要复杂的技术来实现），大数据下IO压力大，表结构更改困难，正式当前使用MySQL的开发人员面临的问题。

1.1.1.6 为什么使用NoSql

为什么使用NoSQL？
今天我们可以通过第方平台（如Google，Facebook等可以很容易的访问和抓取数据。用户个人信息，社交网络，地理位置，用户产生的数据和用户操作日志已经成倍的增加。
我们如果要对这些用户数据进行挖掘，那SQL数据库已经不适合这些应用了
，NoSQL数据库的发展却能很好的处理这些大的数据。

1.1.2 是什么？

NoSQL（NoSQL = Not Only SQL，意思是不仅仅是SQL，泛指非关系型的数据库。
随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题，包含超大规模数据的存储。

（例如古河或Facebook每天为他们的用户手机万亿比特的数据。
这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

1.1.3 能干吗？

1.1.3.1 易拓展

NoSQL数据库种类繁多，但是一个共同的特点都是去掉关系数据库的关系型特性。

数据之间无关系，这样就非常容易扩展。也无形之间，在架构的层面上带来了可扩展的能力。

1.1.3.2 大数据量高性能

NoSQL数据里都具非常高的读写性能，尤其在大数据量下，同样表现优秀。
这得益于它的无关系性，数据库的结构简单。
一般MySQL使用Query Cache，每次表的更新Cache就失效，是一种大粒度的Cache，在针对web2.0的交互频繁的应用，Cache性能不高。而NoSQL的Cache是记录级的，是一种细粒度的Cache，所以NoSQL在这个层面上来说就要性能高很多了。

1.1.3.3 多样灵活的数据模型

NoSQL无需事先为要存储的数据建立字段，随时可以存储自定义的数据格式。
而在关系数据库里，增删字段
是一件非常麻烦的事情。如果是非常大数据量的表，增加字段简直就是一个噩梦。

1.1.3.4 传统RDBMS VS NOSQL

RDBMS vs NoSQL

RDBMS
高度组织化结构化数据 结构化查询语言（SQL数据和关系都存储在单独的表中。数据操纵语言，数据定义语言严格的一致性基础事务

NoSQL
代表着不仅仅是SQL 没声明性查询语言 没预定义的模式
键值对存储，列存储，文档存储，图形数据库
最终一致性，而非ACID属性
非结构化和不可预知的数据
CAP定理
高性能，高可用和可伸缩性

1.1.3 有哪些？

Redis

Memcache

Mongdb

1.1.4 怎么玩？

KV

Cache

Persistence

1.2 3V+3高

1.2.1 大数据时代的3V

海量Volume

多样Variety

实时Velocity

1.2.2 互联网需求的3高

高并发

高可扩

高性能

1.3 NoSql数据模型简介: 聚合模型

KV键值

Bson

列族

图形

1.4 NoSql数据库的四大分类

1.4.1 KV键值:典型介绍

新浪:BerkeleyDB+Redis

美团:Redis+tair

阿里，百度:memcache+redis

1.4.2 文档型数据库(bson格式比较多):典型介绍

CounchDB

MongoDB

1.4.3 列存储数据库：典型介绍

Cassabdra,HBase

分布式文件系统

1.4.4 图关系数据库

Neo4j,InfoGrid

1.5 在分布式数据库中CAP原理CAP+BASE

1.5.1 传统的ACID

1.5.2 CAP

CAP的理论就是说在分布式存储系统中，最多只能实现上面的两点。而由于当前的网络硬件肯定会出现延迟丢包等问题，所以分区容忍性是我们必须要实现的。

所以我们只能在一致性和可用性之间进行权衡，没NoSQL系统能同时保证这一点。

C：强一致性 A：高可用性 P：分布式容错性

CA 传统Oracle数据库

AP大多数网站架构的择

CP Redis、Mongodb

1.5.3 BASE

BASE就是为了解决关系数据库强一致性引起的问题而引起的可用性降低而提出的解决方案。

BASE其实是下面个术语的缩写：
基本可用（Basically Available
软状态（Soft state
最终一致（Eventually consistent

它的思想是通过让系统放松对某一时刻数据
一致性
的要求来换取系统整体伸缩性和性能上改观。缘由就在于大型系统往往由于地域分布和极高性能的要求，不可能采用分布式事务来完成这些指标，我们必须采用另外一种方式来完成，这里BASE就是解决这个问题的办法。

1.5.4 分布式+集群简介

分布式：不同的多台服务器上面部署不同的服务模块（工程，他们之间通过Rpc/Rmi之间通信和调用，对外提供服务和组内协作。
集群：不同的多台服务器上面部署相同的服务模块，通过分布式调度软件进行统一的调度，对外提供服务和访问。

2. Redis入门介绍

2.1 是什么？

Redis：REmote DIctionary Server（远程字典服务器）

是完全开源免费的，用C语言编写的，遵守BSD协议，是一个高性能的（key/value分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库，被称为数据结构数据库。

Redis与其他key-value缓存产品一下三个特点:

1.Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用
2.Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储
3.Redis支持数据的备份，即master-slave模式的数据备份。

2.2 能干吗？

1.内存存储和持久化：redis支持异步将内存中的数据写到硬盘上，同时不影响继续服务。

2.取最新N个数据的操作，如：可以将最新的10条评论的ID放在Redis的List集合里面

3.模拟类似于HttpSession这种需要设定过期时间的功能

4.发布、订阅消息系统

5.定时器、计数器

2.3 去哪下？

1. http://redis.io/

2. 中文版本 http://www.redis.cn/

3. 历史版本 http://download.redis.io/releases/

2.4 怎么玩？

3. Redis下载安装

如果make出现错误

make执行成功之后再执行一下 make install

注意 : 原始的初始化文件咱们不动，咱们可以在根目录下创建一个文件夹
myredis 然后把初始化配置文件拷贝进里面，修改一下

改成后台启动 ，然后进入/usr/local/bin/ 指定配置启动

4. Redis启动后的杂项基础知识详解

4.1 详解

单进程模型来处理客户端的请求。对读写等时间的响应是通过对epoll函数的包装来做到的。Redis的实际处理速度完全依靠主进程的执行效率。

Epoll是Linux内核为处理大批量文件描述符而作了改进的epoll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只少量活跃情况下的系统CPU利用率。

默认16个数据库，类似数组下表从零开始，初始默认使用零号库

使用select 数字 切换库 0代表第一个库

使用dbsize查看当前库的key有多少 可以使用tab键，会自动补全

查看所有key 使用命令keys *

4.2 简记:

4.2.1 Select命令切换数据库

4.2.2 Dbsize查看当前数据库的key的数量

4.2.3 Flushdb：清空当前库

4.2.4 Flushall：通杀全部库

4.2.5 同一密码管理，16个库都是同样密码，要么都ok要么一个也连不上

4.2.6 Redis索引都是从零开始

4.2.7 为什么默认端口是6379?

6379在是手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字。MERZ长期以来被Redis作者antirez及其朋友当作愚蠢的代名词。后来Redis作者在开发Redis时就选用了这个端口。

5. Redis的数据类型

5.1 Redis的五大数据类型

5.1.1 String字符串

String（字符串)

string是redis最基本的类型，可以理解为Memcached一样的类型，一个key对应一个value。

string类型是二进制安全的，意思是redis的string可以包含任何数据。比如ipg图片或者序列化的对象。

string类型是Redis最基本的数据结构，一个redis中字符串value最多可以是512M。

5.1.2 Hash(哈希,类似java里面的Map)

Hash（哈希）
Redis hash是一个键值对集合。
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

类似java里面的Map<String,Object>

5.1.3 List(列表)

List(列表)
Redis列表是简单的字符串列表，照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）。
它的底层是一个链表。

5.1.4 Set(集合)

Set（集合
Redis的Set是string类型的无序集合。它是通过HashTable实现的。

5.1.5 Zset(sorted set有序集合)

zset（序集合
Redis zset和set一样也是string类型元素的集合，且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数
。
redis正是通过分数来为集合中的成员进行从小到大排序。zset的成员是唯一的，但分数（score却可以重复。

5.2 Redis命令参考

http://redisdoc.com/

5.3 Redis键(Key)

5.3.1 常用

1.  DEL key [key ...]

删除给定的一个或多个 key 。 不存在的 key 会被忽略。
返回值：被删除 key 的数量。

2.  EXISTS  key

检查给定 key 是否存在。
返回值：若 key 存在，返回 1 ，否则返回 0 。

3. EXPIRE  key seconds

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
返回值：
设置成功返回 1 。
当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

4.KEYS pattern

查找所符合给定模式 pattern 的 key 。
KEYS * 匹配数据库中所有 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
返回值：符合给定模式的 key 列表。

5.PERSIST key

移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。

返回值：
当生存时间移除成功时，返回 1 .
如果 key 不存在或 key 没有设置生存时间，返回 0 。

6.PEXPIRE key milliseconds

这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
返回值
设置成功，返回 1
key 不存在或设置失败，返回 0

7.PEXPIREAT key milliseconds-timestamp

这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
返回值：
如果生存时间设置成功，返回 1 。
当 key 不存在或没办法设置生存时间时，返回 0 。(查看 EXPIRE 命令获取更多信息)

8.PTTL key

这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
返回值：
当 key 不存在时，返回 -2 。
当 key 存在但没有设置剩余生存时间时，返回 -1 。
否则，以毫秒为单位，返回 key 的剩余生存时间。
在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

9.  RANDOMKEY

从当前数据库中随机返回(不删除)一个 key 。
返回值：
当数据库不为空时，返回一个 key 。
当数据库为空时，返回 nil 。

10.RENAME key newkey

将 key 改名为 newkey 。
当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
当 newkey 已经存在时， RENAME 命令将覆盖旧值。
返回值：改名成功时提示 OK ，失败时候返回一个错误。

11.  RENAMENX key newkey

当且仅当 newkey 不存在时，将 key 改名为 newkey 。
当 key 不存在时，返回一个错误。
返回值：
修改成功时，返回 1 。
如果 newkey 已经存在，返回 0 。

12.SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

返回或保存给定列表、集合、序集合 key 中经过排序的元素。
排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
一般 SORT 用法
最简单的 SORT 使用方法是 SORT key 和 SORT key DESC ：
SORT key 返回键值从小到大排序的结果。
SORT key DESC 返回键值从大到小排序的结果。

13.TTL key

以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
返回值：
当 key 不存在时，返回 -2 。
当 key 存在但没有设置剩余生存时间时，返回 -1 。
否则，以秒为单位，返回 key 的剩余生存时间。
在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

14.TYPE key

返回 key 所储存的值的类型。
返回值：
none (key不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)

5.3.2 案列

5.3.2.1 exists key的名字，判断是否存在

存在返回1 不存在返回0

5.3.2.2 move key db 从当前库移到某个库

5.3.2.3 expire key 秒:给指定key设置秒值

5.3.2.4 ttl key 查看还有多少秒过期, -1永不过期 -2已过期

5.3.2.5 type key 查看key的类型

5.4 Redis字符串(String) 单值单Vlue

5.4.1 常用

5.4.2 案列

del key 删除某个key 返回删除的条数

append key 相当于java里面的append 在指定key的value后面追加

strlen key 返回指定key的长度

下面这个必须value必须是数字

Incr key 在原来的数字key基础上自增

Decr key 在原来的数字key基础上自减

Incrby key 3 在原来key基础上加3

decrby key 3 在原来key基础上减3

getrange key 开始索引 结束索引 获取key的value值的指定区间索引，-1为全部

setrange key 开始索引 值 获取key的value并且从开始索引开始将值覆盖

setnx 如果不存在则set ,存在则忽视 使用这个是防止我们使用set 时覆盖原有的值
设置成功返回1，设置失败返回0

setex key 过期时间 value 设置值的同时设置过期时间

mset k1 v1 k2 v2 … 说白了等同于moreset 一次性设置多个值

mget k1 k2 k3 k4 k5 … 说白了等同于moreget 一次性获取多个key的值

msetnx k1 v1 k2 v2 … 注意 这是一次性设置多个值当这些值不存在时，但凡一个存在则设置不成功，返回0 设置成功则返回1

getset key value 先获取key并返回，再将value设置，覆盖

5.5 Redis列表(List) 单值多value

5.5.1 常用

5.5.2 案列

1push 从左边插入

rpush 从右边插入

读是根据队列的索引依次从左向右读的

lindex 按照索引下表获得元素(从上到下) llen 获取列表内元素个数

lrem key 数量 需要删除的value 删除N个Value

ltrim key 开始索引 结束索引 截取指定范围的值后再赋值给key

rpoplpush 源列表 目的列表 ：就是从原来的列表当中，rpop出来然后lpush进目标列表

lset key index value 就是将value值赋值到列表的index索引位置

linsert key before/after 值1 值2 就是从上到下，将值2插入到值1的前面或后面

5.5.3 性能总结

它是一个字符链表，left，right都可以插入添加。
如果键不存在，创建新的链表。
如果键已经存在，新增内容。
如果值全移除，对应的键也就消失了。
链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了。

5.6 Redis集合(Set)

5.6.1 常用

5.6.2 案列

sadd key value...       向集合当中添加元素
smembers key            列举集合里面的元素
sismember key value     判断key是否存在集合当中，存在返回1 ，不存在返回0         
scard                   获取集合里面的元素个数
srem key value          删除集合当中的指定元素

srandmember key 数字 代表从集合当中随机出几个数字，类似于砸金蛋这样，既要内存快也能达到这种效果
spop key 代表随机从集合当中弹出某个值

smove key1 key2 在key1里某个值 作用就是将key1 里的某个值赋给key2

数学集合类,类似与sql的join union
Sdiff k1 k2 代表k1 k2 取差集，k2有但是k1没有
sinter k1 k2 代表k1 k2 取交集，k1 k2都有的
sunion k1 k2 代表k1 k2 合并之后去重的结果集

5.7 Redis哈希(Hash)

5.7.1 常用

5.7.2 案列

hset key  key value         设置单个值
hget key key                获取单个值
hmset key k1 v1 k2 v2..     设置多个值
hgetall key                 获取key下所有的值
hdel key k1                 删除莫个key的值
hlen key                    获取长度
hexists key k1              判断是否存在
hkeys /hvals                获取所有的key/values

hincrby/hincrbyfloat key key 数字 代表在原来基础上递增多少整数/小数
hsetnx 存在则不添加，不存在则添加

5.8 Redis有序集合Zset(sorted set)

5.8.1 常用

5.8.2 案列

Zadd k1 score1 v1 score2 v2 score v3   添加
zrange k1 0 -1 查询k1内全部值
zrangebyscore k1 70 90  withscores  查询70到90之间带着分数的值

zrem key 分数对应的value值 作用是删除元素

zcard k1 统计k1下面有几个值
zcount k1 70 80 统计k1下面70到80之间的个数
zrank k1 v1 获取k1下面的v1的下标
zscore k1 v1 获取k1下面的v1的分数

zrevrank k1 v1 作用是逆序获取k1里面v1的下标值
zrevrange k1 0 -1 逆序获取k1里面的所有值
zrevrangebyscore k1 100 0 withscores 逆序获取100到0之间的值

6.解析Redis配置文件Redis.conf

# Redis configuration file example

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

################################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Notice option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf

################################ GENERAL通用常见配置化配置  #####################################

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.

#配置yes意思就是将redis的服务将后台启动运行
daemonize yes

# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
# default. You can specify a custom pid file location here.

#进程管道Pid文件路径
pidfile /var/run/redis.pid

# Accept connections on the specified port, default is 6379.
# If port 0 is specified Redis will not listen on a TCP socket.

#端口
port 6379

# TCP listen() backlog.
#
# In high requests-per-second environments you need an high backlog in order
# to avoid slow clients connections issues. Note that the Linux kernel
# will silently truncate it to the value of /proc/sys/net/core/somaxconn so
# make sure to raise both the value of somaxconn and tcp_max_syn_backlog
# in order to get the desired effect.

#队列总和
tcp-backlog 511

# By default Redis listens for connections from all the network interfaces
# available on the server. It is possible to listen to just one or multiple
# interfaces using the "bind" configuration directive, followed by one or
# more IP addresses.
#
# Examples:
#
# bind 192.168.1.100 10.0.0.1

#端口的绑定
# bind 127.0.0.1

# Specify the path for the Unix socket that will be used to listen for
# incoming connections. There is no default, so Redis will not listen
# on a unix socket when not specified.
#
# unixsocket /tmp/redis.sock
# unixsocketperm 700

# Close the connection after a client is idle for N seconds (0 to disable)

#空闲多少时间自动关闭连接，0代表不关闭
timeout 0

# TCP keepalive.
#
# If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
# of communication. This is useful for two reasons:
#
# 1) Detect dead peers.
# 2) Take the connection alive from the point of view of network
#    equipment in the middle.
#
# On Linux, the specified value (in seconds) is the period used to send ACKs.
# Note that to close the connection the double of the time is needed.
# On other kernels the period depends on the kernel configuration.
#
# A reasonable value for this option is 60 seconds.

#保持通讯连接的时间间隔，集群的时候肯定要配置
tcp-keepalive 0

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)

#日志级别 开发调试debug notice和warning看业务需求
loglevel notice

# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null

#日志文件名字，如果不设置默认为""
logfile ""

# To enable logging to the system logger, just set 'syslog-enabled' to yes,
# and optionally update the other syslog parameters to suit your needs.

#是否开启系统日志
# syslog-enabled no

# Specify the syslog identity.

#如果开启了系统日志将以redis开头
# syslog-ident redis

# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.

#系统日志输出的设备
# syslog-facility local0

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT <dbid> where
# dbid is a number between 0 and 'databases'-1

#默认有16个库，切换库可以使用select 库  eg：  select 1 代表切换到 1号库
databases 16

################################ SNAPSHOTTING  ################################
#
# Save the DB on disk:
#
#   save <seconds> <changes>
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving completely by commenting out all "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

# By default Redis will stop accepting writes if RDB snapshots are enabled
# (at least one save point) and the latest background save failed.
# This will make the user aware (in a hard way) that data is not persisting
# on disk properly, otherwise chances are that no one will notice and some
# disaster will happen.
#
# If the background saving process will start working again Redis will
# automatically allow writes again.
#
# However if you have setup your proper monitoring of the Redis server
# and persistence, you may want to disable this feature so that Redis will
# continue to work as usual even if there are problems with disk,
# permissions, and so forth.
stop-writes-on-bgsave-error yes

# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

# Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
# This makes the format more resistant to corruption but there is a performance
# hit to pay (around 10%) when saving and loading RDB files, so you can disable it
# for maximum performances.
#
# RDB files created with checksum disabled have a checksum of zero that will
# tell the loading code to skip the check.
rdbchecksum yes

# The filename where to dump the DB
dbfilename dump.rdb

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir ./

################################# REPLICATION #################################

# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of slaves.
# 2) Redis slaves are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition slaves automatically try to reconnect to masters
#    and resynchronize with them.
#
# slaveof <masterip> <masterport>

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#
# masterauth <master-password>

# When a slave loses its connection with the master, or when the replication
# is still in progress, the slave can act in two different ways:
#
# 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
#    still reply to client requests, possibly with out of date data, or the
#    data set may just be empty if this is the first synchronization.
#
# 2) if slave-serve-stale-data is set to 'no' the slave will reply with
#    an error "SYNC with master in progress" to all the kind of commands
#    but to INFO and SLAVEOF.
#
slave-serve-stale-data yes

# You can configure a slave instance to accept writes or not. Writing against
# a slave instance may be useful to store some ephemeral data (because data
# written on a slave will be easily deleted after resync with the master) but
# may also cause problems if clients are writing to it because of a
# misconfiguration.
#
# Since Redis 2.6 by default slaves are read-only.
#
# Note: read only slaves are not designed to be exposed to untrusted clients
# on the internet. It's just a protection layer against misuse of the instance.
# Still a read only slave exports by default all the administrative commands
# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
# security of read only slaves using 'rename-command' to shadow all the
# administrative / dangerous commands.
slave-read-only yes

# Replication SYNC strategy: disk or socket.
#
# -------------------------------------------------------
# WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
# -------------------------------------------------------
#
# New slaves and reconnecting slaves that are not able to continue the replication
# process just receiving differences, need to do what is called a "full
# synchronization". An RDB file is transmitted from the master to the slaves.
# The transmission can happen in two different ways:
#
# 1) Disk-backed: The Redis master creates a new process that writes the RDB
#                 file on disk. Later the file is transferred by the parent
#                 process to the slaves incrementally.
# 2) Diskless: The Redis master creates a new process that directly writes the
#              RDB file to slave sockets, without touching the disk at all.
#
# With disk-backed replication, while the RDB file is generated, more slaves
# can be queued and served with the RDB file as soon as the current child producing
# the RDB file finishes its work. With diskless replication instead once
# the transfer starts, new slaves arriving will be queued and a new transfer
# will start when the current one terminates.
#
# When diskless replication is used, the master waits a configurable amount of
# time (in seconds) before starting the transfer in the hope that multiple slaves
# will arrive and the transfer can be parallelized.
#
# With slow disks and fast (large bandwidth) networks, diskless replication
# works better.
repl-diskless-sync no

# When diskless replication is enabled, it is possible to configure the delay
# the server waits in order to spawn the child that transfers the RDB via socket
# to the slaves.
#
# This is important since once the transfer starts, it is not possible to serve
# new slaves arriving, that will be queued for the next RDB transfer, so the server
# waits a delay in order to let more slaves arrive.
#
# The delay is specified in seconds, and by default is 5 seconds. To disable
# it entirely just set it to 0 seconds and the transfer will start ASAP.
repl-diskless-sync-delay 5

# Slaves send PINGs to server in a predefined interval. It's possible to change
# this interval with the repl_ping_slave_period option. The default value is 10
# seconds.
#
# repl-ping-slave-period 10

# The following option sets the replication timeout for:
#
# 1) Bulk transfer I/O during SYNC, from the point of view of slave.
# 2) Master timeout from the point of view of slaves (data, pings).
# 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).
#
# It is important to make sure that this value is greater than the value
# specified for repl-ping-slave-period otherwise a timeout will be detected
# every time there is low traffic between the master and the slave.
#
# repl-timeout 60

# Disable TCP_NODELAY on the slave socket after SYNC?
#
# If you select "yes" Redis will use a smaller number of TCP packets and
# less bandwidth to send data to slaves. But this can add a delay for
# the data to appear on the slave side, up to 40 milliseconds with
# Linux kernels using a default configuration.
#
# If you select "no" the delay for data to appear on the slave side will
# be reduced but more bandwidth will be used for replication.
#
# By default we optimize for low latency, but in very high traffic conditions
# or when the master and slaves are many hops away, turning this to "yes" may
# be a good idea.
repl-disable-tcp-nodelay no

# Set the replication backlog size. The backlog is a buffer that accumulates
# slave data when slaves are disconnected for some time, so that when a slave
# wants to reconnect again, often a full resync is not needed, but a partial
# resync is enough, just passing the portion of data the slave missed while
# disconnected.
#
# The bigger the replication backlog, the longer the time the slave can be
# disconnected and later be able to perform a partial resynchronization.
#
# The backlog is only allocated once there is at least a slave connected.
#
# repl-backlog-size 1mb

# After a master has no longer connected slaves for some time, the backlog
# will be freed. The following option configures the amount of seconds that
# need to elapse, starting from the time the last slave disconnected, for
# the backlog buffer to be freed.
#
# A value of 0 means to never release the backlog.
#
# repl-backlog-ttl 3600

# The slave priority is an integer number published by Redis in the INFO output.
# It is used by Redis Sentinel in order to select a slave to promote into a
# master if the master is no longer working correctly.
#
# A slave with a low priority number is considered better for promotion, so
# for instance if there are three slaves with priority 10, 100, 25 Sentinel will
# pick the one with priority 10, that is the lowest.
#
# However a special priority of 0 marks the slave as not able to perform the
# role of master, so a slave with priority of 0 will never be selected by
# Redis Sentinel for promotion.
#
# By default the priority is 100.
slave-priority 100

# It is possible for a master to stop accepting writes if there are less than
# N slaves connected, having a lag less or equal than M seconds.
#
# The N slaves need to be in "online" state.
#
# The lag in seconds, that must be <= the specified value, is calculated from
# the last ping received from the slave, that is usually sent every second.
#
# This option does not GUARANTEE that N replicas will accept the write, but
# will limit the window of exposure for lost writes in case not enough slaves
# are available, to the specified number of seconds.
#
# For example to require at least 3 slaves with a lag <= 10 seconds use:
#
# min-slaves-to-write 3
# min-slaves-max-lag 10
#
# Setting one or the other to 0 disables the feature.
#
# By default min-slaves-to-write is set to 0 (feature disabled) and
# min-slaves-max-lag is set to 10.

################################## SECURITY ###################################

# Require clients to issue AUTH <PASSWORD> before processing any other
# commands.  This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
#
# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#
# requirepass foobared

# Command renaming.
#
# It is possible to change the name of dangerous commands in a shared
# environment. For instance the CONFIG command may be renamed into something
# hard to guess so that it will still be available for internal-use tools
# but not available for general clients.
#
# Example:
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# It is also possible to completely kill a command by renaming it into
# an empty string:
#
# rename-command CONFIG ""
#
# Please note that changing the name of commands that are logged into the
# AOF file or transmitted to slaves may cause problems.

################################### LIMITS ####################################

# Set the max number of connected clients at the same time. By default
# this limit is set to 10000 clients, however if the Redis server is not
# able to configure the process file limit to allow for the specified limit
# the max number of allowed clients is set to the current file limit
# minus 32 (as Redis reserves a few file descriptors for internal uses).
#
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#
# maxclients 10000

# Don't use more memory than the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys
# according to the eviction policy selected (see maxmemory-policy).
#
# If Redis can't remove keys according to the policy, or if the policy is
# set to 'noeviction', Redis will start to reply with errors to commands
# that would use more memory, like SET, LPUSH, and so on, and will continue
# to reply to read-only commands like GET.
#
# This option is usually useful when using Redis as an LRU cache, or to set
# a hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have slaves attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the slaves are subtracted
# from the used memory count, so that network problems / resyncs will
# not trigger a loop where keys are evicted, and in turn the output
# buffer of slaves is full with DELs of keys evicted triggering the deletion
# of more keys, and so forth until the database is completely emptied.
#
# In short... if you have slaves attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for slave
# output buffers (but this is not needed if the policy is 'noeviction').
#
# maxmemory <bytes>

# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
# is reached. You can select among five behaviors:
#
# volatile-lru -> remove the key with an expire set using an LRU algorithm
# allkeys-lru -> remove any key according to the LRU algorithm
# volatile-random -> remove a random key with an expire set
# allkeys-random -> remove a random key, any key
# volatile-ttl -> remove the key with the nearest expire time (minor TTL)
# noeviction -> don't expire at all, just return an error on write operations
#
# Note: with any of the above policies, Redis will return an error on write
#       operations, when there are no suitable keys for eviction.
#
#       At the date of writing these commands are: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort
#
# The default is:
#
# maxmemory-policy noeviction

# LRU and minimal TTL algorithms are not precise algorithms but approximated
# algorithms (in order to save memory), so you can tune it for speed or
# accuracy. For default Redis will check five keys and pick the one that was
# used less recently, you can change the sample size using the following
# configuration directive.
#
# The default of 5 produces good enough results. 10 Approximates very closely
# true LRU but costs a bit more CPU. 3 is very fast but not very accurate.
#
# maxmemory-samples 5

############################## APPEND ONLY MODE ###############################

# By default Redis asynchronously dumps the dataset on disk. This mode is
# good enough in many applications, but an issue with the Redis process or
# a power outage may result into a few minutes of writes lost (depending on
# the configured save points).
#
# The Append Only File is an alternative persistence mode that provides
# much better durability. For instance using the default data fsync policy
# (see later in the config file) Redis can lose just one second of writes in a
# dramatic event like a server power outage, or a single write if something
# wrong with the Redis process itself happens, but the operating system is
# still running correctly.
#
# AOF and RDB persistence can be enabled at the same time without problems.
# If the AOF is enabled on startup Redis will load the AOF, that is the file
# with the better durability guarantees.
#
# Please check http://redis.io/topics/persistence for more information.

appendonly no

# The name of the append only file (default: "appendonly.aof")

appendfilename "appendonly.aof"

# The fsync() call tells the Operating System to actually write data on disk
# instead of waiting for more data in the output buffer. Some OS will really flush
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log. Slow, Safest.
# everysec: fsync only one time every second. Compromise.
#
# The default is "everysec", as that's usually the right compromise between
# speed and data safety. It's up to you to understand if you can relax this to
# "no" that will let the operating system flush the output buffer when
# it wants, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting),
# or on the contrary, use "always" that's very slow but a bit safer than
# everysec.
#
# More details please check the following article:
# http://antirez.com/post/redis-persistence-demystified.html
#
# If unsure, use "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no

# When the AOF fsync policy is set to always or everysec, and a background
# saving process (a background save or AOF log background rewriting) is
# performing a lot of I/O against the disk, in some Linux configurations
# Redis may block too long on the fsync() call. Note that there is no fix for
# this currently, as even performing fsync in a different thread will block
# our synchronous write(2) call.
#
# In order to mitigate this problem it's possible to use the following option
# that will prevent fsync() from being called in the main process while a
# BGSAVE or BGREWRITEAOF is in progress.
#
# This means that while another child is saving, the durability of Redis is
# the same as "appendfsync none". In practical terms, this means that it is
# possible to lose up to 30 seconds of log in the worst scenario (with the
# default Linux settings).
#
# If you have latency problems turn this to "yes". Otherwise leave it as
# "no" that is the safest pick from the point of view of durability.

no-appendfsync-on-rewrite no

# Automatic rewrite of the append only file.
# Redis is able to automatically rewrite the log file implicitly calling
# BGREWRITEAOF when the AOF log size grows by the specified percentage.
#
# This is how it works: Redis remembers the size of the AOF file after the
# latest rewrite (if no rewrite has happened since the restart, the size of
# the AOF at startup is used).
#
# This base size is compared to the current size. If the current size is
# bigger than the specified percentage, the rewrite is triggered. Also
# you need to specify a minimal size for the AOF file to be rewritten, this
# is useful to avoid rewriting the AOF file even if the percentage increase
# is reached but it is still pretty small.
#
# Specify a percentage of zero in order to disable the automatic AOF
# rewrite feature.

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# An AOF file may be found to be truncated at the end during the Redis
# startup process, when the AOF data gets loaded back into memory.
# This may happen when the system where Redis is running
# crashes, especially when an ext4 filesystem is mounted without the
# data=ordered option (however this can't happen when Redis itself
# crashes or aborts but the operating system still works correctly).
#
# Redis can either exit with an error when this happens, or load as much
# data as possible (the default now) and start if the AOF file is found
# to be truncated at the end. The following option controls this behavior.
#
# If aof-load-truncated is set to yes, a truncated AOF file is loaded and
# the Redis server starts emitting a log to inform the user of the event.
# Otherwise if the option is set to no, the server aborts with an error
# and refuses to start. When the option is set to no, the user requires
# to fix the AOF file using the "redis-check-aof" utility before to restart
# the server.
#
# Note that if the AOF file will be found to be corrupted in the middle
# the server will still exit with an error. This option only applies when
# Redis will try to read more data from the AOF file but not enough bytes
# will be found.
aof-load-truncated yes

################################ LUA SCRIPTING  ###############################

# Max execution time of a Lua script in milliseconds.
#
# If the maximum execution time is reached Redis will log that a script is
# still in execution after the maximum allowed time and will start to
# reply to queries with an error.
#
# When a long running script exceeds the maximum execution time only the
# SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
# used to stop a script that did not yet called write commands. The second
# is the only way to shut down the server in the case a write command was
# already issued by the script but the user doesn't want to wait for the natural
# termination of the script.
#
# Set it to 0 or a negative value for unlimited execution without warnings.
lua-time-limit 5000

################################ REDIS CLUSTER  ###############################
#
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
# in order to mark it as "mature" we need to wait for a non trivial percentage
# of users to deploy it in production.
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
# Normal Redis instances can't be part of a Redis Cluster; only nodes that are
# started as cluster nodes can. In order to start a Redis instance as a
# cluster node enable the cluster support uncommenting the following:
#
# cluster-enabled yes

# Every cluster node has a cluster configuration file. This file is not
# intended to be edited by hand. It is created and updated by Redis nodes.
# Every Redis Cluster node requires a different cluster configuration file.
# Make sure that instances running in the same system do not have
# overlapping cluster configuration file names.
#
# cluster-config-file nodes-6379.conf

# Cluster node timeout is the amount of milliseconds a node must be unreachable
# for it to be considered in failure state.
# Most other internal time limits are multiple of the node timeout.
#
# cluster-node-timeout 15000

# A slave of a failing master will avoid to start a failover if its data
# looks too old.
#
# There is no simple way for a slave to actually have a exact measure of
# its "data age", so the following two checks are performed:
#
# 1) If there are multiple slaves able to failover, they exchange messages
#    in order to try to give an advantage to the slave with the best
#    replication offset (more data from the master processed).
#    Slaves will try to get their rank by offset, and apply to the start
#    of the failover a delay proportional to their rank.
#
# 2) Every single slave computes the time of the last interaction with
#    its master. This can be the last ping or command received (if the master
#    is still in the "connected" state), or the time that elapsed since the
#    disconnection with the master (if the replication link is currently down).
#    If the last interaction is too old, the slave will not try to failover
#    at all.
#
# The point "2" can be tuned by user. Specifically a slave will not perform
# the failover if, since the last interaction with the master, the time
# elapsed is greater than:
#
#   (node-timeout * slave-validity-factor) + repl-ping-slave-period
#
# So for example if node-timeout is 30 seconds, and the slave-validity-factor
# is 10, and assuming a default repl-ping-slave-period of 10 seconds, the
# slave will not try to failover if it was not able to talk with the master
# for longer than 310 seconds.
#
# A large slave-validity-factor may allow slaves with too old data to failover
# a master, while a too small value may prevent the cluster from being able to
# elect a slave at all.
#
# For maximum availability, it is possible to set the slave-validity-factor
# to a value of 0, which means, that slaves will always try to failover the
# master regardless of the last time they interacted with the master.
# (However they'll always try to apply a delay proportional to their
# offset rank).
#
# Zero is the only value able to guarantee that when all the partitions heal
# the cluster will always be able to continue.
#
# cluster-slave-validity-factor 10

# Cluster slaves are able to migrate to orphaned masters, that are masters
# that are left without working slaves. This improves the cluster ability
# to resist to failures as otherwise an orphaned master can't be failed over
# in case of failure if it has no working slaves.
#
# Slaves migrate to orphaned masters only if there are still at least a
# given number of other working slaves for their old master. This number
# is the "migration barrier". A migration barrier of 1 means that a slave
# will migrate only if there is at least 1 other working slave for its master
# and so forth. It usually reflects the number of slaves you want for every
# master in your cluster.
#
# Default is 1 (slaves migrate only if their masters remain with at least
# one slave). To disable migration just set it to a very large value.
# A value of 0 can be set but is useful only for debugging and dangerous
# in production.
#
# cluster-migration-barrier 1

# By default Redis Cluster nodes stop accepting queries if they detect there
# is at least an hash slot uncovered (no available node is serving it).
# This way if the cluster is partially down (for example a range of hash slots
# are no longer covered) all the cluster becomes, eventually, unavailable.
# It automatically returns available as soon as all the slots are covered again.
#
# However sometimes you want the subset of the cluster which is working,
# to continue to accept queries for the part of the key space that is still
# covered. In order to do so, just set the cluster-require-full-coverage
# option to no.
#
# cluster-require-full-coverage yes

# In order to setup your cluster make sure to read the documentation
# available at http://redis.io web site.

################################## SLOW LOG ###################################

# The Redis Slow Log is a system to log queries that exceeded a specified
# execution time. The execution time does not include the I/O operations
# like talking with the client, sending the reply and so forth,
# but just the time needed to actually execute the command (this is the only
# stage of command execution where the thread is blocked and can not serve
# other requests in the meantime).
#
# You can configure the slow log with two parameters: one tells Redis
# what is the execution time, in microseconds, to exceed in order for the
# command to get logged, and the other parameter is the length of the
# slow log. When a new command is logged the oldest one is removed from the
# queue of logged commands.

# The following time is expressed in microseconds, so 1000000 is equivalent
# to one second. Note that a negative number disables the slow log, while
# a value of zero forces the logging of every command.
slowlog-log-slower-than 10000

# There is no limit to this length. Just be aware that it will consume memory.
# You can reclaim memory used by the slow log with SLOWLOG RESET.
slowlog-max-len 128

################################ LATENCY MONITOR ##############################

# The Redis latency monitoring subsystem samples different operations
# at runtime in order to collect data related to possible sources of
# latency of a Redis instance.
#
# Via the LATENCY command this information is available to the user that can
# print graphs and obtain reports.
#
# The system only logs operations that were performed in a time equal or
# greater than the amount of milliseconds specified via the
# latency-monitor-threshold configuration directive. When its value is set
# to zero, the latency monitor is turned off.
#
# By default latency monitoring is disabled since it is mostly not needed
# if you don't have latency issues, and collecting data has a performance
# impact, that while very small, can be measured under big load. Latency
# monitoring can easily be enabled at runtime using the command
# "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
latency-monitor-threshold 0

############################# EVENT NOTIFICATION ##############################

# Redis can notify Pub/Sub clients about events happening in the key space.
# This feature is documented at http://redis.io/topics/notifications
#
# For instance if keyspace events notification is enabled, and a client
# performs a DEL operation on key "foo" stored in the Database 0, two
# messages will be published via Pub/Sub:
#
# PUBLISH __keyspace@0__:foo del
# PUBLISH __keyevent@0__:del foo
#
# It is possible to select the events that Redis will notify among a set
# of classes. Every class is identified by a single character:
#
#  K     Keyspace events, published with __keyspace@<db>__ prefix.
#  E     Keyevent events, published with __keyevent@<db>__ prefix.
#  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
#  $     String commands
#  l     List commands
#  s     Set commands
#  h     Hash commands
#  z     Sorted set commands
#  x     Expired events (events generated every time a key expires)
#  e     Evicted events (events generated when a key is evicted for maxmemory)
#  A     Alias for g$lshzxe, so that the "AKE" string means all the events.
#
#  The "notify-keyspace-events" takes as argument a string that is composed
#  of zero or multiple characters. The empty string means that notifications
#  are disabled.
#
#  Example: to enable list and generic events, from the point of view of the
#           event name, use:
#
#  notify-keyspace-events Elg
#
#  Example 2: to get the stream of the expired keys subscribing to channel
#             name __keyevent@0__:expired use:
#
#  notify-keyspace-events Ex
#
#  By default all notifications are disabled because most users don't need
#  this feature and the feature has some overhead. Note that if you don't
#  specify at least one of K or E, no events will be delivered.
notify-keyspace-events ""

############################### ADVANCED CONFIG ###############################

# Hashes are encoded using a memory efficient data structure when they have a
# small number of entries, and the biggest entry does not exceed a given
# threshold. These thresholds can be configured using the following directives.
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# Similarly to hashes, small lists are also encoded in a special way in order
# to save a lot of space. The special representation is only used when
# you are under the following limits:
list-max-ziplist-entries 512
list-max-ziplist-value 64

# Sets have a special encoding in just one case: when a set is composed
# of just strings that happen to be integers in radix 10 in the range
# of 64 bit signed integers.
# The following configuration setting sets the limit in the size of the
# set in order to use this special memory saving encoding.
set-max-intset-entries 512

# Similarly to hashes and lists, sorted sets are also specially encoded in
# order to save a lot of space. This encoding is only used when the length and
# elements of a sorted set are below the following limits:
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# HyperLogLog sparse representation bytes limit. The limit includes the
# 16 bytes header. When an HyperLogLog using the sparse representation crosses
# this limit, it is converted into the dense representation.
#
# A value greater than 16000 is totally useless, since at that point the
# dense representation is more memory efficient.
#
# The suggested value is ~ 3000 in order to have the benefits of
# the space efficient encoding without slowing down too much PFADD,
# which is O(N) with the sparse encoding. The value can be raised to
# ~ 10000 when CPU is not a concern, but space is, and the data set is
# composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
hll-sparse-max-bytes 3000

# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
# order to help rehashing the main Redis hash table (the one mapping top-level
# keys to values). The hash table implementation Redis uses (see dict.c)
# performs a lazy rehashing: the more operation you run into a hash table
# that is rehashing, the more rehashing "steps" are performed, so if the
# server is idle the rehashing is never complete and some more memory is used
# by the hash table.
#
# The default is to use this millisecond 10 times every second in order to
# actively rehash the main dictionaries, freeing memory when possible.
#
# If unsure:
# use "activerehashing no" if you have hard latency requirements and it is
# not a good thing in your environment that Redis can reply from time to time
# to queries with 2 milliseconds delay.
#
# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
activerehashing yes

# The client output buffer limits can be used to force disconnection of clients
# that are not reading data from the server fast enough for some reason (a
# common reason is that a Pub/Sub client can't consume messages as fast as the
# publisher can produce them).
#
# The limit can be set differently for the three different classes of clients:
#
# normal -> normal clients including MONITOR clients
# slave  -> slave clients
# pubsub -> clients subscribed to at least one pubsub channel or pattern
#
# The syntax of every client-output-buffer-limit directive is the following:
#
# client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
#
# A client is immediately disconnected once the hard limit is reached, or if
# the soft limit is reached and remains reached for the specified number of
# seconds (continuously).
# So for instance if the hard limit is 32 megabytes and the soft limit is
# 16 megabytes / 10 seconds, the client will get disconnected immediately
# if the size of the output buffers reach 32 megabytes, but will also get
# disconnected if the client reaches 16 megabytes and continuously overcomes
# the limit for 10 seconds.
#
# By default normal clients are not limited because they don't receive data
# without asking (in a push way), but just after a request, so only
# asynchronous clients may create a scenario where data is requested faster
# than it can read.
#
# Instead there is a default limit for pubsub and slave clients, since
# subscribers and slaves receive data in a push fashion.
#
# Both the hard or the soft limit can be disabled by setting them to zero.
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

# Redis calls an internal function to perform many background tasks, like
# closing connections of clients in timeout, purging expired keys that are
# never requested, and so forth.
#
# Not all tasks are performed with the same frequency, but Redis checks for
# tasks to perform according to the specified "hz" value.
#
# By default "hz" is set to 10. Raising the value will use more CPU when
# Redis is idle, but at the same time will make Redis more responsive when
# there are many keys expiring at the same time, and timeouts may be
# handled with more precision.
#
# The range is between 1 and 500, however a value over 100 is usually not
# a good idea. Most users should use the default of 10 and raise this up to
# 100 only in environments where very low latency is required.
hz 10

# When a child rewrites the AOF file, if the following option is enabled
# the file will be fsync-ed every 32 MB of data generated. This is useful
# in order to commit the file to the disk more incrementally and avoid
# big latency spikes.
aof-rewrite-incremental-fsync yes

6.1 他在哪？

6.2 Units单位

配置大小单位，开头定义了一些基本的度量单位，只支持bytes，不支持bit 对大小写不敏感

6.3 INCLUDES包含

可以通过includes包含，redis.conf可以作为总闸，包含其他redis的配置文件，相当于jsp里面的include

6.4 GENERAL通用

6.5 SNAPSHOTTING快照

6.6 REPLICATION复制

6.7 SECURITY安全

默认情况下是不需要输入密码的 可以使用 config get requirepass查看

如果非要设置密码 有get必定存在set

使用命令 config set requirepass 密码
设置完就需要输入密码登录了， 命令为 auth 密码 为什么是这个命令

6.8 LIMITS限制

6.9 关于查看redis日志

由于我们可以*选择文件夹启动redis服务，
而日志文件默认放在服务启动的当前路径下，

所以当我们要看日志时，就需要先使用
config get dir 看下服务启动的路径，然后在该路径下找

6.10 常见配置Redis.conf介绍

redis.conf 配置项说明如下：

1.   Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

daemonize no

2.  当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定

pidfile /var/run/redis.pid

3.  指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字
port 6379

4.  绑定的主机地址
bind 127.0.0.1

5.  当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
timeout 300

6.  指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
loglevel verbose

7.  日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null
logfile stdout

8.  设置数据库的数量，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id
databases 16

9.  指定在多长时间内，多少次更新操作，就将数据同步到数据文件，可以多个条件配合
save
Redis默认配置文件中提供了三个条件：
save 900 1
save 300 10
save 60 10000
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

10.  指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
rdbcompression yes

11.  指定本地数据库文件名，默认值为dump.rdb
dbfilename dump.rdb

12.  指定本地数据库存放目录
dir ./

13.  设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
slaveof

14.  当master服务设置了密码保护时，slav服务连接master的密码
masterauth

15.  设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令提供密码，默认关闭
requirepass foobared

16.  设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
maxclients 128

17.  指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
maxmemory

18.  指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no

19.  指定更新日志文件名，默认为appendonly.aof
appendfilename appendonly.aof

20.  指定更新日志条件，共3个可选值：
no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折衷，默认值）
appendfsync everysec

21.  指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）
vm-enabled no

22.  虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享
vm-swap-file /tmp/redis.swap

23.  将所大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
vm-max-memory 0

24.  Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值
vm-page-size 32

25.  设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。
vm-pages 134217728

26.  设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4
vm-max-threads 4

27.  设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启
glueoutputbuf yes

28.  指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512

29.  指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）
activerehashing yes

30.  指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件
include /path/to/local.conf

7.Redis的持久化

7.1 RDB(Redis dataBase)

7.1.1 是什么?

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是Snapshot快照，它恢复时将快照文件直接读到内存里。

Redis会单独创建（Fork一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 ,如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。

RDB的缺点是最后一次持久化后的数据可能丢失。

Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量‘程序计数器等）数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。

RDB保存的是dump.rdb文件

7.1.2 如何触发RDB快照?

1.根据系统持久化配置：默认1分钟1万次 /5分钟10次/15分钟1次改变，当然可以自己修改

2.命令save或者是bgsave

Save：save时只管保存，其他不管，全部阻塞
BGSAVE：Redis会在后台异步进行快照操作，快照操作同时还可以响应客户端请求。可以通过lastsave命令获取最后一次成功执行快照的时间。

3.执行flushall命令，也会产生dump.rdb文件，但在flushall瞬间会清空数据库然后写进去所以里面是空的，无意义。

4.shutdown 执行这些相当于commit了一次，会生成dump.rdb

注意: 配置文件中默认的快照dump.rdb文件,记得拷贝一份到另外一台机器或者自己找个地方保存，如果这台机器挂了还可以找回来

7.1.3 如何恢复?

将备份文件（dump.rdb移动到redis安装目录并启动服务即可 CONFIG GET dir获取目录

7.1.4 优势?

适合大规模的数据恢复,对数据完整性和一致性要求不高

7.1.5 劣势?

在一定间隔时间做一次备份，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。
Fork的时候，内存中的数据被克隆了一份，大约2倍的膨胀性需要考虑。

7.1.6 如何停止RBD持久化?

动态所停止RDB保存规则的方法：redis-cli config set save ""

7.1.7 小总结:

7.2 AOP(Append Only File)

7.2.1 是什么?

以日志的形式来记录每个写操作，将Redis执行过的所写指令记录下来（读操作不记录，只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话根据日志文件的内容将写指令从前到后执行一次已完成数据的恢复工作。

AOF保存的是appendonly.aof文件

7.2.2 AOF启动/修复/恢复

7.2.2.1 正常恢复:

启动：设置Yes
将数据的aof文件复制一份保存到对应目录（config get dir查看目录）
恢复：重启redis然后重新加载

7.2.2.2 异常恢复:

启动：设置Yes
备份被写坏的AOF文件
修复: Redis-check-aof --fix进行修复 同理修复dump.rdb redis-check-dump – fix
恢复: 重启redis然后重新加载

7.2.3 Rewrite重写机制: 是什么？

AOF采用文件追加方式，文件会越来越大，为避免出现此种情况，新增了重写机制，当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集。可以使用命令gbrewriteaof

7.2.4 重写原理:

AOF文件持续增长而过大时，会fork出一条新进程来将文件重写（也是先写临时文件最后在rename，遍历新进程的内存中数据，每条记录一条的Set语句。重写aof文件的操作，并没读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照点类似。

7.2.5 触发机制:

Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发。

7.2.6 优势?

每秒同步：appendfsync always 同步持久化 每次发生数据变更会被立即记录到磁盘 性能较差但数据完整性比较好;
每修改同步：appendfsync everysec 异步操作 ，每秒记录 如果一秒内宕机，有数据丢失。
不同步：appendfsync no 从不同步

7.2.7 劣势?

相同数据集的数据而言aof文件要远大于rdb文件，恢复速度慢于rdb;
AOF运行效率要慢于rdb，每秒同步策略效率较好，不同步效率和rdb相同。

7.2.8小总结:

客户端-------->服务器---------->AOF文件

AOF文件时一个只进行追加的日志文件
Redis可以在AOF文件体积变得过大时，自动地在后台对AOF进行重写
AOF文件序地保存了对数据执行的所写入操作，这些写入操作以Redis协议的格式保存，因此AOF文件的内容非常容易被人读懂，对文件进行分析也很轻松。

缺点：
对相同的数据集来说，AOF文件的体积通常要大于RDB文件的体积。
根据所使用的fsync策略，AOF的速度可能会慢于RDB。

7.2.3 redis.conf当中配置

7.3 如何选择

性能考虑:

8.Redis的事务

官网: http://www.redis.cn/topics/transactions.html

8.1 是什么?

可以一次执行多个命令，本质是一组命令的集合。一个事务中的所有命令都会序列化，按顺序地串行化执行而不会被其他命令插入，不许加塞。

8.2 作用？

一个队列中，一次性、顺序性、排他性地执行一系列命令

8.3 怎么玩？

DISCARD：                      取消事务，放弃执行事务块内的所命令。
EXEC：                         执行所事务块的命令。
MULTI：                        标记一个事务块的开始。
UNWATCH：                      取消WATCH命令对多key的监视。
WATCH key [key......]：        监视一个（或多个）key，如果在事务执行之前这个key被其他命令所改动，那么事务将打断。

8.4 分为以下五种:

8.4.1 case1 正常执行：

8.4.2 case2放弃事务

8.4.3 case3全体连坐 指的是一个错，全部都不执行,报错

8.4.4 case4 冤头债主 指的是谁出现问题谁报错，其他正常执行

与case3区别在于 前者是编译出错，命令本身语法就存在问题，后者是运行时出错，命令本身就没问题

8.4.5 case5 watch监控

悲观锁/乐观锁/CAS( Check And Set )

8.4.5.1 悲观锁:

悲观锁：顾名思义，每次去拿数据的时候都被认为别人会修改，所以每次在拿数据的时候都会被锁上，这样别人想拿这个数据就会block直到它拿到锁，传统的关系型数据库里边就用到了很多这种锁机制，比如行锁、表锁等，读锁、写锁等，都是在做操作之前先锁上。

8.4.5.2 乐观锁:

乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多度的应用类型，这样可以提高吞吐量
。
乐观锁策略：提交版本必须大于记录当前版本才能执行更新。
开启了watch会对键进行监控，当在开启事务前watch后有人修改了被监控的键，开启事务后操作提交会出错;

8.4.6 小结:

Watch指令，类似乐观锁，事务提交时，如果Key的值已经被别的客户端改变，比如某个list已经被别的客户端push/pop过了，整个事务队列都不会被执行。

通过WATCH命令在事务执行之前监控了多个keys，倘若在WATCH之后任何key的值的变化，EXEC命令执行的事务都将被放弃，同时返回Nullmulti-bulk应答以通知调用者事务执行失败。

8.4.6.1 3阶段:

开启：以MULTI开始一个事务
入队：将多个命令入队到事务中，接到这些命令并不会立即执行，而是放到等待执行的事务队列里面。
执行：由EXEC命令触发事务

8.4.6.2 3特性:

单独的隔离操作：事务中的所命令都会被序列化、顺序地执行。事务在执行的构成中，不会被其他客户端发送来的命令请求所打断。

没隔离级别的概念：队列中的命令没提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在“事务内的查询要看到事务里的更新，在事务外查询不能看到”这个让人万分头痛的问题。

不保证原子性：redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。

9.Redis的发布订阅

9.1 是什么?

进程间的一种消息通信模式：发送者（pub发送消息，订阅者（sub接受消息。

命令：

PSUBSCRIBE pattem [pattem......]：                               订阅一个或多个符合给定模式的频道
PUBSUB subcommand [argument [argument.....]]：                 查看订阅与发布系统状态。
PUBLISH channel message：                                         将信息发送到指定的频道。
PUNSUBSCRIBE [pattem [pattem....]]：                           退订所有给定模式的频道。
SUBSCRIBE channel [channel...]：                                  订阅给定的一个或多个频道的信息。
UNSUBSCRIBE [channel [channel...]]：                           指退订给定的频道。

先订阅后发布才能收到信息：

可以一次性订阅多个， SUBSCRIBE c1 c2 c3
消息发布 ， PUBLISH c2 hello-redis
订阅多个，通配符*， PSUBSCRIBE new*
收到消息， PUBLISH new1 redis2015

10.Redis的复制（Master/Slave）

10.1 是什么?

就是我们所说的主从复制，主机数据更新后根据配置和策略，自动同步到备机的master/slver机制，Master以写为主，Slave以读为主。

10.2 作用?

读写分离,容灾恢复

10.3 怎么玩?

10.3.1. 配从库不配主库 :在从库里面配置而不是在主库配置

10.3.2. 从库配置：slaveof主库IP主库端口

注意:slave从库每次与master断开之后，都需要重新连接，除非你配置进redis.conf文件

Info replication 可以查看详细信息

10.3.3. 搭建3台机器环境(修改配置文件):

10.3.3.1.将redis.conf文件复制多份，改名

10.3.3.2.修改每个配置文件的内容:

开启daemonize yes      开启后台线程启动
     Pid文件名字        修改pid文件名字
     指定端口           指定端口
     Log文件名字        修改日志文件名字
     Dump.rdb名字       修改rdb名字

10.4 常用三招

10.4.1 一主多从

一主二从: 一个Master两个或以上Slave

主机能读能写，从机只能读，不能写，当主机挂了，从机只能等着，主机回来了还是Master,但是如果从机挂了，当从机再次连接时，他会断开之前的关系，变成Master,需要重新加入Slaveof 主机

10.4.2 薪火相传

上一个Slave可以是下一个slave的Master，slave同样可以接受其他slaves的连接和同步请求，那么该slave作为链条中下一个的master，可以效减轻master的写压力。

中途变更转向：会清楚之前的数据，重新建立拷贝最新的。
slaveof 新主库IP 新主库端口。

10.4.3 反客为主

SLAVEOF no one：使当前数据库通知与其他数据库的同步，转成主数据库。

假设,目前是一主二从，当主机挂了，从机只能干等着，只能读不能写

所以为了避免这种局面，反客为主，停止当前与之前主机关联，转为master

使用命令 slaveof no one 取消与之前主机关联

另外一台从机改成与这台主机关联

10.5 复制原理

Slave启动成功连接到master后会发送一个sync命令。

Master接到命令启动后台的存盘进程，同时收集所接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，以完成一次完全同步。

全量控制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

增量控制：master继续将新的所收集到的修改命令一次传给slave，完成同步。

但是只要是重新连接master，一次完全同步（全量复制）将被自动执行。

10.6 哨兵模式（setinel）

10.6.1 是什么?

反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库;

10.6.2 怎么玩?

10.6.2.1 调整结构，6379带着80、81;

10.6.2.2 自定义的/myredis目录下新建sentinel.conf文件，名字决不能错。

10.6.2.3 配置哨兵:

填写内容: sentinel monitor 被监控数据库名字（自己起名字,随便取）127.0.0.1 6379 1

上面最后一个数字1，表示主机挂掉后slave投票看让谁解题成为主机，得票数多的成为主机

10.6.2.4 启动哨兵：

Redis-sentinel /myredis/sentinel.conf

上述目录依照各自的实际情况配置，可能目录不同

正常主从演示 原的master挂了 投票新选 重新主从继续开工，info replication查查看

10.6.2.5 问题：如果之前的master重启回来，会不会双master冲突？

不会冲突，之前的master回来之后，哨兵监测到，之前的master会变成slave

一组sentinel能同时监控多个Master

当主机挂了，哨兵机制会自动投票选举出新的master

10.7 复制的缺点

复制延时:

由于所的写操作都是先在Master上操作，然后同步更新到slave上，所以从master同步到slave机器一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，slave机器数量的增加也会使这个问题更加严重。