Python基礎-進程和線程,python基礎線程

來源:互聯網
上載者:User

Python基礎-進程和線程,python基礎線程

一、進程和線程的概念

首先,引出“多任務”的概念:多任務處理是指使用者可以在同一時間內運行多個應用程式,每個應用程式被稱作一個任務。Linux、windows就是支援多任務的作業系統,比起單任務系統它的功能增強了許多。

例如,你一邊在用瀏覽器上網,一邊在聽網易雲音樂,一邊在用Word趕作業,這就是多任務,至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著,只是案頭上沒有顯示而已。

但是,這些任務是同時在運行著的嗎?眾所周知,運行一個任務就需要cpu去處理,那同時運行多個任務就必須需要多個cpu?那如果有100個任務需要同時運行,就得買一個100核的cpu嗎?顯然不能!

現在,多核CPU已經非常普及了,但是,即使過去的單核CPU,也可以執行多任務。由於CPU執行代碼都是順序執行的,那麼,單核CPU是怎麼執行多任務的呢?

答案就是作業系統輪流讓各個任務交替執行,任務1執行0.01秒,切換到任務2,任務2執行0.01秒,再切換到任務3,執行0.01秒……這樣反覆執行下去。表面上看,每個任務都是交替執行的,但是,由於CPU的執行速度實在是太快了,我們感覺就像所有任務都在同時執行一樣。

小結:一個cpu同一時刻只能運行一個“任務”;真正的並存執行多任務只能在多核CPU上實現,但是,由於任務數量遠遠多於CPU的核心數量,所以,作業系統也會自動把很多任務輪流調度到每個核心上執行。

對於作業系統來說,一個任務就是一個進程(Process),比如開啟一個瀏覽器就是啟動一個瀏覽器進程,開啟一個記事本就啟動了一個記事本進程,開啟兩個記事本就啟動了兩個記事本進程,開啟一個Word就啟動了一個Word進程。

有些進程還不止同時幹一件事,比如Word,它可以同時進行打字、拼字檢查、列印等事情。在一個進程內部,要同時幹多件事,就需要同時運行多個“子任務”,我們把進程內的這些“子任務”稱為線程(Thread)。

由於每個進程至少要幹一件事,所以,一個進程至少有一個線程。當然,像Word這種複雜的進程可以有多個線程,多個線程可以同時執行,多線程的執行方式和多進程是一樣的,也是由作業系統在多個線程之間快速切換,讓每個線程都短暫地交替運行,看起來就像同時執行一樣。當然,真正地同時執行多線程需要多核CPU才可能實現。

小結:

  • 進程就是一個程式在一個資料集上的一次動態執行過程。進程一般由程式、資料集、進程式控制制塊三部分組成。
  • 線程也叫輕量級進程,它是一個基本的CPU執行單元,也是程式執行過程中的最小單元,由線程ID、程式計數器、寄存器集合和堆棧共同組成。線程的引入減小了程式並發執行時的開銷,提高了作業系統的並發效能。線程沒有自己的系統資源。

二、進程和線程的關係

進程是電腦中的程式關於某資料集上的一次運行活動,是系統進行資源分派和調度的基本單位,是作業系統結構的基礎。或者說進程是具有一定獨立功能的程式關於某個資料集上的一次運行活動,進程是系統進行資源分派和調度的一個獨立單位。
線程則是進程的一個實體,是CPU調度和指派的基本單位,它是比進程更小的能獨立啟動並執行基本單位。

小結:

  • 一個線程只能屬於一個進程,而一個進程可以有多個線程,但至少有一個線程。

  • 資源分派給進程,同一進程的所有線程共用該進程的所有資源。
  • CPU分給線程,即真正在CPU上啟動並執行是線程。

三、並行(xing)和並發

平行處理(Parallel Processing)是電腦系統中能同時執行兩個或更多個處理的一種計算方法。平行處理可同時工作於同一程式的不同方面。平行處理的主要目的是節省大型和複雜問題的解決時間。

並發處理(concurrency Processing)指一個時間段中有幾個程式都處於已啟動運行到運行完畢之間,且這幾個程式都是在同一個處理機(CPU)上運行,但任一個時刻點上只有一個程式在處理機(CPU)上運行。

並發的關鍵是你有處理多個任務的能力,不一定要同時。並行的關鍵是你有同時處理多個任務的能力。所以說,並行是並發的子集。

四、同步與非同步

在電腦領域,同步就是指一個進程在執行某個請求的時候,若該請求需要一段時間才能返回資訊,那麼這個進程將會一直等待下去,直到收到返回資訊才繼續執行下去。

非同步是指進程不需要一直等下去,而是繼續執行其它操作,不管其他進程的狀態。當有訊息返回時系統會通知進程進行處理,這樣可以提高執行的效率。舉個例子,打電話時就是同步通訊,發短息時就是非同步通訊。

舉個例子:

