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">
 # Unisex Bathroom Problem
 <div class="ans">
A bathroom is being designed for the use of both males and females in an office but requires the following constraints to be maintained:
 <ul>
 <li>There cannot be men and women in the bathroom at the same time.</li>
 <li>There should never be more than three employees in the bathroom simultaneously.</li>
</ul>

The solution should avoid deadlocks. For now, though, don’t worry about starvation. 
</div>
</div>

<div class="card">
 # Solution
 <div class="ans">
First let us come up with the skeleton of our Unisex Bathroom class. We want to model the problem programmatically first. We'll need two APIs, one that is called by a male to use the bathroom and another that is called by a female to use the bathroom. Initially, our class looks like the following:


```java
class UnisexBathroomProblem:

 def __init__(self):
 pass

 def male_use_bathroom(self, name):
 pass

 def female_use_bathroom(self, name):
 pass

```
 

Let us try to address the first problem of allowing either men or women to use the bathroom. We'll worry about the max employees later. We need to maintain state in a variable to track which gender is currently using the bathroom. Let's call this variable <code class="mthd">in_use_by</code>. The variable <code class="mthd">in_use_by</code> will take on the values female, male or none to denote the gender currently using the bathroom.

We'll also have a method <code class="mthd">use_bathroom()</code> that'll mock a person using the bathroom. The implementation of this method will simply sleep the thread using the bathroom for some time.

Assume there's no one in the bathroom and a male thread invokes the <code class="mthd">male_use_bathroom()</code> method, the thread has to check first whether the bathroom is being used by a female thread. If it is indeed being used by a female, then the male thread has to wait for the bathroom to be empty. If the male thread already finds the bathroom empty, which in our scenario it does, the thread simply updates the <code class="mthd">in_use_by</code> variable to "male" and proceeds to use the bathroom. After using the bathroom, however, it must let any waiting female threads know that it is done and they can now use the bathroom.

The astute reader would immediately realize that we'll need to guard the variable <code class="mthd">in_use_by</code> since it can possibly be both read and written to by different threads at the same time. We can use a <code class="clazz">Condition</code> variable for it. Using a condition variable also allows us to <code class="mthd">wait()</code> threads of a gender while threads of the other gender are using the bathroom. We'll also introduce a variable <code class="mthd">emps_in_bathroom</code> to keep count of employees currently in the bathroom. Note this variable isn't required to solve the problem but useful to test our solution. Using the above discussion we can craft the <code class="mthd">male_use_bathroom</code> method and the rest of the code as follows:



```python
0. class UnisexBathroomProblem:
1.
2. def __init__(self):
3. self.in_use_by = "none"
4. self.emps_in_bathroom = 0
5. self.cond = Condition()
6.
7. def use_bathroom(self, name):
8. # simulate using a bathroom
10. print("\n{0} is using the bathroom. {1} employees in bathroom".format(name, self.emps_in_bathroom))
11. time.sleep(3)
12. print("\n{0} is done using the bathroom".format(name))
13.
14. def male_use_bathroom(self, name):
15.
16. with self.cond:
17. # remember to use the while loop instead of an if
18. while self.in_use_by == "female":
19. self.cond.wait()
20. self.emps_in_bathroom += 1
21. self.in_use_by = "male"
22.
23. self.use_bathroom(name)
24. 
25. with self.cond:
26. self.emps_in_bathroom -= 1
27. if self.emps_in_bathroom == 0:
28. self.in_use_by = "none"
29. 
30. self.cond.notifyAll()


```

 
The code so far allows any number of men or women to gather in the bathroom. However, it allows only one gender to do so. The methods are mirror images of each other with only gender-specific variable changes. Let's discuss the important portions of the code.

<ul>
 <li>Lines 16-21: After acquiring the condition variable on line#16 we use a while loop to check for the predicate <code class="mthd">in_use_by</code>. If it is set to male or none then, we know the bathroom is either empty or already has men and therefore it is safe to proceed ahead. If the <code class="mthd">in_use_by</code> is set to female, then the male thread, invokes <code class="mthd">wait()</code> on line#19. Note, the thread would give up the lock associated with the condition variable thus allowing other threads to acquire the condition variable and possibly update the <code class="mthd">in_use_by</code> variable.</li>

<li>Line 23 has no synchronization around it. If a male thread reaches here, we are guaranteed that either the bathroom was already in use by men or no one was using it.</li>

<li>Lines 25-30: After using the bathroom, the male thread is about to leave the method so it should remember to decrement the number of occupants in the bathroom. As soon as it does that, it has to check if it were the last member of its gender to leave the bathroom and if so then it should also update the <code class="mthd">in_use_by</code> variable to none. Finally, the thread notifies any other waiting threads that they are free to check the value of <code class="mthd">in_use_by</code> in case it has updated it. Question: Why did we use <code class="mthd">notifyAll()</code> instead of <code class="mthd">notify()</code>?</li>
</ul>

Now we need to incorporate the logic of limiting the number of employees of a given gender that can be in the bathroom at the same time. Limiting access intuitively leads one to use a semaphore. A semaphore would do just that - limit access to a fixed number of threads, which in our case is 3.

