redis基础、高级特性与性能调优-ag真人游戏

redis

本文将从redis的基本特性入手，通过讲述redis的数据结构和主要命令对redis的基本能力进行直观介绍。之后概览redis提供的高级能力，并在部署、维护、性能调优等多个方面进行更深入的介绍和指导。
本文适合使用redis的普通开发人员，以及对redis进行选型、架构设计和性能调优的架构设计人员。

目录

• 概述
• redis的数据结构和相关常用命令
• 数据持久化
• 内存管理与数据淘汰机制
• pipelining
• 事务与scripting
• redis性能调优
• 主从复制与集群分片
• redis java客户端的选择

概述

redis是一个开源的，基于内存的结构化数据存储媒介，可以作为数据库、缓存服务或消息服务使用。
redis支持多种数据结构，包括字符串、哈希表、链表、集合、有序集合、位图、hyperloglogs等。
redis具备lru淘汰、事务实现、以及不同级别的硬盘持久化等能力，并且支持副本集和通过redis sentinel实现的高可用方案，同时还支持通过redis cluster实现的数据自动分片能力。

redis的主要功能都基于单线程模型实现，也就是说redis使用一个线程来服务所有的客户端请求，同时redis采用了非阻塞式io，并精细地优化各种命令的算法时间复杂度，这些信息意味着：

• redis是线程安全的（因为只有一个线程），其所有操作都是原子的，不会因并发产生数据异常
• redis的速度非常快（因为使用非阻塞式io，且大部分命令的算法时间复杂度都是o(1))
• 使用高耗时的redis命令是很危险的，会占用唯一的一个线程的大量处理时间，导致所有的请求都被拖慢。（例如时间复杂度为o(n)的keys命令，严格禁止在生产环境中使用）

redis的数据结构和相关常用命令

本节中将介绍redis支持的主要数据结构，以及相关的常用redis命令。本节只对redis命令进行扼要的介绍，且只列出了较常用的命令。如果想要了解完整的redis命令集，或了解某个命令的详细使用方法，请参考官方文档：https://redis.io/commands

key

redis采用key-value型的基本数据结构，任何二进制序列都可以作为redis的key使用（例如普通的字符串或一张jpeg图片）
关于key的一些注意事项：

• 不要使用过长的key。例如使用一个1024字节的key就不是一个好主意，不仅会消耗更多的内存，还会导致查找的效率降低
• key短到缺失了可读性也是不好的，例如"u1000flw"比起"user:1000:followers"来说，节省了寥寥的存储空间，却引发了可读性和可维护性上的麻烦
• 最好使用统一的规范来设计key，比如"object-type:id:attr"，以这一规范设计出的key可能是"user:1000"或"comment:1234:reply-to"
• redis允许的最大key长度是512mb（对value的长度限制也是512mb）

string

string是redis的基础数据类型，redis没有int、float、boolean等数据类型的概念，所有的基本类型在redis中都以string体现。

与string相关的常用命令：

• set：为一个key设置value，可以配合ex/px参数指定key的有效期，通过nx/xx参数针对key是否存在的情况进行区别操作，时间复杂度o(1)
• get：获取某个key对应的value，时间复杂度o(1)
• getset：为一个key设置value，并返回该key的原value，时间复杂度o(1)
• mset：为多个key设置value，时间复杂度o(n)
• msetnx：同mset，如果指定的key中有任意一个已存在，则不进行任何操作，时间复杂度o(n)
• mget：获取多个key对应的value，时间复杂度o(n)

上文提到过，redis的基本数据类型只有string，但redis可以把string作为整型或浮点型数字来使用，主要体现在incr、decr类的命令上：

• incr：将key对应的value值自增1，并返回自增后的值。只对可以转换为整型的string数据起作用。时间复杂度o(1)
• incrby：将key对应的value值自增指定的整型数值，并返回自增后的值。只对可以转换为整型的string数据起作用。时间复杂度o(1)
• decr/decrby：同incr/incrby，自增改为自减。

incr/decr系列命令要求操作的value类型为string，并可以转换为64位带符号的整型数字，否则会返回错误。
也就是说，进行incr/decr系列命令的value，必须在[-2^63 ~ 2^63 - 1]范围内。

前文提到过，redis采用单线程模型，天然是线程安全的，这使得incr/decr命令可以非常便利的实现高并发场景下的精确控制。

例1：库存控制

在高并发场景下实现库存余量的精准校验，确保不出现超卖的情况。

设置库存总量：

set inv:remain "100"

库存扣减 余量校验：

decr inv:remain

当decr命令返回值大于等于0时，说明库存余量校验通过，如果返回小于0的值，则说明库存已耗尽。

假设同时有300个并发请求进行库存扣减，redis能够确保这300个请求分别得到99到-200的返回值，每个请求得到的返回值都是唯一的，绝对不会找出现两个请求得到一样的返回值的情况。

例2：自增序列生成

实现类似于rdbms的sequence功能，生成一系列唯一的序列号

设置序列起始值：

set sequence "10000"

获取一个序列值：

incr sequence

