python2.7入門---多線程

    多線程相似於同時執行多個不一樣程序，多線程運行有以下優勢：

 

• 使用線程能夠把佔據長時間的程序中的任務放到後臺去處理。
• 用戶界面能夠更加吸引人，這樣好比用戶點擊了一個按鈕去觸發某些事件的處理，能夠彈出一個進度條來顯示處理的進度
• 程序的運行速度可能加快
• 在一些等待的任務實現上如用戶輸入、文件讀寫和網絡收發數據等，線程就比較有用了。在這種狀況下咱們能夠釋放一些珍貴的資源如內存佔用等等。

    線程在執行過程當中與進程仍是有區別的。每一個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。可是線程不可以獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。每一個線程都有他本身的一組CPU寄存器，稱爲線程的上下文，該上下文反映了線程上次運行該線程的CPU寄存器的狀態。指令指針和堆棧指針寄存器是線程上下文中兩個最重要的寄存器，線程老是在進程獲得上下文中運行的，這些地址都用於標誌擁有線程的進程地址空間中的內存。

 

• 線程能夠被搶佔（中斷）。
• 在其餘線程正在運行時，線程能夠暫時擱置（也稱爲睡眠） -- 這就是線程的退讓。

    Python中使用線程有兩種方式：函數或者用類來包裝線程對象。首先是，函數式：調用thread模塊中的start_new_thread()函數來產生新線程。語法以下：

 

thread.start_new_thread ( function, args[, kwargs] )

    參數說明以下：

 

• function - 線程函數。
• args - 傳遞給線程函數的參數,他必須是個tuple類型。
• kwargs - 可選參數。

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
 
    import thread
    import time
 
    # 爲線程定義一個函數
    def print_time( threadName, delay):
       count = 0
       while count < 5:
          time.sleep(delay)
          count += 1
          print "%s: %s" % ( threadName, time.ctime(time.time()) )
 
    # 建立兩個線程
    try:
       thread.start_new_thread( print_time, ("Thread-1", 2, ) )
       thread.start_new_thread( print_time, ("Thread-2", 4, ) )
    except:
       print "Error: unable to start thread"
 
    while 1:
       pass

    執行以上程序輸出結果以下：

 

Thread-1: Thu Jan 22 15:42:17 2009 Thread-1: Thu Jan 22 15:42:19 2009 Thread-2: Thu Jan 22 15:42:19 2009 Thread-1: Thu Jan 22 15:42:21 2009 Thread-2: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:25 2009 Thread-2: Thu Jan 22 15:42:27 2009 Thread-2: Thu Jan 22 15:42:31 2009 Thread-2: Thu Jan 22 15:42:35 2009

    線程的結束通常依靠線程函數的天然結束；也能夠在線程函數中調用thread.exit()，他拋出SystemExit exception，達到退出線程的目的。

    Python經過兩個標準庫thread和threading提供對線程的支持。thread提供了低級別的、原始的線程以及一個簡單的鎖。threading 模塊提供的其餘方法：

 

• threading.currentThread(): 返回當前的線程變量。
• threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啓動後、結束前，不包括啓動前和終止後的線程。
• threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。

    除了使用方法外，線程模塊一樣提供了Thread類來處理線程，Thread類提供瞭如下方法：

 

• run(): 用以表示線程活動的方法。
• start():啓動線程活動。
• join([time]): 等待至線程停止。這阻塞調用線程直至線程的join() 方法被調用停止-正常退出或者拋出未處理的異常-或者是可選的超時發生。
• isAlive(): 返回線程是否活動的。
• getName(): 返回線程名。
• setName(): 設置線程名。

    咱們接下來使用Threading模塊建立線程，直接從threading.Thread繼承，而後重寫__init__方法和run方法：

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-  import threading import time  exitFlag = 0  class myThread (threading.Thread): #繼承父類threading.Thread  def __init__(self, threadID, name, counter):  threading.Thread.__init__(self)  self.threadID = threadID  self.name = name  self.counter = counter  def run(self): #把要執行的代碼寫到run函數裏面 線程在建立後會直接運行run函數  print "Starting " + self.name  print_time(self.name, self.counter, 5)  print "Exiting " + self.name  def print_time(threadName, delay, counter):  while counter:  if exitFlag:  (threading.Thread).exit()  time.sleep(delay)  print "%s: %s" % (threadName, time.ctime(time.time()))  counter -= 1  # 建立新線程 thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2)  # 開啓線程 thread1.start() thread2.start()  print "Exiting Main Thread" 

    以上程序執行結果以下：

 

