Category: Tutorials

A deadlock may be described as a concurrency failure mode. It is a situation in a program where one or more threads wait for a condition that never occurs. As a result, the threads are unable to progress and the program is stuck or frozen and must be terminated manually.

Deadlock situation may arise in many ways in your concurrent program. Deadlocks are never not developed intentionally, instead, they are in fact a side effect or bug in the code.

Common causes of thread deadlocks are listed below −

• A thread that attempts to acquire the same mutex lock twice.
• Threads that wait on each other (e.g. A waits on B, B waits on A).
• When a thread that fails to release a resource such as lock, semaphore, condition, event, etc.
• Threads that acquire mutex locks in different orders (e.g. fail to perform lock ordering).

How to Avoid Deadlocks in Python Threads

When multiple threads in a multi-threaded application attempt to access the same resource, such as performing read/write operations on the same file, it can lead to data inconsistency. Therefore, it is important to synchronize concurrent access to resources by using locking mechanisms.

The Python threading module provides a simple-to-implement locking mechanism to synchronize threads. You can create a new lock object by calling the Lock() class, which initializes the lock in an unlocked state.

Locking Mechanism with the Lock Object

An object of the Lock class has two possible states − locked or unlocked, initially in unlocked state when first created. A lock doesn’t belong to any particular thread.

The Lock class defines acquire() and release() methods.

The acquire() Method

The acquire() method of the Lock class changes the lock’s state from unlocked to locked. It returns immediately unless the optional blocking argument is set to True, in which case it waits until the lock is acquired.

Here is the Syntax of this method −

Lock.acquire(blocking, timeout)

Where,

• blocking − If set to False, it means do not block. If a call with blocking set to True would block, return False immediately; otherwise, set the lock to locked and return True.
• timeout − Specifies a timeout period for acquiring the lock.

The return value of this method is True if the lock is acquired successfully; False if not.

The release() Method

When the state is locked, this method in another thread changes it to unlocked. This can be called from any thread, not only the thread which has acquired the lock

Following is the Syntax of the release() method −

Lock.release()

The release() method should only be called in the locked state. If an attempt is made to release an unlocked lock, a RuntimeError will be raised.

When the lock is locked, reset it to unlocked, and return. If any other threads are blocked waiting for the lock to become unlocked, allow exactly one of them to proceed. There is no return value of this method.

Example

In the following program, two threads try to call the synchronized() method. One of them acquires the lock and gains the access while the other waits. When the run() method is completed for the first thread, the lock is released and the synchronized method is available for second thread.

When both the threads join, the program comes to an end.

from threading import Thread, Lock
import time

lock=Lock()
threads=[]classmyThread(Thread):def__init__(self,name):
  Thread.__init__(self)
  self.name=name
   defrun(self):
  lock.acquire()
  synchronized(self.name)
  lock.release()defsynchronized(threadName):print("{} has acquired lock and is running synchronized method".format(threadName))
   counter=5while counter:print('**', end='')
  time.sleep(2)
  counter=counter-1print('\nlock released for', threadName)
t1=myThread('Thread1')
t2=myThread('Thread2')

t1.start()
threads.append(t1)

t2.start()
threads.append(t2)for t in threads:
   t.join()print("end of main thread")

It will produce the following output −

Thread1 has acquired lock and is running synchronized method
**********
lock released for Thread1
Thread2 has acquired lock and is running synchronized method
**********
lock released for Thread2
end of main thread

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Semaphore Object for Synchronization

In addition to locks, Python threading module supports semaphores, which offering another synchronization technique. It is one of the oldest synchronization techniques invented by a well-known computer scientist, Edsger W. Dijkstra.

The basic concept of semaphore is to use an internal counter which is decremented by each acquire() call and incremented by each release() call. The counter can never go below zero; when acquire() finds that it is zero, it blocks, waiting until some other thread calls release().

The Semaphore class in threading module defines acquire() and release() methods.