直接将返回值作为序列使用即可。

获取一批（如100个）序列值：

incrby sequence 100

假设返回值为n，那么[n - 99 ~ n]的数值都是可用的序列值。

当多个客户端同时向redis申请自增序列时，redis能够确保每个客户端得到的序列值或序列范围都是全局唯一的，绝对不会出现不同客户端得到了重复的序列值的情况。

list

redis的list是链表型的数据结构，可以使用lpush/rpush/lpop/rpop等命令在list的两端执行插入元素和弹出元素的操作。虽然list也支持在特定index上插入和读取元素的功能，但其时间复杂度较高（o(n)），应小心使用。

与list相关的常用命令：

• lpush：向指定list的左侧（即头部）插入1个或多个元素，返回插入后的list长度。时间复杂度o(n)，n为插入元素的数量
• rpush：同lpush，向指定list的右侧（即尾部）插入1或多个元素
• lpop：从指定list的左侧（即头部）移除一个元素并返回，时间复杂度o(1)
• rpop：同lpop，从指定list的右侧（即尾部）移除1个元素并返回
• lpushx/rpushx：与lpush/rpush类似，区别在于，lpushx/rpushx操作的key如果不存在，则不会进行任何操作
• llen：返回指定list的长度，时间复杂度o(1)
• lrange：返回指定list中指定范围的元素（双端包含，即lrange key 0 10会返回11个元素），时间复杂度o(n)。应尽可能控制一次获取的元素数量，一次获取过大范围的list元素会导致延迟，同时对长度不可预知的list，避免使用lrange key 0 -1这样的完整遍历操作。

应谨慎使用的list相关命令：

• lindex：返回指定list指定index上的元素，如果index越界，返回nil。index数值是回环的，即-1代表list最后一个位置，-2代表list倒数第二个位置。时间复杂度o(n)
• lset：将指定list指定index上的元素设置为value，如果index越界则返回错误，时间复杂度o(n)，如果操作的是头/尾部的元素，则时间复杂度为o(1)
• linsert：向指定list中指定元素之前/之后插入一个新元素，并返回操作后的list长度。如果指定的元素不存在，返回-1。如果指定key不存在，不会进行任何操作，时间复杂度o(n)

由于redis的list是链表结构的，上述的三个命令的算法效率较低，需要对list进行遍历，命令的耗时无法预估，在list长度大的情况下耗时会明显增加，应谨慎使用。

换句话说，redis的list实际是设计来用于实现队列，而不是用于实现类似arraylist这样的列表的。如果你不是想要实现一个双端出入的队列，那么请尽量不要使用redis的list数据结构。

为了更好支持队列的特性，redis还提供了一系列阻塞式的操作命令，如blpop/brpop等，能够实现类似于blockingqueue的能力，即在list为空时，阻塞该连接，直到list中有对象可以出队时再返回。针对阻塞类的命令，此处不做详细探讨，请参考官方文档（https://redis.io/topics/data-types-intro） 中"blocking operations on lists"一节。

hash

hash即哈希表，redis的hash和传统的哈希表一样，是一种field-value型的数据结构，可以理解成将hashmap搬入redis。
hash非常适合用于表现对象类型的数据，用hash中的field对应对象的field即可。
hash的优点包括：

• 可以实现二元查找，如"查找id为1000的用户的年龄"
• 比起将整个对象序列化后作为string存储的方法，hash能够有效地减少网络传输的消耗
• 当使用hash维护一个集合时，提供了比list效率高得多的随机访问命令

与hash相关的常用命令：

• hset：将key对应的hash中的field设置为value。如果该hash不存在，会自动创建一个。时间复杂度o(1)
• hget：返回指定hash中field字段的值，时间复杂度o(1)
• hmset/hmget：同hset和hget，可以批量操作同一个key下的多个field，时间复杂度：o(n)，n为一次操作的field数量
• hsetnx：同hset，但如field已经存在，hsetnx不会进行任何操作，时间复杂度o(1)
• hexists：判断指定hash中field是否存在，存在返回1，不存在返回0，时间复杂度o(1)
• hdel：删除指定hash中的field（1个或多个），时间复杂度：o(n)，n为操作的field数量
• hincrby：同incrby命令，对指定hash中的一个field进行incrby，时间复杂度o(1)

应谨慎使用的hash相关命令：

• hgetall：返回指定hash中所有的field-value对。返回结果为数组，数组中field和value交替出现。时间复杂度o(n)
• hkeys/hvals：返回指定hash中所有的field/value，时间复杂度o(n)

上述三个命令都会对hash进行完整遍历，hash中的field数量与命令的耗时线性相关，对于尺寸不可预知的hash，应严格避免使用上面三个命令，而改为使用hscan命令进行游标式的遍历，具体请见 https://redis.io/commands/scan

set

redis set是无序的，不可重复的string集合。

与set相关的常用命令：

