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">
 # With 
 <div class="ans">
Programs often use resources other than CPU time, including access to local disks, network sockets, and databases etc. The usage pattern is usually a <code class="clazz">try-except-finally</code> block. Any cleanup actions are performed in the <code class="clazz">finally</code> block. An alternative to the usual boilterplate code is to use the <code class="clazz">with</code> statement. The <code class="clazz">with</code> statement wraps the execution of a block of statements in a context defined by a context manager object. 

## Context Management Protocol

A context manager object abides by the context management protocol, which states that an object defines the following two methods. Python calls these two methods at appropriate times in the resource management cycle:

<ul>
<li><code class="mthd">__enter__()</code></li>
<li><code class="mthd">__exit__()</code></li>
</ul>

The with statement is used as:

```python
 with context-expression [as target]:
 statement#1
 statement#2
 .
 .
 .
 statement#n
```

<ul>
<li><code class="mthd">__enter__()</code> should return an object that is assigned to the variable after as in the above template. By default the returned object is None, and is optional. A common pattern is to return self and keep the functionality required within the same class.</li>

<li><code class="mthd">__exit__()</code> is called on the original Context Manager object, not the object returned by <code class="mthd">__enter__()</code>. If, however, we return self in the <code class="mthd">__enter__()</code> method, then it is obviously the same object.</li>

<li>If an error is raised in <code class="mthd">__init__()</code> or <code class="mthd">__enter__()</code> then the code block is never executed and <code class="mthd">__exit__()</code> is not called.</li>

<li>Once the code block is entered, <code class="mthd">__exit__</code> is always called, even if an exception is raised in the code block.</li>

<li>In case an exception is raised when executing the block of code wrapped by the <code class="clazz">with</code> statement, three values consisting of the exception types, its value and traceback are passed as arguments to the <code class="mthd">__exit__()</code> method. These parameters are None if no exceptions occur. Lastly, if an exception was raised and the <code class="mthd">__exit__()</code> method returns True, the exception is suppressed. On the contrary, if <code class="mthd">__exit__()</code> returns false then the exception is re-raised.</li>
</ul> 

Context managers can be used in scenarios to save and restore global state, lock and unlock resources, close opened files, etc.


## Example
The most common use of the <code class="clazz">with</code> statement happens when we manipulate files. Without the <code class="clazz">with</code> statement, file manipulation would look as follows:


```python
 file = None
 try:
 file = open("test.txt")
 except Exception as e:
 print(e)

 finally:
 if file is not None:
 file.close()
```


Using the <code class="clazz">with</code> statement the above code is simplified as:


```python
with open("test.txt") as file: 
 data = file.read() 
```


The <code class="clazz">with</code> statement helps simplify some common resource management patterns by abstracting their functionality and allowing them to be factored out and reused. The code becomes expressive and easier to read. In fact, we can write a class that implements the enter and exit methods and makes it compatible with the <code class="clazz">with</code> statement. An example is shown below:


```python
class ExampleClass(object):

 def __init__(self, val):
 print("init")
 self.val = val

 def display(self):
 print(self.val)

 def __enter__(self):
 print("enter invoked")
 return self

 def __exit__(self, exc_type, exc_val, exc_tb):
 print("exit invoked")


if __name__ == "__main__":
 with ExampleClass("hello world") as example:
 example.display()

```

</div>
</div>

<div>
 # With 
 <div>
Programs often use resources other than CPU time, including access to local disks, network sockets, and databases etc. The usage pattern is usually a <code>try-except-finally</code> block. Any cleanup actions are performed in the <code>finally</code> block. An alternative to the usual boilterplate code is to use the <code>with</code> statement. The <code>with</code> statement wraps the execution of a block of statements in a context defined by a context manager object. 

## Context Management Protocol

A context manager object abides by the context management protocol, which states that an object defines the following two methods. Python calls these two methods at appropriate times in the resource management cycle:

<ul>
<li><code>__enter__()</code></li>
<li><code>__exit__()</code></li>
</ul>

The with statement is used as:

```python
 with context-expression [as target]:
 statement#1
 statement#2
 .
 .
 .
 statement#n
```

<ul>
<li><code>__enter__()</code> should return an object that is assigned to the variable after as in the above template. By default the returned object is None, and is optional. A common pattern is to return self and keep the functionality required within the same class.</li>

<li><code>__exit__()</code> is called on the original Context Manager object, not the object returned by <code>__enter__()</code>. If, however, we return self in the <code>__enter__()</code> method, then it is obviously the same object.</li>

<li>If an error is raised in <code>__init__()</code> or <code>__enter__()</code> then the code block is never executed and <code>__exit__()</code> is not called.</li>

<li>Once the code block is entered, <code>__exit__</code> is always called, even if an exception is raised in the code block.</li>

<li>In case an exception is raised when executing the block of code wrapped by the <code>with</code> statement, three values consisting of the exception types, its value and traceback are passed as arguments to the <code>__exit__()</code> method. These parameters are None if no exceptions occur. Lastly, if an exception was raised and the <code>__exit__()</code> method returns True, the exception is suppressed. On the contrary, if <code>__exit__()</code> returns false then the exception is re-raised.</li>
</ul> 

Context managers can be used in scenarios to save and restore global state, lock and unlock resources, close opened files, etc.


## Example
The most common use of the <code>with</code> statement happens when we manipulate files. Without the <code>with</code> statement, file manipulation would look as follows:


```python
 file = None
 try:
 file = open("test.txt")
 except Exception as e:
 print(e)

 finally:
 if file is not None:
 file.close()
```


Using the <code>with</code> statement the above code is simplified as:


```python
with open("test.txt") as file: 
 data = file.read() 
```


The <code>with</code> statement helps simplify some common resource management patterns by abstracting their functionality and allowing them to be factored out and reused. The code becomes expressive and easier to read. In fact, we can write a class that implements the enter and exit methods and makes it compatible with the <code>with</code> statement. An example is shown below:


```python
class ExampleClass(object):

 def __init__(self, val):
 print("init")
 self.val = val

 def display(self):
 print(self.val)

 def __enter__(self):
 print("enter invoked")
 return self

 def __exit__(self, exc_type, exc_val, exc_tb):
 print("exit invoked")


if __name__ == "__main__":
 with ExampleClass("hello world") as example:
 example.display()

```

</div>
</div>

This lesson introduces the use of with and context management with synchronization primitives.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

With

With