Java เทียบเท่าของ C # async / รอ?

ฉันเป็นนักพัฒนา C # ปกติ แต่บางครั้งฉันก็พัฒนาแอปพลิเคชันใน Java ฉันสงสัยว่ามี Java เทียบเท่าของ C # async / รอ? ในคำง่าย ๆ เทียบเท่า java คืออะไร:

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

ไม่ไม่มีอะไรเทียบเท่า async / คอยใน Java - หรือแม้แต่ใน C # ก่อน v5

มันเป็นคุณสมบัติทางภาษาที่ค่อนข้างซับซ้อนในการสร้างเครื่องรัฐหลังฉาก

มีการสนับสนุนภาษาค่อนข้างน้อยสำหรับการซิงโครนัส / การทำงานพร้อมกันใน Java แต่java.util.concurrentแพ็คเกจมีคลาสที่มีประโยชน์มากมายรอบ ๆ สิ่งนี้ (ไม่เทียบเท่ากับ Task Parallel Library แต่ใกล้เคียงที่สุดกับมัน)

awaitใช้ความต่อเนื่องในการดำเนินการรหัสเพิ่มเติมเมื่อเสร็จสิ้นการดำเนินการไม่ตรงกัน ( client.GetStringAsync(...))

ดังนั้นในฐานะที่ใกล้เคียงที่สุดฉันจะใช้โซลูชันCompletableFuture<T>(ตามมาตรฐาน Java 8 เทียบเท่ากับ. net Task<TResult>) เพื่อประมวลผลคำขอ Http แบบอะซิงโครนัส

อัปเดตเมื่อวันที่25-05-2559 เป็น AsyncHttpClient v.2 ที่เผยแพร่ใน Abril วันที่ 13 ของปี 2559:

ดังนั้น Java 8 ที่เทียบเท่ากับตัวอย่าง OP AccessTheWebAsync()คือ:

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

การใช้งานนี้นำมาจากคำตอบของฉันจะได้รับ CompletableFuture จากคำขอไคลเอ็นต์ Async Http ได้อย่างไร และที่เป็นไปตาม API ใหม่ที่มีให้ในรุ่นที่ 2 ของAsyncHttpClientปล่อยออกมาในวันที่ 13 เมษายน 2016 CompletableFuture<T>ที่ได้รับการสนับสนุนที่แท้จริงแล้ว

คำตอบเดิมโดยใช้ AsyncHttpClient รุ่น 1:

ด้วยเหตุนี้เราจึงมีสองแนวทางที่เป็นไปได้:

• คนแรกที่ใช้ non-blocking IO AccessTheWebAsyncNioและผมเรียกมันว่า แต่เนื่องจากAsyncCompletionHandlerเป็นคลาสนามธรรม (แทนที่จะเป็นส่วนต่อประสานการทำงาน) เราไม่สามารถผ่านแลมบ์ดาเป็นอาร์กิวเมนต์ได้ ดังนั้นมันจึงเกิดขึ้นอย่างหลีกเลี่ยงไม่ได้เนื่องจากไวยากรณ์ของคลาสที่ไม่ระบุชื่อ อย่างไรก็ตามวิธีนี้ใกล้เคียงกับขั้นตอนการดำเนินการของตัวอย่าง C # ที่ให้มามากที่สุด

• ส่วนที่สองน้อยกว่า verbose เล็กน้อย แต่มันจะส่งงานใหม่ที่ท้ายที่สุดจะบล็อกเธรดf.get()จนกว่าการตอบสนองจะเสร็จสมบูรณ์

วิธีแรก , verbose เพิ่มเติม แต่ไม่ใช่การปิดกั้น:

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

วิธีที่สอง verbose น้อยลง แต่บล็อกเธรด:

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

ลองใช้ea-asyncซึ่งเขียนโดย Java bytecode เพื่อจำลอง async / รอสวยอยู่ดี ตาม readme ของพวกเขา: "มันเป็นแรงบันดาลใจอย่างมากจาก Async-Await บน. NET CLR"