• sadd：向指定set中添加1个或多个member，如果指定set不存在，会自动创建一个。时间复杂度o(n)，n为添加的member个数
• srem：从指定set中移除1个或多个member，时间复杂度o(n)，n为移除的member个数
• srandmember：从指定set中随机返回1个或多个member，时间复杂度o(n)，n为返回的member个数
• spop：从指定set中随机移除并返回count个member，时间复杂度o(n)，n为移除的member个数
• scard：返回指定set中的member个数，时间复杂度o(1)
• sismember：判断指定的value是否存在于指定set中，时间复杂度o(1)
• smove：将指定member从一个set移至另一个set

慎用的set相关命令：

• smembers：返回指定hash中所有的member，时间复杂度o(n)
• sunion/sunionstore：计算多个set的并集并返回/存储至另一个set中，时间复杂度o(n)，n为参与计算的所有集合的总member数
• sinter/sinterstore：计算多个set的交集并返回/存储至另一个set中，时间复杂度o(n)，n为参与计算的所有集合的总member数
• sdiff/sdiffstore：计算1个set与1或多个set的差集并返回/存储至另一个set中，时间复杂度o(n)，n为参与计算的所有集合的总member数

上述几个命令涉及的计算量大，应谨慎使用，特别是在参与计算的set尺寸不可知的情况下，应严格避免使用。可以考虑通过sscan命令遍历获取相关set的全部member（具体请见 https://redis.io/commands/scan ），如果需要做并集/交集/差集计算，可以在客户端进行，或在不服务实时查询请求的slave上进行。

sorted set

redis sorted set是有序的、不可重复的string集合。sorted set中的每个元素都需要指派一个分数(score)，sorted set会根据score对元素进行升序排序。如果多个member拥有相同的score，则以字典序进行升序排序。

sorted set非常适合用于实现排名。

sorted set的主要命令：

• zadd：向指定sorted set中添加1个或多个member，时间复杂度o(mlog(n))，m为添加的member数量，n为sorted set中的member数量
• zrem：从指定sorted set中删除1个或多个member，时间复杂度o(mlog(n))，m为删除的member数量，n为sorted set中的member数量
• zcount：返回指定sorted set中指定score范围内的member数量，时间复杂度：o(log(n))
• zcard：返回指定sorted set中的member数量，时间复杂度o(1)
• zscore：返回指定sorted set中指定member的score，时间复杂度o(1)
• zrank/zrevrank：返回指定member在sorted set中的排名，zrank返回按升序排序的排名，zrevrank则返回按降序排序的排名。时间复杂度o(log(n))
• zincrby：同incrby，对指定sorted set中的指定member的score进行自增，时间复杂度o(log(n))

慎用的sorted set相关命令：

• zrange/zrevrange：返回指定sorted set中指定排名范围内的所有member，zrange为按score升序排序，zrevrange为按score降序排序，时间复杂度o(log(n) m)，m为本次返回的member数
• zrangebyscore/zrevrangebyscore：返回指定sorted set中指定score范围内的所有member，返回结果以升序/降序排序，min和max可以指定为-inf和 inf，代表返回所有的member。时间复杂度o(log(n) m)
• zremrangebyrank/zremrangebyscore：移除sorted set中指定排名范围/指定score范围内的所有member。时间复杂度o(log(n) m)

上述几个命令，应尽量避免传递[0 -1]或[-inf inf]这样的参数，来对sorted set做一次性的完整遍历，特别是在sorted set的尺寸不可预知的情况下。可以通过zscan命令来进行游标式的遍历（具体请见 https://redis.io/commands/scan ），或通过limit参数来限制返回member的数量（适用于zrangebyscore和zrevrangebyscore命令），以实现游标式的遍历。

bitmap和hyperloglog

redis的这两种数据结构相较之前的并不常用，在本文中只做简要介绍，如想要详细了解这两种数据结构与其相关的命令，请参考官方文档https://redis.io/topics/data-types-intro 中的相关章节

bitmap在redis中不是一种实际的数据类型，而是一种将string作为bitmap使用的方法。可以理解为将string转换为bit数组。使用bitmap来存储true/false类型的简单数据极为节省空间。

hyperloglogs是一种主要用于数量统计的数据结构，它和set类似，维护一个不可重复的string集合，但是hyperloglogs并不维护具体的member内容，只维护member的个数。也就是说，hyperloglogs只能用于计算一个集合中不重复的元素数量，所以它比set要节省很多内存空间。

其他常用命令

• exists：判断指定的key是否存在，返回1代表存在，0代表不存在，时间复杂度o(1)
• del：删除指定的key及其对应的value，时间复杂度o(n)，n为删除的key数量
• expire/pexpire：为一个key设置有效期，单位为秒或毫秒，时间复杂度o(1)
• ttl/pttl：返回一个key剩余的有效时间，单位为秒或毫秒，时间复杂度o(1)
• rename/renamenx：将key重命名为newkey。使用rename时，如果newkey已经存在，其值会被覆盖；使用renamenx时，如果newkey已经存在，则不会进行任何操作，时间复杂度o(1)
• type：返回指定key的类型，string, list, set, zset, hash。时间复杂度o(1)
• config get：获得redis某配置项的当前值，可以使用*通配符，时间复杂度o(1)
• config set：为redis某个配置项设置新值，时间复杂度o(1)
• config rewrite：让redis重新加载redis.conf中的配置

