java 线程池

一、概述

一个简单线程的创建和销毁如下代码，与进程进程相比，线程是一种轻量级的工具，但是轻量并不代表没有，它的创建和关闭依然需要花费时间，如果创建和销毁的时间还大于线程本身完成的工作，那就会得不偿失，甚至会造成Out of Memory。即使没有，大量的线程回收也会给GC带来巨大的压力。为了解决这样的问题，那么线程池应运而生。

		new Thread(new Runnable() {
		
			@Override
			public void run() {
				// TODO Auto-generated method stub	
			}
			
		}).start();

二、什么是线程池

线程池和数据库连接池是类似的概念，在池中总有那么几个活跃的线程，当程序中线程时，从池中取出一个，用完后不直接关闭，而是放回池中。

三、JDK对线程池的支持

• Executor框架提供了多种类型的线程池：

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

1. newFixedThreadPool() :返回一个固定线程数量的线程池，当一个任务来时，如果有空闲的线程，那么就立即执行，否则就将任务放到缓存队列。

    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

2. newSingleThreadExecutor() :返回只有一个线程的线程池，如果有任务来，空闲就处理，否则放入缓存队列。

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

3. newCachedThreadPool() :返回一个可根据实际情况调整线程数量的线程池，数量不确定，但是空闲的线程可以优先复用，当任务来时，若有空闲线程就复用，否则创建新的线程，使用完毕后返回线程池复用。

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

4. newSingleThreadScheduledExecutor(): 返回一个ScheduledExecutorService 对象，线程池大小为1，ScheduledExecutorService 可以给定时间执行某个任务，或者周期性的执行某个任务。

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

5. newScheduledThreadPool(int corePoolSize): 也是返回一个ScheduledExecutorService对象，但是可以指定线程池中线程的数量。

• 核心线程实现刨根问底：
  仔细看newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 这三个线程池的构造函数，虽然它们分别实现不同功能的线程池，但是都是调用了ThreadPoolExecutor 来实现的。功能如此强大的ThreadPoolExecutor ，看看它的构造函数：

	/**
	 * 
	 * @param corePoolSize          线程池中线程的数量
	 * @param maximumPoolSize		最大线程数量
	 * @param keepAliveTime			线程数超过指定的数量，多于线程的最大存活时间
	 * @param unit					存活时间的单位
	 * @param workQueue				任务队列，提交，但是还没有执行的任务
	 * @param threadFactory			创建线程的工厂
	 * @param handler				任务太多时，拒绝任务的策略
	 */
    public ThreadPoolExecutor(int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            TimeUnit unit,
            BlockingQueue workQueue,
            ThreadFactory threadFactory,
            RejectedExecutionHandler handler) {
            
            	//...  核心实现
    }

ThreadPoolExecutor 的构造函数参数中，其他的都比较简单，详细看一下 workQueue (任务队列)和 handler ( 拒绝策略)

1. workQueue ：BlockingQueue接口的对象，实现有如下

   1. 直接提交的队列 (SynchronousQueue)
   2. 有界的任务队列 (ArrayBlockingQueue)
   3. 无界的任务队列 (LinkedBlockingQueue)
   4. 优先任务队列 (PriorityQueue)

2. handler 拒绝策略 ：JDK内置了四种拒绝策略如下：

   1. AbortPolicy：直接抛出异常，组织系统正常工作。
   2. CallerRunsPolicy： 只要线程池没有关闭，该策略直接在调用者的线程中，运行被丢弃的任务，虽然不会真的丢失任务，但是任务提交线程的性能会下降。
   3. DiscardOldestPolicy：该策略将丢弃最老的一个请求
   4. DiscardPolicy：直接丢弃无法处理的任务
      
      如上图看到的，所有的拒绝策略都是 RejectedExecutionHandler 接口的实现，如果以上的策略无法满足生产环境的要求，也可以自定义拒绝策略。

• 自定义扩展线程池
  对于既有线程池的扩展可以从两个方面，ThreadPoolFactory(创建线程的方法，以及设置一些线程的属性), 以及ThreadPoolExecutor的三个扩展方法：beforeExecute(Thread t, Runnable r)、afterExecute(Runnable r, Throwable t)、terminated()。

下面是一个例子：

public class ExtThreadPool {

	public static void main(String[] args) throws InterruptedException {
		ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue(), new ThreadFactory() {

					// 自定义线程创建的方法，可设置线程的相关属性
					@Override
					public Thread newThread(Runnable r) {

						Thread t = new Thread(r);
						System.out.println("创建线程" + t);

						return t;
					}
				}) {

			// 扩展线程池，增强线程执行之前 之后，以及结束的相关操作
			@Override
			protected void beforeExecute(Thread t, Runnable r) {
				System.out.println(((MyTask) r).name + "执行之前");
			}

			@Override
			protected void afterExecute(Runnable r, Throwable t) {
				System.out.println(((MyTask) r).name + "执行完毕");
			}

			@Override
			protected void terminated() {
				System.out.println("线程退出！！！");
			}

		};

		for (int i = 0; i < 5; i++) {
			MyTask task = new MyTask("Task" + i);
			es.execute(task);   // 特别注意，在线程池中尽量使用execute()方法提交任务，否则程序出错信息看不到、很痛苦
			Thread.sleep(1000);
		}
		es.shutdown();
	}

	// 静态内部类
	public static class MyTask implements Runnable {
		public String name;

		public MyTask(String name) {
			this.name = name;
		}

		@Override
		public void run() {
			System.out.println("正在执行的线程" + Thread.currentThread().getId() + " " + Thread.currentThread().getName());

			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}

}