The ultimate guide to senior engineering interviews. Strategies developed by FAANG engineers on Python concurrency, multithreading, monitors, and event loops. Prep faster for top company questions.

Concurrency in Python is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors, Event Loops and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basic Python would be helpful.

Python Concurrency for Senior Engineering Interviews

<div class="card">
   # Events   
   <div class="ans">
<p>An event object is one of the simplest primitives available for synchronization. Internally, it has a boolean flag that can be set or unset using the methods <code class="mthd">set()</code> and <code class="mthd">clear()</code>. Additionally, a thread can check if the flag is set to true by invoking the <code class="mthd">is_set()</code> method.</p>

<p>The event object exposes a <code class="mthd">wait()</code> method that threads can invoke to wait for the internal boolean flag to become true. If the flag is already true, the thread returns immediately. If there are multiple threads waiting on the event object and an active thread sets the flag then all the waiting threads are unblocked.</p>

<p><code class="clazz">Event</code> is a convenience class and a wrapper over a condition variable with a boolean predicate. This is the most common setup for many cooperating threads where two or more threads coordinate among themselves on a boolean predicate.</p>

## Differences with Semaphores
<p>Event objects may seem similar to semaphore or a bounded semaphore but there are slight differences:</p>
<ul>
<li><p>An unbounded semaphore can have its internal counter incremented as many times as <code class="mthd">acquire()</code> is invoked on it, whereas an event object maintains an internal boolean flag that can only flip between two state: set or unset. </p></li>

<li><p>Can a bounded semaphore intialized to 1 be equivalent to an event object? The answer is no because the bounded semaphore will raise a <code class="clazz">ValueError</code> if the bounded semaphore is acquired more number of times than the initial passed in capacity. Also acquiring a semaphore decrements the internal counter of the semaphore whereas waiting on an event object doesn't change the state of the internal boolean flag.</p></li>
<li><p>A thread never gets blocked on <code class="mthd">wait()</code> of an event object if the internal flag is set to true no matter how many times the thread invokes the <code class="mthd">wait()</code> method.</p></li>
</ul>
<p>Below is a naive example of using event to coordinate interaction between two threads:</p>
### Event example
<b>

```python
from threading import Thread
from threading import Event
import time


def task1():
    event.wait()
    event.wait()
    event.wait()
    print("thread invoked wait thrice")


def task2():
    time.sleep(1)
    event.set()


event = Event()

thread1 = Thread(target=task1)
thread1.start()

thread2 = Thread(target=task2)
thread2.start()

thread1.join()
thread2.join()

```
</b>
</div>
</div>


<div>
   # Events   
   <div>
<p>An event object is one of the simplest primitives available for synchronization. Internally, it has a boolean flag that can be set or unset using the methods <code>set()</code> and <code>clear()</code>. Additionally, a thread can check if the flag is set to true by invoking the <code>is_set()</code> method.</p>

<p>The event object exposes a <code>wait()</code> method that threads can invoke to wait for the internal boolean flag to become true. If the flag is already true, the thread returns immediately. If there are multiple threads waiting on the event object and an active thread sets the flag then all the waiting threads are unblocked.</p>

<p><code>Event</code> is a convenience class and a wrapper over a condition variable with a boolean predicate. This is the most common setup for many cooperating threads where two or more threads coordinate among themselves on a boolean predicate.</p>

## Differences with Semaphores
<p>Event objects may seem similar to semaphore or a bounded semaphore but there are slight differences:</p>
<ul>
<li><p>An unbounded semaphore can have its internal counter incremented as many times as <code>acquire()</code> is invoked on it, whereas an event object maintains an internal boolean flag that can only flip between two state: set or unset. </p></li>

<li><p>Can a bounded semaphore intialized to 1 be equivalent to an event object? The answer is no because the bounded semaphore will raise a <code>ValueError</code> if the bounded semaphore is acquired more number of times than the initial passed in capacity. Also acquiring a semaphore decrements the internal counter of the semaphore whereas waiting on an event object doesn't change the state of the internal boolean flag.</p></li>
<li><p>A thread never gets blocked on <code>wait()</code> of an event object if the internal flag is set to true no matter how many times the thread invokes the <code>wait()</code> method.</p></li>
</ul>
<p>Below is a naive example of using event to coordinate interaction between two threads:</p>
### Event example
<b>

```python
from threading import Thread
from threading import Event
import time


def task1():
    event.wait()
    event.wait()
    event.wait()
    print("thread invoked wait thrice")


def task2():
    time.sleep(1)
    event.set()


event = Event()

thread1 = Thread(target=task1)
thread1.start()

thread2 = Thread(target=task2)
thread2.start()

thread1.join()
thread2.join()

```
</b>
</div>
</div>


This lesson talks about Events, which is a lesser known utility class within the threading module.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Events

Events