python線程+隊列（queue）

---恢復內容開始---

python的線程學習

用處 
pocpiliang腳本的編寫

函數式：調用 _thread 模塊中的start_new_thread()函數來產生新線程。語法如下:

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

參數說明:

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

import _thread
import time
為線程定義一個函數
def print_time(threadName,delay):
    i=0
    while i<5:
        time.sleep(delay)
        i=i+1
        print("%s,%s"%(threadName,time.ctime(time.time())))
try:
_thread.start_new_thread(print_time,("first",2,))
_thread.start_new_thread(print_time,("second",4,))
except:
    print("太快了")

我們可以看見 這個線i<5發送四次包 first發兩次  second發一次

 

線程模塊

Python3 通過兩個標准庫 _thread 和 threading 提供對線程的支持。

_thread 提供了低級別的、原始的線程以及一個簡單的鎖，它相比於 threading 模塊的功能還是比較有限的。

threading 模塊除了包含 _thread 模塊中的所有方法外，還提供的其他方法：

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

除了使用方法外，線程模塊同樣提供了Thread類來處理線程，Thread類提供了以下方法:

    run(): 用以表示線程活動的方法。
    start():啟動線程活動。

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

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("開始線程"+self.name)
        print_time(self.name,self.counter,5)
        print("退出線程"+self.name)
def print_time(threadName,delay,counter):
    while counter>0:
        time.sleep(delay)
        print("%s: %s" % (threadName, time.ctime(time.time())))
        counter=counter-1

#創建新線程
thread1 =myThread(1,"第一個線程",1)
thread2 =myThread(2,"第二個線程",2)

# 開啟新線程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主線程")

可以看見這里我們調用線程

 

 

 

 那么接下來重點來了

多線程

多線程的優勢在於可以同時運行多個任務（至少感覺起來是這樣）。但是當線程需要共享數據時，可能存在數據不同步的問題。

考慮這樣一種情況：一個列表里所有元素都是0，線程"set"從后向前把所有元素改成1，而線程"print"負責從前往后讀取列表並打印。

那么，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不同步。為了避免這種情況，引入了鎖的概念。

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 ("開啟線程： " + self.name)
        # 獲取鎖，用於線程同步
        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 ("退出主線程")

 

 

 可以看見是先開始線程1然后線程一完了在開線程二

 

線程優先級隊列（ Queue）

線程優先級隊列（ 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() 實際上意味着等到隊列為空，再執行別的操作

 隊列1 單向先進先出隊列

import queue
#單向隊列
q = queue.Queue(5)
print(q.maxsize)
for i in range(4):
    q.put(i)
print(q.get())
print(q.qsize())
#先進后出隊列

 

 此時q.get()從隊列里面取出來的是0 q.qsize還剩3個所以輸出3

如果代碼改成

import queue
#單向隊列
q = queue.Queue(5)
print(q.maxsize)
for i in range(4):
    q.put(i)
    print(q.get())
print(q.qsize())
#先進后出隊列

 那么將輸出  進一個出一個 那么隊列為空 q.qsize為0

 

 接下來是先進后出隊列

import queue
q =queue.LifoQueue()
for i in range(5):
    q.put(i)
print(q.get())
print(q.qsize())

那么看看運行效果

 

 和我們預想的一樣

接下來是優先級隊列的講解

import queue
q =queue.PriorityQueue()
q.put((5, 5454))
q.put((5, 532566))
q.put((3, 555))
q.put((7, 344))
print(q.get())
print(q.get())

優先級隊列put進去的是一個元祖，(優先級,數據)，優先級數字越小，優先級越高 話不多說我們看代碼

如果有兩個元素優先級是一樣的，那么在出隊的時候是按照先進先出的順序的。

 

 接下來是雙端隊列的講解 看代碼

import queue
q =queue.deque()
for i in range(3):
    q.append(i) 尾部加入
for c in range(5,8):
    q.appendleft(c) 首部加入
q.insert(2,"我是二號位") 任意位置插入
for i in range(10):
    print(q.pop()) 從尾部出