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">
 # Semaphores 
 <div class="ans">
Semaphore is one of the oldest synchronization primitives, invented by <a href="https://en.wikipedia.org/wiki/Edsger_W._Dijkstra" target="_blank">Edsger Dijkstra</a>. A semaphore is nothing more than an atomic counter that gets decremented by one whenever <code class="mthd">acquire()</code> is invoked and incremented by one whenever <code class="mthd">release()</code> is called. The semaphore can be initialized with an initial count value. If none is specified, the semaphore is initialized with a value of one.

## Creating semaphore


```python
# semaphore initialized with a default count of 1
semaphore = Semaphore()

# semaphore initialized with count set to 5
sem_with_count = Semaphore(5)
```

 

## acquire ( )

If a thread invokes <code class="mthd">acquire()</code> on a semaphore, the semaphore counter is decremented by one. If the count is greater than 0, then the thread immediately returns from the <code class="mthd">acquire()</code> call. If the semaphore counter is zero when a thread invokes <code class="mthd">acquire()</code>, the thread gets blocked till another thread releases the semaphore.

## release ( )
When a thread invokes the <code class="mthd">release()</code> method, the internal semaphore counter is incremented by one. If the counter value is zero and another thread is already blocked on an <code class="mthd">acquire()</code> then a release would unblock the waiting thread. If multiple threads are blocked on the semaphore, then one thread is arbitrarily chosen.


## Using Semaphores
Semaphores can be used in versatile ways. The primary use of semaphores is signaling among threads which are working to achieve a common goal. Consider the below snippet which uses a condition variable between threads.
### Missed Signal


```python
from threading import Thread
from threading import Condition
import time


def task1():
 cond_var.acquire()
 cond_var.wait()
 cond_var.release()


def task2():
 cond_var.acquire()
 cond_var.notify()
 cond_var.release()


cond_var = Condition()

# start thread 2 first which invokes notify
thread2 = Thread(target=task2)
thread2.start()

# delay starting thread 1 by three seconds
time.sleep(3)

# start thread 1
thread1 = Thread(target=task1)
thread1.start()

thread1.join()
thread2.join()

```

The above program will never exit since the notifying thread notifies before the first thread has a chance to wait on the condition
variable. This is a manifestation of a missed signal. 

You may realize from your reading in the previous sections that the way we are using the condition variable's <code class="mthd">wait()</code> method is incorrect. The idiomatic usage of <code class="mthd">wait()</code> is in a while loop with an associated boolean condition. For now, observe the possibility of losing signals between threads.

The faulty program appears in the code widget below:
</div>

</div>

<div>
 # Semaphores 
 <div>
Semaphore is one of the oldest synchronization primitives, invented by <a href="https://en.wikipedia.org/wiki/Edsger_W._Dijkstra" target="_blank">Edsger Dijkstra</a>. A semaphore is nothing more than an atomic counter that gets decremented by one whenever <code>acquire()</code> is invoked and incremented by one whenever <code>release()</code> is called. The semaphore can be initialized with an initial count value. If none is specified, the semaphore is initialized with a value of one.

## Creating semaphore


```python
# semaphore initialized with a default count of 1
semaphore = Semaphore()

# semaphore initialized with count set to 5
sem_with_count = Semaphore(5)
```

 

## acquire ( )

If a thread invokes <code>acquire()</code> on a semaphore, the semaphore counter is decremented by one. If the count is greater than 0, then the thread immediately returns from the <code>acquire()</code> call. If the semaphore counter is zero when a thread invokes <code>acquire()</code>, the thread gets blocked till another thread releases the semaphore.

## release ( )
When a thread invokes the <code>release()</code> method, the internal semaphore counter is incremented by one. If the counter value is zero and another thread is already blocked on an <code>acquire()</code> then a release would unblock the waiting thread. If multiple threads are blocked on the semaphore, then one thread is arbitrarily chosen.


## Using Semaphores
Semaphores can be used in versatile ways. The primary use of semaphores is signaling among threads which are working to achieve a common goal. Consider the below snippet which uses a condition variable between threads.
### Missed Signal


```python
from threading import Thread
from threading import Condition
import time


def task1():
 cond_var.acquire()
 cond_var.wait()
 cond_var.release()


def task2():
 cond_var.acquire()
 cond_var.notify()
 cond_var.release()


cond_var = Condition()

# start thread 2 first which invokes notify
thread2 = Thread(target=task2)
thread2.start()

# delay starting thread 1 by three seconds
time.sleep(3)

# start thread 1
thread1 = Thread(target=task1)
thread1.start()

thread1.join()
thread2.join()

```

The above program will never exit since the notifying thread notifies before the first thread has a chance to wait on the condition
variable. This is a manifestation of a missed signal. 

You may realize from your reading in the previous sections that the way we are using the condition variable's <code>wait()</code> method is incorrect. The idiomatic usage of <code>wait()</code> is in a while loop with an associated boolean condition. For now, observe the possibility of losing signals between threads.

The faulty program appears in the code widget below:
</div>

</div>

This lesson introduces semaphores and their uses in Python.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Semaphores

Semaphores

Creating semaphore