ExecutorService 线程池及 Callable, Future, CompletableFuture

ExecutorService java.util.concurrent.Executors.newCachedThreadPool()

返回的是java.util.concurrent.ThreadPoolExecutor对象。

java.util.concurrent.ThreadPoolExecutor

类。用于接收提交的任务，放到线程池中运行。

java.util.concurrent.ThreadPoolExecutor.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

构造函数。

corePoolSize:最小线程数。一般会取Runtime.getRuntime().availableProcessors()。
maximumPoolSize：任务变多时，最大线程数。一般会取corePoolSize*20.
keepAliveTime：多开的线程用完后，等待一定时间再被回收。
unit：时间单位。
workQueue：当线程池已满，新任务不能立即执行的时候，就会放进此等待队列。
threadFactory：创建线程的工厂。
java.util.concurrent.ThreadPoolExecutor.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

ThreadPoolExecutor构造函数的重载。

 long java.util.concurrent.ThreadPoolExecutor.getCompletedTaskCount()
返回执行完毕的任务数，是近似值。
 long java.util.concurrent.ThreadPoolExecutor.getTaskCount()
返回加入执行计划的所有任务总数，是近似值。
 int java.util.concurrent.ThreadPoolExecutor.getActiveCount()
 返回正在执行任务的的活动状态的线程数，是近似值。

java.util.concurrent.ThreadFactory
接口，它只有下面一个方法：
Thread java.util.concurrent.ThreadFactory.newThread(Runnable r)
生成Thread并返回。

2.2 ScheduledThreadPoolExecutor

java.util.concurrent.ScheduledThreadPoolExecutor.ScheduledThreadPoolExecutor(int corePoolSize)
构造函数，创建“计划线程池执行器”。此类为ExecutorService的实现类。

ScheduledFuture<?> java.util.concurrent.ScheduledExecutorService.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
开辟新线程执行任务。延迟initialDelay时间后开始执行command，并且按照period时间周期性重复调用，并且保证在上次运行完后才会执行下一次，周期时间不包括command运行时间。

ScheduledFuture<?> java.util.concurrent.ScheduledExecutorService.scheduleAtFixedRate(Runnable command, long initialDelay, long delay, TimeUnit unit)

延迟initialDelay时间后开始执行command，并且按照period时间周期性重复调用。周期时间包括command运行时间，如果周期时间比command运行时间短，则command运行完毕后，立刻重复运行。

任务中抛出未被捕获的异常不会造成线程池的线程消失。线程池对此做了保护机制。查看jdk源码可以找到这部分代码。

3. 例子

//: concurrency/CallableDemo.java
import java.util.concurrent.*;
import java.util.*;

class TaskWithResult implements Callable {
  private int id;
  public TaskWithResult(int id) {
    this.id = id;
  }
  public String call() throws InterruptedException {
	  TimeUnit.SECONDS.sleep(2);
    return "result of TaskWithResult " + id;
  }
}

public class CallableDemo {
  public static void main(String[] args) {
    ExecutorService exec = Executors.newCachedThreadPool();
    ArrayList> results =
      new ArrayList>();
    for(int i = 0; i < 5; i++)
      results.add(exec.submit(new TaskWithResult(i)));
    for(Future fs : results)
      try {
        // get() blocks until completion:
    	System.out.println(fs.isDone());
        System.out.println(fs.get());
      } catch(InterruptedException e) {
        System.out.println(e);
        return;
      } catch(ExecutionException e) {
        System.out.println(e);
      } finally {
        exec.shutdown();
      }
  }
} /* Output:
false
result of TaskWithResult 0
true
result of TaskWithResult 1
true
result of TaskWithResult 2
true
result of TaskWithResult 3
true
result of TaskWithResult 4
*/
 

4.任务超载