Kürzlich begonnen, die parallele Entwicklungstechnologie von Python zu studieren, einschließlich Multithreading, Multiprozess, Coroutine usw. Ich habe nach und nach einige Informationen im Internet zusammengestellt, und heute habe ich die Greenlet-bezogenen Informationen geordnet.
Technischer Hintergrund der gleichzeitigen Verarbeitung
Parallele Verarbeitung erhält derzeit große Aufmerksamkeit, da paralleles Rechnen in vielen Fällen den Systemdurchsatz erheblich verbessern kann, insbesondere im aktuellen Zeitalter von Multi-Core und Multi-Core. Daher wurden alte Sprachen wie Lisp wieder aufgegriffen und die funktionale Programmierung erfreut sich immer größerer Beliebtheit. Einführung einer Bibliothek für die Parallelverarbeitung in Python: Greenlet. Python verfügt über eine sehr bekannte Bibliothek namens „Stackless“, die hauptsächlich für die gleichzeitige Verarbeitung verwendet wird. Der größte Unterschied zwischen Greenlet und Stackless besteht darin, dass sie sehr leichtgewichtig ist. Nicht genug. Der größte Unterschied besteht darin, dass Sie den Threadwechsel selbst durchführen müssen. Das heißt, Sie müssen angeben, welches Greenlet jetzt ausgeführt werden soll und welches Greenlet erneut ausgeführt werden soll.
Implementierungsmechanismus von Greenlet
Ich habe Python zum Entwickeln von Webprogrammen verwendet und immer den Fastcgi-Modus verwendet. Dann werden in jedem Prozess mehrere Threads für die Anforderungsverarbeitung gestartet Stellen Sie sicher, dass die Antwortzeit für jede Anfrage sehr kurz ist. Andernfalls verweigert der Server den Dienst, solange noch einige langsame Anfragen gestellt werden, da kein Thread auf die Anfrage antworten kann. Normalerweise werden unsere Dienste auf ihre Leistung getestet Gehen Sie online, daher gibt es unter normalen Umständen kein großes Problem. Es ist jedoch unmöglich, alle Szenarien zu testen. Sobald es auftritt, werden einige Teile nicht verfügbar sein. Später wurde es in Coroutine, Greenlet, unter Python konvertiert. Also habe ich einen einfachen Implementierungsmechanismus erstellt.
Jedes Greenlet ist nur ein Python-Objekt (PyGreenlet) im Heap Sie können Millionen oder sogar Dutzende Millionen Greenlets für einen Prozess erstellen.
typedef struct _greenlet {
PyObject_HEAD
char* stack_start;
char* stack_stop;
char* stack_copy;
intptr_t stack_saved;
struct _greenlet* stack_prev;
struct _greenlet* parent;
PyObject* run_info;
struct _frame* top_frame;
int recursion_depth;
PyObject* weakreflist;
PyObject* exc_type;
PyObject* exc_value;
PyObject* exc_traceback;
PyObject* dict;
} PyGreenlet;Nach dem Login kopieren
Jedes Greenlet ist eigentlich eine Funktion und speichert den Kontext, wenn diese Funktion ausgeführt wird. Für eine Funktion ist der Kontext ihr Stapel Alle Greenlets im selben Prozess teilen sich einen vom Betriebssystem zugewiesenen gemeinsamen Benutzerstapel. Daher können nur Greenlets, deren Stapeldaten nicht in Konflikt stehen, den unteren und oberen Teil ihres Stapels über stack_stop und stack_start speichern . Wenn sich der Stack_Stop des auszuführenden Greenlets mit dem derzeit im Stapel befindlichen Greenlet überschneidet, müssen die Stapeldaten dieser überlappenden Greenlets vorübergehend auf dem Heap gespeichert werden. Die gespeicherte Position wird über stack_copy und stack_saved aufgezeichnet Die Positionen von stack_stop und stack_start im Stapel können während der Wiederherstellung vom Heap zurück auf den Stapel kopiert werden. Andernfalls werden die von der Anwendung erstellten Greenlets zerstört der Heap oder vom Heap zum Stack. Es ist wirklich komfortabel, Coroutine für IO-artige Anwendungen zu verwenden.
Das Folgende ist ein einfaches Stack-Space-Modell von Greenlet.c)
A PyGreenlet is a range of C stack addresses that must be
saved and restored in such a way that the full range of the
stack contains valid data when we switch to it.
Stack layout for a greenlet:
| ^^^ |
| older data |
| |
stack_stop . |_______________|
. | |
. | greenlet data |
. | in stack |
. * |_______________| . . _____________ stack_copy + stack_saved
. | | | |
. | data | |greenlet data|
. | unrelated | | saved |
. | to | | in heap |
stack_start . | this | . . |_____________| stack_copy
| greenlet |
| |
| newer data |
| vvv |Nach dem Login kopieren
Das Folgende ist ein einfacher Greenlet-Code.
from greenlet import greenlet
def test1():
print 12
gr2.switch()
print 34
def test2():
print 56
gr1.switch()
print 78
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()Nach dem Login kopieren
Derzeit werden die besprochenen Coroutinen im Allgemeinen von Programmiersprachen unterstützt. Zu den mir bekannten Sprachen, die Coroutine-Unterstützung bieten, gehören derzeit Python, Lua, Go, Erlang, Scala und Rust. Der Unterschied zwischen Coroutinen und Threads besteht darin, dass Coroutinen nicht vom Betriebssystem, sondern vom Programmierer codiert werden. Mit anderen Worten: Die Umschaltung wird vom Programmierer gesteuert, es gibt also keine sogenannte Thread-Sicherheit Frage.
Alle Coroutinen teilen sich den Kontext des gesamten Prozesses, sodass auch der Austausch zwischen Coroutinen sehr praktisch ist.
Im Vergleich zur zweiten Lösung (I/O-Multiplexing) sind mit Coroutinen geschriebene Programme intuitiver, anstatt einen gesamten Prozess in mehrere verwaltete Event-Handler aufzuteilen. Der Nachteil von Coroutinen besteht möglicherweise darin, dass sie die Vorteile von Multicore nicht nutzen können. Dies kann jedoch durch Coroutinen + Prozesse gelöst werden.
Coroutinen können zur Handhabung der Parallelität zur Verbesserung der Leistung verwendet werden und können auch zur Implementierung von Zustandsmaschinen zur Vereinfachung der Programmierung verwendet werden. Ich benutze das zweite mehr. Ich kam Ende letzten Jahres mit Python in Kontakt und lernte das Coroutine-Konzept von Python kennen. Später kam ich über Pycon China 2011 mit der Ertragsverarbeitung in Kontakt. Greenlet ist ebenfalls eine Coroutine-Lösung und meiner Meinung nach eine benutzerfreundlichere Lösung Lösung, insbesondere für die Verarbeitung von Zustandsautomaten.
Derzeit ist dieser Teil im Wesentlichen abgeschlossen. Ich werde mir später die Zeit nehmen, ihn zusammenzufassen.
Zusammenfassend:
1) Multi-Prozess kann die Vorteile von Multi-Core nutzen, aber die Kommunikation zwischen Prozessen ist problematisch. Darüber hinaus führt die Erhöhung der Anzahl von Prozessen zu Leistungseinbußen und die Kosten für die Prozessumstellung sind höher. Die Komplexität des Programmablaufs ist geringer als beim I/O-Multiplexing.
2) Beim E/A-Multiplexing werden mehrere logische Prozesse innerhalb eines Prozesses ohne Prozesswechsel verarbeitet. Die Leistung ist hoch und der Informationsaustausch zwischen Prozessen ist einfach. Allerdings können die Vorteile von Multicore nicht genutzt werden. Zudem wird der Programmablauf durch die Ereignisverarbeitung in kleine Stücke zerlegt, wodurch das Programm komplexer und schwerer verständlich wird.
3) Threads werden innerhalb eines Prozesses ausgeführt und vom Betriebssystem geplant. Die Umstellungskosten sind gering. Darüber hinaus teilen sie sich den virtuellen Adressraum des Prozesses, was den Informationsaustausch zwischen Threads vereinfacht. Allerdings führen Thread-Sicherheitsprobleme zu einer steilen Lernkurve für Threads und sind fehleranfällig.
4) Coroutinen werden von Programmiersprachen bereitgestellt und unter der Kontrolle von Programmierern umgeschaltet, sodass keine Thread-Sicherheitsprobleme auftreten und zur Verarbeitung von Zustandsmaschinen, gleichzeitigen Anforderungen usw. verwendet werden können. Aber Multicore kann nicht genutzt werden.
Die oben genannten vier Lösungen können zusammen verwendet werden, was das Prozess- und Coroutine-Modell angeht
Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung von Python Greenlet und Analyse seiner Implementierungsprinzipien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
