Explication détaillée de la façon dont Python utilise le package asyncio pour gérer la concurrence

Cet article présente principalement en détail les informations pertinentes sur Python utilisant le package asyncio pour gérer la concurrence. Il a une certaine valeur de référence. Les amis intéressés peuvent se référer à

Blocage des E/S et du GIL<.>

L'interpréteur CPython lui-même n'est pas thread-safe, il existe donc un Global Interpreter Lock (GIL) qui permet à un seul thread d'exécuter le bytecode Python à la fois. Par conséquent, un processus Python ne peut généralement pas utiliser plusieurs cœurs de processeur simultanément.

Cependant, toutes les fonctions de la bibliothèque standard qui effectuent des opérations d'E/S bloquantes libéreront le GIL en attendant que le système d'exploitation renvoie un résultat. Cela signifie que le multithreading est possible au niveau du langage Python, et que les programmes Python gourmands en E/S peuvent en bénéficier : pendant qu'un thread Python attend une réponse réseau, la fonction d'E/S bloquante libère le GIL et exécute un autre thread. .

asyncio

Ce package utilise des coroutines pilotées par des boucles d'événements pour implémenter la concurrence. asyncio utilise beaucoup le rendement des expressions et est donc incompatible avec les anciennes versions de Python.

La "coroutine" utilisée par le package asyncio est une définition plus stricte. Les coroutines adaptées à l'API asyncio doivent utiliser le rendement de dans le corps de la définition, mais ne peuvent pas utiliser le rendement. De plus, les coroutines adaptées à asyncio doivent être pilotées par l'appelant et appelées par l'appelant via le rendement de

Exemple 1

@asyncio.coroutine marque la fonction du générateur comme un type de coroutine.

import threading
import asyncio

@asyncio.coroutine
def hello():
  print('Start Hello', threading.currentThread())
  yield from asyncio.sleep(5)
  print('End Hello', threading.currentThread())

@asyncio.coroutine
def world():
  print('Start World', threading.currentThread())
  yield from asyncio.sleep(3)
  print('End World', threading.currentThread())

# 获取EventLoop:
loop = asyncio.get_event_loop()
tasks = [hello(), world()]
# 执行coroutine
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

asyncio.sleep(3) crée une coroutine qui se termine en 3 secondes.

loop.run_until_complete(future), exécuté jusqu'à ce que le futur soit terminé ; si le paramètre est un objet coroutine, vous devez utiliser le wrapper de fonction Ensure_future().
loop.close() ferme la boucle d'événements

Exemple 2

Explication :

import asyncio

@asyncio.coroutine
def worker(text):
  """
  协程运行的函数
  :param text:
  :return:
  """
  i = 0
  while True:
    print(text, i)

    try:
      yield from asyncio.sleep(.1)
    except asyncio.CancelledError:
      break

    i += 1


@asyncio.coroutine
def client(text, io_used):
  worker_fu = asyncio.ensure_future(worker(text))

  # 假装等待I/O一段时间
  yield from asyncio.sleep(io_used)

  # 结束运行协程
  worker_fu.cancel()
  return 'done'


loop = asyncio.get_event_loop()
tasks = [client('xiaozhe', 3), client('zzzz', 5)]
result = loop.run_until_complete(asyncio.wait(tasks))
loop.close()
print('Answer:', result)

1. asyncio.ensure_future(coro_or_future, *, loop=None) : Prévoyez de planifier l'exécution d'un objet coroutine et de renvoyer un objet asyncio.Task.

2. worker_fu.cancel() : annule l'exécution d'une coroutine et lève une exception CancelledError.

3. asyncio.wait() : Le paramètre de la coroutine est un objet itérable composé de futurs ou de coroutines ; wait enveloppera chaque coroutine dans un objet Task.

Comparaison des objets asyncio.Task et des objets threading.Thread

Les objets Asyncio.Task sont presque équivalents aux objets threading.Thread.

L'objet Task est utilisé pour piloter les coroutines et l'objet Thread est utilisé pour appeler des objets appelables.

Les objets de tâche ne sont pas instanciés par vous-même, mais sont obtenus en passant la coroutine à la fonction asyncio.ensure_future(…) ou à la méthode loop.create_task(…).
L'exécution de l'objet Task obtenu a été planifiée ; l'instance Thread doit appeler la méthode start pour lui dire explicitement de s'exécuter.
Si vous souhaitez terminer la tâche, vous pouvez utiliser la méthode d'instance Task.cancel() pour lancer une exception CancelledError dans la coroutine.

Comparaison de sécurité des threads et des coroutines

Si vous avez effectué une programmation importante à l'aide de threads, le planificateur peut interrompre le thread à tout moment. Vous devez vous rappeler de conserver les verrous pour protéger les parties importantes du programme, empêcher les opérations en plusieurs étapes d'être interrompues pendant l'exécution et empêcher les données d'être dans un état invalide.

Les coroutines seront entièrement protégées par défaut pour éviter les interruptions. Nous devons afficher explicitement pour que le reste du programme s'exécute. Pour les coroutines, il n'est pas nécessaire de conserver les verrous et de synchroniser les opérations entre plusieurs threads. Les coroutines elles-mêmes seront synchronisées car une seule coroutine est en cours d'exécution à la fois. Lorsque vous souhaitez céder le contrôle, vous pouvez utiliser le rendement ou le rendement de pour rendre le contrôle au planificateur. C'est pourquoi les coroutines peuvent être annulées en toute sécurité : par définition, les coroutines ne peuvent être annulées qu'en cas de pause, de sorte que les exceptions CancelledError peuvent être gérées et les opérations de nettoyage effectuées.

Futur (futur)