The acquire() Method

If the internal counter is larger than zero on entry, decrement it by one and return True immediately.

If the internal counter is zero on entry, block until awoken by a call to release(). Once awoken (and the counter is greater than 0), decrement the counter by 1 and return True. Exactly one thread will be awoken by each call to release(). The order in which threads awake is arbitrary.

If blocking parameter is set to False, do not block. If a call without an argument would block, return False immediately; otherwise, do the same thing as when called without arguments, and return True.

The release() Method

Release a semaphore, incrementing the internal counter by 1. When it was zero on entry and other threads are waiting for it to become larger than zero again, wake up n of those threads.

Example

This example demonstrates how to use a Semaphore object in Python to control access to a shared resource among multiple threads, for avoiding deadlock in Python’s multi-threaded program.

Open Compiler

from threading import*import time

# creating thread instance where count = 3
lock = Semaphore(4)# creating instancedefsynchronized(name):# calling acquire method
   lock.acquire()for n inrange(3):print('Hello! ', end ='')
  time.sleep(1)print( name)# calling release method
  lock.release()# creating multiple thread
thread_1 = Thread(target = synchronized , args =('Thread 1',))
thread_2 = Thread(target = synchronized , args =('Thread 2',))
thread_3 = Thread(target = synchronized , args =('Thread 3',))# calling the threads
thread_1.start()
thread_2.start()
thread_3.start()

It will produce the following output −

Hello! Hello! Hello! Thread 1
Hello! Thread 2
Thread 3
Hello! Hello! Thread 1
Hello! Thread 3
Thread 2
Hello! Hello! Thread 1
Thread 3
Thread 2

Inter-Thread Communication refers to the process of enabling communication and synchronization between threads within a Python multi-threaded program.

Generally, threads in Python share the same memory space within a process, which allows them to exchange data and coordinate their activities through shared variables, objects, and specialized synchronization mechanisms provided by the threading module.

To facilitate inter-thread communication, the threading module provides various synchronization primitives like, Locks, Events, Conditions, and Semaphores objects. In this tutorial you will learn how to use the Event and Condition object for providing the communication between threads in a multi-threaded program.

The Event Object

An Event object manages the state of an internal flag so that threads can wait or set. Event object provides methods to control the state of this flag, allowing threads to synchronize their activities based on shared conditions.

The flag is initially false and becomes true with the set() method and reset to false with the clear() method. The wait() method blocks until the flag is true.

Following are the key methods of the Event object −

• is_set(): Return True if and only if the internal flag is true.
• set(): Set the internal flag to true. All threads waiting for it to become true are awakened. Threads that call wait() once the flag is true will not block at all.
• clear(): Reset the internal flag to false. Subsequently, threads calling wait() will block until set() is called to set the internal flag to true again.
• wait(timeout=None): Block until the internal flag is true. If the internal flag is true on entry, return immediately. Otherwise, block until another thread calls set() to set the flag to true, or until the optional timeout occurs. When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds.

Example

The following code attempts to simulate the traffic flow being controlled by the state of traffic signal either GREEN or RED.

There are two threads in the program, targeting two different functions. The signal_state() function periodically sets and resets the event indicating change of signal from GREEN to RED.

The traffic_flow() function waits for the event to be set, and runs a loop till it remains set.

Open Compiler

from threading import Event, Thread
import time

terminate =Falsedefsignal_state():global terminate
whilenot terminate:
    time.sleep(0.5)print("Traffic Police Giving GREEN Signal")
    event.set()
    time.sleep(1)print("Traffic Police Giving RED Signal")
    event.clear()deftraffic_flow():global terminate
num =0while num <10andnot terminate:print("Waiting for GREEN Signal")
    event.wait()print("GREEN Signal ... Traffic can move")while event.is_set()andnot terminate:
        num +=1print("Vehicle No:", num," Crossing the Signal")
        time.sleep(1)print("RED Signal ... Traffic has to wait")
