73. Using threading.Event

Here are 10 Python code snippets demonstrating how to use threading.Event for synchronizing threads in Python’s threading module.

---

1. Basic Usage of threading.Event

This example shows how to create an event and set it in one thread, while other threads wait for the event.

import threading
import time

def wait_for_event(event):
    print("Thread waiting for event to be set...")
    event.wait()
    print("Event is set, thread continues execution!")

event = threading.Event()

# Creating a thread that will wait for the event
thread = threading.Thread(target=wait_for_event, args=(event,))
thread.start()

# Simulate some work before setting the event
time.sleep(3)
print("Setting the event now...")
event.set()
thread.join()

---

2. Multiple Threads Waiting for an Event

This example demonstrates how multiple threads can wait for the same event to be set.

import threading
import time

def wait_for_event(event, thread_name):
    print(f"{thread_name} waiting for event...")
    event.wait()
    print(f"{thread_name} continues execution!")

event = threading.Event()

# Creating multiple threads that will wait for the same event
threads = [threading.Thread(target=wait_for_event, args=(event, f"Thread-{i}")) for i in range(3)]

for t in threads:
    t.start()

# Setting the event after a delay
time.sleep(2)
print("Setting the event now...")
event.set()

for t in threads:
    t.join()

---

3. Using clear() to Reset the Event

The clear() method resets the event to its initial state, causing threads to wait again until it is set.

import threading
import time

def wait_for_event(event, thread_name):
    print(f"{thread_name} waiting for event...")
    event.wait()
    print(f"{thread_name} received the event!")

event = threading.Event()

# Creating multiple threads
threads = [threading.Thread(target=wait_for_event, args=(event, f"Thread-{i}")) for i in range(3)]

for t in threads:
    t.start()

# Setting and clearing the event
time.sleep(2)
print("Setting the event...")
event.set()
time.sleep(1)
print("Clearing the event...")
event.clear()

for t in threads:
    t.join()

---

4. Timeout on wait() Method

Threads can wait for an event with a timeout, allowing them to stop waiting after a certain period if the event is not set.

import threading
import time

def wait_for_event_with_timeout(event):
    print("Thread waiting for event (with timeout)...")
    event_is_set = event.wait(timeout=2)
    if event_is_set:
        print("Event was set!")
    else:
        print("Timed out while waiting for the event.")

event = threading.Event()

# Creating and starting the thread
thread = threading.Thread(target=wait_for_event_with_timeout, args=(event,))
thread.start()

# The thread will timeout as the event is not set within the timeout period
thread.join()

---

5. Event Synchronization in a Producer-Consumer Model

Here’s an example where a producer thread sets an event after producing an item, and consumer threads wait for the event to consume it.

import threading
import time

def producer(event):
    print("Producer producing an item...")
    time.sleep(2)
    print("Item produced, setting event.")
    event.set()

def consumer(event):
    print("Consumer waiting for event...")
    event.wait()
    print("Consumer consumes the item!")

event = threading.Event()

# Starting producer and consumer threads
producer_thread = threading.Thread(target=producer, args=(event,))
consumer_thread = threading.Thread(target=consumer, args=(event,))

producer_thread.start()
consumer_thread.start()

producer_thread.join()
consumer_thread.join()

---

6. Multiple Events for Multiple Conditions

In this example, we use multiple threading.Event objects to handle different conditions in different threads.

import threading
import time

def task(event, task_name):
    print(f"{task_name} waiting for event...")
    event.wait()
    print(f"{task_name} started after event is set.")

event1 = threading.Event()
event2 = threading.Event()

# Creating threads
thread1 = threading.Thread(target=task, args=(event1, "Task 1"))
thread2 = threading.Thread(target=task, args=(event2, "Task 2"))

thread1.start()
thread2.start()

# Simulating some work and setting events
time.sleep(1)
event1.set()
time.sleep(1)
event2.set()

thread1.join()
thread2.join()

---

7. Event in an Infinite Loop

This example demonstrates how a thread can wait indefinitely for an event to be set in an infinite loop.

import threading
import time

def wait_forever(event):
    print("Thread waiting forever for event...")
    event.wait()
    print("Thread received the event and exiting.")

event = threading.Event()

# Starting the thread
thread = threading.Thread(target=wait_forever, args=(event,))
thread.start()

# Simulating work before setting the event
time.sleep(5)
event.set()
thread.join()

---

8. Event-Driven Task Scheduling

Here, an event is used to schedule tasks in multiple threads, where each task is triggered when the event is set.

import threading
import time

def scheduled_task(event, task_name):
    print(f"{task_name} waiting for event...")
    event.wait()
    print(f"{task_name} executed after event set.")

event = threading.Event()

# Starting threads for each scheduled task
tasks = [threading.Thread(target=scheduled_task, args=(event, f"Task-{i}")) for i in range(3)]

for task in tasks:
    task.start()

# Setting the event to trigger all tasks
time.sleep(3)
event.set()

for task in tasks:
    task.join()

---

9. Handling Multiple Events in a Thread

This example shows how a thread can wait for multiple events using wait() with multiple event objects.

import threading
import time

def wait_for_multiple_events(event1, event2):
    print("Thread waiting for multiple events...")
    event1.wait()
    event2.wait()
    print("Both events set, thread continues execution.")

event1 = threading.Event()
event2 = threading.Event()

# Starting the thread
thread = threading.Thread(target=wait_for_multiple_events, args=(event1, event2))
thread.start()

# Simulating work before setting the events
time.sleep(1)
event1.set()
time.sleep(1)
event2.set()

thread.join()

---

10. Flag Event for Thread Completion

A flag event is used to notify when a thread has completed its task.

import threading
import time

def perform_task(event):
    print("Thread performing task...")
    time.sleep(3)
    print("Task completed, setting event.")
    event.set()

event = threading.Event()

# Starting the thread
thread = threading.Thread(target=perform_task, args=(event,))
thread.start()

# Main thread waits for completion event
event.wait()
print("Main thread notified that task is complete.")
thread.join()

---

These snippets demonstrate how to use threading.Event to synchronize multiple threads in Python. The event allows threads to wait until certain conditions are met, making it a useful tool for managing concurrency and inter-thread communication.