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">
   # Asynchronous   
   <div class="ans">
<p>We have seen our service go through various transformations and now we'll modify our service once more to make it run on asyncio's event loop. The loop runs in a single thread and all tasks get executed by the same thread. First, let us see the changes required for the service.</p>
<b>

```python
class PrimeService:

    def __init__(self, server_host, server_port):
        self.server_host = server_host
        self.server_port = server_port
        self.executor = ProcessPoolExecutor()

    async def handle_client(self, reader, writer):
        global requests

        while True:
            data = (await reader.read(4096)).decode()
            nth_prime = int(data)

            prime = await asyncio.create_task(find_nth_prime(nth_prime))

            writer.write(str(prime).encode())
            await writer.drain()

            requests += 1
```
</b>

<p>Note we have factored out the methods that crunch numbers and also we don't need to setup the server to accept incoming connections. We'll pass the <code class="mthd">handle_clients()</code> method as a callback to the asyncio's <code class="mthd">start_server()</code> method. The snippet appears below:</p>
<b>

```python
async def main():
    service = PrimeService(server_host, server_port)
    server = await asyncio.start_server(service.handle_client, "localhost", server_port)
    await server.serve_forever()
```
</b>

<p>Since <code class="mthd">main()</code> is a coroutine we start it using:</p>
<b>

```python
def server_code():
    asyncio.run(main())
```
</b>

<p>For our simulation, we'll have one thread that runs the <code class="mthd">server_code()</code> method and also becomes the event loop thread. We also spawn other threads that make client requests. The complete code is given below:</p>
<b>

```python
requests = 0


async def find_nth_prime(nth_prime):
    i = 2
    nth = 0

    while nth != nth_prime:
        if is_prime(i):
            nth += 1
            last_prime = i

        i += 1

    return last_prime


def is_prime(num):
    if num == 2:
        return True

    div = 2

    while div <= num / 2:
        if num % div == 0:
            return False
        div += 1
    return True


def monitor_requests_per_thread():
    global requests
    while 1:
        time.sleep(1)
        print("{0} requests/secs".format(requests))
        requests = 0


class PrimeService:

    def __init__(self, server_host, server_port):
        self.server_host = server_host
        self.server_port = server_port
        self.executor = ProcessPoolExecutor()

    async def handle_client(self, reader, writer):
        global requests

        while True:
            data = (await reader.read(4096)).decode()
            nth_prime = int(data)

            prime = await asyncio.create_task(find_nth_prime(nth_prime))

            writer.write(str(prime).encode())
            await writer.drain()

            requests += 1


def run_simple_client(server_host, server_port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect((server_host, server_port))

    while 1:
        server_socket.send("1".encode())
        server_socket.recv(4096)


def run_long_request(server_host, server_port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect((server_host, server_port))

    while 1:
        server_socket.send("100000".encode())
        server_socket.recv(4096)


async def main():
    service = PrimeService(server_host, server_port)
    server = await asyncio.start_server(service.handle_client, "localhost", server_port)
    await server.serve_forever()


def server_code():
    asyncio.run(main())


if __name__ == "__main__":
    server_port = random.randint(10000, 65000)
    server_host = "localhost"

    Thread(target=server_code, daemon=True).start()

    time.sleep(0.1)

    # run the monitor thread
    Thread(target=monitor_requests_per_thread, daemon=True).start()

    # run a simple request
    Thread(target=run_simple_client, args=(server_host, server_port), daemon=True).start()

    # issue a long-running request after three minutes
    time.sleep(3)
    Thread(target=run_long_request, args=(server_host, server_port), daemon=True).start()

    time.sleep(10)

```
</b>

<p>Again, we don't concern ourselves with graceful shutdown as that is tangential to our discussion. The widget would timeout after running the simulation for a few seconds. Note that the code that appears in the code widget is slightly different so that it can work with Python 3.5 but the intention is the same as we described.</p>
</div>
</div>