event = Event()
t1 = Thread(target=signal_state)
t2 = Thread(target=traffic_flow)
t1.start()
t2.start()# Terminate the threads after some time
time.sleep(5)
terminate =True# join all threads to complete
t1.join()
t2.join()print("Exiting Main Thread")

Output

On executing the above code you will get the following output −

Waiting for GREEN Signal
Traffic Police Giving GREEN Signal
GREEN Signal ... Traffic can move
Vehicle No: 1  Crossing the Signal
Traffic Police Giving RED Signal
RED Signal ... Traffic has to wait
Waiting for GREEN Signal
Traffic Police Giving GREEN Signal
GREEN Signal ... Traffic can move
Vehicle No: 2  Crossing the Signal
Vehicle No: 3  Crossing the Signal
Traffic Police Giving RED Signal
Traffic Police Giving GREEN Signal
Vehicle No: 4  Crossing the Signal
Traffic Police Giving RED Signal
RED Signal ... Traffic has to wait
Traffic Police Giving GREEN Signal
Traffic Police Giving RED Signal
Exiting Main Thread

The Condition Object

The Condition object in Python’s threading module provides a more advanced synchronization mechanism. It allows threads to wait for a notification from another thread before proceeding. The Condition object are always associated with a lock and provide mechanisms for signaling between threads.

Following is the syntax of the threading.Condition() class −

threading.Condition(lock=None)

Below are the key methods of the Condition object −

• acquire(*args): Acquire the underlying lock. This method calls the corresponding method on the underlying lock; the return value is whatever that method returns.
• release(): Release the underlying lock. This method calls the corresponding method on the underlying lock; there is no return value.
• wait(timeout=None): This method releases the underlying lock, and then blocks until it is awakened by a notify() or notify_all() call for the same condition variable in another thread, or until the optional timeout occurs. Once awakened or timed out, it re-acquires the lock and returns.
• wait_for(predicate, timeout=None): This utility method may call wait() repeatedly until the predicate is satisfied, or until a timeout occurs. The return value is the last return value of the predicate and will evaluate to False if the method timed out.
• notify(n=1): This method wakes up at most n of the threads waiting for the condition variable; it is a no-op if no threads are waiting.
• notify_all(): Wake up all threads waiting on this condition. This method acts like notify(), but wakes up all waiting threads instead of one. If the calling thread has not acquired the lock when this method is called, a RuntimeError is raised.

Example

This example demonstrates a simple form of inter-thread communication using the Condition object of the Python’s threading module. Here thread_a and thread_b are communicated using a Condition object, the thread_a waits until it receives a notification from thread_b. the thread_b sleeps for 2 seconds before notifying thread_a and then finishes.

Open Compiler

from threading import Condition, Thread
import time

c = Condition()defthread_a():print("Thread A started")with c:print("Thread A waiting for permission...")
    c.wait()print("Thread A got permission!")print("Thread A finished")defthread_b():print("Thread B started")with c:
    time.sleep(2)print("Notifying Thread A...")
    c.notify()print("Thread B finished")
Thread(target=thread_a).start()
Thread(target=thread_b).start()

Output

On executing the above code you will get the following output −

Thread A started
Thread A waiting for permission...
Thread B started
Notifying Thread A...
Thread B finished
Thread A got permission!
Thread A finished

Example

Here is another code demonstrating how the Condition object is used for providing the communication between threads. In this, the thread t2 runs the taskB() function, and the thread t1 runs the taskA() function. The t1 thread acquires the condition and notifies it.

By that time, the t2 thread is in a waiting state. After the condition is released, the waiting thread proceeds to consume the random number generated by the notifying function.

Open Compiler

from threading import Condition, Thread
import time
import random

