执行异步任务的时候，如果只是new Thread，存在一下弊端

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。

Java本身提供了四种线程池

newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智
能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于
操作系统（或者说JVM）能够创建的最大线程大小。

newCachedThreadPool是存在内存溢出安全隐患的，因为我们假设新建的线程都在工
作，newCachedThreadPool 只会重用空闲并且可用的线程，所以当所需线程数量足够大
时，会不停地创建新线程，在 64-bit JDK 1.7 中 -Xss 默认是 1024k，也就是 1M（一个线
程占用的空间大小），那就是需要 10000*1M = 10G 的堆外内存空间来给线程使用，就 会
发生OOM 

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
      final int index = i;
try {
      Thread.sleep(index * 1000);
} catch (InterruptedException e) {
      e.printStackTrace();
}
 
cachedThreadPool.execute(new Runnable() {
      @Override
      public void run() {
            System.out.println(index);
      }
});

newFixedThreadPool 
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
      final int index = i;
      fixedThreadPool.execute(new Runnable() {
 
            @Override
            public void run() {
            try {
                  System.out.println(index);
                  Thread.sleep(2000);
            } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            }
      }
});

newScheduledThreadPool 
创建一个定长线程池，支持定时及周期性任务执行

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
      @Override
      public void run() {
            System.out.println("delay 3 seconds");
      }
}, 3, TimeUnit.SECONDS);

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
      @Override
      public void run() {
            System.out.println("delay 1 seconds, and excute every 3 seconds");
      }
}, 1, 3, TimeUnit.SECONDS);

newSingleThreadExecutor 
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
      final int index = i;
      singleThreadExecutor.execute(new Runnable() {
            @Override
            public void run() {
            try {
                  System.out.println(index);
                  Thread.sleep(2000);
            } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            }
      }
});

相对于直接new Thread,线程池具有一下优点

a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能