asyncและคอยเป็นน้ำตาลประโยค สาระสำคัญของ async และคอยเป็นเครื่องรัฐ คอมไพเลอร์จะแปลงรหัส async / คอยของคุณเป็นเครื่องรัฐ

ในเวลาเดียวกันเพื่อให้ async / รอการปฏิบัติจริงในโครงการจริงเราต้องมีฟังก์ชันไลบรารี Async I / Oจำนวนมากที่มีอยู่แล้ว สำหรับ C # ฟังก์ชัน I / O ที่ซิงโครไนซ์ดั้งเดิมส่วนใหญ่จะเป็นเวอร์ชั่น Async ทางเลือก เหตุผลที่เราต้องการฟังก์ชั่น Async เหล่านี้เป็นเพราะในกรณีส่วนใหญ่โค้ด async / await ของคุณจะต้มลงไปที่เมธอด Async ของไลบรารี

ฟังก์ชันไลบรารีเวอร์ชัน Async ใน C # เป็นแนวคิดแบบ AsynchronousChannel ใน Java ตัวอย่างเช่นเรามี AsynchronousFileChannel.read ซึ่งสามารถส่งคืน Future หรือรันการเรียกกลับหลังจากดำเนินการอ่าน แต่มันไม่เหมือนกันทุกประการ ฟังก์ชัน C # Async ทั้งหมดส่งคืนงาน (คล้ายกับอนาคต แต่มีประสิทธิภาพมากกว่าในอนาคต)

ดังนั้นสมมติว่า Java รองรับ async / คอยและเราเขียนโค้ดบางอย่างเช่นนี้:

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

จากนั้นฉันก็นึกภาพคอมไพเลอร์จะแปลง async / คอยรหัสต้นฉบับเป็นอะไรเช่นนี้:

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

และนี่คือการดำเนินการสำหรับ 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);
    }
}

ไม่มีเทียบเท่าของ C # async / รอใน Java ในระดับภาษา แนวคิดที่รู้จักกันในชื่อFibers aka กลุ่มการร่วมมือหรือ aka Thread Lightweightอาจเป็นทางเลือกที่น่าสนใจ คุณสามารถค้นหาไลบรารี Java ที่ให้การสนับสนุนเส้นใย

ไลบรารี Java ที่ใช้ Fibers

• JetLang
• Kilim
• ดวงดาวที่ห่างจากโลกสีร้อยสิบพันปีแสง

คุณสามารถอ่านบทความนี้ (จาก Quasar)สำหรับการแนะนำที่ดีกับเส้นใย ครอบคลุมสิ่งที่เป็นเธรดวิธีการนำไฟเบอร์ไปใช้งานบน JVM และมีโค้ดเฉพาะ Quasar

ตามที่ได้กล่าวมาแล้วไม่มีความเทียบเท่าโดยตรง แต่สามารถสร้างการประมาณใกล้เคียงได้อย่างมากด้วยการดัดแปลง Java bytecode (สำหรับทั้งคำแนะนำแบบ async / ที่รอคอยและการใช้งานแบบต่อเนื่องเป็นต้น)

ฉันกำลังทำงานในโครงการที่ใช้ async / คอยบนไลบรารีต่อเนื่อง JavaFlowโปรดตรวจสอบhttps://github.com/vsilaev/java-async-await

ยังไม่มีการสร้าง Maven mojo แต่คุณสามารถรันตัวอย่างด้วยตัวแทน Java ที่ให้มา นี่คือลักษณะของรหัส async / await:

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 เป็นคำอธิบายประกอบที่ตั้งค่าสถานะวิธีที่เรียกใช้งานแบบอะซิงโครนัสรอ () เป็นฟังก์ชันที่รอให้ CompletableFuture ใช้การดำเนินการต่อเนื่องและการเรียกเพื่อ "return asyncResult (someValue)" เป็นสิ่งที่เกี่ยวข้อง

เช่นเดียวกับ C #, การควบคุมการไหลถูกเก็บรักษาไว้และการจัดการข้อยกเว้นอาจทำได้ในลักษณะปกติ (ลอง / จับเช่นในรหัสที่ดำเนินการตามลำดับ)

