Java Equivalent of C # async / tunggu?

Saya adalah pengembang C # yang normal tetapi kadang-kadang saya mengembangkan aplikasi di Java. Saya ingin tahu apakah ada Java yang setara dengan C # async / tunggu? Dengan kata sederhana apa yang setara dengan java:

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

Tidak, tidak ada yang setara dengan async / menunggu di Jawa - atau bahkan dalam C # sebelum v5.

Ini adalah fitur bahasa yang cukup kompleks untuk membangun mesin negara di belakang layar.

Ada dukungan bahasa yang relatif sedikit untuk asynchrony / concurrency di Java, tetapi java.util.concurrentpaket berisi banyak kelas yang berguna di sekitar ini. (Tidak cukup setara dengan Perpustakaan Tugas Paralel, tetapi perkiraan terdekat untuk itu.)

The awaitmenggunakan kelanjutan untuk mengeksekusi kode tambahan ketika asynchronous operasi selesai (client.GetStringAsync(...) ).

Jadi, sebagai perkiraan paling dekat saya akan menggunakan CompletableFuture<T>(Java 8 setara dengan .netTask<TResult> ) solusi untuk memproses permintaan Http secara tidak sinkron.

DIPERBARUI pada 25-05-2016 hingga AsyncHttpClient v.2 dirilis pada Abril ke-13 2016:

Jadi Java 8 setara dengan contoh OP AccessTheWebAsync()adalah sebagai berikut:

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

Penggunaan ini diambil dari jawaban Bagaimana cara saya mendapatkan CompletableFuture dari permintaan Klien Async Http? dan yang sesuai dengan API baru yang disediakan dalam versi 2 dari AsyncHttpClient dirilis pada 13 Abril 2016, yang sudah mendukung intrinsik untuk CompletableFuture<T>.

Jawaban asli menggunakan AsyncHttpClient versi 1:

Untuk itu kami memiliki dua pendekatan yang mungkin:

• yang pertama menggunakan non-blocking IO dan saya menyebutnya AccessTheWebAsyncNio. Namun, karena AsyncCompletionHandlerini adalah kelas abstrak (bukan antarmuka fungsional) kita tidak dapat melewatkan lambda sebagai argumen. Jadi itu menimbulkan verbositas yang tak terhindarkan karena sintaksis dari kelas anonim. Namun, solusi ini adalah yang paling dekat dengan aliran eksekusi dari contoh C # yang diberikan .

• yang kedua sedikit kurang verbose namun akan mengirimkan Tugas baru yang pada akhirnya akan memblokir utas f.get()sampai tanggapan selesai.

Pendekatan pertama , lebih banyak bertele-tele tetapi tidak menghalangi:

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

Pendekatan kedua lebih sedikit bertele-tele tetapi memblokir utas:

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

Lihatlah ea-async yang melakukan penulisan ulang bytecode Java untuk mensimulasikan async / menunggu dengan cukup baik. Per readme mereka: "Ini sangat terinspirasi oleh Async-Tunggu di .NET CLR"

async dan menunggu adalah gula sintaksis. Inti dari async dan menunggu adalah mesin negara. Kompiler akan mengubah kode async / wait Anda menjadi mesin status.

Pada saat yang sama, agar async / menunggu benar-benar dapat dipraktikkan dalam proyek nyata, kita perlu memiliki banyak fungsi perpustakaan I / O Async yang sudah ada. Untuk C #, sebagian besar fungsi I / O yang disinkronkan asli memiliki versi Async alternatif. Alasan kami membutuhkan fungsi-fungsi Async ini adalah karena dalam kebanyakan kasus, kode async / await Anda sendiri akan bermuara pada beberapa metode Async library.

Fungsi pustaka versi Async dalam C # adalah jenis seperti konsep AsynchronousChannel di Jawa. Misalnya, kami memiliki AsynchronousFileChannel.read yang dapat mengembalikan Masa Depan atau menjalankan panggilan balik setelah operasi baca selesai. Tetapi tidak persis sama. Semua fungsi C # Async mengembalikan Tugas (mirip dengan Masa Depan tetapi lebih kuat dari Masa Depan).

