java.util.concurrent.Executors类
java.util.concurrent.Executor接口
二者很相似，但是创建线程池的话都是通过实现接口的方式，多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1创建线程时间，T2在线程中执行任务时间，T3销毁线程时间。
如果：T1 + T3 远大于T2， 则应该采用线程池，用于提高服务器性能。
一个线程池包括以下四个基本组成部分：
- 线程池 管理器（ThreadPoll）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加任务；
- 工作线程（PoolWorker）：线程池中的线程，在没有任务时处于等待状态，可以循环的执行任务；
- 任务接口（Task）：每个任务必须实现的接口，以提供线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
- 任务队列（taskQueue）：用于存放没有处理的任务，提供一种缓冲机制。
线程池技术正是关注如何缩短或调整T1、T3时间的技术，从而提高服务器程序性能。
常见线程池
- newSingleThreadExecutor
单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务 - newFixedThreadExecutor(n)
固定数量的线程池，每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行 -
newCacheThreadExecutor（推荐使用）[无界线程池，可以进行自动线程回收]
可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。 - newScheduleThreadExecutor
大小无限制的线程池，支持定时和周期性的执行线程
为什么使用线程池？
创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上业务工作线程，消耗系统资源的时间，可能导致系统资源不足。
线程池作用（优点）
线程池的作用就是限制系统中执行线程的数量，根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
1、提高效率 创建好一定数量的线程放在池中，等需要使用的时候就从池中拿一个，这要比需要的时候创建一个线程对象要快的多。（减少了创建和销毁线程的次数）
2、方便管理 可以编写线程池管理代码对池中的线程同一进行管理，比如说启动时有该程序创建100个线程，每当有请求的时候，就分配一个线程去工作，如果刚好并发有101个请求，那多出的这一个请求可以排队等候，避免因无休止的创建线程导致系统崩溃。
几个常用来接收线程池对象的类或者接口
ExecutorService 是真正的线程池接口，创建的一般线程池对象我们一般就用它接收。
public interface ExecutorService extends Executor {}
ScheduledExecutorService 接口继承了ExecutorService接口，它用来解决那些需要任务重复执行的问题。
public interface ScheduledExecutorService extends ExecutorService {}
类ThreadPoolExecutor是ExecutorService接口的默认实现类。
public class ThreadPoolExecutor extends AbstractExecutorService {}
类ScheduledThreadPoolExecutor继承了ThreadPoolExecutor类，并实现了ScheduledExecutorService接口，因此该类能执行 一些周期性调度的方法。
public class ScheduledThreadPoolExecutor
extends ThreadPoolExecutor
implements ScheduledExecutorService {}
常见线程池的创建方法源码如下
package cn.ihep.threadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
/**
* 常见线程池创建
*
* @author xiaoming
*
*/
public class ThreadPoolTest {
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
@Test
public void singleThreadExcutor() {
// 创建单线程池
ExecutorService pool = Executors.newSingleThreadExecutor();
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
// 关闭线程池
pool.shutdown();
}
--------------
输出：
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
---------------
@Test
public void fixedThreadExecutor() {
int capacity = 10;
ExecutorService pool = Executors.newFixedThreadPool(capacity);
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
// 将线程放入线程池执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
// 关闭线程池
pool.shutdown();
}
-------------------
输出结果：
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-2
-------------------
@Test
public void cacheThreadExecutor() {
ExecutorService pool = Executors.newCachedThreadPool();
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
// 关闭线程池
pool.shutdown();
}
--------------------
输出结果：
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-2
--------------------
//newScheduledThreadPool线程池的实现
public static void main(String[] args) {
int corePoolSize = 10;
ScheduledExecutorService pool = Executors.newScheduledThreadPool(corePoolSize);
pool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
// 打印系统时间
System.out.println("*****************");
}
}, 1000, 1000 * 5, TimeUnit.MILLISECONDS);
pool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(System.nanoTime());
}
}, 1000, 2000, TimeUnit.MILLISECONDS);
}
---------------------------
输出结果：
*****************
302010811506149
302012811595099
302014811621613
*****************
302016811745346
302018811897303
*****************
302020810967599
... ...
---------------------------
}
线程池有哪几种工作队列
- ArrayBlockingQueue
是一个基于数组结构的有界阻塞队列，此队列按FIFO原则对元素进行排序。 - LinkedBlockingQueue
一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFiexedThreadPool()使用了这个队列 - SynchronousQueue
一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCacheThreadPool使用了这个队列 - PriorityBlockingQueue
一个具有优先级的无限阻塞队列
怎么理解有界/无界队列
有界队列
1.初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行 。
2.当提交的任务数超过了corePoolSize，会将当前的runable提交到一个block queue中。
3.有界队列满了之后，如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务。
4.如果3中也无法处理了，就会走到第四步执行reject操作。
无界队列
与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新的任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加，若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。
