看到这个图片没？没错，就是一辆教练车！我，一个已经工作了好几年大龄暖男，最终还是走上了学车的道路！环顾周围，同事中几乎都手持驾照了。
早上挤出了一小时，练习科目二，前进，后退，前进，后退！最后小腿感觉麻木了，上班还晚了半小时。哎， 终究还是承受了这个年纪不该承受的酸痛~ 悔不当初啊，大学那么闲，干啥不把驾照考了啊！
由此我们可以看到，嗯，挣钱真的很重要啊！有钱了直接请个司机，它不香么？学什么车啊！
言归正传，车不车的咱先不管，当然，也不能随便开车，不然博客都没法发了，嘿嘿！
我们想要跟踪下线程池中线程的运行，肯定是要借助编译工具的，个人用的是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~ 感觉还行的话关注下呗，点个赞也行哈！
1559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
