Hochleistungs-Python-Programmier-Coroutinen (stapellos)

Wir alle wissen, dass es derzeit vier Arten der gleichzeitigen (nicht parallelen) Programmierung gibt: Multiprozess, Multithread, asynchron und Coroutine.

Die Multiprozessprogrammierung in Python verfügt über ein C-ähnliches os.fork, und natürlich gibt es eine gekapselte Multiprozessor-Standardbibliothek auf höherer Ebene. Ich habe vor http://www eine hochverfügbare Python-Programmiermethode geschrieben. cnblogs.com/hymenz/p/3488837.html bietet eine Signalverarbeitungsmethode ähnlich der zwischen dem Master-Prozess und dem Worker-Prozess in Nginx und stellt sicher, dass der Ausgang des Geschäftsprozesses vom Hauptprozess erkannt werden kann.

Es gibt Thread und Threading in der Multi-Thread-Programmierung in Python. Der sogenannte Thread unter Linux ist eigentlich ein LWP-Lightweight-Prozess, der die gleiche Planungsmethode wie der Prozess im Kernel hat ( write Es gibt weitere Informationen zu Fork, Vfork, Clone usw., daher werde ich hier nicht auf Details eingehen.

Es gibt drei Hauptimplementierungen von Asynchronous unter Linux: Select, Poll und Epoll. Asynchronous steht nicht im Mittelpunkt dieses Artikels.

Wenn wir über Coroutinen sprechen, müssen wir zunächst über Yield sprechen:

#coding=utf-8
import time
import sys
# 生产者
def produce(l):
    i=0
    while 1:
        if i < 5:
            l.append(i)
            yield i
            i=i+1
            time.sleep(1)
        else:
            return
      
# 消费者
def consume(l):
    p = produce(l)
    while 1:
        try:
            p.next()
            while len(l) > 0:
                print l.pop()
        except StopIteration:
            sys.exit(0)
l = []
consume(l)

Im obigen Beispiel handelt es sich um einen Generator, wenn das Programm yield i ausführt zurückgegeben, wenn wir p.next() in benutzerdefiniert aufrufen, kehrt das Programm zu yield i von Produce zurück, um die Ausführung fortzusetzen, sodass Elemente in l angehängt werden, und dann drucken wir l.pop(), bis p.next() StopIteration auslöst abnormal.

Anhand des obigen Beispiels können wir sehen, dass die Planung von Coroutinen für den Kernel unsichtbar ist und die Coroutinen gemeinsam geplant werden. Dies verschlechtert die Leistung von Coroutinen erheblich, wenn die Anzahl der Parallelitäten höher ist als Faden.

import stackless
import urllib2
def output():
    while 1:
        url=chan.receive()
        print url
        f=urllib2.urlopen(url)
        #print f.read()
        print stackless.getcurrent()
     
def input():
    f=open('url.txt')
    l=f.readlines()
    for i in l:
        chan.send(i)
chan=stackless.channel()
[stackless.tasklet(output)() for i in xrange(10)]
stackless.tasklet(input)()
stackless.run()

In Bezug auf Coroutinen können Sie sich auf die Implementierung von Greenlet, Stackless, Gevent, Eventlet usw. beziehen.