异步 CompletableFuture 同步返回到单线程 ExecutorService

Question

我正在创建一个单线程 ExecutorService，并将需要异步执行的任务 (CompletableFuture) 分配给该单线程服务（同时尝试了 runAsync 和 supplyAsync）。

package Executor;

import java.util.Date;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorResolver {

    ExecutorService es = Executors.newSingleThreadExecutor();
    volatile int counter = 2;
    static int ten = 10;
    static int five = 5;

    public void printer() {

        System.out.println("This thread is complete :" + Thread.currentThread().getName());
        System.out.println(new Date(System.currentTimeMillis()));

    }

    public void execute() {

        CompletableFuture<Void> ct = CompletableFuture.allOf(CompletableFuture.runAsync(() -> {
            try {
                Thread t = new Thread();
                Thread.sleep(ten * 1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, es).thenRunAsync(this::printer), CompletableFuture.runAsync(() -> {
            try {
                Thread t = new Thread();
                Thread.sleep(five * 1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, es).thenRunAsync(this::printer)

        );

    }

    public static void main(String args[]) {

        ExecutorResolver er = new ExecutorResolver();

        er.execute();

        for (int i = 0; i < 1000; i++) {
            System.out.println("Current thread name : " + Thread.currentThread().getName() + i);
        }
        System.out.println(new Date(System.currentTimeMillis()));

    }

}

但是它们是同步执行的，

See the console log which waits for thread that sleeps for 10 secs and then the executes the one which sleeps for 5 seconds

请让我知道这是可能的还是我做错了什么？

Answer 1

我相信您正在尝试做的是使用单线程异步编程风格。这种风格在 Javascript 尤其是 node.js 应用程序中被大量使用，因为它非常适合必须同时处理许多客户端的服务器端代码，这在 node.js 的创建者this talk 中得到了很好的解释。然而，在 Java 世界中，由于某种原因，这种编程风格并不是很普遍。所以也许你想先学习 node.js 编程。之后，您可以将在那里学到的东西翻译成 Java。 无论如何，我改变了你的代码，我认为它现在正在做你想要的。问题是您不能通过阻塞线程来执行延迟。相反，您也必须为此使用 Future。

package executor;

import java.util.Date;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.Timer;
import java.util.TimerTask;

public class ExecutorResolver {
    private final ExecutorService es = Executors.newSingleThreadExecutor();
    private static final Timer timer = new Timer();

    public static CompletableFuture<Void> delay(long delay) {
      CompletableFuture<Void> fut = new CompletableFuture<>();
      timer.schedule(new TimerTask() {
        @Override
        public void run() {
          fut.complete(null);
        }
      }, delay);
      return fut;
    }

    public static Date date() {
      return new Date(System.currentTimeMillis());
    }

    public void execute() {
        CompletableFuture<Void> ct = CompletableFuture.allOf(
            CompletableFuture
                .runAsync(() -> {
                    System.out.println(date() + ": started first async operation in thread " + Thread.currentThread());
                }, es)
                .thenComposeAsync(x -> delay(10000), es)
                .thenRunAsync(() -> {
                  System.out.println(date() + ": completed first async operation in thread " + Thread.currentThread());
                }, es)
            ,

            CompletableFuture
                .runAsync(() -> {
                    System.out.println(date() + ": started second async operation in thread " + Thread.currentThread());
                }, es)
                .thenComposeAsync(x -> delay(5000), es)
                .thenRunAsync(() -> {
                  System.out.println(date() + ": completed second async operation in thread " + Thread.currentThread());
                }, es)
          );
    }

    public static void main(String args[]) {
        ExecutorResolver er = new ExecutorResolver();
        er.execute();
    }
}