Skip to content

Commit ccb7ba9

Browse files
SnailclimbSnailclimb
committed
Update java线程池学习总结.md
1 parent c660f5a commit ccb7ba9

File tree

1 file changed

+133
-24
lines changed

1 file changed

+133
-24
lines changed

‎docs/java/Multithread/java线程池学习总结.md

+133-24
Original file line numberDiff line numberDiff line change
@@ -312,32 +312,32 @@ public class ThreadPoolExecutorDemo {
312312
**Output：**
313313

314314
```
315-
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:44 CST 2019
316-
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:44 CST 2019
317-
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:44 CST 2019
318-
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:44 CST 2019
319-
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:44 CST 2019
320-
pool-1-thread-5 End. Time = Tue Nov 12 20:59:49 CST 2019
321-
pool-1-thread-3 End. Time = Tue Nov 12 20:59:49 CST 2019
322-
pool-1-thread-2 End. Time = Tue Nov 12 20:59:49 CST 2019
323-
pool-1-thread-4 End. Time = Tue Nov 12 20:59:49 CST 2019
324-
pool-1-thread-1 End. Time = Tue Nov 12 20:59:49 CST 2019
325-
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:49 CST 2019
326-
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:49 CST 2019
327-
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:49 CST 2019
328-
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:49 CST 2019
329-
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:49 CST 2019
330-
pool-1-thread-2 End. Time = Tue Nov 12 20:59:54 CST 2019
331-
pool-1-thread-3 End. Time = Tue Nov 12 20:59:54 CST 2019
332-
pool-1-thread-4 End. Time = Tue Nov 12 20:59:54 CST 2019
333-
pool-1-thread-5 End. Time = Tue Nov 12 20:59:54 CST 2019
334-
pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019
315+
pool-1-thread-3 Start. Time = Sun Apr 12 11:14:37 CST 2020
316+
pool-1-thread-5 Start. Time = Sun Apr 12 11:14:37 CST 2020
317+
pool-1-thread-2 Start. Time = Sun Apr 12 11:14:37 CST 2020
318+
pool-1-thread-1 Start. Time = Sun Apr 12 11:14:37 CST 2020
319+
pool-1-thread-4 Start. Time = Sun Apr 12 11:14:37 CST 2020
320+
pool-1-thread-3 End. Time = Sun Apr 12 11:14:42 CST 2020
321+
pool-1-thread-4 End. Time = Sun Apr 12 11:14:42 CST 2020
322+
pool-1-thread-1 End. Time = Sun Apr 12 11:14:42 CST 2020
323+
pool-1-thread-5 End. Time = Sun Apr 12 11:14:42 CST 2020
324+
pool-1-thread-1 Start. Time = Sun Apr 12 11:14:42 CST 2020
325+
pool-1-thread-2 End. Time = Sun Apr 12 11:14:42 CST 2020
326+
pool-1-thread-5 Start. Time = Sun Apr 12 11:14:42 CST 2020
327+
pool-1-thread-4 Start. Time = Sun Apr 12 11:14:42 CST 2020
328+
pool-1-thread-3 Start. Time = Sun Apr 12 11:14:42 CST 2020
329+
pool-1-thread-2 Start. Time = Sun Apr 12 11:14:42 CST 2020
330+
pool-1-thread-1 End. Time = Sun Apr 12 11:14:47 CST 2020
331+
pool-1-thread-4 End. Time = Sun Apr 12 11:14:47 CST 2020
332+
pool-1-thread-5 End. Time = Sun Apr 12 11:14:47 CST 2020
333+
pool-1-thread-3 End. Time = Sun Apr 12 11:14:47 CST 2020
334+
pool-1-thread-2 End. Time = Sun Apr 12 11:14:47 CST 2020
335335
336336
```
337337

338338
### 4.2 线程池原理分析
339339

340-
承接 4.1 节，我们通过代码输出结果可以看出：**线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。** 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会）
340+
承接 4.1 节，我们通过代码输出结果可以看出：**线程首先会先执行 5 个任务，然后这些任务有任务被执行完的话，就会去拿新的任务执行。** 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会）
341341

342342
现在，我们就分析上面的输出内容来简单分析一下线程池原理。
343343

@@ -346,11 +346,11 @@ pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019
346346
```java
347347
// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
348348
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
349-
349+
350350
private static int workerCountOf(int c) {
351351
return c & CAPACITY;
352352
}
353-
353+
//任务队列
354354
private final BlockingQueue<Runnable> workQueue;
355355

356356
public void execute(Runnable command) {
@@ -390,11 +390,120 @@ pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019
390390

391391
![图解线程池实现原理](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/图解线程池实现原理.png)
392392

393+
394+
395+
**`addWorker` 这个方法主要用来创建新的工作线程，如果返回true说明创建和启动工作线程成功，否则的话返回的就是false。**
396+
397+
```java
398+
// 全局锁，并发操作必备
399+
private final ReentrantLock mainLock = new ReentrantLock();
400+
// 跟踪线程池的最大大小，只有在持有全局锁mainLock的前提下才能访问此集合
401+
private int largestPoolSize;
402+
// 工作线程集合，存放线程池中所有的（活跃的）工作线程，只有在持有全局锁mainLock的前提下才能访问此集合
403+
private final HashSet<Worker> workers = new HashSet<>();
404+
//获取线程池状态
405+
private static int runStateOf(int c) { return c & ~CAPACITY; }
406+
//判断线程池的状态是否为 Running
407+
private static boolean isRunning(int c) {
408+
return c < SHUTDOWN;
409+
}
410+
411+
412+
/**
413+
* 添加新的工作线程到线程池
414+
* @param firstTask 要执行
415+
* @param core参数为true的话表示使用线程池的基本大小，为false使用线程池最大大小
416+
* @return 添加成功就返回true否则返回false
417+
*/
418+
private boolean addWorker(Runnable firstTask, boolean core) {
419+
retry:
420+
for (;;) {
421+
//这两句用来获取线程池的状态
422+
int c = ctl.get();
423+
int rs = runStateOf(c);
424+
425+
// Check if queue empty only if necessary.
426+
if (rs >= SHUTDOWN &&
427+
! (rs == SHUTDOWN &&
428+
firstTask == null &&
429+
! workQueue.isEmpty()))
430+
return false;
431+
432+
for (;;) {
433+
//获取线程池中线程的数量
434+
int wc = workerCountOf(c);
435+
// core参数为true的话表明队列也满了，线程池大小变为 maximumPoolSize
436+
if (wc >= CAPACITY ||
437+
wc >= (core ? corePoolSize : maximumPoolSize))
438+
return false;
439+
//原子操作将workcount的数量加1
440+
if (compareAndIncrementWorkerCount(c))
441+
break retry;
442+
// 如果线程的状态改变了就再次执行上述操作
443+
c = ctl.get();
444+
if (runStateOf(c) != rs)
445+
continue retry;
446+
// else CAS failed due to workerCount change; retry inner loop
447+
}
448+
}
449+
// 标记工作线程是否启动成功
450+
boolean workerStarted = false;
451+
// 标记工作线程是否创建成功
452+
boolean workerAdded = false;
453+
Worker w = null;
454+
try {
455+
456+
w = new Worker(firstTask);
457+
final Thread t = w.thread;
458+
if (t != null) {
459+
// 加锁
460+
final ReentrantLock mainLock = this.mainLock;
461+
mainLock.lock();
462+
try {
463+
//获取线程池状态
464+
int rs = runStateOf(ctl.get());
465+
//rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中
466+
//(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启动新的Worker
467+
// firstTask == null证明只新建线程而不执行任务
468+
if (rs < SHUTDOWN ||
469+
(rs == SHUTDOWN && firstTask == null)) {
470+
if (t.isAlive()) // precheck that t is startable
471+
throw new IllegalThreadStateException();
472+
workers.add(w);
473+
//更新当前工作线程的最大容量
474+
int s = workers.size();
475+
if (s > largestPoolSize)
476+
largestPoolSize = s;
477+
// 工作线程是否启动成功
478+
workerAdded = true;
479+
}
480+
} finally {
481+
// 释放锁
482+
mainLock.unlock();
483+
}
484+
//// 如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方法启动真实的线程实例
485+
if (workerAdded) {
486+
t.start();
487+
/// 标记线程启动成功
488+
workerStarted = true;
489+
}
490+
}
491+
} finally {
492+
// 线程启动失败，需要从工作线程中移除对应的Worker
493+
if (! workerStarted)
494+
addWorkerFailed(w);
495+
}
496+
return workerStarted;
497+
}
498+
```
499+
500+
更多关于线程池源码分析的内容推荐这篇文章：《[JUC线程池ThreadPoolExecutor源码分析](http://www.throwable.club/2019/07/15/java-concurrency-thread-pool-executor/)》
501+
393502
现在，让我们在回到 4.1 节我们写的 Demo， 现在应该是不是很容易就可以搞懂它的原理了呢？
394503

395504
没搞懂的话，也没关系，可以看看我的分析：
396505

397-
> 我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务执行完成后，才会执行剩下的 5 个任务。
506+
> 我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的5个任务中如果有任务被执行完了，线程池就会去拿新的任务执行。
398507
399508
### 4.3 几个常见的对比
400509

0 commit comments

Comments
 (0)