java线程池解析和四种线程池的使用

1、概述

线程池，是指管理一组同构工作线程的资源池。

线程池是与工作队列（Work Queue）密切相关的，其中在工作队列中保存了所有等待的任务。工作者线程（Worker Thread）的任务很简单：从工作队列中获取一个任务，执行任务，然后返回线程池，并等待下一个任务。

“在线程池中执行任务” 比“为每个任务分配一个线程”优势更多。通过重用现有的线程而不是创建新线程，可以在处理多个请求时分摊在线程创建和销毁过程中，产生的巨大开销。另一个额外的好处是，当请求到达时，工作线程通常已经存在，因此不会由于等待创建线程而延迟任务的执行，从而提高了响应性。通过适当调整线程池的大小，可以创建足够多的线程以便使处理器保持忙碌状态，同时还可以防止过多线程相互竞争资源而使应用程序耗尽内存而失败。

2、线程池相关介绍

（1）线程池使用场景

• 单个任务处理时间比较短；
• 需处理的任务的数量大。

（2）线程池的优势

• 减少在创建和销毁过程上所花的时间以及系统资源的开销；
• 如果不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及“过渡切换”。

（3）线程数量

线程不是越多越好，Google给了一个推荐值：
线程个数=CPU核心数+1

（4）线程创建过程

线程首先根据corePoolSize核心池大小，创建线程，如果核心池中线程数量满了，将线程放入工作队列（workQueue）中，如果工作对列中也满了，再放入存储Thread的集合，线程小于最大池大小，如果超过了，则报出异常。

（5）控制一个方法的并发量
比如，同时只能5个多线程进来。

不控制数量，100个线程同时进来，100个线程同时出去：

public class TestThreadPool {    public static void main(String[] args) {        for(int i = 0;i < 100;i ++) {            new Thread(new Runnable() {                 @Override                public void run() {                    method();                }            }).start();        }    }    private static void method() {        System.out.println("Thread Name:" +     Thread.currentThread().getName() + "过来了");        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("Thread Name:" +     Thread.currentThread().getName() + "出去了");    }}

通过Semaphore控制线程并发量，每进来一个线程，加一把锁，结束一个线程，释放一把锁：

public class TestThreadPool {    private static Semaphore semaphore = new Semaphore(5);    public static void main(String[] args) {        for(int i = 0;i < 100;i ++) {            new Thread(new Runnable() {                 @Override                public void run() {                    method();                }            }).start();        }    }    private static void method() {        try {            semaphore.acquire();        } catch (InterruptedException e1) {            // TODO Auto-generated catch block            e1.printStackTrace();        }        System.out.println("Thread Name:" +     Thread.currentThread().getName() + "过来了");        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("Thread Name:" +     Thread.currentThread().getName() + "出去了");        semaphore.release();    }}

（6）ThreadPoolExecutor类

ThreadPoolExecutor构造器

public class ThreadPoolExecutor extends AbstractExecutorService {    .....    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue);    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);    ...}

各个参数含义：

• corePoolSize：核心池的大小。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；

• maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

• unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天TimeUnit.HOURS;             //小时TimeUnit.MINUTES;           //分钟TimeUnit.SECONDS;           //秒TimeUnit.MILLISECONDS;      //毫秒TimeUnit.MICROSECONDS;      //微妙TimeUnit.NANOSECONDS;       //纳秒

• workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue; //基于数组的先进先出队列，此队列创建时必须指定大小；LinkedBlockingQueue;    //基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；SynchronousQueue;   //这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

• threadFactory：线程工厂，主要用来创建线程；

• handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 

3、java四种自带线程池

（1）newFixedThreadPool

newFixedThreadPool创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

代码示例：

package test;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  public class ThreadPoolExecutorTest {   public static void main(String[] args) {    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);    for (int i = 0; i < 10; i++) {     final int index = i;     fixedThreadPool.execute(new Runnable() {      public void run() {       try {        System.out.println(index);        Thread.sleep(2000);       } catch (InterruptedException e) {        e.printStackTrace();       }      }     });    }   }  }  

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

（2）newCachedThreadPool

newCachedThreadPool创建一个可缓存的线程池。这种类型的线程池特点是：
1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

代码示例：

package test;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  public class ThreadPoolExecutorTest {   public static void main(String[] args) {    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() {      public void run() {       System.out.println(index);      }     });    }   }  }  

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

（3）newSingleThreadExecutor

newSingleThreadExecutor创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的 。

示例代码：

package test;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  public class ThreadPoolExecutorTest {   public static void main(String[] args) {    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();    for (int i = 0; i < 10; i++) {     final int index = i;     singleThreadExecutor.execute(new Runnable() {      public void run() {       try {        System.out.println(index);        Thread.sleep(2000);       } catch (InterruptedException e) {        e.printStackTrace();       }      }     });    }   }  }  

结果依次输出，相当于顺序执行各个任务。

（4）newScheduleThreadPool

newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。

package test;  import java.util.concurrent.Executors;  import java.util.concurrent.ScheduledExecutorService;  import java.util.concurrent.TimeUnit;  public class ThreadPoolExecutorTest {   public static void main(String[] args) {    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);    scheduledThreadPool.schedule(new Runnable() {     public void run() {      System.out.println("delay 3 seconds");     }    }, 3, TimeUnit.SECONDS);   }  }  

表示延迟3秒执行。

（5）总结

一.FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

二．CachedThreadPool的特点就是在线程池空闲时，即线程池中没有可运行任务时，它会释放工作线程，从而释放工作线程所占用的资源。但是，但当出现新任务时，又要创建一新的工作线程，又要一定的系统开销。并且，在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

三.SingleThreadExecutor单一线程，顺序执行，会序列化所有提交给它的任务，并维护它自己隐藏的悬挂任务队列。用于更新远程日志，操作文件系统，Socket监听接口。

四.newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行。