其中:
corePoolSize: 核心池的大小。 当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中
maximumPoolSize: 线程池最大线程数,它表示在线程池中最多能创建多少个线程;
keepAliveTime:线程保活时间,超过核心线程数的空闲线程在此时间之后会被回收,这个值设的长一点有利于避免频繁的创建和销毁线程。
unit: 参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性:
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
workQueue: 一个阻塞队列,用来存储等待执行的任务。 一般来说,这里的阻塞队列有以下几种选择:
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue
threadFactory: 线程工厂,主要用来创建线程;
handler: 表示当拒绝处理任务时的策略,有以下四种取值:
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程)
ThreadPoolExecutor.CallerRunsPolicy:只要线程池不关闭,该策略直接在调用者线程中,运行当前被丢弃的任务
个人认为这4中策略不友好,最好自己定义拒绝策略,实现RejectedExecutionHandler接口
下面这张图来了解下线程池中各个参数的相互关系(图片来自极客时间课程)
一.有界队列
1.初始的poolSize < corePoolSize,提交的runnable任务,会直接做为new一个Thread的参数,立马执行 。public class ThreadPoolExcutorTest implements Runnable {
public String name;
public ThreadPoolExcutorTest(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(name);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
1, //corePoolSize
2, //maximumPoolSize
1L,
TimeUnit.SECONDS,
workQueue
);
threadPool.execute(new ThreadPoolExcutorTest("任务1"));
threadPool.execute(new ThreadPoolExcutorTest("任务2"));
threadPool.execute(new ThreadPoolExcutorTest("任务3"));
threadPool.execute(new ThreadPoolExcutorTest("任务4"));
threadPool.execute(new ThreadPoolExcutorTest("任务5"));
threadPool.execute(new ThreadPoolExcutorTest("任务6"));
threadPool.shutdown();
}
}
执行结果是:
且线程是两个两个执行的。
分析:线程池的corePoolSize为1,任务1提交后,线程开始执行,corePoolSize=1 数量用完,接着任务2、3、4提交,放到了有界队列中,此时有界队列也满了。继续提交任务5,由于当前运行的线程数poolSize=1 < maximumPoolsize=2,线程池尝试new一个新的线程来执行任务5,所以任务5会接着执行。当继续提交任务6,时,poolSize=2达到了maximumPoolSize=2,有界队列也满了,所以线程池执行了拒绝操作。
====
可以采用这样通俗的方式进行理解
线程池好比是专门处理文件的一个办公室,corePoolSize的好比是办公室员工(常驻员工,核心线程)的数量,任务好比是办公室需要处理的文件,workQueue好比文件架。当需要处理的文件不多的时候,文件直接到员工手上进行处理。可是当文件多的时候,员工们处理不过来,这时候就将文件放到文件架(workQueue)上,当员工们处理完自己的文件时就去文件架(workQueue)中取。可是如果有大量的文件需要处理,文件夹已经存放不下了,怎么办,就得去其他部门请人(非核心线程)过来帮忙了。当然其他部门的外援也不是想要几个就要几个的。然后就规定,最大只能给你(maximumPoolsize-corePoolSize)个人。新员工就开始处理文件。这时候呢,就有两种情况:
一种是:文件仍然源源不断用来,文件夹满了,外援也达到了最大数量,这时候怎么办呢。拒绝策略(handler)
另一种是:来了外援后,文件慢慢的处理完了,但是为了防止还会有大量的文件进来,就规定,新来的员工呢,不要立即返回原岗位,先等等(keepAliveTime这么长的时间),如果不需要你们处理文件呢,你们再走
二.无界队列
与有界队列相比,除非系统资源耗尽,否则无界的任务队列不存在任务入队失败的情况。当有新的任务到来,系统的线程数小于corePoolSize时,则新建线程执行任务。当达到corePoolSize后,就不会继续增加,若后续仍有新的任务加入,而没有空闲的线程资源,则任务直接进入队列等待。若任务创建和处理的速度差异很大,无界队列会保持快速增长,直到耗尽系统内存。public class ThreadPoolExcutorTest2 implements Runnable {
public Integer count;
public ThreadPoolExcutorTest2(Integer count) {
this.count = count;
}
@Override
public void run() {
System.out.println("任务" + count);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 10, 1L, TimeUnit.SECONDS, workQueue);
for (int i = 1; i <= 20; i++) {
pool.execute(new ThreadPoolExcutorTest2(i));
}
Thread.sleep(1000);
System.out.println("线程池中队列中的线程数量:" + workQueue.size());
pool.shutdown();
}
}
执行结果为:
如果修改了线程池的maximumPoolSize参数(大于corePoolSize的大小),程序执行结果不受影响。所以对于 无界队列,maximumPoolSize的设置设置的再大对于线程的执行是没有影响的。
总结:
可以用以下一句总结:当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize,如果还有任务到来就会采取任务拒绝策略。