Queue is a thread-safe queue (FIFO) implementation in the python standard library. It provides a first-in-first-out data structure suitable for multi-thread programming, that is, a queue, which is used in producers Information transfer between consumer threads
class Queue.Queue(maxsize=0)
FIFO is First in First Out, first in, first out. Queue provides a basic FIFO container, which is very simple to use. maxsize is an integer, indicating the upper limit of the number of data that can be stored in the queue. Once the limit is reached, the insertion will cause blocking until the data in the queue is consumed. If maxsize is less than or equal to 0, there is no limit on the queue size.
Give a chestnut:
1 import Queue2 3 q = Queue.Queue()4 5 for i in range(5):6 q.put(i)7 8 while not q.empty():9 print q.get()
Output:
01 2 3 4
class Queue.LifoQueue(maxsize=0)
LIFO is Last in First Out, last in first out. Similar to the stack, it is also very simple to use. The usage of maxsize is the same as above.
Another example:
1 import Queue2 3 q = Queue.LifoQueue()4 5 for i in range(5):6 q.put(i)7 8 while not q.empty():9 print q.get()
Output:
4 3 2 10
You can see that just replace the Queue.Quenu class
with the Queue.LifiQueue class
class Queue.PriorityQueue(maxsize=0)
Construct a priority queue. The usage of maxsize is the same as above.
import Queueimport threadingclass Job(object):def __init__(self, priority, description): self.priority = priority self.description = descriptionprint 'Job:',descriptionreturndef __cmp__(self, other):return cmp(self.priority, other.priority) q = Queue.PriorityQueue() q.put(Job(3, 'level 3 job')) q.put(Job(10, 'level 10 job')) q.put(Job(1, 'level 1 job'))def process_job(q):while True: next_job = q.get()print 'for:', next_job.description q.task_done() workers = [threading.Thread(target=process_job, args=(q,)), threading.Thread(target=process_job, args=(q,)) ]for w in workers: w.setDaemon(True) w.start() q.join() 结果 Job: level 3 job Job: level 10 job Job: level 1 jobfor: level 1 jobfor: level 3 jobfor: job: level 10 job
means one that was previously added to the team Mission accomplished. Called by the queue's consumer thread. Each get() call gets a task, and the following task_done() call tells the queue that the task has been processed.
If the current join() is blocking, it will resume execution when all tasks in the queue are processed (that is, each task enqueued by put() has a corresponding task_done() transfer).
Blocks the calling thread until all tasks in the queue are processed.
As long as data is added to the queue, the number of unfinished tasks will increase. When the consumer thread calls task_done() (meaning that a consumer obtains the task and completes the task), the number of unfinished tasks will be reduced. When the number of unfinished tasks drops to 0, join() unblocks.
Put item into the queue.
If the optional parameter block is True and timeout is an empty object (default, blocking call, no timeout).
If timeout is a positive integer, the calling process will be blocked for up to timeout seconds. If there is no empty space available, a Full exception (blocking call with timeout) will be thrown.
If block is False, if there is free space available, the data will be put into the queue, otherwise a Full exception will be thrown immediately
Its non-blocking version Is put_nowait
equivalent to put(item, False)
put method
get(False)
The above is the detailed content of Detailed explanation of Python's queue module. For more information, please follow other related articles on the PHP Chinese website!