由於CPU和記憶體的速度遠遠高於外設的速度,所以,在IO編程中,就存在速度嚴重不匹配的問題。比如要把100M的資料寫入磁碟,CPU輸出100M的資料只需要0.01秒,可是磁碟要接收這100M資料可能需要10秒,有兩種辦法解決:

五、threading模組

線程是作業系統直接支援的執行單元,因此,進階語言通常都內建多線程的支援,Python也不例外,並且,Python的線程是真正的Posix Thread,而不是類比出來的線程。

Python的標準庫提供了兩個模組:_thread和threading,_thread是低級模組,threading是進階模組,對_thread進行了封裝。絕大多數情況下,我們只需要使用threading這個進階模組。

1. 調用Thread類直接建立

啟動一個線程就是把一個函數傳入並建立Thread執行個體,然後調用start()開始執行:

 1 import time, threading 2  3 # 新線程執行的代碼: 4 def loop(): 5     print('thread %s is running...' % threading.current_thread().name) 6     n = 0 7     while n < 5: 8         n = n + 1 9         print('thread %s >>> %s' % (threading.current_thread().name, n))10         time.sleep(1)11     print('thread %s ended.' % threading.current_thread().name)12 13 print('thread %s is running...' % threading.current_thread().name)14 t = threading.Thread(target=loop, name='LoopThread')15 t.start()16 t.join()17 print('thread %s ended.' % threading.current_thread().name)18 19 20 #運行結果:21 #thread MainThread is running...22 # thread LoopThread is running...23 # thread LoopThread >>> 124 # thread LoopThread >>> 225 # thread LoopThread >>> 326 # thread LoopThread >>> 427 # thread LoopThread >>> 528 # thread LoopThread ended.29 # thread MainThread ended.
執行個體1

由於任何進程預設就會啟動一個線程,我們把該線程稱為主線程,主線程又可以啟動新的線程,Python的threading模組有個current_thread()函數,它永遠返回當前線程的執行個體。主線程執行個體的名字叫MainThread,子線程的名字在建立時指定,我們用LoopThread命名子線程。名字僅僅在列印時用來顯示,完全沒有其他意義,如果不起名字Python就自動給線程命名為Thread-1,Thread-2……

 1 import threading 2 import time 3  4 def countNum(n): # 定義某個線程要啟動並執行函數 5  6     print("running on number:%s" %n) 7  8     time.sleep(3) 9 10 if __name__ == '__main__':11 12     t1 = threading.Thread(target=countNum,args=(23,)) #產生一個線程執行個體13     t2 = threading.Thread(target=countNum,args=(34,))14 15     t1.start() #啟動線程16     t2.start()17 18     print("ending!")19 20 21 #運行結果:程式列印完“ending!”後等待3秒結束22 #running on number:2323 #running on number:3424 #ending!
執行個體2

該執行個體中共有3個線程:主線程,t1和t2子線程

 

2. 自訂Thread類繼承式建立

 1 #繼承Thread式建立 2  3 import threading 4 import time 5  6 class MyThread(threading.Thread): 7  8     def __init__(self,num): 9         threading.Thread.__init__(self)    #繼承父類__init__10         self.num=num11 12     def run(self):    #必須定義run方法13         print("running on number:%s" %self.num)14         time.sleep(3)15 16 t1=MyThread(56)17 t2=MyThread(78)18 19 t1.start()20 t2.start()21 print("ending")
View Code

3. Thread類的執行個體方法

join和dameon

 1 import threading 2 from time import ctime,sleep 3  4 def Music(name): 5  6         print ("Begin listening to {name}. {time}".format(name=name,time=ctime())) 7         sleep(3) 8         print("end listening {time}".format(time=ctime())) 9 10 def Blog(title):11 12         print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))13         sleep(5)14         print('end recording {time}'.format(time=ctime()))15 16 17 threads = []18 19 20 t1 = threading.Thread(target=Music,args=('FILL ME',))21 t2 = threading.Thread(target=Blog,args=('',))22 23 threads.append(t1)24 threads.append(t2)25 26 if __name__ == '__main__':27 28     #t2.setDaemon(True)29 30     for t in threads:31 32         #t.setDaemon(True) #注意:一定在start之前設定33         t.start()34 35         #t.join()36 37     #t1.join()38     #t2.join()    #  考慮這三種join位置下的結果?39 40     print ("all over %s" %ctime())
join和setDaemon

其它方法:

1 Thread執行個體對象的方法2   # isAlive(): 返回線程是否活動的。3   # getName(): 返回線程名。4   # setName(): 設定線程名。5 6 threading模組提供的一些方法:7   # threading.currentThread(): 返回當前的線程變數。8   # threading.enumerate(): 返回一個包含正在啟動並執行線程的list。正在運行指線程啟動後、結束前,不包括啟動前和終止後的線程。9   # threading.activeCount(): 返回正在啟動並執行線程數量,與len(threading.enumerate())有相同的結果。

六、GIL

'''定義:In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)'''

