Multithreading - Event Objects between Threads

Python Multithread

Event object is one of the simplest mechanisms for communication between threads: one thread signals an event and other threads wait for it
- https://docs.python.org/3/library/threading.html.

We're using multiple threads to spin separate operations off to run concurrently, however, there are times when it is important to be able to synchronize two or more threads' operations. Using Event objects is the simple way to communicate between threads.

An Event manages an internal flag that callers can either set() or clear(). Other threads can wait() for the flag to be set(). Note that the wait() method blocks until the flag is true.

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-9s) %(message)s',)
                    
def wait_for_event(e):
    logging.debug('wait_for_event starting')
    event_is_set = e.wait()
    logging.debug('event set: %s', event_is_set)

def wait_for_event_timeout(e, t):
    while not e.isSet():
        logging.debug('wait_for_event_timeout starting')
        event_is_set = e.wait(t)
        logging.debug('event set: %s', event_is_set)
        if event_is_set:
            logging.debug('processing event')
        else:
            logging.debug('doing other things')

if __name__ == '__main__':
    e = threading.Event()
    t1 = threading.Thread(name='blocking', 
                      target=wait_for_event,
                      args=(e,))
    t1.start()

    t2 = threading.Thread(name='non-blocking', 
                      target=wait_for_event_timeout, 
                      args=(e, 2))
    t2.start()

    logging.debug('Waiting before calling Event.set()')
    time.sleep(3)
    e.set()
    logging.debug('Event is set')

The wait() method takes an argument representing the number of seconds to wait for the event before timing out. It returns a boolean indicating whether or not the event is set, so the caller knows why wait() returned. The isSet() method can be used separately on the event, and it's a non-blocking call.

Output:

(blocking ) wait_for_event starting
(MainThread) Waiting before calling Event.set()
(non-blocking) wait_for_event_timeout starting
(non-blocking) event set: False
(non-blocking) doing other things
(non-blocking) wait_for_event_timeout starting
(MainThread) Event is set
(blocking ) event set: True
(non-blocking) event set: True
(non-blocking) processing event

The wait(timeout=None) blocks until the internal flag is true by the set() method. If the internal flag is true on entry, return immediately. In the example, we're not setting it on entry but we're doing it much later.

If not set, the wait() blocks until

1. another thread calls set() to set the flag to true
2. or until the optional timeout occurs.

When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof).

wait() returns true if and only if the internal flag has been set to true, either before the wait call or after the wait starts, so it will always return True except if a timeout is given and the operation times out.

In our example, wait_for_event_timeout() checks the event status without blocking indefinitely since timeout is given, e.wait(t). However, the wait_for_event() blocks on the call to wait() does not return until the event status changes.

Python Multithread