Compréhension approfondie des fonctions coroutine en python

Le contenu de cet article est de partager avec vous une compréhension approfondie de la fonction coroutine en python. Elle a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer

Concept :

Selon la définition donnée par Wikipédia, "Les coroutines sont des composants de programmes informatiques qui génèrent des sous-programmes pour le multitâche non préemptif. Les coroutines permettent à différents points d'entrée de suspendre ou de démarrer l'exécution d'un programme à différents endroits." D'un point de vue technique, "une coroutine est une fonction dont vous pouvez suspendre l'exécution". Si vous comprenez cela comme « comme un générateur », alors vous pensez bien.

Coroutine, également connue sous le nom de micro-thread , ressemble à un sous-programme, mais elle est différente d'un sous-programme. Pendant le processus d'exécution, elle peut interrompre le sous-programme en cours après l'exécution du programme. d'autres sous-programmes, il revient pour exécuter le sous-programme précédent, mais ses informations associées sont toujours les mêmes qu'auparavant.

Les coroutines sont différentes des threads. Les threads sont une planification préemptive, tandis que les coroutines sont une planification collaborative. Les coroutines doivent effectuer leur propre planification. Les appels de sous-programmes ont toujours une entrée et un retour, et la séquence d'appel est claire. L'appel des coroutines est différent de celui des sous-programmes. Les coroutines ressemblent également à des sous-programmes, mais pendant l'exécution, elles peuvent être interrompues à l'intérieur du sous-programme, puis passer à l'exécution d'autres sous-programmes, puis revenir pour continuer l'exécution au moment approprié.

Avantages des coroutines :

• L'avantage des coroutines est une efficacité d'exécution extrêmement élevée. Étant donné que la commutation de sous-programmes n'est pas une commutation de thread, mais est contrôlée par le programme lui-même, il n'y a pas de surcharge de commutation de thread. Par rapport au multithread, plus le nombre de threads est grand, plus les avantages en termes de performances des coroutines sont évidents. Il est très approprié pour effectuer du multitâche coroutine.

• Les coroutines n'ont pas de problèmes de sécurité des threads. Un processus peut avoir plusieurs coroutines en même temps, mais une seule coroutine est active, et l'activation et la dormance des coroutines sont contrôlées par les programmeurs via la programmation, et non par le système d'exploitation.

Le générateur implémente le principe de la coroutine

Exemple :

def func(n):
    index=0
    if index<=n:
        c=yield 1
        print("task------{}".format(c))
        index+=1f=func(3)
n=next(f)
print(n)try:
    n=f.send(5)#程序就直接结束了
    print("n是{}".format(n))except StopIteration as e:    pass

输出打印：1task------5

Explication :

• Évidemment, func est un générateur et la méthode send a un paramètre qui spécifie la valeur de retour de la dernière instruction rendement suspendue.

• send doit gérer les exceptions.

• En général, la seule différence entre la méthode send et la méthode next est que lors de l'exécution de la méthode send, la valeur de retour de la dernière instruction rendement en attente sera d'abord définie via des paramètres pour réaliser une interaction avec les méthodes du générateur. Cependant, il convient de noter qu'avant qu'un objet générateur n'exécute la méthode suivante, puisqu'aucune instruction rendement n'est suspendue, une erreur sera signalée lors de l'exécution de la méthode send.

• Lorsque le paramètre de la méthode d'envoi est Aucun, cela est tout à fait équivalent à la méthode suivante.

Le générateur implémente les modèles de producteur et de consommateur :

def cunsumer():
    while True:
        n=yield 3
        if not n:            return
        print('cunsumer{}'.format(n))def product(c):
    c.send(None)
    n=0
    while n<5:
        n=n+1
        r=c.send(n)
        print("product{}".format(r))
    c.close()
c=cunsumer()
product(c)

打印：
cunsumer1
product3
cunsumer2
product3
cunsumer3
product3
cunsumer4
product3
cunsumer5
product3

Explication :

dans Le producteur exécute d'abord c.send (Aucun). Le but est de laisser le consommateur raccrocher en premier, puis d'utiliser send pour transmettre la valeur. La première fois que 1 est transmis, le consommateur imprime 1. Le producteur imprime r après le rendement du consommateur. valeur.

Introduction de greenlet