numbers =[]deftaskA(c):for _ inrange(5):with c:
        num = random.randint(1,10)print("Generated random number:", num)
        numbers.append(num)print("Notification issued")
        c.notify()
    time.sleep(0.3)deftaskB(c):for i inrange(5):with c:print("waiting for update")whilenot numbers: 
            c.wait()print("Obtained random number", numbers.pop())
    time.sleep(0.3)
c = Condition()
t1 = Thread(target=taskB, args=(c,))
t2 = Thread(target=taskA, args=(c,))
t1.start()
t2.start()
t1.join()
t2.join()print("Done")

When you execute this code, it will produce the following output −

waiting for update
Generated random number: 2
Notification issued
Obtained random number 2
Generated random number: 5
Notification issued
waiting for update
Obtained random number 5
Generated random number: 1
Notification issued
waiting for update
Obtained random number 1
Generated random number: 9
Notification issued
waiting for update
Obtained random number 9
Generated random number: 2
Notification issued
waiting for update
Obtained random number 2
Done

In Python, when multiple threads are working concurrently with shared resources, it’s important to synchronize their access to maintain data integrity and program correctness. Synchronizing threads in python can be achieved using various synchronization primitives provided by the threading module, such as locks, conditions, semaphores, and barriers to control access to shared resources and coordinate the execution of multiple threads.

In this tutorial, we’ll learn about various synchronization primitives provided by Python’s threading module.

Thread Synchronization using Locks

The lock object in the Python’s threading module provide the simplest synchronization primitive. They allow threads to acquire and release locks around critical sections of code, ensuring that only one thread can execute the protected code at a time.

A new lock is created by calling the Lock() method, which returns a lock object. The lock can be acquired using the acquire(blocking) method, which force the threads to run synchronously. The optional blocking parameter enables you to control whether the thread waits to acquire the lock and released using the release() method.

Example

The following example demonstrates how to use locks (the threading.Lock() method) to synchronize threads in Python, ensuring that multiple threads access shared resources safely and correctly.

Open Compiler

import threading

counter =10defincrement(theLock, N):global counter
   for i inrange(N):
  theLock.acquire()
  counter +=1
  theLock.release()
lock = threading.Lock()
t1 = threading.Thread(target=increment, args=[lock,2])
t2 = threading.Thread(target=increment, args=[lock,10])
t3 = threading.Thread(target=increment, args=[lock,4])

t1.start()
t2.start()
t3.start()# Wait for all threads to completefor thread in(t1, t2, t3):
   thread.join()print("All threads have completed")print("The Final Counter Value:", counter)

Output

When the above code is executed, it produces the following output −

All threads have completed
The Final Counter Value: 26

Condition Objects for Synchronizing Python Threads

Condition variables enable threads to wait until notified by another thread. They are useful for providing communication between the threads. The wait() method is used to block a thread until it is notified by another thread through notify() or notify_all().

Example

This example demonstrates how Condition objects can synchronize threads using the notify() and wait() methods.

Open Compiler

import threading

counter =0# Consumer functiondefconsumer(cv):global counter
   with cv:print("Consumer is waiting")
  cv.wait()# Wait until notified by incrementprint("Consumer has been notified. Current Counter value:", counter)# increment functiondefincrement(cv, N):global counter
   with cv:print("increment is producing items")for i inrange(1, N +1):
     counter += i  # Increment counter by i# Notify the consumer 
  cv.notify()print("Increment has finished")# Create a Condition object
cv = threading.Condition()# Create and start threads
consumer_thread = threading.Thread(target=consumer, args=[cv])
increment_thread = threading.Thread(target=increment, args=[cv,5])

consumer_thread.start()
increment_thread.start()

consumer_thread.join()
increment_thread.join()print("The Final Counter Value:", counter)

Output

On executing the above program, it will produce the following output −

Consumer is waiting
increment is producing items
Increment has finished
Consumer has been notified. Current Counter value: 15
The Final Counter Value: 15

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Synchronizing threads using the join() Method

