开始沉下心来好好分析jdk的类:
1.ThreadPoolExecutor中的主要变量:
runState:线程池的状态 有三种:RUNNING:0;SHUTDOWN:1;STOP:2;TERMINATED:3,默认是0;
BlockingQueue<Runnable> workQueue:所有要执行的任务;
HashSet<Worker> workers:池中所有的线程,它的数量和poolSize保持一致;
long keepAliveTime:当workers中的线程数量超过corePoolSize时,空闲时间超过这个字段的值的空闲线程就会被回收掉;
boolean allowCoreThreadTimeOut:是否允许核心线程数(corePoolSize)超时,如果值为true,当核心线程数超过keepAliveTime时,就会被回收,默认为false;
int corePoolSize:核心线程数,workers中的元素小于这个值时,有任务就新建线程;
int maximumPoolSize:线程池中的最大线程数,如果线程数超过此值,并且workQueue队列已满,则拒绝接受任务;
int poolSize:当前线程池中的线程数量,和workers中的元素数量一致;
2.创建ThreadPoolExecutor,建议使用Executors工厂类进行创建,也可以自己new,自己创建时需要设置合适的参数来保证线程池运行最优。
我们执行下面的初始化方法:
ThreadPoolExecutor executor = new ThreadPoolExecutor(3,8,60,TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(500), new ThreadPoolExecutor.CallerRunsPolicy()));
此方法执行之后,池中各主要变量的变化为:
runState:0; workQueue容量为500;workers为0;keepAliveTime:60秒;corePoolSize:3;maximumPoolSize:8 pooleSize:0
3.执行一次threadPoolExecutor.execute(Runnable)之后,各变量的变化:
workers中多了一个线程,poolSize为1;workQueue中没有元素,只有workers中的元素数量大于等于corePoolSize(3)时,才开始往workQueue中放元素;其他的主要变量在初始化之后,不再变化,以后变化的也就是workers、poolSize、workQueue、runState这四个变量。
4.分析execute()方法源码,来看看怎么使用这些变量的,主要有三种情况:
- poolSize<corePoolSize
- poolSize>=corePoolSize&&workQueue队列没满
- poolSize>=corePoolSize&&workQueue队列已满&&poolSize<maximumPoolSize
源码如下:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
} else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
第一种情况:poolSize<corePoolSize
前三次
先看if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))这一行,在前三次(含第三次)执行execute方法时,poolSize >= corePoolSize这个条件是不成立的,因为corePoolSize设置的是3,而poolSize的初始值是0,每执行一次excute方法,poolSize加1。那接下来看后面的这个条件:!addIfUnderCorePoolSize(command),此方法源码为:
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}
每次调用execute方法都会调用addIfUnderCorePoolSize方法,前三次执行到execute时,也及时前三次执行addIfUnderCorePoolSize方法时,if (poolSize < corePoolSize && runState == RUNNING)这个条件是成立的,会每次都执行到 t = addThread(firstTask);来新创建一个线程,然后启动线程,返回true。addIfUnderCorePoolSize方法执行完回到execute方法中调用的地方 !addIfUnderCorePoolSize(command)=false,所以前三次执行execute方法,只执行到 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))就结束了,条件里的代码是不执行的。
回过头再看下 t = addThread(firstTask)这个方法:
private Thread addThread(Runnable firstTask) {
Worker w = new Worker(firstTask);
Thread t = threadFactory.newThread(w);
if (t != null) {
w.thread = t;
workers.add(w);
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}
这个方法主要是将提交的任务封装到ThreadPoolExecutor的内部类Worker中,这个worker就是真正执行任务的线程,将worker放入workers中进行缓存,同时poolSize加1来记录池中线程的数量。
执行到的这些代码的意思也就明了了:当池中的线程数小于核心线程数时,有任务提交时,任务既不会往workQueue中放,也不会使用workers中已有的空闲线程,而是直接新建线程来执行任务。
第二种情况:poolSize>=corePoolSize&&workQueue队列没满
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize ||!addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
} else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
这种情况下addIfUnderCorePoolSize方法不会执行了,poolSize >= corePoolSize成立,直接进入判断条件内部,如果没有调用shutDown之类的方法,runState值依然是RUNNIING状态,并且将提交的任务放到任务队列workQueue中排队等待执行,execute方法执行结束。
第二种情况的意思就是:当池中的线程数大于等于核心线程数时,会把任务提交到workQueue任务队列中排队等待被执行。
第三种情况:poolSize>=corePoolSize&&workQueue队列已满&&poolSize<maximumPoolSize
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize ||!addIfUnderCorePoolSize(command)) {
if (runState == RUNNING &&workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
这种情况下:runState==RUNNING依然成立,只不过workQueue.offer(command)会返回false,因为队列已经满了,从而开始执行到else if (!addIfUnderMaximumPoolSize(command))这一行,看addIfUnderMaximumPoolSize方法的源码:
private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < maximumPoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}
addIfUnderMaximumPoolSize方法和addIfUnderCorePoolSize唯一不一样的地方就是前者是拿poolSize和maximumPoolSize比较,后者是拿poolSize和corePoolSize比较。
第三种情况表达的意思就是:池中的线程数大于等于核心线程数,并且任务队列也已满,且线程数小于最大线程数,就会继续创建worker线程来执行提交的任务。
如果任务队列满了,并且池中的线程数大于或等于最大线程数了,再提交的任务就会根据指定的策略来拒绝任务了。
以上是池中的线程增加的过程,那增加到最大线程数后,队列里没有要处理的任务了,线程数是怎么减下去的呢?这个就需要通过分析Worker内部类来了解了。
待续。。。