java并发编程之源码分析ThreadPoolExecutor线程池实现原理

最新推荐文章于 2024-07-30 20:50:32 发布

2301_82242844

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量644

点赞数 24

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_82242844/article/details/138464298

版权

程序员专栏收录该内容

555 篇文章 0 订阅

订阅专栏

Rejected tasks
任务拒绝策略

1）AbortPolicy，抛出运行时异常

2）CallerRunsPolicy 调用者直接运行，不在线程中运行。

3）DiscardPolicy 直接将任务丢弃

4）DiscardOldestPolicy 丢弃队列中头部的任务。

New tasks submitted in method {@link #execute} will be
rejected when the Executor has been shut down, and also
when the Executor uses finite bounds for both maximum threads and
work queue capacity, and is saturated. In either case, the {@code
execute} method invokes the {@link
RejectedExecutionHandler#rejectedExecution} method of its {@link
RejectedExecutionHandler}. Four predefined handler policies are
provided:
In the default {@link ThreadPoolExecutor.AbortPolicy}, the
handler throws a runtime {@link RejectedExecutionException} upon
rejection.
In {@link ThreadPoolExecutor.CallerRunsPolicy}, the thread
that invokes {@code execute} itself runs the task. This provides a
simple feedback control mechanism that will slow down the rate that
new tasks are submitted.
In {@link ThreadPoolExecutor.DiscardPolicy}, a task that
cannot be executed is simply dropped.
In {@link ThreadPoolExecutor.DiscardOldestPolicy}, if the
executor is not shut down, the task at the head of the work queue
is dropped, and then execution is retried (which can fail again,
causing this to be repeated.)
It is possible to define and use other kinds of {@link
RejectedExecutionHandler} classes. Doing so requires some care
especially when policies are designed to work only under particular
capacity or queuing policies.
Hook methods
This class provides {@code protected} overridable {@link
#beforeExecute} and {@link #afterExecute} methods that are called
before and after execution of each task. These can be used to
manipulate the execution environment; for example, reinitializing
ThreadLocals, gathering statistics, or adding log
entries. Additionally, method {@link #terminated} can be overridden
to perform any special processing that needs to be done once the
Executor has fully terminated.
If hook or callback methods throw exceptions, internal worker
threads may in turn fail and abruptly terminate.
Queue maintenance
Method {@link #getQueue} allows access to the work queue for
purposes of monitoring and debugging. Use of this method for any
other purpose is strongly discouraged. Two supplied methods,
{@link #remove} and {@link #purge} are available to assist in
storage reclamation when large numbers of queued tasks become
cancelled.
Finalization
A pool that is no longer referenced in a program AND
has no remaining threads will be {@code shutdown} automatically. If
you would like to ensure that unreferenced pools are reclaimed even
if users forget to call {@link #shutdown}, then you must arrange
that unused threads eventually die, by setting appropriate
keep-alive times, using a lower bound of zero core threads and/or
setting {@link #allowCoreThreadTimeOut(boolean)}.
Extension example. Most extensions of this class
override one or more of the protected hook methods. For example,
here is a subclass that adds a simple pause/resume feature:
```
 {@code
```
class PausableThreadPoolExecutor extends ThreadPoolExecutor {
private boolean isPaused;
private ReentrantLock pauseLock = new ReentrantLock();
private Condition unpaused = pauseLock.newCondition();
public PausableThreadPoolExecutor(…) { super(…); }
protected void beforeExecute(Thread t, Runnable r) {
```
super.beforeExecute(t, r);
```
```
pauseLock.lock();
```
```
try {
```
```
  while (isPaused) unpaused.await();
```
```
} catch (InterruptedException ie) {
```
```
  t.interrupt();
```
```
} finally {
```
```
  pauseLock.unlock();
```
```
}
```
}
public void pause() {
```
pauseLock.lock();
```
```
try {
```
```
  isPaused = true;
```
```
} finally {
```
```
  pauseLock.unlock();
```
```
}
```
}
public void resume() {
```
pauseLock.lock();
```
```
try {
```
```
  isPaused = false;
```
```
  unpaused.signalAll();
```
```
} finally {
```
```
  pauseLock.unlock();
```
```
}
```
}
}}
@since 1.5
@author Doug Lea

2、ThreadPoolExecutors 内部数据结构与构造方法详解

===================================

ThreadPoolExecutors的完整构造函数如下，从构造函数中能得出线程池最核心的属性。

/**

Creates a new {@code ThreadPoolExecutor} with the given initial
parameters.
@param corePoolSize the number of threads to keep in the pool, even

   if they are idle, unless {@code allowCoreThreadTimeOut} is set

@param maximumPoolSize the maximum number of threads to allow in the
```
   pool
```
@param keepAliveTime when the number of threads is greater than

   the core, this is the maximum time that excess idle threads

   will wait for new tasks before terminating.

@param unit the time unit for the {@code keepAliveTime} argument
@param workQueue the queue to use for holding tasks before they are

   executed.  This queue will hold only the {@code Runnable}

   tasks submitted by the {@code execute} method.

@param threadFactory the factory to use when the executor
```
   creates a new thread
```
@param handler the handler to use when execution is blocked

   because the thread bounds and queue capacities are reached

@throws IllegalArgumentException if one of the following holds:
```
    {@code corePoolSize < 0}<br>
```
```
    {@code keepAliveTime < 0}<br>
```
```
    {@code maximumPoolSize <= 0}<br>
```

    {@code maximumPoolSize < corePoolSize}

@throws NullPointerException if {@code workQueue}

    or {@code threadFactory} or {@code handler} is null

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler) {

if (corePoolSize < 0 ||

maximumPoolSize <= 0 ||

maximumPoolSize < corePoolSize ||

keepAliveTime < 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

corePoolSize 核心线程数
maximumPoolSize 最大线程数
keepAliveTime 线程保持激活状态的时间，如果为0，永远处于激活状态
unit ，keepAliveTime的单位
workQueue，线程池使用的队列
threadFactory 创建线程的工厂
handler 当队列已满，无更大线程处理任务时的拒绝任务的策略。

除了这些核心参数外，我觉得有必要再关注如下。

HashSet workers
completedTaskCount 完成的任务数
allowCoreThreadTimeOut，该值默认为false,也就是默认keepAliveTime不会生效。

3、核心源码分析

========

3.1 线程状态与几个基础方法设计原理

/**

The main pool control state, ctl, is an atomic integer packing
two conceptual fields
workerCount, indicating the effective number of threads
runState, indicating whether running, shutting down etc
In order to pack them into one int, we limit workerCount to
(2^29)-1 (about 500 million) threads rather than (2^31)-1 (2
billion) otherwise representable. If this is ever an issue in
the future, the variable can be changed to be an AtomicLong,
and the shift/mask constants below adjusted. But until the need
arises, this code is a bit faster and simpler using an int.
The workerCount is the number of workers that have been
permitted to start and not permitted to stop. The value may be
transiently different from the actual number of live threads,
for example when a ThreadFactory fails to create a thread when
asked, and when exiting threads are still performing
bookkeeping before terminating. The user-visible pool size is
reported as the current size of the workers set.
The runState provides the main lifecyle control, taking on values:
RUNNING: Accept new tasks and process queued tasks
SHUTDOWN: Don’t accept new tasks, but process queued tasks
STOP: Don’t accept new tasks, don’t process queued tasks,

        and interrupt in-progress tasks

TIDYING: All tasks have terminated, workerCount is zero,

        the thread transitioning to state TIDYING

        will run the terminated() hook method

TERMINATED: terminated() has completed
The numerical order among these values matters, to allow
ordered comparisons. The runState monotonically increases over
time, but need not hit each state. The transitions are:
RUNNING -> SHUTDOWN
On invocation of shutdown(), perhaps implicitly in finalize()
(RUNNING or SHUTDOWN) -> STOP
On invocation of shutdownNow()
SHUTDOWN -> TIDYING
When both queue and pool are empty
STOP -> TIDYING
When pool is empty
TIDYING -> TERMINATED
When the terminated() hook method has completed
Threads waiting in awaitTermination() will return when the
state reaches TERMINATED.
Detecting the transition from SHUTDOWN to TIDYING is less
straightforward than you’d like because the queue may become
empty after non-empty and vice versa during SHUTDOWN state, but
we can only terminate if, after seeing that it is empty, we see
that workerCount is 0 (which sometimes entails a recheck – see
below).

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

private static final int COUNT_BITS = Integer.SIZE - 3;

private static final int CAPACITY = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits

private static final int RUNNING = -1 << COUNT_BITS;

private static final int SHUTDOWN = 0 << COUNT_BITS;

private static final int STOP = 1 << COUNT_BITS;

private static final int TIDYING = 2 << COUNT_BITS;

private static final int TERMINATED = 3 << COUNT_BITS;

// Packing and unpacking ctl

private static int runStateOf(int c) { return c & ~CAPACITY; }

private static int workerCountOf(int c) { return c & CAPACITY; }

private static int ctlOf(int rs, int wc) { return rs | wc; }

private static boolean isRunning(int c) {

return c < SHUTDOWN;

}

相关源码解读：

不知大家有没有想过为什么线程池的状态简单的定义为 -1,0,1,2,3 不就得了，为什么还要用移位操作呢？

原来这样的，ThreadPool ctl 的这个变量的设计哲学是用int的高3位 + 29个0代表状态，用高位000+低29位来表示线程池中工作线程的数量，太佩服了。

首先 CAPACITY 的值为 workCount 的最大容量，该值为 000 11111 11111111 11111111 11111111,29个1，

我们来看一下

private static int runStateOf(int c) { return c & ~CAPACITY; }

用ctl里面的值与容量取反的方式获取状态值。由于CAPACITY的值为000 11111 11111111 11111111 11111111,那取反后为111 00000 00000000 00000000 00000000, 用 c 与该值进行与运算，这样就直接保留了c的高三位，然后将c的低29位设置为0,这不就是线程池状态的存放规则吗，绝。

根据此方法，不难得出计算workCount的方法。

private static int ctlOf(int rs, int wc) { return rs | wc; }

该方法，主要是用来更新运行状态的。确保工作线程数量不丢失。

线程池状态以及含义。

RUNNING 运行态
SHUTDOWN 关闭，此时不接受新的任务，但继续处理队列中的任务。
STOP 停止，此时不接受新的任务，不处理队列中的任务，并中断正在执行的任务
TIDYING 所有的工作线程全部停止，并工作线程数量为0，将调用terminated方法，进入到TERMINATED
TERMINATED 终止状态

线程池默认状态 RUNNING

如果调用shutdwon() 方法，状态从 RUNNING —> SHUTDOWN。

如果调用shutdwonNow()方法，状态从RUUNING|SHUTDOWN—>STOP。

SHUTDOWN —> TIDYING 。

队列为空并且线程池空。

STOP --> TIDYING。

线程池为空。

线程池设计原理：

线程池的工作线程为ThreadPoolExecutors的Worker线程，无论是submit还是executor方法中传入的Callable task,Runable参数，只是实现了Runnable接口，在线程池的调用过程，不会调用其start方法，只会调用Worker线程的start方法，然后在Worker线程的run方法中会调用入参的run方法。
众所周知，线程的生命周期在run方法运行结束后（包括异常退出）就结束。要想重复利用线程，我们要确保工作线程Worker的run方法运行在一个无限循环中，然后从任务队列中一个一个获取对象，如果任务队列为空，则阻塞，当然需要提供一些控制，结束无限循环，来销毁线程。在源码 runWorker方法与getTask来实现。

大概的实现思路是如果 getTask 返回null, 则该 worker 线程将被销毁。

那 getTask 在什么情况下会返回 false 呢？

如果线程池的状态为SHUTDOWN并且队列不为空
如果线程池的状态大于STOP
如果当前运行的线程数大于核心线程数，会返回null,已销毁该worker线程

对keepAliveTime的理解，如果allowCoreThreadTimeOut为真，那么keepAliveTime其实就是从任务队列获取任务等待的超时时间，也就是workerQueue.poll(keepALiveTime, TimeUnit.NANOSECONDS)

3.2 FUture submit(Callable task) 方法详解

在看的代码的过程中，只要明白了上述基础方法，后面的代码看起来清晰可见，故，我只列出关键方法，大家可以浏览，应该不难。

/**

Submits a value-returning task for execution and returns a
Future representing the pending results of the task. The
Future’s get method will return the task’s result upon
successful completion.
If you would like to immediately block waiting
for a task, you can use constructions of the form
result = exec.submit(aCallable).get();
Note: The {@link Executors} class includes a set of methods
that can convert some other common closure-like objects,
for example, {@link java.security.PrivilegedAction} to
{@link Callable} form so they can be submitted.
@param task the task to submit
@return a Future representing pending completion of the task
@throws RejectedExecutionException if the task cannot be
```
    scheduled for execution
```
@throws NullPointerException if the task is null

Future submit(Callable task);

提交一个任务，并返回结构到Future,Future就是典型的Future设计模式，就是提交任务到线程池后，返回一个凭证，并直接返回，主线程继续执行，然后当线程池将任务运行完毕后，再将结果填充到凭证中，当主线程调用凭证future的get方法时，如果结果还未填充，则阻塞等待。

现将Callable与Future接口的源代码贴出来，然后重点分析submit方法的实现。

public interface Callable {

/**

Computes a result, or throws an exception if unable to do so.
@return computed result
@throws Exception if unable to compute a result

V call() throws Exception;

}

public interface Future {

/**

Attempts to cancel execution of this task. This attempt will
fail if the task has already completed, has already been cancelled,
or could not be cancelled for some other reason. If successful,
and this task has not started when cancel is called,
this task should never run. If the task has already started,
then the mayInterruptIfRunning parameter determines
whether the thread executing this task should be interrupted in
an attempt to stop the task.
After this method returns, subsequent calls to {@link #isDone} will
always return true. Subsequent calls to {@link #isCancelled}
will always return true if this method returned true.
@param mayInterruptIfRunning true if the thread executing this
task should be interrupted; otherwise, in-progress tasks are allowed
to complete
@return false if the task could not be cancelled,
typically because it has already completed normally;
true otherwise

boolean cancel(boolean mayInterruptIfRunning);

/**

Returns true if this task was cancelled before it completed
normally.
@return true if this task was cancelled before it completed

boolean isCancelled();

/**

Returns true if this task completed.
Completion may be due to normal termination, an exception, or
cancellation – in all of these cases, this method will return
true.
@return true if this task completed

boolean isDone();

/**

Waits if necessary for the computation to complete, and then
retrieves its result.
@return the computed result
@throws CancellationException if the computation was cancelled
@throws ExecutionException if the computation threw an
exception
@throws InterruptedException if the current thread was interrupted
while waiting

V get() throws InterruptedException, ExecutionException;

/**

Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.
@param timeout the maximum time to wait
@param unit the time unit of the timeout argument
@return the computed result
@throws CancellationException if the computation was cancelled
@throws ExecutionException if the computation threw an
exception
@throws InterruptedException if the current thread was interrupted
while waiting
@throws TimeoutException if the wait timed out

V get(long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

}

现在开始探究submit的实现原理，该代码出自AbstractExecutorService中

public Future<?> submit(Runnable task) {

if (task == null) throw new NullPointerException();

RunnableFuture ftask = newTaskFor(task, null);

execute(ftask);

return ftask;

}

protected RunnableFuture newTaskFor(Callable callable) {

return new FutureTask(callable);

}

核心实现在ThreadPoolExecutor的execute方法

/**

Executes the given task sometime in the future. The task
may execute in a new thread or in an existing pooled thread.
If the task cannot be submitted for execution, either because this
executor has been shutdown or because its capacity has been reached,
the task is handled by the current {@code RejectedExecutionHandler}.
@param command the task to execute
@throws RejectedExecutionException at discretion of

    {@code RejectedExecutionHandler}, if the task

```
    cannot be accepted for execution
```
@throws NullPointerException if {@code command} is null

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

Proceed in 3 steps:
1. If fewer than corePoolSize threads are running, try to
start a new thread with the given command as its first
task. The call to addWorker atomically checks runState and
workerCount, and so prevents false alarms that would add
threads when it shouldn’t, by returning false.
1. If a task can be successfully queued, then we still need
to double-check whether we should have added a thread
(because existing ones died since last checking) or that
the pool shut down since entry into this method. So we
recheck state and if necessary roll back the enqueuing if
stopped, or start a new thread if there are none.
1. If we cannot queue task, then we try to add a new
thread. If it fails, we know we are shut down or saturated
and so reject the task.

int c = ctl.get();

if (workerCountOf© < corePoolSize) { // @1

if (addWorker(command, true)) // @2

return;

c = ctl.get(); //@3

}

if (isRunning© && workQueue.offer(command)) {

int recheck = ctl.get();

if (! isRunning(recheck) && remove(command))

reject(command);

else if (workerCountOf(recheck) == 0)

addWorker(null, false);

}

else if (!addWorker(command, false))

reject(command);

}

代码@1,如果当前线程池中的线程数量小于核心线程数的话，尝试新增一个新的线程。所以我们把目光投入到addWorker方法中。

addWorker源码详解：

/**

Checks if a new worker can be added with respect to current
pool state and the given bound (either core or maximum). If so,
the worker count is adjusted accordingly, and, if possible, a
new worker is created and started, running firstTask as its
first task. This method returns false if the pool is stopped or
eligible to shut down. It also returns false if the thread
factory fails to create a thread when asked. If the thread
creation fails, either due to the thread factory returning
null, or due to an exception (typically OutOfMemoryError in
Thread#start), we roll back cleanly.
@param firstTask the task the new thread should run first (or
null if none). Workers are created with an initial first task
(in method execute()) to bypass queuing when there are fewer
than corePoolSize threads (in which case we always start one),
or when the queue is full (in which case we must bypass queue).
Initially idle threads are usually created via
prestartCoreThread or to replace other dying workers.
@param core if true use corePoolSize as bound, else
maximumPoolSize. (A boolean indicator is used here rather than a
value to ensure reads of fresh values after checking other pool
state).
@return true if successful

private boolean addWorker(Runnable firstTask, boolean core) {

retry:

for (;😉 { // @1

int c = ctl.get();

int rs = runStateOf©; // @2

// Check if queue empty only if necessary.

if (rs >= SHUTDOWN && //@3

! (rs == SHUTDOWN &&

firstTask == null &&

! workQueue.isEmpty()))

return false;

for (;😉 { //@4

if (wc >= CAPACITY ||

wc >= (core ? corePoolSize : maximumPoolSize)) //@5

return false;

break retry; // @6

c = ctl.get(); // Re-read ctl

continue retry; //@7

// else CAS failed due to workerCount change; retry inner loop

}

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

final ReentrantLock mainLock = this.mainLock;

w = new Worker(firstTask);

final Thread t = w.thread;

if (t != null) {

mainLock.lock(); // @8

try {

// Recheck while holding lock.

// Back out on ThreadFactory failure or if

// shut down before lock acquired.

int c = ctl.get();

if (rs < SHUTDOWN ||

(rs == SHUTDOWN && firstTask == null)) {

if (t.isAlive()) // precheck that t is startable

throw new IllegalThreadStateException();

workers.add(w);

int s = workers.size();

if (s > largestPoolSize)

largestPoolSize = s;

workerAdded = true;

}

} finally {

mainLock.unlock();

}

if (workerAdded) {

t.start(); // 运行线程 // @9

workerStarted = true;

} //@8 end

}

} finally {

if (! workerStarted)

addWorkerFailed(w); // 增加工作线程失败

}

return workerStarted;

}

代码@1，外层循环（自旋模式）

代码@2，获取线程池的运行状态

代码@3，这里的判断条件，为什么不直接写 if(rs >= SHUTDOWN) return false;而要加第二个条件，目前不明白，等在了解到参数firstTask在什么情况下为空。在这里，我们目前只要知道，只有线程池的状态为 RUNNING时，线程池才接收新的任务，去增加工作线程。

代码@4，内层循环，主要的目的就是利用CAS增加一个线程数量。

代码@5，判断当前线程池的数量，如果数量达到规定的数量，则直接返回false,添加工作线程失败。

代码@6，如果修改线程数量成功，则跳出循环，开始创建工作线程。

代码@7，如果修改线程数量不成功(CAS)有两种情况：1、线程数量变化，重试则好，2，如果线程的运行状态变化，则重新开始外层循环，重新判断addWork流程。

代码@8，在锁mainLock的保护下，完成 workers （HashSet）的维护。

接着分析一下代码@9，启动线程，执行关键的方法 runWorker方法：

/**

Main worker run loop. Repeatedly gets tasks from queue and
executes them, while coping with a number of issues:
1. We may start out with an initial task, in which case we
don’t need to get the first one. Otherwise, as long as pool is
running, we get tasks from getTask. If it returns null then the
worker exits due to changed pool state or configuration
parameters. Other exits result from exception throws in
external code, in which case completedAbruptly holds, which
usually leads processWorkerExit to replace this thread.
1. Before running any task, the lock is acquired to prevent
other pool interrupts while the task is executing, and
clearInterruptsForTaskRun called to ensure that unless pool is
stopping, this thread does not have its interrupt set.
1. Each task run is preceded by a call to beforeExecute, which
might throw an exception, in which case we cause thread to die
(breaking loop with completedAbruptly true) without processing
the task.
1. Assuming beforeExecute completes normally, we run the task,
gathering any of its thrown exceptions to send to
afterExecute. We separately handle RuntimeException, Error
(both of which the specs guarantee that we trap) and arbitrary
Throwables. Because we cannot rethrow Throwables within
Runnable.run, we wrap them within Errors on the way out (to the
thread’s UncaughtExceptionHandler). Any thrown exception also
conservatively causes thread to die.
1. After task.run completes, we call afterExecute, which may
also throw an exception, which will also cause thread to
die. According to JLS Sec 14.20, this exception is the one that
will be in effect even if task.run throws.
The net effect of the exception mechanics is that afterExecute

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
f its thrown exceptions to send to

afterExecute. We separately handle RuntimeException, Error
(both of which the specs guarantee that we trap) and arbitrary
Throwables. Because we cannot rethrow Throwables within
Runnable.run, we wrap them within Errors on the way out (to the
thread’s UncaughtExceptionHandler). Any thrown exception also
conservatively causes thread to die.
1. After task.run completes, we call afterExecute, which may
also throw an exception, which will also cause thread to
die. According to JLS Sec 14.20, this exception is the one that
will be in effect even if task.run throws.
The net effect of the exception mechanics is that afterExecute

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-82UYKT6z-1714885107404)]

[外链图片转存中…(img-Egu0ZQnQ-1714885107405)]

[外链图片转存中…(img-r4d2OqEV-1714885107405)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2301_82242844

关注

24
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
java并发编程之源码分析ThreadPoolExecutor线程池实现原理

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
复制链接

扫一扫