Python Queue module

This article mainly introduces the Python Queue module. Now I will share it with you. Friends who need it can refer to it

In Python, queues are the most commonly used form of exchanging data between threads. The Queue module is a module that provides queue operations. Although it is simple and easy to use, some accidents may still occur if you are not careful.

Create a "queue" object
import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue class i.e. It is a synchronous implementation of a queue. The queue length can be infinite or finite. The queue length can be set through the optional parameter maxsize of the Queue constructor. If maxsize is less than 1, it means the queue length is unlimited.

Put a value into the queue
q.put(10)
Call the put() method of the queue object to insert a value at the end of the queue project. put() has two parameters. The first item is required and is the value of the inserted item; the second block is an optional parameter and the default is
1. If the queue is currently empty and block is 1, the put() method causes the calling thread to pause until a data unit is vacated. If block is 0, the put method will throw a Full exception.

Remove a value from the queue
q.get()
Call the get() method of the queue object to delete it from the head of the queue and return an item. The optional parameter is block, which defaults to True. If the queue is empty and block is True, get() causes the calling thread to pause until an item becomes available. If the queue is empty and block is False, the queue will throw an Empty exception.

The Python Queue module has three queues and constructors:
1. The FIFO queue of the Python Queue module is first in, first out. class Queue.Queue(maxsize)
2. LIFO is similar to a heap, that is, first in, last out. class Queue.LifoQueue(maxsize)
3. Another method is that the lower the priority queue level, the first it will come out. class Queue.PriorityQueue(maxsize)

Commonly used methods in this package (q = Queue.Queue()):
q.qsize() Return The size of the queue
q.empty() If the queue is empty, return True, otherwise False
q.full() If the queue is full, return True, otherwise False
q.full corresponds to the maxsize size
q.get([block[, timeout]]) Gets the queue, timeout waiting time
q.get_nowait() is equivalent to q.get(False)
Non-blocking q.put(item) writes to the queue, timeout waiting time
q.put_nowait(item) is equivalent to q.put(item, False)
q.task_done() After completing a job, the q.task_done() function sends a Signal
q.join() actually means waiting until the queue is empty before performing other operations

Example:
Implementing a thread continuously Generate a random number into a queue (consider using the Queue module)
Implement a thread to continuously take out odd numbers from the above queue
Implement another thread to continuously take out even numbers from the above queue

#!/usr/bin/env python
#coding:utf8
import random,threading,time
from Queue import Queue
#Producer thread
class Producer(threading.Thread):
  def __init__(self, t_name, queue):
    threading.Thread.__init__(self,name=t_name)
    self.data=queue
  def run(self):
    for i in range(10):  #随机产生10个数字 ，可以修改为任意大小
      randomnum=random.randint(1,99)
      print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), randomnum)
      self.data.put(randomnum) #将数据依次存入队列
      time.sleep(1)
    print "%s: %s finished!" %(time.ctime(), self.getName())
 
#Consumer thread
class Consumer_even(threading.Thread):
  def __init__(self,t_name,queue):
    threading.Thread.__init__(self,name=t_name)
    self.data=queue
  def run(self):
    while 1:
      try:
        val_even = self.data.get(1,5) #get(self, block=True, timeout=None) ,1就是阻塞等待,5是超时5秒
        if val_even%2==0:
          print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(),self.getName(),val_even)
          time.sleep(2)
        else:
          self.data.put(val_even)
          time.sleep(2)
      except:   #等待输入，超过5秒 就报异常
        print "%s: %s finished!" %(time.ctime(),self.getName())
        break
class Consumer_odd(threading.Thread):
  def __init__(self,t_name,queue):
    threading.Thread.__init__(self, name=t_name)
    self.data=queue
  def run(self):
    while 1:
      try:
        val_odd = self.data.get(1,5)
        if val_odd%2!=0:
          print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val_odd)
          time.sleep(2)
        else:
          self.data.put(val_odd)
          time.sleep(2)
      except:
        print "%s: %s finished!" % (time.ctime(), self.getName())
        break
#Main thread
def main():
  queue = Queue()
  producer = Producer('Pro.', queue)
  consumer_even = Consumer_even('Con_even.', queue)
  consumer_odd = Consumer_odd('Con_odd.',queue)
  producer.start()
  consumer_even.start()
  consumer_odd.start()
  producer.join()
  consumer_even.join()
  consumer_odd.join()
  print 'All threads terminate!'
 
if __name__ == '__main__':
  main()

The above is the detailed content of Python Queue module. For more information, please follow other related articles on the PHP Chinese website!