高级功能(Advanced Features)¶

关于线程的说明(A note about threading)¶

Redis 客户端实例可以安全地在多个线程之间共享。在内部，连接实例仅在执行命令时从连接池中获取，并在执行完命令后立即返回到连接池中。命令执行时不会修改客户端实例的状态。

然而，有一个例外情况：Redis 的 SELECT 命令。SELECT 命令允许你切换当前连接使用的数据库。该数据库将保持选中状态，直到选择了另一个数据库或关闭连接。这会导致一个问题，即某些连接可能会返回到连接池中时仍连接到不同的数据库。

因此，redis-py 不在客户端实例上实现 SELECT 命令。如果你在同一个应用程序中使用多个 Redis 数据库，则应该为每个数据库创建一个单独的客户端实例（可能还需要单独的连接池）。

将 PubSub 或 Pipeline 对象在线程之间传递是不安全的。

管道(Pipelines)¶

默认管道(Default pipelines)¶

管道 (Pipelines) 是 Redis 基类的子类，提供了将多个命令缓冲到服务器的单个请求中的支持。通过减少客户端与服务器之间来回发送的 TCP 数据包数量，它们可以显著提高一组命令的执行性能。

使用管道非常简单：

>>> r = redis.Redis(...)
>>> r.set('bing', 'baz')
>>> # 使用 pipeline() 方法创建一个管道实例
>>> pipe = r.pipeline()
>>> # 以下 SET 命令将被缓冲
>>> pipe.set('foo', 'bar')
>>> pipe.get('bing')
>>> # EXECUTE 调用会将所有缓冲的命令发送到服务器，并返回
>>> # 一个响应列表，每个命令对应一个响应。
>>> pipe.execute()
[True, b'baz']

为了便于使用，所有缓冲到管道中的命令都会返回管道对象本身。因此，可以像这样进行链式调用：

>>> pipe.set('foo', 'bar').sadd('faz', 'baz').incr('auto_number').execute()
[True, True, 6]

此外，管道还可以确保缓冲的命令以原子方式作为一个组执行。这是默认行为。如果你想禁用管道的原子性，但仍然希望缓冲命令，可以关闭事务。

>>> pipe = r.pipeline(transaction=False)

一个常见问题是，需要原子事务但需要在事务中使用 Redis 中的值。例如，假设 INCR 命令不存在，我们需要在 Python 中构建一个原子的 INCR。

一个非常天真的实现是 GET 值，在 Python 中递增它，然后将新值 SET 回去。然而，这并不是原子的，因为多个客户端可能同时执行此操作，每个客户端都会从 GET 获取相同的值。

此时可以使用 WATCH 命令。WATCH 允许在启动事务之前监视一个或多个键。如果这些键在事务执行之前发生了变化，则整个事务将被取消，并抛出 WatchError。为了实现我们自己的客户端 INCR 命令，可以这样做：

>>> with r.pipeline() as pipe:
...     while True:
...         try:
...             # 监视持有序列值的键
...             pipe.watch('OUR-SEQUENCE-KEY')
...             # 在 WATCH 后，管道将进入立即执行模式，
...             # 直到我们告诉它再次开始缓冲命令。
...             # 这使我们可以获取序列的当前值
...             current_value = pipe.get('OUR-SEQUENCE-KEY')
...             next_value = int(current_value) + 1
...             # 现在我们可以使用 MULTI 将管道重新置于缓冲模式
...             pipe.multi()
...             pipe.set('OUR-SEQUENCE-KEY', next_value)
...             # 最后，执行管道（SET 命令）
...             pipe.execute()
...             # 如果在执行过程中没有抛出 WatchError，那么
...             # 我们所做的一切都是原子操作。
...             break
...        except WatchError:
...             # 在我们开始 WATCH 和管道执行之间，另一个客户端
...             # 必须更改了 'OUR-SEQUENCE-KEY'。
...             # 我们最好重试。
...             continue

请注意，由于管道在 WATCH 期间必须绑定到单个连接，因此必须小心确保通过调用 reset() 方法将连接返回到连接池。如果管道作为上下文管理器使用（如上例所示），reset() 将自动调用。当然，你也可以通过显式调用 reset() 手动完成此操作：

>>> pipe = r.pipeline()
>>> while True:
...     try:
...         pipe.watch('OUR-SEQUENCE-KEY')
...         ...
...         pipe.execute()
...         break
...     except WatchError:
...         continue
...     finally:
...         pipe.reset()

一个名为 "transaction" 的便捷方法存在，用于处理监视错误的所有样板代码。它接收一个可调用对象，该对象应期望一个管道对象作为参数，并且可以传入任何数量的要监视的键。我们上面的客户端 INCR 命令可以这样重写，代码更易于阅读：

>>> def client_side_incr(pipe):
...     current_value = pipe.get('OUR-SEQUENCE-KEY')
...     next_value = int(current_value) + 1
...     pipe.multi()
...     pipe.set('OUR-SEQUENCE-KEY', next_value)
>>>
>>> r.transaction(client_side_incr, 'OUR-SEQUENCE-KEY')
[True]

请确保在传递给 Redis.transaction 的可调用对象中，在任何写入命令之前调用 pipe.multi()。

集群中的管道(Pipelines in clusters)¶

ClusterPipeline 是 RedisCluster 的一个子类，提供了在集群模式下对 Redis 管道的支持。当调用 execute() 命令时，所有命令都会按照将要执行的节点进行分组，然后由各自的节点并行执行。管道实例将在所有节点响应之前等待，才会将结果返回给调用者。命令响应以列表形式返回，顺序与发送顺序相同。管道可以显著提高 Redis 集群的吞吐量，通过大幅减少客户端与服务器之间的网络往返次数。

>>> with rc.pipeline() as pipe:
...     pipe.set('foo', 'value1')
...     pipe.set('bar', 'value2')
...     pipe.get('foo')
...     pipe.get('bar')
...     print(pipe.execute())
[True, True, b'value1', b'value2']
...     pipe.set('foo1', 'bar1').get('foo1').execute()
[True, b'bar1']

请注意： - RedisCluster 管道目前仅支持基于键的命令。 - 管道从集群的参数中获取 ‘read_from_replicas’ 的值。因此，如果集群实例中启用了从副本读取，则管道也会将读取命令指向副本。 - 在集群模式下，不支持 ‘transaction’ 选项。在非集群模式下，执行管道时可以使用 ‘transaction’ 选项。这将使用 MULTI/EXEC 命令包装管道命令，并有效地将管道命令转换为单个事务块。这意味着所有命令将按顺序执行，而不会受到其他客户端的干扰。然而，在集群模式下，这是不可能的，因为命令根据其各自的目标节点进行分区。这意味着我们无法将管道命令转变为一个事务块，因为在大多数情况下，它们被拆分为多个较小的管道。

高级功能(Advanced Features)¶

关于线程的说明(A note about threading)¶

管道(Pipelines)¶

默认管道(Default pipelines)¶

集群中的管道(Pipelines in clusters)¶

发布/订阅(Publish / Subscribe)¶

共享 pubsub(Sharded pubsub)¶

监控(Monitor)¶