Python在Ubuntu中如何进行并发处理

聊到Python在Ubuntu下的并发处理，其实有不少路子可以走。选哪种，主要看你的任务到底“卡”在哪儿——是CPU算不过来，还是I/O等得心焦。下面把这几种主流方案拆开看看。

1. 多线程（Threading）

Python的threading模块是用起来最直接的方式之一，适合I/O密集型的操作。这里有个关键点：由于GIL（全局解释器锁）的存在，多线程在CPU密集型任务上其实帮不上什么忙。不过用在文件读写、网络请求这类场景，效果就很不错。

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）

要是任务真吃CPU，那就得上multiprocessing。它通过创建独立的进程来绕过GIL的限制，每个进程都有自己的Python解释器和内存空间，多核利用率直接拉满。当然，代价就是进程间的通信和数据共享会稍微复杂一些。

import multiprocessing

def worker():
    """进程要执行的函数"""
    print(f"Process {multiprocessing.current_process().name} is running")

processes = []
for i in range(5):
    process = multiprocessing.Process(target=worker)
    processes.append(process)
    process.start()

for process in processes:
    process.join()

3. 异步编程（Asyncio）

说到I/O密集型任务，asyncio算是Python 3时代比较“现代”的解法了。它基于协程，用一个单线程就能处理海量并发连接，资源开销极低。异步代码写起来和同步代码很像，但底层却是非阻塞的，这个对比很有意思。

import asyncio

async def worker():
    """异步函数"""
    print("Worker is running")
    await asyncio.sleep(1)
    print("Worker is done")

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

asyncio.run(main())

4. 并发库（Concurrent.futures）

如果你不想自己管理线程或进程的创建销毁细节，concurrent.futures这个高层接口会是个不错的选择。它同时提供了线程池和进程池的抽象，用起来非常统一。

线程池

from concurrent.futures import ThreadPoolExecutor

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

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(worker) for _ in range(5)]
    for future in concurrent.futures.as_completed(futures):
        pass

进程池

from concurrent.futures import ProcessPoolExecutor

def worker():
    """进程要执行的函数"""
    print(f"Process {multiprocessing.current_process().name} is running")

with ProcessPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(worker) for _ in range(5)]
    for future in concurrent.futures.as_completed(futures):
        pass

5. 第三方库

标准库之外，gevent和eventlet也是绕不开的名字。它们本质上也是协程方案，但通过monkey-patching的方式把同步的I/O操作异步化，用起来几乎零学习成本。

使用gevent

import gevent

def worker():
    """协程函数"""
    print(f"Worker {gevent.getcurrent()} is running")
    gevent.sleep(1)
    print(f"Worker {gevent.getcurrent()} is done")

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

总结

选哪条路，归根结底看瓶颈在哪：

• I/O密集型任务，asyncio和gevent是优解。
• CPU密集型任务，multiprocessing是正解。
• 想要代码写起来简单一点，concurrent.futures可以直接拿来当工具箱。

在Ubuntu上，Python标准库已经把这套东西备齐了，直接import就能用，省心得很。