Asynchrone Python-Netzwerkerkundung

Es wird gesagt, dass asynchrone Netzwerke die Verbindungsgeschwindigkeit von Netzwerkservern erheblich verbessern können. Daher habe ich vor, ein Thema zu schreiben, um asynchrone Netzwerke zu lernen und zu verstehen. Da Python über eine sehr berühmte asynchrone Lib verfügt: Twisted, habe ich zur Vervollständigung Python verwendet

OK, schreibe zuerst ein Serversegment des Python-Sockets und öffne drei Ports: 10000, 10001, 10002. Im Krondo-Beispiel ist jeder Server an einen Port gebunden. Während des Tests müssen Sie 3 Shells öffnen Dies ist zu mühsam. Verwenden Sie daher drei Threads, um diese Dienste auszuführen. Wenn kein asynchrones Netzwerk vorhanden ist, stellen Sie eine Verbindung zum Server her.

import optparse
import os
import socket
import time
from threading import Thread
import StringIO
 
txt = '''1111
2222
3333
4444
'''
 
def server(listen_socket):
    while True:
        buf = StringIO.StringIO(txt)
        sock, addr = listen_socket.accept()
        print 'Somebody at %s wants poetry!' % (addr,)
        while True:
                try:
                    line = buf.readline().strip()
                    if not line:
                        sock.close()
                        break
                    sock.sendall(line)  # this is a blocking call
                    print 'send bytes to client:%s' % line
                    #sock.close()
                except socket.error:
                    sock.close()
                    break
                time.sleep(1)  #server和client连接后，server会故意每发送一个单词后等待一秒钟后再发送另一个单词
 
 
def main():
    ports = [10000, 10001, 10002]
    for port in ports:
        listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        addres = (str('127.0.0.1'), port)
        listen_socket.bind(addres)
        listen_socket.listen(5)
        print "start listen at:%s" % (port,)
        worker = Thread(target = server, args = [listen_socket])
        worker.setDaemon(True)
        worker.start()
 
 
if __name__ == '__main__':
    main()
    while True:
        time.sleep(0.1) #如果不sleep的话,CPU会被Python完全占用了
        pass

Der asynchrone Client wird zum Lesen verwendet. Der Code lautet wie folgt:

import socket
 
 
if __name__ == '__main__':
    ports = [10000, 10001, 10002]
    for port in ports:
        address = (str('127.0.0.1'), port)
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect(address)
        poem = ''
        while True:
            data = sock.recv(4)
            if not data:
                sock.close()
                break
            poem += data
        print poem

Das Ergebnis ist, dass die Leseaufgabe nur 4 Sekunden dauert. Die Effizienz ist derzeit dreimal so hoch wie die des synchronisierten Sockets. Bei der asynchronen Transformation des Clients gibt es zwei Hauptpunkte:

import datetime, errno, optparse, select, socket
 
def connect(port):
    """Connect to the given server and return a non-blocking socket."""
    address = (str('127.0.0.1'), port)
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(address)
    sock.setblocking(0)
    return sock
 
def format_address(address):
    host, port = address
    return '%s:%s' % (host or '127.0.0.1', port)
 
if __name__ == '__main__':
    ports = [10000, 10001, 10002]
    start = datetime.datetime.now()
 
    sockets = map(connect, ports)
    poems = dict.fromkeys(sockets, '') # socket -> accumulated poem 
 
    # socket -> task numbers
    sock2task = dict([(s, i + 1) for i, s in enumerate(sockets)])
    sockets = list(sockets) # make a copy
 
    while sockets:
        #运用select来确保那些可读取的异步socket可以立即开始读取IO
        #OS不停的搜索目前可以read的socket，有的话就返回rlist
        rlist, _, _ = select.select(sockets, [], [])
        for sock in rlist:
            data = ''
            while True:
                try:
                    new_data = sock.recv(1024)
                except socket.error, e:
                    if e.args[0] == errno.EWOULDBLOCK:
                        break
                    raise
                else:
                    if not new_data:
                        break
                    else:
                        print new_data
                        data += new_data
 
            task_num = sock2task[sock]
            if not data:
                sockets.remove(sock)
                sock.close()
                print 'Task %d finished' % task_num
            else:
                addr_fmt = format_address(sock.getpeername())
                msg = 'Task %d: got %d bytes of poetry from %s'
                print  msg % (task_num, len(data), addr_fmt)
 
            poems[sock] += data
 
    elapsed = datetime.datetime.now() - start
    print 'Got poems in %s' %  elapsed

Im synchronen Modus erstellt der Client Sockets separat, im asynchronen Modus erstellt der Client alle Sockets von Anfang an.

Setzen Sie den Socket über „sock.setblocking(0)“ in den asynchronen Modus.

Lesbare E/A über die beiden ausgewählten Unix-Systeme zurückgeben

Die wichtigsten sind die Zeilen 26 und 29. Insbesondere gibt die Auswahloperation in Zeile 29 die Liste der zu lesenden Sockets zurück.