The join() method in Python’s threading module is used to wait until all threads have completed their execution. This is a straightforward way to synchronize the main thread with the completion of other threads.

Example

This demonstrates synchronization of threads using the join() method to ensure that the main thread waits for all started threads to complete their work before proceeding.

Open Compiler

import threading
import time

classMyThread(threading.Thread):def__init__(self, threadID, name, counter):
  threading.Thread.__init__(self)
  self.threadID = threadID
  self.name = name
  self.counter = counter
  
   defrun(self):print("Starting "+ self.name)    
  print_time(self.name, self.counter,3)defprint_time(threadName, delay, counter):while counter:
  time.sleep(delay)print("%s: %s"%(threadName, time.ctime(time.time())))
  counter -=1
  
threads =[]# Create new threads
thread1 = MyThread(1,"Thread-1",1)
thread2 = MyThread(2,"Thread-2",2)# Start the new Threads
thread1.start()
thread2.start()# Join the threads
thread1.join()
thread2.join()print("Exiting Main Thread")

Output

On executing the above program, it will produce the following output −

Starting Thread-1
Starting Thread-2
Thread-1: Mon Jul  1 16:05:14 2024
Thread-2: Mon Jul  1 16:05:15 2024
Thread-1: Mon Jul  1 16:05:15 2024
Thread-1: Mon Jul  1 16:05:16 2024
Thread-2: Mon Jul  1 16:05:17 2024
Thread-2: Mon Jul  1 16:05:19 2024
Exiting Main Thread

Additional Synchronization Primitives

In addition to the above synchronization primitives, Python’s threading module offers: −

• RLocks (Reentrant Locks): A variant of locks that allow a thread to acquire the same lock multiple times before releasing it, useful in recursive functions or nested function calls.
• Semaphores:Similar to locks but with a counter. Threads can acquire the semaphore up to a certain limit defined during initialization. Semaphores are useful for limiting access to resources with a fixed capacity.
• Barriers: Allows a fixed number of threads to synchronize at a barrier point and continue executing only when all threads have reached that point. Barriers are useful for coordinating a group of threads that must all complete a certain phase of execution before any of them can proceed further.

Daemon threads in Python are useful for running background tasks that are not critical to the program’s operation. They allow you to run tasks in the background without worrying about keeping track of them.

Python provides two types of threads: non-daemon and daemon threads. By default, threads are non-daemon threads. This tutorial provides a detailed explanation with relevant examples about daemon threads in Python programming.

Overview of Daemon Threads

Sometimes, it is necessary to execute a task in the background. A special type of thread is used for background tasks, called a daemon thread. In other words, daemon threads execute tasks in the background. These threads handle non-critical tasks that may be useful to the application but do not hamper it if they fail or are canceled mid-operation.

Also, a daemon thread will not have control over when it is terminated. The program will terminate once all non-daemon threads finish, even if there are daemon threads still running at that point of time.

Difference Between Daemon & Non-Daemon Threads

Daemon threads can perform tasks such as −

• Create a file that stores Log information in the background.
• Perform web scraping in the background.
• Save the data automatically into a database in the background.

Creating a Daemon Thread in Python

To create a daemon thread, you need to set the daemon property to True of the Thread constructor.

t1=threading.Thread(daemon=True)

By default the daemon property is set to None, If you change it to not None, daemon explicitly sets whether the thread is daemonic.

Example

Take a look at the following example to create a daemon thread and check whether the thread daemonic or not using the daemon attribute.

Open Compiler

import threading 
from time import sleep

# function to be executed in a new threaddefrun():# get the current thread
   thread = threading.current_thread()# is it a daemon thread?print(f'Daemon thread: {thread.daemon}')# Create a new thread and set it as daemon
thread = threading.Thread(target=run, daemon=True)# start the thread
thread.start()print('Is Main Thread is Daemon thread:', threading.current_thread().daemon)# Block for a short time to allow the daemon thread to run
sleep(0.5)

