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">
   # Introduction   
   <div class="ans">
<p>A reentrant lock is defined as a lock which can be reacquired by the same thread. A <code class="clazz">RLock</code> object carries the notion of ownership. If a thread acquires a <code class="clazz">RLock</code> object, it can chose to reacquire it as many times as possible. Consider the following snippet:</p>
## Reentrant lock
<b>

```python
# create a reentrant lock
rlock = RLock()

# acquire the lock twice
rlock.acquire()
rlock.acquire()

# release the lock twice
rlock.release()
rlock.release()

```
</b>

<p>In contrast to <code class="clazz">Lock</code>, the reentrant lock is acquired twice in the above snippet without blocking. Note that it is imperative to release the lock as many times as it is locked, otherwise the lock remains in locked state and any other threads attempting to acquire the lock get blocked. This is shown with an example below:</p> 
</div>
</div>


<div>
   # Introduction   
   <div>
<p>A reentrant lock is defined as a lock which can be reacquired by the same thread. A <code>RLock</code> object carries the notion of ownership. If a thread acquires a <code>RLock</code> object, it can chose to reacquire it as many times as possible. Consider the following snippet:</p>
## Reentrant lock
<b>

```python
# create a reentrant lock
rlock = RLock()

# acquire the lock twice
rlock.acquire()
rlock.acquire()

# release the lock twice
rlock.release()
rlock.release()

```
</b>

<p>In contrast to <code>Lock</code>, the reentrant lock is acquired twice in the above snippet without blocking. Note that it is imperative to release the lock as many times as it is locked, otherwise the lock remains in locked state and any other threads attempting to acquire the lock get blocked. This is shown with an example below:</p> 
</div>
</div>


This lesson explains the reentrant lock in python's threading module.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

RLock

Introduction