1.线程池
众所周知创建大量线程时代价是非常大的：
- 线程的生命周期开销非常大：创建需要时间，导致延迟处理请求，jvm需要分配空间。
- 资源消耗:线程需要占用空间，如果线程数大于可用的处理器数量，那么线程就会闲置，这给Gc造成压力。线程在竞争cpu的时候也会造成性能开销,所以线程不是越多越好，使用不当并不会增加运行效率。
- 稳定性：使用不当会造成内存溢出。
继而就引申出线程池。
1.1线程池的创建
Executors框架：静态方法创建
newCachedThreadPool：创建可变线程数的线程池。有空闲的时候会回收。
newFixedThreadPool：创建固定线程数的线程池。
newScheduledThreadPool：创建固定数量线程池，以延时、定时的方式执行。
newSingleThreadExecutor：创建单线程线程池。
Executors框架：
生命周期：运行->关闭->已终止
Executor扩展了ExecutorSerivice接口。提供了平缓关闭接口的方法。调用shutdown方法后会拒绝新增任务，进入关闭状态。等待所有任务处理完进入已终止。showdownNow会立刻进入已终止。调用awaitTermination会立刻调用shutdown等待关闭后返回同步关闭状态。
2.callable和future
future异步返回线程计算结果。callable可以以泛型的形式显示定义返回异步返回类型。
下面介绍一个例子：
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
Thread.sleep(1000L);
//return the thread name executing this callable task
return Thread.currentThread().getName();
}
public static void main(String args[]){
//Get ExecutorService from Executors utility class, thread pool size is 10
ExecutorService executor = Executors.newFixedThreadPool(10);
//create a list to hold the Future object associated with Callable
Queue<Future<String>> list = new LinkedBlockingQueue<>();
//Create MyCallable instance
Callable<String> callable = new MyCallable();
for(int i=0; i< 100; i++){
//submit Callable tasks to be executed by thread pool
Future<String> future = executor.submit(callable);
//add Future to the list, we can get return value using Future
list.add(future);
}
while (true) {
Future fut = list.poll();
try {
if (fut.isDone()) {
//print the return value of Future, notice the output delay in console
// because Future.get() waits for task to get completed
System.out.println(new Date()+ "::"+fut.get());
} else {
list.add(fut);
}
} catch (InterruptedException | ExecutionException | CancellationException e ) {
e.printStackTrace();
}
}
}
}
其中，当任务执行完成，调用get会返回Exception。如果么有完成，那么进入阻塞状态直至返回。如果执行过程中抛出异常，Executors会封装成ExecutionException重新抛出，通过getCause获取原始异常。如果任务被取消，就会抛出CancellationException。
3.completionService
轮询的方式太低效，可以考虑completionService
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
Thread.sleep(1000L);
return Thread.currentThread().getName();
}
public static void main(String args[]){
//
ExecutorService executor = Executors.newFixedThreadPool(10);
ExecutorCompletionService<String> stringExecutorCompletionService = new ExecutorCompletionService<>(executor);
Queue<Future<String>> list = new LinkedBlockingQueue<>();
Callable<String> callable = new MyCallable();
for(int i=0; i< 100; i++){
Future<String> future = stringExecutorCompletionService.submit(callable);
list.add(future);
}
while (true) {
try {
Future<String> take = stringExecutorCompletionService.take();
String s = take.get();
System.out.println(s);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
}
// 待补充分析源码。
4.为线程的返回值设置时限。
Future.class
如果get超过等待时间讲抛出timeoutexception
