阿里的面试官问了个问题,如果corepollSize=10,MaxPollSize=20,如果来了25个线程 怎么办,
答案:
当一个任务通过execute(Runnable)方法欲添加到线程池时:1、 如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。2、 如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。3、如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,再有新的线程,开始增加线程池的线程数量处理新的线程,直到maximumPoolSize;4、 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。5、 当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
当线程数小于corePoolSize时,提交一个任务创建一个线程(即使这时有空闲线程)来执行该任务。
当线程数大于等于corePoolSize,首选将任务添加等待队列workQueue中(这里的workQueue是上面的BlockingQueue),等有空闲线程时,让空闲线程从队列中取任务。
当等待队列满时,如果线程数量小于maximumPoolSize则创建新的线程,否则使用拒绝线程处理器来处理提交的任务。
慢慢的启动到10,然后把剩下的15个放到阻塞队列里面,并开始在线程池里面创建线程,直到最大MaximumPoolSize;
当然是先放在阻塞队列(如果数量为0,就一直等待,LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列,两边都可以进出的,那种,
参考:聊聊并发(七)——Java中的阻塞队列)里面了,BlockingQueue,面试官想知道具体的处理流程,我掌握的不深,于是下定决心好好查查:
尤其是那个车间里工人的例子,好好看看,理解线程很有用:
在上一章中我们概述了一下线程池,这一章我们看一下创建newFixedThreadPool的源码。例子还是我们在上一章中写的那个例子。
创建newFixedThreadPool的方法:
publicstaticExecutorService newFixedThreadPool(int nThreads) {
returnnew ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
newLinkedBlockingQueue());
}
publicstaticExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
returnnew ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
newLinkedBlockingQueue(),
threadFactory);
}
上面这两个方法是创建固定数量的线程池的两种方法,两者的区别是:第二种创建方法多了一个线程工厂的方法。我们继续看ThreadPoolExecutor这个类中的构造函数:
ThreadPoolExecutor的构造函数:
publicThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }
publicThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if(corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
thrownew IllegalArgumentException();
if(workQueue ==null|| threadFactory ==null|| handler ==null)
thrownew NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
ThreadPollExecutor中的所有的构造函数最终都会调用上面这个构造函数,接下来我们来分析一下这些参数的含义:
corePoolSize:
线程池启动后,在池中保持的线程的最小数量。需要说明的是线程数量是逐步到达corePoolSize值的。例如corePoolSize被设置为10,而任务数量只有5,则线程池中最多会启动5个线程,而不是一次性地启动10个线程。
maxinumPoolSize:
线程池中能容纳的最大线程数量,如果超出,则使用RejectedExecutionHandler拒绝策略处理。
keepAliveTime:
线程的最大生命周期。这里的生命周期有两个约束条件:一:该参数针对的是超过corePoolSize数量的线程;二:处于非运行状态的线程。举个例子:如果corePoolSize(最小线程数)为10,maxinumPoolSize(最大线程数)为20,而此时线程池中有15个线程在运行,过了一段时间后,其中有3个线程处于等待状态的时间超过keepAliveTime指定的时间,则结束这3个线程,此时线程池中则还有12个线程正在运行。
unit:
这是keepAliveTime的时间单位,可以是纳秒,毫秒,秒,分钟等。
workQueue:
任务队列。当线程池中的线程都处于运行状态,而此时任务数量继续增加,则需要一个容器来容纳这些任务,这就是任务队列。这个任务队列是一个阻塞式的单端队列。
newFixedThreadPool和newSingleThreadExector使用的是LinkedBlockingQueue的无界模式(美团面试题目)。
threadFactory:
定义如何启动一个线程,可以设置线程的名称,并且可以确定是否是后台线程等。
handler:
拒绝任务处理器。由于超出线程数量和队列容量而对继续增加的任务进行处理的程序。
OK,ThreadPoolExecutor中的主要参数介绍完了。我们再说一下线程的管理过程:首先创建一个线程池,然后根据任务的数量逐步将线程增大到corePoolSize,如果此时仍有任务增加,则放置到workQueue中,直到workQueue爆满为止,然后继续增加池中的线程数量(增强处理能力),最终达到maxinumPoolSize。那如果此时还有任务要增加进来呢?这就需要handler来处理了,或者丢弃新任务,或者拒绝新任务,或者挤占已有的任务(拒绝策略,美团面试)。在任务队列和线程池都饱和的情况下,一旦有线程处于等待(任务处理完毕,没有新任务)状态的时间超过keepAliveTime,则该线程终止,也就是说池中的线程数量会逐渐降低,直至为corePoolSize数量为止。
总结:
ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
TimeUnit unit,
BlockingQueueworkQueueRejectedExecutionHandler handler) corePoolSize: 线程池维护线程的最少线程数,也是核心线程数,包括空闲线程maximumPoolSize: 线程池维护线程的最大线程数keepAliveTime: 线程池维护线程所允许的空闲时间unit: 程池维护线程所允许的空闲时间的单位workQueue: 线程池所使用的缓冲队列handler: 线程池对拒绝任务的处理策略
在《编写高质量代码 改善Java程序的151个建议》这本书里举的这个例子很形象:
OK,接下来我们来看一下怎么往任务队里中放入线程任务:在java.util.concurrent.AbstractExecutorService这个类的submit方法
submit方法
publicFuture submit(Runnable task) {
if(task ==null)thrownew NullPointerException();
RunnableFuture ftask = newTaskFor(task,null);
execute(ftask);//执行任务 return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/public Future submit(Runnable task, T result) {
if(task ==null)thrownew NullPointerException();
RunnableFuture ftask = newTaskFor(task, result);
execute(ftask);//执行任务 return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/public Future submit(Callable task) {
if(task ==null)thrownew NullPointerException();
RunnableFuture ftask = newTaskFor(task);
execute(ftask);//执行任务 return ftask;
}
![](http://img.e-com-net.com/image/info10/e5e1ad71745b43cb8454b4711a9189c6.gif)
这是三个重载方法,分别对应Runnable、带结果的Runnable接口和Callable回调函数。其中的newTaskFor也是一个重载的方法,它通过层层的包装,把Runnable接口包装成了适配RunnableFuture的实现类,底层实现如下:
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;// ensure visibility of callable }
publicstatic Callable callable(Runnable task, T result) {
if(task ==null)
thrownew NullPointerException();
returnnewRunnableAdapter(task, result);
}
![](http://img.e-com-net.com/image/info10/4d3e4cd957cd4adeb59913932a2cab47.gif)
staticfinalclassRunnableAdapterimplementsCallable {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
![](http://img.e-com-net.com/image/info10/6371ec307fc3469c83638f3725aed7c8.gif)
在submit中最重要的是execute这个方法,这个方法也是我们分析的重点
execute方法:
![](http://img.e-com-net.com/image/info10/a055323e5ca0402b816c0d65167bd2a3.gif)
publicvoid execute(Runnable command) {
if(command ==null)
thrownew NullPointerException();
intc = ctl.get();
if(workerCountOf(c) < corePoolSize) {//if(addWorker(command,true))
return;
c = ctl.get();
}
if(isRunning(c) && workQueue.offer(command)) {
intrecheck = ctl.get();
if(! isRunning(recheck) && remove(command))
reject(command);
elseif(workerCountOf(recheck) == 0)
addWorker(null,false);
}
elseif(!addWorker(command,false))
reject(command);
}
![](http://img.e-com-net.com/image/info10/ef64a30e838b421c9e42aa9ae0a5cf19.gif)
在这个方法中分为三部分
1、如果少于corePoolSize数量的线程在运行,则启动一个新的线程并把传进来的Runnable做为第一个任务。然后会检查线程的运行状态和worker的数量,阻止不符合要求的任务添加到线程中
2、如果一个任务成功的放入到了队列中,我们仍然需要二次检查我们是否应该添加线程或者停止。因此我们重新检查线程状态,是否需要回滚队列,或者是停止或者是启动一个新的线程
3、如果我们不能添加队列任务了,但是仍然在往队列中添加任务,如果添加失败的话,用拒绝策略来处理。
这里最主要的是addWorker这个方法:
![](http://img.e-com-net.com/image/info10/d5a838a8955e459fa65ebb3aa0f9d5a5.gif)
try {
w =new Worker(firstTask);
finalThread t = w.thread;
if(t !=null) {
finalReentrantLock mainLock =this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired. intrs = runStateOf(ctl.get());
if(rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask ==null)) {
if(t.isAlive())// precheck that t is startable thrownew IllegalThreadStateException();
workers.add(w);
ints = workers.size();
if(s > largestPoolSize)
largestPoolSize = s;
workerAdded =true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted =true;
}
}
} finally {
if(! workerStarted)
addWorkerFailed(w);
}
![](http://img.e-com-net.com/image/info10/4fe562de14d544eaaa270429b9cc834d.gif)
我们在这个方法里创建一个线程,注意这个线程不是我们的任务线程,而是经过包装的Worker线程。所以这里的run方法是Worker这个类中的run方法。execute方法是通过Worker类启动的一个工作线程,执行的是我们的第一个任务,然后该线程通过getTask方法从任务队列总获取任务,之后再继续执行。这个任务队列是一个BlockingQueue,是一个阻塞式的,也就是说如果该队列元素为0,则保持等待状态。直到有任务进入为止。
Java中的线程池
我们一般将任务(Task)提交到线程池中运行,对于一个线程池而言,需要关注的内容有以下几点:
在什么样的线程中执行任务
任务按照什么顺序来执行(FIFO,LIFO,优先级)
最多有多少个任务能并发执行
最多有多个任务等待执行
如果系统过载则需要拒绝一个任务,如何通知任务被拒绝?
在执行一个任务之前或之后需要进行哪些操作
围绕上面的问题,我们来研究一下java中的线程池
线程池的创建
Exectors.newFixedThreadPool(int size):创建一个固定大小的线程池。 每来一个任务创建一个线程,当线程数量为size将会停止创建。当线程池中的线程已满,继续提交任务,如果有空闲线程那么空闲线程去执行任务,否则将任务添加到一个无界的等待队列中。
Exectors.newCachedThreadPool():创建一个可缓存的线程池。对线程池的规模没有限制,当线程池的当前规模超过处理需求时(比如线程池中有10个线程,而需要处理的任务只有5个),那么将回收空闲线程。当需求增加时则会添加新的线程。
Exectors.newSingleThreadExcutor():创建一个单线程的Executor,它创建单个工作者线程来执行任务,如果这个线程异常结束,它会创建另一个线程来代替。
Exectors.newScheduledThreadPool():创建一个固定长度的线程池,而且以延迟或定时的方式来执行任务。
上面都是通过工厂方法来创建线程池,其实它们内部都是通过创建ThreadPoolExector对象来创建线程池的。下面是ThreadPoolExctor的构造函数。
![](http://img.e-com-net.com/image/info10/08b7524759784abfa10e2a079a74097a.gif)
publicThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
...
}
![](http://img.e-com-net.com/image/info10/b8d7c89e5b6245c6b6a49703b1424db2.gif)
我们看到构造函数是public类型的,所以我们也可以自定义自己的线程池。
在什么样的线程中执行任务?
java中对于任务的描述有两种,一种是Runnable型的任务,一种是Callable型的任务。前者运行结束后不会返回任何东西,而后者可以返回我们需要的计算结果,甚至异常。
在没有返回值的线程中运行
创建一个线程池,然后调用其execute方法,并将一个Runnable对象传递进去即可。
![](http://img.e-com-net.com/image/info10/2d876bf084e24e10995350e0750530a4.gif)
ExectorService exector = Exectors.newCachedThreadPool();
exector.execute(new Runnable(){publicvoid run(){
System.out.println("running...");
}
});
![](http://img.e-com-net.com/image/info10/7317dca7d8944adaa155b24961c62a45.gif)
在有返回值的线程中运行
![](http://img.e-com-net.com/image/info10/9695e99104644e0c88df6454cdd48121.gif)
ExectorService exector = Exectors.newCachedThreadPool();
Callable task =newCallable() {
public Result call() {
returnnew Computor().compute();
}
};
Future future = exector.submit(task);
result = future.get();//改方法会一直阻塞,直到提交的任务被运行完毕
![](http://img.e-com-net.com/image/info10/e3e10b0c62164e818002fe3d165461fa.gif)
任务按照什么顺序来执行(FIFO,优先级)
如果任务按照某种顺序来执行的话,则任务一定是串行执行的。我们可以看到在ThreadPoolExecutor中第四个参数是BlockingQueue,提交的任务都先放到该队列中。如果传入不同的BlockQueue就可以实现不同的执行顺序。传入LinkedBlockingQueue则表示先来先服务,传入PriorityBlockingQueue则使用优先级来处理任务
Exectors.newSingleThreadExcutor()使用的是先来先服务策略
最多有多少个任务能并发执行
线程池中的线程会不断从workQueue中取任务来执行,如果没任务可执行,则线程处于空闲状态。
在ThreadPoolExecutor中有两个参数corePoolSize和maximumPoolSize,前者被称为基本大小,表示一个线程池初始化时,里面应该有的一定数量的线程。但是默认情况下,ThreadPoolExecutor在初始化是并不会马上创建corePoolSize个线程对象,它使用的是懒加载模式。
当线程数小于corePoolSize时,提交一个任务创建一个线程(即使这时有空闲线程)来执行该任务。
当线程数大于等于corePoolSize,首选将任务添加等待队列workQueue中(这里的workQueue是上面的BlockingQueue),等有空闲线程时,让空闲线程从队列中取任务。
当等待队列满时,如果线程数量小于maximumPoolSize则创建新的线程,否则使用拒绝线程处理器来处理提交的任务。
最多有多少的任务等待执行
这个问题和BlockingQueue相关。 BlockingQueue有三个子类,一个是ArrayBlockingQueue(有界队列),一个是LinkedBlockingQueue(默认无界,但可以配置为有界),PriorityBlockingQueue(默认无界,可配置为有界)。所以,对于有多少个任务等待执行与传入的阻塞队列有关。
newFixedThreadPool和newSingleThreadExector使用的是LinkedBlockingQueue的无界模式。而newCachedThreadPool使用的是SynchronousQueue,这种情况下线程是不需要排队等待的,SynchronousQueue适用于线程池规模无界。
如果系统过载则需要拒绝一个任务,如何通知任务被拒绝?
当有界队列被填满或者某个任务被提交到一个已关闭的Executor时将会启动饱和策略,即使用RejectedExecutionHandler来处理。JDK中提供了几种不同的RejectedExecutionHandler的实现:AbortPolicy,CallerRunsPolicy, DiscardPolicy和DiscardOldestPolicy。
AbortPolicy:默认的饱和策略。该策略将抛出未检查的RejectedExcutionException,调用者可以捕获这个异常,然后根据自己的需求来处理。
DiscardPolicy:该策略将会抛弃提交的任务
DiscardOldestPolicy:该策略将会抛弃下一个将被执行的任务(处于队头的任务),然后尝试重新提交该任务到等待队列
CallerRunsPolicy:该策略既不会抛弃任务也不会抛出异常,而是在调用execute()的线程中运行任务。比如我们在主线程中调用了execute(task)方法,但是这时workQueue已经满了,并且也不会创建的新的线程了。这时候将会在主线程中直接运行execute中的task。
在执行一个任务之前或之后需要进行哪些操作
ThreadPoolExecutor是可扩展的,它提供了几个可以重载的方法:beforeExecute,afterExecute和terminated,这里用到了面向的切面编程的思想。无论任务是从run中正常返回,还是抛出异常而返回,afterExectue都会被调用。如果beforeExecute中抛出了一个RunntimeException,那么任务将不会被执行,并且afterExecute也不会被调用。
![](http://img.e-com-net.com/image/info10/805a9fafb04f4d45802c35af008e9ab4.gif)
import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicLong;publicclass Test {
publicstaticvoid main(String[] args) {
TimingThreadPool executor =newTimingThreadPool(5, 10, 1,
TimeUnit.MINUTES, newLinkedBlockingQueue());
for(inti = 0; i < 5; i++)
executor.execute(new Runnable() {
@Override
publicvoid run() {
System.out.println("running1....");
}
});
executor.shutdown();
}
}classTimingThreadPoolextends ThreadPoolExecutor {
privatefinalThreadLocal startTime =newThreadLocal();
privatefinalAtomicLong numTasks =new AtomicLong();
privatefinalAtomicLong totalTime =new AtomicLong();
publicTimingThreadPool(intcorePoolSize,int maximumPoolSize,
longkeepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
protectedvoid beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
startTime.set(System.nanoTime());
}
@Override
protectedvoid afterExecute(Runnable r, Throwable t) {
try {
longendTime = System.nanoTime();
longtaskTime = endTime - startTime.get();
numTasks.incrementAndGet();
totalTime.addAndGet(taskTime);
} finally {
super.afterExecute(r, t);
}
}
@Override
protectedvoid terminated() {
try {
System.out.println(String.format("Terminated: arg time = %d",
totalTime.get() / numTasks.get()));
} finally {
super.terminated();
}
}
}
![](http://img.e-com-net.com/image/info10/5e7f1f41540b4b57b859819ab3b5b7a9.gif)
上面的代码统计任务平均执行时间,在每个线程中beforeExecute和afertExecute都会执行一次,而terminated等线程池关闭的时候执行