Comprendre l'asyncio de Python | Journal Linux – Bien choisir son serveur d impression

Comment commencer à utiliser asyncio de Python.

Plus tôt cette année, j'ai assisté à PyCon, le salon international Python
conférence. Un sujet, présenté lors de nombreuses conférences et discuté
officieusement dans le couloir, était l'état de filetage en Python – qui
n'est, en un mot, ni idéal ni aussi terrible que certains critiques
se disputer.

Un sujet connexe qui a été soulevé à plusieurs reprises était celui de "l'asyncio", un
approche relativement nouvelle de la concurrence en Python. Non seulement il y avait
des présentations formelles et des discussions informelles sur l'asyncio, mais
nombre de personnes m'ont également posé des questions sur les cours sur le sujet.

Je dois admettre que j'ai été un peu surpris par tout l'intérêt. Après
tous, asyncio n'est pas un nouvel ajout à Python; ça fait un moment
quelques années. Et, cela ne résout pas tous les problèmes associés à
fils. De plus, il peut être déroutant pour de nombreuses personnes de commencer avec cela.

Et pourtant, on ne peut nier qu'après un certain nombre d'années où
les gens ont ignoré l'asyncio, ça commence à prendre de l'ampleur. Je suis sûr
en partie parce que l'asyncio a mûri et s'est amélioré au fil du temps,
merci en grande partie au travail dévoué de nombreux développeurs.
Mais c'est aussi parce que l'asyncio est un choix de plus en plus bon et utile
pour certains types de tâches, en particulier les tâches qui
les réseaux.

Donc, avec cet article, je lance une série sur asyncio – ce que c'est, comment
l'utiliser, où cela est approprié, et comment vous pouvez et devez (et ne pouvez pas non plus
et ne devrait pas) l'intégrer dans votre propre travail.

Qu'est-ce que l'asyncio?

Tout le monde est habitué à ce que les ordinateurs soient capables de faire plus d'une chose à la fois.
le temps – enfin, en quelque sorte. Bien qu’il puisse sembler que les ordinateurs sont
faire plus d'une chose à la fois, ils sont en train de changer, très
rapidement, à travers différentes tâches. Par exemple, lorsque vous ssh dans un Linux
serveur, il peut sembler qu'il n'exécute que vos commandes. Mais
en réalité, vous obtenez une petite "tranche de temps" du CPU, avec le
reste aller à d'autres tâches sur l'ordinateur, tels que les systèmes qui
gérer la mise en réseau, la sécurité et divers protocoles. En effet, si vous êtes
en utilisant SSH pour se connecter à un tel serveur, certaines de ces tranches de temps
sont utilisés par sshd pour gérer votre connexion et même vous permettre de
émettre des commandes.

Tout cela se fait, sur les systèmes d'exploitation modernes, via "préemption
multitâche ". En d'autres termes, les programmes en cours d'exécution n'ont pas le choix
quand ils abandonneront le contrôle du CPU. Ils sont plutôt obligés de
abandonnez le contrôle et reprenez un peu plus tard. Chaque processus
exécuté sur un ordinateur est géré de cette façon. Chaque processus peut, à son tour,
utiliser des threads, des sous-processus qui subdivisent la tranche de temps donnée à leur
processus parent.

Donc, sur un ordinateur hypothétique avec cinq processus (et un cœur), chacun
processus obtiendrait environ 20% du temps. Si l'un de ces processus était
pour avoir quatre threads, chaque thread obtiendrait 5% du temps du processeur.
(Les choses sont évidemment plus complexes que cela, mais c'est un bon moyen de
pensez-y à un niveau élevé.)

Python fonctionne très bien avec les processus via le "multiprocessing"
bibliothèque. Le problème avec les processus est qu'ils sont relativement grands et
encombrants, et vous ne pouvez pas les utiliser pour certaines tâches, telles que l'exécution d'un
fonction en réponse à un clic de bouton, tout en gardant l'interface utilisateur réactive.

