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">
   # Barber Shop
    <div class="ans">
<p>A similar problem appears in Silberschatz and Galvin's OS book, and variations of this problem exist in the wild.</p>
<p>A barbershop consists of a waiting room with <span class="i_b">n</span> chairs, and a barber chair for giving haircuts. If there are no customers
to be served, the barber goes to sleep. If a customer enters the
barbershop and all chairs are occupied, then the customer leaves
the shop. If the barber is busy, but chairs are available, then the
customer sits in one of the free chairs. If the barber is asleep, the
customer wakes up the barber. Write a program to coordinate the interaction between the
barber and the customers.</p>
    </div>
</div>

<div class="card">
# Solution
<div class="ans">
<p>First of all, we need to understand the different state transitions for this problem before we devise a solution. Let's look at them piecemeal:</p>

<ul>

<li><p>A customer enters the shop and if all <span class="i_b">N</span> chairs are occupied, he leaves. This hints at maintaining a count of the waiting customers.</p></li>

<li><p>If any of the <span class="i_b">N</span> chairs is free, the customer takes up the chair to wait for his turn. Note this translates to using a semaphore on which threads that have found a free chair wait on before being called in by the barber for a haircut.</p></li>

<li><p>If a customer enters the shop and the barber is asleep it implies there are no customers in the shop. The just-entered customer thread wakes up the barber thread. This sounds like using a signaling construct to wake up the barber thread.</p></li>

</ul>

<p>We'll have a class which will expose two APIs one for the barber thread to execute and the other for customers. The skeleton of the class would look like the following:</p>
<b>

```python
class BarberShop:

    def __init__(self):
        self.total_chairs = 3
        self.waiting_customers = 0
        self.haircuts_given = 0

    def customer_walks_in(self):
        pass

    def barber(self):
      
        while True:
        # perpetual execution of the barber thread

```
</b>

<p>Now let's think about the customer thread. It enters the shop, acquires a lock to test the value of the counter <code class="mthd">waiting_customers</code>. We must test the value of this variable while no other thread can modify its value, hinting that we'll wrap the test under a lock. If the value equals all the chairs available, then the customer thread gives up the lock and returns from the method. If a chair is available the customer thread increments the variable <code class="mthd">waiting_customers</code>. Remember, the barber might be asleep which can be modelled as the barber thread waiting on a semaphore <code class="mthd">wait_for_customer_to_enter</code>. The customer thread must signal the semaphore <code class="mthd">wait_for_customer_to_enter</code> in case the barber is asleep.</p>

<p>Next, the customer thread itself needs to wait on a semaphore before the barber comes over, greets the customer, and leads him to the salon chair. Let's call this semaphore <code class="mthd">wait_for_barber_to_get_ready</code>. This is the same semaphore the barber signals as soon as it wakes up. All customer threads waiting for a haircut will block on this <code class="mthd">wait_for_barber_to_get_ready</code> semaphore. The barber thread signaling this semaphore is akin to letting one customer come through and sit on the barber chair for a haircut. This logic when coded looks like the following:</p>
<b>

```python
    def customer_walks_in(self):
        with self.lock:
            if self.waiting_customers == self.total_chairs:
                print("Customer walks out, all chairs occupied")
                return

            self.waiting_customers += 1

        self.wait_for_customer_to_enter.release()
        self.wait_for_barber_to_get_ready.acquire()

        # TODO: complete the rest of the logic.

        
```
</b>

<p>Now let's work with the barber code. This should be a perpetual loop, where the barber initially waits on the semaphore <code class="mthd">wait_for_customer_to_enter</code> to simulate no customers in the shop. If woken up, then it implies that there's at least one customer in the shop who needs a hair-cut and the barber gets up, greets the customer and leads him to his chair before starting the haircut. This sequence is translated into code as the barber thread signaling the <code class="mthd">wait_for_barber_to_get_ready</code> semaphore. Next, the barber simulates a haircut by sleeping for 50 milliseconds </p>

<p>Once the haircut is done. The barber needs to inform the customer thread too; it does so by signalling the <code class="mthd">wait_for_barber_to_cut_hair</code> semaphore. The customer thread should already be waiting on this semaphore.</p>

<p> Finally, to let the barber thread know that the current customer thread has left the barber chair and the barber can bring in the next customer, we make the barber thread wait on yet another semaphore <code class="mthd">wait_for_customer_to_leave</code>. This is the same semaphore the customer thread needs to signal before exiting. The barber thread's implementation appears below:</p>
<b>

```python
    def barber(self):

        while True:
            self.wait_for_customer_to_enter.acquire()
            self.wait_for_barber_to_get_ready.release()

            self.haircuts_given += 1

            print("Barber cutting hair")
            time.sleep(1)

            self.wait_for_barber_to_cut_hair.release()
            self.wait_for_customer_to_leave.acquire()
```
</b>

<p>The complete customer thread code appears below:</p>

```python
    def customer_walks_in(self):
        with self.lock:
            if self.waiting_customers == self.total_chairs:
                print("Customer walks out, all chairs occupied")
                return

            self.waiting_customers += 1

        self.wait_for_customer_to_enter.release()
        self.wait_for_barber_to_get_ready.acquire()

        self.wait_for_barber_to_cut_hair.acquire()
        self.wait_for_customer_to_leave.release()

        with self.lock:
            self.waiting_customers -= 1
```


<p>The complete code appears below in the code widget. Note that since the barber thread is perpetual, the widget execution would time-out.</p>
</div>
</div>