Starting Thread-1 Starting Thread-2 Exiting Main Thread Thread-1: Thu Mar 21 09:10:03 2013 Thread-1: Thu Mar 21 09:10:04 2013 Thread-2: Thu Mar 21 09:10:04 2013 Thread-1: Thu Mar 21 09:10:05 2013 Thread-1: Thu Mar 21 09:10:06 2013 Thread-2: Thu Mar 21 09:10:06 2013 Thread-1: Thu Mar 21 09:10:07 2013 Exiting Thread-1 Thread-2: Thu Mar 21 09:10:08 2013 Thread-2: Thu Mar 21 09:10:10 2013 Thread-2: Thu Mar 21 09:10:12 2013 Exiting Thread-2

    咱們再來看線程同步。若是多個線程共同對某個數據修改，則可能出現不可預料的結果，爲了保證數據的正確性，須要對多個線程進行同步。使用Thread對象的Lock和Rlock能夠實現簡單的線程同步，這兩個對象都有acquire方法和release方法，對於那些須要每次只容許一個線程操做的數據，能夠將其操做放到acquire和release方法之間。以下：多線程的優點在於能夠同時運行多個任務（至少感受起來是這樣）。可是當線程須要共享數據時，可能存在數據不一樣步的問題。考慮這樣一種狀況：一個列表裏全部元素都是0，線程"set"從後向前把全部元素改爲1，而線程"print"負責從前日後讀取列表並打印。

    那麼，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不一樣步。爲了不這種狀況，引入了鎖的概念。鎖有兩種狀態——鎖定和未鎖定。每當一個線程好比"set"要訪問共享數據時，必須先得到鎖定；若是已經有別的線程好比"print"得到鎖定了，那麼就讓線程"set"暫停，也就是同步阻塞；等到線程"print"訪問完畢，釋放鎖之後，再讓線程"set"繼續。通過這樣的處理，打印列表時要麼所有輸出0，要麼所有輸出1，不會再出現一半0一半1的尷尬場面。

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-  import threading import time  class myThread (threading.Thread):  def __init__(self, threadID, name, counter):  threading.Thread.__init__(self)  self.threadID = threadID  self.name = name  self.counter = counter  def run(self):  print "Starting " + self.name  # 得到鎖，成功得到鎖定後返回True  # 可選的timeout參數不填時將一直阻塞直到得到鎖定  # 不然超時後將返回False  threadLock.acquire()  print_time(self.name, self.counter, 3)  # 釋放鎖  threadLock.release()  def print_time(threadName, delay, counter):  while counter:  time.sleep(delay)  print "%s: %s" % (threadName, time.ctime(time.time()))  counter -= 1  threadLock = threading.Lock() threads = []  # 建立新線程 thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2)  # 開啓新線程 thread1.start() thread2.start()  # 添加線程到線程列表 threads.append(thread1) threads.append(thread2)  # 等待全部線程完成 for t in threads:  t.join() print "Exiting Main Thread" 

    咱們再來看線程優先級隊列（ Queue）。Python的Queue模塊中提供了同步的、線程安全的隊列類，包括FIFO（先入先出)隊列Queue，LIFO（後入先出）隊列。LifoQueue，和優先級隊列PriorityQueue。這些隊列都實現了鎖原語，可以在多線程中直接使用。可使用隊列來實現線程間的同步。咱們來看Queue模塊中的經常使用方法：

 

• Queue.qsize() 返回隊列的大小
• Queue.empty() 若是隊列爲空，返回True,反之False
• Queue.full() 若是隊列滿了，返回True,反之False
• Queue.full 與 maxsize 大小對應
• Queue.get([block[, timeout]])獲取隊列，timeout等待時間
• Queue.get_nowait() 至關Queue.get(False)
• Queue.put(item) 寫入隊列，timeout等待時間
• Queue.put_nowait(item) 至關Queue.put(item, False)
• Queue.task_done() 在完成一項工做以後，Queue.task_done()函數向任務已經完成的隊列發送一個信號
• Queue.join() 實際上意味着等到隊列爲空，再執行別的操做

    

#!/usr/bin/python
# -*- coding: UTF-8 -*-  import Queue import threading import time  exitFlag = 0  class myThread (threading.Thread):  def __init__(self, threadID, name, q):  threading.Thread.__init__(self)  self.threadID = threadID  self.name = name  self.q = q  def run(self):  print "Starting " + self.name  process_data(self.name, self.q)  print "Exiting " + self.name  def process_data(threadName, q):  while not exitFlag:  queueLock.acquire()  if not workQueue.empty():  data = q.get()  queueLock.release()  print "%s processing %s" % (threadName, data)  else:  queueLock.release()  time.sleep(1)  threadList = ["Thread-1", "Thread-2", "Thread-3"] nameList = ["One", "Two", "Three", "Four", "Five"] queueLock = threading.Lock() workQueue = Queue.Queue(10) threads = [] threadID = 1  # 建立新線程 for tName in threadList:  thread = myThread(threadID, tName, workQueue)  thread.start()  threads.append(thread)  threadID += 1  # 填充隊列 queueLock.acquire() for word in nameList:  workQueue.put(word) queueLock.release() # 等待隊列清空 while not workQueue.empty(): pass # 通知線程是時候退出 exitFlag = 1 # 等待全部線程完成 for t in threads: t.join() print "Exiting Main Thread" 

    以上程序執行結果爲：

 

Starting Thread-1 Starting Thread-2 Starting Thread-3 Thread-1 processing One Thread-2 processing Two Thread-3 processing Three Thread-1 processing Four Thread-2 processing Five Exiting Thread-3 Exiting Thread-1 Exiting Thread-2 Exiting Main Thread

    好啦，到這裏，此次就分享結束了。若是感受不錯的話，請多多點贊支持哦。。。

　　原文連接：https://blog.csdn.net/luyaran/article/details/80004436