ThreadPoolExecutor线程池


1.ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler)
corePoolSize: 核心线程数，能够同时执行的任务数量
maximumPoolSize：除去缓冲队列中等待的任务，最大能容纳的任务数(其实是包括了核心线程池数量)
keepAliveTime：超出workQueue的等待任务的存活时间，就是指maximumPoolSize里面的等待任务的存活时间
unit：时间单位，TimeUnit枚举类型
workQueue:阻塞等待线程的队列，一般使用new LinkedBlockingQueue<Runnable>()这个，如果不指定容量，
          会一直往里边添加，没有限制,workQueue永远不会满；
threadFactory：创建线程的工厂，使用系统默认的类
handler：当任务数超过maximumPoolSize时，对任务的处理策略，默认策略是拒绝添加

执行流程：当线程数小于corePoolSize时，每添加一个任务，则立即开启线程执行
          当corePoolSize满的时候，后面添加的任务将放入缓冲队列workQueue等待；
            当workQueue也满的时候，看是否超过maximumPoolSize线程数，如果超过，默认拒绝执行
举例说明：
假如：corePoolSize=2，maximumPoolSize=3，workQueue容量为8;
      最开始，执行的任务A，B，此时corePoolSize已用完，再次执行任务C，则
       C将被放入缓冲队列workQueue中等待着，如果后来又添加了7个任务，此时workQueue已满，
       则后面再来的任务将会和maximumPoolSize比较，由于maximumPoolSize为3，所以只能容纳1个了，
       因为有2个在corePoolSize中运行了，所以后面来的任务默认都会被拒绝。

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* 对线程池的封装和管理

*

* @author Administrator

*

*/

public class ThreadPoolManager {

     private static ThreadPoolManager mIntance = new ThreadPoolManager();

    

     public static ThreadPoolManager getInstance(){return mIntance;}

     private int corePoolSize;//核心线程池的数量,能够同时执行的线程数量

     private int maximumPoolSize;//最大线程池的数量

     private long keepAliveTime = 1;//存活时间

     private TimeUnit unit = TimeUnit.HOURS;//时间单位

     private ThreadPoolExecutor executor;

    

     private ThreadPoolManager(){

          //对corePoolSize进行赋值,算法:当前设备的可用处理器核心数*2 + 1，能够让CPu的效率得到最大程度的发挥

          corePoolSize = Runtime.getRuntime().availableProcessors()*2 + 1;

          maximumPoolSize = corePoolSize;//虽然用不到，但是如果为0则会报错

          //线程池的机制：领工资机制

          executor = new ThreadPoolExecutor(

                    corePoolSize, //3

                    maximumPoolSize,//5，当缓冲队列也满的时候会放入最大线程池，但是它是包含了核心线程池数量的

                    keepAliveTime,

                    unit,

                    new LinkedBlockingQueue<Runnable>(), //超出核心线程池的任务将会放入缓冲队列等待着

                    Executors.defaultThreadFactory(), //创建线程的工厂

                    new ThreadPoolExecutor.AbortPolicy() //当最大线程池满的时候的处理策略，默认策略是拒绝添加执行

                    );

     }

     /**

     * 往线程池中添加任务

     * @param runnable

     */

     public void execute(Runnable runnable){

          if(runnable==null)return;

         

          executor.execute(runnable);

     }

     /**

     * 从线程池中移除任务

     * @param runnable

     */

     public void remove(Runnable runnable){

          if(runnable==null)return;

         

          executor.remove(runnable);

     }

}