Weitere Informationen zu Coroutinen in C ++

Was sind Coroutinen?

• Stapellose Coroutinen
• Coroutinen stapeln
• Grüne Bäche
• Fasern
• Gorutins

void foo(){
     return; //     
}	
foo(); //   / 

def generate_nums():
     num = 0
     while True:
          yield num
          num = num + 1	

nums = generate_nums()
	
for x in nums:
     print(x)
	
     if x > 9:
          break

Coroutinen als Bibliothek

Coroutinen stapeln

• Sie haben ihren eigenen Stapel,
• Die Lebensdauer der Fasern hängt nicht von dem Code ab, der sie aufruft (normalerweise haben sie einen benutzerdefinierten Scheduler).
• Fasern können von einem Faden gelöst und an einem anderen befestigt werden.
• Kooperative Planung (die Glasfaser muss sich entscheiden, zu einer anderen Glasfaser / einem anderen Planer zu wechseln),
• Kann nicht gleichzeitig im selben Thread arbeiten.

• Das Umschalten des Kontexts der Fasern sollte vom Benutzer der Fasern und nicht vom Betriebssystem durchgeführt werden (außerdem kann das Betriebssystem die Faser freigeben und den Thread freigeben, in dem es funktioniert).
• Es gibt kein echtes Datenrennen zwischen den beiden Fasern, da zu einem bestimmten Zeitpunkt nur eine von ihnen aktiv sein kann.
• Der Glasfaserdesigner muss in der Lage sein, den richtigen Ort und die richtige Zeit auszuwählen, wo und wann es angebracht ist, die Rechenleistung an einen möglichen Planer oder Anrufer zurückzugeben.
• Die Eingabe- / Ausgabeoperationen in der Faser müssen asynchron sein, damit andere Fasern ihre Aufgaben ausführen können, ohne sich gegenseitig zu blockieren.

1. Ein regulärer Funktionsaufruf innerhalb eines Threads. Der Speicher wird auf dem Stapel zugewiesen.
2. . . , . . , .
3. .
4. . .
5. .
6. .
7. . , , , .
8. .
9. .
10. – , .
11. , .
12. . .
13. . : , . , ( ) .
14. , .
15. .
16. . . . , .
17. .
18. , , .

#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
	
#include <boost/intrusive_ptr.hpp>
	
#include <boost/fiber/all.hpp>
	
inline
void fn( std::string const& str, int n) {
     for ( int i = 0; i < n; ++i) {
          std::cout << i << ": " << str << std::endl;
               boost::this_fiber::yield();
     }
}
	
int main() {
     try {
          boost::fibers::fiber f1( fn, "abc", 5);
          std::cerr << "f1 : " << f1.get_id() << std::endl;
          f1.join();
          std::cout << "done." << std::endl;
	
          return EXIT_SUCCESS;
     } catch ( std::exception const& e) {
          std::cerr << "exception: " << e.what() << std::endl;
     } catch (...) {
          std::cerr << "unhandled exception" << std::endl;
     }
     return EXIT_FAILURE;
}

Stapellose Coroutinen

• Corutin ist eng mit ihrem Anrufer verbunden: Wenn eine Coroutine aufgerufen wird, wird die Ausführung an sie übertragen und das Ergebnis der Coroutine wird zurück an den Anrufer übertragen.
• Die Lebensdauer eines Stapelkorutins entspricht der Lebensdauer seines Stapels. Die Lebensdauer einer stapellosen Coroutine entspricht der Lebensdauer ihres Objekts.

1. Ein regulärer Funktionsaufruf, dessen Frame auf dem Stapel gespeichert ist
2. Die Funktion erstellt eine Coroutine . Das heißt, es wird irgendwo auf dem Heap ein Aktivierungsrahmen dafür zugewiesen.
3. Normaler Funktionsaufruf.
4. Rufen Sie Corutin an . Corutins Körper sticht in einem regelmäßigen Stapel hervor. Das Programm wird wie bei einer regulären Funktion ausgeführt.
5. Ein regelmäßiger Funktionsaufruf von Coroutine. Auch hier passiert immer noch alles auf dem Stapel [Hinweis: Sie können die Coroutine von diesem Punkt aus nicht anhalten, da dies nicht die oberste Funktion in der Coroutine ist]
6. [: .]
7. – , , .
9. – , + .
10. 5.
11. 6.
12. . .

Praktische Anwendung von Corutin

• Generatoren
• asynchroner Eingabe- / Ausgabecode
• Lazy Computing
• ereignisgesteuerte Anwendungen

Zusammenfassung

• Warum müssen Sie in C ++ Coroutinen als dedizierte Sprachfunktion implementieren?
• Was ist der Unterschied zwischen gestapelten und stapellosen Coroutinen?
• warum Coroutinen benötigt werden