Bien que CPython (Python standard) puisse implémenter des coroutines via des générateurs, il n'est pas très pratique à utiliser.

Dans le même temps, Stackless Python, un dérivé de Python, implémente des coroutines natives, ce qui est plus pratique à utiliser.

Ainsi, tout le monde a commencé à retirer le code de la coroutine dans Stackless et à en faire un package d'extension CPython.

C'est l'origine de greenlet, donc greenlet est une bibliothèque d'extension C qui implémente des coroutines natives en bas.

Schéma de code :

from greenlet import greenletimport randomimport timedef Producer():
    while True:
        item = random.randint(0,10)
        print("生产了{}".format(item))
        c.switch(item)#切换到消费者，并将item传入消费者
        time.sleep(1)def consumer():
    print('我先执行')    #p.switch()
    while True:
        item = p.switch()#切换到生产者，并且等待生产者传入item
        print('消费了{}'.format(item))
c = greenlet(consumer)#将一个普通函数变成一个协程p = greenlet(Producer)
c.switch()#让消费者先进入暂停状态（只有恢复了才能接收数据）

Valeur Greenlet :

• Coroutine native haute performance

• Commutation explicite avec une sémantique plus claire

• Enveloppez les fonctions directement dans des coroutines, en conservant le style de code d'origine

gevent coroutine

Bien que nous ayons un modèle de programmation de rappel basé sur epoll, il est difficile à utiliser.

Même si on peut utiliser la coroutine génératrice pour réaliser des encapsulations complexes afin de simplifier les difficultés de programmation.

Mais il reste un gros problème : l'encapsulation est difficile, et le code existant doit être presque entièrement réécrit

gevent, en encapsulant les deux bibliothèques libev (basée sur epoll) et greenlet. Aidez-nous à l'encapsuler et permettez-nous d'utiliser les coroutines à la manière d'un thread.

Pour que nous puissions utiliser pleinement la puissance d'epoll et des coroutines sans réécrire le code original.

Diagramme de code :

from gevent import monkey;monkey.patch_all()#会把python标准库当中一些阻塞操作变成非阻塞import geventdef test1():
    print("11")
    gevent.sleep(4)#模拟爬虫请求阻塞
    print("33")def test2():
    print("22")
    gevent.sleep(4)
    print("44")
gevent.joinall([gevent.spawn(test1),gevent.spawn(test2)])#joinall 阻塞当前协程，执行给定的greenlet#spawn 启动协程，参数就是函数的名字

La valeur de gevent :

Passer à une autre coroutine en cas de blocage Continuer à exécuter !

• Utilisez libev basé sur epoll pour éviter le blocage.

• Utilisez une coroutine efficace basée sur gevent pour changer d'exécution.

• Bascule uniquement en cas de blocage. Il n'y a pas de surcharge de round-robin ou de thread.

gevent implémente un serveur simultané

from gevent import monkey;monkey.patch_all()  #建议放在首行，会把python标准库当中一些阻塞操作变成非阻塞import geventimport socket


server=socket.socket()
server.bind(('',6666))
server.listen(5)
print("开始监听")def readable(con,addr):
    print("客户端{}接入".format(addr))    while True:
        data=con.recv(1024)        if data:
            print(data)        else:
            con.close()            breakwhile True:
    con,addr=server.accept()
    gevent.spawn(readable,con,addr)#将readable函数变为协程，并且把con和addr传入其中。

communication coroutine gevent

gevent a également sa propre file d'attente. L'utilisation est fondamentalement la même que celle du threading.

Modèles de producteurs et de consommateurs basés sur gevent et file d'attente

from gevent import monkey;monkey.patch_all()import geventfrom gevent.queue import Queueimport randomdef producter(queue):
    while True:
        item=random.randint(0,99)
        print('生产了{}'.format(item))
        queue.put(item)
        gevent.sleep(1)def comuser(queue):
    while True:
        item=queue.get()
        print('消费了{}'.format(item))
queue=Queue()
p=gevent.spawn(producter,queue)
c=gevent.spawn(comuser,queue)
gevent.joinall([p,c])

打印：
生产了33消费了33生产了95消费了95生产了92消费了92...

相关推荐:

python中多进程+协程的使用

python中协程

Python 协程的详细用法和例子

python 协程示例

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!