Java ตัวมันเองไม่มีคุณสมบัติเทียบเท่า แต่ห้องสมุดของบุคคลที่สามที่มีอยู่ซึ่งมีฟังก์ชันการทำงานที่คล้ายกันเช่นKilim

ก่อนอื่นให้ทำความเข้าใจว่า async / คอยคืออะไร มันเป็นวิธีสำหรับแอปพลิเคชัน GUI แบบเธรดเดียวหรือเซิร์ฟเวอร์ที่มีประสิทธิภาพในการรันหลาย ๆ "เส้นใย" หรือ "ร่วมกิจวัตร" หรือ "กระทู้เบา" ในหัวข้อเดียว

หากคุณมีความตกลงกับใช้หัวข้อสามัญแล้วเทียบเท่า Java เป็นและExecutorService.submit Future.getสิ่งนี้จะบล็อกจนกว่างานจะเสร็จสมบูรณ์และส่งคืนผลลัพธ์ ในขณะเดียวกันเธรดอื่นสามารถทำงานได้

หากคุณต้องการประโยชน์ของสิ่งต่าง ๆ เช่นไฟเบอร์คุณต้องการการสนับสนุนในคอนเทนเนอร์ (ฉันหมายถึงในเหตุการณ์ GUI หรือในเซิร์ฟเวอร์ตัวจัดการการร้องขอ HTTP) หรือโดยการเขียนของคุณเอง

ตัวอย่างเช่น Servlet 3.0 เสนอการประมวลผลแบบอะซิงโครนัส javafx.concurrent.Taskข้อเสนอ JavaFX สิ่งเหล่านี้ไม่มีคุณสมบัติด้านภาษาที่หรูหรา พวกเขาทำงานผ่านการเรียกกลับสามัญ

มีอะไรที่ไม่พื้นเมือง Java ที่ช่วยให้คุณทำเช่นนี้ async / รอคอยคำหลัก แต่สิ่งที่คุณสามารถทำได้ถ้าคุณอยากจะมีที่ใช้CountDownLatch จากนั้นคุณสามารถเลียนแบบ async / รอโดยผ่านสิ่งนี้ (อย่างน้อยใน Java7) นี่เป็นวิธีปฏิบัติทั่วไปในการทดสอบหน่วย Android ที่เราต้องทำการโทรแบบ async (โดยปกติแล้วจะเรียกใช้งานได้โดยตัวจัดการ) แล้วรอผล (นับถอยหลัง)

การใช้สิ่งนี้อย่างไรก็ตามในใบสมัครของคุณซึ่งตรงข้ามกับการทดสอบของคุณไม่ใช่สิ่งที่ฉันแนะนำ นั่นจะเป็นสิ่งที่น่ารังเกียจอย่างยิ่งเมื่อ CountDownLatch ขึ้นอยู่กับคุณอย่างมีประสิทธิภาพในการนับจำนวนครั้งและในสถานที่ที่เหมาะสม

ฉันสร้างและเผยแพร่ Java async / คอยไลบรารี https://github.com/stofu1234/kamaitachi

ไลบรารีนี้ไม่ต้องการนามสกุลคอมไพเลอร์และตระหนักถึงการประมวลผล IO แบบไม่ซ้อนใน Java

    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 มีโชคไม่เทียบเท่า async / await สิ่งที่ใกล้เคียงที่สุดที่คุณจะได้รับคือ ListenableFuture จาก Guava และ Listener chaining แต่มันก็ยังเป็นเรื่องยุ่งยากมากที่จะเขียนสำหรับกรณีที่เกี่ยวข้องกับการเรียกแบบอะซิงโครนัสหลายครั้งเนื่องจากระดับการซ้อนจะเติบโตอย่างรวดเร็ว

หากคุณตกลงกับการใช้ภาษาอื่นที่อยู่ด้านบนของ JVM โชคดีที่มี async / await ใน Scala ซึ่งเป็น C # async โดยตรง / รอคอยเทียบเท่ากับไวยากรณ์และความหมายที่เหมือนกันเกือบ: https://github.com/scala/ async /

