آموزش ماژول threading – کلاس Condition

import threading
import time

# Create the Condition object
kitchen_condition = threading.Condition()

def waiter():
    print("[Waiter] I am waiting for the pizza to be ready...")

    with kitchen_condition:
        kitchen_condition.wait()
        print("[Waiter] Awesome! The pizza is ready. Serving it to the customer!")

def chef():
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)  # Simulating cooking time

    with kitchen_condition:
        print("[Chef] Pizza is done! Ringing the bell...")
        # Wake up the waiting waiter
        kitchen_condition.notify()

# Create threads
waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

# Start threads
waiter_thread.start()
chef_thread.start()

import threading
import time

# Create the Condition object
kitchen_condition = threading.Condition()

def waiter():
    print("[Waiter] I am waiting for the pizza to be ready...")

    with kitchen_condition:
        kitchen_condition.wait()
        print("[Waiter] Awesome! The pizza is ready. Serving it to the customer!")

def chef():
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)  # Simulating cooking time

    with kitchen_condition:
        print("[Chef] Pizza is done! Ringing the bell...")
        # Wake up the waiting waiter
        kitchen_condition.notify()

# Create threads
waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

# Start threads
waiter_thread.start()
chef_thread.start()

import threading
import time

# Create the Condition object
kitchen_condition = threading.Condition()

# A variable to check if food is ready
is_pizza_ready = False

def waiter():
    global is_pizza_ready
    print("[Waiter] I am waiting for the pizza to be ready...")

    with kitchen_condition:
        # Wait until pizza is ready
        while is_pizza_ready == False:
            kitchen_condition.wait()

        print("[Waiter] Awesome! The pizza is ready. Serving it to the customer!")

def chef():
    global is_pizza_ready
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)  # Simulating cooking time

    with kitchen_condition:
        is_pizza_ready = True
        print("[Chef] Pizza is done! Ringing the bell...")
        # Wake up the waiting waiter
        kitchen_condition.notify()

# Create threads
waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

# Start threads
waiter_thread.start()
chef_thread.start()

import threading
import time

# Create the Condition object
kitchen_condition = threading.Condition()

# A variable to check if food is ready
is_pizza_ready = False

def waiter():
    global is_pizza_ready
    print("[Waiter] I am waiting for the pizza to be ready...")

    with kitchen_condition:
        # Wait until pizza is ready
        while is_pizza_ready == False:
            kitchen_condition.wait()

        print("[Waiter] Awesome! The pizza is ready. Serving it to the customer!")

def chef():
    global is_pizza_ready
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)  # Simulating cooking time

    with kitchen_condition:
        is_pizza_ready = True
        print("[Chef] Pizza is done! Ringing the bell...")
        # Wake up the waiting waiter
        kitchen_condition.notify()

# Create threads
waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

# Start threads
waiter_thread.start()
chef_thread.start()

import threading
import time

kitchen_condition = threading.Condition()

def waiter():
    # The waiter is busy with something else before going to the kitchen
    print("[Waiter] Doing some other tasks. I will be late for 2 seconds...")
    time.sleep(2)

    print("[Waiter] Now I am waiting for the pizza to be ready...")
    with kitchen_condition:
        kitchen_condition.wait()   # The waiter sleeps here forever!
        print("[Waiter] Awesome! The pizza is ready. Serving it!")

def chef():
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)

    with kitchen_condition:
        print("[Chef] Pizza is done! Ringing the bell...")
        kitchen_condition.notify()   # The chef rings the bell and leaves

waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

waiter_thread.start()
chef_thread.start()

import threading
import time

kitchen_condition = threading.Condition()

def waiter():
    # The waiter is busy with something else before going to the kitchen
    print("[Waiter] Doing some other tasks. I will be late for 2 seconds...")
    time.sleep(2)

    print("[Waiter] Now I am waiting for the pizza to be ready...")
    with kitchen_condition:
        kitchen_condition.wait()   # The waiter sleeps here forever!
        print("[Waiter] Awesome! The pizza is ready. Serving it!")

def chef():
    print("[Chef] I am making the pizza. It takes 1 seconds...")
    time.sleep(1)

    with kitchen_condition:
        print("[Chef] Pizza is done! Ringing the bell...")
        kitchen_condition.notify()   # The chef rings the bell and leaves

waiter_thread = threading.Thread(target=waiter)
chef_thread = threading.Thread(target=chef)

waiter_thread.start()
chef_thread.start()

import threading
import time

kitchen_condition = threading.Condition()
pizzas_available = 0

