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">
   # Single thread   
   <div class="ans">

<p>In this lesson, we'll present a simulation that bombards the server with a trivial request asking for the 1st prime number in an infinite loop. The server has a single thread that serves the request as well as finds the requested prime number. Additionally, we spin up another thread, <b>monitor thread</b> that counts the number of requests the server is able to complete in a second. We keep a counter that is reset to zero after every second and the number of requests being completed is output every second. The implementation from the previous section changes as below:</p>
<b>

```python
    def moniter_thread(self):
        while True:
            time.sleep(1)
            print("{0} requests/min".format(self.requests))
            self.requests = 0

    def run_service(self):

        s = socket.socket()
        s.bind(('', self.server_port))

        # put the socket into listening mode
        s.listen(5)

        while True:
            client_socket, addr = s.accept()

            data = client_socket.recv(4096).decode()
            nth_prime = int(data)
            prime = self.find_nth_prime(nth_prime)
            client_socket.send(str(prime).encode())
            self.requests += 1
            client_socket.close()
```
</b>

<p>We'll also need to modify the client code to run an infinite loop of requests as follows:</p>
<b>

```python
def run_client(server_host, server_port):
    while True:
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.connect((server_host, server_port))
        server_socket.send("1".encode())
        server_socket.recv(4096).decode()
        server_socket.close()
```
</b>

<p>We'll also initiate a thread with a delay that asks for the 10,000th prime number. Evidently, this would completely consume the single thread that is serving the requests and the number of requests per second would drop to zero.</p>


<p>The simulation in the code widget below runs the service, the monitor thread and the client which makes trivial requests in an infinite loop for roughly ten seconds. Three seconds into the program, we spawn the thread that asks for the 10,000-th prime number and the number of requests completed per seconds drops to zero.</p>
</div>
</div>


<div>
   # Single thread   
   <div>

<p>In this lesson, we'll present a simulation that bombards the server with a trivial request asking for the 1st prime number in an infinite loop. The server has a single thread that serves the request as well as finds the requested prime number. Additionally, we spin up another thread, <b>monitor thread</b> that counts the number of requests the server is able to complete in a second. We keep a counter that is reset to zero after every second and the number of requests being completed is output every second. The implementation from the previous section changes as below:</p>
<b>

```python
    def moniter_thread(self):
        while True:
            time.sleep(1)
            print("{0} requests/min".format(self.requests))
            self.requests = 0

    def run_service(self):

        s = socket.socket()
        s.bind(('', self.server_port))

        # put the socket into listening mode
        s.listen(5)

        while True:
            client_socket, addr = s.accept()

            data = client_socket.recv(4096).decode()
            nth_prime = int(data)
            prime = self.find_nth_prime(nth_prime)
            client_socket.send(str(prime).encode())
            self.requests += 1
            client_socket.close()
```
</b>

<p>We'll also need to modify the client code to run an infinite loop of requests as follows:</p>
<b>

```python
def run_client(server_host, server_port):
    while True:
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.connect((server_host, server_port))
        server_socket.send("1".encode())
        server_socket.recv(4096).decode()
        server_socket.close()
```
</b>

<p>We'll also initiate a thread with a delay that asks for the 10,000th prime number. Evidently, this would completely consume the single thread that is serving the requests and the number of requests per second would drop to zero.</p>


<p>The simulation in the code widget below runs the service, the monitor thread and the client which makes trivial requests in an infinite loop for roughly ten seconds. Three seconds into the program, we spawn the thread that asks for the 10,000-th prime number and the number of requests completed per seconds drops to zero.</p>
</div>
</div>


This lesson discusses the implementation of the web-service using a single thread.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Single Thread

Single thread