并发实战值之----线程池--线程池的创建

2，线程池的创建：

（1）我们可以通过ThreadPoolExecutor类来创建一个线程池。

 

new  ThreadPoolExecutor(corePoolSize,

                       maximumPoolSize,

                       keepAliveTime,

                       milliseconds,

                       runnableTaskQueue, 

                       threadFactory,

                       Handler

                      )；

 

参数详解：

一，corePoolSize（线程池的基本大小）：

    当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。

    FixedThreadPool、SingleThreadExecutor的基本大小和最大大小相同（FixedThreadPool是创建时传入的值、SingleThreadExecutor是1）

二，runnableTaskQueue（任务队列）：

    用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。

     1，ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

     2，LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()和Executors.newSingleThreadExecutor()使用了这个队列。

     3，SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

     4，PriorityBlockingQueue：一个具有优先级得无限阻塞队列。

三，maximumPoolSize（线程池最大大小）：

    线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。

四，ThreadFactory：

    用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常又帮助。

五，RejectedExecutionHandler（饱和策略）：

    当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略。n  AbortPolicy：直接抛出异常。

    1，CallerRunsPolicy：只用调用者所在线程来运行任务。

    2，DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

    3，DiscardPolicy：不处理，丢弃掉。

    4，当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

六，keepAliveTime（线程活动保持时间）：

    线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

七，TimeUnit（线程活动保持时间的单位）：

可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)。

 

（2）ThreadPoolExecutor类的运行原理，即线程池的工作原理：

 

源码分析。上面的流程分析让我们很直观的了解的线程池的工作原理，让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下：

 public void execute(Runnable command) {

        if (command == null)

            throw new NullPointerException();

        //如果线程数小于基本线程数，则创建线程并执行当前任务

        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {       //如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。

            if (runState == RUNNING && workQueue.offer(command)) {

                if (runState != RUNNING || poolSize == 0)

                    ensureQueuedTaskHandled(command);

            }

        //如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许                                            的线程数量，则创建一个线程执行任务。

            else if (!addIfUnderMaximumPoolSize(command))

         //如果线程池创建失败，则按一定的策略处理无法执行的任务

                reject(command); // is shutdown or saturated（线程池停止了或饱和了）

        }

}

 

线程池创建线程时，会将线程封装成工作线程Worker（它实现了Runnable接口），Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。我们可以从Worker的run方法里看到这点：

public void run() {

            try {

                Runnable task = firstTask;

                firstTask = null;

                while (task != null || (task = getTask()) != null) {

                    runTask(task);

                    task = null;

                }

            } finally {

                workerDone(this);

            }

        }

即，execute()方法不断的将任务放到任务队列中，而run()方法不断的从任务队列中去除并执行任务；

 

（3）我们在实际操作中并不直接用ThreadPoolExecutor类来创建线程池，有一个工具类Executors来完成这个任务（内部封装了ThreadPoolExecutor类），用它可以实现创建三种线程池：

     FixedThreadPool（固定线程数的线程池）：即只会创建给定数量的线程

     SingleThreadExecutor（单线程的线程池）：即只有一个线程

     CachedThreadPool（缓冲线程池）：即来一个任务创建一个线程