Events (signal between threads)

diagram an Event is a latch, not a queue mermaid

  flowchart TD
  A["ev = threading.Event()"] --> B["is_set() is False"]
  B --> C["several threads call ev.wait()"]
  C --> D["all of them park -- no CPU used"]
  E["one thread calls ev.set()"] --> F["EVERY waiter is released"]
  F --> G["a thread arriving later does not block at all"]
  G --> H["wait() returns immediately while it stays set"]
  I["ev.clear()"] --> J["back to blocking for the next arrivals"]
  K["need to pass VALUES?"] --> L["use a Queue -- an Event carries no data"]

It has one bit of state. Setting it releases every thread waiting at that moment and every thread that arrives afterwards, until somebody clears it. That makes it right for 'the configuration is loaded' or 'time to shut down', and wrong for handing over items, because there is nothing to hand over and no count.

Verified: set() releases all of them, and stays open

Three threads called wait(), then one set():

Moment	Log
before set()	w0 waiting, w1 waiting, w2 waiting — all parked, is_set() is False
after set()	w0 released, w1 released, w2 released — all three
a fourth waiter, arriving afterwards	wait() returned in 0.0000 s

That last row is the important half. An Event is level-triggered: once set it stays set, so late arrivals are not missed. Compare Condition.notify(), which is edge-triggered — a thread that was not yet waiting when the notify happened simply never hears it.

So use an Event for a state that latches: ready, shutting down, configuration loaded. Use a Queue when there is something to hand over, and a Condition when the predicate can go back and forth.

What is an Event?

An Event is a simple flag:

• one thread sets it
• other threads wait until it’s set

Example

event_example.py

import threading
import time
 
ready = threading.Event()
 
 
def waiter():
    print("Waiting...")
    ready.wait()  # blocks
    print("Go!")
 
 
def setter():
    time.sleep(1)
    ready.set()
 
 
t1 = threading.Thread(target=waiter)
t2 = threading.Thread(target=setter)
 
t1.start(); t2.start()
t1.join(); t2.join()

Resetting an event

• event.clear() resets it to false.
• Useful for repeated cycles.

sketch An Event releases everyone, and stays open p5.js Pause Restart

Three threads park on wait(). One set() releases all of them at once -- not one, and not in turn. And because the flag stays set, a fourth thread arriving afterwards does not block at all. That last property is what distinguishes an Event from a notify, which a late arrival simply misses.

Check yourself

pch.quizTag pch.quizDefaultTitle

1. Three threads are blocked in `ev.wait()`. One thread calls `ev.set()`. How many are released?

   A One B All three C One per subsequent `set()` D None until `clear()`
   pch.quizShowAnswer

   B — All three — Verified — all three logged 'released'. An Event is a latch on a shared flag, not a queue of permits.

2. A thread calls `wait()` on an Event that is ALREADY set. What happens?

   A It blocks until the next `set()` B It returns immediately C It raises D It blocks until `clear()`
   pch.quizShowAnswer

   B — It returns immediately — Measured at 0.0000 s. An Event is level-triggered: it stays set, so late arrivals are not missed. `Condition.notify()` is edge-triggered and a late thread misses it entirely.

3. When should you use a `Queue` instead of an `Event`?

   A When more than one thread waits B When there is data to hand over C When the flag must reset D When the threads are daemons
   pch.quizShowAnswer

   B — When there is data to hand over — An Event carries one bit and no payload. A Queue transfers items, blocks the consumer when empty, and applies back-pressure to the producer when full.

4. What does `ev.clear()` do to threads currently blocked in `wait()`?

   A Releases them B Nothing — they were already released when it was set C Raises in each of them D Re-blocks them
   pch.quizShowAnswer

   B — Nothing — they were already released when it was set — `clear()` only affects who blocks from then on. Threads released by an earlier `set()` have already moved on.

🧪 Try It Yourself

Exercise 1 – threading.Event Set and Wait

pch.exerciseTag pch.exerciseTitle

Exercise 2 – Clear an Event

pch.exerciseTag pch.exerciseTitle

Exercise 3 – Event with Timeout

pch.exerciseTag pch.exerciseTitle