- 简介
为了给并发程序开发提供更好的支持，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<PThread> idelThreads; 5 //已有的线程总数 6 private int threadCounter; 7 private boolean isShutdown = false; 8 9 public ThreadPool() { 10 idelThreads = new Vector<PThread>(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 @Override 22 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 exception 42 } 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 @Override 19 public void run() { 20 // TODO Auto-generated method stub 21 try { 22 Thread.sleep(1000); 23 } catch (InterruptedException e) { 24 // TODO Auto-generated catch block 25 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<Runnable> 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<Runnable> workQueue, ThreadFactory threadFactory, 6 RejectedExecutionHandler handler) { 7 super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 8 threadFactory, handler); 9 } 10 11 @Override 12 protected void beforeExecute(Thread t, Runnable r) { 13 System.out.println("BeforeExecute MyThread name:"+((MyThread)r).getName()+"ID: "+t.getId() ); 14 } 15 16 @Override 17 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 }
