爬蟲入門之多線程與線程池的使用

什麼是線程

python的thread模塊是比較底層的模塊，python的threading模塊是對thread做了一些包裝的，可以更加方便的被使用
1.線程是cpu執行的基本單元
2.線程之間的執行是無序的
3.同一進程下的線程的資源是共享的（線程鎖，互斥鎖）
4.線程可以實現多任務，多用來處理I/O密集型任務

使用threading模塊

單線程執行

import time 
  def saySorry(): 　
　for i in range(5): 
　print("親愛的，我錯了，我能吃飯了嗎？") 
　time.sleep(1)
　def do(): for i in range(5):
　 print("親愛的，我錯了，我給你按摩") 
 time.sleep(1)
 if __name__ == "__main__":
　   saySorry() 
　   saydo()

多線程執行

import threading 
import time
def saySorry(): 　　
	for i in range(5): 
	print("親愛的，我錯了，我能吃飯了嗎？")
	 time.sleep(1)
 def do(): 
 	for i in range(5):
 	print("親愛的，我錯了，我給你按摩")
   	time.sleep(1)
   	if __name__ == "__main__": 
	   	td1 = threading.Thread(target=saySorry) 
   		td1.start() #啓動線程，即讓線程開始執行
   		td2 = threading.Thread(target=saySorry)
   	  	td2.start() #啓動線程，即讓線程開始執行

threading.Thread參數介紹

target:線程執行的函數
name:線程名稱
args:執行函數中需要傳遞的參數，元組類型
kwargs:傳參數（字典）
另外：注意daemon參數
如果某個子線程的daemon屬性爲False，主線程結束時會檢測該子線程是否結束，如果該子線程還在運行，則主線程會等待它完成後再退出；
如果某個子線程的daemon屬性爲True，主線程運行結束時不對這個子線程進行檢查而直接退出，同時所有daemon值爲True的子線程將隨主線程一起結束，而不論是否運行完成。
屬性daemon的值默認爲False，如果需要修改，必須在調用start()方法啓動線程之前進行設置

說明

可以明顯看出使用了多線程併發的操作，花費時間要短很多
當調用start()時，纔會真正的創建線程，並且開始執行

方法名	作用
start()方法	開啓線程
join()方法	線程阻塞
daemon = False	後臺線程,主線程結束不影響子線程運行
daemon = True	前臺線程,主線程結束子線程隨之結束

互斥鎖

