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">
   # Futures & Tasks   
   <div class="ans">

## Future

<p><span class="hi-yl"><code class="clazz">Future</code> represents a computation that is either in progress or will get scheduled in the future. It is a special low-level awaitable object that represents an eventual result of an asynchronous operation.</span> Don't confuse <code class="abtc">threading.Future</code> and <code class="abtc">asyncio.Future</code>. The former is part of the <code class="abtc">threading</code> module and doesn't have an <code class="mthd">__iter__()</code> method defined on it. <code class="abtc">asyncio.Future</code> is an awaitable and can be used with the <code class="clazz">yield from</code> statement. In general you shouldn't need to deal with futures directly. They are usually exposed by libraries or asyncio APIs. For instructional purposes we'll show an example that creates a future that is awaited by a coroutine. Study the snippet below:</p>
<b>

```python
import asyncio
from asyncio import Future


async def bar(future):
    print("bar will sleep for 3 seconds")
    await asyncio.sleep(3)
    print("bar resolving the future")
    future.done()
    future.set_result("future is resolved")


async def foo(future):
    print("foo will await the future")
    await future
    print("foo finds the future resolved")


async def main():
    future = Future()
    results = await asyncio.gather(foo(future), bar(future))


if __name__ == "__main__":
    asyncio.run(main())
    print("main exiting")

```
</b>

<p>Both the coroutines are passed a future. The <code class="mthd">foo()</code> coroutine awaits for the future to get resolved, while the <code class="mthd">bar()</code> coroutine resolves the future after three seconds.</p>
</div>
</div>


<div>
   # Futures & Tasks   
   <div>

## Future

<p><span><code>Future</code> represents a computation that is either in progress or will get scheduled in the future. It is a special low-level awaitable object that represents an eventual result of an asynchronous operation.</span> Don't confuse <code>threading.Future</code> and <code>asyncio.Future</code>. The former is part of the <code>threading</code> module and doesn't have an <code>__iter__()</code> method defined on it. <code>asyncio.Future</code> is an awaitable and can be used with the <code>yield from</code> statement. In general you shouldn't need to deal with futures directly. They are usually exposed by libraries or asyncio APIs. For instructional purposes we'll show an example that creates a future that is awaited by a coroutine. Study the snippet below:</p>
<b>

```python
import asyncio
from asyncio import Future


async def bar(future):
    print("bar will sleep for 3 seconds")
    await asyncio.sleep(3)
    print("bar resolving the future")
    future.done()
    future.set_result("future is resolved")


async def foo(future):
    print("foo will await the future")
    await future
    print("foo finds the future resolved")


async def main():
    future = Future()
    results = await asyncio.gather(foo(future), bar(future))


if __name__ == "__main__":
    asyncio.run(main())
    print("main exiting")

```
</b>

<p>Both the coroutines are passed a future. The <code>foo()</code> coroutine awaits for the future to get resolved, while the <code>bar()</code> coroutine resolves the future after three seconds.</p>
</div>
</div>


This lesson discusses futures and tasks that can get scheduled on the event loop.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Future & Tasks

Futures & Tasks

Future