18.2 線程和進程

18.2.1 什么是進程？

18.2.1 什么是進程？

計算機程序只不過是磁盤中可執行的，二進制的數據。它們只有在被讀取到內存中，被操作系統調用的時候才開始它們的生命周期。進程（重量級進程）是程序的一 次執行，每個進程都有自己的地址空間，內存，數據棧以及其它記錄其運行軌跡的輔助數據。操作系統管理在其上運行的所有進程，并為這些進程公平的分配時間。 進程也可以通過fork和spawn操作來完成其它的任務。不過各個進程有自己的內存空間，數據棧等，所以只能使用進程間通訊（IPC），而不能直接共享 信息。

18.2.2 什么是線程

線程（輕量級進程）跟進程有些相似，不同的是：所有的線程運行在同一個進程中，共享相同的運行環境。它們可以想象成是在主進程或“主線程”中并行運行的“迷你進程”。

線程有開始，順序執行和結束三部分。它有一個自己的指令指針，記錄自己運行到什么地方。線程的運行可能被搶占（中斷），或暫時的被掛起（也叫睡眠），讓其 它的線程運行，這叫做讓步。一個進程中的各個線程之間共享同一片數據空間，所以線程之間可以比進程之間更方便的共享數據以及相互通訊。線程一般都是并發執 行的，正式由于這種并行和數據共享的機制使得多個任務的合作變成可能。實際上，在單CPU的系統中，真正的并發是不可能的，每個線程會被安排成每次只運行 一會，然后就把CPU讓出來，讓其它的線程去運行。在進程的整個運行過程中，每個線程都只做自己的事，在需要的時候跟其它的線程共享運行的結果。

當然，這樣的共享并不是完全沒有危險的。如果多個線程共同訪問同一片數據，則由于數據訪問的順序不一樣，有可能導致數據結果的不一致問題。

另一個需要注意的地方是：由于有的函數會在完成之前阻塞住，在沒有特別為多線程做修改的情況下，這種“貪婪”的函數會讓CPU的市價分配有所傾斜。導致各個線程分配到的運行時間可能不盡相同，不盡公平。

18.3.5 Python的threading模塊

核心提示：避免使用thread模塊。更高級別的 threading 模塊更為先進，對線程的支持更為完善，而且使用 thread 模塊里的屬性有可能會與 threading 出現沖突。其次，低級別的 thread 模塊的同步原語很少（實際上只有一個），而 threading 模塊則有很多。

thread 模塊函數
start_new_thread(function,
args, kwargs=None) 產生一個新的線程，在新線程中用指定的參數和可選的
kwargs來調用這個函數。
allocate_lock() 分配一個LockType 類型的鎖對象
exit() 讓線程退出

LockType類型鎖對象方法
acquire(wait=None) 嘗試獲取鎖對象
locked() 如果獲取了鎖對象返回True，否則返回False
release() 釋放鎖

例子1：簡單的多線程

 1 from time import sleep, ctime
 2 import thread
 3 def loop0():
 4     print "start loop 0 at:", ctime()
 5     sleep(4)
 6     print "loop 0 done at:", ctime()
 7 def loop1():
 8     print "start loop 1 at:", ctime()
 9     sleep(2)
10     print "loop 1 done at:", ctime()
11 def main():
12     print "starting at:", ctime()
13     thread.start_new_thread(loop0, ())
14     thread.start_new_thread(loop1, ())
15     sleep(6)
16     print "all DONE at:", ctime()
17  
18 if __name__ == "__main__":
19     main()

mtsleep1.py

其中sleep(6)是為了讓線程中的sleep(2)和sleep(4)能夠完整運行（而不是隨著主線程結束直接終止）。
我們可以通過使用鎖來保證主線程不會提前結束。

 1 #!/usr/bin/env python
 2 
 3 import thread
 4 from time import sleep, ctime
 5 
 6 loops = [4,2]
 7 
 8 def loop(nloop, nsec, lock):
 9     print 'start loop', nloop, 'at: ', ctime()  #運行時這條語句有錯誤輸出