数据持久化

redis提供了将数据定期自动持久化至硬盘的能力，包括rdb和aof两种方案，两种方案分别有其长处和短板，可以配合起来同时运行，确保数据的稳定性。

必须使用数据持久化吗？

redis的数据持久化机制是可以关闭的。如果你只把redis作为缓存服务使用，redis中存储的所有数据都不是该数据的主体而仅仅是同步过来的备份，那么可以关闭redis的数据持久化机制。
但通常来说，仍然建议至少开启rdb方式的数据持久化，因为：

• rdb方式的持久化几乎不损耗redis本身的性能，在进行rdb持久化时，redis主进程唯一需要做的事情就是fork出一个子进程，所有持久化工作都由子进程完成
• redis无论因为什么原因crash掉之后，重启时能够自动恢复到上一次rdb快照中记录的数据。这省去了手工从其他数据源（如db）同步数据的过程，而且要比其他任何的数据恢复方式都要快
• 现在硬盘那么大，真的不缺那一点地方

rdb

采用rdb持久方式，redis会定期保存数据快照至一个rbd文件中，并在启动时自动加载rdb文件，恢复之前保存的数据。可以在配置文件中配置redis进行快照保存的时机：

save [seconds] [changes]

意为在[seconds]秒内如果发生了[changes]次数据修改，则进行一次rdb快照保存，例如

save 60 100

会让redis每60秒检查一次数据变更情况，如果发生了100次或以上的数据变更，则进行rdb快照保存。
可以配置多条save指令，让redis执行多级的快照保存策略。
redis默认开启rdb快照，默认的rdb策略如下：

save 900 1
save 300 10
save 60 10000

也可以通过bgsave命令手工触发rdb快照保存。

rdb的优点：

• 对性能影响最小。如前文所述，redis在保存rdb快照时会fork出子进程进行，几乎不影响redis处理客户端请求的效率。
• 每次快照会生成一个完整的数据快照文件，所以可以辅以其他手段保存多个时间点的快照（例如把每天0点的快照备份至其他存储媒介中），作为非常可靠的灾难恢复手段。
• 使用rdb文件进行数据恢复比使用aof要快很多。

rdb的缺点：

• 快照是定期生成的，所以在redis crash时或多或少会丢失一部分数据。
• 如果数据集非常大且cpu不够强（比如单核cpu），redis在fork子进程时可能会消耗相对较长的时间（长至1秒），影响这期间的客户端请求。

aof

采用aof持久方式时，redis会把每一个写请求都记录在一个日志文件里。在redis重启时，会把aof文件中记录的所有写操作顺序执行一遍，确保数据恢复到最新。

aof默认是关闭的，如要开启，进行如下配置：

appendonly yes

aof提供了三种fsync配置，always/everysec/no，通过配置项[appendfsync]指定：

• appendfsync no：不进行fsync，将flush文件的时机交给os决定，速度最快
• appendfsync always：每写入一条日志就进行一次fsync操作，数据安全性最高，但速度最慢
• appendfsync everysec：折中的做法，交由后台线程每秒fsync一次

随着aof不断地记录写操作日志，必定会出现一些无用的日志，例如某个时间点执行了命令set key1 "abc"，在之后某个时间点又执行了set key1 "bcd"，那么第一条命令很显然是没有用的。大量的无用日志会让aof文件过大，也会让数据恢复的时间过长。
所以redis提供了aof rewrite功能，可以重写aof文件，只保留能够把数据恢复到最新状态的最小写操作集。
aof rewrite可以通过bgrewriteaof命令触发，也可以配置redis定期自动进行：

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

上面两行配置的含义是，redis在每次aof rewrite时，会记录完成rewrite后的aof日志大小，当aof日志大小在该基础上增长了100%后，自动进行aof rewrite。同时如果增长的大小没有达到64mb，则不会进行rewrite。

aof的优点：

• 最安全，在启用appendfsync always时，任何已写入的数据都不会丢失，使用在启用appendfsync everysec也至多只会丢失1秒的数据。
• aof文件在发生断电等问题时也不会损坏，即使出现了某条日志只写入了一半的情况，也可以使用redis-check-aof工具轻松修复。
• aof文件易读，可修改，在进行了某些错误的数据清除操作后，只要aof文件没有rewrite，就可以把aof文件备份出来，把错误的命令删除，然后恢复数据。

aof的缺点：

• aof文件通常比rdb文件更大
• 性能消耗比rdb高
• 数据恢复速度比rdb慢

内存管理与数据淘汰机制

最大内存设置

默认情况下，在32位os中，redis最大使用3gb的内存，在64位os中则没有限制。

在使用redis时，应该对数据占用的最大空间有一个基本准确的预估，并为redis设定最大使用的内存。否则在64位os中redis会无限制地占用内存（当物理内存被占满后会使用swap空间），容易引发各种各样的问题。

通过如下配置控制redis使用的最大内存：