<div>
   # Barber Shop
    <div>
<p>A similar problem appears in Silberschatz and Galvin's OS book, and variations of this problem exist in the wild.</p>
<p>A barbershop consists of a waiting room with <span>n</span> chairs, and a barber chair for giving haircuts. If there are no customers
to be served, the barber goes to sleep. If a customer enters the
barbershop and all chairs are occupied, then the customer leaves
the shop. If the barber is busy, but chairs are available, then the
customer sits in one of the free chairs. If the barber is asleep, the
customer wakes up the barber. Write a program to coordinate the interaction between the
barber and the customers.</p>
    </div>
</div>

<div>
# Solution
<div>
<p>First of all, we need to understand the different state transitions for this problem before we devise a solution. Let's look at them piecemeal:</p>

<ul>

<li><p>A customer enters the shop and if all <span>N</span> chairs are occupied, he leaves. This hints at maintaining a count of the waiting customers.</p></li>

<li><p>If any of the <span>N</span> chairs is free, the customer takes up the chair to wait for his turn. Note this translates to using a semaphore on which threads that have found a free chair wait on before being called in by the barber for a haircut.</p></li>

<li><p>If a customer enters the shop and the barber is asleep it implies there are no customers in the shop. The just-entered customer thread wakes up the barber thread. This sounds like using a signaling construct to wake up the barber thread.</p></li>

</ul>

<p>We'll have a class which will expose two APIs one for the barber thread to execute and the other for customers. The skeleton of the class would look like the following:</p>
<b>

```python
class BarberShop:

    def __init__(self):
        self.total_chairs = 3
        self.waiting_customers = 0
        self.haircuts_given = 0

    def customer_walks_in(self):
        pass

    def barber(self):
      
        while True:
        # perpetual execution of the barber thread

```
</b>

<p>Now let's think about the customer thread. It enters the shop, acquires a lock to test the value of the counter <code>waiting_customers</code>. We must test the value of this variable while no other thread can modify its value, hinting that we'll wrap the test under a lock. If the value equals all the chairs available, then the customer thread gives up the lock and returns from the method. If a chair is available the customer thread increments the variable <code>waiting_customers</code>. Remember, the barber might be asleep which can be modelled as the barber thread waiting on a semaphore <code>wait_for_customer_to_enter</code>. The customer thread must signal the semaphore <code>wait_for_customer_to_enter</code> in case the barber is asleep.</p>

<p>Next, the customer thread itself needs to wait on a semaphore before the barber comes over, greets the customer, and leads him to the salon chair. Let's call this semaphore <code>wait_for_barber_to_get_ready</code>. This is the same semaphore the barber signals as soon as it wakes up. All customer threads waiting for a haircut will block on this <code>wait_for_barber_to_get_ready</code> semaphore. The barber thread signaling this semaphore is akin to letting one customer come through and sit on the barber chair for a haircut. This logic when coded looks like the following:</p>
<b>

```python
    def customer_walks_in(self):
        with self.lock:
            if self.waiting_customers == self.total_chairs:
                print("Customer walks out, all chairs occupied")
                return

            self.waiting_customers += 1

        self.wait_for_customer_to_enter.release()
        self.wait_for_barber_to_get_ready.acquire()

        # TODO: complete the rest of the logic.

        
```
</b>

<p>Now let's work with the barber code. This should be a perpetual loop, where the barber initially waits on the semaphore <code>wait_for_customer_to_enter</code> to simulate no customers in the shop. If woken up, then it implies that there's at least one customer in the shop who needs a hair-cut and the barber gets up, greets the customer and leads him to his chair before starting the haircut. This sequence is translated into code as the barber thread signaling the <code>wait_for_barber_to_get_ready</code> semaphore. Next, the barber simulates a haircut by sleeping for 50 milliseconds </p>

<p>Once the haircut is done. The barber needs to inform the customer thread too; it does so by signalling the <code>wait_for_barber_to_cut_hair</code> semaphore. The customer thread should already be waiting on this semaphore.</p>

<p> Finally, to let the barber thread know that the current customer thread has left the barber chair and the barber can bring in the next customer, we make the barber thread wait on yet another semaphore <code>wait_for_customer_to_leave</code>. This is the same semaphore the customer thread needs to signal before exiting. The barber thread's implementation appears below:</p>
<b>

```python
    def barber(self):

        while True:
            self.wait_for_customer_to_enter.acquire()
            self.wait_for_barber_to_get_ready.release()

            self.haircuts_given += 1

            print("Barber cutting hair")
            time.sleep(1)

            self.wait_for_barber_to_cut_hair.release()
            self.wait_for_customer_to_leave.acquire()
```
</b>

<p>The complete customer thread code appears below:</p>

```python
    def customer_walks_in(self):
        with self.lock:
            if self.waiting_customers == self.total_chairs:
                print("Customer walks out, all chairs occupied")
                return

            self.waiting_customers += 1

        self.wait_for_customer_to_enter.release()
        self.wait_for_barber_to_get_ready.acquire()

        self.wait_for_barber_to_cut_hair.acquire()
        self.wait_for_customer_to_leave.release()

        with self.lock:
            self.waiting_customers -= 1
```


<p>The complete code appears below in the code widget. Note that since the barber thread is perpetual, the widget execution would time-out.</p>
</div>
</div>

This lesson visits the synchronization issues when programmatically modeling a hypothetical barber shop and how they can be solved using Python's concurrency primitives.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Barber Shop

Barber Shop