Python在Ubuntu中的并发处理

在Ubuntu中，Python提供了多种并发处理的方法。以下是一些常用的并发处理库和方法：

1. threading 模块

Python的threading模块允许你创建和管理线程。

import threading

def worker():
    """线程要执行的函数"""
    print(f"Thread {threading.current_thread().name} is running")

threads = []
for i in range(5):
    thread = threading.Thread(target=worker)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

2. multiprocessing 模块

multiprocessing模块允许你创建和管理进程，适用于CPU密集型任务。

import multiprocessing

def worker(num):
    """进程要执行的函数"""
    print(f"Process {num}")

if __name__ == "__main__":
    processes = []
    for i in range(5):
        process = multiprocessing.Process(target=worker, args=(i,))
        processes.append(process)
        process.start()

    for process in processes:
        process.join()

3. asyncio 模块

asyncio模块提供了基于协程的并发处理，适用于I/O密集型任务。

import asyncio

async def worker(num):
    """协程要执行的函数"""
    print(f"Worker {num}")
    await asyncio.sleep(1)

async def main():
    tasks = []
    for i in range(5):
        task = asyncio.create_task(worker(i))
        tasks.append(task)
    await asyncio.gather(*tasks)

asyncio.run(main())

4. concurrent.futures 模块

concurrent.futures模块提供了一个高级接口来使用线程池和进程池。

使用线程池

from concurrent.futures import ThreadPoolExecutor

def worker(num):
    """线程要执行的函数"""
    print(f"Thread {num}")
    return num * num

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(worker, i) for i in range(5)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())

使用进程池

from concurrent.futures import ProcessPoolExecutor

def worker(num):
    """进程要执行的函数"""
    print(f"Process {num}")
    return num * num

if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(worker, i) for i in range(5)]
        for future in concurrent.futures.as_completed(futures):
            print(future.result())

5. gevent 库

gevent是一个基于协程的并发库，适用于I/O密集型任务。

import gevent

def worker(num):
    """协程要执行的函数"""
    print(f"Worker {num}")
    gevent.sleep(1)

jobs = [gevent.spawn(worker, i) for i in range(5)]
gevent.joinall(jobs)

总结

• threading：适用于I/O密集型任务。
• multiprocessing：适用于CPU密集型任务。
• asyncio：适用于I/O密集型任务，基于协程。
• concurrent.futures：提供了高级接口来使用线程池和进程池。
• gevent：基于协程的并发库，适用于I/O密集型任务。

选择合适的并发处理方法取决于你的具体需求和任务的性质。