Python 多线程、多进程、协程对迭代数据的耗时操作测试

Python 多线程、多进程、协程对迭代数据的耗时操作测试

2023-03-29

CPU计算密集型：

2.17s/p

Python中的多线程受GIL制约，因此表面上的并行，实际上是并发，完全的计算密集型任务就和串行的耗时差不多了；

Deal	耗时	备注
普通的循环执行	22.68	串行
线程池执行	22.10	并发
进程池执行	6.95	并行
协程执行（多线程）	22.39	并发
协程执行（多进程）	6.67	并行
协程执行（多进程，更直接的方式，无嵌套调用）	6.88	并行
协程执行（多进程，并测试异步迭代器的使用）	7.52	并行

I/O密集型：

1s/p

I/O密集型的任务，表面是并行，实际也可以当做并行看待，基本不受GIL的影响，甚至由于开销少，耗时会更短；

Deal	耗时	备注
普通的循环执行	25.05	串行
线程池执行	5.01	并行
进程池执行	6.12	并行
协程执行（多线程）	5.01	并行
协程执行（多进程）	5.04	并行
协程执行（多进程，更直接的方式，无嵌套调用）	5.04	并行
协程执行（多进程，并测试异步迭代器的使用）	5.03	并行

测试代码

• 引入头文件：

# pip install aiohttp
import nest_asyncio

nest_asyncio.apply()  # PyCharm中 不需要这两句

import time
import asyncio
import concurrent.futures
from multiprocessing import Pool

• 线程/进程池的数量设为5：

POOL_SIZE = 5


def download_file(row):
    # 非协程对象支持（耗时操作模拟）
    #     print(row,'_downloading')
    # I/O密集模拟
    time.sleep(1)
    # 计算密集模拟
    #     total = 0
    #     for i in range(10000000):
    #         total += i
    #         total -= i

    #     print(row,'_downloaded')
    return row


async def download_prepare(row, pool):
    # 协程对象支持（基于线程/进程池包装非协程对象，返回Future对象）
    # 在协程对象中 可以await另一个协程对象 如果要支持非协程对象的方法调用 就需要结合线程/进程池
    loop = asyncio.get_event_loop()
    fut = loop.run_in_executor(pool, download_file, row)
    response = await fut


class Reader(object):
    def __init__(self, datalist, pool=None):
        self.datalist = iter(datalist)
        self.pool = pool

    async def readrow(self):
        try:
            row = next(iter(self.datalist))
            # 创建task 需要传入一个协程对象（对应要执行的方法）
            task = asyncio.create_task(download_prepare(row, self.pool))
            # 返回一个可等待对象（这里是Task）
            return task
        except StopIteration:
            return None

    def __aiter__(self):
        return self

    async def __anext__(self):
        val = await self.readrow()
        if val == None:
            raise StopAsyncIteration
        return val


# 普通的循环执行
def main(datalist):
    for row in datalist:
        download_file(row)


# 线程池执行
def main1(datalist):
    threadpool = concurrent.futures.ThreadPoolExecutor(POOL_SIZE)
    for row in datalist:
        # 注意在等待时，与主线程无关，主线程依然在继续执行。
        threadpool.submit(download_file, row)
    threadpool.shutdown(True)  # 等待线程池中的任务执行完毕后，在继续执行


# 进程池执行
def main2(datalist):
    pool = Pool(POOL_SIZE)
    pool.map(download_file, datalist)
    pool.close()  # 关闭进程池，不再接受新的进程
    pool.join()  # 主进程阻塞等待子进程的退出


#  协程执行（多线程）
def main3(datalist):
    with concurrent.futures.ThreadPoolExecutor(max_workers=POOL_SIZE) as pool:
        tasks = [asyncio.create_task(download_prepare(row, pool)) for row in datalist]

        loop = asyncio.get_event_loop()
        loop.run_until_complete(asyncio.wait(tasks))


#  协程执行（多进程）
def main4(datalist):
    with concurrent.futures.ProcessPoolExecutor(max_workers=POOL_SIZE) as pool:
        tasks = [asyncio.create_task(download_prepare(row, pool)) for row in datalist]

        loop = asyncio.get_event_loop()
        loop.run_until_complete(asyncio.wait(tasks))


#  协程执行（多进程，更直接的方式，无嵌套调用）
def main5(datalist):
    loop = asyncio.get_running_loop()
    with concurrent.futures.ProcessPoolExecutor(max_workers=POOL_SIZE) as pool:
        futs = []
        for row in datalist:
            futs.append(loop.run_in_executor(pool, download_file, row))

        done_s, pending_s = asyncio.run(asyncio.wait(futs))

#         print(done_s, pending_s)


#  协程执行（多进程，并测试异步迭代器的使用）
async def main6(datalist):
    with concurrent.futures.ProcessPoolExecutor(max_workers=POOL_SIZE) as pool:
        obj_t = Reader(datalist, pool)
        tasks = []
        async for task in obj_t:
            tasks.append(task)

        done_s, pending_s = await asyncio.wait(tasks)


#         print(done_s, pending_s)

• 迭代25个数据，分别测试计算密集型、I/O密集型任务在不同场景下的耗时：

if __name__ == "__main__":

    print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
    t1 = time.time()
    datalist = [
        "0_0_0_0_353",
        "1_1_0_0_353",
        "2_2_0_0_353",
        "3_4_0_0_353",
        "4_5_0_0_353",
        "0_0_0_0_353",
        "1_1_0_0_353",
        "2_2_0_0_353",
        "3_4_0_0_353",
        "4_5_0_0_353",
        "0_0_0_0_353",
        "1_1_0_0_353",
        "2_2_0_0_353",
        "3_4_0_0_353",
        "4_5_0_0_353",
        "0_0_0_0_353",
        "1_1_0_0_353",
        "2_2_0_0_353",
        "3_4_0_0_353",
        "4_5_0_0_353",
        "0_0_0_0_353",
        "1_1_0_0_353",
        "2_2_0_0_353",
        "3_4_0_0_353",
        "4_5_0_0_353",
    ]

    main(datalist)  # 10s
    print("串行：普通的循环执行——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    main1(datalist)  # 6s
    print("并发：线程池执行——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    main2(datalist)  # 6s
    print("并行：进程池执行——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    main3(datalist)  # 6s
    print("并发：协程执行（多线程）——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    main4(datalist)  # 6s
    print("并行：协程执行（多进程）——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    main5(datalist)  # 6s
    print("并行：协程执行（多进程，更直接的方式，无嵌套调用） ——执行时间：", float(time.time() - t1), "秒")
    t1 = time.time()
    asyncio.run(main6(datalist))  # 6s
    print("并行：协程执行（多进程，并测试异步迭代器的使用）  ——执行时间：", float(time.time() - t1), "秒")
    print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))