Non-blocking I/O explained

I/O

I/O stands for Input/Output, and an I/O operation refers to any process that involves reading data from or writing data to a device or system. These operations are fundamental to how computers and programs interact with various components like storage devices, peripheral devices, or network connections.

Examples of I/O operations include:

Reading data from a file stored on a hard drive or SSD.
Writing data to a file on a storage device.
Receiving data from a network connection, such as downloading a file from a server or loading a webpage.
Sending data over a network connection, such as uploading a file to a server or sending an email.
Reading input from a user through a keyboard or mouse.
Displaying output to a user through a screen or speaker.

I/O operations are essential to the functioning of software and hardware systems, enabling them to communicate, process data, and interact with users. Depending on the nature of the I/O operation and the devices involved, these operations can vary in speed and latency.

Types of I/O

Blocking and non-blocking I/O are two different approaches to handling I/O operations, with non-blocking I/O providing better performance and concurrency in certain situations.

What is a non-blocking I/O? How is it used in web frameworks?

Non-blocking I/O is a method of handling input and output operations that allows a system to continue processing other tasks while waiting for the I/O operation to complete. In traditional blocking I/O, a process or thread is blocked, or paused, until the I/O operation finishes, which can lead to inefficiencies and poor performance, especially in systems with a large number of concurrent connections or tasks.

Non-blocking I/O is used in web frameworks to improve performance, scalability, and resource utilization. In a web application context, it allows a server to handle multiple requests concurrently without waiting for each request to complete before processing the next one. This is particularly useful for handling a large number of simultaneous connections or when the server has to deal with slow clients or high-latency operations, such as database queries or external API calls.

Example: Tornado Web Framework

import tornado.ioloop
import tornado.web
import tornado.httpclient

class MainHandler(tornado.web.RequestHandler):
    async def get(self):
        http_client = tornado.httpclient.AsyncHTTPClient()
        response = await http_client.fetch("https://wellrundigital.com")
        self.write(response.body)

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

In this example, the MainHandler class fetches the content of “https://wellrundigital.com” using Tornado’s AsyncHTTPClient in a non-blocking, asynchronous manner. The await keyword is used to allow other tasks to be processed concurrently while waiting for the HTTP request to complete. This enables the server to handle multiple requests simultaneously without blocking, improving its performance and scalability.

Example: FastAPI Web Framework

import httpx
from fastapi import FastAPI

app = FastAPI()

async def fetch_data(url: str):
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return response

@app.get("/")
async def root():
    response = await fetch_data("https://wellrundigital.com/blog-posts/")
    return response.json()

To run this example, you’ll need to install FastAPI and its dependencies:

pip install fastapi uvicorn httpx

You can run the server using:

uvicorn main:app --reload

In this example, we’ve created a FastAPI application that defines a single route (/). The root function is defined as asynchronous, allowing other tasks to be processed concurrently while waiting for the HTTP request to complete. We use the httpx library, which supports async I/O, to fetch data from an external API (in this case, “https://wellrundigital.com/blog-posts/“).

The fetch_data function is also defined as asynchronous, and it uses the httpx.AsyncClient() context manager for handling HTTP requests in a non-blocking manner. The await keyword is used to allow other tasks to be processed while waiting for the request to complete, making the entire operation non-blocking.

This example demonstrates how FastAPI can be used to create web applications with non-blocking I/O operations, enabling the server to handle multiple requests concurrently and improving overall performance and scalability.

Photo by ThisIsEngineering