3.1 基本概念

并行(Parallelism)：
指多個任務真正同時執行，需要多核CPU支持。就像餐廳有多個廚師同時做不同的菜。

# 并行示例（假設4核CPU）
from multiprocessing import Pooldef task(n):return n * nif __name__ == '__main__':with Pool(4) as p:  # 創建4個進程print(p.map(task, [1, 2, 3, 4]))  # 4個任務真正同時執行

并發(Concurrency)：
指多個任務交替執行，在單核CPU上通過快速切換實現"看似同時"。就像一個廚師輪流做多道菜。

# 并發示例
from multiprocessing import Process
import timedef task(name):print(f"{name}開始")time.sleep(1)print(f"{name}結束")if __name__ == '__main__':processes = []for i in range(3):  # 單核CPU上交替執行p = Process(target=task, args=(f"任務{i}",))p.start()processes.append(p)for p in processes:p.join()

3.2 關鍵區別

3.3 Python中的實現特點

• GIL限制：由于全局解釋器鎖(GIL)，Python多線程無法實現真正的并行，多進程是Python實現并行的主要方式

• 進程開銷：進程創建和上下文切換開銷比線程大，適合CPU密集型任務

• multiprocessing模塊：繞過GIL限制，充分利用多核CPU

4. 同步/異步與阻塞/非阻塞

4.1 進程的三種基本狀態

4.2 同步 vs 異步

同步（Synchronous）：

• 像排隊買奶茶，必須等前一個人完成才能輪到你

• 代碼示例：

from multiprocessing import Process, Lockdef sync_task(lock, num):with lock:  # 同步鎖print(f"進程{num}開始工作")time.sleep(1)print(f"進程{num}結束")if __name__ == '__main__':lock = Lock()for i in range(3):Process(target=sync_task, args=(lock, i)).start()

異步（Asynchronous）：

• 像取號等餐，拿到號后可以去做其他事

• 代碼示例：

from multiprocessing import Pooldef async_task(num):print(f"開始異步任務{num}")time.sleep(1)return num * 10if __name__ == '__main__':with Pool(3) as p:results = [p.apply_async(async_task, (i,)) for i in range(3)]for res in results:print(res.get())  # 需要時才獲取結果

4.3 阻塞 vs 非阻塞

阻塞（Blocking）：

• 像打電話訂餐，必須等客服回應才能做下一件事

• 典型表現：join(),?get()等方法會阻塞

p = Process(target=time.sleep, args=(5,))
p.start()
p.join()  # 這里主程序會阻塞等待
print("子進程結束")

非阻塞（Non-blocking）：

• 像發短信訂餐，發完就可以做其他事

• 典型表現：不調用join()或使用Queue的nowait

processes = []
for i in range(3):p = Process(target=time.sleep, args=(i,))p.start()processes.append(p)# 主進程繼續執行其他代碼...
print("主進程繼續運行")# 最后再統一等待
for p in processes:p.join()

4.4 四種組合模式（重點理解）

1. 同步阻塞：

   • 最傳統的方式

   • 示例：直接函數調用，等待返回結果

   result = time.sleep(3)  # 同步調用，阻塞等待

2. 同步非阻塞：

   • 輪詢檢查狀態

   • 示例：檢查進程是否完成

   while True:if not p.is_alive():breaktime.sleep(0.1)

3. 異步阻塞：

   • 較少使用

   • 示例：使用回調但主線程等待

   def callback(result):print("回調結果:", result)with Pool() as pool:res = pool.apply_async(func, args, callback=callback)res.wait()  # 這里又變成了阻塞

4. 異步非阻塞：

   • 最高效的方式

   • 示例：使用進程池+回調

   def callback(result):print("Got result:", result)with Pool() as pool:for i in range(5):pool.apply_async(func=time.sleep,args=(1,),callback=callback)print("主進程繼續執行...")pool.close()pool.join()

4.5 實際應用場景建議

4.6??完整代碼示例（綜合應用）

"""
多進程模式下載器示例
演示并行、異步非阻塞模式
"""
from multiprocessing import Pool
import time
import randomdef download(url):print(f"開始下載 {url}")time.sleep(random.uniform(1, 3))  # 模擬下載時間print(f"完成下載 {url}")return f"{url}_內容"def save_content(result):print(f"保存結果: {result}")if __name__ == '__main__':urls = ["http://example.com/1","http://example.com/2","http://example.com/3","http://example.com/4"]with Pool(4) as pool:  # 創建進程池# 異步非阻塞模式提交任務results = [pool.apply_async(download, (url,), callback=save_content) for url in urls]print("主進程可以繼續處理其他任務...")# 最終等待所有任務完成pool.close()pool.join()print("所有下載任務完成!")