10     sleep(nsec)
11     print 'loop', nloop, 'done at: ', ctime()
12     lock.release()
13 
14 def main():
15     print 'starting at:', ctime()
16     locks = []
17     nloops = range(len(loops))
18 
19     for i in nloops:
20         lock = thread.allocate_lock()
21         lock.acquire()                 #嘗試獲得鎖（將鎖鎖上）
22         locks.append(lock)
23     for i in nloops:
24         thread.start_new_thread(loop, (i, loops[i], locks[i]))
25 
26     for i in nloops:
27         while locks[i].locked():
28             pass
29     print 'all DONE at:', ctime()
30 main()

mtsleep2.py

18.5 threading 模塊

接下來，我們要介紹的是更高級別的threading模塊，它不僅提供了Thread類，還提供了各種好用的同步機制。

threading 模塊對象 描述
Thread 表示一個線程的執行的對象
Lock 鎖原語對象（跟thread 模塊里的鎖對象相同）
RLock 可重入鎖對象。使單線程可以再次獲得已經獲得了的鎖（遞歸鎖定）。
Condition 條件變量對象能讓一個線程停下來，等待其它線程滿足了某個“條件”。
如，狀態的改變或值的改變。
Event 通用的條件變量。多個線程可以等待某個事件的發生，在事件發生后，
所有的線程都會被激活。
Semaphore 為等待鎖的線程提供一個類似“等候室”的結構
BoundedSemaphore 與Semaphore 類似，只是它不允許超過初始值
Timer 與Thread 相似，只是，它要等待一段時間后才開始運行。

核心提示：守護線程
另一個避免使用thread 模塊的原因是，它不支持守護線程。當主線程退出時，所有的子線程不論它們是否還在工作，都會被強行退出。有時，我們并不期望這種行為，這時，就引入了守護線程的概念
threading
模塊支持守護線程，它們是這樣工作的：守護線程一般是一個等待客戶請求的服務器，如果沒有客戶提出請求，它就在那等著。如果你設定一個線程為守護線程，就
表示你在說這個線程是不重要的，在進程退出的時候，不用等待這個線程退出。就像你在第16
章網絡編程看到的，服務器線程運行在一個無限循環中，一般不會退出。

如果你的主線程要退出的時候，不用等待那些子線程完成，那就設定這些線程的daemon
屬性。即，在線程開始（調用thread.start()）之前，調用setDaemon()函數設定線程的daemon
標志（thread.setDaemon(True)）就表示這個線程“不重要”
如果你想要等待子線程完成再退出， 那就什么都不用做，
或者顯式地調用thread.setDaemon(False)以保證其daemon
標志為False。你可以調用thread.isDaemon()函數來判斷其daemon 標志的值。新的子線程會繼承其父線程的daemon
標志。整個Python 會在所有的非守護線程退出后才會結束,即進程中沒有非守護線程存在的時候才結束。

18.5.1Thread類

函數 描述
start() 開始線程的執行
run() 定義線程的功能的函數（一般會被子類重寫）
join(timeout=None) 程序掛起，直到線程結束；如果給了timeout，則最多阻塞timeout 秒
getName() 返回線程的名字
setName(name) 設置線程的名字
isAlive() 布爾標志，表示這個線程是否還在運行中
isDaemon() 返回線程的daemon 標志
setDaemon(daemonic) 把線程的daemon 標志設為daemonic（一定要在調用start()函數前調用）

有三種方法用Thread類創建線程。

1. 創建一個Thread的實例，傳給它一個函數

2. 創建一個Thread的實例，傳給它一個可調用的類對象

3. 從Thread派生出一個子類， 創建一個這個子類的實例

下面分別給出例子

1.創建一個Thread的實例，傳給它一個函數

 1 #!/usr/bin/env python
 2 
 3 import threading
 4 from time import sleep, ctime
 5 
 6 loops = [4,2]
 7 
 8 def loop(nloop, nsec):
 9     print 'start loop', nloop, 'at:', ctime()
10     sleep(nsec)
11     print 'loop', nloop, 'done at:', ctime()
12 
13 def main():
14     print 'starting at:', ctime()
15     threads = []
16     nloops = range(len(loops))
17 
18     for i in nloops:
19         t = threading.Thread(target = loop, args = (i, loops[i]))
20         threads.append(t)
21 
22     for i in nloops:
23         threads[i].start()
24 
25     for i in nloops:
26         threads[i].join()
27 
28     print 'all DONE at:', ctime()
29 
30 if __name__ == '__main__':
31     main()