maxmemory 100mb

在内存占用达到了maxmemory后，再向redis写入数据时，redis会：

• 根据配置的数据淘汰策略尝试淘汰数据，释放空间
• 如果没有数据可以淘汰，或者没有配置数据淘汰策略，那么redis会对所有写请求返回错误，但读请求仍然可以正常执行

在为redis设置maxmemory时，需要注意：

• 如果采用了redis的主从同步，主节点向从节点同步数据时，会占用掉一部分内存空间，如果maxmemory过于接近主机的可用内存，导致数据同步时内存不足。所以设置的maxmemory不要过于接近主机可用的内存，留出一部分预留用作主从同步。

数据淘汰机制

redis提供了5种数据淘汰策略：

• volatile-lru：使用lru算法进行数据淘汰（淘汰上次使用时间最早的，且使用次数最少的key），只淘汰设定了有效期的key
• allkeys-lru：使用lru算法进行数据淘汰，所有的key都可以被淘汰
• volatile-random：随机淘汰数据，只淘汰设定了有效期的key
• allkeys-random：随机淘汰数据，所有的key都可以被淘汰
• volatile-ttl：淘汰剩余有效期最短的key

最好为redis指定一种有效的数据淘汰策略以配合maxmemory设置，避免在内存使用满后发生写入失败的情况。

一般来说，推荐使用的策略是volatile-lru，并辨识redis中保存的数据的重要性。对于那些重要的，绝对不能丢弃的数据（如配置类数据等），应不设置有效期，这样redis就永远不会淘汰这些数据。对于那些相对不是那么重要的，并且能够热加载的数据（比如缓存最近登录的用户信息，当在redis中找不到时，程序会去db中读取），可以设置上有效期，这样在内存不够时redis就会淘汰这部分数据。

配置方法：

maxmemory-policy volatile-lru   #默认是noeviction，即不进行数据淘汰

pipelining

pipelining

redis提供许多批量操作的命令，如mset/mget/hmset/hmget等等，这些命令存在的意义是减少维护网络连接和传输数据所消耗的资源和时间。
例如连续使用5次set命令设置5个不同的key，比起使用一次mset命令设置5个不同的key，效果是一样的，但前者会消耗更多的rtt(round trip time)时长，永远应优先使用后者。

然而，如果客户端要连续执行的多次操作无法通过redis命令组合在一起，例如：

set a "abc"
incr b
hset c name "hi"

此时便可以使用redis提供的pipelining功能来实现在一次交互中执行多条命令。
使用pipelining时，只需要从客户端一次向redis发送多条命令（以\r\n）分隔，redis就会依次执行这些命令，并且把每个命令的返回按顺序组装在一起一次返回，比如：

$ (printf "ping\r\nping\r\nping\r\n"; sleep 1) | nc localhost 6379
 pong
 pong
 pong

大部分的redis客户端都对pipelining提供支持，所以开发者通常并不需要自己手工拼装命令列表。

pipelining的局限性

pipelining只能用于执行连续且无相关性的命令，当某个命令的生成需要依赖于前一个命令的返回时，就无法使用pipelining了。

通过scripting功能，可以规避这一局限性

事务与scripting

pipelining能够让redis在一次交互中处理多条命令，然而在一些场景下，我们可能需要在此基础上确保这一组命令是连续执行的。

比如获取当前累计的pv数并将其清0

> get vcount
12384
> set vcount 0
ok

如果在get和set命令之间插进来一个incr vcount，就会使客户端拿到的vcount不准确。

redis的事务可以确保复数命令执行时的原子性。也就是说redis能够保证：一个事务中的一组命令是绝对连续执行的，在这些命令执行完成之前，绝对不会有来自于其他连接的其他命令插进去执行。

通过multi和exec命令来把这两个命令加入一个事务中：

> multi
ok
> get vcount
queued
> set vcount 0
queued
> exec
1) 12384
2) ok

redis在接收到multi命令后便会开启一个事务，这之后的所有读写命令都会保存在队列中但并不执行，直到接收到exec命令后，redis会把队列中的所有命令连续顺序执行，并以数组形式返回每个命令的返回结果。

可以使用discard命令放弃当前的事务，将保存的命令队列清空。

需要注意的是，redis事务不支持回滚：
如果一个事务中的命令出现了语法错误，大部分客户端驱动会返回错误，2.6.5版本以上的redis也会在执行exec时检查队列中的命令是否存在语法错误，如果存在，则会自动放弃事务并返回错误。
但如果一个事务中的命令有非语法类的错误（比如对string执行hset操作），无论客户端驱动还是redis都无法在真正执行这条命令之前发现，所以事务中的所有命令仍然会被依次执行。在这种情况下，会出现一个事务中部分命令成功部分命令失败的情况，然而与rdbms不同，redis不提供事务回滚的功能，所以只能通过其他方法进行数据的回滚。

通过事务实现cas

redis提供了watch命令与事务搭配使用，实现cas乐观锁的机制。

假设要实现将某个商品的状态改为已售：

