Aprendizaje de Python - asyncio

asyncio es una biblioteca estándar introducida en Python 3.4, que admite directamente IO asíncrona.

El modelo de programación de asyncio es un bucle de mensajes. Obtenemos directamente una referencia a EventLoop del módulo asyncio, y luego lanzamos la corrutina que debe ejecutarse en EventLoop para su ejecución, y luego se realiza la E / S asincrónica.

Use asyncio para implementar el código Hello world de la siguiente manera:

import asyncio

@asyncio.coroutine
def hello():
	print('Hello world!')
	# 异步调用asyncio.sleep(1):
	r = yield from asyncio.sleep(1)
	print("Hello again!")

# 获取EventLoop:
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())
loop.close()

@ asyncio.coroutine marca un generador como un tipo de corrutina, y luego lanzamos esta corrutina a EventLoop para su ejecución.

hello () imprimirá Hu Hola mundo primero! Luego, el rendimiento de la sintaxis nos permite llamar convenientemente a otro generador. Dado que asyncio.sleep () también es una corrutina, el hilo no esperará a asyncio.sleep (), sino que interrumpirá y ejecutará directamente el siguiente bucle de mensajes. Cuando asyncio.sleep () regresa, el hilo puede obtener el valor de retorno de yield de (aquí es None), y luego ejecutar la siguiente línea de declaraciones.

Considere asyncio.sleep (1) como una operación IO que toma 1 segundo Durante este período, el hilo principal no espera, sino que ejecuta otras corrutinas ejecutables en EventLoop, por lo que se puede lograr una ejecución concurrente.

Intentemos encapsular dos corrutinas con Task:

import threading
import asyncio

@asyncio.coroutine
def hello():
	print('Hello world! (%s)' % threading.currentThread())
	yield from asyncio.sleep(1)
	print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

Observe el proceso de ejecución:

Hello world! (<_MainThread(MainThread, started 140735195337472)>)
Hello world! (<_MainThread(MainThread, started 140735195337472)>)
(暂停约1秒)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)

Se puede ver en el nombre del hilo actual impreso que las dos corrutinas se ejecutan simultáneamente por el mismo hilo.

Si reemplaza asyncio.sleep () con una operación de E / S real, un hilo puede ejecutar varias corrutinas al mismo tiempo.

Usamos la conexión de red asincrónica de asyncio para obtener la página de inicio de sina, sohu y 163:

import asyncio

@asyncio.coroutine
def wget(host):
	print('wget %s...' % host)
	connect = asyncio.open_connection(host, 80)
	reader, writer = yield from connect
	header = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % host
    writer.write(header.encode('utf-8'))
    yield from writer.drain()
    while True:
    	line = yield from reader.readline()
    	if line == b'\r\n':
            break
        print('%s header > %s' % (host, line.decode('utf-8').rstrip()))
    # Ignore the body, close the socket
    writer.close()

loop = asyncio.get_event_loop()
tasks = [wget(host) for host in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
    	

Los resultados son los siguientes:

wget www.sohu.com...
wget www.sina.com.cn...
wget www.163.com...
(等待一段时间)
(打印出sohu的header)
www.sohu.com header > HTTP/1.1 200 OK
www.sohu.com header > Content-Type: text/html
...
(打印出sina的header)
www.sina.com.cn header > HTTP/1.1 200 OK
www.sina.com.cn header > Date: Wed, 20 May 2015 04:56:33 GMT
...
(打印出163的header)
www.163.com header > HTTP/1.0 302 Moved Temporarily
www.163.com header > Server: Cdn Cache Server V2.0
...

Se puede ver que 3 conexiones se completan simultáneamente por un hilo a través de una rutina.

resumen

asyncio proporciona soporte IO asincrónico completo;

Las operaciones asincrónicas deben completarse mediante el rendimiento de una rutina;

Se pueden empaquetar varias corrutinas en un conjunto de tareas y luego ejecutarlas simultáneamente.
(Clave: ejecución concurrente después de encapsular un grupo de tareas)