作用
一、使用简单
二、方便管理多线程
三、可重复利用线程
一个例子
通过下面这个例子，可以看出线程池使用起来非常简单、方便
public class StartProvider {
public static void main(String[] args) {
ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(2);
for (int i = 1; i < 7; ++i) {
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println("test");
}
});
}
}
}
Executors的newFixedThreadPool是创建一个大小固定，其它参数默认的线程池，然后执行Runnable任务，使用起来简单，下面是线程池的参数：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory, RejectedExecutionHandler handler)
- corePoolSize: 核心线程数（常驻线程池的线程数）
- maximumPoolSize: 线程池中最大线程数目
- keepAliveTime: 池中线程数多于核心线程并且idle时，多于核心线程的其它线程存活时间
- unit: keepAliveTime时间单位
- workQueue: 存放任务的队列（核心线程满了之后，任务先进队列）
- threadFactory: 创建线程的线程工厂
- handler: 线程池处理抛弃任务策略
参数设置
根据任务和运行的环境情况（cpu型，io型，cpu核数等），设置参数的值，提高硬件的利用率
corePoolSize
核心线程数的大小，在线程池初始化完成后，池中的线程个数为0，每添加一个任务，线程池就增加一个线程直到线程个数等于corePoolSize。对CPU繁忙型任务线程池大小(CPU核数为N)
线程池大小 = N + 1
对IO繁忙型任务线程池大小为
线程池大小 = (IO操作时间 + CPU运行时间)/CPU运行时间× N 或 2×N +１
maximumPoolSize
最大线程数，当workQueue已满且线程池中的线程数少于maximumPoolSize时，如有新任务，就会创建新的线程，一直到线程池中的线程大小为maximumPoolSize。
keepAliveTime
idle线程(线程数大于corePoolSize且为idle)的存活时间，线程需要占用资源，多余线程需要消亡，这些多余线程在将来很短时间内也可能需要用到，keepAliveTime × unit是这些线程的存活时间。当任务数呈峰谷周期变化时，keepAliveTime × unit设置为半周期，可以减少线程的创建和销毁开销。idle线程是存活keepAliveTime时间是通过取阻塞队列里面的任务延时来实现的：
Runnable r = timed ?
workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS) : workQueue.take();
和keepAliveTime相对应的是allowCoreThreadTimeOut，表示线程池中的核心线程是否销毁，线程池中的核心线程空闲较多时，通过设置allowCoreThreadTimeOut的值来表示是否销毁idle的核心线程。通过线程池的getActiveCount可以获取线程池中正在执行的线程数
workQueue
阻塞队列，用于存储任务。常用的阻塞队列有LinkedBlockingQueue、PriorityBlockingQueue和SynchronousQueue，它们分别用于不同的场景。LinkedBlockingQueue可以设置为有界阻塞队列和无界阻塞队列，按先进先出的顺序执行任务；PriorityBlockingQueue优先级队列，根据Compatator比较器可以设置不同任务的执行顺序；SynchronousQueue同步队列，在插入一个任务进入队列以后，需要取出这个任务才能继续插入。
threadFactory
线程工厂，继承ThreadFactory可定制线程工厂
handler
任务队列满，且线程池中的线程数达到最大值(maximumPoolSize)，有新任务到来时，线程池用handler策略处理新任务。通过继承RejectedExecutionHandler类可以定制处理策略，默认提供了三种处理策略：
- CallerRunsPolicy: 在当前线程中执行任务
public class Main {
public static void main(String[] args){
final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 1; i <= 5; ++i) {
final int index = i;
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
try {
if(!"main".equals(Thread.currentThread().getName())) {
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("nothing");
}
System.out.println("threadPoolInfo:poolSize = " + threadPoolExecutor.getPoolSize() + " queue size =" + threadPoolExecutor.getQueue().size() +
", currentTime:" + System.currentTimeMillis() + ", index = " + index + ", current thread name:" + Thread.currentThread().getName());
}
});
}
System.out.println("end");
}
}
执行结果
线程池任务超出负载时，任务由线程池所在的线程执行，例子中的为main线程
- AbortPolicy： 不执行任务（默认策略），并抛出RejectedExecutionException
public class Main {
public static void main(String[] args){
final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 1; i <= 12; ++i) {
final int index = i;
try {
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println("threadPoolInfo:poolSize = " + threadPoolExecutor.getPoolSize() + " queue size =" + threadPoolExecutor.getQueue().size() +
", currentTime:" + System.currentTimeMillis() + ", index = " + index + ", current thread name:" + Thread.currentThread().getName());
}
});
} catch (RejectedExecutionException e) {
System.out.println("message : " + e.getMessage());
try {
Thread.sleep(1000);
} catch(InterruptedException e1) {
System.out.println("interrupted");
}
}
}
System.out.println("end");
}
}
执行结果
线程池任务超出负载时，没有执行任务，并抛出RejectExecutionException。抛出异常时，需要捕获异常，不然无法使用线程池。
- DiscardPolicy：不执行任务，不抛出异常（静默策略）
- DiscardOldestPolicy ： 抛弃阻塞队列中最久的任务
一个问题
线程池是如何重复多次利用线程的？通过阻塞队列，阻塞队列中没有任务时阻塞线程，有任务则取出任务执行，其原理和下面片段类似，但是复杂很多
public class Main {
public static void main(String[] args) {
final BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<Runnable>();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Runnable runnable = blockingQueue.take();
runnable.run();
System.out.println("blocking........");
} catch (InterruptedException e) {
System.out.println("interrupted");
}
}
}
}).start();
blockingQueue.add(new Runnable() {
@Override
public void run() {
System.out.println("execute task!");
}
});
}
}
线程池中线程线程需要销毁则调用阻塞队列的poll方法，设置阻塞超时时间；否则调用take方法阻塞
关闭
shutdown和shutdownNow未关闭线程池的两个操作，shutdown关闭idle线程，线程池里面的任务继续执行；shutdownNow不等待线程执行完毕，直接关闭线程。
