一、簡(jiǎn)介

       多線程編程技術(shù)可以實(shí)現(xiàn)代碼并行性，優(yōu)化處理能力，同時(shí)功能的更小劃分可以使代碼的可重用性更好。Python中threading和Queue模塊可以用來(lái)實(shí)現(xiàn)多線程編程。
二、詳解
1、線程和進(jìn)程
       進(jìn)程（有時(shí)被稱為重量級(jí)進(jìn)程）是程序的一次執(zhí)行。每個(gè)進(jìn)程都有自己的地址空間、內(nèi)存、數(shù)據(jù)棧以及其它記錄其運(yùn)行軌跡的輔助數(shù)據(jù)。操作系統(tǒng)管理在其上運(yùn)行的所有進(jìn)程，并為這些進(jìn)程公平地分配時(shí)間。進(jìn)程也可以通過(guò)fork和spawn操作來(lái)完成其它的任務(wù)，不過(guò)各個(gè)進(jìn)程有自己的內(nèi)存空間、數(shù)據(jù)棧等，所以只能使用進(jìn)程間通訊（IPC），而不能直接共享信息。
       線程（有時(shí)被稱為輕量級(jí)進(jìn)程）跟進(jìn)程有些相似，不同的是所有的線程運(yùn)行在同一個(gè)進(jìn)程中，共享相同的運(yùn)行環(huán)境。它們可以想像成是在主進(jìn)程或“主線程”中并行運(yùn)行的“迷你進(jìn)程”。線程有開(kāi)始、順序執(zhí)行和結(jié)束三部分，它有一個(gè)自己的指令指針，記錄自己運(yùn)行到什么地方。線程的運(yùn)行可能被搶占(中斷)或暫時(shí)的被掛起(也叫睡眠)讓其它的線程運(yùn)行，這叫做讓步。一個(gè)進(jìn)程中的各個(gè)線程之間共享同一片數(shù)據(jù)空間，所以線程之間可以比進(jìn)程之間更方便地共享數(shù)據(jù)以及相互通訊。線程一般都是并發(fā)執(zhí)行的，正是由于這種并行和數(shù)據(jù)共享的機(jī)制使得多個(gè)任務(wù)的合作變?yōu)榭赡?。?shí)際上，在單CPU的系統(tǒng)中，真正的并發(fā)是不可能的，每個(gè)線程會(huì)被安排成每次只運(yùn)行一小會(huì)，然后就把CPU讓出來(lái)，讓其它的線程去運(yùn)行。在進(jìn)程的整個(gè)運(yùn)行過(guò)程中，每個(gè)線程都只做自己的事，在需要的時(shí)候跟其它的線程共享運(yùn)行的結(jié)果。多個(gè)線程共同訪問(wèn)同一片數(shù)據(jù)不是完全沒(méi)有危險(xiǎn)的，由于數(shù)據(jù)訪問(wèn)的順序不一樣，有可能導(dǎo)致數(shù)據(jù)結(jié)果的不一致的問(wèn)題，這叫做競(jìng)態(tài)條件。而大多數(shù)線程庫(kù)都帶有一系列的同步原語(yǔ)，來(lái)控制線程的執(zhí)行和數(shù)據(jù)的訪問(wèn)。
2、使用線程
（1）全局解釋器鎖(GIL)
       Python代碼的執(zhí)行由Python虛擬機(jī)(也叫解釋器主循環(huán))來(lái)控制。Python在設(shè)計(jì)之初就考慮到要在主循環(huán)中，同時(shí)只有一個(gè)線程在執(zhí)行。雖然 Python 解釋器中可以“運(yùn)行”多個(gè)線程，但在任意時(shí)刻只有一個(gè)線程在解釋器中運(yùn)行。
       對(duì)Python虛擬機(jī)的訪問(wèn)由全局解釋器鎖(GIL)來(lái)控制，正是這個(gè)鎖能保證同一時(shí)刻只有一個(gè)線程在運(yùn)行。在多線程環(huán)境中，Python 虛擬機(jī)按以下方式執(zhí)行：a、設(shè)置 GIL；b、切換到一個(gè)線程去運(yùn)行；c、運(yùn)行指定數(shù)量的字節(jié)碼指令或者線程主動(dòng)讓出控制(可以調(diào)用 time.sleep(0))；d、把線程設(shè)置為睡眠狀態(tài)；e、解鎖 GIL；d、再次重復(fù)以上所有步驟。
        在調(diào)用外部代碼(如 C/C++擴(kuò)展函數(shù))的時(shí)候，GIL將會(huì)被鎖定，直到這個(gè)函數(shù)結(jié)束為止(由于在這期間沒(méi)有Python的字節(jié)碼被運(yùn)行，所以不會(huì)做線程切換)編寫(xiě)擴(kuò)展的程序員可以主動(dòng)解鎖GIL。
