Redis中RPOP、BRPOP、LPOP和BLPOP使用示例代码

更新时间：2026年05月08日 10:37:52 作者：AI浩

这篇文章主要介绍了Redis中RPOP、BRPOP、LPOP和BLPOP使用的相关资料,解释了列表的方向,并详细说明了每个命令的功能、返回值、使用场景,文中通过代码介绍的非常详细,需要的朋友可以参考下

核心概念：列表的方向

在深入命令之前，必须明确 Redis 列表的“方向”概念：

头部 (Left/Head): 列表的起始端。
尾部 (Right/Tail): 列表的结束端。

想象一个列表 ["A", "B", "C"]：

头部是 "A"。
尾部是 "C"。

1.RPOP: 从尾部弹出 (非阻塞)

命令：RPOP key

功能：移除并返回列表 key 的最后一个元素（即尾部元素）。

阻塞：否。这是一个立即返回的命令。

返回值：

如果列表存在且非空：返回被弹出的元素。
如果列表不存在或为空：返回 nil。

使用场景：当你需要一个简单的栈 (Stack) 数据结构时（后进先出，LIFO）。

示例：

# 创建一个列表
127.0.0.1:6379> RPUSH mylist "A" "B" "C"
(integer) 3

# 查看列表内容
127.0.0.1:6379> LRANGE mylist 0 -1
1) "A"
2) "B"
3) "C"

# 执行 RPOP，弹出尾部元素 "C"
127.0.0.1:6379> RPOP mylist
"C"

# 再次查看，"C" 已被移除
127.0.0.1:6379> LRANGE mylist 0 -1
1) "A"
2) "B"

# 再次 RPOP，弹出 "B"
127.0.0.1:6379> RPOP mylist
"B"

# 列表为空时，返回 nil
127.0.0.1:6379> RPOP mylist
(nil)

2.BRPOP: 从尾部弹出 (阻塞)

命令：BRPOP key [key ...] timeout

功能：RPOP 的阻塞版本。它会移除并返回列表的最后一个元素。如果所有给定的列表都为空，它会阻塞连接，直到有元素可用或超时。

阻塞：是。这是其核心特性。

返回值：

成功弹出：返回一个包含两个元素的数组 [key, value]。
超时：返回 nil。

使用场景：实现消费者，用于任务队列或消息队列，避免轮询。

示例：

终端 A (消费者):

# 尝试从 mylist 弹出元素，最多阻塞 5 秒
127.0.0.1:6379> BRPOP mylist 5
(等待中...)

终端 B (生产者):

# 向 mylist 推送一个新元素
127.0.0.1:6379> LPUSH mylist "New Task"
(integer) 1

终端 A (消费者):

# 立即收到响应
1) "mylist"      # 元素来自哪个键
2) "New Task"    # 被弹出的元素值

超时示例:

# 5秒内没有任何元素被推入
127.0.0.1:6379> BRPOP emptylist 5
(nil)
(5.04s)

3.LPOP: 从头部弹出 (非阻塞)

命令：LPOP key

功能：移除并返回列表 key 的第一个元素（即头部元素）。

阻塞：否。

返回值：

如果列表存在且非空：返回被弹出的元素。
如果列表不存在或为空：返回 nil。

使用场景：与 RPOP 相反，如果你将列表用作栈，并希望从另一端操作。

示例：

# 使用之前的列表 ["A", "B"]
127.0.0.1:6379> LRANGE mylist 0 -1
1) "A"
2) "B"

# 执行 LPOP，弹出头部元素 "A"
127.0.0.1:6379> LPOP mylist
"A"

# 列表现在只剩下 ["B"]
127.0.0.1:6379> LRANGE mylist 0 -1
1) "B"

4.BLPOP: 从头部弹出 (阻塞)

命令：BLPOP key [key ...] timeout

功能：LPOP 的阻塞版本。它会移除并返回列表的第一个元素。如果所有给定的列表都为空，它会阻塞连接，直到有元素可用或超时。

阻塞：是。

返回值：

成功弹出：返回一个包含两个元素的数组 [key, value]。
超时：返回 nil。

使用场景：这是最常用的队列消费模式。配合 RPUSH（从尾部推入），可以完美实现先进先出 (FIFO) 的队列。

示例 (FIFO 队列)：

生产者:

# 依次将任务推入队列尾部
127.0.0.1:6379> RPUSH task_queue "Task-1"
(integer) 1
127.0.0.1:6379> RPUSH task_queue "Task-2"
(integer) 2

消费者:

# 从队列头部阻塞式地获取任务
127.0.0.1:6379> BLPOP task_queue 0
1) "task_queue"
2) "Task-1"  # 最先推入的任务最先被消费

# 再次执行，获取下一个任务
127.0.0.1:6379> BLPOP task_queue 0
1) "task_queue"
2) "Task-2"

Python代码示例

首先，请确保你已经安装了 redis 库：

