Futures (based on version 22.0)

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import com.google.common.base.Function;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.Futures.FutureCombiner;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
/**
 * @author Andypan
 * @FuturesTest.java
 * @{describe}
 * @date 2017年7月31日 上午10:09:54
 */
public class FuturesTest
{
public static void main(String[] args) throws InterruptedException, ExecutionException
{
ListeningExecutorService threadPool = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2));
ListenableFuture<Integer> future1 = threadPool.submit(new CallableTaskTest("a", 23));
ListenableFuture<Integer> future2 = threadPool.submit(new CallableTaskTest("b", 19));


Futures.addCallback(future1, new FutureCallback<Integer>() {


@Override
public void onSuccess(Integer result)
{
System.out.println("success");
}


@Override
public void onFailure(Throwable t)
{
}
}, threadPool);


ListenableFuture<List<Integer>> result = Futures.allAsList(future1, future2);
// System.out.println(result.isDone());
// System.out.println(result.get());


// Iterable<ListenableFuture<Integer>> fuIterable =
// Sets.newHashSet(future1, future2);
// Futures.allAsList(fuIterable);


ListenableFuture<List<Integer>> result2 = Futures.allAsList(Sets.newHashSet(future1, future2));
System.out.println(result2.get());


ListenableFuture<List<Integer>> result3 = Futures.successfulAsList(Sets.newHashSet(future1, future2));
System.out.println(result3.get());


ListenableFuture<String> transResult = Futures.transform(future1, new Function<Integer, String>() {


@Override
public String apply(Integer input)
{


return input + " str";
}
}, threadPool);


/* ListenableFuture<String> transResult = */
// Futures.transformAsync(future2, new AsyncFunction<Integer, String>()
// {
//
// @Override
// public ListenableFuture<String> apply(Integer input) throws Exception
// {
//
// return null;
// }
// }, threadPool);


System.out.println(transResult.get());


FutureCombiner<Integer> combiner = Futures.whenAllComplete(Sets.newHashSet(future1, future2));
ListenableFuture<String>  combinerComplete = combiner.call(new Callable<String>() {


@Override
public String call() throws Exception
{


return "combiner succeed !!!";
}
}, threadPool);

System.out.println(combinerComplete.get());
threadPool.shutdown();
}
}