实现一个多线程任务队列处理模型（生产者、消费者模型）

子竹聆风
310 阅读5分钟

在现代软件开发中，处理异步任务是一个常见的需求，尤其是在数据处理和网络爬虫等领域。本文将介绍如何使用 Python 和 Redis 实现一个多线程任务队列处理模型。这个模型包括生产者部分和消费者部分，能够广泛应用于需要任务队列的各种场景。

环境设置

首先，你需要安装 Python 和 Redis。此外，还需要安装 Python 的 redis 库，可以通过以下命令安装：

pip install redis

Redis 配置

为了本文的示例，我们将使用本地运行的 Redis 服务器。默认情况下，Redis 监听本地机器的 6379 端口。你可以使用以下命令启动 Redis 服务：

redis-server

生产者实现

生产者的职责是生成任务并将它们推送到 Redis 队列中。这里是一个简单的生产者代码实现：

import json
from redis import Redis

# Redis连接配置
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = None  # 根据你的设置可能需要密码
redis_conn = Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, decode_responses=True)

QUEUE_NAME = "task_queue"

def produce_tasks():
    """生成任务并推送到Redis队列"""
    tasks = [
        {"id": 1, "data": "数据1"},
        {"id": 2, "data": "数据2"},
        {"id": 3, "data": "数据3"},
        # 可以根据实际需要添加更多任务
    ]
    for task in tasks:
        redis_conn.lpush(QUEUE_NAME, json.dumps(task))
        print(f"任务已推送到Redis: {task}")

if __name__ == '__main__':
    produce_tasks()

消费者实现

消费者部分从 Redis 中获取任务，并使用多线程来提高任务处理的效率。以下是消费者代码实现：

import json
import logging
import traceback
from concurrent.futures import ThreadPoolExecutor
from redis import Redis

# 配置日志
logging.basicConfig(level=logging.INFO)

# Redis连接配置
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = None  # 根据你的设置可能需要密码
redis_conn = Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, decode_responses=True)

# 常量定义
QUEUE_NAME = "task_queue"
WAITING_TIME = 5
BATCH_SIZE = 10
THREAD_NUM = 5

class TaskQueue:
    """任务队列处理类，负责从Redis获取和回填任务"""

    def get_task(self):
        """从redis队列获取单个任务"""
        task_data = redis_conn.brpop(QUEUE_NAME, timeout=WAITING_TIME)
        if not task_data:
            logging.info("Redis中无任务，等待中...")
            return None
        logging.info(f"从Redis获取任务: {task_data}")
        return json.loads(task_data[1])

    def return_task(self, task):
        """任务处理失败后，将任务回填到Redis"""
        result = redis_conn.lpush(QUEUE_NAME, json.dumps(task, ensure_ascii=False))
        logging.warning(f"任务处理失败，已回填到Redis: {result}")

class Crawler:
    """爬虫执行逻辑，处理具体任务"""

    def process_task(self, task):
        """处理单个任务的爬取流程"""
        logging.info(f"开始处理任务: {task}")
        try:
            # 业务处理逻辑
            pass
        except Exception as e:
            logging.error(f"任务处理异常，异常信息: {str(e)}")
            self.task_queue.return_task(task)

def run():
    task_queue = TaskQueue()
    while True:
        task = task_queue.get_task()
        if task:
            with ThreadPoolExecutor(THREAD_NUM) as executor:
                executor.submit(Crawler().process_task, task)

if __name__ == '__main__':
    run()

结论

通过结合生产者和消费者模型，我们创建了一个完整的任务队列处理系统。这个系统不仅能够生成任务，还能高效地处理它们。这种模型特别适用于需要大规模并行处理的应用场景，例如数据抓取、批量数据处理等。希望本文能帮助你理解并实现基于队列的多线程任务处理系统。

自己实现和用celery、huey有什么区别？

在实现任务队列处理时，自行编写代码与使用成熟的任务队列框架（如 Celery 或 Huey）之间存在几个关键的区别。每种选择都有其特定的应用场景和优缺点。以下是这些选择的一些比较：

自己实现任务队列

优点：

  1. 定制化：可以根据具体的需求定制功能，仅包含必要的部分，避免额外的复杂性。
  2. 学习与控制：深入理解任务队列的工作原理，更好地控制任务的处理流程和错误处理。
  3. 轻量级：没有引入额外的依赖和可能不需要的功能，对系统资源的消耗可能较小。

缺点：

  1. 开发与维护成本：需要投入时间和精力去编写、测试和维护代码。
  2. 功能有限：可能缺乏一些高级功能，如任务调度、结果存储、失败重试机制等。
  3. 稳定性与可靠性：自行实现的解决方案可能不如成熟的框架稳定和可靠，特别是在高并发和大规模数据处理场景下。

使用 Celery

优点：

  1. 功能丰富：Celery 支持多种消息代理（如 RabbitMQ、Redis）、定时任务、任务结果存储、失败重试等高级功能。
  2. 高度可配置：提供广泛的配置选项，可以精细控制任务的行为和系统的性能。
  3. 社区支持：有一个活跃的社区支持，丰富的文档和第三方库，遇到问题时可以容易找到帮助。

缺点：

  1. 学习曲线：功能丰富带来的是更复杂的配置和使用方式，需要一定时间学习。
  2. 资源消耗：作为一个功能丰富的框架，可能会占用更多的系统资源。

使用 Huey

优点：

  1. 简单易用：Huey 设计相对简单，比 Celery 更易于设置和使用，适合小到中等规模的项目。
  2. 灵活性：支持 Redis 和 SQLite 作为消息代理，适用于多种部署环境。
  3. 实时处理：非常适合处理实时任务，延迟低。

缺点：

  1. 功能限制：与 Celery 相比，Huey 的功能较少，可能不支持一些复杂的用例。
  2. 社区和支持：虽然社区活跃，但相比 Celery 较小，遇到复杂问题时可能找不到现成的解决方案。

结论

选择自己实现任务队列还是使用像 Celery 或 Huey 这样的框架，取决于项目的具体需求、团队的技能和可接受的维护成本。对于需要快速实现并具有高度定制需求的小型项目，自行实现可能是一个好的选择。对于需要稳定、可扩展且功能全面的企业级应用，使用成熟的框架如 Celery 将是更加合适的选择。如果项目规模介于两者之间，Huey 可以提供一个不错的平衡点。

avatar
文章
阅读
粉丝