先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
现 代 JDK 中 还 提 供 了 三 种 不 同 的 Monitor 实 现 ， 也 就 是 三 种 不 同 的 锁 ：
- 偏向锁 （ Biased Locking）
- 轻量级锁
- 重量级锁
这 三 种 锁 使 得 JDK 得 以 优 化Synchronized的 运 行 ， 当 JVM 检 测 到 不 同 的 竞 争 状 况 时 ， 会 自 动 切 换 到 适 合 的 锁 实 现 ， 这 就 是 锁 的 升级 、降级 。 - 当 没 有 竞 争 出 现 时 ， 默 认 会 使 用 偏向锁 。
JVM 会 利 用
CAS操 作 ， 在 对 象 头 上 的Mark Word部 分 设 置 线 程 ID， 以 表 示 这 个 对 象 偏 向 于 当 前 线 程 ， 所 以 并 不 涉 及 真 正 的 互 斥 锁 ， 因 为 在 很 多 应 用 场 景 中 ， 大 部 分 对 象 生 命 周 期 中 最 多 会 被 一 个 线 程 锁 定 ，使 用 偏 斜 锁 可 以 降 低 无 竞 争 开 销 。
- 如 果 有 另 一 线 程 试 图 锁 定 某 个 被 偏 斜 过 的 对 象 ， JVM 就 撤 销 偏斜锁 ，切 换 到 轻量级锁 实 现 。
- 轻 量 级 锁 依 赖
CAS操 作Mark Word来 试 图 获 取 锁 ， 如 果 重 试 成 功 ，就 使 用 普 通 的 轻 量 级 锁 ； 否 则 ， 进 一 步 升 级 为 重 量 级 锁 。
问题五：为什么说 Synchronized 是非公平锁？
非 公 平 主 要 表 现 在 获 取 锁 的 行 为 上 ， 并 非 是 按 照 申 请 锁 的 时 间 前 后 给 等 待 线 程 分 配 锁 的 ， 每 当 锁 被 释 放 后 ， 任 何 一 个 线 程 都 有 机 会 竞 争 到 锁 ，这 样 做 的 目 的 是 为 了 提 高 执 行 性 能 ， 缺 点 是 可 能 会 产 生 线程饥饿现象 。
可重入锁 ReentrantLock 及其他显式锁相关问题
问题一 ： 跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？
其 实 ， 锁 的 实 现 原 理 基 本 是 为 了 达 到 一 个 目 的 ：
让 所 有 的 线 程 都 能 看 到 某 种 标 记 。
Synchronized 通 过 在 对 象 头 中 设 置 标 记 实 现 了 这 一 目 的 ， 是 一 种 JVM 原 生 的 锁 实 现 方 式 ， 而 ReentrantLock 以 及 所 有 的 基 于 Lock 接 口 的 实 现 类 ， 都 是 通 过 用 一 个 volitile 修 饰 的 int 型 变 量 ， 并 保 证 每 个 线 程 都 能 拥 有 对 该 int 的 可见性 和 原子 修 改 ， 其 本 质 是 基 于 所 谓 的 AQS 框 架 。
问题二 ： 那么请谈谈 AQS 框架是怎么回事儿？
AQS（
AbstractQueuedSynchronizer 类） 是 一 个 用 来 构 建 锁 和 同 步 器 的 框 架 ， 各 种 Lock 包 中 的 锁 （ 常 用 的 有ReentrantLock、ReadWriteLock） ， 以 及 其 他 如Semaphore、CountDownLatch， 甚至 是 早 期 的FutureTask等 ， 都 是 基 于 AQS 来 构建。
- AQS 在 内 部 定 义 了 一 个
volatile int state变 量 ， 表 示 同 步 状 态 ： 当 线 程 调 用lock方 法 时 ， 如 果state=0， 说 明 没 有 任 何 线 程 占 有 共 享 资 源 的 锁 ， 可 以 获 得 锁 并 将state=1； 如 果state=1， 则 说 明 有 线 程 目 前 正 在 使 用 共 享 变 量 ， 其 他 线 程 必 须 加 入 同步队列 进 行 等 待 。 - AQS 通 过
Node 内部类构 成 的 一 个 双 向 链 表 结 构 的 同 步 队 列 ， 来 完 成 线程 获 取 锁 的 排 队 工 作 ， 当 有 线 程 获 取 锁 失 败 后 ， 就 被 添 加 到 队 列 末 尾 。
- Node 类 是 对 要 访 问 同 步 代 码 的 线 程 的 封 装 ， 包 含 了 线 程 本 身 及 其 状 态 叫
waitStatus（ 有 五 种 不 同 取 值 ， 分 别 表 示 是 否 被 阻 塞 ， 是 否 等 待 唤 醒 ，是 否 已 经 被 取 消 等 ） ， 每 个 Node 结 点 关 联 其 prev 结点 和 next 结点 ， 方 便 线 程 释 放 锁 后 快 速 唤 醒 下 一 个 在 等 待 的 线 程 ， 是 一 个FIFO的 过程 。 - Node 类 有 两 个 常 量 ，
SHARED和EXCLUSIVE， 分 别 代 表 共享模式 和 独占模式 。 所 谓 共 享 模 式 是 一 个 锁 允 许 多 条 线 程 同 时 操 作 （ 信 号 量Semaphore就 是 基 于 AQS 的 共 享 模 式 实 现 的 ） ， 独 占 模 式 是 同 一 个 时 间 段 只 能 有 一 个 线 程 对 共 享 资 源 进 行 操 作 ， 多 余 的 请 求 线 程 需 要 排 队 等 待（ 如ReentranLock） 。
- AQS 通 过
内部类 ConditionObject构 建 等 待 队 列 （ 可 有 多 个 ） ， 当Condition调 用 wait() 方法 后 ， 线 程 将 会 加 入 等 待 队 列 中 ， 而 当Condition调 用 signal() 方法 后 ， 线 程 将 从 等 待 队 列 转 移 动 同 步 队 列 中 进 行 锁 竞 争 。 - AQS 和 Condition 各 自 维 护 了 不 同 的 队 列 ， 在 使 用
Lock和Condition的 时 候 ， 其 实 就 是 两 个 队 列 的 互 相 移 动 。
问题三：请尽可能详尽地对比下 Synchronized 和 ReentrantLock的异同 。
ReentrantLock 是 Lock 的 实现类 ， 是 一 个 互 斥 的 同 步 锁 。从 功 能 角 度 ， ReentrantLock 比 Synchronized 的 同 步 操 作 更 精 细（ 因 为 可 以 像 普 通 对 象 一 样 使 用 ） ， 甚 至 实 现 Synchronized 没 有 的 高 级 功 能 ， 如 ：
- 等待可中断： 当 持 有 锁 的 线 程 长 期 不 释 放 锁 的 时 候 ， 正 在 等 待 的 线 程 可 以 选 择 放 弃 等 待 ， 对 处 理 执 行 时 间 非 常 长 的 同 步 块 很 有 用 。
- 带超时的获取锁尝试： 在 指 定 的 时 间 范 围 内 获 取 锁 ， 如 果 时 间 到 了 仍 然 无 法 获 取 则 返 回 。
- 可以判断是否有线程在排队等待获取锁 。
- 可以响应中断请求：与
Synchronized不 同 ， 当 获 取 到 锁 的 线 程 被 中 断 时 ， 能 够 响 应 中 断 ， 中 断 异 常 将 会 被 抛 出 ， 同 时 锁 会 被 释 放 。 - 可以实现公平锁 。
从 锁 释 放 角 度 ， Synchronized 在 JVM 层 面 上 实 现 的 ， 不 但 可 以 通 过 一 些 监 控 工 具 监 控 Synchronized 的 锁 定 ， 而 且 在 代 码 执 行 出 现 异 常 时 ， JVM 会 自 动 释 放 锁 定 ； 但 是 使 用 Lock 则 不 行 ， Lock 是 通 过 代 码 实 现 的 ， 要 保 证 锁 定 一 定 会 被 释 放 ， 就 必 须 将 unLock() 放 到 finally{} 中 。
从 性 能 角 度 ， Synchronized 早 期 实 现 比 较 低 效 ， 对 比 ReentrantLock， 大 多 数 场 景 性 能 都 相 差 较 大 。但 是 在 Java 6 中 对 其 进 行 了 非 常 多 的 改 进 ， 在 竞 争 不 激 烈 时 ，Synchronized 的 性 能 要 优 于 ReetrantLock； 在 高 竞 争 情 况 下 ，Synchronized 的 性 能 会 下 降 几 十 倍 ， 但 是 ReetrantLock 的 性 能 能 维 持 常 态 。
ReentrantLock 是如何实现可重入性的？
ReentrantLock 内 部 自 定 义 了 同步器 Sync（ Sync 既 实 现 了 AQS，又 实 现 了 AOS， 而 AOS 提 供 了 一 种 互 斥 锁 持 有 的 方 式 ） ， 其 实 就 是 加 锁 的 时 候 通 过 CAS 算法 ， 将 线 程 对 象 放 到 一 个 双 向 链 表 中 ， 每 次 获 取 锁 的 时 候 ， 看 下 当 前 维 护 的 那 个 线 程 ID 和 当 前 请 求 的 线 程 ID 是 否 一 样 ， 一 样 就 可 重 入 了 。
问题五：除了 ReetrantLock，你还接触过 JUC 中的哪些并发工具 ？
通 常 所 说 的 并发包（ JUC） 也 就 是 java.util.concurrent 及 其 子 包 ， 集 中 了 Java 并 发 的 各 种 基 础 工 具 类 ， 具 体 主 要 包 括 几 个 方 面 ：
- 提 供 了
CountDownLatch、CyclicBarrier、Semaphore等 ， 比Synchronized更 加 高 级 ， 可 以 实 现 更 加 丰 富 多 线 程 操 作 的 同 步 结 构 。 - 提 供 了
ConcurrentHashMap、 有 序 的ConcunrrentSkipListMap， 或 者 通 过 类 似 快 照 机 制 实 现 线 程 安 全 的 动 态 数 组CopyOnWriteArrayList等 ， 各 种 线 程 安 全 的 容 器 。 - 提 供 了
ArrayBlockingQueue、SynchorousQueue或 针 对 特 定 场 景 的PriorityBlockingQueue等 ， 各 种 并 发 队 列 实 现 。 - 强 大 的 Executor 框架 ， 可 以 创 建 各 种 不 同 类 型 的 线 程 池 ， 调 度 任 务 运 行 等 。
Java 线程池相关问题
问题一：Java 中的线程池是如何实现的？
- 在 Java 中 ， 所 谓 的 线 程 池 中 的 “ 线 程 ” ， 其 实 是 被 抽 象 为 了 一 个 静 态 内 部 类
Worker， 它 基 于 AQS 实 现 ， 存 放 在 线 程 池 的HashSet<Worker> workers成 员 变 量 中 ； - 而 需 要 执 行 的 任 务 则 存 放 在 成 员 变 量 workQueue（
BlockingQueue<Runnable> workQueue） 中 。这 样 ， 整 个 线 程 池 实 现 的 基 本 思 想 就 是 ： 从workQueue中 不 断 取 出需 要 执 行 的 任 务 ， 放 在Workers中 进 行 处 理 。
问题二 ： 创建线程池的几个核心构造参数？
Java 中 的 线 程 池 的 创 建 其 实 非 常 灵 活 ， 我 们 可 以 通 过 配 置 不 同 的 参 数 ， 创 建 出 行 为 不 同 的 线 程 池 ， 这 几 个 参 数 包 括 ：
- corePoolSize： 线 程 池 的 核 心 线 程 数 。
- maximumPoolSize： 线 程 池 允 许 的 最 大 线 程 数 。
- keepAliveTime： 超 过 核 心 线 程 数 时 闲 置 线 程 的 存 活 时 间 。
- workQueue： 任 务 执 行 前 保 存 任 务 的 队 列 ， 保 存 由 execute 方 法 提 交 的
Runnable任 务 。
问题三：线程池中的线程是怎么创建的？是一开始就随着线程池的启动创建好的吗？
显 然 不 是 的 。 线 程 池 默 认 初 始 化 后 不 启 动 Worker， 等 待 有 请 求 时 才 启 动 。
每 当 我 们 调 用 execute() 方法 添 加 一 个 任 务 时 ， 线 程 池 会 做 如 下 判 断 ：
- 如 果 正 在 运 行 的 线 程 数 量 小 于
corePoolSize， 那 么 马 上 创 建 线 程 运 行 这 个 任 务 ； - 如 果 正 在 运 行 的 线 程 数 量 大 于 或 等 于
corePoolSize， 那 么 将 这 个 任 务 放 入 队 列 ； - 如 果 这 时 候 队 列 满 了 ， 而 且 正 在 运 行 的 线 程 数 量 小 于
maximumPoolSize， 那 么 还 是 要 创 建 非 核 心 线 程 立 刻 运 行 这 个 任 务 ； - 如 果 队 列 满 了 ， 而 且 正 在 运 行 的 线 程 数 量 大 于 或 等 于
maximumPoolSize， 那 么 线 程 池 会 抛 出 异 常RejectExecutionException。
当 一 个 线 程 完 成 任 务 时 ， 它 会 从 队 列 中 取 下 一 个 任 务 来 执 行 。 当 一 个 线 程 无 事 可 做 ， 超 过 一 定 的 时 间 （ keepAliveTime） 时 ， 线 程 池 会 判 断 。
如 果 当 前 运 行 的 线 程 数 大 于 corePoolSize， 那 么 这 个 线 程 就 被 停 掉 。所 以 线 程 池 的 所 有 任 务 完 成 后 ， 它 最 终 会 收 缩 到 corePoolSize 的 大 小 。
问题四：既然提到可以通过配置不同参数创建出不同的线程池，那么 Java 中默认实现好的线程池又有哪些呢？请比较它们的异同 。
1.SingleThreadExecutor 线程池
这 个 线 程 池 只 有 一 个 核 心 线 程 在 工 作 ， 也 就 是 相 当 于 单 线 程 串 行 执 行 所 有 任 务 。 如 果 这 个 唯 一 的 线 程 因 为 异 常 结 束 ， 那 么 会 有 一 个 新 的 线 程 来 替 代 它 。 此 线 程 池 保 证 所 有 任 务 的 执 行 顺 序 按 照 任 务 的 提 交 顺 序 执 行 。
- corePoolSize： 1， 只 有 一 个 核 心 线 程 在 工 作 。
- maximumPoolSize： 1。
- keepAliveTime： 0L。
- workQueue：
new LinkedBlockingQueue<Runnable>()， 其 缓 冲 队 列 是 无 界 的 。
2.FixedThreadPool 线程池
FixedThreadPool 是 固 定 大 小 的 线 程 池 ， 只 有 核 心 线 程 。 每 次 提 交 一 个 任 务 就 创 建 一 个 线 程 ， 直 到 线 程 达 到 线 程 池 的 最 大 大 小 。 线 程 池 的 大 小 一 旦 达 到 最 大 值 就 会 保 持 不 变 ， 如 果 某 个 线 程 因 为 执 行 异 常 而 结 束 ， 那 么 线 程 池 会 补 充 一 个 新 线 程 。
FixedThreadPool 多 数 针 对 一 些 很 稳 定 很 固 定 的 正 规 并 发 线 程 ， 多 用 于 服 务 器 。
- corePoolSize：
nThreads - maximumPoolSize：
nThreads - keepAliveTime： 0L
- workQueue：
new LinkedBlockingQueue<Runnable>()， 其 缓 冲 队 列是 无 界 的 。
3.CachedThreadPool 线程池
CachedThreadPool 是 无 界 线 程 池 ， 如 果 线 程 池 的 大 小 超 过 了 处 理 任 务 所 需 要 的 线 程 ， 那 么 就 会 回 收 部 分 空 闲 （ 60 秒 不 执 行 任 务 ） 线 程 ， 当 任 务 数 增 加 时 ， 此 线 程 池 又 可 以 智 能 的 添 加 新 线 程 来 处 理 任 务 。
线 程 池 大 小 完 全 依 赖 于 操 作 系 统 （ 或 者 说 JVM） 能 够 创 建 的 最 大 线 程 大 小 。 SynchronousQueue 是 一 个 是 缓 冲 区 为 1 的 阻 塞 队 列 。
缓 存 型 池 子 通 常 用 于 执 行 一 些 生 存 期 很 短 的 异 步 型 任 务 ， 因 此 在 一 些 面 向 连 接 的 daemon 型 SERVER 中 用 得 不 多 。 但 对 于 生 存 期 短 的 异 步 任 务 ， 它 是 Executor 的 首 选 。
- corePoolSize： 0
- maximumPoolSize：
Integer.MAX_VALUE - keepAliveTime： 60L
- workQueue：
new SynchronousQueue<Runnable>()， 一 个 是 缓 冲 区 为 1 的 阻 塞 队 列 。
4.ScheduledThreadPool 线程池
ScheduledThreadPool： 核 心 线 程 池 固 定 ， 大 小 无 限 的 线 程 池 。 此 线 程 池 支 持 定 时 以 及 周 期 性 执 行 任 务 的 需 求 。 创 建 一 个 周 期 性 执 行 任 务 的 线 程 池 。 如 果 闲 置 ， 非 核 心 线 程 池 会 在 DEFAULT_KEEPALIVEMILLIS 时 间 内 回 收 。
- corePoolSize：
corePoolSize - maximumPoolSize：
Integer.MAX_VALUE - keepAliveTime：
DEFAULT_KEEPALIVE_MILLIS - workQueue：
new DelayedWorkQueue()
Java 内存模型相关问题
问题一：什么是 Java 的内存模型 ， Java中各个线程是怎么彼此看到对方的变量的？
Java 的 内 存 模 型 定 义 了 程 序 中 各 个 变 量 的 访 问 规 则 ， 即 在 虚 拟 机 中 将 变 量 存 储 到 内 存 和 从 内 存 中 取 出 这 样 的 底 层 细 节 。
此 处 的 变 量 包 括 实 例 字 段 、 静 态 字 段 和 构 成 数 组 对 象 的 元 素 ， 但 是 不 包 括 局 部 变 量 和 方 法 参 数 ， 因 为 这 些 是 线 程 私 有 的 ， 不 会 被 共 享 ， 所 以 不 存 在 竞 争 问 题 。
Java 中 各 个 线 程 是 怎 么 彼 此 看 到 对 方 的 变 量 的 呢 ？ Java 中 定 义 了 主 内 存 与 工 作 内 存 的 概 念 ：
所 有 的 变 量 都 存 储 在 主 内 存 ， 每 条 线 程 还 有 自 己 的 工 作 内 存 ， 保 存 了 被 该 线 程 使 用 到 的 变 量 的 主 内 存 副 本 拷 贝 。
线 程 对 变 量 的 所 有 操 作 （ 读 取 、 赋 值 ） 都 必 须 在 工 作 内 存 中 进 行 ， 不 能 直 接 读 写 主 内 存 的 变 量 。 不 同 的 线 程 之 间 也 无 法 直 接 访 问 对 方 工 作 内 存 的 变 量 ， 线 程 间 变 量 值 的 传 递 需 要 通 过 主 内 存 。
问题二：请谈谈 volatile 有什么特点，为什么它能保证变量对所有线程的可见性？
关 键 字 volatile 是 Java 虚拟机 提 供 的 最 轻 量 级 的 同 步 机 制 。 当 一 个 变 量 被 定 义 成 volatile 之 后 ， 具 备 两 种 特 性 ：
- 保 证 此 变 量 对 所 有 线 程 的 可 见 性 。 当 一 条 线 程 修 改 了 这 个 变 量 的 值 ， 新 值 对 于 其 他 线 程 是 可 以 立 即 得 知 的 。 而 普 通 变 量 做 不 到 这 一 点 。
- 禁 止 指 令 重 排 序 优 化 。 普 通 变 量 仅 仅 能 保 证 在 该 方 法 执 行 过 程 中 ， 得 到 正 确 结 果 ， 但 是 不 保 证 程 序 代 码 的 执 行 顺 序 。
复习的面试资料
这些面试全部出自大厂面试真题和面试合集当中，小编已经为大家整理完毕（PDF版）
- 第一部分：Java基础-中级-高级
- 第二部分：开源框架（SSM：Spring+SpringMVC+MyBatis）
- 第三部分：性能调优（JVM+MySQL+Tomcat）
- 第四部分：分布式（限流：ZK+Nginx；缓存：Redis+MongoDB+Memcached；通讯：MQ+kafka）
- 第五部分：微服务（SpringBoot+SpringCloud+Dubbo）
- 第六部分：其他：并发编程+设计模式+数据结构与算法+网络
进阶学习笔记pdf
- Java架构进阶之架构筑基篇（Java基础+并发编程+JVM+MySQL+Tomcat+网络+数据结构与算法）
- Java架构进阶之开源框架篇（设计模式+Spring+SpringMVC+MyBatis）
- Java架构进阶之分布式架构篇 （限流（ZK/Nginx）+缓存（Redis/MongoDB/Memcached）+通讯（MQ/kafka））
- Java架构进阶之微服务架构篇（RPC+SpringBoot+SpringCloud+Dubbo+K8s）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-7DwqWSjJ-1713159976533)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
752
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
