python 多进程和协程配合使用

博客围绕读取3个各含30万行记录的txt文件展开,需求是判断文件中的key是否在redis或mysql数据仓库中,将空记录写入日志文件。任务分工采用多进程读取单个文件、协程批量读取记录,还给出了完整代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、需求分析

有一批key已经写入到3个txt文件中,每一个txt文件有30万行记录。
现在需要读取这些txt文件,判断key是否在数据仓库中。(redis或者mysql)

为空的记录,需要写入到日志文件中!

任务分工

1. 使用多进程技术,每一个进程读取一个txt文件

2. 使用协程技术,批量读取txt文件记录。比如一次性读取 2000条记录

注意:打开文件操作,最好在一个进程中,重复打开文件,会造成系统资源浪费!

二、完整代码

#!/usr/bin/env python3
# coding: utf-8
"""
多线程和协程配合使用示例
"""

import os
import time
from gevent import monkey;monkey.patch_all()
from gevent.pool import Pool
from functools import partial
from multiprocessing import Process

COROUTINE_NUMBER = 2000  # 协程池数量
pool = Pool(COROUTINE_NUMBER)  # 使用协程池

# 模拟数据仓库,测试数据
data_dict = {"1":"x1","3":"x3","5":"x5","7":"x7","9":"x9"}

class TestProgram(object):  # 测试程序
    def __init__(self):
        self.BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # 项目根目录

    def write_log(self,number, content, colour='white', skip=False):
        """
        写入日志文件
        :param content: 写入内容
        :param colour: 颜色
        :param skip: 是否跳过打印时间
        :return:
        """
        # 颜色代码
        colour_dict = {
            'red': 31,  # 红色
            'green': 32,  # 绿色
            'yellow': 33,  # 黄色
            'blue': 34,  # 蓝色
            'purple_red': 35,  # 紫红色
            'bluish_blue': 36,  # 浅蓝色
            'white': 37,  # 白色
        }
        choice = colour_dict.get(colour)  # 选择颜色

        path = os.path.join(self.BASE_DIR, "output_%s.log" % number)  # 日志文件
        with open(path, mode='a+', encoding='utf-8') as f:
            if skip is False:  # 不跳过打印时间时
                content = time.strftime('%Y-%m-%d %H:%M:%S') + ' ' + content

            info = "\033[1;{};1m{}\033[0m".format(choice, content)
            print(info)
            f.write(content + "\n")

    def has_null(self, key, number):
        """
        输出key
        :param key: 键值
        :param number: 文件标记
        :return: bool
        """
        key = key.strip()
        if not data_dict.get(key):
            self.write_log(number,"错误,{} 记录为空".format(key),"red")
            return False

        print(key)
        return True

    def read_file(self, number):
        """
        读取文件
        :param number: 文件标记
        :return:
        """
        file_name = os.path.join(self.BASE_DIR, "data", "%s.txt" % number)
        # print(file_name)
        self.write_log(number, "开始读取文件 {}".format(file_name),"green")
        with open(file_name, encoding='utf-8') as f:
            # 使用协程池,执行任务。语法: pool.map(func,iterator)
            # partial使用偏函数传递参数
            # 注意:has_null第一个参数,必须是迭代器遍历的值
            pool.map(partial(self.has_null, number=number), f)

        self.write_log(number, "结束文件读取 {} 完成".format(file_name),"green")
        return True

    def run(self, number):
        """
        读取指定的文件,判断每一个key是否为空
        :param number:
        :return:
        """
        startime = time.time()  # 开始时间

        # 清空日志
        path = os.path.join(self.BASE_DIR, "output_%s.log" % number)  # 日志文件
        with open(path, mode='w') as f:
            pass

        self.read_file(number)

        endtime = time.time()
        take_time = endtime - startime

        if take_time < 1:  # 判断不足1秒时
            take_time = 1  # 设置为1秒
        # 计算花费时间
        m, s = divmod(take_time, 60)
        h, m = divmod(m, 60)

        self.write_log(number, "%s.txt 花费时间 %02d:%02d:%02d" % (number,h, m, s),"green")

    def main(self):
        """
        使用多线程执行程序
        :return:
        """
        # 文件标记列表
        file_list = ["7001", "7002", "7003"]

        p_lst = []  # 线程列表
        for i in file_list:
            # self.run(i)
            p = Process(target=self.run, args=(i,))  # 子进程调用函数
            p.start()  # 启动子进程
            p_lst.append(p)  # 将所有进程写入列表中

        for p in p_lst: p.join()  # 检测p是否结束,如果没有结束就阻塞直到结束,否则不阻塞


