python 并发编程 多线程 线程queue

线程queue

线程之间已经是共享数据的，为什么还使用线程queue？

线程需要自己加锁，线程queue帮我们处理好加锁的问题

有三种不同的用法

第一种方法:

class queue.Queue(maxsize=0) #队列：先进先出

put('four',block=,timeout=)

第一个参数： 放入的数据

第二个参数：

block=True 时 队列满了，再放数据不抛出异常，程序卡主，不指定block参数，默认是True

block=false时，队列满了，再放数据，不阻塞，抛出异常

源码

 def put(self, item, block=True, timeout=None):

第三个参数 timeout:

设置队列满后，再放数据发生的阻塞时间，如果过了这个时间，还没有取数据，队列还是满的，就抛出异常，就算block=True也抛出异常

put()

设置只能放3个数据，队列满，再去放第四个数据，程序卡主 阻塞了

默认block参数为True

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

q.put("four")

block=False时候，队列满了，再放数据，不阻塞，抛出异常

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

q.put("four",block=False)

'''
  q.put("four",block=False)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 130, in put
    raise Full
queue.Full
'''

timeout

设置队列满后，再放数据发生的阻塞时间，如果过了这个时间，还没有取数据，队列还是满的，就抛出异常，就算block=True也抛出异常

阻塞3秒，3秒后，队列还满，抛出异常

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

q.put("four",block=True, timeout=3)

'''
  q.put("four",block=True, timeout=3)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 141, in put
    raise Full
queue.Full
'''

q.put_nowait('four') ==  q.put('four', block=False)

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

q.put_nowait('four')

'''
 q.put_nowait('four')
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 184, in put_nowait
    return self.put(item, block=False)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 130, in put
    raise Full
queue.Full
'''

取数据 get()

和put一样

put(block=,timeout=)

第一个参数：

block=True 时 队列取空了数据，再取数据不抛出异常，程序卡主，不指定block参数，默认是True

block=false时，队列取空数据，再取数据，不阻塞，抛出异常

第二个参数

timeout：

设置队列取空数据，再取数据后的阻塞时间，如果过了这个时间，还没有放数据，队列还是空的，就抛出异常，就算block=True也抛出异常

源码

def get(self, block=True, timeout=None):

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())

'''
first
second
third
'''

队列取完后，再去取数据，程序卡主，阻塞了

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())
print(q.get())

block=False时，队列取完后，再去取数据，抛出异常

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())
print((q.get(block=False)))

'''
    print((q.get(block=False)))
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 161, in get
    raise Empty
queue.Empty
'''

q.get_nowait()  == q.get(block=False) 一样

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())
print(q.get_nowait())   # == q.get(block=False)

'''
   print(q.get_nowait())   # == q.get(block=False)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 192, in get_nowait
    return self.get(block=False)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\queue.py", line 161, in get
    raise Empty
queue.Empty
'''

timeout：

设置队列取空数据，再取数据后的阻塞时间，如果过了这个时间，还没有放数据，队列还是空的，就抛出异常，就算block=True也抛出异常

import queue

q = queue.Queue(3)  # 先进先出 --> 队列

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())
print((q.get(block=True, timeout=3)))

第二种方法：

class queue.LifoQueue(maxsize=0) #堆栈：后进先出

用法和Queue类一样

import queue

q = queue.LifoQueue(3)  # 堆栈：后进先出

q.put("first")
q.put("second")
q.put("third")

# 取数据
print(q.get())
print(q.get())
print(q.get())

'''
third
second
first
'''

第三种方法

class queue.PriorityQueue(maxsize=0) #优先级队列：存储数据时可设置优先级的队列

put进入一个元组,元组的第一个元素是优先级
(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
第二个元素是放入的数据，可以是列表，字符串，字典等

import queue

q = queue.PriorityQueue(3)  # 堆栈：后进先出

'''
put进入一个元组,元组的第一个元素是优先级
(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
'''

q.put((40,"first"))
q.put((10,"second"))
q.put((30,"third"))

# 取数据
print(q.get())
print(q.get())
print(q.get())

'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'second')
(30, 'third')
(40, 'first')
'''

结果 数字越小优先级越高,优先级高的优先出队