GIL:由於python的CPython解釋器的原因，存在一個GIL全局解釋器鎖用來保證同一時刻只有一個線程在執行，類似於單核處理，所有說多線程並不能充分的利用cpu資源
當多個線程幾乎同時修改某一個共享數據的時候，需要進行同步控制線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。
互斥鎖爲資源引入一個狀態：鎖定/非鎖定
某個線程要更改共享數據時，先將其鎖定，此時資源的狀態爲“鎖定”，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成“非鎖定”，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。
hreading模塊中定義了Lock類，可以方便的處理鎖定：

	# 創建鎖
 	mutex = threading.Lock() 
	 # 鎖定 
 	mutex.acquire()
  	# 釋放
 	 mutex.release(

注意：

如果這個鎖之前是沒有上鎖的，那麼acquire不會堵塞
如果在調用acquire對這個鎖上鎖之前它已經被其他線程上了鎖，那麼此時acquire會堵塞，直到這個鎖被解鎖爲止
使用互斥鎖完成2個線程對同一個全局變量各加100萬次的操作

import threading 
import time
g_num = 0
def test1(num): 
global g_num
 for i in range(num):
  mutex.acquire() # 上鎖 
  g_num += 1
   mutex.release() # 解鎖
   print("---test1---g_num=%d"%g_num)
def test2(num):
	global g_num
	for i in range(num):
	mutex.acquire() # 上鎖
	g_num += 1
	mutex.release() # 解鎖	
	print("---test2---g_num=%d"%g_num)
	# 創建一個互斥鎖 
	# 默認是未上鎖的狀態 
	mutex = threading.Lock()
	創建2個線程，讓他們各自對g_num加1000000次
	p1 = threading.Thread(target=test1, args=(1000000,))
	p1.start()
	p2 = threading.Thread(target=test2, args=(1000000,))
	p2.start()
	p1.join() p2.join()
	print("2個線程對同一個全局變量操作之後的最終結果是:%s" % g_num)

運行結果：

2個線程對同一個全局變量操作之後的最終結果是:2000000

可以看到最後的結果，加入互斥鎖後，其結果與預期相符。
上鎖解鎖過程

當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入“locked”狀態。
每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變爲“blocked”狀態，稱爲“阻塞”，直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入“unlocked”狀態。
線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。

總結

鎖的好處

確保了某段關鍵代碼只能由一個線程從頭到尾完整地執行
鎖的壞處：

阻止了多線程併發執行，包含鎖的某段代碼實際上只能以單線程模式執行，效率就大大地下降了
由於可以存在多個鎖，不同的線程持有不同的鎖，並試圖獲取對方持有的鎖時，可能會造成死鎖

線程池

導入模塊包

from concurrent.futures import ThreadPoolExecutor

創建線程池，並往線程池中添加任務

#創建一個線程池 
pool = ThreadPoolExecutor(10) 
#如何提交任務給線程池呢？
# 往線程池中添加任務
for pagenum in range(50): 
#submit: 表示將我們需要執行的任務給這個線程池，
handler = pool.submit(get_page_data,pagenum)
#給線程池設置任務之後，可以設置一個回調函數， #作用是：當我們某個任務執行完畢之後，就會回調你設置的回調函數
handler.add_done_callback(done)
pool.shutdown(wait=True)

案例

from concurrent.futures import ThreadPoolExecutor
import requests
from lxml.html import etree
import requests

class CollegateRank(object):

    def get_page_data(self,url):
        response = self.send_request(url=url)
        if response:
            # print(response)
            with open('page.html','w',encoding='gbk') as file:
                file.write(response)
            self.parse_page_data(response)


    def parse_page_data(self,response):
        #使用xpath解析數據
        etree_xpath = etree.HTML(response)
        ranks = etree_xpath.xpath('//div[@class="scores_List"]/dl')
        # print(ranks)
        pool = ThreadPoolExecutor(10)
        for dl in ranks:
            school_info = {}
            school_info['url'] = self.extract_first(dl.xpath('./dt/a[1]/@href'))
            school_info['icon'] = self.extract_first(dl.xpath('./dt/a[1]/img/@src'))
            school_info['name'] = self.extract_first(dl.xpath('./dt/strong/a/text()'))
            school_info['adress'] = self.extract_first(dl.xpath('./dd/ul/li[1]/text()'))
            school_info['tese'] = '、'.join(dl.xpath('./dd/ul/li[2]/span/text()'))
            school_info['type'] = self.extract_first(dl.xpath('./dd/ul/li[3]/text()'))
            school_info['belong'] = self.extract_first(dl.xpath('./dd/ul/li[4]/text()'))
            school_info['level'] = self.extract_first(dl.xpath('./dd/ul/li[5]/text()'))
            school_info['weburl'] = self.extract_first(dl.xpath('./dd/ul/li[6]/text()'))

            print(school_info['url'],school_info)
            result = pool.submit(self.send_request,school_info['url'])
            result.add_done_callback(self.parse_school_detail)
        # pool.shutdown()

    # 線程執行完畢的回調方法
    def parse_school_detail(self,future):
        text = future.result()
        print('解析數據',len(text))

    def extract_first(self,data=None,defalut=None):
        if len(data)  > 0:
            return data[0]
        return defalut


    def send_request(self, url, headers=None):
        headers = headers if headers else {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36'}
        response = requests.get(url=url,headers=headers)
        if response.status_code == 200:
            return response.text

if __name__ == '__main__':
    url = 'http://college.gaokao.com/schlist/'
    obj = CollegateRank()
    obj.get_page_data(url)

爬蟲入門之多線程與線程池的使用

什麼是線程

使用threading模塊

threading.Thread參數介紹

互斥鎖

總結

線程池

爬蟲入門之urllib的使用

爬蟲入門之分佈式爬蟲

爬蟲入門之scrapy部署

測試計劃和測試報告

appium自動化總結

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結