CompletableFuture,Future和RXJava的Observable之间的区别

Question

我想知道completablefuture、future和observablerxjava之间的区别。

我知道的是所有的都是异步的

RXJava Observable--与CompletableFuture类似，但有其他优点（不确定）

例如：如果客户端需要进行多个服务调用，并且当我们使用future(Java)future.get()时，将顺序执行...想知道如何在rxjava中更好...

文档http://reactivex.io/intr.html说

很想知道rxjava是如何解决这个问题的。我从文件中发现很难理解。

Answer 1

期货

Futures是在Java 5（2004）中引入的。它们基本上是一个尚未完成的操作结果的占位符。操作完成后，future将包含该结果。例如，操作可以是提交给ExecutorService的可运行或可调用实例。操作的提交者可以使用future对象检查操作是否为isDone（）,或者使用阻塞get（）方法等待其完成。

示例：

/**
* A task that sleeps for a second, then returns 1
**/
public static class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        Thread.sleep(1000);
        return 1;
    }

}

public static void main(String[] args) throws Exception{
    ExecutorService exec = Executors.newSingleThreadExecutor();
    Future<Integer> f = exec.submit(new MyCallable());

    System.out.println(f.isDone()); //False

    System.out.println(f.get()); //Waits until the task is done, then prints 1
}

/**
* A supplier that sleeps for a second, and then returns one
**/
public static class MySupplier implements Supplier<Integer> {

    @Override
    public Integer get() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            //Do nothing
        }
        return 1;
    }
}

/**
* A (pure) function that adds one to a given Integer
**/
public static class PlusOne implements Function<Integer, Integer> {

    @Override
    public Integer apply(Integer x) {
        return x + 1;
    }
}

public static void main(String[] args) throws Exception {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    CompletableFuture<Integer> f = CompletableFuture.supplyAsync(new MySupplier(), exec);
    System.out.println(f.isDone()); // False
    CompletableFuture<Integer> f2 = f.thenApply(new PlusOne());
    System.out.println(f2.get()); // Waits until the "calculation" is done, then prints 2
}

RxJava

RxJava是Netflix创建的用于反应编程的完整库。乍一看，它似乎与Java8的流类似。是的，只是它的力量要大得多。

与Futures类似，可以使用RxJava将一堆同步或异步操作串在一起，以创建处理管道。与Futures不同的是,Futures是单次使用的,RxJava可以处理零个或多个项目的流。包括具有无限数量项的永无止境流。由于拥有丰富得难以置信的操作符集，它也更加灵活和强大。

Java9的Reactive Streams aka Flow API是由各种Reactive Streams库（如RXJava2、Akka Streams和Vertx）实现的一组接口。它们允许这些反应性库相互连接，同时保留所有重要的背压。