Java-Äquivalent von C# async/await?

Ich bin ein normaler C#-Entwickler, aber gelegentlich entwickle ich Anwendungen in Java. Ich frage mich, ob es ein Java-Äquivalent zu C# async/await gibt? In einfachen Worten, was ist das Java-Äquivalent von:

async Task<int> AccessTheWebAsync()
{ 
    HttpClient client = new HttpClient();
    var urlContents = await client.GetStringAsync("http://msdn.microsoft.com");
    return urlContents.Length;
}

Nein, es gibt kein Äquivalent zu async/await in Java – oder sogar in C# vor v5.

Es ist ein ziemlich komplexes Sprachfeature, um hinter den Kulissen eine Zustandsmaschine zu erstellen.

Es gibt relativ wenig Sprache Unterstützung für Asynchronität/Parallelität in Java, aber die java.util.concurrent Paket enthält viele nützliche Klassen um diese herum. (Nicht ganz gleichwertig mit der Task Parallel Library, aber die nächste Annäherung daran.)

Das await verwendet eine Fortsetzung, um zusätzlichen Code auszuführen, wenn der asynchrone Vorgang abgeschlossen ist (client.GetStringAsync(...)).

Als beste Annäherung würde ich also a verwenden CompletableFuture<T> (das Java 8-Äquivalent zu .net Task<TResult>)-basierte Lösung, um die Http-Anfrage asynchron zu verarbeiten.

AKTUALISIERT am 25.05.2016 zu AsyncHttpClient v.2 veröffentlicht am 13. April 2016:

Also das Java 8-Äquivalent zum OP-Beispiel von AccessTheWebAsync() ist das Folgende:

CompletableFuture<Integer> AccessTheWebAsync()
{
    AsyncHttpClient asyncHttpClient = new DefaultAsyncHttpClient();
    return asyncHttpClient
       .prepareGet("http://msdn.microsoft.com")
       .execute()
       .toCompletableFuture()
       .thenApply(Response::getResponseBody)
       .thenApply(String::length);
}

Diese Verwendung wurde aus der Antwort auf How do I get a CompletableFuture from a Async Http Client request entnommen? und die gemäß der neuen API in Version 2 von bereitgestellt wird AsyncHttpClient veröffentlicht am 13. April 2016, das bereits intrinsische Unterstützung für hat CompletableFuture<T>.

Ursprüngliche Antwort mit Version 1 von AsyncHttpClient:

Dazu haben wir zwei mögliche Vorgehensweisen:

• Der erste verwendet nicht blockierendes IO und ich nenne es AccessTheWebAsyncNio. Doch weil die AsyncCompletionHandler eine abstrakte Klasse ist (statt einer funktionalen Schnittstelle), können wir kein Lambda als Argument übergeben. Daher kommt es aufgrund der Syntax anonymer Klassen zu einer unvermeidlichen Ausführlichkeit. Jedoch, Diese Lösung kommt dem Ausführungsablauf des angegebenen C#-Beispiels am nächsten.

• Die zweite ist etwas weniger ausführlich, wird jedoch eine neue einreichen Aufgabe das wird letztendlich einen Thread blockieren f.get() bis die Antwort vollständig ist.

Erste Ansatzausführlicher, aber nicht blockierend:

static CompletableFuture<Integer> AccessTheWebAsyncNio(){
    final AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    final CompletableFuture<Integer> promise = new CompletableFuture<>();
    asyncHttpClient
        .prepareGet("https://msdn.microsoft.com")
        .execute(new AsyncCompletionHandler<Response>(){
            @Override
            public Response onCompleted(Response resp) throws Exception {
                promise.complete(resp.getResponseBody().length());
                return resp;
            }
        });
    return promise;
}

Zweiter Ansatz weniger ausführlich, aber blockiert einen Thread:

static CompletableFuture<Integer> AccessTheWebAsync(){
    try(AsyncHttpClient asyncHttpClient = new AsyncHttpClient()){
        Future<Response> f = asyncHttpClient
            .prepareGet("https://msdn.microsoft.com")
            .execute();
        return CompletableFuture.supplyAsync(
            () -> return f.join().getResponseBody().length());
    }
}

Kasse ea-async was Java-Bytecode umschreibt, um async/await ziemlich gut zu simulieren. Laut ihrer Readme: “Es ist stark von Async-Await auf der .NET CLR inspiriert”

asynchron und erwarten sind syntaktische Zucker. Die Essenz von async und await ist eine Zustandsmaschine. Der Compiler wandelt Ihren async/await-Code in einen Zustandsautomaten um.

Damit async/await in realen Projekten wirklich praktikabel ist, müssen wir gleichzeitig viele haben Asynchrone E/A-Bibliotheksfunktionen Bereits vorhanden. Für C# haben die meisten ursprünglichen synchronisierten I/O-Funktionen eine alternative Async-Version. Der Grund, warum wir diese Async-Funktionen benötigen, liegt darin, dass Ihr eigener Async/Await-Code in den meisten Fällen auf eine Async-Methode der Bibliothek hinausläuft.