It will produce the following output −

Daemon thread: True
Is Main Thread is Daemon thread: False

If a thread object is created in the main thread without any parameters, then the created thread will be a non-daemon thread because the main thread is not a daemon thread. Therefore, all threads created in the main thread default to non-daemon. However, we can change the daemon property to True by using the Thread.daemon attribute before starting the thread, nothing but before calling the start() method.

Example

Here is an example −

Open Compiler

import threading 
from time import sleep

# function to be executed in a new threaddefrun():# get the current thread
   thread = threading.current_thread()# is it a daemon thread?print(f'Daemon thread: {thread.daemon}')# Create a new thread  
thread = threading.Thread(target=run)# Using the daemon property set the thread as daemon before starting the thread
thread.daemon =True# start the thread
thread.start()print('Is Main Thread is Daemon thread:', threading.current_thread().daemon)# Block for a short time to allow the daemon thread to run
sleep(0.5)

On executing the above program, we will get the following output −

Daemon thread: True
Is Main Thread is Daemon thread: False

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Managing the Daemon Thread Attribute

If you attempt to set the daemon status of a thread after starting it, then a RuntimeError will be raised.

Example

Here is another example that demonstrates the getting the RuntimeError when you try to set the daemon status of a thread after starting it.

Open Compiler

from time import sleep
from threading import current_thread
from threading import Thread

# function to be executed in a new threaddefrun():# get the current thread
   thread = current_thread()# is it a daemon thread?print(f'Daemon thread: {thread.daemon}')
   thread.daemon =True# create a new thread
thread = Thread(target=run)# start the new thread
thread.start()# block for a 0.5 sec for daemon thread to run
sleep(0.5)

It will produce the following output −

Daemon thread: False
Exception in thread Thread-1 (run):
Traceback (most recent call last):
   . . . .
   . . . .
thread.daemon = True
  File "/usr/lib/python3.10/threading.py", line 1203, in daemon
raise RuntimeError("cannot set daemon status of active thread")
RuntimeError: cannot set daemon status of active thread

In Python, currently thread priority is not directly supported by the threading module. unlike Java, Python does not support thread priorities, thread groups, or certain thread control mechanisms like destroying, stopping, suspending, resuming, or interrupting threads.

Even thought Python threads are designed simple and is loosely based on Java’s threading model. This is because of Python’s Global Interpreter Lock (GIL), which manages Python threads.

However, you can simulate priority-based behavior using techniques such as sleep durations, custom scheduling logic within threads or using the additional module which manages task priorities.

Setting the Thread Priority Using Sleep()

You can simulate thread priority by introducing delays or using other mechanisms to control the execution order of threads. One common approach to simulate thread priority is by adjusting the sleep duration of your threads.

Threads with a lower priority sleep longer, and threads with a high priority sleep shorter.

Example

Here’s a simple example to demonstrate how to customize the thread priorities using the delays in Python threads. In this example, Thread-2 completes before Thread-1 because it has a lower priority value, resulting in a shorter sleep time.

Open Compiler

import threading
import time

classDummyThread(threading.Thread):def__init__(self, name, priority):
  threading.Thread.__init__(self)
  self.name = name
  self.priority = priority
   defrun(self):
  name = self.name
  time.sleep(1.0* self.priority)print(f"{name} thread with priority {self.priority} is running")# Creating threads with different priorities
t1 = DummyThread(name='Thread-1', priority=4)
t2 = DummyThread(name='Thread-2', priority=1)# Starting the threads
t1.start()
t2.start()# Waiting for both threads to complete
t1.join()
t2.join()print('All Threads are executed')

Output

On executing the above program, you will get the following results −

Thread-2 thread with priority 1 is running
Thread-1 thread with priority 4 is running
All Threads are executed

Adjusting Python Thread Priority on Windows

