ThreadPoolExecutor

　　　使用Java自带的线程池，一般都是如下的使用：

ExecutorService exec = Executors.newCachedThreadPool(); //will create one thread for each task 
        for(int i=0;i<7;i++){
            exec.execute(new BasicThread());
        }
        exec.shutdown();

　　一般使用newFixedThreadPool、newSingleThreadExecutor或者newCachedThreadPool来创建不同类型的线程池。

　　下面看看这几个方法的源代码：　　

public static ExecutorService newFixedThreadPool(int nThreads) {  
        return new ThreadPoolExecutor(nThreads, nThreads,  
                                      0L, TimeUnit.MILLISECONDS,  
                                      new LinkedBlockingQueue<Runnable>());  
    }  

public static ExecutorService newSingleThreadExecutor() {  
        return new FinalizableDelegatedExecutorService  
            (new ThreadPoolExecutor(1, 1,  
                                    0L, TimeUnit.MILLISECONDS,  
                                    new LinkedBlockingQueue<Runnable>()));  
    } 

public static ExecutorService newCachedThreadPool() {  
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
                                      60L, TimeUnit.SECONDS,  
                                      new SynchronousQueue<Runnable>());  
    }  

　　底层用到的都是ThreadPoolExecutor，但是实现的方法是不太一样的。我们可以直接使用ThreadPoolExecutor来实现各种不同的线程池。

 

　　线程池的基本原理其实也很简单，无非预先启动一些线程(Worker)，线程进入死循环状态，每次从任务队列中获取一个任务进行执行，直到线程池被关闭。可以看看Worker源码了解其实现。

　　ThreadPoolExecutor的构造方法如下：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) 

　　其中的workQueue和handler是实现不同功能线程池的关键。

　　在看workQueue和handler先看看其他参数的含义：

　　* corePoolSize - 池中所保存的线程数，包括空闲线程。 

　   * maximumPoolSize - 池中允许的最大线程数(采用LinkedBlockingQueue时没有作用)。

       * keepAliveTime -当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间，线程池维护线程所允许的空闲时间。

       * unit - keepAliveTime参数的时间单位，线程池维护线程所允许的空闲时间的单位:秒 。

       * workQueue - 执行前用于保持任务的队列（缓冲队列）。此队列仅保持由execute 方法提交的 Runnable 任务。

       * RejectedExecutionHandler -线程池对拒绝任务的处理策略(重试添加当前的任务，自动重复调用execute()方法)

　　

　　当一个任务通过execute(Runnable)方法欲添加到线程池时：

•      * 1.如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
•      * 2.如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
•      * 3.如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
•      * 4.如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过
•      * handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize
•      * ，如果三者都满了，使用handler处理被拒绝的任务。
•      * 5.当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

 

　　看workQueue和handler之前先看一下ThreadFactory，当我们希望为线程池中的每个线程进行命名时，可以采用ThreadFactory来完成。　

package multiThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolExecutorTest {

 public static void main(String[] args) {
  ExecutorService es = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new MSGThreadFactory());
  for (int i = 0; i < 10; i++) {
   Thread f = new Thread(new Runnable() {
    public void run() {
     try {
      Thread.sleep(10000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
   // f.setName("test multi-thread" + i); useless
   es.execute(f);
  }
  es.shutdown();
 }
}

// 在debug模式下可以看到线程已经被命名
class MSGThreadFactory implements ThreadFactory {
 static final AtomicInteger poolNumber = new AtomicInteger(1);
 final ThreadGroup group;
 final AtomicInteger threadNumber = new AtomicInteger(1);
 final String namePrefix;

 MSGThreadFactory() {
  SecurityManager s = System.getSecurityManager();
  group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
  namePrefix = "MSG-ReportAnalyse-pool-" + poolNumber.getAndIncrement() + "-thread-";
 }

 public Thread newThread(Runnable r) {
  Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
  if (t.isDaemon())
   t.setDaemon(false);
  if (t.getPriority() != Thread.NORM_PRIORITY)
   t.setPriority(Thread.NORM_PRIORITY);
  return t;
 }
}

 

　　下面是几种类型的workQueue的使用方法：

　　SynchronousQueue，直接提交队列：

　　该Queue类型，每个插入操作必须等待另一个线程的对应移除操作。比如，先添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然。就是缓冲区为1的生产者消费者模式。

　　newCachedThreadPool中的等待队列就是SynchronousQueue类型的。

　　使用SynchronousQueue时通常设置很大的maximumPoolSize值，否则很容易执行RejectedExecutionHandler。使用newCachedThreadPool同时提交大量的任务，会产生等数量的线程，可能会耗尽系统资源。

 

       ArrayBlockingQuene，有界的队列：

　　使用 ArrayBlockingQuene(int capacity)来制定等待队列的最大长度，等待队列被填满时，将执行RejectedExecutionHandler。

 

　　LinkedBlockingQuene，无界队列：

　　使用LinkedBlockingQuene()，除非系统资源耗尽，否则新任务将一直被插入到等待队列中。newFixedThreadPool、newSingleThreadExecutor使用的都是LinkedBlockingQuene。

 

　　PriorityBlockingQuene，优先任务队列：

　　前面的队列都是先进先出的，使用PriorityBlockingQuene可以自己定义任务的优先级，高优先级的任务将被先执行。任务继承自Runnable,Comprable接口，在compareTo()方法定义任务优先级的比较方式。实现的线程池将按照任务的的优先级来进行处理。

 

　　下面是拒绝策略RejectedExecutionHandler的分类：

　　CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

　　AbortPolicy：处理程序遭到拒绝将抛出运行时 RejectedExecutionException。

　　DiscardPolicy：不能执行的任务将被删除。

　　DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

 　　

　　要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：

1. 任务的性质：CPU密集型任务，IO密集型任务和混合型任务。
2. 任务的优先级：高，中和低。
3. 任务的执行时间：长，中和短。
4. 任务的依赖性：是否依赖其他系统资源，如数据库连接。

　　任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能少的线程数量，如配置N_cpu+1个线程的线程池。IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2*N_cpu。混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

 

　　优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

　　执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。

　　依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，如果等待的时间越长CPU空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用CPU。