Donc, vous voudrez peut-être utiliser des threads. Et en effet, les threads de Python fonctionnent,
et ils fonctionnent bien, pour de nombreuses tâches. Mais ils ne sont pas aussi bons qu'ils pourraient l'être,
à cause du GIL (le verrou d'interpréteur global), qui garantit que
un seul thread s'exécute à la fois. Alors bien sûr, Python vous laissera courir
programmes multithread, et ceux-là même fonctionnent bien quand ils sont
faire beaucoup d'E / S. C'est parce que les E / S sont lentes par rapport au CPU et
mémoire, et Python peut en profiter pour desservir d'autres threads.
Si vous utilisez des threads pour effectuer des calculs sérieux,
Les threads de Python sont une mauvaise idée, et ils ne vous mèneront nulle part. Même avec
de nombreux cœurs, un seul thread s'exécutera à la fois, ce qui signifie que vous êtes
rien de mieux que d'exécuter vos calculs en série.

Les ajouts asyncio à Python offrent un modèle différent pour la concurrence.
Comme pour les threads, asyncio n'est pas une bonne solution aux problèmes liés au processeur
(c'est-à-dire, qui ont besoin de beaucoup de temps CPU pour effectuer les calculs).
Cela ne convient pas non plus lorsque vous devez absolument que les choses fonctionnent vraiment
en parallèle, comme cela arrive avec les processus.

Mais si vos programmes fonctionnent avec le réseau, ou s'ils font des E / S étendues,
asyncio pourrait bien être une bonne façon de procéder.

La bonne nouvelle est que si cela est approprié, asyncio peut être beaucoup plus facile à
travailler avec des fils.

La mauvaise nouvelle est que vous devrez penser d'une manière nouvelle et différente au travail
avec asyncio.

Multitâche coopératif et coroutines

Plus tôt, j'ai mentionné que les systèmes d'exploitation modernes utilisent
multitâche "pour faire avancer les choses, forçant les processus à abandonner le contrôle
du CPU en faveur d'un autre processus. Mais il y a un autre modèle, connu
comme "multitâche coopératif", dans lequel le système attend qu'un programme
abandonne volontairement le contrôle du CPU. D'où le mot «coopération» – si la fonction a décidé d'effectuer des tas de calculs, et jamais
abandonne le contrôle, alors le système ne peut rien y faire.

Cela ressemble à une recette pour un désastre; pourquoi voudriez-vous écrire, encore moins
exécuter, des programmes qui abandonnent le CPU? La réponse est simple. Quand ton
programme utilise les E / S, vous pouvez à peu près garantir que vous serez
attendre paresseusement jusqu'à ce que vous obteniez une réponse, compte tenu du ralentissement des E / S
est que les programmes exécutés en mémoire. Ainsi, vous pouvez renoncer volontairement
CPU chaque fois que vous faites quelque chose avec les E / S, sachant que assez tôt, d'autres
De même, les programmes invoqueront les E / S et abandonneront le processeur, renvoyant
contrôle pour vous.

Pour que cela fonctionne, vous aurez besoin de tous les programmes
au sein de cet univers multitâche coopératif pour convenir d'un terrain
règles. En particulier, vous en aurez besoin pour accepter que toutes les E / S vont
à travers le système multitâche, et qu'aucune des tâches ne monopolisera le
CPU pendant une longue période de temps.

Mais attendez, vous en aurez également besoin d'un peu plus. Vous devrez donner aux tâches un moyen de
arrêtez de l'exécuter volontairement pendant un petit moment, puis redémarrez d'où
ils se sont arrêtés.

Ce dernier morceau existe en fait en Python depuis un certain temps, mais avec
syntaxe légèrement différente. Commençons le voyage
et l'exploration de l'asyncio là-bas.

Une fonction Python normale, lorsqu'elle est appelée, s'exécute du début à la fin.
Par exemple:

def foo ():
    impression ("a")
    impression ("b")
    impression ("c")

Si vous appelez cela, vous verrez:

une
b
c

Bien sûr, il est généralement bon pour les fonctions non seulement d'imprimer
quelque chose, mais aussi pour retourner une valeur:

def bonjour (nom):
    retourner f'Bonjour, nom '

Maintenant, lorsque vous appelez la fonction, vous récupérez quelque chose. Vous pouvez saisir
qui a renvoyé la valeur et l'assignez à une variable:

s = bonjour ('Reuven')

Mais il y a une variation sur revenir qui se révélera au cœur de ce
vous faites ici, à savoir rendement. le rendement la déclaration ressemble et agit
un peu comme revenir, mais il peut être utilisé plusieurs fois dans une fonction,
même dans une boucle:

def bonjour (nom):
    pour i dans la plage (5):
        rendement f '[i] Bonjour, name '

Parce qu'il utilise rendement, plutôt que revenir, c'est ce qu'on appelle un
"fonction générateur". Et quand vous l'invoquez, vous ne récupérez pas un
chaîne, mais plutôt un Générateur objet:

>>> g = bonjour ('Reuven')
>>> type (g)
Générateur

UNE Générateur est une sorte d'objet qui sait se comporter à l'intérieur d'un
Python pour boucle. (En d'autres termes, il implémente le protocole d'itération.)

Lorsqu'elle est placée dans une telle boucle, la fonction commence à s'exécuter. cependant,
chaque fois que la fonction de générateur rencontre un rendement déclaration, il
retourner la valeur à la boucle et se mettre en veille. Quand se réveille-t-il
encore? Quand le pour la boucle demande que la prochaine valeur soit retournée
l'itérateur:

pour s in g:
    impression (s)

Les fonctions de générateur fournissent ainsi l'essentiel de ce dont vous avez besoin: a
fonction qui s'exécute normalement, jusqu'à ce qu'elle atteigne un certain point dans le code.
À ce stade, il renvoie une valeur à son appelant et se met en veille. Quand
le pour boucle demande la prochaine valeur au générateur, la fonction
continue à s'exécuter là où il s'était arrêté (c'est-à-dire juste après la
rendement
comme si elle ne s'était jamais arrêtée.

Le fait est que les générateurs tels que décrits ici produisent une sortie, mais ne peuvent pas
obtenir n'importe quelle entrée. Par exemple, vous pouvez créer un générateur pour en renvoyer un
Nombre de Fibonacci par itération, mais vous ne pouvez pas lui dire de sauter dix
chiffres à venir. Une fois que la fonction générateur est en cours d'exécution, elle ne peut pas
entrées de l'appelant.

Il ne peut pas obtenir de telles entrées via le protocole d'itération normal, c'est-à-dire.
Les générateurs prennent en charge un envoyer méthode, permettant au monde extérieur d'envoyer
tout objet Python au générateur. De cette façon, les générateurs prennent désormais en charge
communication bidirectionnelle. Par exemple:

def bonjour (nom):
    tandis que True:
        name = yield f'Bonjour, name '
        sinon nom:
            Pause

Étant donné la fonction de générateur ci-dessus, vous pouvez maintenant dire:

>>> g = bonjour ('monde')

>>> suivant (g)
'Bonjour le monde'

>>> g.send ('Reuven')
«Bonjour, Reuven»

>>> g.send ('Linux Journal')
«Bonjour, Linux Journal»

En d'autres termes, vous exécutez d'abord la fonction de générateur pour obtenir un générateur
objet ("g") en arrière. Vous devez ensuite l'amorcer avec le suivant une fonction,
jusqu'à et y compris le premier rendement déclaration. À partir de ce
pointez sur, vous pouvez soumettre toute valeur que vous voulez au générateur via le
envoyer méthode. Jusqu'à ce que vous couriez g.send (Aucun), vous continuerez à recevoir
sortie en arrière.

Utilisé de cette façon, le générateur est appelé "coroutine", c'est-à-dire qu'il
a l'état et s'exécute. Mais, il s'exécute en tandem avec le principal
routine, et vous pouvez l'interroger chaque fois que vous voulez en tirer quelque chose.

L'asyncio de Python utilise ces concepts de base, quoique légèrement
syntaxe différente, pour atteindre ses objectifs. Et même si cela peut sembler
une chose banale pour pouvoir envoyer des données dans des générateurs, et obtenir
les choses reviennent régulièrement, c'est loin d'être le cas. En effet, cette
fournit le cœur d'une infrastructure complète qui vous permet de
créer des applications réseau efficaces pouvant gérer de nombreuses applications simultanées
utilisateurs, sans la douleur des threads ou des processus.

Dans mon prochain article, je prévois de commencer à regarder la syntaxe spécifique d'Asyncio et comment elle
correspond à ce que j'ai montré ici. Restez à l'écoute.