pip install redis

1. 基础设置

我们先创建一个 Redis 连接，并定义一个辅助函数来清理测试用的 key。

import redis
import time
import threading

# 创建 Redis 连接
r = redis.Redis(host='localhost', port=6379, decode_responses=True)

def cleanup_keys(*keys):
    """清理测试用的 keys"""
    r.delete(*keys)

2.RPOP和LPOP示例 (非阻塞)

这两个命令会立即返回结果，无论列表是否为空。

# 清理环境
cleanup_keys('test_list')

# 向列表中添加元素
r.rpush('test_list', 'A', 'B', 'C')
print("初始列表:", r.lrange('test_list', 0, -1))  # ['A', 'B', 'C']

# LPOP: 从头部弹出
head_element = r.lpop('test_list')
print("LPOP 弹出:", head_element)  # A
print("LPOP 后列表:", r.lrange('test_list', 0, -1))  # ['B', 'C']

# RPOP: 从尾部弹出
tail_element = r.rpop('test_list')
print("RPOP 弹出:", tail_element)  # C
print("RPOP 后列表:", r.lrange('test_list', 0, -1))  # ['B']

# 对空列表操作
empty_lpop = r.lpop('empty_list')
empty_rpop = r.rpop('empty_list')
print("空列表 LPOP:", empty_lpop)  # None
print("空列表 RPOP:", empty_rpop)  # None

输出:

初始列表: ['A', 'B', 'C']
LPOP 弹出: A
LPOP 后列表: ['B', 'C']
RPOP 弹出: C
RPOP 后列表: ['B']
空列表 LPOP: None
空列表 RPOP: None

3.BLPOP示例 (阻塞式队列消费者)

BLPOP 是实现 FIFO（先进先出）队列的标准方式。生产者使用 RPUSH，消费者使用 BLPOP。

# 清理环境
cleanup_keys('task_queue')

def producer():
    """模拟生产者，每隔2秒推送一个任务"""
    for i in range(3):
        task = f"Task-{i+1}"
        r.rpush('task_queue', task)
        print(f"[生产者] 推送任务: {task}")
        time.sleep(2)

def blpop_consumer():
    """BLPOP 消费者，阻塞等待任务"""
    print("[BLPOP消费者] 开始等待任务...")
    while True:
        # 阻塞等待，超时时间设为5秒
        result = r.blpop('task_queue', timeout=5)
        if result is None:
            print("[BLPOP消费者] 超时，没有收到新任务，退出。")
            break
        key, value = result
        print(f"[BLPOP消费者] 处理任务: {value} (来自 {key})")

# 启动生产者线程
producer_thread = threading.Thread(target=producer)
producer_thread.start()

# 运行消费者
blpop_consumer()

# 等待生产者线程结束
producer_thread.join()

输出:

[BLPOP消费者] 开始等待任务...[生产者] 推送任务: Task-1

[BLPOP消费者] 处理任务: Task-1 (来自 task_queue)
[生产者] 推送任务: Task-2
[BLPOP消费者] 处理任务: Task-2 (来自 task_queue)
[生产者] 推送任务: Task-3[BLPOP消费者] 处理任务: Task-3 (来自 task_queue)

[BLPOP消费者] 超时，没有收到新任务，退出。

4.BRPOP示例 (阻塞式栈或反向队列)

BRPOP 通常与 LPUSH 配合，也可以实现 FIFO 队列，但更常用于实现 LIFO（后进先出）的栈。

# 清理环境
cleanup_keys('stack')

def brpop_consumer():
    """BRPOP 消费者，模拟一个栈的弹出操作"""
    print("[BRPOP消费者] 开始从栈中弹出元素...")
    # 先手动压入一些元素
    r.lpush('stack', 'X', 'Y', 'Z')  # 栈: ['Z', 'Y', 'X'] (Z 在顶部/尾部)
    print("当前栈内容:", r.lrange('stack', 0, -1))

    # 弹出3次
    for _ in range(3):
        result = r.brpop('stack', timeout=1)
        if result:
            key, value = result
            print(f"[BRPOP消费者] 弹出: {value}")
    
    # 尝试在空栈上弹出，会超时
    result = r.brpop('stack', timeout=2)
    print("[BRPOP消费者] 空栈弹出结果:", result)  # None

brpop_consumer()

输出:

[BRPOP消费者] 开始从栈中弹出元素...
当前栈内容: ['Z', 'Y', 'X']
[BRPOP消费者] 弹出: X
[BRPOP消费者] 弹出: Y
[BRPOP消费者] 弹出: Z
[BRPOP消费者] 空栈弹出结果: None

5.BLPOP/BRPOP监听多个列表 (优先级队列)

这是阻塞命令的一个强大特性，可以用于实现简单的优先级队列。

# 清理环境
cleanup_keys('high_priority', 'low_priority')

