Python的多線程多進程是什么

# Python的多線程多進程是什么

## 引言

在當今計算密集型應用和IO密集型任務并行的時代，如何充分利用計算機的多核資源成為開發者必須面對的課題。Python作為一門廣泛使用的高級編程語言，提供了多線程（`threading`模塊）和多進程（`multiprocessing`模塊）兩種并發編程范式。本文將深入探討這兩種技術的核心概念、實現原理、適用場景以及實際應用中的陷阱與解決方案。

## 一、并發編程基礎概念

### 1.1 什么是并發與并行

**并發（Concurrency）** 指系統能夠處理多個任務的能力，這些任務在時間上可能交替執行；**并行（Parallelism）** 則是真正意義上的同時執行多個任務，通常需要多核處理器支持。

```python
# 并發示例：單核CPU通過時間片輪轉實現"偽并行"
def task1():
    print("Task 1 running")

def task2():
    print("Task 2 running")

# 交替執行（非真正并行）

1.2 線程與進程的本質區別

二、Python多線程深入解析

2.1 threading模塊核心API

import threading

def worker(num):
    print(f"Worker {num} started")

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

for t in threads:
    t.join()

關鍵對象：

• Thread：線程類
• Lock/RLock：同步鎖
• Event：事件通知
• Condition：條件變量
• Semaphore：信號量

2.2 GIL（全局解釋器鎖）機制詳解

GIL本質：CPython解釋器層面的互斥鎖，防止多線程同時執行Python字節碼。

import sys
print(sys.getswitchinterval())  # 默認線程切換間隔0.005秒

GIL的影響：

• 計算密集型任務：多線程無法利用多核
• IO密集型任務：GIL會在IO操作時釋放

2.3 線程同步實戰

from threading import Lock

counter = 0
lock = Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

# 創建線程
threads = [threading.Thread(target=increment) for _ in range(10)]

常見同步問題：

• 競態條件（Race Condition）
• 死鎖（四個必要條件）
• 活鎖（Livelock）

三、Python多進程全面剖析

3.1 multiprocessing模塊架構

from multiprocessing import Process

def f(name):
    print(f'Hello {name}')

if __name__ == '__main__':
    p = Process(target=f, args=('Bob',))
    p.start()
    p.join()

核心組件：

• Process：進程類
• Queue：進程間通信
• Pipe：雙向通信
• Pool：進程池
• Manager：共享狀態

3.2 進程間通信（IPC）方案對比

3.3 進程池最佳實踐

from multiprocessing import Pool

def square(x):
    return x * x

if __name__ == '__main__':
    with Pool(4) as p:
        results = p.map(square, range(100))
        print(results)

進程池參數調優：

• processes：建議設置為CPU核心數
• maxtasksperchild：防止內存泄漏
• chunksize：大數據批處理優化

四、性能對比與選型指南

4.1 基準測試數據

# 計算密集型任務測試
def compute_intensive(n):
    return sum(i*i for i in range(n))

# IO密集型任務模擬
def io_intensive():
    time.sleep(0.1)

測試結果（4核CPU）：

4.2 決策樹模型

是否需要真正并行？
├─ 否 → threading
│   ├─ 主要是IO操作？ → 直接使用
│   └─ 需要規避GIL？ → 考慮C擴展
└─ 是 → multiprocessing
    ├─ 數據共享頻繁？ → Manager/共享內存
    └─ 獨立任務？ → Pool

五、高級技巧與陷阱規避

5.1 混合使用線程與進程

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def hybrid_approach():
    # CPU密集型使用進程
    with ProcessPoolExecutor() as proc_executor:
        proc_results = list(proc_executor.map(cpu_task, data))
    
    # IO密集型使用線程
    with ThreadPoolExecutor() as thread_executor:
        thread_results = list(thread_executor.map(io_task, proc_results))

5.2 常見陷阱解決方案

1. 僵尸進程處理

import signal
signal.signal(signal.SIGCHLD, signal.SIG_IGN)

1. 線程局部存儲

thread_local = threading.local()
thread_local.value = 42

1. 進程池內存泄漏

Pool(processes=4, maxtasksperchild=100)

六、現代替代方案

6.1 asyncio協程模型

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    tasks = [fetch_data() for _ in range(10)]
    results = await asyncio.gather(*tasks)

6.2 分布式任務隊列

• Celery：成熟的分布式任務系統
• Dask：大數據并行處理
• Ray：計算框架

結語

Python的多線程與多進程各有所長，理解其底層機制才能做出合理選擇。在Python 3.12+版本中，隨著GIL的逐步優化（如PEP 703）和異步IO生態的完善，并發編程的選擇將更加多樣化。建議開發者根據具體場景進行基準測試，同時關注新興技術如結構化并發（PEP 654）的發展。

“并發是關于正確性的，并行才是關于性能的” —— Rob Pike “`

（注：實際文章約4850字，此處為結構化大綱與核心代碼示例。完整文章需擴展各部分說明、添加更多示例和性能分析圖表。）