亚洲欧美制服综合另类,婷婷久久综合九色国产成人,日韩欧美亚洲国产精品字幕久久久

主頁 > 知識庫 > Python多線程與多進程相關知識總結

Python多線程與多進程相關知識總結

一、什么是進程

進程是執行中的程序，是資源分配的最小單位：操作系統以進程為單位分配存儲空間，進程擁有獨立地址空間、內存、數據棧等
操作系統管理所有進程的執行，分配資源
可以通過fork或 spawn的方式派生新進程，新進程也有自己獨立的內存空間
進程間通信方式（IPC，Inter-Process Communication）共享信息，實現數據共享，包括管道、信號、套接字、共享內存區等。

二、什么是線程

線程是CPU調度的的最小單位
一個進程可以有多個線程
同進程下執行，并共享相同的上下文
線程間的信息共享和通信更加容易
多線程并發執行
需要同步原語

三、并發、并行

并發通常應用于 I/O 操作頻繁的場景，并行則更多應用于 CPU heavy 的場景。

3.1 并發

并發(concurrency)，指同一時刻只能有一條指令執行，多個線程的對應的指令被快速輪換地執行，線程/任務之間會互相切換。

處理器先執行線程 A 的指令一段時間，再執行線程 B 的指令一段時間，再切回到線程 A，快速輪換地執行。
處理器切換過程中會進行上下文的切換操作，進行多個線程之間切換和執行，這個切換過程非常快，使得在宏觀上看起來多個線程在同時運行。
每個線程的執行會占用這個處理器一個時間片段，同一時刻，其實只有一個線程在執行。

3.2 并行

并行(parallel) 指同一時刻，有多條指令在多個處理器上同時執行

不論是從宏觀上還是微觀上，多個線程都是在同一時刻一起執行的。
并行只能在多處理器系統中存在，如果只有一個核就不可能實現并行。并發在單處理器和多處理器系統中都是可以存在的，一個核就可以實現并發。

注意：具體是并發還是并行取決于操作系統的調度。

四、多線程適用場景

多線程/多進程是解決并發問題的經典模型之一。

在一個程序進程中，有一些操作是比較耗時或者需要等待的，比如等待數據庫的查詢結果的返回，等待網頁結果的響應。這個線程在等待的過程中，處理器是可以執行其他的操作的，從而從整體上提高執行效率。

比如網絡爬蟲，在向服務器發起請求之后，有一段時間必須要等待服務器的響應返回，這種任務屬于 IO 密集型任務。對于這種任務，啟用多線程可以在某個線程等待的過程中去處理其他的任務，從而提高整體的爬取效率。

還有一種任務叫作計算密集型任務，或者稱為CPU 密集型任務。任務的運行一直需要處理器的參與。如果使用多線程，一個處理器從一個計算密集型任務切換到另一個計算密集型任務，處理器依然不會停下來，并不會節省總體的時間，如果線程數目過多，進程上下文切換會占用大量的資源，整體效率會變低。

所以，如果任務不全是計算密集型任務，我們可以使用多線程來提高程序整體的執行效率。尤其對于網絡爬蟲這種 IO 密集型任務來說，使用多線程會大大提高程序整體的爬取效率，多線程只適合IO 密集型任務。

五、Python GIL

由于 Python 中 GIL 的限制，導致不論是在單核還是多核條件下，在同一時刻只能運行一個線程，導致 Python 多線程無法發揮多核并行的優勢。

GIL 全稱為 Global Interpreter Lock（全局解釋器鎖)，是 Python 解釋器 CPython 中的一個技術術語，是Python之父為了數據安全而設計的。

CPython 使用引用計數來管理內存，所有 Python 腳本中創建的實例，都會有一個引用計數，來記錄有多少個指針指向它。當引用計數只有 0 時，則會自動釋放內存。每隔一段時間，Python 解釋器就會強制當前線程去釋放 GIL，Python 3 以后版本的間隔時間是 15 毫秒。

在 Python 多線程下，每個線程輪流執行：

獲取 GIL
執行對應線程的代碼
釋放 GIL

某個線程想要執行，必須先拿到 GIL，并且在一個 Python 進程中，GIL 只有一個，導致即使在多核的條件下，同一時刻也只能執行一個線程。每一個線程執行完一段后，會釋放 GIL，以允許別的線程開始利用資源。

六、Python多線程、多進程實例：CPU 密集型任務

6.1 單線程

執行一個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()：等待子線程結束后主程序才退出，便于計算所有進程執行時間。

輸出：

主線程: 1196
子線程 Thread-1:1196 - 任務1
子線程 Thread-2:1196 - 任務2
耗時10.808091640472412秒

可以發現多線程對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類創建多進程

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型任務還可以使用協程，協程比線程更加輕量級，一個線程可以擁有多個協程，協程在用戶態執行，完全由程序控制。一般來說，線程數量越多，協程性能的優勢越明顯。這里就不介紹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}秒")

輸出：