def buggy_waiter(name):
    global pizzas_available
    print(f"[{name}] Waiting for pizza...")

    with kitchen_condition:
        if pizzas_available == 0:                # BUG: using if instead of while
            print(f"[{name}] Plate is empty. Going to wait...")
            kitchen_condition.wait()

        print(f"[{name}] I woke up! Let's take the pizza.")

        if pizzas_available > 0:
            pizzas_available -= 1
            print(f"[{name}] Yummy! I ate the pizza.")
        else:
            print(f"[{name}] ERROR: Where is the pizza? Plate is empty! (Condition Stolen)")

def chef():
    global pizzas_available
    time.sleep(1)  # cooking time
    with kitchen_condition:
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters

w1 = threading.Thread(target=buggy_waiter, args=("Waiter 1",))
w2 = threading.Thread(target=buggy_waiter, args=("Waiter 2",))
c = threading.Thread(target=chef)

w1.start()
w2.start()
c.start()

import threading
import time

kitchen_condition = threading.Condition()
pizzas_available = 0

def buggy_waiter(name):
    global pizzas_available
    print(f"[{name}] Waiting for pizza...")

    with kitchen_condition:
        if pizzas_available == 0:                # BUG: using if instead of while
            print(f"[{name}] Plate is empty. Going to wait...")
            kitchen_condition.wait()

        print(f"[{name}] I woke up! Let's take the pizza.")

        if pizzas_available > 0:
            pizzas_available -= 1
            print(f"[{name}] Yummy! I ate the pizza.")
        else:
            print(f"[{name}] ERROR: Where is the pizza? Plate is empty! (Condition Stolen)")

def chef():
    global pizzas_available
    time.sleep(1)  # cooking time
    with kitchen_condition:
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters

w1 = threading.Thread(target=buggy_waiter, args=("Waiter 1",))
w2 = threading.Thread(target=buggy_waiter, args=("Waiter 2",))
c = threading.Thread(target=chef)

w1.start()
w2.start()
c.start()

import threading
import time

kitchen_condition = threading.Condition()
pizzas_available = 0

def correct_waiter(name):
    global pizzas_available
    print(f"[{name}] Waiting for pizza...")

    with kitchen_condition:
        # Correct approach: use while
        while pizzas_available == 0:
            print(f"[{name}] Plate is empty. Going to wait...")
            kitchen_condition.wait()

        pizzas_available -= 1
        # When the thread wakes up, it continues from the line after wait()
        print(f"[{name}] I woke up! Let's take the pizza.")

def chef():
    global pizzas_available
    time.sleep(1)  # cooking time
    with kitchen_condition:
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters

w1 = threading.Thread(target=correct_waiter, args=("Waiter 1",))
w2 = threading.Thread(target=correct_waiter, args=("Waiter 2",))
c = threading.Thread(target=chef)

w1.start()
w2.start()
c.start()

import threading
import time

kitchen_condition = threading.Condition()
pizzas_available = 0

def correct_waiter(name):
    global pizzas_available
    print(f"[{name}] Waiting for pizza...")

    with kitchen_condition:
        # Correct approach: use while
        while pizzas_available == 0:
            print(f"[{name}] Plate is empty. Going to wait...")
            kitchen_condition.wait()

        pizzas_available -= 1
        # When the thread wakes up, it continues from the line after wait()
        print(f"[{name}] I woke up! Let's take the pizza.")

def chef():
    global pizzas_available
    time.sleep(1)  # cooking time
    with kitchen_condition:
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters

w1 = threading.Thread(target=correct_waiter, args=("Waiter 1",))
w2 = threading.Thread(target=correct_waiter, args=("Waiter 2",))
c = threading.Thread(target=chef)

w1.start()
w2.start()
c.start()

import threading
import time

condition = threading.Condition()
job_queue = []

def worker(worker_id):
    while True:
        with condition:
            while not job_queue:            # nothing to do yet
                condition.wait()            # sleep until a job arrives
            job = job_queue.pop(0)
        if job is None:                     # shutdown signal
            print(f"worker {worker_id} stopping")
            break
        print(f"worker {worker_id} processing {job}")
        time.sleep(0.2)

def dispatcher(jobs):
    for j in jobs:
        with condition:
            job_queue.append(j)
            condition.notify()              # wake one worker
        time.sleep(0.1)
    with condition:
        job_queue.append(None)              # tell the worker to stop
        condition.notify()

w = threading.Thread(target=worker, args=(1,))
d = threading.Thread(target=dispatcher, args=(['job-a', 'job-b', 'job-c'],))

w.start()
d.start()
w.join()
d.join()

import threading
import time

condition = threading.Condition()
job_queue = []

def worker(worker_id):
    while True:
        with condition:
            while not job_queue:            # nothing to do yet
                condition.wait()            # sleep until a job arrives
            job = job_queue.pop(0)
        if job is None:                     # shutdown signal
            print(f"worker {worker_id} stopping")
            break
        print(f"worker {worker_id} processing {job}")
        time.sleep(0.2)