（2）退出線程
       當(dāng)一個(gè)線程結(jié)束計(jì)算，它就退出了。線程可以調(diào)用thread.exit()之類的退出函數(shù)，也可以使用Python退出進(jìn)程的標(biāo)準(zhǔn)方法，如sys.exit()或拋出一個(gè)SystemExit異常等。不過(guò)，不可以直接“殺掉”("kill")一個(gè)線程。
        不建議使用thread模塊，很明顯的一個(gè)原因是，當(dāng)主線程退出的時(shí)候，所有其它線程沒(méi)有被清除就退出了。另一個(gè)模塊threading就能確保所有“重要的”子線程都退出后，進(jìn)程才會(huì)結(jié)束。
（3）Python的線程模塊
       Python提供了幾個(gè)用于多線程編程的模塊，包括thread、threading和Queue等。thread和threading模塊允許程序員創(chuàng)建和管理線程。thread模塊提供了基本的線程和鎖的支持，threading提供了更高級(jí)別、功能更強(qiáng)的線程管理的功能。Queue模塊允許用戶創(chuàng)建一個(gè)可以用于多個(gè)線程之間共享數(shù)據(jù)的隊(duì)列數(shù)據(jù)結(jié)構(gòu)。
       避免使用thread模塊，因?yàn)楦呒?jí)別的threading模塊更為先進(jìn)，對(duì)線程的支持更為完善，而且使用thread模塊里的屬性有可能會(huì)與threading出現(xiàn)沖突；其次低級(jí)別的thread模塊的同步原語(yǔ)很少(實(shí)際上只有一個(gè))，而threading模塊則有很多；再者，thread模塊中當(dāng)主線程結(jié)束時(shí)，所有的線程都會(huì)被強(qiáng)制結(jié)束掉，沒(méi)有警告也不會(huì)有正常的清除工作，至少threading模塊能確保重要的子線程退出后進(jìn)程才退出。
3、thread模塊
       thread模塊除了產(chǎn)生線程外，thread模塊也提供了基本的同步數(shù)據(jù)結(jié)構(gòu)鎖對(duì)象（lock object也叫原語(yǔ)鎖、簡(jiǎn)單鎖、互斥鎖、互斥量、二值信號(hào)量）。同步原語(yǔ)與線程的管理是密不可分的。
        常用的線程函數(shù)以及LockType類型的鎖對(duì)象的方法：

  #!/usr/bin/env python 
   
  import thread 
  from time import sleep, ctime 
   
  def loop0(): 
    print '+++start loop 0 at:', ctime() 
    sleep(4) 
    print '+++loop 0 done at:', ctime() 
   
  def loop1(): 
    print '***start loop 1 at:', ctime() 
    sleep(2) 
    print '***loop 1 done at:', ctime() 
   
  def main(): 
    print '------starting at:', ctime() 
    thread.start_new_thread(loop0, ()) 
    thread.start_new_thread(loop1, ()) 
    sleep(6) 
    print '------all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

       thread 模塊提供的簡(jiǎn)單的多線程的機(jī)制，兩個(gè)循環(huán)并發(fā)地被執(zhí)行，總的運(yùn)行時(shí)間為最慢的那個(gè)線程的運(yùn)行時(shí)間（主線程6s），而不是所有的線程的運(yùn)行時(shí)間之和。start_new_thread()要求要有前兩個(gè)參數(shù)，就算想要運(yùn)行的函數(shù)不要參數(shù)，也要傳一個(gè)空的元組。
  

       sleep(6)是讓主線程停下來(lái)，主線程一旦運(yùn)行結(jié)束，就關(guān)閉運(yùn)行著其他兩個(gè)線程。但這可能造成主線程過(guò)早或過(guò)晚退出，那就要使用線程鎖，可以在兩個(gè)子線程都退出后，主線程立即退出。