Die Bibliotheksfunktionen der Async-Version in C# ähneln dem AsynchronousChannel-Konzept in Java. Zum Beispiel haben wir AsynchronousFileChannel.read, das entweder ein Future zurückgeben oder einen Rückruf ausführen kann, nachdem der Lesevorgang abgeschlossen ist. Aber es ist nicht genau dasselbe. Alle asynchronen C#-Funktionen geben Tasks zurück (ähnlich wie Future, aber leistungsfähiger als Future).

Nehmen wir also an, Java unterstützt async/await, und wir schreiben Code wie diesen:

public static async Future<Byte> readFirstByteAsync(String filePath) {
    Path path = Paths.get(filePath);
    AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);

    ByteBuffer buffer = ByteBuffer.allocate(100_000);
    await channel.read(buffer, 0, buffer, this);
    return buffer.get(0);
}

Dann würde ich mir vorstellen, dass der Compiler den ursprünglichen async/await-Code in so etwas umwandelt:

public static Future<Byte> readFirstByteAsync(String filePath) {

    CompletableFuture<Byte> result = new CompletableFuture<Byte>();

    AsyncHandler ah = new AsyncHandler(result, filePath);

    ah.completed(null, null);

    return result;
}

Und hier ist die Implementierung für AsyncHandler:

class AsyncHandler implements CompletionHandler<Integer, ByteBuffer>
{
    CompletableFuture<Byte> future;
    int state;
    String filePath;

    public AsyncHandler(CompletableFuture<Byte> future, String filePath)
    {
        this.future = future;
        this.state = 0;
        this.filePath = filePath;
    }

    @Override
    public void completed(Integer arg0, ByteBuffer arg1) {
        try {
            if (state == 0) {
                state = 1;
                Path path = Paths.get(filePath);
                AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);

                ByteBuffer buffer = ByteBuffer.allocate(100_000);
                channel.read(buffer, 0, buffer, this);
                return;
            } else {
                Byte ret = arg1.get(0);
                future.complete(ret);
            }

        } catch (Exception e) {
            future.completeExceptionally(e);
        }
    }

    @Override
    public void failed(Throwable arg0, ByteBuffer arg1) {
        future.completeExceptionally(arg0);
    }
}

Auf Sprachebene gibt es in Java kein Äquivalent zu C# async/await. Ein Konzept, bekannt als Fasern auch bekannt kooperative Fäden auch bekannt leichte Fäden könnte eine interessante Alternative sein. Sie finden Java-Bibliotheken, die Glasfasern unterstützen.

Java-Bibliotheken, die Fibers implementieren

• JetLang
• Kelim
• Quasar

Du kannst lesen dieser Artikel (von Quasar) für eine schöne Einführung in Fasern. Es behandelt, was Threads sind, wie Fibers auf der JVM implementiert werden können und enthält einen Quasar-spezifischen Code.

Wie bereits erwähnt, gibt es kein direktes Äquivalent, aber eine sehr gute Annäherung könnte mit Java-Bytecode-Modifikationen erstellt werden (sowohl für async/await-ähnliche Anweisungen als auch für die zugrunde liegende Fortsetzungsimplementierung).

Ich arbeite gerade an einem Projekt, das async/await zusätzlich implementiert JavaFlow-Fortsetzung Bibliothek, bitte prüfen https://github.com/vsilaev/java-async-await

Es wurde noch kein Maven-Mojo erstellt, aber Sie können Beispiele mit dem mitgelieferten Java-Agenten ausführen. So sieht async/await-Code aus:

public class AsyncAwaitNioFileChannelDemo {

public static void main(final String[] argv) throws Exception {

    ...
    final AsyncAwaitNioFileChannelDemo demo = new AsyncAwaitNioFileChannelDemo();
    final CompletionStage<String> result = demo.processFile("./.project");
    System.out.println("Returned to caller " + LocalTime.now());
    ...
}


public @async CompletionStage<String> processFile(final String fileName) throws IOException {
    final Path path = Paths.get(new File(fileName).toURI());
    try (
            final AsyncFileChannel file = new AsyncFileChannel(
                path, Collections.singleton(StandardOpenOption.READ), null
            );              
            final FileLock lock = await(file.lockAll(true))
        ) {

        System.out.println("In process, shared lock: " + lock);
        final ByteBuffer buffer = ByteBuffer.allocateDirect((int)file.size());

        await( file.read(buffer, 0L) );
        System.out.println("In process, bytes read: " + buffer);
        buffer.rewind();

        final String result = processBytes(buffer);

        return asyncResult(result);

    } catch (final IOException ex) {
        ex.printStackTrace(System.out);
        throw ex;
    }
}

@async ist die Anmerkung, die eine Methode als asynchron ausführbar kennzeichnet, await() ist eine Funktion, die mit Fortsetzungen auf CompletableFuture wartet, und ein Aufruf von „return asyncResult(someValue)“ beendet die zugehörige CompletableFuture/Continuation

Wie bei C# bleibt die Ablaufsteuerung erhalten und die Ausnahmebehandlung kann auf reguläre Weise erfolgen (try/catch wie in sequentiell ausgeführtem Code).

Java selbst hat keine gleichwertigen Funktionen, aber es gibt Bibliotheken von Drittanbietern, die ähnliche Funktionen bieten, zKelim.