if(exec(hget stock:1001 state) == "in stock")
    exec(hset stock:1001 state "sold");

这一伪代码执行时，无法确保并发安全性，有可能多个客户端都获取到了"in stock"的状态，导致一个库存被售卖多次。

使用watch命令和事务可以解决这一问题：

exec(watch stock:1001);
if(exec(hget stock:1001 state) == "in stock") {
    exec(multi);
    exec(hset stock:1001 state "sold");
    exec(exec);
}

watch的机制是：在事务exec命令执行时，redis会检查被watch的key，只有被watch的key从watch起始时至今没有发生过变更，exec才会被执行。如果watch的key在watch命令到exec命令之间发生过变化，则exec命令会返回失败。

scripting

通过eval与evalsha命令，可以让redis执行lua脚本。这就类似于rdbms的存储过程一样，可以把客户端与redis之间密集的读/写交互放在服务端进行，避免过多的数据交互，提升性能。

scripting功能是作为事务功能的替代者诞生的，事务提供的所有能力scripting都可以做到。redis官方推荐使用lua script来代替事务，前者的效率和便利性都超过了事务。

关于scripting的具体使用，本文不做详细介绍，请参考官方文档 https://redis.io/commands/eval

redis性能调优

尽管redis是一个非常快速的内存数据存储媒介，也并不代表redis不会产生性能问题。
前文中提到过，redis采用单线程模型，所有的命令都是由一个线程串行执行的，所以当某个命令执行耗时较长时，会拖慢其后的所有命令，这使得redis对每个任务的执行效率更加敏感。

针对redis的性能优化，主要从下面几个层面入手：

• 最初的也是最重要的，确保没有让redis执行耗时长的命令
• 使用pipelining将连续执行的命令组合执行
• 操作系统的transparent huge pages功能必须关闭：

echo never > /sys/kernel/mm/transparent_hugepage/enabled

• 如果在虚拟机中运行redis，可能天然就有虚拟机环境带来的固有延迟。可以通过./redis-cli --intrinsic-latency 100命令查看固有延迟。同时如果对redis的性能有较高要求的话，应尽可能在物理机上直接部署redis。
• 检查数据持久化策略
• 考虑引入读写分离机制

长耗时命令

redis绝大多数读写命令的时间复杂度都在o(1)到o(n)之间，在文本和官方文档中均对每个命令的时间复杂度有说明。

通常来说，o(1)的命令是安全的，o(n)命令在使用时需要注意，如果n的数量级不可预知，则应避免使用。例如对一个field数未知的hash数据执行hgetall/hkeys/hvals命令，通常来说这些命令执行的很快，但如果这个hash中的field数量极多，耗时就会成倍增长。
又如使用sunion对两个set执行union操作，或使用sort对list/set执行排序操作等时，都应该严加注意。

避免在使用这些o(n)命令时发生问题主要有几个办法：

• 不要把list当做列表使用，仅当做队列来使用
• 通过机制严格控制hash、set、sorted set的大小
• 可能的话，将排序、并集、交集等操作放在客户端执行
• 绝对禁止使用keys命令
• 避免一次性遍历集合类型的所有成员，而应使用scan类的命令进行分批的，游标式的遍历

redis提供了scan命令，可以对redis中存储的所有key进行游标式的遍历，避免使用keys命令带来的性能问题。同时还有sscan/hscan/zscan等命令，分别用于对set/hash/sorted set中的元素进行游标式遍历。scan类命令的使用请参考官方文档：https://redis.io/commands/scan

redis提供了slow log功能，可以自动记录耗时较长的命令。相关的配置参数有两个：

slowlog-log-slower-than xxxms  #执行时间慢于xxx毫秒的命令计入slow log
slowlog-max-len xxx  #slow log的长度，即最大纪录多少条slow log

使用slowlog get [number]命令，可以输出最近进入slow log的number条命令。
使用slowlog reset命令，可以重置slow log

网络引发的延迟

• 尽可能使用长连接或连接池，避免频繁创建销毁连接
• 客户端进行的批量数据操作，应使用pipeline特性在一次交互中完成。具体请参照本文的pipelining章节

数据持久化引发的延迟

redis的数据持久化工作本身就会带来延迟，需要根据数据的安全级别和性能要求制定合理的持久化策略：

• aof fsync always的设置虽然能够绝对确保数据安全，但每个操作都会触发一次fsync，会对redis的性能有比较明显的影响
• aof fsync every second是比较好的折中方案，每秒fsync一次
• aof fsync never会提供aof持久化方案下的最优性能
• 使用rdb持久化通常会提供比使用aof更高的性能，但需要注意rdb的策略配置
• 每一次rdb快照和aof rewrite都需要redis主进程进行fork操作。fork操作本身可能会产生较高的耗时，与cpu和redis占用的内存大小有关。根据具体的情况合理配置rdb快照和aof rewrite时机，避免过于频繁的fork带来的延迟

redis在fork子进程时需要将内存分页表拷贝至子进程，以占用了24gb内存的redis实例为例，共需要拷贝24gb / 4kb * 8 = 48mb的数据。在使用单xeon 2.27ghz的物理机上，这一fork操作耗时216ms。

