如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？在Java中可以通过线程池来达到这样的效果。首先我们从最核心的ThreadPoolExecutor类中的方法讲起。
java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。下面我们来看一下ThreadPoolExecutor类的具体实现源码。
在ThreadPoolExecutor类中提供了四个构造方法：
public class ThreadPoolExecutor extends AbstractExecutorService {
.....
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
...
}
从上面的代码可以得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。
下面解释下一下构造器中各个参数的含义：
corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
unit：参数keepAliveTime的时间单位
workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略，默认有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
线程池执行的流程：
当任务提交给ThreadPoolExecutor 线程池中，先检查核心线程数是否已经全部使用，如果没有交由核心线程去执行任务，如果核心线程数已经全部占用，则将任务添加到队列里面，如果队列已经占满，比较当前线程池的中线程的数量是不是与超过maximumPoolSize，如果没有查过则创建线程去执行，也就是说线程池最多可以接受多少任务呢？就是maximumPoolSize+队列的大小。当线程池中的线程的数量大于corePoolSize数量有空闲线程则执行回收，回收时间是keepAliveTime，单位是unit，都是初始化的时候设置的。
下面通过代码来说明：
定义一个实现了Runnable接口的类，当作任务类；
public class MyTask implements Runnable {
private int taskId;
private String taskName;
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
public MyTask(int taskId, String taskName) {
this.taskId = taskId;
this.taskName = taskName;
}
@Override
public void run() {
System.out.println("taskId:" + taskId + ",taskName:" + taskName);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
定义如下的线程池：
ThreadPoolExecutor pool = new ThreadPoolExecutor(// 自定义一个线程池
1, // coreSize
2, // maxSize
60, // 60s
TimeUnit.SECONDS, new ArrayBlockingQueue<>(3) // 有界队列，容量是3个
, Executors.defaultThreadFactory()
, new ThreadPoolExecutor.AbortPolicy()
);
该线程池最多可以放2+3个任务，现在我们放6个任务进去，看看执行的效果：
pool.execute(new MyTask(1, "任务1"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.execute(new MyTask(2, "任务2"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.execute(new MyTask(3, "任务3"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.execute(new MyTask(4, "任务4"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.execute(new MyTask(5, "任务5"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.execute(new MyTask(6, "任务6"));
System.out.println("活跃的线程数："+pool.getActiveCount() + ",核心线程数：" + pool.getCorePoolSize() + ",线程池大小：" + pool.getPoolSize() + ",队列的大小" + pool.getQueue().size());
pool.shutdown();
我们的执行结果：
我们可以看到，首先抛出了异常，大致意思是拒绝了一个线程加入到线程池，因为我线程池最大允许5个线程的加入，当线程池满了执行的拒绝策略是DiscardPolicy直接拒绝线程的加入，并抛出异常。
接下来，我们看每次添加一个线程打印的活跃的线程数等相关消息。
当任务1加入到线程池中：
活跃的线程数：1,核心线程数：1,线程池大小：1,队列的大小0，也就是说，任务1加入核心未被占满，开启一个核心线程去执行。此时线程的大小也为1.
当任务2加入到线程池中时：
活跃的线程数：1,核心线程数：1,线程池大小：1,队列的大小1 。也就是说，此时核心已经占满了，队列没有满，则往队列里面增加任务。此时线程的大小仍然也为1.因为就一个核心线程在执行任务。
当任务3加入到线程池中时：同任务2.
当任务4加入到线程池中时：同任务2.此时队列已经满。
当任务5加入到线程池中时：
活跃的线程数：2,核心线程数：1,线程池大小：2,队列的大小3，活跃的线程变为2，也就是maximumPoolSize数量，因为任务4加入到线程池时，线程池的队列已经满了，此时会检查活跃的线程是不是大于maximumPoolSize，如果不大于则创建线程去执行任务，到底执行新加入还是队列里面最老加入的。此时通过下面的执行结果来判断。
我们看到任务1和任务5最先执行，任务1不用讲自然会在最先执行的里面，任务5在最先执行的任务里面，说明，当线程队列满了，如果开起了新线程，则会去执行新加入的任务，不是从队列里面去老的任务。从后面执行来看，当之前的任务直线完成了，线程池会从队列里面获取任务去执行。这就是一个线程池的大致执行流程。
当然个人觉得那个原生的拒绝策略都不太实用，比如互联网任务，我们定义一个线程池，当线程池满了，我们要合理的处理后续的任务，比如记录下来下次再去执行，或者告知责任人那些任务没有处理等等，个人任务这个应该自己定义，当线程满了，我们可以自由控制。下面定义一个拒绝策略。
public class MyRejected implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
MyTask task = (MyTask) r;
System.out.println("报警信息："+task.getTaskName()+" 被线程池拒绝，没有被执行");
//可以往消息队列中间件里面放 可以发Email等等
}
}
如上，我们实现RejectedExecutionHandler 接口。就可以自定义一个拒绝策略很简单。
我们需要线程池的定义，使用自己的拒绝策略。
ThreadPoolExecutor pool = new ThreadPoolExecutor(// 自定义一个线程池
1, // coreSize
2, // maxSize
60, // 60s
TimeUnit.SECONDS, new ArrayBlockingQueue<>(3) // 有界队列，容量是3个
, Executors.defaultThreadFactory()
, new MyRejected()
);
其他的代码不用修改，执行结果如下：
现在就执行了自己自定义拒绝策略。
以上只是讲解的自定义的线程池，当然java本身已经内置了一些线程，比如：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
这里就不详细讲解了，内部实现都是ThreadPoolExecutor ，个人倾向自定义的线程池，这样比较灵活。