时间戳

首页 > 解决方案 > 我在 Java 中使用什么将等同于 Javascript 中的 Async Await？

java - 我在 Java 中使用什么将等同于 Javascript 中的 Async Await？

问题描述

public class main {
    private static class myClass {
        ...
    }

    public static MaxSubSequence Class1()) {
        ...
    }

    public static MaxSubSequence Class2() {
        ...
    }

    public static MaxSubSequence class3() {
        ...
    }

    public static MaxSubSequence class4() {
        ...

    }

    public static void main(String[] args) {
        Class1();
        Class2();
        Class3();
        Class4();
    }

}

在上面的示例代码中，我试图计算 main 中每个函数调用的 CPU 时间。如果我做：

long Start= System. nanoTime();
Class1();
long End= System.nanoTime();
long CPUTime=End-Start;

long Start= System. nanoTime();
Class2();
long End= System.nanoTime();
long CPUTime=End-Start;

long Start= System. nanoTime();
Class3();
long End= System.nanoTime();
long CPUTime=End-Start;

long Start= System. nanoTime();
Class4();
long End= System.nanoTime();
long CPUTime=End-Start;*

那么CPU时间就会出错。我想先完成执行，然后再Class1()像Class2()Javascript一样，但我不知道该怎么做。有人可以帮我吗？Class3()Class4()Async Await

标签： javaasync-await

解决方案

您可以在可完成的未来中调用方法的执行并将它们链接在一起。如果我理解正确，这就是我尝试做的方式。 Completable:join阻塞直到执行完成。

public class SimpleCompletableFutureSequence {

    static class MyClass {
        public String execute(String arg) {
            // this will be otherwise lengthy operation
            return arg;
        }

        public CalculatedTimedResponse executeAnother(String arg) {
            LocalTime startTime = LocalTime.now();
            LocalTime endTime = LocalTime.now();
            MyClass myClass = new MyClass();
            String response = null;
            try {
                response = myClass.execute(arg);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                endTime = LocalTime.now();
            }
            Duration timeDifference = Duration.between(startTime, endTime);
            System.out.println("Difference: " + timeDifference.toSecondsPart());
            return new CalculatedTimedResponse(timeDifference.toSecondsPart(), response);
        }
    }

    static CompletableFuture<String> class1() {
        return CompletableFuture.completedFuture(new MyClass().execute("class1"));
    }

    static CompletableFuture<String> class2() {
        return CompletableFuture.completedFuture(new MyClass().execute("class2"));
    }

    static CompletableFuture<String> class3() {
        return CompletableFuture.completedFuture(new MyClass().execute("class3"));
    }

    static CompletableFuture<String> class4() {
        return CompletableFuture.completedFuture(new MyClass().execute("class4"));
    }

    public static void main(String[] args) {
        List<CompletableFuture<String>> allFutures = Arrays.asList(class1(), class2(), class3(), class4());
        List<String> allResponse = allFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
        System.out.println(allResponse);
    }
}

如果您打算计算时差，那么我尝试这样做：

static class CalculatedTimedResponse {
        int difference;
        String response;

        public CalculatedTimedResponse(int difference, String response) {
            this.difference = difference;
            this.response = response;
        }

        @Override
        public String toString() {
            return "CalculatedTimedResponse{" +
                    "difference=" + difference +
                    ", response='" + response + '\'' +
                    '}';
        }
    }

和 2 个可完成的期货

static CompletableFuture<CalculatedTimedResponse> class1Response = CompletableFuture.supplyAsync(new Supplier<CalculatedTimedResponse>() {
        @Override
        public CalculatedTimedResponse get() {
            return new MyClass().executeAnother("time-execute- 1");
        }
    });

    static CompletableFuture<CalculatedTimedResponse> class2Response = CompletableFuture.supplyAsync(new Supplier<CalculatedTimedResponse>() {
        @Override
        public CalculatedTimedResponse get() {
            return new MyClass().executeAnother("time-execute- 2");
        }
    });

List<CompletableFuture<CalculatedTimedResponse>> timedFutures = Arrays.asList(class1Response, class2Response);
        List<CalculatedTimedResponse> allTimeResponse = timedFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
        System.out.println(allTimeResponse);

源代码

推荐阅读