mtsleep3.py

所有線程都創建了之后，再一起調用start()函數啟動，而不是創建一個啟動一個，而且，不用再管理一堆鎖（分配鎖，獲得鎖，釋放鎖，檢查鎖的狀態），只要簡單地對每個線程調用join()函數就可以了。

join()會等到線程結束，或者在給力timeout參數的情況下等到超時，使用join()會比使用一個等待鎖釋放的無限循環更清晰（這種鎖也被稱為自旋鎖）。

join()的另一個比較重要的方面是它可以完全不被調用。事實上一旦線程啟動以后就會一直運行，直到線程的函數結束。如果你的主線程除了等線程結束以外還有其他的事情要做，那就不用調用join()，只有當你要等待線程結束的時候才調用join()。

2.創建一個Thread的實例，傳給它一個可調用的類對象。

 1 #!/usr/bin/env python
 2 
 3 import threading
 4 from time import sleep, ctime
 5 
 6 loops = [4,2]
 7 
 8 class ThreadFunc(object):
 9 
10     def __init__(self, func, args, name=''):
11         self.name = name
12         self.func = func
13         self.args = args
14 
15     def __call__(self):
16         self.res = self.func(*self.args)
17 
18 def loop(nloop, nsec):
19         print 'start loop', nloop, 'at:', ctime()
20         sleep(nsec)
21         print 'loop', nloop, 'done at:', ctime()
22 
23 def main():
24     print 'starting at:', ctime()
25     threads = []
26     nloops = range(len(loops))
27 
28     for i in nloops:
29         t = threading.Thread(target = ThreadFunc(loop, (i,loops[i]),
30                                                  loop.__name__))
31         threads.append(t)
32 
33     for i in nloops:
34         threads[i].start()
35 
36     for i in nloops:
37         threads[i].join()
38 
39     print 'all DONE at:', ctime()
40 
41 if __name__ == '__main__':
42     main()
43         

mtsleep4.py

3.從Thread類中派生出一個子類，創建一個這個子類的實例

mtsleep5和mtsleep4的最大區別在于1.MyThread子類的構造器一定要先調用其基類的構造器 2.之前的特殊函數__call__()在子類中，名字要改為run()。

 1 #!/usr/bin/env python
 2 
 3 import threading
 4 from time import sleep, ctime
 5 
 6 loops = (4, 2)
 7 
 8 class MyThread(threading.Thread):
 9     def __init__(self, func, args, name=''):
10             threading.Thread.__init__(self)
11             self.name = name
12             self.func = func
13             self.args = args
14 
15     def run(self):
16         self.func(*self.args) #apply(self.func, self.args)
17 
18 def loop(nloop, nsec):
19     print 'start loop', nloop, 'at:', ctime()
20     sleep(nsec)
21     print 'loop', nloop, 'done at:', ctime()
22 
23 def main():
24     print 'starting at:', ctime()
25     threads = []
26     nloops = range(len(loops))
27 
28     for i in nloops:
29         t = MyThread(loop, (i, loops[i]), loop.__name__)
30         threads.append(t)
31 
32     for i in nloops:
33         threads[i].start()
34 
35     for i in nloops:
36         threads[i].join()
37 
38     print 'all DONE at:', ctime()
39 
40 if __name__ == '__main__':
41     main()

mtsleep5.py

為了讓mtsleep5中的Thread的子類更為通用我們把子類單獨放在一個模塊中，并加上一個getResult()函數用以返回函數的運行結果

 1 #!/usr/bin/eny python
 2 
 3 import threading
 4 from time import ctime
 5 
 6 class MyThread(threading.Thread):
 7     def __init__(self, func, args, name=''):
 8         threading.Thread.__init__(self)
 9         self.name = name
10         self.func = func
11         self.args = args
12 
13     def getResult(self):
14         return self.res
15     
16     def run(self):
17         print 'starting', self.name, 'at:'. ctime()
18         self.res = self.func(*self.args)
19         print self.name, 'finished at:', ctime()

myThread.py

