開啟線程池和進程池

　　線程與進程的應用場合很多，主要處理並發與多任務。然而，當開啟的線程與進程過多時，系統的開銷過多會造成性能低下甚至崩潰。這時，希望出現一種方法能規定只能執行指定數量線程與進程的策略。特別是針對不知道要開啟多少線程或進程，而有可能出現線程或進程過多的情況。於是，線程池與進程池出現了。python3以后增加了concurrent.futures模塊，為異步執行提供了高級的接口。

線程池

concurrent.futures.ThreadPoolExecutor(max_workers=None, thread_name_prefix='')： 線程池，提供能異步地執行任務的線程。

參數max_workers為最大的能提供線程的個數，默認為CPU的核數乘5，如果CPU為四核那么能開啟的最大線程數為20。

參數thread_name_prefix為線程名前綴，為了方便控制線程和調試線程。

 

ThreadPoolExecutor下面有submit，map，shutdown方法：

• submit（fn, *args, **kwargs）方法將返回一個futurn對象，代表將要執行或未完成的任務的結果。
• map(func, *iterables, timeout=None, chunksize=1)將返回一個迭代器iter，沒弄next方法執行iter一次，將並發max_workers個線程。
• shutdown(wait=True)將釋放完成任務的線程池所占的所有資源，參數wait如果為True，則等待未完成的任務。如果使用with，則不用顯示地調用。

注意： shutdown方法的wait不管是True或是False，解釋器都會把剩余的任務執行完。區別就是一個是等待(阻塞)，一個是不等待。

Future對象

　　Future對象為Executor.submit()執行后的結果，代表將要執行或未完成的任務的結果。注意，不用手動調用concurrent.futures.Future生成Future對象。 它有以下多種方法：

• cancel()： 試圖取消任務。如果當前任務正在被執行而且不能取消，返回False，否則此任務被取消並返回True。cancelled()： 如果任務成功地取消，返回True
• running()： 如果當前任務正在被執行而且不能取消，返回True
• done()： 如果任務被完成或成功地被取消則返回True
• result(timeout=None)： 返回任務的結果，如果任務未完成則等待timeout秒。
• exception(timeout=None)：在timeout秒內返回任務的異常
• add_done_callback(fn)： 添加回調函數。並且futurnd對象最為回調函數的唯一參數，無論任務被取消或完成。

import requests, time
from bs4 import BeautifulSoup
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed



URLS = [
    'http://www.baidu.com',
    'http://www.bing.com',
    'http://wwww.sougou.com',
    'http://www.soso.com'
]

def get_page_title(url, timeout): 
    '''得到頁面的標題'''
    html = requests.get(       # 使用requests發送get請求
        url=url,
        timeout=timeout,
        headers = {
            'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:51.0) Gecko/20100101 Firefox/51.0'
        }
    )
#     print(html.text)
    soup = BeautifulSoup(html.text, "html.parser")  # 解析文檔
    title = soup.find('title')    # 得到頁面的標題
    return title.text



with ThreadPoolExecutor(max_workers=4) as excutor:    # 使用with得到一個最大線程數為4的線程池
    start = time.time()                               
    future_and_url = {excutor.submit(get_page_title, url, 10):url for url in URLS} # 提交任務
    for future in as_completed(future_and_url):  # 使用as_completed返回一個已完成任務的迭代器
        url = future_and_url[future]
        try:
            data = future.result()   # 得到任務的結果
        except Exception as e:
            print("has occured exception:", e)
        else:
            cost_time = time.time() - start
            print("got title:%s"%data, 'spend %ss'%cost_time)

輸出為：

got title:百度一下，你就知道 spend 0.28019237518310547s
got title:搜狗搜索引擎 - 上網從搜狗開始 spend 0.3059103488922119s
got title:搜狗®寵物 | 熱門論談 spend 1.7201545238494873s
got title:微軟必應搜索 - 全球搜索，有問必應 (Bing) spend 10.456863164901733s

 

進程池

　　進程池同樣也提供能異步執行任務的進程，不同的是它能有效地回避全局解釋鎖的限制。一個進程會開辟獨立的空間，所以進程運行着自己的解釋器，互不影響。

 concurrent.futures.ProcessPoolExecutor(max_workers=None): 進程池，max_workers與線程不同的是默認為CPU的核數。

先用線程試試看，在比較。

def is_perfect_number(number):
    '''判斷是否為完美數'''
    sum = 0
    for i in range(1,number):
        if number%i == 0:
             sum += i
    if sum == number:
        return True
    return False



def find_perfect_number_t(number):
    '''利用線程尋找這個數字范圍內所有的完美數'''
    perfect_number = []
    start_time = time.time()
    with ThreadPoolExecutor() as executor:
        future_dict = {executor.submit(is_perfect_number, i): i for i in range(1, number)}
  
        for future in as_completed(future_dict):
            if future.result():
                perfect_number.append(future_dict[future])
        print('The perfect number of %s is:'%number, perfect_number)
    print('has spend %ss'%(time.time()-start_time))

執行：

find_perfect_number_t(25000)

輸出為：

The perfect number of 25000 is: [6, 28, 496, 8128]
has spend 134.63016271591187s

現在我們改換進程：

def find_perfect_number_p(number):
    '''利用進程尋找這個數字范圍內所有的完美數'''
    perfect_number = []
    start_time = time.time()
    with ProcessPoolExecutor() as executor:
        future_dict = {executor.submit(is_perfect_number, i): i for i in range(1, number)}
  
        for future in as_completed(future_dict):
            if future.result():
                perfect_number.append(future_dict[future])
        print('The perfect number of %s is:'%number, perf

再執行：

find_perfect_number_p(25000)

輸出為：

The perfect number of 25000 is: [6, 496, 28, 8128]
has spend 45.46505379676819s

這是運行線程代碼的cpu負載圖：

這是進程的負載圖：

結論：

　　上面的例子很好地展示了線程與進程的區別。我的CPU為四核，python的多線程只使用了CPU一個核，CPU使用率只有35%。多進程充分利用了全部CPU，使用率達到100%。但進程的創建和銷毀所消耗的資源比線程大得多，所以在運算量不大的情況下，使用線程其實還是要比進程快。python中多進程適用解決大運算量問題並且充分利用CPU的情況。