多线程之五：线程池

1．线程池的基本使用

    1.1. 为什么需要线程池

        假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

        1.1.1. 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间, T1 + T3 远大于 T2。

            采用线程池减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

        1.1.2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机).

    1.2.JDK为我们提供了哪些支持

        1.2.1. 内置线程池

        

    1.3.线程池的使用

        1.3.1. 线程池的种类

            newFixedThreadPool

                创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

            newSingleThreadExecutor

                创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

            newCachedThreadPool

                创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

            newScheduledThreadPool

                创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

        1.3.2. 不同线程池的共同性

            在下面线程池及其核心代码分析一节中会有所体现。

    1.4. 线程池使用的小例子

        1.4.1. 简单线程池

public class fixedThreadExecutorTest{

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        //创建一个可重用固定线程数的线程池

        ExecutorService pool=Executors.newFixedThreadPool(2);

        //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口;

        Thread t1=new TestThread();

        Thread t2=new TestThread();

        Thread t3=new TestThread();

        Thread t4=new TestThread();

        //将线程放到池中执行；

        pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

    }

}

        3.4.2. ScheduledThreadPool

public class scheduledThreadExecutorTest{

    public static void main(String[] args) {

        // TODO Auto-generated method stub

       ScheduledThreadPoolExecutor exec =new ScheduledThreadPoolExecutor(1);

       exec.scheduleAtFixedRate(new Runnable(){//每隔一段时间就触发异常

        @Override

        public void run() {

            // TODO Auto-generated method stub

            //throw new RuntimeException();

            System.out.println("===================");

            

        }}, 1000, 5000, TimeUnit.MILLISECONDS);  

       exec.scheduleAtFixedRate(new Runnable(){//每隔一段时间打印系统时间，证明两者是互不影响的

        @Override

        public void run() {

            // TODO Auto-generated method stub

            System.out.println(System.nanoTime());

            

        }}, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}

 

    1.5. 线程池及其核心代码分析

        ThreadPoolExecutor的完整构造方法的签名是：

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

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

               maximumPoolSize-池中允许的最大线程数。

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

               unit - keepAliveTime 参数的时间单位。

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

               threadFactory - 执行程序创建新线程时使用的工厂。

               handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

               BlockingQueue的三种类型：

                   直接提交策略，也即SynchronousQueue。

               它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

                   无界队列策略，即LinkedBlockingQueue

               使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

                   有界队列，使用ArrayBlockingQueue

               当使用有限的 maximumPoolSizes时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

        JDK中4个内置线程池的代码：

            newFixedThreadPool (int nThreads):固定大小线程池

public static ExecutorService newFixedThreadPool(int nThreads) {   

           return new ThreadPoolExecutor(nThreads, nThreads,   

                0L, TimeUnit.MILLISECONDS,   

                new LinkedBlockingQueue<Runnable>());   

}

            newSingleThreadExecutor()：单线程

public static ExecutorService newSingleThreadExecutor() {   

    return new FinalizableDelegatedExecutorService   

        (new ThreadPoolExecutor(1, 1,   

            0L, TimeUnit.MILLISECONDS,   

            new LinkedBlockingQueue<Runnable>()));   

}

            newCachedThreadPool()：无界线程池，可以进行自动线程回收

public static ExecutorService newCachedThreadPool() {   

    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,   

        60L, TimeUnit.SECONDS,   

        new SynchronousQueue<Runnable>());   

    }

            newScheduledThreadPool ()：定时任务线程池

//预定执行而构建的固定线程池  

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  

        return new ScheduledThreadPoolExecutor(corePoolSize);  

}  

    1.6.扩展和增强线程池

        1.6.1.回调接口

            ThreadPoolExecutor对以下方法进行了空实现，所以需要开发者继承ThreadPoolExecutor并且重写实现以下方法。

            protected void beforeExecute(Thread t, Runnable r) { }  

            protected void afterExecute(Runnable r, Throwable t) { }  

            protected void terminated() { }

        1.6.2. 拒绝策略

            RejectedExecutionHandler接口提供了对于拒绝任务的处理的自定方法的机会。在ThreadPoolExecutor中已经默认包含了4中策略。

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

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

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

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

            使用内置策略代码示例：

ThreadPoolExecutor e=new ThreadPoolExecutor( 2, 3, 30, TimeUnit.SECONDS,    

new  SynchronousQueue<Runnable>(),    

Executors.defaultThreadFactory() ,   

//传入要使用的策略

new ThreadPoolExecutor.CallerRunsPolicy());

            使用自定义策略代码示例：

ThreadPoolExecutor e= new ThreadPoolExecutor( 2, 3, 30, TimeUnit.SECONDS,    
				    new  SynchronousQueue<Runnable>(),    
				    Executors.defaultThreadFactory() ,    
				    new RejectedExecutionHandler(){
						public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
							//do something
						}	
					}
			);

        1.6.3.自定义ThreadFactory

public class CustomThreadFactory implements ThreadFactory  

{  

   private int          counter;  

   private String       name;  

   private List<String> stats;  

   

   public CustomThreadFactory(String name)  

   {  

      counter = 1;  

      this.name = name;  

      stats = new ArrayList<String>();  

   }  

   

   @Override  

   public Thread newThread(Runnable runnable)  

   {  

      Thread t = new Thread(runnable, name + "-Thread_" + counter);  

      counter++;  

      stats.add(String.format("Created thread %d with name %s on %s \n", t.getId(), t.getName(), new Date()));  

      return t;  

   }  

   

   public String getStats()  

   {  

      StringBuffer buffer = new StringBuffer();  

      Iterator<String> it = stats.iterator();  

      while (it.hasNext())  

      {  

         buffer.append(it.next());  

      }  

      return buffer.toString();  

   }  

}