Java-Coroutinen

Java-Coroutinen sind als eine Reihe von Anweisungen definiert, die an den Computer gesendet werden, indem sie als Einheit verpackt werden, um eine bestimmte Aufgabe zu verallgemeinern, die durch einen Multitasking-Stil ausgeführt werden soll, bei dem kein Wechsel von einem laufenden Prozess zu dem erfolgt anderen Prozess und führt ihn stattdessen gleichzeitig als kooperatives Multitasking aus. Die Ausführung dieser Anweisungen erfolgt dadurch, dass sie unterbrochen und wieder aufgenommen werden können. Wir sind mit dem Genre der Programme, die durch Co-Routinen, kooperative Aufgaben, Ereignisschleifen, Iteratoren, Pipes usw. geschrieben werden, ziemlich vertraut. Allerdings ist man normalerweise verwirrt über das Konzept von Coroutinen im Vergleich zu anderen Konzepten wie Unterroutinen, Threads, Generatoren , gegenseitige Rekursion.

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax von Java-Coroutinen

Nachstehend finden Sie die erwähnte Syntax:

1. Abhängigkeiten in POM eingeben.

<dependency>
<groupId> {package name goes here} </groupId>
<artifactId> {artifact ID goes here} </artifactId>
<version> {version number goes here} </version>
</dependency>

2. Deklarieren der Klasseninstanz der Coroutine.

public static final class < Class name goes here > implements Coroutine

3. Überschreiben Sie Implementierungen einer übergeordneten Klasse.

@Override

4. Deklarieren von Coroutinen über com.offbynull.coroutines.

CoroutineRunnerr = new CoroutineRunner(new <class name> ());

Wie funktionieren Coroutinen in Java?

Bevor wir uns mit den Coroutinen in Java befassen, schauen wir uns die verschiedenen Arten der Implementierung an, da die unterschiedlichen Methoden die Funktionsweise der Coroutinen in reinem Java bestimmen. Tatsächlich gibt es einige Einschränkungen, die durch die Java-Abstraktionen auferlegt werden, aber die Implementierung hört nicht auf, implementiert zu werden.

Weithin akzeptiert gibt es 4 Methoden, die sich um die Implementierung von Coroutinen kümmern.

• Um Coroutinen nativ zu unterstützen, gibt es modifizierte JVMs, die gepatcht werden, um die Implementierung von Coroutinen zu gewährleisten. Eine dieser modifizierten JVMs ist das Da Vinci Machine Project.
• Durch Umschreiben des regulären Bytecodes kann man auch Coroutine-Funktionalität implementieren. Diese Routinen werden entweder im laufenden Betrieb oder zur Kompilierungszeit erledigt. Es gibt verschiedene Implementierungen, nämlich. von offbynull, Google Code Archive und/oder Apache Commons.
• Man kann Java Native Interface auch über plattformspezifische Mechanismen implementieren und in den Betriebssystem- oder C-Bibliotheken implementieren und dabei helfen, die JVM-Funktionalität bereitzustellen.
• Last but not least können Coroutinen auch mithilfe von Threading implementiert werden, obwohl die Leistung stark von der Thread-Implementierung der JVM abhängt.

Die Coroutinen sind leichtgewichtige Threads, die durch die gemeinsame Nutzung vorhandener Threads ausgeführt werden, anstatt einen dedizierten Systemthread für sich selbst zu haben. Diese kooperative Art der Ausführung erfolgt durch gemeinsame Nutzung und stellt sicher, dass der gemeinsam genutzte Thread nicht mehr als nötig belegt ist. ForkJoinTask in Java 7 und CompletableFuture in Java 8 bieten explizite Unterstützung für die gemeinsame Thread-Ausführung. Wenn die Coroutinen nun auf unbestimmte Zeit ausgesetzt werden, werden keine Rechenressourcen beansprucht und die Ausführung kann erst dann wieder aufgenommen werden, wenn erwartete Ressourcen verfügbar sind.

