线程池概念
线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多的资源。
简单得理解：上面说到的多线程可以提高效率（不能提高程序的运行速度），但是过多的线程反而会适得其反，最好的办法就是适当的创建一定数量的线程，之后将所有的任务都放入一个‘池子’中，每个线程工作完成后，直接去池子里取下一个任务。类似于去银行办业务，银行叫号的过程。
为什么要使用线程池
在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或切换过度而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
线程池主要是用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建带来的延迟。这样，就可以立即为请求服务，使应用程序相应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
从JDK5开始，java就内置线程池了，可以直接使用。
线程池原理
线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行，它的主要特点为：线程复用，控制最大并发数，管理线程。
线程池的组成
一般线程池主要分为以下4个部分组成：
1. 线程管理器：用于创建并管理线程池。
2. 工作线程：线程池中的线程。
3. 任务接口：每个任务必须实现的接口，用于工作线程调度其运行。
4. 任务队列：用于存放待处理的任务，提供一种缓冲机制。
java中的线程池是通过Executor框架实现的，该框架中用到了Executor、Executors、ExecutorService、ThreadPoolExecutor、Callable、Future和FutureTask这几个类。
ThreadPoolExecutor的构造方法如下：
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingDeque<Runnable> workQueue){ this(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,Executors.defaultThreadFactory(),defaultHandler); }
1. corePoolSize：指定了线程池中的线程数量
2. maximumPoolSize：指定了线程池中的最大线程数量
3. keepAliveTime：当前线程数量超过corePoolSize时，多余的空闲线程的存活时间，即多次时间内会被销毁
4. unit：keepAliveTime的单位
5. workQueue：任务队列，被提交但尚未被执行的任务
6. threadFactory：线程工厂，用于创建线程，一般用默认的即可
7. handler：拒绝策略，当任务太多来不及处理，如何拒绝任务。
拒绝策略
线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。
JDK内置的拒绝策略如下：
1. AbortPolicy：直接抛出异常，阻止系统正常运行。
2. CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被废弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能急剧下降。
3. DiscardOldestPolicy：丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务。
4. DiscardPolicy：该策略默默地丢弃无法处理的任务，不予任务处理。如果允许任务丢失，这是最好的一种策略。
5. 以上内置拒绝策略均实现了RejectedExecutionHandler接口，若以上策略仍无法满足实际需要，完全可以自己扩展RejectedExecutionHandler接口。
线程池工作过程
1. 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行他们。
2. 当调用execute()方法添加一个任务时，线程池会做如下判断：
（1）如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务。
（2）如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列。
（3）如果这时候队列满了，而且正在运行的线程数量小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务。
（4）如果队列满了，而且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会抛出异常RejectExecutionException。
3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。
4. 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。
4种线程池
java里面线程池接口的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正线程池接口是ExecutorService。
1. newCachedThreadPool
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用他们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用execute将重用以前构造的线程（如果线程可用）。如果现在线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有60s未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。
2. newFixedThreadPool
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数nThreads线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
3. newScheduledThreadPool
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
4. newSingleThreadExecutor
Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程），这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去。
使用线程池方式-Runnable接口
public static void main(String[] args) throws InterruptedException { //调用工厂类的静态方法，创建线程池对象 //返回线程池对象，是返回的接口 //newFixedThreadPool：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。 ExecutorService es = Executors.newFixedThreadPool(2);//线程池中有两个线程 //调用接口实现类对象es中的方法submit提交线程任务 //将Runnable接口实现类对象传递。 es.submit(new ThreadPoolRunnableTest()); es.submit(new ThreadPoolRunnableTest()); es.submit(new ThreadPoolRunnableTest()); es.submit(new ThreadPoolRunnableTest()); //shutdown方法为销毁线程池，一般不用。 //es.shutdown(); } public class ThreadPoolRunnableTest implements Runnable{ public void run(){ for(int i=0;i<1000;i++){ if(i==999){ System.out.println("线程的名称为："+Thread.currentThread().getName()); } } } }
效果：
我一共运行了三次，虽然只有两个线程，但是可以看到每次的结果都不同。同时也可以看右侧的状态是一直处于运行的，是因为线程池没有销毁，这也正是我们所想要的效果，如果想要销毁可以调用shutdown方法，程序也会停下来。
使用线程池方式-Callable方式
因为之前说的继承Thread类和实现Runnable接口的方式，重写的run方法都没有返回值，那么使用callable的方式可以获取返回值。
public static void main(String[] args) throws InterruptedException, ExecutionException { //调用工厂类的静态方法，创建线程池对象 //返回线程池对象，是返回的接口 //newFixedThreadPool：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。 ExecutorService es = Executors.newFixedThreadPool(2);//线程池中有两个线程 //调用接口实现类对象es中的方法submit提交线程任务,返回Future接口的实现类 Future<String> f = es.submit(new ThreadPoolCallable()); String s = f.get(); System.out.println(s); //shutdown方法为销毁线程池，一般不用。 //es.shutdown(); } public class ThreadPoolCallable implements Callable<String> { public String call(){ return "123"; } }
效果：
线程池--多线程实现异步运算
因为需要返回值，所以选择callable的方式。
要求：使用多线程技术求和。两个线程，第一个：计算1到100的和，第二个：计算1到200的和。
public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService es = Executors.newFixedThreadPool(2);//线程池中有两个线程 //调用接口实现类对象es中的方法submit提交线程任务,返回Future接口的实现类 Future<Integer> f1 = es.submit(new GetSumCallable(100)); Future<Integer> f2 = es.submit(new GetSumCallable(200)); System.out.println(f1.get()); System.out.println(f2.get()); } public class GetSumCallable implements Callable<Integer> { private int a; public GetSumCallable(int a){ this.a = a; } public Integer call(){ int sum = 0; for(int i=0;i<=a;i++){ sum = sum + i; } return sum; } }
效果：
阻塞队列
阻塞队列中，线程阻塞有这样的两种情况
1. 当队列中没有数据的情况下，消费者端所有线程都会被自动阻塞（挂起），直到有数据放入队列。
2. 当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。
阻塞队列的主要方法
抛出异常：抛出一个异常
特殊值：返回一个特殊值（null或false，视情况而定）
阻塞：在成功操作之前，一直阻塞线程
超时：放弃前只在最大的时间内阻塞
java中的阻塞队列
1. ArrayBlockingQueue：由数据结构组成的有界阻塞队列（公平、非公平）
2. LinkedBlockingQueue：由链表结构组成的有界阻塞队列（两个独立锁提高并发）
3. PriorityBlockingQueue：支持优先级排序的无界阻塞队列（compareTo排序实现优先）
4. DelayQueue：使用优先级队列实现的无界阻塞队列（缓存失效、定时任务）
5. SynchronousQueue：不存储元素的阻塞队列（不存储数据、可用于传递数据）
6. LinkedTransferQueue：由链表结构组成的无界阻塞队列
7. LinkedBlockingQueue：由链表结构组成的双向阻塞队列
参考：
1. 黑马程序员视频
持续更新！！！