Jadi misalkan Java mendukung async / menunggu, dan kami menulis beberapa kode seperti ini:

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

Maka saya akan membayangkan kompiler akan mengubah kode async / wait asli menjadi sesuatu seperti ini:

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

Dan di sini adalah implementasi untuk 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);
    }
}

Tidak ada yang setara dengan C # async / menunggu di Jawa pada tingkat bahasa. Suatu konsep yang dikenal dengan Fibers aka threads koperasi alias benang ringan bisa menjadi alternatif yang menarik. Anda dapat menemukan perpustakaan Java yang menyediakan dukungan untuk serat.

Perpustakaan Java mengimplementasikan Serat

• JetLang
• Kilim
• Quasar

Anda dapat membaca artikel ini (dari Quasar) untuk pengantar serat yang bagus. Ini mencakup apa utasnya, bagaimana serat dapat diimplementasikan pada JVM dan memiliki beberapa kode khusus Quasar.

Seperti yang telah disebutkan, tidak ada padanan langsung, tetapi perkiraan yang sangat dekat dapat dibuat dengan modifikasi bytecode Java (untuk instruksi async / await-like dan implementasi lanjutan yang mendasarinya).

Saya sedang bekerja sekarang pada proyek yang mengimplementasikan async / menunggu di atas perpustakaan kelanjutan JavaFlow , silakan periksa https://github.com/vsilaev/java-async-await

Belum ada Maven mojo yang dibuat, tetapi Anda dapat menjalankan contoh dengan agen Java yang disediakan. Berikut ini adalah bagaimana kode async / menunggu:

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 adalah anotasi yang menandai metode sebagai asinkron yang dapat dieksekusi, menanti () adalah fungsi yang menunggu di CompletableFuture menggunakan kelanjutan dan panggilan untuk "mengembalikan asyncResult (someValue)" adalah apa yang menyelesaikan CompletableFuture / Continuation terkait

Seperti halnya C #, aliran kontrol dipertahankan dan penanganan pengecualian dapat dilakukan secara teratur (coba / tangkap seperti dalam kode yang dieksekusi berurutan)

Java sendiri tidak memiliki fitur yang setara, tetapi ada perpustakaan pihak ketiga yang menawarkan fungsionalitas serupa, misalnya Kilim .

Pertama, pahami apa itu async / tunggu. Ini adalah cara untuk aplikasi GUI berulir tunggal atau server yang efisien untuk menjalankan beberapa "serat" atau "co-rutin" atau "utas ringan" pada satu utas.

Jika Anda baik-baik saja dengan menggunakan utas biasa, maka padanan Java adalah ExecutorService.submitdan Future.get. Ini akan memblokir sampai tugas selesai, dan mengembalikan hasilnya. Sementara itu, utas lain dapat berfungsi.

Jika Anda menginginkan manfaat dari sesuatu seperti serat, Anda memerlukan dukungan dalam wadah (maksud saya di loop acara GUI atau di server HTTP request handler), atau dengan menulis sendiri.

Sebagai contoh, Servlet 3.0 menawarkan pemrosesan yang tidak sinkron. Penawaran JavaFX javafx.concurrent.Task. Ini tidak memiliki keanggunan fitur bahasa. Mereka bekerja melalui panggilan balik biasa.

Tidak ada yang asli untuk java yang memungkinkan Anda melakukan ini seperti kata kunci async / menunggu, tetapi apa yang dapat Anda lakukan jika Anda benar-benar ingin menggunakan CountDownLatch . Anda kemudian dapat meniru async / menunggu dengan melewati ini (setidaknya di Java7). Ini adalah praktik umum dalam pengujian unit Android di mana kita harus melakukan panggilan async (biasanya runnable yang diposting oleh handler), dan kemudian menunggu hasilnya (hitung mundur).

