python

Python中，队列是线程间最常用的交换数据的形式。queue模块是提供队列操作的模块，虽然简单易用，但是不小心的话，还是会出现一些意外。

1、queue简单说明

#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''
 queue队列：常用在多线程里面，能够直接在线程安全的在多个线程之间进行数据交换，不需要当参数传递
 
 class queue.Queue(maxsize=0)  #先进先出
 class queue.LifoQueue(maxsize=0)  #后进先出 last in first out
 class queue.PriorityQueue(maxsize=0)  #存储数据时可以设置优先级的队列
 
 队列中可以存放任意类型数据
 
 队列常用方法：
    put(x)  将x存储到队列，存不下就就会阻塞，timeout设置阻塞超时时间，不设置会一直阻塞
    put_nowait(x)  不阻塞，放不进去就报错
    get()  从队列中取出一个值（先进先出），其余的跟put一样
    get_nowait()  从队列中取出一个值，队列没有值时直接报错
    full()  判断队列是否满了
    empty()  判断队列是否为空
    qsize()  返回队列实际的长度(存了多少个值)
    
'''

import queue

class Human(object):
    def __init__(self,n):
        self.n = n

print('33[31;1m 先进先出队列Queue 33[0m')
q = queue.Queue(maxsize=3)   #队列中最多存储几个值,可以不加maxsize
# q.get() #get是阻塞函数，当队列里面没有数据时，就会一直等待
# q.get(timeout=3)   # 阻塞3秒，没有数据就报错
# q.get_nowait()  #不阻塞，没有数据就直接报错 queue.Empty Error
q.put([1,2,'a',[5,6]])  #这里传入的列表在队列中只是一个数据
q.put(1)

h = Human(2)
q.put(h)
print(q.full())   # full 判断队列是否存满了  empty 判断队列是否为空
# q.put(4,timeout=2)

print('33[31;1m 先进后出队列LifoQueue 33[0m')

lq = queue.LifoQueue()
for i in range(5):
    lq.put(i)
print('LifoQueue values:',lq) #LifoQueue values: <queue.LifoQueue object at 0x0000022EA3959DA0>
print('取第一个值：',lq.get())

print('33[31;1m 设置优先级队列PriorityQueue 33[0m')
pq = queue.PriorityQueue()
pq.put((1,'asb'))
pq.put((10,223))     #优先级和数据以元组两个值的形式传递给put，因为put第二个参数默认是timeout
pq.put((8,[1,5]))
pq.put((3,(1,'c')))

print(pq.get())
print(pq.get())
print(pq.get())
print(pq.get())
'''
(1, 'asb')
(3, (1, 'c'))
(8, [1, 5])
(10, 223)
'''

　　执行结果

 先进先出队列Queue 
True
 先进后出队列LifoQueue 
LifoQueue values: <queue.LifoQueue object at 0x000001C9D6CE3CC0>
取第一个值： 4
 设置优先级队列PriorityQueue 
(1, 'asb')
(3, (1, 'c'))
(8, [1, 5])
(10, 223)

2、queue简单使用

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import queue
import threading
import time

def get_value(i,q):
    time.sleep(2)
    value = q.get()
    print('线程[%s]获取的值：%s' %(i,value))

if __name__ == '__main__':
    q = queue.Queue()
    for i in range(20):
        q.put(i**2)

    thread_list = []
    for i in range(20):
        t = threading.Thread(target=get_value,args=[i,q,])
        t.start()
        thread_list.append(t)

    for i in thread_list:
        i.join()

print('33[32;1m ----main thread end----33[0m')

　　执行结果

线程[3]获取的值：0
线程[2]获取的值：1
线程[1]获取的值：4
线程[0]获取的值：9
线程[18]获取的值：16
线程[19]获取的值：25
线程[17]获取的值：36
线程[10]获取的值：49
线程[15]获取的值：64
线程[14]获取的值：81
线程[12]获取的值：100
线程[16]获取的值：121
线程[11]获取的值：144
线程[9]获取的值：169
线程[8]获取的值：196
线程[7]获取的值：225
线程[5]获取的值：256
线程[13]获取的值：289
线程[6]获取的值：324
线程[4]获取的值：361
 ----main thread end----

3、基于queue的生产者消费者模型

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import threading
import queue
import time

def customer(n):
    while True:
        # print('hello')
        print("33[32;1m customer [%s] 33[0m get task: %s" % (n,q.get()))
            #消费者线程第一次执行到get时会阻塞，所以每次都是生产者在前面
        time.sleep(1)
        q.task_done()  #每个从队列里面取值的线程执行结束后，都会通知队列说任务结束

def producer(n):
    count = 1
    while True:
        print("producer [%s] producted a new task: %s " %(n,count))
        q.put(count)
        count += 1
        q.join()  #当队列里面还有值就处于阻塞状态，没值时就会解除阻塞(阻塞状态是不占用任何资源的)
        print('all task has benn cosumed by consumers...')


if __name__ == '__main__':
    q = queue.Queue()
    thread_list = [] #用来存放所有的线程，目的是后面的join，让父线程等这些线程结束后再结束

    for i in range(3):
        c = threading.Thread(target=customer,args=[i,])
        c.start()
        thread_list.append(c)

    for i in range(2):
        p = threading.Thread(target=producer,args=[i,])
        p.start()
        thread_list.append(p)

    for thread in thread_list:
        thread.join()


    # print("33[32;1m ----main thread end---- 33[0m")

　　执行结果

producer [0] producted a new task: 1 
 customer [0]  get task: 1
producer [1] producted a new task: 1 
 customer [1]  get task: 1
all task has benn cosumed by consumers...
all task has benn cosumed by consumers...
producer [0] producted a new task: 2 
producer [1] producted a new task: 2 
 customer [2]  get task: 2
 customer [1]  get task: 2
all task has benn cosumed by consumers...
all task has benn cosumed by consumers...
producer [0] producted a new task: 3 
producer [1] producted a new task: 3 
 customer [0]  get task: 3
 customer [1]  get task: 3
all task has benn cosumed by consumers...
producer [0] producted a new task: 4 
 customer [2]  get task: 4
all task has benn cosumed by consumers...
all task has benn cosumed by consumers...
producer [0] producted a new task: 5 
producer [1] producted a new task: 4 
 customer [0]  get task: 4
 customer [1]  get task: 5