How to Implement Backpressure Pause Producer with a Bounded Queue in Python

import threading
import time
import queue
import random


class Producer:
    def __init__(self, q):
        self.q = q
        self.running = True

    def produce(self):
        while self.running:
            item = random.randint(1, 100)
            try:
                self.q.put(item, timeout=0.5)
                print(f"Produced: {item}, qsize={self.q.qsize()}", flush=True)
            except queue.Full:
                print(f"Backpressure: queue full (size={self.q.qsize()}), pausing...", flush=True)
                time.sleep(0.2)  # simulated backpressure pause

    def stop(self):
        self.running = False


def consumer(q, num_items):
    for _ in range(num_items):
        item = q.get()
        time.sleep(0.1)  # simulate processing
        q.task_done()
        print(f"Consumed: {item}", flush=True)


if __name__ == "__main__":
    q = queue.Queue(maxsize=3)
    p = Producer(q)
    producer_thread = threading.Thread(target=p.produce)
    producer_thread.start()

    consumer_thread = threading.Thread(target=consumer, args=(q, 8))
    consumer_thread.start()
    consumer_thread.join()
    p.stop()
    producer_thread.join()