C # async / await'in Java Eşdeğeri?

Normal bir C # geliştiricisiyim, ancak bazen Java'da uygulama geliştiriyorum. C # async / await'in Java eşdeğeri olup olmadığını merak ediyorum? Basit bir deyişle, java eşdeğeri nedir:

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

Hayır, Java'da veya hatta C # v5'ten önce async / await'in eşdeğeri yoktur.

Perde arkasında bir durum makinesi oluşturmak oldukça karmaşık bir dil özelliğidir.

Java'da eşzamansızlık / eşzamanlılık için nispeten az dil desteği vardır, ancak java.util.concurrentpaket bununla ilgili birçok yararlı sınıf içerir . (Görev Paralel Kitaplığı'na tam olarak eşdeğer değildir, ancak ona en yakın yaklaşımdır.)

, Zaman awaituyumsuz işlem tamamlandığında ( client.GetStringAsync(...)) ek kod yürütmek için bir devamlılık kullanır .

Bu nedenle, en yakın yaklaşım olarak , Http isteğini eşzamansız olarak işlemek için CompletableFuture<T>(Java 8 eşdeğeri .net Task<TResult>) tabanlı bir çözüm kullanırdım.

25-05-2016 tarihinde, Abril 13th 2016'da yayınlanan AsyncHttpClient v.2'ye GÜNCELLENMİŞTİR :

Dolayısıyla, OP örneğine eşdeğer Java 8 AccessTheWebAsync()aşağıdaki gibidir:

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

Bu kullanım, Async Http İstemci isteğinden Nasıl CompletableFuture alabilirim? Yanıtından alınmıştır. ve Abril 13th 2016'da yayımlanan AsyncHttpClient sürüm 2'de sağlanan yeni API'ye göre CompletableFuture<T>,.

AsyncHttpClient'in 1. sürümünü kullanan orijinal yanıt:

Bu amaçla iki olası yaklaşımımız var:

• ilki engellemeyen IO kullanıyor ve ben buna diyorum AccessTheWebAsyncNio. Yine de, AsyncCompletionHandlersoyut bir sınıf olduğu için (işlevsel bir arayüz yerine) argüman olarak bir lambda geçiremeyiz. Bu nedenle, anonim sınıfların sözdizimi nedeniyle kaçınılmaz ayrıntılara maruz kalır. Ancak bu çözüm, verilen C # örneğinin yürütme akışına en yakın olanıdır .

• ikincisi biraz daha az ayrıntılıdır, ancak sonuçta yanıt tamamlanana kadar bir iş parçacığını engelleyecek yeni bir Görev sunacaktır f.get().

İlk yaklaşım , daha ayrıntılı ama engellemeyen:

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;
}

İkinci yaklaşım daha az ayrıntılı ama bir iş parçacığını engelliyor:

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());
    }
}

Async / await'i oldukça güzel bir şekilde simüle etmek için Java bayt kodunu yeniden yazan ea-async'e göz atın . Beniokularına göre: "NET CLR'deki Async-Await'ten büyük ölçüde esinlenmiştir"

asenkron ve bekleme , sözdizimsel şekerlerdir. Eşzamansız ve beklemenin özü, durum makinesidir. Derleyici zaman uyumsuz / bekleme kodunuzu bir durum makinesine dönüştürecektir.

Aynı zamanda, async / await'in gerçek projelerde gerçekten uygulanabilir olması için, halihazırda yerinde çok sayıda Async I / O kütüphanesi işlevine ihtiyacımız var . C # için, çoğu orijinal senkronize G / Ç işlevinin alternatif bir Async sürümü vardır. Bu Async işlevlerine ihtiyaç duymamızın nedeni, çoğu durumda, kendi zaman uyumsuz / bekleme kodunuzun bazı kitaplık Async yöntemine indirgenmesidir.