On Windows Operating system you can manipulate the thread priority using the ctypes module, This is one of the Python’s standard module used for interacting with the Windows API.

Example

This example demonstrates how to manually set the priority of threads in Python on a Windows system using the ctypes module.

import threading
import ctypes
import time

# Constants for Windows API
w32 = ctypes.windll.kernel32
SET_THREAD =0x20
PRIORITIZE_THE_THREAD =1classMyThread(threading.Thread):def__init__(self, start_event, name, iterations):super().__init__()
  self.start_event = start_event
  self.thread_id =None
  self.iterations = iterations
  self.name = name
   defset_priority(self, priority):ifnot self.is_alive():print('Cannot set priority for a non-active thread')return

  thread_handle = w32.OpenThread(SET_THREAD,False, self.thread_id)
  success = w32.SetThreadPriority(thread_handle, priority)
  w32.CloseHandle(thread_handle)ifnot success:print('Failed to set thread priority:', w32.GetLastError())defrun(self):
  self.thread_id = w32.GetCurrentThreadId()
  self.start_event.wait()while self.iterations:print(f"{self.name} running")
     start_time = time.time()while time.time()- start_time <1:pass
     self.iterations -=1# Create an event to synchronize thread start
start_event = threading.Event()# Create threads
thread_normal = MyThread(start_event, name='normal', iterations=4)
thread_high = MyThread(start_event, name='high', iterations=4)# Start the threads
thread_normal.start()
thread_high.start()# Adjusting priority of 'high' thread
thread_high.set_priority(PRIORITIZE_THE_THREAD)# Trigger thread execution
start_event.set()

Output

While executing this code in your Python interpreter, you will get the following results −

high running
normal running
high running
normal running
high running
normal running
high running
normal running

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Prioritizing Python Threads Using the Queue Module

The queue module in Python’s standard library is useful in threaded programming when information must be exchanged safely between multiple threads. The Priority Queue class in this module implements all the required locking semantics.

With a priority queue, the entries are kept sorted (using the heapq module) and the lowest valued entry is retrieved first.

The Queue objects have following methods to control the Queue −

• get() − The get() removes and returns an item from the queue.
• put() − The put adds item to a queue.
• qsize() − The qsize() returns the number of items that are currently in the queue.
• empty() − The empty( ) returns True if queue is empty; otherwise, False.
• full() − the full() returns True if queue is full; otherwise, False.

queue.PriorityQueue(maxsize=0)

This is the Constructor for a priority queue. maxsize is an integer that sets the upper limit on the number of items that can be placed in the queue. If maxsize is less than or equal to zero, the queue size is infinite.

The lowest valued entries are retrieved first (the lowest valued entry is the one that would be returned by min(entries)). A typical pattern for entries is a tuple in the form −

(priority_number, data)

Example

This example demonstrates the use of the PriorityQueue class in the queue module to manage task priorities between the two threads.

Open Compiler

from time import sleep
from random import random, randint
from threading import Thread
from queue import PriorityQueue

queue = PriorityQueue()defproducer(queue):print('Producer: Running')for i inrange(5):# create item with priority
  value = random()
  priority = randint(0,5)
  item =(priority, value)
  queue.put(item)# wait for all items to be processed
   queue.join()

   queue.put(None)print('Producer: Done')defconsumer(queue):print('Consumer: Running')whileTrue:# get a unit of work
  item = queue.get()if item isNone:break
  sleep(item[1])print(item)
  queue.task_done()print('Consumer: Done')
producer = Thread(target=producer, args=(queue,))
producer.start()

consumer = Thread(target=consumer, args=(queue,))
consumer.start()

producer.join()
consumer.join()

Output

On execution, It will produce the following output −

Producer: Running
Consumer: Running
(0, 0.15332707626852804)
(2, 0.4730737391435892)
(2, 0.8679231358257962)
(3, 0.051924220435665025)
(4, 0.23945882716108446)
Producer: Done
Consumer: Done