可以通过info命令返回的latest_fork_usec字段查看上一次fork操作的耗时（微秒）

swap引发的延迟

当linux将redis所用的内存分页移至swap空间时，将会阻塞redis进程，导致redis出现不正常的延迟。swap通常在物理内存不足或一些进程在进行大量i/o操作时发生，应尽可能避免上述两种情况的出现。

/proc//smaps文件中会保存进程的swap记录，通过查看这个文件，能够判断redis的延迟是否由swap产生。如果这个文件中记录了较大的swap size，则说明延迟很有可能是swap造成的。

数据淘汰引发的延迟

当同一秒内有大量key过期时，也会引发redis的延迟。在使用时应尽量将key的失效时间错开。

引入读写分离机制

redis的主从复制能力可以实现一主多从的多节点架构，在这一架构下，主节点接收所有写请求，并将数据同步给多个从节点。
在这一基础上，我们可以让从节点提供对实时性要求不高的读请求服务，以减小主节点的压力。
尤其是针对一些使用了长耗时命令的统计类任务，完全可以指定在一个或多个从节点上执行，避免这些长耗时命令影响其他请求的响应。

关于读写分离的具体说明，请参见后续章节

主从复制与集群分片

主从复制

redis支持一主多从的主从复制架构。一个master实例负责处理所有的写请求，master将写操作同步至所有slave。
借助redis的主从复制，可以实现读写分离和高可用：

• 实时性要求不是特别高的读请求，可以在slave上完成，提升效率。特别是一些周期性执行的统计任务，这些任务可能需要执行一些长耗时的redis命令，可以专门规划出1个或几个slave用于服务这些统计任务
• 借助redis sentinel可以实现高可用，当master crash后，redis sentinel能够自动将一个slave晋升为master，继续提供服务

启用主从复制非常简单，只需要配置多个redis实例，在作为slave的redis实例中配置：

slaveof 192.168.1.1 6379  #指定master的ip和端口

当slave启动后，会从master进行一次冷启动数据同步，由master触发bgsave生成rdb文件推送给slave进行导入，导入完成后master再将增量数据通过redis protocol同步给slave。之后主从之间的数据便一直以redis protocol进行同步

使用sentinel做自动failover

redis的主从复制功能本身只是做数据同步，并不提供监控和自动failover能力，要通过主从复制功能来实现redis的高可用，还需要引入一个组件：redis sentinel

redis sentinel是redis官方开发的监控组件，可以监控redis实例的状态，通过master节点自动发现slave节点，并在监测到master节点失效时选举出一个新的master，并向所有redis实例推送新的主从配置。

redis sentinel需要至少部署3个实例才能形成选举关系。

关键配置：

sentinel monitor mymaster 127.0.0.1 6379 2  #master实例的ip、端口，以及选举需要的赞成票数
sentinel down-after-milliseconds mymaster 60000  #多长时间没有响应视为master失效
sentinel failover-timeout mymaster 180000  #两次failover尝试间的间隔时长
sentinel parallel-syncs mymaster 1  #如果有多个slave，可以通过此配置指定同时从新master进行数据同步的slave数，避免所有slave同时进行数据同步导致查询服务也不可用

另外需要注意的是，redis sentinel实现的自动failover不是在同一个ip和端口上完成的，也就是说自动failover产生的新master提供服务的ip和端口与之前的master是不一样的，所以要实现ha，还要求客户端必须支持sentinel，能够与sentinel交互获得新master的信息才行。

集群分片

为何要做集群分片：

• redis中存储的数据量大，一台主机的物理内存已经无法容纳
• redis的写请求并发量大，一个redis实例以无法承载

当上述两个问题出现时，就必须要对redis进行分片了。
redis的分片方案有很多种，例如很多redis的客户端都自行实现了分片功能，也有向twemproxy这样的以代理方式实现的redis分片方案。然而首选的方案还应该是redis官方在3.0版本中推出的redis cluster分片方案。

本文不会对redis cluster的具体安装和部署细节进行介绍，重点介绍redis cluster带来的好处与弊端。

redis cluster的能力

• 能够自动将数据分散在多个节点上
• 当访问的key不在当前分片上时，能够自动将请求转发至正确的分片
• 当集群中部分节点失效时仍能提供服务

其中第三点是基于主从复制来实现的，redis cluster的每个数据分片都采用了主从复制的结构，原理和前文所述的主从复制完全一致，唯一的区别是省去了redis sentinel这一额外的组件，由redis cluster负责进行一个分片内部的节点监控和自动failover。

redis cluster分片原理

redis cluster中共有16384个hash slot，redis会计算每个key的crc16，将结果与16384取模，来决定该key存储在哪一个hash slot中，同时需要指定redis cluster中每个数据分片负责的slot数。slot的分配在任何时间点都可以进行重新分配。

客户端在对key进行读写操作时，可以连接cluster中的任意一个分片，如果操作的key不在此分片负责的slot范围内，redis cluster会自动将请求重定向到正确的分片上。