Namun menggunakan ini di dalam aplikasi Anda sebagai lawan dari tes Anda BUKAN apa yang saya rekomendasikan. Itu akan sangat buruk karena CountDownLatch tergantung pada Anda secara efektif menghitung jumlah waktu yang tepat dan di tempat yang tepat.

Saya membuat dan merilis perpustakaan Java async / wait. https://github.com/stofu1234/kamaitachi

Pustaka ini tidak memerlukan ekstensi kompiler, dan mewujudkan pemrosesan IO stackless di Jawa.

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

Sayangnya, Java tidak memiliki padanan dengan async / menunggu. Kemungkinan terdekat yang bisa Anda dapatkan adalah dengan ListenableFuture dari Guava dan pendengaran pendengar, tetapi masih sangat sulit untuk menulis untuk kasus yang melibatkan beberapa panggilan tidak sinkron, karena tingkat bersarang akan tumbuh dengan cepat.

Jika Anda setuju menggunakan bahasa lain di atas JVM, untungnya ada async / menunggu di Scala yang merupakan C # async / tunggu langsung yang setara dengan sintaks dan semantik yang hampir identik: https://github.com/scala/ async /

Perhatikan bahwa meskipun fungsi ini membutuhkan dukungan kompiler yang cukup canggih di C #, di Scala dapat ditambahkan sebagai pustaka berkat sistem makro yang sangat kuat di Scala dan karenanya dapat ditambahkan bahkan ke versi Scala yang lebih lama seperti 2.10. Selain itu, Scala kompatibel dengan Java, sehingga Anda dapat menulis kode async di Scala dan kemudian memanggilnya dari Jawa.

Ada juga proyek serupa lainnya yang disebut Akka Dataflow http://doc.akka.io/docs/akka/2.3-M1/scala/dataflow.html yang menggunakan kata-kata yang berbeda tetapi secara konseptual sangat mirip, namun diimplementasikan menggunakan kelanjutan yang dibatasi, bukan makro (sehingga bekerja dengan versi Scala yang lebih lama seperti 2.9).

Java tidak memiliki padanan langsung dari fitur bahasa C # yang disebut async / await, namun ada pendekatan berbeda untuk masalah yang coba dipecahkan oleh async / await. Ini disebut proyek Loom , yang akan menyediakan utas virtual untuk konkurensi throughput tinggi. Ini akan tersedia di beberapa versi OpenJDK mendatang.

Pendekatan ini juga memecahkan " masalah fungsi berwarna " yang dimiliki oleh async / menunggu.

Fitur serupa juga dapat ditemukan di Golang ( goroutine ).

Jika Anda hanya setelah kode bersih yang mensimulasikan efek yang sama seperti async / menunggu di java dan tidak keberatan memblokir utas yang dipanggil sampai selesai, seperti dalam ujian, Anda bisa menggunakan sesuatu seperti kode ini:

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

Pustaka AsynHelper Java mencakup sekumpulan kelas / metode utilitas untuk panggilan asinkron (dan tunggu).

Jika diinginkan untuk menjalankan seperangkat pemanggilan metode atau blok kode secara tidak serempak, itu termasuk metode pembantu yang berguna, AsyncTask .submitTasks seperti dalam cuplikan di bawah ini.

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

Jika diinginkan untuk menunggu sampai semua kode asinkron selesai dijalankan, varian AsyncTask.submitTasksAndWait dapat digunakan.

Juga jika diinginkan untuk memperoleh nilai balik dari setiap pemanggilan metode atau blok kode asinkron, AsyncSupplier .submitSuppliers dapat digunakan sehingga hasilnya dapat diperoleh dari larik pemasok yang dikembalikan oleh metode tersebut. Berikut cuplikan sampel:

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

Jika jenis pengembalian setiap metode berbeda, gunakan jenis cuplikan di bawah ini.

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

Hasil dari panggilan metode asinkron / blok kode juga dapat diperoleh pada titik kode berbeda di utas yang sama atau utas berbeda seperti pada cuplikan di bawah ini.

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