在CODE上查看代碼片派生到我的代碼片

  #!/usr/bin/env python 
   
  import thread 
  from time import sleep, ctime 
   
  loops = [4, 2] 
   
  def loop(nloop, nsec, lock): 
    print '+++start loop:', nloop, 'at:', ctime() 
    sleep(nsec) 
    print '+++loop:', nloop, 'done at:', ctime() 
    lock.release() 
   
  def main(): 
    print '---starting threads...' 
    locks = [] 
    nloops = range(len(loops)) 
   
    for i in nloops: 
      lock = thread.allocate_lock() 
      lock.acquire() 
      locks.append(lock) 
   
    for i in nloops: 
      thread.start_new_thread(loop,  
        (i, loops[i], locks[i])) 
   
    for i in nloops: 
      while locks[i].locked(): pass 
   
    print '---all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

4、threading模塊
        更高級(jí)別的threading模塊，它不僅提供了Thread類，還提供了各種非常好用的同步機(jī)制。threading 模塊里所有的對(duì)象：

thread模塊不支持守護(hù)線程，當(dāng)主線程退出時(shí)，所有的子線程不論它們是否還在工作，都會(huì)被強(qiáng)行退出。而threading模塊支持守護(hù)線程，守護(hù)線程一般是一個(gè)等待客戶請(qǐng)求的服務(wù)器，如果沒(méi)有客戶提出請(qǐng)求它就在那等著，如果設(shè)定一個(gè)線程為守護(hù)線程，就表示這個(gè)線程是不重要的，在進(jìn)程退出的時(shí)候，不用等待這個(gè)線程退出。如果主線程退出不用等待那些子線程完成，那就設(shè)定這些線程的daemon屬性，即在線程thread.start()開(kāi)始前，調(diào)用setDaemon()函數(shù)設(shè)定線程的daemon標(biāo)志(thread.setDaemon(True))就表示這個(gè)線程“不重要”。如果想要等待子線程完成再退出，那就什么都不用做或者顯式地調(diào)用thread.setDaemon(False)以保證其daemon標(biāo)志為False，可以調(diào)用thread.isDaemon()函數(shù)來(lái)判斷其daemon標(biāo)志的值。新的子線程會(huì)繼承其父線程的daemon標(biāo)志，整個(gè)Python會(huì)在所有的非守護(hù)線程退出后才會(huì)結(jié)束，即進(jìn)程中沒(méi)有非守護(hù)線程存在的時(shí)候才結(jié)束。
（1）threading的Thread類
       它有很多thread模塊里沒(méi)有的函數(shù)，Thread對(duì)象的函數(shù)：

       創(chuàng)建一個(gè)Thread的實(shí)例，傳給它一個(gè)函數(shù)
在CODE上查看代碼片派生到我的代碼片

  #!/usr/bin/env python 
   
  import threading 
  from time import sleep, ctime 
   
  loops = [ 4, 2 ] 
   
  def loop(nloop, nsec): 
    print '+++start loop:', nloop, 'at:', ctime() 
    sleep(nsec) 
    print '+++loop:', nloop, 'done at:', ctime() 
   
  def main(): 
    print '---starting at:', ctime() 
    threads = [] 
    nloops = range(len(loops)) 
   
    for i in nloops: 
      t = threading.Thread(target=loop, 
      args=(i, loops[i])) 
      threads.append(t) 
   
    for i in nloops:      # start threads 
      threads[i].start() 
   
    for i in nloops:      # wait for all 
      threads[i].join()    # threads to finish 
   
    print '---all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

        實(shí)例化一個(gè)Thread(調(diào)用 Thread())與調(diào)用thread.start_new_thread()之間最大的區(qū)別就是，新的線程不會(huì)立即開(kāi)始。在創(chuàng)建線程對(duì)象，但不想馬上開(kāi)始運(yùn)行線程的時(shí)候，這是一個(gè)很有用的同步特性。所有的線程都創(chuàng)建了之后，再一起調(diào)用 start()函數(shù)啟動(dòng)，而不是創(chuàng)建一個(gè)啟動(dòng)一個(gè)。而且也不用再管理一堆鎖（分配鎖、獲得鎖、釋放鎖、檢查鎖的狀態(tài)等），只要簡(jiǎn)單地對(duì)每個(gè)線程調(diào)用join()主線程等待子線程的結(jié)束即可。join()還可以設(shè)置timeout的參數(shù)，即主線程等到超時(shí)為止。
        join()的另一個(gè)比較重要的方面是它可以完全不用調(diào)用，一旦線程啟動(dòng)后，就會(huì)一直運(yùn)行，直到線程的函數(shù)結(jié)束，退出為止。如果主線程除了等線程結(jié)束外，還有其它的事情要做，那就不用調(diào)用 join()，只有在等待線程結(jié)束的時(shí)候才調(diào)用join()。