Unsere erste Aufgabe besteht darin, Coroutinen zu deklarieren. Es fehlt ein nativer Mechanismus zum Deklarieren von Objekten, der eine Suspendierung beinhaltet. Der einzige Weg besteht darin, es über eine API zu implementieren. Es kann als Instanz der Klasse Coroutine deklariert werden und esoco GmBH stellt die Methode Coroutine.first( ) zur Verfügung, um eine neue Coroutine-Instanz aufzurufen. Alternativ kann man die Konstruktorinstanz aufrufen, um dieselbe Aufgabe auszuführen. Mithilfe von Coroutine.then( ) können Benutzer zusätzliche Funktionen zur Ergänzung bereitstellen. Ein weiteres wichtiges Merkmal der Coroutine ist, dass sie unveränderlich ist und die definierte Schrittfolge nicht geändert werden kann.

Mit CoroutineWriter und CoroutineReader kann die Coroutine serialisiert oder deserialisiert werden. Standardmäßig wird die in Java integrierte Serialisierungsfunktion verwendet, und der Status der Coroutine wird auf dieser Grundlage erstellt. Darüber hinaus gibt es benutzerdefinierte Implementierungen zur weiteren Steuerung der Serialisierung oder Deserialisierung, die an CoroutineWriter und CoroutineReader weitergeleitet werden, um verschiedene Serialisierungsformate wie XML, JSON oder verschiedene Serialisierungsformate wie XStream, Kryo, Jackson usw. hinzuzufügen.

Serialisierung ist eine erweiterte Funktion und die Kenntnis des JVM-Bytecodes wird dringend empfohlen. Das Konzept der Serialisierung ermöglicht die Konvertierung von Coroutine in ein Byte-Array und zurück von einem Byte-Array.

Die typischen Anwendungsfälle der Serialisierung sind:

• Using serialization, one can cache or checkpoint to a disk and write it back again.
• Over the wire coroutine transmission.
• Coroutine forking.

Another derivative of serialization is the versioning which enables developers to change the logic of coroutine along side still being able to load data using serialization from earlier versions.

Examples of Java Coroutines

Given below are the examples of Java Coroutines:

Example #1

A “Hello World” type example coroutines.

Syntax:

public static final class CoroutineDemo implements Coroutine {
@Override
public void run(Continuation c) {
System.out.println("Start of Main stream ");
for (int i = 0; i < 10; i++) {
echo(c, i);
}
}
private void echo(Continuation c, int x) {
System.out.println(x);
c.suspend();
}
}
CoroutineRunner runnerVar = new CoroutineRunner(new CoroutineDemo());
runnerVar.execute();
runnerVar.execute();
runnerVar.execute();
runnerVar.execute();

Output:

Example #2

Forking of an object.

Syntax:

public final class CoroutineDemo implements Coroutine {
@Override
public void run(Continuation c) {
System.out.println("Start of Main stream");
for (int i = 0; i < 10; i++) {
echo(c, i);
}
}
private void echo(Continuation c, int x) {
System.out.println(x);
c.suspend();
}
}
CoroutineRunner runner1 = new CoroutineRunner(new CoroutineDemo());
runner1.execute();
byte[] dumped = new CoroutineWriter().write(runner1);
CoroutineRunner runner2 = new CoroutineReader().read(dumped);
runner1.execute();
runner2.execute();
runner1.execute();
runner2.execute();
runner1.execute();
runner2.execute();

Output:

Conclusion

Through this article, we have looked at the working of Java coroutines. First, one needs to make sure that the POM and details of the maven build are properly instantiated and the build is done. With the different use case of a simple one and the forking, we are able to understand how 2 variables carry the information and if something gets updated in the root, the same thing is reflected back into the fork as well through serialization.

Das obige ist der detaillierte Inhalt vonJava-Coroutinen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!