TestProgram().main()  # 启动主程序,它会开启3个进程。
View Code

执行输出:

### Python 中线程、进程协程的概念及用法 #### 一、概念区分 在 Python 编程中,线程、进程协程是三种不同的并发模型。 1. **进程 (Process)** 进程是指操作系统分配资源的一个独立单位。每个进程都有自己的内存空间其他资源。Python 提供了 `multiprocessing` 模块来支持多进程编程[^3]。通过创建多个进程,可以利用多核 CPU 的优势,从而提升程序性能。 2. **线程 (Thread)** 线程是进程中更细粒度的执行单元,属于同一进程下的线程共享相同的内存空间。Python 使用 `threading` 模块来处理线程操作[^4]。尽管线程间的切换开销较小,但由于全局解释器锁(GIL),Python 的 CPython 解释器在同一时刻只允许一个线程运行真正的计算密集型任务。 3. **协程 (Coroutine)** 协程是一种轻量级的线程替代方案,它由程序员手动控制其调度逻辑。Python 原生支持协程,可以通过 `asyncio` `yield` 实现异步编程[^1]。相比线程,协程不需要频繁上下文切换,因此更加高效。 --- #### 二、具体用法 1. **进程使用** 利用 `multiprocessing.Process` 创建子进程,并通过队列或管道等方式实现进程间通信。 ```python from multiprocessing import Process, Queue def worker(queue): queue.put("Data processed by child process") if __name__ == "__main__": q = Queue() p = Process(target=worker, args=(q,)) p.start() result = q.get() # 获取子进程传递的数据 print(result) p.join() ``` 2. **线程的使用** 使用 `threading.Thread` 来启动新线程,通常配合锁或其他同步工具解决竞争条件问题。 ```python import threading lock = threading.Lock() def increment_counter(): global counter with lock: for _ in range(100000): counter += 1 counter = 0 t1 = threading.Thread(target=increment_counter) t2 = threading.Thread(target=increment_counter) t1.start(); t2.start() t1.join(); t2.join() print(f"Final Counter Value: {counter}") ``` 3. **协程使用** 结合 `async/await` 关键字编写异步函数,在 I/O 密集型场景下表现尤为出色。 ```python import asyncio async def fetch_data(): await asyncio.sleep(1) # 模拟网络请求延迟 return {"data": "Fetched data"} async def main(): task = asyncio.create_task(fetch_data()) response = await task print(response) asyncio.run(main()) ``` --- #### 三、适用场景分析 1. **进程适合的任务** 当需要充分利用多核处理器的能力或者避免 GIL 对多线程的影响时,应优先考虑使用多进程。例如图像处理、科学计算等领域。 2. **线程适合的任务** 如果应用程序涉及大量阻塞调用(如文件读写、数据库查询等),则可以选择基于线程的方式减少等待时间。不过需要注意的是,由于 GIL 存在,纯计算类工作在线程环境下可能不会带来显著加速效果。 3. **协程适合的任务** 面向高并发需求且主要是 IO-bound 类型的工作流时,推荐采用协程技术。比如 Web 应用服务器端开发、爬虫设计等方面均能体现良好适应性。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值