回炉再造-线程池

为什么要用线程池：

其一、减少在创建和销毁线程上所花的时间以及系统资源的开销 。其二、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;    
}