IO密集型任務 VS 計算密集型任務

• 所謂IO密集型任務，是指磁碟IO、網路IO佔主要的任務，計算量很小。比如請求網頁、讀寫檔案等。當然我們在Python中可以利用sleep達到IO密集型任務的目的。
  
• 所謂計算密集型任務，是指CPU計算佔主要的任務，CPU一直處於滿負荷狀態。比如在一個很大的列表中查詢元素（當然這不合理），複雜的加減乘除等。

多執行緒 VS 多程序

1、多執行緒

多執行緒即在一個程序中啟動多個執行緒執行任務。一般來說使用多執行緒可以達到並行的目的，但由於Python中使用了全域性解釋鎖GIL的概念，導致Python中的多執行緒並不是並行執行，而是“交替執行”。類似於下圖：（圖片轉自網路，侵刪）

所以Python中的多執行緒適合IO密集型任務，而不適合計算密集型任務。

Python提供兩組多執行緒介面，一是thread模組_thread，提供低等級介面。二是threading模組，提供更容易使用的基於物件的介面，可以繼承Thread物件來實現執行緒，此外其還提供了其它執行緒相關的物件，例如Timer，Lock等。

2、多程序

由於Python中GIL的原因，對於計算密集型任務，Python下比較好的並行方式是使用多程序，這樣可以非常有效的使用CPU資源。當然同一時間執行的程序數量取決你電腦的CPU核心數。

Python中的程序模組為mutliprocess模組，提供了很多容易使用的基於物件的介面。另外它提供了封裝好的管道和佇列，可以方便的在程序間傳遞訊息。Python還提供了程序池Pool物件，可以方便的管理和控制執行緒。

例項講解Python中的多執行緒、多程序如何應對IO密集型任務、計算密集型任務

首先定義一個佇列，並定義初始化佇列的函式：

# 定義全域性變數Queue
g_queue = multiprocessing.Queue()

def init_queue():
    print("init g_queue start")
    while not g_queue.empty():
        g_queue
 
.get()
    for _index in range(10):
        g_queue.put(_index)
    print("init g_queue end")
    return

然後定義IO密集型任務和計算密集型任務，分別從佇列中獲取任務資料：

# 定義一個IO密集型任務：利用time.sleep()
def task_io(task_id):
    print("IOTask[%s] start" % task_id)
    while not g_queue.empty():
        time.sleep(1)
        try:
            data = g_queue.get(block=True, timeout=1)
            print("IOTask[%s] get data: %s" % (task_id, data))
        except Exception as excep:
            print("IOTask[%s] error: %s" % (task_id, str(excep)))
    print("IOTask[%s] end" % task_id)
    return

g_search_list = list(range(10000))
# 定義一個計算密集型任務：利用一些複雜加減乘除、列表查詢等
def task_cpu(task_id):
    print("CPUTask[%s] start" % task_id)
    while not g_queue.empty():
        count = 0
        for i in range(10000):
            count += pow(3*2, 3*2) if i in g_search_list else 0
        try:
            data = g_queue.get(block=True, timeout=1)
            print("CPUTask[%s] get data: %s" % (task_id, data))
        except Exception as excep:
            print("CPUTask[%s] error: %s" % (task_id, str(excep)))
    print("CPUTask[%s] end" % task_id)
    return task_id

準備完上述程式碼之後，進行試驗：

if __name__ == '__main__':
    print("cpu count:", multiprocessing.cpu_count(), "\n")

    print("========== 直接執行IO密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    task_io(0)
    print("結束：", time.time() - time_0, "\n")

    print("========== 多執行緒執行IO密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    thread_list = [threading.Thread(target=task_io, args=(i,)) for i in range(5)]
    for t in thread_list:
        t.start()
    for t in thread_list:
        if t.is_alive():
            t.join()
    print("結束：", time.time() - time_0, "\n")

    print("========== 多程序執行IO密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    process_list = [multiprocessing.Process(target=task_io, args=(i,)) for i in range(multiprocessing.cpu_count())]
    for p in process_list:
        p.start()
    for p in process_list:
        if p.is_alive():
            p.join()
    print("結束：", time.time() - time_0, "\n")

    print("========== 直接執行CPU密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    task_cpu(0)
    print("結束：", time.time() - time_0, "\n")

    print("========== 多執行緒執行CPU密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    thread_list = [threading.Thread(target=task_cpu, args=(i,)) for i in range(5)]
    for t in thread_list:
        t.start()
    for t in thread_list:
        if t.is_alive():
            t.join()
    print("結束：", time.time() - time_0, "\n")

    print("========== 多程序執行cpu密集型任務 ==========")
    init_queue()
    time_0 = time.time()
    process_list = [multiprocessing.Process(target=task_cpu, args=(i,)) for i in range(multiprocessing.cpu_count())]
    for p in process_list:
        p.start()
    for p in process_list:
        if p.is_alive():
            p.join()
    print("結束：", time.time() - time_0, "\n")

結果說明：

對於IO密集型任務：

• 直接執行用時：10.0333秒
• 多執行緒執行用時：4.0156秒
• 多程序執行用時：5.0182秒

說明多執行緒適合IO密集型任務。

對於計算密集型任務