本文以多次查询数据库为例进行说明。为了能够模拟查询数据库,这里会事先创建一个map,将查询条件和查询结果封装到map中。
在batchExec方法中,传入带有泛型的查询条件集合,核心操作是遍历查询条件集合,将每一个查询条件传给SingleTask(业务实现类),SingleTask必需要实现callable接口,在call方法中实现查询业务,这里使用上面创建好的map来进行模拟操作。
对于每一个查询任务SingleTask,将其放入ListeningExecutorService的submit()方法中执行,会返回一个ListenableFuture对象,我们使用Futures的addCallback()方法对得到的ListenableFuture进行监听,如果success则得到查询结果,并将结果放入结果集合中。这里需要注意的是需要将每一个ListenableFuture单独存入一个集合中,使用Futures的allAsList()方法能够得到一个新的ListenableFuture对象,然后使用future的get()方法来阻塞这个ListenableFuture。这么做的原因是:必须等到所有的查询结果都返回后,才能返回最终的查询结果。
2.1 装饰者模式获得ListeningExecutorService。
2.2 ListenableFuture listenableFuture = pool.submit()获得 ListenableFuture。
2.3 Futures.addCallback()设置回调函数。
package com.uitl.TaskUtil;
import com.google.common.util.concurrent.*;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
public class MutiFutureTask {
private static final int PoolSize = 20;
//带有回调机制的线程池
private static final ListeningExecutorService pool= MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(PoolSize));
public static <T, V> List<V> batchExec(List<T> params, BatchFuture<T, V> batchFuture) {
if(CollectionUtils.isEmpty(params)){
return null;
}
final List<V> value = Collections.synchronizedList(new ArrayList<V>());
try{
List<ListenableFuture<V>> futures = new ArrayList<ListenableFuture<V>>();
for(T t : params){
//将实现了Callable的任务提交到线程池中,得到一个带有回调机制的ListenableFuture实例
ListenableFuture<V> sfuture = pool.submit(new SingleTask<T, V>(t, batchFuture));
Futures.addCallback(sfuture, new FutureCallback<V>() {
@Override
public void onSuccess(V result) {
value.add(result);
}
@Override
public void onFailure(Throwable t) {
throw new RuntimeException(t);
}
});
futures.add(sfuture);
}
ListenableFuture<List<V>> allAsList = Futures.allAsList(futures);
allAsList.get();
}catch(InterruptedException e){
e.printStackTrace();
}catch(ExecutionException e){
e.printStackTrace();
}
return value;
}
/**
*业务实现类
* @param <T>
* @param <V>
*/
private static class SingleTask<T, V> implements Callable<V> {
private T param;
private BatchFuture<T, V> batchFuture;
public SingleTask(T param, BatchFuture<T, V> batchFuture){
this.param = param;
this.batchFuture = batchFuture;
}
@Override
public V call() throws Exception {
return batchFuture.callback(param);
}
}
public interface BatchFuture<T,V>{
V callback(T param);
}
}
class MutiFutureTaskTest {
private static final Map<Integer,Person> persons = new HashMap<Integer,Person>();
static{
persons.put(1, new Person(1, "test1", 1, "aaa", 8888888888l));
persons.put(2, new Person(2, "test2", 2, "bbb", 8888888888l));
}
public static void main(String[] args) {
List<Integer> param = new ArrayList<Integer>();
param.add(1);
param.add(2);
param.add(3);
param.add(4);
param.add(5);
List<Person> result = MutiFutureTask.batchExec(param, new MutiFutureTask.BatchFuture<Integer, Person>() {
@Override
public Person callback(Integer param) {
return persons.get(param);
}
});
System.out.println(result.size());
}
}
转自 : https://blog.csdn.net/pistolove/article/details/53389646