线程池总结

ref:https://www.cnblogs.com/dongguacai/p/6030187.html

     http://www.360doc.com/content/15/0511/14/12726874_469670444.shtml

     https://blog.csdn.net/honghailiang888/article/details/51690711

     http://www.open-open.com/lib/view/open1406778349171.html

　  https://blog.csdn.net/chaofanwei2/article/details/51393794

     http://www.360doc.com/content/15/0511/14/12726874_469670444.shtml

什么是线程池？

　　诸如web服务器、数据库服务器、文件服务器和邮件服务器等许多服务器应用都面向处理来自某些远程来源的大量短小的任务。构建服务器应用程序的一个过于简单的模型是：每当一个请求到达就创建一个新的服务对象，然后在新的服务对象中为请求服务。但当有大量请求并发访问时，服务器不断的创建和销毁对象的开销很大。所以提高服务器效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这样就引入了“池”的概念，“池”的概念使得人们可以定制一定量的资源，然后对这些资源进行复用，而不是频繁的创建和销毁。

　　线程池是预先创建线程的一种技术。线程池在还没有任务到来之前，创建一定数量的线程，放入空闲队列中。这些线程都是处于睡眠状态，即均为启动，不消耗CPU，而只是占用较小的内存空间。当请求到来之后，缓冲池给这次请求分配一个空闲线程，把请求传入此线程中运行，进行处理。当预先创建的线程都处于运行状态，即预制线程不够，线程池可以自由创建一定数量的新线程，用于处理更多的请求。当系统比较闲的时候，也可以通过移除一部分一直处于停用状态的线程。

线程池简介    

　　多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。       

　　假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
　　如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
                一个线程池包括以下四个基本组成部分：
                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。                
　　线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
　　线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
　　假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

　　代码实现中并没有实现任务接口，而是把Runnable对象加入到线程池管理器（ThreadPool），然后剩下的事情就由线程池管理器（ThreadPool）来完成了。

线程池的创建

1 public ThreadPoolExecutor(int corePoolSize,
2                               int maximumPoolSize,
3                               long keepAliveTime,
4                               TimeUnit unit,
5                               BlockingQueue<Runnable> workQueue,
6                               RejectedExecutionHandler handler) 

　　corePoolSize：线程池核心线程数量

　　maximumPoolSize:线程池最大线程数量

　　keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

　　unit：存活时间的单位

　　workQueue：存放任务的队列

　　handler：超出线程范围和队列容量的任务的处理程序

线程池的实现原理

　　提交一个任务到线程池中，线程池的处理流程如下：

　　1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

　　2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

　　3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

图1 线程池的主要处理流程

java类库中提供的线程池简介

　　java提供的线程池更加强大，相信理解线程池的工作原理，看类库中的线程池就不会感到陌生了。

图2 JDK类库中的线程池的类框图 

图3 Executors类的生成ExecutorService实例的静态方法

　　Java通过Executors提供四种线程池，分别为：
　　newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
　　newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
　　newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
　　newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

　　(1) newCachedThreadPool
　　创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

　　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);  
   　　 }  
  　　 });  
  　　}  
　　 }  
　　}
　　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);
   　　 }
  　　 });
  　　}
　　 }
　　}

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

　　(2) 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();  
   }  
  }  
  });  
 }  
 }  
}
　　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();
   }
  }
  });
 }
 }
}