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   
   <div class="ans">
<p><span class="hi-yl">A barrier is a synchronization construct to wait for a certain number of threads to reach a common synchronization point in code.</span> The involved threads each invoke the barrier object's <code class="mthd">wait()</code> method and get blocked till all of threads have called <code class="mthd">wait()</code>. When the last thread invokes <code class="mthd">wait()</code> all of the waiting threads are released simultaneously. The below snippet shows example usage of barrier:</p>
## Using a barrier
<b>

```python
from threading import Barrier
from threading import Thread
import random
import time


def thread_task():
    time.sleep(random.randint(0, 7))
    print("\nCurrently {0} threads blocked on barrier".format(barrier.n_waiting))
    barrier.wait()


num_threads = 5
barrier = Barrier(num_threads)
threads = [0] * num_threads

for i in range(num_threads):
    threads[i - 1] = Thread(target=thread_task)

for i in range(num_threads):
    threads[i].start()

```
</b>

</div>
</div>


<div>
   # Barrier   
   <div>
<p><span>A barrier is a synchronization construct to wait for a certain number of threads to reach a common synchronization point in code.</span> The involved threads each invoke the barrier object's <code>wait()</code> method and get blocked till all of threads have called <code>wait()</code>. When the last thread invokes <code>wait()</code> all of the waiting threads are released simultaneously. The below snippet shows example usage of barrier:</p>
## Using a barrier
<b>

```python
from threading import Barrier
from threading import Thread
import random
import time


def thread_task():
    time.sleep(random.randint(0, 7))
    print("\nCurrently {0} threads blocked on barrier".format(barrier.n_waiting))
    barrier.wait()


num_threads = 5
barrier = Barrier(num_threads)
threads = [0] * num_threads

for i in range(num_threads):
    threads[i - 1] = Thread(target=thread_task)

for i in range(num_threads):
    threads[i].start()

```
</b>

</div>
</div>


This lesson discusses the all-important barrier synchronization construct.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Barrier

Barrier