Queue in Python: Create and Use Queues

As you build a Python program that processes items in sequence, a queue holds them until they are retrieved. Python’s queue module includes synchronized FIFO queues, while collections.deque provides a basic FIFO container.

I’ll explain how to create a queue and pair retrieved work with completion tracking. You’ll also learn when priority ordering is useful.

TL;DR: Choose the Right Python Queue

Use queue.Queue for synchronized work shared between threads, and choose collections.deque for a simple FIFO container in one thread.

• Queue() creates an unlimited FIFO queue. Queue(maxsize=n) sets a positive item limit.
• put() adds an item and get() removes the oldest item.
• Call task_done() after processing each retrieved item when join() tracks completion.

What Is a Queue in Python?

A queue stores items for later retrieval according to a chosen order. In a first-in, first-out queue, or FIFO queue, the first item added is the first one returned.

Python’s queue module provides synchronized queues for threads, coordinating producers that add work and consumers that retrieve it.

The module includes FIFO Queue, LIFO LifoQueue, PriorityQueue and SimpleQueue. Queue fits a thread-based work pipeline because it supports transfer and completion tracking.

The standard-library queue module is included with Python and needs no installation. Queue coordinates threads, while collections.deque is a general container with operations at both ends.

How to Use queue.Queue Step by Step

Create a Queue, add work with put(), retrieve it with get(), and mark it complete with task_done(). Then join() waits until the unfinished-task count reaches zero.

Step 1: Create a queue and add work

Import Queue and set maxsize when pending work needs a limit. A positive maximum makes put() wait for space.

This example adds two named tasks to the queue.

from queue import Queue

tasks = Queue(maxsize=2)
tasks.put("email")
tasks.put("report")
print("First task:", tasks.get())
tasks.task_done()
print("Second task:", tasks.get())
tasks.task_done()
tasks.join()
print("All queued tasks are complete")

Run the saved file as python3 queue_demo.py from its workspace. The captured command printed the following:

First task: email
Second task: report
All queued tasks are complete

The first get() returns email because it was added first. Each task_done() decrements the unfinished-task count, and join() returns when that count reaches zero.

Step 2: Pair retrieval with completion

A consumer calls get(), handles the item, then calls task_done(). Put task_done() in a finally block so an error does not leave join() waiting.

Pair each successful get() call with exactly one task_done() call. An extra call raises ValueError because the completion count cannot go below zero. join() waits for queue tasks, not for the worker thread to exit.

For the larger design, see AskPython’s guide to the producer-consumer problem in Python.

Which Python Queue Should You Use?

Choose by the work: deque for a basic FIFO container, Queue for threaded tasks, and PriorityQueue for priority ordering.

• collections.deque: single-container FIFO with append() and popleft().
• queue.Queue: threaded FIFO with task tracking.
• queue.SimpleQueue: threaded FIFO without task tracking.
• queue.PriorityQueue: threaded priority retrieval.
• heapq: single-thread min-heap operations.

Use append() and popleft() for deque FIFO work without task accounting. See AskPython’s list versus deque comparison.

Priority queues order by value

PriorityQueue returns the lowest-valued entry first based on tuple ordering. Store tuples containing comparable priority and task values.

Priority controls retrieval order rather than arrival time.

Equal priorities compare the next tuple field. Add a unique counter before the task when task objects cannot be compared or arrival order should break ties.

Give each entry a distinct counter value.

heapq provides min-heap operations over a list. Use it for local priority scheduling without thread coordination.

Queue Edge Cases to Know

Use a timeout when a thread should wait only for a bounded interval.

A positive maxsize limits pending items. put() waits for space, while put_nowait() raises Full immediately.

Likewise, get(timeout=…) raises Empty when no item arrives in time.

qsize(), empty() and full() are approximate during concurrent access. Another thread can change the state before the next operation, so handle Empty or Full directly.

Queue.empty() checks state but removes no items. Use get() to consume them, and task_done() if join() tracks completion.

Python 3.13 added Queue.shutdown() and ShutDown for stopping additions and draining work. Check the official docs for shutdown modes.

Conclusion: Match the Queue to the Work

Use Queue for synchronized threaded work, deque for basic FIFO storage, and a priority queue when order depends on priority.

• Python queue module documentation
• Python deque documentation
• Python heapq documentation

FAQ

These short answers cover common questions about creating and choosing a Python queue.