[FIXED] Blocking and non-blocking calls on server side, why does it matter for asynchronous client side?

Issue

Experimenting with some asynchronous code, in Python 3.8.0, I stumbled on the following situation. I have client.py which can handle connections asynchronously with a server in server.py. This server pretends to do some work, but actually sleeps for some seconds and then returns. My question is, since the server is running in a completely different process, why does it matter whether the sleep method is blocking or not and if processes on the server side may not be blocking, what is the benefit of doing asynchronous calls like these in the first place?

# client.py

import time
import asyncio

import aiohttp


async def request_coro(url, session):
    async with session.get(url) as response:
        return await response.read()


async def concurrent_requests(number, url='http://localhost:8080'):
    tasks = []
    async with aiohttp.ClientSession() as session:
        for n in range(number):
            # Schedule the tasks
            task = asyncio.create_task(request_coro(url, session))
            tasks.append(task)

        # returns when all tasks are completed
        return await asyncio.gather(*tasks)


t0 = time.time()
responses = asyncio.run(concurrent_requests(10))
elapsed_concurrent = time.time() - t0

sum_sleeps = sum((int(i) for i in responses))
print(f'{elapsed_concurrent=:.2f} and {sum_sleeps=:.2f}')

# server.py

import time
import random
import logging
import asyncio

from aiohttp import web


random.seed(10)


async def index(requests):
    # Introduce some latency at the server side
    sleeps = random.randint(1, 3)

    # NON-BLOCKING
    # await asyncio.sleep(sleeps)

    # BLOCKING
    time.sleep(sleeps)

    return web.Response(text=str(sleeps))


app = web.Application()
app.add_routes([web.get('/', index),
                web.get('/index', index)])


logging.basicConfig(level=logging.DEBUG)
web.run_app(app, host='localhost', port=8080)

These are the results from 10 asynchronous calls by the client using either the blocking or the non-blocking sleep methods:

asyncio.sleep (non-blocking)

elapsed_concurrent=3.02 and sum_sleeps=19.00

time.sleep (blocking)

elapsed_concurrent=19.04 and sum_sleeps=19.00

Solution

Although the server is running in a completely different process, it can not take multiple active connections at the same time, like a multi threaded server. So the client and the server are working asynchonously both having their own event loop.

The server can only take new connections from the client when the event loop is suspended in a non-blocking sleep. Making it appear that the server is multi threaded but actually rapidly alternates between available connections. A blocking sleep will make the requests sequential because the suspended event loop will sit idle and can not handle new connections in the mean time.

Answered By - BramAppel