吃透Redis系列（三）：Redis管道，发布/订阅，事物，过期时间 详细介绍

本文主要是介绍吃透Redis系列（三）：Redis管道，发布/订阅，事物，过期时间 详细介绍，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Redis系列文章：

吃透Redis系列（一）：Linux下Redis安装

吃透Redis系列（二）：Redis六大数据类型详细用法

吃透Redis系列（三）：Redis管道，发布/订阅，事物，过期时间 详细介绍

吃透Redis系列（四）：布隆（bloom）过滤器详细介绍

吃透Redis系列（五）：RDB和AOF持久化详细介绍

吃透Redis系列（六）：主从复制详细介绍

吃透Redis系列（七）：哨兵机制详细介绍

吃透Redis系列（八）：集群详细介绍

吃透Redis系列（九）：Redis代理twemproxy和predixy详细介绍

吃透Redis系列（十）：Redis内存模型详细介绍

吃透Redis系列（十一）：Jedis和Lettuce客户端详细介绍

Redis 管道

请求/响应协议和RTT

Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务。

这意味着通常情况下一个请求会遵循以下步骤：

• 客户端向服务端发送一个查询请求，并监听Socket返回，通常是以阻塞模式，等待服务端响应。
• 服务端处理命令，并将结果返回给客户端。

因此，例如下面是4个命令序列执行情况：

• Client: INCR X
• Server: 1
• Client: INCR X
• Server: 2
• Client: INCR X
• Server: 3
• Client: INCR X
• Server: 4

客户端和服务器通过网络进行连接。这个连接可以很快（loopback接口）或很慢（建立了一个多次跳转的网络连接）。无论网络延如何延时，数据包总是能从客户端到达服务器，并从服务器返回数据回复客户端。

这个时间被称之为 RTT (Round Trip Time - 往返时间). 当客户端需要在一个批处理中执行多次请求时很容易看到这是如何影响性能的（例如添加许多元素到同一个list，或者用很多Keys填充数据库）。例如，如果RTT时间是250毫秒（在一个很慢的连接下），即使服务器每秒能处理100k的请求数，我们每秒最多也只能处理4个请求。

如果采用loopback接口，RTT就短得多（比如我的主机ping 127.0.0.1只需要44毫秒），但它任然是一笔很多的开销在一次批量写入操作中。

幸运的是有一种方法可以改善这种情况。

Redis 管道（Pipelining）

一次请求/响应服务器能实现处理新的请求即使旧的请求还未被响应。这样就可以将多个命令发送到服务器，而不用等待回复，最后在一个步骤中读取该答复。

这就是管道（pipelining），是一种几十年来广泛使用的技术。例如许多POP3协议已经实现支持这个功能，大大加快了从服务器下载新邮件的过程。

Redis很早就支持管道（pipelining）技术，因此无论你运行的是什么版本，你都可以使用管道（pipelining）操作Redis。

下面是一个使用的例子：

1，开启redis服务端

service redis_6379 start

2，用nc与服务端建立连接，并发送多个指令

echo -e "set k1 99\n incr k1\n get k1" | nc localhost 6379

回车输出：

• 第一条命令set k1 99 输出ok
• 第二条命令incr k1 k1值+1输出100
• 第三条命令get k1 查询k1的值输出100

$3的意思是100这个宽度是3。

\n 是linux中的还行符号，window中的还行符号是：\r\n

重要说明: 使用管道发送命令时，服务器将被迫回复一个队列答复，占用很多内存。所以，如果你需要发送大量的命令，最好是把他们按照合理数量分批次的处理，例如10K的命令，读回复，然后再发送另一个10k的命令，等等。这样速度几乎是相同的，但是在回复这10k命令队列需要非常大量的内存用来组织返回数据内容。

Redis 发布订阅

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

Redis 客户端可以订阅任意数量的频道。

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

实例

以下实例演示了发布订阅是如何工作的，需要开启三个 redis-cli 客户端。

1，开启两个redis-cli并订阅bo通道

2，再开启一个客户端用于发布消息：apple

3，可以看到两个客户端都收到了另外一个客户端发布的消息：apple

应用场景

微信聊天记录：

• 实时性的数据通过发布/订阅来实现
• 三天之内的聊天记录放在redis的sorted_set有序列表里面，以时间作为分值，来排序
• 更久的数据肯定是要放到mysql数据库里面了

上面实例我们想一下，当我通过发布/订阅收到一个客户端发送来的消息时，我们要调一下sorted_set去存储，又要调一下数据库去存储，那么我现在不想调用，有没有更好的方式呢？当然有：

我们把sorted_set拆分出来一个redis，通过订阅实时redis来实现通知，数据库微服务也要订阅当前redis来达到通知的效果就可以了。

Redis 事物

MULTI 、 EXEC 、 DISCARD 和 WATCH 是 Redis 事务相关的命令。事务可以一次执行多个命令， 并且带有以下两个重要的保证：

• 事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
• 事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。

EXEC 命令负责触发并执行事务中的所有命令：

• 如果客户端在使用 MULTI 开启了一个事务之后，却因为断线而没有成功执行 EXEC ，那么事务中的所有命令都不会被执行。
• 另一方面，如果客户端成功在开启事务之后执行 EXEC ，那么事务中的所有命令都会被执行。

