一：事务
1：概述
Redis中的事务（transaction）是一组命令的集合。事务同命令一样都是Redis的最小执行单位，一个事务中的命令要么都执行，要么都不执行。
事务的原理是是先将属于一个事务的所有命令都发送给Redis，然后再让Redis依次执行这些命令。比如：
127.0.0.1:6379> multi OK 127.0.0.1:6379> sadd aset 2 QUEUED 127.0.0.1:6379> sadd aset 1 QUEUED 127.0.0.1:6379> exec 1) (integer) 1 2) (integer) 1
上面的代码演示了事务的使用方式。首先使用multi命令告诉Redis：“下面我发给你的命令属于同一个事务，你先不要执行，而是把它们暂时存起来”。Redis回答：“OK”。
当把所有在同一个事务中要执行的命令都发给Redis后，使用exec命令告诉Redis，将事务队列中的所有命令按照发送顺序依次执行。exec命令的返回值就是这些命令的返回值组成的列表，返回值顺序和命令的顺序相同。
Redis保证一个事务中的所有命令要么都执行，要么都不执行。如果在发送exec命令前客户端断线了，则Redis会清空事务队列，事务中的所有命令都不会执行。而一旦客户端发送了exec命令，所有的命令就都会被执行，即使此后客户端断链也没关系，因为Redis中己经记录了所有要执行的命令。
除此之外，Redis的事务还能保证一个事务内的命令依次执行而不被其他命令打断。
2：错误处理
a、语法错误，比如：
127.0.0.1:6379> multi OK 127.0.0.1:6379> set a 1 QUEUED 127.0.0.1:6379> set b (error) ERR wrong number of arguments for 'set' command 127.0.0.1:6379> errcommand c (error) ERR unknown command 'errcommand' 127.0.0.1:6379> exec (error) EXECABORT Transaction discarded because of previous errors.
跟在multi命令后执行了3个命令：一个正确的命令，成功加入到事务队列中；其余两个命令都有语法错误。只要有一个命令有语法错误，执行exec命令后Redis就会直接返回错误，连语法正确的命令也不会执行。
b、运行错误。运行错误指在命令执行时出现的错误，比如使用散列类型的命令操作集合类型的键，这种错误在实际执行之前Redis是无法发现的。如果事务里的一条命令出现了运行错误，事务里其他的命令依然会继续执行（包括出错命令之后的命令），示例如下：
127.0.0.1:6379> multi OK 127.0.0.1:6379> set a 1 QUEUED 127.0.0.1:6379> sadd a 2 QUEUED 127.0.0.1:6379> set a 3 QUEUED 127.0.0.1:6379> exec 1) OK 2) (error) WRONGTYPE Operation against a key holding the wrong kind of value 3) OK 127.0.0.1:6379> get a "3"
可见虽然命令”sadd a 2”出现了错误，但是”set a 3”依然执行了。
Redis的事务没有关系数据库事务提供的回滚功能。为此开发者必须在事务执行出错后自己收拾剩下的摊子（将数据库复原回事务执行前的状态等）。不过由于Redis不支持回滚功能，也使得Redis在事务上可以保持简洁和快速。
3：watch命令
watch命令可以监控一个或多个键，一旦有一个键被修改（或删除），整个的事务就不会执行。监控一直持续到exec命令。比如：
127.0.0.1:6379> set b 1 OK 127.0.0.1:6379> set a 1 OK 127.0.0.1:6379> watch a OK 127.0.0.1:6379> set a 2 OK 127.0.0.1:6379> multi OK 127.0.0.1:6379> set b 2 QUEUED 127.0.0.1:6379> set a 3 QUEUED 127.0.0.1:6379> set b 4 QUEUED 127.0.0.1:6379> exec (nil) 127.0.0.1:6379> get a "2" 127.0.0.1:6379> get b "1"
上例中，在执行watch命令后，事务执行前，修改了a的值，所以，最后事务中的命令”set a 3”没有执行，而且命令”set b 2”和”set b 4”也没有执行。exec命令返回空结果。
执行exec命令后会取消对所有键的监控，也可以用unwatch命令来取消监控。
二：生存时间
在Redis中可以使用expire命令设置一个键的生存时间，到时间后Redis会自动删除它。 expire命令的使用方法为：”expire key seconds”，其中seconds表示键的生存时间，单位是秒。expire命令返回1表示设置成功，返回0则表示键不存在或设置失败。
如果想知道一个键还有多久的时间会被删除，可以使用ttl命令。返回值是键的剩余时间（单位是秒）。如果ttl命令返回-2，表明该key不存在，如果ttl返回-1，表明该key存在，但是没有关联超时时间。比如：
127.0.0.1:6379> set foo 1 OK 127.0.0.1:6379> expire foo 20 (integer) 1 127.0.0.1:6379> ttl foo (integer) 18 127.0.0.1:6379> ttl foo (integer) 10 127.0.0.1:6379> ttl foo (integer) -2 127.0.0.1:6379> set bar 2 OK 127.0.0.1:6379> ttl bar (integer) -1
如果想取消键的生存时间设置（即将键恢复成永久的），可以使用persist命令。如果生存时间被成功清除则返回1；否则返回0（因为键不存在或键本来就是永久的）。比如：
127.0.0.1:6379> set foo 1 OK 127.0.0.1:6379> ttl foo (integer) -1 127.0.0.1:6379> expire foo 20 (integer) 1 127.0.0.1:6379> ttl foo (integer) 18 127.0.0.1:6379> persist foo (integer) 1 127.0.0.1:6379> ttl foo (integer) -1
除了persist命令之外，使用set或getset命令为键赋值也会清除键的生存时间，其他只对键值进行操作的命令（如incr、lpush、hset、zrem）均不会影响键的生存时间。比如：
127.0.0.1:6379> set foo 1 OK 127.0.0.1:6379> expire foo 20 (integer) 1 127.0.0.1:6379> ttl foo (integer) 18 127.0.0.1:6379> set foo 2 OK 127.0.0.1:6379> ttl foo (integer) -1 127.0.0.1:6379> expire foo 20 (integer) 1 127.0.0.1:6379> ttl foo (integer) 17 127.0.0.1:6379> incr foo (integer) 3 127.0.0.1:6379> ttl foo (integer) 12
expire命令的seconds参数必须是整数，所以最小单位是1秒。如果想要更精确的控制键的生存时间应该使用pexpire命令，pexpire命令与expire命令的唯一区别是前者的时间单位是毫秒，即pexpire key 1000与expire key 1等价。
另外，pttl命令以毫秒为单位返回键的剩余时间。
还有两个命令expireat和pexpireat。expireat命令与expire命令的差别在于前者使用绝对时间表示键的生存时间。pexpireat命令与expireat命令的区别是前者的时间单位是毫秒。比如：
127.0.0.1:6379> set foo 1 OK 127.0.0.1:6379> expireat foo 1448972556 (integer) 1 127.0.0.1:6379> ttl foo (integer) 186 127.0.0.1:6379> pexpireat foo 1448972556000 (integer) 1 127.0.0.1:6379> ttl foo (integer) 165
将Redis作为缓存使用时，当服务器内存有限时，如果大量地使用缓存键且生存时间设置得过长就会导致Redis占满内存；另一方面如果为了防止Redis占用内存过大而将缓存键的生存时间设得太短，就可能导致缓存命中率过低并且大量内存白白地闲置。
实际开发中会发现很难为缓存键设置合理的生存时间，为此可以限制Redis能够使用的最大内存，并让Redis按照一定的规则淘汰不需要的缓存键，这种方式在只将Redis用作缓存系统时非常实用。
具体的设置方法为：修改配置文件的maxmemory参数，限制Redis最大可用内存大小（单位是字节），当超出了这个限制时Redis会依据maxmemory-policy参数指定的策略来删除不需要的键，直到Redis占用的内存小于指定内存。
maxmemory-policy支持的规则如下表所示：
其中的LRU（Least Recently Used）算法即“最近最少使用”，其认为最近最少使用的键在未来一段时间内也不会被用到，当需要空间时这些键是可以被删除的。
三：排序
1：sort命令
有序集合常见的使用场景是大数据排序，如游戏的玩家排行榜等。除了使用有序集合外，还可以借助Redis的sort命令，对列表类型、集合类型和有序集合类型键进行排序，并且可以完成与关系数据库中的join查询相类似的任务。比如：
127.0.0.1:6379> sadd set 1 4 5 2 3 9 10 -1 (integer) 8 127.0.0.1:6379> lpush list 1 4 5 2 3 9 10 -1 (integer) 8 127.0.0.1:6379> zadd zset 10.0 1 2.4 4 3.2 5 10.1 2 9.7 3 2.1 9 1.1 10 2.9 -1 (integer) 8 127.0.0.1:6379> sort set 1) "-1" 2) "1" 3) "2" 4) "3" 5) "4" 6) "5" 7) "9" 8) "10" 127.0.0.1:6379> sort list 1) "-1" 2) "1" 3) "2" 4) "3" 5) "4" 6) "5" 7) "9" 8) "10" 127.0.0.1:6379> sort zset 1) "-1" 2) "1" 3) "2" 4) "3" 5) "4" 6) "5" 7) "9" 8) "10"
除了可以排列数字外，sort命令还可以通过alpha参数实现按照字典顺序排列非数字元素，就像这样：
127.0.0.1:6379> sadd set2 a 2 b z e 3 x f 9 (integer) 9 127.0.0.1:6379> sort set2 (error) ERR One or more scores can't be converted into double 127.0.0.1:6379> sort set2 alpha 1) "2" 2) "3" 3) "9" 4) "a" 5) "b" 6) "e" 7) "f" 8) "x" 9) "z"
sort命令的desc参数可以实现将元素按照从大到小的顺序排列；sort命令还支持limit参数来返回指定范围的结果。用法和sql语句一样，limit offset count，表示跳过前offset个元素，并获取之后的count个元素。比如：
127.0.0.1:6379> sort set2 alpha desc 1) "z" 2) "x" 3) "f" 4) "e" 5) "b" 6) "a" 7) "9" 8) "3" 9) "2" 127.0.0.1:6379> sort set2 alpha desc limit 0 3 1) "z" 2) "x" 3) "f" 127.0.0.1:6379> sort set2 alpha desc limit 2 3 1) "f" 2) "e" 3) "b"
2：by参数
sort命令支持by参数，by参数的语法为“by 参考健”。其中参考键可以是字符串类型键或者是散列类型key的某个field（表示为key->field)。如果提供了by参数，sort命令将不再依据元素自身的值进行排序，而是针对每个元素，使用元素的值替换参考键中的第一个”*”，并获取其值，然后依据该值对元素排序。就像这样：
127.0.0.1:6379> sadd set a b c d e (integer) 5 127.0.0.1:6379> hset a time 5 (integer) 1 127.0.0.1:6379> hset b time 1 (integer) 1 127.0.0.1:6379> hset c time 7 (integer) 1 127.0.0.1:6379> hset d time 2 (integer) 1 127.0.0.1:6379> hset e time 10 (integer) 1 127.0.0.1:6379> hset f time 9 (integer) 1 127.0.0.1:6379> sort set by *->time 1) "b" 2) "d" 3) "a" 4) "c" 5) "e"
上例中，对集合set进行排序，但是不在按照集合中元素本身的值进行排序，而是根据by参数，针对set中的每个元素，使用元素的值替换参考键中的第一个”*”，并获取其值，然后依据该值对元素排序。也就是根据散列类型a、b、c、d、e的time字段的值进行排序。
除了散列类型之外，参考键还可以是字符串类型，比如：
127.0.0.1:6379> lpush list a b c d e (integer) 5 127.0.0.1:6379> mset a 100 b 2 c 1 d 90 e 28 f 19 OK 127.0.0.1:6379> sort list by * 1) "c" 2) "b" 3) "e" 4) "d" 5) "a"
当参考键名不包含”*”时（即常量键名，与元素值无关），sort命令将不会执行排序操作，因为Redis认为这种情况是没有意义的（因为所有要比较的值都一样）。例如：
127.0.0.1:6379> sort list by hehe 1) "e" 2) "d" 3) "c" 4) "b" 5) "a"
例子中hehe是常量键名（甚至hehe键可以不存在），此时sort的结果与lrange的结果相同，没有执行排序操作。在不需要排序但需要借助sort命令获得与元素相关联的数据时，常量键名是很有用的。
如果几个元素的参考键值相同，则sort命令会再比较元素本身的值来决定元素的顺序。像这样：
127.0.0.1:6379> lpush list g (integer) 6 127.0.0.1:6379> set g 2 OK 127.0.0.1:6379> sort list by * 1) "c" 2) "b" 3) "g" 4) "e" 5) "d" 6) "a"
例子中，元素g的参考键：字符串g，和元素b的参考键：字符串b，它们的值相同，都是2，因此，sort命令会再比较”g”和”b”元素本身的大小来决定两者的顺序。
当某个元素的参考键不存在时，会默认参考键的值为0：
127.0.0.1:6379> lpush list h (integer) 7 127.0.0.1:6379> sort list by * 1) "h" 2) "c" 3) "b" 4) "g" 5) "e" 6) "d" 7) "a"
3：get参数
sort命令支持get参数。get参数不影响排序，它的作用是使sort命令的返回结果不再是元索自身的值，而是get参数指定的键值。get参数的规则和by参数一样，get参数也支持字符串类型和散列类型的键，并使用”*”作为占位符。比如：
127.0.0.1:6379> sadd set a b c d e (integer) 5 127.0.0.1:6379> hmset a time 5 title hello OK 127.0.0.1:6379> hmset b time 1 title world OK 127.0.0.1:6379> hmset c time 7 title this OK 127.0.0.1:6379> hmset d time 2 title is OK 127.0.0.1:6379> hmset e time 10 title a OK 127.0.0.1:6379> hmset f time 9 title redis OK 127.0.0.1:6379> sort set by *->time get *->title 1) "world" 2) "is" 3) "hello" 4) "this" 5) "a" 127.0.0.1:6379> sort list by * get * 1) (nil) 2) "1" 3) "2" 4) "2" 5) "28" 6) "90" 7) "100"
一个sort命令中可以有多个get参数（而by参数只能有一个），有n个get参数，每个元素返回的结果就有n行。如果还需要返回元素本身，则可以使用：”get #”。比如：
127.0.0.1:6379> sort set by *->time get *->time get *->title get # 1) "1" 2) "world" 3) "b" 4) "2" 5) "is" 6) "d" 7) "5" 8) "hello" 9) "a" 10) "7" 11) "this" 12) "c" 13) "10" 14) "a" 15) "e"
4：store参数
默认情况下，sort会直接返回排序结果，如果希望保存排序结果，可以使用store参数。 保存后的键的类型为列表类型，如果键己经存在则会覆盖它。加上store参数后sort命令的返回值为结果的个数。比如：
127.0.0.1:6379> sort set by *->time get *->time get *->title get # store reslist (integer) 15 127.0.0.1:6379> lrange reslist 0 -1 1) "1" 2) "world" 3) "b" 4) "2" 5) "is" 6) "d" 7) "5" 8) "hello" 9) "a" 10) "7" 11) "this" 12) "c" 13) "10" 14) "a" 15) "e"
5：性能优化
sort是Redis中最强大最复杂的命令之一，如果使用不好很容易成为性能瓶颈。sort命令的时间复杂度是O(n + m log m)，其中n表示要排序的列表（集合或有序集合）中的元素个数，m表示要返回的元素个数。当n较大的时候sort命令的性能相对较低，并且Redis在排序前会建立一个长度为n的容器来存储待排序的元素，虽然是一个临时的过程，但如果同时进行较多的大数据量排序操作则会严重影响性能。所以开发中使用sort命令时需要注意以下几点：
a、尽可能减少待排序键中元素的数量（使n尽可能小）；
b、使用limit参数只获取需要的数据（使m尽可能小）；
c、如果要排序的数据数量较大，尽可能使用store参数将结果缓存。
四：消息通知
1：任务队列
队列可以用Redis的列表类型实现，比如使用lpush和rpop命令就可以实现队列的概念。要实现任务队列，只需要让生产者将任务使用lpush命令加入到某个键中，另一边让消费者不断地使用rpop命令从该键中取出任务即可。
使用rpop命令时，消费者需要不断的定期轮训队列，查看队列中是否有新的任务，也就是要定期调用一次rpop命令。其实借助brpop命令更方便一些，它是阻塞版本的rpop命令，唯一的区别是当列表中没有元素时，brpop命令会阻塞住连接，直到有新元素加入。
brpop命令接收两个参数，第一个是键名，第二个是超时时间，单位是秒。当超过了此时间，仍然没有获得新元素的话就返回nil。如果超时时间置为0，表示不限制等待的时间，即如果没有新元素加入，列表就会永远阻塞下去。当获得一个元素后brpop命令返回两个值，分别是键名和元素值。
举例如下，首先在终端A上调用brpop命令，这里的list甚至可以不存在：
127.0.0.1:6379> brpop list 0
此时该命令会阻塞住。然后，在终端B中执行lpush命令：
127.0.0.1:6379> lpush list hehe (integer) 1
此时，在终端A上，brpop命令才会有输出：
127.0.0.1:6379> brpop list 0 1) "list" 2) "hehe"
使用brpop命令，还可以实现一个优先级队列。brpop命令可以同时接收多个键，其完整的命令格式为：brpop key key [key ...] timeout
同时检测多个键，如果所有键都没有元素则阻塞，如果其中有一个键有元素则会从该键中弹出元素。
举例如下，首先在终端A上调用brpop命令：
127.0.0.1:6379> brpop list1 list2 0
此时终端A阻塞，然后在终端B上输入命令：
127.0.0.1:6379> lpush list2 this (integer) 1
此时，在终端A上输出：
127.0.0.1:6379> brpop list1 list2 0 1) "list2" 2) "this"
如果多个键都有元素，则按照从左到右的顺序取第一个键中的一个元素。比如，首先在终端B上调用命令：
127.0.0.1:6379> lpush list1 l1 (integer) 1 127.0.0.1:6379> lpush list2 l2 (integer) 1
然后，在终端A上，调用brpop命令：
127.0.0.1:6379> brpop list2 list1 0 1) "list2" 2) "l2"
可见只返回list2的消息。借此特性可以实现优先级队列，一旦list2中有消息，无论list1中有多少消息，都是首先返回list2的消息。
2：发布和订阅
除了实现任务队列外，Redis还提供了一组命令可以实现“发布/订阅”（publish/subscribe）模式。“发布/订阅”模式也是进程间的消息传递方式，其原理是：“发布/订阅”模式中包含两种角色，分别是发布者和订阅者。订阅者可以订阅一个或若干个频道（channel）,而发布者可以向指定的频道发送消息，所有订阅此频道的订阅者都会收到此消息。
发布者发布消息的命令是publish，用法是publish channel message，比如：
127.0.0.1:6379> publish channel1 hi (integer) 0
这样消息就发出去了。publish命令的返回值表示接收到这条消息的订阅者数量。因为此时没有客户端订阅channel1，所以返回0。发出去的消息不会被持久化，也就是说当有客户端订阅channel1后只能收到后续发布到该频道的消息，之前发送的就收不到了。
订阅频道的命令是subscribe，可以同时订阅多个频道，用法是：subscribe channel [channel ...]。比如在终端A上输入：
127.0.0.1:6379> subscribe channel1 Reading messages... (press Ctrl-C to quit) 1) "subscribe" 2) "channel1" 3) (integer) 1
执行subscribe命令后客户端会进入订阅状态（这里表现为阻塞状态，等待接收消息），进入订阅状态后客户端可收到三种类型的回复。每种类型的回复都包含3个值，第一个值是消息的类型，根据消息类型的不同，第二、三个值的含义也不同。消息类型可能的取值有：
a：subscribe，表示订阅成功的反馈信息。此时，比如上面的例子中，第二个值是订阅成功的频道名称，第三个值是当前客户端订阅的频道数量。
b：message，表示接收到的消息。第二个值表示产生消息的频道名称，第三个值是消息的内容。比如，在另一个终端上，输入：
127.0.0.1:6379> publish channel1 hi (integer) 2
向channel1中发布一个消息”hi”，该命令返回2，表示当前有两个客户端订阅该频道，每个客户端的返回的内容都是：
... 1) "message" 2) "channel1" 3) "hi
c：unsubscribe，表示成功取消订阅某个频道，此时第二个值是对应的频道名称，第三个值是当前客户端订阅的频道数量，当此值为0时，客户端会退出订阅状态。
客户端进入订阅状态之后，就只能执行subscribe/unsubscribe/psubscribe/punsubscribe这4种命令，不能执行“发布/订阅”模式之外的命令。但是在redis-cli中，进入订阅状态后，终端就处于接收消息状态，无法再执行任何命令，因此这种限制应该是针对编程客户端而言的。
使用psubscribe命令，可以指定订阅的规则，规则支持glob风格的通配符格式，比如在终端A中输入：
psubscribe channel.?* Reading messages... (press Ctrl-C to quit) 1) "psubscribe" 2) "channel.?*" 3) (integer) 1
此时，在终端B中执行下列命令：
127.0.0.1:6379> publish channel.1 "this is channel.1" (integer) 1 127.0.0.1:6379> publish channel.10 "this is channel.10" (integer) 1 127.0.0.1:6379> publish channel.1234 "this is channel.1234" (integer) 1
此时，终端A上的输出是：
1) "pmessage" 2) "channel.?*" 3) "channel.1" 4) "this is channel.1" 1) "pmessage" 2) "channel.?*" 3) "channel.10" 4) "this is channel.10" 1) "pmessage" 2) "channel.?*" 3) "channel.1234" 4) "this is channel.1234"
消息的第一个值表示这条消息是通过psubscribe命令订阅频道而收到的，第二个值表示订阅时使用的通配符，第三个值表示实际收到消息的频道，第四个值则是消息内容。
使用psubscribe命令可以重复订阅同一个频道，如某客户端执行了”psubscribe channel.? channel.?*”，这时向channel.2发布消息后该客户端会收到两条消息，而同时publish命令返回的值也是2而不是1。同样的，如果客户端执行了”subscribe channel.10”和”psubscribe channel.?*”的话，向channel.10发送命令该客户端也会收到两条消息（但是是两种类型，message和pmessage）。
punsubscribe命令可以退订指定的规则，用法是” punsubscribe [pattern pattern]”，如果没有参数则会退订所有规则。
注意使用punsubscribe命令只能退订通过psubscribe命令订阅的规则，不会影响通过subscribe命令订阅的频道；同样unsubscribe命令也不会影响通过psubscribe命令订阅的规则。
五：管道
客户端和Redis使用TCP协议连接。不论客户端向Redis发送命令还是Redis向客户端返回命令的执行结果，都需要经过网络传输，在执行多个命令时，即使命令不需要上一条命令的执行结果，每条命令都需要等待上一条命令执行完才能执行。
Redis的底层通信协议对管道提供了支持。通过管道可以一次性发送多条命令，并在执行完后一次性将结果返回，当一组命令中每条命令都不依赖于之前命令的执行结果时，就可以将这组命令一起通过管道发出。管道通过减少客户端与Redis的通信次数来实现降低往返时延的目的。管道在各种编程语言的客户端中都得到了支持。