概述
通常为了提供任务的处理速度,会使用一些并发模型，ThreadPoolExecutor中的invokeAll便是一种。
代码
package test.current;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
public class TestCallable {
public static void main(String[] args)
throws InterruptedException, ExecutionException {
List<Callable<List<Long>>> tasks =
new ArrayList<>();
for (
int i =
0; i <
10; i++) {
Callable<List<Long>> task =
new Callable<List<Long>>() {
@Override
public List<Long>
call()
throws Exception {
return Arrays.asList(
1L,
2L);
}
};
tasks.add(task);
}
List<Long> finalResults =
new ArrayList<>(
10);
List<Future<List<Long>>> results = ThreadPool.getThreadPool().invokeAll(tasks);
for(Future<List<Long>> ele : results) {
List<Long> list = ele.get();
finalResults.addAll(list);
}
System.out.println(finalResults);
}
}
package test.current;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPool {
private static final int CORE_SIZE =
8;
private static final int MAX_SIZE =
12;
private static final long KEEP_ALIVE_TIME =
30;
private static final int QUEUE_SIZE =
50000;
private static ThreadPoolExecutor threadPool =
new ThreadPoolExecutor(CORE_SIZE, MAX_SIZE, KEEP_ALIVE_TIME,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(QUEUE_SIZE),
new ThreadPoolExecutor.AbortPolicy());
public static ThreadPoolExecutor
getThreadPool() {
return threadPool;
}
}
可以把需要执行的任务创建一个Callable task,利用线程池中的线程并发的执行这些task,从而提高任务的执行效率。
Sam哥哥
认证博客专家
项目管理
团队管理
总结和思考
喜欢研究和思考关于管理、领导力，流程、文化、人、效率，沟通、成本、执行的东西，因为这些因素跟【能否把事情真正做好】强相关。
