达内目前开设Java、JAVA大数据、python、软件测试、室内设计,平面设计,UI设计,电商等二十多大课程体系，为IT企业提供人才服务，并为行业提供应用型人才

　　达内拥有行业内完善的教研团队，200余位总监级讲师，1000余名教研人员，全方位保障学员学习。贯彻总监级讲师组合授课，秉承“出高徒、高徒拿高薪”的教学理念，是达内公司确保教学质量的重要环节

　　其实java线程池的实现原理很简单，说白了就是一个线程集合workerSet和一个Java阻塞队列workQueue。当用户向线程池提交一个任务(也就是线程)时，线程池会先将任务放入workQueue中。workerSet中的线程会不断的从workQueue中获取线程然后执行。当workQueue中没有任务的时候，worker就会阻塞，直到队列中有任务了就取出来继续执行。

　　线程池的几个主要参数的作用

　　public ThreadPoolExecutor(int corePoolSize,

　　int maximumPoolSize,

　　long keepAliveTime,

　　TimeUnit unit,

　　BlockingQueueworkQueue,

　　ThreadFactory threadFactory,

　　RejectedExecutionHandler handler)

　　corePoolSize: 规定线程池有几个线程(worker)在运行。

　　maximumPoolSize: 当workQueue满了,不能添加任务的时候，这个参数才会生效。规定线程池较多只能有多少个线程(worker)在执行。

　　keepAliveTime: 超出corePoolSize大小的那些线程的生存时间,这些线程如果长时间没有执行任务并且超过了keepAliveTime设定的时间，就会消亡。

　　unit: 生存时间对于的单位

　　workQueue: 存放任务的队列

　　threadFactory: 创建线程的工厂

　　handler: 当workQueue已经满了，并且线程池线程数已经达到maximumPoolSize，将执行拒绝策略。

　　任务提交后的流程分析

　　用户通过submit提交一个任务。线程池会执行如下流程:

　　判断当前运行的worker数量是否超过corePoolSize,如果不超过corePoolSize。就创建一个worker直接执行该任务。—— 线程池较开始是没有worker在运行的

　　如果正在运行的worker数量超过或者等于corePoolSize,那么就将该任务加入到workQueue队列中去。

　　如果workQueue队列满了,也就是offer方法返回false的话，就检查当前运行的worker数量是否小于maximumPoolSize,如果小于就创建一个worker直接执行该任务。

　　如果当前运行的worker数量是否大于等于maximumPoolSize，那么就执行RejectedExecutionHandler来拒绝这个任务的提交。

　　源码解析

　　我们先来看一下ThreadPoolExecutor中的几个关键属性。

　　//这个属性是用来存放 当前运行的worker数量以及线程池状态的

　　//int是32位的，这里把int的高3位拿来充当线程池状态的标志位,后29位拿来充当当前运行worker的数量

　　private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

　　//存放任务的阻塞队列

　　private final BlockingQueueworkQueue;

　　//worker的集合,用set来存放

　　private final HashSetworkers = new HashSet();

　　//历史达到的worker数较大值

　　private int largestPoolSize;

　　//当队列满了并且worker的数量达到maxSize的时候,执行具体的拒绝策略

　　private volatile RejectedExecutionHandler handler;

　　//超出coreSize的worker的生存时间

　　private volatile long keepAliveTime;

　　//常驻worker的数量

　　private volatile int corePoolSize;

　　//较大worker的数量,一般当workQueue满了才会用到这个参数

　　private volatile int maximumPoolSize;

　　1. 提交任务相关源码

　　下面是execute方法的源码

　　public void execute(Runnable command) {

　　if (command == null)

　　throw new NullPointerException();

　　int c = ctl.get();

　　//workerCountOf(c)会获取当前正在运行的worker数量

　　if (workerCountOf(c) < corePoolSize) {

　　//如果workerCount小于corePoolSize,就创建一个worker然后直接执行该任务

　　if (addWorker(command, true))

　　return;

　　c = ctl.get();

　　}

　　//isRunning(c)是判断线程池是否在运行中,如果线程池被关闭了就不会再接受任务

　　//后面将任务加入到队列中

　　if (isRunning(c) && workQueue.offer(command)) {

　　//如果添加到队列成功了,会再检查一次线程池的状态

　　int recheck = ctl.get();

　　//如果线程池关闭了,就将刚才添加的任务从队列中移除

　　if (! isRunning(recheck) && remove(command))

　　//执行拒绝策略

　　reject(command);

　　else if (workerCountOf(recheck) == 0)

　　addWorker(null, false);

　　}

　　//如果加入队列失败,就尝试直接创建worker来执行任务

　　else if (!addWorker(command, false))

　　//如果创建worker失败,就执行拒绝策略

　　reject(command);

　　}

　　添加worker的方法addWorker源码

　　private boolean addWorker(Runnable firstTask, boolean core) {

　　retry:

　　//使用自旋+cas失败重试来增加线程竞争问题

　　for (;;) {

　　//先获取线程池的状态

　　int c = ctl.get();

　　int rs = runStateOf(c);

　　// 如果线程池是关闭的,或者workQueue队列非空,就直接返回false,不做任何处理

　　if (rs >= SHUTDOWN &&

　　! (rs == SHUTDOWN &&

　　firstTask == null &&

　　! workQueue.isEmpty()))

　　return false;

　　for (;;) {

　　int wc = workerCountOf(c);

　　//根据入参core 来判断可以创建的worker数量是否达到上限,如果达到上限了就拒绝创建worker

　　if (wc >= CAPTY ||

　　wc >= (core ? corePoolSize : maximumPoolSize))

　　return false;

　　//没有的话就尝试修改ctl添加workerCount的值。这里用了cas操作,如果失败了下一个循环会继续重试,直到设置成功

　　if (compareAndIncrementWorkerCount(c))

　　//如果设置成功了就跳出外层的那个for循环

　　break retry;

　　//重读一次ctl,判断如果线程池的状态改变了,会再重新循环一次

　　c = ctl.get(); // Re-read ctl

　　if (runStateOf(c) != rs)

　　continue retry;

　　}

　　}

　　boolean workerStarted = false;

　　boolean workerAdded = false;

　　Worker w = null;

　　try {

　　final ReentrantLock mainLock = this.mainLock;

　　//创建一个worker,将提交上来的任务直接交给worker

　　w = new Worker(firstTask);

　　final Thread t = w.thread;

　　if (t != null) {

　　//加锁,防止竞争

　　mainLock.lock();

　　try {

　　int c = ctl.get();

　　int rs = runStateOf(c);

　　//还是判断线程池的状态

　　if (rs < SHUTDOWN ||

　　(rs == SHUTDOWN && firstTask == null)) {

　　//如果worker的线程已经启动了,会抛出异常

　　if (t.isAlive())

　　throw new IllegalThreadStateException();

　　//添加新建的worker到线程池中

　　workers.add(w);

　　int s = workers.size();

　　//更新历史worker数量的较大值

　　if (s > largestPoolSize)

　　largestPoolSize = s;

　　//设置新增标志位

　　workerAdded = true;

　　}

　　} finally {

　　mainLock.unlock();

　　}

　　//如果worker是新增的,就启动该线程

　　if (workerAdded) {

　　t.start();

　　//成功启动了线程,设置对应的标志位

　　workerStarted = true;

　　}

　　}

　　} finally {

　　//如果启动失败了,会触发执行相应的方法

　　if (! workerStarted)

　　addWorkerFailed(w);

　　}

　　return workerStarted;

　　}