• 简介

　　为了给并发程序开发提供更好的支持，java不仅提供了Thread类、Runnable接口等简单的多线程支持工具，还提供了用于多线程管理的线程池，用于提高并发程序的性能。

• 无限制线程的缺陷

　　多线程的软件设计方法确实可以提高多核处理器的计算能力，提高系统的性能和吞吐量，但是如果不加限制的使用多线程，对于系统性能不仅不能提升，反而会下降产生不利影响。

　　简单的线程创建方法new Thread().start()，通过thread来启动线程，并且由系统自动的回收线程。在简单的系统这样做并没有问题，但是在真实的生产系统中，在某一时刻会有大量的请求，这样就需要为每一个请求创建一个线程，而当线程数量过大时，会耗尽CPU和内存资源。

　　虽然线程是一种轻量级的工具，但是其创建和销毁也需要消耗一定的时间；其次，线程本身也是需要占用内存空间的，大量的线程会抢占内存只有，导致Out of memory异常，并且大量线程的回收会给GC带来很大压力，延长GC停顿的时间。

　　因此，对线程的使用必须控制一个度，在适当的范围内使用会提供系统性能，但是，一旦超过了这个范围，大量的线程就会拖垮整个系统。在生产环境下，必须要对其进行管理和控制。

• 简单线程池的实现

　　前面介绍在多线程中不断的创建和销毁线程会带来额外的开销，这样就需要引入一种线程复用机制，即线程池。线程池的基本功能就是进行线程复用，当系统接受一个提交的任务，需要一个线程时，并不急于去创建一个线程，而是去现场池中寻找，是否有闲置的线程，若有，直接使用线程池中的线程工作，如没有，再去创建新的线程。待任务完成后，也不是简单的销毁线程，而是将线程放回线程池中，以便下次复用。

　　上面已经把线程池实现的原理简单说明了一下，下面我们自己实现一个线程，来了解一下线程池实现的核心功能，有助于理解线程池的实现。

　　线程池实现代码：

1 public class ThreadPool { 2     private static ThreadPool instance = null; 3     //空闲线程队列 4     private List
     
       idelThreads; 5     //已有的线程总数 6     private int threadCounter; 7     private boolean isShutdown = false; 8      9     public ThreadPool() {10         idelThreads = new Vector
      
       (5);11         threadCounter=0;12     }13 14     public synchronized int getCreatedThreadsCount() {15         16         return threadCounter;17     }18     19     //取得线程池实例20     public synchronized static ThreadPool getInstatce(){21         if(instance==null){22             instance = new ThreadPool();23         }24         return instance;25     }26     27     //把线程重新放回到池中28     29     public synchronized void repool(PThread repoolThread){30         if(!isShutdown){31             idelThreads.add(repoolThread);32         }else{33             repoolThread.shutdown();34         }35     }36     37     //停止池中所有线程38     public synchronized void shutdown(){39         isShutdown = true;40         for (int i = 0; i < idelThreads.size(); i++) {41             PThread pthread = idelThreads.get(i);42             pthread.shutdown();43         }44     }45     //执行任务46     public synchronized void start(Runnable target){47         PThread pthread = null;48         //如果有闲置线程49         if(idelThreads.size()>0){50             int index = idelThreads.size()-1;51             pthread=idelThreads.get(index);52             idelThreads.remove(index);53             pthread.setTarget(target);54         }else{
   //如果没有闲置线程55             threadCounter++;56             PThread p = new PThread(instance, target, "PThread#"+threadCounter);57             p.start();58         }59     }60     61     62     63 }
      
     

　　从代码中可以看出，线程池中有一个闲置线程的队列，在执行任务时，如果有闲置线程，则从线程池中取线程执行任务，如果没有现在线程，则创建新的线程，并且在现场使用完毕后，会将线程重新放回到闲置线程队列中。

　　另外，线程池的使用还需要一个永不退出的线程的配合使用，该线程在手动关闭前永不结束，并且一直等待新任务的到来。代码如下：

