多线程——newCachedThreadPool线程池

newCachedThreadPool线程池：

理解：

　　1).newCachedThreadPool可以创建一个无限大小的线程池(实际上是一个可缓存线程池)。

    　　可以通过Executors的静态方法创建线程池：

    　　　　public static ExecutorService newCachedThreadPool() 或者

    　　　　 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) 。

　　2).返回的是ExecutorService对象线程池。

　　3).newCachedThreadPool在执行过程中通常会创建与所需数量相同的线程，然后在它回收旧线程时停止创建新线程，因此它是合理的Executor的首选。

  　　 只有当这种方式会引发问题时(内存溢出)，你才需要切换到newFixedThreadPool()。

　　4).无限制不代表不可以复用线程，假设说一开始进来10个任务，启动了10个线程，10个任务结束后，然后又来了5个任务(线程还没被回收)，

    　　这时候会复用之前的线程，不会新起线程，这就达到了使用“线程池”的意义。

使用场景：
　　1. 耗时较短的任务。
　　2. 任务处理速度 > 任务提交速度 ，这样才能保证不会不断创建新的进程，避免内存被占满。

//首先看Executors中通过newCachedThreadPool创建线程池的方法的源码
//此方法是通过new一个ThreadPoolExecutor来创建的
//这个构造方法有5个参数：
//第一个参数corePoolSize(核心池大小)为0，
//第二个参数maximumPoolSize(最大线程池大小)为Integer.MAX_VALUE无限大，源码中是：public static final int   MAX_VALUE = 0x7fffffff;
//第三个参数keepAliveTime(线程存货的时间)是60秒，意味着线程空闲时间超过60秒就会被杀死。
//第五个参数采用SynchronousQueue装等待的任务，这个阻塞队列没有存储空间，这意味着只要有请求到来，就必须要找到一条工作线程处理他，
//    如果当前没有空闲的线程，那么就会再创建一条新的线程。
public class Executors {   
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
}

//ThreadPoolExecutor类中此构造函数源码：
public class ThreadPoolExecutor extends AbstractExecutorService {
      public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), defaultHandler);
    }
}

下面是Thinking in java书中的例子：

public class LiftOff implements Runnable {
    protected int countDown = 5;
    private static int taskCount = 0;
    private final int id = taskCount++;

    public LiftOff() {
    }

    public LiftOff(int countDown) {
        this.countDown = countDown;
    }

    public String status() {
        return "# " + id + " ( " + (countDown > 0 ? countDown : "LiftOff !") + " )";
    }

    @Override
    public void run() {
        while (countDown-- > 0) {
            System.out.println(status());
            Thread.yield();
        }
    }
}

public class CachedThreadPool {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            executorService.execute(new LiftOff());
        }
    }
}
结果：
# 2 ( 4 )
# 0 ( 4 )
# 1 ( 4 )
# 2 ( 3 )
# 0 ( 3 )
# 2 ( 2 )
# 1 ( 3 )
# 2 ( 1 )
# 0 ( 2 )
# 2 ( LiftOff ! )
# 1 ( 2 )
# 0 ( 1 )
# 1 ( 1 )
# 0 ( LiftOff ! )
# 1 ( LiftOff ! )