The Producer-Consumer pattern using locks in Python

 The Producer-Consumer pattern using locks in Python

addresses the challenge of coordinating access to a
shared resource (a buffer or queue) between threads
that produce data and threads that consume it.
 This pattern prevents race conditions and ensures
data integrity in concurrent environments.
Core Components:
 Shared Buffer/Queue:
A data structure (e.g., [Link] or a list) that
temporarily stores items produced by producers and
consumed by consumers.
 Lock ([Link]):
A synchronization primitive used to protect the shared
buffer from simultaneous access by multiple
threads. Only one thread can hold the lock at a time,
ensuring mutual exclusion.
 Producer Threads:
 Generate data items.
 Acquire the lock before adding an item to the shared
buffer.
 Add the item to the buffer.
 Release the lock.
 (Optional) If the buffer is full, the producer might wait
until space becomes available (often handled implicitly
 by [Link]'s put method with a timeout or by
using Condition objects).
 Consumer Threads:
 Process data items.
 Acquire the lock before removing an item from the
shared buffer.
 Remove the item from the buffer.
 Release the lock.
 (Optional) If the buffer is empty, the consumer might
wait until items become available (often handled
implicitly by [Link]'s get method with a timeout or
by using Condition objects).
Implementation Example (Conceptual):
import threading
import time
import random
from collections import deque

class ProducerConsumer:
def __init__(self, buffer_size):
[Link] = deque(maxlen=buffer_size)
[Link] = [Link]() # Protects access to the buffer

def producer(self, name):

for i in range(5):
item = f"Item {i} from {name}"
with [Link]: # Acquire lock using a context manager
if len([Link]) < [Link]:
 [Link](item)
print(f"{name} produced: {item}")
else:
print(f"{name} tried to produce but buffer is full.")
[Link]([Link](0.1, 0.5))

def consumer(self, name):

for _ in range(5):
with [Link]: # Acquire lock
if [Link]:
item = [Link]()
print(f"{name} consumed: {item}")
else:
print(f"{name} tried to consume but buffer is
empty.")
[Link]([Link](0.1, 0.5))

if __name__ == "__main__":
pc = ProducerConsumer(buffer_size=3)

producer_thread1 = [Link](target=[Link],
args=("Producer-1",))
consumer_thread1 = [Link](target=[Link],
args=("Consumer-1",))

producer_thread1.start()
consumer_thread1.start()

producer_thread1.join()
consumer_thread1.join()
 print("Producer-Consumer simulation finished.")

Explanation:
 The deque acts as the shared buffer with a maxlen for a
fixed size.
 [Link]() creates a lock object.
 The with [Link]: statement ensures the lock is acquired
before entering the block and automatically released
upon exiting, preventing race conditions when
accessing [Link].
 Producers add items, and consumers remove them. Basic
checks are included for buffer full/empty conditions. For
more robust
waiting/notification, [Link] or [Link] ar
e typically used.
 Producer consumer using lock in python
 The most effective way to implement the producer-
consumer pattern in Python is to use
the [Link] class, which is a thread-safe data
structure that handles all the necessary locking and
synchronization internally.
 This avoids common pitfalls like race conditions or
deadlocks that can occur when manually managing locks
and condition variables.
Producer-Consumer Example using [Link]

This example uses a [Link] and a sentinel value ( None )

to signal the consumer threads to stop.
import threading
import queue
import time
import random

# The shared queue object handles all necessary locking internally

# We can set a maxsize for a bounded buffer, e.g.,
[Link](maxsize=10)
shared_queue = [Link]()
NUM_ITEMS = 10
NUM_CONSUMERS = 2

def producer():
"""Produces items and adds them to the queue."""
for i in range(NUM_ITEMS):
item = [Link](1, 100)
shared_queue.put(item) # put() adds an item
print(f"Producer produced item {item} (Queue size:
{shared_queue.qsize()})")
[Link]([Link]() * 0.5) # Simulate production time
 # Add a sentinel value for each consumer to signal completion
for _ in range(NUM_CONSUMERS):
shared_queue.put(None)
print("Producer finished all items and sent stop signals.")

def consumer(consumer_id):
"""Consumes items from the queue."""
while True:
item = shared_queue.get() # get() removes and returns an item
if item is None:
# Check for the sentinel value to exit the loop
print(f"Consumer {consumer_id} received stop signal, exiting.")
shared_queue.task_done() # Mark the task as done
break

print(f"Consumer {consumer_id} got => {item}")

[Link]([Link]() * 0.5) # Simulate consumption time
shared_queue.task_done() # Mark the task as done

# Main part of the program

if __name__ == "__main__":
producer_thread = [Link](target=producer)
consumer_threads = []
for i in range(NUM_CONSUMERS):
c_thread = [Link](target=consumer, args=(i,))
consumer_threads.append(c_thread)
c_thread.start()

producer_thread.start()

# Wait for the producer to finish

producer_thread.join()

# Wait for all items in the queue to be processed

 # [Link]() blocks until all items have been consumed and
task_done() called
shared_queue.join()

# At this point, all consumer threads should have exited their loops
due to the sentinel value
# The main thread can now safely exit

print("Main thread exiting.")

Key Concepts
 [Link] : The thread-safe shared buffer where producers
put items and consumers get items.
 put() : Adds an item to the queue, blocking if the queue is full.

 get() : Removes and returns an item from the queue, blocking if

the queue is empty.
 task_done() : Signals that a retrieved item has been processed.

 join() : On the queue, blocks until all items are processed. On a

thread, blocks until the thread terminates.
 Sentinel Value ( None ): A special item signaling consumers to
stop.