ea async

EA Async

EA Async implementiert Async-Await-Methoden in der JVM. Es ermöglicht Programmierern, asynchronen Code sequentiell zu schreiben.

Es ist stark von Async-Await auf der .NET CLR inspiriert. Weitere Informationen finden Sie unter Asynchrone Programmierung mit Async und Await.

Wer sollte es nutzen?

EA Async sollte verwendet werden, um nicht blockierenden asynchronen Code zu schreiben, der CompletableFutures oder CompletionStage stark nutzt. Es verbessert die Skalierbarkeit, indem es Arbeitsthreads freigibt, während Ihr Code auf andere Prozesse wartet. Und verbessert die Produktivität, indem asynchroner Code einfacher und lesbarer wird.

Entwickler & Lizenz

Dieses Projekt wurde von Electronic Arts entwickelt und ist unter der BSD 3-Clause-Lizenz lizenziert.

Beispiele

Mit EA Async

 import static com . ea . async . Async . await ;
import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        if (! await ( bank . decrement ( cost ))) {
            return completedFuture ( false );
        }
        await ( inventory . giveItem ( itemTypeId ));
        return completedFuture ( true );
    }
}

In diesem Beispiel gibt Bank.decrement CompletableFuture<Boolean> zurück und Inventory.giveItem gibt CompletableFuture<String> zurück

EA Async schreibt die Aufrufe von Async.await neu, sodass Ihre Methoden nicht blockieren.

Die Methoden wirken blockierend, werden aber tatsächlich in asynchrone Methoden umgewandelt, die CompletableFutures verwenden, um die Ausführung fortzusetzen, sobald Zwischenergebnisse eintreffen.

Ohne EA Async

So sieht das erste Beispiel ohne EA Async aus. Es ist etwas weniger lesbar.

 import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        return bank . decrement ( cost )
            . thenCompose ( result -> {
                if (! result ) {
                    return completedFuture ( false );
                }
                return inventory . giveItem ( itemTypeId ). thenApply ( res -> true );
            });
    }
}

Dies ist ein kleines Beispiel ... Eine Methode mit ein paar weiteren CompletableFutures kann sehr kompliziert aussehen.

EA Async abstrahiert die Komplexität der CompletableFutures.

Mit EA Async (2)

Dir gefällt CompletableFutures? Versuchen Sie, diese Methode so umzuwandeln, dass sie nur CompletableFutures verwendet, ohne jemals zu blockieren (also keine Verknüpfung):

 import static com . ea . async . Async . await ;
import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        if (! await ( bank . decrement ( cost ))) {
            return completedFuture ( false );
        }
        try {
            await ( inventory . giveItem ( itemTypeId ));
            return completedFuture ( true );
        } catch ( Exception ex ) {
            await ( bank . refund ( cost ));
            throw new AppException ( ex );
        }
    }
}

Habe es? Schicken Sie es uns. Es sieht wahrscheinlich hässlich aus...

Erste Schritte

EA Async unterstützt derzeit JDK 8-10.

Es funktioniert mit Java und Scala und sollte mit den meisten JVM-Sprachen funktionieren. Die einzige Voraussetzung für die Verwendung von EA Async besteht darin, dass es nur innerhalb von Methoden verwendet werden darf, die CompletableFuture , CompletionStage oder Unterklassen von CompletableFuture zurückgeben.

Verwendung mit Maven

< dependency >
    < groupId >com.ea.async</ groupId >
    < artifactId >ea-async</ artifactId >
    < version >1.2.3</ version >
</ dependency >

Gradle

 'com.ea.async:ea-async:1.2.3'

Instrumentierung Ihres Codes

Option 1 – JVM-Parameter

Starten Sie Ihre Anwendung mit einem zusätzlichen JVM-Parameter: -javaagent:ea-async-1.2.3.jar

 java -javaagent:ea-async-1.2.3.jar -cp your_claspath YourMainClass args...

Es wird empfohlen, dies als Standardoption zu Startern in IntelliJ-Projekten hinzuzufügen, die ea-async verwenden.

Option 2 – Laufzeit

Rufen Sie während Ihrer Hauptveranstaltung oder so früh wie möglich mindestens einmal an:

 Async.init();

Vorausgesetzt, dass Ihre JVM die Funktion aktiviert hat, wird dadurch ein Laufzeitinstrumentierungsagent gestartet. Wenn Sie vergessen, diese Funktion aufzurufen, initialisiert der erste await vonwait das System (und gibt eine Warnung aus).

Dies ist eine Lösung zum Testen und Entwickeln, sie erfordert den geringsten Konfigurationsaufwand. Es könnte das JVM-Debugging beeinträchtigen. Diese Alternative ist als Fallback vorhanden.

Option 3 – Instrumentierungstool ausführen

Die Datei ea-async-1.2.3.jar ist eine ausführbare JAR-Datei, mit der Sie Ihre Dateien vorab instrumentieren können.

Verwendung:

java -cp YOUR_PROJECT_CLASSPATH -jar ea-async-1.2.3.jar classDirectory

Beispiel:

java -cp guava.jar ; commons-lang.jar  -jar ea-async-1.2.3.jar target/classes

Danach sind alle Dateien in target/classes instrumentiert. In diesen Klassen sind keine Verweise auf Async.await und Async.init mehr vorhanden.

Option 4 – Build-Time-Instrumentierung mit Maven – bevorzugt

Verwenden Sie das ea-async-maven-plugin. Es instrumentiert Ihre Klassen in der Kompilierungszeit und entfernt alle Verweise auf Async.await und Async.init() .

Mit der Build-Time-Instrumentierung müssen Ihre Projektbenutzer EA Async nicht in ihrem Klassenpfad haben, es sei denn, sie entscheiden sich auch dafür, es zu verwenden. Das bedeutet, dass EA Async keine transitive Abhängigkeit sein muss .

Dies ist die beste Option für Bibliotheken und Maven-Projekte.

< build >
    < plugins >
        < plugin >
            < groupId >com.ea.async</ groupId >
            < artifactId >ea-async-maven-plugin</ artifactId >
            < version >1.2.3</ version >
            < executions >
                < execution >
                    < goals >
                        < goal >instrument</ goal >
                        < goal >instrument-test</ goal >
                    </ goals >
                </ execution >
            </ executions >
        </ plugin >
    </ plugins >
</ build >