隊列queue 多應用在多線程場景，多線程訪問共享變量。

對於多線程而言，訪問共享變量時，隊列queue的線程安全的。

因為queue使用了一個線程鎖(pthread.Lock())，以及三個條件變量(pthread.condition()),來保證了線程安全。

總結：隊列提供了一個安全可靠的共享數據使用方案。

###queue的初始化函數###
def __init__(self, maxsize=0):
        self.maxsize = maxsize
        self._init(maxsize)
        
        # mutex must be held whenever the queue is mutating.  All methods    
        # that acquire mutex must release it before returning.  mutex    
        # is shared between the three conditions, so acquiring and    
        # releasing the conditions also acquires and releases mutex.  
          
        self.mutex = _threading.Lock()   
         
        # Notify not_empty whenever an item is added to the queue; a    
        # thread waiting to get is notified then.    
        
        self.not_empty = _threading.Condition(self.mutex)    
        
        # Notify not_full whenever an item is removed from the queue;    
        # a thread waiting to put is notified then.    
        
        self.not_full = _threading.Condition(self.mutex)    
        
        # Notify all_tasks_done whenever the number of unfinished tasks    
        # drops to zero; thread waiting to join() is notified to resume   
         
        self.all_tasks_done = _threading.Condition(self.mutex)    
        self.unfinished_tasks = 0

二、隊列數據存取規則：

###例子一：先進先出###
import queue
q = queue.Queue()
for i in range(5):
    q.put(i)
    
for i in range(5):
    print(q.get(),end=" ")
#---結果---
0 1 2 3 4 

###例子二：後進先出###
import queue
q = queue.LifoQueue()
for i in range(5):
    q.put(i)
for i in range(5):
    print(q.get(),end=" ")
#---結果---
4 3 2 1 0

###例子三：按優先標誌位讀取###
#參考其它資料，看到許多講述優先級隊列的實現，但是我覺得直接用元組的方式比較簡單粗暴。
import queue
p = queue.PriorityQueue()
p.put((3,"3"))
p.put((1,"1"))
p.put((4,"4"))
p.put((2,"2"))

for i in range(3):
    print(p.get())
#---結果：按元組索引0排序---    
(1, '1')
(2, '2')
(3, '3')
(4, '4')
    
    
###例子四：多元組判斷###   
import queue

p = queue.PriorityQueue()

p.put((1,4,"a"))
p.put((2,1,"666"))
p.put((1,3,"4"))
p.put((2,2,"2"))


for i in range(3):
    print(p.get())   
#-----結果：元組對應的序號進行比較，主鍵是序號0，越往後，優先度越低。-----
(1, 3, '4')
(1, 4, 'a')
(2, 1, '666')
(2, 2, '2')

三、隊列的常用方法和屬性：

四、隊列數據進出規則實例 ：

也是一個最簡單的生產者消費者例子。

'''例子一：隊列基本的進出規則'''


import queue,time,threading,random

def productor(name,s):                        # 生產者函數，向隊列裏放產品
	time.sleep(s)
	print ('服務員{}有時間了'.format(name))
	q.put(name)

def customer():                               # 消費者函數，從隊列裏取產品
	s = q.get()
	print ('服務員{}被叫走了'.format(s))


l = []
q = queue.LifoQueue()        # 後進先出，把LifoQueue改成Queue，先進先出。

for i in range(5):
	n = random.randint(1,7)
	t = threading.Thread(target=productor,args=(i,n))    # 生產線程
	l.append(t)
	t.start()

for i in l:
	i.join()
	customer()
	
	
	        
#-----運行結果：因為有Random，所以結果不固定，主要觀察消費順序。------
服務員0有時間了
服務員0被叫走了

服務員1有時間了
服務員1被叫走了

服務員4有時間了
服務員3有時間了
服務員2有時間了

服務員2被叫走了
服務員3被叫走了
服務員4被叫走了

參考資料：

http://python.jobbole.com/87592/

https://www.2cto.com/kf/201608/540910.html

https://www.cnblogs.com/itogo/p/5635629.html

[python模塊]隊列queue