1 public class PThread extends Thread{ 2     //线程池 3     private ThreadPool pool; 4     //任务 5     private Runnable target; 6     private boolean isShutDown = false; 7     private boolean isIdle = false; 8     public PThread(ThreadPool pool, Runnable target,String name) { 9         super(name);10         this.pool = pool;11         this.target = target;12     }13     14     public synchronized Runnable getTarget() {15         return target;16     }17     public synchronized boolean isIdle() {18         return isIdle;19     }20 21     @Override22     public void run() {23         24         while(!isShutDown){25             isIdle = false;26             27             if(target!=null){28                 //运行任务29                 target.run();30             }31             //任务结束，闲置任务32             isIdle=true;33             34             try {35                 pool.repool(this);36                 synchronized (this) {37                     //线程闲置，等待任务到来38                     wait();39                 }40             } catch (Exception e) {41                 // TODO: handle exception42             }43             44             isIdle=false;45         }46     47     }48     49     public synchronized void setTarget(Runnable target){50         this.target=target;51         //设置任务之后，通知run方法，开始执行52         notifyAll();53     }54     55     public synchronized void shutdown(){56         isShutDown=true;57         notifyAll();58     }59     60     61 }

　　执行线程：

1 public class MyThread implements Runnable{ 2      3      4     private String name; 5      6      7      8     public MyThread() { 9         10     }11 12 13     public MyThread(String name) {14         this.name = name;15     }16 17 18     @Override19     public void run() {20         // TODO Auto-generated method stub21         try {22             Thread.sleep(1000);23         } catch (InterruptedException e) {24             // TODO Auto-generated catch block25             e.printStackTrace();26         }27     }28     29 }

　　测试代码：

1 public class TestClient { 2     public static void main(String[] args) { 3          4         ExecutorService executor = Executors.newCachedThreadPool(); 5          6         long begin = System.currentTimeMillis(); 7          8         for (int i = 0; i < 1000; i++) { 9             //new Thread(new MyThread("testnopoolThread"+i)).start();10             11             ThreadPool.getInstatce().start(new MyThread("testpoolThread"+i));12             13             //executor.execute(new MyThread("executorpoolThread"+i));14         }15         16         System.out.println(System.currentTimeMillis()-begin);17     18     }19 }

 　　线程池能减少线程频繁调度的开销，线程的复用，对系统性能的提升效果比较明显。

• Executor框架

　　JDK提供了一整套的Executor框架，帮助开发人员有效的进行线程控制。ThreadPoolExecutor表示一个线程池，Executors类扮演着线程池工厂的角色，通过Executor可以取得一个特定功能的线程池。

　　newFixedThreadPool():该方法返回一个固定线程数量的线程池，该线程池中线程的数量始终保持不变。当一个任务提交后，线程池中若有空闲线程则立即执行，若没有，新任务会被保存在一个任务队列中，待有现车空闲时，便处理任务队列中的任务。

　　newSingleThreadExecutor():该方法返回只有一个线程的线程池。若多余的任务被提交到该线程池，任务会被保存到一个任务队列中，若线程空闲，按先进先出的顺序执行队列中的任务。

　　newCacheThreadPool()：该方法返回一个根据实际情况调整线程数量的线程池。若有空闲线程可以复用，则优先选择使用可复用的线程，否则，创建新的线程处理新任务。

　　newSingleThreadScheduledExecutor()方法：该方法返回一个ScheduledExecutorService对象，线程池大小为1，在给定时间内执行某一任务。

• 自定义线程池

　　newFixedThreadPool、newSingleThreadExecutor、newCacheThreadPool的内部实现都实现了ThreadPoolExecutor。在ThreadPoolExecutor中有一个最主要的构造函数：

1 public ThreadPoolExecutor(int corePoolSize, 2                               int maximumPoolSize, 3                               long keepAliveTime, 4                               TimeUnit unit, 5                               BlockingQueue
     
       workQueue, 6                               ThreadFactory threadFactory, 7                               RejectedExecutionHandler handler) { 8         if (corePoolSize < 0 || 9             maximumPoolSize <= 0 ||10             maximumPoolSize < corePoolSize ||11             keepAliveTime < 0)12             throw new IllegalArgumentException();13         if (workQueue == null || threadFactory == null || handler == null)14             throw new NullPointerException();15         this.corePoolSize = corePoolSize;16         this.maximumPoolSize = maximumPoolSize;17         this.workQueue = workQueue;18         this.keepAliveTime = unit.toNanos(keepAliveTime);19         this.threadFactory = threadFactory;20         this.handler = handler;21     }
     

　　corePoolSize：线程池中核心线程的数量；

　　maximumPoolSize：线程池中最大线程的数量；

　　keepAliveTime：当线程池中的线程数量超过corePoolSize时，多余的空闲线程的存活时间；

　　unit：keepAliveTime的单位；

　　workQueue：任务队列，提交但是尚未执行的任务；

　　threadFactory：线程工厂，用于创建线程；

　　hander:拒绝策略，当任务太多时，怎么拒绝任务。

　　主要来介绍下workQueue和hander：

　　workQueue任务队列，提交但是尚未执行的任务，主要由以下几种实现方式：

　　直接提交的队列：该功能由SynchronousQueue对象提供。SynchronousQueue是一个特殊的BlockingQueue,它没有容量，每当插入操作都要等待响应的删除操作，反之，每当删除操作斗鱼等待线程插入操作。它不保证任务，总是将任务提交给线程来执行，如果没有空闲线程，则创建新的线程，当线程数达到最大数值时，则执行拒绝策略。因此，如果使用SynchronousQueue，通常会设置很大的maximumPoolSize，否则很容易执行拒绝策略。

　　有界任务队列：当使用有界任务队列，若有新的任务需要执行，如果线程池的实际线程数小于corePoolSize，则会创建新的线程，若大于corePoolSize，则将新任务加入到等待队列中，若任务队列已满，无法加入，则在总数不大于maximumPoolSize的前提下，创建新的线程执行。若大于maximumPoolSize，则执行拒绝策略。如ArrayBlockingQueue队列。

　　无界任务队列：于有界任务队列相比，除非耗尽系统资源，否则不会出现任务放入任务队列失败的情况。当有新的任务到来时，系统的线程数小于corePoolSize，线程池就会产生新的线程执行任务。当系统的线程数达到corePoolSize，就不再增加。如后续仍有新的任务产生，但是没有空闲的线程资源，那么线程进入任务队列进行等待。如：LinkedBlockingQueue队列。

　　优先任务队列：优先任务队列是带有执行优先级的队列。可以控制任务的执行顺序，是一个特殊的无界队列。如PriorityBlockingQueue队列。PriorityBlockingQueue可以根据任务自身的优先级顺序先后执行，在确保系统性能的同时，也能有很好的质量保证。线程要实现comparable接口。

　　hander是线程池的拒绝策略：

　　JDK内置的拒绝策略如下：

　　AbortPolicy策略:该策略会直接抛出异常，阻止系统的正常工作。

　　CallerRunsPolicy策略：只要线程池未关系，该策略直接在调用者线程中，运行当前被丢弃的任务。

　　DiscardOledestPolicy策略：该策略将丢弃最老的一个请求，尝试再次执行提交当前任务。

　　DiscardPolicy策略：该策略丢弃无法处理的任务，不予以任何处理。

　　在JDK所提供的线程池不能满足需求的时候，可以考虑实现自定义的线程池，自定义的线程池可以提供更为灵活的任务处理和调度方式。

• 扩展ThreadPoolExecutor

　　ThreadPoolExecutor是一个可扩展的线程池，它提供了beforeExecute()、afterExecute()和terminated()三个方法实现对线程池的控制。

　　在默认的ThreadPoolExecutor实现中，提供了空的beforeExecute()、afterExecute()的实现。在实际应用中，可以对其进行扩展，实现对线程池状态的跟踪，输出一些有用的调试信息，以帮助系统故障诊断。

　　下面就是一个带有日志输出功能的线程池，该线程池会在任务执行前输入任务执行的名称和id，同时，在任务执行完毕后，可以输出线程的id和当前线程池的线程数量。

　　

1 public class MyThreadPoolExecutor extends ThreadPoolExecutor{ 2  3     public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 4             long keepAliveTime, TimeUnit unit, 5             BlockingQueue
     
       workQueue, ThreadFactory threadFactory, 6             RejectedExecutionHandler handler) { 7         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 8                 threadFactory, handler); 9     }10 11     @Override12     protected void beforeExecute(Thread t, Runnable r) {13         System.out.println("BeforeExecute MyThread name:"+((MyThread)r).getName()+"ID: "+t.getId() );14     }15 16     @Override17     protected void afterExecute(Runnable r, Throwable t) {18         System.out.println("AfterExecute MyThread ID:"+Thread.currentThread().getId());19         System.out.println("AfterExecute Poolsize:"+this.getPoolSize());20     }21     22     23     24 }