</div>
</div>

<div>
 # Unisex Bathroom Problem
 <div>
A bathroom is being designed for the use of both males and females in an office but requires the following constraints to be maintained:
 <ul>
 <li>There cannot be men and women in the bathroom at the same time.</li>
 <li>There should never be more than three employees in the bathroom simultaneously.</li>
</ul>

The solution should avoid deadlocks. For now, though, don’t worry about starvation. 
</div>
</div>

<div>
 # Solution
 <div>
First let us come up with the skeleton of our Unisex Bathroom class. We want to model the problem programmatically first. We'll need two APIs, one that is called by a male to use the bathroom and another that is called by a female to use the bathroom. Initially, our class looks like the following:


```java
class UnisexBathroomProblem:

 def __init__(self):
 pass

 def male_use_bathroom(self, name):
 pass

 def female_use_bathroom(self, name):
 pass

```
 

Let us try to address the first problem of allowing either men or women to use the bathroom. We'll worry about the max employees later. We need to maintain state in a variable to track which gender is currently using the bathroom. Let's call this variable <code>in_use_by</code>. The variable <code>in_use_by</code> will take on the values female, male or none to denote the gender currently using the bathroom.

We'll also have a method <code>use_bathroom()</code> that'll mock a person using the bathroom. The implementation of this method will simply sleep the thread using the bathroom for some time.

Assume there's no one in the bathroom and a male thread invokes the <code>male_use_bathroom()</code> method, the thread has to check first whether the bathroom is being used by a female thread. If it is indeed being used by a female, then the male thread has to wait for the bathroom to be empty. If the male thread already finds the bathroom empty, which in our scenario it does, the thread simply updates the <code>in_use_by</code> variable to "male" and proceeds to use the bathroom. After using the bathroom, however, it must let any waiting female threads know that it is done and they can now use the bathroom.

The astute reader would immediately realize that we'll need to guard the variable <code>in_use_by</code> since it can possibly be both read and written to by different threads at the same time. We can use a <code>Condition</code> variable for it. Using a condition variable also allows us to <code>wait()</code> threads of a gender while threads of the other gender are using the bathroom. We'll also introduce a variable <code>emps_in_bathroom</code> to keep count of employees currently in the bathroom. Note this variable isn't required to solve the problem but useful to test our solution. Using the above discussion we can craft the <code>male_use_bathroom</code> method and the rest of the code as follows:



```python
0. class UnisexBathroomProblem:
1.
2. def __init__(self):
3. self.in_use_by = "none"
4. self.emps_in_bathroom = 0
5. self.cond = Condition()
6.
7. def use_bathroom(self, name):
8. # simulate using a bathroom
10. print("\n{0} is using the bathroom. {1} employees in bathroom".format(name, self.emps_in_bathroom))
11. time.sleep(3)
12. print("\n{0} is done using the bathroom".format(name))
13.
14. def male_use_bathroom(self, name):
15.
16. with self.cond:
17. # remember to use the while loop instead of an if
18. while self.in_use_by == "female":
19. self.cond.wait()
20. self.emps_in_bathroom += 1
21. self.in_use_by = "male"
22.
23. self.use_bathroom(name)
24. 
25. with self.cond:
26. self.emps_in_bathroom -= 1
27. if self.emps_in_bathroom == 0:
28. self.in_use_by = "none"
29. 
30. self.cond.notifyAll()


```

 
The code so far allows any number of men or women to gather in the bathroom. However, it allows only one gender to do so. The methods are mirror images of each other with only gender-specific variable changes. Let's discuss the important portions of the code.

<ul>
 <li>Lines 16-21: After acquiring the condition variable on line#16 we use a while loop to check for the predicate <code>in_use_by</code>. If it is set to male or none then, we know the bathroom is either empty or already has men and therefore it is safe to proceed ahead. If the <code>in_use_by</code> is set to female, then the male thread, invokes <code>wait()</code> on line#19. Note, the thread would give up the lock associated with the condition variable thus allowing other threads to acquire the condition variable and possibly update the <code>in_use_by</code> variable.</li>

<li>Line 23 has no synchronization around it. If a male thread reaches here, we are guaranteed that either the bathroom was already in use by men or no one was using it.</li>

<li>Lines 25-30: After using the bathroom, the male thread is about to leave the method so it should remember to decrement the number of occupants in the bathroom. As soon as it does that, it has to check if it were the last member of its gender to leave the bathroom and if so then it should also update the <code>in_use_by</code> variable to none. Finally, the thread notifies any other waiting threads that they are free to check the value of <code>in_use_by</code> in case it has updated it. Question: Why did we use <code >notifyAll()</code> instead of <code >notify()</code>?</li>
</ul>

Now we need to incorporate the logic of limiting the number of employees of a given gender that can be in the bathroom at the same time. Limiting access intuitively leads one to use a semaphore. A semaphore would do just that - limit access to a fixed number of threads, which in our case is 3.

</div>
</div>

A synchronization practice problem requiring us to synchronize the usage of a single bathroom by both the genders.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Unisex Bathroom Problem

Unisex Bathroom Problem

Solution