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="ans">
# Generator-based Coroutine Example
<p>The simplest generator based coroutine we can write is as follows:</p>
## Example Coroutine
<b>

```python
@asyncio.coroutine
def do_something_important():
    yield from asyncio.sleep(1)
```
</b>

<p>The coroutine sleeps for one second. Note the decorator and the use of <code class="clazz">yield from</code>. Without, either of them we wouldn't be able to use the coroutine with async.io. The <code class="clazz">yield from</code> statement gives up control back to the event loop and resumes execution after the coroutine <code class="mthd">asyncio.sleep()</code> has completed. Note that <code class="mthd">asyncio.sleep()</code> is itself a coroutine. Let us modify this coroutine to call another coroutine which performs the sleep. The changes are shown below:</p>
<b>

```python
@asyncio.coroutine
def go_to_sleep(sleep):
    print("sleeping for " + str(sleep) + " seconds")
    yield from asyncio.sleep(sleep)


@asyncio.coroutine
def do_something_important(sleep):
    # what is more important than getting
    # enough sleep!
    yield from go_to_sleep(sleep)

```
</b>

<p>Now imagine we invoke the coroutine <code class="mthd">do_something_important()</code> thrice serially with the values 1, 2 and 3 respectively. Without using threads or
multiprocessing the serial code will execute in <b>1 + 2 + 3 = 6 seconds</b>, however, if we leverage async.io the same code can complete in roughly <b>3 seconds</b> even though all of the
invocations run in the same thread. The intuition is that whenever a blocking operation is encountered the control is passed back to the event loop and execution is only
resumed when the blocking operation has completed. Run the snippet below and observe the total execution time.</p>

</div>

<div>
# Generator-based Coroutine Example
<p>The simplest generator based coroutine we can write is as follows:</p>
## Example Coroutine
<b>

```python
@asyncio.coroutine
def do_something_important():
    yield from asyncio.sleep(1)
```
</b>

<p>The coroutine sleeps for one second. Note the decorator and the use of <code>yield from</code>. Without, either of them we wouldn't be able to use the coroutine with async.io. The <code>yield from</code> statement gives up control back to the event loop and resumes execution after the coroutine <code>asyncio.sleep()</code> has completed. Note that <code>asyncio.sleep()</code> is itself a coroutine. Let us modify this coroutine to call another coroutine which performs the sleep. The changes are shown below:</p>
<b>

```python
@asyncio.coroutine
def go_to_sleep(sleep):
    print("sleeping for " + str(sleep) + " seconds")
    yield from asyncio.sleep(sleep)


@asyncio.coroutine
def do_something_important(sleep):
    # what is more important than getting
    # enough sleep!
    yield from go_to_sleep(sleep)

```
</b>

<p>Now imagine we invoke the coroutine <code>do_something_important()</code> thrice serially with the values 1, 2 and 3 respectively. Without using threads or
multiprocessing the serial code will execute in <b>1 + 2 + 3 = 6 seconds</b>, however, if we leverage async.io the same code can complete in roughly <b>3 seconds</b> even though all of the
invocations run in the same thread. The intuition is that whenever a blocking operation is encountered the control is passed back to the event loop and execution is only
resumed when the blocking operation has completed. Run the snippet below and observe the total execution time.</p>

</div>

Continues the discussion on generator based coroutines.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

... continued

Generator-based Coroutine Example