回炉再造-线程池
为什么要用线程池：
其一、减少在创建和销毁线程上所花的时间以及系统资源的开销 。其二、2将当前任务与主线程隔离，能实现和主线程的异步执行，特别是很多可以分开重复执行的任务。但是，一味的开线程也不一定能带来性能上的，线池休眠也是要占用一定的内存空间，所以合理的选择线程池的大小也是有一定的依据。
一、Executors的API介绍
Java类库提供了许多静态方法来创建一个线程池：
a、newFixedThreadPool 创建一个固定长度的线程池，当到达线程最大数量时，线程池的规模将不再变化。
b、newCachedThreadPool 创建一个可缓存的线程池，如果当前线程池的规模超出了处理需求，将回收空的线程；当需求增加时，会增加线程数量；线程池规模无限制。
c、newSingleThreadPoolExecutor 创建一个单线程的Executor，确保任务对了，串行执行
d、newScheduledThreadPool 创建一个固定长度的线程池，而且以延迟或者定时的方式来执行，类似Timer；
小结一下：在线程池中执行任务比为每个任务分配一个线程优势更多，通过重用现有的线程而不是创建新线程，可以在处理多个请求时分摊线程创建和销毁产生的巨大的开销。当请求到达时，通常工作线程已经存在，提高了响应性；通过配置线程池的大小，可以创建足够多的线程使CPU达到忙碌状态，还可以防止线程太多耗尽计算机的资源。
二、几种executorService线程池对象
| 1.newCachedThreadPool() | -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中 -缓存型池子通常用于执行一些生存期很短的异步型任务 因此在一些面向连接的daemon型SERVER中用得不多。 -能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。 注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。 |
| 2.newFixedThreadPool | -newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 -其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子 -和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器 -从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同: fixed池线程数固定，并且是0秒IDLE（无IDLE） cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE |
| 3.ScheduledThreadPool | -调度型线程池 -这个池子里的线程可以按schedule依次delay执行，或周期执行 |
| 4.SingleThreadExecutor | -单例线程，任意时间池中只能有一个线程 -用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE） |
1.CachedThreadPool：
package com.xing.test; import java.util.Date; public class ThreadPool implements Runnable{ private String name; public ThreadPool(String name) { this.name = "thread"+name; } @Override public void run() { System.out.println( name +" Start. Time = "+new Date()); processCommand(); System.out.println( name +" End. Time = "+new Date()); } private void processCommand() { try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public String toString(){ return this.name; } } @Test public void CachedThreadPool(){ System.out.println(Thread.currentThread().getName()+"开始"); ExecutorService ctp = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { ctp.execute(new ThreadPool(String.valueOf(i))); } ctp.shutdown(); System.out.println(Thread.currentThread().getName()+"结束");
从运行结果可以看出来，主线程结束了但是线程池还在运行，放入线程池中的线程不一定会按照放入的顺序执行。
注意：这里有execute方法也有submit方法可以执行一个线程任务，那么二者有什么不同呢：
1.我个人简单的理解是execute没有返回值，但是submit提交一个任务进行执行并返回一个表示该任务的 Future。该 Future 的 get 方法在成功完成时将会返回给定的结果。
2.submit的源码实现是调用了execute方法的，所以执行一个线程不需要结果的话直接用execute会拥有更高的性能。submit中的线程要实现接口Callable
2.FixedThreadPool：
FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。规定数目的线程处理所有任务，一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。这种模式与上面的CachedThreadPool是不同的，CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。而FixedThreadPool模式下最多 的线程数目是一定的。
代码实例：
@Test public void FixedThreadPool(){ System.out.println("Main Thread: Starting at: "+ new Date()); ExecutorService exec = Executors.newFixedThreadPool(5); for(int i = 0; i < 10; i++) { exec.execute(new ThreadPool(String.valueOf(i))); // exec.submit(new ThreadPool(String.valueOf(i))); } exec.shutdown(); //执行到此处并不会马上关闭线程池 System.out.println("Main Thread: Finished at:"+ new Date()); }
上面创建了一个固定大小的线程池，大小为5.也就说同一时刻最多只有5个线程能运行。并且线程执行完成后就从线程池中移出。它也不能保证放入的线程能按顺序执行。这要看在等待运行的线程的竞争状态了。
3、newSingleThreadExecutor：
其实这个就是创建只能运行一条线程的线程池。它能保证线程的先后顺序执行，并且能保证一条线程执行完成后才开启另一条新的线程
代码实例：
@Test public void FixedThreadPool(){ System.out.println("Main Thread: Starting at: "+ new Date()); ExecutorService exec = Executors.newSingleThreadExecutor(); //创建大小为1的固定线程池 for(int i = 0; i < 10; i++) { exec.execute(new ThreadPool(String.valueOf(i))); } exec.shutdown(); //执行到此处并不会马上关闭线程池 System.out.println("Main Thread: Finished at:"+ new Date()); }
等价于Executors.newFixedThreadExecutor(1) ;
4、newScheduledThreadPool:
这是一个计划线程池类，它能设置线程执行的先后间隔及执行时间等，功能比上面的三个强大了一些
代码实例：
@Test public void ScheduledThreadPoolExector(){ System.out.println("Main Thread: Starting at: "+ new Date()); ScheduledThreadPoolExecutor exec = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10); //创建大小为10的线程池 for(int i = 0; i < 10; i++) { exec.schedule(new ThreadPool(String.valueOf(i)), 1, TimeUnit.SECONDS);//延迟1秒执行 } exec.shutdown(); //执行到此处并不会马上关闭线程池 while(!exec.isTerminated()){ //wait for all tasks to finish } System.out.println("Main Thread: Finished at:"+ new Date()); }
每个放进线程池的线程都会延迟1秒执行
下面实现每隔2秒执行一次，注意，如果上次的线程还没有执行完成，那么会阻塞下一个线程的执行。即使线程池设置得足够大。
/** * 初始化延迟0ms开始执行，每隔2000ms重新执行一次任务 * @author linbingwen * @since 2016年6月6日 */ public static void executeFixedRate() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(10); executor.scheduleAtFixedRate( new MyHandle(), 0, 2000, TimeUnit.MILLISECONDS); }
间隔指的是连续两次任务开始执行的间隔。对于scheduleAtFixedRate方法，当执行任务的时间大于我们指定的间隔时间时，它并不会在指定间隔时开辟一个新的线程并发执行这个任务。而是等待该线程执行完毕。
/** * 以固定延迟时间进行执行 * 本次任务执行完成后，需要延迟设定的延迟时间，才会执行新的任务 */ public static void executeFixedDelay() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(10); executor.scheduleWithFixedDelay( new MyHandle(), 0, 2000, TimeUnit.MILLISECONDS); }
间隔指的是连续上次执行完成和下次开始执行之间的间隔。
周期性的执行一个任务，可以使用下面方法设定每天在固定时间执行一次任务
/** * 每天晚上9点执行一次 * 每天定时安排任务进行执行 */ public static void executeEightAtNightPerDay() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); long oneDay = 24 * 60 * 60 * 1000; long initDelay = getTimeMillis("21:00:00") - System.currentTimeMillis(); initDelay = initDelay > 0 ? initDelay : oneDay + initDelay; executor.scheduleAtFixedRate( new MyHandle(), initDelay, oneDay, TimeUnit.MILLISECONDS); } /** * 获取指定时间对应的毫秒数 * @param time "HH:mm:ss" * @return */ private static long getTimeMillis(String time) { try { DateFormat dateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss"); DateFormat dayFormat = new SimpleDateFormat("yy-MM-dd"); Date curDate = dateFormat.parse(dayFormat.format(new Date()) + " " + time); return curDate.getTime(); } catch (ParseException e) { e.printStackTrace(); } return 0; }
