线程池这个概念已经深入人心了，今天就是通过几个入门事例，学习一下线程池在JAVA中的应用。

一、大小固定的线程池——Executors.newFixedThreadPool()

  下面咱们明确两个类：

  1、ExecutorService：线程池的接口类

  2、Executors：Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具

  3、Executors.newFixedThreadPool()：这是一个静态方法，也是这个事例的核心，目的是创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大值。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

package com.taobao.threadpool;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

/**
 * 线程池的应用
 * @author liqiu
 *
 */
public class Test {
    public static void main(String[] args) {
        // 创建一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        // 将线程放入池中进行执行
        for (int i=0; i<9; i++){
            pool.execute(new MyThread(i));
        }
        // 关闭线程池
        pool.shutdown();
    }
}

class MyThread extends Thread {
    int num;
    public MyThread(int i){
        this.num = i;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在执行。。。" + this.num);
    }
}

  执行的结果：

pool-1-thread-1正在执行。。。0
pool-1-thread-1正在执行。。。3
pool-1-thread-1正在执行。。。4
pool-1-thread-3正在执行。。。2
pool-1-thread-3正在执行。。。6
pool-1-thread-3正在执行。。。7
pool-1-thread-3正在执行。。。8
pool-1-thread-2正在执行。。。1
pool-1-thread-1正在执行。。。5

二、其他的Executores方法

  1、Executors.newSingleThreadExecutor()：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。这种用法我认为违背了线程池的概念，毕竟是一个池子，竟然只有一条鱼，很没劲。事例和上一个一样，有兴趣的话自己试一试。

  2、Executors.newCachedThreadPool()：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。说白了就是默认有若干个线程，如果请求增多了，也会继续增加线程的个数，但是会自动自动回收超出的部分线程。

  3、Executors.newScheduledThreadPool()：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

  4、Executors.newSingleThreadExecutor()：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

三、自定义线程池

  阅读了上面的内容，应该已经可以使用JAVA提供的线程池了，但是有一个特殊的情况还是需要咱们特制线程池。

package com.taobao.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池的应用
 * 
 * @author liqiu
 * 
 */
public class Test {
    public static void main(String[] args) {
        // 创建等待队列
        BlockingQueue bqueue = new ArrayBlockingQueue(20);
        // 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 2, TimeUnit.MILLISECONDS, bqueue);
        // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
        for (int i = 0; i <= 9; i++) {
            // 将线程放入池中进行执行
            pool.execute(new MyThread(i));
        } 
        // 关闭线程池
        pool.shutdown();
    }
}

class MyThread extends Thread {
    int num;
    public MyThread(int i){
        this.num = i;
    }
    @Override
    public void run() {
        System.out.println(this.num+" 正在被"+Thread.currentThread().getName() + "执行。。。");
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行的结果：

0 正在被pool-1-thread-1执行。。。
1 正在被pool-1-thread-2执行。。。
2 正在被pool-1-thread-1执行。。。
3 正在被pool-1-thread-2执行。。。
4 正在被pool-1-thread-1执行。。。
5 正在被pool-1-thread-2执行。。。
6 正在被pool-1-thread-1执行。。。
7 正在被pool-1-thread-2执行。。。
8 正在被pool-1-thread-1执行。。。
9 正在被pool-1-thread-2执行。。。

下面解释一下程序：

ThreadPoolExecutor 类的方法：

　　public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

  参数说明名如下：
　　corePoolSize – 池中所保存的线程数，包括空闲线程。

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

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

　　unit – keepAliveTime 参数的时间单位。

　　workQueue – 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。本例实用的是BlockingQueue，有关它的内容可以参考：http://www.cnblogs.com/liqiu/p/3630281.html

小结：

  可见用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。