接下來給出一個腳本比較遞歸求斐波那契、階乘和累加和函數的運行。腳本先在單線程中運行再在多線程中運行以說明多線程的好處。

 1 #!/usr/bin/eny python
 2 
 3 from myThread import MyThread
 4 from time import ctime, sleep
 5 
 6 def fib(x):
 7     sleep(0.005)
 8     if x < 2: return 1
 9     return (fib(x-2) + fib(x-1))
10 
11 def fac(x):
12     sleep(0.1)
13     if x < 2:return 1
14     return (x * fac(x-1))
15 
16 def sum(x):
17     sleep(0.1)
18     if x < 2:return 1
19     return (x + sum(x - 1))
20 
21 funcs = [fib, fac, sum]
22 n = 12
23 
24 def main():
25     nfuncs = range(len(funcs))
26 
27     print '*** SINGLE THREAD'
28     for i in nfuncs:
29         print 'starting', funcs[i].__name__, 'at:', ctime()
30         print funcs[i](n)
31         print funcs[i].__name__, 'finished at:', ctime()
32 
33     print '
*** MUTIPLE THREADS'
34     threads = []
35     for i in nfuncs:
36         t = MyThread(funcs[i],(n,), funcs[i].__name__)
37         threads.append(t)
38 
39     for i in nfuncs:
40         threads[i].start()
41 
42     for i in nfuncs:
43         threads[i].join()
44         print threads[i].getResult()
45 
46     print 'all DONE'
47 
48 if __name__ == '__main__':
49     main()

mtfacfib.py

18.5.3threading模塊中的其他函數

函數	描述
activeCount()	當前活動的線程對象的數量
crrentThread()	返回當前線程對象
enumerate()	返回當前活動線程的列表
settrace(func)	為所有線程設置一個跟蹤函數
setprofile(func)	為所有線程設置一個profile函數

18.5.4 生產者-消費者問題和Queue模塊

生產者-消費者問題，就是生產者把生產的貨物放進隊列一類的數據結構中供消費者使用，其中生產貨物和消費貨物的時間都是不固定的。

Queue模塊可以用來解決生產者-消費者問題，讓各個線程之間通信，所用到的屬性如下：

函數	描述
Queue模塊函數
queue(size)	創建一個大小為size的Queue對象
Queue對象函數
qsize()	返回隊列的大小（由于在返回的時候，隊列可能會被其他線程修改，所以這個值是近似值）
empty()	如果隊列為空返回True, 否則返回False
full()	如果隊列已滿返回True，否則返回False
put(item, block=0)	把item放到隊列中，如果給了block，函數會一直阻塞到隊列中有空間為止
get(block=0)	從隊列中取一個對象，如果給了block，函數會一直阻塞直到隊列中有對象為止。

 1 #!/usr/bin/env python
 2 
 3 from random import randint
 4 from time import sleep
 5 from Queue import Queue
 6 from myThread import MyThread
 7 
 8 def writeQ(queue):
 9     print 'producing object for Q...'
10     queue.put('xxx', 1)
11     print "size now", queue.qsize()
12 
13 def readQ(queue):
14     val = queue.get(1)
15     print 'consumed object from Q... size now', queue.qsize()
16 
17 def writer(queue, loops):
18     for i in range(loops):
19         writeQ(queue)
20         sleep(randint(1, 3))
21 
22 def reader(queue, loops):
23     for i in range(loops):
24         readQ(queue)
25         sleep(randint(1, 3))
26 
27 funcs = [writer, reader]
28 nfuncs = range(len(funcs))
29 
30 def main():
31     nloops = randint(2, 5)
32     q = Queue(32)
33 
34     threads = []
35     for i in nfuncs:
36         t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)
37         threads.append(t)
38 
39     for i in nfuncs:
40         threads[i].start()
41 
42     for i in nfuncs:
43         threads[i].join()
44 
45     print 'all DONE'
46 
47 if __name__ == '__main__':
48     main()

procons.py

18.6相關模塊

模塊	描述
thread	基本的、低級別的線程模塊
threading	高級別的線程和同步對象
Queue	供多線程使用的同步隊列
mutex	互斥對象
SocketServer	具有線程控制的TCP和UDP管理器

總結

以上是生活随笔為你收集整理的18ch的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。