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">
   # Barrier,  Semaphore, Condition Variable   
   <div class="ans">

## Semaphore
<p>The <code class="abtc">multiprocessing.Semaphore</code> is very similar to <code class="abtc">threading.Semaphore</code>. The only difference is that the <code class="mthd">acquire()</code> method's first argument is named <i>block</i> instead of <i>blocking</i> as is the case for threading.Semaphore. Below is a simple program between two processes that take turns to write "ping" and "pong" on the console. The script uses <code class="abtc">multiprocessing.Semaphore</code>  initialized to zero. Additionally, we also use a <code class="abtc">multiprocessing.Value</code> boolean object to indicate to the two processes to exit.</p>
### Printing ping and pong
<b>

```python
from multiprocessing import Semaphore, Process, Value
from ctypes import c_bool
import time
import multiprocessing


def process_A(sem1, sem2, exit):
    while not exit.value:
        print("ping")
        sem1.release()
        sem2.acquire()
        time.sleep(0.05)


def process_B(sem1, sem2, exit):
    while not exit.value:
        # wait for a prime number to become available
        sem1.acquire()
        print("pong")
        sem2.release()
        time.sleep(0.05)


if __name__ == '__main__':
    sem1 = Semaphore(0)
    sem2 = Semaphore(0)

    exit_prog = Value(c_bool, False)

    processA = Process(target=process_A, args=(sem1, sem2, exit_prog))
    processA.start()

    processB = Process(target=process_B, args=(sem1, sem2, exit_prog))
    processB.start()

    # Let the threads run for 3 seconds
    time.sleep(3)

    exit_prog.value = True

    processA.join()
    processB.join()

```
</b>

</div>
</div>


<div>
   # Barrier,  Semaphore, Condition Variable   
   <div>

## Semaphore
<p>The <code>multiprocessing.Semaphore</code> is very similar to <code>threading.Semaphore</code>. The only difference is that the <code>acquire()</code> method's first argument is named <i>block</i> instead of <i>blocking</i> as is the case for threading.Semaphore. Below is a simple program between two processes that take turns to write "ping" and "pong" on the console. The script uses <code>multiprocessing.Semaphore</code>  initialized to zero. Additionally, we also use a <code>multiprocessing.Value</code> boolean object to indicate to the two processes to exit.</p>
### Printing ping and pong
<b>

```python
from multiprocessing import Semaphore, Process, Value
from ctypes import c_bool
import time
import multiprocessing


def process_A(sem1, sem2, exit):
    while not exit.value:
        print("ping")
        sem1.release()
        sem2.acquire()
        time.sleep(0.05)


def process_B(sem1, sem2, exit):
    while not exit.value:
        # wait for a prime number to become available
        sem1.acquire()
        print("pong")
        sem2.release()
        time.sleep(0.05)


if __name__ == '__main__':
    sem1 = Semaphore(0)
    sem2 = Semaphore(0)

    exit_prog = Value(c_bool, False)

    processA = Process(target=process_A, args=(sem1, sem2, exit_prog))
    processA.start()

    processB = Process(target=process_B, args=(sem1, sem2, exit_prog))
    processB.start()

    # Let the threads run for 3 seconds
    time.sleep(3)

    exit_prog.value = True

    processA.join()
    processB.join()

```
</b>

</div>
</div>


This lesson discusses the various synchronization constructs offered by the multiprocessing module which have counterparts in the threading module.  

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Barrier, Semaphore, Condition Variable

Barrier, Semaphore, Condition Variable

Semaphore