目錄
- 一、什么是進程
- 二、什么是線程
- 三、并發(fā)、并行
- 四、多線程適用場景
- 五、Python GIL
- 六、Python多線程、多進程實例:CPU 密集型任務
- 七、Python多線程、多進程實例:IO密集型任務
- 7.1 單線程
- 7.2 多線程
- 7.3 多進程
- 7.4 協程
- 八、總結
一、什么是進程
- 進程是執(zhí)行中的程序,是資源分配的最小單位:操作系統(tǒng)以進程為單位分配存儲空間,進程擁有獨立地址空間、內存、數據棧等
- 操作系統(tǒng)管理所有進程的執(zhí)行,分配資源
- 可以通過fork或 spawn的方式派生新進程,新進程也有自己獨立的內存空間
- 進程間通信方式(IPC,Inter-Process Communication)共享信息,實現數據共享,包括管道、信號、套接字、共享內存區(qū)等。
二、什么是線程
- 線程是CPU調度的的最小單位
- 一個進程可以有多個線程
- 同進程下執(zhí)行,并共享相同的上下文
- 線程間的信息共享和通信更加容易
- 多線程并發(fā)執(zhí)行
- 需要同步原語
三、并發(fā)、并行
并發(fā)通常應用于 I/O 操作頻繁的場景,并行則更多應用于 CPU heavy 的場景。
3.1 并發(fā)
并發(fā)(concurrency),指同一時刻只能有一條指令執(zhí)行,多個線程的對應的指令被快速輪換地執(zhí)行,線程/任務之間會互相切換。
- 處理器先執(zhí)行線程 A 的指令一段時間,再執(zhí)行線程 B 的指令一段時間,再切回到線程 A,快速輪換地執(zhí)行。
- 處理器切換過程中會進行上下文的切換操作,進行多個線程之間切換和執(zhí)行,這個切換過程非??欤沟迷诤暧^上看起來多個線程在同時運行。
- 每個線程的執(zhí)行會占用這個處理器一個時間片段,同一時刻,其實只有一個線程在執(zhí)行。
3.2 并行
并行(parallel) 指同一時刻,有多條指令在多個處理器上同時執(zhí)行
- 不論是從宏觀上還是微觀上,多個線程都是在同一時刻一起執(zhí)行的。
- 并行只能在多處理器系統(tǒng)中存在,如果只有一個核就不可能實現并行。并發(fā)在單處理器和多處理器系統(tǒng)中都是可以存在的,一個核就可以實現并發(fā)。
注意:具體是并發(fā)還是并行取決于操作系統(tǒng)的調度。
四、多線程適用場景
多線程/多進程是解決并發(fā)問題的經典模型之一。
在一個程序進程中,有一些操作是比較耗時或者需要等待的,比如等待數據庫的查詢結果的返回,等待網頁結果的響應。這個線程在等待的過程中,處理器是可以執(zhí)行其他的操作的,從而從整體上提高執(zhí)行效率。
比如網絡爬蟲,在向服務器發(fā)起請求之后,有一段時間必須要等待服務器的響應返回,這種任務屬于 IO 密集型任務。對于這種任務,啟用多線程可以在某個線程等待的過程中去處理其他的任務,從而提高整體的爬取效率。
還有一種任務叫作計算密集型任務,或者稱為CPU 密集型任務。任務的運行一直需要處理器的參與。如果使用多線程,一個處理器從一個計算密集型任務切換到另一個計算密集型任務,處理器依然不會停下來,并不會節(jié)省總體的時間,如果線程數目過多,進程上下文切換會占用大量的資源,整體效率會變低。
所以,如果任務不全是計算密集型任務,我們可以使用多線程來提高程序整體的執(zhí)行效率。尤其對于網絡爬蟲這種 IO 密集型任務來說,使用多線程會大大提高程序整體的爬取效率,多線程只適合IO 密集型任務。
五、Python GIL
由于 Python 中 GIL 的限制,導致不論是在單核還是多核條件下,在同一時刻只能運行一個線程,導致 Python 多線程無法發(fā)揮多核并行的優(yōu)勢。
GIL 全稱為 Global Interpreter Lock(全局解釋器鎖),是 Python 解釋器 CPython 中的一個技術術語,是Python之父為了數據安全而設計的。
CPython 使用引用計數來管理內存,所有 Python 腳本中創(chuàng)建的實例,都會有一個引用計數,來記錄有多少個指針指向它。當引用計數只有 0 時,則會自動釋放內存。每隔一段時間,Python 解釋器就會強制當前線程去釋放 GIL,Python 3 以后版本的間隔時間是 15 毫秒。
在 Python 多線程下,每個線程輪流執(zhí)行:
- 獲取 GIL
- 執(zhí)行對應線程的代碼
- 釋放 GIL
某個線程想要執(zhí)行,必須先拿到 GIL,并且在一個 Python 進程中,GIL 只有一個,導致即使在多核的條件下,同一時刻也只能執(zhí)行一個線程。每一個線程執(zhí)行完一段后,會釋放 GIL,以允許別的線程開始利用資源。
六、Python多線程、多進程實例:CPU 密集型任務
6.1 單線程
執(zhí)行一個CPU 密集型任務:
import time
import os
def cpu_bound_task(n):
print('當前進程: {}'.format(os.getpid()))
while n > 0:
n -= 1
if __name__ == "__main__":
print('主進程: {}'.format(os.getpid()))
start = time.time()
for i in range(2):
cpu_bound_task(100000000)
end = time.time()
print(f"耗時{end - start}秒")
輸出:
主進程: 10104
當前進程: 10104
當前進程: 10104
耗時10.829032897949219秒
6.2 多線程
import os
import threading
import time
def cpu_bound_task(n,i):
print(f'子線程 {threading.current_thread().name}:{os.getpid()} - 任務{i}')
while n > 0:
n -= 1
if __name__=='__main__':
start = time.time()
print(f'主線程: {os.getpid()}')
thread_list = []
for i in range(1, 3):
t = threading.Thread(target=cpu_bound_task, args=(100000000,i))
thread_list.append(t)
for t in thread_list:
t.start()
for t in thread_list:
t.join()
end = time.time()
print(f"耗時{end - start}秒")
- start():啟動線程
- join():等待子線程結束后主程序才退出,便于計算所有進程執(zhí)行時間。
輸出:
主線程: 1196
子線程 Thread-1:1196 - 任務1
子線程 Thread-2:1196 - 任務2
耗時10.808091640472412秒
可以發(fā)現多線程對CPU 密集型任務性能沒有提升效果。
6.3 多進程
from multiprocessing import Process
import os
import time
def cpu_bound_task(n,i):
print(f'子進程: {os.getpid()} - 任務{i}')
while n > 0:
n -= 1
if __name__=='__main__':
print(f'父進程: {os.getpid()}')
start = time.time()
p1 = Process(target=cpu_bound_task, args=(100000000,1))
p2 = Process(target=cpu_bound_task, args=(100000000,2))
p1.start()
p2.start()
p1.join()
p2.join()
end = time.time()
print(f"耗時{end - start}秒")
輸出:
父進程: 22636
子進程: 18072 - 任務1
子進程: 9580 - 任務2
耗時6.264241933822632秒
也可以使用Pool類創(chuàng)建多進程
from multiprocessing import Pool, cpu_count
import os
import time
def cpu_bound_task(n,i):
print(f'子進程: {os.getpid()} - 任務{i}')
while n > 0:
n -= 1
if __name__=='__main__':
print(f"CPU內核數:{cpu_count()}")
print(f'父進程: {os.getpid()}')
start = time.time()
p = Pool(4)
for i in range(2):
p.apply_async(cpu_bound_task, args=(100000000,i))
p.close()
p.join()
end = time.time()
print(f"耗時{end - start}秒")
輸出:
CPU內核數:8
父進程: 18616
子進程: 21452 - 任務0
子進程: 16712 - 任務1
耗時5.928101301193237秒
七、Python多線程、多進程實例:IO密集型任務
7.1 單線程
IO 密集型任務:
def io_bound_task(self, n, i):
print(f'子進程: {os.getpid()} - 任務{i}')
print(f'IO Task{i} start')
time.sleep(n)
print(f'IO Task{i} end')
if __name__=='__main__':
print('主進程: {}'.format(os.getpid()))
start = time.time()
for i in range(2):
self.io_bound_task(4,i)
end = time.time()
print(f"耗時{end - start}秒")
輸出:
主進程: 2780
子進程: 2780 - 任務0
IO Task0 start
IO Task0 end
子進程: 2780 - 任務1
IO Task1 start
IO Task1 end
耗時8.04494023323059秒
7.2 多線程
print(f"CPU內核數:{cpu_count()}")
print(f'父進程: {os.getpid()}')
start = time.time()
p = Pool(2)
for i in range(2):
p.apply_async(io_bound_task, args=(4, i))
p.close()
p.join()
end = time.time()
print(f"耗時{end - start}秒")
輸出:
CPU內核數:8
父進程: 1396
子進程: 2712 - 任務0
IO Task0 start
子進程: 10492 - 任務1
IO Task1 start
IO Task0 endIO Task1 end
耗時4.201171398162842秒
可以看出對于IO密集型任務,Python多線程具有顯著提升。
7.3 多進程
print(f'父進程: {os.getpid()}')
start = time.time()
p1 = Process(target=io_bound_task, args=(4, 1))
p2 = Process(target=io_bound_task, args=(4, 2))
p1.start()
p2.start()
p1.join()
p2.join()
end = time.time()
print("耗時{}秒".format((end - start)))
輸出:
父進程: 12328
子進程: 12452 - 任務2
IO Task2 start
子進程: 16896 - 任務1
IO Task1 start
IO Task1 endIO Task2
end
耗時4.1241302490234375秒
7.4 協程
IO型任務還可以使用協程,協程比線程更加輕量級,一個線程可以擁有多個協程,協程在用戶態(tài)執(zhí)行,完全由程序控制。一般來說,線程數量越多,協程性能的優(yōu)勢越明顯。這里就不介紹Python協程了,下面Python代碼是協程的其中一種實現方式:
import asyncio
import time
async def io_bound_task(self,n,i):
print(f'子進程: {os.getpid()} - 任務{i}')
print(f'IO Task{i} start')
# time.sleep(n)
await asyncio.sleep(n)
print(f'IO Task{i} end')
if __name__ == '__main__':
start = time.time()
loop = asyncio.get_event_loop()
tasks = [io_bound_task(4, i) for i in range(2)]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
end = time.time()
print(f"耗時{end - start}秒")
輸出:
子進程: 5436 - 任務1
IO Task1 start
子進程: 5436 - 任務0
IO Task0 start
IO Task1 end
IO Task0 end
耗時4.008626461029053秒
八、總結
Python 由于GIL鎖的存在,無法利用多進程的優(yōu)勢,要真正利用多核,可以重寫一個不帶GIL的解釋器, 比如JPython(Java 實現的 Python 解釋器)。
某些Python 庫使用C語言實現,例如 NumPy 庫不受 GIL 的影響。在實際工作中,如果對性能要求很高,可以使用C++ 實現,然后再提供 Python 的調用接口。另外Java語言也沒有GIL限制。
對于多線程任務,如果線程數量很多,建議使用Python協程,執(zhí)行效率比多線程高。
到此這篇關于Python多線程與多進程相關知識總結的文章就介紹到這了,更多相關Python多線程與多進程內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!
您可能感興趣的文章:- Python多進程的使用詳情
- python實現多進程并發(fā)控制Semaphore與互斥鎖LOCK
- python 多進程和多線程使用詳解
- python 實現多進程日志輪轉ConcurrentLogHandler
- Python 多進程原理及實現
- python多進程基礎詳解