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>We have already discussed the Global Interpreter Lock and the challenges it presents when writing concurrent applications in Python. Depending on the use case we can either apply a multithreaded approach or an asynchronous one but in either case, we'll need to be mindful of the ways in which the GIL can impact our solution. In this section, we'll work with a web service that is implemented first using threads and then asyncio and examine the issues we'll face with compute-bound tasks. The examples in this section are inspired from <a href="https://www.dabeaz.com/" target="-blank">Dave Beazley's</a> PyCon <a href="https://www.youtube.com/watch?v=MCs5OvhV9S4" target="_blank">talk</a>.</p>

## Setup
<p>We'll create a very simple webservice that returns the <b>nth</b> prime number requested by a client. For instance, if the input is 1 the service returns the first prime number which is 2, if the input is 10 the service returns 29, which is the 10th prime number. We pick a very inefficient compute-intensive algorithm to find the nth prime number. You shouldn't focus on the code that finds the prime number as it can be substituted for any computationally intensive task.</p>

<p>Initially, we'll start with a multithreaded implementation of the server. The code which starts up the service is shown below:</p>
<b>

```python
    def run_service(self):
        s = socket.socket()
        s.bind(('', self.server_port))

        # put the socket into listening mode
        s.listen(5)
        client_socket, addr = s.accept()
        data = client_socket.recv(4096).decode()
        nth_prime = int(data)
        print("Asked to find the {0}-nth prime".format(nth_prime))

        prime = self.find_nth_prime(nth_prime)
        client_socket.send(str(prime).encode())
```
</b>

<p>The complete code appears in the code-widget below. </p>
</div>
</div>


<div>
   # Introduction   
   <div>
<p>We have already discussed the Global Interpreter Lock and the challenges it presents when writing concurrent applications in Python. Depending on the use case we can either apply a multithreaded approach or an asynchronous one but in either case, we'll need to be mindful of the ways in which the GIL can impact our solution. In this section, we'll work with a web service that is implemented first using threads and then asyncio and examine the issues we'll face with compute-bound tasks. The examples in this section are inspired from <a href="https://www.dabeaz.com/" target="-blank">Dave Beazley's</a> PyCon <a href="https://www.youtube.com/watch?v=MCs5OvhV9S4" target="_blank">talk</a>.</p>

## Setup
<p>We'll create a very simple webservice that returns the <b>nth</b> prime number requested by a client. For instance, if the input is 1 the service returns the first prime number which is 2, if the input is 10 the service returns 29, which is the 10th prime number. We pick a very inefficient compute-intensive algorithm to find the nth prime number. You shouldn't focus on the code that finds the prime number as it can be substituted for any computationally intensive task.</p>

<p>Initially, we'll start with a multithreaded implementation of the server. The code which starts up the service is shown below:</p>
<b>

```python
    def run_service(self):
        s = socket.socket()
        s.bind(('', self.server_port))

        # put the socket into listening mode
        s.listen(5)
        client_socket, addr = s.accept()
        data = client_socket.recv(4096).decode()
        nth_prime = int(data)
        print("Asked to find the {0}-nth prime".format(nth_prime))

        prime = self.find_nth_prime(nth_prime)
        client_socket.send(str(prime).encode())
```
</b>

<p>The complete code appears in the code-widget below. </p>
</div>
</div>


This lesson lays the context for a hands-on exercise we'll undertake to study the effects of GIL on a web-service when designed and implemented using different concurrency paradigms.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Introduction