用法

MULTI 命令用于开启一个事务，它总是返回 OK 。 MULTI 执行之后， 客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当 EXEC命令被调用时， 所有队列中的命令才会被执行。

另一方面， 通过调用 DISCARD ， 客户端可以清空事务队列， 并放弃执行事务。

1，开启client1，设置k1的值bo，并开启事物，然后输入查询命令get k1

127.0.0.1:6379> set k1 bo
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> 

2，开启client2，开启事物，并删除k1，并执行事物

127.0.0.1:6379> multi
OK
127.0.0.1:6379> del k1
QUEUED
127.0.0.1:6379> exec
1) (integer) 1
127.0.0.1:6379> 

此时删除k1成功

3，执行client1中的事物

127.0.0.1:6379> exec
1) (nil)
127.0.0.1:6379>

发现此时key1已经被删除了！

注意：Redis是单进程，单线程，单实例的，所以谁的exec先到，就先执行谁的事物！

事物中的错误

使用事务时可能会遇上以下两种错误：

• 事务在执行 EXEC 之前，入队的命令可能会出错。比如说，命令可能会产生语法错误（参数数量错误，参数名错误，等等），或者其他更严重的错误，比如内存不足（如果服务器使用 maxmemory 设置了最大内存限制的话）。
• 命令可能在 EXEC 调用之后失败。举个例子，事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面，诸如此类。

对于发生在 EXEC 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回 QUEUED ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。不过，从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用 EXEC 命令时，拒绝执行并自动放弃这个事务。

至于那些在 EXEC 命令执行之后所产生的错误， 并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。

为什么 Redis 事物不支持回滚（roll back）

如果你有使用关系式数据库的经验， 那么 “Redis 在事务失败时不进行回滚，而是继续执行余下的命令”这种做法可能会让你觉得有点奇怪。

以下是这种做法的优点：

• Redis 命令只会因为错误的语法而失败（并且这些问题不能在入队时发现），或是命令用在了错误类型的键上面：这也就是说，从实用性的角度来说，失败的命令是由编程错误造成的，而这些错误应该在开发的过程中被发现，而不应该出现在生产环境中。
• 因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。

有种观点认为 Redis 处理事务的做法会产生 bug ， 然而需要注意的是， 在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过 INCR 命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了 INCR ， 回滚是没有办法处理这些情况的。

放弃事物

当执行 DISCARD 命令时， 事务会被放弃， 事务队列会被清空， 并且客户端会从事务状态中退出：

127.0.0.1:6379> multi
OK
127.0.0.1:6379> discard
OK
127.0.0.1:6379> 

使用 check-and-set 操作实现乐观锁

WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。

被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 EXEC 执行之前被修改了， 那么整个事务都会被取消， EXEC 返回nil-reply来表示事务已经失败。

1，client1 设置k1为1，然后开启事物，k1值+1

127.0.0.1:6379> set k1 1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1
QUEUED

2，client2 watch k1然后开启事物，获取k1的值

127.0.0.1:6379> watch k1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> get k1
QUEUED

3，client1 执行事物，查询一下k1的值

127.0.0.1:6379> set k1 1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1
QUEUED
127.0.0.1:6379> exec
1) (integer) 2
127.0.0.1:6379> get k1
"2"

4，client2执行事物

127.0.0.1:6379> watch k1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> exec
(nil)

可见，当client2执行事物时，由于被watch住的k1已经被client1加1，所以导致client2在执行事物时获取k1的值时会返回(nil)，证明不会执行此事物。

Redis Key过期时间

通常Redis keys创建时没有设置相关过期时间。他们会一直存在，除非使用显示的命令移除，例如，使用DEL命令。

EXPIRE一类命令能关联到一个有额外内存开销的key。当key执行过期操作时，Redis会确保按照规定时间删除他们。

key的过期时间和永久有效性可以通过EXPIRE和PERSIST命令（或者其他相关命令）来进行更新或者删除过期时间。

• redis的过期时间不会随着访问而延长。
• 发生写会剔除过期时间。

redis设置过期时间

1. set key value ex seconds
2. expire key seconds

redis清除过期时间

Redis keys过期有两种方式：被动和主动方式。

当一些客户端尝试访问它时，key会被发现并主动的过期。

当然，这样是不够的，因为有些过期的keys，永远不会访问他们。 无论如何，这些keys应该过期，所以定时随机测试设置keys的过期时间。所有这些过期的keys将会从密钥空间删除。

具体就是Redis每秒10次做的事情：

1. 测试随机的20个keys进行相关过期检测。
2. 删除所有已经过期的keys。
3. 如果有多于25%的keys过期，重复步奏1.

这是一个平凡的概率算法，基本上的假设是，我们的样本是这个密钥控件，并且我们不断重复过期检测，直到过期的keys的百分百低于25%,这意味着，在任何给定的时刻，最多会清除1/4的过期keys。

目的是稍微牺牲了一些内存，但是保证了redis高性能！

这篇关于吃透Redis系列（三）：Redis管道，发布/订阅，事物，过期时间 详细介绍的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---