How does the Python asynchronous framework of the three major web front-end frameworks work?

In this article, we will look at the example of socket programming to see how Python asynchronous framework works. We need to understand simple socket programming and the I/O reuse mechanism provided by Linux. Python asynchronous framework is also implemented based on the I/O multiplexing mechanism provided by the underlying operating system. For example, select/poll/epoll can be used under Linux. Let’s first look at a simple python socket server example. The Python code uses Python3 and ensures that the selectors module can be used.

An example

import socket
HOST = 'localhost'    # The remote host
PORT = 8888 # Arbitrary non-privileged port
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((HOST, PORT))
    s.listen(50)
    while True:
        conn, addr = s.accept()
        print('Connected by', addr)
        with conn:
            while 1:
                data = conn.recv(1024)
                if not data:
                    break
                conn.sendall(data)

We will use a golang tcp client to test it:

package main
import (
    "fmt"
    "net"
    "os"
    "sync"
)
func sendMessage(msg string) error {
    conn, err := net.Dial("tcp", "localhost:8888")
    if err != nil {
        return fmt.Errorf("error: %v", err)
    }
    defer conn.Close()
    _, err = conn.Write([]byte("hello"))
    if err != nil {
        return fmt.Errorf("error: %v", err)
    }
    reply := make([]byte, 1024)
    _, err = conn.Read(reply)
    if err != nil {
        println("Write to server failed:", err.Error())
        os.Exit(1)
    }
    println("reply from server=", string(reply))
    return nil
}
func main() {
    var wg sync.WaitGroup
    nbGoroutines := 20
    wg.Add(nbGoroutines)
    for k := 0; k < nbGoroutines; k++ {
        go func() {
            err := sendMessage("hello")
            if err != nil {
                fmt.Printf("fail: %v\n", err)
            }
            wg.Done()
        }()
    }
    wg.Wait()
}

Use go to run it and you can see output.

Next we use the selectros provided by python3 to transform it. This module encapsulates the I/O multiplexing mechanism provided by the underlying operating system, such as epoll used on Linux. Through the I/O multiplexing mechanism, we can monitor the read and write events of multiple file descriptors and register callback functions to achieve better concurrency performance. Let's first look at the example given in the python3 selectors document

import selectors
import socket
sel = selectors.DefaultSelector()
def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)
def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()
sock = socket.socket()
sock.bind(('localhost', 1234))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)
while True:  # 这其实就是通常在异步框架中所说的 event loop 啦
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)

Let's run this tcp echo server that uses the seelctors I/O multiplexing mechanism and look at the output results.

That’s almost it. Let’s continue to run the tcp client written in go to test it and see the results.

In the following tutorials we will use python's coroutine instead of the callback function to transform this example, so that we can use async/await to run it

The above is the detailed content of How does the Python asynchronous framework of the three major web front-end frameworks work?. For more information, please follow other related articles on the PHP Chinese website!