Python 并發(fā)編程是指在 Python 中編寫能夠同時執(zhí)行多個任務(wù)的程序。并發(fā)編程在任何一門語言當(dāng)中都是比較難的，因為會涉及各種各樣的問題，在Python當(dāng)中也不例外。Python 提供了多種方式來實現(xiàn)并發(fā)，包括多線程（threading）、多進(jìn)程（multiprocessing）、異步編程（asyncio），以及一些高級用法concurrent.futures和第三方庫如gevent。

多線程 (Threading)

多線程是通過使用 threading 模塊來創(chuàng)建和管理線程。線程是輕量級的過程，可以與同一進(jìn)程中的其他線程共享數(shù)據(jù)和資源。然而，由于 Python 的全局解釋器鎖（GIL）的存在，如果用的解釋器是CPython的話，那么多線程在 CPU 密集型任務(wù)上不會有性能提升的，但是IO密集型的是會有的。

import threading
import time

def worker(num):
    print(f"Worker {num} starting")
    time.sleep(2)
    print(f"Worker {num} finished")

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

# Wait for all threads to complete
for t in threads:
    t.join()
print("All workers finished.")

上面的例子中，通過threading模塊中的Thread啟動了另一個線程，輸出中首先出現(xiàn)的是每個線程的啟動消息，如 "Worker 0 starting"，然后是 "Worker 1 starting" 等等。
接下來是每個線程的完成消息，如 "Worker 0 finished"。由于線程的執(zhí)行順序不是固定的，因此實際輸出中的線程完成順序可能會有所不同。

全局解釋器鎖（GIL）是歷史歷史遺留下來的問題，在Python3.13可能會得到解決。

多進(jìn)程 (Multiprocessing)

多進(jìn)程則可以通過使用 multiprocessing 模塊來創(chuàng)建獨立的進(jìn)程。每個進(jìn)程都有自己的內(nèi)存空間，因此可以繞過 GIL，適用于 CPU 密集型任務(wù)。

from multiprocessing import Process
import time

def worker(num):
    print(f"Worker {num} starting")
    time.sleep(2)
    print(f"Worker {num} finished")

processes = []
for i in range(5):
    p = Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

# Wait for all processes to complete
for p in processes:
    p.join()
print("All workers finished.")

多進(jìn)程與多線程示例類似，但這里是在不同的進(jìn)程中執(zhí)行。通過multiprocessing模塊中的Process啟動了另一個進(jìn)程，每個進(jìn)程開始和完成的消息按順序出現(xiàn)。由于進(jìn)程之間沒有共享內(nèi)存，每個進(jìn)程都在獨立的環(huán)境中運行，因此輸出中的完成順序與啟動順序相同。

異步編程 (Asyncio)

Python 3.4 引入了 asyncio 模塊，它是一個用于編寫單線程并發(fā)代碼的模塊，使用 async 和 await 關(guān)鍵字。異步編程允許你編寫并發(fā)代碼，以非阻塞的方式運行。這非常適合 I/O 密集型任務(wù)，如網(wǎng)絡(luò)請求、文件操作等。

import asyncio

async def worker(num):
    print(f"Worker {num} starting")
    await asyncio.sleep(2)
    print(f"Worker {num} finished")

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

asyncio.run(main())
print("All workers finished.")

由于協(xié)程是基于事件循環(huán)的，因此輸出中的完成順序可能與啟動順序不同。異步編程也是python并發(fā)編程中比較重要的一個概念，后面很大篇幅都要圍繞這個異步編程來展開的。

使用 concurrent.futures

concurrent.futures 提供了一個高層次的接口來處理并行執(zhí)行的任務(wù)，實際上就是線程池或者進(jìn)程池的玩意，這個池的概念就是線程或者進(jìn)程用完不銷毀，重復(fù)利用，具體后面展開說說。

示例

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time

def worker(num):
    print(f"Worker {num} starting")
    time.sleep(2)
    return f"Worker {num} finished"

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

for future in futures:
    print(future.result())

print("All workers finished.")

首先，創(chuàng)建了一個最大容納 5 個工作線程的線程池。然后，提交了 5 個 worker 任務(wù)到線程池中，并立即返回了 5 個 Future 對象。接著，程序遍歷這些 Future 對象，等待每個任務(wù)完成，并打印它們的返回值。最后，打印所有工作線程已經(jīng)完成的消息。不過還是那個問題，由于 Python 的全局解釋器鎖（GIL），在 CPU 密集型任務(wù)中，線程池并不會帶來性能上的提升。

以上這些方法都可以根據(jù)你的具體需求來選擇使用。如果你需要進(jìn)行更多的細(xì)節(jié)控制或者有特定的性能要求，你還可以考慮使用更底層的 API 或者第三方庫。

到此這篇關(guān)于Python并發(fā)編程的幾種實現(xiàn)方式的文章就介紹到這了,更多相關(guān)Python并發(fā)編程的實現(xiàn)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論