โปรดทราบว่าแม้ว่าฟังก์ชันนี้ต้องการการสนับสนุนคอมไพเลอร์ขั้นสูงใน C # แต่ใน Scala สามารถเพิ่มเป็นห้องสมุดได้ด้วยระบบแมโครที่ทรงพลังมากใน Scala และสามารถเพิ่มได้แม้กระทั่ง Scala รุ่นเก่าเช่น 2.10 นอกจากนี้ Scala ยังเข้ากันได้กับ Java ดังนั้นคุณสามารถเขียนรหัส async ใน Scala แล้วเรียกมันจาก Java

นอกจากนี้ยังมีอีกโครงการที่คล้ายกันที่เรียกว่า Akka Dataflow http://doc.akka.io/docs/akka/2.3-M1/scala/dataflow.htmlซึ่งใช้ถ้อยคำต่างกัน แต่แนวคิดจะคล้ายกันมาก แต่นำมาใช้โดยใช้ตัวคั่นแบบต่อเนื่องไม่ใช่แมโคร (ดังนั้นจึงใช้งานได้กับ Scala เวอร์ชันที่เก่ากว่าเช่น 2.9)

Java ไม่มีคุณสมบัติเทียบเท่าโดยตรงกับภาษา C # ที่เรียกว่า async / await แต่มีวิธีการที่แตกต่างจากปัญหาที่ async / คอยพยายามแก้ไข เรียกว่าโปรเจ็กต์Loomซึ่งจะให้เธรดเสมือนจริงสำหรับการทำงานพร้อมกันของปริมาณงานสูง จะสามารถใช้ได้ใน OpenJDK บางรุ่นในอนาคต

วิธีการนี้ยังแก้ไข " ปัญหาฟังก์ชันสี " ที่ async / await มี

คุณสมบัติที่คล้ายกันสามารถพบได้ใน Golang ( goroutines )

หากคุณเพิ่งทำความสะอาดโค้ดซึ่งจำลองเอฟเฟกต์เดียวกันกับ async / คอยในจาวาและไม่รังเกียจที่จะปิดกั้นเธรดที่ถูกเรียกใช้จนกว่าจะเสร็จสิ้นเช่นในการทดสอบคุณสามารถใช้บางอย่างเช่นรหัสนี้:

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 ประกอบด้วยชุดของคลาส / วิธีการยูทิลิตี้สำหรับการโทรแบบอะซิงโครนัส (และรอ)

หากต้องการเรียกใช้ชุดการเรียกเมธอดหรือบล็อคโค้ดแบบอะซิงโครนัสกระบวนการจะรวมเมธอดตัวช่วยเหลือที่มีประโยชน์AsyncTask .submitTasksตามด้านล่างตัวอย่าง

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

หากต้องการรอจนกว่ารหัสอะซิงโครนัสทั้งหมดจะทำงานเสร็จสมบูรณ์AsyncTask.submitTasksAndWait varient สามารถใช้งานได้

นอกจากนี้หากต้องการรับค่าส่งคืนจากการเรียกใช้เมธอดแบบอะซิงโครนัสหรือการบล็อกรหัสแต่ละครั้งสามารถใช้AsyncSupplier .submitSuppliersเพื่อให้ได้ผลลัพธ์จากอาร์เรย์ผู้จัดหาผลลัพธ์ที่ส่งคืนโดยวิธีการ ด้านล่างนี้เป็นตัวอย่างข้อมูล:

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

หากประเภทการคืนของแต่ละวิธีแตกต่างกันให้ใช้ตัวอย่างข้อมูลด้านล่าง

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

ผลลัพธ์ของการเรียกใช้วิธีการแบบอะซิงโครนัส / การบล็อกรหัสสามารถรับได้ที่จุดต่าง ๆ ของรหัสในเธรดเดียวกันหรือเธรดที่แตกต่างกันในข้อมูลตัวอย่างด้านล่าง

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