多進程與多線程Python時間

Question

我有2個簡單的函數（在一定范圍內循環），可以不依賴任何關系獨立運行。.我正在嘗試同時使用Python多處理模塊和多線程模塊來運行這2個函數。

當我比較輸出時，我看到多進程應用程序比多線程模塊多1秒鍾。

我讀多線程因為全局解釋器鎖而沒那么高效......

基於以上陳述 -
1.如果兩個進程之間沒有依賴性，最好使用多重處理嗎？
2.如何計算可以在我的機器上運行以最大化效率的進程/線程數。
3.另外，有沒有一種方法可以通過使用多線程來計算程序的效率...

多線程模塊......

from multiprocessing import Process

import thread
import platform

import os
import time
import threading
class Thread1(threading.Thread):
    def __init__(self,threadindicator):
        threading.Thread.__init__(self)
        self.threadind = threadindicator

    def run(self):
        starttime = time.time() 
        if self.threadind == 'A':
            process1()
        else:
            process2()
        endtime = time.time()
        print 'Thread 1 complete : Time Taken = ', endtime - starttime

def process1():
    starttime = time.time() 
    for i in range(100000):
        for j in range(10000):
            pass        
    endtime = time.time() 

def process2():
    for i in range(1000):
        for j in range(1000):
            pass

def main():

    print 'Main Thread'
    starttime = time.time()
    thread1 = Thread1('A')
    thread2 = Thread1('B')
    thread1.start()
    thread2.start()
    threads = []
    threads.append(thread1)
    threads.append(thread2)

    for t in threads:
        t.join()
    endtime = time.time()
    print 'Main Thread Complete , Total Time Taken = ', endtime - starttime


if __name__ == '__main__':
    main()

多進程模塊

from multiprocessing import Process
import platform

import os
import time

def process1():
#     print 'process_1 processor =',platform.processor()
    starttime = time.time() 
    for i in range(100000):
        for j in range(10000):
            pass
    endtime = time.time()
    print 'Process 1 complete : Time Taken = ', endtime - starttime 


def process2():
#     print 'process_2 processor =',platform.processor()
    starttime = time.time()
    for i in range(1000):
        for j in range(1000):
            pass
    endtime = time.time()
    print 'Process 2 complete : Time Taken = ', endtime - starttime

def main():
    print 'Main Process start'
    starttime = time.time()
    processlist = []

    p1 = Process(target=process1)
    p1.start()
    processlist.append(p1)

    p2 = Process(target = process2)
    p2.start()
    processlist.append(p2)

    for i in processlist:
        i.join()
    endtime = time.time()
    print 'Main Process Complete - Total time taken = ', endtime - starttime

if __name__ == '__main__':
    main()

Answer 1

如果您的計算機上有兩個可用的CPU，則有兩個不需要通信的進程，並且您想同時使用這兩個進程來提高程序速度，則應該使用多處理模塊，而不是線程模塊。

全局解釋器鎖（GIL）阻止Python解釋器通過使用多個線程來有效利用多個CPU，因為一次只能有一個線程執行Python字節碼。 因此，多線程不會改善應用程序的整體運行時間，除非您有長時間阻塞的調用（例如，等待IO）或釋放GIL（例如， numpy會執行一些昂貴的調用）。 但是，多處理庫創建了單獨的子進程，因此創建了解釋器的多個副本，因此可以有效利用多個CPU。

但是，在您給出的示例中，您有一個過程非常快地完成（在我的計算機上不到0.1秒），而一個過程大約需要18秒才能完成。 確切的數字可能會因您的硬件而異。 在這種情況下，幾乎所有工作都是在一個進程中進行的，因此無論您實際上只使用一個CPU。 在這種情況下，產生進程與線程的開銷增加，可能導致基於進程的版本變慢。

如果兩個進程都執行18秒的嵌套循環，則應該看到多處理代碼運行得更快（假設您的計算機實際上有多個CPU）。 在我的機器上，我看到多處理代碼在大約18.5秒內完成，多線程代碼在71.5秒內完成。 我不確定為什么多線程處理花費了超過36秒的時間，但是我猜是GIL引起了某種線程爭用問題，這減慢了兩個線程的執行速度。

關於第二個問題，假設系統上沒有其他負載，則應使用與系統上CPU數量相等的進程數。 您可以通過在Linux系統上執行lscpu ，在Mac系統上執行sysctl hw.ncpu或在Windows上的“運行”對話框中運行dxdiag來發現這一點（可能還有其他方法，但這是我一直這樣做的方式）。

對於第三個問題，最簡單的方法是從多余的進程中獲得多少效率，就是像time.time()一樣使用time.time()或Linux中的time實用工具來測量程序的總運行time 。例如time python myprog.py ）。 理想的加速應該等於您正在使用的進程數，因此，假設您從額外的進程中獲得最大收益，那么在4個CPU上運行的4進程程序最多應比具有1個進程的同一程序快4倍。 如果其他流程對您的幫助不大，則將少於4倍。