A demonstration of how a Queue can be used to sync requests over serial

serial_executor_test.py

import asyncio
import functools

class Router(object):
    def __init__(self, n):
        self.serial_queue = asyncio.Queue()
        self.n = n
    
    async def serial_executor(self):
        count = 0
        while True:
            await asyncio.sleep(0)
            if not self.serial_queue.empty():
                handler_f, return_queue = await self.serial_queue.get()
                reply = await handler_f()
                await return_queue.put(reply)
                count += 1
                if count == self.n:
                    break
    
    async def handler(self, msg, return_queue):
        await self.serial_queue.put(
            (functools.partial(self.printer, msg), return_queue))
    
    async def printer(self, msg):
        await asyncio.sleep(0.1)  # A little bit of work
        return 'Printed: {}'.format(msg)

THE_BIG_N = 100
r = Router(THE_BIG_N)
zqueue = asyncio.Queue()
print(zqueue)

async def client(n):
    count = 0
    sent_count = 0
    while True:
        if sent_count < n:
            print('client: {}'.format(sent_count))
            await r.handler(str(sent_count), zqueue)
            sent_count += 1
        await asyncio.sleep(0)
        if not zqueue.empty():
            reply = await zqueue.get()
            print(reply)
            count += 1
            if count == n:
                break
    

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(r.serial_executor(), client(THE_BIG_N)))