Python中的線程是作業系統的原生線程,Python虛擬機器使用一個全域解譯器鎖(Global Interpreter Lock)來互斥線程對Python虛擬機器的使用。為了支援多線程機制,一個基本的要求就是需要實現不同線程對共用資源訪問的互斥,所以引入了GIL。
GIL:在一個線程擁有瞭解釋器的訪問權之後,其他的所有線程都必須等待它釋放解譯器的訪問權,即使這些線程的下一條指令並不會互相影響。
在調用任何Python C API之前,要先獲得GIL
GIL缺點:多處理器退化為單一處理器;優點:避免大量的加鎖解鎖操作。

1. GIL的早期設計

Python支援多線程,而解決多線程之間資料完整性和狀態同步的最簡單方法自然就是加鎖。 於是有了GIL這把超級大鎖,而當越來越多的程式碼程式庫開發人員接受了這種設定後,他們開始大量依賴這種特性(即預設python內部對象是thread-safe的,無需在實現時考慮額外的記憶體鎖和同步操作)。慢慢的這種實現方式被發現是蛋疼且低效的。但當大家試圖去拆分和去除GIL的時候,發現大量庫代碼開發人員已經重度依賴GIL而非常難以去除了。有多難?做個類比,像MySQL這樣的“小項目”為了把Buffer Pool Mutex這把大鎖拆分成各個小鎖也花了從5.5到5.6再到5.7多個大版為期近5年的時間,並且仍在繼續。MySQL這個背後有公司支援且有固定Team Dev的產品走的如此艱難,那又更何況Python這樣核心開發和代碼貢獻者高度社區化的團隊呢?

2. GIL的影響

無論你啟多少個線程,你有多少個cpu, Python在執行一個進程的時候會淡定的在同一時刻只允許一個線程運行。
所以,python是無法利用多核CPU實現多線程的。
這樣,python對於計算密集型的任務開多線程的效率甚至不如串列(沒有大量切換),但是,對於IO密集型的任務效率還是有顯著提升的。

計算密集型執行個體:

 1 #coding:utf8 2 from threading import Thread 3 import time 4  5 def counter(): 6     i = 0 7     for _ in range(100000000): 8         i = i + 1 9     return True10 11 12 def main():13     l=[]14     start_time = time.time()15     for i in range(2):16 17         t = Thread(target=counter)18         t.start()19         l.append(t)20         t.join()21 22     for t in l:23         t.join()24     # counter()25     # counter()26     end_time = time.time()27     print("Total time: {}".format(end_time - start_time))28 29 if __name__ == '__main__':30     main()31 32 33 '''34 py2.7:35      串列:9.17599987984s36      並發:9.26799988747s37 py3.6:38      串列:9.540389776229858s39      並發:9.568442583084106s40 41 '''
計算密集型,多線程並發相比串列,沒有顯著優勢

3. 解決方案

用multiprocessing替代Thread multiprocessing庫的出現很大程度上是為了彌補thread庫因為GIL而低效的缺陷。它完整的複製了一套thread所提供的介面方便遷移。唯一的不同就是它使用了多進程而不是多線程。每個進程有自己的獨立的GIL,因此也不會出現進程之間的GIL爭搶。

 1 #coding:utf8 2 from multiprocessing import Process 3 import time 4  5 def counter(): 6     i = 0 7     for _ in range(100000000): 8         i = i + 1 9 10     return True11 12 def main():13 14     l=[]15     start_time = time.time()16 17     # for _ in range(2):18     #     t=Process(target=counter)19     #     t.start()20     #     l.append(t)21     #     #t.join()22     #23     # for t in l:24     #    t.join()25     counter()26     counter()27     end_time = time.time()28     print("Total time: {}".format(end_time - start_time))29 30 if __name__ == '__main__':31     main()32 33 34 '''35 36 py2.7:37      串列:8.92299985886 s38      並行:8.19099998474 s39 40 py3.6:41      串列:9.963459014892578 s42      並發:5.1366541385650635 s43 44 '''
multiprocess多進程實現並發運算能夠提升效率

當然multiprocessing也不是萬能良藥。它的引入會增加程式實現時線程間資料通訊和同步的困難。就拿計數器來舉例子,如果我們要多個線程累加同一個變數,對於thread來說,申明一個global變數,用thread.Lock的context包裹住,三行就搞定了。而multiprocessing由於進程之間無法看到對方的資料,只能通過在主線程申明一個Queue,put再get或者用share memory的方法。這個額外的實現成本使得本來就非常痛苦的多線程程式編碼,變得更加痛苦了。

小結:因為GIL的存在,只有IO Bound情境下的多線程會得到較好的效能提升;如果對並行計算效能較高的程式可以考慮把核心部分變成C模組,或者索性用其他語言實現;GIL在較長一段時間內將會繼續存在,但是會不斷對其進行改進。

 

 

 

 

 未完待續。。。

 

 

 

參考資料:

1. http://www.cnblogs.com/yuanchenqi/articles/6755717.html#top

2. http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143192823818768cd506abbc94eb5916192364506fa5d000?t=1494233371173#comments

 

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.