這個示例展示了：

1. 并行執行（4個下載任務同時進行）

2. 異步非阻塞模式（提交任務后立即繼續執行）

3. 回調機制（下載完成后自動保存）

5. Python中的進程操作

Python通過multiprocessing模塊實現多進程編程，下面介紹幾種創建進程的方式。

5.1 方式一：使用Process類直接創建

from multiprocessing import Process
import osdef func(num):print(f"這是一個普通方法{num}")print(f"我是子進程，我的pid：{os.getpid()}，我的父進程編號：{os.getppid()}")if __name__ == '__main__':# 創建進程對象p1 = Process(name="路飛", target=func, args=(1,))# 啟動進程p1.start()# 輸出父進程信息print(f"我是父進程，我的pid：{os.getpid()}，我的父進程編號：{os.getppid()}")print(p1)

代碼解析：

1. 導入Process類和os模塊

2. 定義目標函數func，它將在子進程中執行

3. 創建Process實例，指定目標函數和參數

4. 調用start()方法啟動進程

5. os.getpid()獲取當前進程ID，os.getppid()獲取父進程ID

5.2 方式二：繼承Process類創建

from multiprocessing import Process
import osclass MyProcess(Process):def __init__(self, *args):super(MyProcess, self).__init__()self.args = argsdef run(self):print(f"我是子進程{self.args[0]}")if __name__ == '__main__':p1 = MyProcess(1)p2 = MyProcess(2)p3 = MyProcess(3)p1.start()p2.start()p3.start()

代碼解析：

1. 自定義類繼承Process類

2. 重寫run()方法，定義進程執行邏輯

3. 創建自定義類的實例并啟動

4. 這種方式更面向對象，適合復雜任務

5.3 進程常用方法

from multiprocessing import Process
import timedef fun():print("我是子進程")for i in range(3):time.sleep(5)print(f"我是子進程{i}")if __name__ == '__main__':p1 = Process(name='路飛', target=fun)p1.start()p1.join()  # 父進程等待子進程結束for i in range(2):time.sleep(1)print(f"我是父進程{i}")

關鍵方法：

• p.start()：啟動進程，并調用該子進程中的p.run()

• ?p.run ()： 進程啟動時運行的方法，正是它去調用target 指定的函數，我們自定義類的類中一定要實現該方法

• p.join([timeout])：主線程等待p終止（強調：是主線程處于等的狀態，而p是處于運行的狀態）。

  timeout 是可選的超時時間，需要強調的是， p.join 只能 join 住 start 開啟的進程，而不能 join 住 run 開啟的進程

• p.is_alive()：如果p仍然運行，返回True

• p.terminate()：強制終止進程p，不會進行任何清理操作，如果p創建了子進程，該子進程就成了僵尸進 程。使用該方法需要特別小心這種情況。如果p還保存了一個鎖那么也將不會被釋放，進而導致死鎖

5.4 進程常用屬性

from multiprocessing import Process
import timedef fun():for i in range(10):time.sleep(1)print("我是子進程")if __name__ == '__main__':p = Process(target=fun)p.daemon = True  # 設置為守護進程p.start()time.sleep(5)print("我是父進程")

重要屬性：

• daemon：默認值為False，如果設為True，代表p為后臺運行的守護進程，當p的父進程終止時， p也隨之終止，并且設定為True后，p不能創建自己的新進程，必須在p.start()之前設置

  守護進程：跟隨著父進程的代碼執行結束，守護進程就結束

• name：進程名稱

• pid：進程ID

• exitcode：進程在運行時為None、如果為–N，表示被信號N結束(了解即可)

6. 進程同步與通信

6.1 進程間數據隔離

from multiprocessing import Processdef work():global nn = 0print('子進程內: ', n)if __name__ == '__main__':n = 100p = Process(target=work)p.start()print('主進程內: ', n)

輸出結果：

主進程內: 100
子進程內: 0

解釋：進程間內存空間獨立，修改子進程中的變量不會影響父進程。

7. 實際應用建議

1. CPU密集型任務：適合使用多進程，可以充分利用多核CPU

2. I/O密集型任務：多線程可能更合適，避免進程創建開銷

3. 守護進程：用于執行后臺任務，如日志記錄、監控等

4. 進程池：當需要創建大量進程時，考慮使用Pool類

8. 注意事項

1. Windows平臺必須使用if __name__ == '__main__':保護主代碼

2. 進程創建和銷毀開銷較大，不宜創建過多進程

3. 進程間通信需要使用隊列(Queue)或管道(Pipe)等機制

4. 避免僵尸進程(子進程結束但父進程未回收資源)