12

我有两个在其他线程上完成的 ListenableFutures。每个未来都是不同的类型，我希望在它们都完成时使用它们的两个结果。

有没有一种优雅的方式来使用番石榴来处理这个问题？

4

5 回答 5

9

如果您想要某种类型的安全性，您可以执行以下操作：

class Composite {
  public A a;
  public B b;
}

public ListenableFuture<Composite> combine(ListenableFuture<A> futureA, 
                                           final ListenableFuture<B> futureB) {

  return Futures.transform(futureA, new AsyncFunction<A, Composite>() {
    public ListenableFuture<Composite> apply(final A a) throws Exception {
      return Futures.transform(futureB, new Function<B, Compisite>() {
        public Composite apply(B b) {
          return new Composite(a, b);
        }
      }
    } 
  }

}

ListenableFuture<A> futureA = ...
ListenableFuture<B> futureB = ...

ListenableFuture<Composite> result = combine(futureA, futureB);

在这种情况下，如果您愿意，Composite可以Pair<A, B>来自 Apache Commons。

此外，任何一个未来的失败都将导致组合未来的失败。

另一个解决方案是看看Spotify 团队的Trickle。GitHub README 有一个示例，它显示了类似问题的解决方案。

毫无疑问，还有其他解决方案，但这是我脑海中浮现的解决方案。

于 2014-03-14T20:41:06.460 回答
4 
Runnable listener = new Runnable() {
    private boolean jobDone = false;

    @Override
    public synchronized void run() {
        if (jobDone || !(future1.isDone() && future2.isDone())) {
            return;
        }
        jobDone = true;
        // TODO do your job
    }
};
future1.addListener(listener);
future2.addListener(listener);

不是很优雅，但应该做的工作。

或者，更优雅，但你需要演员表：

ListenableFuture<List<Object>> composedFuture = 
    Futures.allAsList(future1, future2);
于 2012-12-07T13:07:35.470 回答
1

从 Guava v20.0 开始，您可以使用：

ListenableFuture<CombinedResult> resultFuture =
   Futures.whenAllSucceed(future1, future2)
       .call(callableThatCombinesAndReturnsCombinedResult, executor);

在此处查看java 文档示例

于 2018-11-20T10:12:24.750 回答
0

如果你想要一些类型安全，你可以使用EventBus姐妹 Guavacom.google.common.eventbus包中的 2 个不同的独立任务的结果

例如，假设你们中的一个Futures返回Integer，另一个返回Double。

首先，创建一个累加器（其他名称builder、collector等）类，您将使用 EventBus 将其注册为事件接收器。如您所见，它确实是一个 POJO，它将处理Integer和Double事件

class Accumulator
{
    Integer intResult;
    Double  doubleResult;

    @Subscribe // This annotation makes it an event handler
    public void setIntResult ( final Integer val )
    {
        intResult = val;
    }

    @Subscribe
    public void setDoubleResult ( final Double val )
    {
        doubleResult = val;
    }
}

这是将采用 2 个期货并将它们组合成一个累加器的方法的实现。

final ListenableFuture< Integer > future1 = ...;
final ListenableFuture< Double > future2 = ...;

final ImmutableList< ListenableFuture< ? extends Object> > futures =
    ImmutableList.< ListenableFuture<? extends Object> >of( future1, future2 );

final ListenableFuture< Accumulator > resultFuture =
    Futures.transform(
        // If you don't care about failures, use allAsList
        Futures.successfulAsList( futures ),
        new Function< List<Object>, Accumulator > ( )
        {
            @Override
            public Accumulator apply ( final List< Object > input )
            {
                final Accumulator accumulator = new Accumulator( );

                final EventBus eventBus = new EventBus( );
                eventBus.register( accumulator );

                for ( final Object cur: input )
                {
                    // Failed results will be set to null
                    if ( cur != null )
                    {
                        eventBus.post( cur );
                    }
                }

                return accumulator;
            }
        }
    );

final Accumulator accumulator = resultFuture.get( );
于 2013-03-22T16:31:02.867 回答
0

这是一个简单的示例，它将执行添加 2 个可侦听的期货：

//Asynchronous call to get first value
final ListenableFuture<Integer> futureValue1 = ...;

//Take the result of futureValue1 and transform it into a function to get the second value
final AsyncFunction<Integer, Integer> getSecondValueAndSumFunction = new AsyncFunction<Integer, Integer>() {
    @Override
    public ListenableFuture<Integer> apply(final Integer value1) {

        //Asynchronous call to get second value
        final ListenableFuture<Integer> futureValue2 = ...;


        //Return the sum of the values
        final Function<Integer, Integer> addValuesFuture = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer value2) {

                Integer sum = value1 + value2;
                return sum;
            }               
        };              

        //Transform the second value so its value can be added to the first
        final ListenableFuture<Integer> sumFuture = Futures.transform(futureValue2, addValuesFuture);   

        return sumFuture;
    }
};

final ListenableFuture<Integer> valueOnePlusValueTwo = Futures.transform(futureValue1, getSecondValueAndSumFunction);
于 2016-02-23T20:31:35.780 回答