C # 'daki Async sürüm kitaplığı işlevleri Java'daki AsynchronousChannel kavramına benzer. Örneğin, bir Future döndüren veya okuma işlemi tamamlandıktan sonra bir geri arama yürüten AsynchronousFileChannel.read var. Ama tam olarak aynı değil. Tüm C # Async işlevleri Görevleri döndürür (Geleceğe benzer, ancak Gelecekten daha güçlüdür).

Diyelim ki Java async / await'i destekliyor ve şöyle bir kod yazıyoruz:

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);
}

Sonra derleyicinin orijinal eşzamansız / bekleme kodunu aşağıdaki gibi bir şeye dönüştürebileceğini düşünürdüm:

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;
}

Ve işte AsyncHandler için uygulama:

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);
    }
}

Java'da dil düzeyinde C # async / await'in eşdeğeri yoktur. Lifler olarak bilinen bir kavram, diğer bir deyişle işbirlikli iplikler, yani hafif iplikler ilginç bir alternatif olabilir. Lifler için destek sağlayan Java kitaplıklarını bulabilirsiniz.

Fibers uygulayan Java kitaplıkları

• JetLang
• Kilim
• Quasar

Elyaflara güzel bir giriş için bu makaleyi (Quasar'dan) okuyabilirsiniz . İpliklerin ne olduğunu, liflerin JVM'de nasıl uygulanabileceğini kapsar ve Quasar'a özgü bazı kodlara sahiptir.

Belirtildiği gibi, doğrudan bir eşdeğer yoktur, ancak Java bayt kodu modifikasyonları ile çok yakın bir yaklaşım oluşturulabilir (hem asenkron / bekleme benzeri talimatlar hem de temelde devam eden uygulama uygulaması için).

Şu anda JavaFlow devam kitaplığının üstüne async / await uygulayan bir proje üzerinde çalışıyorum , lütfen https://github.com/vsilaev/java-async-await adresini kontrol edin

Henüz Maven mojo oluşturulmadı, ancak sağlanan Java aracısıyla örnekler çalıştırabilirsiniz. Eşzamansız / bekleme kodu şu şekilde görünür:

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, bir yöntemi eşzamansız olarak yürütülebilir olarak işaretleyen ek açıklamadır, await (), devamları kullanarak CompletableFuture üzerinde bekleyen bir işlevdir ve ilişkili CompletableFuture / Continuation'u sonlandıran "asyncResult (someValue) döndür" çağrısıdır.

C # ile olduğu gibi, kontrol akışı korunur ve istisna işleme düzenli bir şekilde yapılabilir (sıralı olarak yürütülen koddaki gibi dene / yakala)

Java'nın kendisinin eşdeğer özellikleri yoktur, ancak Kilim gibi benzer işlevler sunan üçüncü taraf kitaplıkları mevcuttur .

İlk olarak, zaman uyumsuz / beklemenin ne olduğunu anlayın. Tek iş parçacıklı bir GUI uygulamasının veya verimli bir sunucunun tek bir iş parçacığı üzerinde birden çok "lif" veya "ortak yordam" veya "hafif iş parçacığı" çalıştırmasının bir yoludur.

Sıradan iş parçacıkları kullanmakta sorun yoksa, Java eşdeğeri ExecutorService.submitve Future.get. Bu, görev tamamlanana kadar engellenecek ve sonucu döndürecektir. Bu arada, diğer konular işe yarayabilir.

Lifler gibi bir şeyden yararlanmak istiyorsanız, kapsayıcıda (GUI olay döngüsünde veya sunucu HTTP istek işleyicisinde) veya kendi yazınızı yazarak desteğe ihtiyacınız var.

Örneğin, Servlet 3.0 eşzamansız işlem sunar. JavaFX sunar javafx.concurrent.Task. Yine de bunlar dil özelliklerinin zarafetine sahip değil. Sıradan geri aramalarla çalışırlar.

Async / await anahtar kelimeler gibi bunu yapmanıza izin veren java'ya özgü bir şey yoktur, ancak gerçekten istiyorsanız yapabileceğiniz şey bir CountDownLatch kullanmaktır . Daha sonra bunu geçerek async / await'i taklit edebilirsiniz (en azından Java7'de). Bu, zaman uyumsuz bir çağrı yapmamız gereken (genellikle bir işleyici tarafından gönderilen bir çalıştırılabilir) ve ardından sonucu beklediğimiz (geri sayım) Android birim testinde yaygın bir uygulamadır.

Ancak bunu testinizin aksine uygulamanızın içinde kullanmak benim önerdiğim şey DEĞİLDİR . CountDownLatch, doğru sayıda ve doğru yerlerde etkili bir şekilde geri saymanıza bağlı olduğundan, bu son derece kalitesiz olurdu.

Java async / await kitaplığını oluşturdum ve yayınladım. https://github.com/stofu1234/kamaitachi

Bu kitaplık derleyici uzantısına ihtiyaç duymaz ve Java'da yığınsız GÇ işlemeyi gerçekleştirir.

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

　　　↓

    //LikeWebApplicationTester.java
    BlockingQueue<Integer> AccessTheWebAsync() {
       HttpClient client = new HttpClient();
       return awaiter.await(
            () -> client.GetStringAsync("http://msdn.microsoft.com"),
            urlContents -> {
                return urlContents.length();
            });
    }
    public void doget(){
        BlockingQueue<Integer> lengthQueue=AccessTheWebAsync();
        awaiter.awaitVoid(()->lengthQueue.take(),
            length->{
                System.out.println("Length:"+length);
            }
            );
    }

Java maalesef async / await'in eşdeğeri yoktur. Elde edebileceğiniz en yakın şey, muhtemelen Guava'dan ListenableFuture ve dinleyici zincirleme ile olabilir, ancak iç içe geçme düzeyi çok hızlı bir şekilde artacağından, birden çok eşzamansız çağrı içeren durumlar için yazmak yine de çok zahmetli olacaktır.

JVM'nin üstünde farklı bir dil kullanmakta sorun yoksa, neyse ki Scala'da neredeyse aynı sözdizimi ve anlambilim ile doğrudan C # async / await eşdeğeri olan async / await vardır: https://github.com/scala/ eşzamansız /

Bu işlevselliğin C # 'da oldukça gelişmiş bir derleyici desteğine ihtiyaç duymasına rağmen, Scala'daki çok güçlü bir makro sistemi sayesinde bir kütüphane olarak eklenebileceğini ve bu nedenle Scala'nın 2.10 gibi eski sürümlerine bile eklenebileceğini unutmayın. Ek olarak Scala, Java ile sınıf uyumludur, böylece zaman uyumsuz kodu Scala'da yazabilir ve ardından Java'dan çağırabilirsiniz.

Akka Dataflow http://doc.akka.io/docs/akka/2.3-M1/scala/dataflow.html adında , farklı ifadeler kullanan ancak kavramsal olarak çok benzer olan, ancak makrolar yerine sınırlandırılmış devamlar kullanılarak uygulanan benzer bir proje daha var. (bu nedenle 2.9 gibi daha eski Scala sürümleriyle çalışır).

Java, async / await adlı C # dil özelliğinin doğrudan eşdeğerine sahip değildir, ancak async / await'in çözmeye çalıştığı soruna farklı bir yaklaşım vardır. Yüksek verimli eşzamanlılık için sanal iş parçacıkları sağlayacak olan proje Tezgahı olarak adlandırılır . OpenJDK'nin gelecekteki bazı sürümlerinde mevcut olacaktır.

Bu yaklaşım aynı zamanda async / await'in sahip olduğu " renkli fonksiyon problemini " de çözer .

Golang'da da ( gorutinler ) benzer özellik bulunabilir .

Java'da async / await ile aynı etkiyi simüle eden temiz kodun hemen peşindeyseniz ve bir testte olduğu gibi, bitene kadar çağrılan iş parçacığını engellemekten çekinmiyorsanız, şu kod gibi bir şey kullanabilirsiniz:

interface Async {
    void run(Runnable handler);
}

static void await(Async async) throws InterruptedException {

    final CountDownLatch countDownLatch = new CountDownLatch(1);
    async.run(new Runnable() {

        @Override
        public void run() {
            countDownLatch.countDown();
        }
    });
    countDownLatch.await(YOUR_TIMEOUT_VALUE_IN_SECONDS, TimeUnit.SECONDS);
}

    await(new Async() {
        @Override
        public void run(final Runnable handler) {
            yourAsyncMethod(new CompletionHandler() {

                @Override
                public void completion() {
                    handler.run();
                }
            });
        }
    });

AsynHelper Java kitaplığı, eşzamansız çağrılar (ve bekleme) için bir dizi yardımcı sınıf / yöntem içerir.

Bir dizi yöntem çağrısı veya kod bloğunu eşzamansız olarak çalıştırmak istenirse , aşağıdaki kod parçacığında olduğu gibi AsyncTask .submitTasks yararlı bir yardımcı yöntem içerir .

AsyncTask.submitTasks(
    () -> getMethodParam1(arg1, arg2),
    () -> getMethodParam2(arg2, arg3)
    () -> getMethodParam3(arg3, arg4),
    () -> {
             //Some other code to run asynchronously
          }
    );

Tüm eşzamansız kodların çalışması tamamlanana kadar beklemek istenirse, AsyncTask.submitTasksAndWait değişkeni kullanılabilir.

Ayrıca, zaman uyumsuz yöntem çağrısı veya kod bloğunun her birinden bir dönüş değeri elde etmek istenirse, AsyncSupplier .submitSuppliers , sonucun daha sonra yöntem tarafından döndürülen sonuç sağlayıcı dizisinden elde edilebilmesi için kullanılabilir. Örnek pasajı aşağıdadır:

Supplier<Object>[] resultSuppliers = 
   AsyncSupplier.submitSuppliers(
     () -> getMethodParam1(arg1, arg2),
     () -> getMethodParam2(arg3, arg4),
     () -> getMethodParam3(arg5, arg6)
   );

Object a = resultSuppliers[0].get();
Object b = resultSuppliers[1].get();
Object c = resultSuppliers[2].get();

myBigMethod(a,b,c);

Her yöntemin dönüş türü farklıysa, aşağıdaki parçacığı kullanın.

Supplier<String> aResultSupplier = AsyncSupplier.submitSupplier(() -> getMethodParam1(arg1, arg2));
Supplier<Integer> bResultSupplier = AsyncSupplier.submitSupplier(() -> getMethodParam2(arg3, arg4));
Supplier<Object> cResultSupplier = AsyncSupplier.submitSupplier(() -> getMethodParam3(arg5, arg6));

myBigMethod(aResultSupplier.get(), bResultSupplier.get(), cResultSupplier.get());

Eşzamansız yöntem çağrılarının / kod bloklarının sonucu, aynı iş parçacığındaki farklı bir kod noktasında veya aşağıdaki kod parçacığındaki gibi farklı bir iş parçacığında da elde edilebilir.

AsyncSupplier.submitSupplierForSingleAccess(() -> getMethodParam1(arg1, arg2), "a");
AsyncSupplier.submitSupplierForSingleAccess(() -> getMethodParam2(arg3, arg4), "b");
AsyncSupplier.submitSupplierForSingleAccess(() -> getMethodParam3(arg5, arg6), "c");


//Following can be in the same thread or a different thread
Optional<String> aResult = AsyncSupplier.waitAndGetFromSupplier(String.class, "a");
Optional<Integer> bResult = AsyncSupplier.waitAndGetFromSupplier(Integer.class, "b");
Optional<Object> cResult = AsyncSupplier.waitAndGetFromSupplier(Object.class, "c");

 myBigMethod(aResult.get(),bResult.get(),cResult.get());