<div>
   # Asynchronous   
   <div>
<p>We have seen our service go through various transformations and now we'll modify our service once more to make it run on asyncio's event loop. The loop runs in a single thread and all tasks get executed by the same thread. First, let us see the changes required for the service.</p>
<b>

```python
class PrimeService:

    def __init__(self, server_host, server_port):
        self.server_host = server_host
        self.server_port = server_port
        self.executor = ProcessPoolExecutor()

    async def handle_client(self, reader, writer):
        global requests

        while True:
            data = (await reader.read(4096)).decode()
            nth_prime = int(data)

            prime = await asyncio.create_task(find_nth_prime(nth_prime))

            writer.write(str(prime).encode())
            await writer.drain()

            requests += 1
```
</b>

<p>Note we have factored out the methods that crunch numbers and also we don't need to setup the server to accept incoming connections. We'll pass the <code>handle_clients()</code> method as a callback to the asyncio's <code>start_server()</code> method. The snippet appears below:</p>
<b>

```python
async def main():
    service = PrimeService(server_host, server_port)
    server = await asyncio.start_server(service.handle_client, "localhost", server_port)
    await server.serve_forever()
```
</b>

<p>Since <code>main()</code> is a coroutine we start it using:</p>
<b>

```python
def server_code():
    asyncio.run(main())
```
</b>

<p>For our simulation, we'll have one thread that runs the <code>server_code()</code> method and also becomes the event loop thread. We also spawn other threads that make client requests. The complete code is given below:</p>
<b>

```python
requests = 0


async def find_nth_prime(nth_prime):
    i = 2
    nth = 0

    while nth != nth_prime:
        if is_prime(i):
            nth += 1
            last_prime = i

        i += 1

    return last_prime


def is_prime(num):
    if num == 2:
        return True

    div = 2

    while div <= num / 2:
        if num % div == 0:
            return False
        div += 1
    return True


def monitor_requests_per_thread():
    global requests
    while 1:
        time.sleep(1)
        print("{0} requests/secs".format(requests))
        requests = 0


class PrimeService:

    def __init__(self, server_host, server_port):
        self.server_host = server_host
        self.server_port = server_port
        self.executor = ProcessPoolExecutor()

    async def handle_client(self, reader, writer):
        global requests

        while True:
            data = (await reader.read(4096)).decode()
            nth_prime = int(data)

            prime = await asyncio.create_task(find_nth_prime(nth_prime))

            writer.write(str(prime).encode())
            await writer.drain()

            requests += 1


def run_simple_client(server_host, server_port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect((server_host, server_port))

    while 1:
        server_socket.send("1".encode())
        server_socket.recv(4096)


def run_long_request(server_host, server_port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect((server_host, server_port))

    while 1:
        server_socket.send("100000".encode())
        server_socket.recv(4096)


async def main():
    service = PrimeService(server_host, server_port)
    server = await asyncio.start_server(service.handle_client, "localhost", server_port)
    await server.serve_forever()


def server_code():
    asyncio.run(main())


if __name__ == "__main__":
    server_port = random.randint(10000, 65000)
    server_host = "localhost"

    Thread(target=server_code, daemon=True).start()

    time.sleep(0.1)

    # run the monitor thread
    Thread(target=monitor_requests_per_thread, daemon=True).start()

    # run a simple request
    Thread(target=run_simple_client, args=(server_host, server_port), daemon=True).start()

    # issue a long-running request after three minutes
    time.sleep(3)
    Thread(target=run_long_request, args=(server_host, server_port), daemon=True).start()

    time.sleep(10)

```
</b>

<p>Again, we don't concern ourselves with graceful shutdown as that is tangential to our discussion. The widget would timeout after running the simulation for a few seconds. Note that the code that appears in the code widget is slightly different so that it can work with Python 3.5 but the intention is the same as we described.</p>
</div>
</div>


This lesson demonstrates how we can convert our threaded design to an asynchronous one.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Asynchronous

Asynchronous