def dispatcher(jobs):
    for j in jobs:
        with condition:
            job_queue.append(j)
            condition.notify()              # wake one worker
        time.sleep(0.1)
    with condition:
        job_queue.append(None)              # tell the worker to stop
        condition.notify()

w = threading.Thread(target=worker, args=(1,))
d = threading.Thread(target=dispatcher, args=(['job-a', 'job-b', 'job-c'],))

w.start()
d.start()
w.join()
d.join()

import threading
import time

BUFFER_MAX = 3
buffer = []
condition = threading.Condition()

def producer():
    for i in range(6):
        with condition:
            while len(buffer) == BUFFER_MAX:      # no free space
                print("buffer full, producer waits")
                condition.wait()
            buffer.append(i)
            print(f"produced {i}, buffer={buffer}")
            condition.notify()                    # wake a waiting consumer
        time.sleep(0.05)

def consumer():
    count = 0
    while count < 6:
        with condition:
            while not buffer:                     # nothing to consume
                condition.wait()
            item = buffer.pop(0)
            print(f"consumed {item}, buffer={buffer}")
            condition.notify()                    # wake a waiting producer
        count += 1
        time.sleep(0.2)

p = threading.Thread(target=producer)
c = threading.Thread(target=consumer)
p.start()
c.start()
p.join()
c.join()

import threading
import time

BUFFER_MAX = 3
buffer = []
condition = threading.Condition()

def producer():
    for i in range(6):
        with condition:
            while len(buffer) == BUFFER_MAX:      # no free space
                print("buffer full, producer waits")
                condition.wait()
            buffer.append(i)
            print(f"produced {i}, buffer={buffer}")
            condition.notify()                    # wake a waiting consumer
        time.sleep(0.05)

def consumer():
    count = 0
    while count < 6:
        with condition:
            while not buffer:                     # nothing to consume
                condition.wait()
            item = buffer.pop(0)
            print(f"consumed {item}, buffer={buffer}")
            condition.notify()                    # wake a waiting producer
        count += 1
        time.sleep(0.2)

p = threading.Thread(target=producer)
c = threading.Thread(target=consumer)
p.start()
c.start()
p.join()
c.join()

import threading
import time

main_lock = threading.Lock()
item_condition = threading.Condition()
item_ready = False

def consumer():
    print("Consumer: Waiting to acquire the main warehouse lock...")
    with main_lock:               # Acquire the outer lock (first)
        print("Consumer: Acquired the main warehouse lock. Now waiting for the item.")
        with item_condition:      # Acquire the inner lock (second)
            while not item_ready:
                print("Consumer: Calling wait()...")
                item_condition.wait()   # <--- The deadlock happens here!
            print("Consumer: Item picked up!")

def producer():
    time.sleep(1)                 # Wait for the consumer to acquire the lock first
    global item_ready
    print("Producer: I want to put the item in the warehouse. Waiting for the main lock...")

    with main_lock:               # Producer gets stuck here!
        with item_condition:
            item_ready = True
            item_condition.notify()
            print("Producer: Item is ready and notification sent.")

t1 = threading.Thread(target=consumer)
t2 = threading.Thread(target=producer)

t1.start()
t2.start()

import threading
import time

main_lock = threading.Lock()
item_condition = threading.Condition()
item_ready = False

def consumer():
    print("Consumer: Waiting to acquire the main warehouse lock...")
    with main_lock:               # Acquire the outer lock (first)
        print("Consumer: Acquired the main warehouse lock. Now waiting for the item.")
        with item_condition:      # Acquire the inner lock (second)
            while not item_ready:
                print("Consumer: Calling wait()...")
                item_condition.wait()   # <--- The deadlock happens here!
            print("Consumer: Item picked up!")

def producer():
    time.sleep(1)                 # Wait for the consumer to acquire the lock first
    global item_ready
    print("Producer: I want to put the item in the warehouse. Waiting for the main lock...")

    with main_lock:               # Producer gets stuck here!
        with item_condition:
            item_ready = True
            item_condition.notify()
            print("Producer: Item is ready and notification sent.")

t1 = threading.Thread(target=consumer)
t2 = threading.Thread(target=producer)

t1.start()
t2.start()

def chef():
    global pizzas_available
    with kitchen_condition:
        time.sleep(1)  # cooking time
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters

def chef():
    global pizzas_available
    with kitchen_condition:
        time.sleep(1)  # cooking time
        pizzas_available += 1
        print("[Chef] Made exactly 1 pizza! Waking up ALL waiters...")
        kitchen_condition.notify_all()   # wake up all waiters