def multi_list_producer():
    """向高优先级和低优先级队列推送任务"""
    time.sleep(1)  # 稍等一下，让消费者先启动
    r.rpush('low_priority', 'Low-Priority-Task')
    print("[生产者] 推送低优先级任务")
    time.sleep(1)
    r.rpush('high_priority', 'High-Priority-Task')
    print("[生产者] 推送高优先级任务")

def priority_consumer():
    """消费者优先监听高优先级队列"""
    print("[优先级消费者] 启动，优先监听: high_priority, low_priority")
    # BLPOP 会按顺序检查列表
    for _ in range(2):
        result = r.blpop(['high_priority', 'low_priority'], timeout=5)
        if result:
            key, value = result
            print(f"[优先级消费者] 处理任务: {value} (来自 {key})")

# 启动生产者线程
prod_thread = threading.Thread(target=multi_list_producer)
prod_thread.start()

# 运行消费者
priority_consumer()

prod_thread.join()

输出:

[优先级消费者] 启动，优先监听: high_priority, low_priority
[生产者] 推送低优先级任务
[优先级消费者] 处理任务: Low-Priority-Task (来自 low_priority)
[生产者] 推送高优先级任务
[优先级消费者] 处理任务: High-Priority-Task (来自 high_priority)

总结对比表

命令	功能	弹出方向	阻塞	典型用途
`RPOP`	移除并返回最后一个元素	尾部 (Right)	否	栈 (LIFO)
`BRPOP`	阻塞式移除并返回最后一个元素	尾部 (Right)	是	消费者（配合 `LPUSH` 实现 FIFO）
`LPOP`	移除并返回第一个元素	头部 (Left)	否	栈 (LIFO) (另一端)
`BLPOP`	阻塞式移除并返回第一个元素	头部 (Left)	是	标准队列消费者 (FIFO) (配合 `RPUSH`)

关键记忆点：

L 开头的命令操作头部。
R 开头的命令操作尾部。
B 开头的命令是阻塞版本。
标准 FIFO 队列 = RPUSH (生产者) + BLPOP (消费者)。

到此这篇关于Redis中RPOP、BRPOP、LPOP和BLPOP使用示例代码的文章就介绍到这了,更多相关Redis中RPOP、BRPOP、LPOP和BLPOP内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Redis缓存空间优化实践详解
缓存Redis，是我们最常用的服务，其适用场景广泛，被大量应用到各业务场景中。也正因如此，缓存成为了重要的硬件成本来源，我们有必要从空间上做一些优化，降低成本的同时也会提高性能，本文通过代码示例介绍了redis如何优化缓存空间，需要的朋友可以参考一下
2023-04-04
Redis设置key的过期时间
本文主要介绍了Redis设置key的过期时间，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-01-01
Redis中的配置与优化过程
本文系统介绍了Redis作为非关系型数据库的特点,包括其高性能、多数据类型支持、内存与持久化机制,对比了RDB与AOF的优缺点及配置方式,最后讲解了内存优化策略与性能管理方法
2025-10-10
利用Redis统计网站在线活跃用户的方法
Redis支持对String类型的value进行基于二进制位的置位操作。通过将一个用户的id对应value上的一位，通过对活跃用户对应的位进行置位，就能够用一个value记录所有活跃用户的信息。下面这篇文章主要介绍了利用Redis统计网站在线活跃用户的方法，需要的朋友可以参考。
2017-01-01
Redis Lua脚本的使用教程
在Redis的学习中,Lua脚本是一项强大的高级特性,它允许用户在Redis中执行复杂的操作,本文就来介绍一下Redis Lua,脚本的使用教程,感兴趣的可以了解一下
2024-03-03
关于redis状态监控和性能调优详解
Redis是一种高级key-value数据库。它跟memcached类似，不过数据可以持久化，而且支持的数据类型很丰富。有字符串，链表、哈希、集合和有序集合5种。下面这篇文章主要给大家介绍了关于redis状态监控和性能调优的相关资料，需要的朋友可以参考下。
2017-09-09
解密Redis助力双11背后电商秒杀系统(推荐)
这篇文章主要介绍了解密Redis助力双11背后电商秒杀系统,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-10-10
缓存击穿中逻辑过期和单纯互斥锁的区别及说明
本文介绍了两种缓存过期策略：逻辑过期加互斥锁和单纯互斥锁,逻辑过期加互斥锁解决了缓存击穿问题,避免了大量请求同时更新数据库,单纯互斥锁在缓存过期后会删除缓存并等待锁释放,逻辑过期更适合对实时性要求不高的场景,而单纯互斥锁则适用于对实时性要求高的场景
2026-02-02
Redis cluster集群模式的原理解析
这篇文章主要介绍了Redis cluster集群模式的原理解析，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-04-04
SpringBoot整合Redis入门之缓存数据的方法
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API，下面通过本文给大家介绍下SpringBoot整合Redis入门之缓存数据的相关知识，感兴趣的朋友一起看看吧
2021-11-11