創(chuàng)建一個(gè)Thread的實(shí)例，傳給它一個(gè)可調(diào)用的類對(duì)象
[html] view plaincopy在CODE上查看代碼片派生到我的代碼片

  #!/usr/bin/env python 
   
  import threading 
  from time import sleep, ctime 
   
  loops = [ 4, 2 ] 
   
  class ThreadFunc(object): 
   
    def __init__(self, func, args, name=''): 
      self.name = name 
      self.func = func 
      self.args = args 
   
    def __call__(self): 
      apply(self.func, self.args) 
   
  def loop(nloop, nsec): 
    print 'start loop', nloop, 'at:', ctime() 
    sleep(nsec) 
    print 'loop', nloop, 'done at:', ctime() 
   
  def main(): 
    print 'starting at:', ctime() 
    threads = [] 
    nloops = range(len(loops)) 
   
    for i in nloops:  # create all threads 
      t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__)) 
      threads.append(t) 
   
    for i in nloops:  # start all threads 
      threads[i].start() 
   
    for i in nloops:  # wait for completion 
      threads[i].join() 
   
    print 'all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

        與傳一個(gè)函數(shù)很相似的另一個(gè)方法是在創(chuàng)建線程的時(shí)候，傳一個(gè)可調(diào)用的類的實(shí)例供線程啟動(dòng)的時(shí)候執(zhí)行，這是多線程編程的一個(gè)更為面向?qū)ο蟮姆椒?。相?duì)于一個(gè)或幾個(gè)函數(shù)來(lái)說(shuō)，類對(duì)象里可以使用類的強(qiáng)大的功能。創(chuàng)建新線程的時(shí)候，Thread對(duì)象會(huì)調(diào)用ThreadFunc對(duì)象，這時(shí)會(huì)用到一個(gè)特殊函數(shù)__call__()。由于已經(jīng)有了要用的參數(shù)，所以就不用再傳到Thread()的構(gòu)造函數(shù)中。由于有一個(gè)參數(shù)的元組，這時(shí)要使用apply()函數(shù)或使用self.res = self.func(*self.args)。
從Thread派生出一個(gè)子類，創(chuàng)建一個(gè)這個(gè)子類的實(shí)例
在CODE上查看代碼片派生到我的代碼片

  #!/usr/bin/env python 
   
  import threading 
  from time import sleep, ctime 
   
  loops = [ 4, 2 ] 
   
  class MyThread(threading.Thread): 
    def __init__(self, func, args, name=''): 
      threading.Thread.__init__(self) 
      self.name = name 
      self.func = func 
      self.args = args 
   
    def getResult(self): 
      return self.res 
   
    def run(self): 
      print 'starting', self.name, 'at:', ctime() 
      self.res = apply(self.func, self.args) 
      print self.name, 'finished at:', ctime() 
   
  def loop(nloop, nsec): 
    print 'start loop', nloop, 'at:', ctime() 
    sleep(nsec) 
    print 'loop', nloop, 'done at:', ctime() 
   
  def main(): 
    print 'starting at:', ctime() 
    threads = [] 
    nloops = range(len(loops)) 
   
    for i in nloops: 
      t = MyThread(loop, (i, loops[i]), 
      loop.__name__) 
      threads.append(t) 
   
    for i in nloops: 
      threads[i].start() 
   
    for i in nloops: 
      threads[i].join() 
   
    print 'all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

     子類化Thread類，MyThread子類的構(gòu)造函數(shù)一定要先調(diào)用基類的構(gòu)造函數(shù)，特殊函數(shù)__call__()在子類中，名字要改為run()。在 MyThread類中，加入一些用于調(diào)試的輸出信息，把代碼保存到myThread模塊中，并導(dǎo)入這個(gè)類。除使用apply()函數(shù)來(lái)運(yùn)行這些函數(shù)之外，還可以把結(jié)果保存到實(shí)現(xiàn)的self.res屬性中，并創(chuàng)建一個(gè)新的函數(shù)getResult()來(lái)得到結(jié)果。