Normalement, vous ne devriez pas créer de futurs vous-même, mais ne pouvez être instancié que par le cadre de concurrence (concurrent.futures ou asyncio). La raison est simple : les contrats à terme représentent quelque chose qui finira par se produire, et la seule façon de savoir avec certitude que quelque chose va se produire est que son exécution soit planifiée.

asyncio.Future

Dans le package asyncio, la méthode BaseEventLoop.create_task(…) reçoit une coroutine, planifie son exécution et renvoie une instance de tâche asyncio -. est également une instance de la classe asyncio.Future, car Task est une sous-classe de Future et est utilisée pour envelopper les coroutines.

asyncio.ensure_future(coro_or_future, *, loop=None)

Cette fonction unifie les coroutines et les futurs : le premier paramètre peut être l'un des deux. S'il s'agit d'un objet Future ou Task, il est renvoyé inchangé. S'il s'agit d'une coroutine, la fonction asynchrone appellera la méthode loop.create_task(...) pour créer un objet Task. L'argument de mot-clé loop= est facultatif et est utilisé pour transmettre la boucle d'événements ; s'il n'est pas transmis, la fonction async obtiendra l'objet de boucle en appelant la fonction asyncio.get_event_loop().

BaseEventLoop.create_task(coro)

Cette méthode planifie le temps d'exécution de la coroutine et renvoie un objet asyncio.Task.

Il existe plusieurs fonctions dans le package asyncio qui encapsulent automatiquement la coroutine spécifiée par le paramètre dans un objet asyncio.Task, comme la méthode BaseEventLoop.run_until_complete(…).

asyncio.as_completed

为了集成进度条，我们可以使用的是 as_completed 生成器函数；幸好， asyncio 包提供了这个生成器函数的相应版本。

使用asyncio和aiohttp包

从 Python 3.4 起， asyncio 包只直接支持 TCP 和 UDP。如果想使用 HTTP 或其他协议，那么要借助第三方包 aiohttp 。

cc_list = ['China', 'USA']

@asyncio.coroutine
def get_flag(cc):
  url = '{}/{cc}/{cc}.gif'.format(BASE_URL, cc=cc.lower())
  resp = yield from aiohttp.request('GET', url)
  image = yield from resp.read()
  return image

@asyncio.coroutine
def download_one(name): 
  image = yield from get_flag(name) 
  save_flag(image, name.lower() + '.gif')
  return name

loop = asyncio.get_event_loop() 
wait_coro = asyncio.wait([download_one(cc) for cc in sorted(cc_list)]) 
res, _ = loop.run_until_complete(wait_coro) 
loop.close()

使用 asyncio 包时，我们编写的异步代码中包含由 asyncio 本身驱动的协程（即委派生成器），而生成器最终把职责委托给 asyncio 包或第三方库（如aiohttp）中的协程。这种处理方式相当于架起了管道，让 asyncio 事件循环（通过我们编写的协程）驱动执行低层异步 I/O 操作的库函数。

避免阻塞型调用

有两种方法能避免阻塞型调用中止整个应用程序的进程：
1. 在单独的线程中运行各个阻塞型操作
2. 把每个阻塞型操作转换成非阻塞的异步调用使用

多个线程是可以的，但是各个操作系统线程（Python 使用的是这种线程）消耗的内存达兆字节（具体的量取决于操作系统种类）。如果要处理几千个连接，而每个连接都使用一个线程的话，我们负担不起。

把生成器当作协程使用是异步编程的另一种方式。对事件循环来说，调用回调与在暂停的协程上调用 .send() 方法效果差不多。各个暂停的协程是要消耗内存，但是比线程消耗的内存数量级小。

上面的脚本为什么会很快

在上面的脚本中，调用 loop.run_until_complete 方法时，事件循环驱动各个download_one 协程，运行到第一个 yield from 表达式处时，那个表达式驱动各个get_flag 协程，然后在get_flag协程里面运行到第一个 yield from 表达式处时，调用 aiohttp.request(…)函数。这些调用都不会阻塞，因此在零点几秒内所有请求全部开始。

asyncio 的基础设施获得第一个响应后，事件循环把响应发给等待结果的 get_flag 协程。得到响应后， get_flag 向前执行到下一个 yield from 表达式处，调用resp.read() 方法，然后把控制权还给主循环。其他响应会陆续返回。所有 get_ flag 协程都获得结果后，委派生成器 download_one 恢复，保存图像文件。

async和await

为了简化并更好地标识异步IO，从Python 3.5开始引入了新的语法async和await，可以让coroutine的代码更简洁易读。

async和await是针对coroutine的新语法，要使用新的语法，只需要做两步简单的替换。
1. 把@asyncio.coroutine替换为async
2. 把yield from替换为await

例如：

@asyncio.coroutine
def hello():
  print("Hello world!")
  r = yield from asyncio.sleep(1)
  print("Hello again!")

等同于

async def hello():
  print("Hello world!")
  r = await asyncio.sleep(1)
  print("Hello again!")

网站请求实例

import asyncio
import aiohttp

urls = [
  'http://www.163.com/',
  'http://www.sina.com.cn/',
  'https://www.hupu.com/',
  'http://www.php.cn/'
]


async def get_url_data(u):
  """
  读取url的数据
  :param u:
  :return:
  """
  print('running ', u)
  async with aiohttp.ClientSession() as session:
    async with session.get(u) as resp:
      print(u, resp.status, type(resp.text()))
      # print(await resp.text())

  return resp.headers


async def request_url(u):
  """
  主调度函数
  :param u:
  :return:
  """
  res = await get_url_data(u)
  return res


loop = asyncio.get_event_loop()
task_lists = asyncio.wait([request_url(u) for u in urls])
all_res, _ = loop.run_until_complete(task_lists)
loop.close()

print(all_res)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!