hash tags

在基础的分片原则上，redis还支持hash tags功能，以hash tags要求的格式明明的key，将会确保进入同一个slot中。例如：{uiv}user:1000和{uiv}user:1001拥有同样的hash tag {uiv}，会保存在同一个slot中。

使用redis cluster时，pipelining、事务和lua script功能涉及的key必须在同一个数据分片上，否则将会返回错误。如要在redis cluster中使用上述功能，就必须通过hash tags来确保一个pipeline或一个事务中操作的所有key都位于同一个slot中。

有一些客户端（如redisson）实现了集群化的pipelining操作，可以自动将一个pipeline里的命令按key所在的分片进行分组，分别发到不同的分片上执行。但是redis不支持跨分片的事务，事务和lua script还是必须遵循所有key在一个分片上的规则要求。

主从复制 vs 集群分片

在设计软件架构时，要如何在主从复制和集群分片两种部署方案中取舍呢？

从各个方面看，redis cluster都是优于主从复制的方案

• redis cluster能够解决单节点上数据量过大的问题
• redis cluster能够解决单节点访问压力过大的问题
• redis cluster包含了主从复制的能力

那是不是代表redis cluster永远是优于主从复制的选择呢？

并不是。

软件架构永远不是越复杂越好，复杂的架构在带来显著好处的同时，一定也会带来相应的弊端。采用redis cluster的弊端包括：

• 维护难度增加。在使用redis cluster时，需要维护的redis实例数倍增，需要监控的主机数量也相应增加，数据备份/持久化的复杂度也会增加。同时在进行分片的增减操作时，还需要进行reshard操作，远比主从模式下增加一个slave的复杂度要高。
• 客户端资源消耗增加。当客户端使用连接池时，需要为每一个数据分片维护一个连接池，客户端同时需要保持的连接数成倍增多，加大了客户端本身和操作系统资源的消耗。
• 性能优化难度增加。你可能需要在多个分片上查看slow log和swap日志才能定位性能问题。
• 事务和lua script的使用成本增加。在redis cluster中使用事务和lua script特性有严格的限制条件，事务和script中操作的key必须位于同一个分片上，这就使得在开发时必须对相应场景下涉及的key进行额外的规划和规范要求。如果应用的场景中大量涉及事务和script的使用，如何在保证这两个功能的正常运作前提下把数据平均分到多个数据分片中就会成为难点。

所以说，在主从复制和集群分片两个方案中做出选择时，应该从应用软件的功能特性、数据和访问量级、未来发展规划等方面综合考虑，只在确实有必要引入数据分片时再使用redis cluster。
下面是一些建议：

1. 需要在redis中存储的数据有多大？未来2年内可能发展为多大？这些数据是否都需要长期保存？是否可以使用lru算法进行非热点数据的淘汰？综合考虑前面几个因素，评估出redis需要使用的物理内存。
2. 用于部署redis的主机物理内存有多大？有多少可以分配给redis使用？对比(1)中的内存需求评估，是否足够用？
3. redis面临的并发写压力会有多大？在不使用pipelining时，redis的写性能可以超过10万次/秒（更多的benchmark可以参考 https://redis.io/topics/benchmarks ）
4. 在使用redis时，是否会使用到pipelining和事务功能？使用的场景多不多？

综合上面几点考虑，如果单台主机的可用物理内存完全足以支撑对redis的容量需求，且redis面临的并发写压力距离benchmark值还尚有距离，建议采用主从复制的架构，可以省去很多不必要的麻烦。同时，如果应用中大量使用pipelining和事务，也建议尽可能选择主从复制架构，可以减少设计和开发时的复杂度。

redis java客户端的选择

redis的java客户端很多，官方推荐的有三种：jedis、redisson和lettuce。

在这里对jedis和redisson进行对比介绍

jedis：

• 轻量，简洁，便于集成和改造
• 支持连接池
• 支持pipelining、事务、lua scripting、redis sentinel、redis cluster
• 不支持读写分离，需要自己实现
• 文档差（真的很差，几乎没有……）

redisson：

• 基于netty实现，采用非阻塞io，性能高
• 支持异步请求
• 支持连接池
• 支持pipelining、lua scripting、redis sentinel、redis cluster
• 不支持事务，官方建议以lua scripting代替事务
• 支持在redis cluster架构下使用pipelining
• 支持读写分离，支持读负载均衡，在主从复制和redis cluster架构下都可以使用
• 内建tomcat session manager，为tomcat 6/7/8提供了会话共享功能
• 可以与spring session集成，实现基于redis的会话共享
• 文档较丰富，有中文文档

对于jedis和redisson的选择，同样应遵循前述的原理，尽管jedis比起redisson有各种各样的不足，但也应该在需要使用redisson的高级特性时再选用redisson，避免造成不必要的程序复杂度提升。

jedis：
github：https://github.com/xetorthio/jedis
文档：https://github.com/xetorthio/jedis/wiki

redisson：
github：https://github.com/redisson/redisson
文档：https://github.com/redisson/redisson/wiki