看到这个图片没?没错,就是一辆教练车!我,一个已经工作了好几年大龄暖男,最终还是走上了学车的道路!环顾周围,同事中几乎都手持驾照了。
早上挤出了一小时,练习科目二,前进,后退,前进,后退!最后小腿感觉麻木了,上班还晚了半小时。哎, 终究还是承受了这个年纪不该承受的酸痛~ 悔不当初啊,大学那么闲,干啥不把驾照考了啊!
由此我们可以看到,嗯,挣钱真的很重要啊!有钱了直接请个司机,它不香么?学什么车啊!
言归正传,车不车的咱先不管,当然,也不能随便开车,不然博客都没法发了,嘿嘿!
我们想要跟踪下线程池中线程的运行,肯定是要借助编译工具的,个人用的是idea,使用其他工具的哥们可以去百度下debug的处理。异步线程调试,不知道大家有没有调试过。
先来一个简单的程序(没错,我就是来凑字数滴☺)~
public static void main(String[] args) throws Exception {
ZnThreadPoolExecutor poolExecutor = new ZnThreadPoolExecutor(3, 6, 0, TimeUnit.SECONDS, new LinkedBlockingQueue(10));
CountDownLatch countDownLatch = new CountDownLatch(1);
System.out.println( "进入前打印:" +Thread.currentThread().getName()+" id:" + Thread.currentThread().getId());
poolExecutor.execute(()->{
System.out.println( "方法中的运行线程:" +Thread.currentThread().getName()+" id:" + Thread.currentThread().getId());
System.out.println("线程运行了!!");
countDownLatch.countDown();
});
// 保证异步程序运行了
countDownLatch.await();
System.out.println("主线程运行结束!");
poolExecutor.shutdown();
}
上文中,ZnThreadPoolExecutor 是我直接复制ThreadPoolExecutor代码,然后稍作修改(主流程/逻辑没变),生成的类。大家把它当成ThreadPoolExecutor就好。
这是一个简单的线程池程序,先构造一个线程池,然后启动执行,打印一句话,然后就没了。
那么,问几个小小的问题: poolExecutor.execute 这行代码执行做了什么操作?创建新的线程了么?启动新的线程了么?
我们来进入代码看一看。
首先说个调试的小技巧,就是异步线程调试的时候,在断点处右击,选择Thread,不然的话,没法进行异步线程调试滴。
如图我们添加了断点,哪怕是异步线程的执行也可以走进去的,还有就是,我提前打印了线程的名称和Id,方便进入方法之后的对比。当然,在 execute 方法中肯定要加断点,不然直接跑过了就不好了。
好,启动方法!由于断点已经加好,直接点击F9就好,不用一步一步来了。
可以看到,已经进入了线程池方法,进入方法前,我打印了线程信息,毫无疑问是main线程!那么进来之后呢?我也打印了线程名和线程id,运行之后,如图所示:
可以看到,也是main线程!也就是说运行 execute 方法的线程就是main线程!就好似线程启动一样,创建线程的时候可以进行线程设置,设置名称啊,父线程啊,优先级啊等等,如果不执行start方法,系统是不会重新开辟一个线程资源运行线程的。而线程池这里,明显是没有调用start方法的,所以这里运行的线程就是main线程,根本没有什么所谓的开辟新线程!
然后继续往下走!
注意这里的入参,Runnable command !这个是什么,大家应该很清楚吧?没错,就是新线程运行的run方法,只是还没有调用而已。
下面的代码在之前的博客中都有讲解,有空的兄弟可以去看下,下面我们直接进入 addWorker 中的 t.start()这里。
毫无疑问,目前的线程还是main线程,然后就是运行 t.start()。
在这里,明显是启动了一个新线程,异步运行我们需要执行的逻辑。这里的t是哪里来的呢?
没错!t就是Worker中获取的,那么t.start()运行的run()方法,自然也要到Worker中去寻找,我们来看一下。
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
可以看到Worker继承于AQS,实现了Runnable,咦,开启线程的常用的两种方法是什么来着?继承Thread和实现Runnable,这里明显就是一个实现Runnable的内部类!我们来看下其中的run方法。
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
System.out.println("runWorker线程名称:"+wt.getName()+" id:"+wt.getId());
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
这里明显有封装了一层,在run方法中运行runWorker方法,具体的实现逻辑是在runWorker方法中实现的。那么怎么进入runWorker方法呢?是不是点击下一步直接就过去了?哈哈。
在runWorker中提前打好断点,设置成Thread,然后点击F9 就能进来了!进入之后,我们看下运行的线程
没错,在这里线程池明显是启动了新的线程运行run方法!那么什么时候开始运行我们的代码逻辑呢?继续往下看。
没错!运行task.run();之后,才会运行我们的代码逻辑!我们进去看看。
咦,执行task.run()之后,线程怎么还是之前的线程?不应该重新启动一个线程么?启动什么啊,老铁!调用方法使用的是run!有没有调用start方法,启动啥线程啊,Thread里面的run方法和start方法,啥区别又迷糊了?调用start的时候才会启动新的线程,调用run的时候就是方法的调用,根本不会启动新线程的哦!
下面运行完就结束了,就不截图了,还有个东西想要提一下。
说两个问题,第一,线程是怎么从缓存队列里面获取任务的?运行完之后等分配还是其他?第二,还有就是线程怎么关闭啊?好像在这里面都没看到啊!我们来看下,一个十分关键的方法getTask()!
是的,你没有想错,都在这里了!我们进去看下。
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 校验
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 三目运算!如果是最后一个的话,超时的话就返回为空。take也是取出队列的头元素,不过如果获取不到会阻塞
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
这一步设计的很巧妙!
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
存活时间就是大于核心线程数小于最大线程数的线程等待的时间!如果缓存队列已经里面的元素取完了,过了keepAliveTime之后,线程就跳出这个循环,然后进入runWorker中的finally方法,而如果是核心线程的话,根据allowCoreThreadTimeOut这个字段确认!因为这行代码:
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
三目运算符的判断值,主要就是根据这行代码来的!
/**
* If false (default), core threads stay alive even when idle.
* If true, core threads use keepAliveTime to time out waiting
* for work.
*/
private volatile boolean allowCoreThreadTimeOut;
翻译下上面的注释:如果为false(默认值),则核心线程即使在空闲时也保持活动状态。如果为true,则核心线程使用keepAliveTime来超时等待为了工作。
也就是说allowCoreThreadTimeOut默认是false,也就是三目运算符会执行 workQueue.take() !没错!如果没有任务的话,就是缓存队列线程阻塞(阻塞队列的知识点,不太明白的老铁可以去看看阻塞队列的内容)!直到有新的任务到来!核心线程根本就走不出runWork中的循环方法,所以根本就不会关闭啊!
至于其他线程,我们看下runWork中的finally执行的方法processWorkerExit !在这里执行了 workers.remove(w);也就是把worker从set集合中移除了,线程池中的线程数量也就减一!最后方法执行完毕!方法执行完毕了,线程怎么了?你停了么?
停啥啊,老铁!你开个线程执行代码,代码执行完了,线程不就over了,难道每次执行完代码,还要来个stop?这个方法结束,线程 也就结束了!也就是线程池中的一个线程走到了生命的终点~
以上就是线程池中线程运行的大致过程,如有错误,还请指出!
No sacrifice,no victory~ 感觉还行的话关注下呗,点个赞也行哈!