Java 欺骗未来的对象，它们是可重用的吗？

我是个新手。我现在正在阅读某人的代码，发现未来的对象在不同的连接操作中被重用。我的问题是，这会导致将来的对象执行多次（在每个联接中），还是只执行一次并存储结果以供以后的联接

例如：

Future<A> a= b
            .join(c)
            .flatMap(new SomeFunctionReturningA());

Future<Tuple2<A, B>> future1 = a.join(b);
Future<D> future2 = future1.flatMap(new SomeFunctionReturningD()); 
future2.get();

未来a=b
.加入（c）
.flatMap（新的SomeFunctionReturningA（））；
未来1=a.加入（b）；
Future future2=future1.flatMap（新的SomeFunctionReturningD（））；
未来2.获取（）；

---

那么b将执行两次，还是只执行一次？

我自己写了一个快速测试：

import com.twitter.util.Function;
import com.twitter.util.Future;
import java.util.Random;
import org.junit.Test;
import scala.Tuple2;

public class FinagleFutureTest {
    int counter = 0;

    @Test
    public void test(){
        Counter counter = new Counter();
        Future<Counter> one = Future.value(counter).flatMap(new IncrementFunction());
        Future<Counter> two = one.flatMap(new IncrementFunction());
        Future<Tuple2<Counter, Counter>> three = two.join(one);
        Tuple2<Counter, Counter> tuple = three.flatMap(new TupleFunction()).get();
        System.out.println("one: "+ tuple._2().count+", "+tuple._2().randomInt);
        System.out.println("two: "+ tuple._1().count+", "+tuple._1().randomInt);
    }

    static class TupleFunction extends Function<Tuple2<Counter, Counter>, Future<Tuple2<Counter, Counter>>>{

        @Override
        public Future<Tuple2<Counter, Counter>> apply(Tuple2<Counter, Counter> t1) {
            return Future.value(t1);
        }

    }

    static class IncrementFunction extends Function<Counter, Future<Counter>>{
        @Override
        public Future<Counter> apply(Counter counter) {
            counter.add();
            return Future.value(counter);
        }
    }

    static class Counter{
        public int count = 0;
        public int randomInt;
        Counter(){
            Random random = new Random();
            randomInt = random.nextInt();
        }
        public void add(){
            count++;
        }
    }
}

---

因此得出的结论是，Future对象只执行一次，无论它涉及多少个联接操作。

Future只是一个值的容器，并且该值将只设置一次！

未来[T]

具有不同的状态：

• 空的
• 设置一个类型为T的值
• 破例

当您在未来的

a

上对函数

f

使用

map/flatMap

时，您只需创建一个新的未来

B

，它将是函数

f

转换的前一个未来的结果

请注意：

• 如果未来的

  A

  尚未“填充”，您将拥有一个尚未填充的

  B

• 在

  a

  中设置值

  a

  的线程也将执行

  f（a）

  并在

  B

  中设置值
• 如果

  A

  已“填充”，则map/flatMap的调用者也将执行

  f（A）

  ，但不会重新计算

  A

  的值
• 您还可以使用

  onSuccess/onFailure

  ，它将只注册一些代码，以便在将来获得其值时执行

---

未来对象只执行一次

Finagle使用com.twitter.util。Future是尚未可用的值的句柄

利用未来最基本的两种方式是： 阻塞并等待计算返回 注册在计算最终成功或失败时调用的回调 FuturePool对象使您能够在其自己的线程上放置阻塞操作

您可以从和获得更多关于欺骗未来（未来池）的了解

one: 2, 2009034289
two: 2, 2009034289