Coroutines Java

Les coroutines Java sont définies comme un ensemble d'instructions qui sont envoyées à l'ordinateur en le regroupant comme une unité pour généraliser une tâche spécifique à effectuer par un style de multitâche où il n'y a pas de passage d'un processus en cours d'exécution à l'autre. autre processus et l'exécute simultanément en tant que multitâche coopératif. Ces instructions sont exécutées en permettant leur suspension et leur reprise. Nous sommes assez familiers avec le genre de programmes écrits via des co-routines, des tâches coopératives, des boucles d'événements, des itérateurs, des tuyaux, etc. Cependant, on est généralement confus quant au concept de coroutines par rapport aux autres concepts tels que les sous-programmes, les threads, les générateurs. , récursion mutuelle.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe des coroutines Java

Vous trouverez ci-dessous la syntaxe mentionnée :

1. Saisie des dépendances dans POM.

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

2. Déclarer l'instance de classe de la coroutine.

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

3. Remplacer les implémentations sur une classe parent.

@Override

4. Déclarer des coroutines via com.offbynull.coroutines.

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

Comment fonctionnent les coroutines en Java ?

Avant de voir les coroutines en Java, examinons les différentes manières de les implémenter, car les différentes manières détermineront le fonctionnement des coroutines en Java pur. Il existe en fait certaines restrictions imposées par les abstractions de Java, mais l'implémentation n'empêche pas d'être implémentée.

Largement acceptées, il existe 4 méthodes qui s'occupent de l'implémentation des coroutines.

• Afin de prendre en charge les coroutines de manière native, il existe des JVM modifiées qui sont corrigées pour prendre en charge l'implémentation des coroutines. L'une de ces JVM modifiées est le projet Da Vinci Machine.
• En réécrivant le bytecode normal, on peut également implémenter la fonctionnalité coroutine. Ces routines sont prises en charge soit à la volée, soit au moment de la compilation. Il existe diverses implémentations présentes, à savoir. depuis offbynull, l'archive de code Google et/ou Apache commons.
• On peut également implémenter Java Native Interface via des mécanismes spécifiques à la plate-forme et implémentés dans les bibliothèques OS ou C et aider à fournir la fonctionnalité JVM.
• Dernier point mais non le moindre, les coroutines peuvent également être implémentées à l'aide de threads, bien que les performances dépendent énormément de l'implémentation des threads par la JVM.

Les coroutines sont des threads légers qui s'exécutent en partageant des threads existants au lieu d'avoir un thread système dédié pour eux-mêmes. Cette manière coopérative de fonctionner en partageant et en veillant à ce que le fil partagé ne soit pas occupé plus que nécessaire. ForkJoinTask dans Java 7 et CompletableFuture dans Java 8 fournissent une prise en charge explicite concernant l'exécution du thread partagé. Désormais, si les coroutines sont suspendues pour une durée indéterminée, aucune ressource de calcul n'est utilisée et ne peut reprendre l'exécution que lorsque les ressources attendues sont disponibles.

Notre première tâche est de déclarer les coroutines. Il manque un mécanisme natif pour déclarer tout objet incluant une suspension ; le seul moyen est de l'implémenter via une API. Elle peut être déclarée comme une instance de la classe coroutine, et esoco GmBH fournit la méthode Coroutine.first() afin d'invoquer une nouvelle instance de coroutine. Alternativement, on peut appeler l’instance du constructeur pour effectuer la même tâche. En utilisant Coroutine.then( ), les utilisateurs peuvent fournir des fonctionnalités supplémentaires en complément. Un autre trait majeur de la coroutine est qu’elle est immuable et que la séquence d’étapes telle que définie ne peut pas être modifiée.

À l'aide de CoroutineWriter et CoroutineReader, la coroutine peut être sérialisée ou désérialisée. La fonction de sérialisation intégrée de Java est utilisée par défaut et l'état de la coroutine est constitué à partir de cela. En dehors de cela, il existe des implémentations personnalisées pour contrôler davantage la sérialisation ou la désérialisation et transmises à CoroutineWriter et CoroutineReader pour l'ajout de différents formats de sérialisation comme XML, JSON ou différents sérialiseurs comme XStream, Kryo, Jackson etc.

La sérialisation est une fonctionnalité avancée et la familiarité avec le byte code JVM est fortement recommandée. Le concept de sérialisation permet la conversion de la coroutine en un tableau d'octets et inversement à partir d'un tableau d'octets.

Les cas d'utilisation typiques de la sérialisation sont :

• 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.

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!