（2）threading模塊中的其它函數(shù)

5、Queue模塊
       常用的 Queue 模塊的屬性：

       Queue模塊可以用來(lái)進(jìn)行線程間通訊，讓各個(gè)線程之間共享數(shù)據(jù)。Queue解決生產(chǎn)者-消費(fèi)者的問(wèn)題，現(xiàn)在創(chuàng)建一個(gè)隊(duì)列，讓生產(chǎn)者線程把新生產(chǎn)的貨物放進(jìn)去供消費(fèi)者線程使用。生產(chǎn)者生產(chǎn)貨物所要花費(fèi)的時(shí)間無(wú)法預(yù)先確定，消費(fèi)者消耗生產(chǎn)者生產(chǎn)的貨物的時(shí)間也是不確定的。
在CODE上查看代碼片派生到我的代碼片

  #!/usr/bin/env python 
   
  from random import randint 
  from time import sleep 
  from Queue import Queue 
  from myThread import MyThread 
   
  def writeQ(queue): 
    print '+++producing object for Q...', 
    queue.put('xxx', 1) 
    print "+++size now:", queue.qsize() 
   
  def readQ(queue): 
    val = queue.get(1) 
    print '---consumed object from Q... size now', \ 
      queue.qsize() 
   
  def writer(queue, loops): 
    for i in range(loops): 
      writeQ(queue) 
      sleep(randint(1, 3)) 
   
  def reader(queue, loops): 
    for i in range(loops): 
      readQ(queue) 
      sleep(randint(2, 5)) 
   
  funcs = [writer, reader] 
  nfuncs = range(len(funcs)) 
   
  def main(): 
    nloops = randint(2, 5) 
    q = Queue(32) 
   
    threads = [] 
    for i in nfuncs: 
      t = MyThread(funcs[i], (q, nloops), \ 
        funcs[i].__name__) 
      threads.append(t) 
   
    for i in nfuncs: 
      threads[i].start() 
   
    for i in nfuncs: 
      threads[i].join() 
   
    print '***all DONE' 
   
  if __name__ == '__main__': 
    main() 

這個(gè)實(shí)現(xiàn)中使用了Queue對(duì)象和隨機(jī)地生產(chǎn)(和消耗)貨物的方式。生產(chǎn)者和消費(fèi)者相互獨(dú)立并且并發(fā)地運(yùn)行，它們不一定是輪流執(zhí)行的（隨機(jī)數(shù)模擬）。writeQ()和readQ()函數(shù)分別用來(lái)把對(duì)象放入隊(duì)列和消耗隊(duì)列中的一個(gè)對(duì)象，在這里使用字符串'xxx'來(lái)表示隊(duì)列中的對(duì)象。writer()函數(shù)就是一次往隊(duì)列中放入一個(gè)對(duì)象，等待一會(huì)然后再做同樣的事，一共做指定的次數(shù)，這個(gè)次數(shù)是由腳本運(yùn)行時(shí)隨機(jī)生成的。reader()函數(shù)做的事比較類似，只是它是用來(lái)消耗對(duì)象的。
6、線程相關(guān)模塊
       多線程相關(guān)的標(biāo)準(zhǔn)庫(kù)模塊：

       三、總結(jié)
（1）一個(gè)要完成多項(xiàng)任務(wù)的程序，可以考慮每個(gè)任務(wù)使用一個(gè)線程，這樣的程序在設(shè)計(jì)上相對(duì)于單線程做所有事的程序來(lái)說(shuō)，更為清晰明了。
（2）單線程的程序在程序性能上的限制，尤其在有相互獨(dú)立、運(yùn)行時(shí)間不確定、多個(gè)任務(wù)的程序里，而把多個(gè)任務(wù)分隔成多個(gè)線程同時(shí)運(yùn)行會(huì)比順序運(yùn)行速度更快。由于Python解釋器是單線程的，所以不是所有的程序都能從多線程中得到好處。
（3）若有不足，請(qǐng)留言，在此先感謝！

最新評(píng)論