{ "version": "https://jsonfeed.org/version/1.1", "title": "JavaGuide", "home_page_url": "https://javaguide.cn/", "feed_url": "https://javaguide.cn/feed.json", "description": "JavaGuide 是一份面向后端开发/后端面试的学习与复习指南，覆盖 Java、数据库/MySQL、Redis、分布式、高并发、高可用、系统设计等核心知识。", "favicon": "https://javaguide.cn/favicon.ico", "items": [ { "title": "一文搞懂 Harness Engineering：六层架构、上下文管理与一线团队实战", "url": "https://javaguide.cn/ai/agent/harness-engineering.html", "id": "https://javaguide.cn/ai/agent/harness-engineering.html", "summary": "深度解析 Harness Engineering，梳理 Agent = Model + Harness 的核心定义，拆解 OpenAI、Anthropic、Stripe 等一线团队的实战经验与踩坑教训。", "content_html": "

最近大半年，很多开发者都有同感：明明用的是最贵的模型，Agent 跑起来还是各种拉胯——重复犯错、做到一半放弃、越跑越蠢。换了更强的模型，效果也没好到哪去。

\n

原因不在模型。Can.ac 做了个实验直接证明了这一点：同一个模型，只换了文件编辑接口的调用方式，编码基准分数从 6.7% 直接跳到 68.3%。模型没变，变的是外围的那套系统。

\n

Harness Engineering 正在成为 AI Agent 开发圈的高频词。Mitchell Hashimoto 在博客里用了这个说法（他原话是“我不知道业界有没有公认的术语，我自己管这叫 harness engineering”），OpenAI 几天后发了一篇百万行代码的实验报告，Birgitta Böckeler 在 Martin Fowler 网站上写了深度分析，Anthropic 在三月份又放出了全新的多智能体架构设计。几周之内，Harness 成了讨论 AI Agent 开发绕不开的概念。

\n

今天这篇文章就来系统梳理 Harness Engineering 的核心概念和工程方法，帮你搞清楚：决定 Agent 表现的天花板，到底在哪里。 本文接近 1.3w 字，建议收藏，你将搞懂：

\n
    \n
  1. Harness 到底是什么：为什么说“你不是模型，那你就是 Harness”？Agent = Model + Harness 这个公式怎么理解？和 Prompt Engineering、Context Engineering 是什么关系？六层架构长什么样？
    2. \n
  2. ⭐ 为什么瓶颈不在模型而在 Harness：同一个模型只换了接口格式，分数从 6.7% 跳到 68.3%？上下文用到 40% Agent 就开始变蠢？
    3. \n
  3. ⭐ 从零搭建 Harness 的行动清单：P0/P1/P2 三个优先级，按需取用。
    4. \n
  4. ⭐ 一线团队实战案例（附录）：OpenAI 三人五月百万行零手写、Anthropic 的 GAN 式三智能体架构和 context resets 交接棒策略、Stripe 每周 1300+ 无人值守 PR、Mitchell Hashimoto 的六步进阶。
    5. \n
\n
\n

📌 系列阅读：本文是 AI Agent 系列的一部分，相关文章：

\n\n
\n

⭐️ Harness 核心概念

\n

Harness 到底是什么？

\n

一句话：Agent = Model + Harness。你不是模型，那你就是 Harness。

\n

听起来有点绝对？但仔细想想，它确实抓住了关键。

\n

Harness 就是模型之外的一切——系统提示词、工具调用、文件系统、沙箱环境、编排逻辑、钩子中间件、反馈回路、约束机制。模型本身只是能力的来源，只有通过 Harness 把状态、工具、反馈和约束串起来，它才真正变成一个 Agent。

\n

LangChain 的 Vivek Trivedi 在《The Anatomy of an Agent Harness》里把这个定义讲得很清楚：先搞清楚模型负责什么，剩下的系统要补什么，用这条线把整个系统切开。

\n

打个比方：模型是 CPU，Harness 是操作系统。CPU 再强，OS 拉胯也白搭。你买了最新款 M5 芯片，装了个崩溃不断的系统，体验还不如老芯片配稳定的 OS。

\n

\"Agent

\n

Harness 和 Prompt/Context Engineering 是什么关系？

\n

三者不是并列关系，而是嵌套关系。更重要的是，每一层解决的是完全不同的问题：

\n

\"Harness

\n

| 层级 | 解决的核心问题 | 关注点 | 典型工作 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/harness/harness-agent-equals-model-harness-arch.png", "date_published": "2026-04-08T16:06:36.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "Claude Code 接入第三方模型实战：JVM 智能诊断与慢查询治理", "url": "https://javaguide.cn/ai/ai-coding/cc-glm5.1.html", "id": "https://javaguide.cn/ai/ai-coding/cc-glm5.1.html", "summary": "通过 Claude Code 接入 GLM-5.1 模型，完成 JVM 智能诊断助手从零搭建和百万级数据量慢查询治理两个实战任务，分享 AI 辅助编程的工作方法与踩坑经验。", "content_html": "

大家好，我是 Guide。前面分享过 IDEA 搭配 Qoder 插件的实战和 Trae 接入大模型的实战，分别覆盖了 JetBrains 体系和 VS Code 体系下的 AI 辅助编码。这篇换个角度，聊聊 Claude Code 接入第三方模型 的实战体验。

\n

Claude Code 本身是 Anthropic 官方的 CLI 编码工具，但它支持通过环境变量切换底层模型。这意味着你不必局限于 Claude 系列，完全可以接入其他模型来使用。本文以 GLM-5.1 作为示例，但接入方式是通用的——换成其他兼容模型，流程基本一致。

\n

我选了两个比较有代表性的复杂场景来验证：

\n\n

一个是从零开始的工程交付，另一个是面对既有系统的性能治理，正好覆盖 AI 辅助编程的两种典型工作模式。

\n

环境准备：Claude Code 接入第三方模型

\n

在正式开始之前，需要完成 Claude Code 与第三方模型的对接。整个配置过程分三步：

\n

第一步：安装 Claude Code

\n
npm i -g @anthropic-ai/claude-code@latest
\n

第二步：安装 cc-switch 完成模型切换（macOS 用户可通过 homebrew 安装，详情参考 cc-switch 官方文档：https://github.com/farion1231/cc-switch/blob/main/README_ZH.md）

\n

第三步：按照模型提供方的说明，完成 Claude Code 内部模型环境变量与目标模型的对应关系配置。以 GLM-5.1 为例，参考：https://docs.bigmodel.cn/cn/coding-plan/tool/claude

\n

配置过程截图如下：

\n

点击加号添加模型：

\n

\"点击添加模型\"

\n

选择对应的模型：

\n

\"选择模型\"

\n

配置参数：

\n

\"配置参数\"

\n

Claude Code 内部模型环境变量与目标模型对应关系的 JSON 配置：

\n

\"Claude

\n

如果你更偏向页面开发，推荐通过 VSCode + Claude Code for VS Code 方式进行交互和编码验收。完成插件安装之后，可以直接在 IDE 中与模型对话和代码审查，相对于 CLI 界面会更直观一些：

\n

\"VSCode

\n

场景一：从零搭建 JVM 智能诊断 Agent

\n

为什么需要 JVM 智能诊断助手？

\n

JVM 线上诊断一直以来都是 Java 开发最棘手的问题。在传统开发模式下，面对性能瓶颈或线上故障，研发人员的排查路径基本固定：

\n
    \n
  1. 查看 Grafana 监控面板，初步定位异常方向
    2. \n
  2. 登录线上服务器，排查 CPU、内存、GC 等各项指标
    3. \n
  3. 明确 Java 应用层面的问题后，启动 Arthas 执行一系列诊断指令，逐步缩小问题范围
    4. \n
  4. 定位到具体代码段，分析根因并制定修复方案
    5. \n
\n

在 AI 出现以前，这套流程虽然繁琐，但确实是最直接有效的手段。但随着业务越来越复杂，故障响应时效要求也越来越高，传统模式的弊端越来越明显：

\n\n

随着 AI 技术的演进，特别是 Agent 和 Skill 等概念的成熟，笔者就有了一个工程化的构想：能否借助 AI 将诊断经验沉淀复用，让 AI 根据既有经验构建明确的决策路径？同时结合它的决策方案赋予对应的工具，使其基于用户给定的服务名和故障表象，自动化连接线上服务器完成诊断，定位具体代码段，最终输出问题根因和解决方案。

\n

需求交付与架构设计

\n

有了构想之后，接下来就是技术选型和方案落地。笔者将完整的需求描述交给 AI：

\n
研发一款基于Arthas的智能体诊断工具，该工具需实现以下核心功能：\n1. 当用户输入线上故障服务名称及具体故障现象后，系统能够自动定位至目标故障服务器，主动对目标服务进行实时监控与深度分析。\n2. 通过集成Arthas的反编译功能，精准定位到引发故障的具体代码段\n3. 基于分析结果生成包含问题根因、代码修复建议及实施步骤的完整解决思路。\n\n请提供该工具的技术选型方案，包括但不限于开发语言（优先考虑Java技术栈）、核心框架、数据库表设计、部署架构等，并设计详细的系统实现方案，涵盖功能模块划分、数据流程设计、关键技术难点及解决方案等内容。
\n

AI 收到需求后，没有立刻开始写代码，而是先结合项目上下文（完全空的文件夹）进行推理分析，自主完成了一份包含十几个阶段的完整技术方案。”给一个目标，AI 自己拆出整条路径”——这是 AI 辅助编程的一大优势，你可以把精力放在需求描述和方案评审上，让 AI 负责路径规划。

\n

\"AI

\n

AI 结合需求，针对 Agent 拆解出技术选型和 Arthas 集成方案的检索。从检索关键字可以看出，它在方案选取上优先考虑成熟稳定的解决方案：

\n

\"AI

\n

AI 检索了大量资料和 Arthas 官方文档后，输出了下面这份系统架构设计图。从上到下分三层：用户层输入服务名和故障现象，Agent 层由 Skill 引擎、Arthas HTTP Client 和 AI 分析引擎三大核心模块协同工作，最底层通过 Arthas 内置 HTTP API 对接多个目标服务实例。架构的模块划分和职责边界清晰，从故障输入到定位代码再到生成报告的完整链路设计到位：

\n

\"AI

\n

AI 给出了架构图之后，还进一步拆解了 6 个核心组件的职责分工——从 AI Agent Server 的流程编排，到 Arthas HTTP Client 的会话管理，到 Skill 引擎的诊断步骤链定义，再到 AI 分析引擎的报告生成，每个组件的边界和协作关系都交代得比较清楚：

\n

\"AI

\n

最后来看最重要的数据流设计。架构设计明确之后，只要数据流链路完整清晰，基本就可以着手开发了。AI 结合一个常见的 RT 超时场景，给出了完整的诊断链路——从 Skill 匹配、诊断步骤执行、问题追踪、根因定位，到 Arthas 反编译和最终的诊断报告输出。AI 针对 Arthas HTTP API 设计了完整的会话模式交互流程（init_session → async_exec → pull_results → interrupt_job → close_session），连watch、trace这类持续监听型命令的异步轮询机制都考虑到了。这一点在评审时需要重点关注——如果 AI 对底层工具的通信模型理解有偏差，后续编码阶段就会出现问题：

\n

\"AI

\n

其他细节就不多做赘述了。整体来说，架构和数据流链路都比较到位。AI 不仅针对既有需求给出了方案，还主动输出了 6 个后续扩展方向——WebSocket 实时推送、诊断知识库向量化存储、已知 Pattern 的自动修复补丁、告警联动自动触发诊断、自定义 Skill 市场、多语言支持。这些扩展方向都紧扣当前架构的技术延伸：知识库基于现有的诊断报告数据，自动修复基于已有的 Skill 引擎，告警联动基于现有的服务实例查询机制。

\n

\"AI

\n

编码交付与工程结构

\n

确认方案没有问题后，笔者直接下达开发指令：

\n
整体方案没有问题，请完成开发工作吧
\n

AI 收到指令后，开始自主编码。按照之前的架构设计，逐模块推进——从父 POM 和 Maven 多模块骨架搭建，到通用工具类、数据模型、数据访问层、Arthas 客户端封装、Skill 引擎、AI 分析引擎、业务逻辑层、Web 控制器，直到启动模块和部署配置，11 个子步骤全部完成：

\n

\"AI

\n

片刻之后，AI 完成了全部编码工作，并输出了一份详细的交付清单。9 个模块、46 个文件全部到位——从通用工具类到 7 个内置诊断 Skill，从 Arthas HTTP API 的 exec+session 双模式封装到 Spring AI Alibaba 诊断分析器，一个不少：

\n

\"AI

\n

先看整体模块结构，AI 按照 Java 多模块的标准规范完成了工程划分，从上到下严格遵循 common→model→dal→client→skill→ai→service→web→bootstrap 的依赖层级，命名规范统一。

\n

agent-skill 模块值得关注，AI 设计了 Skill 引擎的抽象接口，并内置了 7 个覆盖常见 JVM 故障场景的诊断技能（CPU 飙高、OOM、死锁、慢接口、GC 异常、线程泄漏、类找不到），每个 Skill 都定义了完整的诊断步骤链。这种”框架 + 内置实现”的设计思路，扩展性不错：

\n
jvm-ai-agent/\n├── jvm-ai-agent-server/                 # 智能体服务端（核心）\n│   ├── agent-common/                    # 通用模块：工具类、常量、DTO\n│   ├── agent-model/                     # 数据模型：实体、数据库映射\n│   ├── agent-dal/                       # 数据访问层：Mapper、Repository\n│   ├── agent-arthas-client/             # Arthas HTTP API 客户端封装\n│   ├── agent-skill/                     # Skill 引擎（诊断方法论）\n│   ├── agent-ai/                        # AI 分析引擎\n│   ├── agent-service/                   # 业务逻辑层（含服务实例查询）\n│   ├── agent-web/                       # Web 层：REST API、WebSocket\n│   └── agent-server-bootstrap/          # 启动模块\n│\n└── pom.xml                              # 父 POM
\n

再看诊断核心逻辑，AI 严格按照架构设计中定义的数据流完成了完整的诊断业务链开发。整个 executeDiagnosis 方法按照 Skill 匹配、实例定位、诊断链执行、动态命令解析、AI 分析、报告生成的流程推进，异常处理也考虑到了非关键步骤失败时继续执行的容错策略：

\n
    \n
  1. Skill 匹配：通过DefaultSkillMatcher根据故障现象关键词匹配最佳诊断技能
    2. \n
  2. 实例定位：通过ServiceInstanceLocator根据服务名解析目标实例 IP 和 Arthas 端口
    3. \n
  3. 诊断链执行：遍历 Skill 定义的诊断步骤链，依次执行 Arthas 命令并收集结果
    4. \n
  4. 动态命令解析：从 Arthas 输出中提取类名、方法名等上下文变量，注入后续步骤的动态命令模板
    5. \n
  5. AI 分析报告：将全部诊断数据交给 AI 分析引擎，生成包含根因、修复建议、严重程度的结构化报告
    6. \n
\n
private void executeDiagnosis(DiagnosisRecord record, DiagnosisRequest request) {\n    try {\n        // 1. 匹配 Skill\n        Optional<SkillDefinition> skillOpt = skillMatcher.findBestMatch(request.getSymptom());\n        if (skillOpt.isEmpty()) {\n            failDiagnosis(record, \"无法匹配到合适的诊断技能\");\n            return;\n        }\n        SkillDefinition skill = skillOpt.get();\n        // ......\n\n        // 2. 定位目标实例\n        ServiceRegistry instance = instanceLocator.resolveInstance(\n                request.getServiceName(), request.getInstanceIp());\n        // ......\n\n        // 3. 执行诊断步骤链\n        List<DiagnosticStep> chain = skill.getDiagnosticChain();\n        StringBuilder allDiagnosticData = new StringBuilder();\n        String decompiledCode = \"\";\n        Map<String, String> contextVars = new HashMap<>();\n\n        for (int i = 0; i < chain.size(); i++) {\n            DiagnosticStep step = chain.get(i);\n            // ...... 初始化步骤实体\n\n            try {\n                // 解析动态命令（支持上下文变量注入）\n                String command = resolveCommand(step, contextVars);\n                // ......\n\n                // 执行Arthas命令并记录耗时\n                String result = executeStep(host, port, step, command);\n\n                // 如果是 jad 结果，记录为反编译代码\n                if (\"jad\".equals(step.getResultType())) {\n                    decompiledCode = result;\n                }\n\n                // 从结果中提取上下文变量供后续步骤使用\n                extractContextVars(result, contextVars);\n            } catch (Exception e) {\n                // 非关键步骤失败时继续执行\n                // ......\n            }\n        }\n\n        // 4. AI 分析\n        String report = diagnosisAnalyzer.analyze(\n                request.getSymptom(), allDiagnosticData.toString(), decompiledCode, skill);\n\n        // 5. 保存报告（从Markdown报告中提取根因、严重程度等结构化字段）\n        // ......\n\n        // 6. 更新诊断记录状态\n        record.setStatus(DiagnosisStatus.COMPLETED.getCode());\n        // ......\n    } catch (Exception e) {\n        failDiagnosis(record, e.getMessage());\n    }\n}
\n

Agent 交互页面集成

\n

在 AI 编码期间，笔者查阅了 Spring AI Alibaba 的官方文档，发现它提供了现成的 Agent Chat UI。与其让 AI 从头生成前端页面，不如直接集成这个交互组件，实现 SSE 流式输出的诊断体验。于是笔者给了一条简短的指令：

\n
根据Spring AI Alibaba官方文档（参考链接https://java2ai.com/docs/frameworks/studio/quick-start：），实现agent智能体交互页面开发工作
\n

只给了一个文档链接和一句话，AI 就自己去读官方文档、理解集成步骤、完成了页面开发。这也是使用 AI 辅助编程的一个实用技巧：当你只需要集成某个现成组件时，直接给出文档链接往往比详细描述需求更高效。

\n

\"AI

\n

到这里，一个完整的智能诊断 Agent 就构建完成了。为了验收功能，笔者在本地起了一个 CPU 飙升的测试接口：

\n
@Slf4j\n@RestController\npublic class TestController {\n    @RequestMapping(\"cpu-100\")\n    public  void cpu() {\n        while (true){\n        }\n    }\n}
\n

启动 Agent 服务，访问 http://localhost:{应用端口}/chatui/index.html，在聊天框输入：order-service 程序CPU飙升,请协助排查。Agent 在收到故障表象后，完成了完整的诊断链路——先通过 Dashboard 获取概览定位到 CPU 占用最高的线程 ID，再基于线程栈帧信息定位到问题代码段，最后通过 Arthas 反编译（jad）输出热点代码并生成包含根因分析和修复建议的完整诊断报告。整个过程 Agent 全程自主完成，SSE 流式输出让每一步诊断进度都清晰可见：

\n

\"Agent

\n

场景二：百万级数据量下的慢查询治理

\n

场景一验证的是 AI”从 0 到 1 的规划与交付能力”，那场景二要验证的就是另一个维度：在一个已有一定复杂度的代码库中，AI 能否准确理解既有架构、定位问题、并完成增量优化。

\n

问题定位：搜索接口耗时 18 秒

\n

这是一个基于 Spring Boot + MyBatis 的订单查询服务（glm-testing-service），核心业务围绕订单的查询和分析展开，包含四个接口：

\n

| 接口 | 路径 | 说明 |
\n|

\n", "image": "https://oss.javaguide.cn/ai/coding/glm5.1-cc/add-model-entry.png", "date_published": "2026-04-08T15:41:57.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 编程实战" ] }, { "title": "IDEA + Qoder 插件多场景实战：接口优化与代码重构", "url": "https://javaguide.cn/ai/ai-coding/idea-qoder-plugin.html", "id": "https://javaguide.cn/ai/ai-coding/idea-qoder-plugin.html", "summary": "通过两个真实实战案例，展示 IDEA 搭配 Qoder 插件在深分页优化、祖传代码重构等场景下的实际效果，分享从执行者到指挥者的工作模式转变。", "content_html": "

大家好，我是 Guide。如果你是 JetBrains IDE 的重度用户，大概率有过这样的纠结：想用 AI 辅助编程，但主流工具——Cursor、Trae、Qoder——大多基于 VS Code。切过去？舍不得 JetBrains 调试和重构体验。不切？又感觉错过了 AI 的效率红利。

\n

有朋友会说：Claude Code、Gemini CLI 这些终端工具不是挺香的吗？确实香，但说实话，CLI 模式也有明显的短板：没有原生 UI 交互，看代码、审 diff 都不够直观。虽然可以通过一些开源项目（如 vibe kanban、1Code）来缓解，但在做复杂项目时，还是存在一些局限性。

\n

现在的后端开发者，大致分成了四大阵营：

\n

| 阵营 | 工具组合 | 特点 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/coding/qoder/idea-plugin/plugin-install-interface.png", "date_published": "2026-03-29T06:07:23.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 编程实战" ] }, { "title": "Trae + MiniMax 多场景实战：Redis 故障排查与跨语言重构", "url": "https://javaguide.cn/ai/ai-coding/trae-m2.7.html", "id": "https://javaguide.cn/ai/ai-coding/trae-m2.7.html", "summary": "使用 Trae IDE 接入 MiniMax 大模型，通过 Redis 连接池故障排查和 Redis C 源码到 Go 跨语言重构两个真实场景，分享 AI 辅助编程的实战经验与工作技巧。", "content_html": "

大家好，我是 Guide。前面分享过一篇 IDEA 搭配 Qoder 插件的实战，那篇主要讲在 JetBrains 体系内用 AI 辅助编码。这篇换个角度，聊聊 Trae IDE 接入大模型 的实战体验。

\n

Trae 是字节跳动推出的 AI 编程 IDE，基于 VS Code 生态，支持接入多种大模型。本文使用 MiniMax M2.7 作为示例，但 Trae 的接入方式是通用的——换成 Claude、GPT 等其他模型，流程基本一致。

\n

我这里使用 MiniMax 是因为我刚好订阅了 MiniMax Code Plan 想要实际测试一些，并非广告，你可以换成其他模型，思路都是一样的。

\n

我选了两个比较有代表性的复杂场景来实际验证：

\n\n

快速上手：Trae 接入大模型

\n

Trae 支持接入多种大模型，下面以接入自定义模型为例，演示通用配置流程。

\n

第一步：到 Trae 官网下载安装并完成初始化，同时到对应模型平台完成注册和 API Key 创建（本文示例使用 MiniMax 平台）：

\n

https://platform.minimaxi.com/subscribe/token-plan

\n

第二步：在 Trae 中点击"Add Model"添加自定义模型：

\n

\"Trae添加模型入口\"

\n

第三步：选择"Other Models"并手动输入模型 ID 和 API Key：

\n

\"选择Other

\n

第四步：输入模型 ID（如 MiniMax-M2.7）和申请的 API Key，点击"Add Model"。若无报错提示，即表示接入成功：

\n

\"输入模型ID和API

\n

接入完成后，就可以在 Trae 中使用该模型进行 AI 辅助编程了。接下来通过两个实战场景，分享具体的使用方式和技巧。

\n

场景一：接口超时问题快速止血与根因定位

\n

问题定位

\n

第一个案例是某次真实线上故障的复现（已脱敏）。当时部门同学反馈某列表查询接口报错，页面无数据。线上监控系统定位到接口信息如下：

\n

接口：GET http://localhost:8080/api/rbac/user/list

\n

返回结果：

\n
{\n    \"code\": 500,\n    \"message\": \"系统繁忙，请稍后重试\",\n    \"data\": null,\n    \"timestamp\": \"2026-03-19T10:11:02.632242\"\n}
\n

结合异常堆栈信息关键字Read timed out，以及对应代码段的get(key)操作，我们可以初步认为该报错只是表象并非根因。

\n
@Override\npublic String getConfigValue(String configKey, String environment) {\n    String cacheKey = CONFIG_CACHE_PREFIX + configKey + \":\" + environment;\n    String value = stringRedisTemplate.opsForValue().get(cacheKey);\n    if (value != null) {\n        return value;\n    }\n    // 后续逻辑省略\n}
\n

按照常规处理流程，我们需要快速定位问题根因、完成止血，再联系运维深入排查。但项目中多处用到Redis，逐一排查耗时长，期间可能影响业务稳定性。

\n

为了验证 AI 辅助排查的实际效果，笔者复刻了该故障场景（已脱敏），让模型接手处理。按照企业级线上故障处理流程，首先需要定位根因并完成止血。于是向模型下达了第一条指令：

\n
针对访问 http://localhost:8080/api/rbac/user/list 接口时出现的500错误（错误信息：\"系统繁忙，请稍后重试\"），请执行以下操作：\n1. 分析提供的异常堆栈信息，准确定位导致服务器内部错误的根本原因；\n2. 提供详细的线上紧急止血方案，包括但不限于：临时回滚策略、流量限制措施、服务降级方案或紧急重启流程；\n3. 解释错误产生的技术原因，指出具体的代码模块或配置问题；\n\n...... 异常堆栈关键信息：`java.net.SocketTimeoutException: Read timed out`
\n

\"向M2.7下达的诊断指令截图\"

\n

模型收到请求后，很快定位到指定代码的上下文，并推理出4种可能的根因：

\n\n

\"M2.7推理结果截图\"

\n

到这一步，模型已经把问题空间从"N处Redis调用"压缩到了"4种可能根因"——这种快速收敛问题范围的能力，是 AI 辅助排查的核心价值。接下来看它的止血思路。

\n

止血

\n

模型针对既定异常栈帧快速梳理了代码调用逻辑，准确地指出：列表查询接口被切面拦截，连接池耗尽是500错误的根因。另外一个关键点，它指出了这段代码缺乏降级策略——这一点笔者是在复盘会上才意识到的。

\n

\"M2.7代码调用链路分析截图\"

\n

针对线上问题，止血策略是最关键的环节。模型给出了几个解决方案，第一个就是临时关闭权限校验开关——原因在于方案一需要清除Redis缓存数据。虽然方案有些激进，不过，它详细指出了代码的调用链路和表结构信息，这也能很好地辅助我通过业务语义猜测可能的场景和原因。

\n

\"M2.7调用链路分析\"

\n

基于模型提供的调用链路信息，笔者进一步询问方案一的技术依据，确保业务理解上快速对齐：

\n
结合代码开发的完整工作流程，详细阐述方案一的技术依据、设计思路及实施合理性。
\n

这也是让笔者比较满意的地方，模型给出了问题代码的调用链路图，让我快速了解到列表查询期间所经过的完整切面和具体故障所处位置，帮助理解当前问题的影响面以及本次异常的直接原因。

\n

经过不到10分钟的交互，笔者不仅迅速获得一个宏观的架构视角，理解了当前复杂架构的故障和各解决方案的依据，例如方案一：通过修改数据库配置重启刷新缓存来规避权限校验。

\n

\"M2.7调用链路图截图\"

\n

我们再来看看方案三的思路：当Redis不可用时，使用本地缓存或默认值，避免级联失败。模型结合当前工程代码段给出了修改建议：

\n

\"M2.7方案三代码片段\"

\n

模型分析后，我们对问题有了初步的判断：Redis客户端连接池耗尽，导致日常业务接口基于缓存开关查询逻辑崩溃，进而引发雪崩效应。综合模型的多个建议，本着保守、快速止血、业务高峰期不压垮数据库的原则，得出以下hotfix方案：

\n
根据提供的方案，创建一个hotfix止血分支，用于紧急修复Redis异常问题。具体实施步骤如下：\n1. 基于当前生产环境代码创建hotfix分支，命名规范为\"hotfix/redis-exception-handler\"\n2. 按照方案三实现Redis异常捕获机制，在所有Redis操作处添加try-catch块\n3. 当捕获到Redis异常时，自动降级为直接查询数据库获取数据\n4. 实现JVM本地缓存机制，将查询结果缓存至内存中，设置合理的缓存过期时间\n5. 完成单元测试和集成测试，覆盖率需达到80%以上\n6. 准备回滚方案，确保在紧急情况下能够快速恢复到上一版本
\n

\"hotfix方案指令\"

\n

模型收到指令后，准确理解了问题，完成任务拆解并逐步执行：

\n

\"M2.7任务拆解过程\"

\n

最终输出的代码结果如下：模型在原有权限校验逻辑中整合了数据库降级查询，对权限校验逻辑的理解和复杂设计的整合做得比较到位。

\n
@Around(\"permissionCheck()\")\npublic Object checkPermission(ProceedingJoinPoint joinPoint) throws Throwable {\n    try {\n        // 从配置中心读取权限校验开关\n        String checkEnabled = configService.getConfigValue(\"permission.check.enabled\", \"PROD\");\n        if (!\"true\".equalsIgnoreCase(checkEnabled)) {\n            return joinPoint.proceed();\n        }\n\n        // ... 原有权限校验逻辑 ...\n\n        // 尝试从Redis缓存获取权限信息\n        Boolean hasPermission = checkPermissionFromCache(redisKey);\n\n        if (hasPermission != null) {\n            // ... 命中缓存处理 ...\n        }\n\n        // 降级：从数据库查询权限\n        boolean hasPermissionFromDB = checkPermissionFromDatabase(userId, apiPath, httpMethod);\n        // ... 降级逻辑处理 ...\n\n    } catch (Exception e) {\n        if (e instanceof RuntimeException && \"无权限访问\".equals(e.getMessage())) {\n            throw e;\n        }\n        // 发生异常时，触发监控告警并采用保守策略放行\n        AlertManager.notify(\"PERMISSION_CHECK_ERROR\", e.getMessage());\n        return joinPoint.proceed();\n    }\n}
\n

getConfigValue同样补充了本地缓存逻辑，多级缓存设计在容错处理上做得不错。

\n
/**\n * 获取配置值（指定环境）\n */\n@Override\npublic String getConfigValue(String configKey, String environment) {\n    String cacheKey = CONFIG_CACHE_PREFIX + configKey + \":\" + environment;\n\n    // 【第一步：尝试从本地缓存获取】\n    String localValue = localCacheManager.get(cacheKey);\n    if (localValue != null) {\n        return localValue;\n    }\n\n    // 【第二步：尝试从Redis获取】\n    try {\n        if (isRedisAvailable()) {\n            String value = stringRedisTemplate.opsForValue().get(cacheKey);\n            if (value != null) {\n                localCacheManager.put(cacheKey, value, LOCAL_CACHE_TTL);\n                return value;\n            }\n        }\n    } catch (Exception e) {\n        // Redis异常，降级到数据库\n        handleRedisFailure(e);\n    }\n\n    // 【第三步：降级到数据库】\n    // ... 其他逻辑 ...\n    return getConfigValueFromDatabaseWithFallback(configKey, environment);\n}
\n

这其中值得注意的一个细节是本地缓存的设计：模型采用开闭原则，基于ConcurrentHashMap完成了本地缓存工具类的封装，考虑到了堆内存溢出风险，配合LRU算法实现缓存清理：

\n
@Component\npublic class LocalCacheManager {\n    // 核心存储：ConcurrentHashMap保证线程安全\n    private final Map<String, CacheEntry> cache = new ConcurrentHashMap<>();\n    private final ScheduledExecutorService cleanupExecutor;\n\n    // 缓存配置\n    private static final long DEFAULT_TTL_MILLIS = 300000; // 5分钟\n    private static final long MAX_CACHE_SIZE = 10000;\n\n    public LocalCacheManager() {\n        // 守护线程执行定时清理\n        this.cleanupExecutor = Executors.newSingleThreadScheduledExecutor(r -> {\n            Thread t = new Thread(r, \"local-cache-cleanup\");\n            t.setDaemon(true);\n            return t;\n        });\n        this.cleanupExecutor.scheduleAtFixedRate(this::cleanupExpiredEntries, 1, 1, TimeUnit.MINUTES);\n    }\n\n    public void put(String key, String value) {\n        put(key, value, DEFAULT_TTL_MILLIS);\n    }\n\n    public void put(String key, String value, long ttlMillis) {\n        // 容量满时触发LRU清理\n        if (cache.size() >= MAX_CACHE_SIZE) {\n            cleanupExpiredEntries();\n            if (cache.size() >= MAX_CACHE_SIZE) {\n                evictOldestHalf();\n            }\n        }\n        cache.put(key, new CacheEntry(value, System.currentTimeMillis() + ttlMillis));\n    }\n\n    public String get(String key) {\n        CacheEntry entry = cache.get(key);\n        if (entry == null || entry.isExpired()) {\n            cache.remove(key);\n            return null;\n        }\n        return entry.getValue();\n    }\n\n    // ... 其他方法省略 ...\n\n    // LRU清理：删除最老的50%数据\n    private void evictOldestHalf() {\n        // ...... 省略排序和清理逻辑 ......\n    }\n\n    // 缓存条目\n    private static class CacheEntry {\n        private final String value;\n        private final long expirationTime;\n\n        public CacheEntry(String value, long expirationTime) {\n            this.value = value;\n            this.expirationTime = expirationTime;\n        }\n\n        public String getValue() {\n            return value;\n        }\n\n        public boolean isExpired() {\n            return System.currentTimeMillis() > expirationTime;\n        }\n    }\n}
\n

根因定位

\n

通过hotfix分支针对线上故障止血之后，我们再来深入排查Redis连接池耗尽的原因。按照模型的输出结果和推断，一个常规的get指令操作按照Redis 10w qps的性能表现来看，10个连接（平均每个指令1~2ms），理想情况下每秒处理约6600条指令，远低于Redis的极限处理能力，所以问题可能出在代码层面，我们需要进一步推断项目中是否存在不合理的Redis操作：

\n
结合本次发生的具体故障现象和表现特征，对项目进行全面的系统性全局分析。分析范围应覆盖项目架构、代码实现、依赖管理、环境配置、数据交互等多个维度，重点识别并输出可能导致生产故障的直接原因。
\n

\"M2.7全局分析指令\"

\n

此时模型开始基于全局项目结构和上下文进行详细的阅读和推理分析：

\n

\"M2.7项目结构分析\"

\n

最终模型给出了详细的故障分析报告，指出根因：不当的Redis数据结构设计使用scan操作导致连接池夯死。同时，还结合上下文给出了该操作的业务流程，便于我们迅速理解这条故障链路：

\n

\"M2.7故障根因分析\"

\n

而解决方案也是非常干净利落，通过优化数据结构的方式降低Redis读写操作的时间复杂度，避免连接池夯死：

\n

\"M2.7优化方案建议\"

\n

场景一整体体验不错。从N处Redis调用中精准定位根因，到给出完整止血方案，整个推理链条清晰完整。

\n

不过也发现了一些问题：它给出的方案一（清除Redis缓存）略显激进，实际生产环境可能需要更保守的策略。另外，部分边界条件的防御性代码还是需要人工补充——AI能帮你走到90%，剩下的10%还得靠自己。

\n

场景2：从Redis C源码到Go实现的跨语言重构

\n

背景说明

\n

接下来我们再来一个高难度场景——复刻Redis慢查询指令。mini-redis是采用Go语言goroutine-per-connection理念提升吞吐量，并以C语言的风格实现符合RESP协议的缓存中间件，由于语言在设计理念上存在偏差，涉及复杂逻辑梳理和异构方案落地。用于验证大模型的跨语言架构设计能力再合适不过。

\n

需求梳理与方案设计

\n

针对项目重构类需求，按传统开发流程，我们需要大量时间阅读源代码梳理逻辑，期间因历史原因代码无注释，需结合上下文推理调试。了解原有逻辑后，还需结合新项目架构制定实施步骤，并设计单元测试确保既有逻辑稳定运行。整个流程（研发、测试到发布）保守估计需要3个工作日。抱着试试看的心态，笔者将源代码阅读和技术文档整理工作交给 AI 负责。

\n
我现在需要通过Go语言复刻Redis慢查询指令的实现。请你详细阅读Redis源代码，深入理解慢查询功能的完整实现原理、数据结构设计、处理流程和关键步骤。具体包括但不限于：慢查询日志的存储机制、慢查询阈值的配置与调整、慢查询命令的收集与记录流程、相关API接口的设计与实现，以及慢查询信息的查询与展示方式。请基于这些理解，整理出清晰的技术文档，包括核心原理说明、关键数据结构分析、实现步骤分解以及可能的性能优化考量。
\n

等待片刻后，模型明确指出技术要求，自底向上地介绍数据结构到执行链路，进行了详尽的分析和介绍：

\n

\"M2.7慢查询数据结构分析\"

\n

查看其对慢查询切面逻辑的定位非常准确，在主流程上输出了必要的注释，让我快速了解慢查询的整体处理流程：

\n

\"M2.7慢查询切面逻辑\"

\n

再看其对slot get指令的理解，也非常到位，思路和资深开发一样，抓大放小，明确核心逻辑，在主流程上输出必要的注释：

\n

\"M2.7

\n

确认模型对慢查询有了准确的理解后，接下来让它以开发专家的视角进行功能拆解、落地、测试回归的完整设计文档：

\n
按照测试驱动开发(TDD)方法论，使用Go语言创建一个全面详细的开发教程文档，指导复刻Redis的实现。该教程必须符合以下规范：\n\n1. 开发方法：\n   - 严格执行测试驱动开发工作流程：先编写会失败的测试，然后实现最简代码以通过测试，最后进行重构\n   - 采用类似于原始Redis C语言实现的面向过程的编程风格\n   - 尽可能使用纯Go语法和标准库\n\n2. 教程结构：\n   - 从项目设置和环境配置说明开始\n   - 按Redis功能拆分为逻辑模块进行开发\n   - 针对每个模块/特性，提供：\n     a. 明确的测试用例定义，包含预期输入和输出\n     b. 逐步的代码实现，附带逐行解释\n     c. 明确的测试命令和验证流程\n     d. 预期测试结果和成功标准\n\n3. 技术要求：\n   - 包含所有组件的完整代码片段\n   - 指定确切的文件结构和命名规范\n   - 详细说明编译和测试命令\n   - 解释常见问题的调试流程\n   - 在适用时参考相关的Redis C源代码模式\n\n4. 实现细节：\n   - 从核心数据结构（字符串、列表、哈希等）开始\n   - 逐步推进到命令处理和协议实现\n   - 包含网络层和客户端-服务器通信\n   - 涵盖持久化机制（RDB/AOF）\n   - 按照相同的行为模式实现基本的Redis命令\n\n5. 测试要求：\n   - 为每个组件提供完整的测试代码\n   - 解释测试断言和验证方法\n   - 包含单元测试和集成测试\n   - 指定如何运行测试并解读结果\n   - 详细说明如何根据Redis规范验证正确行为\n\n该教程应足够全面，让具备中级Go知识的开发者能够按照指定方法成功构建一个功能类似的Redis系统。
\n

等待片刻后，我们收到一份设计文档。模型结合Redis源代码上下文，梳理出慢查询的核心脉络和关键定义，并规划出完整的开发步骤：
\n\"慢查询设计文档\"

\n

编码实现

\n

我们从Redis源代码中抽取设计文档后，为确保C语言工程的设计思路能在个人Go语言项目工程规范中准确落地，将其复制到mini-redis项目，让模型分析方案的可行性和修改建议：

\n

\"M2.7可行性分析\"

\n

等待片刻后模型完成文档最后的可行性分析和整理，我们开始对其设计方案进行进一步的复核确认。从项目概述上可以看到，模型针对mini-redis项目结构进行了分析，准确地定位到慢查询可以直接复用的链表结构体并完成文档微调：

\n

\"M2.7链表结构体分析\"

\n

再来看看最关键的数据结构实现思路，模型也结合mini-redis的编码规范，生成了Go语言风格的结构体：

\n

\"M2.7

\n

针对慢查询时间测量，有个细节值得提一下。个人实现的指令处理入口和原生Redis有些设计上的出入：由于Go语言语法糖特性，笔者对指针、指针函数以及文件编排做了特殊处理。模型准确地基于笔者的协程模型定位到时间测量的切面，完成前置计时和后置统计，实现慢查询监控。

\n

\"M2.7时间测量切面\"

\n

最后就是核心的慢查询指令实现，无论是参数解析还是指令查询和响应处理函数，模型都结合笔者的当前项目封装的逻辑给出了明确的编码方案：

\n

\"M2.7慢查询指令实现\"

\n

经过仔细复核设计文档，整体开发思路基本一致，但在代码组织细节上仍有调优空间——例如模型将slowlog指令独立成文件，而未遵循项目惯例统一放入command.go。考虑到慢查询功能并非核心内存读写指令，且其日志管理逻辑相对独立，这一处理也算合理折中。权衡之后，我们决定保留模型的实现方式，同时手动调整部分文件布局以符合既有工程规范，随后推进剩余开发工作。

\n

这一细节也说明：AI生成的代码架构虽然合理，但与既有工程规范的适配仍然需要人工把关。

\n

另外提一句，整个慢查询功能的实现过程中，模型有两次生成了不符合项目风格的代码（比如错误处理方式），需要手动调整。这不是大问题，但说明完全依赖AI生成还是不行的。

\n

验收

\n

因为笔者明确指定了TDD的开发模型，所以模型在这期间结合输出反馈和文档说明完成自循环修复，最终结合mini-redis的项目风格完成了慢查询指令的复刻。

\n

得益于 AI 的推理和重构能力，在验收过程中我们有了更多的构思空间。之前一直因为源代码梳理总结和技术验收成本过大，导致 redis.conf 配置加载逻辑一直没有实现。

\n

因为笔者需要将慢查询时间设置为0，方便对慢查询指令做最后的验收工作，所以笔者索性再次对其提出加载配置的需求：

\n

\"M2.7配置加载实现\"

\n

整个逻辑梳理和开发工作不到1小时，笔者顺利完成了慢查询指令复刻和验收，为了演示慢查询功能，将mini-redis的慢查询阈值设置为0：

\n
# 慢查询阈值（微秒）\n# 执行时间超过此值的命令会被记录到慢查询日志中\n# 负值表示禁用慢查询日志，0 表示记录所有命令\n# 默认值：10000（10毫秒）\nslowlog-log-slower-than 0
\n

启动mini-redis服务端后，键入slowlog get 默认返回空：

\n

\"slowlog

\n

执行简单的set操作后，键入slowlog get，这条指令如预期被判定为慢查询指令并输出：

\n

\"slowlog

\n

同理，我们依次键入后续几条指令，也都准确按照链表头插法入队，实现按照时间降序排列输出：

\n

\"slowlog

\n

实战总结：AI 辅助编程的工作流思考

\n

通过两个典型场景的实战，总结一下使用 Trae + 大模型辅助编程的一些经验和思考。

\n

AI 辅助编程能做什么

\n

在上述两个场景中，AI 辅助编程体现了几个核心能力：

\n

| 能力维度 | 场景表现 | 说明 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/coding/m2.7/trae-add-model-entry.png", "date_published": "2026-03-29T06:07:23.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 编程实战" ] }, { "title": "AI 应用开发面试指南", "url": "https://javaguide.cn/ai/", "id": "https://javaguide.cn/ai/", "summary": "深入浅出掌握 AI 应用开发核心知识，涵盖大模型基础、Agent、RAG、MCP 协议、AI 编程实战等高频面试考点，适合校招/社招 AI 应用开发岗位面试复习。", "content_html": "
\n

写在前面

\n

现在网上有很多所谓”AI 技术文章”，点进去一看，满篇空洞的套话，逻辑混乱，读起来千篇一律。

\n

这类文章有几个共同特点：

\n\n

我在写这一系列 AI 文章的时候，坚持一个原则：要么不写，要写就写透。每一篇文章我都投入了大量时间：

\n\n

希望这些文章能真正帮到你。

\n
\n
\n

持续更新中

\n

AI 面试系列目前正在持续更新中，后续会陆续补充更多高频面试考点。

\n

当前内容可能还不够完善，如果你有想要了解的主题或任何建议，欢迎在项目 issue 区留言反馈。

\n
\n

这个专栏能帮你解决什么问题？

\n

如果你正在准备 AI 应用开发相关的面试，或者想要系统学习 AI 应用开发的核心知识，这个专栏就是为你准备的。

\n

通过这个专栏，你将获得：

\n

1. 扎实的大模型基础知识

\n

很多开发者在构建 Agent 工作流或调优 RAG 检索时，往往会在最底层的 LLM 参数上踩坑。比如：

\n\n

这些问题，如果你不理解 LLM 的底层原理，就永远只能“知其然不知其所以然”。在《万字拆解 LLM 运行机制》中，我会带你扒开 LLM 的黑盒，把 Token、上下文窗口、Temperature 等概念还原为清晰、可控的工程概念。

\n

2. 系统的 AI Agent 知识体系

\n

AI Agent 是当下 AI 应用开发最热门的方向。但网上的资料要么太浅，要么太散，很难形成系统的认知。

\n

在《一文搞懂 AI Agent 核心概念》中，我会带你：

\n\n

在《大模型提示词工程实践指南》中，我会带你：

\n\n

在《上下文工程实战指南》中，我会带你：

\n\n

3. 深入理解 RAG 检索增强生成

\n

RAG 是企业级 AI 应用的核心技术。但很多开发者只知道“把文档切成块，转成向量，然后检索”这个流程，却不理解背后的原理。

\n

在 RAG 系列文章中，我会带你深入理解：

\n\n

4. 掌握工具与协议

\n

在 AI 应用开发中，工具接入的碎片化是一个大问题。MCP 协议的出现，就是要解决这个问题。

\n

在《万字拆解 MCP 协议》中，我会带你理解：

\n\n

在《万字详解 Agent Skills》中，我会带你理解：

\n\n

在《一文搞懂 Harness Engineering》（六层架构、上下文管理与一线团队实战）中，我会带你理解：

\n\n

5. AI 编程面试准备

\n

AI 编程工具正在深刻改变开发者的工作方式。在面试中，你可能会被问到：

\n\n

在《AI 编程开放性面试题》中，我会分享 7 道高频开放性面试问题的回答思路。

\n

6. AI 编程实战

\n

纸上得来终觉浅。只有亲手用过 AI 编程工具，才能真正理解它的工作边界和使用技巧。在 AI 编程实战系列中，我会通过真实场景的实战案例，分享 AI 辅助编程的使用经验：

\n\n

文章列表

\n

大模型基础

\n\n

AI Agent

\n\n

RAG（检索增强生成）

\n\n

AI 编程实战

\n\n

配图预览

\n

为了帮助读者更好地理解抽象的技术概念，我在每篇文章中都绘制了大量配图。这里展示几张：

\n

\"上下文窗口示意图\"

\n

上下文窗口是 LLM 的“工作记忆”，决定了模型能处理的最大文本量

\n

\"RAG

\n

RAG 的核心思想：先检索相关上下文，再让 LLM 基于上下文生成回答

\n

\"MCP

\n

MCP 被称为“AI 领域的 USB-C 接口”，统一了 LLM 与外部工具的通信规范

\n

写在最后

\n

这个专栏我会持续更新。如果觉得有帮助，欢迎分享给身边的朋友。有问题或建议，直接在项目 issue 区留言就行。

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/llm/llm-context-window.png", "date_published": "2026-03-26T12:44:11.000Z", "date_modified": "2026-04-08T16:06:36.000Z", "authors": [], "tags": [] }, { "title": "万字拆解 MCP，附带工程实践", "url": "https://javaguide.cn/ai/agent/mcp.html", "id": "https://javaguide.cn/ai/agent/mcp.html", "summary": "深入解析 MCP 协议核心概念，涵盖 MCP 四大核心能力、四层分层架构、JSON-RPC 2.0 通信机制及生产级 MCP Server 开发最佳实践。", "content_html": "

在 LLM 应用开发从”单体调用”向”复杂 Agent”演进的当下，开发者最头疼的其实不是换模型——框架早把不同模型的 API 差异给封装好了。真正让人抓狂的是工具接入的碎片化：每次想让 AI 用上 GitHub、本地文件或者 MySQL，就得为 Claude、GPT、DeepSeek 分别写一套适配代码。改一个工具接口，得同步维护好几套代码，又烦又容易出错。

\n

MCP (Model Context Protocol) 的出现，就是要终结这种混乱。它被形象地称为 “AI 领域的 USB-C 接口”，通过统一的通信协议，让工具开发者一次开发 MCP Server，之后所有支持 MCP 的 AI 应用都能直接复用，真正实现模型与外部数据源、工具的高效解耦。

\n

今天 Guide 就来分享几道 MCP 基础概念相关的问题，希望对大家有帮助。本文接近 1.6w 字，建议收藏，通过本文你讲搞懂：

\n
    \n
  1. ⭐ 什么是 MCP？它解决了什么核心问题？
    2. \n
  2. ⭐ MCP、Function Calling 和 Agent 有什么区别与联系？
    3. \n
  3. MCP v1.0 的四大核心能力是什么？
    4. \n
  4. ⭐ MCP 的四层分层架构是如何运行的？
    5. \n
  5. 为什么 MCP 选择了 JSON-RPC 2.0 而非 RESTful？
    6. \n
  6. ⭐️ MCP 支持哪些传输方式？（stdio、Streamable HTTP）
    7. \n
  7. ⭐ 生产环境下开发 MCP Server 有哪些必知的最佳实践？
    8. \n
\n

MCP 基础概念

\n

⭐️ 什么是 MCP？它解决了什么问题？

\n

MCP (Model Context Protocol) 是 Anthropic 于 2024 年提出的开放协议，被誉为 "AI 领域的 USB-C 接口标准"。它通过 JSON-RPC 2.0 统一了 LLM 与外部数据源/工具的通信规范，解决了 AI 应用开发中的复杂性和碎片化问题。

\n

它允许 AI 接入数据源（如本地文件、数据库）、工具（如搜索引擎、计算器）以及工作流（如特定提示词），使其能够获取关键信息并执行具体任务。

\n

\"MCP

\n

在 MCP 出现之前，开发者为不同 LLM（OpenAI GPT、Claude、文心一言等）和不同后端系统集成工具时，需要编写大量定制化的适配代码。这导致了：

\n\n

MCP 通过定义统一的通信协议，让一次开发的工具可以跨多个 LLM 平台使用，就像 USB-C 接口让不同设备可以通用充电线一样。

\n
\n

🌈 拓展一下：

\n

MCP 的核心价值在于解耦和标准化。就像 HTTP 统一了网页传输、RESTful API 统一了服务接口一样，MCP 统一了 AI 与外部世界的交互方式。没有这一层标准化，每接一个新工具就得适配一遍各家的 API，规模化基本无从谈起。

\n
\n

MCP 的四大核心能力是什么？

\n

MCP v1.0 定义了四种核心能力类型，覆盖了 LLM 与外部交互的主要场景：

\n

| 能力 | 核心作用 | 实际场景举例 | 失败路径与边界 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/skills/mcp-simple-diagram.png", "date_published": "2026-03-26T09:55:47.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "万字详解 Agent Skills：是什么？怎么用？和 Prompt、MCP 有什么区别？", "url": "https://javaguide.cn/ai/agent/skills.html", "id": "https://javaguide.cn/ai/agent/skills.html", "summary": "深入解析 Agent Skills 概念，探讨 Skills 与 Prompt、MCP、Function Calling 的本质区别，以及如何在实战中设计优秀的 Skill 固化代码规范。", "content_html": "

2025 年初，Anthropic 在推出 MCP（Model Context Protocol） 之后，进一步提出了 Agent Skills 的概念。背后的思路其实很清楚：连接性（Connectivity）与能力（Capability）应该分离。

\n

很多开发者认为”只要提示词写得好，AI 就能帮我做一切”。但事实是：Prompt 适合单次任务，Skills 才是构建可复用 AI 能力的正确做法。

\n

Skills 把 AI 应用从”个人技巧”拉到了”工程化”的层面。今天 Guide 就带大家彻底搞懂这个概念，聊清楚 Skills 的设计理念、与相关技术的本质区别，以及如何在实战中用好这个能力。本文接近 1.2w 字，建议收藏，通过本文你将搞懂：

\n
    \n
  1. ⭐ Skills 是什么：为什么说 Skill 是”延迟加载”的 sub-agent？它的核心机制——上下文注入和延迟加载是如何工作的？
    2. \n
  2. ⭐ Skills vs Prompt vs MCP vs Function Calling：这四者的本质区别是什么？它们分别适用于什么场景？这是面试中的高频盲区。
    3. \n
  3. ⭐ 优秀的 Skill 长什么样：一个设计良好的 Skill 应该包含哪些要素？元数据、触发条件、执行流程如何设计？
    4. \n
  4. ⭐ 项目实战：如何在真实开发中用 Skills 固化代码规范、排查流程、Review 标准？如何把团队中的”隐性知识”变成可复用的 AI 能力？
    5. \n
\n

Skills 是什么？

\n

用一句话概括：Skill 是一个用自然语言定义的、具有特定领域上下文（Domain Context）的逻辑指令集，本质上是通过延迟加载（Lazy Loading）优化 Token 消耗的 Sub-Agent（子智能体）。

\n

在团队协作中，很多"隐性知识"都在老员工脑子里，比如代码规范、排查流程、Review 标准。Skills 的核心价值，就是把这些隐性规则变成显性的文档（SOP），让 AI 能够自主阅读、理解并执行。

\n

与传统编程不同，Skills 不强制规定每一步的代码逻辑，而是用自然语言将决策权下放给模型——模型通过 load_skill() 动态加载 SKILL.md 后，将其中定义的规则、流程和约束实时注入到推理上下文中，指导后续的工具调用和决策。这既保留了 Agent 处理不确定性的优势，又避免了纯代码编排的僵化。

\n
\n

为什么不用"基于 Function Calling 封装"？这个表述容易让人误以为 Skill 是某种 Function Calling 的语法糖。实际上，Skill 的核心机制是上下文注入——Agent 读取 Markdown 文档，把其中的规则和流程纳入推理上下文。Function Calling 只是 Agent 执行某些动作（如调脚本、查资源）时可能用到的底层手段，不是 Skills 本身的定义层。

\n

注意：load_skill() 是对"Agent 读取并激活 SKILL.md"这一过程的概念性描述，不同工具（Claude Code、Cursor 等）的实际触发方式会有差异。

\n
\n

关键机制：

\n\n

Skills 和 Prompt、MCP、Function Calling有什么区别？

\n

这也是面试中常被问到的点，容易混淆：

\n

1. Skills vs Prompt

\n

| 维度 | Prompt | Skills |
\n| :

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/skills/mcp-simple-diagram.png", "date_published": "2026-03-26T09:55:47.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "9 道 AI 编程相关的开放性面试问题", "url": "https://javaguide.cn/ai/llm-basis/ai-ide.html", "id": "https://javaguide.cn/ai/llm-basis/ai-ide.html", "summary": "涵盖 Cursor、Claude Code、Trae 等 AI 编程 IDE 使用技巧，Spec Coding 与 Vibe Coding 区别，以及 AI 对后端开发影响等高频面试问题。", "content_html": "

腾讯面试的时候，面试官问我：“用过什么 AI 编程工具？”。我说：“Trae。”

\n

空气突然安静了两秒。我搞不清楚为什么面试官沉默了，当时我还在想：“是不是我回答得不够高级？”。

\n

面试被挂后才意识到：Trae 是字节的，腾讯家的是 CodeBuddy，阿里家的是 Qoder。

\n

段子归段子！今天 Guide 分享 7 道当下校招和社招技术面试中经常会被问到的 AI 编程开放性问题，希望对你有帮助。通过本文你将搞懂：

\n
    \n
  1. ⭐ AI 编程 IDE：Cursor、Claude Code 等 AI 编程工具有什么使用技巧？如何建立自己的使用方法论？
    2. \n
  2. ⭐ AI 对后端开发的影响：你如何看待 AI 对后端开发的影响？AI 会淘汰初级程序员吗？AI 带来的最大风险是什么？
    3. \n
  3. ⭐ 未来核心竞争力：你觉得未来 3 年后端工程师的核心竞争力是什么？
    4. \n
\n

AI 编程 IDE 和使用技巧

\n

用过什么 AI 编程 IDE 吗？什么感觉？

\n

我用过几款 AI 编程工具，例如 Cursor、Trae、Claude Code，其中我日常开发中主要用的是 Cursor（根据你自己的使用去说就好，我这里以国内用的比较多的 Cursor 为例）。

\n

目前整体感觉是：AI 编程能力进步真的太快了！它已经从几年前简单的代码补全，进化成了一个可以深度协作的工程助手。

\n

我总结了一套自己的使用方法论：

\n
    \n
  1. 在接手复杂项目或模块时，我不会直接让 AI 写代码，而是先让 Cursor 分析整个代码库，生成一份包含核心架构、模块职责和数据流的文档。这一步非常关键，因为它决定了后续协作的质量。只有当我和 AI 对项目有一致理解时，后续产出才会稳定、高质量。
    2. \n
  2. 对于每个独立的开发任务，我都会开启一个新的对话，并提供必要的上下文，包括需求背景、涉及模块和约束条件。这种方式能显著减少上下文污染，让 AI 生成的代码更加精准，基本不需要大幅返工。
    3. \n
  3. 我也会定期删除冗余实现和废弃代码。旧代码会误导 AI 的判断，增加上下文噪音，长期不清理会直接影响协作效率。
    4. \n
\n

AI 是一个强大的知识库和辅助工具，可以帮我们快速实现功能、学习新知识。但如果完全依赖 AI 写代码而不理解其原理，个人技术能力可能会退化。

\n

因此我会坚持几个原则：

\n\n

我希望效率提升，但不以牺牲技术能力为代价。

\n

⭐知道哪些 Cursor 使用技巧？

\n
\n

这里是以 Cursor 为例，其他 AI IDE 都是类似的。

\n
\n
    \n
  1. 先理架构再动手：无论是自己写代码还是让 AI 生成代码，都必须先明确需求、整体架构和模块边界。如果在架构模糊的情况下直接编码，很容易出现重复实现或职责冲突，后期修改成本反而更高。
    2. \n
  2. 单 Chat 专注单功能：新功能或大改动开启新的 Chat，并在开头引入项目结构说明或关键文档作为上下文基础。这样可以避免历史对话干扰，提高输出质量。
    3. \n
  3. 功能落地后写指南：让 AI 总结实现过程，抽象出通用步骤，形成“操作指南”。比如新增接口的标准流程、文件导出的统一实现方式等。这些沉淀下来的内容，可以在后续类似需求中快速复用。
    4. \n
  4. 不依赖 AI，主动复盘：AI 仅作辅助，代码生成后需认真 Review，理解原理、优化不合理处，避免技术停滞。
    5. \n
  5. 定期删无用代码：清理冗余代码，减少对 AI 的误导和上下文干扰，提升开发效率。
    6. \n
  6. 用好配置文件：.cursorrules 定义 AI 生成代码的规则、风格和常用片段；.cursorignore 指定不允许 AI 修改的文件 / 目录，保护核心代码。
    7. \n
  7. 持续维护文档：项目重大变更后，让 AI 同步更新文档、记录 "踩坑" 经验，积累团队知识库。
    8. \n
  8. 让 AI 先 "学" 项目：大型项目先让 Cursor 分析代码库，生成含架构、目录职责、核心类等的结构文档，作为后续开发的基础上下文。
    9. \n
\n

知道那些 Claude Code 使用技巧？

\n

和上一个问题其实是有重合的，我单独分享过一篇：⭐Claude Code使用技巧总结。

\n

AI 对后端开发的影响

\n

⭐你如何看待 AI 对后端开发影响？

\n

我认为 AI 不会取代后端工程师，但会显著改变后端工程师的工作方式和能力结构。

\n

AI 将我们从重复的、模式化的工作中解放出来，成为我们最强的帮手：

\n\n

AI 让后端工程师能更专注于业务建模、复杂系统设计和架构决策这些更具创造性的核心工作。并且，AI 同样能够辅助我们更好地完成这些事情。

\n

拿我自己来说，我经常会和 AI 讨论业务和技术方案，它总能给我不错的启发——尤其是在需求拆解和技术选型时，AI 能提供多角度的思考。

\n

你觉得 AI 会淘汰初级程序员吗？

\n

短期内不会淘汰，但会彻底改变初级程序员的能力结构。

\n

以前初级工程师的价值在于：

\n\n

现在这些工作 AI 都能做得很好，甚至更高效、更少出错。但这不意味着初级程序员会被淘汰，只是他们的价值创造点发生了迁移。

\n

未来初级工程师需要具备：

\n\n

AI 让编程门槛变低，但对"理解能力"的要求反而更高。未来的初级工程师更像是一个"AI 协调者"，而非单纯的"代码编写者"。

\n

从企业招聘角度看，纯编码能力的需求会减少，但对"能利用 AI 快速交付业务价值"的工程师需求会增加。

\n

AI 带来的最大风险是什么？

\n

我认为主要有三个层面：

\n

1. 技术能力退化

\n

过度依赖 AI 会导致工程师自身技术能力的退化，尤其是：

\n\n

2. 架构失控

\n

AI 生成的代码往往关注"当前功能可用"，容易忽视长期架构健康度。这很大程度上源于 Vibe Coding（氛围编程）——依赖模糊意图让 AI"自由发挥"。

\n\n

3. 安全风险（尤其需要重视）

\n\n

4. 分布式场景下的失效模式（尤其危险）

\n

AI 生成的代码在分布式环境中极易忽略关键约束，导致生产事故：

\n

| 失效模式 | AI 常见问题 | 生产风险 |
\n|

\n", "date_published": "2026-03-26T09:55:47.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "万字详解 RAG 向量索引算法和向量数据库", "url": "https://javaguide.cn/ai/rag/rag-vector-store.html", "id": "https://javaguide.cn/ai/rag/rag-vector-store.html", "summary": "深入解析 RAG 场景下的向量数据库选型与使用，涵盖向量索引算法（HNSW、IVFFLAT）、ANN 近似检索原理、pgvector 实践等高频面试考点。", "content_html": "

前段时间面某大厂的时候，面试官问我：“你们 RAG 系统的向量检索怎么做的？”，我说：“用 MySQL 存 Embedding，查询时遍历计算相似度。”

\n

空气突然安静了五秒。我看到面试官的嘴角抽了一下，才意识到问题大了——当时我们知识库有 50 多万条 Chunk，每次查询都要全表扫描，平均响应时间 3 秒+，用户早就跑光了。

\n

面试被挂后才懂：这叫“暴力搜索”，而生产级方案应该是向量数据库 + ANN 索引。

\n

段子归段子，向量数据库确实是当下 RAG 应用的基础设施，也是 AI 应用开发面试的高频考点。今天 Guide 分享几道向量数据库相关的面试题，希望对大家有帮助：

\n
    \n
  1. ⭐️ RAG 场景为什么需要向量数据库？
    2. \n
  2. ⭐️ 什么是向量索引算法？
    3. \n
  3. 有哪些向量索引算法？
    4. \n
  4. ⭐️ 你的项目使用的什么向量索引算法？
    5. \n
  5. HNSW 索引和 IVFFLAT 索引的区别是什么？
    6. \n
  6. 有哪些向量数据库？
    7. \n
  7. ⭐️ 你为什么选择 PostgreSQL + pgvector？
    8. \n
  8. 为什么不选择 MySQL 搭配向量数据库呢？
    9. \n
\n

⭐️ RAG 场景为什么需要向量数据库？

\n

RAG（Retrieval-Augmented Generation）的核心是“语义检索”——把文档和用户问题都转成高维向量（Embedding），然后找最相似的 Top-K 片段作为 LLM 上下文。传统关系型数据库（MySQL、PostgreSQL 原生）或全文搜索引擎（ES 的 BM25）无法高效完成这件事，所以必须引入向量数据库（或带向量扩展的数据库）。

\n

\"RAG

\n

1. 高维向量相似度搜索

\n

Embedding 通常是 768~3072 维的稠密向量，传统数据库只能用 = 或 LIKE 做精确匹配，无法计算“余弦相似度 / 内积 / 欧氏距离”。

\n

暴力搜索：如果强行用 SQL 遍历全表计算相似度，复杂度是 O(n)。以 100 万条 1024 维向量为例：

\n\n

秒级延迟——对于需要实时响应的问答系统完全不可接受。

\n

ANN 近似检索：向量数据库专为最近邻搜索（ANN, Approximate Nearest Neighbor）设计，通过图导航或空间划分大幅减少距离计算次数，将检索延迟降至毫秒级。

\n

| 指标 | 暴力搜索 | ANN 索引检索 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/rag/rag-why-need-vector-store.png", "date_published": "2026-03-26T09:55:47.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "为什么忘记密码时只能重置，不能告诉你原密码？", "url": "https://javaguide.cn/system-design/security/why-password-reset-instead-of-retrieval.html", "id": "https://javaguide.cn/system-design/security/why-password-reset-instead-of-retrieval.html", "summary": "详细解答为什么忘记密码时网站只能让你重置密码，而不能告诉你原密码。核心原因是服务端使用哈希算法存储密码，哈希算法不可逆，无法从哈希值还原出原始密码。本文还介绍了密码存储安全、加盐机制、Bcrypt 加密、密码传输安全等知识。", "content_html": "

这是一个挺有意思的问题，很多公司也在面试中问过。挺简单的，不知道大家平时在重置密码的时候有没有想过这个问题。

\n

\"重置帐号密码\"

\n

回答这个问题其实就一句话：因为服务端也不知道你的原密码是什么。存原密码的程序员已经被开了 🤣。

\n

如果服务端知道你的原密码，那就是严重的安全风险问题了。

\n

我们这里来简单分析一下。

\n

这篇文章不会谈论太多加密算法相关的内容，感兴趣的朋友可以看这篇文章：常见加密算法总结。

\n

\n

为什么服务端不知道你的原密码？

\n

做过开发的应该都知道，服务端在保存密码到数据库的时候，绝对不能直接明文存储。

\n

如果明文存储的话，风险太大：

\n
    \n
  1. 数据库数据有被盗的风险
    2. \n
  2. 有数据库权限的内部人员可能恶意利用
    3. \n
  3. 黑客入侵后可以直接获取所有用户密码
    4. \n
\n

因此，密码必须经过处理后才能存储。这个处理方式就是使用哈希算法。

\n

哈希算法简介

\n

哈希算法也叫散列函数或摘要算法，它的作用是对任意长度的数据生成一个固定长度的唯一标识，也叫哈希值、散列值或消息摘要（后文统称为哈希值）。

\n

\"哈希算法效果演示\"

\n

哈希算法有两个关键特点：

\n
    \n
  1. 不可逆性：你无法通过哈希之后的值再得到原值。这是核心！
    2. \n
  2. 确定性：相同的输入永远产生相同的输出。
    3. \n
\n

有个很形象的比喻：你存的密码就像切过的土豆丝，不能被复原成土豆。但网站判断密码是否正确的方式，就是把你输入的新密码当成土豆再切一次，看看这两盘土豆丝是不是一样的。

\n

这两个特点决定了哈希算法非常适合用于密码存储：服务端只存储密码的哈希值，验证时只需比较哈希值是否一致。

\n

哈希算法的分类

\n

哈希算法可以简单分为两类：

\n
    \n
  1. 加密哈希算法：安全性较高的哈希算法，它可以提供一定的数据完整性保护和数据防篡改能力，能够抵御一定的攻击手段，安全性相对较高，但性能较差，适用于对安全性要求较高的场景。例如 SHA2、SHA3、SM3、RIPEMD-160、BLAKE2等等。
    2. \n
  2. 非加密哈希算法：安全性相对较低的哈希算法，易受到暴力破解、冲突攻击等攻击手段的影响，但性能较高，适用于对安全性没有要求的业务场景。例如 CRC32、MurMurHash3等等。
    3. \n
\n

除了这两种之外，还有一些特殊的哈希算法，例如安全性更高的慢哈希算法。

\n

为什么不推荐 MD5？

\n

早期常用 MD5 来加密密码，但现在已经不被推荐，原因如下：

\n
    \n
  1. 抗碰撞性差：存在弱碰撞问题，即多个不同的输入可能产生相同的 MD5 值。
    2. \n
  2. 哈希值较短：128 位的哈希值容易被彩虹表攻击。
    3. \n
  3. 计算速度太快：反而容易被暴力破解。
    4. \n
\n

详细介绍可以阅读这篇文章：简历别再写 MD5 加密密码了！

\n

为什么需要加盐？

\n

单纯使用哈希算法存储密码，仍然存在被彩虹表攻击的风险。彩虹表是一种预先计算好的哈希值对照表，攻击者可以通过查表的方式快速破解密码。

\n

盐（Salt）在密码学中，是指通过在密码任意固定位置插入特定的字符串，让哈希后的结果和使用原始密码的哈希结果不相符，这种过程称之为"加盐"。

\n

加盐的作用：

\n
    \n
  1. 增加密码的复杂度和唯一性。
    2. \n
  2. 使得彩虹表攻击失效（每个用户的盐都不同）。
    3. \n
  3. 即使两个用户使用相同密码，哈希值也不同。
    4. \n
\n

密码存储方案推荐

\n

目前推荐的密码存储方案有两种：

\n

方案一：加密哈希算法 + Salt

\n

使用安全性较高的加密哈希算法（如 SHA-256、SHA-3）加上盐值。

\n

SHA-256 + Salt 示例代码：

\n
String password = \"123456\";\nString salt = \"1abd1c\";\n// 创建SHA-256摘要对象\nMessageDigest messageDigest = MessageDigest.getInstance(\"SHA-256\");\nmessageDigest.update((password + salt).getBytes());\n// 计算哈希值\nbyte[] result = messageDigest.digest();\n// 将哈希值转换为十六进制字符串\nString hexString = new HexBinaryAdapter().marshal(result);\nSystem.out.println(\"Original String: \" + password);\nSystem.out.println(\"SHA-256 Hash: \" + hexString.toLowerCase());
\n

输出：

\n
Original String: 123456\nSHA-256 Hash: 424026bb6e21ba5cda976caed81d15a3be7b1b2accabb79878758289df98cbec
\n

方案二：慢哈希算法（更推荐）

\n

Bcrypt 是专门为密码加密而设计的哈希算法，属于慢哈希算法。它内置了 salt 机制和 cost（成本）参数：

\n\n

Bcrypt 可以有效防止彩虹表攻击和暴力破解攻击。

\n

Java 应用程序的安全框架 Spring Security 官方推荐使用 BCryptPasswordEncoder：

\n
@Bean\npublic PasswordEncoder passwordEncoder(){\n    return new BCryptPasswordEncoder();\n}
\n

登录验证流程

\n

当你输入密码登录时，验证流程如下：

\n
    \n
  1. 服务端根据用户名从数据库取出该用户的盐值和存储的哈希值。
    2. \n
  2. 服务端将用户输入的密码与盐值拼接，计算哈希值。
    3. \n
  3. 比较计算出的哈希值与数据库中存储的哈希值是否一致。
    4. \n
  4. 如果一致，说明密码正确；否则密码错误。
    5. \n
\n

\n

重置密码时如何判断新密码与旧密码相同？

\n

细心的同学可能发现，有些网站在重置密码时会提示"新密码不可与旧密码相同"。那网站是怎么知道新密码和旧密码相同的呢？

\n

其实原理和验证密码正确性一样：

\n
    \n
  1. 用户输入新密码。
    2. \n
  2. 服务端用该用户的盐值，计算新密码的哈希值。
    3. \n
  3. 将新密码的哈希值与数据库中存储的旧密码哈希值比较。
    4. \n
  4. 如果相同，说明新密码和旧密码一样，拒绝修改。
    5. \n
\n

所以网站并不知道你的旧密码是什么，只是比较了两盘"土豆丝"是否一样。

\n

密码传输安全

\n

前面讲的都是密码在服务端的存储安全，那密码在传输过程中安全吗？

\n

有个常见的面试问题：如果某个员工知道加密方式，那岂不是他可以在私下或者离职后拦截包然后模拟加密从而获取密码？

\n

答案是：存储与传输本身就是分开处理的。

\n

完整的密码安全方案需要同时保障存储安全和传输安全。

\n

使用 HTTPS

\n

HTTPS 协议是保障传输安全的基础。HTTP 协议运行在 TCP 之上，所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份。HTTPS 则是运行在 SSL/TLS 之上的 HTTP 协议，所有传输的内容都经过加密。

\n

关于 HTTP 和 HTTPS 的详细对比可以看这篇文章：HTTP vs HTTPS（应用层）。

\n

但是，仅仅依赖 HTTPS 还不够安全：

\n
    \n
  1. HTTPS 存在降级攻击、中间人攻击等风险
    2. \n
  2. HTTPS 只能保证传输过程中第三方抓包看到的是密文，无法防范客户端本身的恶意行为
    3. \n
\n

因此，我们还需要对密码进行加密后再传输。

\n

密码加密传输

\n

加密算法分为对称加密和非对称加密两大类。

\n

对称加密是指加密和解密使用同一个密钥的算法，也叫共享密钥加密算法。

\n

\"对称加密\"

\n

非对称加密是指加密和解密使用不同密钥的算法，也叫公开密钥加密算法。这两个密钥一个称为公钥（可公开），另一个称为私钥（需保密）。用公钥加密的数据只能用对应的私钥解密，反之亦然。

\n

\"非对称加密\"

\n

常见的非对称加密算法有 RSA、DSA、ECC 等。

\n

对于密码传输这一场景，推荐使用非对称加密。完整流程如下：

\n
    \n
  1. 服务端生成公私钥对，私钥严格保密存储在服务端，公钥下发到客户端
    2. \n
  2. 客户端传输密码前，使用公钥加密密码
    3. \n
  3. 服务端收到加密数据后，用私钥解密获取原始密码
    4. \n
  4. 服务端对原始密码进行哈希处理、加盐后存储
    5. \n
\n

完整的安全方案

\n

综合存储和传输，一个完整的密码安全方案包含三层：

\n
// 第一层：客户端加密（非对称加密传输）\nconst encryptedPassword = rsaEncrypt(password, publicKey);\n\n// 第二层：HTTPS 安全传输\n// 第三层：服务端存储（哈希 + 盐值）
\n

所以，即使内部员工知道加密算法，他也只能拿到：

\n\n

这两层保护确保了密码在全链路的安全性。

\n

总结

\n

回到最初的问题：为什么忘记密码时只能重置，不能告诉你原密码？

\n

因为服务端存储的是密码经过哈希算法处理后的值，哈希算法是不可逆的，无法从哈希值还原出原始密码。这是密码安全的基本原则。

\n

如果一个网站能够告诉你原密码，那说明它明文存储了密码，这是严重的安全隐患，建议立即修改密码并远离该网站。

\n

更重要的是：如果你在所有网站都用了相同的密码，一个不靠谱的网站泄漏了你的密码，就相当于你所有的账户都面临风险。所以，不要在所有网站使用相同密码！

\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/security/reset-password-page.png", "date_published": "2026-03-23T08:33:10.000Z", "date_modified": "2026-03-23T08:33:10.000Z", "authors": [], "tags": [ "系统设计" ] }, { "title": "Java 26 新特性概览", "url": "https://javaguide.cn/java/new-features/java26.html", "id": "https://javaguide.cn/java/new-features/java26.html", "summary": "概览 JDK 26 的关键新特性与预览改动，关注 HTTP/3、GC 性能优化、AOT 缓存与语言/平台增强。", "content_html": "

JDK 26 于 2026 年 3 月 17 日 发布，这是一个非 LTS（非长期支持版）版本。上一个长期支持版是 JDK 25，下一个长期支持版预计是 JDK 29。

\n

JDK 26 共有 10 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\n

JEP 517: 为 HTTP Client API 引入 HTTP/3 支持

\n

JDK 26 为 java.net.http.HttpClient API 正式添加了 HTTP/3 支持，这是一个期待已久的重要更新。

\n

HTTP/3 的优势：

\n\n

详细介绍可以阅读这篇文章：计算机网络常见面试题总结（上）（网络分层模型、常见网路协议总结、HTTP、WebSocket、DNS 等）

\n

使用方式：

\n

HTTP/3 的使用非常简单，几乎不需要修改现有代码。HttpClient 会自动协商使用最高版本的 HTTP 协议：

\n
HttpClient client = HttpClient.newHttpClient();\n\nHttpRequest request = HttpRequest.newBuilder()\n    .uri(URI.create(\"https://example.com\"))\n    .build();\n\n// 如果服务器支持 HTTP/3，HttpClient 会自动升级使用\nHttpResponse<String> response = client.send(request,\n    HttpResponse.BodyHandlers.ofString());\n\nSystem.out.println(response.body());
\n

如果需要明确指定使用 HTTP/3，可以通过 version() 方法设置：

\n
// 所有请求默认优先使用 HTTP/3\nHttpClient client = HttpClient.newBuilder()\n    .version(HttpClient.Version.HTTP_3)  // 明确指定 HTTP/3\n    .build();\n\n// 设置单个HttpRequest对象的首选协议版本\nHttpRequest request = HttpRequest.newBuilder(URI.create(\"https://javaguide.cn/\"))\n                         .version(HttpClient.Version.HTTP_3)\n                         .GET().build();
\n

JEP 522: G1 GC 吞吐量优化

\n

从 JDK9 开始，G1 垃圾收集器成为了默认的垃圾收集器。 它在延迟和吞吐量之间寻求平衡。然而，这种平衡有时会影响应用程序的性能。与面向吞吐量的 Parallel GC 相比，G1 更多地与应用程序并发工作，以减少 GC 暂停时间。但这意味着应用线程必须与 GC 线程共享 CPU 并进行协调，这种同步会降低吞吐量并增加延迟。

\n

JEP 522 引入了双卡表（Card Table）机制：

\n
    \n
  1. 第一张卡表：应用线程的写屏障在更新这张卡表时无需任何同步，使得写屏障代码更简单、更快速。
    2. \n
  2. 第二张卡表：优化器线程在后台并行处理这张初始为空的卡表。
    3. \n
\n

当 G1 检测到扫描第一张卡表可能超过暂停时间目标时，它会原子性地交换这两张卡表。应用线程继续更新空的、原先的第二张表，而优化器线程则处理满的、原先的第一张表，无需进一步同步。

\n

性能提升效果：

\n\n

内存开销：

\n

第二张卡表与第一张容量相同，每张卡表需要 Java 堆容量的 0.2%，即每 1GB 堆内存额外使用约 2MB 原生内存。

\n

JEP 516: AOT 对象缓存支持任意 GC

\n

这是 Project Leyden 的重要里程碑，使得提前（AOT）对象缓存能够与任意垃圾收集器配合使用。

\n

之前在 JDK 24 中引入的 AOT 类数据共享（JEP 483）只支持 G1 垃圾收集器，无法与 ZGC 等其他 GC 配合使用。这是因为 AOT 缓存中存储的对象引用使用的是物理内存地址，而不同 GC 的内存布局和对象移动策略不同。

\n

JEP 516 将对象引用的存储方式从物理内存地址改为逻辑索引：

\n\n

性能收益：

\n\n

JEP 500: 准备让 final 真正不可变

\n

这个特性为 Java 的完整性优先原则铺平道路，准备让 final 字段真正变得不可变。

\n

从 JDK 1.0 开始，Java 的 final 字段实际上可以通过深度反射被修改：

\n
import java.lang.reflect.Field;\nimport java.lang.reflect.Method;\n\nclass Example {\n    private final String name = \"Original\";\n\n    public String getName() {\n        return name;\n    }\n}\n\n// 通过反射修改 final 字段\nExample example = new Example();\nField field = Example.class.getDeclaredField(\"name\");\nfield.setAccessible(true);\n\n// 移除 final 修饰符\nField modifiersField = Field.class.getDeclaredField(\"modifiers\");\nmodifiersField.setAccessible(true);\nmodifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);\n\nfield.set(example, \"Modified\");  // 成功修改了 final 字段！\nSystem.out.println(example.getName());  // 输出 \"Modified\"
\n

这种能力虽然被一些框架（如序列化库、依赖注入框架、测试工具）使用，但破坏了 final 的不可变性保证，也阻碍了编译器优化。

\n

在 JDK 26 中，当通过深度反射修改 final 字段时，JVM 会发出警告。这是为未来版本中默认禁止此类操作做准备。

\n

对于确实需要修改 final 字段的场景，JDK 26 提供了显式的选择机制，允许开发者在过渡期继续使用此能力，同时为未来的严格模式做好准备。

\n

JEP 526: 延迟常量 (第二次预览)

\n

该特性第一次预览是由 JEP 501 （JDK 25）提出，JDK 26 是第二次预览。

\n

传统的 static final 字段在类加载时就会初始化，这会：

\n\n

JEP 526 引入了 LazyConstant<T>，一种持有不可变数据的对象，JVM 将其视为真正的常量，以获得与声明 final 字段相同的性能。

\n
// 传统方式：类加载时立即初始化\nstatic final ExpensiveObject TRADITIONAL = new ExpensiveObject();\n\n// 新方式：首次访问时才初始化\nstatic final LazyConstant<ExpensiveObject> LAZY =\n    LazyConstant.of(() -> new ExpensiveObject());\n\n// 使用时\nExpensiveObject obj = LAZY.get();  // 此时才初始化
\n

优势：

\n\n

JEP 525: 结构化并发 (第六次预览)

\n

JDK 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope，它支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主/父任务继续之前完成或者子任务随主/父任务失败而取消。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n

Java 26 的新变动：

\n\n

JEP 530: 模式匹配支持基本类型 (第四次预览)

\n

该特性第一次预览是由 JEP 455 （JDK 23 ）提出。

\n

模式匹配可以在 switch 和 instanceof 语句中处理所有的基本数据类型（int, double, boolean 等）

\n
static void test(Object obj) {\n    if (obj instanceof int i) {\n        System.out.println(\"这是一个int类型: \" + i);\n    }\n}
\n

JDK 26 对该特性进行了进一步增强：

\n\n

这样就可以像处理对象类型一样，对基本类型进行更安全、更简洁的类型匹配和转换，进一步消除了 Java 中的模板代码。

\n

JEP 524: 加密对象 PEM 编码 (第二次预览)

\n

该特性第一次预览是由 JEP 518 （JDK 25）提出。

\n

PEM（Privacy-Enhanced Mail）是一种广泛使用的文本格式，用于存储和传输加密对象，如证书、私钥和公钥。JEP 524 提供了一个新的 API，用于将加密对象编码为 PEM 格式，以及从 PEM 格式解码回加密对象。

\n
// 将密钥编码为 PEM 格式\nKeyPairGenerator kpg = KeyPairGenerator.getInstance(\"RSA\");\nkpg.initialize(2048);\nKeyPair keyPair = kpg.generateKeyPair();\n\n// 编码为 PEM\nString pemEncoded = PemEncoding.encode(keyPair.getPrivate());\n\n// 从 PEM 解码\nPrivateKey decodedKey = PemEncoding.decode(pemEncoded);
\n

这个 API 减少了错误风险，简化了合规性要求，并通过简化企业、云和监管需求的加密设置和集成，增强了安全 Java 应用程序的可移植性和互操作性。

\n

JEP 529: Vector API (向量 API, 第十一次孵化)

\n

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

\n

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

\n

这是对数组元素的简单标量计算：

\n
void scalarComputation(float[] a, float[] b, float[] c) {\n   for (int i = 0; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n   }\n}
\n

这是使用 Vector API 进行的等效向量计算：

\n
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;\n\nvoid vectorComputation(float[] a, float[] b, float[] c) {\n    int i = 0;\n    int upperBound = SPECIES.loopBound(a.length);\n    for (; i < upperBound; i += SPECIES.length()) {\n        // FloatVector va, vb, vc;\n        var va = FloatVector.fromArray(SPECIES, a, i);\n        var vb = FloatVector.fromArray(SPECIES, b, i);\n        var vc = va.mul(va)\n                   .add(vb.mul(vb))\n                   .neg();\n        vc.intoArray(c, i);\n    }\n    for (; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n    }\n}
\n

尽管仍在孵化中，但其第十一次迭代足以证明其重要性。它使得 Java 在科学计算、机器学习、AI 推理、大数据处理等性能敏感领域，能够编写出接近甚至媲美 C++ 等本地语言性能的代码。

\n

JEP 504: 移除 Applet API

\n

Applet API 在 JDK 9 中被标记为废弃，在 JDK 17 中被标记为即将移除。在 JDK 26 中，Applet API 终于被完全移除。大快人心啊！

\n

这意味着：

\n\n

Applet 技术早已过时，现代 Web 开发已完全转向其他技术栈。移除这个遗留 API 是 Java 平台现代化的必要步骤。

\n

总结

\n

JDK 26 虽然是一个非 LTS 版本，但包含了一些值得关注的重要特性：

\n

| 类别 | 特性 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2026-03-21T06:28:26.000Z", "date_modified": "2026-03-21T06:28:26.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "MySQL索引失效场景总结", "url": "https://javaguide.cn/database/mysql/mysql-index-invalidation.html", "id": "https://javaguide.cn/database/mysql/mysql-index-invalidation.html", "summary": "全面总结MySQL索引失效的常见场景，包括SELECT *查询、违背最左前缀原则、索引列计算函数转换、LIKE模糊查询、OR连接、IN/NOT IN使用不当、隐式类型转换以及ORDER BY排序优化陷阱，帮助你避免索引失效导致的性能问题。", "content_html": "

在数据库性能优化中，索引是最直接有效的优化手段之一。然而，建了索引并不等于一定能用上索引。实际开发中，我们经常遇到这样的困惑：明明在字段上建立了索引，查询却依然慢如蜗牛，通过 EXPLAIN 分析发现居然是全表扫描。

\n

导致索引失效的原因多种多样，既有 SQL 语句写法问题，也有索引设计不当的因素。有些失效场景是显性的（如违背最左前缀原则），有些则非常隐蔽（如隐式类型转换）。如果不深入了解这些失效场景，很容易在生产环境中埋下性能隐患。

\n

本文将系统总结 MySQL 索引失效的常见场景，分析失效背后的原理机制，并提供相应的优化建议，帮助你在日常开发和排查问题中快速定位并解决索引失效问题。

\n

SELECT * 查询（成本权衡）

\n\n

违背最左前缀原则

\n\n

Index Skip Scan 失败路径图：

\n

失效示例：

\n
-- 索引：(sname, s_code, address)\nSELECT * FROM students WHERE s_code = 1;                  -- 跳过最左列 sname，索引失效\nSELECT * FROM students WHERE sname = 'A' AND address = 'Shanghai'; -- 跳过中间列，仅 sname 走索引（索引下推 ICP 可优化过滤）\nSELECT * FROM students WHERE sname = 'A' AND s_code > 1 AND address = 'Shanghai'; -- 范围查询后，address 无法用于定位，仅用于过滤
\n

在索引列上进行计算、函数或类型转换

\n\n

失效示例：

\n
SELECT * FROM students WHERE height + 1 = 170;            -- 对索引列进行计算\nSELECT * FROM students WHERE DATE(create_time) = '2022-01-01'; -- 对索引列使用函数
\n

优化建议：

\n
SELECT * FROM students WHERE height = 169;                -- 将计算移到等号右边\nSELECT * FROM students WHERE create_time BETWEEN '2022-01-01 00:00:00' AND '2022-01-01 23:59:59';
\n

LIKE 模糊查询以通配符开头

\n\n

失效示例：

\n
SELECT * FROM students WHERE sname LIKE '%Guide';          -- 前缀模糊，全表扫描\nSELECT * FROM students WHERE sname LIKE '%Guide%';         -- 前后模糊，全表扫描
\n

OR 连接与 Index Merge

\n\n

失效示例：

\n
-- 假设 sname 和 address 都有索引，但各匹配 30%+ 数据\nSELECT * FROM students WHERE sname = '学生 1' OR address = '上海'; -- 可能放弃索引，全表扫描\n\n-- 建议改写为\nSELECT * FROM students WHERE sname = '学生 1'\nUNION ALL\nSELECT * FROM students WHERE address = '上海'; -- 各自走索引
\n

验证方式：EXPLAIN 中若出现 type: index_merge 和 Extra: Using union; Using where，说明使用了 Index Merge。

\n

IN / NOT IN 使用不当

\n

IN 列表长度：

\n\n

NOT IN ：

\n\n

失效示例：

\n
SELECT * FROM students WHERE s_code IN (1, 2, 3, ..., 500); -- 列表过长，可能改用统计估算导致误判\nSELECT * FROM students WHERE s_code NOT IN (1, 2, 3);     -- 常量列表，全表扫描
\n

隐式类型转换

\n

这是开发中最隐蔽的坑，转换的方向决定了索引的生死。

\n

| 场景 | 示例 | 转换方向 | 索引是否有效 |
\n|

\n", "date_published": "2026-03-09T10:52:44.000Z", "date_modified": "2026-03-21T06:28:26.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "ZAB协议详解", "url": "https://javaguide.cn/distributed-system/protocol/zab.html", "id": "https://javaguide.cn/distributed-system/protocol/zab.html", "summary": "ZooKeeper的核心共识协议ZAB（ZooKeeper Atomic Broadcast，原子广播协议）详解，包括消息广播模式、崩溃恢复模式、Leader选举机制（ZXID/epoch）、数据恢复机制及Follower/Observer角色解析。", "content_html": "

作为一款极其优秀的分布式协调框架，ZooKeeper 的高可用和数据一致性备受业界推崇。很多人误以为 ZooKeeper 使用的是大名鼎鼎的 Paxos 算法，但实际上，它的"灵魂"是一个专门为其定制的共识协议——ZAB（ZooKeeper Atomic Broadcast，原子广播协议）。

\n

ZAB 并非像 Paxos 那样是通用的分布式一致性算法，它是一种特别为 ZooKeeper 设计的、支持崩溃可恢复的原子消息广播算法。基于 ZAB 协议，ZooKeeper 实现了一种主备模式的架构，来保持集群中各个副本之间的数据一致性。

\n

ZAB 集群的核心角色与状态

\n

在深入协议运作之前，我们需要先了解 ZooKeeper 集群中的三个主要角色：

\n\n

对应的，集群中的节点通常处于以下四种状态之一：

\n\n

核心标识：ZXID 与 Epoch

\n

为了保证分布式环境下消息的绝对顺序性，ZAB 协议引入了一个全局单调递增的事务 ID——ZXID。

\n

ZXID 是一个 64 位的长整型（long）：

\n\n

\"ZXID

\n

ZAB 的两种基本模式

\n

ZAB 协议的运作可以精简为两种基本模式的交替：消息广播（正常工作状态）和崩溃恢复（异常或启动状态）。

\n

1. 消息广播模式（正常处理写请求）

\n

\"ZAB

\n

当集群拥有健康的 Leader，且过半的节点完成了状态同步后，就会进入消息广播模式。这个过程类似于一个简化的“两阶段提交（2PC）”：

\n
    \n
  1. 生成提案： Leader 接收到写请求后，将其转化为一个带有 ZXID 的提案（Proposal）。
    2. \n
  2. 顺序发送： Leader 为每个 Follower 维护了一个先进先出（FIFO）的网络队列（基于 TCP 协议），确保提案按生成顺序发送给 Follower。
    3. \n
  3. 写入与反馈（WAL 强制落盘）： Follower 收到提案后，必须将其追加到本地的事务日志（TxnLog）中，并强制执行系统调用 fsync 将内核缓冲区的数据物理刷入磁盘。只有确认数据切实落盘，才会向 Leader 响应 ACK。这一过程是 ZAB 抵御断电丢失数据的核心防线。因此，在物理部署上，强烈建议将 ZooKeeper 的事务日志目录（dataLogDir）挂载到独立且无锁的 SSD 上，避免与其他高 I/O 进程争用磁盘，从而规避因 fsync 阻塞导致的 P99 响应时间恶化。生产环境中必须重点监控节点的 fsynctime 指标，若平均刷盘耗时经常超过 100ms，集群随时可能崩溃。
    4. \n
  4. 广播提交： 当 Leader 收到过半数 节点的 ACK 响应后，就会认为该写操作成功。Leader 在本地写日志时会更新内部的 quorum 计数器（而非显式向自己发送 ACK），确认过半后向客户端返回成功响应，并向所有节点广播 Commit 消息。Follower 收到 Commit 后，正式将数据应用到内存中。
    5. \n
\n

2. 崩溃恢复模式（Leader 宕机或网络异常）

\n

当系统刚启动，或者 Leader 服务器崩溃、与过半 Follower 失去联系时，整个集群就会暂停对外服务，进入 LOOKING 状态，触发崩溃恢复模式。崩溃恢复主要包含两个阶段：Leader 选举和数据恢复。

\n

\"zab-crash-recovery-flow\"

\n

阶段一：Leader 选举

\n

选举的核心原则是：拥有最新数据的节点优先当选。 每个节点都会先投自己一票，投票信息包含 (Epoch, ZXID, myid)。随后节点会交换选票，并按照以下顺序进行 PK：

\n
    \n
  1. 比较 Epoch： 纪元大的优先。
    2. \n
  2. 比较 ZXID： 如果 Epoch 相同，ZXID 大的优先（代表数据越新）。
    3. \n
  3. 比较 myid： 如果前两者都相同，服务器唯一标识 myid 大的优先。
    4. \n
\n

一旦某个节点获得了过半数的选票，它就会成为新的 Leader。(这也是为什么 ZooKeeper 推荐部署奇数台服务器的原因，能以最低的成本实现半数以上的容错。)

\n

阶段二：数据恢复

\n

选出新 Leader 只是第一步，为了保证数据一致性，ZAB 必须在数据同步阶段实现两个极其重要的保证：

\n
    \n
  1. 确保已经在旧 Leader 上提交的事务，最终被所有节点提交。 （防止数据丢失）
    2. \n
  2. 丢弃那些只在旧 Leader 上提出，但还没来得及提交的事务。 （防止脏数据干扰）
    3. \n
\n

新 Leader 会找到当前最大的 Epoch 并加 1 作为新纪元，随后与所有 Follower 进行比对。Follower 会发送自己事务日志中最新记录的 lastZxid（包含已提议但尚未提交的提案），Leader 根据这个值采取多态同步策略：差异化增量同步（DIFF）、强制丢弃未提交日志（TRUNC） 或 全量快照传输（SNAP）。

\n

这一设计至关重要：Leader 需要准确识别 Follower 日志中是否残留着旧 Leader 未完成提交的"幽灵提案"，才能正确下发 TRUNC 指令让其截断回滚。如果只上报已提交的 ZXID，这些未提交的脏数据将无法被感知，TRUNC 分支就永远不会被触发。

\n

更关键的是，此时新的 Epoch 已经生效。若原 Leader 因 JVM 触发长达数十秒的 Full GC 而发生"假死"，当其苏醒并试图向集群下发旧 Epoch 的提案时，由于过半节点已记录了更高的新 Epoch 且已向新 Leader 提交 quorum，这些幽灵提案将被节点无情拒绝并抛弃。ZAB 正是通过 Epoch 机制 + 多数派 quorum 的组合，从根本上免疫了网络环境下的脑裂现象——单靠 Epoch 拒绝还不够，必须有过半节点已经连上新 Leader，旧 Leader 才真正失去写入能力。

\n

当过半的机器与新 Leader 完成了状态和数据同步，ZAB 协议就会平滑退出崩溃恢复模式，重新进入消息广播模式。

\n

与 Raft 对比

\n

ZAB 与 Raft 的高度相似性： 如果你了解过 Raft 算法，会发现它们非常相似。它们都有唯一的主节点，都使用 Epoch/Term 来标识任期，并且都采用了只要半数以上节点确认即可提交的策略。这说明在现代分布式共识领域，这种基于主备和多数派选举的架构已经成为了事实上的标准。

\n

在当前的分布式系统实践中，Raft 算法通常被视为比 ZAB 更实用和受欢迎的选择。 这是因为 Raft 从设计之初就强调易懂性和可实现性，它将领导者选举、日志复制和安全性明确分离，这使得开发者更容易正确实施和调试，而 ZAB 作为 ZooKeeper 的专有协议，更侧重于原子广播的特定需求，导致其通用性较差。

\n

Raft 已广泛应用于现代系统，如 Kubernetes 的 etcd、Hashicorp Consul、Apache Kafka（在其 KIP-500 版本中去除 ZooKeeper 依赖，转向 Raft-based KRaft）、TiKV 等，这极大“民主化”了分布式共识的开发。

\n

相比之下，ZAB 主要绑定在 ZooKeeper 上，虽然 ZooKeeper 仍是经典的协调服务，但许多新项目倾向于选择 Raft 以避免 ZooKeeper 的额外复杂性和潜在瓶颈（如在大规模下共识开销）。

\n

此外，Raft 的社区支持更活跃，衍生出多种优化变体（如用于区块链的改进版本），使其在效率和适用场景上更具优势。 然而，如果你的系统已深度集成 ZooKeeper，ZAB 仍是最优化的选择；否则，对于新设计或通用共识需求，Raft 是当前更实用的标准。

\n

总结

\n

ZAB 协议通过精心设计的 Leader 选举和多数派确认机制，在分布式系统的分区容错性（P）和一致性（C）之间做出了选择（满足 CP 属性）。当出现网络分区时，ZAB 宁愿牺牲短暂的可用性（A）进行选举，也要保证数据的一致性。

\n

需要特别强调的是，ZAB 协议默认不保证严格的强一致性（线性一致性），而是提供顺序一致性（Sequential Consistency）。

\n

由于 Follower 可以直接处理客户端的读请求且不强求数据绝对同步，客户端完全可能读取到落后于 Leader 的陈旧数据（Stale Read）。在生产环境中，若业务涉及如分布式锁等对数据新鲜度要求极高的场景，必须在执行 read() 操作前显式调用 sync() 原语，强制要求连接的 Follower 追平 Leader 的事务状态机。

\n

当发生网络分区时，客户端若连接至被隔离的少数派 Follower，虽然写操作会失败，但仍可读出过期数据，这是使用 ZAB 协议时必须考虑的边界场景。

\n", "image": "https://oss.javaguide.cn/github/javaguide/distributed-system/protocol/zab-zxid-structure.png", "date_published": "2026-03-04T08:41:16.000Z", "date_modified": "2026-03-12T04:06:59.000Z", "authors": [], "tags": [ "分布式" ] }, { "title": "如何基于Redis实现消息队列？", "url": "https://javaguide.cn/database/redis/redis-stream-mq.html", "id": "https://javaguide.cn/database/redis/redis-stream-mq.html", "summary": "讲解 Redis 做消息队列的三种方式：List、Pub/Sub、Stream。对比生产级 MQ 核心能力，详解 Redis 5.0 Stream 的消费者组、ACK 机制及与 Kafka/RabbitMQ 的适用场景对比。", "content_html": "

先说结论：可以是可以，但要看具体场景。和专业的消息队列（如 Kafka、RabbitMQ）相比，还是有一些欠缺的地方。

\n

正式开始介绍之前，我们先来看看：一个生产级 MQ 需要具备哪些核心能力？

\n

| 能力维度 | 定义 | 关键指标/特征 |
\n| :

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/redis/redis-pub-sub.png", "date_published": "2026-03-01T07:29:56.000Z", "date_modified": "2026-04-08T07:23:21.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "2026 最新后端面试 PDF 资料", "url": "https://javaguide.cn/interview-preparation/pdf-interview-javaguide.html", "id": "https://javaguide.cn/interview-preparation/pdf-interview-javaguide.html", "summary": "2026 版后端面试 PDF 资料整理（JavaGuide）：梳理校招/社招高频考点与复习优先级，覆盖 Java 基础、集合、并发、MySQL、Redis、Spring/Spring Boot、JVM、系统设计与项目经验准备，帮你抓重点高效备战。", "content_html": "

大家好，我是 Guide。

\n

2026 版后端 PDF 面试资料终于搞定了！这次的更新量大得惊人，熬了几个通宵，总算能拿出来见人了。

\n

在上一版的基础上，我把内容又往深里挖了挖。目前这份资料已经涵盖了 Java 核心、计算机基础、数据库、缓存、分布式、设计模式、智力题、学习路线、面经等全方位内容。毫不夸张地说，你备战后端面试需要的硬核干货，这一份全包了！

\n

为了让大家看得更爽，我对其中大部分 PDF 进行了“推倒重来式”的优化：

\n\n

\n

这些 PDF 面试资料的质量都非常高，绝大部分都是 Guide 的原创，也会有一些其他优质技术博主分享的原创资料。

\n

之所以一直坚持出 PDF 版，是因为有一些朋友比较喜欢看 PDF 资料，甚至把 PDF 资料打印出来学习。

\n

\n

截止到目前，这套资料在各个渠道的汇总下载量已经突破了 35w+ 。 说实话，这个数字对我来说不只是流量，更是沉甸甸的信任和责任。

\n

老规矩，没有任何花里胡哨的套路，直接白嫖： 在 JavaGuide 公众号后台回复 PDF 即可获取。

\n\"JavaGuide\n

由于 PDF 的时效性问题，如果想要更完美的体验，个人其实还是更建议大家去 JavaGuide 网站上在线阅读，内容更新，一直在持续完善。

\n

部分内容概览

\n

《JavaGuide 面试突击》— Java 集合：

\n

\"《JavaGuide

\n

《JavaGuide 面试突击》— JVM：

\n

\"《JavaGuide

\n

《JavaGuide 面试突击》—设计模式：

\n

\"《JavaGuide

\n

Java 学习路线：

\n

\"Java

\n

如何获取？

\n

老规矩，没有任何花里胡哨的套路，直接白嫖： 在 JavaGuide 公众号后台回复 PDF 即可获取。

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/intro/pdf-interview-javaguide.png", "date_published": "2026-01-21T03:04:06.000Z", "date_modified": "2026-01-21T03:04:06.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "《SpringAI 智能面试平台+RAG 知识库》", "url": "https://javaguide.cn/zhuanlan/interview-guide.html", "id": "https://javaguide.cn/zhuanlan/interview-guide.html", "summary": "Spring AI智能面试平台实战项目，基于Spring Boot 4.0和Spring AI 2.0开发，集成RAG知识库和简历分析功能。", "content_html": "

很多小伙伴跟我反馈："我的简历上全是增删改查（CRUD），面试官看都不看，怎么办？"

\n

既然 AI 浪潮已至，我们就直接把大模型能力、向量数据库、RAG 架构装进你的项目里。

\n

项目介绍

\n

这是一个基于 Spring Boot 4.0 + Java 21 + Spring AI 2.0 的 AI 智能面试辅助平台。系统提供三大核心功能：

\n
    \n
  1. 智能简历分析：上传简历后，AI 自动进行多维度评分并给出改进建议
    2. \n
  2. 模拟面试系统：基于简历内容生成个性化面试题，支持实时问答和答案评估
    3. \n
  3. RAG 知识库问答：上传技术文档构建私有知识库，支持向量检索增强的智能问答
    4. \n
\n

\"效果展示\"

\n

项目地址 （欢迎 star 鼓励）：

\n\n

完整代码完全免费开源，没有 Pro 版本或者付费版！

\n

简历写法

\n

如何将《SpringAI 智能面试平台+RAG知识库》实战项目写进简历？我一共提供了五大方向版本任选，精准匹配岗位需求：

\n
    \n
  1. 后端方向：提供"架构与分布式能力侧重"、"AI 应用与响应式编程侧重"、"工程化与基础设施侧重"三个版本，无论你面试的是后端、大模型应用还是架构岗位，都能找到最合适的切入点。
    2. \n
  2. 测试/测开方向：专门设计了"单元测试与 TDD"以及"功能/异常场景覆盖"两个版本，突出测试工程师在 AI 质量保障中的核心竞争力。
    3. \n
\n

\"《SpringAI

\n

每一条描述都紧扣项目真实逻辑，严格遵守项目介绍规范。不仅教你怎么写，更教你怎么补，例如针对本项目未涉及的"用户认证与鉴权"给出补充建议，教你如何基于 SpringSecurity/Sa-Token 包装主流的认证授权方案。

\n

并且，我还补充了面试官可深挖的技术难点（如Redis Stream vs 传统消息队列、分布式限流的实现细节）以及项目难点与解决方案模板。

\n

教程概览

\n

带大家看看我写的配套教程，用心程度一切都在文字中！整个项目教程，我手绘了几十张技术配图帮助理解。

\n

例如，RAG 面试题总结这篇，耗时一周终于完成了第一版，一共 3.4 万字，包含 35 道高频 RAG 面试题，光校对都进行了三次。而且，这还只是第一版，后续还会继续完善优化！

\n

\"RAG

\n

这篇是对应的 RAG 知识库详细开发思路的介绍。

\n

\"RAG

\n

不仅教你"如何写出代码"，更教你"为什么这么设计"以及"在企业真实场景中如何应对复杂挑战"。

\n

配套教程内容安排

\n

这个项目当前实现的功能比较简单，学习门槛极低，但涉及到的知识点比较丰富。通过保姆级教程，我们将从零构建一个融合了 LLM 集成、RAG（检索增强生成）、向量数据库、分布式限流及异步处理的完整后端架构。

\n

无论你是想学习 Spring AI 的前沿应用，还是需要一个高含金量的简历项目，本项目都将为你提供从基建搭建、业务攻坚到面试话术复盘的全方位指导。

\n

配套项目教程需要付费（后文/文末有加入方法），但请大家理解，主要是想覆盖一些时间成本。而且，收费和提供的服务相比绝对是超级良心了。这辈子不可能干割韭菜的事！

\n

内容安排如下（已经更完，一共 13w+ 字）：

\n

\"配套教程内容概览\"

\n

环境搭建

\n\n

核心功能开发

\n\n

进阶优化

\n\n

面试

\n\n

加入学习

\n

本项目为 JavaGuide 知识星球 内部专属实战项目，通过语雀文档在线阅读学习，不单独对外开放。

\n

之所以选择在星球内部发布，是为了确保每一位学习者都能获得深度的技术答疑和完整的求职配套服务。

\n

整个项目教程预计在 1-2 个月内更完。每一篇文章（不提供视频，浪费时间且不利于学习能力提高）都经过反复推敲，确保高质量、零门槛，即便是基础薄弱的同学也能跟着文档从零跑通。

\n

这只是开始。后续星球还会持续推出更多贴合企业真实业务场景的 Java 实战项目，带你始终站在技术前沿（预告一下，下一个项目是企业级智能客服系统，会带大家实践更多AI能力）。

\n

并且，我的星球还有很多其他服务，比如一对一提问、简历修改、后端系统面试资料（包含高频系统设计&场景题）、学习打卡等，其中任何一项服务单独拎出来的价值都已远超星球门票。欢迎详细了解我的知识星球！

\n

已经坚持维护六年，内容持续更新，虽白菜价（0.4 元/天）但质量很高，主打一个良心！

\n

目前星球正在做活动，两本书的价格，就能让你拥有上万培训班的服务！这里再提供一张 **30 ** 元的优惠卷（价格马上上调，老用户扫码续费半价 ）：

\n

\"知识星球30元优惠卷\"

\n

用心做内容，坚持本心，不割韭菜，其他交给时间！共勉！

\n

系统架构

\n

提示：架构图采用 draw.io 绘制，导出为 svg 格式，在 Dark 模式下的显示效果会有问题。

\n

系统采用前后端分离架构，整体分为三层：前端展示层、后端服务层、数据存储层。

\n

\"系统架构图\"

\n

后端层：

\n\n

数据存储层：

\n\n

异步处理流程：

\n

简历分析、知识库向量化和面试报告生成采用 Redis Stream 异步处理，这里以简历分析和知识库向量化为例介绍一下整体流程：

\n
上传请求 → 保存文件 → 发送消息到 Stream → 立即返回\n                              ↓\n                      Consumer 消费消息\n                              ↓\n                    执行分析/向量化任务\n                              ↓\n                      更新数据库状态\n                              ↓\n                   前端轮询获取最新状态
\n

状态流转： PENDING → PROCESSING → COMPLETED / FAILED

\n

知识库问答处理流程：

\n
知识库问答 → 问题向量化 → pgvector 相似度搜索 → 检索相关文档\n                                                      ↓\n                                构建 Prompt → LLM 生成回答 → SSE 流式返回
\n

技术栈概览

\n

后端技术

\n

| 技术 | 版本 | 说明 |
\n|

\n", "image": "https://oss.javaguide.cn/xingqiu/pratical-project/interview-guide/page-resume-history.png", "date_published": "2026-01-12T06:25:02.000Z", "date_modified": "2026-04-08T07:23:21.000Z", "authors": [], "tags": [ "知识星球" ] }, { "title": "一致性哈希算法详解", "url": "https://javaguide.cn/distributed-system/protocol/consistent-hashing.html", "id": "https://javaguide.cn/distributed-system/protocol/consistent-hashing.html", "summary": "一致性哈希算法原理详解，讲解哈希环、虚拟节点机制、数据倾斜问题解决方案，以及在分布式缓存（Redis/Memcached）、负载均衡、分库分表中的应用场景。", "content_html": "

开始之前，先说两个常见的场景：

\n
    \n
  1. 负载均衡：由于访问人数太多，我们的网站部署了多台服务器个共同提供相同的服务，但每台服务器上存储的数据不同。为了保证请求的正确响应，相同参数（key）的请求（比如同个 IP 的请求、同一个用户的请求）需要发到同一台服务器处理。
    2. \n
  2. 分布式缓存：由于缓存数据量太大，我们部署了多台缓存服务器共同提供缓存服务。缓存数据需要尽可能均匀地分布式在这些缓存服务器上，通过 key 可以找到对应的缓存服务器。
    3. \n
\n

这两种场景的本质，都是需要建立一个从 key 到服务器/节点的稳定映射关系。

\n

为了实现这个目标，你首先会想到什么方案呢？

\n

普通哈希算法

\n

相信大家很快就能想到 “哈希+取模” 这个经典组合。通过哈希函数计算出 key 的哈希值，再对服务器数量取模，从而将 key 映射到固定的服务器上。

\n

公式也很简单：

\n
node_number = hash(key) % N
\n
\n

\"哈希取模\"

\n

然而，传统的哈希取模算法有一个比较大的缺陷就是：无法很好的解决机器/节点动态减少（比如某台机器宕机）或者增加的场景（比如又增加了一台机器）。

\n

想象一下，服务器的初始数量为 4 台 (N = 4)，如果其中一台服务器宕机，N 就变成了 3。此时，对于同一个 key，hash(key) % 3 的结果很可能与 hash(key) % 4 完全不同。

\n

\"哈希取模-移除节点Node2\"

\n

这意味着几乎所有的数据映射关系都会错乱。在分布式缓存场景下，这会导致大规模的缓存失效和缓存穿透，瞬间将压力全部打到后端的数据库上，引发系统雪崩。

\n

据估算，当节点数量从 N 变为 N-1 时，平均有 (N-1)/N 比例的数据需要迁移，这个比例 趋近于 100% 。这种“牵一发而动全身”的效应，在生产环境中是完全不可接受的。

\n

为了更好地解决这个问题，一致性哈希算法诞生了。

\n

一致性哈希算法

\n

一致性哈希算法在 1997 年由麻省理工学院提出（这篇论文的 PDF 在线阅读地址：https://www.cs.princeton.edu/courses/archive/fall09/cos518/papers/chash.pdf），是一种特殊的哈希算法，在移除或者添加一个服务器时，能够尽可能小地改变已存在的服务请求与处理请求服务器之间的映射关系。一致性哈希解决了传统哈希算法在分布式哈希表（Distributed Hash Table，DHT）中存在的动态伸缩等问题 。

\n

一致性哈希算法的底层原理也很简单，关键在于哈希环的引入。

\n

哈希环

\n

一致性哈希算法将哈希空间组织成一个环形结构，将数据和节点都映射到这个环上，然后根据顺时针的规则确定数据或请求应该分配到哪个节点上。通常情况下，哈希环的起点是 0，终点是 2^32 - 1，并且起点与终点连接，故这个环的整数分布范围是 [0, 2^32-1] 。

\n

传统哈希算法是对服务器数量取模，一致性哈希算法是对哈希环的范围取模，固定值，通常为 2^32：

\n
node_number = hash(key) % 2^32
\n

服务器/节点如何映射到哈希环上呢？也是哈希取模。例如，一般我们会根据服务器的 IP 或者主机名进行哈希，然后再取模。

\n
hash（服务器ip）% 2^32
\n

如下图所示：

\n

\"哈希环\"

\n

我们将数据和节点都映射到哈希环上，环上的每个节点都负责一个区间。对于上图来说，每个节点负责的数据情况如下：

\n\n

节点移除/增加

\n

新增节点和移除节点的情况下，哈希环的引入可以避免影响范围太大，减少需要迁移的数据。

\n

还是用上面分享的哈希环示意图为例，假设 Node2 节点被移除的话，那 Node3 就要负责 Node2 的数据，直接迁移 Node2 的数据到 Node3 即可，其他节点不受影响。

\n

\"节点移除\"

\n

同样地，如果我们在 Node1 和 Node2 之间新增一个节点 Node5，那么原本应该由 Node2 负责的一部分数据（即哈希值落在 Node1 和 Node5 之间的数据，如图中的 value1）现在会由 Node5 负责。我们只需要将这部分数据从 Node2 迁移到 Node5 即可，同样只影响了相邻的节点，影响范围非常小。

\n

\"节点增加\"

\n

数据倾斜问题

\n

理想情况下，节点在环上是均匀分布的。然而，现实可能并不是这样的，尤其是节点数量比较少的时候。节点可能被映射到附近的区域，这样的话，就会导致绝大部分数据都由其中一个节点负责。

\n

\"数据倾斜\"

\n

对于上图来说，每个节点负责的数据情况如下：

\n\n

除了数据倾斜问题，还有一个隐患。当新增或者删除节点的时候，数据分配不均衡。例如，Node3 被移除的话，Node3 负责的所有数据都要交给 Node4，随后所有的请求都要达到 Node4 上。假设 Node4 的服务器处理能力比较差的话，那可能直接就被干崩了。理想情况下，应该有更多节点来分担压力。

\n

如何解决这些问题呢？答案是引入虚拟节点。

\n

虚拟节点

\n

虚拟节点就是对真实的物理节点在哈希环上虚拟出几个它的分身节点。数据落到分身节点上实际上就是落到真实的物理节点上，通过将虚拟节点均匀分散在哈希环的各个部分。

\n

如下图所示，Node1、Node2、Node3、Node4 这 4 个节点都对应 3 个虚拟节点（下图只是为了演示，实际情况节点分布不会这么有规律）。

\n

\"虚拟节点\"

\n

对于上图来说，每个节点最终负责的数据情况如下：

\n\n

引入虚拟节点的好处是巨大的：

\n
    \n
  1. 数据均衡： 虚拟节点越多，环上的“服务器点”就越密集，数据分布自然就越均匀，从根本上解决了数据倾斜问题。通常，每个真实节点对应的虚拟节点数在 100 到 200 之间，例如 Nginx 选择为每个权重分配 160 个虚拟节点。这里的权重的是为了区分服务器，例如处理能力更强的服务器权重越高，进而导致对应的虚拟节点越多，被命中的概率越大。
    2. \n
  2. 容错性增强： 这才是虚拟节点最精妙的地方。当一个物理节点宕机，它相当于在环上的多个虚拟节点同时下线。这些虚拟节点原本负责的数据和流量，会自然地、均匀地分散给环上其他多个不同的物理节点去接管，而不会将压力集中于某一个邻居节点。这极大地提升了系统的稳定性和容错能力。
    3. \n
\n

参考

\n\n", "image": "https://oss.javaguide.cn/github/javaguide/distributed-system/protocol/consistent-hashing/hashqumo.png", "date_published": "2025-10-29T09:03:08.000Z", "date_modified": "2026-03-12T08:34:17.000Z", "authors": [], "tags": [ "分布式" ] }, { "title": "Java 25 新特性概览", "url": "https://javaguide.cn/java/new-features/java25.html", "id": "https://javaguide.cn/java/new-features/java25.html", "summary": "概览 JDK 25 的关键新特性与预览改动，关注并发、GC 与语言/平台增强。", "content_html": "

JDK 25 于 2025 年 9 月 16 日 发布，这是一个非常重要的版本，里程碑式。

\n

JDK 25 是 LTS（长期支持版），至此为止，目前有 JDK8、JDK11、JDK17、JDK21 和 JDK 25 这五个长期支持版了。

\n

JDK 25 共有 18 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\n

JDK 25

\n

JEP 506: 作用域值

\n

作用域值（Scoped Values）可以在线程内和线程间共享不可变的数据，优于线程局部变量 ThreadLocal ，尤其是在使用大量虚拟线程时。

\n
final static ScopedValue<...> V = new ScopedValue<>();\n\n// In some method\nScopedValue.where(V, <value>)\n           .run(() -> { ... V.get() ... call methods ... });\n\n// In a method called directly or indirectly from the lambda expression\n... V.get() ...
\n

作用域值通过其“写入时复制”(copy-on-write)的特性，保证了数据在线程间的隔离与安全，同时性能极高，占用内存也极低。这个特性将成为未来 Java 并发编程的标准实践。

\n

JEP 512: 紧凑源文件与实例主方法

\n

该特性第一次预览是由 JEP 445 （JDK 21 ）提出，随后经过了 JDK 22 、JDK 23 和 JDK 24 的改进和完善，最终在 JDK 25 顺利转正。

\n

这个改进极大地简化了编写简单 Java 程序的步骤，允许将类和主方法写在同一个没有顶级 public class的文件中，并允许 main 方法成为一个非静态的实例方法。

\n
class HelloWorld {\n    void main() {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

进一步简化：

\n
void main() {\n    System.out.println(\"Hello, World!\");\n}
\n

这是为了降低 Java 的学习门槛和提升编写小型程序、脚本的效率而迈出的一大步。初学者不再需要理解 public static void main(String[] args) 这一长串复杂的声明。对于快速原型验证和脚本编写，这也使得 Java 成为一个更有吸引力的选择。

\n

JEP 519: 紧凑对象头

\n

该特性第一次预览是由 JEP 450 （JDK 24 ）提出，JDK 25 就顺利转正了。

\n

通过优化对象头的内部结构，在 64 位架构的 HotSpot 虚拟机中，将对象头大小从原本的 96-128 位（12-16 字节）缩减至 64 位（8 字节），最终实现减少堆内存占用、提升部署密度、增强数据局部性的效果。

\n

紧凑对象头并没有成为 JVM 默认的对象头布局方式，需通过显式配置启用：

\n\n

JEP 521: 分代 Shenandoah GC

\n

Shenandoah GC 在 JDK12 中成为正式可生产使用的 GC，默认关闭，通过 -XX:+UseShenandoahGC 启用。

\n

Redhat 主导开发的 Pauseless GC 实现，主要目标是 99.9% 的暂停小于 10ms，暂停与堆大小无关等

\n

传统的 Shenandoah 对整个堆进行并发标记和整理，虽然暂停时间极短，但在处理年轻代对象时效率不如分代 GC。引入分代后，Shenandoah 可以更频繁、更高效地回收年轻代中的大量“朝生夕死”的对象，使其在保持极低暂停时间的同时，拥有了更高的吞吐量和更低的 CPU 开销。

\n

Shenandoah GC 需要通过命令启用：

\n\n

JEP 507: 模式匹配支持基本类型 (第三次预览)

\n

该特性第一次预览是由 JEP 455 （JDK 23 ）提出。

\n

模式匹配可以在 switch 和 instanceof 语句中处理所有的基本数据类型（int, double, boolean 等）

\n
static void test(Object obj) {\n    if (obj instanceof int i) {\n        System.out.println(\"这是一个int类型: \" + i);\n    }\n}
\n

这样就可以像处理对象类型一样，对基本类型进行更安全、更简洁的类型匹配和转换，进一步消除了 Java 中的模板代码。

\n

JEP 505: 结构化并发(第五次预览)

\n

JDK 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope，它支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n

JEP 511: 模块导入声明

\n

该特性第一次预览是由 JEP 476 （JDK 23 ）提出，随后在 JEP 494 （JDK 24）中进行了完善，JDK 25 顺利转正。

\n

模块导入声明允许在 Java 代码中简洁地导入整个模块的所有导出包，而无需逐个声明包的导入。这一特性简化了模块化库的重用，特别是在使用多个模块时，避免了大量的包导入声明，使得开发者可以更方便地访问第三方库和 Java 基本类。

\n

此特性对初学者和原型开发尤为有用，因为它无需开发者将自己的代码模块化，同时保留了对传统导入方式的兼容性，提升了开发效率和代码可读性。

\n
// 导入整个 java.base 模块，开发者可以直接访问 List、Map、Stream 等类，而无需每次手动导入相关包\nimport module java.base;\n\npublic class Example {\n    public static void main(String[] args) {\n        String[] fruits = { \"apple\", \"berry\", \"citrus\" };\n        Map<String, String> fruitMap = Stream.of(fruits)\n            .collect(Collectors.toMap(\n                s -> s.toUpperCase().substring(0, 1),\n                Function.identity()));\n\n        System.out.println(fruitMap);\n    }\n}
\n

JEP 513: 灵活的构造函数体

\n

该特性第一次预览是由 JEP 447 （JDK 22）提出，随后在 JEP 482 （JDK 23）和 JEP 492 （JDK 24）经历了预览，JDK 25 顺利转正。

\n

Java 要求在构造函数中，super(...) 或 this(...) 调用必须作为第一条语句出现。这意味着我们无法在调用父类构造函数之前在子类构造函数中直接初始化字段。

\n

灵活的构造函数体解决了这一问题，它允许在构造函数体内，在调用 super(..) 或 this(..) 之前编写语句，这些语句可以初始化字段，但不能引用正在构造的实例。这样可以防止在父类构造函数中调用子类方法时，子类的字段未被正确初始化，增强了类构造的可靠性。

\n

这一特性解决了之前 Java 语法限制了构造函数代码组织的问题，让开发者能够更自由、更自然地表达构造函数的行为，例如在构造函数中直接进行参数验证、准备和共享，而无需依赖辅助方法或构造函数，提高了代码的可读性和可维护性。

\n
class Person {\n    private final String name;\n    private int age;\n\n    public Person(String name, int age) {\n        if (age < 0) {\n            throw new IllegalArgumentException(\"Age cannot be negative.\");\n        }\n        this.name = name; // 在调用父类构造函数之前初始化字段\n        this.age = age;\n        // ... 其他初始化代码\n    }\n}\n\nclass Employee extends Person {\n    private final int employeeId;\n\n    public Employee(String name, int age, int employeeId) {\n        this.employeeId = employeeId; // 在调用父类构造函数之前初始化字段\n        super(name, age); // 调用父类构造函数\n        // ... 其他初始化代码\n    }\n}
\n

JEP 508: 向量 API(第十次孵化)

\n

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

\n

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

\n

这是对数组元素的简单标量计算：

\n
void scalarComputation(float[] a, float[] b, float[] c) {\n   for (int i = 0; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n   }\n}
\n

这是使用 Vector API 进行的等效向量计算：

\n
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;\n\nvoid vectorComputation(float[] a, float[] b, float[] c) {\n    int i = 0;\n    int upperBound = SPECIES.loopBound(a.length);\n    for (; i < upperBound; i += SPECIES.length()) {\n        // FloatVector va, vb, vc;\n        var va = FloatVector.fromArray(SPECIES, a, i);\n        var vb = FloatVector.fromArray(SPECIES, b, i);\n        var vc = va.mul(va)\n                   .add(vb.mul(vb))\n                   .neg();\n        vc.intoArray(c, i);\n    }\n    for (; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n    }\n}
\n

尽管仍在孵化中，但其第十次迭代足以证明其重要性。它使得 Java 在科学计算、机器学习、大数据处理等性能敏感领域，能够编写出接近甚至媲美 C++等本地语言性能的代码。这是 Java 在高性能计算领域保持竞争力的关键。

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2025-09-18T12:54:50.000Z", "date_modified": "2026-03-21T06:28:26.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "为什么前后端都要做数据校验？", "url": "https://javaguide.cn/system-design/security/data-validation.html", "id": "https://javaguide.cn/system-design/security/data-validation.html", "summary": "前后端数据校验必要性详解，讲解参数校验、权限校验的重要性及防止绕过前端校验的安全防护措施。", "content_html": "
\n

相关面试题：

\n\n
\n

咱们平时做 Web 开发，不管是写前端页面还是后端接口，都离不开跟数据打交道。那怎么保证这些传来传去的数据是靠谱的、安全的呢？这就得靠数据校验了。而且，这活儿，前端得干，后端更得干，还得加上权限校验这道重要的“锁”，缺一不可！

\n

为啥这么说？你想啊，前端校验主要是为了用户体验和挡掉一些明显的“瞎填”数据，但懂点技术的人绕过前端校验简直不要太轻松（比如直接用 Postman 之类的工具发请求）。所以，后端校验才是咱们系统安全和数据准确性的最后一道，也是最硬核的防线。它得确保进到系统里的数据不仅格式对，还得符合业务规矩，最重要的是，执行这个操作的人得有权限！

\n

\n

前端校验

\n

前端校验就像个贴心的门卫，主要目的是在用户填数据的时候，就赶紧告诉他哪儿不对，让他改，省得提交了半天，结果后端说不行，还得重来。这样做的好处显而易见：

\n
    \n
  1. 用户体验好： 输入时就有提示，错了马上知道，改起来方便，用户感觉流畅不闹心。
    2. \n
  2. 减轻后端压力： 把一些明显格式错误、必填项没填的数据在前端就拦下来，减少了发往后端的无效请求，省了服务器资源和网络流量。需要注意的是，后端同样还是要校验，只是加上前端校验可以减少很多无效请求。
    3. \n
\n

那前端一般都得校验点啥呢？

\n\n

总之，前端校验的核心是 引导用户正确输入 和 提升交互体验。

\n

后端校验

\n

前端校验只是第一道防线，虽然提升了用户体验，但毕竟可以被绕过，真正起决定性作用的是后端校验。后端需要对所有前端传来的数据都抱着“可能有问题”的态度，进行全面审查。后端校验不仅要覆盖前端的基本检查（如格式、范围、长度等），还需要更严格、更深入的验证，确保系统的安全性和数据的一致性。以下是后端校验的重点内容：

\n
    \n
  1. 完整性校验: 接口文档中明确要求的字段必须存在，例如 userId 和 orderId。如果缺失任何必需字段，后端应立即返回错误，拒绝处理请求。
    2. \n
  2. 合法性/存在性校验: 验证传入的数据是否真实有效。例如，传过来的 productId 是否存在于数据库中？couponId 是否已经过期或被使用？这通常需要通过查库或调用其他服务来确认。
    3. \n
  3. 一致性校验: 针对涉及多个数据对象的操作，验证它们是否符合业务逻辑。例如，更新订单状态前，需要确保订单的当前状态允许修改，不能直接从“未支付”跳到“已完成”。一致性校验是保证数据流转正确性的关键。
    4. \n
  4. 安全性校验: 后端必须防范各种恶意攻击，包括但不限于 XSS、SQL 注入等。所有外部输入都应进行严格的过滤和验证，例如使用参数化查询防止 SQL 注入，或对返回的 HTML 数据进行转义，避免跨站脚本攻击。
    5. \n
  5. ...基本上，前端能做的校验，后端为了安全都得再来一遍。
    6. \n
\n

在 Java 后端，每次都手写 if-else 来做这些基础校验太累了。好在 Java 社区给我们提供了 Bean Validation 这套标准规范。它允许我们用注解的方式，直接在 JavaBean（比如我们的 DTO 对象）的属性上声明校验规则，非常方便。

\n\n

早期的 Spring Boot (大概 2.3.x 之前): spring-boot-starter-web 里自带了 hibernate-validator，你啥都不用加。

\n

Spring Boot 2.3.x 及之后: 为了更灵活，校验相关的依赖被单独拎出来了。你需要手动添加 spring-boot-starter-validation 依赖：

\n
<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-validation</artifactId>\n</dependency>
\n

Bean Validation 规范及其实现（如 Hibernate Validator）提供了丰富的注解，用于声明式地定义校验规则。以下是一些常用的注解及其说明：

\n\n

当 Controller 方法使用 @RequestBody 注解来接收请求体并将其绑定到一个对象时，可以在该参数前添加 @Valid 注解来触发对该对象的校验。如果验证失败，它将抛出MethodArgumentNotValidException。

\n
@Data\n@AllArgsConstructor\n@NoArgsConstructor\npublic class Person {\n    @NotNull(message = \"classId 不能为空\")\n    private String classId;\n\n    @Size(max = 33)\n    @NotNull(message = \"name 不能为空\")\n    private String name;\n\n    @Pattern(regexp = \"((^Man$|^Woman$|^UGM$))\", message = \"sex 值不在可选范围\")\n    @NotNull(message = \"sex 不能为空\")\n    private String sex;\n\n    @Email(message = \"email 格式不正确\")\n    @NotNull(message = \"email 不能为空\")\n    private String email;\n}\n\n\n@RestController\n@RequestMapping(\"/api\")\npublic class PersonController {\n    @PostMapping(\"/person\")\n    public ResponseEntity<Person> getPerson(@RequestBody @Valid Person person) {\n        return ResponseEntity.ok().body(person);\n    }\n}
\n

对于直接映射到方法参数的简单类型数据（如路径变量 @PathVariable 或请求参数 @RequestParam），校验方式略有不同：

\n
    \n
  1. 在 Controller 类上添加 @Validated 注解：这个注解是 Spring 提供的（非 JSR 标准），它使得 Spring 能够处理方法级别的参数校验注解。这是必需步骤。
    2. \n
  2. 将校验注解直接放在方法参数上：将 @Min, @Max, @Size, @Pattern 等校验注解直接应用于对应的 @PathVariable 或 @RequestParam 参数。
    3. \n
\n

一定一定不要忘记在类上加上 @Validated 注解了，这个参数可以告诉 Spring 去校验方法参数。

\n
@RestController\n@RequestMapping(\"/api\")\n@Validated // 关键步骤 1: 必须在类上添加 @Validated\npublic class PersonController {\n\n    @GetMapping(\"/person/{id}\")\n    public ResponseEntity<Integer> getPersonByID(\n            @PathVariable(\"id\")\n            @Max(value = 5, message = \"ID 不能超过 5\") // 关键步骤 2: 校验注解直接放在参数上\n            Integer id\n    ) {\n        // 如果传入的 id > 5，Spring 会在进入方法体前抛出 ConstraintViolationException 异常。\n        // 全局异常处理器同样需要处理此异常。\n        return ResponseEntity.ok().body(id);\n    }\n\n    @GetMapping(\"/person\")\n    public ResponseEntity<String> findPersonByName(\n            @RequestParam(\"name\")\n            @NotBlank(message = \"姓名不能为空\") // 同样适用于 @RequestParam\n            @Size(max = 10, message = \"姓名长度不能超过 10\")\n            String name\n    ) {\n        return ResponseEntity.ok().body(\"Found person: \" + name);\n    }\n}
\n

Bean Validation 主要解决的是数据格式、语法层面的校验。但光有这个还不够。

\n

权限校验

\n

数据格式都验过了，没问题。但是，这个操作，当前登录的这个用户，他有权做吗？ 这就是权限校验要解决的问题。比如：

\n\n

权限校验发生在数据校验之后，它关心的是“谁 (Who) 能对 什么资源 (What) 执行 什么操作 (Action)”。

\n

为啥权限校验这么重要？

\n\n

目前 Java 后端主流的方式是使用成熟的安全框架来实现权限校验，而不是自己手写（容易出错且难以维护）。

\n
    \n
  1. Spring Security (业界标准，推荐): 基于过滤器链（Filter Chain）拦截请求，进行认证（Authentication - 你是谁？）和授权（Authorization - 你能干啥？）。Spring Security 功能强大、社区活跃、与 Spring 生态无缝集成。不过，配置相对复杂，学习曲线较陡峭。
    2. \n
  2. Apache Shiro: 另一个流行的安全框架，相对 Spring Security 更轻量级，API 更直观易懂。同样提供认证、授权、会话管理、加密等功能。对于不熟悉 Spring 或觉得 Spring Security 太重的项目，是一个不错的选择。
    3. \n
  3. Sa-Token: 国产的轻量级 Java 权限认证框架。支持认证授权、单点登录、踢人下线、自动续签等功能。相比于 Spring Security 和 Shiro 来说，Sa-Token 内置的开箱即用的功能更多，使用也更简单。
    4. \n
  4. 手动检查 (不推荐用于复杂场景): 在 Service 层或 Controller 层代码里，手动获取当前用户信息（例如从 SecurityContextHolder 或 Session 中），然后 if-else 判断用户角色或权限。权限逻辑与业务逻辑耦合、代码重复、难以维护、容易遗漏。只适用于非常简单的权限场景。
    5. \n
\n

权限模型简介:

\n\n

一般情况下，绝大部分系统都使用的是 RBAC 权限模型或者其简化版本。用一个图来描述如下：

\n

\"RBAC

\n

关于权限系统设计的详细介绍，可以看这篇文章：权限系统设计详解。

\n

总结

\n

总而言之，要想构建一个安全、稳定、用户体验好的 Web 应用，前后端数据校验和后端权限校验这三道关卡，都得设好，而且各有侧重：

\n\n

参考

\n\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/security/user-input-validation.png", "date_published": "2025-05-04T10:24:21.000Z", "date_modified": "2026-03-23T08:33:10.000Z", "authors": [], "tags": [ "系统设计" ] }, { "title": "已经淘汰的 Java 技术，不要再学了！", "url": "https://javaguide.cn/about-the-author/deprecated-java-technologies.html", "id": "https://javaguide.cn/about-the-author/deprecated-java-technologies.html", "summary": "已淘汰的Java技术盘点，JSP、Struts、EJB、Java Applets、SOAP等过时技术不建议学习，附现代替代方案推荐。", "content_html": "

前几天，我在知乎上随手回答了一个问题：“Java 学到 JSP 就学不下去了，怎么办？”。

\n

出于不想让别人走弯路的心态，我回答说：已经淘汰的技术就不要学了，并顺带列举了一些在 Java 开发领域中已经被淘汰的技术。

\n

已经淘汰的 Java 技术

\n

我的回答原内容如下，列举了一些在 Java 开发领域中已经被淘汰的技术：

\n

JSP

\n\n

Struts（尤其是 1.x）

\n\n

EJB (Enterprise JavaBeans)

\n\n

Java Applets

\n\n

SOAP / JAX-WS

\n\n

RMI（Remote Method Invocation）

\n\n

Swing / JavaFX

\n\n

Ant

\n\n

杠精言论

\n

没想到，评论区果然出现了一类很常见的杠精：

\n
\n

“学的不是技术，是思想。那爬也是人类不需要的技术吗？为啥你一生下来得先学会爬？如果基础思想都不会就去学各种框架，到最后只能是只会 CV 的废物！”

\n
\n\n

这句话表面上看似有道理，但实际上却暴露了一个人的无知和偏执。

\n

知识越贫乏的人，相信的东西就越绝对，因为他们从未认真了解过与自己观点相对立的角度，也缺乏对技术发展的全局认识。

\n

举个例子，我刚开始学习 Java 后端开发的时候，完全没什么经验，就随便买了一本书开始看。当时看的是 《Java Web 整合开发王者归来》 这本书（梦开始的地方）。

\n

在我上大学那会儿，这本书的很多内容其实已经过时了，比如它花了大量篇幅介绍 JSP、Struts、Hibernate、EJB 和 SVN 等技术。不过，直到现在，我依然非常感谢这本书，带我走进了 Java 后端开发的大门。

\n

\n

这本书一共 1010 页，我当时可以说是废寝忘食地学，花了很长时间才把整本书完全“啃”下来。

\n

回头来看，我如果能有意识地避免学习这些已经淘汰的技术，真的可以节省大量时间去学习更加主流和实用的内容。

\n

那么，这些被淘汰的技术有用吗？说句实话，屁用没有，纯粹浪费时间。

\n

既然都要花时间学习，为什么不去学那些更主流、更有实际价值的技术呢？

\n

现在本身就很卷，不管是 Java 方向还是其他技术方向，要学习的技术都很多。

\n

想要理解所谓的“底层思想”，与其浪费时间在 JSP 这种已经不具备实际应用价值的技术上，不如深入学习一下 Servlet，研究 Spring 的 AOP 和 IoC 原理，从源码角度理解 Spring MVC 的工作机制。

\n

这些内容，不仅能帮助你掌握核心的思想，还能在实际开发中真正派上用场，这难道不比花大量时间在 JSP 上更有意义吗？

\n

还有公司在用的技术就要学吗？

\n

我把这篇文章的相关言论发表在我的公众号之后，又收到另外一类在我看来非常傻叉的言论：

\n\n

这种观点完全是钻牛角尖！如果按这种逻辑，那你还需要去学 Struts2、SVN、JavaFX 等过时技术，因为它们也还有公司在用。我有一位大学同学毕业后去了武汉的一家国企，写了一年 JavaFX 就受不了跑了。他在之前从来没有接触过 JavaFX，招聘时也没被问过相关问题。

\n

一定不要假设自己要面对的是过时技术栈的项目。你要找工作肯定要用主流技术栈去找，还要尽量找能让自己技术有成长，干着也舒服点。真要是找不到合适的工作，去维护老项目，那都是后话，现学现卖就行了。

\n

对于初学者来说别人劝了还非要学习淘汰的技术，多少脑子有点不够用，基本可以告别这一行了！

\n", "image": "https://oss.javaguide.cn/github/javaguide/about-the-author/prattle/java-web-integration-development-king-returns.png", "date_published": "2025-03-25T05:34:17.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "走近作者" ] }, { "title": "Java 24 新特性概览", "url": "https://javaguide.cn/java/new-features/java24.html", "id": "https://javaguide.cn/java/new-features/java24.html", "summary": "总结 JDK 24 的新特性与改动，便于跟踪 Java 演进。", "content_html": "

JDK 24 于 2025 年 3 月发布，这是一个非 LTS（长期支持版）版本。下一个长期支持版是 JDK 25，预计于 2025 年 9 月发布。

\n

JDK 24 共有 24 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\n

JEP 478: Key Derivation Function API (密钥派生函数 API)

\n

密钥派生函数 API 是一种用于从初始密钥和其他数据派生额外密钥的加密算法。它的核心作用是为不同的加密目的（如加密、认证等）生成多个不同的密钥，避免密钥重复使用带来的安全隐患。这在新代加密中是一个重要的里程碑，为后续新兴的量子计算环境打下了基础。

\n

通过该 API，开发者可以使用最新的密钥派生算法（如 HKDF 和未来的 Argon2）：

\n
// 创建一个 KDF 对象，使用 HKDF-SHA256 算法\nKDF hkdf = KDF.getInstance(\"HKDF-SHA256\");\n\n// 创建 Extract 和 Expand 参数规范\nAlgorithmParameterSpec params =\n    HKDFParameterSpec.ofExtract()\n                     .addIKM(initialKeyMaterial) // 设置初始密钥材料\n                     .addSalt(salt)             // 设置盐值\n                     .thenExpand(info, 32);     // 设置扩展信息和目标长度\n\n// 派生一个 32 字节的 AES 密钥\nSecretKey key = hkdf.deriveKey(\"AES\", params);\n\n// 可以使用相同的 KDF 对象进行其他密钥派生操作
\n

JEP 483: Early Class-File Loading & Linking (提前类加载和链接)

\n

在传统 JVM 中，应用在每次启动时需要动态加载和链接类。这种机制对启动时间敏感的应用（如微服务或无服务器函数）带来了显著的性能瓶颈。该特性通过缓存已加载和链接的类，显著减少了重复工作的开销，显著减少 Java 应用程序的启动时间。测试表明，对大型应用（如基于 Spring 的服务器应用），启动时间可减少 40% 以上。

\n

这个优化是零侵入性的，对应用程序、库或框架的代码无需任何更改，启动也方式保持一致，仅需添加相关 JVM 参数（如 -XX:+ClassDataSharing）。

\n

JEP 484: Class File API (类文件 API)

\n

类文件 API 在 JDK 22 进行了第一次预览（JEP 457），在 JDK 23 进行了第二次预览并进一步完善（JEP 466）。最终，该特性在 JDK 24 中顺利转正。

\n

类文件 API 的目标是提供一套标准化的 API，用于解析、生成和转换 Java 类文件，取代过去对第三方库（如 ASM）在类文件处理上的依赖。

\n
// 创建一个 ClassFile 对象，这是操作类文件的入口。\nClassFile cf = ClassFile.of();\n// 解析字节数组为 ClassModel\nClassModel classModel = cf.parse(bytes);\n\n// 构建新的类文件，移除以 \"debug\" 开头的所有方法\nbyte[] newBytes = cf.build(classModel.thisClass().asSymbol(),\n        classBuilder -> {\n            // 遍历所有类元素\n            for (ClassElement ce : classModel) {\n                // 判断是否为方法 且 方法名以 \"debug\" 开头\n                if (!(ce instanceof MethodModel mm\n                        && mm.methodName().stringValue().startsWith(\"debug\"))) {\n                    // 添加到新的类文件中\n                    classBuilder.with(ce);\n                }\n            }\n        });
\n

JEP 485: Stream Gatherers (流收集器)

\n

流收集器 Stream::gather(Gatherer) 是一个强大的新特性，它允许开发者定义自定义的中间操作，从而实现更复杂、更灵活的数据转换。Gatherer 接口是该特性的核心，它定义了如何从流中收集元素，维护中间状态，并在处理过程中生成结果。

\n

与现有的 filter、map 或 distinct 等内置操作不同，Stream::gather 使得开发者能够实现那些难以用标准 Stream 操作完成的任务。例如，可以使用 Stream::gather 实现滑动窗口、自定义规则的去重、或者更复杂的状态转换和聚合。 这种灵活性极大地扩展了 Stream API 的应用范围，使开发者能够应对更复杂的数据处理场景。

\n

基于 Stream::gather(Gatherer) 实现字符串长度的去重逻辑：

\n
var result = Stream.of(\"foo\", \"bar\", \"baz\", \"quux\")\n                   .gather(Gatherer.ofSequential(\n                       HashSet::new, // 初始化状态为 HashSet,用于保存已经遇到过的字符串长度\n                       (set, str, downstream) -> {\n                           if (set.add(str.length())) {\n                               return downstream.push(str);\n                           }\n                           return true; // 继续处理流\n                       }\n                   ))\n                   .toList();// 转换为列表\n\n// 输出结果 ==> [foo, quux]
\n

JEP 486: Disable the Security Manager (永久禁用安全管理器)

\n

JDK 24 不再允许启用 Security Manager，即使通过 java -Djava.security.manager命令也无法启用，这是逐步移除该功能的关键一步。虽然 Security Manager 曾经是 Java 中限制代码权限（如访问文件系统或网络、读取或写入敏感文件、执行系统命令）的重要工具，但由于复杂性高、使用率低且维护成本大，Java 社区决定最终移除它。

\n

JEP 487: Scoped Values (作用域值, 第四次预览)

\n

作用域值（Scoped Values）可以在线程内和线程间共享不可变的数据，优于线程局部变量，尤其是在使用大量虚拟线程时。

\n
final static ScopedValue<...> V = new ScopedValue<>();\n\n// In some method\nScopedValue.where(V, <value>)\n           .run(() -> { ... V.get() ... call methods ... });\n\n// In a method called directly or indirectly from the lambda expression\n... V.get() ...
\n

作用域值允许在大型程序中的组件之间安全有效地共享数据，而无需求助于方法参数。

\n

JEP 491: Virtual Threads Synchronization Without Pinning (虚拟线程的同步而不固定平台线程)

\n

优化了虚拟线程与 synchronized 的工作机制。 虚拟线程在 synchronized 方法和代码块中阻塞时，通常能够释放其占用的操作系统线程（平台线程），避免了对平台线程的长时间占用，从而提升应用程序的并发能力。 这种机制避免了“固定 (Pinning)”——即虚拟线程长时间占用平台线程，阻止其服务于其他虚拟线程的情况。

\n

现有的使用 synchronized 的 Java 代码无需修改即可受益于虚拟线程的扩展能力。 例如，一个 I/O 密集型的应用程序，如果使用传统的平台线程，可能会因为线程阻塞而导致并发能力下降。 而使用虚拟线程，即使在 synchronized 块中发生阻塞，也不会固定平台线程，从而允许平台线程继续服务于其他虚拟线程，提高整体的并发性能。

\n

JEP 493: Linking Run-Time Images Without JMOD Files (在没有 JMOD 文件的情况下链接运行时镜像)

\n

默认情况下，JDK 同时包含运行时镜像（运行时所需的模块）和 JMOD 文件。这个特性使得 jlink 工具无需使用 JDK 的 JMOD 文件就可以创建自定义运行时镜像，减少了 JDK 的安装体积（约 25%）。

\n

说明：

\n\n

JEP 495: Simplified Source Files and Instance Main Methods (简化的源文件和实例主方法, 第四次预览)

\n

这个特性主要简化了 main 方法的声明。对于 Java 初学者来说，这个 main 方法的声明引入了太多的 Java 语法概念，不利于初学者快速上手。

\n

没有使用该特性之前定义一个 main 方法：

\n
public class HelloWorld {\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

使用该新特性之后定义一个 main 方法：

\n
class HelloWorld {\n    void main() {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

进一步简化（未命名的类允许我们省略类名）

\n
void main() {\n   System.out.println(\"Hello, World!\");\n}
\n

JEP 497: Quantum-Resistant Digital Signature Algorithm (ML-DSA) (量子抗性数字签名算法)

\n

JDK 24 引入了支持实施抗量子的基于模块晶格的数字签名算法 （Module-Lattice-Based Digital Signature Algorithm, ML-DSA），为抵御未来量子计算机可能带来的威胁做准备。

\n

ML-DSA 是美国国家标准与技术研究院（NIST）在 FIPS 204 中标准化的量子抗性算法，用于数字签名和身份验证。

\n

JEP 498: Warnings When Using sun.misc.Unsafe Memory Access Methods (使用 sun.misc.Unsafe 内存访问方法时发出警告)

\n

JDK 23(JEP 471) 提议弃用 sun.misc.Unsafe 中的内存访问方法，这些方法将来的版本中会被移除。在 JDK 24 中，当首次调用 sun.misc.Unsafe 的任何内存访问方法时，运行时会发出警告。

\n

这些不安全的方法已有安全高效的替代方案：

\n\n

这两个类是 Foreign Function & Memory API（外部函数和内存 API） 的核心组件，分别用于管理和操作堆外内存。Foreign Function & Memory API 在 JDK 22 中正式转正，成为标准特性。

\n
import jdk.incubator.foreign.*;\nimport java.lang.invoke.VarHandle;\n\n// 管理堆外整数数组的类\nclass OffHeapIntBuffer {\n\n    // 用于访问整数元素的VarHandle\n    private static final VarHandle ELEM_VH = ValueLayout.JAVA_INT.arrayElementVarHandle();\n\n    // 内存管理器\n    private final Arena arena;\n\n    // 堆外内存段\n    private final MemorySegment buffer;\n\n    // 构造函数，分配指定数量的整数空间\n    public OffHeapIntBuffer(long size) {\n        this.arena  = Arena.ofShared();\n        this.buffer = arena.allocate(ValueLayout.JAVA_INT, size);\n    }\n\n    // 释放内存\n    public void deallocate() {\n        arena.close();\n    }\n\n    // 以volatile方式设置指定索引的值\n    public void setVolatile(long index, int value) {\n        ELEM_VH.setVolatile(buffer, 0L, index, value);\n    }\n\n    // 初始化指定范围的元素为0\n    public void initialize(long start, long n) {\n        buffer.asSlice(ValueLayout.JAVA_INT.byteSize() * start,\n                       ValueLayout.JAVA_INT.byteSize() * n)\n              .fill((byte) 0);\n    }\n\n    // 将指定范围的元素复制到新数组\n    public int[] copyToNewArray(long start, int n) {\n        return buffer.asSlice(ValueLayout.JAVA_INT.byteSize() * start,\n                              ValueLayout.JAVA_INT.byteSize() * n)\n                     .toArray(ValueLayout.JAVA_INT);\n    }\n}
\n

JEP 499: Structured Concurrency (结构化并发, 第四次预览)

\n

JDK 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope，它支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2025-03-20T07:56:49.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Async 注解原理分析", "url": "https://javaguide.cn/system-design/framework/spring/async.html", "id": "https://javaguide.cn/system-design/framework/spring/async.html", "summary": "Spring @Async异步注解原理详解，涵盖异步任务配置、线程池设置、@EnableAsync机制及常见使用问题。", "content_html": "

@Async 注解由 Spring 框架提供，被该注解标注的类或方法会在 异步线程 中执行。这意味着当方法被调用时，调用者将不会等待该方法执行完成，而是可以继续执行后续的代码。

\n

@Async 注解的使用非常简单，需要两个步骤：

\n
    \n
  1. 在启动类上添加注解 @EnableAsync ，开启异步任务。
    2. \n
  2. 在需要异步执行的方法或类上添加注解 @Async 。
    3. \n
\n
@SpringBootApplication\n// 开启异步任务\n@EnableAsync\npublic class YourApplication {\n\n    public static void main(String[] args) {\n        SpringApplication.run(YourApplication.class, args);\n    }\n}\n\n// 异步服务类\n@Service\npublic class MyService {\n\n    // 推荐使用自定义线程池，这里只是演示基本用法\n    @Async\n    public CompletableFuture<String> doSomethingAsync() {\n\n        // 这里会有一些业务耗时操作\n        // ...\n        // 使用 CompletableFuture 可以更方便地处理异步任务的结果，避免阻塞主线程\n        return CompletableFuture.completedFuture(\"Async Task Completed\");\n    }\n\n}
\n

接下来，我们一起来看看 @Async 的底层原理。

\n

@Async 原理分析

\n

@Async 可以异步执行任务，本质上是使用 动态代理 来实现的。通过 Spring 中的后置处理器 BeanPostProcessor 为使用 @Async 注解的类创建动态代理，之后 @Async 注解方法的调用会被动态代理拦截，在拦截器中将方法的执行封装为异步任务提交给线程池处理。

\n

接下来，我们来详细分析一下。

\n

开启异步

\n

使用 @Async 之前，需要在启动类上添加 @EnableAsync 来开启异步，@EnableAsync 注解如下：

\n
// 省略其他注解 ...\n@Import(AsyncConfigurationSelector.class)\npublic @interface EnableAsync { /* ... */ }
\n

在 @EnableAsync 注解上通过 @Import 注解引入了 AsyncConfigurationSelector ，因此 Spring 会去加载通过 @Import 注解引入的类。

\n

AsyncConfigurationSelector 类实现了 ImportSelector 接口，因此在该类中会重写 selectImports() 方法来自定义加载 Bean 的逻辑，如下：

\n
public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {\n\t@Override\n\t@Nullable\n\tpublic String[] selectImports(AdviceMode adviceMode) {\n\t\tswitch (adviceMode) {\n   // 基于 JDK 代理织入的通知\n\t\t\tcase PROXY:\n\t\t\t\treturn new String[] {ProxyAsyncConfiguration.class.getName()};\n   // 基于 AspectJ 织入的通知\n\t\t\tcase ASPECTJ:\n\t\t\t\treturn new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};\n\t\t\tdefault:\n\t\t\t\treturn null;\n\t\t}\n\t}\n}
\n

在 selectImports() 方法中，会根据通知的不同类型来选择加载不同的类，其中 adviceMode 默认值为 PROXY 。

\n

这里以基于 JDK 代理的通知为例，此时会加载 ProxyAsyncConfiguration 类，如下：

\n
@Configuration\n@Role(BeanDefinition.ROLE_INFRASTRUCTURE)\npublic class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {\n\t@Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)\n\t@Role(BeanDefinition.ROLE_INFRASTRUCTURE)\n\tpublic AsyncAnnotationBeanPostProcessor asyncAdvisor() {\n\t\t // ...\n  // 加载后置处理器\n\t\tAsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();\n\n  // ...\n\t\treturn bpp;\n\t}\n}
\n

后置处理器

\n

在 ProxyAsyncConfiguration 类中，会通过 @Bean 注解加载一个后置处理器 AsyncAnnotationBeanPostProcessor ，这个后置处理器是使 @Async 注解起作用的关键。

\n

如果某一个类或者方法上使用了 @Async 注解，AsyncAnnotationBeanPostProcessor 处理器就会为该类创建一个动态代理。

\n

该类的方法在执行时，会被代理对象的拦截器所拦截，其中被 @Async 注解标记的方法会异步执行。

\n

AsyncAnnotationBeanPostProcessor 代码如下：

\n
public class AsyncAnnotationBeanPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor {\n\t@Override\n\tpublic void setBeanFactory(BeanFactory beanFactory) {\n\t\tsuper.setBeanFactory(beanFactory);\n  // 创建 AsyncAnnotationAdvisor，它是一个 Advisor\n  // 用于拦截带有 @Async 注解的方法并将这些方法异步执行。\n\t\tAsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);\n  // 如果设置了自定义的 asyncAnnotationType，则将其设置到 advisor 中。\n  // asyncAnnotationType 用于指定自定义的异步注解，例如 @MyAsync。\n\t\tif (this.asyncAnnotationType != null) {\n\t\t\tadvisor.setAsyncAnnotationType(this.asyncAnnotationType);\n\t\t}\n\t\tadvisor.setBeanFactory(beanFactory);\n\t\tthis.advisor = advisor;\n\t}\n}
\n

AsyncAnnotationBeanPostProcessor 的父类实现了 BeanFactoryAware 接口，因此在该类中重写了 setBeanFactory() 方法作为扩展点，来加载 AsyncAnnotationAdvisor 。

\n

创建 Advisor

\n

Advisor 是 Spring AOP 对 Advice 和 Pointcut 的抽象。Advice 为执行的通知逻辑，Pointcut 为通知执行的切入点。

\n

在后置处理器 AsyncAnnotationBeanPostProcessor 中会去创建 AsyncAnnotationAdvisor ， 在它的构造方法中，会构建对应的 Advice 和 Pointcut ，如下：

\n
public class AsyncAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {\n\n    private Advice advice; // 异步执行的 Advice\n    private Pointcut pointcut; // 匹配 @Async 注解方法的切点\n\n    // 构造函数\n    public AsyncAnnotationAdvisor(/* 参数省略 */) {\n        // 1. 创建 Advice，负责异步执行逻辑\n        this.advice = buildAdvice(executor, exceptionHandler);\n        // 2. 创建 Pointcut，选择要被增强的目标方法\n        this.pointcut = buildPointcut(asyncAnnotationTypes);\n    }\n\n    // 创建 Advice\n    protected Advice buildAdvice(/* 参数省略 */) {\n        // 创建处理异步执行的拦截器\n        AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null);\n        // 使用执行器和异常处理器配置拦截器\n        interceptor.configure(executor, exceptionHandler);\n        return interceptor;\n    }\n\n    // 创建 Pointcut\n    protected Pointcut buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes) {\n        ComposablePointcut result = null;\n        for (Class<? extends Annotation> asyncAnnotationType : asyncAnnotationTypes) {\n            // 1. 类级别切点：如果类上有注解则匹配\n            Pointcut cpc = new AnnotationMatchingPointcut(asyncAnnotationType, true);\n            // 2. 方法级别切点：如果方法上有注解则匹配\n            Pointcut mpc = new AnnotationMatchingPointcut(null, asyncAnnotationType, true);\n\n            if (result == null) {\n                result = new ComposablePointcut(cpc);\n            } else {\n                // 使用 union 合并之前的切点\n                result.union(cpc);\n            }\n            // 将方法级别切点添加到组合切点\n            result = result.union(mpc);\n        }\n        // 返回组合切点，如果没有提供注解类型则返回 Pointcut.TRUE\n        return (result != null ? result : Pointcut.TRUE);\n    }\n}
\n

AsyncAnnotationAdvisor 的核心在于构建 Advice 和 Pointcut ：

\n\n

后置处理逻辑

\n

AsyncAnnotationBeanPostProcessor 后置处理器中实现的 postProcessAfterInitialization() 方法在其父类 AbstractAdvisingBeanPostProcessor 中，在 Bean 初始化之后，会进入到 postProcessAfterInitialization() 方法进行后置处理。

\n

在后置处理方法中，会判断 Bean 是否符合后置处理器中 Advisor 通知的条件，如果符合，则创建代理对象。如下：

\n
// AbstractAdvisingBeanPostProcessor\npublic Object postProcessAfterInitialization(Object bean, String beanName) {\n\tif (this.advisor == null || bean instanceof AopInfrastructureBean) {\n\t\treturn bean;\n\t}\n\tif (bean instanceof Advised) {\n\t\tAdvised advised = (Advised) bean;\n\t\tif (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {\n\t\t\tif (this.beforeExistingAdvisors) {\n\t\t\t\tadvised.addAdvisor(0, this.advisor);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tadvised.addAdvisor(this.advisor);\n\t\t\t}\n\t\t\treturn bean;\n\t\t}\n\t}\n // 判断给定的 Bean 是否符合后置处理器中 Advisor 通知的条件，符合的话，就创建代理对象。\n\tif (isEligible(bean, beanName)) {\n\t\tProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);\n\t\tif (!proxyFactory.isProxyTargetClass()) {\n\t\t\tevaluateProxyInterfaces(bean.getClass(), proxyFactory);\n\t\t}\n  // 添加 Advisor。\n\t\tproxyFactory.addAdvisor(this.advisor);\n\t\tcustomizeProxyFactory(proxyFactory);\n  // 返回代理对象。\n\t\treturn proxyFactory.getProxy(getProxyClassLoader());\n\t}\n\treturn bean;\n}
\n

@Async 注解方法的拦截

\n

@Async 注解方法的执行会在 AnnotationAsyncExecutionInterceptor 中被拦截，在 invoke() 方法中执行拦截器的逻辑。此时会将 @Async 注解标注的方法封装为异步任务，交给执行器来执行。

\n

invoke() 方法在 AnnotationAsyncExecutionInterceptor 的父类 AsyncExecutionInterceptor 中定义，如下：

\n
public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor, Ordered {\n\t@Override\n\t@Nullable\n\tpublic Object invoke(final MethodInvocation invocation) throws Throwable {\n\t\tClass<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);\n\t\tMethod specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);\n\t\tfinal Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);\n\n  // 1、确定异步任务执行器\n\t\tAsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);\n\n  // 2、将要执行的方法封装为 Callable 异步任务\n\t\tCallable<Object> task = () -> {\n\t\t\ttry {\n    // 2.1、执行方法\n\t\t\t\tObject result = invocation.proceed();\n    // 2.2、如果方法返回值是 Future 类型，阻塞等待结果\n\t\t\t\tif (result instanceof Future) {\n\t\t\t\t\treturn ((Future<?>) result).get();\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (ExecutionException ex) {\n\t\t\t\thandleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());\n\t\t\t}\n\t\t\tcatch (Throwable ex) {\n\t\t\t\thandleError(ex, userDeclaredMethod, invocation.getArguments());\n\t\t\t}\n\t\t\treturn null;\n\t\t};\n\t\t// 3、提交任务\n\t\treturn doSubmit(task, executor, invocation.getMethod().getReturnType());\n\t}\n}
\n

在 invoke() 方法中，主要有 3 个步骤：

\n
    \n
  1. 确定执行异步任务的执行器。
    2. \n
  2. 将 @Async 注解标注的方法封装为 Callable 异步任务。
    3. \n
  3. 将任务提交给执行器执行。
    4. \n
\n

1、获取异步任务执行器

\n

在 determineAsyncExecutor() 方法中，会获取异步任务的执行器（即执行异步任务的 线程池 ）。代码如下：

\n
// 确定异步任务的执行器\nprotected AsyncTaskExecutor determineAsyncExecutor(Method method) {\n // 1、先从缓存中获取。\n\tAsyncTaskExecutor executor = this.executors.get(method);\n\tif (executor == null) {\n\t\tExecutor targetExecutor;\n  // 2、获取执行器的限定符。\n\t\tString qualifier = getExecutorQualifier(method);\n\t\tif (StringUtils.hasLength(qualifier)) {\n   // 3、根据限定符获取对应的执行器。\n\t\t\ttargetExecutor = findQualifiedExecutor(this.beanFactory, qualifier);\n\t\t}\n\t\telse {\n   // 4、如果没有限定符，则使用默认的执行器。即 Spring 提供的默认线程池：SimpleAsyncTaskExecutor。\n\t\t\ttargetExecutor = this.defaultExecutor.get();\n\t\t}\n\t\tif (targetExecutor == null) {\n\t\t\treturn null;\n\t\t}\n  // 5、将执行器包装为 TaskExecutorAdapter 适配器。\n  // TaskExecutorAdapter 是 Spring 对于 JDK 线程池做的一层抽象，还是继承自 JDK 的线程池 Executor。这里可以不用管太多，只要知道它是线程池就可以了。\n\t\texecutor = (targetExecutor instanceof AsyncListenableTaskExecutor ?\n\t\t\t\t(AsyncListenableTaskExecutor) targetExecutor : new TaskExecutorAdapter(targetExecutor));\n\t\tthis.executors.put(method, executor);\n\t}\n\treturn executor;\n}
\n

在 determineAsyncExecutor() 方法中确定了异步任务的执行器（线程池），主要是通过 @Async 注解的 value 值来获取执行器的限定符，根据限定符再去 BeanFactory 中查找对应的执行器就可以了。

\n

如果在 @Async 注解中没有指定线程池，则会通过 this.defaultExecutor.get() 来获取默认的线程池，其中 defaultExecutor 在下边方法中进行赋值：

\n
// AsyncExecutionInterceptor\nprotected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {\n // 1、尝试从 beanFactory 中获取线程池。\n\tExecutor defaultExecutor = super.getDefaultExecutor(beanFactory);\n // 2、如果 beanFactory 中没有，则创建 SimpleAsyncTaskExecutor 线程池。\n\treturn (defaultExecutor != null ? defaultExecutor : new SimpleAsyncTaskExecutor());\n}
\n

其中 super.getDefaultExecutor() 会在 beanFactory 中尝试获取 Executor 类型的线程池。代码如下：

\n
protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {\n\tif (beanFactory != null) {\n\t\ttry {\n   // 1、从 beanFactory 中获取 TaskExecutor 类型的线程池。\n\t\t\treturn beanFactory.getBean(TaskExecutor.class);\n\t\t}\n\t\tcatch (NoUniqueBeanDefinitionException ex) {\n\t\t\ttry {\n\t\t\t\t// 2、如果有多个，则尝试从 beanFactory 中获取执行名称的 Executor 线程池。\n\t\t\t\treturn beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);\n\t\t\t}\n\t\t\tcatch (NoSuchBeanDefinitionException ex2) {\n\t\t\t\tif (logger.isInfoEnabled()) {\n\t\t\t\t\t// ...\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tcatch (NoSuchBeanDefinitionException ex) {\n\t\t\ttry {\n    // 3、如果没有，则尝试从 beanFactory 中获取执行名称的 Executor 线程池。\n\t\t\t\treturn beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);\n\t\t\t}\n\t\t\tcatch (NoSuchBeanDefinitionException ex2) {\n\t\t\t\t// ...\n\t\t\t}\n\t\t}\n\t}\n\treturn null;\n}
\n

在 getDefaultExecutor() 中，如果从 beanFactory 获取线程池失败的话，则会创建 SimpleAsyncTaskExecutor 线程池。

\n

该线程池的在每次执行异步任务时，都会创建一个新的线程去执行任务，并不会对线程进行复用，从而导致异步任务执行的开销很大。一旦在 @Async 注解标注的方法某一瞬间并发量剧增，应用就会大量创建线程，从而影响服务质量甚至出现服务不可用。

\n

同一时刻如果向 SimpleAsyncTaskExecutor 线程池提交 10000 个任务，那么该线程池就会创建 10000 个线程，其的 execute() 方法如下：

\n
// SimpleAsyncTaskExecutor：execute() 内部会调用 doExecute()\nprotected void doExecute(Runnable task) {\n    // 创建新线程\n    Thread thread = (this.threadFactory != null ? this.threadFactory.newThread(task) : createThread(task));\n    thread.start();\n}
\n

建议：在使用 @Async 时需要自己指定线程池，避免 Spring 默认线程池带来的风险。

\n

在 @Async 注解中的 value 指定了线程池的限定符，根据限定符可以获取 自定义的线程池 。获取限定符的代码如下：

\n
// AnnotationAsyncExecutionInterceptor\nprotected String getExecutorQualifier(Method method) {\n\t// 1.从方法上获取 Async 注解。\n\tAsync async = AnnotatedElementUtils.findMergedAnnotation(method, Async.class);\n // 2. 如果方法上没有找到 @Async 注解，则尝试从方法所在的类上获取 @Async 注解。\n\tif (async == null) {\n\t\tasync = AnnotatedElementUtils.findMergedAnnotation(method.getDeclaringClass(), Async.class);\n\t}\n // 3. 如果找到了 @Async 注解，则获取注解的 value 值并返回，作为线程池的限定符。\n //    如果 \"value\" 属性值为空字符串，则使用默认的线程池。\n //    如果没有找到 @Async 注解，则返回 null，同样使用默认的线程池。\n\treturn (async != null ? async.value() : null);\n}
\n

2、将方法封装为异步任务

\n

在 invoke() 方法获取执行器之后，会将方法封装为异步任务，代码如下：

\n
// 将要执行的方法封装为 Callable 异步任务\nCallable<Object> task = () -> {\n    try {\n        // 2.1、执行被拦截的方法 (proceed() 方法是 AOP 中的核心方法，用于执行目标方法)\n        Object result = invocation.proceed();\n\n        // 2.2、如果被拦截方法的返回值是 Future 类型，则需要阻塞等待结果，\n        //     并将 Future 的结果作为异步任务的结果返回。 这是为了处理异步方法嵌套调用的情况。\n        //     例如，一个异步方法内部调用了另一个异步方法，则需要等待内部异步方法执行完成，\n        //     才能返回最终的结果。\n        if (result instanceof Future) {\n            return ((Future<?>) result).get(); // 阻塞等待 Future 的结果\n        }\n    }\n    catch (ExecutionException ex) {\n        // 2.3、处理 ExecutionException 异常。 ExecutionException 是 Future.get() 方法抛出的异常，\n        handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments()); // 处理原始异常\n    }\n    catch (Throwable ex) {\n        // 2.4、处理其他类型的异常。 将异常、被拦截的方法和方法参数作为参数调用 handleError() 方法进行处理。\n        handleError(ex, userDeclaredMethod, invocation.getArguments());\n    }\n    // 2.5、如果方法返回值不是 Future 类型，或者发生异常，则返回 null。\n    return null;\n};
\n

相比于 Runnable ，Callable 可以返回结果，并且抛出异常。

\n

将 invocation.proceed() 的执行（原方法的执行）封装为 Callable 异步任务。这里仅仅当 result （方法返回值）类型为 Future 才返回，如果是其他类型则直接返回 null 。

\n

因此使用 @Async 注解标注的方法如果使用 Future 类型之外的返回值，则无法获取方法的执行结果。

\n

3、提交异步任务

\n

在 AsyncExecutionInterceptor # invoke() 中将要执行的方法封装为 Callable 任务之后，就会将任务交给执行器来执行。提交相关的代码如下：

\n
protected Object doSubmit(Callable<Object> task, AsyncTaskExecutor executor, Class<?> returnType) {\n    // 根据方法的返回值类型，选择不同的异步执行方式并返回结果。\n    // 1. 如果方法返回值是 CompletableFuture 类型\n    if (CompletableFuture.class.isAssignableFrom(returnType)) {\n        // 使用 CompletableFuture.supplyAsync() 方法异步执行任务。\n        return CompletableFuture.supplyAsync(() -> {\n            try {\n                return task.call();\n            }\n            catch (Throwable ex) {\n                throw new CompletionException(ex); // 将异常包装为 CompletionException，以便在 future.get() 时抛出\n            }\n        }, executor);\n    }\n    // 2. 如果方法返回值是 ListenableFuture 类型\n    else if (ListenableFuture.class.isAssignableFrom(returnType)) {\n        // 将 AsyncTaskExecutor 强制转换为 AsyncListenableTaskExecutor，\n        // 并调用 submitListenable() 方法提交任务。\n        // AsyncListenableTaskExecutor 是 ListenableFuture 的专用异步执行器，\n        // 它可以返回一个 ListenableFuture 对象，允许添加回调函数来监听任务的完成。\n        return ((AsyncListenableTaskExecutor) executor).submitListenable(task);\n    }\n    // 3. 如果方法返回值是 Future 类型\n    else if (Future.class.isAssignableFrom(returnType)) {\n        // 直接调用 AsyncTaskExecutor 的 submit() 方法提交任务，并返回一个 Future 对象。\n        return executor.submit(task);\n    }\n    // 4. 如果方法返回值是 void 或其他类型\n    else {\n        // 直接调用 AsyncTaskExecutor 的 submit() 方法提交任务。\n        // 由于方法返回值是 void，因此不需要返回任何结果，直接返回 null。\n        executor.submit(task);\n        return null;\n    }\n}
\n

在 doSubmit() 方法中，会根据 @Async 注解标注方法的返回值不同，来选择不同的任务提交方式，最后任务会由执行器（线程池）执行。

\n

总结

\n

\n

理解 @Async 原理的核心在于理解 @EnableAsync 注解，该注解开启了异步任务的功能。

\n

主要流程如上图，会通过后置处理器来创建代理对象，之后代理对象中 @Async 方法的执行会走到 Advice 内部的拦截器中，之后将方法封装为异步任务，并提交线程池进行处理。

\n

@Async 使用建议

\n

自定义线程池

\n

如果没有显式地配置线程池，在 @Async 底层会先在 BeanFactory 中尝试获取线程池，如果获取不到，则会创建一个 SimpleAsyncTaskExecutor 实现。SimpleAsyncTaskExecutor 本质上不算是一个真正的线程池，因为它对于每个请求都会启动一个新线程而不重用现有线程，这会带来一些潜在的问题，例如资源消耗过大。

\n

具体线程池获取可以参考这篇文章：浅析 Spring 中 Async 注解底层异步线程池原理｜得物技术。

\n

一定要显式配置一个线程池，推荐ThreadPoolTaskExecutor。并且，还可以根据任务的性质和需求，为不同的异步方法指定不同的线程池。

\n
@Configuration\n@EnableAsync\npublic class AsyncConfig {\n\n    @Bean(name = \"executor1\")\n    public Executor executor1() {\n        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();\n        executor.setCorePoolSize(3);\n        executor.setMaxPoolSize(5);\n        executor.setQueueCapacity(50);\n        executor.setThreadNamePrefix(\"AsyncExecutor1-\");\n        executor.initialize();\n        return executor;\n    }\n\n    @Bean(name = \"executor2\")\n    public Executor executor2() {\n        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();\n        executor.setCorePoolSize(2);\n        executor.setMaxPoolSize(4);\n        executor.setQueueCapacity(100);\n        executor.setThreadNamePrefix(\"AsyncExecutor2-\");\n        executor.initialize();\n        return executor;\n    }\n}
\n

@Async 注解中指定线程池的 Bean 名称：

\n
@Service\npublic class AsyncService {\n\n    @Async(\"executor1\")\n    public void performTask1() {\n        // 任务1的逻辑\n        System.out.println(\"Executing Task1 with Executor1\");\n    }\n\n    @Async(\"executor2\")\n    public void performTask2() {\n        // 任务2的逻辑\n        System.out.println(\"Executing Task2 with Executor2\");\n    }\n}
\n

避免 @Async 注解失效

\n

@Async 注解会在以下几个场景失效，需要注意：

\n

1、同一类中调用异步方法

\n

如果你在同一个类内部调用一个@Async注解的方法，那这个方法将不会异步执行。

\n
@Service\npublic class MyService {\n\n    public void myMethod() {\n        // 直接通过 this 引用调用，绕过了 Spring 的代理机制，异步执行失效\n        asyncMethod();\n    }\n\n    @Async\n    public void asyncMethod() {\n        // 异步执行的逻辑\n    }\n}
\n

这是因为 Spring 的异步机制是通过 代理 实现的，而在同一个类内部的方法调用会绕过 Spring 的代理机制，也就是绕过了代理对象，直接通过 this 引用调用的。由于没有经过代理，所有的代理相关的处理（即将任务提交线程池异步执行）都不会发生。

\n

为了避免这个问题，比较推荐的做法是将异步方法移至另一个 Spring Bean 中。

\n
@Service\npublic class AsyncService {\n    @Async\n    public void asyncMethod() {\n        // 异步执行的逻辑\n    }\n}\n\n@Service\npublic class MyService {\n    @Autowired\n    private AsyncService asyncService;\n\n    public void myMethod() {\n        asyncService.asyncMethod();\n    }\n}
\n

2、使用 static 关键字修饰异步方法

\n

如果@Async注解的方法被 static 关键字修饰，那这个方法将不会异步执行。

\n

这是因为 Spring 的异步机制是通过代理实现的，由于静态方法不属于实例而是属于类且不参与继承，Spring 的代理机制（无论是基于 JDK 还是 CGLIB）无法拦截静态方法来提供如异步执行这样的增强功能。

\n

篇幅问题，这里没有进一步详细介绍，不了解的代理机制的朋友，可以看看我写的 Java 代理模式详解这篇文章。

\n

如果你需要异步执行一个静态方法的逻辑，可以考虑设计一个非静态的包装方法，这个包装方法使用 @Async 注解，并在其内部调用静态方法

\n
@Service\npublic class AsyncService {\n\n    @Async\n    public void asyncWrapper() {\n        // 调用静态方法\n        SClass.staticMethod();\n    }\n}\n\npublic class SClass {\n    public static void staticMethod() {\n        // 执行一些操作\n    }\n}
\n

3、忘记开启异步支持

\n

Spring Boot 默认情况下不启用异步支持，确保在主配置类 Application 上添加@EnableAsync注解以启用异步功能。

\n
@SpringBootApplication\n@EnableAsync\npublic class Application {\n    public static void main(String[] args) {\n        SpringApplication.run(Application.class, args);\n    }\n}
\n

4、@Async 注解的方法所在的类必须是 Spring Bean

\n

@Async 注解的方法必须位于 Spring 管理的 Bean 中，只有这样，Spring 才能在创建 Bean 时应用代理，代理能够拦截方法调用并实现异步执行的逻辑。如果该方法不在 Spring 管理的 bean 中，Spring 就无法创建必要的代理，@Async 注解就不会产生任何效果。

\n

返回值类型

\n

建议将 @Async 注解方法的返回值类型定义为 void 和 Future 。

\n\n

如果将 @Async 注解方法的返回值定义为其他类型（如 Object 、 String 等等），则无法获取方法返回值。

\n

这种设计符合异步编程的基本原则，即调用者不应立即期待一个结果，而是应该能够在未来某个时间点获取结果。如果返回类型是 Future，调用者可以使用这个返回的 Future 对象来查询任务的状态，取消任务，或者在任务完成时获取结果。

\n

处理异步方法中的异常

\n

异步方法中抛出的异常默认不会被调用者捕获。为了管理这些异常，建议使用CompletableFuture的异常处理功能，或者配置一个全局的AsyncUncaughtExceptionHandler来处理没有正确捕获的异常。

\n
@Configuration\n@EnableAsync\npublic class AsyncConfig implements AsyncConfigurer{\n\n    @Override\n    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {\n        return new CustomAsyncExceptionHandler();\n    }\n\n}\n\n// 自定义异常处理器\nclass CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {\n\n    @Override\n    public void handleUncaughtException(Throwable ex, Method method, Object... params) {\n        // 日志记录或其他处理逻辑\n    }\n}
\n

未考虑事务管理

\n

@Async注解的方法需要事务支持时，务必在该异步方法上独立使用。

\n
@Service\npublic class AsyncTransactionalService {\n\n    @Async\n    // Propagation.REQUIRES_NEW 表示 Spring 在执行异步方法时开启一个新的、与当前事务无关的事务\n    @Transactional(propagation = Propagation.REQUIRES_NEW)\n    public void asyncTransactionalMethod() {\n        // 这里的操作会在新的事务中执行\n        // 执行一些数据库操作\n    }\n}
\n

未指定异步方法执行顺序

\n

@Async注解的方法执行是非阻塞的，它们可能以任意顺序完成。如果需要按照特定的顺序处理结果，你可以将方法的返回值设定为 Future 或 CompletableFuture ，通过返回值对象来实现一个方法在另一个方法完成后再执行。

\n
@Async\npublic CompletableFuture<String> fetchDataAsync() {\n    return CompletableFuture.completedFuture(\"Data\");\n}\n\n@Async\npublic CompletableFuture<String> processDataAsync(String data) {\n    return CompletableFuture.supplyAsync(() -> \"Processed \" + data);\n}
\n

processDataAsync 方法在 fetchDataAsync后执行：

\n
CompletableFuture<String> dataFuture = asyncService.fetchDataAsync();\ndataFuture.thenCompose(data -> asyncService.processDataAsync(data))\n          .thenAccept(result -> System.out.println(result));
\n

\n", "date_published": "2024-12-26T14:09:00.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "框架" ] }, { "title": "Java 22 & 23 新特性概览", "url": "https://javaguide.cn/java/new-features/java22-23.html", "id": "https://javaguide.cn/java/new-features/java22-23.html", "summary": "概览 JDK 22/23 的关键 JEP 与语言/平台增强，持续追踪性能与并发相关改动。", "content_html": "

JDK 23 和 JDK 22 一样，这也是一个非 LTS（长期支持）版本，Oracle 仅提供六个月的支持。下一个长期支持版是 JDK 25，预计于 2025 年 9 月发布。

\n

下图是从 JDK8 到 JDK 24 每个版本的更新带来的新特性数量和更新时间：

\n

\n

由于 JDK 22 和 JDK 23 重合的新特性较多，这里主要以 JDK 23 为主介绍，会补充 JDK 22 独有的一些特性。

\n

JDK 23 一共有 12 个新特性：

\n\n

JDK 22 共有 12 个新特性，如下所示：

\n

\n

其中，下面这 4 条新特性我会单独拎出来详细介绍一下：

\n\n

JDK 23

\n

JEP 455: 模式中的原始类型、instanceof 和 switch（预览）

\n

在 JEP 455 之前， instanceof 只支持引用类型，switch 表达式和语句的 case 标签只能使用整数字面量、枚举常量和字符串字面量。

\n

JEP 455 的预览特性中，instanceof 和 switch 全面支持所有原始类型，包括 byte, short, char, int, long, float, double, boolean。

\n
// 传统写法\nif (i >= -128 && i <= 127) {\n    byte b = (byte)i;\n    ... b ...\n}\n\n// 使用 instanceof 改进\nif (i instanceof byte b) {\n    ... b ...\n}\n\nlong v = ...;\n// 传统写法\nif (v == 1L) {\n    // ...\n} else if (v == 2L) {\n    // ...\n} else if (v == 10_000_000_000L) {\n    // ...\n}\n\n// 使用 long 类型的 case 标签\nswitch (v) {\n    case 1L:\n        // ...\n        break;\n    case 2L:\n        // ...\n        break;\n    case 10_000_000_000L:\n        // ...\n        break;\n    default:\n        // ...\n}
\n

JEP 466: Class File API（第二次预览）

\n

类文件 API 在 JDK 22 进行了第一次预览，由 JEP 457 提出。

\n

类文件 API 的目标是提供一套标准化的 API，用于解析、生成和转换 Java 类文件，取代过去对第三方库（如 ASM）在类文件处理上的依赖。

\n
// 创建一个 ClassFile 对象，这是操作类文件的入口。\nClassFile cf = ClassFile.of();\n// 解析字节数组为 ClassModel\nClassModel classModel = cf.parse(bytes);\n\n// 构建新的类文件，移除以 \"debug\" 开头的所有方法\nbyte[] newBytes = cf.build(classModel.thisClass().asSymbol(),\n        classBuilder -> {\n            // 遍历所有类元素\n            for (ClassElement ce : classModel) {\n                // 判断是否为方法 且 方法名以 \"debug\" 开头\n                if (!(ce instanceof MethodModel mm\n                        && mm.methodName().stringValue().startsWith(\"debug\"))) {\n                    // 添加到新的类文件中\n                    classBuilder.with(ce);\n                }\n            }\n        });
\n

JEP 467：Markdown 文档注释

\n

在 JavaDoc 文档注释中可以使用 Markdown 语法，取代原本只能使用 HTML 和 JavaDoc 标签的方式。

\n

Markdown 更简洁易读，减少了手动编写 HTML 的繁琐，同时保留了对 HTML 元素和 JavaDoc 标签的支持。这个增强旨在让 API 文档注释的编写和阅读变得更加轻松，同时不会影响现有注释的解释。Markdown 提供了对常见文档元素（如段落、列表、链接等）的简化表达方式，提升了文档注释的可维护性和开发者体验。

\n

\"Markdown

\n

JEP 469：向量 API（第八次孵化）

\n

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

\n

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

\n

这是对数组元素的简单标量计算：

\n
void scalarComputation(float[] a, float[] b, float[] c) {\n   for (int i = 0; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n   }\n}
\n

这是使用 Vector API 进行的等效向量计算：

\n
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;\n\nvoid vectorComputation(float[] a, float[] b, float[] c) {\n    int i = 0;\n    int upperBound = SPECIES.loopBound(a.length);\n    for (; i < upperBound; i += SPECIES.length()) {\n        // FloatVector va, vb, vc;\n        var va = FloatVector.fromArray(SPECIES, a, i);\n        var vb = FloatVector.fromArray(SPECIES, b, i);\n        var vc = va.mul(va)\n                   .add(vb.mul(vb))\n                   .neg();\n        vc.intoArray(c, i);\n    }\n    for (; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n    }\n}
\n

JEP 473：流收集器（第二次预览）

\n

流收集器在 JDK 22 进行了第一次预览，由 JEP 461 提出。

\n

这个改进使得 Stream API 可以支持自定义中间操作。

\n
source.gather(a).gather(b).gather(c).collect(...)
\n

JEP 471：弃用 sun.misc.Unsafe 中的内存访问方法

\n

JEP 471 提议弃用 sun.misc.Unsafe 中的内存访问方法，这些方法将来的版本中会被移除。

\n

这些不安全的方法已有安全高效的替代方案：

\n\n

这两个类是 Foreign Function & Memory API（外部函数和内存 API） 的核心组件，分别用于管理和操作堆外内存。Foreign Function & Memory API 在 JDK 22 中正式转正，成为标准特性。

\n
import jdk.incubator.foreign.*;\nimport java.lang.invoke.VarHandle;\n\n// 管理堆外整数数组的类\nclass OffHeapIntBuffer {\n\n    // 用于访问整数元素的VarHandle\n    private static final VarHandle ELEM_VH = ValueLayout.JAVA_INT.arrayElementVarHandle();\n\n    // 内存管理器\n    private final Arena arena;\n\n    // 堆外内存段\n    private final MemorySegment buffer;\n\n    // 构造函数，分配指定数量的整数空间\n    public OffHeapIntBuffer(long size) {\n        this.arena  = Arena.ofShared();\n        this.buffer = arena.allocate(ValueLayout.JAVA_INT, size);\n    }\n\n    // 释放内存\n    public void deallocate() {\n        arena.close();\n    }\n\n    // 以volatile方式设置指定索引的值\n    public void setVolatile(long index, int value) {\n        ELEM_VH.setVolatile(buffer, 0L, index, value);\n    }\n\n    // 初始化指定范围的元素为0\n    public void initialize(long start, long n) {\n        buffer.asSlice(ValueLayout.JAVA_INT.byteSize() * start,\n                       ValueLayout.JAVA_INT.byteSize() * n)\n              .fill((byte) 0);\n    }\n\n    // 将指定范围的元素复制到新数组\n    public int[] copyToNewArray(long start, int n) {\n        return buffer.asSlice(ValueLayout.JAVA_INT.byteSize() * start,\n                              ValueLayout.JAVA_INT.byteSize() * n)\n                     .toArray(ValueLayout.JAVA_INT);\n    }\n}
\n

JEP 474：ZGC：默认的分代模式

\n

Z 垃圾回收器 (ZGC) 的默认模式切换为分代模式，并弃用非分代模式，计划在未来版本中移除。这是因为分代 ZGC 是大多数场景下的更优选择。

\n

JEP 476：模块导入声明 (预览)

\n

模块导入声明允许在 Java 代码中简洁地导入整个模块的所有导出包，而无需逐个声明包的导入。这一特性简化了模块化库的重用，特别是在使用多个模块时，避免了大量的包导入声明，使得开发者可以更方便地访问第三方库和 Java 基本类。

\n

此特性对初学者和原型开发尤为有用，因为它无需开发者将自己的代码模块化，同时保留了对传统导入方式的兼容性，提升了开发效率和代码可读性。

\n
// 导入整个 java.base 模块，开发者可以直接访问 List、Map、Stream 等类，而无需每次手动导入相关包\nimport module java.base;\n\npublic class Example {\n    public static void main(String[] args) {\n        String[] fruits = { \"apple\", \"berry\", \"citrus\" };\n        Map<String, String> fruitMap = Stream.of(fruits)\n            .collect(Collectors.toMap(\n                s -> s.toUpperCase().substring(0, 1),\n                Function.identity()));\n\n        System.out.println(fruitMap);\n    }\n}
\n

JEP 477：未命名类和实例 main 方法 （第三次预览）

\n

这个特性主要简化了 main 方法的声明。对于 Java 初学者来说，这个 main 方法的声明引入了太多的 Java 语法概念，不利于初学者快速上手。

\n

没有使用该特性之前定义一个 main 方法：

\n
public class HelloWorld {\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

使用该新特性之后定义一个 main 方法：

\n
class HelloWorld {\n    void main() {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

进一步简化（未命名的类允许我们省略类名）

\n
void main() {\n   System.out.println(\"Hello, World!\");\n}
\n

JEP 480：结构化并发 （第三次预览）

\n

Java 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope。StructuredTaskScope 支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n

JEP 481：作用域值 （第三次预览）

\n

作用域值（Scoped Values）可以在线程内和线程间共享不可变的数据，优于线程局部变量，尤其是在使用大量虚拟线程时。

\n
final static ScopedValue<...> V = new ScopedValue<>();\n\n// In some method\nScopedValue.where(V, <value>)\n           .run(() -> { ... V.get() ... call methods ... });\n\n// In a method called directly or indirectly from the lambda expression\n... V.get() ...
\n

作用域值允许在大型程序中的组件之间安全有效地共享数据，而无需求助于方法参数。

\n

JEP 482：灵活的构造函数体（第二次预览）

\n

这个特性最初在 JDK 22 由 JEP 447: Statements before super(...) (Preview)提出。

\n

Java 要求在构造函数中，super(...) 或 this(...) 调用必须作为第一条语句出现。这意味着我们无法在调用父类构造函数之前在子类构造函数中直接初始化字段。

\n

灵活的构造函数体解决了这一问题，它允许在构造函数体内，在调用 super(..) 或 this(..) 之前编写语句，这些语句可以初始化字段，但不能引用正在构造的实例。这样可以防止在父类构造函数中调用子类方法时，子类的字段未被正确初始化，增强了类构造的可靠性。

\n

这一特性解决了之前 Java 语法限制了构造函数代码组织的问题，让开发者能够更自由、更自然地表达构造函数的行为，例如在构造函数中直接进行参数验证、准备和共享，而无需依赖辅助方法或构造函数，提高了代码的可读性和可维护性。

\n
class Person {\n    private final String name;\n    private int age;\n\n    public Person(String name, int age) {\n        if (age < 0) {\n            throw new IllegalArgumentException(\"Age cannot be negative.\");\n        }\n        this.name = name; // 在调用父类构造函数之前初始化字段\n        this.age = age;\n        // ... 其他初始化代码\n    }\n}\n\nclass Employee extends Person {\n    private final int employeeId;\n\n    public Employee(String name, int age, int employeeId) {\n        this.employeeId = employeeId; // 在调用父类构造函数之前初始化字段\n        super(name, age); // 调用父类构造函数\n        // ... 其他初始化代码\n    }\n}
\n

JDK 22

\n

JEP 423：G1 垃圾收集器区域固定

\n

JEP 423 提出在 G1 垃圾收集器中实现区域固定（Region Pinning）功能，旨在减少由于 Java Native Interface (JNI) 关键区域导致的延迟问题。

\n

JNI 关键区域内的对象不能在垃圾收集时被移动，因此 G1 以往通过禁用垃圾收集解决该问题，导致线程阻塞及严重的延迟。通过在 G1 的老年代和年轻代中引入区域固定机制，允许在关键区域内固定对象所在的内存区域，同时继续回收未固定的区域，避免了禁用垃圾回收的需求。这种改进有助于显著降低延迟，提升系统在与 JNI 交互时的吞吐量和稳定性。

\n

JEP 454：外部函数和内存 API

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。Java 18 中进行了第二次孵化，由JEP 419 提出。Java 19 中是第一次预览，由 JEP 424 提出。JDK 20 中是第二次预览，由 JEP 434 提出。JDK 21 中是第三次预览，由 JEP 442 提出。

\n

最终，该特性在 JDK 22 中顺利转正。

\n

在 Java 19 新特性概览 中，我有详细介绍到外部函数和内存 API，这里就不再做额外的介绍了。

\n

JEP 456：未命名模式和变量

\n

未命名模式和变量在 JDK 21 中由 JEP 443提出预览，JDK 22 中就已经转正。

\n

关于这个新特性的详细介绍，可以看看Java 21 新特性概览(重要)这篇文章中的介绍。

\n

JEP 458：启动多文件源代码程序

\n

Java 11 引入了 JEP 330：启动单文件源代码程序，增强了 java 启动器的功能，使其能够直接运行单个 Java 源文件。通过命令 java HelloWorld.java，Java 可以在内存中隐式编译源代码并立即执行，而不需要在磁盘上生成 .class 文件。这简化了开发者在编写小型工具程序或学习 Java 时的工作流程，避免了手动编译的额外步骤。

\n

假设文件Prog.java声明了两个类：

\n
class Prog {\n    public static void main(String[] args) { Helper.run(); }\n}\n\nclass Helper {\n    static void run() { System.out.println(\"Hello!\"); }\n}
\n

java Prog.java命令会在内存中编译两个类并执行main该文件中声明的第一个类的方法。

\n

这种方式有一个限制，程序的所有源代码必须放在一个.java文件中。

\n

JEP 458：启动多文件源代码程序 是对 JEP 330 功能的扩展，允许直接运行由多个 Java 源文件组成的程序，而无需显式的编译步骤。

\n

假设一个目录中有两个 Java 源文件 Prog.java 和 Helper.java，每个文件各自声明了一个类：

\n
// Prog.java\nclass Prog {\n    public static void main(String[] args) { Helper.run(); }\n}\n\n// Helper.java\nclass Helper {\n    static void run() { System.out.println(\"Hello!\"); }\n}
\n

当你运行命令 java Prog.java 时，Java 启动器会在内存中编译并执行 Prog 类的 main 方法。由于 Prog 类中的代码引用了 Helper 类，启动器会自动在文件系统中找到 Helper.java 文件，编译其中的 Helper 类，并在内存中执行它。这个过程是自动的，开发者无需显式调用 javac 来编译所有源文件。

\n

这一特性使得从小型项目到大型项目的过渡更加平滑，开发者可以自由选择何时引入构建工具，避免在快速迭代时被迫设置复杂的项目结构。该特性消除了单文件的限制，进一步简化了从单一文件到多文件程序的开发过程，特别适合原型开发、快速实验以及早期项目的探索阶段。

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2024-09-20T03:02:27.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "程序员最该拿的几种高含金量证书", "url": "https://javaguide.cn/high-quality-technical-articles/programmer/high-value-certifications-for-programmers.html", "id": "https://javaguide.cn/high-quality-technical-articles/programmer/high-value-certifications-for-programmers.html", "summary": "程序员最该拿的几种高含金量证书：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "

证书是能有效证明自己能力的好东西，它就是你实力的象征。在短短的面试时间内，证书可以为你加不少分。通过考证来提升自己，是一种性价比很高的办法。不过，相比金融、建筑、医疗等行业，IT 行业的职业资格证书并没有那么多。

\n

下面我总结了一下程序员可以考的一些常见证书。

\n

软考

\n

全国计算机技术与软件专业技术资格（水平）考试，简称“软考”，是国内认可度较高的一项计算机技术资格认证。尽管一些人吐槽其实际价值，但在特定领域和情况下，它还是非常有用的，例如软考证书在国企和事业单位中具有较高的认可度、在某些城市软考证书可以用于积分落户、可用于个税补贴。

\n

软考有初、中、高三个级别，建议直接考高级。相比于 PMP（项目管理专业人士认证），软考高项的难度更大，特别是论文部分，绝大部分人都挂在了论文部分。过了软考高项，在一些单位可以内部挂证，每个月多拿几百。

\n

\"软考高级证书\"

\n

官网地址：https://www.ruankao.org.cn/。

\n

备考建议：2024 年上半年，一次通过软考高级架构师考试的备考秘诀 - 阿里云开发者

\n

PAT

\n

攀拓计算机能力测评（PAT）是一个专注于考察算法能力的测评体系，由浙江大学主办。该测评分为四个级别：基础级、乙级、甲级和顶级。

\n

通过 PAT 测评并达到联盟企业规定的相应评级和分数，可以跳过学历门槛，免除筛选简历和笔试环节，直接获得面试机会。具体有哪些公司可以去官网看看：https://www.patest.cn/company 。

\n

对于考研浙江大学的同学来说，PAT（甲级）成绩在一年内可以作为硕士研究生招生考试上机复试成绩。

\n

\"PAT（甲级）成绩作用\"

\n

PMP

\n

PMP（Project Management Professional）认证由美国项目管理协会（PMI）提供，是全球范围内认可度最高的项目管理专业人士资格认证。PMP 认证旨在提升项目管理专业人士的知识和技能，确保项目顺利完成。

\n

\"PMP

\n

PMP 是“一证在手，全球通用”的资格认证，对项目管理人士来说，PMP 证书含金量还是比较高的。放眼全球，很多成功企业都会将 PMP 认证作为项目经理的入职标准。

\n

但是！真正有价值的不是 PMP 证书，而是《PMBOK》 那套项目管理体系，在《PMBOK》（PMP 考试指定用书）中也包含了非常多商业活动、实业项目、组织规划、建筑行业等各个领域的项目案例。

\n

另外，PMP 证书不是一个高大上的证书，而是一个基础的证书。

\n

ACP

\n

ACP（Agile Certified Practitioner）认证同样由美国项目管理协会（PMI）提供，是项目管理领域的另一个重要认证。与 PMP（Project Management Professional）注重传统的瀑布方法论不同，ACP 专注于敏捷项目管理方法论，如 Scrum、Kanban、Lean、Extreme Programming（XP）等。

\n

OCP

\n

Oracle Certified Professional（OCP）是 Oracle 公司提供的一项专业认证，专注于 Oracle 数据库及相关技术。这个认证旨在验证和认证个人在使用和管理 Oracle 数据库方面的专业知识和技能。

\n

下图展示了 Oracle 认证的不同路径和相应的认证级别，分别是核心路径（Core Track）和专业路径（Speciality Track）。

\n

\"OCP

\n

阿里云认证

\n

阿里云（Alibaba Cloud）提供的专业认证，认证方向包括云计算、大数据、人工智能、Devops 等。职业认证分为 ACA、ACP、ACE 三个等级，除了职业认证之外，还有一个开发者 Clouder 认证，这是专门为开发者设立的专项技能认证。

\n

\n

官网地址：https://edu.aliyun.com/certification/。

\n

华为认证

\n

华为认证是由华为技术有限公司提供的面向 ICT（信息与通信技术）领域的专业认证，认证方向包括网络、存储、云计算、大数据、人工智能等，非常庞大的认证体系。

\n

\n

AWS 认证

\n

AWS 云认证考试是 AWS 云计算服务的官方认证考试，旨在验证 IT 专业人士在设计、部署和管理 AWS 基础架构方面的技能。

\n

AWS 认证分为多个级别，包括基础级、从业者级、助理级、专业级和专家级（Specialty），涵盖多个角色和技能：

\n\n

备考建议：小白入门云计算的最佳方式，是去考一张 AWS 的证书（附备考经验）

\n

Google Cloud 认证

\n

与 AWS 认证不同，Google Cloud 认证只有一门助理级认证（Associate Cloud Engineer），其他大部分为专业级（专家级）认证。

\n

备考建议：如何备考谷歌云认证

\n

官网地址：https://cloud.google.com/certification

\n

微软认证

\n

微软的认证体系主要针对其 Azure 云平台，分为基础级别、助理级别和专家级别，认证方向包括云计算、数据管理、开发、生产力工具等。

\n

\n

Elastic 认证

\n

Elastic 认证是由 Elastic 公司提供的一系列专业认证，旨在验证个人在使用 Elastic Stack（包括 Elasticsearch、Logstash、Kibana 、Beats 等）方面的技能和知识。

\n

如果你在日常开发核心工作是负责 ElasticSearch 相关业务的话，还是比较建议考的，含金量挺高。

\n

目前 Elastic 认证证书分为四类：Elastic Certified Engineer、Elastic Certified Analyst、Elastic Certified Observability Engineer、Elastic Certified SIEM Specialist。

\n

比较建议考 Elastic Certified Engineer，这个是 Elastic Stack 的基础认证，考察安装、配置、管理和维护 Elasticsearch 集群等核心技能。

\n

\n

其他

\n\n", "image": "https://oss.javaguide.cn/github/javaguide/programmer-life/programmer-certification/ruankao-advanced-certification%20.jpg", "date_published": "2024-07-22T11:26:12.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "技术文章精选集" ] }, { "title": "CAS 详解", "url": "https://javaguide.cn/java/concurrent/cas.html", "id": "https://javaguide.cn/java/concurrent/cas.html", "summary": "CAS比较并交换深度解析：详解CAS原子操作原理、Unsafe类实现、ABA问题及解决方案、自旋锁机制、与悲观锁性能对比。", "content_html": "

乐观锁和悲观锁的介绍以及乐观锁常见实现方式可以阅读笔者写的这篇文章：乐观锁和悲观锁详解。

\n

这篇文章主要介绍 ：Java 中 CAS 的实现以及 CAS 存在的一些问题。

\n

Java 中 CAS 是如何实现的？

\n

在 Java 中，实现 CAS（Compare-And-Swap, 比较并交换）操作的一个关键类是Unsafe。

\n

Unsafe类位于sun.misc包下，是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性，它通常用于 JVM 内部或一些需要极高性能和底层访问的库中，而不推荐普通开发者在应用程序中使用。关于 Unsafe类的详细介绍，可以阅读这篇文章：📌Java 魔法类 Unsafe 详解。

\n

sun.misc包下的Unsafe类提供了compareAndSwapObject、compareAndSwapInt、compareAndSwapLong方法来实现的对Object、int、long类型的 CAS 操作：

\n
/**\n * 以原子方式更新对象字段的值。\n *\n * @param o        要操作的对象\n * @param offset   对象字段的内存偏移量\n * @param expected 期望的旧值\n * @param x        要设置的新值\n * @return 如果值被成功更新，则返回 true；否则返回 false\n */\nboolean compareAndSwapObject(Object o, long offset, Object expected, Object x);\n\n/**\n * 以原子方式更新 int 类型的对象字段的值。\n */\nboolean compareAndSwapInt(Object o, long offset, int expected, int x);\n\n/**\n * 以原子方式更新 long 类型的对象字段的值。\n */\nboolean compareAndSwapLong(Object o, long offset, long expected, long x);
\n

Unsafe类中的 CAS 方法是native方法。native关键字表明这些方法是用本地代码（通常是 C 或 C++）实现的，而不是用 Java 实现的。这些方法直接调用底层的硬件指令来实现原子操作。也就是说，Java 语言并没有直接用 Java 实现 CAS。

\n

更准确点来说，Java 中 CAS 是 C++ 内联汇编的形式实现的，通过 JNI（Java Native Interface） 调用。因此，CAS 的具体实现与操作系统以及 CPU 密切相关。

\n

java.util.concurrent.atomic 包提供了一些用于原子操作的类。

\n

\"JUC原子类概览\"

\n

关于这些 Atomic 原子类的介绍和使用，可以阅读这篇文章：Atomic 原子类总结。

\n

Atomic 类依赖于 CAS 乐观锁来保证其方法的原子性，而不需要使用传统的锁机制（如 synchronized 块或 ReentrantLock）。

\n

AtomicInteger是 Java 的原子类之一，主要用于对 int 类型的变量进行原子操作，它利用Unsafe类提供的低级别原子操作方法实现无锁的线程安全性。

\n

下面，我们通过解读AtomicInteger的核心源码（JDK1.8），来说明 Java 如何使用Unsafe类的方法来实现原子操作。

\n

AtomicInteger核心源码如下：

\n
// 获取 Unsafe 实例\nprivate static final Unsafe unsafe = Unsafe.getUnsafe();\nprivate static final long valueOffset;\n\nstatic {\n    try {\n        // 获取“value”字段在AtomicInteger类中的内存偏移量\n        valueOffset = unsafe.objectFieldOffset\n            (AtomicInteger.class.getDeclaredField(\"value\"));\n    } catch (Exception ex) { throw new Error(ex); }\n}\n// 确保“value”字段的可见性\nprivate volatile int value;\n\n// 如果当前值等于预期值，则原子地将值设置为newValue\n// 使用 Unsafe#compareAndSwapInt 方法进行CAS操作\npublic final boolean compareAndSet(int expect, int update) {\n    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);\n}\n\n// 原子地将当前值加 delta 并返回旧值\npublic final int getAndAdd(int delta) {\n    return unsafe.getAndAddInt(this, valueOffset, delta);\n}\n\n// 原子地将当前值加 1 并返回加之前的值（旧值）\n// 使用 Unsafe#getAndAddInt 方法进行CAS操作。\npublic final int getAndIncrement() {\n    return unsafe.getAndAddInt(this, valueOffset, 1);\n}\n\n// 原子地将当前值减 1 并返回减之前的值（旧值）\npublic final int getAndDecrement() {\n    return unsafe.getAndAddInt(this, valueOffset, -1);\n}
\n

Unsafe#getAndAddInt源码：

\n
// 原子地获取并增加整数值\npublic final int getAndAddInt(Object o, long offset, int delta) {\n    int v;\n    do {\n        // 以 volatile 方式获取对象 o 在内存偏移量 offset 处的整数值\n        v = getIntVolatile(o, offset);\n    } while (!compareAndSwapInt(o, offset, v, v + delta));\n    // 返回旧值\n    return v;\n}
\n

可以看到，getAndAddInt 使用了 do-while 循环：在compareAndSwapInt操作失败时，会不断重试直到成功。也就是说，getAndAddInt方法会通过 compareAndSwapInt 方法来尝试更新 value 的值，如果更新失败（当前值在此期间被其他线程修改），它会重新获取当前值并再次尝试更新，直到操作成功。

\n

由于 CAS 操作可能会因为并发冲突而失败，因此通常会与while循环搭配使用，在失败后不断重试，直到操作成功。这就是 自旋锁机制 。

\n

CAS 算法存在哪些问题？

\n

ABA 问题是 CAS 算法最常见的问题。

\n

ABA 问题

\n

如果一个变量 V 初次读取的时候是 A 值，并且在准备赋值的时候检查到它仍然是 A 值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回 A，那 CAS 操作就会误认为它从来没有被修改过。这个问题被称为 CAS 操作的 "ABA"问题。

\n

ABA 问题的解决思路是在变量前面追加上版本号或者时间戳。JDK 1.5 以后的 AtomicStampedReference 类就是用来解决 ABA 问题的，其中的 compareAndSet() 方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

\n
public boolean compareAndSet(V   expectedReference,\n                             V   newReference,\n                             int expectedStamp,\n                             int newStamp) {\n    Pair<V> current = pair;\n    return\n        expectedReference == current.reference &&\n        expectedStamp == current.stamp &&\n        ((newReference == current.reference &&\n          newStamp == current.stamp) ||\n         casPair(current, Pair.of(newReference, newStamp)));\n}
\n

循环时间长开销大

\n

CAS 经常会用到自旋操作来进行重试，也就是不成功就一直循环执行直到成功。如果长时间不成功，会给 CPU 带来非常大的执行开销。

\n

如果 JVM 能够支持处理器提供的pause指令，那么自旋操作的效率将有所提升。pause指令有两个重要作用：

\n
    \n
  1. 延迟流水线执行指令：pause指令可以延迟指令的执行，从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本，在某些处理器上，延迟时间可能为零。
    2. \n
  2. 避免内存顺序冲突：在退出循环时，pause指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空，从而提高 CPU 的执行效率。
    3. \n
\n

只能保证一个共享变量的原子操作

\n

CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时，CAS 就显得无能为力。不过，从 JDK 1.5 开始，Java 提供了AtomicReference类，这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中，我们可以使用AtomicReference来执行 CAS 操作。

\n

除了 AtomicReference 这种方式之外，还可以利用加锁来保证。

\n

总结

\n

在 Java 中，CAS 通过 Unsafe 类中的 native 方法实现，这些方法调用底层的硬件指令来完成原子操作。由于其实现依赖于 C++ 内联汇编和 JNI 调用，因此 CAS 的具体实现与操作系统以及 CPU 密切相关。

\n

CAS 虽然具有高效的无锁特性，但也需要注意 ABA 、循环时间长开销大等问题。

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/JUC%E5%8E%9F%E5%AD%90%E7%B1%BB%E6%A6%82%E8%A7%88.png", "date_published": "2024-07-17T04:53:20.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "如何基于Redis实现延时任务？", "url": "https://javaguide.cn/database/redis/redis-delayed-task.html", "id": "https://javaguide.cn/database/redis/redis-delayed-task.html", "summary": "详解基于Redis实现延时任务的两种方案：过期事件监听和Redisson延时队列，分析各方案的优缺点、可靠性问题和适用场景。", "content_html": "

基于 Redis 实现延时任务的功能无非就下面两种方案：

\n
    \n
  1. Redis 过期事件监听
    2. \n
  2. Redisson 内置的延时队列
    3. \n
\n

面试的时候，你可以先说自己考虑了这两种方案，但最后发现 Redis 过期事件监听这种方案存在很多问题，因此你最终选择了 Redisson 内置的 DelayedQueue 这种方案。

\n

这个时候面试官可能会追问你一些相关的问题，我们后面会提到，提前准备就好了。

\n

另外，除了下面介绍到的这些问题之外，Redis 相关的常见问题建议你都复习一遍，不排除面试官会顺带问你一些 Redis 的其他问题。

\n

Redis 过期事件监听实现延时任务功能的原理？

\n

Redis 2.0 引入了发布订阅 (pub/sub) 功能。在 pub/sub 中，引入了一个叫做 channel（频道） 的概念，有点类似于消息队列中的 topic（主题）。

\n

pub/sub 涉及发布者（publisher）和订阅者（subscriber，也叫消费者）两个角色：

\n\n

\"Redis

\n

在 pub/sub 模式下，生产者需要指定消息发送到哪个 channel 中，而消费者则订阅对应的 channel 以获取消息。

\n

Redis 中有很多默认的 channel，这些 channel 是由 Redis 本身向它们发送消息的，而不是我们自己编写的代码。其中，__keyevent@0__:expired 就是一个默认的 channel，负责监听 key 的过期事件。也就是说，当一个 key 过期之后，Redis 会发布一个 key 过期的事件到__keyevent@<db>__:expired这个 channel 中。

\n

我们只需要监听这个 channel，就可以拿到过期的 key 的消息，进而实现了延时任务功能。

\n

这个功能被 Redis 官方称为 keyspace notifications ，作用是实时监控 Redis 键和值的变化。

\n

Redis 过期事件监听实现延时任务功能有什么缺陷？

\n

1、时效性差

\n

官方文档的一段介绍解释了时效性差的原因，地址：https://redis.io/docs/manual/keyspace-notifications/#timing-of-expired-events 。

\n

\"Redis

\n

这段话的核心是：过期事件消息是在 Redis 服务器删除 key 时发布的，而不是一个 key 过期之后就会就会直接发布。

\n

我们知道常用的过期数据的删除策略就两个：

\n
    \n
  1. 惰性删除：只会在取出 key 的时候才对数据进行过期检查。这样对 CPU 最友好，但是可能会造成太多过期 key 没有被删除。
    2. \n
  2. 定期删除：每隔一段时间抽取一批 key 执行删除过期 key 操作。并且，Redis 底层会通过限制删除操作执行的时长和频率来减少删除操作对 CPU 时间的影响。
    3. \n
\n

定期删除对内存更加友好，惰性删除对 CPU 更加友好。两者各有千秋，所以 Redis 采用的是 定期删除+惰性/懒汉式删除 。

\n

因此，就会存在我设置了 key 的过期时间，但到了指定时间 key 还未被删除，进而没有发布过期事件的情况。

\n

2、丢消息

\n

Redis 的 pub/sub 模式中的消息并不支持持久化，这与消息队列不同。在 Redis 的 pub/sub 模式中，发布者将消息发送给指定的频道，订阅者监听相应的频道以接收消息。当没有订阅者时，消息会被直接丢弃，在 Redis 中不会存储该消息。

\n

3、多服务实例下消息重复消费

\n

Redis 的 pub/sub 模式目前只有广播模式，这意味着当生产者向特定频道发布一条消息时，所有订阅相关频道的消费者都能够收到该消息。

\n

这个时候，我们需要注意多个服务实例重复处理消息的问题，这会增加代码开发量和维护难度。

\n

Redisson 延迟队列原理是什么？有什么优势？

\n

Redisson 是一个开源的 Java 语言 Redis 客户端，提供了很多开箱即用的功能，比如多种分布式锁的实现、延时队列。

\n

我们可以借助 Redisson 内置的延时队列 RDelayedQueue 来实现延时任务功能。

\n

Redisson 的延迟队列 RDelayedQueue 是基于 Redis 的 SortedSet 来实现的。SortedSet 是一个有序集合，其中的每个元素都可以设置一个分数，代表该元素的权重。Redisson 利用这一特性，将需要延迟执行的任务插入到 SortedSet 中，并给它们设置相应的过期时间作为分数。

\n

Redisson 定期使用 zrangebyscore 命令扫描 SortedSet 中过期的元素，然后将这些过期元素从 SortedSet 中移除，并将它们加入到就绪消息列表中。就绪消息列表是一个阻塞队列，有消息进入就会被消费者监听到。这样做可以避免消费者对整个 SortedSet 进行轮询，提高了执行效率。

\n

相比于 Redis 过期事件监听实现延时任务功能，这种方式具备下面这些优势：

\n
    \n
  1. 减少了丢消息的可能：DelayedQueue 中的消息会被持久化，即使 Redis 宕机了，根据持久化机制，也只可能丢失一点消息，影响不大。当然了，你也可以使用扫描数据库的方法作为补偿机制。
    2. \n
  2. 消息不存在重复消费问题：每个客户端都是从同一个目标队列中获取任务的，不存在重复消费的问题。
    3. \n
\n

跟 Redisson 内置的延时队列相比，消息队列可以通过保障消息消费的可靠性、控制消息生产者和消费者的数量等手段来实现更高的吞吐量和更强的可靠性，实际项目中首选使用消息队列的延时消息这种方案。

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/redis/redis-pub-sub.png", "date_published": "2024-03-23T02:55:07.000Z", "date_modified": "2026-03-23T08:33:10.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "Redis为什么用跳表实现有序集合", "url": "https://javaguide.cn/database/redis/redis-skiplist.html", "id": "https://javaguide.cn/database/redis/redis-skiplist.html", "summary": "深入讲解Redis有序集合Zset为何选择跳表而非红黑树、B+树实现，详解跳表的数据结构原理、时间复杂度分析和Redis源码实现。", "content_html": "

前言

\n

近几年针对 Redis 面试时会涉及常见数据结构的底层设计，其中就有这么一道比较有意思的面试题：“Redis 的有序集合底层为什么要用跳表，而不用平衡树、红黑树或者 B+树？”。

\n

本文就以这道大厂常问的面试题为切入点，带大家详细了解一下跳表这个数据结构。

\n

本文整体脉络如下图所示，笔者会从有序集合的基本使用到跳表的源码分析和实现，让你会对 Redis 的有序集合底层实现的跳表有着更深刻的理解和掌握。

\n

\n

跳表在 Redis 中的运用

\n

这里我们需要先了解一下 Redis 用到跳表的数据结构有序集合的使用，Redis 有个比较常用的数据结构叫有序集合(sorted set，简称 zset)，正如其名它是一个可以保证有序且元素唯一的集合，所以它经常用于排行榜等需要进行统计排列的场景。

\n

这里我们通过命令行的形式演示一下排行榜的实现，可以看到笔者分别输入 3 名用户：xiaoming、xiaohong、xiaowang，它们的score分别是 60、80、60，最终按照成绩升级降序排列。

\n
\n127.0.0.1:6379> zadd rankList 60 xiaoming\n(integer) 1\n127.0.0.1:6379> zadd rankList 80 xiaohong\n(integer) 1\n127.0.0.1:6379> zadd rankList 60 xiaowang\n(integer) 1\n\n# 返回有序集中指定区间内的成员，通过索引，分数从高到低\n127.0.0.1:6379> ZREVRANGE rankList 0 100 WITHSCORES\n1) \"xiaohong\"\n2) \"80\"\n3) \"xiaowang\"\n4) \"60\"\n5) \"xiaoming\"\n6) \"60\"
\n

此时我们通过 object 指令查看 zset 的数据结构，可以看到当前有序集合存储的还是ziplist(压缩列表)。

\n
127.0.0.1:6379> object encoding rankList\n\"ziplist\"
\n

因为设计者考虑到 Redis 数据存放于内存，为了节约宝贵的内存空间，在有序集合元素小于 64 字节且个数小于 128 的时候，会使用 ziplist，而这个阈值的默认值的设置就来自下面这两个配置项。

\n
zset-max-ziplist-value 64\nzset-max-ziplist-entries 128
\n

一旦有序集合中的某个元素超出这两个其中的一个阈值它就会转为 skiplist（实际是 dict+skiplist，还会借用字典来提高获取指定元素的效率）。

\n

我们不妨在添加一个大于 64 字节的元素，可以看到有序集合的底层存储转为 skiplist。

\n
127.0.0.1:6379> zadd rankList 90 yigemingzihuichaoguo64zijiedeyonghumingchengyongyuceshitiaobiaodeshijiyunyong\n(integer) 1\n\n# 超过阈值，转为跳表\n127.0.0.1:6379> object encoding rankList\n\"skiplist\"
\n

也就是说，ZSet 有两种不同的实现，分别是 ziplist 和 skiplist，具体使用哪种结构进行存储的规则如下：

\n\n

手写一个跳表

\n

为了更好的回答上述问题以及更好的理解和掌握跳表，这里可以通过手写一个简单的跳表的形式来帮助读者理解跳表这个数据结构。

\n

我们都知道有序链表在添加、查询、删除的平均时间复杂都都是 O(n) 即线性增长，所以一旦节点数量达到一定体量后其性能表现就会非常差劲。而跳表我们完全可以理解为在原始链表基础上，建立多级索引，通过多级索引检索定位将增删改查的时间复杂度变为 O(log n) 。

\n

可能这里说的有些抽象，我们举个例子，以下图跳表为例，其原始链表存储按序存储 1-10，有 2 级索引，每级索引的索引个数都是基于下层元素个数的一半。

\n

\n

假如我们需要查询元素 6，其工作流程如下：

\n
    \n
  1. 从 2 级索引开始，先来到节点 4。
    2. \n
  2. 查看 4 的后继节点，是 8 的 2 级索引，这个值大于 6，说明 2 级索引后续的索引都是大于 6 的，没有再往后搜寻的必要，我们索引向下查找。
    3. \n
  3. 来到 4 的 1 级索引，比对其后继节点为 6，查找结束。
    4. \n
\n

相较于原始有序链表需要 6 次，我们的跳表通过建立多级索引，我们只需两次就直接定位到了目标元素，其查寻的复杂度被直接优化为O(log n)。

\n

\n

对应的添加也是一个道理，假如我们需要在这个有序集合中添加一个元素 7，那么我们就需要通过跳表找到小于元素 7 的最大值，也就是下图元素 6 的位置，将其插入到元素 6 的后面，让元素 6 的索引指向新插入的节点 7，其工作流程如下：

\n
    \n
  1. 从 2 级索引开始定位到了元素 4 的索引。
    2. \n
  2. 查看索引 4 的后继索引为 8，索引向下推进。
    3. \n
  3. 来到 1 级索引，发现索引 4 后继索引为 6，小于插入元素 7，指针推进到索引 6 位置。
    4. \n
  4. 继续比较 6 的后继节点为索引 8，大于元素 7，索引继续向下。
    5. \n
  5. 最终我们来到 6 的原始节点，发现其后继节点为 7，指针没有继续向下的空间，自此我们可知元素 6 就是小于插入元素 7 的最大值，于是便将元素 7 插入。
    6. \n
\n

\n

这里我们又面临一个问题，我们是否需要为元素 7 建立索引，索引多高合适？

\n

我们上文提到，理想情况是每一层索引是下一层元素个数的二分之一，假设我们的总共有 16 个元素，对应各级索引元素个数应该是：

\n
1. 一级索引:16/2=8\n2. 二级索引:8/2 =4\n3. 三级索引:4/2=2
\n

由此我们用数学归纳法可知：

\n
1. 一级索引:16/2=16/2^1=8\n2. 二级索引:8/2 => 16/2^2 =4\n3. 三级索引:4/2=>16/2^3=2
\n

假设元素个数为 n，那么对应 k 层索引的元素个数 r 计算公式为:

\n
r=n/2^k
\n

同理我们再来推断以下索引的最大高度，一般来说最高级索引的元素个数为 2，我们设元素总个数为 n，索引高度为 h，代入上述公式可得：

\n
2= n/2^h\n=> 2*2^h=n\n=> 2^(h+1)=n\n=> h+1=log2^n\n=> h=log2^n -1
\n

而 Redis 又是内存数据库，我们假设元素最大个数是65536，我们把65536代入上述公式可知最大高度为 16。所以我们建议添加一个元素后为其建立的索引高度不超过 16。

\n

因为我们要求尽可能保证每一个上级索引都是下级索引的一半，在实现高度生成算法时，我们可以这样设计：

\n
    \n
  1. 跳表的高度计算从原始链表开始，即默认情况下插入的元素的高度为 1，代表没有索引，只有元素节点。
    2. \n
  2. 设计一个为插入元素生成节点索引高度 level 的方法。
    3. \n
  3. 进行一次随机运算，随机数值范围为 0-1 之间。
    4. \n
  4. 如果随机数大于 0.5 则为当前元素添加一级索引，自此我们保证生成一级索引的概率为 50% ，这也就保证了 1 级索引理想情况下只有一半的元素会生成索引。
    5. \n
  5. 同理后续每次随机算法得到的值大于 0.5 时，我们的索引高度就加 1，这样就可以保证节点生成的 2 级索引概率为 25% ，3 级索引为 12.5% ……
    6. \n
\n

我们回过头，上述插入 7 之后，我们通过随机算法得到 2，即要为其建立 1 级索引：

\n

\n

最后我们再来说说删除，假设我们这里要删除元素 10，我们必须定位到当前跳表各层元素小于 10 的最大值，索引执行步骤为：

\n
    \n
  1. 2 级索引 4 的后继节点为 8，指针推进。
    2. \n
  2. 索引 8 无后继节点，该层无要删除的元素，指针直接向下。
    3. \n
  3. 1 级索引 8 后继节点为 10，说明 1 级索引 8 在进行删除时需要将自己的指针和 1 级索引 10 断开联系，将 10 删除。
    4. \n
  4. 1 级索引完成定位后，指针向下，后继节点为 9，指针推进。
    5. \n
  5. 9 的后继节点为 10，同理需要让其指向 null，将 10 删除。
    6. \n
\n

\n

模板定义

\n

有了整体的思路之后，我们可以开始实现一个跳表了，首先定义一下跳表中的节点Node，从上文的演示中可以看出每一个Node它都包含以下几个元素：

\n
    \n
  1. 存储的value值。
    2. \n
  2. 后继节点的地址。
    3. \n
  3. 多级索引。
    4. \n
\n

为了更方便统一管理Node后继节点地址和多级索引指向的元素地址，笔者在Node中设置了一个forwards数组，用于记录原始链表节点的后继节点和多级索引的后继节点指向。

\n

以下图为例，我们forwards数组长度为 5，其中索引 0记录的是原始链表节点的后继节点地址，而其余自底向上表示从 1 级索引到 4 级索引的后继节点指向。

\n

\n

于是我们的就有了这样一个代码定义，可以看出笔者对于数组的长度设置为固定的 16**(上文的推算最大高度建议是 16)，默认data为-1，节点最大高度maxLevel初始化为 1，注意这个maxLevel**的值代表原始链表加上索引的总高度。

\n
/**\n * 跳表索引最大高度为16\n */\nprivate static final int MAX_LEVEL = 16;\n\nclass Node {\n    private int data = -1;\n    private Node[] forwards = new Node[MAX_LEVEL];\n    private int maxLevel = 0;\n\n}
\n

元素添加

\n

定义好节点之后，我们先实现以下元素的添加，添加元素时首先自然是设置data这一步我们直接根据将传入的value设置到data上即可。

\n

然后就是高度maxLevel的设置 ，我们在上文也已经给出了思路，默认高度为 1，即只有一个原始链表节点，通过随机算法每次大于 0.5 索引高度加 1，由此我们得出高度计算的算法randomLevel()：

\n
/**\n * 理论来讲，一级索引中元素个数应该占原始数据的 50%，二级索引中元素个数占 25%，三级索引12.5% ，一直到最顶层。\n * 因为这里每一层的晋升概率是 50%。对于每一个新插入的节点，都需要调用 randomLevel 生成一个合理的层数。\n * 该 randomLevel 方法会随机生成 1~MAX_LEVEL 之间的数，且 ：\n * 50%的概率返回 1\n * 25%的概率返回 2\n *  12.5%的概率返回 3 ...\n * @return\n */\nprivate int randomLevel() {\n    int level = 1;\n    while (Math.random() > PROB && level < MAX_LEVEL) {\n        ++level;\n    }\n    return level;\n}
\n

然后再设置当前要插入的Node和Node索引的后继节点地址，这一步稍微复杂一点，我们假设当前节点的高度为 4，即 1 个节点加 3 个索引，所以我们创建一个长度为 4 的数组maxOfMinArr ，遍历各级索引节点中小于当前value的最大值。

\n

假设我们要插入的value为 5，我们的数组查找结果当前节点的前驱节点和 1 级索引、2 级索引的前驱节点都为 4，三级索引为空。

\n

\n

然后我们基于这个数组maxOfMinArr 定位到各级的后继节点，让插入的元素 5 指向这些后继节点，而maxOfMinArr指向 5，结果如下图：

\n

\n

转化成代码就是下面这个形式，是不是很简单呢？我们继续：

\n
/**\n * 默认情况下的高度为1，即只有自己一个节点\n */\nprivate int levelCount = 1;\n\n/**\n * 跳表最底层的节点，即头节点\n */\nprivate Node h = new Node();\n\npublic void add(int value) {\n    int level = randomLevel(); // 新节点的随机高度\n\n    Node newNode = new Node();\n    newNode.data = value;\n    newNode.maxLevel = level;\n\n    // 用于记录每层前驱节点的数组\n    Node[] update = new Node[level];\n    for (int i = 0; i < level; i++) {\n        update[i] = h;\n    }\n\n    Node p = h;\n    // 关键修正：从跳表的当前最高层开始查找\n    for (int i = levelCount - 1; i >= 0; i--) {\n        while (p.forwards[i] != null && p.forwards[i].data < value) {\n            p = p.forwards[i];\n        }\n        // 只记录需要更新的层的前驱节点\n        if (i < level) {\n            update[i] = p;\n        }\n    }\n\n    // 插入新节点\n    for (int i = 0; i < level; i++) {\n        newNode.forwards[i] = update[i].forwards[i];\n        update[i].forwards[i] = newNode;\n    }\n\n    // 更新跳表的总高度\n    if (levelCount < level) {\n        levelCount = level;\n    }\n}
\n

元素查询

\n

查询逻辑比较简单，从跳表最高级的索引开始定位找到小于要查的 value 的最大值，以下图为例，我们希望查找到节点 8：

\n

\n\n

所以我们的代码实现也很上述步骤差不多，从最高级索引开始向前查找，如果不为空且小于要查找的值，则继续向前搜寻，遇到不小于的节点则继续向下，如此往复，直到得到当前跳表中小于查找值的最大节点，查看其前驱是否等于要查找的值：

\n
public Node get(int value) {\n    Node p = h; // 从头节点开始\n\n    // 从最高层级索引开始，逐层向下\n    for (int i = levelCount - 1; i >= 0; i--) {\n        // 在当前层级向右查找，直到 p.forwards[i] 为 null\n        // 或者 p.forwards[i].data 大于等于目标值 value\n        while (p.forwards[i] != null && p.forwards[i].data < value) {\n            p = p.forwards[i]; // 向右移动\n        }\n        // 此时 p.forwards[i] 为 null，或者 p.forwards[i].data >= value\n        // 或者 p 是当前层级中小于 value 的最大节点（如果存在这样的节点）\n    }\n\n    // 经过所有层级的查找，p 现在是原始链表（0级索引）中\n    // 小于目标值 value 的最大节点（或者头节点，如果所有元素都大于等于 value）\n\n    // 检查 p 在原始链表中的下一个节点是否是目标值\n    if (p.forwards[0] != null && p.forwards[0].data == value) {\n        return p.forwards[0]; // 找到了，返回该节点\n    }\n\n    return null; // 未找到\n}
\n

元素删除

\n

最后是删除逻辑，需要查找各层级小于要删除节点的最大值，假设我们要删除 10：

\n
    \n
  1. 3 级索引得到小于 10 的最大值为 5，继续向下。
    2. \n
  2. 2 级索引从索引 5 开始查找，发现小于 10 的最大值为 8，继续向下。
    3. \n
  3. 同理 1 级索引得到 8，继续向下。
    4. \n
  4. 原始节点找到 9。
    5. \n
  5. 从最高级索引开始，查看每个小于 10 的节点后继节点是否为 10，如果等于 10，则让这个节点指向 10 的后继节点，将节点 10 及其索引交由 GC 回收。
    6. \n
\n

\n
/**\n * 删除\n *\n * @param value\n */\npublic void delete(int value) {\n    Node p = h;\n    //找到各级节点小于value的最大值\n    Node[] updateArr = new Node[levelCount];\n    for (int i = levelCount - 1; i >= 0; i--) {\n        while (p.forwards[i] != null && p.forwards[i].data < value) {\n            p = p.forwards[i];\n        }\n        updateArr[i] = p;\n    }\n    //查看原始层节点前驱是否等于value，若等于则说明存在要删除的值\n    if (p.forwards[0] != null && p.forwards[0].data == value) {\n        //从最高级索引开始查看其前驱是否等于value，若等于则将当前节点指向value节点的后继节点\n        for (int i = levelCount - 1; i >= 0; i--) {\n            if (updateArr[i].forwards[i] != null && updateArr[i].forwards[i].data == value) {\n                updateArr[i].forwards[i] = updateArr[i].forwards[i].forwards[i];\n            }\n        }\n    }\n\n    //从最高级开始查看是否有一级索引为空，若为空则层级减1\n    while (levelCount > 1 && h.forwards[levelCount - 1] == null) {\n        levelCount--;\n    }\n\n}
\n

完整代码以及测试

\n

完整代码如下，读者可自行参阅:

\n
public class SkipList {\n\n    /**\n     * 跳表索引最大高度为16\n     */\n    private static final int MAX_LEVEL = 16;\n\n    /**\n     * 每个节点添加一层索引高度的概率为二分之一\n     */\n    private static final float PROB = 0.5f;\n\n    /**\n     * 默认情况下的高度为1，即只有自己一个节点\n     */\n    private int levelCount = 1;\n\n    /**\n     * 跳表最底层的节点，即头节点\n     */\n    private Node h = new Node();\n\n    public SkipList() {\n    }\n\n    public class Node {\n\n        private int data = -1;\n        /**\n         *\n         */\n        private Node[] forwards = new Node[MAX_LEVEL];\n        private int maxLevel = 0;\n\n        @Override\n        public String toString() {\n            return \"Node{\"\n                    + \"data=\" + data\n                    + \", maxLevel=\" + maxLevel\n                    + '}';\n        }\n    }\n\n    public void add(int value) {\n        int level = randomLevel(); // 新节点的随机高度\n\n        Node newNode = new Node();\n        newNode.data = value;\n        newNode.maxLevel = level;\n\n        // 用于记录每层前驱节点的数组\n        Node[] update = new Node[level];\n        for (int i = 0; i < level; i++) {\n            update[i] = h;\n        }\n\n        Node p = h;\n        // 关键修正：从跳表的当前最高层开始查找\n        for (int i = levelCount - 1; i >= 0; i--) {\n            while (p.forwards[i] != null && p.forwards[i].data < value) {\n                p = p.forwards[i];\n            }\n            // 只记录需要更新的层的前驱节点\n            if (i < level) {\n                update[i] = p;\n            }\n        }\n\n        // 插入新节点\n        for (int i = 0; i < level; i++) {\n            newNode.forwards[i] = update[i].forwards[i];\n            update[i].forwards[i] = newNode;\n        }\n\n        // 更新跳表的总高度\n        if (levelCount < level) {\n            levelCount = level;\n        }\n    }\n\n    /**\n     * 理论来讲，一级索引中元素个数应该占原始数据的 50%，二级索引中元素个数占 25%，三级索引12.5% ，一直到最顶层。\n     * 因为这里每一层的晋升概率是 50%。对于每一个新插入的节点，都需要调用 randomLevel 生成一个合理的层数。 该 randomLevel\n     * 方法会随机生成 1~MAX_LEVEL 之间的数，且 ： 50%的概率返回 1 25%的概率返回 2 12.5%的概率返回 3 ...\n     *\n     * @return\n     */\n    private int randomLevel() {\n        int level = 1;\n        while (Math.random() > PROB && level < MAX_LEVEL) {\n            ++level;\n        }\n        return level;\n    }\n\n    public Node get(int value) {\n        Node p = h;\n        //找到小于value的最大值\n        for (int i = levelCount - 1; i >= 0; i--) {\n            while (p.forwards[i] != null && p.forwards[i].data < value) {\n                p = p.forwards[i];\n            }\n        }\n        //如果p的前驱节点等于value则直接返回\n        if (p.forwards[0] != null && p.forwards[0].data == value) {\n            return p.forwards[0];\n        }\n\n        return null;\n    }\n\n    /**\n     * 删除\n     *\n     * @param value\n     */\n    public void delete(int value) {\n        Node p = h;\n        //找到各级节点小于value的最大值\n        Node[] updateArr = new Node[levelCount];\n        for (int i = levelCount - 1; i >= 0; i--) {\n            while (p.forwards[i] != null && p.forwards[i].data < value) {\n                p = p.forwards[i];\n            }\n            updateArr[i] = p;\n        }\n        //查看原始层节点前驱是否等于value，若等于则说明存在要删除的值\n        if (p.forwards[0] != null && p.forwards[0].data == value) {\n            //从最高级索引开始查看其前驱是否等于value，若等于则将当前节点指向value节点的后继节点\n            for (int i = levelCount - 1; i >= 0; i--) {\n                if (updateArr[i].forwards[i] != null && updateArr[i].forwards[i].data == value) {\n                    updateArr[i].forwards[i] = updateArr[i].forwards[i].forwards[i];\n                }\n            }\n        }\n\n        //从最高级开始查看是否有一级索引为空，若为空则层级减1\n        while (levelCount > 1 && h.forwards[levelCount - 1] == null) {\n            levelCount--;\n        }\n\n    }\n\n    public void printAll() {\n        Node p = h;\n        //基于最底层的非索引层进行遍历，只要后继节点不为空，则速速出当前节点，并移动到后继节点\n        while (p.forwards[0] != null) {\n            System.out.println(p.forwards[0]);\n            p = p.forwards[0];\n        }\n\n    }\n}
\n

测试代码：

\n
public static void main(String[] args) {\n        SkipList skipList = new SkipList();\n        for (int i = 0; i < 24; i++) {\n            skipList.add(i);\n        }\n\n        System.out.println(\"**********输出添加结果**********\");\n        skipList.printAll();\n\n        SkipList.Node node = skipList.get(22);\n        System.out.println(\"**********查询结果:\" + node+\" **********\");\n\n        skipList.delete(22);\n        System.out.println(\"**********删除结果**********\");\n        skipList.printAll();\n\n\n    }
\n

Redis 跳表的特点：

\n
    \n
  1. 采用双向链表，不同于上面的示例，存在一个回退指针。主要用于简化操作，例如删除某个元素时，还需要找到该元素的前驱节点，使用回退指针会非常方便。
    2. \n
  2. score 值可以重复，如果 score 值一样，则按照 ele（节点存储的值，为 sds）字典排序
    3. \n
  3. Redis 跳跃表默认允许最大的层数是 32，被源码中 ZSKIPLIST_MAXLEVEL 定义。
    4. \n
\n

和其余三种数据结构的比较

\n

最后，我们再来回答一下文章开头的那道面试题: “Redis 的有序集合底层为什么要用跳表，而不用平衡树、红黑树或者 B+树？”。

\n

平衡树 vs 跳表

\n

先来说说它和平衡树的比较，平衡树我们又会称之为 AVL 树，是一个严格的平衡二叉树，平衡条件必须满足（所有节点的左右子树高度差不超过 1，即平衡因子为范围为 [-1,1]）。平衡树的插入、删除和查询的时间复杂度和跳表一样都是 O(log n) 。

\n

对于范围查询来说，它也可以通过中序遍历的方式达到和跳表一样的效果。但是它的每一次插入或者删除操作都需要保证整颗树左右节点的绝对平衡，只要不平衡就要通过旋转操作来保持平衡，这个过程是比较耗时的。

\n

\n

跳表诞生的初衷就是为了克服平衡树的一些缺点，跳表的发明者在论文《Skip lists: a probabilistic alternative to balanced trees》中有详细提到：

\n

\n
\n

Skip lists are a data structure that can be used in place of balanced trees. Skip lists use probabilistic balancing rather than strictly enforced balancing and as a result the algorithms for insertion and deletion in skip lists are much simpler and significantly faster than equivalent algorithms for balanced trees.

\n

跳表是一种可以用来代替平衡树的数据结构。跳表使用概率平衡而不是严格强制的平衡，因此，跳表中的插入和删除算法比平衡树的等效算法简单得多，速度也快得多。

\n
\n

笔者这里也贴出了 AVL 树插入操作的核心代码，可以看出每一次添加操作都需要进行一次递归定位插入位置，然后还需要根据回溯到根节点检查沿途的各层节点是否失衡，再通过旋转节点的方式进行调整。

\n
// 向二分搜索树中添加新的元素(key, value)\npublic void add(K key, V value) {\n    root = add(root, key, value);\n}\n\n// 向以node为根的二分搜索树中插入元素(key, value)，递归算法\n// 返回插入新节点后二分搜索树的根\nprivate Node add(Node node, K key, V value) {\n\n    if (node == null) {\n        size++;\n        return new Node(key, value);\n    }\n\n    if (key.compareTo(node.key) < 0)\n        node.left = add(node.left, key, value);\n    else if (key.compareTo(node.key) > 0)\n        node.right = add(node.right, key, value);\n    else // key.compareTo(node.key) == 0\n        node.value = value;\n\n    node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));\n\n    int balanceFactor = getBalanceFactor(node);\n\n    // LL型需要右旋\n    if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {\n        return rightRotate(node);\n    }\n\n    //RR型失衡需要左旋\n    if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {\n        return leftRotate(node);\n    }\n\n    //LR需要先左旋成LL型，然后再右旋\n    if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {\n        node.left = leftRotate(node.left);\n        return rightRotate(node);\n    }\n\n    //RL\n    if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {\n        node.right = rightRotate(node.right);\n        return leftRotate(node);\n    }\n    return node;\n}
\n

红黑树 vs 跳表

\n

红黑树（Red Black Tree）也是一种自平衡二叉查找树，它的查询性能略微逊色于 AVL 树，但插入和删除效率更高。红黑树的插入、删除和查询的时间复杂度和跳表一样都是 O(log n) 。

\n

红黑树是一个黑平衡树，即从任意节点到另外一个叶子叶子节点，它所经过的黑节点是一样的。当对它进行插入操作时，需要通过旋转和染色（红黑变换）来保证黑平衡。不过，相较于 AVL 树为了维持平衡的开销要小一些。关于红黑树的详细介绍，可以查看这篇文章：红黑树。

\n

相比较于红黑树来说，跳表的实现也更简单一些。并且，按照区间来查找数据这个操作，红黑树的效率没有跳表高。

\n

\n

对应红黑树添加的核心代码如下，读者可自行参阅理解：

\n
private Node < K, V > add(Node < K, V > node, K key, V val) {\n\n    if (node == null) {\n        size++;\n        return new Node(key, val);\n\n    }\n\n    if (key.compareTo(node.key) < 0) {\n        node.left = add(node.left, key, val);\n    } else if (key.compareTo(node.key) > 0) {\n        node.right = add(node.right, key, val);\n    } else {\n        node.val = val;\n    }\n\n    //左节点不为红，右节点为红，左旋\n    if (isRed(node.right) && !isRed(node.left)) {\n        node = leftRotate(node);\n    }\n\n    //左链右旋\n    if (isRed(node.left) && isRed(node.left.left)) {\n        node = rightRotate(node);\n    }\n\n    //颜色翻转\n    if (isRed(node.left) && isRed(node.right)) {\n        flipColors(node);\n    }\n\n    return node;\n}
\n

B+树 vs 跳表

\n

想必使用 MySQL 的读者都知道 B+树这个数据结构，B+树是一种常用的数据结构，具有以下特点：

\n
    \n
  1. 多叉树结构：它是一棵多叉树，每个节点可以包含多个子节点，减小了树的高度，查询效率高。
    2. \n
  2. 存储效率高:其中非叶子节点存储多个 key，叶子节点存储 value，使得每个节点更够存储更多的键，根据索引进行范围查询时查询效率更高。-
    3. \n
  3. 平衡性：它是绝对的平衡，即树的各个分支高度相差不大，确保查询和插入时间复杂度为 O(log n) 。
    4. \n
  4. 顺序访问：叶子节点间通过链表指针相连，范围查询表现出色。
    5. \n
  5. 数据均匀分布：B+树插入时可能会导致数据重新分布，使得数据在整棵树分布更加均匀，保证范围查询和删除效率。
    6. \n
\n

\n

所以，B+树更适合作为数据库和文件系统中常用的索引结构之一，它的核心思想是通过可能少的 IO 定位到尽可能多的索引来获得查询数据。对于 Redis 这种内存数据库来说，它对这些并不感冒，因为 Redis 作为内存数据库它不可能存储大量的数据，所以对于索引不需要通过 B+树这种方式进行维护，只需按照概率进行随机维护即可，节约内存。而且使用跳表实现 zset 时相较前者来说更简单一些，在进行插入时只需通过索引将数据插入到链表中合适的位置再随机维护一定高度的索引即可，也不需要像 B+树那样插入时发现失衡时还需要对节点分裂与合并。

\n

Redis 作者给出的理由

\n

当然我们也可以通过 Redis 的作者自己给出的理由:

\n
\n

There are a few reasons:
\n1、They are not very memory intensive. It's up to you basically. Changing parameters about the probability of a node to have a given number of levels will make then less memory intensive than btrees.
\n2、A sorted set is often target of many ZRANGE or ZREVRANGE operations, that is, traversing the skip list as a linked list. With this operation the cache locality of skip lists is at least as good as with other kind of balanced trees.
\n3、They are simpler to implement, debug, and so forth. For instance thanks to the skip list simplicity I received a patch (already in Redis master) with augmented skip lists implementing ZRANK in O(log(N)). It required little changes to the code.

\n
\n

翻译过来的意思就是:

\n
\n

有几个原因：

\n

1、它们不是很占用内存。这主要取决于你。改变节点拥有给定层数的概率的参数，会使它们比 B 树更节省内存。

\n

2、有序集合经常是许多 ZRANGE 或 ZREVRANGE 操作的目标，也就是说，以链表的方式遍历跳表。通过这种操作，跳表的缓存局部性至少和其他类型的平衡树一样好。

\n

3、它们更容易实现、调试等等。例如，由于跳表的简单性，我收到了一个补丁（已经在 Redis 主分支中），用增强的跳表实现了 O(log(N))的 ZRANK。它只需要对代码做很少的修改。

\n
\n

小结

\n

本文通过大量篇幅介绍跳表的工作原理和实现，帮助读者更进一步的熟悉跳表这一数据结构的优劣，最后再结合各个数据结构操作的特点进行比对，从而帮助读者更好的理解这道面试题，建议读者实现理解跳表时，尽可能配合执笔模拟来了解跳表的增删改查详细过程。

\n

参考

\n\n", "image": "https://oss.javaguide.cn/javaguide/database/redis/skiplist/202401222005468.png", "date_published": "2024-01-29T16:10:36.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "访问网页的全过程（知识串联）", "url": "https://javaguide.cn/cs-basics/network/the-whole-process-of-accessing-web-pages.html", "id": "https://javaguide.cn/cs-basics/network/the-whole-process-of-accessing-web-pages.html", "summary": "串联从输入 URL 到页面渲染的完整链路，涵盖 DNS、TCP、HTTP 与静态资源加载，助力面试与实践理解。", "content_html": "

开发岗中总是会考很多计算机网络的知识点，但如果让面试官只考一道题，便涵盖最多的计网知识点，那可能就是 网页浏览的全过程 了。本篇文章将带大家从头到尾过一遍这道被考烂的面试题，必会！！！

\n

总的来说，网络通信模型可以用下图来表示，也就是大家只要熟记网络结构五层模型，按照这个体系，很多知识点都能顺出来了。访问网页的过程也是如此。

\n

\n

开始之前，我们先简单过一遍完整流程：

\n
    \n
  1. 在浏览器中输入指定网页的 URL。
    2. \n
  2. 浏览器通过 DNS 协议，获取域名对应的 IP 地址。
    3. \n
  3. 浏览器根据 IP 地址和端口号，向目标服务器发起一个 TCP 连接请求。
    4. \n
  4. 浏览器在 TCP 连接上，向服务器发送一个 HTTP 请求报文，请求获取网页的内容。
    5. \n
  5. 服务器收到 HTTP 请求报文后，处理请求，并返回 HTTP 响应报文给浏览器。
    6. \n
  6. 浏览器收到 HTTP 响应报文后，解析响应体中的 HTML 代码，渲染网页的结构和样式，同时根据 HTML 中的其他资源的 URL（如图片、CSS、JS 等），再次发起 HTTP 请求，获取这些资源的内容，直到网页完全加载显示。
    7. \n
  7. 浏览器在不需要和服务器通信时，可以主动关闭 TCP 连接，或者等待服务器的关闭请求。
    8. \n
\n

应用层

\n

一切的开始——打开浏览器，在地址栏输入 URL，回车确认。那么，什么是 URL？访问 URL 有什么用？

\n

URL

\n

URL（Uniform Resource Locators），即统一资源定位器。网络上的所有资源都靠 URL 来定位，每一个文件就对应着一个 URL，就像是路径地址。理论上，文件资源和 URL 一一对应。实际上也有例外，比如某些 URL 指向的文件已经被重定位到另一个位置，这样就有多个 URL 指向同一个文件。

\n

URL 的组成结构

\n

\"URL的组成结构\"

\n
    \n
  1. 协议。URL 的前缀通常表示了该网址采用了何种应用层协议，通常有两种——HTTP 和 HTTPS。当然也有一些不太常见的前缀头，比如文件传输时用到的ftp:。
    2. \n
  2. 域名。域名便是访问网址的通用名，这里也有可能是网址的 IP 地址，域名可以理解为 IP 地址的可读版本，毕竟绝大部分人都不会选择记住一个网址的 IP 地址。
    3. \n
  3. 端口。如果指明了访问网址的端口的话，端口会紧跟在域名后面，并用一个冒号隔开。
    4. \n
  4. 资源路径。域名（端口）后紧跟的就是资源路径，从第一个/开始，表示从服务器上根目录开始进行索引到的文件路径，上图中要访问的文件就是服务器根目录下/path/to/myfile.html。早先的设计是该文件通常物理存储于服务器主机上，但现在随着网络技术的进步，该文件不一定会物理存储在服务器主机上，有可能存放在云上，而文件路径也有可能是虚拟的（遵循某种规则）。
    5. \n
  5. 参数。参数是浏览器在向服务器提交请求时，在 URL 中附带的参数。服务器解析请求时，会提取这些参数。参数采用键值对的形式key=value，每一个键值对使用&隔开。参数的具体含义和请求操作的具体方法有关。
    6. \n
  6. 锚点。锚点顾名思义，是在要访问的页面上的一个锚。要访问的页面大部分都多于一页，如果指定了锚点，那么在客户端显示该网页是就会定位到锚点处，相当于一个小书签。值得一提的是，在 URL 中，锚点以#开头，并且不会作为请求的一部分发送给服务端。
    7. \n
\n

DNS

\n

键入了 URL 之后，第一个重头戏登场——DNS 服务器解析。DNS（Domain Name System）域名系统，要解决的是 域名和 IP 地址的映射问题 。毕竟，域名只是一个网址便于记住的名字，而网址真正存在的地址其实是 IP 地址。

\n

传送门：DNS 域名系统详解（应用层）

\n

HTTP/HTTPS

\n

利用 DNS 拿到了目标主机的 IP 地址之后，浏览器便可以向目标 IP 地址发送 HTTP 报文，请求需要的资源了。在这里，根据目标网站的不同，请求报文可能是 HTTP 协议或安全性增强的 HTTPS 协议。

\n

传送门：

\n\n

传输层

\n

由于 HTTP 协议是基于 TCP 协议的，在应用层的数据封装好以后，要交给传输层，经 TCP 协议继续封装。

\n

TCP 协议保证了数据传输的可靠性，是数据包传输的主力协议。

\n

传送门：

\n\n

网络层

\n

终于，来到网络层，此时我们的主机不再是和另一台主机进行交互了，而是在和中间系统进行交互。也就是说，应用层和传输层都是端到端的协议，而网络层及以下都是中间件的协议了。

\n

网络层的核心功能——转发与路由，必会！！！如果面试官问到了网络层，而你恰好又什么都不会的话，最最起码要说出这五个字——转发与路由。

\n\n

所以到目前为止，我们的数据包经过了应用层、传输层的封装，来到了网络层，终于开始准备在物理层面传输了，第一个要解决的问题就是——往哪里传输？或者说，要把数据包发到哪个路由器上？ 这便是 BGP 协议要解决的问题。

\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/network/five-layers.png", "date_published": "2024-01-29T14:06:19.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "美团三年，总结的10条血泪教训", "url": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/meituan-three-year-summary-lesson-10.html", "id": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/meituan-three-year-summary-lesson-10.html", "summary": "美团三年，总结的10条血泪教训：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：作者用了很多生动的例子和故事展示了自己在美团的成长和感悟，看了之后受益颇多！

\n

内容概览：

\n

本文的作者提出了以下十条建议，希望能对其他职场人有所启发和帮助：

\n
    \n
  1. 结构化思考与表达，提高个人影响力
    2. \n
  2. 忘掉职级，该怼就怼，推动事情往前走
    3. \n
  3. 用好平台资源，结识优秀的人，学习通识课
    4. \n
  4. 一切都是争取来的，不要等待机会，要主动寻求
    5. \n
  5. 关注商业，升维到老板思维，看清趋势，及时止损
    6. \n
  6. 培养数据思维，利用数据了解世界，指导决策
    7. \n
  7. 做一个好"销售"，无论是自己还是产品，都要学会展示和说服
    8. \n
  8. 少加班多运动，保持身心健康，提高工作效率
    9. \n
  9. 有随时可以离开的底气，不要被职场所困，借假修真，提升自己
    10. \n
  10. 只是一份工作，不要过分纠结，相信自己，走出去看看
    11. \n
\n

原文地址：https://mp.weixin.qq.com/s/XidSVIwd4oKkDKEICaY1mQ

\n
\n

在美团的三年多时光，如同一部悠长的交响曲，高高低低，而今离开已有一段时间。闲暇之余，梳理了三年多的收获与感慨，总结成 10 条，既是对过去一段时光的一个深情回眸，也是对未来之路的一份期许。

\n

倘若一些感悟能为刚步入职场的年轻人，或是刚在职业生涯中崭露头角的后起之秀，带来一点点启示与帮助，也是莫大的荣幸。

\n

01 结构化思考与表达

\n

美团是一家特别讲究方法论的公司，人人都要熟读四大名著《高效能人士的七个习惯》、《金字塔原理》、《用图表说话》和《学会提问》。

\n

与结构化思考和表达相关的，是《金字塔原理》，作者是麦肯锡公司第一位女性咨询顾问。这本书告诉我们，思考和表达的过程，就像构建金字塔（或者构建一棵树），先有整体结论，再寻找证据，证据之间要讲究相互独立、而且能穷尽（MECE 原则），论证的过程也要按特定的顺序进行，比如时间顺序、空间顺序、重要性顺序……

\n

作为大厂社畜，日常很大一部分工作就是写文档、看别人文档。大家做的事，但最后呈现的结果却有很大差异。一篇逻辑清晰、详略得当的文档，给人一种如沐春风的感受，能提炼出重要信息，是好的参考指南。

\n

结构化思考与表达算是职场最通用的能力，也是打造个人影响力最重要的途径之一。

\n

02 忘掉职级，该怼就怼

\n

在阿里工作时，能看到每个人的 Title，看到江湖地位高（职级高+入职时间早）的同学，即便跟自己没有汇报关系，不自然的会多一层敬畏。推进工作时，会多一层压力，对方未读或已读未回时，不知如何应对。

\n

美团只能看到每个人的坑位信息，还有 Ta 的上级。工作相关的问题，可以向任何人提问，如果协同方没有及时响应，隔段时间@一次，甚至"怼一怼"，都没啥问题，事情一直往前推进才最重要。除了大象消息直接提问外，还有个大杀器--TT（公司级问题流转系统），在上面提问时，加上对方主管，如果对方未及时回应，问题会自动升级，每天定时 Push，直到解决为止。

\n

我见到一些很年轻的同事，他们在推动 OKR、要资源的事上，很有一套，只要能达到自己的目标，不会考虑别人的感受，最终，他们还真能把事办成。

\n

当然了，段位越高的人，越能用自己的人格魅力、影响力、资源等，去影响和推动事情的进程，而不是靠对他人的 Push。只是在拿结果的事上，不要把自己太当回事，把别人太当回事，大家在一起，也只是为了完成各自的任务，忘掉职级，该怼时还得怼。

\n

03 用好平台资源

\n

没有人能在一家公司待一辈子，公司再牛，跟自己关系不大，重要的是，在有限的时间内，最大化用好平台资源。

\n

在美团除了认识自己节点的同事外，有幸认识一群特别棒的协作方，还有其他 BU 的同学。

\n

这些优秀的人身上，有很多共同的特质：谦虚、利他、乐于分享、双赢思维。

\n

有两位做运营的同学。

\n

一位是无意中关注他公众号结识上的。他公众号记录了很多职场成长、家庭建造上的思考和收获，还有定期个人复盘。他和太太都是大厂中层管理者，从文章中看到的不是他多厉害，而是非常接地气的故事。我们约饭了两次，有很多共同话题，现在还时不时有一些互动。

\n

一位职级更高的同学，他在内网发起了一个"请我喝一杯咖啡，和我一起聊聊个人困惑"的活动，我报名参与了一期。和他聊天的过程，特别像是一场教练对话（最近学习教练课程时才感受到的），帮我排除干扰、聚焦目标的同时，也从他分享个人成长蜕变的过程，收获很多动力。（刚好自己最近也学习了教练技术，后面也准备采用类似的方式，去帮助曾经像我一样迷茫的人）

\n

还有一些协作方同学。他们工作做得超级到位，能感受到，他们在乎他人时间；稍微有点出彩的事儿，不忘记拉上更多人。利他和双赢思维，在他们身上是最好的阐释。

\n

除了结识优秀的人，向他们学习外，还可以关注各个通道/工种的课程资源。

\n

在大厂，多数人的角色都是螺丝钉，但千万不要局限于做一颗螺丝钉。多去学习一些通识课，了解商业交付的各个环节，看清商业世界，明白自己的定位，超越自己的定位。

\n

04 一切都是争取来的

\n

工作很多年了，很晚才明白这个道理。

\n

之前一直认为，只要做好自己该做的，一定会被看见，被赏识，也会得到更多机会。但很多时候，这只是个人的一厢情愿。除了自己，不会有人关心你的权益。

\n

社会主义初级阶段，我国国内的主要矛盾是人民日益增长的物质文化需要同落后的社会生产之间的矛盾。无论在哪里，资源都是稀缺的，自己在乎的，就得去争取。

\n

想成长某个技能、想参与哪个模块、想做哪个项目，升职加薪……自己不提，不去争取，不会有人主动给你。

\n

争不争取是一回事，能不能得到是一回事，只有争取，才有可能得到。争取了，即便没有得到，最终也没失去什么。

\n

05 关注商业

\n

大公司，极度关注效率，大部分岗位，拆解的粒度越细，效率会越高，这些对组织是有利的。但对个人来说，则很容易螺丝钉化。

\n

做技术的同学，更是这样。

\n

做前端的同学，不会关注数据是如何落库的；做后端的同学，不会思考页面是否存在兼容性问题；做业务开发的，不用考虑微服务诸多中间件是如何搭建起来的……

\n

大部分人都想着怎么把自己这摊子事搞好，不会去思考上下游同学在做些什么，更少有人真正关注商业，关心公司的盈利模式，关心每一次产品迭代到底带来哪些业务价值。

\n

把手头的事做好是应该的，但绝不能停留在此。所有的产品，只有在商业社会产生交付，让客户真正获益，才是有价值的。

\n

关注商业，能帮我们升维到老板思维，明白投入产出比，抓大放小；也帮助我们，在碰到不好的业务时，及时止损；更重要的是，它帮助我们真正看清趋势，提前做好准备。

\n

《五分钟商学院》系列，是很好的商业入门级书籍。尽管作者刘润最近存在争议，但不可否认，他比我们大多数人段位还是高很多，他的书值得一读。

\n

06 培养数据思维

\n

当今数字化时代，数据思维显得尤为重要。数据不仅可以帮助我们更好地了解世界，还可以指导我们的决策和行动。

\n

非常幸运的是，在阿里和美团的两份经历，都是做商业化广告业务，在离钱💰最近的地方，也培养了数据的敏感性。见过商业数据指标的定义、加工、生产和应用全流程，也在不断熏陶下，能看懂大部分指标背后的价值。

\n

除了直接面向业务的数据，还有研发协作全流程产生的数据。数据被记录和汇总统计后，能直观地看到每个环节的效率和质量。螺丝钉们的工作，也彻彻底底被数字量化，除了积极面对虚拟化、线上化、数字化外，我们别无他法。

\n

受工作数据化的影响，生活中，我也渐渐变成了一个数据记录狂，日常运动（骑行、跑步、健走等）必须通过智能手表记录下来，没带 Apple Watch，感觉这次白运动了。每天也在很努力地完成三个圆环。

\n

数据时代，我们沦为了透明人。也得益于数据被记录和分析，我们做任何事，都能快速得到反馈，这也是自我提升的一个重要环节。

\n

07 做一个好"销售"

\n

就某种程度来说，所有的工作，本质都是销售。

\n

这是很多大咖的观点，我也是很晚才明白这个道理。

\n

我们去一家公司应聘，本质上是在讲一个「我很牛」的故事，销售的是自己；日常工作汇报、季度/年度述职、晋升答辩，是在销售自己；在任何一个场合曝光，也是在销售自己。

\n

如果我们所服务的组织，对外提供的是一件产品或一项服务，所有上下游协作的同学，唯一在做的事就是，齐心协力把产品/服务卖出去， 我们本质做的还是销售。

\n

所以， 千万不要看不起任何销售，也不要认为认为销售是一件很丢面子的事。

\n

真正的大佬，随时随地都在销售。

\n

08 少加班多运动

\n

在职场，大家都认同一个观点，工作是做不完的。

\n

我们要做的是，用好时间管理四象限法，识别重要程度和优先级，有限时间，聚焦在固定几件事上。

\n

这要求我们不断提高自己的问题识别能力、拆解能力，还有专注力。

\n

我们会因为部分项目的需要而加班，但不会长期加班。

\n

加班时间短一点，就能腾出更多时间运动。

\n

最近一次线下培训课，认识一位老师 Hubert，Hubert 是一位超级有魅力的中年大叔（可以通过「有意思教练」的课程链接到他），从外企高管的位置离开后，和太太一起创办了一家培训机构。作为公司高层，日常工作非常忙，头发也有些花白了，但一身腱子肉胜过很多健身教练，给人的状态也是很年轻。聊天得知，Hubert 经常 5 点多起来泡健身房~

\n

我身边还有一些同事，跟我年龄差不多，因为长期加班，发福严重，比实际年龄看起来苍老 10+岁；

\n

还有同事曾经加班进 ICU，幸好后面身体慢慢恢复过来。

\n

某某厂员工长期加班猝死的例子，更是屡见不鲜。

\n

减少加班，增加运动，绝对是一件性价比极高的事。

\n

09 有随时可以离开的底气

\n

当今职场，跟父辈时候完全不一样，职业的多样性和变化性越来越快，很少有人能够在同一份工作或同一个公司待一辈子。除了某些特定的岗位，如公务员、事业单位等，大多数人都会在职业生涯中经历多次的职业变化和调整。

\n

在商业组织里，个体是弱势群体，但不要做弱者。每一段职场，每一项工作，都是上天给我们的修炼。

\n

我很喜欢"借假修真"这个词。我们参与的大大小小的项目， 重要吗？对公司来说可能重要，对个人来说，则未必。我们去做，一方面是迫于生计；

\n

另外一方面，参与每个项目的感悟、心得、体会，是真实存在的，很多的能力，都是在这个过程得到提升。

\n

明白这一点，就不会被职场所困，会刻意在各样事上提升自己，积累的越多，对事务的本质理解的越深、越广，也越发相信很多底层知识是通用的，内心越平静，也会建立起随时都可以离开的底气。

\n

10 只是一份工作

\n

工作中，我们时常会遇到各种挑战和困难，如发展瓶颈、难以处理的人和事，甚至职场 PUA 等。这些经历可能会让我们感到疲惫、沮丧，甚至怀疑自己的能力和价值。然而，重要的是要明白，困难只是成长道路上的暂时阻碍，而不是我们的定义。

\n

写总结和复盘是很好的方式，可以帮我们理清思路，找到问题的根源，并学习如何应对类似的情况。但也要注意不要陷入自我怀疑和内耗的陷阱。遇到困难时，应该学会相信自己，积极寻找解决问题的方法，而不是过分纠结于自己的不足和错误。

\n

内网常有同学匿名分享工作压力过大，常常失眠甚至中度抑郁，每次看到这些话题，非常难过。大环境不好，是不争的事实，但并不代表个体就没有出路。

\n

我们容易预设困难，容易加很多"可是"，当窗户布满灰尘时，不要试图努力把窗户擦干净，走出去吧，你将看到一片蔚蓝的天空。

\n

最后

\n

写到最后，特别感恩美团三年多的经历。感谢我的 Leader 们，感谢曾经并肩作战过的小伙伴，感谢遇到的每一位和我一样在平凡的岗位，努力想带给身边一片微光的同学。所有的相遇，都是缘分。

\n", "date_published": "2023-12-17T07:37:37.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [ { "name": "CityDreamer部落" } ], "tags": [ "技术文章精选集" ] }, { "title": "程序员如何快速学习新技术", "url": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/programmer-quickly-learn-new-technology.html", "id": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/programmer-quickly-learn-new-technology.html", "summary": "程序员如何快速学习新技术：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：这是《Java 面试指北》练级攻略篇中的一篇文章，分享了我对于如何快速学习一门新技术的看法。

\n

\"《Java

\n
\n

很多时候，我们因为工作原因需要快速学习某项技术，进而在项目中应用。或者说，我们想要去面试的公司要求的某项技术我们之前没有接触过，为了应对面试需要，我们需要快速掌握这项技术。

\n

作为一个人纯自学出生的程序员，这篇文章简单聊聊自己对于如何快速学习某项技术的看法。

\n

学习任何一门技术的时候，一定要先搞清楚这个技术是为了解决什么问题的。深入学习这个技术的之前，一定先从全局的角度来了解这个技术，思考一下它是由哪些模块构成的，提供了哪些功能，和同类的技术想必它有什么优势。

\n

比如说我们在学习 Spring 的时候，通过 Spring 官方文档你就可以知道 Spring 最新的技术动态，Spring 包含哪些模块 以及 Spring 可以帮你解决什么问题。

\n

\n

再比如说我在学习消息队列的时候，我会先去了解这个消息队列一般在系统中有什么作用，帮助我们解决了什么问题。消息队列的种类很多，具体学习研究某个消息队列的时候，我会将其和自己已经学习过的消息队列作比较。像我自己在学习 RocketMQ 的时候，就会先将其和自己曾经学习过的第 1 个消息队列 ActiveMQ 进行比较，思考 RocketMQ 相对于 ActiveMQ 有了哪些提升，解决了 ActiveMQ 的哪些痛点，两者有哪些相似的地方，又有哪些不同的地方。

\n

学习一个技术最有效最快的办法就是将这个技术和自己之前学到的技术建立连接，形成一个网络。

\n

然后，我建议你先去看看官方文档的教程，运行一下相关的 Demo ，做一些小项目。

\n

不过，官方文档通常是英文的，通常只有国产项目以及少部分国外的项目提供了中文文档。并且，官方文档介绍的往往也比较粗糙，不太适合初学者作为学习资料。

\n

如果你看不太懂官网的文档，你也可以搜索相关的关键词找一些高质量的博客或者视频来看。 一定不要一上来就想着要搞懂这个技术的原理。

\n

就比如说我们在学习 Spring 框架的时候，我建议你在搞懂 Spring 框架所解决的问题之后，不是直接去开始研究 Spring 框架的原理或者源码，而是先实际去体验一下 Spring 框架提供的核心功能 IoC（Inverse of Control:控制反转） 和 AOP(Aspect-Oriented Programming:面向切面编程)，使用 Spring 框架写一些 Demo，甚至是使用 Spring 框架做一些小项目。

\n

一言以蔽之， 在研究这个技术的原理之前，先要搞懂这个技术是怎么使用的。

\n

这样的循序渐进的学习过程，可以逐渐帮你建立学习的快感，获得即时的成就感，避免直接研究原理性的知识而被劝退。

\n

研究某个技术原理的时候，为了避免内容过于抽象，我们同样可以动手实践。

\n

比如说我们学习 Tomcat 原理的时候，我们发现 Tomcat 的自定义线程池挺有意思，那我们自己也可以手写一个定制版的线程池。再比如我们学习 Dubbo 原理的时候，可以自己动手造一个简易版的 RPC 框架。

\n

另外，学习项目中需要用到的技术和面试中需要用到的技术其实还是有一些差别的。

\n

如果你学习某一项技术是为了在实际项目中使用的话，那你的侧重点就是学习这项技术的使用以及最佳实践，了解这项技术在使用过程中可能会遇到的问题。你的最终目标就是这项技术为项目带来了实际的效果，并且，这个效果是正面的。

\n

如果你学习某一项技术仅仅是为了面试的话，那你的侧重点就应该放在这项技术在面试中最常见的一些问题上，也就是我们常说的八股文。

\n

很多人一提到八股文，就是一脸不屑。在我看来，如果你不是死记硬背八股文，而是去所思考这些面试题的本质。那你在准备八股文的过程中，同样也能让你加深对这项技术的了解。

\n

最后，最重要同时也是最难的还是 知行合一！知行合一！知行合一！ 不论是编程还是其他领域，最重要不是你知道的有多少，而是要尽量做到知行合一。

\n", "image": "https://oss.javaguide.cn/javamianshizhibei/training-strategy-articles.png", "date_published": "2023-11-09T08:24:19.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "技术文章精选集" ] }, { "title": "经典算法思想总结（含LeetCode题目推荐）", "url": "https://javaguide.cn/cs-basics/algorithms/classical-algorithm-problems-recommendations.html", "id": "https://javaguide.cn/cs-basics/algorithms/classical-algorithm-problems-recommendations.html", "summary": "总结常见算法思想与解题模板，配合典型题目推荐，强调思维路径与复杂度权衡，快速构建解题体系。", "content_html": "

贪心算法

\n

算法思想

\n

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

\n

一般解题步骤

\n\n

LeetCode

\n

455.分发饼干：https://leetcode.cn/problems/assign-cookies/

\n

121.买卖股票的最佳时机：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/

\n

122.买卖股票的最佳时机 II：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/

\n

55.跳跃游戏：https://leetcode.cn/problems/jump-game/

\n

45.跳跃游戏 II：https://leetcode.cn/problems/jump-game-ii/

\n

动态规划

\n

算法思想

\n

动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的。

\n

经典题目：01 背包、完全背包

\n

一般解题步骤

\n\n

LeetCode

\n

509.斐波那契数：https://leetcode.cn/problems/fibonacci-number/

\n

746.使用最小花费爬楼梯：https://leetcode.cn/problems/min-cost-climbing-stairs/

\n

416.分割等和子集：https://leetcode.cn/problems/partition-equal-subset-sum/

\n

518.零钱兑换：https://leetcode.cn/problems/coin-change-ii/

\n

647.回文子串：https://leetcode.cn/problems/palindromic-substrings/

\n

516.最长回文子序列：https://leetcode.cn/problems/longest-palindromic-subsequence/

\n

回溯算法

\n

算法思想

\n

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条

\n

件时，就“回溯”返回，尝试别的路径。其本质就是穷举。

\n

经典题目：8 皇后

\n

一般解题步骤

\n\n

leetcode

\n

77.组合：https://leetcode.cn/problems/combinations/

\n

39.组合总和：https://leetcode.cn/problems/combination-sum/

\n

40.组合总和 II：https://leetcode.cn/problems/combination-sum-ii/

\n

78.子集：https://leetcode.cn/problems/subsets/

\n

90.子集 II：https://leetcode.cn/problems/subsets-ii/

\n

51.N 皇后：https://leetcode.cn/problems/n-queens/

\n

分治算法

\n

算法思想

\n

将一个规模为 N 的问题分解为 K 个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。

\n

经典题目：二分查找、汉诺塔问题

\n

一般解题步骤

\n\n

LeetCode

\n

108.将有序数组转换成二叉搜索数：https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/

\n

148.排序列表：https://leetcode.cn/problems/sort-list/

\n

23.合并 k 个升序链表：https://leetcode.cn/problems/merge-k-sorted-lists/

\n", "date_published": "2023-10-28T10:18:37.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "常见数据结构经典LeetCode题目推荐", "url": "https://javaguide.cn/cs-basics/algorithms/common-data-structures-leetcode-recommendations.html", "id": "https://javaguide.cn/cs-basics/algorithms/common-data-structures-leetcode-recommendations.html", "summary": "按数据结构类别整理经典 LeetCode 题目清单，聚焦高频与核心考点，助力系统化刷题与巩固。", "content_html": "

数组

\n

704.二分查找：https://leetcode.cn/problems/binary-search/

\n

80.删除有序数组中的重复项 II：https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii

\n

977.有序数组的平方：https://leetcode.cn/problems/squares-of-a-sorted-array/

\n

链表

\n

707.设计链表：https://leetcode.cn/problems/design-linked-list/

\n

206.反转链表：https://leetcode.cn/problems/reverse-linked-list/

\n

92.反转链表 II：https://leetcode.cn/problems/reverse-linked-list-ii/

\n

61.旋转链表：https://leetcode.cn/problems/rotate-list/

\n

栈与队列

\n

232.用栈实现队列：https://leetcode.cn/problems/implement-queue-using-stacks/

\n

225.用队列实现栈：https://leetcode.cn/problems/implement-stack-using-queues/

\n

347.前 K 个高频元素：https://leetcode.cn/problems/top-k-frequent-elements/

\n

239.滑动窗口最大值：https://leetcode.cn/problems/sliding-window-maximum/

\n

二叉树

\n

105.从前序与中序遍历构造二叉树：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

\n

117.填充每个节点的下一个右侧节点指针 II：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii

\n

236.二叉树的最近公共祖先：https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/

\n

129.求根节点到叶节点数字之和：https://leetcode.cn/problems/sum-root-to-leaf-numbers/

\n

102.二叉树的层序遍历：https://leetcode.cn/problems/binary-tree-level-order-traversal/

\n

530.二叉搜索树的最小绝对差：https://leetcode.cn/problems/minimum-absolute-difference-in-bst/

\n

图

\n

200.岛屿数量：https://leetcode.cn/problems/number-of-islands/

\n

207.课程表：https://leetcode.cn/problems/course-schedule/

\n

210.课程表 II：https://leetcode.cn/problems/course-schedule-ii/

\n

堆

\n

215.数组中的第 K 个最大元素:https://leetcode.cn/problems/kth-largest-element-in-an-array/

\n

216.数据流的中位数:https://leetcode.cn/problems/find-median-from-data-stream/

\n

217.前 K 个高频元素：https://leetcode.cn/problems/top-k-frequent-elements/

\n", "date_published": "2023-10-28T10:18:37.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "虚拟线程常见问题总结", "url": "https://javaguide.cn/java/concurrent/virtual-thread.html", "id": "https://javaguide.cn/java/concurrent/virtual-thread.html", "summary": "Java 21虚拟线程详解：全面解析Virtual Threads虚拟线程原理、与平台线程区别、Project Loom项目、适用IO密集型场景、使用注意事项与最佳实践。", "content_html": "
\n

本文部分内容来自 Lorin 的PR。

\n
\n

虚拟线程在 Java 21 正式发布，这是一项重量级的更新。

\n

什么是虚拟线程？

\n

虚拟线程（Virtual Thread）是 JDK 而不是 OS 实现的轻量级线程(Lightweight Process，LWP），由 JVM 调度。许多虚拟线程共享同一个操作系统线程，虚拟线程的数量可以远大于操作系统线程的数量。

\n

虚拟线程和平台线程有什么关系？

\n

在引入虚拟线程之前，java.lang.Thread 包已经支持所谓的平台线程（Platform Thread），也就是没有虚拟线程之前，我们一直使用的线程。JVM 调度程序通过平台线程（载体线程）来管理虚拟线程，一个平台线程可以在不同的时间执行不同的虚拟线程（多个虚拟线程挂载在一个平台线程上），当虚拟线程被阻塞或等待时，平台线程可以切换到执行另一个虚拟线程。

\n

虚拟线程、平台线程和系统内核线程的关系图如下所示（图源：How to Use Java 19 Virtual Threads）：

\n

\"虚拟线程、平台线程和系统内核线程的关系\"

\n

关于平台线程和系统内核线程的对应关系多提一点：在 Windows 和 Linux 等主流操作系统中，Java 线程采用的是一对一的线程模型，也就是一个平台线程对应一个系统内核线程。Solaris 系统是一个特例，HotSpot VM 在 Solaris 上支持多对多和一对一。具体可以参考 R 大的回答: JVM 中的线程模型是用户级的么？。

\n

虚拟线程有什么优点和缺点？

\n

优点

\n\n

缺点

\n\n

如何创建虚拟线程？

\n

官方提供了以下四种方式创建虚拟线程：

\n
    \n
  1. 使用 Thread.startVirtualThread() 创建
    2. \n
  2. 使用 Thread.ofVirtual() 创建
    3. \n
  3. 使用 ThreadFactory 创建
    4. \n
  4. 使用 Executors.newVirtualThreadPerTaskExecutor()创建
    5. \n
\n

1、使用 Thread.startVirtualThread() 创建

\n
public class VirtualThreadTest {\n  public static void main(String[] args) {\n    CustomThread customThread = new CustomThread();\n    Thread.startVirtualThread(customThread);\n  }\n}\n\nstatic class CustomThread implements Runnable {\n  @Override\n  public void run() {\n    System.out.println(\"CustomThread run\");\n  }\n}
\n

2、使用 Thread.ofVirtual() 创建

\n
public class VirtualThreadTest {\n  public static void main(String[] args) {\n    CustomThread customThread = new CustomThread();\n    // 创建不启动\n    Thread unStarted = Thread.ofVirtual().unstarted(customThread);\n    unStarted.start();\n    // 创建直接启动\n    Thread.ofVirtual().start(customThread);\n  }\n}\nstatic class CustomThread implements Runnable {\n  @Override\n  public void run() {\n    System.out.println(\"CustomThread run\");\n  }\n}
\n

3、使用 ThreadFactory 创建

\n
public class VirtualThreadTest {\n  public static void main(String[] args) {\n    CustomThread customThread = new CustomThread();\n    ThreadFactory factory = Thread.ofVirtual().factory();\n    Thread thread = factory.newThread(customThread);\n    thread.start();\n  }\n}\n\nstatic class CustomThread implements Runnable {\n  @Override\n  public void run() {\n    System.out.println(\"CustomThread run\");\n  }\n}
\n

4、使用Executors.newVirtualThreadPerTaskExecutor()创建

\n
public class VirtualThreadTest {\n  public static void main(String[] args) {\n    CustomThread customThread = new CustomThread();\n    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();\n    executor.submit(customThread);\n  }\n}\nstatic class CustomThread implements Runnable {\n  @Override\n  public void run() {\n    System.out.println(\"CustomThread run\");\n  }\n}
\n

虚拟线程和平台线程性能对比

\n

通过多线程和虚拟线程的方式处理相同的任务，对比创建的系统线程数和处理耗时。

\n

说明：统计创建的系统线程中部分为后台线程（比如 GC 线程），两种场景下都一样，所以并不影响对比。

\n

测试代码：

\n
public class VirtualThreadTest {\n    static List<Integer> list = new ArrayList<>();\n    public static void main(String[] args) {\n        // 开启线程 统计平台线程数\n        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);\n        scheduledExecutorService.scheduleAtFixedRate(() -> {\n            ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();\n            ThreadInfo[] threadInfo = threadBean.dumpAllThreads(false, false);\n            updateMaxThreadNum(threadInfo.length);\n        }, 10, 10, TimeUnit.MILLISECONDS);\n\n        long start = System.currentTimeMillis();\n        // 虚拟线程\n        ExecutorService executor =  Executors.newVirtualThreadPerTaskExecutor();\n        // 使用平台线程\n        // ExecutorService executor =  Executors.newFixedThreadPool(200);\n        for (int i = 0; i < 10000; i++) {\n            executor.submit(() -> {\n                try {\n                    // 线程睡眠 0.5 s，模拟业务处理\n                    TimeUnit.MILLISECONDS.sleep(500);\n                } catch (InterruptedException ignored) {\n                }\n            });\n        }\n        executor.close();\n        System.out.println(\"max：\" + list.get(0) + \" platform thread/os thread\");\n        System.out.printf(\"totalMillis：%dms\\n\", System.currentTimeMillis() - start);\n\n\n    }\n    // 更新创建的平台最大线程数\n    private static void updateMaxThreadNum(int num) {\n        if (list.isEmpty()) {\n            list.add(num);\n        } else {\n            Integer integer = list.get(0);\n            if (num > integer) {\n                list.add(0, num);\n            }\n        }\n    }\n}
\n

请求数 10000 单请求耗时 1s：

\n
// Virtual Thread\nmax：22 platform thread/os thread\ntotalMillis：1806ms\n\n// Platform Thread  线程数200\nmax：209 platform thread/os thread\ntotalMillis：50578ms\n\n// Platform Thread  线程数500\nmax：509 platform thread/os thread\ntotalMillis：20254ms\n\n// Platform Thread  线程数1000\nmax：1009 platform thread/os thread\ntotalMillis：10214ms\n\n// Platform Thread  线程数2000\nmax：2009 platform thread/os thread\ntotalMillis：5358ms
\n

请求数 10000 单请求耗时 0.5s：

\n
// Virtual Thread\nmax：22 platform thread/os thread\ntotalMillis：1316ms\n\n// Platform Thread  线程数200\nmax：209 platform thread/os thread\ntotalMillis：25619ms\n\n// Platform Thread  线程数500\nmax：509 platform thread/os thread\ntotalMillis：10277ms\n\n// Platform Thread  线程数1000\nmax：1009 platform thread/os thread\ntotalMillis：5197ms\n\n// Platform Thread  线程数2000\nmax：2009 platform thread/os thread\ntotalMillis：2865ms
\n
\n

注意：有段时间 JDK 一直致力于 Reactor 响应式编程来提高 Java 性能，但响应式编程难以理解、调试、使用，最终又回到了同步编程，最终虚拟线程诞生。

\n

虚拟线程的底层原理是什么？

\n

如果你想要详细了解虚拟线程实现原理，推荐一篇文章：虚拟线程 - VirtualThread 源码透视。

\n

面试一般是不会问到这个问题的，仅供学有余力的同学进一步研究学习。

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/virtual-threads-platform-threads-kernel-threads-relationship.png", "date_published": "2023-10-15T12:01:30.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Java 21 新特性概览(重要)", "url": "https://javaguide.cn/java/new-features/java21.html", "id": "https://javaguide.cn/java/new-features/java21.html", "summary": "概览 JDK 21 的关键新特性与实践影响，重点介绍字符串模板、Sequenced Collections、分代 ZGC、虚拟线程等。", "content_html": "

JDK 21 于 2023 年 9 月 19 日 发布，这是一个非常重要的版本，里程碑式。

\n

JDK 21 是 LTS（长期支持版），至此为止，目前有 JDK8、JDK11、JDK17 和 JDK21 这四个长期支持版了。

\n

JDK 21 共有 15 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 24 每个版本的更新带来的新特性数量和更新时间：

\n

\n

JEP 430: String Templates（字符串模板，预览）

\n

String Templates(字符串模板) 目前仍然是 JDK 21 中的一个预览功能。

\n

String Templates 提供了一种更简洁、更直观的方式来动态构建字符串。通过使用占位符${}，我们可以将变量的值直接嵌入到字符串中，而不需要手动处理。在运行时，Java 编译器会将这些占位符替换为实际的变量值。并且，表达式支持局部变量、静态/非静态字段甚至方法、计算结果等特性。

\n

实际上，String Templates（字符串模板）在大多数编程语言中都存在:

\n
\"Greetings {{ name }}!\";  //Angular\n`Greetings ${ name }!`;    //Typescript\n$\"Greetings { name }!\"    //Visual basic\nf\"Greetings { name }!\"    //Python
\n

Java 在没有 String Templates 之前，我们通常使用字符串拼接或格式化方法来构建字符串：

\n
//concatenation\nmessage = \"Greetings \" + name + \"!\";\n\n//String.format()\nmessage = String.format(\"Greetings %s!\", name);  //concatenation\n\n//MessageFormat\nmessage = new MessageFormat(\"Greetings {0}!\").format(name);\n\n//StringBuilder\nmessage = new StringBuilder().append(\"Greetings \").append(name).append(\"!\").toString();
\n

这些方法或多或少都存在一些缺点，比如难以阅读、冗长、复杂。

\n

Java 使用 String Templates 进行字符串拼接，可以直接在字符串中嵌入表达式，而无需进行额外的处理：

\n
String message = STR.\"Greetings \\{name}!\";
\n

在上面的模板表达式中：

\n\n

Java 目前支持三种模板处理器：

\n\n
String name = \"Lokesh\";\n\n//STR\nString message = STR.\"Greetings \\{name}.\";\n\n//FMT\nString message = FMT.\"Greetings %-12s\\{name}.\";\n\n//RAW\nStringTemplate st = RAW.\"Greetings \\{name}.\";\nString message = STR.process(st);
\n

除了 JDK 自带的三种模板处理器外，你还可以实现 StringTemplate.Processor 接口来创建自己的模板处理器，只需要继承 StringTemplate.Processor接口，然后实现 process 方法即可。

\n

我们可以使用局部变量、静态/非静态字段甚至方法作为嵌入表达式：

\n
//variable\nmessage = STR.\"Greetings \\{name}!\";\n\n//method\nmessage = STR.\"Greetings \\{getName()}!\";\n\n//field\nmessage = STR.\"Greetings \\{this.name}!\";
\n

还可以在表达式中执行计算并打印结果：

\n
int x = 10, y = 20;\nString s = STR.\"\\{x} + \\{y} = \\{x + y}\";  //\"10 + 20 = 30\"
\n

为了提高可读性，我们可以将嵌入的表达式分成多行:

\n
String time = STR.\"The current time is \\{\n    //sample comment - current time in HH:mm:ss\n    DateTimeFormatter\n      .ofPattern(\"HH:mm:ss\")\n      .format(LocalTime.now())\n  }.\";
\n

JEP 431: Sequenced Collections（序列化集合）

\n

JDK 21 引入了一种新的集合类型：Sequenced Collections（序列化集合，也叫有序集合），这是一种具有确定出现顺序（encounter order）的集合（无论我们遍历这样的集合多少次，元素的出现顺序始终是固定的）。序列化集合提供了处理集合的第一个和最后一个元素以及反向视图（与原始集合相反的顺序）的简单方法。

\n

Sequenced Collections 包括以下三个接口：

\n\n

SequencedCollection 接口继承了 Collection接口， 提供了在集合两端访问、添加或删除元素以及获取集合的反向视图的方法。

\n
interface SequencedCollection<E> extends Collection<E> {\n\n  // New Method\n\n  SequencedCollection<E> reversed();\n\n  // Promoted methods from Deque<E>\n\n  void addFirst(E);\n  void addLast(E);\n\n  E getFirst();\n  E getLast();\n\n  E removeFirst();\n  E removeLast();\n}
\n

List 和 Deque 接口实现了SequencedCollection 接口。

\n

这里以 ArrayList 为例，演示一下实际使用效果：

\n
ArrayList<Integer> arrayList = new ArrayList<>();\n\narrayList.add(1);   // List contains: [1]\n\narrayList.addFirst(0);  // List contains: [0, 1]\narrayList.addLast(2);   // List contains: [0, 1, 2]\n\nInteger firstElement = arrayList.getFirst();  // 0\nInteger lastElement = arrayList.getLast();  // 2\n\nList<Integer> reversed = arrayList.reversed();\nSystem.out.println(reversed); // Prints [2, 1, 0]
\n

SequencedSet接口直接继承了 SequencedCollection 接口并重写了 reversed() 方法。

\n
interface SequencedSet<E> extends SequencedCollection<E>, Set<E> {\n\n    SequencedSet<E> reversed();\n}
\n

SortedSet 和 LinkedHashSet 实现了SequencedSet接口。

\n

这里以 LinkedHashSet 为例，演示一下实际使用效果：

\n
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(List.of(1, 2, 3));\n\nInteger firstElement = linkedHashSet.getFirst();   // 1\nInteger lastElement = linkedHashSet.getLast();    // 3\n\nlinkedHashSet.addFirst(0);  //List contains: [0, 1, 2, 3]\nlinkedHashSet.addLast(4);   //List contains: [0, 1, 2, 3, 4]\n\nSystem.out.println(linkedHashSet.reversed());   //Prints [4, 3, 2, 1, 0]
\n

SequencedMap 接口继承了 Map接口， 提供了在集合两端访问、添加或删除键值对、获取包含 key 的 SequencedSet、包含 value 的 SequencedCollection、包含 entry（键值对） 的 SequencedSet以及获取集合的反向视图的方法。

\n
interface SequencedMap<K,V> extends Map<K,V> {\n\n  // New Methods\n\n  SequencedMap<K,V> reversed();\n\n  SequencedSet<K> sequencedKeySet();\n  SequencedCollection<V> sequencedValues();\n  SequencedSet<Entry<K,V>> sequencedEntrySet();\n\n  V putFirst(K, V);\n  V putLast(K, V);\n\n\n  // Promoted Methods from NavigableMap<K, V>\n\n  Entry<K, V> firstEntry();\n  Entry<K, V> lastEntry();\n\n  Entry<K, V> pollFirstEntry();\n  Entry<K, V> pollLastEntry();\n}
\n

SortedMap 和LinkedHashMap 实现了SequencedMap 接口。

\n

这里以 LinkedHashMap 为例，演示一下实际使用效果：

\n
LinkedHashMap<Integer, String> map = new LinkedHashMap<>();\n\nmap.put(1, \"One\");\nmap.put(2, \"Two\");\nmap.put(3, \"Three\");\n\nmap.firstEntry();   //1=One\nmap.lastEntry();    //3=Three\n\nSystem.out.println(map);  //{1=One, 2=Two, 3=Three}\n\nMap.Entry<Integer, String> first = map.pollFirstEntry();   //1=One\nMap.Entry<Integer, String> last = map.pollLastEntry();    //3=Three\n\nSystem.out.println(map);  //{2=Two}\n\nmap.putFirst(1, \"One\");     //{1=One, 2=Two}\nmap.putLast(3, \"Three\");    //{1=One, 2=Two, 3=Three}\n\nSystem.out.println(map);  //{1=One, 2=Two, 3=Three}\nSystem.out.println(map.reversed());   //{3=Three, 2=Two, 1=One}
\n

JEP 439: Generational ZGC（分代 ZGC）

\n

JDK21 中对 ZGC 进行了功能扩展，增加了分代 GC 功能。不过，默认是关闭的，需要通过配置打开：

\n
// 启用分代ZGC\njava -XX:+UseZGC -XX:+ZGenerational ...
\n

在未来的版本中，官方会把 ZGenerational 设为默认值，即默认打开 ZGC 的分代 GC。在更晚的版本中，非分代 ZGC 就被移除。

\n
\n

In a future release we intend to make Generational ZGC the default, at which point -XX:-ZGenerational will select non-generational ZGC. In an even later release we intend to remove non-generational ZGC, at which point the ZGenerational option will become obsolete.

\n

在将来的版本中，我们打算将 Generational ZGC 作为默认选项，此时-XX:-ZGenerational 将选择非分代 ZGC。在更晚的版本中，我们打算移除非分代 ZGC，此时 ZGenerational 选项将变得过时。

\n
\n

分代 ZGC 可以显著减少垃圾回收过程中的停顿时间，并提高应用程序的响应性能。这对于大型 Java 应用程序和高并发场景下的性能优化非常有价值。

\n

JEP 440: Record Patterns（记录模式）

\n

记录模式在 Java 19 进行了第一次预览， 由 JEP 405 提出。JDK 20 中是第二次预览，由 JEP 432 提出。最终，记录模式在 JDK21 顺利转正。

\n

Java 20 新特性概览已经详细介绍过记录模式，这里就不重复了。

\n

JEP 441: Pattern Matching for switch（switch 的模式匹配）

\n

增强 Java 中的 switch 表达式和语句，允许在 case 标签中使用模式。当模式匹配时，执行 case 标签对应的代码。

\n

在下面的代码中，switch 表达式使用了类型模式来进行匹配。

\n
static String formatterPatternSwitch(Object obj) {\n    return switch (obj) {\n        case Integer i -> String.format(\"int %d\", i);\n        case Long l    -> String.format(\"long %d\", l);\n        case Double d  -> String.format(\"double %f\", d);\n        case String s  -> String.format(\"String %s\", s);\n        default        -> obj.toString();\n    };\n}
\n

JEP 442: Foreign Function & Memory API（外部函数和内存 API，第三次预览）

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。Java 18 中进行了第二次孵化，由JEP 419 提出。Java 19 中是第一次预览，由 JEP 424 提出。JDK 20 中是第二次预览，由 JEP 434 提出。JDK 21 中是第三次预览，由 JEP 442 提出。

\n

在 Java 19 新特性概览 中，我有详细介绍到外部函数和内存 API，这里就不再做额外的介绍了。

\n

JEP 443: Unnamed Patterns and Variables（未命名模式和变量，预览）

\n

未命名模式和变量使得我们可以使用下划线 _ 表示未命名的变量以及模式匹配时不使用的组件，旨在提高代码的可读性和可维护性。

\n

未命名变量的典型场景是 try-with-resources 语句、 catch 子句中的异常变量和for循环。当变量不需要使用的时候就可以使用下划线 _代替，这样清晰标识未被使用的变量。

\n
try (var _ = ScopedContext.acquire()) {\n  // No use of acquired resource\n}\ntry { ... }\ncatch (Exception _) { ... }\ncatch (Throwable _) { ... }\n\nfor (int i = 0, _ = runOnce(); i < arr.length; i++) {\n  ...\n}
\n

未命名模式是一个无条件的模式，并不绑定任何值。未命名模式变量出现在类型模式中。

\n
if (r instanceof ColoredPoint(_, Color c)) { ... c ... }\n\nswitch (b) {\n    case Box(RedBall _), Box(BlueBall _) -> processBox(b);\n    case Box(GreenBall _)                -> stopProcessing();\n    case Box(_)                          -> pickAnotherBox();\n}
\n

JEP 444: Virtual Threads（虚拟线程）

\n

虚拟线程是一项重量级的更新，一定一定要重视！

\n

虚拟线程在 Java 19 中进行了第一次预览，由JEP 425提出。JDK 20 中是第二次预览。最终，虚拟线程在 JDK21 顺利转正。

\n

Java 20 新特性概览已经详细介绍过虚拟线程，这里就不重复了。

\n

JEP 445: Unnamed Classes and Instance Main Methods（未命名类和实例 main 方法，预览）

\n

这个特性主要简化了 main 方法的声明。对于 Java 初学者来说，这个 main 方法的声明引入了太多的 Java 语法概念，不利于初学者快速上手。

\n

没有使用该特性之前定义一个 main 方法：

\n
public class HelloWorld {\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

使用该新特性之后定义一个 main 方法：

\n
class HelloWorld {\n    void main() {\n        System.out.println(\"Hello, World!\");\n    }\n}
\n

进一步精简(未命名的类允许我们不定义类名)：

\n
void main() {\n   System.out.println(\"Hello, World!\");\n}
\n

参考

\n\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2023-10-08T07:27:41.000Z", "date_modified": "2026-01-26T14:45:12.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Maven最佳实践", "url": "https://javaguide.cn/tools/maven/maven-best-practices.html", "id": "https://javaguide.cn/tools/maven/maven-best-practices.html", "summary": "Maven 是一种广泛使用的 Java 项目构建自动化工具。它简化了构建过程并帮助管理依赖关系，使开发人员的工作更轻松。在这篇博文中，我们将讨论一些最佳实践、提示和技巧，以优化我们在项目中对 Maven 的使用并改善我们的开发体验。", "content_html": "
\n

本文由 JavaGuide 翻译并完善，原文地址：https://medium.com/@AlexanderObregon/maven-best-practices-tips-and-tricks-for-java-developers-438eca03f72b 。

\n
\n

Maven 是一种广泛使用的 Java 项目构建自动化工具。它简化了构建过程并帮助管理依赖关系，使开发人员的工作更轻松。Maven 详细介绍可以参考我写的这篇 Maven 核心概念总结 。

\n

这篇文章不会涉及到 Maven 概念的介绍，主要讨论一些最佳实践、建议和技巧，以优化我们在项目中对 Maven 的使用并改善我们的开发体验。

\n

Maven 标准目录结构

\n

Maven 遵循标准目录结构来保持项目之间的一致性。遵循这种结构可以让其他开发人员更轻松地理解我们的项目。

\n

Maven 项目的标准目录结构如下：

\n
src/\n  main/\n    java/\n    resources/\n  test/\n    java/\n    resources/\npom.xml
\n
\n

这只是一个最简单的 Maven 项目目录示例。实际项目中，我们还会根据项目规范去做进一步的细分。

\n

指定 Maven 编译器插件

\n

默认情况下，Maven 使用 Java5 编译我们的项目。要使用不同的 JDK 版本，请在 pom.xml 文件中配置 Maven 编译器插件。

\n

例如，如果你想要使用 Java8 来编译你的项目，你可以在<build>标签下添加以下的代码片段：

\n
<build>\n  <plugins>\n    <plugin>\n      <groupId>org.apache.maven.plugins</groupId>\n      <artifactId>maven-compiler-plugin</artifactId>\n      <version>3.8.1</version>\n      <configuration>\n        <source>1.8</source>\n        <target>1.8</target>\n      </configuration>\n    </plugin>\n  </plugins>\n</build>
\n

这样，Maven 就会使用 Java8 的编译器来编译你的项目。如果你想要使用其他版本的 JDK，你只需要修改<source>和<target>标签的值即可。例如，如果你想要使用 Java11，你可以将它们的值改为 11。

\n

有效管理依赖关系

\n

Maven 的依赖管理系统是其最强大的功能之一。在顶层 pom 文件中，通过标签 dependencyManagement 定义公共的依赖关系，这有助于避免冲突并确保所有模块使用相同版本的依赖项。

\n

例如，假设我们有一个父模块和两个子模块 A 和 B，我们想要在所有模块中使用 JUnit 5.7.2 作为测试框架。我们可以在父模块的pom.xml文件中使用<dependencyManagement>标签来定义 JUnit 的版本：

\n
<dependencyManagement>\n  <dependencies>\n    <dependency>\n      <groupId>org.junit.jupiter</groupId>\n      <artifactId>junit-jupiter</artifactId>\n      <version>5.7.2</version>\n      <scope>test</scope>\n    </dependency>\n  </dependencies>\n</dependencyManagement>
\n

在子模块 A 和 B 的 pom.xml 文件中，我们只需要引用 JUnit 的 groupId 和 artifactId 即可:

\n
<dependencies>\n  <dependency>\n    <groupId>org.junit.jupiter</groupId>\n    <artifactId>junit-jupiter</artifactId>\n  </dependency>\n</dependencies>
\n

针对不同环境使用配置文件

\n

Maven 配置文件允许我们配置不同环境的构建设置，例如开发、测试和生产。在 pom.xml 文件中定义配置文件并使用命令行参数激活它们：

\n
<profiles>\n  <profile>\n    <id>development</id>\n    <activation>\n      <activeByDefault>true</activeByDefault>\n    </activation>\n    <properties>\n      <environment>dev</environment>\n    </properties>\n  </profile>\n  <profile>\n    <id>production</id>\n    <properties>\n      <environment>prod</environment>\n    </properties>\n  </profile>\n</profiles>
\n

使用命令行激活配置文件：

\n
mvn clean install -P production
\n

保持 pom.xml 干净且井然有序

\n

组织良好的 pom.xml 文件更易于维护和理解。以下是维护干净的 pom.xml 的一些技巧：

\n\n
<properties>\n  <junit.version>5.7.0</junit.version>\n  <mockito.version>3.9.0</mockito.version>\n</properties>
\n

使用 Maven Wrapper

\n

Maven Wrapper 是一个用于管理和使用 Maven 的工具，它允许在没有预先安装 Maven 的情况下运行和构建 Maven 项目。

\n

Maven 官方文档是这样介绍 Maven Wrapper 的：

\n
\n

The Maven Wrapper is an easy way to ensure a user of your Maven build has everything necessary to run your Maven build.

\n

Maven Wrapper 是一种简单的方法，可以确保 Maven 构建的用户拥有运行 Maven 构建所需的一切。

\n
\n

Maven Wrapper 可以确保构建过程使用正确的 Maven 版本，非常方便。要使用 Maven Wrapper，请在项目目录中运行以下命令：

\n
mvn wrapper:wrapper
\n

此命令会在我们的项目中生成 Maven Wrapper 文件。现在我们可以使用 ./mvnw （或 Windows 上的 ./mvnw.cmd）而不是 mvn 来执行 Maven 命令。

\n

通过持续集成实现构建自动化

\n

将 Maven 项目与持续集成 (CI) 系统（例如 Jenkins 或 GitHub Actions）集成，可确保自动构建、测试和部署我们的代码。CI 有助于及早发现问题并在整个团队中提供一致的构建流程。以下是 Maven 项目的简单 GitHub Actions 工作流程示例：

\n
name: Java CI with Maven\n\non: [push]\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n\n    steps:\n    - name: Checkout code\n      uses: actions/checkout@v2\n\n    - name: Set up JDK 11\n      uses: actions/setup-java@v2\n      with:\n        java-version: '11'\n        distribution: 'adopt'\n\n    - name: Build with Maven\n      run: ./mvnw clean install
\n

利用 Maven 插件获得附加功能

\n

有许多 Maven 插件可用于扩展 Maven 的功能。一些流行的插件包括（前三个是 Maven 自带的插件，后三个是第三方提供的插件）：

\n\n

jacoco-maven-plugin 使用示例：

\n
<build>\n  <plugins>\n    <plugin>\n      <groupId>org.jacoco</groupId>\n      <artifactId>jacoco-maven-plugin</artifactId>\n      <version>0.8.8</version>\n      <executions>\n        <execution>\n          <goals>\n            <goal>prepare-agent</goal>\n          </goals>\n        </execution>\n        <execution>\n          <id>generate-code-coverage-report</id>\n          <phase>test</phase>\n          <goals>\n            <goal>report</goal>\n          </goals>\n        </execution>\n      </executions>\n    </plugin>\n  </plugins>\n</build>
\n

如果这些已有的插件无法满足我们的需求，我们还可以自定义插件。

\n

探索可用的插件并在 pom.xml 文件中配置它们以增强我们的开发过程。

\n

总结

\n

Maven 是一个强大的工具，可以简化 Java 项目的构建过程和依赖关系管理。通过遵循这些最佳实践和技巧，我们可以优化 Maven 的使用并改善我们的 Java 开发体验。请记住使用标准目录结构，有效管理依赖关系，利用不同环境的配置文件，并将项目与持续集成系统集成，以确保构建一致。

\n", "date_published": "2023-09-15T13:14:19.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "开发工具" ] }, { "title": "IoC & AOP详解（快速搞懂）", "url": "https://javaguide.cn/system-design/framework/spring/ioc-and-aop.html", "id": "https://javaguide.cn/system-design/framework/spring/ioc-and-aop.html", "summary": "Spring IoC与AOP核心原理详解，深入讲解控制反转、依赖注入、切面编程及动态代理的实现机制。", "content_html": "

这篇文章会从下面从以下几个问题展开对 IoC & AOP 的解释

\n\n

首先声明：IoC & AOP 不是 Spring 提出来的，它们在 Spring 之前其实已经存在了，只不过当时更加偏向于理论。Spring 在技术层次将这两个思想进行了很好的实现。

\n

IoC （Inversion of control ）

\n

什么是 IoC?

\n

IoC （Inversion of Control ）即控制反转/反转控制。它是一种思想不是一个技术实现。描述的是：Java 开发领域对象的创建以及管理的问题。

\n

例如：现有类 A 依赖于类 B

\n\n

从以上两种开发方式的对比来看：我们 “丧失了一个权力” (创建、管理对象的权力)，从而也得到了一个好处（不用再考虑对象的创建、管理等一系列的事情）

\n

为什么叫控制反转?

\n\n

\"IoC

\n

IoC 解决了什么问题?

\n

IoC 的思想就是两方之间不互相依赖，由第三方容器来管理相关资源。这样有什么好处呢？

\n
    \n
  1. 对象之间的耦合度或者说依赖程度降低；
    2. \n
  2. 资源变的容易管理；比如你用 Spring 容器提供的话很容易就可以实现一个单例。
    3. \n
\n

例如：现有一个针对 User 的操作，利用 Service 和 Dao 两层结构进行开发

\n

在没有使用 IoC 思想的情况下，Service 层想要使用 Dao 层的具体实现的话，需要通过 new 关键字在UserServiceImpl 中手动 new 出 IUserDao 的具体实现类 UserDaoImpl（不能直接 new 接口类）。

\n

很完美，这种方式也是可以实现的，但是我们想象一下如下场景：

\n

开发过程中突然接到一个新的需求，针对IUserDao 接口开发出另一个具体实现类。因为 Server 层依赖了IUserDao的具体实现，所以我们需要修改UserServiceImpl中 new 的对象。如果只有一个类引用了IUserDao的具体实现，可能觉得还好，修改起来也不是很费力气，但是如果有许许多多的地方都引用了IUserDao的具体实现的话，一旦需要更换IUserDao 的实现方式，那修改起来将会非常的头疼。

\n

\"IoC&Aop-ioc-illustration-dao-service\"

\n

使用 IoC 的思想，我们将对象的控制权（创建、管理）交由 IoC 容器去管理，我们在使用的时候直接向 IoC 容器 “要” 就可以了

\n

\n

IoC 和 DI 有区别吗？

\n

IoC（Inverse of Control:控制反转）是一种设计思想或者说是某种模式。这个设计思想就是 将原本在程序中手动创建对象的控制权交给第三方比如 IoC 容器。 对于我们常用的 Spring 框架来说， IoC 容器实际上就是个 Map（key，value）,Map 中存放的是各种对象。不过，IoC 在其他语言中也有应用，并非 Spring 特有。

\n

IoC 最常见以及最合理的实现方式叫做依赖注入（Dependency Injection，简称 DI）。

\n

老马（Martin Fowler）在一篇文章中提到将 IoC 改名为 DI，原文如下，原文地址：https://martinfowler.com/articles/injection.html 。

\n

\n

老马的大概意思是 IoC 太普遍并且不表意，很多人会因此而迷惑，所以，使用 DI 来精确指名这个模式比较好。

\n

AOP（Aspect oriented programming）

\n

这里不会涉及太多专业的术语，核心目的是将 AOP 的思想说清楚。

\n

什么是 AOP？

\n

AOP（Aspect Oriented Programming）即面向切面编程，AOP 是 OOP（面向对象编程）的一种延续，二者互补，并不对立。

\n

AOP 的目的是将横切关注点（如日志记录、事务管理、权限控制、接口限流、接口幂等等）从核心业务逻辑中分离出来，通过动态代理、字节码操作等技术，实现代码的复用和解耦，提高代码的可维护性和可扩展性。OOP 的目的是将业务逻辑按照对象的属性和行为进行封装，通过类、对象、继承、多态等概念，实现代码的模块化和层次化（也能实现代码的复用），提高代码的可读性和可维护性。

\n

AOP 为什么叫面向切面编程？

\n

AOP 之所以叫面向切面编程，是因为它的核心思想就是将横切关注点从核心业务逻辑中分离出来，形成一个个的切面（Aspect）。

\n

\"面向切面编程图解\"

\n

这里顺带总结一下 AOP 关键术语（不理解也没关系，可以继续往下看）：

\n\n

AOP 常见的通知类型有哪些？

\n

\n\n

AOP 解决了什么问题？

\n

OOP 不能很好地处理一些分散在多个类或对象中的公共行为（如日志记录、事务管理、权限控制、接口限流、接口幂等等），这些行为通常被称为 横切关注点（cross-cutting concerns） 。如果我们在每个类或对象中都重复实现这些行为，那么会导致代码的冗余、复杂和难以维护。

\n

AOP 可以将横切关注点（如日志记录、事务管理、权限控制、接口限流、接口幂等等）从 核心业务逻辑（core concerns，核心关注点） 中分离出来，实现关注点的分离。

\n

\n

以日志记录为例进行介绍，假如我们需要对某些方法进行统一格式的日志记录，没有使用 AOP 技术之前，我们需要挨个写日志记录的逻辑代码，全是重复的逻辑。

\n
public CommonResponse<Object> method1() {\n      // 业务逻辑\n      xxService.method1();\n      // 省略具体的业务处理逻辑\n      // 日志记录\n      ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();\n      HttpServletRequest request = attributes.getRequest();\n      // 省略记录日志的具体逻辑 如：获取各种信息，写入数据库等操作...\n      return CommonResponse.success();\n}\n\npublic CommonResponse<Object> method2() {\n      // 业务逻辑\n      xxService.method2();\n      // 省略具体的业务处理逻辑\n      // 日志记录\n      ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();\n      HttpServletRequest request = attributes.getRequest();\n      // 省略记录日志的具体逻辑 如：获取各种信息，写入数据库等操作...\n      return CommonResponse.success();\n}\n\n// ...
\n

使用 AOP 技术之后，我们可以将日志记录的逻辑封装成一个切面，然后通过切入点和通知来指定在哪些方法需要执行日志记录的操作。

\n
\n// 日志注解\n@Target({ElementType.PARAMETER,ElementType.METHOD})\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface Log {\n\n    /**\n     * 描述\n     */\n    String description() default \"\";\n\n    /**\n     * 方法类型 INSERT DELETE UPDATE OTHER\n     */\n    MethodType methodType() default MethodType.OTHER;\n}\n\n// 日志切面\n@Component\n@Aspect\npublic class LogAspect {\n  // 切入点，所有被 Log 注解标注的方法\n  @Pointcut(\"@annotation(cn.javaguide.annotation.Log)\")\n  public void webLog() {\n  }\n\n   /**\n   * 环绕通知\n   */\n  @Around(\"webLog()\")\n  public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {\n    // 省略具体的处理逻辑\n  }\n\n  // 省略其他代码\n}
\n

这样的话，我们一行注解即可实现日志记录：

\n
@Log(description = \"method1\",methodType = MethodType.INSERT)\npublic CommonResponse<Object> method1() {\n      // 业务逻辑\n      xxService.method1();\n      // 省略具体的业务处理逻辑\n      return CommonResponse.success();\n}
\n

AOP 的应用场景有哪些？

\n\n

AOP 实现方式有哪些？

\n

AOP 的常见实现方式有动态代理、字节码操作等方式。

\n

Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 CGLIB 生成一个被代理对象的子类来作为代理，如下图所示：

\n

\"SpringAOPProcess\"

\n

Spring Boot 和 Spring 的动态代理的策略是不是也是一样的呢？其实不一样，很多人都理解错了。

\n

Spring Boot 2.0 之前，默认使用 JDK 动态代理。如果目标类没有实现接口，会抛出异常，开发者必须显式配置（spring.aop.proxy-target-class=true）使用 CGLIB 动态代理 或者注入接口来解决。Spring Boot 1.5.x 自动配置 AOP 代码如下：

\n
@Configuration\n@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class })\n@ConditionalOnProperty(prefix = \"spring.aop\", name = \"auto\", havingValue = \"true\", matchIfMissing = true)\npublic class AopAutoConfiguration {\n\n\t@Configuration\n\t@EnableAspectJAutoProxy(proxyTargetClass = false)\n // 该配置类只有在 spring.aop.proxy-target-class=false 或未显式配置时才会生效。\n // 也就是说，如果开发者未明确选择代理方式，Spring 会默认加载 JDK 动态代理。\n\t@ConditionalOnProperty(prefix = \"spring.aop\", name = \"proxy-target-class\", havingValue = \"false\", matchIfMissing = true)\n\tpublic static class JdkDynamicAutoProxyConfiguration {\n\n\t}\n\n\t@Configuration\n\t@EnableAspectJAutoProxy(proxyTargetClass = true)\n // 该配置类只有在 spring.aop.proxy-target-class=true 时才会生效。\n // 即开发者通过属性配置明确指定使用 CGLIB 动态代理时，Spring 会加载这个配置类。\n\t@ConditionalOnProperty(prefix = \"spring.aop\", name = \"proxy-target-class\", havingValue = \"true\", matchIfMissing = false)\n\tpublic static class CglibAutoProxyConfiguration {\n\n\t}\n\n}
\n

Spring Boot 2.0 开始，如果用户什么都不配置的话，默认使用 CGLIB 动态代理。如果需要强制使用 JDK 动态代理，可以在配置文件中添加：spring.aop.proxy-target-class=false。Spring Boot 2.0 自动配置 AOP 代码如下：

\n
@Configuration\n@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,\n\t\tAnnotatedElement.class })\n@ConditionalOnProperty(prefix = \"spring.aop\", name = \"auto\", havingValue = \"true\", matchIfMissing = true)\npublic class AopAutoConfiguration {\n\n\t@Configuration\n\t@EnableAspectJAutoProxy(proxyTargetClass = false)\n // 该配置类只有在 spring.aop.proxy-target-class=false 时才会生效。\n // 即开发者通过属性配置明确指定使用 JDK 动态代理时，Spring 会加载这个配置类。\n\t@ConditionalOnProperty(prefix = \"spring.aop\", name = \"proxy-target-class\", havingValue = \"false\", matchIfMissing = false)\n\tpublic static class JdkDynamicAutoProxyConfiguration {\n\n\t}\n\n\t@Configuration\n\t@EnableAspectJAutoProxy(proxyTargetClass = true)\n // 该配置类只有在 spring.aop.proxy-target-class=true 或未显式配置时才会生效。\n // 也就是说，如果开发者未明确选择代理方式，Spring 会默认加载 CGLIB 代理。\n\t@ConditionalOnProperty(prefix = \"spring.aop\", name = \"proxy-target-class\", havingValue = \"true\", matchIfMissing = true)\n\tpublic static class CglibAutoProxyConfiguration {\n\n\t}\n\n}
\n

当然你也可以使用 AspectJ ！Spring AOP 已经集成了 AspectJ ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了。

\n

Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。 Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。

\n

Spring AOP 已经集成了 AspectJ ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了。AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单。

\n

如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，它比 Spring AOP 快很多。

\n

参考

\n\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/framework/spring/IoC&Aop-ioc-illustration.png", "date_published": "2023-09-10T14:59:47.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "框架" ] }, { "title": "一文搞懂 AI Agent 核心概念：Agent Loop、Context Engineering、Tools 注册", "url": "https://javaguide.cn/ai/agent/agent-basis.html", "id": "https://javaguide.cn/ai/agent/agent-basis.html", "summary": "深入解析 AI Agent 核心概念，梳理从被动响应到常驻自治的六代进化史，对比 Agent、传统编程、Workflow 的本质区别。", "content_html": "

\"《SpringAI

\n

还记得第一次被 ChatGPT 震撼的时刻吗？那时它还是个需要你费尽心思写提示词的"静态百科全书"。然而短短三年过去，AI 的进化速度早已超越了我们的想象——它不仅长出了"四肢"，学会了自己调用工具、自己操作电脑屏幕，甚至正在朝着 24 小时全自动打工的"数字实体"狂奔！

\n

AI Agent（智能体） 正在从"聊天工具"向"超级生产力"狂奔，这是当下 AI 应用开发最热门的方向之一。无论是 OpenAI 的 Assistant API、Anthropic 的 Claude Agent，还是各种低代码平台（Coze、Dify），都在围绕 Agent 这个核心概念展开。

\n

今天 Guide 就来系统梳理 AI Agent 的核心概念，帮你建立完整的知识体系。本文接近 1.5w 字，建议收藏，通过本文你将搞懂：

\n
    \n
  1. AI Agent 六代进化史：从 2022 年的被动响应到 2025 年的常驻自治，Agent 经历了怎样的演进？每一代的核心特征和技术突破是什么？
    2. \n
  2. ⭐ Agent vs 传统编程 vs Workflow：三者的本质区别是什么？为什么说"传统编程和 Workflow 是人在做决策，Agent 是 AI 在做决策"？
    3. \n
  3. ⭐ Agent Loop（智能体循环）：Agent 是如何通过"感知-思考-行动"的循环来完成复杂任务的？ReAct、Reflection 等推理模式是如何工作的？
    4. \n
  4. ⭐ Context Engineering（上下文工程）：如何设计 System Prompt？如何管理多轮对话的上下文？如何避免上下文溢出？
    5. \n
  5. ⭐ Tools 注册与 Function Calling：Agent 如何调用外部工具？Function Calling 的底层机制是什么？如何设计可靠的工具接口？
    6. \n
\n

背景与演进

\n

AI Agent 六代进化史

\n

还记得第一次被 ChatGPT 震撼的时刻吗？那时它还是个需要你费尽心思写提示词的“静态百科全书”。

\n

然而短短三年过去，AI 的进化速度早已超越了我们的想象——它不仅长出了“四肢”，学会了自己调用工具、自己操作电脑屏幕，甚至正在朝着 24 小时全自动打工的“数字实体”狂奔！

\n

从最初的“被动响应”到未来的“具身智能”，AI Agent（智能体）到底经历了怎样的疯狂迭代？今天，我们就来一次性硬核梳理 AI Agent 的六代进化史。带你看懂 AI 从聊天工具到超级生产力的终极演进路线图！👇

\n
    \n
  1. 第 0 代（2022年底）：被动响应。 以 ChatGPT 为代表，依赖提示词工程（Prompt Engineering），本质是“静态知识预言机”，无法感知实时世界且缺乏行动能力。
    2. \n
  2. 第 1 代（2023年中）：工具觉醒。 引入 Function Calling （允许模型调用外部API）和 RAG 技术（增强外部知识检索，虽 2020 年提出，但 2023 年广泛应用），赋予 AI “执行四肢”与外部记忆。AutoGPT 是早期代理尝试，但确实因无限循环和缺乏可靠规划而效率低（常被称为“hallucination-prone”）。
    3. \n
  3. 第 2 代（2023年底）：工程化编排。 确立 ReAct 推理框架，推广多智能体协作模式。Coze、Dify 等低代码平台降低了开发门槛，强调流程的可控性。这代强调从混乱自治到工程化，如通过DAG（有向无环图）避免AutoGPT的低效。
    4. \n
  4. 第 3 代（2024年底）：标准化与多模态。 MCP 协议（Model Context Protocol）终结了集成碎片化，Computer Use 允许 Agent 通过屏幕、鼠标、键盘交互图形界面（多模态扩展）。Cursor 等 AI 编程工具推动了“Vibe Coding”（氛围编程，使用 AI 根据自然语言提示生成功能代码）。
    5. \n
  5. 第 4 代（2025年底）：常驻自治。 核心是 Agent Skills 技能封装和 Heartbeat 心跳机制（OpenClaw、Moltbook等普及），使 Agent 成为 24 小时后台运行、具备本地数据主权的“数字实体”。
    6. \n
  6. 第 5 代（前瞻）：闭环与具身。 进化方向为内建记忆、具备预测能力的世界模型，并从数字世界扩展至物理机器人领域。
    7. \n
\n

⭐️ Agent、传统编程、Workflow 三者的本质区别是什么？

\n

传统编程和 Workflow 是人在做决策，Agent 是 AI 在做决策。 这是最本质的区别，其他差异（灵活性、门槛、维护成本）都从这一点派生而来。

\n

从决策主体看：

\n
传统编程：程序员 ──→ 代码 ──→ 执行结果\nWorkflow：产品/开发 ──→ 流程图 ──→ 执行结果\nAgent：用户描述意图 ──→ AI 决策 ──→ 动态执行
\n

一句话总结：传统编程和 Workflow 都是人在做决策、提前设计好所有逻辑，而 Agent 是 AI 在做决策。

\n

从三个核心维度对比：

\n

1. 决策与灵活性

\n

| 方式 | 遇到预设外的情况时... |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/agent/agent-core-arch.png", "date_published": "2023-08-07T10:15:14.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "万字拆解 LLM 运行机制：Token、上下文与采样参数", "url": "https://javaguide.cn/ai/llm-basis/llm-operation-mechanism.html", "id": "https://javaguide.cn/ai/llm-basis/llm-operation-mechanism.html", "summary": "深入剖析大语言模型（LLM）底层运行机制，详解 Token、上下文窗口、Temperature、Top-p 等核心概念与采样参数，帮助开发者真正理解并掌控大模型。", "content_html": "

\"《SpringAI

\n

在探讨 RAG、Agent 工作流、MCP 协议等复杂架构的过程中，我发现一个非常普遍的现象：很多开发者在构建 Agent 工作流或调优 RAG 检索时，往往会在最底层的 LLM 参数上踩坑。比如，为什么明明设置了温度为 0，结构化输出还是偶尔崩溃？为什么往模型里塞了长文档后，它好像失忆了，忽略了 System Prompt 里的关键指令？

\n

万丈高楼平地起。 如果不搞懂底层 LLM 吞吐数据的基本原理，再高级的设计模式在生产环境中也会变得脆弱不堪。

\n

因此，有了这篇基础扫盲文章。我们将暂时放下顶层的架构设计，回到一切的起点。大模型没有魔法，底层只有纯粹的数学与工程。接下来，我们将扒开 LLM 的黑盒，把日常调用 API 时遇到的 Token、上下文窗口、Temperature 等高频词汇，还原为清晰、可控的工程概念。通过本文你将搞懂：

\n
    \n
  1. 大模型（LLM）到底在做什么？
    2. \n
  2. ⭐ Token 是什么？为什么中文和英文的 Token 消耗不同？
    3. \n
  3. ⭐ 上下文窗口是什么？为什么会有上限？
    4. \n
  4. ⭐ Temperature、Top-p、Top-k 等采样参数如何影响输出？
    5. \n
  5. 如何做 Token 预算？输入输出如何计费？
    6. \n
\n

大模型（LLM）到底在做什么

\n

一句话理解大模型

\n

当你在输入法里打“今天天气真”，它会自动建议“好”——大模型做的事情本质上一样，只不过它看的不是前面几个字，而是前面几千甚至几十万个字，且每次只“补”一个 Token（文本碎片），然后把刚补的内容也加入上下文，再预测下一个，如此循环，直到生成完整回答。

\n

这个过程叫做自回归生成（Autoregressive Generation）。

\n

理解了这一点，后面所有概念都有了根基：

\n\n

有了这个心智模型，我们再逐一展开。

\n

全局概念地图

\n

在深入每个概念之前，先看一张完整的调用流程图，帮你在 30 秒内建立全局认知：

\n
用户输入\n  ↓\n[Tokenizer] → Token 序列\n  ↓\n塞入上下文窗口（System Prompt + User Prompt + 历史 + RAG 片段）\n  ↓                                              ↑\n模型推理（自注意力机制）                    [Embedding + 向量检索]\n  ↓                                         从知识库召回相关片段\nlogits → [Temperature/Top-p/Top-k] → 采样出下一个 Token\n  ↓\n重复直到 EOS 或 Max Tokens\n  ↓\n结构化输出解析 & 校验\n  ↓\n业务消费
\n

后续每个小节都能在这张图上找到对应位置。

\n

Token：模型的“阅读单位”

\n

你可以把 Token 理解为“模型的阅读单位”。我们人类读中文是一个字一个字地看，读英文是一个词一个词地看；但模型既不按字、也不按词——它用一套自己的“拆字规则”（叫 Tokenizer）把文本切成大小不等的碎片，每个碎片就是一个 Token。

\n

为什么不直接按字或按词切？ 因为模型需要在“词表大小”和“序列长度”之间取平衡：

\n\n

所以实际使用的是一种折中方案——子词切分算法（如 BPE、Unigram），它会把高频词保留为整体，把低频词拆成更小的片段。

\n
\n

💡 一个直觉：你可以把 Token 想象成乐高积木——常用的“积木块”比较大（比如“你好”可能是一个 Token），不常用的词会被拆成更小的基础块拼起来。

\n
\n

Token 不是“一个字”或“一个词”的严格等价物：

\n\n

因此，工程上通常只用 经验估算 做容量规划，而用 实际 API 返回的 usage（若供应商提供）做精确计费与监控。

\n

经验估算（仅用于粗略规划）：

\n\n

以 DeepSeek 官方数据为例：1 个英文字符约消耗 0.3 Token，1 个中文字符约消耗 0.6 Token。换算过来，1 个 Token 约等于 3.3 个英文字符或 1.7 个中文字符，与上述经验值吻合。

\n

💡 成本趋势提示：Token 成本与编码器（Tokenizer）版本强相关。早期模型（如 GPT-3.5）中文压缩率较低（约 1 字 1.5~2 Token）。GPT-4o 使用 o200k_base Tokenizer（词表约 20 万），相比前代 cl100k_base 对中文的压缩率有进一步提升；Qwen2.5 词表约 15 万，对中文常用词同样有优化。实测数据因文本类型而异：新闻类文本约 1.5 字/Token，技术文档约 1.2 字/Token。“趋近 1 字 1 Token”仅适用于高频词汇，不建议作为成本估算基准。在做成本预算时，请务必查阅当前模型版本的官方 Tokenizer 演示，勿沿用旧模型经验。

\n

Token 划分的精细度会直接影响模型的理解能力。特别是在中文处理时，分词歧义（同一字符序列的多种切分方式）和生僻字/低频专业术语的切分粒度，会直接影响模型的语义理解效果。

\n

Token 化过程示例：

\n\n

\"Token

\n
\n

⚠️ 注意：实际的 Token 切分由模型供应商的 Tokenizer 实现，不同供应商对相同文本可能产生不同的 Token 序列。生产环境中应使用对应供应商的 Tokenizer 工具进行精确计数。

\n
\n

特殊 Token：除了文本内容对应的 Token，模型内部还会使用一些特殊标记，这些也会计入 Token 总数：

\n

| 特殊 Token | 用途 | 示例 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/llm/llm-token-process.png", "date_published": "2023-08-07T10:15:14.000Z", "date_modified": "2026-04-08T07:51:57.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "万字详解 RAG 基础概念", "url": "https://javaguide.cn/ai/rag/rag-basis.html", "id": "https://javaguide.cn/ai/rag/rag-basis.html", "summary": "深入解析 RAG（检索增强生成）核心概念，涵盖 RAG 工作原理、与传统搜索引擎区别、核心优势与局限性等高频面试考点。", "content_html": "

\"《SpringAI

\n

去年面字节的时候，面试官问我：“你们项目里的知识库问答是怎么做的？” 我说：“直接调 OpenAI 的 API，把文档塞进去让模型自己读。”

\n

空气突然安静了三秒。我看到面试官的眉头皱了一下，才意识到事情不对——当时我们项目的文档有 20 多万字，每次请求都超 Token 上限，而且模型根本记不住上周刚更新的接口文档。

\n

面试被挂后才懂：这叫“裸调 LLM”，而正确的做法应该是 RAG。

\n

段子归段子，RAG（检索增强生成）确实是当下 LLM 应用开发的核心技术栈，也是面试中的高频考点。今天 Guide 分享几道 RAG 基础概念相关的面试题，希望对大家有帮助：

\n
    \n
  1. ⭐️ 什么是 RAG？
    2. \n
  2. ⭐️ 为什么需要 RAG？
    3. \n
  3. RAG 的常见用途有哪些？
    4. \n
  4. ⭐️ 既然这些场景这么好，为什么有些企业还是宁愿用传统搜索而不是 RAG？
    5. \n
  5. RAG 工作原理
    6. \n
  6. RAG 与传统搜索引擎的区别是什么？
    7. \n
  7. ⭐️ RAG 的核心优势和局限性分别是什么？
    8. \n
\n

⭐️ 什么是 RAG？

\n

RAG (Retrieval-Augmented Generation，检索增强生成) 是一种将强大的信息检索 (Information Retrieval, IR) 技术与生成式大语言模型 (LLM) 相结合的框架。

\n

RAG 的核心思想是：在让 LLM 回答问题或生成文本之前，先从一个大规模的知识库（如数据库、文档集合）中检索出相关的上下文信息，然后将这些信息与原始问题一并提供给 LLM，从而“增强”其生成能力，使其能够产出更准确、更具时效性、更符合特定领域知识的回答。

\n

\"RAG

\n

⭐️ 为什么需要 RAG？

\n

\"RAG（检索增强生成）如何解决

\n

尽管 LLM 本身拥有海量的知识，但它依然面临三个核心挑战，而 RAG 正是解决这些挑战的有效方案：

\n

1. 解决知识时效性问题（对抗“知识截止”）

\n

预训练的 LLM 的知识被固化在其 训练数据的截止时间点（Knowledge Cutoff）。例如，GPT-4 的知识库可能截止于 2023 年 12 月。对于此后发生的新事件、新知识，LLM 无法直接给出准确答案。RAG 通过 动态检索外部知识源，为 LLM 提供“实时”的知识补充，从而克服了知识过时的问题。

\n

2. 打通私有数据访问（支撑企业级应用）

\n

出于数据安全和商业机密的考虑，企业内部的 私有数据（如产品文档、内部知识库、客户数据等）无法被公开的 LLM 直接访问。RAG 技术能够安全地连接这些私有数据源，在用户提问时，仅将与问题相关的片段信息提取出来提供给 LLM，使其能够在 不泄露全部数据 的前提下，基于企业自身的知识进行回答，实现真正可用的企业级智能应用。

\n

3. 提升回答的准确性与可追溯性（对抗“模型幻觉”）

\n

LLM 有时会产生 “幻觉（Hallucination）” ，即编造不符合事实的信息。RAG 通过提供明确的、有据可查的参考文本，强制 LLM 的回答 基于检索到的事实，大大降低了幻觉的发生率。同时，由于可以展示引用的原文，使得答案的 来源可追溯、可验证，增强了系统的可靠性和用户的信任度。

\n

RAG 的常见用途有哪些？

\n

RAG（检索增强生成）最适合用在 “答案依赖外部资料、且资料会变化/很长” 的场景：先从知识库检索相关内容，再让大模型基于检索结果生成回答，从而减少胡编、提升可追溯性。

\n

下面列举几个最常见的场景：

\n\n

⭐️ 既然这些场景这么好，为什么有些企业还是宁愿用传统搜索而不是 RAG？

\n

因为 RAG 存在推理成本和响应延迟的问题。在某些纯粹为了“找文件”而非“总结答案”的简单场景，传统搜索依然具备极致的效率优势。

\n

下面简单对比一下二者：

\n

| 维度 | 传统搜索（搜索框） | RAG（检索+生成） |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/ai/rag/rag-simplified-architecture-diagram.jpeg", "date_published": "2023-08-07T10:15:14.000Z", "date_modified": "2026-04-10T08:31:20.000Z", "authors": [], "tags": [ "AI 应用开发" ] }, { "title": "SQL常见面试题总结（2）", "url": "https://javaguide.cn/database/sql/sql-questions-02.html", "id": "https://javaguide.cn/database/sql/sql-questions-02.html", "summary": "SQL常见面试题总结第二篇，详解INSERT、UPDATE、DELETE等DML数据操作语句，包括批量插入、从其他表导入、带更新的插入等实战技巧。", "content_html": "
\n

题目来源于：牛客题霸 - SQL 进阶挑战

\n
\n

增删改操作

\n

SQL 插入记录的方式汇总：

\n\n

插入记录（一）

\n

描述：牛客后台会记录每个用户的试卷作答记录到 exam_record 表，现在有两个用户的作答记录详情如下：

\n\n

试卷作答记录表exam_record中，表已建好，其结构如下，请用一条语句将这两条记录插入表中。

\n

| Filed | Type | Null | Key | Extra | Default | Comment |
\n|

\n", "date_published": "2023-07-13T14:23:50.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "SQL常见面试题总结（3）", "url": "https://javaguide.cn/database/sql/sql-questions-03.html", "id": "https://javaguide.cn/database/sql/sql-questions-03.html", "summary": "SQL常见面试题总结第三篇，深入讲解聚合函数COUNT、SUM、AVG、MAX、MIN的使用，以及GROUP BY分组、HAVING过滤、截断平均值计算等进阶技巧。", "content_html": "
\n

题目来源于：牛客题霸 - SQL 进阶挑战

\n
\n

较难或者困难的题目可以根据自身实际情况和面试需要来决定是否要跳过。

\n

聚合函数

\n

SQL 类别高难度试卷得分的截断平均值（较难）

\n

描述： 牛客的运营同学想要查看大家在 SQL 类别中高难度试卷的得分情况。

\n

请你帮她从exam_record数据表中计算所有用户完成 SQL 类别高难度试卷得分的截断平均值（去掉一个最大值和一个最小值后的平均值）。

\n

示例数据：examination_info（exam_id 试卷 ID, tag 试卷类别, difficulty 试卷难度, duration 考试时长, release_time 发布时间）

\n

| id | exam_id | tag | difficulty | duration | release_time |
\n|

\n", "date_published": "2023-07-13T14:23:50.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "SQL常见面试题总结（4）", "url": "https://javaguide.cn/database/sql/sql-questions-04.html", "id": "https://javaguide.cn/database/sql/sql-questions-04.html", "summary": "SQL常见面试题总结第四篇，详解MySQL 8.0窗口函数ROW_NUMBER、RANK、DENSE_RANK、NTILE、LAG、LEAD等的用法和应用场景。", "content_html": "
\n

题目来源于：牛客题霸 - SQL 进阶挑战

\n
\n

较难或者困难的题目可以根据自身实际情况和面试需要来决定是否要跳过。

\n

专用窗口函数

\n

MySQL 8.0 版本引入了窗口函数的支持，下面是 MySQL 中常见的窗口函数及其用法：

\n
    \n
  1. ROW_NUMBER(): 为查询结果集中的每一行分配一个唯一的整数值。
    2. \n
\n
SELECT col1, col2, ROW_NUMBER() OVER (ORDER BY col1) AS row_num\nFROM table;
\n
    \n
  1. RANK(): 计算每一行在排序结果中的排名。
    2. \n
\n
SELECT col1, col2, RANK() OVER (ORDER BY col1 DESC) AS ranking\nFROM table;
\n
    \n
  1. DENSE_RANK(): 计算每一行在排序结果中的排名，保留相同的排名。
    2. \n
\n
SELECT col1, col2, DENSE_RANK() OVER (ORDER BY col1 DESC) AS ranking\nFROM table;
\n
    \n
  1. NTILE(n): 将结果分成 n 个基本均匀的桶，并为每个桶分配一个标识号。
    2. \n
\n
SELECT col1, col2, NTILE(4) OVER (ORDER BY col1) AS bucket\nFROM table;
\n
    \n
  1. SUM(), AVG(),COUNT(), MIN(), MAX(): 这些聚合函数也可以与窗口函数结合使用，计算窗口内指定列的汇总、平均值、计数、最小值和最大值。
    2. \n
\n
SELECT col1, col2, SUM(col1) OVER () AS sum_col\nFROM table;
\n
    \n
  1. LEAD() 和 LAG(): LEAD 函数用于获取当前行之后的某个偏移量的行的值，而 LAG 函数用于获取当前行之前的某个偏移量的行的值。
    2. \n
\n
SELECT col1, col2, LEAD(col1, 1) OVER (ORDER BY col1) AS next_col1,\n                 LAG(col1, 1) OVER (ORDER BY col1) AS prev_col1\nFROM table;
\n
    \n
  1. FIRST_VALUE() 和 LAST_VALUE(): FIRST_VALUE 函数用于获取窗口内指定列的第一个值，LAST_VALUE 函数用于获取窗口内指定列的最后一个值。
    2. \n
\n
SELECT col1, col2, FIRST_VALUE(col2) OVER (PARTITION BY col1 ORDER BY col2) AS first_val,\n                 LAST_VALUE(col2) OVER (PARTITION BY col1 ORDER BY col2) AS last_val\nFROM table;
\n

窗口函数通常需要配合 OVER 子句一起使用，用于定义窗口的大小、排序规则和分组方式。

\n

每类试卷得分前三名

\n

描述：

\n

现有试卷信息表 examination_info（exam_id 试卷 ID, tag 试卷类别, difficulty 试卷难度, duration 考试时长, release_time 发布时间）：

\n

| id | exam_id | tag | difficulty | duration | release_time |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/sql/29A377601170AB822322431FCDF7EDFE.png", "date_published": "2023-07-13T14:23:50.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "SQL常见面试题总结（5）", "url": "https://javaguide.cn/database/sql/sql-questions-05.html", "id": "https://javaguide.cn/database/sql/sql-questions-05.html", "summary": "SQL常见面试题总结第五篇，详解NULL空值处理技巧，包括IFNULL、COALESCE函数，以及使用CASE WHEN进行条件统计和完成率计算。", "content_html": "
\n

题目来源于：牛客题霸 - SQL 进阶挑战

\n
\n

较难或者困难的题目可以根据自身实际情况和面试需要来决定是否要跳过。

\n

空值处理

\n

统计有未完成状态的试卷的未完成数和未完成率

\n

描述：

\n

现有试卷作答记录表 exam_record（uid 用户 ID, exam_id 试卷 ID, start_time 开始作答时间, submit_time 交卷时间, score 得分），数据如下：

\n

| id | uid | exam_id | start_time | submit_time | score |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/sql/D2B491866B85826119EE3474F10D3636.png", "date_published": "2023-07-13T14:23:50.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "LinkedHashMap 源码分析", "url": "https://javaguide.cn/java/collection/linkedhashmap-source-code.html", "id": "https://javaguide.cn/java/collection/linkedhashmap-source-code.html", "summary": "LinkedHashMap源码深度剖析：详解LinkedHashMap维护双向链表实现插入/访问有序、LRU缓存实现、与HashMap区别及遍历效率优化。", "content_html": "

LinkedHashMap 简介

\n

LinkedHashMap 是 Java 提供的一个集合类，它继承自 HashMap，并在 HashMap 基础上维护一条双向链表，使得具备如下特性:

\n
    \n
  1. 支持遍历时会按照插入顺序有序进行迭代。
    2. \n
  2. 支持按照元素访问顺序排序,适用于封装 LRU 缓存工具。
    3. \n
  3. 因为内部使用双向链表维护各个节点，所以遍历时的效率和元素个数成正比，相较于和容量成正比的 HashMap 来说，迭代效率会高很多。
    4. \n
\n

LinkedHashMap 逻辑结构如下图所示，它是在 HashMap 基础上在各个节点之间维护一条双向链表，使得原本散列在不同 bucket 上的节点、链表、红黑树有序关联起来。

\n

\"LinkedHashMap

\n

LinkedHashMap 使用示例

\n

插入顺序遍历

\n

如下所示，我们按照顺序往 LinkedHashMap 添加元素然后进行遍历。

\n
HashMap < String, String > map = new LinkedHashMap < > ();\nmap.put(\"a\", \"2\");\nmap.put(\"g\", \"3\");\nmap.put(\"r\", \"1\");\nmap.put(\"e\", \"23\");\n\nfor (Map.Entry < String, String > entry: map.entrySet()) {\n    System.out.println(entry.getKey() + \":\" + entry.getValue());\n}
\n

输出：

\n
a:2\ng:3\nr:1\ne:23
\n

可以看出，LinkedHashMap 的迭代顺序是和插入顺序一致的,这一点是 HashMap 所不具备的。

\n

访问顺序遍历

\n

LinkedHashMap 定义了排序模式 accessOrder(boolean 类型，默认为 false)，访问顺序则为 true，插入顺序则为 false。

\n

为了实现访问顺序遍历，我们可以使用传入 accessOrder 属性的 LinkedHashMap 构造方法，并将 accessOrder 设置为 true，表示其具备访问有序性。

\n
LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, 0.75f, true);\nmap.put(1, \"one\");\nmap.put(2, \"two\");\nmap.put(3, \"three\");\nmap.put(4, \"four\");\nmap.put(5, \"five\");\n//访问元素2,该元素会被移动至链表末端\nmap.get(2);\n//访问元素3,该元素会被移动至链表末端\nmap.get(3);\nfor (Map.Entry<Integer, String> entry : map.entrySet()) {\n    System.out.println(entry.getKey() + \" : \" + entry.getValue());\n}
\n

输出：

\n
1 : one\n4 : four\n5 : five\n2 : two\n3 : three
\n

可以看出，LinkedHashMap 的迭代顺序是和访问顺序一致的。

\n

LRU 缓存

\n

从上一个我们可以了解到通过 LinkedHashMap 我们可以封装一个简易版的 LRU（Least Recently Used，最近最少使用） 缓存，确保当存放的元素超过容器容量时，将最近最少访问的元素移除。

\n

\n

具体实现思路如下：

\n\n
public class LRUCache<K, V> extends LinkedHashMap<K, V> {\n    private final int capacity;\n\n    public LRUCache(int capacity) {\n        super(capacity, 0.75f, true);\n        this.capacity = capacity;\n    }\n\n    /**\n     * 判断size超过容量时返回true，告知LinkedHashMap移除最老的缓存项(即链表的第一个元素)\n     */\n    @Override\n    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {\n        return size() > capacity;\n    }\n}
\n

测试代码如下，笔者初始化缓存容量为 3，然后按照次序先后添加 4 个元素。

\n
LRUCache<Integer, String> cache = new LRUCache<>(3);\ncache.put(1, \"one\");\ncache.put(2, \"two\");\ncache.put(3, \"three\");\ncache.put(4, \"four\");\ncache.put(5, \"five\");\nfor (int i = 1; i <= 5; i++) {\n    System.out.println(cache.get(i));\n}
\n

输出：

\n
null\nnull\nthree\nfour\nfive
\n

从输出结果来看，由于缓存容量为 3 ，因此，添加第 4 个元素时，第 1 个元素会被删除。添加第 5 个元素时，第 2 个元素会被删除。

\n

LinkedHashMap 源码解析

\n

Node 的设计

\n

在正式讨论 LinkedHashMap 前，我们先来聊聊 LinkedHashMap 节点 Entry 的设计,我们都知道 HashMap 的 bucket 上的因为冲突转为链表的节点会在符合以下两个条件时会将链表转为红黑树:

\n
    \n
  1. 链表上的节点个数达到树化的阈值 7，即TREEIFY_THRESHOLD - 1。
    2. \n
  2. bucket 的容量达到最小的树化容量即MIN_TREEIFY_CAPACITY。
    3. \n
\n
\n

🐛 修正（参见：issue#2147）：

\n

链表上的节点个数达到树化的阈值是 8 而非 7。因为源码的判断是从链表初始元素开始遍历，下标是从 0 开始的，所以判断条件设置为 8-1=7，其实是迭代到尾部元素时再判断整个链表长度大于等于 8 才进行树化操作。

\n

\n
\n

而 LinkedHashMap 是在 HashMap 的基础上为 bucket 上的每一个节点建立一条双向链表，这就使得转为红黑树的树节点也需要具备双向链表节点的特性，即每一个树节点都需要拥有两个引用存储前驱节点和后继节点的地址,所以对于树节点类 TreeNode 的设计就是一个比较棘手的问题。

\n

对此我们不妨来看看两者之间节点类的类图，可以看到:

\n
    \n
  1. LinkedHashMap 的节点内部类 Entry 基于 HashMap 的基础上，增加 before 和 after 指针使节点具备双向链表的特性。
    2. \n
  2. HashMap 的树节点 TreeNode 继承了具备双向链表特性的 LinkedHashMap 的 Entry。
    3. \n
\n

\"LinkedHashMap

\n

很多读者此时就会有这样一个疑问，为什么 HashMap 的树节点 TreeNode 要通过 LinkedHashMap 获取双向链表的特性呢?为什么不直接在 Node 上实现前驱和后继指针呢?

\n

先来回答第一个问题，我们都知道 LinkedHashMap 是在 HashMap 基础上对节点增加双向指针实现双向链表的特性,所以 LinkedHashMap 内部链表转红黑树时，对应的节点会转为树节点 TreeNode,为了保证使用 LinkedHashMap 时树节点具备双向链表的特性，所以树节点 TreeNode 需要继承 LinkedHashMap 的 Entry。

\n

再来说说第二个问题，我们直接在 HashMap 的节点 Node 上直接实现前驱和后继指针,然后 TreeNode 直接继承 Node 获取双向链表的特性为什么不行呢？其实这样做也是可以的。只不过这种做法会使得使用 HashMap 时存储键值对的节点类 Node 多了两个没有必要的引用，占用没必要的内存空间。

\n

所以，为了保证 HashMap 底层的节点类 Node 没有多余的引用，又要保证 LinkedHashMap 的节点类 Entry 拥有存储链表的引用，设计者就让 LinkedHashMap 的节点 Entry 去继承 Node 并增加存储前驱后继节点的引用 before、after，让需要用到链表特性的节点去实现需要的逻辑。然后树节点 TreeNode 再通过继承 Entry 获取 before、after 两个指针。

\n
static class Entry<K,V> extends HashMap.Node<K,V> {\n        Entry<K,V> before, after;\n        Entry(int hash, K key, V value, Node<K,V> next) {\n            super(hash, key, value, next);\n        }\n    }
\n

但是这样做，不也使得使用 HashMap 时的 TreeNode 多了两个没有必要的引用吗?这不也是一种空间的浪费吗？

\n
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {\n  //略\n\n}
\n

对于这个问题,引用作者的一段注释，作者们认为在良好的 hashCode 算法时，HashMap 转红黑树的概率不大。就算转为红黑树变为树节点，也可能会因为移除或者扩容将 TreeNode 变为 Node，所以 TreeNode 的使用概率不算很大，对于这一点资源空间的浪费是可以接受的。

\n
Because TreeNodes are about twice the size of regular nodes, we\nuse them only when bins contain enough nodes to warrant use\n(see TREEIFY_THRESHOLD). And when they become too small (due to\nremoval or resizing) they are converted back to plain bins.  In\nusages with well-distributed user hashCodes, tree bins are\nrarely used.  Ideally, under random hashCodes, the frequency of\nnodes in bins follows a Poisson distribution
\n

构造方法

\n

LinkedHashMap 构造方法有 4 个实现也比较简单，直接调用父类即 HashMap 的构造方法完成初始化。

\n
public LinkedHashMap() {\n    super();\n    accessOrder = false;\n}\n\npublic LinkedHashMap(int initialCapacity) {\n    super(initialCapacity);\n    accessOrder = false;\n}\n\npublic LinkedHashMap(int initialCapacity, float loadFactor) {\n    super(initialCapacity, loadFactor);\n    accessOrder = false;\n}\n\npublic LinkedHashMap(int initialCapacity,\n    float loadFactor,\n    boolean accessOrder) {\n    super(initialCapacity, loadFactor);\n    this.accessOrder = accessOrder;\n}
\n

我们上面也提到了，默认情况下 accessOrder 为 false，如果我们要让 LinkedHashMap 实现键值对按照访问顺序排序(即将最近未访问的元素排在链表首部、最近访问的元素移动到链表尾部)，需要调用第 4 个构造方法将 accessOrder 设置为 true。

\n

get 方法

\n

get 方法是 LinkedHashMap 增删改查操作中唯一一个重写的方法， accessOrder 为 true 的情况下， 它会在元素查询完成之后，将当前访问的元素移到链表的末尾。

\n
public V get(Object key) {\n     Node < K, V > e;\n     //获取key的键值对,若为空直接返回\n     if ((e = getNode(hash(key), key)) == null)\n         return null;\n     //若accessOrder为true，则调用afterNodeAccess将当前元素移到链表末尾\n     if (accessOrder)\n         afterNodeAccess(e);\n     //返回键值对的值\n     return e.value;\n }
\n

从源码可以看出，get 的执行步骤非常简单:

\n
    \n
  1. 调用父类即 HashMap 的 getNode 获取键值对，若为空则直接返回。
    2. \n
  2. 判断 accessOrder 是否为 true，若为 true 则说明需要保证 LinkedHashMap 的链表访问有序性，执行步骤 3。
    3. \n
  3. 调用 LinkedHashMap 重写的 afterNodeAccess 将当前元素添加到链表末尾。
    4. \n
\n

关键点在于 afterNodeAccess 方法的实现，这个方法负责将元素移动到链表末尾。

\n
void afterNodeAccess(Node < K, V > e) { // move node to last\n    LinkedHashMap.Entry < K, V > last;\n    //如果accessOrder 且当前节点不为链表尾节点\n    if (accessOrder && (last = tail) != e) {\n\n        //获取当前节点、以及前驱节点和后继节点\n        LinkedHashMap.Entry < K, V > p =\n            (LinkedHashMap.Entry < K, V > ) e, b = p.before, a = p.after;\n\n        //将当前节点的后继节点指针指向空，使其和后继节点断开联系\n        p.after = null;\n\n        //如果前驱节点为空，则说明当前节点是链表的首节点，故将后继节点设置为首节点\n        if (b == null)\n            head = a;\n        else\n            //如果前驱节点不为空，则让前驱节点指向后继节点\n            b.after = a;\n\n        //如果后继节点不为空，则让后继节点指向前驱节点\n        if (a != null)\n            a.before = b;\n        else\n            //如果后继节点为空，则说明当前节点在链表最末尾，直接让last 指向前驱节点,这个 else其实 没有意义，因为最开头if已经确保了p不是尾结点了，自然after不会是null\n            last = b;\n\n        //如果last为空，则说明当前链表只有一个节点p，则将head指向p\n        if (last == null)\n            head = p;\n        else {\n            //反之让p的前驱指针指向尾节点，再让尾节点的前驱指针指向p\n            p.before = last;\n            last.after = p;\n        }\n        //tail指向p，自此将节点p移动到链表末尾\n        tail = p;\n\n        ++modCount;\n    }\n}
\n

从源码可以看出， afterNodeAccess 方法完成了下面这些操作:

\n
    \n
  1. 如果 accessOrder 为 true 且链表尾部不为当前节点 p，我们则需要将当前节点移到链表尾部。
    2. \n
  2. 获取当前节点 p、以及它的前驱节点 b 和后继节点 a。
    3. \n
  3. 将当前节点 p 的后继指针设置为 null，使其和后继节点 p 断开联系。
    4. \n
  4. 尝试将前驱节点指向后继节点，若前驱节点为空，则说明当前节点 p 就是链表首节点，故直接将后继节点 a 设置为首节点，随后我们再将 p 追加到 a 的末尾。
    5. \n
  5. 再尝试让后继节点 a 指向前驱节点 b。
    6. \n
  6. 上述操作让前驱节点和后继节点完成关联，并将当前节点 p 独立出来，这一步则是将当前节点 p 追加到链表末端，如果链表末端为空，则说明当前链表只有一个节点 p，所以直接让 head 指向 p 即可。
    7. \n
  7. 上述操作已经将 p 成功到达链表末端，最后我们将 tail 指针即指向链表末端的指针指向 p 即可。
    8. \n
\n

可以结合这张图理解，展示了 key 为 13 的元素被移动到了链表尾部。

\n

\"LinkedHashMap

\n

看不太懂也没关系，知道这个方法的作用就够了，后续有时间再慢慢消化。

\n

newNode——新节点尾插链表

\n

上文介绍了 afterNodeAccess 如何将已存在的节点移动到链表尾部，那么新插入的节点是如何被添加到链表中的呢？

\n

答案在于 LinkedHashMap 重写了 HashMap 的 newNode 方法。当 HashMap 插入新键值对时，会调用 newNode 创建节点对象，LinkedHashMap 在重写的方法中不仅创建了 Entry 节点，还额外调用了 linkNodeLast 将其链接到双向链表的尾部：

\n
// HashMap 的 newNode 是普通实现\nNode<K,V> newNode(int hash, K key, V value, Node<K,V> next) {\n    return new Node<>(hash, key, value, next);\n}\n\n// LinkedHashMap 重写 newNode，额外调用 linkNodeLast\nNode<K,V> newNode(int hash, K key, V value, Node<K,V> e) {\n    LinkedHashMap.Entry<K,V> p =\n        new LinkedHashMap.Entry<>(hash, key, value, e);\n    linkNodeLast(p);  // 关键：将新节点链接到链表尾部\n    return p;\n}
\n

linkNodeLast 方法的实现如下：

\n
// 将节点链接到双向链表尾部\nprivate void linkNodeLast(LinkedHashMap.Entry<K,V> p) {\n    LinkedHashMap.Entry<K,V> last = tail;\n    tail = p;  // tail 指向新节点\n    if (last == null)\n        head = p;  // 链表为空，head 也指向新节点\n    else {\n        p.before = last;  // 新节点的前驱指向原尾节点\n        last.after = p;   // 原尾节点的后继指向新节点\n    }\n}
\n

这就是 LinkedHashMap 实现插入有序的核心机制：每次插入新节点时，通过重写 newNode 并调用 linkNodeLast，将新节点追加到双向链表尾部。这样遍历时从头节点 head 开始沿着 after 指针遍历，就能按插入顺序获取所有元素。

\n

同理，LinkedHashMap 也重写了 newTreeNode 方法，确保树节点插入时同样会被链接到链表尾部：

\n
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {\n    TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);\n    linkNodeLast(p);\n    return p;\n}
\n

remove 方法后置操作——afterNodeRemoval

\n

LinkedHashMap 并没有对 remove 方法进行重写，而是直接继承 HashMap 的 remove 方法，为了保证键值对移除后双向链表中的节点也会同步被移除，LinkedHashMap 重写了 HashMap 的空实现方法 afterNodeRemoval。

\n
final Node<K,V> removeNode(int hash, Object key, Object value,\n                               boolean matchValue, boolean movable) {\n        //略\n            if (node != null && (!matchValue || (v = node.value) == value ||\n                                 (value != null && value.equals(v)))) {\n                if (node instanceof TreeNode)\n                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);\n                else if (node == p)\n                    tab[index] = node.next;\n                else\n                    p.next = node.next;\n                ++modCount;\n                --size;\n                //HashMap的removeNode完成元素移除后会调用afterNodeRemoval进行移除后置操作\n                afterNodeRemoval(node);\n                return node;\n            }\n        }\n        return null;\n    }\n//空实现\nvoid afterNodeRemoval(Node<K,V> p) { }
\n

我们可以看到从 HashMap 继承来的 remove 方法内部调用的 removeNode 方法将节点从 bucket 删除后，调用了 afterNodeRemoval。

\n
void afterNodeRemoval(Node<K,V> e) { // unlink\n\n    //获取当前节点p、以及e的前驱节点b和后继节点a\n        LinkedHashMap.Entry<K,V> p =\n            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;\n    //将p的前驱和后继指针都设置为null，使其和前驱、后继节点断开联系\n        p.before = p.after = null;\n\n    //如果前驱节点为空，则说明当前节点p是链表首节点，让head指针指向后继节点a即可\n        if (b == null)\n            head = a;\n        else\n        //如果前驱节点b不为空，则让b直接指向后继节点a\n            b.after = a;\n\n    //如果后继节点为空，则说明当前节点p在链表末端，所以直接让tail指针指向前驱节点a即可\n        if (a == null)\n            tail = b;\n        else\n        //反之后继节点的前驱指针直接指向前驱节点\n            a.before = b;\n    }
\n

从源码可以看出， afterNodeRemoval 方法的整体操作就是让当前节点 p 和前驱节点、后继节点断开联系，等待 gc 回收，整体步骤为:

\n
    \n
  1. 获取当前节点 p、以及 p 的前驱节点 b 和后继节点 a。
    2. \n
  2. 让当前节点 p 和其前驱、后继节点断开联系。
    3. \n
  3. 尝试让前驱节点 b 指向后继节点 a，若 b 为空则说明当前节点 p 在链表首部，我们直接将 head 指向后继节点 a 即可。
    4. \n
  4. 尝试让后继节点 a 指向前驱节点 b，若 a 为空则说明当前节点 p 在链表末端，所以直接让 tail 指针指向前驱节点 b 即可。
    5. \n
\n

可以结合这张图理解，展示了 key 为 13 的元素被删除，也就是从链表中移除了这个元素。

\n

\"LinkedHashMap

\n

看不太懂也没关系，知道这个方法的作用就够了，后续有时间再慢慢消化。

\n

put 方法后置操作——afterNodeInsertion

\n

同样的 LinkedHashMap 并没有实现插入方法，而是直接继承 HashMap 的所有插入方法交由用户使用，但为了维护双向链表访问的有序性，它做了这样两件事:

\n
    \n
  1. 重写 afterNodeAccess(上文提到过),如果当前被插入的 key 已存在与 map 中，因为 LinkedHashMap 的插入操作会将新节点追加至链表末尾，所以对于存在的 key 则调用 afterNodeAccess 将其放到链表末端。
    2. \n
  2. 重写了 HashMap 的 afterNodeInsertion 方法，当 removeEldestEntry 返回 true 时，会将链表首节点移除。
    3. \n
\n

这一点我们可以在 HashMap 的插入操作核心方法 putVal 中看到。

\n
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,\n                   boolean evict) {\n          //略\n            if (e != null) { // existing mapping for key\n                V oldValue = e.value;\n                if (!onlyIfAbsent || oldValue == null)\n                    e.value = value;\n                 //如果当前的key在map中存在，则调用afterNodeAccess\n                afterNodeAccess(e);\n                return oldValue;\n            }\n        }\n        ++modCount;\n        if (++size > threshold)\n            resize();\n         //调用插入后置方法，该方法被LinkedHashMap重写\n        afterNodeInsertion(evict);\n        return null;\n    }
\n

上述步骤的源码上文已经解释过了，所以这里我们着重了解一下 afterNodeInsertion 的工作流程，假设我们的重写了 removeEldestEntry，当链表 size 超过 capacity 时，就返回 true。

\n
/**\n * 判断size超过容量时返回true，告知LinkedHashMap移除最老的缓存项(即链表的第一个元素)\n */\nprotected boolean removeEldestEntry(Map.Entry < K, V > eldest) {\n    return size() > capacity;\n}
\n

以下图为例，假设笔者最后新插入了一个不存在的节点 19,假设 capacity 为 4，所以 removeEldestEntry 返回 true，我们要将链表首节点移除。

\n

\"LinkedHashMap

\n

移除的步骤很简单，查看链表首节点是否存在，若存在则断开首节点和后继节点的关系，并让首节点指针指向下一节点，所以 head 指针指向了 12，节点 10 成为没有任何引用指向的空对象，等待 GC。

\n

\"LinkedHashMap

\n
void afterNodeInsertion(boolean evict) { // possibly remove eldest\n        LinkedHashMap.Entry<K,V> first;\n        //如果evict为true且队首元素不为空以及removeEldestEntry返回true，则说明我们需要最老的元素(即在链表首部的元素)移除。\n        if (evict && (first = head) != null && removeEldestEntry(first)) {\n          //获取链表首部的键值对的key\n            K key = first.key;\n            //调用removeNode将元素从HashMap的bucket中移除，并和LinkedHashMap的双向链表断开，等待gc回收\n            removeNode(hash(key), key, null, false, true);\n        }\n    }
\n

从源码可以看出， afterNodeInsertion 方法完成了下面这些操作:

\n
    \n
  1. 判断 eldest 是否为 true，只有为 true 才能说明可能需要将最年长的键值对(即链表首部的元素)进行移除，具体是否具体要进行移除，还得确定链表是否为空((first = head) != null)，以及 removeEldestEntry 方法是否返回 true，只有这两个方法返回 true 才能确定当前链表不为空，且链表需要进行移除操作了。
    2. \n
  2. 获取链表第一个元素的 key。
    3. \n
  3. 调用 HashMap 的 removeNode 方法，该方法我们上文提到过，它会将节点从 HashMap 的 bucket 中移除，并且 LinkedHashMap 还重写了 removeNode 中的 afterNodeRemoval 方法，所以这一步将通过调用 removeNode 将元素从 HashMap 的 bucket 中移除，并和 LinkedHashMap 的双向链表断开，等待 gc 回收。
    4. \n
\n

LinkedHashMap 和 HashMap 遍历性能比较

\n

LinkedHashMap 维护了一个双向链表来记录数据插入的顺序，因此在迭代遍历生成的迭代器的时候，是按照双向链表的路径进行遍历的。这一点相比于 HashMap 那种遍历整个 bucket 的方式来说，高效许多。

\n

这一点我们可以从两者的迭代器中得以印证，先来看看 HashMap 的迭代器，可以看到 HashMap 迭代键值对时会用到一个 nextNode 方法，该方法会返回 next 指向的下一个元素，并会从 next 开始遍历 bucket 找到下一个 bucket 中不为空的元素 Node。

\n
 final class EntryIterator extends HashIterator\n implements Iterator < Map.Entry < K, V >> {\n     public final Map.Entry < K,\n     V > next() {\n         return nextNode();\n     }\n }\n\n //获取下一个Node\n final Node < K, V > nextNode() {\n     Node < K, V > [] t;\n     //获取下一个元素next\n     Node < K, V > e = next;\n     if (modCount != expectedModCount)\n         throw new ConcurrentModificationException();\n     if (e == null)\n         throw new NoSuchElementException();\n     //将next指向bucket中下一个不为空的Node\n     if ((next = (current = e).next) == null && (t = table) != null) {\n         do {} while (index < t.length && (next = t[index++]) == null);\n     }\n     return e;\n }
\n

相比之下 LinkedHashMap 的迭代器则是直接使用通过 after 指针快速定位到当前节点的后继节点，简洁高效许多。

\n
 final class LinkedEntryIterator extends LinkedHashIterator\n implements Iterator < Map.Entry < K, V >> {\n     public final Map.Entry < K,\n     V > next() {\n         return nextNode();\n     }\n }\n //获取下一个Node\n final LinkedHashMap.Entry < K, V > nextNode() {\n     //获取下一个节点next\n     LinkedHashMap.Entry < K, V > e = next;\n     if (modCount != expectedModCount)\n         throw new ConcurrentModificationException();\n     if (e == null)\n         throw new NoSuchElementException();\n     //current 指针指向当前节点\n     current = e;\n     //next直接当前节点的after指针快速定位到下一个节点\n     next = e.after;\n     return e;\n }
\n

为了验证笔者所说的观点，笔者对这两个容器进行了压测，测试插入 1000w 和迭代 1000w 条数据的耗时，代码如下:

\n
int count = 1000_0000;\nMap<Integer, Integer> hashMap = new HashMap<>();\nMap<Integer, Integer> linkedHashMap = new LinkedHashMap<>();\n\nlong start, end;\n\nstart = System.currentTimeMillis();\nfor (int i = 0; i < count; i++) {\n    hashMap.put(ThreadLocalRandom.current().nextInt(1, count), ThreadLocalRandom.current().nextInt(0, count));\n}\nend = System.currentTimeMillis();\nSystem.out.println(\"map time putVal: \" + (end - start));\n\nstart = System.currentTimeMillis();\nfor (int i = 0; i < count; i++) {\n    linkedHashMap.put(ThreadLocalRandom.current().nextInt(1, count), ThreadLocalRandom.current().nextInt(0, count));\n}\nend = System.currentTimeMillis();\nSystem.out.println(\"linkedHashMap putVal time: \" + (end - start));\n\nstart = System.currentTimeMillis();\nlong num = 0;\nfor (Integer v : hashMap.values()) {\n    num = num + v;\n}\nend = System.currentTimeMillis();\nSystem.out.println(\"map get time: \" + (end - start));\n\nstart = System.currentTimeMillis();\nfor (Integer v : linkedHashMap.values()) {\n    num = num + v;\n}\nend = System.currentTimeMillis();\nSystem.out.println(\"linkedHashMap get time: \" + (end - start));\nSystem.out.println(num);
\n

从输出结果来看，因为 LinkedHashMap 需要维护双向链表的缘故，插入元素相较于 HashMap 会更耗时，但是有了双向链表明确的前后节点关系，迭代效率相对于前者高效了许多。不过，总体来说却别不大，毕竟数据量这么庞大。

\n
map time putVal: 5880\nlinkedHashMap putVal time: 7567\nmap get time: 143\nlinkedHashMap get time: 67\n63208969074998
\n

LinkedHashMap 常见面试题

\n

什么是 LinkedHashMap？

\n

LinkedHashMap 是 Java 集合框架中 HashMap 的一个子类，它继承了 HashMap 的所有属性和方法，并且在 HashMap 的基础重写了 afterNodeRemoval、afterNodeInsertion、afterNodeAccess 方法。使之拥有顺序插入和访问有序的特性。

\n

LinkedHashMap 如何按照插入顺序迭代元素？

\n

LinkedHashMap 按照插入顺序迭代元素是它的默认行为。LinkedHashMap 内部维护了一个双向链表，用于记录元素的插入顺序。因此，当使用迭代器迭代元素时，元素的顺序与它们最初插入的顺序相同。

\n

LinkedHashMap 如何按照访问顺序迭代元素？

\n

LinkedHashMap 可以通过构造函数中的 accessOrder 参数指定按照访问顺序迭代元素。当 accessOrder 为 true 时，每次访问一个元素时，该元素会被移动到链表的末尾，因此下次访问该元素时，它就会成为链表中的最后一个元素，从而实现按照访问顺序迭代元素。

\n

LinkedHashMap 如何实现 LRU 缓存？

\n

将 accessOrder 设置为 true 并重写 removeEldestEntry 方法当链表大小超过容量时返回 true，使得每次访问一个元素时，该元素会被移动到链表的末尾。一旦插入操作让 removeEldestEntry 返回 true 时，视为缓存已满，LinkedHashMap 就会将链表首元素移除，由此我们就能实现一个 LRU 缓存。

\n

LinkedHashMap 和 HashMap 有什么区别？

\n

LinkedHashMap 和 HashMap 都是 Java 集合框架中的 Map 接口的实现类。它们的最大区别在于迭代元素的顺序。HashMap 迭代元素的顺序是不确定的，而 LinkedHashMap 提供了按照插入顺序或访问顺序迭代元素的功能。此外，LinkedHashMap 内部维护了一个双向链表，用于记录元素的插入顺序或访问顺序，而 HashMap 则没有这个链表。因此，LinkedHashMap 的插入性能可能会比 HashMap 略低，但它提供了更多的功能并且迭代效率相较于 HashMap 更加高效。

\n

参考文献

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/collection/linkhashmap-structure-overview.png", "date_published": "2023-07-11T13:02:50.000Z", "date_modified": "2026-03-11T02:51:59.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "DelayQueue 源码分析", "url": "https://javaguide.cn/java/collection/delayqueue-source-code.html", "id": "https://javaguide.cn/java/collection/delayqueue-source-code.html", "summary": "DelayQueue源码深度解析：详解延迟队列实现原理、Delayed接口使用、延时任务调度、订单超时取消等应用场景、基于PriorityQueue的线程安全设计。", "content_html": "

DelayQueue 简介

\n

DelayQueue 是 JUC 包(java.util.concurrent)为我们提供的延迟队列，用于实现延时任务比如订单下单 15 分钟未支付直接取消。它是 BlockingQueue 的一种，底层是一个基于 PriorityQueue 实现的一个无界队列，是线程安全的。关于PriorityQueue可以参考笔者编写的这篇文章：PriorityQueue 源码分析 。

\n

\"BlockingQueue

\n

DelayQueue 中存放的元素必须实现 Delayed 接口，并且需要重写 getDelay()方法（计算是否到期）。

\n
public interface Delayed extends Comparable<Delayed> {\n    long getDelay(TimeUnit unit);\n}
\n

默认情况下, DelayQueue 会按照到期时间升序编排任务。只有当元素过期时（getDelay()方法返回值小于等于 0），才能从队列中取出。

\n

DelayQueue 发展史

\n\n

总的来说，DelayQueue 的发展史主要是通过优化其实现方式和提高其性能和可靠性，使其更加适用于基于时间的调度和缓存过期删除等场景。

\n

DelayQueue 常见使用场景示例

\n

我们这里希望任务可以按照我们预期的时间执行，例如提交 3 个任务，分别要求 1s、2s、3s 后执行，即使是乱序添加，1s 后要求 1s 执行的任务会准时执行。

\n

\"延迟任务\"

\n

对此我们可以使用 DelayQueue 来实现,所以我们首先需要继承 Delayed 实现 DelayedTask，实现 getDelay 方法以及优先级比较 compareTo。

\n
/**\n * 延迟任务\n */\npublic class DelayedTask implements Delayed {\n    /**\n     * 任务到期时间\n     */\n    private long executeTime;\n    /**\n     * 任务\n     */\n    private Runnable task;\n\n    public DelayedTask(long delay, Runnable task) {\n        this.executeTime = System.currentTimeMillis() + delay;\n        this.task = task;\n    }\n\n    /**\n     * 查看当前任务还有多久到期\n     * @param unit\n     * @return\n     */\n    @Override\n    public long getDelay(TimeUnit unit) {\n        return unit.convert(executeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);\n    }\n\n    /**\n     * 延迟队列需要到期时间升序入队，所以我们需要实现compareTo进行到期时间比较\n     * @param o\n     * @return\n     */\n    @Override\n    public int compareTo(Delayed o) {\n        return Long.compare(this.executeTime, ((DelayedTask) o).executeTime);\n    }\n\n    public void execute() {\n        task.run();\n    }\n}
\n

完成任务的封装之后，使用就很简单了，设置好多久到期然后将任务提交到延迟队列中即可。

\n
// 创建延迟队列，并添加任务\nDelayQueue < DelayedTask > delayQueue = new DelayQueue < > ();\n\n//分别添加1s、2s、3s到期的任务\ndelayQueue.add(new DelayedTask(2000, () -> System.out.println(\"Task 2\")));\ndelayQueue.add(new DelayedTask(1000, () -> System.out.println(\"Task 1\")));\ndelayQueue.add(new DelayedTask(3000, () -> System.out.println(\"Task 3\")));\n\n// 取出任务并执行\nwhile (!delayQueue.isEmpty()) {\n  //阻塞获取最先到期的任务\n  DelayedTask task = delayQueue.take();\n  if (task != null) {\n    task.execute();\n  }\n}
\n

从输出结果可以看出，即使笔者先提到 2s 到期的任务，1s 到期的任务 Task1 还是优先执行的。

\n
Task 1\nTask 2\nTask 3
\n

DelayQueue 源码解析

\n

这里以 JDK1.8 为例，分析一下 DelayQueue 的底层核心源码。

\n

DelayQueue 的类定义如下：

\n
public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E>\n{\n  //...\n}
\n

DelayQueue 继承了 AbstractQueue 类，实现了 BlockingQueue 接口。

\n

\"DelayQueue类图\"

\n

核心成员变量

\n

DelayQueue 的 4 个核心成员变量如下：

\n
//可重入锁，实现线程安全的关键\nprivate final transient ReentrantLock lock = new ReentrantLock();\n//延迟队列底层存储数据的集合,确保元素按照到期时间升序排列\nprivate final PriorityQueue<E> q = new PriorityQueue<E>();\n\n//指向准备执行优先级最高的线程\nprivate Thread leader = null;\n//实现多线程之间等待唤醒的交互\nprivate final Condition available = lock.newCondition();
\n
\n

构造方法

\n

相较于其他的并发容器，延迟队列的构造方法比较简单，它只有两个构造方法，因为所有成员变量在类加载时都已经初始完成了，所以默认构造方法什么也没做。还有一个传入 Collection 对象的构造方法，它会将调用 addAll()方法将集合元素存到优先队列 q 中。

\n
public DelayQueue() {}\n\npublic DelayQueue(Collection<? extends E> c) {\n    this.addAll(c);\n}
\n

添加元素

\n

DelayQueue 添加元素的方法无论是 add、put 还是 offer,本质上就是调用一下 offer ,所以了解延迟队列的添加逻辑我们只需阅读 offer 方法即可。

\n

offer 方法的整体逻辑为:

\n
    \n
  1. 尝试获取 lock 。
    2. \n
  2. 如果上锁成功,则调 q 的 offer 方法将元素存放到优先队列中。
    3. \n
  3. 调用 peek 方法看看当前队首元素是否就是本次入队的元素,如果是则说明当前这个元素是即将到期的任务(即优先级最高的元素)，于是将 leader 设置为空,通知因为队列为空时调用 take 等方法导致阻塞的线程来争抢元素。
    4. \n
  4. 上述步骤执行完成，释放 lock。
    5. \n
  5. 返回 true。
    6. \n
\n

源码如下，笔者已详细注释，读者可自行参阅:

\n
public boolean offer(E e) {\n    //尝试获取lock\n    final ReentrantLock lock = this.lock;\n    lock.lock();\n    try {\n        //如果上锁成功,则调q的offer方法将元素存放到优先队列中\n        q.offer(e);\n        //调用peek方法看看当前队首元素是否就是本次入队的元素,如果是则说明当前这个元素是即将到期的任务(即优先级最高的元素)\n        if (q.peek() == e) {\n            //将leader设置为空,通知调用取元素方法而阻塞的线程来争抢这个任务\n            leader = null;\n            available.signal();\n        }\n        return true;\n    } finally {\n        //上述步骤执行完成，释放lock\n        lock.unlock();\n    }\n}
\n

获取元素

\n

DelayQueue 中获取元素的方式分为阻塞式和非阻塞式，先来看看逻辑比较复杂的阻塞式获取元素方法 take,为了让读者可以更直观的了解阻塞式获取元素的全流程，笔者将以 3 个线程并发获取元素为例讲述 take 的工作流程。

\n
\n

想要理解下面的内容，需要用到 AQS 相关的知识，推荐阅读下面这两篇文章：

\n\n
\n

1、首先， 3 个线程会尝试获取可重入锁 lock,假设我们现在有 3 个线程分别是 t1、t2、t3,随后 t1 得到了锁，而 t2、t3 没有抢到锁，故将这两个线程存入等待队列中。

\n

\n

2、紧接着 t1 开始进行元素获取的逻辑。

\n

3、线程 t1 首先会查看 DelayQueue 队列首元素是否为空。

\n

4、如果元素为空，则说明当前队列没有任何元素，故 t1 就会被阻塞存到 conditionWaiter 这个队列中。

\n

\n

注意，调用 await 之后 t1 就会释放 lcok 锁，假如 DelayQueue 持续为空，那么 t2、t3 也会像 t1 一样执行相同的逻辑并进入 conditionWaiter 队列中。

\n

\n

如果元素不为空，则判断当前任务是否到期，如果元素到期，则直接返回出去。如果元素未到期，则判断当前 leader 线程(DelayQueue 中唯一一个可以等待并获取元素的线程引用)是否为空，若不为空，则说明当前 leader 正在等待执行一个优先级比当前元素还高的元素到期，故当前线程 t1 只能调用 await 进入无限期等待，等到 leader 取得元素后唤醒。反之，若 leader 线程为空，则将当前线程设置为 leader 并进入有限期等待,到期后取出元素并返回。

\n

自此我们阻塞式获取元素的逻辑都已完成后,源码如下，读者可自行参阅:

\n
public E take() throws InterruptedException {\n    // 尝试获取可重入锁,将底层AQS的state设置为1,并设置为独占锁\n    final ReentrantLock lock = this.lock;\n    lock.lockInterruptibly();\n    try {\n        for (;;) {\n            //查看队列第一个元素\n            E first = q.peek();\n            //若为空,则将当前线程放入ConditionObject的等待队列中，并将底层AQS的state设置为0，表示释放锁并进入无限期等待\n            if (first == null)\n                available.await();\n            else {\n                //若元素不为空，则查看当前元素多久到期\n                long delay = first.getDelay(NANOSECONDS);\n                //如果小于0则说明已到期直接返回出去\n                if (delay <= 0)\n                    return q.poll();\n                //如果大于0则说明任务还没到期，首先需要释放对这个元素的引用\n                first = null; // don't retain ref while waiting\n                //判断leader是否为空，如果不为空，则说明正有线程作为leader并等待一个任务到期，则当前线程进入无限期等待\n                if (leader != null)\n                    available.await();\n                else {\n                    //反之将我们的线程成为leader\n                    Thread thisThread = Thread.currentThread();\n                    leader = thisThread;\n                    try {\n                        //并进入有限期等待\n                        available.awaitNanos(delay);\n                    } finally {\n                        //等待任务到期时，释放leader引用，进入下一次循环将任务return出去\n                        if (leader == thisThread)\n                            leader = null;\n                    }\n                }\n            }\n        }\n    } finally {\n        // 收尾逻辑:当leader为null，并且队列中有任务时，唤醒等待的获取元素的线程。\n        if (leader == null && q.peek() != null)\n            available.signal();\n        //释放锁\n        lock.unlock();\n    }\n}
\n

我们再来看看非阻塞的获取元素方法 poll ，逻辑比较简单，整体步骤如下:

\n
    \n
  1. 尝试获取可重入锁。
    2. \n
  2. 查看队列第一个元素,判断元素是否为空。
    3. \n
  3. 若元素为空，或者元素未到期，则直接返回空。
    4. \n
  4. 若元素不为空且到期了，直接调用 poll 返回出去。
    5. \n
  5. 释放可重入锁 lock 。
    6. \n
\n

源码如下,读者可自行参阅源码及注释:

\n
public E poll() {\n    //尝试获取可重入锁\n    final ReentrantLock lock = this.lock;\n    lock.lock();\n    try {\n        //查看队列第一个元素,判断元素是否为空\n        E first = q.peek();\n\n        //若元素为空，或者元素未到期，则直接返回空\n        if (first == null || first.getDelay(NANOSECONDS) > 0)\n            return null;\n        else\n            //若元素不为空且到期了，直接调用poll返回出去\n            return q.poll();\n    } finally {\n        //释放可重入锁lock\n        lock.unlock();\n    }\n}
\n

查看元素

\n

上文获取元素时都会调用到 peek 方法，peek 顾名思义仅仅窥探一下队列中的元素，它的步骤就 4 步:

\n
    \n
  1. 上锁。
    2. \n
  2. 调用优先队列 q 的 peek 方法查看索引 0 位置的元素。
    3. \n
  3. 释放锁。
    4. \n
  4. 将元素返回出去。
    5. \n
\n
public E peek() {\n    final ReentrantLock lock = this.lock;\n    lock.lock();\n    try {\n        return q.peek();\n    } finally {\n        lock.unlock();\n    }\n}
\n

DelayQueue 常见面试题

\n

DelayQueue 的实现原理是什么？

\n

DelayQueue 底层是使用优先队列 PriorityQueue 来存储元素，而 PriorityQueue 采用二叉小顶堆的思想确保值小的元素排在最前面，这就使得 DelayQueue 对于延迟任务优先级的管理就变得十分方便了。同时 DelayQueue 为了保证线程安全还用到了可重入锁 ReentrantLock,确保单位时间内只有一个线程可以操作延迟队列。最后，为了实现多线程之间等待和唤醒的交互效率，DelayQueue 还用到了 Condition，通过 Condition 的 await 和 signal 方法完成多线程之间的等待唤醒。

\n

DelayQueue 的实现是否线程安全？

\n

DelayQueue 的实现是线程安全的，它通过 ReentrantLock 实现了互斥访问和 Condition 实现了线程间的等待和唤醒操作，可以保证多线程环境下的安全性和可靠性。

\n

DelayQueue 的使用场景有哪些？

\n

DelayQueue 通常用于实现定时任务调度和缓存过期删除等场景。在定时任务调度中，需要将需要执行的任务封装成延迟任务对象，并将其添加到 DelayQueue 中，DelayQueue 会自动按照剩余延迟时间进行升序排序(默认情况)，以保证任务能够按照时间先后顺序执行。对于缓存过期这个场景而言，在数据被缓存到内存之后，我们可以将缓存的 key 封装成一个延迟的删除任务，并将其添加到 DelayQueue 中，当数据过期时，拿到这个任务的 key，将这个 key 从内存中移除。

\n

DelayQueue 中 Delayed 接口的作用是什么？

\n

Delayed 接口定义了元素的剩余延迟时间(getDelay)和元素之间的比较规则(该接口继承了 Comparable 接口)。若希望元素能够存放到 DelayQueue 中，就必须实现 Delayed 接口的 getDelay() 方法和 compareTo() 方法，否则 DelayQueue 无法得知当前任务剩余时长和任务优先级的比较。

\n

DelayQueue 和 Timer/TimerTask 的区别是什么？

\n

DelayQueue 和 Timer/TimerTask 都可以用于实现定时任务调度，但是它们的实现方式不同。DelayQueue 是基于优先级队列和堆排序算法实现的，可以实现多个任务按照时间先后顺序执行；而 Timer/TimerTask 是基于单线程实现的，只能按照任务的执行顺序依次执行，如果某个任务执行时间过长，会影响其他任务的执行。另外，DelayQueue 还支持动态添加和移除任务，而 Timer/TimerTask 只能在创建时指定任务。

\n

参考文献

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/collection/blocking-queue-hierarchy.png", "date_published": "2023-06-30T11:46:59.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "常见加密算法总结", "url": "https://javaguide.cn/system-design/security/encryption-algorithms.html", "id": "https://javaguide.cn/system-design/security/encryption-algorithms.html", "summary": "常见加密算法详解，涵盖AES、RSA等对称与非对称加密算法及MD5、SHA等哈希算法的原理与应用场景。", "content_html": "

加密算法是一种用数学方法对数据进行变换的技术，目的是保护数据的安全，防止被未经授权的人读取或修改。加密算法可以分为三大类：对称加密算法、非对称加密算法和哈希算法（也叫摘要算法）。

\n

日常开发中常见的需要用到加密算法的场景：

\n
    \n
  1. 保存在数据库中的密码需要加盐之后使用哈希算法（比如 BCrypt）进行加密。
    2. \n
  2. 保存在数据库中的银行卡号、身份号这类敏感数据需要使用对称加密算法（比如 AES）保存。
    3. \n
  3. 网络传输的敏感数据比如银行卡号、身份号需要用 HTTPS + 非对称加密算法（如 RSA）来保证传输数据的安全性。
    4. \n
  4. ……
    5. \n
\n

ps: 严格上来说，哈希算法其实不属于加密算法，只是可以用到某些加密场景中（例如密码加密），两者可以看作是并列关系。加密算法通常指的是可以将明文转换为密文，并且能够通过某种方式（如密钥）再将密文还原为明文的算法。而哈希算法是一种单向过程，它将输入信息转换成一个固定长度的、看似随机的哈希值，但这个过程是不可逆的，也就是说，不能从哈希值还原出原始信息。

\n

哈希算法

\n

哈希算法也叫散列函数或摘要算法，它的作用是对任意长度的数据生成一个固定长度的唯一标识，也叫哈希值、散列值或消息摘要（后文统称为哈希值）。

\n

\"哈希算法效果演示\"

\n

哈希算法的是不可逆的，你无法通过哈希之后的值再得到原值。

\n

哈希值的作用是可以用来验证数据的完整性和一致性。

\n

举两个实际的例子：

\n\n

这种算法的特点是不可逆：

\n\n

哈希算法可以简单分为两类：

\n
    \n
  1. 加密哈希算法：安全性较高的哈希算法，它可以提供一定的数据完整性保护和数据防篡改能力，能够抵御一定的攻击手段，安全性相对较高，但性能较差，适用于对安全性要求较高的场景。例如 SHA2、SHA3、SM3、RIPEMD-160、BLAKE2 等等。
    2. \n
  2. 非加密哈希算法：安全性相对较低的哈希算法，易受到暴力破解、冲突攻击等攻击手段的影响，但性能较高，适用于对安全性没有要求的业务场景。例如 CRC32、MurMurHash3 等等。
    3. \n
\n

除了这两种之外，还有一些特殊的哈希算法，例如安全性更高的慢哈希算法。

\n

常见的哈希算法有：

\n\n

哈希算法一般是不需要密钥的，但也存在部分特殊哈希算法需要密钥。例如，MAC 和 SipHash 就是一种基于密钥的哈希算法，它在哈希算法的基础上增加了一个密钥，使得只有知道密钥的人才能验证数据的完整性和来源。

\n

MD

\n

MD 算法有多个版本，包括 MD2、MD4、MD5 等，其中 MD5 是最常用的版本，它可以生成一个 128 位（16 字节）的哈希值。从安全性上说：MD5 > MD4 > MD2。除了这些版本，还有一些基于 MD4 或 MD5 改进的算法，如 RIPEMD、HAVAL 等。

\n

即使是最安全 MD 算法 MD5 也存在被破解的风险，攻击者可以通过暴力破解或彩虹表攻击等方式，找到与原始数据相同的哈希值，从而破解数据。

\n

为了增加破解难度，通常可以选择加盐。盐（Salt）在密码学中，是指通过在密码任意固定位置插入特定的字符串，让哈希后的结果和使用原始密码的哈希结果不相符，这种过程称之为“加盐”。

\n

加盐之后就安全了吗？并不一定，这只是增加了破解难度，不代表无法破解。而且，MD5 算法本身就存在弱碰撞（Collision）问题，即多个不同的输入产生相同的 MD5 值。

\n

因此，MD 算法已经不被推荐使用，建议使用更安全的哈希算法比如 SHA-2、Bcrypt。

\n

Java 提供了对 MD 算法系列的支持，包括 MD2、MD5。

\n

MD5 代码示例（未加盐）：

\n
String originalString = \"Java学习 + 面试指南：javaguide.cn\";\n// 创建MD5摘要对象\nMessageDigest messageDigest = MessageDigest.getInstance(\"MD5\");\nmessageDigest.update(originalString.getBytes(StandardCharsets.UTF_8));\n// 计算哈希值\nbyte[] result = messageDigest.digest();\n// 将哈希值转换为十六进制字符串\nString hexString = new HexBinaryAdapter().marshal(result);\nSystem.out.println(\"Original String: \" + originalString);\nSystem.out.println(\"MD5 Hash: \" + hexString.toLowerCase());
\n

输出：

\n
Original String: Java学习 + 面试指南：javaguide.cn\nMD5 Hash: fb246796f5b1b60d4d0268c817c608fa
\n

SHA

\n

SHA（Secure Hash Algorithm）系列算法是一组密码哈希算法，用于将任意长度的数据映射为固定长度的哈希值。SHA 系列算法由美国国家安全局（NSA）于 1993 年设计，目前共有 SHA-1、SHA-2、SHA-3 三种版本。

\n

SHA-1 算法将任意长度的数据映射为 160 位的哈希值。然而，SHA-1 算法存在一些严重的缺陷，比如安全性低，容易受到碰撞攻击和长度扩展攻击。因此，SHA-1 算法已经不再被推荐使用。 SHA-2 家族（如 SHA-256、SHA-384、SHA-512 等）和 SHA-3 系列是 SHA-1 算法的替代方案，它们都提供了更高的安全性和更长的哈希值长度。

\n

SHA-2 家族是在 SHA-1 算法的基础上改进而来的，它们采用了更复杂的运算过程和更多的轮次，使得攻击者更难以通过预计算或巧合找到碰撞。

\n

为了寻找一种更安全和更先进的密码哈希算法，美国国家标准与技术研究院（National Institute of Standards and Technology，简称 NIST）在 2007 年公开征集 SHA-3 的候选算法。NIST 一共收到了 64 个算法方案，经过多轮的评估和筛选，最终在 2012 年宣布 Keccak 算法胜出，成为 SHA-3 的标准算法（SHA-3 与 SHA-2 算法没有直接的关系）。 Keccak 算法具有与 MD 和 SHA-1/2 完全不同的设计思路，即海绵结构（Sponge Construction），使得传统攻击方法无法直接应用于 SHA-3 的攻击中（能够抵抗目前已知的所有攻击方式包括碰撞攻击、长度扩展攻击、差分攻击等）。

\n

由于 SHA-2 算法还没有出现重大的安全漏洞，而且在软件中的效率更高，所以大多数人还是倾向于使用 SHA-2 算法。

\n

相比 MD5 算法，SHA-2 算法之所以更强，主要有两个原因：

\n\n

当然，SHA-2 也不是绝对安全的，也有被暴力破解或者彩虹表攻击的风险，所以，在实际的应用中，加盐还是必不可少的。

\n

Java 提供了对 SHA 算法系列的支持，包括 SHA-1、SHA-256、SHA-384 和 SHA-512。

\n

SHA-256 代码示例（未加盐）：

\n
String originalString = \"Java学习 + 面试指南：javaguide.cn\";\n// 创建SHA-256摘要对象\nMessageDigest messageDigest = MessageDigest.getInstance(\"SHA-256\");\nmessageDigest.update(originalString.getBytes());\n// 计算哈希值\nbyte[] result = messageDigest.digest();\n// 将哈希值转换为十六进制字符串\nString hexString = new HexBinaryAdapter().marshal(result);\nSystem.out.println(\"Original String: \" + originalString);\nSystem.out.println(\"SHA-256 Hash: \" + hexString.toLowerCase());
\n

输出：

\n
Original String: Java学习 + 面试指南：javaguide.cn\nSHA-256 Hash: 184eb7e1d7fb002444098c9bde3403c6f6722c93ecfac242c0e35cd9ed3b41cd
\n

Bcrypt

\n

Bcrypt 算法是一种基于 Blowfish 加密算法的密码哈希算法，专门为密码加密而设计，安全性高。

\n

由于 Bcrypt 采用了 salt（盐） 和 cost（成本） 两种机制，它可以有效地防止彩虹表攻击和暴力破解攻击，从而保证密码的安全性。salt 是一个随机生成的字符串，用于和密码混合，增加密码的复杂度和唯一性。cost 是一个数值参数，用于控制 Bcrypt 算法的迭代次数，增加密码哈希的计算时间和资源消耗。

\n

Bcrypt 算法可以根据实际情况进行调整加密的复杂度，可以设置不同的 cost 值和 salt 值，从而满足不同的安全需求，灵活性很高。

\n

Java 应用程序的安全框架 Spring Security 支持多种密码编码器，其中 BCryptPasswordEncoder 是官方推荐的一种，它使用 BCrypt 算法对用户的密码进行加密存储。

\n
@Bean\npublic PasswordEncoder passwordEncoder(){\n    return new BCryptPasswordEncoder();\n}
\n

对称加密

\n

对称加密算法是指加密和解密使用同一个密钥的算法，也叫共享密钥加密算法。

\n

\"对称加密\"

\n

常见的对称加密算法有 DES、3DES、AES 等。

\n

DES 和 3DES

\n

DES（Data Encryption Standard）使用 64 位的密钥(有效秘钥长度为 56 位,8 位奇偶校验位)和 64 位的明文进行加密。

\n

虽然 DES 一次只能加密 64 位，但我们只需要把明文划分成 64 位一组的块，就可以实现任意长度明文的加密。如果明文长度不是 64 位的倍数，必须进行填充，常用的模式有 PKCS5Padding, PKCS7Padding, NOPADDING。

\n

DES 加密算法的基本思想是将 64 位的明文分成两半，然后对每一半进行多轮的变换，最后再合并成 64 位的密文。这些变换包括置换、异或、选择、移位等操作，每一轮都使用了一个子密钥，而这些子密钥都是由同一个 56 位的主密钥生成的。DES 加密算法总共进行了 16 轮变换，最后再进行一次逆置换，得到最终的密文。

\n

\"DES（Data

\n

这是一个经典的对称加密算法，但也有明显的缺陷，即 56 位的密钥安全性不足，已被证实可以在短时间内破解。

\n

为了提高 DES 算法的安全性，人们提出了一些变种或者替代方案，例如 3DES（Triple DES）。

\n

3DES（Triple DES）是 DES 向 AES 过渡的加密算法，它使用 2 个或者 3 个 56 位的密钥对数据进行三次加密。3DES 相当于是对每个数据块应用三次 DES 的对称加密算法。

\n

为了兼容普通的 DES，3DES 并没有直接使用 加密->加密->加密 的方式，而是采用了加密->解密->加密 的方式。当三种密钥均相同时，前两步相互抵消，相当于仅实现了一次加密，因此可实现对普通 DES 加密算法的兼容。3DES 比 DES 更为安全，但其处理速度不高。

\n

AES

\n

AES（Advanced Encryption Standard）算法是一种更先进的对称密钥加密算法，它使用 128 位、192 位或 256 位的密钥对数据进行加密或解密，密钥越长，安全性越高。

\n

AES 也是一种分组(或者叫块)密码，分组长度只能是 128 位，也就是说，每个分组为 16 个字节。AES 加密算法有多种工作模式（mode of operation），如：ECB、CBC、OFB、CFB、CTR、XTS、OCB、GCM（目前使用最广泛的模式）。不同的模式参数和加密流程不同，但是核心仍然是 AES 算法。

\n

和 DES 类似，对于不是 128 位倍数的明文需要进行填充，常用的填充模式有 PKCS5Padding, PKCS7Padding, NOPADDING。不过，AES-GCM 是流加密算法，可以对任意长度的明文进行加密，所以对应的填充模式为 NoPadding，即无需填充。

\n

AES 的速度比 3DES 快，而且更安全。

\n

\"AES（Advanced

\n

DES 算法和 AES 算法简单对比（图片来自于：RSA vs. AES Encryption: Key Differences Explained）：

\n

\"DES

\n

基于 Java 实现 AES 算法代码示例：

\n
private static final String AES_ALGORITHM = \"AES\";\n// AES密钥\nprivate static final String AES_SECRET_KEY = \"4128D9CDAC7E2F82951CBAF7FDFE675B\";\n// AES加密模式为GCM，填充方式为NoPadding\n// AES-GCM 是流加密（Stream cipher）算法，所以对应的填充模式为 NoPadding，即无需填充。\nprivate static final String AES_TRANSFORMATION = \"AES/GCM/NoPadding\";\n// 加密器\nprivate static Cipher encryptionCipher;\n// 解密器\nprivate static Cipher decryptionCipher;\n\n/**\n * 完成一些初始化工作\n */\npublic static void init() throws Exception {\n    // 将AES密钥转换为SecretKeySpec对象\n    SecretKeySpec secretKeySpec = new SecretKeySpec(AES_SECRET_KEY.getBytes(), AES_ALGORITHM);\n    // 使用指定的AES加密模式和填充方式获取对应的加密器并初始化\n    encryptionCipher = Cipher.getInstance(AES_TRANSFORMATION);\n    encryptionCipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);\n    // 使用指定的AES加密模式和填充方式获取对应的解密器并初始化\n    decryptionCipher = Cipher.getInstance(AES_TRANSFORMATION);\n    decryptionCipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new GCMParameterSpec(128, encryptionCipher.getIV()));\n}\n\n/**\n * 加密\n */\npublic static String encrypt(String data) throws Exception {\n    byte[] dataInBytes = data.getBytes();\n    // 加密数据\n    byte[] encryptedBytes = encryptionCipher.doFinal(dataInBytes);\n    return Base64.getEncoder().encodeToString(encryptedBytes);\n}\n\n/**\n * 解密\n */\npublic static String decrypt(String encryptedData) throws Exception {\n    byte[] dataInBytes = Base64.getDecoder().decode(encryptedData);\n    // 解密数据\n    byte[] decryptedBytes = decryptionCipher.doFinal(dataInBytes);\n    return new String(decryptedBytes, StandardCharsets.UTF_8);\n}\n\npublic static void main(String[] args) throws Exception {\n    String originalString = \"Java学习 + 面试指南：javaguide.cn\";\n    init();\n    String encryptedData = encrypt(originalString);\n    String decryptedData = decrypt(encryptedData);\n    System.out.println(\"Original String: \" + originalString);\n    System.out.println(\"AES Encrypted Data : \" + encryptedData);\n    System.out.println(\"AES Decrypted Data : \" + decryptedData);\n}
\n

输出：

\n
Original String: Java学习 + 面试指南：javaguide.cn\nAES Encrypted Data : E1qTkK91suBqToag7WCyoFP9uK5hR1nSfM6p+oBlYj71bFiIVnk5TsQRT+zpjv8stha7oyKi3jQ=\nAES Decrypted Data : Java学习 + 面试指南：javaguide.cn
\n

非对称加密

\n

非对称加密算法是指加密和解密使用不同的密钥的算法，也叫公开密钥加密算法。这两个密钥互不相同，一个称为公钥，另一个称为私钥。公钥可以公开给任何人使用，私钥则要保密。

\n

如果用公钥加密数据，只能用对应的私钥解密（加密）；如果用私钥加密数据，只能用对应的公钥解密（签名）。这样就可以实现数据的安全传输和身份认证。

\n

\"非对称加密\"

\n

常见的非对称加密算法有 RSA、DSA、ECC 等。

\n

RSA

\n

RSA（Rivest–Shamir–Adleman algorithm）算法是一种基于大数分解的困难性的非对称加密算法，它需要选择两个大素数作为私钥的一部分，然后计算出它们的乘积作为公钥的一部分（寻求两个大素数比较简单，而将它们的乘积进行因式分解却极其困难）。RSA 算法原理的详细介绍，可以参考这篇文章：你真的了解 RSA 加密算法吗？ - 小傅哥。

\n

RSA 算法的安全性依赖于大数分解的难度，目前已经有 512 位和 768 位的 RSA 公钥被成功分解，因此建议使用 2048 位或以上的密钥长度。

\n

RSA 算法的优点是简单易用，可以用于数据加密和数字签名；缺点是运算速度慢，不适合大量数据的加密。

\n

RSA 算法是是目前应用最广泛的非对称加密算法，像 SSL/TLS、SSH 等协议中就用到了 RSA 算法。

\n

\"HTTPS

\n

基于 Java 实现 RSA 算法代码示例：

\n
private static final String RSA_ALGORITHM = \"RSA\";\n\n/**\n * 生成RSA密钥对\n */\npublic static KeyPair generateKeyPair() throws NoSuchAlgorithmException {\n    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);\n    // 密钥大小为2048位\n    keyPairGenerator.initialize(2048);\n    return keyPairGenerator.generateKeyPair();\n}\n\n/**\n * 使用公钥加密数据\n */\npublic static String encrypt(String data, PublicKey publicKey) throws Exception {\n    Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);\n    cipher.init(Cipher.ENCRYPT_MODE, publicKey);\n    byte[] encryptedData = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));\n    return Base64.getEncoder().encodeToString(encryptedData);\n}\n\n/**\n * 使用私钥解密数据\n */\npublic static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {\n    byte[] decodedData = Base64.getDecoder().decode(encryptedData);\n    Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);\n    cipher.init(Cipher.DECRYPT_MODE, privateKey);\n    byte[] decryptedData = cipher.doFinal(decodedData);\n    return new String(decryptedData, StandardCharsets.UTF_8);\n}\n\npublic static void main(String[] args) throws Exception {\n    KeyPair keyPair = generateKeyPair();\n    PublicKey publicKey = keyPair.getPublic();\n    PrivateKey privateKey = keyPair.getPrivate();\n    String originalString = \"Java学习 + 面试指南：javaguide.cn\";\n    String encryptedData = encrypt(originalString, publicKey);\n    String decryptedData = decrypt(encryptedData, privateKey);\n    System.out.println(\"Original String: \" + originalString);\n    System.out.println(\"RSA Encrypted Data : \" + encryptedData);\n    System.out.println(\"RSA Decrypted Data : \" + decryptedData);\n}
\n

输出：

\n
Original String: Java学习 + 面试指南：javaguide.cn\nRSA Encrypted Data : T9ey/CEPUAhZm4UJjuVNIg8RPd1fQ32S9w6+rvOKxmuMumkJY2daFfWuCn8A73Mk5bL6TigOJI0GHfKOt/W2x968qLM3pBGCcPX17n4pR43f32IIIz9iPdgF/INOqDxP5ZAtCDvTiuzcSgDHXqiBSK5TDjtj7xoGjfudYAXICa8pWitnqDgJYoo2J0F8mKzxoi8D8eLE455MEx8ZT1s7FUD/z7/H8CfShLRbO9zq/zFI06TXn123ufg+F4lDaq/5jaIxGVEUB/NFeX4N6OZCFHtAV32mw71BYUadzI9TgvkkUr1rSKmQ0icNhnRdKedJokGUh8g9QQ768KERu92Ibg==\nRSA Decrypted Data : Java学习 + 面试指南：javaguide.cn
\n

DSA

\n

DSA（Digital Signature Algorithm）算法是一种基于离散对数的困难性的非对称加密算法，它需要选择一个素数 q 和一个 q 的倍数 p 作为私钥的一部分，然后计算出一个模 p 的原根 g 和一个模 q 的整数 y 作为公钥的一部分。DSA 算法的安全性依赖于离散对数的难度，目前已经有 1024 位的 DSA 公钥被成功破解，因此建议使用 2048 位或以上的密钥长度。

\n

DSA 算法的优点是数字签名速度快，适合生成数字证书；缺点是不能用于数据加密，且签名过程需要随机数。

\n

DSA 算法签名过程：

\n
    \n
  1. 使用消息摘要算法对要发送的数据进行加密，生成一个信息摘要，也就是一个短的、唯一的、不可逆的数据表示。
    2. \n
  2. 发送方用自己的 DSA 私钥对信息摘要再进行加密，形成一个数字签名，也就是一个可以证明数据来源和完整性的数据附加。
    3. \n
  3. 将原始数据和数字签名一起通过互联网传送给接收方。
    4. \n
  4. 接收方用发送方的公钥对数字签名进行解密，得到信息摘要。同时，接收方也用消息摘要算法对收到的原始数据进行加密，得到另一个信息摘要。接收方将两个信息摘要进行比较，如果两者一致，则说明在传送过程中数据没有被篡改或损坏；否则，则说明数据已经失去了安全性和保密性。
    5. \n
\n

\"DSA

\n

总结

\n

这篇文章介绍了三种加密算法：哈希算法、对称加密算法和非对称加密算法。

\n\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/security/encryption-algorithms/hash-function-effect-demonstration.png", "date_published": "2023-06-27T12:05:39.000Z", "date_modified": "2026-03-21T06:28:26.000Z", "authors": [], "tags": [ "系统设计" ] }, { "title": "Java NIO 核心知识总结", "url": "https://javaguide.cn/java/io/nio-basis.html", "id": "https://javaguide.cn/java/io/nio-basis.html", "summary": "Java NIO核心知识全面总结：详解Channel通道、Buffer缓冲区、Selector选择器三大核心组件、非阻塞IO实现、零拷贝技术、与传统IO性能对比。", "content_html": "

在学习 NIO 之前，需要先了解一下计算机 I/O 模型的基础理论知识。还不了解的话，可以参考我写的这篇文章：Java IO 模型详解。

\n

NIO 简介

\n

在传统的 Java I/O 模型（BIO）中，I/O 操作是以阻塞的方式进行的。也就是说，当一个线程执行一个 I/O 操作时，它会被阻塞直到操作完成。这种阻塞模型在处理多个并发连接时可能会导致性能瓶颈，因为需要为每个连接创建一个线程，而线程的创建和切换都是有开销的。

\n

为了解决这个问题，在 Java1.4 版本引入了一种新的 I/O 模型 — NIO （New IO，也称为 Non-blocking IO） 。NIO 弥补了同步阻塞 I/O 的不足，它在标准 Java 代码中提供了非阻塞、面向缓冲、基于通道的 I/O，可以使用少量的线程来处理多个连接，大大提高了 I/O 效率和并发。

\n

下图是 BIO、NIO 和 AIO 处理客户端请求的简单对比图（关于 AIO 的介绍，可以看我写的这篇文章：Java IO 模型详解，不是重点，了解即可）。

\n

\"BIO、NIO

\n

⚠️需要注意：使用 NIO 并不一定意味着高性能，它的性能优势主要体现在高并发和高延迟的网络环境下。当连接数较少、并发程度较低或者网络传输速度较快时，NIO 的性能并不一定优于传统的 BIO 。

\n

NIO 核心组件

\n

NIO 主要包括以下三个核心组件：

\n\n

三者的关系如下图所示（暂时不理解没关系，后文会详细介绍）：

\n

\"Buffer、Channel和Selector三者之间的关系\"

\n

下面详细介绍一下这三个组件。

\n

Buffer（缓冲区）

\n

在传统的 BIO 中，数据的读写是面向流的， 分为字节流和字符流。

\n

在 Java 1.4 的 NIO 库中，所有数据都是用缓冲区处理的，这是新库和之前的 BIO 的一个重要区别，有点类似于 BIO 中的缓冲流。NIO 在读取数据时，它是直接读到缓冲区中的。在写入数据时，写入到缓冲区中。 使用 NIO 在读写数据时，都是通过缓冲区进行操作。

\n

Buffer 的子类如下图所示。其中，最常用的是 ByteBuffer，它可以用来存储和操作字节数据。

\n

\"Buffer

\n

你可以将 Buffer 理解为一个数组，IntBuffer、FloatBuffer、CharBuffer 等分别对应 int[]、float[]、char[] 等。

\n

为了更清晰地认识缓冲区，我们来简单看看Buffer 类中定义的四个成员变量：

\n
public abstract class Buffer {\n    // Invariants: mark <= position <= limit <= capacity\n    private int mark = -1;\n    private int position = 0;\n    private int limit;\n    private int capacity;\n}
\n

这四个成员变量的具体含义如下：

\n
    \n
  1. 容量（capacity）：Buffer可以存储的最大数据量，Buffer创建时设置且不可改变；
    2. \n
  2. 界限（limit）：Buffer 中可以读/写数据的边界。写模式下，limit 代表最多能写入的数据，一般等于 capacity（可以通过limit(int newLimit)方法设置）；读模式下，limit 等于 Buffer 中实际写入的数据大小。
    3. \n
  3. 位置（position）：下一个可以被读写的数据的位置（索引）。从写操作模式到读操作模式切换的时候（flip），position 都会归零，这样就可以从头开始读写了。
    4. \n
  4. 标记（mark）：Buffer允许将位置直接定位到该标记处，这是一个可选属性；
    5. \n
\n

并且，上述变量满足如下的关系：0 <= mark <= position <= limit <= capacity 。

\n

另外，Buffer 有读模式和写模式这两种模式，分别用于从 Buffer 中读取数据或者向 Buffer 中写入数据。Buffer 被创建之后默认是写模式，调用 flip() 可以切换到读模式。如果要再次切换回写模式，可以调用 clear() 或者 compact() 方法。

\n

\"position

\n

\"position

\n

Buffer 对象不能通过 new 调用构造方法创建对象 ，只能通过静态方法实例化 Buffer。

\n

这里以 ByteBuffer为例进行介绍：

\n
// 分配堆内存\npublic static ByteBuffer allocate(int capacity);\n// 分配直接内存\npublic static ByteBuffer allocateDirect(int capacity);
\n

Buffer 最核心的两个方法：

\n
    \n
  1. get : 读取缓冲区的数据
    2. \n
  2. put ：向缓冲区写入数据
    3. \n
\n

除上述两个方法之外，其他的重要方法：

\n\n

Buffer 中数据变化的过程：

\n
import java.nio.*;\n\npublic class CharBufferDemo {\n    public static void main(String[] args) {\n        // 分配一个容量为8的CharBuffer\n        CharBuffer buffer = CharBuffer.allocate(8);\n        System.out.println(\"初始状态：\");\n        printState(buffer);\n\n        // 向buffer写入3个字符\n        buffer.put('a').put('b').put('c');\n        System.out.println(\"写入3个字符后的状态：\");\n        printState(buffer);\n\n        // 调用flip()方法，准备读取buffer中的数据，将 position 置 0,limit 的置 3\n        buffer.flip();\n        System.out.println(\"调用flip()方法后的状态：\");\n        printState(buffer);\n\n        // 读取字符\n        while (buffer.hasRemaining()) {\n            System.out.print(buffer.get());\n        }\n\n        // 调用clear()方法，清空缓冲区，将 position 的值置为 0，将 limit 的值置为 capacity 的值\n        buffer.clear();\n        System.out.println(\"调用clear()方法后的状态：\");\n        printState(buffer);\n\n    }\n\n    // 打印buffer的capacity、limit、position、mark的位置\n    private static void printState(CharBuffer buffer) {\n        System.out.print(\"capacity: \" + buffer.capacity());\n        System.out.print(\", limit: \" + buffer.limit());\n        System.out.print(\", position: \" + buffer.position());\n        System.out.print(\", mark 开始读取的字符: \" + buffer.mark());\n        System.out.println(\"\\n\");\n    }\n}
\n

输出:

\n
初始状态：\ncapacity: 8, limit: 8, position: 0\n\n写入3个字符后的状态：\ncapacity: 8, limit: 8, position: 3\n\n准备读取buffer中的数据！\n\n调用flip()方法后的状态：\ncapacity: 8, limit: 3, position: 0\n\n读取到的数据：abc\n\n调用clear()方法后的状态：\ncapacity: 8, limit: 8, position: 0
\n

为了帮助理解，我绘制了一张图片展示 capacity、limit和position每一阶段的变化。

\n

\"capacity、limit和position每一阶段的变化\"

\n

Channel（通道）

\n

Channel 是一个通道，它建立了与数据源（如文件、网络套接字等）之间的连接。我们可以利用它来读取和写入数据，就像打开了一条自来水管，让数据在 Channel 中自由流动。

\n

BIO 中的流是单向的，分为各种 InputStream（输入流）和 OutputStream（输出流），数据只是在一个方向上传输。通道与流的不同之处在于通道是双向的，它可以用于读、写或者同时用于读写。

\n

Channel 与前面介绍的 Buffer 打交道，读操作的时候将 Channel 中的数据填充到 Buffer 中，而写操作时将 Buffer 中的数据写入到 Channel 中。

\n

\"Channel

\n

另外，因为 Channel 是全双工的，所以它可以比流更好地映射底层操作系统的 API。特别是在 UNIX 网络编程模型中，底层操作系统的通道都是全双工的，同时支持读写操作。

\n

Channel 的子类如下图所示。

\n

\"Channel

\n

其中，最常用的是以下几种类型的通道：

\n\n

\"Channel继承关系图\"

\n

Channel 最核心的两个方法：

\n
    \n
  1. read ：读取数据并写入到 Buffer 中。
    2. \n
  2. write ：将 Buffer 中的数据写入到 Channel 中。
    3. \n
\n

这里我们以 FileChannel 为例演示一下是读取文件数据的。

\n
RandomAccessFile reader = new RandomAccessFile(\"/Users/guide/Documents/test_read.in\", \"r\");\nFileChannel channel = reader.getChannel();\nByteBuffer buffer = ByteBuffer.allocate(1024);\nchannel.read(buffer);
\n

Selector（选择器）

\n

Selector（选择器） 是 NIO 中的一个关键组件，它允许一个线程处理多个 Channel。Selector 是基于事件驱动的 I/O 多路复用模型，主要运作原理是：通过 Selector 注册通道的事件，Selector 会不断地轮询注册在其上的 Channel。当事件发生时，比如：某个 Channel 上面有新的 TCP 连接接入、读和写事件，这个 Channel 就处于就绪状态，会被 Selector 轮询出来。Selector 会将相关的 Channel 加入到就绪集合中。通过 SelectionKey 可以获取就绪 Channel 的集合，然后对这些就绪的 Channel 进行相应的 I/O 操作。

\n

\"Selector

\n

一个多路复用器 Selector 可以同时轮询多个 Channel，由于 JDK 使用了 epoll() 代替传统的 select 实现，所以它并没有最大连接句柄 1024/2048 的限制。这也就意味着只需要一个线程负责 Selector 的轮询，就可以接入成千上万的客户端。

\n

Selector 可以监听以下四种事件类型：

\n
    \n
  1. SelectionKey.OP_ACCEPT：表示通道接受连接的事件，这通常用于 ServerSocketChannel。
    2. \n
  2. SelectionKey.OP_CONNECT：表示通道完成连接的事件，这通常用于 SocketChannel。
    3. \n
  3. SelectionKey.OP_READ：表示通道准备好进行读取的事件，即有数据可读。
    4. \n
  4. SelectionKey.OP_WRITE：表示通道准备好进行写入的事件，即可以写入数据。
    5. \n
\n

Selector是抽象类，可以通过调用此类的 open() 静态方法来创建 Selector 实例。Selector 可以同时监控多个 SelectableChannel 的 IO 状况，是非阻塞 IO 的核心。

\n

一个 Selector 实例有三个 SelectionKey 集合：

\n
    \n
  1. 所有的 SelectionKey 集合：代表了注册在该 Selector 上的 Channel，这个集合可以通过 keys() 方法返回。
    2. \n
  2. 被选择的 SelectionKey 集合：代表了所有可通过 select() 方法获取的、需要进行 IO 处理的 Channel，这个集合可以通过 selectedKeys() 返回。
    3. \n
  3. 被取消的 SelectionKey 集合：代表了所有被取消注册关系的 Channel，在下一次执行 select() 方法时，这些 Channel 对应的 SelectionKey 会被彻底删除，程序通常无须直接访问该集合，也没有暴露访问的方法。
    4. \n
\n

简单演示一下如何遍历被选择的 SelectionKey 集合并进行处理：

\n
Set<SelectionKey> selectedKeys = selector.selectedKeys();\nIterator<SelectionKey> keyIterator = selectedKeys.iterator();\nwhile (keyIterator.hasNext()) {\n    SelectionKey key = keyIterator.next();\n    if (key != null) {\n        if (key.isAcceptable()) {\n            // ServerSocketChannel 接收了一个新连接\n        } else if (key.isConnectable()) {\n            // 表示一个新连接建立\n        } else if (key.isReadable()) {\n            // Channel 有准备好的数据，可以读取\n        } else if (key.isWritable()) {\n            // Channel 有空闲的 Buffer，可以写入数据\n        }\n    }\n    keyIterator.remove();\n}
\n

Selector 还提供了一系列和 select() 相关的方法：

\n\n

使用 Selector 实现网络读写的简单示例：

\n
import java.io.IOException;\nimport java.net.InetSocketAddress;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.Selector;\nimport java.nio.channels.ServerSocketChannel;\nimport java.nio.channels.SocketChannel;\nimport java.util.Iterator;\nimport java.util.Set;\n\npublic class NioSelectorExample {\n\n  public static void main(String[] args) {\n    try {\n      ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();\n      serverSocketChannel.configureBlocking(false);\n      serverSocketChannel.socket().bind(new InetSocketAddress(8080));\n\n      Selector selector = Selector.open();\n      // 将 ServerSocketChannel 注册到 Selector 并监听 OP_ACCEPT 事件\n      serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);\n\n      while (true) {\n        int readyChannels = selector.select();\n\n        if (readyChannels == 0) {\n          continue;\n        }\n\n        Set<SelectionKey> selectedKeys = selector.selectedKeys();\n        Iterator<SelectionKey> keyIterator = selectedKeys.iterator();\n\n        while (keyIterator.hasNext()) {\n          SelectionKey key = keyIterator.next();\n\n          if (key.isAcceptable()) {\n            // 处理连接事件\n            ServerSocketChannel server = (ServerSocketChannel) key.channel();\n            SocketChannel client = server.accept();\n            client.configureBlocking(false);\n\n            // 将客户端通道注册到 Selector 并监听 OP_READ 事件\n            client.register(selector, SelectionKey.OP_READ);\n          } else if (key.isReadable()) {\n            // 处理读事件\n            SocketChannel client = (SocketChannel) key.channel();\n            ByteBuffer buffer = ByteBuffer.allocate(1024);\n            int bytesRead = client.read(buffer);\n\n            if (bytesRead > 0) {\n              buffer.flip();\n              System.out.println(\"收到数据：\" +new String(buffer.array(), 0, bytesRead));\n              // 将客户端通道注册到 Selector 并监听 OP_WRITE 事件\n              client.register(selector, SelectionKey.OP_WRITE);\n            } else if (bytesRead < 0) {\n              // 客户端断开连接\n              client.close();\n            }\n          } else if (key.isWritable()) {\n            // 处理写事件\n            SocketChannel client = (SocketChannel) key.channel();\n            ByteBuffer buffer = ByteBuffer.wrap(\"Hello, Client!\".getBytes());\n            client.write(buffer);\n\n            // 将客户端通道注册到 Selector 并监听 OP_READ 事件\n            client.register(selector, SelectionKey.OP_READ);\n          }\n\n          keyIterator.remove();\n        }\n      }\n    } catch (IOException e) {\n      e.printStackTrace();\n    }\n  }\n}
\n

在示例中，我们创建了一个简单的服务器，监听 8080 端口，使用 Selector 处理连接、读取和写入事件。当接收到客户端的数据时，服务器将读取数据并将其打印到控制台，然后向客户端回复 "Hello, Client!"。

\n

NIO 零拷贝

\n

零拷贝是提升 IO 操作性能的一个常用手段，像 ActiveMQ、Kafka 、RocketMQ、QMQ、Netty 等顶级开源项目都用到了零拷贝。

\n

零拷贝是指计算机执行 IO 操作时，CPU 不需要将数据从一个存储区域复制到另一个存储区域，从而可以减少上下文切换以及 CPU 的拷贝时间。也就是说，零拷贝主要解决操作系统在处理 I/O 操作时频繁复制数据的问题。零拷贝的常见实现技术有： mmap+write、sendfile和 sendfile + DMA gather copy 。

\n

下图展示了各种零拷贝技术的对比图：

\n

| | CPU 拷贝 | DMA 拷贝 | 系统调用 | 上下文切换 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/nio/bio-aio-nio.png", "date_published": "2023-06-26T15:16:09.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "ArrayBlockingQueue 源码分析", "url": "https://javaguide.cn/java/collection/arrayblockingqueue-source-code.html", "id": "https://javaguide.cn/java/collection/arrayblockingqueue-source-code.html", "summary": "ArrayBlockingQueue源码深度解析：详解有界阻塞队列实现、生产者消费者模式应用、ReentrantLock+Condition并发控制、线程池工作队列机制。", "content_html": "

阻塞队列简介

\n

阻塞队列的历史

\n

Java 阻塞队列的历史可以追溯到 JDK1.5 版本，当时 Java 平台增加了 java.util.concurrent，即我们常说的 JUC 包，其中包含了各种并发流程控制工具、并发容器、原子类等。这其中自然也包含了我们这篇文章所讨论的阻塞队列。

\n

为了解决高并发场景下多线程之间数据共享的问题，JDK1.5 版本中出现了 ArrayBlockingQueue 和 LinkedBlockingQueue，它们是带有生产者-消费者模式实现的并发容器。其中，ArrayBlockingQueue 是有界队列，即添加的元素达到上限之后，再次添加就会被阻塞或者抛出异常。而 LinkedBlockingQueue 则由链表构成的队列，正是因为链表的特性，所以 LinkedBlockingQueue 在添加元素上并不会向 ArrayBlockingQueue 那样有着较多的约束，所以 LinkedBlockingQueue 设置队列是否有界是可选的(注意这里的无界并不是指可以添加任意数量的元素，而是说队列的大小默认为 Integer.MAX_VALUE，近乎于无限大)。

\n

随着 Java 的不断发展，JDK 后续的几个版本又对阻塞队列进行了不少的更新和完善:

\n
    \n
  1. JDK1.6 版本:增加 SynchronousQueue，一个不存储元素的阻塞队列。
    2. \n
  2. JDK1.7 版本:增加 TransferQueue，一个支持更多操作的阻塞队列。
    3. \n
  3. JDK1.8 版本:增加 DelayQueue，一个支持延迟获取元素的阻塞队列。
    4. \n
\n

阻塞队列的思想

\n

阻塞队列就是典型的生产者-消费者模型，它可以做到以下几点:

\n
    \n
  1. 当阻塞队列数据为空时，所有的消费者线程都会被阻塞，等待队列非空。
    2. \n
  2. 当生产者往队列里填充数据后，队列就会通知消费者队列非空，消费者此时就可以进来消费。
    3. \n
  3. 当阻塞队列因为消费者消费过慢或者生产者存放元素过快导致队列填满时无法容纳新元素时，生产者就会被阻塞，等待队列非满时继续存放元素。
    4. \n
  4. 当消费者从队列中消费一个元素之后，队列就会通知生产者队列非满，生产者可以继续填充数据了。
    5. \n
\n

总结一下：阻塞队列就说基于非空和非满两个条件实现生产者和消费者之间的交互，尽管这些交互流程和等待通知的机制实现非常复杂，好在 Doug Lea 的操刀之下已将阻塞队列的细节屏蔽，我们只需调用 put、take、offer、poll 等 API 即可实现多线程之间的生产和消费。

\n

这也使得阻塞队列在多线程开发中有着广泛的运用，最常见的例子无非是我们的线程池,从源码中我们就能看出当核心线程无法及时处理任务时，这些任务都会扔到 workQueue 中。

\n
public ThreadPoolExecutor(int corePoolSize,\n                            int maximumPoolSize,\n                            long keepAliveTime,\n                            TimeUnit unit,\n                            BlockingQueue<Runnable> workQueue,\n                            ThreadFactory threadFactory,\n                            RejectedExecutionHandler handler) {// ...}
\n

ArrayBlockingQueue 常见方法及测试

\n

简单了解了阻塞队列的历史之后，我们就开始重点讨论本篇文章所要介绍的并发容器——ArrayBlockingQueue。为了后续更加深入的了解 ArrayBlockingQueue，我们不妨基于下面几个实例了解以下 ArrayBlockingQueue 的使用。

\n

先看看第一个例子，我们这里会用两个线程分别模拟生产者和消费者，生产者生产完会使用 put 方法生产 10 个元素给消费者进行消费，当队列元素达到我们设置的上限 5 时，put 方法就会阻塞。
\n同理消费者也会通过 take 方法消费元素，当队列为空时，take 方法就会阻塞消费者线程。这里笔者为了保证消费者能够在消费完 10 个元素后及时退出。便通过倒计时门闩，来控制消费者结束，生产者在这里只会生产 10 个元素。当消费者将 10 个元素消费完成之后，按下倒计时门闩，所有线程都会停止。

\n
public class ProducerConsumerExample {\n\n    public static void main(String[] args) throws InterruptedException {\n\n        // 创建一个大小为 5 的 ArrayBlockingQueue\n        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);\n\n        // 创建生产者线程\n        Thread producer = new Thread(() -> {\n            try {\n                for (int i = 1; i <= 10; i++) {\n                    // 向队列中添加元素，如果队列已满则阻塞等待\n                    queue.put(i);\n                    System.out.println(\"生产者添加元素：\" + i);\n                }\n            } catch (InterruptedException e) {\n                e.printStackTrace();\n            }\n\n        });\n\n        CountDownLatch countDownLatch = new CountDownLatch(1);\n\n        // 创建消费者线程\n        Thread consumer = new Thread(() -> {\n            try {\n                int count = 0;\n                while (true) {\n\n                    // 从队列中取出元素，如果队列为空则阻塞等待\n                    int element = queue.take();\n                    System.out.println(\"消费者取出元素：\" + element);\n                    ++count;\n                    if (count == 10) {\n                        break;\n                    }\n                }\n\n                countDownLatch.countDown();\n            } catch (InterruptedException e) {\n                e.printStackTrace();\n            }\n\n        });\n\n        // 启动线程\n        producer.start();\n        consumer.start();\n\n        // 等待线程结束\n        producer.join();\n        consumer.join();\n\n        countDownLatch.await();\n\n        producer.interrupt();\n        consumer.interrupt();\n    }\n\n}
\n

代码输出结果如下，可以看到只有生产者往队列中投放元素之后消费者才能消费，这也就意味着当队列中没有数据的时消费者就会阻塞，等待队列非空再继续消费。

\n
生产者添加元素：1\n生产者添加元素：2\n消费者取出元素：1\n消费者取出元素：2\n生产者添加元素：3\n消费者取出元素：3\n生产者添加元素：4\n生产者添加元素：5\n消费者取出元素：4\n生产者添加元素：6\n消费者取出元素：5\n生产者添加元素：7\n生产者添加元素：8\n生产者添加元素：9\n生产者添加元素：10\n消费者取出元素：6\n消费者取出元素：7\n消费者取出元素：8\n消费者取出元素：9\n消费者取出元素：10
\n

了解了 put、take 这两个会阻塞的存和取方法之后，我我们再来看看阻塞队列中非阻塞的入队和出队方法 offer 和 poll。

\n

如下所示，我们设置了一个大小为 3 的阻塞队列，我们会尝试在队列用 offer 方法存放 4 个元素，然后再从队列中用 poll 尝试取 4 次。

\n
public class OfferPollExample {\n\n    public static void main(String[] args) {\n        // 创建一个大小为 3 的 ArrayBlockingQueue\n        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);\n\n        // 向队列中添加元素\n        System.out.println(queue.offer(\"A\"));\n        System.out.println(queue.offer(\"B\"));\n        System.out.println(queue.offer(\"C\"));\n\n        // 尝试向队列中添加元素，但队列已满，返回 false\n        System.out.println(queue.offer(\"D\"));\n\n        // 从队列中取出元素\n        System.out.println(queue.poll());\n        System.out.println(queue.poll());\n        System.out.println(queue.poll());\n\n        // 尝试从队列中取出元素，但队列已空，返回 null\n        System.out.println(queue.poll());\n    }\n\n}
\n

最终代码的输出结果如下，可以看到因为队列的大小为 3 的缘故，我们前 3 次存放到队列的结果为 true，第 4 次存放时，由于队列已满，所以存放结果返回 false。这也是为什么我们后续的 poll 方法只得到了 3 个元素的值。

\n
true\ntrue\ntrue\nfalse\nA\nB\nC\nnull
\n

了解了阻塞存取和非阻塞存取，我们再来看看阻塞队列的一个比较特殊的操作，某些场景下，我们希望能够一次性将阻塞队列的结果存到列表中再进行批量操作，我们就可以使用阻塞队列的 drainTo 方法，这个方法会一次性将队列中所有元素存放到列表，如果队列中有元素，且成功存到 list 中则 drainTo 会返回本次转移到 list 中的元素数，反之若队列为空，drainTo 则直接返回 0。

\n
public class DrainToExample {\n\n    public static void main(String[] args) {\n        // 创建一个大小为 5 的 ArrayBlockingQueue\n        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);\n\n        // 向队列中添加元素\n        queue.add(1);\n        queue.add(2);\n        queue.add(3);\n        queue.add(4);\n        queue.add(5);\n\n        // 创建一个 List，用于存储从队列中取出的元素\n        List<Integer> list = new ArrayList<>();\n\n        // 从队列中取出所有元素，并添加到 List 中\n        queue.drainTo(list);\n\n        // 输出 List 中的元素\n        System.out.println(list);\n    }\n\n}
\n

代码输出结果如下

\n
[1, 2, 3, 4, 5]
\n

ArrayBlockingQueue 源码分析

\n

自此我们对阻塞队列的使用有了基本的印象，接下来我们就可以进一步了解一下 ArrayBlockingQueue 的工作机制了。

\n

整体设计

\n

在了解 ArrayBlockingQueue 的具体细节之前，我们先来看看 ArrayBlockingQueue 的类图。

\n

\"ArrayBlockingQueue

\n

从图中我们可以看出，ArrayBlockingQueue 实现了阻塞队列 BlockingQueue 这个接口，不难猜出通过实现 BlockingQueue 这个接口之后，ArrayBlockingQueue 就拥有了阻塞队列那些常见的操作行为。

\n

同时， ArrayBlockingQueue 还继承了 AbstractQueue 这个抽象类，这个继承了 AbstractCollection 和 Queue 的抽象类，从抽象类的特定和语义我们也可以猜出，这个继承关系使得 ArrayBlockingQueue 拥有了队列的常见操作。

\n

所以我们是否可以得出这样一个结论，通过继承 AbstractQueue 获得队列所有的操作模板，其实现的入队和出队操作的整体框架。然后 ArrayBlockingQueue 通过实现 BlockingQueue 获取到阻塞队列的常见操作并将这些操作实现，填充到 AbstractQueue 模板方法的细节中，由此 ArrayBlockingQueue 成为一个完整的阻塞队列。

\n

为了印证这一点，我们到源码中一探究竟。首先我们先来看看 AbstractQueue，从类的继承关系我们可以大致得出，它通过 AbstractCollection 获得了集合的常见操作方法，然后通过 Queue 接口获得了队列的特性。

\n
public abstract class AbstractQueue<E>\n    extends AbstractCollection<E>\n    implements Queue<E> {\n       //...\n}
\n

对于集合的操作无非是增删改查，所以我们不妨从添加方法入手，从源码中我们可以看到，它实现了 AbstractCollection 的 add 方法，其内部逻辑如下:

\n
    \n
  1. 调用继承 Queue 接口得来的 offer 方法，如果 offer 成功则返回 true。
    2. \n
  2. 如果 offer 失败，即代表当前元素入队失败直接抛异常。
    3. \n
\n
public boolean add(E e) {\n  if (offer(e))\n      return true;\n  else\n      throw new IllegalStateException(\"Queue full\");\n}
\n

而 AbstractQueue 中并没有对 Queue 的 offer 的实现，很明显这样做的目的是定义好了 add 的核心逻辑，将 offer 的细节交由其子类即我们的 ArrayBlockingQueue 实现。

\n

到此，我们对于抽象类 AbstractQueue 的分析就结束了，我们继续看看 ArrayBlockingQueue 中实现的另一个重要接口 BlockingQueue。

\n

点开 BlockingQueue 之后，我们可以看到这个接口同样继承了 Queue 接口，这就意味着它也具备了队列所拥有的所有行为。同时，它还定义了自己所需要实现的方法。

\n
public interface BlockingQueue<E> extends Queue<E> {\n\n     //元素入队成功返回true，反之则会抛出异常IllegalStateException\n    boolean add(E e);\n\n     //元素入队成功返回true，反之返回false\n    boolean offer(E e);\n\n     //元素入队成功则直接返回，如果队列已满元素不可入队则将线程阻塞，因为阻塞期间可能会被打断，所以这里方法签名抛出了InterruptedException\n    void put(E e) throws InterruptedException;\n\n   //和上一个方法一样,只不过队列满时只会阻塞单位为unit，时间为timeout的时长，如果在等待时长内没有入队成功则直接返回false。\n    boolean offer(E e, long timeout, TimeUnit unit)\n        throws InterruptedException;\n\n    //从队头取出一个元素，如果队列为空则阻塞等待，因为会阻塞线程的缘故，所以该方法可能会被打断，所以签名定义了InterruptedException\n    E take() throws InterruptedException;\n\n      //取出队头的元素并返回，如果当前队列为空则阻塞等待timeout且单位为unit的时长，如果这个时间段没有元素则直接返回null。\n    E poll(long timeout, TimeUnit unit)\n        throws InterruptedException;\n\n      //获取队列剩余元素个数\n    int remainingCapacity();\n\n     //删除我们指定的对象，如果成功返回true，反之返回false。\n    boolean remove(Object o);\n\n    //判断队列中是否包含指定元素\n    public boolean contains(Object o);\n\n     //将队列中的元素全部存到指定的集合中\n    int drainTo(Collection<? super E> c);\n\n    //转移maxElements个元素到集合中\n    int drainTo(Collection<? super E> c, int maxElements);\n}
\n

了解了 BlockingQueue 的常见操作后，我们就知道了 ArrayBlockingQueue 通过实现 BlockingQueue 的方法并重写后，填充到 AbstractQueue 的方法上，由此我们便知道了上文中 AbstractQueue 的 add 方法的 offer 方法是哪里是实现的了。

\n
public boolean add(E e) {\n  //AbstractQueue的offer来自下层的ArrayBlockingQueue从BlockingQueue实现并重写的offer方法\n  if (offer(e))\n      return true;\n  else\n      throw new IllegalStateException(\"Queue full\");\n}
\n

初始化

\n

了解 ArrayBlockingQueue 的细节前，我们不妨先看看其构造函数，了解一下其初始化过程。从源码中我们可以看出 ArrayBlockingQueue 有 3 个构造方法，而最核心的构造方法就是下方这一个。

\n
// capacity 表示队列初始容量，fair 表示 锁的公平性\npublic ArrayBlockingQueue(int capacity, boolean fair) {\n  //如果设置的队列大小小于0，则直接抛出IllegalArgumentException\n  if (capacity <= 0)\n      throw new IllegalArgumentException();\n  //初始化一个数组用于存放队列的元素\n  this.items = new Object[capacity];\n  //创建阻塞队列流程控制的锁\n  lock = new ReentrantLock(fair);\n  //用lock锁创建两个条件控制队列生产和消费\n  notEmpty = lock.newCondition();\n  notFull =  lock.newCondition();\n}
\n

这个构造方法里面有两个比较核心的成员变量 notEmpty(非空) 和 notFull （非满） ，需要我们格外留意，它们是实现生产者和消费者有序工作的关键所在，这一点笔者会在后续的源码解析中详细说明，这里我们只需初步了解一下阻塞队列的构造即可。

\n

另外两个构造方法都是基于上述的构造方法，默认情况下，我们会使用下面这个构造方法，该构造方法就意味着 ArrayBlockingQueue 用的是非公平锁，即各个生产者或者消费者线程收到通知后，对于锁的争抢是随机的。

\n
 public ArrayBlockingQueue(int capacity) {\n        this(capacity, false);\n    }
\n

还有一个不怎么常用的构造方法，在初始化容量和锁的非公平性之后，它还提供了一个 Collection 参数，从源码中不难看出这个构造方法是将外部传入的集合的元素在初始化时直接存放到阻塞队列中。

\n
public ArrayBlockingQueue(int capacity, boolean fair,\n                              Collection<? extends E> c) {\n  //初始化容量和锁的公平性\n  this(capacity, fair);\n\n  final ReentrantLock lock = this.lock;\n  //上锁并将c中的元素存放到ArrayBlockingQueue底层的数组中\n  lock.lock();\n  try {\n      int i = 0;\n      try {\n                //遍历并添加元素到数组中\n          for (E e : c) {\n              checkNotNull(e);\n              items[i++] = e;\n          }\n      } catch (ArrayIndexOutOfBoundsException ex) {\n          throw new IllegalArgumentException();\n      }\n      //记录当前队列容量\n      count = i;\n                      //更新下一次put或者offer或用add方法添加到队列底层数组的位置\n      putIndex = (i == capacity) ? 0 : i;\n  } finally {\n      //完成遍历后释放锁\n      lock.unlock();\n  }\n}
\n

阻塞式获取和新增元素

\n

ArrayBlockingQueue 阻塞式获取和新增元素对应的就是生产者-消费者模型，虽然它也支持非阻塞式获取和新增元素（例如 poll() 和 offer(E e) 方法，后文会介绍到），但一般不会使用。

\n

ArrayBlockingQueue 阻塞式获取和新增元素的方法为：

\n\n

这两个方法实现的关键就是在于两个条件对象 notEmpty(非空) 和 notFull （非满），这个我们在上文的构造方法中有提到。

\n

接下来笔者就通过两张图让大家了解一下这两个条件是如何在阻塞队列中运用的。

\n

\"ArrayBlockingQueue

\n

假设我们的代码消费者先启动，当它发现队列中没有数据，那么非空条件就会将这个线程挂起，即等待条件非空时挂起。然后 CPU 执行权到达生产者，生产者发现队列中可以存放数据，于是将数据存放进去，通知此时条件非空，此时消费者就会被唤醒到队列中使用 take 等方法获取值了。

\n

\"ArrayBlockingQueue

\n

随后的执行中，生产者生产速度远远大于消费者消费速度，于是生产者将队列塞满后再次尝试将数据存入队列，发现队列已满，于是阻塞队列就将当前线程挂起，等待非满。然后消费者拿着 CPU 执行权进行消费，于是队列可以存放新数据了，发出一个非满的通知，此时挂起的生产者就会等待 CPU 执行权到来时再次尝试将数据存到队列中。

\n

简单了解阻塞队列的基于两个条件的交互流程之后，我们不妨看看 put 和 take 方法的源码。

\n
public void put(E e) throws InterruptedException {\n    //确保插入的元素不为null\n    checkNotNull(e);\n    //加锁\n    final ReentrantLock lock = this.lock;\n    //这里使用lockInterruptibly()方法而不是lock()方法是为了能够响应中断操作，如果在等待获取锁的过程中被打断则该方法会抛出InterruptedException异常。\n    lock.lockInterruptibly();\n    try {\n            //如果count等数组长度则说明队列已满，当前线程将被挂起放到AQS队列中，等待队列非满时插入（非满条件）。\n       //在等待期间，锁会被释放，其他线程可以继续对队列进行操作。\n        while (count == items.length)\n            notFull.await();\n           //如果队列可以存放元素，则调用enqueue将元素入队\n        enqueue(e);\n    } finally {\n        //释放锁\n        lock.unlock();\n    }\n}
\n

put方法内部调用了 enqueue 方法来实现元素入队，我们继续深入查看一下 enqueue 方法的实现细节：

\n
private void enqueue(E x) {\n   //获取队列底层的数组\n    final Object[] items = this.items;\n    //将putindex位置的值设置为我们传入的x\n    items[putIndex] = x;\n    //更新putindex，如果putindex等于数组长度，则更新为0\n    if (++putIndex == items.length)\n        putIndex = 0;\n    //队列长度+1\n    count++;\n    //通知队列非空，那些因为获取元素而阻塞的线程可以继续工作了\n    notEmpty.signal();\n}
\n

从源码中可以看到入队操作的逻辑就是在数组中追加一个新元素，整体执行步骤为:

\n
    \n
  1. 获取 ArrayBlockingQueue 底层的数组 items。
    2. \n
  2. 将元素存到 putIndex 位置。
    3. \n
  3. 更新 putIndex 到下一个位置，如果 putIndex 等于队列长度，则说明 putIndex 已经到达数组末尾了，下一次插入则需要 0 开始。(ArrayBlockingQueue 用到了循环队列的思想，即从头到尾循环复用一个数组)
    4. \n
  4. 更新 count 的值，表示当前队列长度+1。
    5. \n
  5. 调用 notEmpty.signal() 通知队列非空，消费者可以从队列中获取值了。
    6. \n
\n

自此我们了解了 put 方法的流程，为了更加完整的了解 ArrayBlockingQueue 关于生产者-消费者模型的设计，我们继续看看阻塞获取队列元素的 take 方法。

\n
public E take() throws InterruptedException {\n       //获取锁\n     final ReentrantLock lock = this.lock;\n     lock.lockInterruptibly();\n     try {\n             //如果队列中元素个数为0，则将当前线程打断并存入AQS队列中，等待队列非空时获取并移除元素（非空条件）\n         while (count == 0)\n             notEmpty.await();\n            //如果队列不为空则调用dequeue获取元素\n         return dequeue();\n     } finally {\n          //释放锁\n         lock.unlock();\n     }\n}
\n

理解了 put 方法再看take 方法就很简单了，其核心逻辑和put 方法正好是相反的，比如put 方法在队列满的时候等待队列非满时插入元素（非满条件），而take 方法等待队列非空时获取并移除元素（非空条件）。

\n

take方法内部调用了 dequeue 方法来实现元素出队，其核心逻辑和 enqueue 方法也是相反的。

\n
private E dequeue() {\n  //获取阻塞队列底层的数组\n  final Object[] items = this.items;\n  @SuppressWarnings(\"unchecked\")\n  //从队列中获取takeIndex位置的元素\n  E x = (E) items[takeIndex];\n  //将takeIndex置空\n  items[takeIndex] = null;\n  //takeIndex向后挪动，如果等于数组长度则更新为0\n  if (++takeIndex == items.length)\n      takeIndex = 0;\n  //队列长度减1\n  count--;\n  if (itrs != null)\n      itrs.elementDequeued();\n  //通知那些被打断的线程当前队列状态非满，可以继续存放元素\n  notFull.signal();\n  return x;\n}
\n

由于dequeue 方法（出队）和上面介绍的 enqueue 方法（入队）的步骤大致类似，这里就不重复介绍了。

\n

为了帮助理解，我专门画了一张图来展示 notEmpty(非空) 和 notFull （非满）这两个条件对象是如何控制 ArrayBlockingQueue 的存和取的。

\n

\"ArrayBlockingQueue

\n\n

非阻塞式获取和新增元素

\n

ArrayBlockingQueue 非阻塞式获取和新增元素的方法为：

\n\n

先来看看 offer 方法，逻辑和 put 差不多，唯一的区别就是入队失败时不会阻塞当前线程，而是直接返回 false。

\n
public boolean offer(E e) {\n        //确保插入的元素不为null\n        checkNotNull(e);\n        //获取锁\n        final ReentrantLock lock = this.lock;\n        lock.lock();\n        try {\n             //队列已满直接返回false\n            if (count == items.length)\n                return false;\n            else {\n                //反之将元素入队并直接返回true\n                enqueue(e);\n                return true;\n            }\n        } finally {\n            //释放锁\n            lock.unlock();\n        }\n    }
\n

poll 方法同理，获取元素失败也是直接返回空，并不会阻塞获取元素的线程。

\n
public E poll() {\n        final ReentrantLock lock = this.lock;\n        //上锁\n        lock.lock();\n        try {\n            //如果队列为空直接返回null，反之出队返回元素值\n            return (count == 0) ? null : dequeue();\n        } finally {\n            lock.unlock();\n        }\n    }
\n

add 方法其实就是对于 offer 做了一层封装，如下代码所示，可以看到 add 会调用没有规定时间的 offer，如果入队失败则直接抛异常。

\n
public boolean add(E e) {\n        return super.add(e);\n    }\n\n\npublic boolean add(E e) {\n        //调用offer方法如果失败直接抛出异常\n        if (offer(e))\n            return true;\n        else\n            throw new IllegalStateException(\"Queue full\");\n    }
\n

remove 方法同理，调用 poll，如果返回 null 则说明队列没有元素，直接抛出异常。

\n
public E remove() {\n        E x = poll();\n        if (x != null)\n            return x;\n        else\n            throw new NoSuchElementException();\n    }
\n

peek() 方法的逻辑也很简单，内部调用了 itemAt 方法。

\n
public E peek() {\n        //加锁\n        final ReentrantLock lock = this.lock;\n        lock.lock();\n        try {\n            //当队列为空时返回 null\n            return itemAt(takeIndex);\n        } finally {\n            //释放锁\n            lock.unlock();\n        }\n    }\n\n//返回队列中指定位置的元素\n@SuppressWarnings(\"unchecked\")\nfinal E itemAt(int i) {\n    return (E) items[i];\n}
\n

指定超时时间内阻塞式获取和新增元素

\n

在 offer(E e) 和 poll() 非阻塞获取和新增元素的基础上，设计者提供了带有等待时间的 offer(E e, long timeout, TimeUnit unit) 和 poll(long timeout, TimeUnit unit) ，用于在指定的超时时间内阻塞式地添加和获取元素。

\n
 public boolean offer(E e, long timeout, TimeUnit unit)\n        throws InterruptedException {\n\n        checkNotNull(e);\n        long nanos = unit.toNanos(timeout);\n        final ReentrantLock lock = this.lock;\n        lock.lockInterruptibly();\n        try {\n        //队列已满，进入循环\n            while (count == items.length) {\n            //时间到了队列还是满的，则直接返回false\n                if (nanos <= 0)\n                    return false;\n                 //阻塞nanos时间，等待非满\n                nanos = notFull.awaitNanos(nanos);\n            }\n            enqueue(e);\n            return true;\n        } finally {\n            lock.unlock();\n        }\n    }
\n

可以看到，带有超时时间的 offer 方法在队列已满的情况下，会等待用户所传的时间段，如果规定时间内还不能存放元素则直接返回 false。

\n
public E poll(long timeout, TimeUnit unit) throws InterruptedException {\n        long nanos = unit.toNanos(timeout);\n        final ReentrantLock lock = this.lock;\n        lock.lockInterruptibly();\n        try {\n          //队列为空，循环等待，若时间到还是空的，则直接返回null\n            while (count == 0) {\n                if (nanos <= 0)\n                    return null;\n                nanos = notEmpty.awaitNanos(nanos);\n            }\n            return dequeue();\n        } finally {\n            lock.unlock();\n        }\n    }
\n

同理，带有超时时间的 poll 也一样，队列为空则在规定时间内等待，若时间到了还是空的，则直接返回 null。

\n

判断元素是否存在

\n

ArrayBlockingQueue 提供了 contains(Object o) 来判断指定元素是否存在于队列中。

\n
public boolean contains(Object o) {\n    //若目标元素为空，则直接返回 false\n    if (o == null) return false;\n    //获取当前队列的元素数组\n    final Object[] items = this.items;\n    //加锁\n    final ReentrantLock lock = this.lock;\n    lock.lock();\n    try {\n        // 如果队列非空\n        if (count > 0) {\n            final int putIndex = this.putIndex;\n            //从队列头部开始遍历\n            int i = takeIndex;\n            do {\n                if (o.equals(items[i]))\n                    return true;\n                if (++i == items.length)\n                    i = 0;\n            } while (i != putIndex);\n        }\n        return false;\n    } finally {\n        //释放锁\n        lock.unlock();\n    }\n}
\n

ArrayBlockingQueue 获取和新增元素的方法对比

\n

为了帮助理解 ArrayBlockingQueue ，我们再来对比一下上面提到的这些获取和新增元素的方法。

\n

新增元素：

\n

| 方法 | 队列满时处理方式 | 方法返回值 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/java/collection/arrayblockingqueue-class-diagram.png", "date_published": "2023-06-21T05:03:13.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "CopyOnWriteArrayList 源码分析", "url": "https://javaguide.cn/java/collection/copyonwritearraylist-source-code.html", "id": "https://javaguide.cn/java/collection/copyonwritearraylist-source-code.html", "summary": "CopyOnWriteArrayList源码深度解析：详解写时复制COW机制、适用读多写少场景、线程安全List实现、快照一致性保证及内存开销权衡。", "content_html": "

CopyOnWriteArrayList 简介

\n

在 JDK1.5 之前，如果想要使用并发安全的 List 只能选择 Vector。而 Vector 是一种老旧的集合，已经被淘汰。Vector 对于增删改查等方法基本都加了 synchronized，这种方式虽然能够保证同步，但这相当于对整个 Vector 加上了一把大锁，使得每个方法执行的时候都要去获得锁，导致性能非常低下。

\n

JDK1.5 引入了 Java.util.concurrent（JUC）包，其中提供了很多线程安全且并发性能良好的容器，其中唯一的线程安全 List 实现就是 CopyOnWriteArrayList 。关于java.util.concurrent 包下常见并发容器的总结，可以看我写的这篇文章：Java 常见并发容器总结 。

\n

CopyOnWriteArrayList 到底有什么厉害之处？

\n

对于大部分业务场景来说，读取操作往往是远大于写入操作的。由于读取操作不会对原有数据进行修改，因此，对于每次读取都进行加锁其实是一种资源浪费。相比之下，我们应该允许多个线程同时访问 List 的内部数据，毕竟对于读取操作来说是安全的。

\n

这种思路与 ReentrantReadWriteLock 读写锁的设计思想非常类似，即读读不互斥、读写互斥、写写互斥（只有读读不互斥）。CopyOnWriteArrayList 更进一步地实现了这一思想。为了将读操作性能发挥到极致，CopyOnWriteArrayList 中的读取操作是完全无需加锁的。更加厉害的是，写入操作也不会阻塞读取操作，只有写写才会互斥。这样一来，读操作的性能就可以大幅度提升。

\n

CopyOnWriteArrayList 线程安全的核心在于其采用了 写时复制（Copy-On-Write） 的策略，从 CopyOnWriteArrayList 的名字就能看出了。

\n

Copy-On-Write 的思想是什么？

\n

CopyOnWriteArrayList名字中的“Copy-On-Write”即写时复制，简称 COW。

\n

下面是维基百科对 Copy-On-Write 的介绍，介绍的挺不错：

\n
\n

写入时复制（英语：Copy-on-write，简称 COW）是一种计算机程序设计领域的优化策略。其核心思想是，如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的。此作法主要的优点是如果调用者没有修改该资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。

\n
\n

这里再以 CopyOnWriteArrayList为例介绍：当需要修改（ add，set、remove 等操作） CopyOnWriteArrayList 的内容时，不会直接修改原数组，而是会先创建底层数组的副本，对副本数组进行修改，修改完之后再将修改后的数组赋值回去，这样就可以保证写操作不会影响读操作了。

\n

可以看出，写时复制机制非常适合读多写少的并发场景，能够极大地提高系统的并发性能。

\n

不过，写时复制机制并不是银弹，其依然存在一些缺点，下面列举几点：

\n
    \n
  1. 内存占用：每次写操作都需要复制一份原始数据，会占用额外的内存空间，在数据量比较大的情况下，可能会导致内存资源不足。
    2. \n
  2. 写操作开销：每一次写操作都需要复制一份原始数据，然后再进行修改和替换，所以写操作的开销相对较大，在写入比较频繁的场景下，性能可能会受到影响。
    3. \n
  3. 数据一致性问题：修改操作不会立即反映到最终结果中，还需要等待复制完成，这可能会导致一定的数据一致性问题。
    4. \n
  4. ……
    5. \n
\n

CopyOnWriteArrayList 源码分析

\n

这里以 JDK1.8 为例，分析一下 CopyOnWriteArrayList 的底层核心源码。

\n

CopyOnWriteArrayList 的类定义如下：

\n
public class CopyOnWriteArrayList<E>\nextends Object\nimplements List<E>, RandomAccess, Cloneable, Serializable\n{\n  //...\n}
\n

CopyOnWriteArrayList 实现了以下接口：

\n\n

\"CopyOnWriteArrayList

\n

初始化

\n

CopyOnWriteArrayList 中有一个无参构造函数和两个有参构造函数。

\n
// 创建一个空的 CopyOnWriteArrayList\npublic CopyOnWriteArrayList() {\n    setArray(new Object[0]);\n}\n\n// 按照集合的迭代器返回的顺序创建一个包含指定集合元素的 CopyOnWriteArrayList\npublic CopyOnWriteArrayList(Collection<? extends E> c) {\n    Object[] elements;\n    if (c.getClass() == CopyOnWriteArrayList.class)\n        elements = ((CopyOnWriteArrayList<?>)c).getArray();\n    else {\n        elements = c.toArray();\n        // c.toArray might (incorrectly) not return Object[] (see 6260652)\n        if (elements.getClass() != Object[].class)\n            elements = Arrays.copyOf(elements, elements.length, Object[].class);\n    }\n    setArray(elements);\n}\n\n// 创建一个包含指定数组的副本的列表\npublic CopyOnWriteArrayList(E[] toCopyIn) {\n    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));\n}
\n

插入元素

\n

CopyOnWriteArrayList 的 add()方法有三个版本：

\n\n

这里以add(E e)为例进行介绍：

\n
// 插入元素到 CopyOnWriteArrayList 的尾部\npublic boolean add(E e) {\n    final ReentrantLock lock = this.lock;\n    // 加锁\n    lock.lock();\n    try {\n        // 获取原来的数组\n        Object[] elements = getArray();\n        // 原来数组的长度\n        int len = elements.length;\n        // 创建一个长度+1的新数组，并将原来数组的元素复制给新数组\n        Object[] newElements = Arrays.copyOf(elements, len + 1);\n        // 元素放在新数组末尾\n        newElements[len] = e;\n        // array指向新数组\n        setArray(newElements);\n        return true;\n    } finally {\n        // 解锁\n        lock.unlock();\n    }\n}
\n

从上面的源码可以看出：

\n\n
\n

Arrays.copyOf 方法的时间复杂度是 O(n)，其中 n 表示需要复制的数组长度。因为这个方法的实现原理是先创建一个新的数组，然后将源数组中的数据复制到新数组中，最后返回新数组。这个方法会复制整个数组，因此其时间复杂度与数组长度成正比，即 O(n)。值得注意的是，由于底层调用了系统级别的拷贝指令，因此在实际应用中这个方法的性能表现比较优秀，但是也需要注意控制复制的数据量，避免出现内存占用过高的情况。

\n
\n

读取元素

\n

CopyOnWriteArrayList 的读取操作是基于内部数组 array 并没有发生实际的修改，因此在读取操作时不需要进行同步控制和锁操作，可以保证数据的安全性。这种机制下，多个线程可以同时读取列表中的元素。

\n
// 底层数组，只能通过getArray和setArray方法访问\nprivate transient volatile Object[] array;\n\npublic E get(int index) {\n    return get(getArray(), index);\n}\n\nfinal Object[] getArray() {\n    return array;\n}\n\nprivate E get(Object[] a, int index) {\n    return (E) a[index];\n}
\n

不过，get方法是弱一致性的，在某些情况下可能读到旧的元素值。

\n

get(int index)方法是分两步进行的：

\n
    \n
  1. 通过getArray()获取当前数组的引用；
    2. \n
  2. 直接从数组中获取下标为 index 的元素。
    3. \n
\n

这个过程并没有加锁，所以在并发环境下可能出现如下情况：

\n
    \n
  1. 线程 1 调用get(int index)方法获取值，内部通过getArray()方法获取到了 array 属性值；
    2. \n
  2. 线程 2 调用CopyOnWriteArrayList的add、set、remove 等修改方法时，内部通过setArray方法修改了array属性的值；
    3. \n
  3. 线程 1 还是从旧的 array 数组中取值。
    4. \n
\n

获取列表中元素的个数

\n
public int size() {\n    return getArray().length;\n}
\n

CopyOnWriteArrayList中的array数组每次复制都刚好能够容纳下所有元素，并不像ArrayList那样会预留一定的空间。因此，CopyOnWriteArrayList中并没有size属性CopyOnWriteArrayList的底层数组的长度就是元素个数，因此size()方法只要返回数组长度就可以了。

\n

删除元素

\n

CopyOnWriteArrayList删除元素相关的方法一共有 4 个：

\n
    \n
  1. remove(int index)：移除此列表中指定位置上的元素。将任何后续元素向左移动（从它们的索引中减去 1）。
    2. \n
  2. boolean remove(Object o)：删除此列表中首次出现的指定元素，如果不存在该元素则返回 false。
    3. \n
  3. boolean removeAll(Collection<?> c)：从此列表中删除指定集合中包含的所有元素。
    4. \n
  4. void clear()：移除此列表中的所有元素。
    5. \n
\n

这里以remove(int index)为例进行介绍：

\n
public E remove(int index) {\n    // 获取可重入锁\n    final ReentrantLock lock = this.lock;\n    // 加锁\n    lock.lock();\n    try {\n         //获取当前array数组\n        Object[] elements = getArray();\n        // 获取当前array长度\n        int len = elements.length;\n        //获取指定索引的元素(旧值)\n        E oldValue = get(elements, index);\n        int numMoved = len - index - 1;\n        // 判断删除的是否是最后一个元素\n        if (numMoved == 0)\n             // 如果删除的是最后一个元素，直接复制该元素前的所有元素到新的数组\n            setArray(Arrays.copyOf(elements, len - 1));\n        else {\n            // 分段复制，将index前的元素和index+1后的元素复制到新数组\n            // 新数组长度为旧数组长度-1\n            Object[] newElements = new Object[len - 1];\n            System.arraycopy(elements, 0, newElements, 0, index);\n            System.arraycopy(elements, index + 1, newElements, index,\n                             numMoved);\n            //将新数组赋值给array引用\n            setArray(newElements);\n        }\n        return oldValue;\n    } finally {\n         // 解锁\n        lock.unlock();\n    }\n}
\n

判断元素是否存在

\n

CopyOnWriteArrayList提供了两个用于判断指定元素是否在列表中的方法：

\n\n
// 判断是否包含指定元素\npublic boolean contains(Object o) {\n    //获取当前array数组\n    Object[] elements = getArray();\n    //调用index尝试查找指定元素，如果返回值大于等于0，则返回true，否则返回false\n    return indexOf(o, elements, 0, elements.length) >= 0;\n}\n\n// 判断是否保证指定集合的全部元素\npublic boolean containsAll(Collection<?> c) {\n    //获取当前array数组\n    Object[] elements = getArray();\n    //获取数组长度\n    int len = elements.length;\n    //遍历指定集合\n    for (Object e : c) {\n        //循环调用indexOf方法判断，只要有一个没有包含就直接返回false\n        if (indexOf(e, elements, 0, len) < 0)\n            return false;\n    }\n    //最后表示全部包含或者制定集合为空集合，那么返回true\n    return true;\n}
\n

CopyOnWriteArrayList 常用方法测试

\n

代码：

\n
// 创建一个 CopyOnWriteArrayList 对象\nCopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();\n\n// 向列表中添加元素\nlist.add(\"Java\");\nlist.add(\"Python\");\nlist.add(\"C++\");\nSystem.out.println(\"初始列表：\" + list);\n\n// 使用 get 方法获取指定位置的元素\nSystem.out.println(\"列表第二个元素为：\" + list.get(1));\n\n// 使用 remove 方法删除指定元素\nboolean result = list.remove(\"C++\");\nSystem.out.println(\"删除结果：\" + result);\nSystem.out.println(\"列表删除元素后为：\" + list);\n\n// 使用 set 方法更新指定位置的元素\nlist.set(1, \"Golang\");\nSystem.out.println(\"列表更新后为：\" + list);\n\n// 使用 add 方法在指定位置插入元素\nlist.add(0, \"PHP\");\nSystem.out.println(\"列表插入元素后为：\" + list);\n\n// 使用 size 方法获取列表大小\nSystem.out.println(\"列表大小为：\" + list.size());\n\n// 使用 removeAll 方法删除指定集合中所有出现的元素\nresult = list.removeAll(List.of(\"Java\", \"Golang\"));\nSystem.out.println(\"批量删除结果：\" + result);\nSystem.out.println(\"列表批量删除元素后为：\" + list);\n\n// 使用 clear 方法清空列表中所有元素\nlist.clear();\nSystem.out.println(\"列表清空后为：\" + list);
\n

输出：

\n
列表更新后为：[Java, Golang]\n列表插入元素后为：[PHP, Java, Golang]\n列表大小为：3\n批量删除结果：true\n列表批量删除元素后为：[PHP]\n列表清空后为：[]
\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/collection/copyonwritearraylist-class-diagram.png", "date_published": "2023-06-08T12:34:44.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "LinkedList 源码分析", "url": "https://javaguide.cn/java/collection/linkedlist-source-code.html", "id": "https://javaguide.cn/java/collection/linkedlist-source-code.html", "summary": "LinkedList源码深度解析：剖析双向链表结构、Deque接口实现、头尾插入删除O(1)时间复杂度、与ArrayList性能对比及适用场景。", "content_html": "

\"《SpringAI

\n

LinkedList 简介

\n

LinkedList 是一个基于双向链表实现的集合类，经常被拿来和 ArrayList 做比较。关于 LinkedList 和ArrayList的详细对比，我们 Java 集合常见面试题总结(上)有详细介绍到。

\n

\"双向链表\"

\n

不过，我们在项目中一般是不会使用到 LinkedList 的，需要用到 LinkedList 的场景几乎都可以使用 ArrayList 来代替，并且，性能通常会更好！就连 LinkedList 的作者约书亚 · 布洛克（Josh Bloch）自己都说从来不会使用 LinkedList 。

\n

\n

另外，不要下意识地认为 LinkedList 作为链表就最适合元素增删的场景。我在上面也说了，LinkedList 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1)，其他情况增删元素的平均时间复杂度都是 O(n) 。

\n

LinkedList 插入和删除元素的时间复杂度？

\n\n

LinkedList 为什么不能实现 RandomAccess 接口？

\n

RandomAccess 是一个标记接口，用来表明实现该接口的类支持随机访问（即可以通过索引快速访问元素）。由于 LinkedList 底层数据结构是链表，内存地址不连续，只能通过指针来定位，不支持随机快速访问，所以不能实现 RandomAccess 接口。

\n

LinkedList 源码分析

\n

这里以 JDK1.8 为例，分析一下 LinkedList 的底层核心源码。

\n

LinkedList 的类定义如下：

\n
public class LinkedList<E>\n    extends AbstractSequentialList<E>\n    implements List<E>, Deque<E>, Cloneable, java.io.Serializable\n{\n  //...\n}
\n

LinkedList 继承了 AbstractSequentialList ，而 AbstractSequentialList 又继承于 AbstractList 。

\n

阅读过 ArrayList 的源码我们就知道，ArrayList 同样继承了 AbstractList ， 所以 LinkedList 会有大部分方法和 ArrayList 相似。

\n

LinkedList 实现了以下接口：

\n\n

\"LinkedList

\n

LinkedList 中的元素是通过 Node 定义的：

\n
private static class Node<E> {\n    E item;// 节点值\n    Node<E> next; // 指向的下一个节点（后继节点）\n    Node<E> prev; // 指向的前一个节点（前驱结点）\n\n    // 初始化参数顺序分别是：前驱结点、本身节点值、后继节点\n    Node(Node<E> prev, E element, Node<E> next) {\n        this.item = element;\n        this.next = next;\n        this.prev = prev;\n    }\n}
\n

初始化

\n

LinkedList 中有一个无参构造函数和一个有参构造函数。

\n
// 创建一个空的链表对象\npublic LinkedList() {\n}\n\n// 接收一个集合类型作为参数，会创建一个与传入集合相同元素的链表对象\npublic LinkedList(Collection<? extends E> c) {\n    this();\n    addAll(c);\n}
\n

插入元素

\n

LinkedList 除了实现了 List 接口相关方法，还实现了 Deque 接口的很多方法，所以我们有很多种方式插入元素。

\n

我们这里以 List 接口中相关的插入方法为例进行源码讲解，对应的是add() 方法。

\n

add() 方法有两个版本：

\n\n
// 在链表尾部插入元素\npublic boolean add(E e) {\n    linkLast(e);\n    return true;\n}\n\n// 在链表指定位置插入元素\npublic void add(int index, E element) {\n    // 下标越界检查\n    checkPositionIndex(index);\n\n    // 判断 index 是不是链表尾部位置\n    if (index == size)\n        // 如果是就直接调用 linkLast 方法将元素节点插入链表尾部即可\n        linkLast(element);\n    else\n        // 如果不是则调用 linkBefore 方法将其插入指定元素之前\n        linkBefore(element, node(index));\n}\n\n// 将元素节点插入到链表尾部\nvoid linkLast(E e) {\n    // 将最后一个元素赋值（引用传递）给节点 l\n    final Node<E> l = last;\n    // 创建节点，并指定节点前驱为链表尾节点 last，后继引用为空\n    final Node<E> newNode = new Node<>(l, e, null);\n    // 将 last 引用指向新节点\n    last = newNode;\n    // 判断尾节点是否为空\n    // 如果 l 是null 意味着这是第一次添加元素\n    if (l == null)\n        // 如果是第一次添加，将first赋值为新节点，此时链表只有一个元素\n        first = newNode;\n    else\n        // 如果不是第一次添加，将新节点赋值给l（添加前的最后一个元素）的next\n        l.next = newNode;\n    size++;\n    modCount++;\n}\n\n// 在指定元素之前插入元素\nvoid linkBefore(E e, Node<E> succ) {\n    // assert succ != null;断言 succ不为 null\n    // 定义一个节点元素保存 succ 的 prev 引用，也就是它的前一节点信息\n    final Node<E> pred = succ.prev;\n    // 初始化节点，并指明前驱和后继节点\n    final Node<E> newNode = new Node<>(pred, e, succ);\n    // 将 succ 节点前驱引用 prev 指向新节点\n    succ.prev = newNode;\n    // 判断前驱节点是否为空，为空表示 succ 是第一个节点\n    if (pred == null)\n        // 新节点成为第一个节点\n        first = newNode;\n    else\n        // succ 节点前驱的后继引用指向新节点\n        pred.next = newNode;\n    size++;\n    modCount++;\n}
\n

获取元素

\n

LinkedList获取元素相关的方法一共有 3 个：

\n
    \n
  1. getFirst()：获取链表的第一个元素。
    2. \n
  2. getLast()：获取链表的最后一个元素。
    3. \n
  3. get(int index)：获取链表指定位置的元素。
    4. \n
\n
// 获取链表的第一个元素\npublic E getFirst() {\n    final Node<E> f = first;\n    if (f == null)\n        throw new NoSuchElementException();\n    return f.item;\n}\n\n// 获取链表的最后一个元素\npublic E getLast() {\n    final Node<E> l = last;\n    if (l == null)\n        throw new NoSuchElementException();\n    return l.item;\n}\n\n// 获取链表指定位置的元素\npublic E get(int index) {\n  // 下标越界检查，如果越界就抛异常\n  checkElementIndex(index);\n  // 返回链表中对应下标的元素\n  return node(index).item;\n}
\n

这里的核心在于 node(int index) 这个方法：

\n
// 返回指定下标的非空节点\nNode<E> node(int index) {\n    // 断言下标未越界\n    // assert isElementIndex(index);\n    // 如果index小于size的二分之一  从前开始查找（向后查找）  反之向前查找\n    if (index < (size >> 1)) {\n        Node<E> x = first;\n        // 遍历，循环向后查找，直至 i == index\n        for (int i = 0; i < index; i++)\n            x = x.next;\n        return x;\n    } else {\n        Node<E> x = last;\n        for (int i = size - 1; i > index; i--)\n            x = x.prev;\n        return x;\n    }\n}
\n

get(int index) 或 remove(int index) 等方法内部都调用了该方法来获取对应的节点。

\n

从这个方法的源码可以看出，该方法通过比较索引值与链表 size 的一半大小来确定从链表头还是尾开始遍历。如果索引值小于 size 的一半，就从链表头开始遍历，反之从链表尾开始遍历。这样可以在较短的时间内找到目标节点，充分利用了双向链表的特性来提高效率。

\n

删除元素

\n

LinkedList删除元素相关的方法一共有 5 个：

\n
    \n
  1. removeFirst()：删除并返回链表的第一个元素。
    2. \n
  2. removeLast()：删除并返回链表的最后一个元素。
    3. \n
  3. remove(E e)：删除链表中首次出现的指定元素，如果不存在该元素则返回 false。
    4. \n
  4. remove(int index)：删除指定索引处的元素，并返回该元素的值。
    5. \n
  5. void clear()：移除此链表中的所有元素。
    6. \n
\n
// 删除并返回链表的第一个元素\npublic E removeFirst() {\n    final Node<E> f = first;\n    if (f == null)\n        throw new NoSuchElementException();\n    return unlinkFirst(f);\n}\n\n// 删除并返回链表的最后一个元素\npublic E removeLast() {\n    final Node<E> l = last;\n    if (l == null)\n        throw new NoSuchElementException();\n    return unlinkLast(l);\n}\n\n// 删除链表中首次出现的指定元素，如果不存在该元素则返回 false\npublic boolean remove(Object o) {\n    // 如果指定元素为 null，遍历链表找到第一个为 null 的元素进行删除\n    if (o == null) {\n        for (Node<E> x = first; x != null; x = x.next) {\n            if (x.item == null) {\n                unlink(x);\n                return true;\n            }\n        }\n    } else {\n        // 如果不为 null ,遍历链表找到要删除的节点\n        for (Node<E> x = first; x != null; x = x.next) {\n            if (o.equals(x.item)) {\n                unlink(x);\n                return true;\n            }\n        }\n    }\n    return false;\n}\n\n// 删除链表指定位置的元素\npublic E remove(int index) {\n    // 下标越界检查，如果越界就抛异常\n    checkElementIndex(index);\n    return unlink(node(index));\n}
\n

这里的核心在于 unlink(Node<E> x) 这个方法：

\n
E unlink(Node<E> x) {\n    // 断言 x 不为 null\n    // assert x != null;\n    // 获取当前节点（也就是待删除节点）的元素\n    final E element = x.item;\n    // 获取当前节点的下一个节点\n    final Node<E> next = x.next;\n    // 获取当前节点的前一个节点\n    final Node<E> prev = x.prev;\n\n    // 如果前一个节点为空，则说明当前节点是头节点\n    if (prev == null) {\n        // 直接让链表头指向当前节点的下一个节点\n        first = next;\n    } else { // 如果前一个节点不为空\n        // 将前一个节点的 next 指针指向当前节点的下一个节点\n        prev.next = next;\n        // 将当前节点的 prev 指针置为 null，，方便 GC 回收\n        x.prev = null;\n    }\n\n    // 如果下一个节点为空，则说明当前节点是尾节点\n    if (next == null) {\n        // 直接让链表尾指向当前节点的前一个节点\n        last = prev;\n    } else { // 如果下一个节点不为空\n        // 将下一个节点的 prev 指针指向当前节点的前一个节点\n        next.prev = prev;\n        // 将当前节点的 next 指针置为 null，方便 GC 回收\n        x.next = null;\n    }\n\n    // 将当前节点元素置为 null，方便 GC 回收\n    x.item = null;\n    size--;\n    modCount++;\n    return element;\n}
\n

unlink() 方法的逻辑如下：

\n
    \n
  1. 首先获取待删除节点 x 的前驱和后继节点；
    2. \n
  2. 判断待删除节点是否为头节点或尾节点：\n\n
    3. \n
  3. 将待删除节点 x 的前驱的后继指向待删除节点的后继 next，断开 x 和 x.prev 之间的链接；
    4. \n
  4. 将待删除节点 x 的后继的前驱指向待删除节点的前驱 prev，断开 x 和 x.next 之间的链接；
    5. \n
  5. 将待删除节点 x 的元素置空，修改链表长度。
    6. \n
\n

可以参考下图理解（图源：LinkedList 源码分析(JDK 1.8)）：

\n

\"unlink

\n

遍历链表

\n

推荐使用for-each 循环来遍历 LinkedList 中的元素， for-each 循环最终会转换成迭代器形式。

\n
LinkedList<String> list = new LinkedList<>();\nlist.add(\"apple\");\nlist.add(\"banana\");\nlist.add(\"pear\");\n\nfor (String fruit : list) {\n    System.out.println(fruit);\n}
\n

LinkedList 的遍历的核心就是它的迭代器的实现。

\n
// 双向迭代器\nprivate class ListItr implements ListIterator<E> {\n    // 表示上一次调用 next() 或 previous() 方法时经过的节点；\n    private Node<E> lastReturned;\n    // 表示下一个要遍历的节点；\n    private Node<E> next;\n    // 表示下一个要遍历的节点的下标，也就是当前节点的后继节点的下标；\n    private int nextIndex;\n    // 表示当前遍历期望的修改计数值，用于和 LinkedList 的 modCount 比较，判断链表是否被其他线程修改过。\n    private int expectedModCount = modCount;\n    …………\n}
\n

下面我们对迭代器 ListItr 中的核心方法进行详细介绍。

\n

我们先来看下从头到尾方向的迭代：

\n
// 判断还有没有下一个节点\npublic boolean hasNext() {\n    // 判断下一个节点的下标是否小于链表的大小，如果是则表示还有下一个元素可以遍历\n    return nextIndex < size;\n}\n// 获取下一个节点\npublic E next() {\n    // 检查在迭代过程中链表是否被修改过\n    checkForComodification();\n    // 判断是否还有下一个节点可以遍历，如果没有则抛出 NoSuchElementException 异常\n    if (!hasNext())\n        throw new NoSuchElementException();\n    // 将 lastReturned 指向当前节点\n    lastReturned = next;\n    // 将 next 指向下一个节点\n    next = next.next;\n    nextIndex++;\n    return lastReturned.item;\n}
\n

再来看一下从尾到头方向的迭代：

\n
// 判断是否还有前一个节点\npublic boolean hasPrevious() {\n    return nextIndex > 0;\n}\n\n// 获取前一个节点\npublic E previous() {\n    // 检查是否在迭代过程中链表被修改\n    checkForComodification();\n    // 如果没有前一个节点，则抛出异常\n    if (!hasPrevious())\n        throw new NoSuchElementException();\n    // 将 lastReturned 和 next 指针指向上一个节点\n    lastReturned = next = (next == null) ? last : next.prev;\n    nextIndex--;\n    return lastReturned.item;\n}
\n

如果需要删除或插入元素，也可以使用迭代器进行操作。

\n
LinkedList<String> list = new LinkedList<>();\nlist.add(\"apple\");\nlist.add(null);\nlist.add(\"banana\");\n\n//  Collection 接口的 removeIf 方法底层依然是基于迭代器\nlist.removeIf(Objects::isNull);\n\nfor (String fruit : list) {\n    System.out.println(fruit);\n}
\n

迭代器对应的移除元素的方法如下：

\n
// 从列表中删除上次被返回的元素\npublic void remove() {\n    // 检查是否在迭代过程中链表被修改\n    checkForComodification();\n    // 如果上次返回的节点为空，则抛出异常\n    if (lastReturned == null)\n        throw new IllegalStateException();\n\n    // 获取当前节点的下一个节点\n    Node<E> lastNext = lastReturned.next;\n    // 从链表中删除上次返回的节点\n    unlink(lastReturned);\n    // 修改指针\n    if (next == lastReturned)\n        next = lastNext;\n    else\n        nextIndex--;\n    // 将上次返回的节点引用置为 null，方便 GC 回收\n    lastReturned = null;\n    expectedModCount++;\n}
\n

LinkedList 常用方法测试

\n

代码：

\n
// 创建 LinkedList 对象\nLinkedList<String> list = new LinkedList<>();\n\n// 添加元素到链表末尾\nlist.add(\"apple\");\nlist.add(\"banana\");\nlist.add(\"pear\");\nSystem.out.println(\"链表内容：\" + list);\n\n// 在指定位置插入元素\nlist.add(1, \"orange\");\nSystem.out.println(\"链表内容：\" + list);\n\n// 获取指定位置的元素\nString fruit = list.get(2);\nSystem.out.println(\"索引为 2 的元素：\" + fruit);\n\n// 修改指定位置的元素\nlist.set(3, \"grape\");\nSystem.out.println(\"链表内容：\" + list);\n\n// 删除指定位置的元素\nlist.remove(0);\nSystem.out.println(\"链表内容：\" + list);\n\n// 删除第一个出现的指定元素\nlist.remove(\"banana\");\nSystem.out.println(\"链表内容：\" + list);\n\n// 获取链表的长度\nint size = list.size();\nSystem.out.println(\"链表长度：\" + size);\n\n// 清空链表\nlist.clear();\nSystem.out.println(\"清空后的链表：\" + list);
\n

输出：

\n
索引为 2 的元素：banana\n链表内容：[apple, orange, banana, grape]\n链表内容：[orange, banana, grape]\n链表内容：[orange, grape]\n链表长度：2\n清空后的链表：[]
\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/bidirectional-linkedlist.png", "date_published": "2023-06-07T05:18:39.000Z", "date_modified": "2026-03-10T15:16:51.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "工作五年之后，对技术和业务的思考", "url": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/thinking-about-technology-and-business-after-five-years-of-work.html", "id": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/thinking-about-technology-and-business-after-five-years-of-work.html", "summary": "工作五年之后，对技术和业务的思考：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：这是我在两年前看到的一篇对我触动比较深的文章。确实要学会适应变化，并积累能力。积累解决问题的能力，优化思考方式，拓宽自己的认知。

\n

原文地址： https://mp.weixin.qq.com/s/CTbEdi0F4-qFoJT05kNlXA

\n
\n

苦海无边，回头无岸。

\n

01 前言

\n

晃晃悠悠的，在互联网行业工作了五年，默然回首，你看哪里像灯火阑珊处？

\n

初入职场，大部分程序员会觉得苦学技术，以后会顺风顺水升职加薪，这样的想法没有错，但是不算全面，五年后你会不会继续做技术写代码这是核心问题。

\n

初入职场，会觉得努力加班可以不断提升能力，可以学到技术的公司就算薪水低点也可以接受，但是五年之后会认为加班都是在不断挤压自己的上升空间，薪水低是人生的天花板。

\n

这里想说的关键问题就是：初入职场的认知和想法大部分不会再适用于五年后的认知。

\n

工作五年之后面临的最大压力就是选择：职场天花板，技术能力天花板，薪水天花板，三十岁天花板。

\n

如何面对这些问题，是大部分程序员都在思考和纠结的。做选择的唯一参考点就是：利益最大化，这里可以理解为职场更好的升职加薪，顺风顺水。

\n

五年，变化最大不是工作经验，能力积累，而是心态，清楚的知道现实和理想之间是存在巨大的差距。

\n

02 学会适应变化，并积累能力

\n

回首自己的职场五年，最认可的一句话就是：学会适应变化，并积累能力。

\n

变化的就是，五年的时间技术框架更新迭代，开发工具的变迁，公司环境队友的更换，甚至是不同城市的流浪，想着能把肉体和灵魂安放在一处，有句很经典的话就是：唯一不变的就是变化本身。

\n

要积累的是：解决问题的能力，思考方式，拓宽认知。

\n

这种很难直白的描述，属于个人认知的范畴，不同的人有不一样的看法，所以只能站在大众化的角度去思考。

\n

首先聊聊技术，大部分小白级别的，都希望自己的技术能力不断提高，争取做到架构师级别，但是站在当前的互联网环境中，这种想法实现难度还是偏高，这里既不是打击也不是为了抬杠。

\n

可以观察一下现状，技术团队大的 20-30 人，小的 10-15 人，能有一个架构师去专门管理底层框架都是少有现象。

\n

这个问题的原因很多，首先架构师的成本过高，环境架构也不是需要经常升级，说的难听点可能框架比项目生命周期更高。

\n

所以大部分公司的大部分业务，基于现有大部分成熟的开源框架都可以解决，这也就导致架构师这个角色通常由项目主管代替或者级别较高的开发直接负责，这就是现实情况。

\n

这就导致技术框架的选择思路就是：只选对的。即这方面的人才多，开源解决方案多，以此降低技术方面对公司业务发展的影响。

\n

那为什么还要不断学习和积累技术能力？如果没有这个能力，程序员岗位可能根本走不了五年之久，需要用技术深度积累不断解决工作中的各种问题，用技术的广度提升自己实现业务需求的认知边界，这是安放肉体的根本保障。

\n

这就是导致很多五年以后的程序员压力陡然升高的原因，走向管理岗的另一个壁垒就是业务思维和认知。

\n

03 提高业务能力的积累

\n

程序员该不该用心研究业务，这个问题真的没有纠结的必要，只要不是纯技术型的公司，都需要面对业务。

\n

不管技术、运营、产品、管理层，都是在面向业务工作。

\n

从自己职场轨迹来看，五年变化最大就是解决业务问题的能力，职场之初面对很多业务场景都不知道如何下手，到几年之后设计业务的解决方案。

\n

这是大部分程序员在职场前五年跳槽就能涨薪的根本原因，面对业务场景，基于积累的经验和现有的开源工具，能快速给出合理的解决思路和实现过程。

\n

工作五年可能对技术底层的清晰程度都没有初入职场的小白清楚，但是写的程序却可以避开很多坑坑洼洼，对于业务的审视也是很细节全面。

\n

解决业务能力的积累，对于技术视野的宽度需求更甚，比如职场初期对于海量数据的处理束手无策，但是在工作几年之后见识数据行业的技术栈，真的就是技术选型的视野问题。

\n

什么是衡量技术能力的标准？站在一个共识的角度上看：系统的架构与代码设计能适应业务的不断变化和各种需求。

\n

相对比与技术，业务的变化更加快速频繁，高级工程师或者架构师之所以薪资高，这些角色一方面能适应业务的迭代，并且在工作中具有一定前瞻性，会考虑业务变化的情况下代码复用逻辑，这样的能力是需要一定的技术视野和业务思维的沉淀。

\n

所以职场中：业务能说的井井有条，代码能写的明明白白，得到机会的可能性更大。

\n

04 不同的阶段技术和业务的平衡和选择

\n

从理性的角度看技术和业务两个方面，能让大部分人职场走的平稳顺利，但是不同的阶段对两者的平衡和选择是不一样的。

\n

在思考如何选择的时候，可以参考二八原则的逻辑，即在任何一组东西中，最重要的只占其中一小部分，约 20%，其余 80%尽管是多数，却是次要的，因此又称二八定律。

\n

个人真的非常喜欢这个原则，大部分人都不是天才，所以很难三心二意同时做好几件事情，在同一时间段内应该集中精力做好一件事件。

\n

但是单纯的二八原则模式可能不适应大部分职场初期的人，因为初期要学习很多内容，如何在职场生存：专业能力，职场关系，为人处世，产品设计等等。

\n

当然这些东西不是都要用心刻意学习，但是合理安排二二六原则或其他组合是更明智的，首先是专业能力要重点练习，其次可以根据自己的兴趣合理选择一到两个方面去慢慢了解，例如产品，运营，运维，数据等，毕竟三五年以后会不会继续写代码很难说，多给自己留个机会总是有备无患。

\n

在职场初期，基本都是从技术角度去思考问题，如何快速提升自己的编码能力，在公司能稳定是首要目标，因此大部分时间都是在做基础编码和学习规范，这时可能 90%的心思都是放在基础编码上，另外 10%会学习环境架构。

\n

最多一到两年，就会开始独立负责模块需求开发，需要自己设计整个代码思路，这里业务就会进入视野，要懂得业务上下游关联关系，学会思考如何设计代码结构，才能在需求变动的情况下代码改动较少，这个时候可能就会放 20%的心思在业务方面，30%学习架构方式。

\n

三到五年这个时间段，是解决问题能力提升最快的时候，因为这个阶段的程序员基本都是在开发核心业务链路，例如交易、支付、结算、智能商业等模块，需要对业务整体有较清晰的把握能力，不然就是给自己挖坑，这个阶段要对业务流付出大量心血思考。

\n

越是核心的业务线，越是容易爆发各种问题，如果在日常工作中不花心思处理各种细节问题，半夜异常自动的消息和邮件总是容易让人憔悴。

\n

所以努力学习技术是提升自己，培养自己的业务认知也同样重要，个人认为这二者的分量平分秋色，只是需要在合适的阶段做出合理的权重划分。

\n

05 学会在职场做选择和生存

\n

基于技术能力和业务思维，学会在职场做选择和生存，这些是职场前五年一路走来的最大体会。

\n

不管是技术还是业务，这两个概念依旧是个很大的命题，不容易把握，所以学会理清这两个方面能力中的公共模块是关键。

\n

不管技术还是业务，都不可能从一家公司完全复制到另一家公司，但是可以把一家公司的技术框架，业务解决方案学会，并且带到另一家公司，例如技术领域内的架构、设计、流程、数据管理，业务领域内的思考方式、产品逻辑、分析等，这些是核心能力并且是大部分公司人才招聘的要求，所以这些才是工作中需要重点积累的。

\n

人的精力是有限的，而且面对三十这个天花板，各种事件也会接连而至，在职场中学会合理安排时间并不断提升核心能力，这样才能保证自己的竞争力。

\n

职场就像苦海无边，回首望去可能也没有岸边停泊，但是要具有换船的能力或者有个小木筏也就大差不差了。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "date_published": "2023-06-04T16:54:06.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [ { "name": "知了一笑" } ], "tags": [ "技术文章精选集" ] }, { "title": "使用建议", "url": "https://javaguide.cn/javaguide/use-suggestion.html", "id": "https://javaguide.cn/javaguide/use-suggestion.html", "summary": "JavaGuide使用建议，讲解如何高效利用本站内容进行Java学习与面试准备的方法指南。", "content_html": "

对于不准备面试的同学来说 ，本文档倾向于给你提供一个比较详细的学习路径，目录清晰，让你对于 Java 整体的知识体系有一个清晰认识。你可以跟着视频、书籍或者官方文档学习完某个知识点之后，然后来这里找对应的总结，帮助你更好地掌握对应的知识点。甚至说，你在有编程基础的情况下，想要学习某个知识点的话，可以直接看我的总结，这样学习效率会非常高。

\n

对于准备面试的同学来说 ，本文档涵盖 Java 程序员所需要掌握的核心知识的常见面试问题总结。

\n

大部分人看 JavaGuide 应该都是为了准备技术八股文。那如何才能更高效地准备技术八股文？

\n

对于技术八股文来说，尽量不要死记硬背，这种方式非常枯燥且对自身能力提升有限！但是！想要一点不背是不太现实的，只是说要结合实际应用场景和实战来理解记忆。

\n

我一直觉得面试八股文最好是和实际应用场景和实战相结合。很多同学现在的方向都错了，上来就是直接背八股文，硬生生学成了文科，那当然无趣了。

\n

举个例子：你的项目中需要用到 Redis 来做缓存，你对照着官网简单了解并实践了简单使用 Redis 之后，你去看了 Redis 对应的八股文。你发现 Redis 可以用来做限流、分布式锁，于是你去在项目中实践了一下并掌握了对应的八股文。紧接着，你又发现 Redis 内存不够用的情况下，还能使用 Redis Cluster 来解决，于是你就又去实践了一下并掌握了对应的八股文。

\n

而且， 面试中有水平的面试官都是根据你的项目经历来顺带着问一些技术八股文 。

\n

举个例子：你的项目用到了消息队列，那面试官可能就会问你：为什么使用消息队列？项目中什么模块用到了消息队列？如何保证消息不丢失？如何保证消息的顺序性?（结合你使用的具体的消息队列来准备）……。

\n

一定要记住你的主要目标是理解和记关键词，而不是像背课文一样一字一句地记下来！

\n

另外，记录博客或者用自己的理解把对应的知识点讲给别人听也是一个不错的选择。

\n

最后，准备技术面试的同学一定要定期复习（自测的方式非常好），不然确实会遗忘的。

\n", "date_published": "2023-05-22T02:13:07.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "走近项目" ] }, { "title": "十年大厂成长之路", "url": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/ten-years-of-dachang-growth-road.html", "id": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/ten-years-of-dachang-growth-road.html", "summary": "十年大厂成长之路：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：这篇文章的作者有着丰富的工作经验，曾在大厂工作了 12 年。结合自己走过的弯路和接触过的优秀技术人，他总结出了一些对于个人成长具有普遍指导意义的经验和特质。

\n

原文地址： https://mp.weixin.qq.com/s/vIIRxznpRr5yd6IVyNUW2w

\n
\n

最近这段时间，有好几个年轻的同学和我聊到自己的迷茫。其中有关于技术成长的、有关于晋升的、有关于择业的。我很高兴他们愿意听我这个“过来人”分享自己的经验。

\n

我自己毕业后进入大厂，在大厂工作 12 年，我说的内容都来自于我自己或者身边人的真实情况。尤其，我会把 【我自己走过的弯路】 和 【我看到过的优秀技术人的特质】 相结合来给出建议。

\n

这些内容我觉得具有普遍的指导意义，所以决定做个整理分享出来。我相信，无论你在大厂还是小厂，如果你相信这些建议，或早或晚他们会帮助到你。

\n

我自己工作 12 年，走了些弯路，所以我就来讲讲，“在一个技术人 10 年的发展过程中，应该注意些什么”。我们把内容分为两块：

\n
    \n
  1. 十年技术路怎么走
    2. \n
  2. 一些重要选择
    3. \n
\n

01 十年技术路怎么走

\n

【1-2 年】=> 从“菜鸟”到“职业”

\n

应届生刚进入到工作时，会有各种不适应。比如写好的代码会被反复打回、和团队老司机讨论技术问题会有一堆问号、不敢提问和质疑、碰到问题一个人使劲死磕等等。

\n

简单来说就是，即使日以继夜地埋头苦干，最后也无法顺利的开展工作。

\n

这个阶段最重要的几个点：

\n

【多看多模仿】：比如写代码的时候，不要就像在学校完成书本作业那样只关心功能是否正确，还要关心模块的设计、异常的处理、代码的可读性等等。在你还没有了解这些内容的精髓之前，也要照猫画虎地模仿起来，慢慢地你就会越来越明白真实世界的代码是怎么写的，以及为什么要这么写。

\n

做技术方案的时候也是同理，技术文档的要求你也许并不理解，但你可以先参考已有文档写起来。

\n

【脸皮厚一点】：不懂就问，你是新人大家都是理解的。你做的各种方案也可以多找老司机们 review，不要怕被看笑话。

\n

【关注工作方式】：比如发现需求在计划时间完不成就要尽快报风险、及时做好工作内容的汇报（例如周报）、开会后确定会议结论和 todo 项、承诺时间就要尽力完成、严格遵循公司的要求（例如发布规范、权限规范等）

\n

一般来说，工作 2 年后，你就应该成为一个职业人。老板可以相信任何工作交到你的手里，不会出现“意外”（例如一个重要需求明天要上线了，突然被告知上不了）。

\n

【3-4 年】=> 从“职业”到“尖兵”

\n

工作两年后，对业务以及现有系统的了解已经到达了一定的程度，技术同学会开始承担更有难度的技术挑战。

\n

例如需要将性能提升到某一个水位、例如需要对某一个重要模块进行重构、例如有个重要的项目需要协同 N 个团队一起完成。

\n

可见，上述的这些技术问题，难度都已经远远超过一个普通的需求。解决这些问题需要有一定的技术能力，同时也需要具备更高的协同能力。

\n

这个阶段最重要的几个点：

\n

【技术能力提升】：无论是公司内还是公司外的技术内容，都要多做主动的学习。基本上这个阶段的技术难题都集中在【性能】【稳定性】和【扩展性】上，而这些内容在业界都是有成型的方法论的。

\n

【主人翁精神】：技术难题除了技术方案设计及落地外，背后还有一系列的其他工作。例如上线后对效果的观测、重点项目对于上下游改造和风险的了解程度、对于整个技改后续的计划（二期、三期的优化思路）等。

\n

在工作四年后，基本上你成为了团队的一、二号技术位。很多技术难题即使不是你来落地，也是由你来决定方案。你会做调研、会做方案对比、会考虑整个技改的生命周期。

\n

【5-7 年】=> 从“尖兵”到“专家”

\n

技术尖兵重点在于解决某一个具体的技术难题或者重点项目。而下一步的发展方向，就是能够承担起来一整个“业务板块”，也就是“领域技术专家”。

\n

想要承担一整个“业务板块”需要 【对业务领域有深刻的理解，同时基于这些理解来规划技术的发展方向】 。

\n

拿支付做个例子。简单的支付功能其实很容易完成，只要处理好和双联（网联和银联）的接口调用（成功、失败、异常）即可。但在很多背景下，支付没有那么简单。

\n

例如，支付是一个用户敏感型操作，非常强调用户体验，如何能兼顾体验和接口的不稳定？支付接口还需要承担费用，同步和异步的接口费用不同，如何能够降本？支付接口往往还有限额等。这一系列问题的背后涉及到很多技术的设计，包括异步化、补偿设计、资金流设计、最终一致性设计等等。

\n

这个阶段最重要的几个点：

\n

【深入理解行业及趋势】：密切关注行业的各种变化（新鲜的玩法、政策的变动、竞对的策略、科技等外在因素的影响等等），和业务同学加强沟通。

\n

【深入了解行业解决方案】：充分对标已有的国内外技术方案，做深入学习和尝试，评估建设及运维成本，结合业务趋势制定计划。

\n

【8-10 年】=> 从“专家”到“TL”

\n

其实很多时候，如果能做到专家，基本也是一个 TL 的角色了，但这并不代表正在执行 TL 的职责。

\n

专家虽然已经可以做到“为业务发展而规划好技术发展”，但问题是要怎么落地呢？显然，靠一个人的力量是不可能完成建设的。所以，这里的 TL 更多强调的不是“领导”这个职位，而是 【通过聚合一个团队的力量来实施技术规划】 。

\n

所以，这里的 TL 需要具备【团队技术培养】【合理分配资源】【确认工作优先级】【激励与奖惩】等各种能力。

\n

这个阶段最重要的几个点：

\n

【学习管理学】：这里的管理学当然不是指 PUA，而是指如何在每个同学都有各自诉求的现实背景下，让个人目标和团队目标相结合，产生向前发展的动力。

\n

【始终扎根技术】：很多时候，工作重心偏向管理以后，就会荒废技术。但事实是，一个优秀的领导永远是一个优秀的技术人。参与一起讨论技术方案并给予指导、不断扩展自己的技术宽度、保持对技术的好奇心，这些是让一个技术领导持续拥有向心力的关键。

\n

02 一些重要选择

\n

下面来聊聊在十年间我们可能会碰到的一些重要选择。这些都是真实的血与泪的教训。

\n

我该不该转岗？

\n

大厂都有转岗的机制。转岗可以帮助员工寻找自己感兴趣的方向，也可以帮助新型团队招募有即战力的同学。

\n

转岗看似只是在公司内部变动，但你需要谨慎决定。

\n

本人转岗过多次。虽然还在同一家公司，但转岗等同于换工作。无论是领域沉淀、工作内容、信任关系、协作关系都是从零开始。

\n

针对转岗我的建议是：如果你是想要拓宽自己的技术广度，也就是抱着提升技术能力的想法，我觉得可以转岗。但如果你想要晋升，不建议你转岗。晋升需要在一个领域的持续积淀和在一个团队信任感的持续建立。

\n

当然，转岗可能还有其他原因，例如家庭原因、身体原因等，这个不展开讨论了。

\n

我该不该跳槽？

\n

跳槽和转岗一样，往往有很多因素造成，不能一概而论，我仅以几个场景来说：

\n

【晋升失败】：扪心自问，如果你觉得自己确实还不够格，那你就踏踏实实继续努力。如果你觉得评委有失偏颇，你可以尝试去外面面试一下，让市场来给你答案。

\n

【成长局限】：觉得自己做的事情没有挑战，无法成长。你可以和老板聊一下，有可能是因为你没有看到其中的挑战，也有可能老板没有意识到你的“野心”。

\n

【氛围不适】：一般来自于新入职或者领导更换，这种情况下不适是正常的。我的建议是，如果一个环境是“对事不对人”的，那就可以留下来，努力去适应，这种不适应只是做事方式不同导致的。但如果这个环境是“对人不对事”的话，走吧。

\n

跳槽该找怎样的工作？

\n

我们跳槽的时候往往会同时面试好几家公司。行情好的时候，往往可以收到多家 offer，那么我们要如何选择呢？

\n

考虑一个 offer 往往有这几点：【公司品牌】【薪资待遇】【职级职称】【技术背景】。每个同学其实都有自己的诉求，所以无论做什么选择都没有对错之分。

\n

我的一个建议是：你要关注新岗位的空间，这个空间是有希望满足你的期待的。

\n

比如，你想成为架构师，那新岗位是否有足够的技术挑战来帮助你提升技术能力，而不仅仅是疲于奔命地应付需求？

\n

比如，你想往技术管理发展，那新岗位是否有带人的机会？是否有足够的问题需要搭建团队来解决？

\n

比如，你想扎根在某个领域持续发展（例如电商、游戏），那新岗位是不是延续这个领域，并且可以碰到更多这个领域的问题？

\n

当然，如果薪资实在高到无法拒绝，以上参考可以忽略!

\n

结语

\n

以上就是我对互联网从业技术人员十年成长之路的心得，希望在你困惑和关键选择的时候可以帮助到你。如果我的只言片语能够在未来的某个时间帮助到你哪怕一点，那将是我莫大的荣幸。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "date_published": "2023-05-15T09:49:43.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [ { "name": "CodingBetterLife" } ], "tags": [ "技术文章精选集" ] }, { "title": "32条总结教你提升职场经验", "url": "https://javaguide.cn/high-quality-technical-articles/work/32-tips-improving-career.html", "id": "https://javaguide.cn/high-quality-technical-articles/work/32-tips-improving-career.html", "summary": "32条总结教你提升职场经验：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：阿里开发者的一篇职场经验的分享。

\n

原文地址： https://mp.weixin.qq.com/s/6BkbGekSRTadm9j7XUL13g

\n
\n

成长的捷径

\n\n

功夫在日常

\n\n
\n

最后一条大概意思就是有时候我们会在意自己在聚光灯下（述职、晋升、周报、汇报等）的表现，以为大家会根据这个评价自己。实际上日常是怎么完成业务需求、帮助身边同学、创造价值的，才是大家评价自己的依据，而且每个人是什么样的特质，合作过三次的伙伴就可以精准评价，在聚光灯下的表演只能骗自己。

\n
\n

学会被管理

\n
\n

上级、主管是泛指，开发对口的 PD 主管等也在范围内。

\n
\n\n

思维转换

\n\n

要栓住情绪

\n\n

成为 Leader

\n
\n

Manager 有下属，Leader 有追随者，管理者不需要很多，但人人都可以是 Leader。

\n
\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "date_published": "2023-05-15T09:49:43.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "技术文章精选集" ] }, { "title": "JVM线上问题排查和性能调优案例", "url": "https://javaguide.cn/java/jvm/jvm-in-action.html", "id": "https://javaguide.cn/java/jvm/jvm-in-action.html", "summary": "汇集 JVM 在生产中的问题排查与优化案例，涵盖内存与 GC、工具使用等。", "content_html": "

JVM 线上问题排查和性能调优也是面试常问的一个问题，尤其是社招中大厂的面试。

\n

这篇文章，我会分享一些我看到的相关的案例。

\n

下面是正文。

\n

一次线上 OOM 问题分析 - 艾小仙 - 2023

\n\n

生产事故-记一次特殊的 OOM 排查 - 程语有云 - 2023

\n\n

一次大量 JVM Native 内存泄露的排查分析（64M 问题） - 掘金 - 2022

\n\n

YGC 问题排查，又让我涨姿势了！ - IT 人的职场进阶 - 2021

\n\n

听说 JVM 性能优化很难？今天我小试了一把！ - 陈树义 - 2021

\n

通过观察 GC 频率和停顿时间，来进行 JVM 内存空间调整，使其达到最合理的状态。调整过程记得小步快跑，避免内存剧烈波动影响线上服务。 这其实是最为简单的一种 JVM 性能调优方式了，可以算是粗调吧。

\n

你们要的线上 GC 问题案例来啦 - 编了个程 - 2021

\n\n

Java 中 9 种常见的 CMS GC 问题分析与解决 - 美团技术团 - 2020

\n

这篇文章共 2w+ 字，详细介绍了 GC 基础，总结了 CMS GC 的一些常见问题分析与解决办法。

\n

给祖传系统做了点 GC 调优，暂停时间降低了 90% - 京东云技术团队 - 2023

\n

这篇文章提到了一个在规则引擎系统中遇到的 GC（垃圾回收）问题，主要表现为系统在启动后发生了一次较长的 Young GC（年轻代垃圾回收）导致性能下降。经过分析，问题的核心在于动态对象年龄判定机制，它导致了过早的对象晋升，引起了长时间的垃圾回收。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "date_published": "2023-05-10T08:36:34.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "分布式ID设计实战指南", "url": "https://javaguide.cn/distributed-system/distributed-id-design.html", "id": "https://javaguide.cn/distributed-system/distributed-id-design.html", "summary": "分布式ID设计实战指南，结合订单系统、一码付、优惠券等业务场景讲解分布式ID的设计要点、技术选型及不同场景下的ID生成策略。", "content_html": "
\n

提示

\n

看到百度 Geek 说的一篇结合具体场景聊分布式 ID 设计的文章，感觉挺不错的。于是，我将这篇文章的部分内容整理到了这里。原文传送门：分布式 ID 生成服务的技术原理和项目实战 。

\n
\n

网上绝大多数的分布式 ID 生成服务，一般着重于技术原理剖析，很少见到根据具体的业务场景去选型 ID 生成服务的文章。

\n

本文结合一些使用场景，进一步探讨业务场景中对 ID 有哪些具体的要求。

\n

场景一：订单系统

\n

我们在商场买东西一码付二维码，下单生成的订单号，使用到的优惠券码，联合商品兑换券码，这些是在网上购物经常使用到的单号，那么为什么有些单号那么长，有些只有几位数？有些单号一看就知道年月日的信息，有些却看不出任何意义？下面展开分析下订单系统中不同场景的 id 服务的具体实现。

\n

1、一码付

\n

我们常见的一码付，指的是一个二维码可以使用支付宝或者微信进行扫码支付。

\n

二维码的本质是一个字符串。聚合码的本质就是一个链接地址。用户使用支付宝微信直接扫一个码付钱，不用担心拿支付宝扫了微信的收款码或者用微信扫了支付宝的收款码，这极大减少了用户扫码支付的时间。

\n

实现原理是当客户用 APP 扫码后，网站后台就会判断客户的扫码环境。（微信、支付宝、QQ 钱包、京东支付、云闪付等）。

\n

判断扫码环境的原理就是根据打开链接浏览器的 HTTP header。任何浏览器打开 http 链接时，请求的 header 都会有 User-Agent(UA、用户代理)信息。

\n

UA 是一个特殊字符串头，服务器依次可以识别出客户使用的操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等很多信息。

\n

各渠道对应支付产品的名称不一样，一定要仔细看各支付产品的 API 介绍。

\n
    \n
  1. 微信支付：JSAPI 支付支付
    2. \n
  2. 支付宝：手机网站支付
    3. \n
  3. QQ 钱包：公众号支付
    4. \n
\n

其本质均为在 APP 内置浏览器中实现 HTML5 支付。

\n

\"文库会员支付示例\"

\n

文库的研发同学在这个思路上，做了优化迭代。动态生成一码付的二维码预先绑定用户所选的商品信息和价格，根据用户所选的商品动态更新。这样不仅支持一码多平台调起支付，而且不用用户选择商品输入金额，即可完成订单支付的功能，很丝滑。用户在真正扫码后，服务端才通过前端获取用户 UID，结合二维码绑定的商品信息，真正的生成订单，发送支付信息到第三方（qq、微信、支付宝），第三方生成支付订单推给用户设备，从而调起支付。

\n

区别于固定的一码付，在文库的应用中，使用到了动态二维码，二维码本质是一个短网址，ID 服务提供短网址的唯一标志参数。唯一的短网址映射的 ID 绑定了商品的订单信息，技术和业务的深度结合，缩短了支付流程，提升用户的支付体验。

\n

2、订单号

\n

订单号在实际的业务过程中作为一个订单的唯一标识码存在，一般实现以下业务场景：

\n
    \n
  1. 用户订单遇到问题，需要找客服进行协助；
    2. \n
  2. 对订单进行操作，如线下收款，订单核销；
    3. \n
  3. 下单，改单，成单，退单，售后等系统内部的订单流程处理和跟进。
    4. \n
\n

很多时候搜索订单相关信息的时候都是以订单 ID 作为唯一标识符，这是由于订单号的生成规则的唯一性决定的。从技术角度看，除了 ID 服务必要的特性之外，在订单号的设计上需要体现几个特性：

\n

（1）信息安全

\n

编号不能透露公司的运营情况，比如日销、公司流水号等信息，以及商业信息和用户手机号，身份证等隐私信息。并且不能有明显的整体规律（可以有局部规律），任意修改一个字符就能查询到另一个订单信息，这也是不允许的。

\n

类比于我们高考时候的考生编号的生成规则，一定不能是连号的，否则只需要根据顺序往下查询就能搜索到别的考生的成绩，这是绝对不可允许。

\n

（2）部分可读

\n

位数要便于操作，因此要求订单号的位数适中，且局部有规律。这样可以方便在订单异常，或者退货时客服查询。

\n

过长的订单号或易读性差的订单号会导致客服输入困难且易错率较高，影响用户体验的售后体验。因此在实际的业务场景中，订单号的设计通常都会适当携带一些允许公开的对使用场景有帮助的信息，如时间，星期，类型等等，这个主要根据所涉及的编号对应的使用场景来。

\n

而且像时间、星期这些自增长的属于作为订单号的设计的一部分元素，有助于解决业务累积而导致的订单号重复的问题。

\n

（3）查询效率

\n

常见的电商平台订单号大多是纯数字组成，兼具可读性的同时，int 类型相对 varchar 类型的查询效率更高，对在线业务更加友好。

\n

3、优惠券和兑换券

\n

优惠券、兑换券是运营推广最常用的促销工具之一，合理使用它们，可以让买家得到实惠，商家提升商品销量。常见场景有：

\n
    \n
  1. 在文库购买【文库 VIP+QQ 音乐年卡】联合商品，支付成功后会得到 QQ 音乐年卡的兑换码，可以去 QQ 音乐 App 兑换音乐会员年卡；
    2. \n
  2. 疫情期间，部分地方政府发放的消费券；
    3. \n
  3. 瓶装饮料经常会出现输入优惠编码兑换奖品。
    4. \n
\n

\"优惠编码兑换奖品\"

\n

从技术角度看，有些场景适合 ID 即时生成，比如电商平台购物领取的优惠券，只需要在用户领取时分配优惠券信息即可。有些线上线下结合的场景，比如疫情优惠券，瓶盖开奖，京东卡，超市卡这种，则需要预先生成，预先生成的券码具备以下特性：

\n

1.预先生成，在活动正式开始前提供出来进行活动预热；

\n

2.优惠券体量大，以万为单位，通常在 10 万级别以上；

\n

3.不可破解、仿制券码；

\n

4.支持用后核销；

\n

5.优惠券、兑换券属于广撒网的策略，所以利用率低，也就不适合使用数据库进行存储 （占空间，有效的数据又少）。

\n

设计思路上，需要设计一种有效的兑换码生成策略，支持预先生成，支持校验，内容简洁，生成的兑换码都具有唯一性，那么这种策略就是一种特殊的编解码策略，按照约定的编解码规则支撑上述需求。

\n

既然是一种编解码规则，那么需要约定编码空间(也就是用户看到的组成兑换码的字符)，编码空间由字符 a-z,A-Z,数字 0-9 组成，为了增强兑换码的可识别度，剔除大写字母 O 以及 I,可用字符如下所示，共 60 个字符：

\n

abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXZY0123456789

\n

之前说过，兑换码要求尽可能简洁，那么设计时就需要考虑兑换码的字符数，假设上限为 12 位，而字符空间有 60 位，那么可以表示的空间范围为 60^12=130606940160000000000000(也就是可以 12 位的兑换码可以生成天量,应该够运营同学挥霍了)，转换成 2 进制：

\n

1001000100000000101110011001101101110011000000000000000000000(61 位)

\n

兑换码组成成分分析

\n

兑换码可以预先生成，并且不需要额外的存储空间保存这些信息，每一个优惠方案都有独立的一组兑换码(指运营同学组织的每一场运营活动都有不同的兑换码,不能混合使用, 例如双 11 兑换码不能使用在双 12 活动上)，每个兑换码有自己的编号，防止重复，为了保证兑换码的有效性，对兑换码的数据需要进行校验，当前兑换码的数据组成如下所示：

\n

优惠方案 ID + 兑换码序列号 i + 校验码

\n

编码方案

\n
    \n
  1. 兑换码序列号 i，代表当前兑换码是当前活动中第 i 个兑换码，兑换码序列号的空间范围决定了优惠活动可以发行的兑换码数目，当前采用 30 位 bit 位表示，可表示范围：1073741824（10 亿个券码）。
    2. \n
  2. 优惠方案 ID, 代表当前优惠方案的 ID 号，优惠方案的空间范围决定了可以组织的优惠活动次数，当前采用 15 位表示，可以表示范围：32768（考虑到运营活动的频率，以及 ID 的初始值 10000，15 位足够，365 天每天有运营活动，可以使用 54 年）。
    3. \n
  3. 校验码，校验兑换码是否有效，主要为了快捷的校验兑换码信息的是否正确，其次可以起到填充数据的目的，增强数据的散列性，使用 13 位表示校验位，其中分为两部分，前 6 位和后 7 位。
    4. \n
\n

深耕业务还会有区分通用券和单独券的情况，分别具备以下特点，技术实现需要因地制宜地思考。

\n
    \n
  1. 通用券：多个玩家都可以输入兑换，然后有总量限制，期限限制。
    2. \n
  2. 单独券：运营同学可以在后台设置兑换码的奖励物品、期限、个数，然后由后台生成兑换码的列表，兑换之后核销。
    3. \n
\n

场景二：Tracing

\n

1、日志跟踪

\n

在分布式服务架构下，一个 Web 请求从网关流入，有可能会调用多个服务对请求进行处理，拿到最终结果。这个过程中每个服务之间的通信又是单独的网络请求，无论请求经过的哪个服务出了故障或者处理过慢都会对前端造成影响。

\n

处理一个 Web 请求要调用的多个服务，为了能更方便的查询哪个环节的服务出现了问题，现在常用的解决方案是为整个系统引入分布式链路跟踪。

\n

\"在分布式链路跟踪\"

\n

在分布式链路跟踪中有两个重要的概念：跟踪（trace）和 跨度（ span)。trace 是请求在分布式系统中的整个链路视图，span 则代表整个链路中不同服务内部的视图，span 组合在一起就是整个 trace 的视图。

\n

在整个请求的调用链中，请求会一直携带 traceid 往下游服务传递，每个服务内部也会生成自己的 spanid 用于生成自己的内部调用视图，并和 traceid 一起传递给下游服务。

\n

2、TraceId 生成规则

\n

这种场景下，生成的 ID 除了要求唯一之外，还要求生成的效率高、吞吐量大。traceid 需要具备接入层的服务器实例自主生成的能力，如果每个 trace 中的 ID 都需要请求公共的 ID 服务生成，纯纯的浪费网络带宽资源。且会阻塞用户请求向下游传递，响应耗时上升，增加了没必要的风险。所以需要服务器实例最好可以自行计算 tracid，spanid，避免依赖外部服务。

\n

产生规则：服务器 IP + ID 产生的时间 + 自增序列 + 当前进程号 ，比如：

\n

0ad1348f1403169275002100356696

\n

前 8 位 0ad1348f 即产生 TraceId 的机器的 IP，这是一个十六进制的数字，每两位代表 IP 中的一段，我们把这个数字，按每两位转成 10 进制即可得到常见的 IP 地址表示方式 10.209.52.143，您也可以根据这个规律来查找到请求经过的第一个服务器。

\n

后面的 13 位 1403169275002 是产生 TraceId 的时间。之后的 4 位 1003 是一个自增的序列，从 1000 涨到 9000，到达 9000 后回到 1000 再开始往上涨。最后的 5 位 56696 是当前的进程 ID，为了防止单机多进程出现 TraceId 冲突的情况，所以在 TraceId 末尾添加了当前的进程 ID。

\n

3、SpanId 生成规则

\n

span 是层的意思，比如在第一个实例算是第一层， 请求代理或者分流到下一个实例处理，就是第二层，以此类推。通过层，SpanId 代表本次调用在整个调用链路树中的位置。

\n

假设一个 服务器实例 A 接收了一次用户请求，代表是整个调用的根节点，那么 A 层处理这次请求产生的非服务调用日志记录 spanid 的值都是 0，A 层需要通过 RPC 依次调用 B、C、D 三个服务器实例，那么在 A 的日志中，SpanId 分别是 0.1，0.2 和 0.3，在 B、C、D 中，SpanId 也分别是 0.1，0.2 和 0.3；如果 C 系统在处理请求的时候又调用了 E，F 两个服务器实例，那么 C 系统中对应的 spanid 是 0.2.1 和 0.2.2，E、F 两个系统对应的日志也是 0.2.1 和 0.2.2。

\n

根据上面的描述可以知道，如果把一次调用中所有的 SpanId 收集起来，可以组成一棵完整的链路树。

\n

spanid 的生成本质：在跨层传递透传的同时，控制大小版本号的自增来实现的。

\n

场景三：短网址

\n

短网址主要功能包括网址缩短与还原两大功能。相对于长网址，短网址可以更方便地在电子邮件，社交网络，微博和手机上传播，例如原来很长的网址通过短网址服务即可生成相应的短网址，避免折行或超出字符限制。

\n

\"短网址作用\"

\n

常用的 ID 生成服务比如：MySQL ID 自增、 Redis 键自增、号段模式，生成的 ID 都是一串数字。短网址服务把客户的长网址转换成短网址，

\n

实际是在 dwz.cn 域名后面拼接新产生的数字类型 ID，直接用数字 ID，网址长度也有些长，服务可以通过数字 ID 转更高进制的方式压缩长度。这种算法在短网址的技术实现上越来越多了起来，它可以进一步压缩网址长度。转进制的压缩算法在生活中有广泛的应用场景，举例：

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/distributed-system/distributed-id-design-pay-one-card.png", "date_published": "2023-05-05T02:23:30.000Z", "date_modified": "2026-03-12T04:06:59.000Z", "authors": [], "tags": [ "分布式" ] }, { "title": "Spring Cloud Gateway面试题总结", "url": "https://javaguide.cn/distributed-system/spring-cloud-gateway-questions.html", "id": "https://javaguide.cn/distributed-system/spring-cloud-gateway-questions.html", "summary": "Spring Cloud Gateway核心原理详解，包括路由配置、Predicate断言、Filter过滤器机制、限流熔断、工作流程等常见面试题与实践要点。", "content_html": "
\n

本文重构完善自6000 字 | 16 图 | 深入理解 Spring Cloud Gateway 的原理 - 悟空聊架构这篇文章。

\n
\n

什么是 Spring Cloud Gateway？

\n

Spring Cloud Gateway 属于 Spring Cloud 生态系统中的网关，其诞生的目标主要是为了替代 Zuul 1.x。Zuul 1.x 基于 Servlet 阻塞 I/O 架构，在高并发场景下性能有限。而 Zuul 2.x 虽然采用了 Netty 非阻塞架构，但 Spring Cloud 官方并未正式集成 Zuul 2.x。Spring Cloud Gateway 起步要比 Zuul 2.x 更早。

\n

为了提升网关的性能，Spring Cloud Gateway 基于 Spring WebFlux 。Spring WebFlux 使用 Reactor 库来实现响应式编程模型，底层基于 Netty 实现同步非阻塞的 I/O。

\n

\n

Spring Cloud Gateway 不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/指标，限流。

\n

Spring Cloud Gateway 和 Zuul 2.x 的差别不大，也是通过过滤器来处理请求。不过，目前更加推荐使用 Spring Cloud Gateway 而非 Zuul，Spring Cloud 生态对其支持更加友好。

\n\n

Spring Cloud Gateway 的工作流程？

\n

Spring Cloud Gateway 的工作流程如下图所示：

\n

\"Spring

\n

这是 Spring 官方博客中的一张图，原文地址：https://spring.io/blog/2022/08/26/creating-a-custom-spring-cloud-gateway-filter。

\n

具体的流程分析：

\n
    \n
  1. 路由判断：客户端的请求到达网关后，先经过 Gateway Handler Mapping 处理，这里面会做断言（Predicate）判断，看下符合哪个路由规则，这个路由映射后端的某个服务。
    2. \n
  2. 请求过滤：然后请求到达 Gateway Web Handler，这里面有很多过滤器，组成过滤器链（Filter Chain），这些过滤器可以对请求进行拦截和修改，比如添加请求头、参数校验等等，有点像净化污水。然后将请求转发到实际的后端服务。这些过滤器逻辑上可以称作 Pre-Filters，Pre 可以理解为“在...之前”。
    3. \n
  3. 服务处理：后端服务会对请求进行处理。
    4. \n
  4. 响应过滤：后端处理完结果后，返回给 Gateway 的过滤器再次做处理，逻辑上可以称作 Post-Filters，Post 可以理解为“在...之后”。
    5. \n
  5. 响应返回：响应经过过滤处理后，返回给客户端。
    6. \n
\n

总结：客户端的请求先通过匹配规则找到合适的路由，就能映射到具体的服务。然后请求经过过滤器处理后转发给具体的服务，服务处理后，再次经过过滤器处理，最后返回给客户端。

\n

Spring Cloud Gateway 的断言是什么？

\n

断言（Predicate）这个词听起来极其深奥，它是一种编程术语，我们生活中根本就不会用它。说白了它就是对一个表达式进行 if 判断，结果为真或假，如果为真则做这件事，否则做那件事。

\n

在 Gateway 中，如果客户端发送的请求满足了断言的条件，则映射到指定的路由器，就能转发到指定的服务上进行处理。

\n

断言配置的示例如下，配置了两个路由规则，有一个 predicates 断言配置，当请求 url 中包含 api/thirdparty，就匹配到了第一个路由 route_thirdparty。

\n

\"断言配置示例\"

\n

常见的路由断言规则如下图所示：

\n

\"Spring

\n

Spring Cloud Gateway 的路由和断言是什么关系？

\n

Route 路由和 Predicate 断言的对应关系如下：：

\n

\"路由和断言的对应关系\"

\n\n

Spring Cloud Gateway 如何实现动态路由？

\n

在使用 Spring Cloud Gateway 的时候，官方文档提供的方案总是基于配置文件或代码配置的方式。

\n

Spring Cloud Gateway 作为微服务的入口，需要尽量避免重启，而现在配置更改需要重启服务不能满足实际生产过程中的动态刷新、实时变更的业务需求，所以我们需要在 Spring Cloud Gateway 运行时动态配置网关。

\n

实现动态路由的方式有很多种，其中一种推荐的方式是基于 Nacos 注册中心来做。 Spring Cloud Gateway 可以从注册中心获取服务的元数据（例如服务名称、路径等），然后根据这些信息自动生成路由规则。这样，当你添加、移除或更新服务实例时，网关会自动感知并相应地调整路由规则，无需手动维护路由配置。

\n

其实这些复杂的步骤并不需要我们手动实现，通过 Nacos Server 和 Spring Cloud Alibaba Nacos Config 即可实现配置的动态变更，官方文档地址：https://github.com/alibaba/spring-cloud-alibaba/wiki/Nacos-config 。

\n

Spring Cloud Gateway 的过滤器有哪些？

\n

过滤器 Filter 按照请求和响应可以分为两种：

\n\n

另外一种分类是按照过滤器 Filter 作用的范围进行划分：

\n\n

局部过滤器

\n

常见的局部过滤器如下图所示：

\n

\n

具体怎么用呢？这里有个示例，如果 URL 匹配成功，则去掉 URL 中的 “api”。

\n
filters: #过滤器\n  - RewritePath=/api/(?<segment>.*),/$\\{segment} # 将跳转路径中包含的 “api” 替换成空
\n

当然我们也可以自定义过滤器，本篇不做展开。

\n

全局过滤器

\n

常见的全局过滤器如下图所示：

\n

\n

全局过滤器最常见的用法是进行负载均衡。配置如下所示：

\n
spring:\n  cloud:\n    gateway:\n      routes:\n        - id: route_member # 第三方微服务路由规则\n          uri: lb://passjava-member # 负载均衡，将请求转发到注册中心注册的 passjava-member 服务\n          predicates: # 断言\n            - Path=/api/member/** # 如果前端请求路径包含 api/member，则应用这条路由规则\n          filters: #过滤器\n            - RewritePath=/api/(?<segment>.*),/$\\{segment} # 将跳转路径中包含的api替换成空
\n

这里有个关键字 lb，用到了全局过滤器 LoadBalancerClientFilter，当匹配到这个路由后，会将请求转发到 passjava-member 服务，且支持负载均衡转发，也就是先将 passjava-member 解析成实际的微服务的 host 和 port，然后再转发给实际的微服务。

\n

Spring Cloud Gateway 支持限流吗？

\n

Spring Cloud Gateway 自带了限流过滤器，对应的接口是 RateLimiter，RateLimiter 接口只有一个实现类 RedisRateLimiter （基于 Redis + Lua 实现的限流），提供的限流功能比较简易且不易使用。

\n

从 Sentinel 1.6.0 版本开始，Sentinel 引入了 Spring Cloud Gateway 的适配模块，可以提供两种资源维度的限流：route 维度和自定义 API 维度。也就是说，Spring Cloud Gateway 可以结合 Sentinel 实现更强大的网关流量控制。

\n

Spring Cloud Gateway 如何自定义全局异常处理？

\n

在 SpringBoot 项目中，我们捕获全局异常只需要在项目中配置 @RestControllerAdvice和 @ExceptionHandler就可以了。不过，这种方式在 Spring Cloud Gateway 下不适用。

\n

Spring Cloud Gateway 提供了多种全局处理的方式，比较常用的一种是实现ErrorWebExceptionHandler并重写其中的handle方法。

\n
@Order(-1)\n@Component\n@RequiredArgsConstructor\npublic class GlobalErrorWebExceptionHandler implements ErrorWebExceptionHandler {\n    private final ObjectMapper objectMapper;\n\n    @Override\n    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {\n    // ...\n    }\n}
\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/distributed-system/api-gateway/springcloud-gateway-%20demo.png", "date_published": "2023-05-04T10:53:24.000Z", "date_modified": "2026-03-12T04:06:59.000Z", "authors": [], "tags": [ "分布式" ] }, { "title": "Disruptor常见问题总结", "url": "https://javaguide.cn/high-performance/message-queue/disruptor-questions.html", "id": "https://javaguide.cn/high-performance/message-queue/disruptor-questions.html", "summary": "本文总结 Disruptor 高性能内存队列的核心知识与面试要点，涵盖 Disruptor 架构（RingBuffer/Sequencer/WaitStrategy）、高性能原理（无锁设计/缓存行填充/预分配内存）、与 ArrayBlockingQueue 对比、生产者消费者模式等，助力 Disruptor 学习与面试。", "content_html": "

Disruptor 是一个相对冷门一些的知识点，不过，如果你的项目经历中用到了 Disruptor 的话，那面试中就很可能会被问到。

\n

一位球友之前投稿的面经（社招）中就涉及一些 Disruptor 的问题，文章传送门：圆梦！顺利拿到字节、淘宝、拼多多等大厂 offer！ 。

\n

\n

这篇文章可以看作是对 Disruptor 做的一个简单总结，每个问题都不会扯太深入，主要针对面试或者速览 Disruptor。

\n

Disruptor 是什么？

\n

Disruptor 是一个开源的高性能内存队列，诞生初衷是为了解决内存队列的性能和内存安全问题，由英国外汇交易公司 LMAX 开发。

\n

根据 Disruptor 官方介绍，基于 Disruptor 开发的系统 LMAX（新的零售金融交易平台），单线程就能支撑每秒 600 万订单。Martin Fowler 在 2011 年写的一篇文章 The LMAX Architecture 中专门介绍过这个 LMAX 系统的架构，感兴趣的可以看看这篇文章。。

\n

LMAX 公司 2010 年在 QCon 演讲后，Disruptor 获得了业界关注，并获得了 2011 年的 Oracle 官方的 Duke's Choice Awards(Duke 选择大奖)。

\n

\n
\n

“Duke 选择大奖”旨在表彰过去一年里全球个人或公司开发的、最具影响力的 Java 技术应用，由甲骨文公司主办。含金量非常高！

\n
\n

我专门找到了 Oracle 官方当年颁布获得 Duke's Choice Awards 项目的那篇文章（文章地址：https://blogs.oracle.com/java/post/and-the-winners-arethe-dukes-choice-award） 。从文中可以看出，同年获得此大奖荣誉的还有大名鼎鼎的 Netty、JRebel 等项目。

\n

\"2011

\n

Disruptor 提供的功能优点类似于 Kafka、RocketMQ 这类分布式队列，不过，其作为范围是 JVM(内存)。

\n\n

关于如何在 Spring Boot 项目中使用 Disruptor，可以看这篇文章：Spring Boot + Disruptor 实战入门 。

\n

为什么要用 Disruptor？

\n

Disruptor 主要解决了 JDK 内置线程安全队列的性能和内存安全问题。

\n

JDK 中常见的线程安全的队列如下：

\n

| 队列名字 | 锁 | 是否有界 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/disruptor-interview-questions.png", "date_published": "2023-05-04T10:53:24.000Z", "date_modified": "2026-01-21T03:04:06.000Z", "authors": [], "tags": [ "高性能" ] }, { "title": "NAT 协议详解（网络层）", "url": "https://javaguide.cn/cs-basics/network/nat.html", "id": "https://javaguide.cn/cs-basics/network/nat.html", "summary": "解析 NAT 的地址转换与端口映射机制，结合 LAN/WAN 通信与转换表，理解家庭与企业网络的实践细节。", "content_html": "

应用场景

\n

NAT 协议（Network Address Translation） 的应用场景如同它的名称——网络地址转换，应用于内部网到外部网的地址转换过程中。具体地说，在一个小的子网（局域网，Local Area Network，LAN）内，各主机使用的是同一个 LAN 下的 IP 地址，但在该 LAN 以外，在广域网（Wide Area Network，WAN）中，需要一个统一的 IP 地址来标识该 LAN 在整个 Internet 上的位置。

\n

这个场景其实不难理解。随着一个个小型办公室、家庭办公室（Small Office, Home Office, SOHO）的出现，为了管理这些 SOHO，一个个子网被设计出来，从而在整个 Internet 中的主机数量将非常庞大。如果每个主机都有一个“绝对唯一”的 IP 地址，那么 IPv4 地址的表达能力可能很快达到上限（$2^{32}$）。因此，实际上，SOHO 子网中的 IP 地址是“相对的”，这在一定程度上也缓解了 IPv4 地址的分配压力。

\n

SOHO 子网的“代理人”，也就是和外界的窗口，通常由路由器扮演。路由器的 LAN 一侧管理着一个小子网，而它的 WAN 接口才是真正参与到 Internet 中的接口，也就有一个“绝对唯一的地址”。NAT 协议，正是在 LAN 中的主机在与 LAN 外界通信时，起到了地址转换的关键作用。

\n

细节

\n

\"NAT

\n

假设当前场景如上图。中间是一个路由器，它的右侧组织了一个 LAN，网络号为10.0.0/24。LAN 侧接口的 IP 地址为10.0.0.4，并且该子网内有至少三台主机，分别是10.0.0.1，10.0.0.2和10.0.0.3。路由器的左侧连接的是 WAN，WAN 侧接口的 IP 地址为138.76.29.7。

\n

首先，针对以上信息，我们有如下事实需要说明：

\n
    \n
  1. 路由器右侧子网的网络地址为 10.0.0.0/24（网络前缀 24 位，主机号占 8 位），三台主机地址以及路由器的 LAN 侧接口地址，均由 DHCP 协议规定。而且，该 DHCP 运行在路由器内部（路由器自维护一个小 DHCP 服务器），从而为子网内提供 DHCP 服务。
    2. \n
  2. 路由器的 WAN 侧接口地址同样由 DHCP 协议规定，但该地址是路由器从 ISP（网络服务提供商）处获得，也就是该 DHCP 通常运行在路由器所在区域的 DHCP 服务器上。
    3. \n
\n

现在，路由器内部还运行着 NAT 协议，从而为 LAN-WAN 间通信提供地址转换服务。为此，一个很重要的结构是 NAT 转换表。为了说明 NAT 的运行细节，假设有以下请求发生：

\n
    \n
  1. 主机10.0.0.1向 IP 地址为128.119.40.186的 Web 服务器（端口 80）发送了 HTTP 请求（如请求页面）。此时，主机10.0.0.1将随机指派一个端口，如3345，作为本次请求的源端口号，将该请求发送到路由器中（目的地址将是128.119.40.186，但会先到达10.0.0.4）。
    2. \n
  2. 10.0.0.4即路由器的 LAN 接口收到10.0.0.1的请求。路由器将为该请求指派一个新的源端口号，如5001，并将请求报文发送给 WAN 接口138.76.29.7。同时，在 NAT 转换表中记录一条转换记录138.76.29.7:5001——10.0.0.1:3345。
    3. \n
  3. 请求报文到达 WAN 接口，继续向目的主机128.119.40.186发送。
    4. \n
\n

之后，将会有如下响应发生：

\n
    \n
  1. 主机128.119.40.186收到请求，构造响应报文，并将其发送给目的地138.76.29.7:5001。
    2. \n
  2. 响应报文到达路由器的 WAN 接口。路由器查询 NAT 转换表，发现138.76.29.7:5001在转换表中有记录，从而将其目的地址和目的端口转换成为10.0.0.1:3345，再发送到10.0.0.4上。
    3. \n
  3. 被转换的响应报文到达路由器的 LAN 接口，继而被转发至目的地10.0.0.1。
    4. \n
\n

\"LAN-WAN

\n

🐛 修正（参见：issue#2009）：上图第四步的 Dest 值应该为 10.0.0.1:3345 而不是138.76.29.7:5001，这里笔误了。

\n

划重点

\n

针对以上过程，有以下几个重点需要强调：

\n
    \n
  1. 当请求报文到达路由器，并被指定了新端口号时，由于端口号有 16 位，因此，通常来说，一个路由器管理的 LAN 中的最大主机数 $≈65500$（$2^{16}$ 的地址空间），但通常 SOHO 子网内不会有如此多的主机数量。
    2. \n
  2. 对于目的服务器来说，从来不知道“到底是哪个主机给我发送的请求”，它只知道是来自138.76.29.7:5001的路由器转发的请求。因此，可以说，路由器在 WAN 和 LAN 之间起到了屏蔽作用，所有内部主机发送到外部的报文，都具有同一个 IP 地址（不同的端口号），所有外部发送到内部的报文，也都只有一个目的地（不同端口号），是经过了 NAT 转换后，外部报文才得以正确地送达内部主机。
    3. \n
  3. 在报文穿过路由器，发生 NAT 转换时，如果 LAN 主机 IP 已经在 NAT 转换表中注册过了，则不需要路由器新指派端口，而是直接按照转换记录穿过路由器。同理，外部报文发送至内部时也如此。
    4. \n
\n

总结 NAT 协议的特点，有以下几点：

\n
    \n
  1. NAT 协议通过对 WAN 屏蔽 LAN，有效地缓解了 IPv4 地址分配压力。
    2. \n
  2. LAN 主机 IP 地址的变更，无需通告 WAN。
    3. \n
  3. WAN 的 ISP 变更接口地址时，无需通告 LAN 内主机。
    4. \n
  4. LAN 主机对 WAN 不可见，不可直接寻址，可以保证一定程度的安全性。
    5. \n
\n

然而，NAT 协议由于其独特性，存在着一些争议。比如，可能你已经注意到了，NAT 协议在 LAN 以外，标识一个内部主机时，使用的是端口号，因为 IP 地址都是相同的。这种将端口号作为主机寻址的行为，可能会引发一些误会。此外，路由器作为网络层的设备，修改了传输层的分组内容（修改了源 IP 地址和端口号），同样是不规范的行为。但是，尽管如此，NAT 协议作为 IPv4 时代的产物，极大地方便了一些本来棘手的问题，一直被沿用至今。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/network/nat-demo.png", "date_published": "2023-04-30T08:44:12.000Z", "date_modified": "2026-02-22T12:21:13.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "程序员简历编写指南", "url": "https://javaguide.cn/interview-preparation/resume-guide.html", "id": "https://javaguide.cn/interview-preparation/resume-guide.html", "summary": "程序员简历编写指南：从筛选逻辑出发讲清简历结构、项目经历与技能描述写法，提供简历模板与避坑建议，帮助你提高简历通过率并让面试官更好地深挖你的亮点。", "content_html": "
\n

友情提示

\n

本文节选自 《Java 面试指北》。这是一份教你如何更高效地准备面试的小册，涵盖常见八股文（系统设计、常见框架、分布式、高并发 ……）、优质面经等内容。

\n
\n

前言

\n

一份好的简历可以在整个申请面试以及面试过程中起到非常重要的作用。

\n

为什么说简历很重要呢？ 我们可以从下面几点来说：

\n

1、简历就像是我们的一个门面一样，它在很大程度上决定了是否能够获得面试机会。

\n\n

另外，就算你通过了第一轮的筛选获得面试机会，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。

\n

2、简历上的内容很大程度上决定了面试官提问的侧重点。

\n\n

在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。一般情况下，技术能力和学习能力比较厉害的，写出来的简历也比较棒！

\n

简历模板

\n

简历的样式真的非常非常重要！！！如果你的简历样式丑到没朋友的话，面试官真的没有看下去的欲望。一天处理上百份的简历的痛苦，你不懂！

\n

我这里的话，推荐大家使用 Markdown 语法写简历，然后再将 Markdown 格式转换为 PDF 格式后进行简历投递。如果你对 Markdown 语法不太了解的话，可以花半个小时简单看一下 Markdown 语法说明: http://www.markdown.cn/。

\n

下面是我收集的一些还不错的简历模板：

\n\n

上面这些简历模板大多是只有 1 页内容，很难展现足够的信息量。如果你不是顶级大牛（比如 ACM 大赛获奖）的话，我建议还是尽可能多写一点可以突出你自己能力的内容（校招生 2 页之内，社招生 3 页之内，记得精炼语言，不要过多废话）。

\n

再总结几点 简历排版的注意事项：

\n\n

另外，知识星球里还有真实的简历模板可供参考，地址：https://t.zsxq.com/12ypxGNzU （需加入知识星球获取）。

\n

\n

简历内容

\n

个人信息

\n\n

示例：

\n

\n

简历要不要放照片呢？ 很多人写简历的时候都有这个问题。

\n

其实放不放都行，影响不大，完全不用在意这个问题。除非，你投递的岗位明确要求要放照片。 不过，如果要放的话，不要放生活照，还是应该放正规一些的照片比如证件照。

\n

求职意向

\n

你想要应聘什么岗位，希望在什么城市。另外，你也可以将求职意向放到个人信息这块写。

\n

示例：

\n

\n

教育经历

\n

教育经历也不可或缺。通过教育经历的介绍，你要确保能让面试官就可以知道你的学历、专业、毕业学校以及毕业的日期。

\n

示例：

\n
\n

北京理工大学 硕士，软件工程 2019.09 - 2022.01
\n湖南大学 学士，应用化学 2015.09 ~ 2019.06

\n
\n

专业技能

\n

先问一下你自己会什么，然后看看你意向的公司需要什么。一般 HR 可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。

\n

下面是一份最新的 Java 后端开发技能清单，你可以根据自身情况以及岗位招聘要求做动态调整，核心思想就是尽可能满足岗位招聘的所有技能要求。

\n

\"Java

\n

我这里再单独放一个我看过的某位同学的技能介绍，我们来找找问题。

\n

\n

上图中的技能介绍存在的问题：

\n\n

实习经历/工作经历（重要）

\n

工作经历针对社招，实习经历针对校招。

\n

工作经历建议采用时间倒序的方式来介绍。实习经历和工作经历都需要简单突出介绍自己在职期间主要做了什么。

\n

示例：

\n
\n

XXX 公司 （201X 年 X 月 ~ 201X 年 X 月 ）

\n\n
\n

项目经历（重要）

\n

简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。

\n

很多求职者的项目经历介绍都会面临过于啰嗦、过于简单、没突出亮点等问题。

\n

项目经历介绍模板如下：

\n
\n

项目名称（字号要大一些）

\n

2017-05~2018-06 淘宝 Java 后端开发工程师

\n\n
\n

1、项目经历应该突出自己做了什么，简单概括项目基本情况。

\n

项目介绍尽量压缩在两行之内，不需要介绍太多，但也不要随便几个字就介绍完了。

\n

另外，个人收获和项目成果都是可选的，如果选择写的话，也不要花费太多篇幅，记住你的重点是介绍工作内容/个人职责。

\n

2、技术架构直接写技术名词就行，不要再介绍技术是干嘛的了，没意义，属于无效介绍。

\n

\n

3、尽量减少纯业务的个人职责介绍，对于面试不太友好。尽量再多挖掘一些亮点（6~8 条个人职责介绍差不多了，做好筛选），最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目优化了某个模块的性能。

\n

即使不是你做的功能模块或者解决的问题，你只要搞懂吃透了就能拿来自己用，适当润色即可！

\n

像性能优化方向上的亮点面试之前也比较容易准备，但也不要都是性能优化相关的，这种也算是一个极端。

\n

另外，技术优化取得的成果尽量要量化一下：

\n\n

个人职责介绍示例（这里只是举例，不要照搬，结合自己项目经历自己去写，不然面试的时候容易被问倒） ：

\n\n

4、如果你觉得你的项目技术比较落后的话，可以自己私下进行改进。重要的是让项目比较有亮点，通过什么方式就无所谓了。

\n

项目经历这部分对于简历来说非常重要，《Java 面试指北》的面试准备篇有好几篇关于优化项目经历的文章，建议你仔细阅读一下，应该会对你有帮助。

\n

\n

5、避免个人职责介绍都是围绕一个技术点来写，非常不可取。

\n

\n

6、避免模糊性描述，介绍要具体（技术+场景+效果），也要注意精简语言（避免堆砌技术词，省略不必要的描述）。

\n

\n

荣誉奖项（可选）

\n

如果你有含金量比较高的竞赛（比如 ACM、阿里的天池大赛）的获奖经历的话，荣誉奖项这块内容一定要写一下！并且，你还可以将荣誉奖项这块内容适当往前放，放在一个更加显眼的位置。

\n

校园经历（可选）

\n

如果有比较亮眼的校园经历的话就简单写一下，没有就不写！

\n

个人评价

\n

个人评价就是对自己的解读，一定要用简洁的语言突出自己的特点和优势，避免废话！ 像勤奋、吃苦这些比较虚的东西就不要扯了，面试官看着这种个人评价就烦。

\n

我们可以从下面几个角度来写个人评价：

\n\n

列举 3 个实际的例子：

\n\n

STAR 法则和 FAB 法则

\n

STAR 法则（Situation Task Action Result）

\n

相信大家一定听说过 STAR 法则。对于面试，你可以将这个法则用在自己的简历以及和面试官沟通交流的过程中。

\n

STAR 法则由下面 4 个单词组成（STAR 法则的名字就是由它们的首字母组成）：

\n\n

FAB 法则（Feature Advantage Benefit）

\n

除了 STAR 法则，你还需要了解在销售行业经常用到的一个叫做 FAB 的法则。

\n

FAB 法则由下面 3 个单词组成（FAB 法则的名字就是由它们的首字母组成）：

\n\n

简单来说，FAB 法则主要是让你的面试官知道你的优势和你能为公司带来的价值。

\n

建议

\n

避免页数过多

\n

精简表述，突出亮点。校招简历建议不要超过 2 页，社招简历建议不要超过 3 页。如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。

\n

看了几千份简历，有少部分同学的简历页数都接近 10 页了，让我头皮发麻。

\n

\"简历页数过多\"

\n

避免语义模糊

\n

尽量避免主观表述，少一点语义模糊的形容词。表述要简洁明了，简历结构要清晰。

\n

举例：

\n\n

注意简历样式

\n

简历样式同样很重要，一定要注意！不必追求花里胡哨，但要尽量保证结构清晰且易于阅读。

\n

其他

\n\n

简历修改

\n

到目前为止，我至少帮助 6000+ 位球友提供了免费的简历修改服务。由于个人精力有限，修改简历仅限加入星球的读者，需要帮看简历的话，可以加入 JavaGuide 官方知识星球（点击链接查看详细介绍）。

\n

\"img\"

\n

虽然收费只有培训班/训练营的百分之一，但是知识星球里的内容质量更高，提供的服务也更全面，非常适合准备 Java 面试和学习 Java 的同学。

\n

下面是星球提供的部分服务（点击下方图片即可获取知识星球的详细介绍）：

\n

\"星球服务\"

\n

这里再提供一份限时专属优惠卷：

\n

\"知识星球30元优惠卷\"

\n", "image": "https://oss.javaguide.cn/javamianshizhibei/image-20230918073550606.png", "date_published": "2023-04-28T13:38:12.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "数据冷热分离详解", "url": "https://javaguide.cn/high-performance/data-cold-hot-separation.html", "id": "https://javaguide.cn/high-performance/data-cold-hot-separation.html", "summary": "本文详解数据冷热分离的核心原理与实践方案，涵盖冷热数据判定策略、多级分层设计、数据迁移一致性保障、冷数据查询优化、存储选型（HBase/TiDB/对象存储），以及订单/日志/内容系统的典型落地案例。", "content_html": "

\"JavaGuide官方知识星球\"

\n

什么是数据冷热分离？

\n

数据冷热分离是指根据数据的访问频率和业务重要性，将数据划分为冷数据和热数据，并分别存储在不同性能和成本的存储介质中的架构策略。

\n

这种架构的核心目标有三个：

\n
    \n
  1. 提升查询性能：热数据存储在高性能介质（如 SSD、内存）中，保障核心业务的响应速度。
    2. \n
  2. 降低存储成本：冷数据迁移至低成本介质（如 HDD、对象存储），大幅削减存储开支。
    3. \n
  3. 满足合规要求：部分行业（如金融、医疗）要求数据长期归档，冷热分离可兼顾合规与成本。
    4. \n
\n

冷数据和热数据

\n

热数据是指被频繁访问和修改、且需要快速响应的数据；冷数据是指访问频率极低、对当前业务价值较小、但需要长期保留的数据。

\n

冷热数据的区分方法主要有两种：

\n
    \n
  1. 时间维度区分：按照数据的创建时间、更新时间或过期时间划分。例如，订单系统将一段时间前（如 90 天或 1 年）的订单数据标记为冷数据。该方法适用于数据访问频率与时间强相关的场景，实现简单、成本低。
    2. \n
  2. 访问频率区分：将高频访问的数据视为热数据，低频访问的数据视为冷数据。例如，内容系统将浏览量低于阈值的文章标记为冷数据。该方法需要额外记录访问频率，适用于访问频率与数据本身特性强相关的场景。
    3. \n
\n

如何选择区分策略？

\n\n

冷热分离的多级分层策略

\n

实际落地时，"冷"与"热"往往不是非此即彼的二分法，而是渐进式多级分层：

\n

| 层级 | 数据特性 | 判定规则示例 | 存储策略 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/high-performance/data-cold-hot-separation.png", "date_published": "2023-04-28T11:27:56.000Z", "date_modified": "2026-03-13T03:31:15.000Z", "authors": [], "tags": [ "高性能" ] }, { "title": "深度分页介绍及优化建议", "url": "https://javaguide.cn/high-performance/deep-pagination-optimization.html", "id": "https://javaguide.cn/high-performance/deep-pagination-optimization.html", "summary": "深度分页是指查询偏移量过大导致性能下降的场景，本文详解深度分页产生的原因及四种优化方案：范围查询、子查询优化、INNER JOIN 延迟关联、覆盖索引，并分析各方案的适用场景与优缺点。", "content_html": "

\"JavaGuide官方知识星球\"

\n

什么是深度分页？怎么导致的？

\n

查询偏移量过大的场景我们称为深度分页，这会导致查询性能较低，例如：

\n
# MySQL 在无法利用索引的情况下跳过1000000条记录后，再获取10条记录\nSELECT * FROM t_order ORDER BY id LIMIT 1000000, 10
\n

当查询偏移量过大时，MySQL 的查询优化器可能会选择全表扫描而不是利用索引来优化查询。

\n

深度分页变慢的根本原因在于 MySQL 的执行机制：对于 LIMIT offset, N，MySQL 并非直接跳到 offset 处，而是必须从头扫描 offset + N 条记录。如果查询依赖二级索引且不满足覆盖索引，这意味着 MySQL 需要对前 offset 条记录执行毫无意义的回表查询（产生海量的随机 I/O），最后再将这些辛苦查出的数据丢弃。即便优化器最终因代价过高退化为全表扫描，顺序扫描百万行的成本依然巨大。

\n

\"深度分页问题\"

\n

不同机器上这个查询偏移量过大的临界点可能不同，取决于多个因素，包括硬件配置（如 CPU 性能、磁盘速度）、表的大小、索引的类型和统计信息等。

\n

\"转全表扫描的临界点\"

\n

MySQL 的查询优化器采用基于成本的策略来选择最优的查询执行计划。它会根据 CPU 和 I/O 的成本来决定是否使用索引扫描或全表扫描。如果优化器认为全表扫描的成本更低，它就会放弃使用索引。不过，即使偏移量很大，如果查询中使用了覆盖索引（covering index），MySQL 仍然可能会使用索引，避免回表操作。

\n

深度分页优化建议

\n
\n

本文基于 MySQL 8.0 + InnoDB 存储引擎，不同版本优化器行为可能存在差异。

\n
\n

范围查询（游标分页）

\n

通过记录上一页最后一条记录的 ID，使用 WHERE id > last_id LIMIT n 获取下一页数据：

\n
# 通过记录上次查询结果的最后一条记录的 ID 进行下一页的查询\nSELECT * FROM t_order WHERE id > 100000 ORDER BY id LIMIT 10
\n

游标分页的核心优势：不依赖 ID 的连续性。MySQL 只需要在 B+ 树上定位到 last_id 的位置，然后顺序向后读取 n 条记录即可，中间是否有断层（如 ID 被删除）完全不影响结果的准确性和性能。

\n

这种方式的限制：

\n
    \n
  1. 不支持跳页：无法直接跳转到第 N 页，只能逐页向后（或向前）翻页。
    2. \n
  2. 排序字段受限：如果查询需要按照其他字段（如创建时间）排序而非 ID 排序，需使用联合游标 (sort_field, id) 保证唯一性和顺序。
    3. \n
  3. 并发场景：当分页查询期间有新数据插入或删除时，可能出现：\n\n
    4. \n
\n

子查询

\n

我们先查询出 limit 第一个参数对应的主键值，再根据这个主键值再去过滤并 limit，这样效率会更快一些。

\n

阿里巴巴《Java 开发手册》中也有对应的描述：

\n
\n

利用延迟关联或者子查询优化超多分页场景。

\n

\n
\n
-- 先通过子查询在主键索引上进行偏移，快速找到起始ID\nSELECT * FROM t_order\nWHERE id >= (\n    SELECT id FROM t_order ORDER BY id LIMIT 1000000, 1\n) ORDER BY id LIMIT 10;
\n

工作原理:

\n
    \n
  1. 子查询 (SELECT id FROM t_order ORDER BY id LIMIT 1000000, 1) 利用主键索引扫描并跳过前 1000000 条记录，返回第 1000001 条记录的主键值。
    2. \n
  2. 主查询 SELECT * FROM t_order WHERE id >= ... ORDER BY id LIMIT 10 以该主键为起点，获取后续 10 条完整记录。
    3. \n
\n

不过，某些情况下子查询可能会产生临时表，影响性能，因此在复杂查询中建议优先考虑延迟关联。

\n
\n

复杂过滤场景：在包含复杂过滤条件的分页场景中（如 WHERE status = 1 ORDER BY id LIMIT 1000000, 10），符合条件的 ID 往往是离散的。此时子查询的优势更加明显：通过在子查询中利用联合索引（如 (status, id)）实现覆盖索引扫描，可以高效地跳过前 100 万条符合条件的记录，定位到目标 ID 后，主查询只需回表 10 次。

\n
\n

当然，我们也可以利用子查询先去获取目标分页的 ID 集合，然后再根据 ID 集合获取内容，但这种写法非常繁琐，不如使用 INNER JOIN 延迟关联。

\n

延迟关联

\n

延迟关联与子查询的优化思路类似，都是通过将 LIMIT 操作转移到主键索引树上，减少回表次数。相比直接使用子查询，延迟关联通过 INNER JOIN 将子查询结果集成到主查询中，避免了子查询可能产生的临时表。在执行 INNER JOIN 时，MySQL 优化器能够利用索引进行高效的连接操作（如索引扫描或其他优化策略），因此在深度分页场景下，性能通常优于直接使用子查询。

\n
-- 使用 INNER JOIN 进行延迟关联\nSELECT t1.*\nFROM t_order t1\nINNER JOIN (\n    -- 这里的子查询可以利用覆盖索引，性能极高\n    SELECT id FROM t_order ORDER BY id LIMIT 1000000, 10\n) t2 ON t1.id = t2.id\nORDER BY t1.id;
\n

工作原理:

\n
    \n
  1. 子查询 (SELECT id FROM t_order ORDER BY id LIMIT 1000000, 10) 利用主键索引扫描并跳过前 1000000 条记录，返回目标分页的 10 条记录的 ID。
    2. \n
  2. 通过 INNER JOIN 将子查询结果与主表 t_order 关联，获取完整的记录数据。
    3. \n
\n

除了使用 INNER JOIN 之外，还可以使用逗号连接子查询。

\n
-- 使用逗号进行延迟关联\nSELECT t1.* FROM t_order t1,\n(SELECT id FROM t_order ORDER BY id LIMIT 1000000, 10) t2\nWHERE t1.id = t2.id\nORDER BY t1.id;
\n

注意: 虽然逗号连接子查询也能实现类似的效果，但为了代码可读性和可维护性，建议使用更规范的 INNER JOIN 语法。

\n

覆盖索引

\n

索引中已经包含了所有需要获取的字段的查询方式称为覆盖索引。

\n

覆盖索引的好处：

\n\n

假设建立了 (code, type) 联合索引，下面的查询即可使用覆盖索引：

\n
# 在 InnoDB 中，辅助索引天然包含主键 id\n# 如果只需要查询 id, code, type 这三列，只需建立 (code, type) 的联合索引即可实现覆盖\nSELECT id, code, type FROM t_order\nORDER BY code\nLIMIT 1000000, 10;
\n

⚠️注意:

\n\n

生产落地建议

\n

监控与告警

\n\n

常见误区

\n

| 误区 | 事实 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/mysql/deep-pagination-phenomenon.png", "date_published": "2023-04-28T11:27:56.000Z", "date_modified": "2026-03-13T10:05:05.000Z", "authors": [], "tags": [ "高性能" ] }, { "title": "面试太紧张怎么办？", "url": "https://javaguide.cn/interview-preparation/how-to-handle-interview-nerves.html", "id": "https://javaguide.cn/interview-preparation/how-to-handle-interview-nerves.html", "summary": "面试太紧张影响发挥怎么办？从心态调整、提前准备到模拟面试与表达训练，提供一套可落地的方法，帮助你降低焦虑、提升临场表现，更稳定地通过技术面试。", "content_html": "

\"JavaGuide官方知识星球\"

\n

很多小伙伴在第一次技术面试时都会感到紧张甚至害怕，遇到稍微刁钻的问题大脑就一片空白，面试结束后还会有种“懵懵的”感觉。我也经历过类似的状况，对这种手心出汗、语无伦次的窘境深有体会。

\n

其实，紧张是非常正常的生理和心理反应——它代表你对这次机会的重视，也源于人类对未知结果的天然担忧。但如果任由过度紧张蔓延，绝对会大幅折损你的临场发挥水平。

\n

下面，我将结合自己的实战经验，从心态重塑、战术准备、临场应对、面后复盘四个维度，分享一套可落地的“抗紧张”指南。

\n

试着接受紧张情绪，调整心态

\n

首先要明白，紧张是正常情绪，特别是初次或前几次面试时，多少都会有点忐忑。不要过分排斥这种情绪，可以适当地“拥抱”它：

\n\n

提前准备，减少不确定性

\n

不确定性越多，越容易紧张。 如果你能够在面试前做充分的准备，很多“未知”就会消失，紧张情绪自然会减轻很多。

\n

认真准备技术面试

\n\n

模拟面试和自测

\n\n

《Java 面试指北》 的 「技术面试题自测篇」概览：

\n

\"技术面试题自测篇\"

\n

多表达

\n

平时要多说，多表达出来，不要只是在心里面想，不然真正面试的时候会发现想的和说的不太一样。

\n

我前面推荐的模拟面试和自测，有一部分原因就是为了能够多多表达。

\n

多面试

\n\n

保证休息

\n\n

遇到不会的问题不要慌

\n

一场面试，不太可能面试官提的每一个问题你都能轻松应对，除非这场面试非常简单。

\n

在面试过程中，遇到不会的问题，首先要做的是快速回顾自己过往的知识，看是否能找到突破口。如果实在没有思路的话，可以真诚地向面试要一些提示比如谈谈你对这个问题的理解以及困惑点。一定不要觉得向面试官要提示很可耻，只要沟通没问题，这其实是很正常的。最怕的就是自己不会，还乱回答一通，这样会让面试官觉得你技术态度有问题。

\n

面试结束后的复盘

\n

很多人关注面试前的准备，却忽略了面试后的复盘，这一步真的非常非常非常重要：

\n
    \n
  1. 记录面试中的问题：无论回答得好坏，都把它们写下来。如果问到了一些没想过的问题，可以认真思考并在面试后补上答案。
    2. \n
  2. 反思自己的表现：有没有遇到卡壳的地方？是知识没准备到还是过于紧张导致表达混乱？下次如何改进？
    3. \n
  3. 持续完善自己的“面试题库”：把新的问题补充进去，不断拓展自己的知识面，也逐步降低对未知问题的恐惧感。
    4. \n
\n", "image": "https://oss.javaguide.cn/javamianshizhibei/technical-interview-questions-self-test.png", "date_published": "2023-04-28T11:27:56.000Z", "date_modified": "2026-03-04T08:41:37.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "校招没有实习经历怎么办？实习经历怎么写？", "url": "https://javaguide.cn/interview-preparation/internship-experience.html", "id": "https://javaguide.cn/interview-preparation/internship-experience.html", "summary": "校招没有实习经历也能上岸：从补强项目经验、持续优化简历到系统准备技术面试，给出可执行的提升路径与注意事项，帮助你在没有大厂实习的情况下提高面试通过率。", "content_html": "

\"JavaGuide官方知识星球\"

\n

由于目前的面试太卷，对于犹豫是否要找实习的同学来说，个人建议不论是本科生还是研究生都应该在参加校招面试之前，争取一下不错的实习机会，尤其是大厂的实习机会，日常实习或者暑期实习都可以。当然，如果大厂实习面不上，中小厂实习也是可以接受的。

\n

不过，现在的实习是真难找，这两年有非常多的同学没有找到实习，有一部分甚至是 211/985 名校的同学。实习难找是一方面原因，国内很多学校的导师压根不放实习，这也是很棘手的问题。

\n

没有实习经历怎么办？

\n

如果实在是找不到合适的实习的话，那也没办法，我们应该多花时间去把下面这三件事情给做好：

\n
    \n
  1. 补强项目经历
    2. \n
  2. 持续完善简历
    3. \n
  3. 准备技术面试
    4. \n
\n

补强项目经历

\n

校招没有实习经历的话，找工作比较吃亏（没办法，太卷了），需要在项目经历部分多发力弥补一下。

\n

建议你尽全力地去补强自己的项目经历，完善现有的项目或者去做更有亮点的项目，尽可能地通过项目经历去弥补一些。

\n

你面试中的重点就是你的项目经历涉及到的知识点，如果你的项目经历比较简单的话，面试官直接不知道问啥了。另外，你的项目经历中不涉及的知识点，但在技能介绍中提到的知识点也很大概率会被问到。像 Redis 这种基本是面试 Java 后端岗位必备的技能，我觉得大部分面试官应该都会问。

\n

推荐阅读一下网站的这篇文章：项目经验指南。

\n

完善简历

\n

一定一定一定要重视简历啊！建议至少花 2~3 天时间来专门完善自己的简历。并且，后续还要持续完善。

\n

对于面试官来说，筛选简历的时候会比较看重下面这些维度：

\n
    \n
  1. 实习/工作经历：看你是否有不错的实习经历，大厂且与面试岗位相关的实习/工作经历最佳。
    2. \n
  2. 获奖经历：如果有含金量比较高（知名度较高的赛事比如 ACM、阿里云天池）的获奖经历的话，也是加分点，尤其是对于校招来说，这类求职者属于是很多大厂争抢的对象（但不是说获奖了就能进大厂，还是要面试表现还可以）。对于社招来说，获奖经历作用相对较小，通常会更看重过往的工作经历和项目经验。
    3. \n
  3. 项目经验：项目经验对于面试来说非常重要，面试官会重点关注，同时也是有水平的面试提问的重点。
    4. \n
  4. 技能匹配度：看你的技能是否满足岗位的需求。在投递简历之前，一定要确认一下自己的技能介绍中是否缺少一些你要投递的对应岗位的技能要求。
    5. \n
  5. 学历：相对其他行业来说，程序员求职面试对于学历的包容度还是比较高的，只要你在其他方面有过人之出的话，也是可以弥补一下学历的缺陷的。你要知道，很多行业比如律师、金融，学历就是敲门砖，学历没达到要求，直接面试机会都没有。不过，由于现在面试越来越卷，一些大厂、国企和研究所也开始卡学历了，很多岗位都要求 211/985，甚至必须需要硕士学历。总之，学历很难改变，学校较差的话，就投递那些对学历没有明确要求的公司即可，努力提升自己的其他方面的硬实力。
    6. \n
\n

对于大部分求职者来说，实习/工作经历、项目经验、技能匹配度更重要一些。不过，不排除一些公司会因为学历卡人。

\n

详细的程序员简历编写指南可以参考这篇文章：程序员简历编写指南(重要)。

\n

准备技术面试

\n

面试之前一定要提前准备一下常见的面试题也就是八股文：

\n\n

不同类型的公司对于技能的要求侧重点是不同的比如腾讯、字节可能更重视计算机基础比如网络、操作系统这方面的内容。阿里、美团这种可能更重视你的项目经历、实战能力。

\n

一定不要抱着一种思想，觉得八股文或者基础问题的考查意义不大。如果你抱着这种思想复习的话，那效果可能不会太好。实际上，个人认为还是很有意义的，八股文或者基础性的知识在日常开发中也会需要经常用到。例如，线程池这块的拒绝策略、核心参数配置什么的，如果你不了解，实际项目中使用线程池可能就用的不是很明白，容易出现问题。而且，其实这种基础性的问题是最容易准备的，像各种底层原理、系统设计、场景题以及深挖你的项目这类才是最难的！

\n

八股文资料首推我的 《Java 面试指北》 和 JavaGuide 。里面不仅仅是原创八股文，还有很多对实际开发有帮助的干货。除了我的资料之外，你还可以去网上找一些其他的优质的文章、视频来看。

\n

如果你想要系统准备 Java 后端面试但又不知道如何开始的，可以参考 Java 后端面试通关计划（后端通用）。

\n

实习经历在简历上一般怎么写比较出彩？

\n

实习经历的描述一定要避免空谈，尽量列举出你在实习期间取得的成就和具体贡献，使用具体的数据和指标来量化你的工作成果。

\n

示例（这里假设项目细节放在实习经历这里介绍，你也可以选择将实习经历参与的项目放到项目经历中）：

\n
    \n
  1. 负责订单模块核心流程开发，实现订单状态的精确流转，并保障与库存、支付等模块的数据一致性。
    2. \n
  2. 负责行为风控黑名单看板的开发，支持查看拉黑用户、批量拉黑以及取消拉黑。
    3. \n
  3. 基于 Redisson + AOP 封装限流组件，实现对核心接口（如付费、课程搜索）的限流，有效防止恶意请求冲击。
    4. \n
  4. 优化用户统计模块性能，利用 CompletableFuture 并行加载多维度数据（如用户增长、课程活跃度），，平均相应时间从 3.5s 降低到 1s。
    5. \n
  5. 封装通用数据脱敏组件，通过自定义 Jackson 注解实现对手机号、邮箱等敏感信息的自动、无侵入式脱敏。
    6. \n
  6. 优化文件上传模块，基于 MinIO 实现了文件的分片上传、断点续传以及极速秒传功能。
    7. \n
  7. 排查并解决扣费模块由于扣费父任务和反作弊子任务使用同一个线程池导致的死锁问题，通过线程池隔离策略根除该隐患。
    8. \n
  8. 实习期间独立负责 7 个功能需求与 3 个线上问题修复，代码均一次性通过评审与测试。
    9. \n
\n

下面是星球一位球友分享的实习经历介绍，整体写的还是非常不错的：

\n

\"实习经历模板\"

\n

📌关于实习经历这块再多提一点：很多同学实习期间可能接触不到什么实际的开发任务，大部分时间可能都是在熟悉和维护项目。

\n

对于这种情况，应对思路是一套组合拳：首先，你肯定是要和 mentor 沟通继续争取做一些有价值的工作，这样你的实习经历才更有价值，简历上自然就能够有东西可写。记得找一个 mentor 不那么忙的时候沟通，放低姿态，真诚一些，表明自己现有的工作已经认真完成，想要承担更多责任的意愿。其次，不管是否能够争取到这种机会，你都要自己有意识地寻找项目中适合自己研究的功能点（比如同组其他实习生干的活），进行深度挖掘。重点关注以下几个方面：

\n
    \n
  1. 这个功能是干嘛的？ 它解决了什么业务痛点？给哪个业务方用的？整个流程是怎样的？
    2. \n
  2. 它是怎么实现的？ 用了哪些关键技术、框架或者设计模式？核心代码的逻辑是怎样的？
    3. \n
  3. 为什么要这么设计？ 当初设计的时候有没有别的方案？现在这个方案好在哪，又有什么潜在的坑？如果让你来做，你会怎么设计？
    4. \n
\n

只要你把具体的功能点彻底搞懂，那就可以在简历上合理包装成自己的成果。除了功能点开发之外，也可以包装一些合适的问题排查解决经历，这样能够体现你解决问题的能力。 面试时也不用太担心自己“露馅”，只要你选择的内容不属于那些显然不会交给实习生完成的高难度任务，并且能清晰地讲明白，就不会有问题。

\n", "image": "https://oss.javaguide.cn/github/javaguide/interview-preparation/qiuyou-shixijingli-demo.png", "date_published": "2023-04-28T11:27:56.000Z", "date_modified": "2026-03-02T15:06:39.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "Java 学习路线(最新版，4w+字)", "url": "https://javaguide.cn/interview-preparation/java-roadmap.html", "id": "https://javaguide.cn/interview-preparation/java-roadmap.html", "summary": "Java学习路线最新版：结合当下 Java 后端招聘要求，提供从基础到进阶的系统学习路径与资料建议，覆盖Java核心、数据库、缓存、中间件、框架与面试重点，帮助高效规划与提速上岸。", "content_html": "

\"JavaGuide官方知识星球\"

\n
\n

重要说明

\n

本学习路线保持年度系统性修订，严格同步 Java 技术生态与招聘市场的最新动态，确保内容时效性与前瞻性。

\n
\n

历时一个月精心打磨，笔者基于当下 Java 后端开发岗位招聘的最新要求，对既有学习路线进行了全面升级。本次升级涵盖技术栈增删、学习路径优化、配套学习资源更新等维度，力争构建出更符合 Java 开发者成长曲线的知识体系。

\n

亮色板概览：

\n

\"Java

\n

暗色板概览：

\n

\"Java

\n

这可能是你见过的最用心、最全面的 Java 后端学习路线。这份学习路线共包含 4w+ 字，但你完全不用担心内容过多而学不完。我会根据学习难度，划分出适合找小厂工作必学的内容，以及适合逐步提升 Java 后端开发能力的学习路径。

\n

\"Java

\n

对于初学者，你可以按照这篇文章推荐的学习路线和资料进行系统性的学习；对于有经验的开发者，你可以根据这篇文章更一步地深入学习 Java 后端开发，提升个人竞争力。

\n

在看这份学习路线的过程中，建议搭配 Java 面试重点总结(重要)，可以让你在学习过程中更有目的性。

\n

由于这份学习路线内容太多，因此我将其整理成了 PDF 版本（共 55 页），方便大家阅读。这份 PDF 有黑夜和白天两种阅读版本，满足大家的不同需求。

\n

这份学习路线的获取方法很简单：直接在公众号「JavaGuide」后台回复“路线”即可获取。

\n

\"JavaGuide

\n", "image": "https://oss.javaguide.cn/github/javaguide/interview-preparation/java-road-map-pdf.png", "date_published": "2023-04-28T11:27:56.000Z", "date_modified": "2026-01-17T03:43:57.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "《后端面试高频系统设计&场景题》", "url": "https://javaguide.cn/zhuanlan/back-end-interview-high-frequency-system-design-and-scenario-questions.html", "id": "https://javaguide.cn/zhuanlan/back-end-interview-high-frequency-system-design-and-scenario-questions.html", "summary": "后端面试高频系统设计与场景题专栏，涵盖秒杀系统、短链系统、海量数据处理等30+道经典面试题解析。", "content_html": "

介绍

\n

《后端面试高频系统设计&场景题》 是我的知识星球的一个内部小册，系统性地总结了后端面试中高频出现的系统设计案例和场景题。

\n

为什么你需要这份小册？

\n

近年来，国内技术面试"越来越卷"。越来越多的公司（阿里、美团、字节、腾讯等）开始在面试中考察 系统设计 和 场景问题，以此来更全面地考察求职者的综合能力——不论是校招还是社招。

\n
\n

很多同学八股文背得滚瓜烂熟，但一遇到"如何设计一个秒杀系统？"这类开放性问题就懵了。

\n
\n

系统设计和场景题的考察特点：

\n\n

于是，《后端面试高频系统设计&场景题》 小册就诞生了！

\n

这份小册能带给你什么？

\n

1. 面试加分项

\n

系统设计和场景题回答得好，面试官会对你印象非常好！这类问题稍微准备就能脱颖而出。

\n

2. 提升系统设计思维

\n

即使不是准备面试，这份小册也能帮助你建立系统设计的思维框架，提升解决实际问题的能力。

\n

3. 实战落地参考

\n

涉及到的很多案例都可以直接用到自己的项目上，比如：

\n\n

内容概览

\n

📐 系统设计案例

\n

| 主题 | 核心知识点 |
\n|

\n", "image": "https://oss.javaguide.cn/xingqiu/back-end-interview-high-frequency-system-design-and-scenario-questions-fengmian.png", "date_published": "2023-04-28T09:48:34.000Z", "date_modified": "2026-03-12T08:34:17.000Z", "authors": [], "tags": [ "知识星球" ] }, { "title": "PriorityQueue 源码分析（付费）", "url": "https://javaguide.cn/java/collection/priorityqueue-source-code.html", "id": "https://javaguide.cn/java/collection/priorityqueue-source-code.html", "summary": "PriorityQueue源码深度解析：详解基于二叉堆的优先队列实现、堆化siftUp/siftDown操作、Comparator自定义排序、动态扩容机制。", "content_html": "

PriorityQueue 源码分析 为我的知识星球（点击链接即可查看详细介绍以及加入方法）专属内容，已经整理到了《Java 必读源码系列》中。

\n

\"PriorityQueue

\n

《Java 必读源码系列》（点击链接即可查看详细介绍）的部分内容展示如下。

\n

\"《Java

\n

为了帮助更多同学准备 Java 面试以及学习 Java ，我创建了一个纯粹的Java 面试知识星球。虽然收费只有培训班/训练营的百分之一，但是知识星球里的内容质量更高，提供的服务也更全面，非常适合准备 Java 面试和学习 Java 的同学。

\n

欢迎准备 Java 面试以及学习 Java 的同学加入我的 知识星球，干货非常多，学习氛围也很不错！收费虽然是白菜价，但星球里的内容或许比你参加上万的培训班质量还要高。

\n

下面是星球提供的部分服务（点击下方图片即可获取知识星球的详细介绍）：

\n

\"星球服务\"

\n

我有自己的原则，不割韭菜，用心做内容，真心希望帮助到你！

\n

如果你感兴趣的话，不妨花 3 分钟左右看看星球的详细介绍：JavaGuide 知识星球详细介绍 。

\n

这里再送一个 30 元的星球专属优惠券，数量有限（价格即将上调。老用户续费半价 ，微信扫码即可续费）！

\n

\"知识星球30元优惠卷\"

\n

进入星球之后，记得查看 星球使用指南 （一定要看！！！） 和 星球优质主题汇总 。

\n

无任何套路，无任何潜在收费项。用心做内容，不割韭菜！

\n

不过， 一定要确定需要再进 。并且， 三天之内觉得内容不满意可以全额退款 。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/xingqiu/image-20230727084055593.png", "date_published": "2023-04-28T09:48:34.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Spring Boot核心源码解读（付费）", "url": "https://javaguide.cn/system-design/framework/spring/springboot-source-code.html", "id": "https://javaguide.cn/system-design/framework/spring/springboot-source-code.html", "summary": "Spring Boot核心源码深度解读，涵盖启动流程、自动配置机制、条件注解及SpringApplication源码分析。", "content_html": "

Spring Boot 核心源码解读 为我的知识星球（点击链接即可查看详细介绍以及加入方法）专属内容，已经整理到了《Java 必读源码系列》中。

\n

\"Spring

\n

《Java 必读源码系列》（点击链接即可查看详细介绍）的部分内容展示如下。

\n

\"《Java

\n

为了帮助更多同学准备 Java 面试以及学习 Java ，我创建了一个纯粹的Java 面试知识星球。虽然收费只有培训班/训练营的百分之一，但是知识星球里的内容质量更高，提供的服务也更全面，非常适合准备 Java 面试和学习 Java 的同学。

\n

欢迎准备 Java 面试以及学习 Java 的同学加入我的 知识星球，干货非常多，学习氛围也很不错！收费虽然是白菜价，但星球里的内容或许比你参加上万的培训班质量还要高。

\n

下面是星球提供的部分服务（点击下方图片即可获取知识星球的详细介绍）：

\n

\"星球服务\"

\n

我有自己的原则，不割韭菜，用心做内容，真心希望帮助到你！

\n

如果你感兴趣的话，不妨花 3 分钟左右看看星球的详细介绍：JavaGuide 知识星球详细介绍 。

\n

这里再送一个 30 元的星球专属优惠券，数量有限（价格即将上调。老用户续费半价 ，微信扫码即可续费）！

\n

\"知识星球30元优惠卷\"

\n

进入星球之后，记得查看 星球使用指南 （一定要看！！！） 和 星球优质主题汇总 。

\n

无任何套路，无任何潜在收费项。用心做内容，不割韭菜！

\n

不过， 一定要确定需要再进 。并且， 三天之内觉得内容不满意可以全额退款 。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/xingqiu/springboot-source-code.png", "date_published": "2023-04-28T09:48:34.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "框架" ] }, { "title": "Java 后端面试通关计划（涵盖后端通用体系）", "url": "https://javaguide.cn/interview-preparation/backend-interview-plan.html", "id": "https://javaguide.cn/interview-preparation/backend-interview-plan.html", "summary": "Java 后端面试通关计划：严格按照面试考察真实优先级编排，涵盖项目经历、Java核心、MySQL/Redis、框架、系统设计、计算机基础、分布式与JVM，适合校招/社招准备。", "content_html": "

本计划严格按照面试考察的真实优先级进行编排，顺序为：
\n「 项目经历与简历深挖 → Java核心/MySQL/Redis → 框架应用 → 系统设计与场景题 → 计算机基础 → 分布式/高并发 → JVM」

\n

每一阶段都对应了本站具体的精选文章，方便你按图索骥，逐个击破。

\n\n

计划总览

\n

| 阶段 | 建议时长 | 核心产出 | 自测标准 |
\n|

\n", "image": "https://oss.javaguide.cn/xingqiu/back-end-interview-high-frequency-system-design-and-scenario-questions-fengmian.png", "date_published": "2023-04-22T02:34:42.000Z", "date_modified": "2026-03-11T02:51:59.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "Java后端面试重点总结", "url": "https://javaguide.cn/interview-preparation/key-points-of-interview.html", "id": "https://javaguide.cn/interview-preparation/key-points-of-interview.html", "summary": "Java后端面试重点总结：梳理校招/社招高频考点与复习优先级，覆盖Java基础、集合、并发、MySQL、Redis、Spring/Spring Boot、JVM与项目经验准备，帮你抓重点高效备战。", "content_html": "

\"JavaGuide官方知识星球\"

\n
\n

友情提示

\n

本文节选自 《Java 面试指北》。这是一份教你如何更高效地准备面试的专栏，内容和 JavaGuide 互补，涵盖常见八股文（系统设计、常见框架、分布式、高并发 ……）、优质面经等内容。

\n
\n

Java 后端面试哪些知识点是重点？

\n

准备面试的时候，具体哪些知识点是重点呢？如何把握重点？

\n

先看下面这张全局图（后续会详细解读）：

\n

\"Java

\n

给你几点靠谱的建议：

\n
    \n
  1. Java 基础、集合、并发、MySQL、Redis 、Spring、Spring Boot 这些 Java 后端开发必备的知识点（MySQL + Redis >= Java > Spring + Spring Boot）。大厂以及中小厂的面试问的比较多的就是这些知识点。Spring 和 Spring Boot 这俩框架类的知识点相对前面的知识点来说重要性要稍低一些，但一般面试也会问一些，尤其是中小厂。并发知识一般中大厂提问更多也更难，尤其是大厂喜欢深挖底层，很容易把人问倒。计算机基础相关的内容会在下面提到。
    2. \n
  2. 你的项目经历涉及到的知识点是重中之重，有水平的面试官都是会根据你的项目经历来问的。举个例子，你的项目经历使用了 Redis 来做限流，那 Redis 相关的八股文（比如 Redis 常见数据结构）以及限流相关的八股文（比如常见的限流算法）你就应该多花更多心思来搞懂吃透！你把项目经历上的知识点吃透之后，再把你简历上哪些写熟练掌握的技术给吃透，最后再去花时间准备其他知识点。
    3. \n
  3. 针对自身找工作的需求，你又可以适当地调整复习的重点。像中小厂一般问计算机基础比较少一些，有些大厂比如字节比较重视计算机基础尤其是算法。这样的话，如果你的目标是中小厂的话，计算机基础就准备面试来说不是那么重要了。如果复习时间不够的话，可以暂时先放放，腾出时间给其他重要的知识点。
    4. \n
  4. 一般校招的面试不会强制要求你会分布式/微服务、高并发的知识（不排除个别岗位有这方面的硬性要求），所以到底要不要掌握还是要看你个人当前的实际情况。如果你会这方面的知识的话，对面试相对来说还是会更有利一些（想要让项目经历有亮点，还是得会一些性能优化的知识。性能优化的知识这也算是高并发知识的一个小分支了）。如果你的技能介绍或者项目经历涉及到分布式/微服务、高并发的知识，那建议你尽量也要抽时间去认真准备一下，面试中很可能会被问到，尤其是项目经历用到的时候。不过，也还是主要准备写在简历上的那些知识点就好。
    5. \n
  5. JVM 相关的知识点，一般是大厂（例如美团、阿里）和一些不错的中厂（例如携程、顺丰、招银网络）才会问到，面试国企、差一点的中厂和小厂就没必要准备了。JVM 面试中比较常问的是 Java 内存区域、JVM 垃圾回收、类加载器和双亲委派模型 以及 JVM 调优和问题排查（我之前分享过一些常见的线上问题案例，里面就有 JVM 相关的）。
    6. \n
  6. 不同的大厂面试侧重点也会不同。比如说你要去阿里这种公司的话，项目和八股文就是重点，阿里笔试一般会有代码题，进入面试后就很少问代码题了，但是对原理性的问题问的比较深，经常会问一些你对技术的思考。再比如说你要面试字节这种公司，那计算机基础，尤其是算法是重点，字节的面试十分注重代码功底，有时候开始面试就会直接甩给你一道代码题，写出来再谈别的。也会问面试八股文，以及项目，不过，相对来说要少很多。
    7. \n
  7. 多去找一些面经看看，尤其你目标公司或者类似公司对应岗位的面经。这样可以实现针对性的复习，还能顺便自测一波，检查一下自己的掌握情况。
    8. \n
\n

看似 Java 后端八股文很多，实际把复习范围一缩小，重要的东西就是那些。考虑到时间问题，你不可能连一些比较冷门的知识点也给准备了。这没必要，主要精力先放在那些重要的知识点即可。

\n

如何更高效地准备八股文？

\n\n

对于技术八股文来说，尽量不要死记硬背，这种方式非常枯燥且对自身能力提升有限！但是！想要一点不背是不太现实的，只是说要结合实际应用场景和实战来理解记忆。

\n

我一直觉得面试八股文最好是和实际应用场景和实战相结合。很多同学现在的方向都错了，上来就是直接背八股文，硬生生学成了文科，那当然无趣了。

\n

举个例子：你的项目中需要用到 Redis 来做缓存，你对照着官网简单了解并实践了简单使用 Redis 之后，你去看了 Redis 对应的八股文。你发现 Redis 可以用来做限流、分布式锁，于是你去在项目中实践了一下并掌握了对应的八股文。紧接着，你又发现 Redis 内存不够用的情况下，还能使用 Redis Cluster 来解决，于是你就又去实践了一下并掌握了对应的八股文。

\n

一定要记住你的主要目标是理解和记关键词，而不是像背课文一样一字一句地记下来，这样毫无意义！效率最低，对自身帮助也最小！

\n

还要注意适当“投机取巧”，不要单纯死记八股，有些技术方案的实现有很多种，例如分布式 ID、分布式锁、幂等设计，想要完全记住所有方案不太现实，你就重点记忆你项目的实现方案以及选择该种实现方案的原因就好了。当然，其他方案还是建议你简单了解一下，不然也没办法和你选择的方案进行对比。

\n

想要检测自己是否搞懂或者加深印象，记录博客或者用自己的理解把对应的知识点讲给别人听也是一个不错的选择。

\n

另外，准备八股文的过程中，强烈建议你花个几个小时去根据你的简历（主要是项目经历部分）思考一下哪些地方可能被深挖，然后把你自己的思考以面试问题的形式体现出来。面试之后，你还要根据当下的面试情况复盘一波，对之前自己整理的面试问题进行完善补充。这个过程对于个人进一步熟悉自己的简历（尤其是项目经历）部分，非常非常有用。这些问题你也一定要多花一些时间搞懂吃透，能够流畅地表达出来。面试问题可以参考 Java 面试常见问题总结（2024 最新版），记得根据自己项目经历去深入拓展即可！

\n

最后，准备技术面试的同学一定要定期复习（自测的方式非常好），不然确实会遗忘的。

\n

详细面试准备计划（后端通用）

\n

Java 后端面试重点和详细准备计划

\n", "image": "https://oss.javaguide.cn/github/javaguide/interview-preparation/back-end-interview-focus.png", "date_published": "2023-04-22T02:34:42.000Z", "date_modified": "2026-03-08T05:13:15.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "计算机网络常见面试题总结(下)", "url": "https://javaguide.cn/cs-basics/network/other-network-questions2.html", "id": "https://javaguide.cn/cs-basics/network/other-network-questions2.html", "summary": "最新计算机网络高频面试题总结（下）：TCP/UDP深度对比、三次握手四次挥手、HTTP/3 QUIC优化、IPv6优势、NAT/ARP详解，附表格+⭐️重点标注，一文掌握传输层&网络层核心考点，快速通关后端技术面试！", "content_html": "

\"《SpringAI

\n

下篇主要是传输层和网络层相关的内容。

\n

TCP 与 UDP

\n

⭐️TCP 与 UDP 的区别（重要）

\n
    \n
  1. 是否面向连接：\n\n
    2. \n
  2. 是否是可靠传输：\n\n
    3. \n
  3. 是否有状态：\n\n
    4. \n
  4. 传输效率：\n\n
    5. \n
  5. 传输形式：\n\n
    6. \n
  6. 首部开销：\n\n
    7. \n
  7. 是否提供广播或多播服务：\n\n
    8. \n
  8. ……
    9. \n
\n

为了更直观地对比，可以看下面这个表格：

\n

| 特性 | TCP | UDP |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/network/http-3-implementation.png", "date_published": "2023-04-13T11:00:22.000Z", "date_modified": "2026-03-10T15:16:51.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "DNS 域名系统详解（应用层）", "url": "https://javaguide.cn/cs-basics/network/dns.html", "id": "https://javaguide.cn/cs-basics/network/dns.html", "summary": "详解 DNS 的层次结构与解析流程，覆盖递归/迭代、缓存与权威服务器，明确应用层端口与性能优化要点。", "content_html": "

DNS（Domain Name System）域名管理系统，是当用户使用浏览器访问网址之后，使用的第一个重要协议。DNS 要解决的是域名和 IP 地址的映射问题。

\n

\"DNS:域名系统\"

\n

在实际使用中，有一种情况下，浏览器是可以不必动用 DNS 就可以获知域名和 IP 地址的映射的。浏览器在本地会维护一个hosts列表，一般来说浏览器要先查看要访问的域名是否在hosts列表中，如果有的话，直接提取对应的 IP 地址记录，就好了。如果本地hosts列表内没有域名-IP 对应记录的话，那么 DNS 就闪亮登场了。

\n

目前 DNS 的设计采用的是分布式、层次数据库结构，DNS 是应用层协议，通常基于 UDP 协议，端口为 53。当响应数据超过 UDP 报文长度限制（512 字节，EDNS0 可扩展至更大）或进行区域传送（Zone Transfer）时，会改用 TCP 协议以保证数据完整性。

\n

\"TCP/IP

\n

DNS 服务器

\n

DNS 服务器自底向上可以依次分为以下几个层级(所有 DNS 服务器都属于以下四个类别之一):

\n\n

世界上真的只有 13 台根服务器吗？ 这是一个流传已久的技术误解。如果你在网上搜索，仍能看到许多陈旧文章宣称“全球仅有 13 台根服务器，且全部由美国控制”。

\n

事实并非如此。

\n

最初在设计 DNS（域名系统）架构时，受限于早期 IPv4 数据包的大小限制（UDP 报文需控制在 512 字节以内），预留给根服务器地址的空间确实只够容纳 13 个 IP 地址，每个 IP 地址对应一个不同的根 DNS 服务器。这 13 个地址分别被命名为 a.root-servers.net 到 m.root-servers.net。

\n

虽然逻辑上只有 13 个 IP 地址，但随着互联网规模的爆发，物理上的“单一服务器”早已无法承载全球的查询压力。为了提升 DNS 的可靠性、安全性和响应速度，技术人员引入了 IP 任播（Anycast） 技术。

\n

通过任播技术，每一个逻辑 IP 地址背后都可以对应成百上千台分布在全球各地的物理服务器。当你发起查询请求时，互联网路由协议（BGP）会自动将请求引导至地理位置或网络路径上离你最近的那台物理实例。

\n

截止到 2023 年底，全球根服务器物理实例总数已超过 1700 台。根据 Root-Servers.org 的最新实时监测数据，到 2026 年，全球根服务器物理实例已突破 1900+ 台，并正向 2000 台大关迈进。

\n

\"Root-Servers.org\"

\n

DNS 工作流程

\n

以下图为例，介绍 DNS 的查询解析过程。DNS 的查询解析过程分为两种模式：

\n\n

下图是实践中常采用的方式，从请求主机到本地 DNS 服务器的查询是递归的，其余的查询时迭代的。

\n

\n

现在，主机cis.poly.edu想知道gaia.cs.umass.edu的 IP 地址。假设主机cis.poly.edu的本地 DNS 服务器为dns.poly.edu，并且gaia.cs.umass.edu的权威 DNS 服务器为dns.cs.umass.edu。

\n
    \n
  1. 首先，主机cis.poly.edu向本地 DNS 服务器dns.poly.edu发送一个 DNS 请求，该查询报文包含被转换的域名gaia.cs.umass.edu。
    2. \n
  2. 本地 DNS 服务器dns.poly.edu检查本机缓存，发现并无记录，也不知道gaia.cs.umass.edu的 IP 地址该在何处，不得不向根服务器发送请求。
    3. \n
  3. 根服务器注意到请求报文中含有edu顶级域，因此告诉本地 DNS，你可以向edu的 TLD DNS 发送请求，因为目标域名的 IP 地址很可能在那里。
    4. \n
  4. 本地 DNS 获取到了edu的 TLD DNS 服务器地址，向其发送请求，询问gaia.cs.umass.edu的 IP 地址。
    5. \n
  5. edu的 TLD DNS 服务器仍不清楚请求域名的 IP 地址，但是它注意到该域名有umass.edu前缀，因此返回告知本地 DNS，umass.edu的权威服务器可能记录了目标域名的 IP 地址。
    6. \n
  6. 这一次，本地 DNS 将请求发送给权威 DNS 服务器dns.cs.umass.edu。
    7. \n
  7. 终于，由于gaia.cs.umass.edu向权威 DNS 服务器备案过，在这里有它的 IP 地址记录，权威 DNS 成功地将 IP 地址返回给本地 DNS。
    8. \n
  8. 最后，本地 DNS 获取到了目标域名的 IP 地址，将其返回给请求主机。
    9. \n
\n

除了迭代式查询，还有一种递归式查询如下图，具体过程和上述类似，只是顺序有所不同。

\n

\n

另外，DNS 的缓存位于本地 DNS 服务器。由于全世界的根服务器甚少，只有 600 多台，分为 13 组，且顶级域的数量也在一个可数的范围内，因此本地 DNS 通常已经缓存了很多 TLD DNS 服务器，所以在实际查找过程中，无需访问根服务器。根服务器通常是被跳过的，不请求的。这样可以提高 DNS 查询的效率和速度，减少对根服务器和 TLD 服务器的负担。

\n

DNS 报文格式

\n

DNS 的报文格式如下图所示：

\n

\n

DNS 报文分为查询和回答报文，两种形式的报文结构相同。

\n\n

DNS 记录

\n

DNS 服务器在响应查询时，需要查询自己的数据库，数据库中的条目被称为 资源记录(Resource Record，RR) 。RR 提供了主机名到 IP 地址的映射。RR 是一个包含了Name, Value, Type, TTL四个字段的四元组。

\n

\n

TTL是该记录的生存时间，它决定了资源记录应当从缓存中删除的时间。

\n

Name和Value字段的取值取决于Type：

\n

\n\n

CNAME记录总是指向另一则域名，而非 IP 地址。假设有下述 DNS zone：

\n
NAME                    TYPE   VALUE
\n
", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/network/dns-overview.png", "date_published": "2023-04-11T08:54:54.000Z", "date_modified": "2026-02-22T12:21:13.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "坚持写技术博客六年了!", "url": "https://javaguide.cn/about-the-author/writing-technology-blog-six-years.html", "id": "https://javaguide.cn/about-the-author/writing-technology-blog-six-years.html", "summary": "坚持写技术博客六年的心得分享，写博客的好处、如何坚持下去、写哪些方向的博客、实用写作技巧等经验总结。", "content_html": "

坚持写技术博客已经有六年了，也算是一个小小的里程碑了。

\n

一开始，我写技术博客就是简单地总结自己课堂上学习的课程比如网络、操作系统。渐渐地，我开始撰写一些更为系统化的知识点详解和面试常见问题总结。

\n

\"JavaGuide

\n

许多人都想写技术博客，但却不清楚这对他们有何好处。有些人开始写技术博客，却不知道如何坚持下去，也不知道该写些什么。这篇文章我会认真聊聊我对记录技术博客的一些看法和心得，或许可以帮助你解决这些问题。

\n

写技术博客有哪些好处？

\n

学习效果更好，加深知识点的认识

\n

费曼学习法 大家应该已经比较清楚了，这是一个经过实践证明非常有效的学习方式。费曼学习法的命名源自 Richard Feynman，这位物理学家曾获得过诺贝尔物理学奖，也曾参与过曼哈顿计划。

\n

所谓费曼学习法，就是当你学习了一个新知识之后，想象自己是一个老师：用最简单、最浅显直白的话复述、表达复杂深奥的知识，最好不要使用行业术语，让非行业内的人也能听懂。为了达到这种效果，最好想象你是在给一个 80 多岁或 8 岁的小孩子上课，甚至他们都能听懂。

\n

\"教授别人学习效果最好\"

\n

看书、看视频这类都属于是被动学习，学习效果比较差。费曼学习方法属于主动学习，学习效果非常好。

\n

写技术博客实际就是教别人的一种方式。 不过，记录技术博客的时候是可以有专业术语（除非你的文章群体是非技术人员），只是你需要用自己的话表述出来，尽量让别人一看就懂。切忌照搬书籍或者直接复制粘贴其他人的总结！

\n

如果我们被动的学习某个知识点，可能大部分时候都是仅仅满足自己能够会用的层面，你并不会深究其原理，甚至很多关键概念都没搞懂。

\n

如果你是要将你所学到的知识总结成一篇博客的话，一定会加深你对这个知识点的思考。很多时候，你为了将一个知识点讲清楚，你回去查阅很多资料，甚至需要查看很多源码，这些细小的积累在潜移默化中加深了你对这个知识点的认识。

\n

甚至，我还经常会遇到这种情况：写博客的过程中，自己突然意识到自己对于某个知识点的理解存在错误。

\n

写博客本身就是一个对自己学习到的知识进行总结、回顾、思考的过程。记录博客也是对于自己学习历程的一种记录。随着时间的流逝、年龄的增长，这又何尝不是一笔宝贵的精神财富呢？

\n

知识星球的一位球友还提到写技术博客有助于完善自己的知识体系：

\n

\"写技术博客有助于完善自己的知识体系\"

\n

帮助别人的同时获得成就感

\n

就像我们程序员希望自己的产品能够得到大家的认可和喜欢一样。我们写技术博客在某一方面当然也是为了能够得到别人的认可。

\n

当你写的东西对别人产生帮助的时候，你会产生成就感和幸福感。

\n

\"读者的认可\"

\n

这种成就感和幸福感会作为 正向反馈 ，继续激励你写博客。

\n

但是，即使受到很多读者的赞赏，也要保持谦虚学习的太多。人外有人，比你技术更厉害的读者多了去，一定要虚心学习！

\n

当然，你可以可能会受到很多非议。可能会有很多人说你写的文章没有深度，还可能会有很多人说你闲的蛋疼，你写的东西网上/书上都有。

\n

坦然对待这些非议，做好自己，走好自己的路就好！用行动自证！

\n

可能会有额外的收入

\n

写博客可能还会为你带来经济收入。输出价值的同时，还能够有合理的经济收入，这是最好的状态！

\n

为什么说是可能呢？ 因为就目前来看，大部分人还是很难短期通过写博客有收入。我也不建议大家一开始写博客就奔着赚钱的目的，这样功利性太强了，效果可能反而不好。就比如说你坚持了写了半年发现赚不到钱，那你可能就会坚持不下去了。

\n

我自己从大二开始写博客，大三下学期开始将自己的文章发布到公众号上，一直到大四下学期，才通过写博客赚到属于自己的第一笔钱。

\n

第一笔钱是通过微信公众号接某培训机构的推广获得的。没记错的话，当时通过这个推广为自己带来了大约 500 元的收入。虽然这不是很多，但对于还在上大学的我来说，这笔钱非常宝贵。那时我才知道，原来写作真的可以赚钱，这也让我更有动力去分享自己的写作。可惜的是，在接了两次这家培训机构的广告之后，它就倒闭了。

\n

之后，很长一段时间我都没有接到过广告。直到网易的课程合作找上门，一篇文章 1000 元，每个月接近一篇，发了接近两年，这也算是我在大学期间比较稳定的一份收入来源了。

\n

\"网易的课程合作\"

\n

老粉应该大部分都是通过 JavaGuide 这个项目认识我的，这是我在大三开始准备秋招面试时创建的一个项目。没想到这个项目竟然火了一把，一度霸占了 GitHub 榜单。可能当时国内这类开源文档教程类项目太少了，所以这个项目受欢迎程度非常高。

\n

\"JavaGuide

\n

项目火了之后，有一个国内比较大的云服务公司找到我，说是要赞助 JavaGuide 这个项目。我既惊又喜，担心别人是骗子，反复确认合同之后，最终确定以每月 1000 元的费用在我的项目首页加上对方公司的 banner。

\n

随着时间的推移，以及自己后来写了一些比较受欢迎、比较受众的文章，我的博客知名度也有所提升，通过写博客的收入也增加了不少。

\n

增加个人影响力

\n

写技术博客是一种展示自己技术水平和经验的方式，能够让更多的人了解你的专业领域知识和技能。持续分享优质的技术文章，一定能够在技术领域增加个人影响力，这一点是毋庸置疑的。

\n

有了个人影响力之后，不论是对你后面找工作，还是搞付费知识分享或者出书，都非常有帮助。

\n

拿我自己来说，已经很多知名出版社的编辑找过我，协商出一本的书的事情。这种机会应该也是很多人梦寐以求的。不过，我都一一拒绝了，因为觉得自己远远没有达到能够写书的水平。

\n

\"电子工业出版社编辑邀约出书\"

\n

其实不出书最主要的原因还是自己嫌麻烦，整个流程的事情太多了。我自己又是比较佛系随性的人，平时也不想把时间都留给工作。

\n

怎样才能坚持写技术博客？

\n

不可否认，人都是有懒性的，这是人的本性。我们需要一个目标/动力来 Push 一下自己。

\n

就技术写作而言，你的目标可以以技术文章的数量为标准，比如：

\n\n

不过，以技术文章的数量为目标有点功利化，文章的质量同样很重要。一篇高质量的技术文可能需要花费一周甚至半个月的业余时间才能写完。一定要避免自己刻意追求数量，而忽略质量，迷失技术写作的本心。

\n

我个人给自己定的目标是：每个月至少写一篇原创技术文章或者认真修改完善过去写的三篇技术文章 （像开源项目推荐、开源项目学习、个人经验分享、面经分享等等类型的文章不会被记入）。

\n

我的目标对我来说比较容易完成，因此不会出现为了完成目标而应付任务的情况。在我状态比较好，工作也不是很忙的时候，还会经常超额完成任务。下图是我今年 3 月份完成的任务（任务管理工具：Microsoft To-Do）。除了 gossip 协议是去年写的之外，其他都是 3 月份完成的。

\n

\n

如果觉得以文章数量为标准过于功利的话，也可以比较随性地按照自己的节奏来写作。不过，一般这种情况下，你很可能过段时间就忘了还有这件事，开始慢慢抵触写博客。

\n

写完一篇技术文章之后，我们不光要同步到自己的博客，还要分发到国内一些常见的技术社区比如博客园、掘金。分发到其他平台的原因是获得关注进而收获正向反馈（动力来源之一）与建议，这是技术写作能坚持下去的非常重要的一步，一定要重视！！！

\n

说实话，当你写完一篇自认为还不错的文章的幸福感和成就感还是有的。但是，让自己去做这件事情还是比较痛苦的。 就好比你让自己出去玩很简单，为了达到这个目的，你可以有各种借口。但是，想要自己老老实实学习，还是需要某个外力来督促自己的。

\n

写哪些方向的博客比较好？

\n

通常来说，写下面这些方向的博客会比较好：

\n
    \n
  1. 详细讲解某个知识点：一定要有自己的思考而不是东拼西凑。不仅要介绍知识点的基本概念和原理，还需要适当结合实际案例和应用场景进行举例说明。
    2. \n
  2. 问题排查/性能优化经历：需要详细描述清楚具体的场景以及解决办法。一定要有足够的细节描述，包括出现问题的具体场景、问题的根本原因、解决问题的思路和具体步骤等等。同时，要注重实践性和可操作性，帮助读者更好地学习理解。
    3. \n
  3. 源码阅读记录：从一个功能点出发描述其底层源码实现，谈谈你从源码中学到了什么。
    4. \n
\n

最重要的是一定要重视 Markdown 规范，不然内容再好也会显得不专业。

\n

详见 Markdown 规范 （很重要，尽量按照规范来，对你工作中写文档会非常有帮助）

\n

有没有什么写作技巧分享？

\n

句子不要过长

\n

句子不要过长，尽量使用短句（但也不要太短），这样读者更容易阅读和理解。

\n

尽量让文章更加生动有趣

\n

尽量让文章更加生动有趣，比如你可以适当举一些形象的例子、用一些有趣的段子、歇后语或者网络热词。

\n

不过，这个也主要看你的文章风格。

\n

使用简单明了的语言

\n

避免使用阅读者可能无法理解的行话或复杂语言。

\n

注重清晰度和说服力，保持简单。简单的写作是有说服力的，一个五句话的好论点会比一百句话的精彩论点更能打动人。为什么格言、箴言这类文字容易让人接受，与简洁、直白也有些关系。

\n

使用视觉效果

\n

图表、图像等视觉效果可以让朴素的文本内容更容易理解。记得在适当的地方使用视觉效果来增强你的文章的表现力。

\n

\n

技术文章配图色彩要鲜明

\n

下面是同样内容的两张图，都是通过 drawio 画的，小伙伴们更喜欢哪一张呢？

\n

我相信大部分小伙伴都会选择后面一个色彩更鲜明的！

\n

色彩的调整不过花费了我不到 30s 的时间，带来的阅读体验的上升却是非常之大！

\n

\n

确定你的读者

\n

写作之前，思考一下你的文章的主要受众全体是谁。受众群体确定之后，你可以根据受众的需求和理解水平调整你的写作风格和内容难易程度。

\n

审查和修改

\n

在发表之前一定要审查和修改你的文章。这将帮助你发现错误、澄清任何令人困惑的信息并提高文档的整体质量。

\n

好文是改出来的，切记！！！

\n

总结

\n

总的来说，写技术博客是一件利己利彼的事情。你可能会从中收获到很多东西，你写的东西也可能对别人也有很大的帮助。但是，写技术博客还是比较耗费自己时间的，你需要和工作以及生活做好权衡。

\n", "image": "https://oss.javaguide.cn/about-the-author/college-life/image-20230408131717766.png", "date_published": "2023-04-09T12:42:14.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "走近作者" ] }, { "title": "操作系统常见面试题总结(下)", "url": "https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-02.html", "id": "https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-02.html", "summary": "最新操作系统高频面试题总结（下）：虚拟内存映射、内存碎片/伙伴系统、TLB+页缺失处理、分页分段对比、页面置换算法详解、文件系统&磁盘调度，附图表+⭐️重点标注，一文掌握OS内存/文件考点，快速通关后端面试！", "content_html": "

\"《SpringAI

\n

内存管理

\n

内存管理主要做了什么？

\n

\"内存管理主要做的事情\"

\n

操作系统的内存管理非常重要，主要负责下面这些事情：

\n\n

什么是内存碎片？

\n

内存碎片是由内存的申请和释放产生的，通常分为下面两种：

\n\n

\"内存碎片\"

\n

内存碎片会导致内存利用率下降，如何减少内存碎片是内存管理要非常重视的一件事情。

\n

常见的内存管理方式有哪些？

\n

内存管理方式可以简单分为下面两种：

\n\n

连续内存管理

\n

块式管理 是早期计算机操作系统的一种连续内存管理方式，存在严重的内存碎片问题。块式管理会将内存分为几个固定大小的块，每个块中只包含一个进程。如果程序运行需要内存的话，操作系统就分配给它一块，如果程序运行只需要很小的空间的话，分配的这块内存很大一部分几乎被浪费了。这些在每个块中未被利用的空间，我们称之为内部内存碎片。除了内部内存碎片之外，由于两个内存块之间可能还会有外部内存碎片，这些不连续的外部内存碎片由于太小了无法再进行分配。

\n

在 Linux 系统中，连续内存管理采用了 伙伴系统（Buddy System）算法 来实现，这是一种经典的连续内存分配算法，可以有效解决外部内存碎片的问题。伙伴系统的主要思想是将内存按 2 的幂次划分（每一块内存大小都是 2 的幂次比如 2^6=64 KB），并将相邻的内存块组合成一对伙伴（注意：必须是相邻的才是伙伴）。

\n

当进行内存分配时，伙伴系统会尝试找到大小最合适的内存块。如果找到的内存块过大，就将其一分为二，分成两个大小相等的伙伴块。如果还是大的话，就继续切分，直到到达合适的大小为止。

\n

假设两块相邻的内存块都被释放，系统会将这两个内存块合并，进而形成一个更大的内存块，以便后续的内存分配。这样就可以减少内存碎片的问题，提高内存利用率。

\n

\"伙伴系统（Buddy

\n

虽然解决了外部内存碎片的问题，但伙伴系统仍然存在内存利用率不高的问题（内部内存碎片）。这主要是因为伙伴系统只能分配大小为 2^n 的内存块，因此当需要分配的内存大小不是 2^n 的整数倍时，会浪费一定的内存空间。举个例子：如果要分配 65 大小的内存快，依然需要分配 2^7=128 大小的内存块。

\n

\"伙伴系统内存浪费问题\"

\n

对于内部内存碎片的问题，Linux 采用 SLAB 进行解决。由于这部分内容不是本篇文章的重点，这里就不详细介绍了。

\n

非连续内存管理

\n

非连续内存管理存在下面 3 种方式：

\n\n

虚拟内存

\n

什么是虚拟内存?有什么用？

\n

虚拟内存(Virtual Memory) 是计算机系统内存管理非常重要的一个技术，本质上来说它只是逻辑存在的，是一个假想出来的内存空间，主要作用是作为进程访问主存（物理内存）的桥梁并简化内存管理。

\n

\"虚拟内存作为进程访问主存的桥梁\"

\n

总结来说，虚拟内存主要提供了下面这些能力：

\n\n

没有虚拟内存有什么问题？

\n

如果没有虚拟内存的话，程序直接访问和操作的都是物理内存，看似少了一层中介，但多了很多问题。

\n

具体有什么问题呢？ 这里举几个例子说明(参考虚拟内存提供的能力回答这个问题)：

\n
    \n
  1. 用户程序可以访问任意物理内存，可能会不小心操作到系统运行必需的内存，进而造成操作系统崩溃，严重影响系统的安全。
    2. \n
  2. 同时运行多个程序容易崩溃。比如你想同时运行一个微信和一个 QQ 音乐，微信在运行的时候给内存地址 1xxx 赋值后，QQ 音乐也同样给内存地址 1xxx 赋值，那么 QQ 音乐对内存的赋值就会覆盖微信之前所赋的值，这就可能会造成微信这个程序会崩溃。
    3. \n
  3. 程序运行过程中使用的所有数据或指令都要载入物理内存，根据局部性原理，其中很大一部分可能都不会用到，白白占用了宝贵的物理内存资源。
    4. \n
  4. ……
    5. \n
\n

什么是虚拟地址和物理地址？

\n

物理地址（Physical Address） 是真正的物理内存中地址，更具体点来说是内存地址寄存器中的地址。程序中访问的内存地址不是物理地址，而是 虚拟地址（Virtual Address） 。

\n

也就是说，我们编程开发的时候实际就是在和虚拟地址打交道。比如在 C 语言中，指针里面存储的数值就可以理解成为内存里的一个地址，这个地址也就是我们说的虚拟地址。

\n

操作系统一般通过 CPU 芯片中的一个重要组件 MMU(Memory Management Unit，内存管理单元) 将虚拟地址转换为物理地址，这个过程被称为 地址翻译/地址转换（Address Translation） 。

\n

\"地址翻译过程\"

\n

通过 MMU 将虚拟地址转换为物理地址后，再通过总线传到物理内存设备，进而完成相应的物理内存读写请求。

\n

MMU 将虚拟地址翻译为物理地址的主要机制有两种: 分段机制 和 分页机制 。

\n

什么是虚拟地址空间和物理地址空间？

\n\n

虚拟地址与物理内存地址是如何映射的？

\n

MMU 将虚拟地址翻译为物理地址的主要机制有 3 种:

\n
    \n
  1. 分段机制
    2. \n
  2. 分页机制
    3. \n
  3. 段页机制
    4. \n
\n

其中，现代操作系统广泛采用分页机制，需要重点关注！

\n

分段机制

\n

分段机制（Segmentation） 以段(一段 连续 的物理内存)的形式管理/分配物理内存。应用程序的虚拟地址空间被分为大小不等的段，段是有实际意义的，每个段定义了一组逻辑信息，例如有主程序段 MAIN、子程序段 X、数据段 D 及栈段 S 等。

\n

段表有什么用？地址翻译过程是怎样的？

\n

分段管理通过 段表（Segment Table） 映射虚拟地址和物理地址。

\n

分段机制下的虚拟地址由两部分组成：

\n\n

具体的地址翻译过程如下：

\n
    \n
  1. MMU 首先解析得到虚拟地址中的段号；
    2. \n
  2. 通过段号去该应用程序的段表中取出对应的段信息（找到对应的段表项）；
    3. \n
  3. 从段信息中取出该段的起始地址（物理地址）加上虚拟地址中的段内偏移量得到最终的物理地址。
    4. \n
\n

\"分段机制下的地址翻译过程\"

\n

段表中还存有诸如段长(可用于检查虚拟地址是否超出合法范围)、段类型（该段的类型，例如代码段、数据段等）等信息。

\n

通过段号一定要找到对应的段表项吗？得到最终的物理地址后对应的物理内存一定存在吗？

\n

不一定。段表项可能并不存在：

\n\n

分段机制为什么会导致内存外部碎片？

\n

分段机制容易出现外部内存碎片，即在段与段之间留下碎片空间(不足以映射给虚拟地址空间中的段)。从而造成物理内存资源利用率的降低。

\n

举个例子：假设可用物理内存为 5G 的系统使用分段机制分配内存。现在有 4 个进程，每个进程的内存占用情况如下：

\n\n

此时，我们关闭了进程 1 和进程 4，则第 1 段和第 4 段的内存会被释放，空闲物理内存还有 1.5G。由于这 1.5G 物理内存并不是连续的，导致没办法将空闲的物理内存分配给一个需要 1.5G 物理内存的进程。

\n

\"分段机制导致外部内存碎片\"

\n

分页机制

\n

分页机制（Paging） 把主存（物理内存）分为连续等长的物理页，应用程序的虚拟地址空间划也被分为连续等长的虚拟页。现代操作系统广泛采用分页机制。

\n

注意：这里的页是连续等长的，不同于分段机制下不同长度的段。

\n

在分页机制下，应用程序虚拟地址空间中的任意虚拟页可以被映射到物理内存中的任意物理页上，因此可以实现物理内存资源的离散分配。分页机制按照固定页大小分配物理内存，使得物理内存资源易于管理，可有效避免分段机制中外部内存碎片的问题。

\n

页表有什么用？地址翻译过程是怎样的？

\n

分页管理通过 页表（Page Table） 映射虚拟地址和物理地址。我这里画了一张基于单级页表进行地址翻译的示意图。

\n

\"单级页表\"

\n

在分页机制下，每个进程都会有一个对应的页表。

\n

分页机制下的虚拟地址由两部分组成：

\n\n

具体的地址翻译过程如下：

\n
    \n
  1. MMU 首先解析得到虚拟地址中的虚拟页号；
    2. \n
  2. 通过虚拟页号去该应用程序的页表中取出对应的物理页号（找到对应的页表项）；
    3. \n
  3. 用该物理页号对应的物理页起始地址（物理地址）加上虚拟地址中的页内偏移量得到最终的物理地址。
    4. \n
\n

\"分页机制下的地址翻译过程\"

\n

页表中还存有诸如访问标志（标识该页面有没有被访问过）、脏数据标识位等信息。

\n

通过虚拟页号一定要找到对应的物理页号吗？找到了物理页号得到最终的物理地址后对应的物理页一定存在吗？

\n

不一定！可能会存在 页缺失 。也就是说，物理内存中没有对应的物理页或者物理内存中有对应的物理页但虚拟页还未和物理页建立映射（对应的页表项不存在）。关于页缺失的内容，后面会详细介绍到。

\n

单级页表有什么问题？为什么需要多级页表？

\n

以 32 位的环境为例，虚拟地址空间范围共有 2^32（4G）。假设 一个页的大小是 2^12（4KB），那页表项共有 4G / 4K = 2^20 个。每个页表项为一个地址，占用 4 字节，(2^20 * 2^2) / (1024 * 1024)= 4MB。也就是说一个程序啥都不干，页表大小就得占用 4M。

\n

系统运行的应用程序多起来的话，页表的开销还是非常大的。而且，绝大部分应用程序可能只能用到页表中的几项，其他的白白浪费了。

\n

为了解决这个问题，操作系统引入了 多级页表 ，多级页表对应多个页表，每个页表与前一个页表相关联。32 位系统一般为二级页表，64 位系统一般为四级页表。

\n

这里以二级页表为例进行介绍：二级列表分为一级页表和二级页表。一级页表共有 1024 个页表项，一级页表又关联二级页表，二级页表同样共有 1024 个页表项。二级页表中的一级页表项是一对多的关系，二级页表按需加载（只会用到很少一部分二级页表），进而节省空间占用。

\n

假设只需要 2 个二级页表，那两级页表的内存占用情况为: 4KB（一级页表占用） + 4KB * 2（二级页表占用） = 12 KB。

\n

\"多级页表\"

\n

多级页表属于时间换空间的典型场景，利用增加页表查询的次数减少页表占用的空间。

\n

TLB 有什么用？使用 TLB 之后的地址翻译流程是怎样的？

\n

为了提高虚拟地址到物理地址的转换速度，操作系统在 页表方案 基础之上引入了 转址旁路缓存(Translation Lookaside Buffer，TLB，也被称为快表) 。

\n

\"加入

\n

在主流的 AArch64 和 x86-64 体系结构下，TLB 属于 (Memory Management Unit，内存管理单元) 内部的单元，本质上就是一块高速缓存（Cache），缓存了虚拟页号到物理页号的映射关系，你可以将其简单看作是存储着键（虚拟页号）值（物理页号）对的哈希表。

\n

使用 TLB 之后的地址翻译流程是这样的：

\n
    \n
  1. 用虚拟地址中的虚拟页号作为 key 去 TLB 中查询；
    2. \n
  2. 如果能查到对应的物理页的话，就不用再查询页表了，这种情况称为 TLB 命中（TLB hit)。
    3. \n
  3. 如果不能查到对应的物理页的话，还是需要去查询主存中的页表，同时将页表中的该映射表项添加到 TLB 中，这种情况称为 TLB 未命中（TLB miss)。
    4. \n
  4. 当 TLB 填满后，又要登记新页时，就按照一定的淘汰策略淘汰掉快表中的一个页。
    5. \n
\n

\"使用

\n

由于页表也在主存中，因此在没有 TLB 之前，每次读写内存数据时 CPU 要访问两次主存。有了 TLB 之后，对于存在于 TLB 中的页表数据只需要访问一次主存即可。

\n

TLB 的设计思想非常简单，但命中率往往非常高，效果很好。这就是因为被频繁访问的页就是其中的很小一部分。

\n

看完了之后你会发现快表和我们平时经常在开发系统中使用的缓存（比如 Redis）很像，的确是这样的，操作系统中的很多思想、很多经典的算法，你都可以在我们日常开发使用的各种工具或者框架中找到它们的影子。

\n

换页机制有什么用？

\n

换页机制的思想是当物理内存不够用的时候，操作系统选择将一些物理页的内容放到磁盘上去，等要用到的时候再将它们读取到物理内存中。也就是说，换页机制利用磁盘这种较低廉的存储设备扩展的物理内存。

\n

这也就解释了一个日常使用电脑常见的问题：为什么操作系统中所有进程运行所需的物理内存即使比真实的物理内存要大一些，这些进程也是可以正常运行的，只是运行速度会变慢。

\n

这同样是一种时间换空间的策略，你用 CPU 的计算时间，页的调入调出花费的时间，换来了一个虚拟的更大的物理内存空间来支持程序的运行。

\n

什么是页缺失？

\n

根据维基百科:

\n
\n

页缺失（Page Fault，又名硬错误、硬中断、分页错误、寻页缺失、缺页中断、页故障等）指的是当软件试图访问已映射在虚拟地址空间中，但是目前并未被加载在物理内存中的一个分页时，由 MMU 所发出的中断。

\n
\n

常见的页缺失有下面这两种：

\n\n

发生上面这两种缺页错误的时候，应用程序访问的是有效的物理内存，只是出现了物理页缺失或者虚拟页和物理页的映射关系未建立的问题。如果应用程序访问的是无效的物理内存的话，还会出现 无效缺页错误（Invalid Page Fault） 。

\n

常见的页面置换算法有哪些?

\n

当发生硬性页缺失时，如果物理内存中没有空闲的物理页面可用的话。操作系统就必须将物理内存中的一个物理页淘汰出去，这样就可以腾出空间来加载新的页面了。

\n

用来选择淘汰哪一个物理页的规则叫做 页面置换算法 ，我们可以把页面置换算法看成是淘汰物物理页的规则。

\n

页缺失太频繁的发生会非常影响性能，一个好的页面置换算法应该是可以减少页缺失出现的次数。

\n

常见的页面置换算法有下面这 5 种（其他还有很多页面置换算法都是基于这些算法改进得来的）：

\n

\"常见的页面置换算法\"

\n
    \n
  1. 最佳页面置换算法（OPT，Optimal）：优先选择淘汰的页面是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。但由于人们目前无法预知进程在内存下的若干页面中哪个是未来最长时间内不再被访问的，因而该算法无法实现，只是理论最优的页面置换算法，可以作为衡量其他置换算法优劣的标准。
    2. \n
  2. 先进先出页面置换算法（FIFO，First In First Out） : 最简单的一种页面置换算法，总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面进行淘汰。该算法易于实现和理解，一般只需要通过一个 FIFO 队列即可满足需求。不过，它的性能并不是很好。
    3. \n
  3. 最近最久未使用页面置换算法（LRU ，Least Recently Used）：LRU 算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 T，当须淘汰一个页面时，选择现有页面中其 T 值最大的，即最近最久未使用的页面予以淘汰。LRU 算法是根据各页之前的访问情况来实现，因此是易于实现的。OPT 算法是根据各页未来的访问情况来实现，因此是不可实现的。
    4. \n
  4. 最少使用页面置换算法（LFU，Least Frequently Used） : 和 LRU 算法比较像，不过该置换算法选择的是之前一段时间内使用最少的页面作为淘汰页。
    5. \n
  5. 时钟页面置换算法（Clock）：可以认为是一种最近未使用算法，即逐出的页面都是最近没有使用的那个。
    6. \n
\n

FIFO 页面置换算法性能为何不好？

\n

主要原因主要有二：

\n
    \n
  1. 经常访问或者需要长期存在的页面会被频繁调入调出：较早调入的页往往是经常被访问或者需要长期存在的页，这些页会被反复调入和调出。
    2. \n
  2. 存在 Belady 现象：被置换的页面并不是进程不会访问的，有时就会出现分配的页面数增多但缺页率反而提高的异常现象。出现该异常的原因是因为 FIFO 算法只考虑了页面进入内存的顺序，而没有考虑页面访问的频率和紧迫性。
    3. \n
\n

哪一种页面置换算法实际用的比较多？

\n

LRU 算法是实际使用中应用的比较多，也被认为是最接近 OPT 的页面置换算法。

\n

不过，需要注意的是，实际应用中这些算法会被做一些改进，就比如 InnoDB Buffer Pool（ InnoDB 缓冲池，MySQL 数据库中用于管理缓存页面的机制）就改进了传统的 LRU 算法，使用了一种称为"Adaptive LRU"的算法（同时结合了 LRU 和 LFU 算法的思想）。

\n

分页机制和分段机制有哪些共同点和区别？

\n

共同点：

\n\n

区别：

\n\n

段页机制

\n

结合了段式管理和页式管理的一种内存管理机制。程序视角中，内存被划分为多个逻辑段，每个逻辑段进一步被划分为固定大小的页。

\n

在段页式机制下，地址翻译的过程分为两个步骤：

\n
    \n
  1. 段式地址映射（虚拟地址 → 线性地址）：\n\n
    2. \n
  2. 页式地址映射（线性地址 → 物理地址）：\n\n
    3. \n
\n

局部性原理

\n

要想更好地理解虚拟内存技术，必须要知道计算机中著名的 局部性原理（Locality Principle）。另外，局部性原理既适用于程序结构，也适用于数据结构，是非常重要的一个概念。

\n

局部性原理是指在程序执行过程中，数据和指令的访问存在一定的空间和时间上的局部性特点。其中，时间局部性是指一个数据项或指令在一段时间内被反复使用的特点，空间局部性是指一个数据项或指令在一段时间内与其相邻的数据项或指令被反复使用的特点。

\n

在分页机制中，页表的作用是将虚拟地址转换为物理地址，从而完成内存访问。在这个过程中，局部性原理的作用体现在两个方面：

\n\n

总之，局部性原理是计算机体系结构设计的重要原则之一，也是许多优化算法的基础。在分页机制中，利用时间局部性和空间局部性，采用缓存和预取技术，可以提高页面的命中率，从而提高内存访问效率

\n

文件系统

\n

文件系统主要做了什么？

\n

文件系统主要负责管理和组织计算机存储设备上的文件和目录，其功能包括以下几个方面：

\n
    \n
  1. 存储管理：将文件数据存储到物理存储介质中，并且管理空间分配，以确保每个文件都有足够的空间存储，并避免文件之间发生冲突。
    2. \n
  2. 文件管理：文件的创建、删除、移动、重命名、压缩、加密、共享等等。
    3. \n
  3. 目录管理：目录的创建、删除、移动、重命名等等。
    4. \n
  4. 文件访问控制：管理不同用户或进程对文件的访问权限，以确保用户只能访问其被授权访问的文件，以保证文件的安全性和保密性。
    5. \n
\n

硬链接和软链接有什么区别？

\n

在 Linux/类 Unix 系统上，文件链接（File Link）是一种特殊的文件类型，可以在文件系统中指向另一个文件。常见的文件链接类型有两种：

\n

1、硬链接（Hard Link）

\n\n

2、软链接（Symbolic Link 或 Symlink）

\n\n

硬链接为什么不能跨文件系统？

\n

我们之前提到过，硬链接是通过 inode 节点号建立连接的，而硬链接和源文件共享相同的 inode 节点号。

\n

然而，每个文件系统都有自己的独立 inode 表，且每个 inode 表只维护该文件系统内的 inode。如果在不同的文件系统之间创建硬链接，可能会导致 inode 节点号冲突的问题，即目标文件的 inode 节点号已经在该文件系统中被使用。

\n

提高文件系统性能的方式有哪些？

\n\n

常见的磁盘调度算法有哪些？

\n

磁盘调度算法是操作系统中对磁盘访问请求进行排序和调度的算法，其目的是提高磁盘的访问效率。

\n

一次磁盘读写操作的时间由磁盘寻道/寻找时间、延迟时间和传输时间决定。磁盘调度算法可以通过改变到达磁盘请求的处理顺序，减少磁盘寻道时间和延迟时间。

\n

常见的磁盘调度算法有下面这 6 种（其他还有很多磁盘调度算法都是基于这些算法改进得来的）：

\n

\"常见的磁盘调度算法\"

\n
    \n
  1. 先来先服务算法（First-Come First-Served，FCFS）：按照请求到达磁盘调度器的顺序进行处理，先到达的请求的先被服务。FCFS 算法实现起来比较简单，不存在算法开销。不过，由于没有考虑磁头移动的路径和方向，平均寻道时间较长。同时，该算法容易出现饥饿问题，即一些后到的磁盘请求可能需要等待很长时间才能得到服务。
    2. \n
  2. 最短寻道时间优先算法（Shortest Seek Time First，SSTF）：也被称为最佳服务优先（Shortest Service Time First，SSTF）算法，优先选择距离当前磁头位置最近的请求进行服务。SSTF 算法能够最小化磁头的寻道时间，但容易出现饥饿问题，即磁头附近的请求不断被服务，远离磁头的请求长时间得不到响应。实际应用中，需要优化一下该算法的实现，避免出现饥饿问题。
    3. \n
  3. 扫描算法（SCAN）：也被称为电梯（Elevator）算法，基本思想和电梯非常类似。磁头沿着一个方向扫描磁盘，如果经过的磁道有请求就处理，直到到达磁盘的边界，然后改变移动方向，依此往复。SCAN 算法能够保证所有的请求得到服务，解决了饥饿问题。但是，如果磁头从一个方向刚扫描完，请求才到的话。这个请求就需要等到磁头从相反方向过来之后才能得到处理。
    4. \n
  4. 循环扫描算法（Circular Scan，C-SCAN）：SCAN 算法的变体，只在磁盘的一侧进行扫描，并且只按照一个方向扫描，直到到达磁盘边界，然后回到磁盘起点，重新开始循环。
    5. \n
  5. 边扫描边观察算法（LOOK）：SCAN 算法中磁头到了磁盘的边界才改变移动方向，这样可能会做很多无用功，因为磁头移动方向上可能已经没有请求需要处理了。LOOK 算法对 SCAN 算法进行了改进，如果磁头移动方向上已经没有别的请求，就可以立即改变磁头移动方向，依此往复。也就是边扫描边观察指定方向上还有无请求，因此叫 LOOK。
    6. \n
  6. 均衡循环扫描算法（C-LOOK）：C-SCAN 只有到达磁盘边界时才能改变磁头移动方向，并且磁头返回时也需要返回到磁盘起点，这样可能会做很多无用功。C-LOOK 算法对 C-SCAN 算法进行了改进，如果磁头移动的方向上已经没有磁道访问请求了，就可以立即让磁头返回，并且磁头只需要返回到有磁道访问请求的位置即可。
    7. \n
\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/memory-management-roles.png", "date_published": "2023-04-09T12:09:19.000Z", "date_modified": "2026-03-10T15:16:51.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "Java 20 新特性概览", "url": "https://javaguide.cn/java/new-features/java20.html", "id": "https://javaguide.cn/java/new-features/java20.html", "summary": "总结 JDK 20 的语言与并发改动，延续虚拟线程与模式匹配相关增强。", "content_html": "

JDK 20 于 2023 年 3 月 21 日发布，非长期支持版本。

\n

根据开发计划，下一个 LTS 版本就是将于 2023 年 9 月发布的 JDK 21。

\n

JDK 20 共有 7 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\"

\n

JEP 429: Scoped Values（作用域值，第一次孵化）

\n

作用域值（Scoped Values）它可以在线程内和线程间共享不可变的数据，优于线程局部变量，尤其是在使用大量虚拟线程时。

\n
final static ScopedValue<...> V = new ScopedValue<>();\n\n// In some method\nScopedValue.where(V, <value>)\n           .run(() -> { ... V.get() ... call methods ... });\n\n// In a method called directly or indirectly from the lambda expression\n... V.get() ...
\n

作用域值允许在大型程序中的组件之间安全有效地共享数据，而无需求助于方法参数。

\n

关于作用域值的详细介绍，推荐阅读作用域值常见问题解答这篇文章。

\n

JEP 432: Record Patterns（记录模式，第二次预览）

\n

记录模式（Record Patterns） 可对 record 的值进行解构，也就是更方便地从记录类（Record Class）中提取数据。并且，还可以嵌套记录模式和类型模式结合使用，以实现强大的、声明性的和可组合的数据导航和处理形式。

\n

记录模式不能单独使用，而是要与 instanceof 或 switch 模式匹配一同使用。

\n

先以 instanceof 为例简单演示一下。

\n

简单定义一个记录类：

\n
record Shape(String type, long unit){}
\n

没有记录模式之前：

\n
Shape circle = new Shape(\"Circle\", 10);\nif (circle instanceof Shape shape) {\n\n  System.out.println(\"Area of \" + shape.type() + \" is : \" + Math.PI * Math.pow(shape.unit(), 2));\n}
\n

有了记录模式之后：

\n
Shape circle = new Shape(\"Circle\", 10);\nif (circle instanceof Shape(String type, long unit)) {\n  System.out.println(\"Area of \" + type + \" is : \" + Math.PI * Math.pow(unit, 2));\n}
\n

再看看记录模式与 switch 的配合使用。

\n

定义一些类：

\n
interface Shape {}\nrecord Circle(double radius) implements Shape { }\nrecord Square(double side) implements Shape { }\nrecord Rectangle(double length, double width) implements Shape { }
\n

没有记录模式之前：

\n
Shape shape = new Circle(10);\nswitch (shape) {\n    case Circle c:\n        System.out.println(\"The shape is Circle with area: \" + Math.PI * c.radius() * c.radius());\n        break;\n\n    case Square s:\n        System.out.println(\"The shape is Square with area: \" + s.side() * s.side());\n        break;\n\n    case Rectangle r:\n        System.out.println(\"The shape is Rectangle with area: \" + r.length() * r.width());\n        break;\n\n    default:\n        System.out.println(\"Unknown Shape\");\n        break;\n}
\n

有了记录模式之后：

\n
Shape shape = new Circle(10);\nswitch(shape) {\n\n  case Circle(double radius):\n    System.out.println(\"The shape is Circle with area: \" + Math.PI * radius * radius);\n    break;\n\n  case Square(double side):\n    System.out.println(\"The shape is Square with area: \" + side * side);\n    break;\n\n  case Rectangle(double length, double width):\n    System.out.println(\"The shape is Rectangle with area: \" + length * width);\n    break;\n\n  default:\n    System.out.println(\"Unknown Shape\");\n    break;\n}
\n

记录模式可以避免不必要的转换，使得代码更简洁易读。而且，用了记录模式后不必再担心 null 或者 NullPointerException，代码更安全可靠。

\n

记录模式在 Java 19 进行了第一次预览， 由 JEP 405 提出。JDK 20 中是第二次预览，由 JEP 432 提出。这次的改进包括：

\n\n

注意：不要把记录模式和 JDK16 正式引入的记录类搞混了。

\n

JEP 433: Pattern Matching for switch（switch 模式匹配，第四次预览）

\n

正如 instanceof 一样， switch 也紧跟着增加了类型匹配自动转换功能。

\n

instanceof 代码示例：

\n
// Old code\nif (o instanceof String) {\n    String s = (String)o;\n    ... use s ...\n}\n\n// New code\nif (o instanceof String s) {\n    ... use s ...\n}
\n

switch 代码示例：

\n
// Old code\nstatic String formatter(Object o) {\n    String formatted = \"unknown\";\n    if (o instanceof Integer i) {\n        formatted = String.format(\"int %d\", i);\n    } else if (o instanceof Long l) {\n        formatted = String.format(\"long %d\", l);\n    } else if (o instanceof Double d) {\n        formatted = String.format(\"double %f\", d);\n    } else if (o instanceof String s) {\n        formatted = String.format(\"String %s\", s);\n    }\n    return formatted;\n}\n\n// New code\nstatic String formatterPatternSwitch(Object o) {\n    return switch (o) {\n        case Integer i -> String.format(\"int %d\", i);\n        case Long l    -> String.format(\"long %d\", l);\n        case Double d  -> String.format(\"double %f\", d);\n        case String s  -> String.format(\"String %s\", s);\n        default        -> o.toString();\n    };\n}
\n

switch 模式匹配分别在 Java17、Java18、Java19 中进行了预览，Java20 是第四次预览了。每一次的预览基本都会有一些小改进，这里就不细提了。

\n

JEP 434: Foreign Function & Memory API（外部函数和内存 API，第二次预览）

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。Java 18 中进行了第二次孵化，由JEP 419 提出。Java 19 中是第一次预览，由 JEP 424 提出。

\n

JDK 20 中是第二次预览，由 JEP 434 提出，这次的改进包括：

\n\n

在 Java 19 新特性概览 中，我有详细介绍到外部函数和内存 API，这里就不再做额外的介绍了。

\n

JEP 436: Virtual Threads（虚拟线程，第二次预览）

\n

虚拟线程（Virtual Thread）是 JDK 而不是 OS 实现的轻量级线程（Lightweight Process，LWP），由 JVM 调度。许多虚拟线程共享同一个操作系统线程，虚拟线程的数量可以远大于操作系统线程的数量。

\n

在引入虚拟线程之前，java.lang.Thread 包已经支持所谓的平台线程，也就是没有虚拟线程之前，我们一直使用的线程。JVM 调度程序通过平台线程（载体线程）来管理虚拟线程，一个平台线程可以在不同的时间执行不同的虚拟线程（多个虚拟线程挂载在一个平台线程上），当虚拟线程被阻塞或等待时，平台线程可以切换到执行另一个虚拟线程。

\n

虚拟线程、平台线程和系统内核线程的关系图如下所示（图源：How to Use Java 19 Virtual Threads）：

\n

\"虚拟线程、平台线程和系统内核线程的关系\"

\n

关于平台线程和系统内核线程的对应关系多提一点：在 Windows 和 Linux 等主流操作系统中，Java 线程采用的是一对一的线程模型，也就是一个平台线程对应一个系统内核线程。Solaris 系统是一个特例，HotSpot VM 在 Solaris 上支持多对多和一对一。具体可以参考 R 大的回答: JVM 中的线程模型是用户级的么？。

\n

相比较于平台线程来说，虚拟线程是廉价且轻量级的，使用完后立即被销毁，因此它们不需要被重用或池化，每个任务可以有自己专属的虚拟线程来运行。虚拟线程暂停和恢复来实现线程之间的切换，避免了上下文切换的额外耗费，兼顾了多线程的优点，简化了高并发程序的复杂，可以有效减少编写、维护和观察高吞吐量并发应用程序的工作量。

\n

虚拟线程在其他多线程语言中已经被证实是十分有用的，比如 Go 中的 Goroutine、Erlang 中的进程。

\n

知乎有一个关于 Java 19 虚拟线程的讨论，感兴趣的可以去看看：https://www.zhihu.com/question/536743167 。

\n

Java 虚拟线程的详细解读和原理可以看下面这几篇文章：

\n\n

虚拟线程在 Java 19 中进行了第一次预览，由JEP 425提出。JDK 20 中是第二次预览，做了一些细微变化，这里就不细提了。

\n

最后，我们来看一下四种创建虚拟线程的方法：

\n
// 1、通过 Thread.ofVirtual() 创建\nRunnable fn = () -> {\n  // your code here\n};\n\nThread thread = Thread.ofVirtual(fn)\n                      .start();\n\n// 2、通过 Thread.startVirtualThread() 创建\nThread thread = Thread.startVirtualThread(() -> {\n  // your code here\n});\n\n// 3、通过 Executors.newVirtualThreadPerTaskExecutor() 创建\nvar executorService = Executors.newVirtualThreadPerTaskExecutor();\n\nexecutorService.submit(() -> {\n  // your code here\n});\n\nclass CustomThread implements Runnable {\n  @Override\n  public void run() {\n    System.out.println(\"CustomThread run\");\n  }\n}\n\n//4、通过 ThreadFactory 创建\nCustomThread customThread = new CustomThread();\n// 获取线程工厂类\nThreadFactory factory = Thread.ofVirtual().factory();\n// 创建虚拟线程\nThread thread = factory.newThread(customThread);\n// 启动线程\nthread.start();
\n

通过上述列举的 4 种创建虚拟线程的方式可以看出，官方为了降低虚拟线程的门槛，尽力复用原有的 Thread 线程类，这样可以平滑的过渡到虚拟线程的使用。

\n

JEP 437: Structured Concurrency（结构化并发，第二次孵化）

\n

Java 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope。StructuredTaskScope 支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n

JDK 20 中对结构化并发唯一变化是更新为支持在任务范围内创建的线程StructuredTaskScope继承范围值 这简化了跨线程共享不可变数据，详见JEP 429。

\n

JEP 438: Vector API（向量 API，第五次孵化）

\n

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

\n

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

\n

向量（Vector） API 最初由 JEP 338 提出，并作为孵化 API集成到 Java 16 中。第二轮孵化由 JEP 414 提出并集成到 Java 17 中，第三轮孵化由 JEP 417 提出并集成到 Java 18 中，第四轮由 JEP 426 提出并集成到了 Java 19 中。

\n

Java20 的这次孵化基本没有改变向量 API ，只是进行了一些错误修复和性能增强，详见 JEP 438。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2023-03-27T07:25:00.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "从校招入职腾讯的四年工作总结", "url": "https://javaguide.cn/high-quality-technical-articles/personal-experience/four-year-work-in-tencent-summary.html", "id": "https://javaguide.cn/high-quality-technical-articles/personal-experience/four-year-work-in-tencent-summary.html", "summary": "从校招入职腾讯的四年工作总结：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "

程序员是一个流动性很大的职业，经常会有新面孔的到来，也经常会有老面孔的离开，有主动离开的，也有被动离职的。

\n

再加上这几年卷得厉害，做的事更多了，拿到的却更少了，互联网好像也没有那么香了。

\n

人来人往，变动无常的状态，其实也早已习惯。

\n

打工人的唯一出路，无外乎精进自己的专业技能，提升自己的核心竞争力，这样无论有什么变动，走到哪里，都能有口饭吃。

\n

今天分享一位博主，校招入职腾讯，工作四年后，离开的故事。

\n

至于为什么离开，我也不清楚，可能是有其他更好的选择，或者是觉得当前的工作对自己的提升有限。

\n

下文中的“我”，指这位作者本人。

\n
\n

原文地址：https://zhuanlan.zhihu.com/p/602517682

\n
\n

研究生毕业后， 一直在腾讯工作，不知不觉就过了四年。个人本身没有刻意总结的习惯，以前只顾着往前奔跑了，忘了停下来思考总结。记得看过一个职业规划文档，说的三年一个阶段，五年一个阶段的说法，现在恰巧是四年，同时又从腾讯离开，该做一个总结了。

\n

先对自己这四年做一个简单的评价吧：个人认为，没有完全的浪费和辜负这四年的光阴。为何要这么说了？因为我发现和别人对比，好像意义不大，比我混的好的人很多；比我混的差的人也不少。说到底，我只是一个普普通通的人，才不惊人，技不压众，接受自己的平凡，然后看自己做的，是否让自己满意就好。

\n

下面具体谈几点吧，我主要想聊下工作，绩效，EPC，嫡系看法，最后再谈下收获。

\n

工作情况

\n

我在腾讯内部没有转过岗，但是做过的项目也还是比较丰富的，包括：BUGLY、分布式调用链（Huskie)、众包系统（SOHO)，EPC 度量系统。其中一些是对外的，一些是内部系统，可能有些大家不知道。还是比较感谢这些项目经历，既有纯业务的系统，也有偏框架的系统，让我学到了不少知识。

\n

接下来，简单介绍一下每个项目吧，毕竟每一个项目都付出了很多心血的：

\n

BUGLY，这是一个终端 Crash 联网上报的系统，很多 APP 都接入了。Huskie，这是一个基于 zipkin 搭建的分布式调用链跟踪项目。SOHO，这是一个众包系统，主要是将数据标准和语音采集任务众包出去，让人家做。EPC 度量系统，这是研发效能度量系统，主要是度量研发效能情况的。这里我谈一下对于业务开发的理解和认识，很多人可能都跟我最开始一样，有一个疑惑，整天做业务开发如何成长？换句话说，就是说整天做 CRUD，如何成长？我开始也有这样的疑惑，后来我转变了观念。

\n

我觉得对于系统的复杂度，可以粗略的分为技术复杂度和业务复杂度，对于业务系统，就是业务复杂度高一些，对于框架系统就是技术复杂度偏高一些。解决这两种复杂度，都具有很大的挑战。

\n

此前做过的众包系统，就是各种业务逻辑，搞过去，搞过来，其实这就是业务复杂度高。为了解决这个问题，我们开始探索和实践领域驱动（DDD），确实带来了一些帮助，不至于系统那么混乱了。同时，我觉得这个过程中，自己对于 DDD 的感悟，对于我后来的项目系统划分和设计以及开发都带来了帮助。

\n

当然 DDD 不是银弹，我也不是吹嘘它有多好，只是了解了它后，有时候设计和开发时，能换一种思路。

\n

可以发现，其实平时咱们做业务，想做好，其实也没那么容易，如果可以多探索多实践，将一些好的方法或思想或架构引入进来，与个人和业务都会有有帮助。

\n

绩效情况

\n

我在腾讯工作四年，腾讯半年考核一次，一共考核八次，回想了下，四年来的绩效情况为:三星，三星，五星，三星，五星，四星，四星，三星。统计一下， 四五星占比刚好一半。

\n

\n

PS：还好以前有奖杯，不然一点念想都没了。(现在腾讯似乎不发了）

\n

印象比较深的是两次五星获得经历。第一次五星是工作的第二年，那一年是在做众包项目，因为项目本身难度不大，因此我把一些精力投入到了团队的基础建设中，帮团队搭建了 java 以及 golang 的项目脚手架，又做了几次中心技术分享，最终 Leader 觉得我表现比较突出，因此给了我五星。看来，主动一些，与个人与团队都是有好处的，最终也能获得一些回报。

\n

第二次五星，就是与 EPC 有关了。说一个搞笑的事，我也是后来才知道的，项目初期，总监去汇报时，给老板演示系统，加载了很久指标才刷出来，总监很不好意思的说正在优化；过了一段时间，又去汇报演示，结果又很尴尬的刷了很久才出来，总监无赖表示还是在优化。没想到，自己曾经让总监这么丢脸，哈哈。好吧，说一下结果，最终，我自己写了一个查询引擎替换了 Mondrian，之后再也没有出现那种尴尬的情况了。随之而来，也给了好绩效鼓励。做 EPC 度量项目，我觉得自己成长很大，比如抗压能力，当你从零到一搭建一个系统时，会有一个先扛住再优化的过程，此外如果你的项目很重要，尤其是数据相关，那么任何一点问题，都可能让你神经紧绷，得想尽办法降低风险和故障。此外，另一个不同的感受就是，以前得项目，我大多是开发者，而这个系统，我是 Owner 负责人，当你 Owner 一个系统时，你得时刻负责，同时还需要思考系统的规划和方向，此外还需要分配好需求和把控进度，角色体验跟以前完全不一样。

\n

谈谈 EPC

\n

很多人都骂 EPC，或者笑 EPC，作为度量平台核心开发者之一，我来谈谈客观的看法。

\n

其实 EPC 初衷是好的，希望通过全方位多维度的研效指标，来度量研发效能各环节的质量，进而反推业务，提升研发效能。然而，最终在实践的过程中，才发现，客观条件并不支持（工具还没建设好）；此外，一味的追求指标数据，使得下面的人想方设法让指标好看，最终违背了初衷。

\n

为什么，说 EPC 好了，其实如果你仔细了解下 EPC，你就会发现，他是一套相当完善且比较先进的指标度量体系。覆盖了需求，代码，缺陷，测试，持续集成，运营部署各个环节。

\n

此外，这个过程中，虽然一些人和一些业务做弊，但绝大多数业务还是做出了改变的，比如微视那边的人反馈是，以前的代码写的跟屎一样，当有了 EPC 后，代码质量好了很多。虽然最后微视还是亡了，但是大厦将倾，EPC 是救不了的，亡了也更不能怪 EPC。

\n

谈谈嫡系

\n

大家都说腾讯，嫡系文化盛行。但其实我觉得在那个公司都一样吧。这也符合事物的基本规律，人们只相信自己信任并熟悉的人。作为领导，你难道会把把重要的事情交给自己不熟悉的人吗？

\n

其实我也不知道我算不算嫡系，脉脉上有人问过”怎么知道自己算不算嫡系”，下面有一个回答，我觉得很妙：如果你不知道你是不是嫡系，那你就不是。哈哈，这么说来，我可能不是。

\n

但另一方面，后来我负责了团队内很重要的事情，应该是中心内都算很重要的事，我独自负责一个方向，直接向总监汇报，似乎又有点像。

\n

网上也有其他说法，一针见血，是不是嫡系，就看钱到不到位，这么说也有道理。我在 7 级时，就发了股票，自我感觉，还是不错的。我当时以为不出意外的话，我以后的钱途和发展是不是就会一帆风顺。不出意外就出了意外，第二年，EPC 不达预期，部门总经理和总监都被换了，中心来了一个新的总监。

\n

好吧，又要重新建立信任了。再到后来，是不是嫡系已经不重要了，因为大环境不好，又加上裁员，大家主动的被动的差不多都走了。

\n

总结一下，嫡系的存在，其实情有可原。怎么样成为嫡系了？其实我也不知道。不过，我觉得，与其思考怎么成为嫡系，不如思考怎么展现自己的价值和能力，当别人发现你的价值和能力了，那自然更多的机会就会给予你，有了机会，只要把握住了，那就有更多的福利了。

\n

再谈收获

\n

收获，什么叫做收获了？个人觉得无论是外在的物质，技能，职级；还是内在的感悟，认识，都算收获。

\n

先说一些可量化的吧，我觉得有:

\n\n

1、文档能力

\n

作为程序员，文档能力其实是一项很重要的能力。其实我也没觉得自己文档能力有多好，但是前后两任总监，都说我的文档不错，那看来，我可能在平均水准之上。

\n

2、明确方向

\n

最后，说一个更虚的，但是我觉得最有价值的收获: 我逐渐明确了，或者确定了以后的方向和路，那就是走数据开发。

\n

其实，找到并确定一个目标很难，身边有清晰目标和方向的人很少，大多数是迷茫的。

\n

前一段时间，跟人聊天，谈到职业规划，说是可以从两个角度思考：

\n\n

腾讯的四年，是我的第一份工作经历，认识了很多厉害的人，学到了很多。最后自己主动离开，也算走的体面（即使损失了大礼包），还是感谢腾讯。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/high-quality-technical-articles/640.png", "date_published": "2023-03-24T11:23:46.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [ { "name": "pioneeryi" } ], "tags": [ "技术文章精选集" ] }, { "title": "Redis持久化机制详解", "url": "https://javaguide.cn/database/redis/redis-persistence.html", "id": "https://javaguide.cn/database/redis/redis-persistence.html", "summary": "深入解析Redis三种持久化机制RDB快照、AOF日志和混合持久化的工作原理、配置方法和优缺点对比，帮助你选择适合业务场景的持久化策略。", "content_html": "

使用缓存的时候，我们经常需要对内存中的数据进行持久化也就是将内存中的数据写入到硬盘中。大部分原因是为了之后重用数据（比如重启机器、机器故障之后恢复数据），或者是为了做数据同步（比如 Redis 集群的主从节点通过 RDB 文件同步数据）。

\n

Redis 不同于 Memcached 的很重要一点就是，Redis 支持持久化，而且支持 3 种持久化方式:

\n\n

官方文档地址：https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/ 。

\n

\n

本文基于 Redis 7.0+ 版本。不同版本的持久化机制有重要差异，使用前请确认你的 Redis 版本：

\n

| 版本 | 持久化默认方式 | 重要特性 |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/redis/redis4.0-persitence.png", "date_published": "2023-03-23T13:09:30.000Z", "date_modified": "2026-04-06T06:53:34.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "Redis常见阻塞原因总结", "url": "https://javaguide.cn/database/redis/redis-common-blocking-problems-summary.html", "id": "https://javaguide.cn/database/redis/redis-common-blocking-problems-summary.html", "summary": "全面总结Redis常见的阻塞原因，包括O(n)复杂度命令、bigkey操作、AOF日志刷盘、RDB快照创建、主从同步等场景，帮助你排查和预防Redis性能问题。", "content_html": "

\"JavaGuide官方知识星球\"

\n
\n

本文整理完善自：https://mp.weixin.qq.com/s/0Nqfq_eQrUb12QH6eBbHXA ，作者：阿 Q 说代码

\n
\n

这篇文章会详细总结一下可能导致 Redis 阻塞的情况，这些情况也是影响 Redis 性能的关键因素，使用 Redis 的时候应该格外注意！

\n

O(n) 命令

\n

Redis 中的大部分命令都是 O(1)时间复杂度，但也有少部分 O(n) 时间复杂度的命令，例如：

\n\n

由于这些命令时间复杂度是 O(n)，有时候也会全表扫描，随着 n 的增大，执行耗时也会越长，从而导致客户端阻塞。不过， 这些命令并不是一定不能使用，但是需要明确 N 的值。另外，有遍历的需求可以使用 HSCAN、SSCAN、ZSCAN 代替。

\n

除了这些 O(n)时间复杂度的命令可能会导致阻塞之外， 还有一些时间复杂度可能在 O(N) 以上的命令，例如：

\n\n

SAVE 创建 RDB 快照

\n

Redis 提供了两个命令来生成 RDB 快照文件：

\n\n

默认情况下，Redis 默认配置会使用 bgsave 命令。如果手动使用 save 命令生成 RDB 快照文件的话，就会阻塞主线程。

\n

AOF

\n

AOF 日志记录阻塞

\n

Redis AOF 持久化机制是在执行完命令之后再记录日志，这和关系型数据库（如 MySQL）通常都是执行命令之前记录日志（方便故障恢复）不同。

\n

\"AOF

\n

为什么是在执行完命令之后记录日志呢？

\n\n

这样也带来了风险（我在前面介绍 AOF 持久化的时候也提到过）：

\n\n

AOF 刷盘阻塞

\n

开启 AOF 持久化后每执行一条会更改 Redis 中的数据的命令，Redis 就会将该命令写入到 AOF 缓冲区 server.aof_buf 中，然后再根据 appendfsync 配置来决定何时将其同步到硬盘中的 AOF 文件。

\n

在 Redis 的配置文件中存在三种不同的 AOF 持久化方式（ fsync策略），它们分别是：

\n
    \n
  1. appendfsync always：主线程调用 write 执行写操作后，主线程立即会调用 fsync 函数同步 AOF 文件（刷盘），fsync 完成后线程返回。always 策略由主线程直接执行 fsync，而非后台线程。这种方式数据最安全，但每个写操作都会同步阻塞主线程，严重降低 Redis 的性能（write + fsync）。
    2. \n
  2. appendfsync everysec：主线程调用 write 执行写操作后立即返回，由后台线程（ aof_fsync 线程）每秒钟调用 fsync 函数（系统调用）同步一次 AOF 文件（write+fsync，fsync间隔为 1 秒）
    3. \n
  3. appendfsync no：主线程调用 write 执行写操作后立即返回，让操作系统决定何时进行同步，Linux 下一般为 30 秒一次（write但不fsync，fsync 的时机由操作系统决定）。
    4. \n
\n

当后台线程（ aof_fsync 线程）调用 fsync 函数同步 AOF 文件时，需要等待，直到写入完成。当磁盘压力太大的时候，会导致 fsync 操作发生阻塞，主线程调用 write 函数时也会被阻塞。fsync 完成后，主线程执行 write 才能成功返回。

\n

关于 AOF 工作流程的详细介绍可以查看：Redis 持久化机制详解，有助于理解 AOF 刷盘阻塞。

\n

AOF 重写阻塞

\n
    \n
  1. fork 出一条子线程来将文件重写，在执行 BGREWRITEAOF 命令时，Redis 服务器会维护一个 AOF 重写缓冲区，该缓冲区会在子线程创建新 AOF 文件期间，记录服务器执行的所有写命令。
    2. \n
  2. 当子线程完成创建新 AOF 文件的工作之后，服务器会将重写缓冲区中的所有内容追加到新 AOF 文件的末尾，使得新的 AOF 文件保存的数据库状态与现有的数据库状态一致。
    3. \n
  3. 最后，服务器用新的 AOF 文件替换旧的 AOF 文件，以此来完成 AOF 文件重写操作。
    4. \n
\n

阻塞就是出现在第 2 步的过程中，将缓冲区中新数据写到新文件的过程中会产生阻塞。

\n

相关阅读：Redis AOF 重写阻塞问题分析。

\n

大 Key

\n

如果一个 key 对应的 value 所占用的内存比较大，那这个 key 就可以看作是 bigkey。具体多大才算大呢？有一个不是特别精确的参考标准：

\n\n

大 key 造成的阻塞问题如下：

\n\n

查找大 key

\n

当我们在使用 Redis 自带的 --bigkeys 参数查找大 key 时，最好选择在从节点上执行该命令，因为主节点上执行时，会阻塞主节点。

\n\n

删除大 key

\n

删除操作的本质是要释放键值对占用的内存空间。

\n

释放内存只是第一步，为了更加高效地管理内存空间，在应用程序释放内存时，操作系统需要把释放掉的内存块插入一个空闲内存块的链表，以便后续进行管理和再分配。这个过程本身需要一定时间，而且会阻塞当前释放内存的应用程序。

\n

所以，如果一下子释放了大量内存，空闲内存块链表操作时间就会增加，相应地就会造成 Redis 主线程的阻塞，如果主线程发生了阻塞，其他所有请求可能都会超时，超时越来越多，会造成 Redis 连接耗尽，产生各种异常。

\n

删除大 key 时建议采用分批次删除和异步删除的方式进行。

\n

清空数据库

\n

清空数据库和上面 bigkey 删除也是同样道理，flushdb、flushall 也涉及到删除和释放所有的键值对，也是 Redis 的阻塞点。

\n

集群扩容

\n

Redis 集群可以进行节点的动态扩容缩容，这一过程目前还处于半自动状态，需要人工介入。

\n

在扩缩容的时候，需要进行数据迁移。而 Redis 为了保证迁移的一致性，迁移所有操作都是同步操作。

\n

执行迁移时，两端的 Redis 均会进入时长不等的阻塞状态，对于小 Key，该时间可以忽略不计，但如果一旦 Key 的内存使用过大，严重的时候会触发集群内的故障转移，造成不必要的切换。

\n

Swap（内存交换）

\n

什么是 Swap？ Swap 直译过来是交换的意思，Linux 中的 Swap 常被称为内存交换或者交换分区。类似于 Windows 中的虚拟内存，就是当内存不足的时候，把一部分硬盘空间虚拟成内存使用，从而解决内存容量不足的情况。因此，Swap 分区的作用就是牺牲硬盘，增加内存，解决 VPS 内存不够用或者爆满的问题。

\n

Swap 对于 Redis 来说是非常致命的，Redis 保证高性能的一个重要前提是所有的数据在内存中。如果操作系统把 Redis 使用的部分内存换出硬盘，由于内存与硬盘的读写速度差几个数量级，会导致发生交换后的 Redis 性能急剧下降。

\n

识别 Redis 发生 Swap 的检查方法如下：

\n

1、查询 Redis 进程号

\n
redis-cli -p 6383 info server | grep process_id\nprocess_id: 4476
\n

2、根据进程号查询内存交换信息

\n
cat /proc/4476/smaps | grep Swap\nSwap: 0kB\nSwap: 0kB\nSwap: 4kB\nSwap: 0kB\nSwap: 0kB\n.....
\n

如果交换量都是 0KB 或者个别的是 4KB，则正常。

\n

预防内存交换的方法：

\n\n

CPU 竞争

\n

Redis 是典型的 CPU 密集型应用，不建议和其他多核 CPU 密集型服务部署在一起。当其他进程过度消耗 CPU 时，将严重影响 Redis 的吞吐量。

\n

可以通过redis-cli --stat获取当前 Redis 使用情况。通过top命令获取进程对 CPU 的利用率等信息 通过info commandstats统计信息分析出命令不合理开销时间，查看是否是因为高算法复杂度或者过度的内存优化问题。

\n

网络问题

\n

连接拒绝、网络延迟，网卡软中断等网络问题也可能会导致 Redis 阻塞。

\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/database/redis/redis-aof-write-log-disc.png", "date_published": "2023-03-23T10:25:39.000Z", "date_modified": "2026-04-06T06:53:48.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "MySQL查询缓存详解", "url": "https://javaguide.cn/database/mysql/mysql-query-cache.html", "id": "https://javaguide.cn/database/mysql/mysql-query-cache.html", "summary": "深入解析MySQL查询缓存的工作原理、配置管理及其优缺点，分析为什么MySQL 8.0移除了查询缓存功能，以及生产环境中的最佳实践建议。", "content_html": "

缓存是一个有效且实用的系统性能优化手段，无论是操作系统，还是各类应用软件与 Web 服务，均广泛采用了缓存机制。

\n

然而，有经验的 DBA 都建议生产环境中把 MySQL 自带的 Query Cache（查询缓存）给关掉。而且，从 MySQL 5.7.20 开始，就已经默认弃用查询缓存了。在 MySQL 8.0 及之后，更是直接删除了查询缓存的功能。

\n

这又是为什么呢？查询缓存真就这么鸡肋么?

\n

带着如下几个问题，我们正式进入本文。

\n\n

MySQL 查询缓存介绍

\n

MySQL 体系架构如下图所示：

\n

\n

为了提高完全相同的查询语句的响应速度，MySQL Server 会对查询语句进行 Hash 计算得到一个 Hash 值。MySQL Server 不会对 SQL 做任何处理，SQL 必须完全一致 Hash 值才会一样。得到 Hash 值之后，通过该 Hash 值到查询缓存中匹配该查询的结果。

\n\n

也就是说，一个查询语句（select）到了 MySQL Server 之后，会先到查询缓存看看，如果曾经执行过的话，就直接返回结果集给客户端。

\n

\n

MySQL 查询缓存管理和配置

\n

通过 show variables like '%query_cache%'命令可以查看查询缓存相关的信息。

\n

8.0 版本之前的话，打印的信息可能是下面这样的：

\n
mysql> show variables like '%query_cache%';\n+
\n
", "image": "https://oss.javaguide.cn/github/javaguide/mysql/mysql-architecture.png", "date_published": "2023-03-16T03:33:45.000Z", "date_modified": "2026-03-10T15:16:51.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "程序员的技术成长战略", "url": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/the-growth-strategy-of-the-technological-giant.html", "id": "https://javaguide.cn/high-quality-technical-articles/advanced-programmer/the-growth-strategy-of-the-technological-giant.html", "summary": "程序员的技术成长战略：围绕技术知识与面试总结梳理关键概念、常见问题与实践要点，帮助你高效学习与备战面试。", "content_html": "
\n

推荐语：波波老师的一篇文章，写的非常好，不光是对技术成长有帮助，其他领域也是同样适用的！建议反复阅读，形成一套自己的技术成长策略。

\n

原文地址： https://mp.weixin.qq.com/s/YrN8T67s801-MRo01lCHXA

\n
\n

1. 前言

\n

在波波的微信技术交流群里头，经常有学员问关于技术人该如何学习成长的问题，虽然是微信交流，但我依然可以感受到小伙伴们焦虑的心情。

\n

技术人为啥焦虑？ 恕我直言，说白了是胆识不足格局太小。胆就是胆量，焦虑的人一般对未来的不确定性怀有恐惧。识就是见识，焦虑的人一般看不清楚周围世界，也看不清自己和适合自己的道路。格局也称志向，容易焦虑的人通常视野窄志向小。如果从战略和管理的视角来看，就是对自己和周围世界的认知不足，没有一个清晰和长期的学习成长战略，也没有可执行的阶段性目标计划+严格的执行。

\n

因为问此类问题的学员很多，让我感觉有点烦了，为了避免重复回答，所以我专门总结梳理了这篇长文，试图统一来回答这类问题。如果后面还有学员问类似问题，我会引导他们来读这篇文章，然后让他们用三个月、一年甚至更长的时间，去思考和回答这样一个问题：你的技术成长战略究竟是什么？ 如果你想清楚了这个问题，有清晰和可落地的答案，那么恭喜你，你只需按部就班执行就好，根本无需焦虑，你实现自己的战略目标并做出成就只是一个时间问题；否则，你仍然需要通过不断磨炼+思考，务必去搞清楚这个人生的大问题！！！

\n

下面我们来看一些行业技术大牛是怎么做的。

\n

二. 跟技术大牛学成长战略

\n

我们知道软件设计是有设计模式(Design Pattern)的，其实技术人的成长也是有成长模式(Growth Pattern)的。波波经常在 Linkedin 上看一些技术大牛的成长履历，探究其中的成长模式，从而启发制定自己的技术成长战略。

\n

当然，很少有技术大牛会清晰地告诉你他们的技术成长战略，以及每一年的细分落地计划。但是，这并不妨碍我们通过他们的过往履历和产出成果，去溯源他们的技术成长战略。实际上， 越是牛逼的技术人，他们的技术成长战略和路径越是清晰，我们越容易从中探究出一些成功的模式。

\n

2.1 系统性能专家案例

\n

国内的开发者大都热衷于系统性能优化，有些人甚至三句话离不开高性能/高并发，但真正能深入这个领域，做到专家级水平的却寥寥无几。

\n

我这边要特别介绍的这个技术大牛叫 Brendan Gregg ，他是系统性能领域经典书《System Performance: Enterprise and the Cloud》(中文版《性能之巅：洞悉系统、企业和云计算》)的作者，也是著名的性能分析利器火焰图(Flame Graph)的作者。

\n

Brendan Gregg 之前是 Netflix 公司的高级性能架构师，在 Netflix 工作近 7 年。2022 年 4 月，他离开了 Netflix 去了 Intel，担任院士职位。

\n

\n

总体上，他已经在系统性能领域深耕超过 10 年，Brendan Gregg 的过往履历可以在 linkedin 上看到。在这 10 年间，除了书籍以外，Brendan Gregg 还产出了超过上百份和系统性能相关的技术文档，演讲视频/ppt，还有各种工具软件，相关内容都整整齐齐地分享在他的技术博客上，可以说他是一个非常高产的技术大牛。

\n

\"性能工具\"

\n

上图来自 Brendan Gregg 的新书《BPF Performance Tools: Linux System and Application Observability》。从这个图可以看出，Brendan Gregg 对系统性能领域的掌握程度，已经深挖到了硬件、操作系统和应用的每一个角落，可以说是 360 度无死角，整个计算机系统对他来说几乎都是透明的。波波认为，Brendan Gregg 是名副其实的，世界级的，系统性能领域的大神级人物。

\n

2.2 从开源到企业案例

\n

我要分享的第二个技术大牛是 Jay Kreps，他是知名的开源消息中间件 Kafka 的创始人/架构师，也是 Confluent 公司的联合创始人和 CEO，Confluent 公司是围绕 Kafka 开发企业级产品和服务的技术公司。

\n

从Jay Kreps 的 Linkedin 的履历上我们可以看出，Jay Kreps 之前在 Linkedin 工作了 7 年多(2007.6 ~ 2014. 9)，从高级工程师、工程主管，一直做到首席资深工程师。Kafka 大致是在 2010 年，Jay Kreps 在 Linkedin 发起的一个项目，解决 Linkedin 内部的大数据采集、存储和消费问题。之后，他和他的团队一直专注 Kafka 的打磨，开源(2011 年初)和社区生态的建设。

\n

到 2014 年底，Kafka 在社区已经非常成功，有了一个比较大的用户群，于是 Jay Kreps 就和几个早期作者一起离开了 Linkedin，成立了Confluent 公司，开始了 Kafka 和周边产品的企业化服务道路。今年(2020.4 月)，Confluent 公司已经获得 E 轮 2.5 亿美金融资，公司估值达到 45 亿美金。从 Kafka 诞生到现在，Jay Kreps 差不多在这个产品和公司上投入了整整 10 年。

\n

\"Confluent创始人三人组\"

\n

上图是 Confluent 创始人三人组，一个非常有意思的组合，一个中国人(左)，一个印度人(右)，中间的 Jay Kreps 是美国人。

\n

我之所以对 Kafka 和 Jay Kreps 的印象特别深刻，是因为在 2012 年下半年，我在携程框架部也是专门搞大数据采集的，我还开发过一套功能类似 Kafka 的 Log Collector + Agent 产品。我记得同时期有不止 4 个同类型的开源产品：Facebook Scribe、Apache Chukwa、Apache Flume 和 Apache Kafka。现在回头看，只有 Kafka 走到现在发展得最好，这个和创始人的专注和持续投入是分不开的，当然背后和几个创始人的技术大格局也是分不开的。

\n

当年我对战略性思维几乎没有概念，还处在什么技术都想学、认为各种项目做得越多越牛的阶段。搞了半年的数据采集以后，我就掉头搞其它“更有趣的”项目去了(从这个事情的侧面，也可以看出我当年的技术格局是很小的)。中间我陆续关注过 Jay 的一些创业动向，但是没想到他能把 Confluent 公司发展到目前这个规模。现在回想，其实在十年前，Jay Kreps 对自己的技术成长就有比较明确的战略性思考，也具有大的技术格局和成事的一些必要特质。Jay Kreps 和 Kafka 给我上了一堂生动的技术战略和实践课。

\n

2.3 技术媒体大 V 案例

\n

介绍到这里，有些同学可能会反驳说：波波你讲的这些大牛都是学历背景好，功底扎实起点高，所以他们才更能成功。其实不然，这里我再要介绍一位技术媒体界的大 V 叫 Brad Traversy，大家可以看他的 Linkedin 简历，背景很一般，学历差不多是一个非正规的社区大学(相当于大专)，没有正规大厂工作经历，有限几份工作一直是在做网站外包。

\n

\n

但是！！！Brad Traversy 目前是技术媒体领域的一个大 V，当前他在 Youtube 上的频道有 138 万多的订阅量，10 年累计输出 Web 开发和编程相关教学视频超过 800 个。Brad Traversy 也是 Udemy 上的一个成功讲师，目前已经在 Udemy 上累计输出课程 19 门，购课学生数量近 42 万。

\n

\n

Brad Traversy 目前是自由职业者，他的 Youtube 广告+Udemy 课程的收入相当不错。

\n

就是这样一位技术媒体大 V，你很难想象，在年轻的时候，贴在他身上的标签是：不良少年，酗酒，抽烟，吸毒，纹身，进监狱。。。直

\n

到结婚后的第一个孩子诞生，他才开始担起责任做出改变，然后凭借对技术的一腔热情，开始在 Youtube 平台上持续输出免费课程。从此他找到了适合自己的战略目标，然后人生开始发生各种积极的变化。。。如果大家对 Brad Traversy 的过往经历感兴趣，推荐观看他在 Youtube 上的自述视频《My Struggles & Success》。

\n

\"My

\n

我粗略浏览了Brad Traversy 在 Youtube 上的所有视频，10 年总计输出 800+视频，平均每年 80+。第一个视频提交于 2010 年 8 月，刚开始几年几乎没有订阅量，2017 年 1 月订阅量才到 50k，这中间差不多隔了 6 年。2017.10 月订阅量猛增到 200k，2018 年 3 月订阅量到 300k。当前 2021.1 月，订阅量达到 138 万。可以认为从 2017 开始，也就是在积累了 6 ～ 7 年后，他的订阅量开始出现拐点。如果把这些数据画出来，将会是一条非常漂亮的复利曲线。

\n

2.4 案例小结

\n

Brendan Gregg，Jay Kreps 和 Brad Traversy 三个人走的技术路线各不相同，但是他们的成功具有共性或者说模式：

\n

1、找到了适合自己的长期战略目标。

\n\n

2、专注深耕一个(或有限几个相关的)细分领域(Niche)，保持定力，不随便切换领域。

\n\n

3、长期投入，三人都持续投入了 10 年。

\n

4、年度细分计划+持续可量化的价值产出(Persistent & Measurable Value Output)。

\n\n

5、以终为始是牛人和普通人的一大区别。

\n

普通人通常走一步算一步，很少长远规划。牛人通 常是先有远大目标，然后采用倒推法，将大目标细化到每年/月/周的详细落地计划。Brendan Gregg，Jay Kreps 和 Brad Traversy 三人都是以终为始的典型。

\n

\"以终为始\"

\n

上面总结了几位技术大牛的成长模式，其中一个重点就是：这些大牛的成长都是通过 持续有价值产出(Persistent Valuable Output) 来驱动的。持续产出为啥如此重要，这个还要从下面的学习金字塔说起。

\n

三、学习金字塔和刻意训练

\n

\"学习金字塔\"

\n

学习金字塔是美国缅因州国家训练实验室的研究成果，它认为：

\n
\n
    \n
  1. 我们平时上课听讲之后，学习内容平均留存率大致只有 5%左右；
    2. \n
  2. 书本阅读的平均留存率大致只有 10%左右；
    3. \n
  3. 学习配上视听效果的课程，平均留存率大致在 20%左右；
    4. \n
  4. 老师实际动手做实验演示后的平均留存率大致在 30%左右；
    5. \n
  5. 小组讨论(尤其是辩论后)的平均留存率可以达到 50%左右；
    6. \n
  6. 在实践中实际应用所学之后，平均留存率可以达到 75%左右；
    7. \n
  7. 在实践的基础上，再把所学梳理出来，转而再传授给他人后，平均留存率可以达到 90%左右。
    8. \n
\n
\n

上面列出的 7 种学习方法，前四种称为 被动学习 ，后三种称为 主动学习。

\n

拿学游泳做个类比，被动学习相当于你看别人游泳，而主动学习则是你自己要下水去游。我们知道游泳或者跑步之类的运动是要燃烧身体卡路里的，这样才能达到锻炼身体和长肌肉的效果(肌肉是卡路里燃烧的结果)。如果你只是看别人游泳，自己不实际去游，是不会长肌肉的。同样的，主动学习也是要燃烧脑部卡路里的，这样才能达到训练大脑和长脑部“肌肉”的效果。

\n

我们也知道，燃烧身体的卡路里，通常会让人感觉不舒适，如果燃烧身体卡路里会让人感觉舒适的话，估计这个世界上应该不会有胖子这类人。同样，燃烧脑部卡路里也会让人感觉不适、紧张、出汗或语无伦次，如果燃烧脑部卡路里会让人感觉舒适的话，估计这个世界上人人都很聪明，人人都能发挥最大潜能。当然，这些不舒适是短期的，长期会使你更健康和聪明。波波一直认为， 人与人之间的先天身体其实都差不多，但是后天身体素质和能力有差异，这些差异，很大程度是由后天对身体和大脑的训练质量、频度和强度所造成的。

\n

明白这个道理之后，心智成熟和自律的人就会对自己进行持续地 刻意训练 。这个刻意训练包括对身体的训练，比如波波现在每天坚持跑步 3km，走 3km，每天做 60 个仰卧起坐，5 分钟平板撑等等，每天保持让身体燃烧一定量的卡路里。刻意训练也包括对大脑的训练，比如波波现在每天做项目写代码 coding(训练脑+手)，平均每天在 B 站上输出十分钟免费视频(训练脑+口头表达)，另外有定期总结输出公众号文章(训练脑+文字表达)，还有每天打半小时左右的平衡球(下图)或古墓丽影游戏(训练小脑+手)，每天保持让大脑燃烧一定量的卡路里，并保持一定强度(适度不适感)。

\n

\"平衡球游戏\"

\n

关于刻意训练的专业原理和方法论，推荐看书籍《刻意练习》。

\n

\"刻意练习\"

\n

注意，如果你平时从来不做举重锻炼的，那么某天突然做举重会很不适应甚至受伤。脑部训练也是一样的，如果你从来没有做过视频输出，那么刚开始做会很不适应，做出来的视频质量会很差。不过没有关系，任何训练都是一个循序渐进，不断强化的过程。等大脑相关区域的"肌肉"长出来以后，会逐步进入正循环，后面会越来越顺畅，相关"肌肉"会越来越发达。所以，和健身一样，健脑也不能遇到困难就放弃，需要循序渐进(Incremental)+持续地(Persistent)刻意训练。

\n

理解了学习金字塔和刻意训练以后，现在再来看 Brendan Gregg，Jay Kreps 和 Brad Traversy 这些大牛的做法，他们的学习成长都是建立在持续有价值产出的基础上的，这些产出都是刻意训练+燃烧脑部卡路里的成果。他们的产出要么是建立在实践基础上的产出，例如 Jay Kreps 的 Kafka 开源项目和 Confluent 公司；要么是在实践的基础上，再整理传授给其他人的产出，例如，Brendan Greeg 的技术演讲 ppt/视频，书籍，还有 Brad Traversy 的教学视频等等。换句话说，他们一直在学习金字塔的 5 ～ 7 层主动和高效地学习。并且，他们的学习产出还可以获得用户使用，有客户价值(Customer Value)，有用户就有反馈和度量。记住，有反馈和度量的学习，也称闭环学习，它是能够不断改进提升的；反之，没有反馈和度量的学习，无法改进提升。

\n

现在，你也应该明白，晒个书单秀个技能图谱很简单，读个书上个课也不难。但是要你给出 5 ～ 10 年的总体技术成长战略，再基于这个战略给出每年的细分落地计划(尤其是产出计划)，然后再严格按计划执行，这的确是很难的事情。这需要大量的实践训练+深度思考，要燃烧大量的脑部卡路里！但这是上天设置的进化法则，成长为真正的技术大牛如同成长为一流的运动员，是需要通过燃烧与之相匹配量的卡路里来交换的。成长为真正的技术大牛，也是需要通过产出与之匹配的社会价值来交换的，只有这样社会才能正常进化。你推进了社会进化，社会才会回馈你。如果不是这样，社会就无法正常进化。

\n

四、战略思维的诞生

\n

\"思考周期和机会点\"

\n

一般毕业生刚进入企业工作的时候，思考大都是以天/星期/月为单位的，基本上都是今天学个什么技术，明天学个什么语言，很少会去思考一年甚至更长的目标。这是个眼前漆黑看不到的懵懂时期，捕捉到机会点的能力和概率都非常小。

\n

工作了三年以后，悟性好的人通常会以一年为思考周期，制定和实施一些年度计划。这个时期是相信天赋和比拼能力的阶段，可以捕捉到一些小机会。

\n

工作了五年以后，一些悟性好的人会产生出一定的胆识和眼光，他们会以 3 ～ 5 年为周期来制定和实施计划，开始主动布局去捕捉一些中型机会点。

\n

工作了十年以后，悟性高的人会看到模式和规则变化，例如看出行业发展模式，还有人才的成长模式等，于是开始诞生出战略性思维。然后他们会以 5 ～ 10 年为周期来制定和实施自己的战略计划，开始主动布局去捕捉一些中大机会点。Brendan Gregg，Jay Kreps 和 Brad Traversy 都是属于这个阶段的人。

\n

当然还有很少一些更牛的时代精英，他们能够看透时代和人性，他们的思考是以一生甚至更长时间为单位的，这些超人不在本文讨论范围内。

\n

五、建议

\n

1、以 5 ～ 10 年为周期去布局谋划你的战略。

\n

现在大学生毕业的年龄一般在 22 ～ 23 岁，那么在工作了十年后，也就是在你 32 ～ 33 岁的时候，你也差不多看了十年了，应该对自己和周围的世界(你的行业和领域)有一个比较深刻的领悟了。如果你到这个年纪还懵懵懂懂，今天抓东明天抓西，那么只能说你的胆识格局是相当的低。在当前 IT 行业竞争这么激烈的情况下，到 35 岁被下岗可能就在眼前了。

\n

有了战略性思考，你应该以 5 ～ 10 年为周期去布局谋划你的战略。以 Brendan Gregg，Jay Kreps 和 Brad Traversy 这些大牛为例，人生若真的要干点成就出来，投入周期一般都要十年的。从 33 岁开始，你大致有 3 个十年，因为到 60 岁以后，一般人都老眼昏花干不了大事了。如果你悟性差一点，到 40 岁才开始规划，那么你大致还有 2 个十年。如果你规划好了，这 2 ～ 3 个十年可以成就不小的事业。否则，你很可能一生都成就不了什么事业，或者一直在帮助别人成就别人的事业。

\n

2、专注自己的精力。

\n

考虑到人生能干事业的时间也就是 2 ～ 3 个十年，你会发现人生其实很短暂，这时候你会把精力都投入到实现你的十年战略上去，没有时间再浪费在比如网上的闲聊和扯皮争论上去。

\n

3、细分落地计划尤其是产出计划。

\n

有了十年战略方向，下一步是每年的细分落地计划，尤其是产出计划。这些计划主要应该工作在学习金字塔的 5/6/7 层。产出应该是刻意训练+燃烧卡路里的结果，每天让身体和大脑都保持燃烧一定量的卡路里。

\n

4、产出有价值的东西形成正反馈。

\n

产出应该有客户价值，自己能学习(自己成长进化)，对别人还有用(推动社会成长进化)，这样可以得到用户回馈和度量，形成一个闭环，可以持续改进和提升你的学习。

\n

5、少即是多。

\n

深耕一个(或有限几个相关的)领域。所有细分计划应该紧密围绕你的战略展开。克制内心欲望，不要贪多和分心，不要被喧嚣的世界所迷惑。

\n

6、战略方向+细分计划都要写下来，定期 review 优化。

\n

7、要有定力，持续努力。

\n

曲则全、枉则直，战略实现是不可能直线的。战略方向和细分计划通常要按需调整，尤其在早期，但是最终要收敛。如果老是变不收敛，就是缺乏战略定力，是个必须思考和解决的大问题。

\n

别人的成长战略可以参考，但是不要刻意去模仿，你有你自己的颜色，你应该成为独一无二的你。

\n

战略方向和细分计划明确了，接下来就是按部就班执行，十年如一日铁打不动。

\n

8、慢就是快。

\n

战略目标的实现也和种树一样是生长出来的，需要时间耐心栽培，记住慢就是快。焦虑纠结的时候，像念经一样默念王阳明《传习录》中的教诲：

\n
\n

立志用功，如种树然。方其根芽，犹未有干；及其有干，尚未有枝；枝而后叶，叶而后花实。初种根时，只管栽培灌溉。勿作枝想，勿作花想，勿作实想。悬想何益？但不忘栽培之功，怕没有枝叶花实？

\n

译文：

\n

实现战略目标，就像种树一样。刚开始只是一个小根芽，树干还没有长出来；树干长出来了，枝叶才能慢慢长出来；树枝长出来，然后才能开花和结果。刚开始种树的时候，只管栽培灌溉，别老是纠结枝什么时候长出来，花什么时候开，果实什么时候结出来。纠结有什么好处呢？只要你坚持投入栽培，还怕没有枝叶花实吗？

\n
\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/high-quality-technical-articles/cdb11ce2f1c3a69fd19e922a7f5f59bf.png", "date_published": "2023-02-23T04:45:00.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [ { "name": "波波微课" } ], "tags": [ "技术文章精选集" ] }, { "title": "网络攻击常见手段总结（安全）", "url": "https://javaguide.cn/cs-basics/network/network-attack-means.html", "id": "https://javaguide.cn/cs-basics/network/network-attack-means.html", "summary": "总结常见 TCP/IP 攻击与防护思路，覆盖 DDoS、IP/ARP 欺骗、中间人等手段，强调工程防护实践。", "content_html": "
\n

本文整理完善自TCP/IP 常见攻击手段 - 暖蓝笔记 - 2021这篇文章。

\n
\n

这篇文章的内容主要是介绍 TCP/IP 常见攻击手段，尤其是 DDoS 攻击，也会补充一些其他的常见网络攻击手段。

\n

IP 欺骗

\n

IP 是什么?

\n

在网络中，所有的设备都会分配一个地址。这个地址就仿佛小蓝的家地址「多少号多少室」，这个号就是分配给整个子网的，「室」对应的号码即分配给子网中计算机的，这就是网络中的地址。「号」对应的号码为网络号，「室」对应的号码为主机号，这个地址的整体就是 IP 地址。

\n

通过 IP 地址我们能知道什么？

\n

通过 IP 地址，我们就可以知道判断访问对象服务器的位置，从而将消息发送到服务器。一般发送者发出的消息首先经过子网的集线器，转发到最近的路由器，然后根据路由位置访问下一个路由器的位置，直到终点

\n

IP 头部格式 :

\n

\n

IP 欺骗技术是什么？

\n

骗呗，拐骗，诱骗！

\n

IP 欺骗技术就是伪造某台主机的 IP 地址的技术。通过 IP 地址的伪装使得某台主机能够伪装另外的一台主机，而这台主机往往具有某种特权或者被另外的主机所信任。

\n

假设现在有一个合法用户 (1.1.1.1) 已经同服务器建立正常的连接，攻击者构造攻击的 TCP 数据，伪装自己的 IP 为 1.1.1.1，并向服务器发送一个带有 RST 位的 TCP 数据段。服务器接收到这样的数据后，认为从 1.1.1.1 发送的连接有错误，就会清空缓冲区中建立好的连接。

\n

这时，如果合法用户 1.1.1.1 再发送合法数据，服务器就已经没有这样的连接了，该用户就必须从新开始建立连接。攻击时，伪造大量的 IP 地址，向目标发送 RST 数据，使服务器不对合法用户服务。虽然 IP 地址欺骗攻击有着相当难度，但我们应该清醒地意识到，这种攻击非常广泛，入侵往往从这种攻击开始。

\n

\"IP

\n

如何缓解 IP 欺骗？

\n

虽然无法预防 IP 欺骗，但可以采取措施来阻止伪造数据包渗透网络。入口过滤 是防范欺骗的一种极为常见的防御措施，如 BCP38（通用最佳实践文档）所示。入口过滤是一种数据包过滤形式，通常在网络边缘设备上实施，用于检查传入的 IP 数据包并确定其源标头。如果这些数据包的源标头与其来源不匹配或者看上去很可疑，则拒绝这些数据包。一些网络还实施出口过滤，检查退出网络的 IP 数据包，确保这些数据包具有合法源标头，以防止网络内部用户使用 IP 欺骗技术发起出站恶意攻击。

\n

SYN Flood(洪水)

\n

SYN Flood 是什么？

\n

SYN Flood 是互联网上最原始、最经典的 DDoS（Distributed Denial of Service，分布式拒绝服务）攻击之一，旨在耗尽可用服务器资源，致使服务器无法传输合法流量

\n

SYN Flood 利用了 TCP 协议的三次握手机制，攻击者通常利用工具或者控制僵尸主机向服务器发送海量的变源 IP 地址或变源端口的 TCP SYN 报文，服务器响应了这些报文后就会生成大量的半连接，当系统资源被耗尽后，服务器将无法提供正常的服务。
\n增加服务器性能，提供更多的连接能力对于 SYN Flood 的海量报文来说杯水车薪，防御 SYN Flood 的关键在于判断哪些连接请求来自于真实源，屏蔽非真实源的请求以保障正常的业务请求能得到服务。

\n

\n

TCP SYN Flood 攻击原理是什么？

\n

TCP SYN Flood 攻击利用的是 TCP 的三次握手（SYN -> SYN/ACK -> ACK），假设连接发起方是 A，连接接受方是 B，即 B 在某个端口（Port）上监听 A 发出的连接请求，过程如下图所示，左边是 A，右边是 B。

\n

\n

A 首先发送 SYN（Synchronization）消息给 B，要求 B 做好接收数据的准备；B 收到后反馈 SYN-ACK（Synchronization-Acknowledgement） 消息给 A，这个消息的目的有两个：

\n\n

大家注意到没有，最关键的一点在于双方是否都按对方的要求进入了可以接收消息的状态。而这个状态的确认主要是双方将要使用的消息序号(SequenceNum)，TCP 为保证消息按发送顺序抵达接收方的上层应用，需要用消息序号来标记消息的发送先后顺序的。

\n

TCP是「双工」(Duplex)连接，同时支持双向通信，也就是双方同时可向对方发送消息，其中 SYN 和 SYN-ACK 消息开启了 A→B 的单向通信通道（B 获知了 A 的消息序号）；SYN-ACK 和 ACK 消息开启了 B→A 单向通信通道（A 获知了 B 的消息序号）。

\n

上面讨论的是双方在诚实守信，正常情况下的通信。

\n

但实际情况是，网络可能不稳定会丢包，使握手消息不能抵达对方，也可能是对方故意不按规矩来，故意延迟或不发送握手确认消息。

\n

假设 B 通过某 TCP 端口提供服务，B 在收到 A 的 SYN 消息时，积极的反馈了 SYN-ACK 消息，使连接进入半开状态，因为 B 不确定自己发给 A 的 SYN-ACK 消息或 A 反馈的 ACK 消息是否会丢在半路，所以会给每个待完成的半开连接都设一个Timer，如果超过时间还没有收到 A 的 ACK 消息，则重新发送一次 SYN-ACK 消息给 A，直到重试超过一定次数时才会放弃。

\n

\"图片\"

\n

B 为帮助 A 能顺利连接，需要分配内核资源维护半开连接，那么当 B 面临海量的连接 A 时，如上图所示，SYN Flood 攻击就形成了。攻击方 A 可以控制肉鸡向 B 发送大量 SYN 消息但不响应 ACK 消息，或者干脆伪造 SYN 消息中的 Source IP，使 B 反馈的 SYN-ACK 消息石沉大海，导致 B 被大量注定不能完成的半开连接占据，直到资源耗尽，停止响应正常的连接请求。

\n

SYN Flood 的常见形式有哪些？

\n

恶意用户可通过三种不同方式发起 SYN Flood 攻击：

\n
    \n
  1. 直接攻击： 不伪造 IP 地址的 SYN 洪水攻击称为直接攻击。在此类攻击中，攻击者完全不屏蔽其 IP 地址。由于攻击者使用具有真实 IP 地址的单一源设备发起攻击，因此很容易发现并清理攻击者。为使目标机器呈现半开状态，黑客将阻止个人机器对服务器的 SYN-ACK 数据包做出响应。为此，通常采用以下两种方式实现：部署防火墙规则，阻止除 SYN 数据包以外的各类传出数据包；或者，对传入的所有 SYN-ACK 数据包进行过滤，防止其到达恶意用户机器。实际上，这种方法很少使用（即便使用过也不多见），因为此类攻击相当容易缓解 – 只需阻止每个恶意系统的 IP 地址。哪怕攻击者使用僵尸网络（如 Mirai 僵尸网络），通常也不会刻意屏蔽受感染设备的 IP。
    2. \n
  2. 欺骗攻击： 恶意用户还可以伪造其发送的各个 SYN 数据包的 IP 地址，以便阻止缓解措施并加大身份暴露难度。虽然数据包可能经过伪装，但还是可以通过这些数据包追根溯源。此类检测工作很难开展，但并非不可实现；特别是，如果 Internet 服务提供商 (ISP) 愿意提供帮助，则更容易实现。
    3. \n
  3. 分布式攻击（DDoS）： 如果使用僵尸网络发起攻击，则追溯攻击源头的可能性很低。随着混淆级别的攀升，攻击者可能还会命令每台分布式设备伪造其发送数据包的 IP 地址。哪怕攻击者使用僵尸网络（如 Mirai 僵尸网络），通常也不会刻意屏蔽受感染设备的 IP。
    4. \n
\n

如何缓解 SYN Flood？

\n

扩展积压工作队列

\n

目标设备安装的每个操作系统都允许具有一定数量的半开连接。若要响应大量 SYN 数据包，一种方法是增加操作系统允许的最大半开连接数目。为成功扩展最大积压工作，系统必须额外预留内存资源以处理各类新请求。如果系统没有足够的内存，无法应对增加的积压工作队列规模，将对系统性能产生负面影响，但仍然好过拒绝服务。

\n

回收最先创建的 TCP 半开连接

\n

另一种缓解策略是在填充积压工作后覆盖最先创建的半开连接。这项策略要求完全建立合法连接的时间低于恶意 SYN 数据包填充积压工作的时间。当攻击量增加或积压工作规模小于实际需求时，这项特定的防御措施将不奏效。

\n

SYN Cookie

\n

此策略要求服务器创建 Cookie。为避免在填充积压工作时断开连接，服务器使用 SYN-ACK 数据包响应每一项连接请求，而后从积压工作中删除 SYN 请求，同时从内存中删除请求，保证端口保持打开状态并做好重新建立连接的准备。如果连接是合法请求并且已将最后一个 ACK 数据包从客户端机器发回服务器，服务器将重建（存在一些限制）SYN 积压工作队列条目。虽然这项缓解措施势必会丢失一些 TCP 连接信息，但好过因此导致对合法用户发起拒绝服务攻击。

\n

UDP Flood(洪水)

\n

UDP Flood 是什么？

\n

UDP Flood 也是一种拒绝服务攻击，将大量的用户数据报协议（UDP）数据包发送到目标服务器，目的是压倒该设备的处理和响应能力。防火墙保护目标服务器也可能因 UDP 泛滥而耗尽，从而导致对合法流量的拒绝服务。

\n

UDP Flood 攻击原理是什么？

\n

UDP Flood 主要通过利用服务器响应发送到其中一个端口的 UDP 数据包所采取的步骤。在正常情况下，当服务器在特定端口接收到 UDP 数据包时，会经过两个步骤：

\n\n

举个例子。假设今天要联系酒店的小蓝，酒店客服接到电话后先查看房间的列表来确保小蓝在客房内，随后转接给小蓝。

\n

首先，接待员接收到呼叫者要求连接到特定房间的电话。接待员然后需要查看所有房间的清单，以确保客人在房间中可用，并愿意接听电话。碰巧的是，此时如果突然间所有的电话线同时亮起来，那么他们就会很快就变得不堪重负了。

\n

当服务器接收到每个新的 UDP 数据包时，它将通过步骤来处理请求，并利用该过程中的服务器资源。发送 UDP 报文时，每个报文将包含源设备的 IP 地址。在这种类型的 DDoS 攻击期间，攻击者通常不会使用自己的真实 IP 地址，而是会欺骗 UDP 数据包的源 IP 地址，从而阻止攻击者的真实位置被暴露并潜在地饱和来自目标的响应数据包服务器。

\n

由于目标服务器利用资源检查并响应每个接收到的 UDP 数据包的结果，当接收到大量 UDP 数据包时，目标的资源可能会迅速耗尽，导致对正常流量的拒绝服务。

\n

\n

如何缓解 UDP Flooding？

\n

大多数操作系统部分限制了 ICMP 报文的响应速率，以中断需要 ICMP 响应的 DDoS 攻击。这种缓解的一个缺点是在攻击过程中，合法的数据包也可能被过滤。如果 UDP Flood 的容量足够高以使目标服务器的防火墙的状态表饱和，则在服务器级别发生的任何缓解都将不足以应对目标设备上游的瓶颈。

\n

HTTP Flood(洪水)

\n

HTTP Flood 是什么？

\n

HTTP Flood 是一种大规模的 DDoS（Distributed Denial of Service，分布式拒绝服务）攻击，旨在利用 HTTP 请求使目标服务器不堪重负。目标因请求而达到饱和，且无法响应正常流量后，将出现拒绝服务，拒绝来自实际用户的其他请求。

\n

\"HTTP

\n

HTTP Flood 的攻击原理是什么？

\n

HTTP 洪水攻击是“第 7 层”DDoS 攻击的一种。第 7 层是 OSI 模型的应用程序层，指的是 HTTP 等互联网协议。HTTP 是基于浏览器的互联网请求的基础，通常用于加载网页或通过互联网发送表单内容。缓解应用程序层攻击特别复杂，因为恶意流量和正常流量很难区分。

\n

为了获得最大效率，恶意行为者通常会利用或创建僵尸网络，以最大程度地扩大攻击的影响。通过利用感染了恶意软件的多台设备，攻击者可以发起大量攻击流量来进行攻击。

\n

HTTP 洪水攻击有两种：

\n\n

如何防护 HTTP Flood？

\n

如前所述，缓解第 7 层攻击非常复杂，而且通常要从多方面进行。一种方法是对发出请求的设备实施质询，以测试它是否是机器人，这与在线创建帐户时常用的 CAPTCHA 测试非常相似。通过提出 JavaScript 计算挑战之类的要求，可以缓解许多攻击。

\n

其他阻止 HTTP 洪水攻击的途径包括使用 Web 应用程序防火墙 (WAF)、管理 IP 信誉数据库以跟踪和有选择地阻止恶意流量，以及由工程师进行动态分析。Cloudflare 具有超过 2000 万个互联网设备的规模优势，能够分析来自各种来源的流量并通过快速更新的 WAF 规则和其他防护策略来缓解潜在的攻击，从而消除应用程序层 DDoS 流量。

\n

DNS Flood(洪水)

\n

DNS Flood 是什么？

\n

域名系统（DNS）服务器是互联网的“电话簿“；互联网设备通过这些服务器来查找特定 Web 服务器以便访问互联网内容。DNS Flood 攻击是一种分布式拒绝服务（DDoS）攻击，攻击者用大量流量淹没某个域的 DNS 服务器，以尝试中断该域的 DNS 解析。如果用户无法找到电话簿，就无法查找到用于调用特定资源的地址。通过中断 DNS 解析，DNS Flood 攻击将破坏网站、API 或 Web 应用程序响应合法流量的能力。很难将 DNS Flood 攻击与正常的大流量区分开来，因为这些大规模流量往往来自多个唯一地址，查询该域的真实记录，模仿合法流量。

\n

DNS Flood 的攻击原理是什么？

\n

\n

域名系统的功能是将易于记忆的名称（例如 example.com）转换成难以记住的网站服务器地址（例如 192.168.0.1），因此成功攻击 DNS 基础设施将导致大多数人无法使用互联网。DNS Flood 攻击是一种相对较新的基于 DNS 的攻击，这种攻击是在高带宽物联网（IoT）僵尸网络（如 Mirai）兴起后激增的。DNS Flood 攻击使用 IP 摄像头、DVR 盒和其他 IoT 设备的高带宽连接直接淹没主要提供商的 DNS 服务器。来自 IoT 设备的大量请求淹没 DNS 提供商的服务，阻止合法用户访问提供商的 DNS 服务器。

\n

DNS Flood 攻击不同于 DNS 放大攻击。与 DNS Flood 攻击不同，DNS 放大攻击反射并放大不安全 DNS 服务器的流量，以便隐藏攻击的源头并提高攻击的有效性。DNS 放大攻击使用连接带宽较小的设备向不安全的 DNS 服务器发送无数请求。这些设备对非常大的 DNS 记录发出小型请求，但在发出请求时，攻击者伪造返回地址为目标受害者。这种放大效果让攻击者能借助有限的攻击资源来破坏较大的目标。

\n

如何防护 DNS Flood?

\n

DNS Flood 对传统上基于放大的攻击方法做出了改变。借助轻易获得的高带宽僵尸网络，攻击者现能针对大型组织发动攻击。除非被破坏的 IoT 设备得以更新或替换，否则抵御这些攻击的唯一方法是使用一个超大型、高度分布式的 DNS 系统，以便实时监测、吸收和阻止攻击流量。

\n

TCP 重置攻击

\n

在 TCP 重置攻击中，攻击者通过向通信的一方或双方发送伪造的消息，告诉它们立即断开连接，从而使通信双方连接中断。正常情况下，如果客户端收发现到达的报文段对于相关连接而言是不正确的，TCP 就会发送一个重置报文段，从而导致 TCP 连接的快速拆卸。

\n

TCP 重置攻击利用这一机制，通过向通信方发送伪造的重置报文段，欺骗通信双方提前关闭 TCP 连接。如果伪造的重置报文段完全逼真，接收者就会认为它有效，并关闭 TCP 连接，防止连接被用来进一步交换信息。服务端可以创建一个新的 TCP 连接来恢复通信，但仍然可能会被攻击者重置连接。万幸的是，攻击者需要一定的时间来组装和发送伪造的报文，所以一般情况下这种攻击只对长连接有杀伤力，对于短连接而言，你还没攻击呢，人家已经完成了信息交换。

\n

从某种意义上来说，伪造 TCP 报文段是很容易的，因为 TCP/IP 都没有任何内置的方法来验证服务端的身份。有些特殊的 IP 扩展协议（例如 IPSec）确实可以验证身份，但并没有被广泛使用。客户端只能接收报文段，并在可能的情况下使用更高级别的协议（如 TLS）来验证服务端的身份。但这个方法对 TCP 重置包并不适用，因为 TCP 重置包是 TCP 协议本身的一部分，无法使用更高级别的协议进行验证。

\n

模拟攻击

\n
\n

以下实验是在 OSX 系统中完成的，其他系统请自行测试。

\n
\n

现在来总结一下伪造一个 TCP 重置报文要做哪些事情：

\n\n

为了实验简单，我们可以使用本地计算机通过 localhost 与自己通信，然后对自己进行 TCP 重置攻击。需要以下几个步骤：

\n\n

下面正式开始实验。

\n
\n

建立 TCP 连接

\n
\n

可以使用 netcat 工具来建立 TCP 连接，这个工具很多操作系统都预装了。打开第一个终端窗口，运行以下命令：

\n
nc -nvl 8000
\n

这个命令会启动一个 TCP 服务，监听端口为 8000。接着再打开第二个终端窗口，运行以下命令：

\n
nc 127.0.0.1 8000
\n

该命令会尝试与上面的服务建立连接，在其中一个窗口输入一些字符，就会通过 TCP 连接发送给另一个窗口并打印出来。

\n

\n
\n

嗅探流量

\n
\n

编写一个攻击程序，使用 Python 网络库 scapy 来读取两个终端窗口之间交换的数据，并将其打印到终端上。代码比较长，下面为一部份，完整代码后台回复 TCP 攻击，代码的核心是调用 scapy 的嗅探方法：

\n

\n

这段代码告诉 scapy 在 lo0 网络接口上嗅探数据包，并记录所有 TCP 连接的详细信息。

\n\n
\n

发送伪造的重置报文

\n
\n

下面开始修改程序，发送伪造的 TCP 重置报文来进行 TCP 重置攻击。根据上面的解读，只需要修改 prn 函数就行了，让其检查数据包，提取必要参数，并利用这些参数来伪造 TCP 重置报文并发送。

\n

例如，假设该程序截获了一个从（src_ip, src_port）发往 （dst_ip, dst_port）的报文段，该报文段的 ACK 标志位已置为 1，ACK 号为 100,000。攻击程序接下来要做的是：

\n\n

对于我的程序而言，只需将这一行取消注释，并注释这一行的上面一行，就可以全面攻击了。按照步骤 1 的方法设置 TCP 连接，打开第三个窗口运行攻击程序，然后在 TCP 连接的其中一个终端输入一些字符串，你会发现 TCP 连接被中断了！

\n
\n

进一步实验

\n
\n
    \n
  1. 可以继续使用攻击程序进行实验，将伪造数据包的序列号加减 1 看看会发生什么，是不是确实需要和截获数据包的 ACK 号完全相同。
    2. \n
  2. 打开 Wireshark，监听 lo0 网络接口，并使用过滤器 ip.src == 127.0.0.1 && ip.dst == 127.0.0.1 && tcp.port == 8000 来过滤无关数据。你可以看到 TCP 连接的所有细节。
    3. \n
  3. 在连接上更快速地发送数据流，使攻击更难执行。
    4. \n
\n

中间人攻击

\n

猪八戒要向小蓝表白，于是写了一封信给小蓝，结果第三者小黑拦截到了这封信，把这封信进行了篡改，于是乎在他们之间进行搞破坏行动。这个马文才就是中间人，实施的就是中间人攻击。好我们继续聊聊什么是中间人攻击。

\n

什么是中间人?

\n

攻击中间人攻击英文名叫 Man-in-the-MiddleAttack，简称「MITM 攻击」。指攻击者与通讯的两端分别创建独立的联系，并交换其所收到的数据，使通讯的两端认为他们正在通过一个私密的连接与对方 直接对话，但事实上整个会话都被攻击者完全控制。我们画一张图：

\n

\"图片\"

\n

从这张图可以看到，中间人其实就是攻击者。通过这种原理，有很多实现的用途，比如说，你在手机上浏览不健康网站的时候，手机就会提示你，此网站可能含有病毒，是否继续访问还是做其他的操作等等。

\n

中间人攻击的原理是什么？

\n

举个例子，我和公司签了一个一份劳动合同，一人一份合同。不晓得哪个可能改了合同内容，不知道真假了，怎么搞？只好找专业的机构来鉴定，自然就要花钱。

\n

在安全领域有句话：我们没有办法杜绝网络犯罪，只好想办法提高网络犯罪的成本。既然没法杜绝这种情况，那我们就想办法提高作案的成本，今天我们就简单了解下基本的网络安全知识，也是面试中的高频面试题了。

\n

为了避免双方说活不算数的情况，双方引入第三家机构，将合同原文给可信任的第三方机构，只要这个机构不监守自盗，合同就相对安全。

\n

如果第三方机构内部不严格或容易出现纰漏？

\n

虽然我们将合同原文给第三方机构了，为了防止内部人员的更改，需要采取什么措施呢

\n

一种可行的办法是引入 摘要算法 。即合同和摘要一起，为了简单的理解摘要。大家可以想象这个摘要为一个函数，这个函数对原文进行了加密，会产生一个唯一的散列值，一旦原文发生一点点变化，那么这个散列值将会变化。

\n

有哪些常用的摘要算法呢？

\n

目前比较常用的加密算法有消息摘要算法和安全散列算法(SHA)。MD5 是将任意长度的文章转化为一个 128 位的散列值，可是在 2004 年，MD5 被证实了容易发生碰撞，即两篇原文产生相同的摘要。这样的话相当于直接给黑客一个后门，轻松伪造摘要。

\n

所以在大部分的情况下都会选择 SHA 算法 。

\n

出现内鬼了怎么办？

\n

看似很安全的场面了，理论上来说杜绝了篡改合同的做法。主要某个员工同时具有修改合同和摘要的权利，那搞事儿就是时间的问题了，毕竟没哪个系统可以完全的杜绝员工接触敏感信息，除非敏感信息都不存在。所以能不能考虑将合同和摘要分开存储呢

\n

那如何确保员工不会修改合同呢？

\n

这确实蛮难的，不过办法总比困难多。我们将合同放在双方手中，摘要放在第三方机构，篡改难度进一步加大

\n

那么员工万一和某个用户串通好了呢？

\n

看来放在第三方的机构还是不好使，同样存在不小风险。所以还需要寻找新的方案，这就出现了 数字签名和证书。

\n

数字证书和签名有什么用？

\n

同样的，举个例子。Sum 和 Mike 两个人签合同。Sum 首先用 SHA 算法计算合同的摘要，然后用自己私钥将摘要加密，得到数字签名。Sum 将合同原文、签名，以及公钥三者都交给 Mike

\n

\n

如果 Sum 想要证明合同是 Mike 的，那么就要使用 Mike 的公钥，将这个签名解密得到摘要 x，然后 Mike 计算原文的 sha 摘要 Y，随后对比 x 和 y，如果两者相等，就认为数据没有被篡改

\n

在这样的过程中，Mike 是不能更改 Sum 的合同，因为要修改合同不仅仅要修改原文还要修改摘要，修改摘要需要提供 Mike 的私钥，私钥即 Sum 独有的密码，公钥即 Sum 公布给他人使用的密码

\n

总之，公钥加密的数据只能私钥可以解密。私钥加密的数据只有公钥可以解密，这就是 非对称加密 。

\n

隐私保护？不是吓唬大家，信息是透明的兄 die，不过尽量去维护个人的隐私吧，今天学习对称加密和非对称加密。

\n

大家先读读这个字"钥",是读"yao"，我以前也是，其实读"yue"

\n

什么是对称加密？

\n

对称加密，顾名思义，加密方与解密方使用同一钥匙(秘钥)。具体一些就是，发送方通过使用相应的加密算法和秘钥，对将要发送的信息进行加密；对于接收方而言，使用解密算法和相同的秘钥解锁信息，从而有能力阅读信息。

\n

\"图片\"

\n

常见的对称加密算法有哪些？

\n

DES

\n

DES 使用的密钥表面上是 64 位的，然而只有其中的 56 位被实际用于算法，其余 8 位可以被用于奇偶校验，并在算法中被丢弃。因此，DES 的有效密钥长度为 56 位，通常称 DES 的密钥长度为 56 位。假设秘钥为 56 位，采用暴力破 Jie 的方式，其秘钥个数为 2 的 56 次方，那么每纳秒执行一次解密所需要的时间差不多 1 年的样子。当然，没人这么干。DES 现在已经不是一种安全的加密方法，主要因为它使用的 56 位密钥过短。

\n

\n

IDEA

\n

国际数据加密算法(International Data Encryption Algorithm)。秘钥长度 128 位，优点没有专利的限制。

\n

AES

\n

当 DES 被破解以后，没过多久推出了 AES 算法，提供了三种长度供选择，128 位、192 位和 256，为了保证性能不受太大的影响，选择 128 即可。

\n

SM1 和 SM4

\n

之前几种都是国外的，我们国内自行研究了国密 SM1和 SM4。其中 S 都属于国家标准，算法公开。优点就是国家的大力支持和认可

\n

总结：

\n

\n

常见的非对称加密算法有哪些？

\n

在对称加密中，发送方与接收方使用相同的秘钥。那么在非对称加密中则是发送方与接收方使用的不同的秘钥。其主要解决的问题是防止在秘钥协商的过程中发生泄漏。比如在对称加密中，小蓝将需要发送的消息加密，然后告诉你密码是 123balala,ok,对于其他人而言，很容易就能劫持到密码是 123balala。那么在非对称的情况下，小蓝告诉所有人密码是 123balala,对于中间人而言，拿到也没用，因为没有私钥。所以，非对称密钥其实主要解决了密钥分发的难题。如下图

\n

\n

其实我们经常都在使用非对称加密，比如使用多台服务器搭建大数据平台 hadoop，为了方便多台机器设置免密登录，是不是就会涉及到秘钥分发。再比如搭建 docker 集群也会使用相关非对称加密算法。

\n

常见的非对称加密算法：

\n\n

总结：

\n

\n

常见的散列算法有哪些？

\n

这个大家应该更加熟悉了，比如我们平常使用的 MD5 校验，在很多时候，我并不是拿来进行加密，而是用来获得唯一性 ID。在做系统的过程中，存储用户的各种密码信息，通常都会通过散列算法，最终存储其散列值。

\n

MD5（不推荐）

\n

MD5 可以用来生成一个 128 位的消息摘要，它是目前应用比较普遍的散列算法，具体的应用场景你可以自行  参阅。虽然，因为算法的缺陷，它的唯一性已经被破解了，但是大部分场景下，这并不会构成安全问题。但是，如果不是长度受限（32 个字符），我还是不推荐你继续使用 MD5 的。

\n

SHA

\n

安全散列算法。SHA 包括SHA-1、SHA-2和SHA-3三个版本。该算法的基本思想是：接收一段明文数据，通过不可逆的方式将其转换为固定长度的密文。简单来说，SHA 将输入数据（即预映射或消息）转化为固定长度、较短的输出值，称为散列值（或信息摘要、信息认证码）。SHA-1 已被证明不够安全，因此逐渐被 SHA-2 取代，而 SHA-3 则作为 SHA 系列的最新版本，采用不同的结构（Keccak 算法）提供更高的安全性和灵活性。

\n

SM3

\n

国密算法SM3。加密强度和 SHA-256 算法 相差不多。主要是受到了国家的支持。

\n

总结：

\n

\"图片\"

\n

大部分情况下使用对称加密，具有比较不错的安全性。如果需要分布式进行秘钥分发，考虑非对称。如果不需要可逆计算则散列算法。 因为这段时间有这方面需求，就看了一些这方面的资料，入坑信息安全，就怕以后洗发水都不用买。谢谢大家查看！

\n

第三方机构和证书机制有什么用？

\n

问题还有，此时如果 Sum 否认给过 Mike 的公钥和合同，不久 gg 了

\n

所以需要 Sum 过的话做过的事儿需要足够的信誉，这就引入了 第三方机构和证书机制 。

\n

证书之所以会有信用，是因为证书的签发方拥有信用。所以如果 Sum 想让 Mike 承认自己的公钥，Sum 不会直接将公钥给 Mike ，而是提供由第三方机构，含有公钥的证书。如果 Mike 也信任这个机构，法律都认可，那 ik，信任关系成立

\n

\n

如上图所示，Sum 将自己的申请提交给机构，产生证书的原文。机构用自己的私钥签名 Sum 的申请原文（先根据原文内容计算摘要，再用私钥加密），得到带有签名信息的证书。Mike 拿到带签名信息的证书，通过第三方机构的公钥进行解密，获得 Sum 证书的摘要、证书的原文。有了 Sum 证书的摘要和原文，Mike 就可以进行验签。验签通过，Mike 就可以确认 Sum 的证书的确是第三方机构签发的。

\n

用上面这样一个机制，合同的双方都无法否认合同。这个解决方案的核心在于需要第三方信用服务机构提供信用背书。这里产生了一个最基础的信任链，如果第三方机构的信任崩溃，比如被黑客攻破，那整条信任链条也就断裂了

\n

为了让这个信任条更加稳固，就需要环环相扣，打造更长的信任链，避免单点信任风险

\n

\n

上图中，由信誉最好的根证书机构提供根证书，然后根证书机构去签发二级机构的证书；二级机构去签发三级机构的证书；最后有由三级机构去签发 Sum 证书。

\n

如果要验证 Sum 证书的合法性，就需要用三级机构证书中的公钥去解密 Sum 证书的数字签名。

\n

如果要验证三级机构证书的合法性，就需要用二级机构的证书去解密三级机构证书的数字签名。

\n

如果要验证二级结构证书的合法性，就需要用根证书去解密。

\n

以上，就构成了一个相对长一些的信任链。如果其中一方想要作弊是非常困难的，除非链条中的所有机构同时联合起来，进行欺诈。

\n

中间人攻击如何避免?

\n

既然知道了中间人攻击的原理也知道了他的危险，现在我们看看如何避免。相信我们都遇到过下面这种状况：

\n

\n

出现这个界面的很多情况下，都是遇到了中间人攻击的现象，需要对安全证书进行及时地监测。而且大名鼎鼎的 github 网站，也曾遭遇过中间人攻击：

\n

想要避免中间人攻击的方法目前主要有两个：

\n\n

DDOS

\n

通过上面的描述，总之即好多种攻击都是 DDOS 攻击，所以简单总结下这个攻击相关内容。

\n

其实，像全球互联网各大公司，均遭受过大量的 DDoS。

\n

2018 年，GitHub 在一瞬间遭到高达 1.35Tbps 的带宽攻击。这次 DDoS 攻击几乎可以堪称是互联网有史以来规模最大、威力最大的 DDoS 攻击了。在 GitHub 遭到攻击后，仅仅一周后，DDoS 攻击又开始对 Google、亚马逊甚至 Pornhub 等网站进行了 DDoS 攻击。后续的 DDoS 攻击带宽最高也达到了 1Tbps。

\n

DDoS 攻击究竟是什么？

\n

DDos 全名 Distributed Denial of Service，翻译成中文就是分布式拒绝服务。指的是处于不同位置的多个攻击者同时向一个或数个目标发动攻击，是一种分布的、协同的大规模攻击方式。单一的 DoS 攻击一般是采用一对一方式的，它利用网络协议和操作系统的一些缺陷，采用欺骗和伪装的策略来进行网络攻击，使网站服务器充斥大量要求回复的信息，消耗网络带宽或系统资源，导致网络或系统不胜负荷以至于瘫痪而停止提供正常的网络服务。

\n
\n

举个例子

\n
\n

我开了一家有五十个座位的重庆火锅店，由于用料上等，童叟无欺。平时门庭若市，生意特别红火，而对面二狗家的火锅店却无人问津。二狗为了对付我，想了一个办法，叫了五十个人来我的火锅店坐着却不点菜，让别的客人无法吃饭。

\n

上面这个例子讲的就是典型的 DDoS 攻击，一般来说是指攻击者利用“肉鸡”对目标网站在较短的时间内发起大量请求，大规模消耗目标网站的主机资源，让它无法正常服务。在线游戏、互联网金融等领域是 DDoS 攻击的高发行业。

\n

攻击方式很多，比如 ICMP Flood、UDP Flood、NTP Flood、SYN Flood、CC 攻击、DNS Query Flood等等。

\n

如何应对 DDoS 攻击？

\n

高防服务器

\n

还是拿开的重庆火锅店举例，高防服务器就是我给重庆火锅店增加了两名保安，这两名保安可以让保护店铺不受流氓骚扰，并且还会定期在店铺周围巡逻防止流氓骚扰。

\n

高防服务器主要是指能独立硬防御 50Gbps 以上的服务器，能够帮助网站拒绝服务攻击，定期扫描网络主节点等，这东西是不错，就是贵~

\n

黑名单

\n

面对火锅店里面的流氓，我一怒之下将他们拍照入档，并禁止他们踏入店铺，但是有的时候遇到长得像的人也会禁止他进入店铺。这个就是设置黑名单，此方法秉承的就是“错杀一千，也不放一百”的原则，会封锁正常流量，影响到正常业务。

\n

DDoS 清洗

\n

DDos 清洗，就是我发现客人进店几分钟以后，但是一直不点餐，我就把他踢出店里。

\n

DDoS 清洗会对用户请求数据进行实时监控，及时发现 DOS 攻击等异常流量，在不影响正常业务开展的情况下清洗掉这些异常流量。

\n

CDN 加速

\n

CDN 加速，我们可以这么理解：为了减少流氓骚扰，我干脆将火锅店开到了线上，承接外卖服务，这样流氓找不到店在哪里，也耍不来流氓了。

\n

在现实中，CDN 服务将网站访问流量分配到了各个节点中，这样一方面隐藏网站的真实 IP，另一方面即使遭遇 DDoS 攻击，也可以将流量分散到各个节点中，防止源站崩溃。

\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/p3-juejin/843fd07074874ee0b695eca659411b42~tplv-k3u1fbpfcp-zoom-1.png", "date_published": "2023-02-19T09:28:45.000Z", "date_modified": "2026-03-23T08:33:10.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "SQL常见面试题总结（1）", "url": "https://javaguide.cn/database/sql/sql-questions-01.html", "id": "https://javaguide.cn/database/sql/sql-questions-01.html", "summary": "SQL常见面试题总结第一篇，涵盖SELECT检索数据、WHERE条件过滤、ORDER BY排序、DISTINCT去重、LIMIT分页等基础查询操作及牛客真题解析。", "content_html": "
\n

题目来源于：牛客题霸 - SQL 必知必会

\n
\n

检索数据

\n

SELECT 用于从数据库中查询数据。

\n

从 Customers 表中检索所有的 ID

\n

现有表 Customers 如下：

\n

| cust_id |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/csdn/d1794312b448516831369f869814ab39.png", "date_published": "2023-02-17T05:40:22.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "SQL语法基础知识总结", "url": "https://javaguide.cn/database/sql/sql-syntax-summary.html", "id": "https://javaguide.cn/database/sql/sql-syntax-summary.html", "summary": "SQL语法基础知识总结，系统讲解DDL数据定义、DML数据操作、DQL数据查询、DCL数据控制语言，涵盖表操作、约束、索引、事务、连接查询等核心知识点。", "content_html": "
\n

本文整理完善自下面这两份资料：

\n\n
\n

基本概念

\n

数据库术语

\n\n

SQL 语法

\n

SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。

\n

SQL 语法结构

\n

\n

SQL 语法结构包括：

\n\n

SQL 语法要点

\n\n

SQL 语句可以写成一行，也可以分写为多行。

\n
-- 一行 SQL 语句\n\nUPDATE user SET username='robot', password='robot' WHERE username = 'root';\n\n-- 多行 SQL 语句\nUPDATE user\nSET username='robot', password='robot'\nWHERE username = 'root';
\n

SQL 支持三种注释：

\n
## 注释1\n-- 注释2\n/* 注释3 */
\n

SQL 分类

\n

数据定义语言（DDL）

\n

数据定义语言（Data Definition Language，DDL）是 SQL 语言集中负责数据结构定义与数据库对象定义的语言。

\n

DDL 的主要功能是定义数据库对象。

\n

DDL 的核心指令是 CREATE、ALTER、DROP。

\n

数据操纵语言（DML）

\n

数据操纵语言（Data Manipulation Language, DML）是用于数据库操作，对数据库其中的对象和数据运行访问工作的编程语句。

\n

DML 的主要功能是 访问数据，因此其语法都是以读写数据库为主。

\n

DML 的核心指令是 INSERT、UPDATE、DELETE、SELECT。这四个指令合称 CRUD(Create, Read, Update, Delete)，即增删改查。

\n

事务控制语言（TCL）

\n

事务控制语言 (Transaction Control Language, TCL) 用于管理数据库中的事务。这些用于管理由 DML 语句所做的更改。它还允许将语句分组为逻辑事务。

\n

TCL 的核心指令是 COMMIT、ROLLBACK。

\n

数据控制语言（DCL）

\n

数据控制语言 (Data Control Language, DCL) 是一种可对数据访问权进行控制的指令，它可以控制特定用户账户对数据表、查看表、预存程序、用户自定义函数等数据库对象的控制权。

\n

DCL 的核心指令是 GRANT、REVOKE。

\n

DCL 以控制用户的访问权限为主，因此其指令作法并不复杂，可利用 DCL 控制的权限有：CONNECT、SELECT、INSERT、UPDATE、DELETE、EXECUTE、USAGE、REFERENCES。

\n

根据不同的 DBMS 以及不同的安全性实体，其支持的权限控制也有所不同。

\n

我们先来介绍 DML 语句用法。 DML 的主要功能是读写数据库实现增删改查。

\n

增删改查

\n

增删改查，又称为 CRUD，数据库基本操作中的基本操作。

\n

插入数据

\n

INSERT INTO 语句用于向表中插入新记录。

\n

插入完整的行

\n
# 插入一行\nINSERT INTO user\nVALUES (10, 'root', 'root', 'xxxx@163.com');\n# 插入多行\nINSERT INTO user\nVALUES (10, 'root', 'root', 'xxxx@163.com'), (12, 'user1', 'user1', 'xxxx@163.com'), (18, 'user2', 'user2', 'xxxx@163.com');
\n

插入行的一部分

\n
INSERT INTO user(username, password, email)\nVALUES ('admin', 'admin', 'xxxx@163.com');
\n

插入查询出来的数据

\n
INSERT INTO user(username)\nSELECT name\nFROM account;
\n

更新数据

\n

UPDATE 语句用于更新表中的记录。

\n
UPDATE user\nSET username='robot', password='robot'\nWHERE username = 'root';
\n

删除数据

\n\n

删除表中的指定数据

\n
DELETE FROM user\nWHERE username = 'robot';
\n

清空表中的数据

\n
TRUNCATE TABLE user;
\n

查询数据

\n

SELECT 语句用于从数据库中查询数据。

\n

DISTINCT 用于返回唯一不同的值。它作用于所有列，也就是说所有列的值都相同才算相同。

\n

LIMIT 限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。

\n\n

查询单列

\n
SELECT prod_name\nFROM products;
\n

查询多列

\n
SELECT prod_id, prod_name, prod_price\nFROM products;
\n

查询所有列

\n
SELECT *\nFROM products;
\n

查询不同的值

\n
SELECT DISTINCT\nvend_id FROM products;
\n

限制查询结果

\n
-- 返回前 5 行\nSELECT * FROM mytable LIMIT 5;\nSELECT * FROM mytable LIMIT 0, 5;\n-- 返回第 3 ~ 5 行\nSELECT * FROM mytable LIMIT 2, 3;
\n

排序

\n

order by 用于对结果集按照一个列或者多个列进行排序。默认按照升序对记录进行排序，如果需要按照降序对记录进行排序，可以使用 desc 关键字。

\n

order by 对多列排序的时候，先排序的列放前面，后排序的列放后面。并且，不同的列可以有不同的排序规则。

\n
SELECT * FROM products\nORDER BY prod_price DESC, prod_name ASC;
\n

分组

\n

group by：

\n\n

分组

\n
SELECT cust_name, COUNT(cust_address) AS addr_num\nFROM Customers GROUP BY cust_name;
\n

分组后排序

\n
SELECT cust_name, COUNT(cust_address) AS addr_num\nFROM Customers GROUP BY cust_name\nORDER BY cust_name DESC;
\n

having：

\n\n

使用 WHERE 和 HAVING 过滤数据

\n
SELECT cust_name, COUNT(*) AS NumberOfOrders\nFROM Customers\nWHERE cust_email IS NOT NULL\nGROUP BY cust_name\nHAVING COUNT(*) > 1;
\n

having vs where：

\n\n

子查询

\n

子查询是嵌套在较大查询中的 SQL 查询，也称内部查询或内部选择，包含子查询的语句也称为外部查询或外部选择。简单来说，子查询就是指将一个 select 查询（子查询）的结果作为另一个 SQL 语句（主查询）的数据来源或者判断条件。

\n

子查询可以嵌入 SELECT、INSERT、UPDATE 和 DELETE 语句中，也可以和 =、<、>、IN、BETWEEN、EXISTS 等运算符一起使用。

\n

子查询常用在 WHERE 子句和 FROM 子句后边：

\n\n
\n

注意：MYSQL 数据库从 4.1 版本才开始支持子查询，早期版本是不支持的。

\n
\n

用于 WHERE 子句的子查询的基本语法如下：

\n
select column_name [, column_name ]\nfrom   table1 [, table2 ]\nwhere  column_name operator\n    (select column_name [, column_name ]\n    from table1 [, table2 ]\n    [where])
\n
\n

用于 FROM 子句的子查询的基本语法如下：

\n
select column_name [, column_name ]\nfrom (select column_name [, column_name ]\n      from table1 [, table2 ]\n      [where]) as temp_table_name\nwhere  condition
\n

用于 FROM 的子查询返回的结果相当于一张临时表，所以需要使用 AS 关键字为该临时表起一个名字。

\n

子查询的子查询

\n
SELECT cust_name, cust_contact\nFROM customers\nWHERE cust_id IN (SELECT cust_id\n                  FROM orders\n                  WHERE order_num IN (SELECT order_num\n                                      FROM orderitems\n                                      WHERE prod_id = 'RGAN01'));
\n

内部查询首先在其父查询之前执行，以便可以将内部查询的结果传递给外部查询。执行过程可以参考下图：

\n

\n

WHERE

\n\n

| 运算符 | 描述 |
\n|

\n", "image": "https://oss.javaguide.cn/p3-juejin/cb684d4c75fc430e92aaee226069c7da~tplv-k3u1fbpfcp-zoom-1.png", "date_published": "2023-02-17T05:40:22.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "Gradle核心概念总结", "url": "https://javaguide.cn/tools/gradle/gradle-core-concepts.html", "id": "https://javaguide.cn/tools/gradle/gradle-core-concepts.html", "summary": "Gradle 就是一个运行在 JVM 上的自动化的项目构建工具，用来帮助我们自动构建项目。", "content_html": "
\n

这部分内容主要根据 Gradle 官方文档整理，做了对应的删减，主要保留比较重要的部分，不涉及实战，主要是一些重要概念的介绍。

\n
\n

Gradle 这部分内容属于可选内容，可以根据自身需求决定是否学习，目前国内还是使用 Maven 普遍一些。

\n

Gradle 介绍

\n

Gradle 官方文档是这样介绍的 Gradle 的：

\n
\n

Gradle is an open-source build automation tool flexible enough to build almost any type of software. Gradle makes few assumptions about what you’re trying to build or how to build it. This makes Gradle particularly flexible.

\n

Gradle 是一个开源的构建自动化工具，它足够灵活，可以构建几乎任何类型的软件。Gradle 对你要构建什么或者如何构建它做了很少的假设。这使得 Gradle 特别灵活。

\n
\n

简单来说，Gradle 就是一个运行在 JVM 上的自动化的项目构建工具，用来帮助我们自动构建项目。

\n

对于开发者来说，Gradle 的主要作用主要有 3 个：

\n
    \n
  1. 项目构建：提供标准的、跨平台的自动化项目构建方式。
    2. \n
  2. 依赖管理：方便快捷的管理项目依赖的资源（jar 包），避免资源间的版本冲突问题。
    3. \n
  3. 统一开发结构：提供标准的、统一的项目结构。
    4. \n
\n

Gradle 构建脚本是使用 Groovy 或 Kotlin 语言编写的，表达能力非常强，也足够灵活。

\n

Groovy 介绍

\n

Gradle 是运行在 JVM 上的一个程序，它可以使用 Groovy 来编写构建脚本。

\n

Groovy 是运行在 JVM 上的脚本语言，是基于 Java 扩展的动态语言，它的语法和 Java 非常的相似，可以使用 Java 的类库。Groovy 可以用于面向对象编程，也可以用作纯粹的脚本语言。在语言的设计上它吸纳了 Java、Python、Ruby 和 Smalltalk 语言的优秀特性，比如动态类型转换、闭包和元编程支持。

\n

我们可以用学习 Java 的方式去学习 Groovy ，学习成本相对来说还是比较低的，即使开发过程中忘记 Groovy 语法，也可以用 Java 语法继续编码。

\n

基于 JVM 的语言有很多种比如 Groovy，Kotlin，Java，Scala，他们最终都会编译生成 Java 字节码文件并在 JVM 上运行。

\n

Gradle 优势

\n

Gradle 是新一代的构建系统，具有高效和灵活等诸多优势，广泛用于 Java 开发。不仅 Android 将其作为官方构建系统, 越来越多的 Java 项目比如 Spring Boot 也慢慢迁移到 Gradle。

\n\n

Gradle Wrapper 介绍

\n

Gradle 官方文档是这样介绍的 Gradle Wrapper 的：

\n
\n

The recommended way to execute any Gradle build is with the help of the Gradle Wrapper (in short just “Wrapper”). The Wrapper is a script that invokes a declared version of Gradle, downloading it beforehand if necessary. As a result, developers can get up and running with a Gradle project quickly without having to follow manual installation processes saving your company time and money.

\n

执行 Gradle 构建的推荐方法是借助 Gradle Wrapper(简而言之就是“Wrapper”)。Wrapper 它是一个脚本，调用了已经声明的 Gradle 版本，如果需要的话，可以预先下载它。因此，开发人员可以快速启动并运行 Gradle 项目，而不必遵循手动安装过程，从而为公司节省时间和金钱。

\n
\n

我们可以称 Gradle Wrapper 为 Gradle 包装器，它将 Gradle 再次包装，让所有的 Gradle 构建方法在 Gradle 包装器的帮助下运行。

\n

Gradle Wrapper 的工作流程图如下（图源Gradle Wrapper 官方文档介绍）：

\n

\"包装器工作流程\"

\n

整个流程主要分为下面 3 步：

\n
    \n
  1. 首先当我们刚创建的时候，如果指定的版本没有被下载，就先会去 Gradle 的服务器中下载对应版本的压缩包；
    2. \n
  2. 下载完成后需要先进行解压缩并且执行批处理文件；
    3. \n
  3. 后续项目每次构建都会重用这个解压过的 Gradle 版本。
    4. \n
\n

Gradle Wrapper 会给我们带来下面这些好处：

\n
    \n
  1. 在给定的 Gradle 版本上标准化项目，从而实现更可靠和健壮的构建。
    2. \n
  2. 可以让我们的电脑中不安装 Gradle 环境也可以运行 Gradle 项目。
    3. \n
  3. 为不同的用户和执行环境（例如 IDE 或持续集成服务器）提供新的 Gradle 版本就像更改 Wrapper 定义一样简单。
    4. \n
\n

生成 Gradle Wrapper

\n

如果想要生成 Gradle Wrapper 的话，需要本地配置好 Gradle 环境变量。Gradle 中已经内置了 Wrapper Task，在项目根目录执行执行gradle wrapper命令即可帮助我们生成 Gradle Wrapper。

\n

执行命令 gradle wrapper 命令时可以指定一些参数来控制 wrapper 的生成。具体有如下两个配置参数：

\n\n

执行gradle wrapper命令之后，Gradle Wrapper 就生成完成了，项目根目录中生成如下文件：

\n
├── gradle\n│   └── wrapper\n│       ├── gradle-wrapper.jar\n│       └── gradle-wrapper.properties\n├── gradlew\n└── gradlew.bat
\n

每个文件的含义如下：

\n\n

gradle-wrapper.properties 文件的内容如下：

\n
distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-6.0.1-bin.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists
\n
\n

更新 Gradle Wrapper

\n

更新 Gradle Wrapper 有 2 种方式：

\n
    \n
  1. 接修改distributionUrl字段，然后执行 Gradle 命令。
    2. \n
  2. 执行 gradlew 命令gradlew wrapper –-gradle-version [version]。
    3. \n
\n

下面的命令会将 Gradle 版本升级为 7.6。

\n
gradlew wrapper --gradle-version 7.6
\n

gradle-wrapper.properties 文件中的 distributionUrl 属性也发生了改变。

\n
distributionUrl=https\\://services.gradle.org/distributions/gradle-7.6-all.zip
\n

自定义 Gradle Wrapper

\n

Gradle 已经内置了 Wrapper Task，因此构建 Gradle Wrapper 会生成 Gradle Wrapper 的属性文件，这个属性文件可以通过自定义 Wrapper Task 来设置。比如我们想要修改要下载的 Gralde 版本为 7.6，可以这么设置：

\n
task wrapper(type: Wrapper) {\n    gradleVersion = '7.6'\n}
\n

也可以设置 Gradle 发行版压缩包的下载地址和 Gradle 解包后的本地存储路径等配置。

\n
task wrapper(type: Wrapper) {\n    gradleVersion = '7.6'\n    distributionUrl = '../../gradle-7.6-bin.zip'\n    distributionPath=wrapper/dists\n}
\n

distributionUrl 属性可以设置为本地的项目目录，你也可以设置为网络地址。

\n

Gradle 任务

\n

在 Gradle 中，任务(Task)是构建执行的单个工作单元。

\n

Gradle 的构建是基于 Task 进行的，当你运行项目的时候，实际就是在执行了一系列的 Task 比如编译 Java 源码的 Task、生成 jar 文件的 Task。

\n

Task 的声明方式如下（还有其他几种声明方式）：

\n
// 声明一个名字为 helloTask 的 Task\ntask helloTask{\n     doLast{\n       println \"Hello\"\n     }\n}
\n

创建一个 Task 后，可以根据需要给 Task 添加不同的 Action，上面的“doLast”就是给队列尾增加一个 Action。

\n
 //在Action 队列头部添加Action\n Task doFirst(Action<? super Task> action);\n Task doFirst(Closure action);\n\n //在Action 队列尾部添加Action\n Task doLast(Action<? super Task> action);\n Task doLast(Closure action);\n\n //删除所有的Action\n Task deleteAllActions();
\n

一个 Task 中可以有多个 Acton，从队列头部开始向队列尾部执行 Acton。

\n

Action 代表的是一个个函数、方法，每个 Task 都是一堆 Action 按序组成的执行图。

\n

Task 声明依赖的关键字是dependsOn，支持声明一个或多个依赖：

\n
task first {\n doLast {\n        println \"+++++first+++++\"\n    }\n}\ntask second {\n doLast {\n        println \"+++++second+++++\"\n    }\n}\n\n// 指定多个 task 依赖\ntask print(dependsOn :[second,first]) {\n doLast {\n      logger.quiet \"指定多个task依赖\"\n    }\n}\n\n// 指定一个 task 依赖\ntask third(dependsOn : print) {\n doLast {\n      println '+++++third+++++'\n    }\n}
\n

执行 Task 之前，会先执行它的依赖 Task。

\n

我们还可以设置默认 Task，脚本中我们不调用默认 Task ，也会执行。

\n
defaultTasks 'clean', 'run'\n\ntask clean {\n    doLast {\n        println 'Default Cleaning!'\n    }\n}\n\ntask run {\n    doLast {\n        println 'Default Running!'\n    }\n}
\n

Gradle 本身也内置了很多 Task 比如 copy（复制文件）、delete（删除文件）。

\n
task deleteFile(type: Delete) {\n    delete \"C:\\\\Users\\\\guide\\\\Desktop\\\\test\"\n}
\n

Gradle 插件

\n

Gradle 提供的是一套核心的构建机制，而 Gradle 插件则是运行在这套机制上的一些具体构建逻辑，其本质上和 .gradle 文件是相同。你可以将 Gradle 插件看作是封装了一系列 Task 并执行的工具。

\n

Gradle 插件主要分为两类：

\n\n

虽然 Gradle 插件与 .gradle 文件本质上没有区别，.gradle 文件也能实现 Gradle 插件类似的功能。但是，Gradle 插件使用了独立模块封装构建逻辑，无论是从开发开始使用来看，Gradle 插件的整体体验都更友好。

\n\n

Gradle 构建生命周期

\n

Gradle 构建的生命周期有三个阶段：初始化阶段，配置阶段和运行阶段。

\n

\n

在初始化阶段与配置阶段之间、配置阶段结束之后、执行阶段结束之后，我们都可以加一些定制化的 Hook。

\n

\n

初始化阶段

\n

Gradle 支持单项目和多项目构建。在初始化阶段，Gradle 确定哪些项目将参与构建，并为每个项目创建一个 Project 实例 。本质上也就是执行 settings.gradle 脚本，从而读取整个项目中有多少个 Project 实例。

\n

配置阶段

\n

在配置阶段，Gradle 会解析每个工程的 build.gradle 文件，创建要执行的任务子集和确定各种任务之间的关系，以供执行阶段按照顺序执行，并对任务的做一些初始化配置。

\n

每个 build.gradle 对应一个 Project 对象，配置阶段执行的代码包括 build.gradle 中的各种语句、闭包以及 Task 中的配置语句。

\n

在配置阶段结束后，Gradle 会根据 Task 的依赖关系会创建一个 有向无环图 。

\n

运行阶段

\n

在运行阶段，Gradle 根据配置阶段创建和配置的要执行的任务子集，执行任务。

\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/csdn/efa7a0006b04051e2b84cd116c6ccdfc.png", "date_published": "2023-02-02T10:43:22.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "开发工具" ] }, { "title": "MySQL自增主键一定是连续的吗？", "url": "https://javaguide.cn/database/mysql/mysql-auto-increment-primary-key-continuous.html", "id": "https://javaguide.cn/database/mysql/mysql-auto-increment-primary-key-continuous.html", "summary": "详解MySQL自增主键不连续的原因，分析唯一键冲突、事务回滚、批量插入等场景下自增值的分配机制，以及InnoDB自增锁模式的配置与影响。", "content_html": "
\n

作者：飞天小牛肉

\n

原文：https://mp.weixin.qq.com/s/qci10h9rJx_COZbHV3aygQ

\n
\n

众所周知，自增主键可以让聚集索引尽量地保持递增顺序插入，避免了随机查询，从而提高了查询效率。

\n

但实际上，MySQL 的自增主键并不能保证一定是连续递增的。

\n

下面举个例子来看下，如下所示创建一张表：

\n

\n

自增值保存在哪里？

\n

使用 insert into test_pk values(null, 1, 1) 插入一行数据，再执行 show create table 命令来看一下表的结构定义：

\n

\n

上述表的结构定义存放在后缀名为 .frm 的本地文件中，在 MySQL 安装目录下的 data 文件夹下可以找到这个 .frm 文件：

\n

\n

从上述表结构可以看到，表定义里面出现了一个 AUTO_INCREMENT=2，表示下一次插入数据时，如果需要自动生成自增值，会生成 id = 2。

\n

但需要注意的是，自增值并不会保存在这个表结构也就是 .frm 文件中，不同的引擎对于自增值的保存策略不同：

\n

1）MyISAM 引擎的自增值保存在数据文件中

\n

2）InnoDB 引擎的自增值，其实是保存在了内存里，并没有持久化。第一次打开表的时候，都会去找自增值的最大值 max(id)，然后将 max(id)+1 作为这个表当前的自增值。

\n

举个例子：我们现在表里当前数据行里最大的 id 是 1，AUTO_INCREMENT=2，对吧。这时候，我们删除 id=1 的行，AUTO_INCREMENT 还是 2。

\n

\n

但如果马上重启 MySQL 实例，重启后这个表的 AUTO_INCREMENT 就会变成 1。 也就是说，MySQL 重启可能会修改一个表的 AUTO_INCREMENT 的值。

\n

\n

\n

以上，是在我本地 MySQL 5.x 版本的实验，实际上，到了 MySQL 8.0 版本后，自增值的变更记录被放在了 redo log 中，提供了自增值持久化的能力 ，也就是实现了“如果发生重启，表的自增值可以根据 redo log 恢复为 MySQL 重启前的值”

\n

也就是说对于上面这个例子来说，重启实例后这个表的 AUTO_INCREMENT 仍然是 2。

\n

理解了 MySQL 自增值到底保存在哪里以后，我们再来看看自增值的修改机制，并以此引出第一种自增值不连续的场景。

\n

自增值不连续的场景

\n

自增值不连续场景 1

\n

在 MySQL 里面，如果字段 id 被定义为 AUTO_INCREMENT，在插入一行数据的时候，自增值的行为如下：

\n\n

根据要插入的值和当前自增值的大小关系，自增值的变更结果也会有所不同。假设某次要插入的值是 insert_num，当前的自增值是 autoIncrement_num：

\n\n

也就是说，如果插入的 id 是 100，当前的自增值是 90，insert_num >= autoIncrement_num，那么自增值就会被修改为新的自增值即 101

\n

一定是这样吗？

\n

非也~

\n

了解过分布式 id 的小伙伴一定知道，为了避免两个库生成的主键发生冲突，我们可以让一个库的自增 id 都是奇数，另一个库的自增 id 都是偶数

\n

这个奇数偶数其实是通过 auto_increment_offset 和 auto_increment_increment 这两个参数来决定的，这俩分别用来表示自增的初始值和步长，默认值都是 1。

\n

所以，上面的例子中生成新的自增值的步骤实际是这样的：从 auto_increment_offset 开始，以 auto_increment_increment 为步长，持续叠加，直到找到第一个大于 100 的值，作为新的自增值。

\n

所以，这种情况下，自增值可能会是 102，103 等等之类的，就会导致不连续的主键 id。

\n

更遗憾的是，即使在自增初始值和步长这两个参数都设置为 1 的时候，自增主键 id 也不一定能保证主键是连续的

\n

自增值不连续场景 2

\n

举个例子，我们现在往表里插入一条 (null,1,1) 的记录，生成的主键是 1，AUTO_INCREMENT= 2，对吧

\n

\n

这时我再执行一条插入 (null,1,1) 的命令，很显然会报错 Duplicate entry，因为我们设置了一个唯一索引字段 a：

\n

\n

但是，你会惊奇的发现，虽然插入失败了，但自增值仍然从 2 增加到了 3！

\n

这是为啥？

\n

我们来分析下这个 insert 语句的执行流程：

\n
    \n
  1. 执行器调用 InnoDB 引擎接口准备插入一行记录 (null,1,1);
    2. \n
  2. InnoDB 发现用户没有指定自增 id 的值，则获取表 test_pk 当前的自增值 2；
    3. \n
  3. 将传入的记录改成 (2,1,1);
    4. \n
  4. 将表的自增值改成 3；
    5. \n
  5. 继续执行插入数据操作，由于已经存在 a=1 的记录，所以报 Duplicate key error，语句返回
    6. \n
\n

可以看到，自增值修改的这个操作，是在真正执行插入数据的操作之前。

\n

这个语句真正执行的时候，因为碰到唯一键 a 冲突，所以 id = 2 这一行并没有插入成功，但也没有将自增值再改回去。所以，在这之后，再插入新的数据行时，拿到的自增 id 就是 3。也就是说，出现了自增主键不连续的情况。

\n

至此，我们已经罗列了两种自增主键不连续的情况：

\n
    \n
  1. 自增初始值和自增步长设置不为 1
    2. \n
  2. 唯一键冲突
    3. \n
\n

除此之外，事务回滚也会导致这种情况

\n

自增值不连续场景 3

\n

我们现在表里有一行 (1,1,1) 的记录，AUTO_INCREMENT = 3：

\n

\n

我们先插入一行数据 (null, 2, 2)，也就是 (3, 2, 2) 嘛，并且 AUTO_INCREMENT 变为 4：

\n

\n

再去执行这样一段 SQL：

\n

\n

虽然我们插入了一条 (null, 3, 3) 记录，但是使用 rollback 进行回滚了，所以数据库中是没有这条记录的：

\n

\n

在这种事务回滚的情况下，自增值并没有同样发生回滚！如下图所示，自增值仍然固执地从 4 增加到了 5：

\n

\n

所以这时候我们再去插入一条数据（null, 3, 3）的时候，主键 id 就会被自动赋为 5 了：

\n

\n

那么，为什么在出现唯一键冲突或者回滚的时候，MySQL 没有把表的自增值改回去呢？回退回去的话不就不会发生自增 id 不连续了吗？

\n

事实上，这么做的主要原因是为了提高性能。

\n

我们直接用反证法来验证：假设 MySQL 在事务回滚的时候会把自增值改回去，会发生什么？

\n

现在有两个并行执行的事务 A 和 B，在申请自增值的时候，为了避免两个事务申请到相同的自增 id，肯定要加锁，然后顺序申请，对吧。

\n
    \n
  1. 假设事务 A 申请到了 id = 1， 事务 B 申请到 id=2，那么这时候表 t 的自增值是 3，之后继续执行。
    2. \n
  2. 事务 B 正确提交了，但事务 A 出现了唯一键冲突，也就是 id = 1 的那行记录插入失败了，那如果允许事务 A 把自增 id 回退，也就是把表的当前自增值改回 1，那么就会出现这样的情况：表里面已经有 id = 2 的行，而当前的自增 id 值是 1。
    3. \n
  3. 接下来，继续执行的其他事务就会申请到 id=2。这时，就会出现插入语句报错“主键冲突”。
    4. \n
\n

\n

而为了解决这个主键冲突，有两种方法：

\n
    \n
  1. 每次申请 id 之前，先判断表里面是否已经存在这个 id，如果存在，就跳过这个 id
    2. \n
  2. 把自增 id 的锁范围扩大，必须等到一个事务执行完成并提交，下一个事务才能再申请自增 id
    3. \n
\n

很显然，上述两个方法的成本都比较高，会导致性能问题。而究其原因呢，是我们假设的这个 “允许自增 id 回退”。

\n

因此，InnoDB 放弃了这个设计，语句执行失败也不回退自增 id。也正是因为这样，所以才只保证了自增 id 是递增的，但不保证是连续的。

\n

综上，已经分析了三种自增值不连续的场景，还有第四种场景：批量插入数据。

\n

自增值不连续场景 4

\n

对于批量插入数据的语句，MySQL 有一个批量申请自增 id 的策略：

\n
    \n
  1. 语句执行过程中，第一次申请自增 id，会分配 1 个；
    2. \n
  2. 1 个用完以后，这个语句第二次申请自增 id，会分配 2 个；
    3. \n
  3. 2 个用完以后，还是这个语句，第三次申请自增 id，会分配 4 个；
    4. \n
  4. 依此类推，同一个语句去申请自增 id，每次申请到的自增 id 个数都是上一次的两倍。
    5. \n
\n

注意，这里说的批量插入数据，不是在普通的 insert 语句里面包含多个 value 值！！！，因为这类语句在申请自增 id 的时候，是可以精确计算出需要多少个 id 的，然后一次性申请，申请完成后锁就可以释放了。

\n

而对于 insert … select、replace …… select 和 load data 这种类型的语句来说，MySQL 并不知道到底需要申请多少 id，所以就采用了这种批量申请的策略，毕竟一个一个申请的话实在太慢了。

\n

举个例子，假设我们现在这个表有下面这些数据：

\n

\n

我们创建一个和当前表 test_pk 有相同结构定义的表 test_pk2：

\n

\n

然后使用 insert...select 往 teset_pk2 表中批量插入数据：

\n

\n

可以看到，成功导入了数据。

\n

再来看下 test_pk2 的自增值是多少：

\n

\n

如上分析，是 8 而不是 6

\n

具体来说，insert……select 实际上往表中插入了 5 行数据 （1 1）（2 2）（3 3）（4 4）（5 5）。但是，这五行数据是分三次申请的自增 id，结合批量申请策略，每次申请到的自增 id 个数都是上一次的两倍，所以：

\n\n

由于这条语句实际只用上了 5 个 id，所以 id=6 和 id=7 就被浪费掉了。之后，再执行 insert into test_pk2 values(null,6,6)，实际上插入的数据就是（8,6,6)：

\n

\n

小结

\n

本文总结下自增值不连续的 4 个场景：

\n
    \n
  1. 自增初始值和自增步长设置不为 1
    2. \n
  2. 唯一键冲突
    3. \n
  3. 事务回滚
    4. \n
  4. 批量插入（如 insert...select 语句）
    5. \n
\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/p3-juejin/3e6b80ba50cb425386b80924e3da0d23~tplv-k3u1fbpfcp-zoom-1.png", "date_published": "2023-02-02T09:54:04.000Z", "date_modified": "2026-03-23T08:33:10.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "乐观锁和悲观锁详解", "url": "https://javaguide.cn/java/concurrent/optimistic-lock-and-pessimistic-lock.html", "id": "https://javaguide.cn/java/concurrent/optimistic-lock-and-pessimistic-lock.html", "summary": "乐观锁与悲观锁深度对比：详解synchronized/ReentrantLock悲观锁实现、CAS/版本号乐观锁机制、适用场景分析、性能对比与选型建议。", "content_html": "

如果将悲观锁（Pessimistic Lock）和乐观锁（Optimistic Lock）对应到现实生活中来。悲观锁有点像是一位比较悲观（也可以说是未雨绸缪）的人，总是会假设最坏的情况，避免出现问题。乐观锁有点像是一位比较乐观的人，总是会假设最好的情况，在要出现问题之前快速解决问题。

\n

什么是悲观锁？

\n

悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。

\n

像 Java 中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

\n
public void performSynchronisedTask() {\n    synchronized (this) {\n        // 需要同步的操作\n    }\n}\n\nprivate Lock lock = new ReentrantLock();\nlock.lock();\ntry {\n   // 需要同步的操作\n} finally {\n    lock.unlock();\n}
\n

高并发的场景下，激烈的锁竞争会造成线程阻塞，大量阻塞线程会导致系统的上下文切换，增加系统的性能开销。并且，悲观锁还可能会存在死锁问题（线程获得锁的顺序不当时），影响代码的正常运行。

\n

什么是乐观锁？

\n

乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的资源（也就是数据）是否被其它线程修改了（具体方法可以使用版本号机制或 CAS 算法）。

\n

在 Java 中java.util.concurrent.atomic包下面的原子变量类（比如AtomicInteger、LongAdder）就是使用了乐观锁的一种实现方式 CAS 实现的。
\n\"JUC原子类概览\"

\n
// LongAdder 在高并发场景下会比 AtomicInteger 和 AtomicLong 的性能更好\n// 代价就是会消耗更多的内存空间（空间换时间）\nLongAdder sum = new LongAdder();\nsum.increment();
\n

高并发的场景下，乐观锁相比悲观锁来说，不存在锁竞争造成线程阻塞，也不会有死锁问题，在性能上往往会更胜一筹。但是，如果冲突频繁发生（写占比非常多的情况），会频繁失败并重试，这样同样会非常影响性能，导致 CPU 飙升。

\n

不过，大量失败重试的问题也是可以解决的，像我们前面提到的 LongAdder以空间换时间的方式就解决了这个问题。

\n

理论上来说：

\n\n

如何实现乐观锁？

\n

乐观锁一般会使用版本号机制或 CAS 算法实现，CAS 算法相对来说更多一些，这里需要格外注意。

\n

版本号机制

\n

一般是在数据表中加上一个数据版本号 version 字段，表示数据被修改的次数。当数据被修改时，version 值会加一。当线程 A 要更新数据值时，在读取数据的同时也会读取 version 值，在提交更新时，若刚才读取到的 version 值为当前数据库中的 version 值相等时才更新，否则重试更新操作，直到更新成功。

\n

举一个简单的例子：假设数据库中帐户信息表中有一个 version 字段，当前值为 1 ；而当前帐户余额字段（ balance ）为 $100 。

\n
    \n
  1. 操作员 A 此时将其读出（ version=1 ），并从其帐户余额中扣除 $50（ $100-$50 ）。
    2. \n
  2. 在操作员 A 操作的过程中，操作员 B 也读入此用户信息（ version=1 ），并从其帐户余额中扣除 $20 （ $100-$20 ）。
    3. \n
  3. 操作员 A 完成了修改工作，将数据版本号（ version=1 ），连同帐户扣除后余额（ balance=$50 ），提交至数据库更新，此时由于提交数据版本等于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。
    4. \n
  4. 操作员 B 完成了操作，也将版本号（ version=1 ）试图向数据库提交数据（ balance=$80 ），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 1 ，而数据库记录当前版本为 2 ，不满足 “ 提交版本必须等于当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。
    5. \n
\n

这样就避免了操作员 B 用基于 version=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能。

\n

CAS 算法

\n

CAS 的全称是 Compare And Swap（比较与交换） ，用于实现乐观锁，被广泛应用于各大框架中。CAS 的思想很简单，就是用一个预期值和要更新的变量值进行比较，两值相等才会进行更新。

\n

CAS 是一个原子操作，底层依赖于一条 CPU 的原子指令。

\n
\n

原子操作 即最小不可拆分的操作，也就是说操作一旦开始，就不能被打断，直到操作完成。

\n
\n

CAS 涉及到三个操作数：

\n\n

当且仅当 V 的值等于 E 时，CAS 通过原子方式用新值 N 来更新 V 的值。如果不等，说明已经有其它线程更新了 V，则当前线程放弃更新。

\n

举一个简单的例子：线程 A 要修改变量 i 的值为 6，i 原值为 1（V = 1，E=1，N=6，假设不存在 ABA 问题）。

\n
    \n
  1. i 与 1 进行比较，如果相等， 则说明没被其他线程修改，可以被设置为 6 。
    2. \n
  2. i 与 1 进行比较，如果不相等，则说明被其他线程修改，当前线程放弃更新，CAS 操作失败。
    3. \n
\n

当多个线程同时使用 CAS 操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。

\n

关于 CAS 的进一步介绍，可以阅读读者写的这篇文章：CAS 详解，其中详细提到了 Java 中 CAS 的实现以及 CAS 存在的一些问题。

\n

总结

\n

本文详细介绍了乐观锁和悲观锁的概念以及乐观锁常见实现方式：

\n\n

悲观锁和乐观锁各有优缺点，适用于不同的应用场景。在实际开发中，选择合适的锁机制能够有效提升系统的并发性能和稳定性。

\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/JUC%E5%8E%9F%E5%AD%90%E7%B1%BB%E6%A6%82%E8%A7%88-20230814005211968.png", "date_published": "2023-01-31T08:27:36.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Elasticsearch常见面试题总结(付费)", "url": "https://javaguide.cn/database/elasticsearch/elasticsearch-questions-01.html", "id": "https://javaguide.cn/database/elasticsearch/elasticsearch-questions-01.html", "summary": "Elasticsearch常见面试题总结，涵盖ES核心概念、倒排索引原理、分片与副本机制、查询DSL、聚合分析、集群调优等高频面试知识点。", "content_html": "

Elasticsearch 相关的面试题为我的知识星球（点击链接即可查看详细介绍以及加入方法）专属内容，已经整理到了《Java 面试指北》中。

\n

\n

这本《Java 面试指北》（后端面试通用）的内容经过反复打磨，质量极高，旨在帮助每一位 Java/后端求职者从容应对面试挑战。

\n

用数据说话： 截至目前，专栏累计阅读量已突破 477.1W，收获点赞 5,118 个，评论互动 1,657 条。值得一提的是，评论区不仅仅是留言板，更是答疑区——几乎每一条提问，我都会用心回复，确保无疑问遗留。

\n

\n

《Java 面试指北》（点击链接即可查看详细介绍）的部分内容展示如下，你可以将其看作是 JavaGuide 的补充完善，两者可以配合使用。

\n

\"《Java

\n

下面是《Java 面试指北》收到的部分球友的真实反馈：

\n

\"《Java

\n

如果需要面试辅导（比如简历优化、一对一模拟问答、高频考点突击资料等），欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽然是白菜价（0.4 元/天），但质量很高、服务也很全面，主打一个良心！

\n

下面是星球提供的部分服务（点击下方图片即可获取知识星球的详细介绍）：

\n

\"星球服务\"

\n

下面是今年收到了部分好评，每一条都是真实存在的。我看到很多培训班或者机构通过虚构一些不存在的好评来欺骗他人购买高价服务（行业内非常常见），真的很难理解。

\n

\"球友对星球的真实评价\"

\n

我有自己的原则，不割韭菜，用心做内容，真心希望帮助到你！ 如果你感兴趣的话，不妨花 3 分钟左右看看星球的详细介绍：JavaGuide 知识星球详细介绍 。

\n

这里再送一张 30 元的星球专属优惠券，数量有限（价格即将上调。老用户续费半价 ，微信扫码即可续费）！

\n

\"知识星球30元优惠卷\"

\n

🚀 入圈必做（干货满满，一定要看！）：

\n
    \n
  1. 星球使用指南
    2. \n
  2. 优质主题汇总
    3. \n
\n

无任何套路，无任何潜在收费项。用心做内容，不割韭菜！

\n

不过， 一定要确定需要再进 。并且， 三天之内觉得内容不满意可以全额退款 。

\n", "image": "https://oss.javaguide.cn/javamianshizhibei/elasticsearch-questions.png", "date_published": "2023-01-29T03:31:13.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "MySQL执行计划分析", "url": "https://javaguide.cn/database/mysql/mysql-query-execution-plan.html", "id": "https://javaguide.cn/database/mysql/mysql-query-execution-plan.html", "summary": "详解MySQL EXPLAIN执行计划的各列含义，包括id、select_type、type、key、rows、Extra等关键字段解读，帮助你分析SQL性能瓶颈并进行针对性优化。", "content_html": "

优化 SQL 的第一步应该是读懂 SQL 的执行计划。本篇文章，我们一起来学习下 MySQL EXPLAIN 执行计划相关知识。

\n
\n

版本说明：本文内容基于 MySQL 5.7+ 和 8.0+ 版本。filtered 和 partitions 列在 MySQL 5.7+ 可用，EXPLAIN ANALYZE 和 Hash Join 特性需要 MySQL 8.0.18+ 和 8.0.20+。

\n
\n

什么是执行计划？

\n

执行计划 是指一条 SQL 语句在经过 MySQL 查询优化器 的优化后，具体的执行方式。

\n

执行计划通常用于 SQL 性能分析、优化等场景。通过 EXPLAIN 的结果，可以了解到如数据表的查询顺序、数据查询操作的操作类型、哪些索引可以被命中、哪些索引实际会命中、每个数据表有多少行记录被查询等信息。

\n

如何获取执行计划？

\n

MySQL 为我们提供了 EXPLAIN 命令，来获取执行计划的相关信息。

\n

需要注意的是，标准 EXPLAIN 语句并不会真的去执行相关的语句，而是通过查询优化器对语句进行分析，找出最优的查询方案，并显示对应的信息。

\n

MySQL 8.0.18 引入了 EXPLAIN ANALYZE，它会真正执行查询并输出每个步骤的实际耗时与行数，比标准 EXPLAIN 的估算数据更可靠，适合在测试环境深度排查慢查询：

\n
mysql> EXPLAIN ANALYZE SELECT * FROM users WHERE age = 25\\G\n*************************** 1. row ***************************\nEXPLAIN: -> Covering index lookup on users using idx_age_score_name (age=25)\n(cost=1.52 rows=12) (actual time=0.0272..0.0344 rows=12 loops=1)
\n

此外，EXPLAIN FORMAT=JSON 可以输出优化器的成本模型数据（query_cost），比表格形式更能反映各步骤的实际代价，在多表 JOIN 或子查询调优时尤为有用：

\n
mysql> EXPLAIN FORMAT=JSON SELECT * FROM users WHERE age = 25\\G\n*************************** 1. row ***************************\nEXPLAIN: {\n  \"query_block\": {\n    \"select_id\": 1,\n    \"cost_info\": {\n      \"query_cost\": \"1.52\"\n    },\n    \"table\": {\n      \"table_name\": \"users\",\n      \"access_type\": \"ref\",\n      \"key\": \"idx_age_score_name\",\n      \"rows_examined_per_scan\": 12,\n      \"filtered\": \"100.00\",\n      \"using_index\": true\n    }\n  }\n}
\n

EXPLAIN 执行计划支持 SELECT、DELETE、INSERT、REPLACE 以及 UPDATE 语句。我们一般多用于分析 SELECT 查询语句，使用起来非常简单，语法如下：

\n
EXPLAIN SELECT 查询语句；
\n

我们简单来看下一条查询语句的执行计划：

\n

示例 1：单表查询（使用索引）

\n
-- 表结构：users(id, age, score, name, address)，联合索引 idx_age_score_name(age, score, name)\nmysql> EXPLAIN SELECT * FROM users WHERE age = 25;\n+
\n
", "date_published": "2023-01-14T10:33:11.000Z", "date_modified": "2026-03-10T15:38:18.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "NoSQL基础知识总结", "url": "https://javaguide.cn/database/nosql.html", "id": "https://javaguide.cn/database/nosql.html", "summary": "NoSQL数据库基础知识总结，包括NoSQL与SQL的区别、NoSQL的优势、四种NoSQL数据库类型（键值、文档、图形、宽列）及其代表产品Redis、MongoDB、Neo4j等的应用场景。", "content_html": "

NoSQL 是什么？

\n

NoSQL（Not Only SQL 的缩写）泛指非关系型的数据库，主要针对的是键值、文档以及图形类型数据存储。并且，NoSQL 数据库天生支持分布式，数据冗余和数据分片等特性，旨在提供可扩展的高可用高性能数据存储解决方案。

\n

一个常见的误解是 NoSQL 数据库或非关系型数据库不能很好地存储关系型数据。NoSQL 数据库可以存储关系型数据—它们与关系型数据库的存储方式不同。

\n

NoSQL 数据库代表：HBase、Cassandra、MongoDB、Redis。

\n

\n

SQL 和 NoSQL 有什么区别？

\n

| | SQL 数据库 | NoSQL 数据库 |
\n| :

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/mongodb/sql-nosql-tushi.png", "date_published": "2023-01-12T09:46:41.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "MongoDB常见面试题总结（上）", "url": "https://javaguide.cn/database/mongodb/mongodb-questions-01.html", "id": "https://javaguide.cn/database/mongodb/mongodb-questions-01.html", "summary": "MongoDB常见面试题总结上篇，详解MongoDB基础概念、存储结构、数据类型、副本集高可用、分片集群水平扩展等核心知识点，助力后端面试准备。", "content_html": "
\n

少部分内容参考了 MongoDB 官方文档的描述，在此说明一下。

\n
\n

MongoDB 基础

\n

MongoDB 是什么？

\n

MongoDB 是一个基于 分布式文件存储 的开源 NoSQL 数据库系统，由 C++ 编写的。MongoDB 提供了 面向文档 的存储方式，操作起来比较简单和容易，支持“无模式”的数据建模，可以存储比较复杂的数据类型，是一款非常流行的 文档类型数据库 。

\n

在高负载的情况下，MongoDB 天然支持水平扩展和高可用，可以很方便地添加更多的节点/实例，以保证服务性能和可用性。在许多场景下，MongoDB 可以用于代替传统的关系型数据库或键/值存储方式，皆在为 Web 应用提供可扩展的高可用高性能数据存储解决方案。

\n

MongoDB 的存储结构是什么？

\n

MongoDB 的存储结构区别于传统的关系型数据库，主要由如下三个单元组成：

\n\n

也就是说，MongoDB 将数据记录存储为文档 （更具体来说是BSON 文档），这些文档在集合中聚集在一起，数据库中存储一个或多个文档集合。

\n

SQL 与 MongoDB 常见术语对比：

\n

| SQL | MongoDB |
\n|

\n", "image": "https://oss.javaguide.cn/github/javaguide/database/mongodb/crud-annotated-document..png", "date_published": "2023-01-12T09:46:41.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "MongoDB常见面试题总结（下）", "url": "https://javaguide.cn/database/mongodb/mongodb-questions-02.html", "id": "https://javaguide.cn/database/mongodb/mongodb-questions-02.html", "summary": "MongoDB常见面试题总结下篇，深入讲解MongoDB各类索引（单字段、复合、多键、文本、地理位置、TTL）的原理、使用场景和查询优化技巧。", "content_html": "

MongoDB 索引

\n

MongoDB 索引有什么用?

\n

和关系型数据库类似，MongoDB 中也有索引。索引的目的主要是用来提高查询效率，如果没有索引的话，MongoDB 必须执行 集合扫描 ，即扫描集合中的每个文档，以选择与查询语句匹配的文档。如果查询存在合适的索引，MongoDB 可以使用该索引来限制它必须检查的文档数量。并且，MongoDB 可以使用索引中的排序返回排序后的结果。

\n

虽然索引可以显著缩短查询时间，但是使用索引、维护索引是有代价的。在执行写入操作时，除了要更新文档之外，还必须更新索引，这必然会影响写入的性能。因此，当有大量写操作而读操作少时，或者不考虑读操作的性能时，都不推荐建立索引。

\n

MongoDB 支持哪些类型的索引？

\n

MongoDB 支持多种类型的索引，包括单字段索引、复合索引、多键索引、哈希索引、文本索引、 地理位置索引等，每种类型的索引有不同的使用场合。

\n\n

复合索引中字段的顺序有影响吗？

\n

复合索引中字段的顺序非常重要，例如下图中的复合索引由{userid:1, score:-1}组成，则该复合索引首先按照userid升序排序；然后再每个userid的值内，再按照score降序排序。

\n

\"复合索引\"

\n

在复合索引中，按照何种方式排序，决定了该索引在查询中是否能被应用到。

\n

走复合索引的排序：

\n
db.s2.find().sort({\"userid\": 1, \"score\": -1})\ndb.s2.find().sort({\"userid\": -1, \"score\": 1})
\n

不走复合索引的排序：

\n
db.s2.find().sort({\"userid\": 1, \"score\": 1})\ndb.s2.find().sort({\"userid\": -1, \"score\": -1})\ndb.s2.find().sort({\"score\": 1, \"userid\": -1})\ndb.s2.find().sort({\"score\": 1, \"userid\": 1})\ndb.s2.find().sort({\"score\": -1, \"userid\": -1})\ndb.s2.find().sort({\"score\": -1, \"userid\": 1})
\n

我们可以通过 explain 进行分析：

\n
db.s2.find().sort({\"score\": -1, \"userid\": 1}).explain()
\n

复合索引遵循左前缀原则吗？

\n

MongoDB 的复合索引遵循左前缀原则：拥有多个键的索引，可以同时得到所有这些键的前缀组成的索引，但不包括除左前缀之外的其他子集。比如说，有一个类似 {a: 1, b: 1, c: 1, ..., z: 1} 这样的索引，那么实际上也等于有了 {a: 1}、{a: 1, b: 1}、{a: 1, b: 1, c: 1} 等一系列索引，但是不会有 {b: 1} 这样的非左前缀的索引。

\n

什么是 TTL 索引？

\n

TTL 索引提供了一个过期机制，允许为每一个文档设置一个过期时间 expireAfterSeconds ，当一个文档达到预设的过期时间之后就会被删除。TTL 索引除了有 expireAfterSeconds 属性外，和普通索引一样。

\n

数据过期对于某些类型的信息很有用，比如机器生成的事件数据、日志和会话信息，这些信息只需要在数据库中保存有限的时间。

\n

TTL 索引运行原理：

\n\n

TTL 索引限制：

\n\n

什么是覆盖索引查询？

\n

根据官方文档介绍，覆盖查询是以下的查询：

\n\n

由于所有出现在查询中的字段是索引的一部分， MongoDB 无需在整个数据文档中检索匹配查询条件和返回使用相同索引的查询结果。因为索引存在于内存中，从索引中获取数据比通过扫描文档读取数据要快得多。

\n

举个例子：我们有如下 users 集合:

\n
{\n   \"_id\": ObjectId(\"53402597d852426020000002\"),\n   \"contact\": \"987654321\",\n   \"dob\": \"01-01-1991\",\n   \"gender\": \"M\",\n   \"name\": \"Tom Benzamin\",\n   \"user_name\": \"tombenzamin\"\n}
\n

我们在 users 集合中创建联合索引，字段为 gender 和 user_name :

\n
db.users.ensureIndex({gender:1,user_name:1})
\n

现在，该索引会覆盖以下查询：

\n
db.users.find({gender:\"M\"},{user_name:1,_id:0})
\n

为了让指定的索引覆盖查询，必须显式地指定 _id: 0 来从结果中排除 _id 字段，因为索引不包括 _id 字段。

\n

MongoDB 高可用

\n

复制集群

\n

什么是复制集群？

\n

MongoDB 的复制集群又称为副本集群，是一组维护相同数据集合的 mongod 进程。

\n

客户端连接到整个 Mongodb 复制集群，主节点机负责整个复制集群的写，从节点可以进行读操作，但默认还是主节点负责整个复制集群的读。主节点发生故障时，自动从从节点中选举出一个新的主节点，确保集群的正常使用，这对于客户端来说是无感知的。

\n

通常来说，一个复制集群包含 1 个主节点（Primary），多个从节点（Secondary）以及零个或 1 个仲裁节点（Arbiter）。

\n\n

下图是一个典型的三成员副本集群：

\n

\n

主节点与备节点之间是通过 oplog（操作日志） 来同步数据的。oplog 是 local 库下的一个特殊的 上限集合(Capped Collection) ，用来保存写操作所产生的增量日志，类似于 MySQL 中 的 Binlog。

\n
\n

上限集合类似于定长的循环队列，数据顺序追加到集合的尾部，当集合空间达到上限时，它会覆盖集合中最旧的文档。上限集合的数据将会被顺序写入到磁盘的固定空间内，所以，I/O 速度非常快，如果不建立索引，性能更好。

\n
\n

\n

当主节点上的一个写操作完成后，会向 oplog 集合写入一条对应的日志，而从节点则通过这个 oplog 不断拉取到新的日志，在本地进行回放以达到数据同步的目的。

\n

副本集最多有一个主节点。 如果当前主节点不可用，一个选举会抉择出新的主节点。MongoDB 的节点选举规则能够保证在 Primary 挂掉之后选取的新节点一定是集群中数据最全的一个。

\n

为什么要用复制集群？

\n\n

分片集群

\n

什么是分片集群？

\n

分片集群是 MongoDB 的分布式版本，相较副本集，分片集群数据被均衡的分布在不同分片中， 不仅大幅提升了整个集群的数据容量上限，也将读写的压力分散到不同分片，以解决副本集性能瓶颈的难题。

\n

MongoDB 的分片集群由如下三个部分组成（下图来源于官方文档对分片集群的介绍）：

\n

\n\n

为什么要用分片集群？

\n

随着系统数据量以及吞吐量的增长，常见的解决办法有两种：垂直扩展和水平扩展。

\n

垂直扩展通过增加单个服务器的能力来实现，比如磁盘空间、内存容量、CPU 数量等；水平扩展则通过将数据存储到多个服务器上来实现，根据需要添加额外的服务器以增加容量。

\n

类似于 Redis Cluster，MongoDB 也可以通过分片实现 水平扩展 。水平扩展这种方式更灵活，可以满足更大数据量的存储需求，支持更高吞吐量。并且，水平扩展所需的整体成本更低，仅仅需要相对较低配置的单机服务器即可，代价是增加了部署的基础设施和维护的复杂性。

\n

也就是说当你遇到如下问题时，可以使用分片集群解决：

\n\n

什么是分片键？

\n

分片键（Shard Key） 是数据分区的前提， 从而实现数据分发到不同服务器上，减轻服务器的负担。也就是说，分片键决定了集合内的文档如何在集群的多个分片间的分布状况。

\n

分片键就是文档里面的一个字段，但是这个字段不是普通的字段，有一定的要求：

\n\n

如何选择分片键？

\n

选择合适的片键对 sharding 效率影响很大，主要基于如下四个因素（摘自分片集群使用注意事项 - - 腾讯云文档）：

\n\n

综上，在选择片键时要考虑以上 4 个条件，尽可能满足更多的条件，才能降低 MoveChunks 对性能的影响，从而获得最优的性能体验。

\n

分片策略有哪些？

\n

MongoDB 支持两种分片算法来满足不同的查询需求（摘自MongoDB 分片集群介绍 - 阿里云文档）：

\n

1、基于范围的分片：

\n

\n

MongoDB 按照分片键（Shard Key）的值的范围将数据拆分为不同的块（Chunk），每个块包含了一段范围内的数据。当分片键的基数大、频率低且值非单调变更时，范围分片更高效。

\n\n

2、基于 Hash 值的分片

\n

\n

MongoDB 计算单个字段的哈希值作为索引值，并以哈希值的范围将数据拆分为不同的块（Chunk）。

\n\n

除了上述两种分片策略，您还可以配置 复合片键 ，例如由一个低基数的键和一个单调递增的键组成。

\n

分片数据如何存储？

\n

Chunk（块） 是 MongoDB 分片集群的一个核心概念，其本质上就是由一组 Document 组成的逻辑数据单元。每个 Chunk 包含一定范围片键的数据，互不相交且并集为全部数据，即离散数学中划分的概念。

\n

分片集群不会记录每条数据在哪个分片上，而是记录 Chunk 在哪个分片上一级这个 Chunk 包含哪些数据。

\n

默认情况下，一个 Chunk 的最大值默认为 64MB（可调整，取值范围为 1~1024 MB。如无特殊需求，建议保持默认值），进行数据插入、更新、删除时，如果此时 Mongos 感知到了目标 Chunk 的大小或者其中的数据量超过上限，则会触发 Chunk 分裂。

\n

\"Chunk

\n

数据的增长会让 Chunk 分裂得越来越多。这个时候，各个分片上的 Chunk 数量可能会不平衡。Mongos 中的 均衡器(Balancer) 组件就会执行自动平衡，尝试使各个 Shard 上 Chunk 的数量保持均衡，这个过程就是 再平衡（Rebalance）。默认情况下，数据库和集合的 Rebalance 是开启的。

\n

如下图所示，随着数据插入，导致 Chunk 分裂，让 AB 两个分片有 3 个 Chunk，C 分片只有一个，这个时候就会把 B 分配的迁移一个到 C 分片实现集群数据均衡。

\n

\"Chunk

\n
\n

Balancer 是 MongoDB 的一个运行在 Config Server 的 Primary 节点上(自 MongoDB 3.4 版本起)的后台进程，它监控每个分片上 Chunk 数量，并在某个分片上 Chunk 数量达到阈值进行迁移。

\n
\n

Chunk 只会分裂，不会合并，即使 chunkSize 的值变大。

\n

Rebalance 操作是比较耗费系统资源的，我们可以通过在业务低峰期执行、预分片或者设置 Rebalance 时间窗等方式来减少其对 MongoDB 正常使用所带来的影响。

\n

Chunk 迁移原理是什么？

\n

关于 Chunk 迁移原理的详细介绍，推荐阅读 MongoDB 中文社区的一文读懂 MongoDB chunk 迁移这篇文章。

\n

学习资料推荐

\n\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/database/mongodb/mongodb-composite-index.png", "date_published": "2023-01-12T09:46:41.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "数据库" ] }, { "title": "软件工程简明教程", "url": "https://javaguide.cn/system-design/basis/software-engineering.html", "id": "https://javaguide.cn/system-design/basis/software-engineering.html", "summary": "软件工程基础知识详解，涵盖软件危机、软件开发过程模型、瀑布模型、敏捷开发等软件工程核心概念。", "content_html": "

大部分软件开发从业者，都会忽略软件开发中的一些最基础、最底层的一些概念。但是，这些软件开发的概念对于软件开发来说非常重要，就像是软件开发的基石一样。这也是我写这篇文章的原因。

\n

何为软件工程？

\n

1968 年 NATO（北大西洋公约组织）提出了软件危机（Software crisis）一词。同年，为了解决软件危机问题，“软件工程”的概念诞生了。一门叫做软件工程的学科也就应运而生。

\n

随着时间的推移，软件工程这门学科也经历了一轮又一轮的完善，其中的一些核心内容比如软件开发模型越来越丰富实用！

\n

什么是软件危机呢？

\n

简单来说，软件危机描述了当时软件开发的一个痛点：我们很难高效地开发出质量高的软件。

\n

Dijkstra（Dijkstra 算法的作者） 在 1972 年图灵奖获奖感言中也提到过软件危机，他是这样说的：“导致软件危机的主要原因是机器变得功能强大了几个数量级！坦率地说：只要没有机器，编程就完全没有问题。当我们有一些弱小的计算机时，编程成为一个温和的问题，而现在我们有了庞大的计算机，编程也同样成为一个巨大的问题”。

\n

说了这么多，到底什么是软件工程呢？

\n

工程是为了解决实际的问题将理论应用于实践。软件工程指的就是将工程思想应用于软件开发。

\n

上面是我对软件工程的定义，我们再来看看比较权威的定义。IEEE 软件工程汇刊给出的定义是这样的：　(1)将系统化的、规范的、可量化的方法应用到软件的开发、运行及维护中，即将工程化方法应用于软件。　(2)在(1)中所述方法的研究。

\n

总之，软件工程的终极目标就是：在更少资源消耗的情况下，创造出更好、更容易维护的软件。

\n

软件开发过程

\n

维基百科是这样定义软件开发过程的：

\n
\n

软件开发过程（英语：software development process），或软件过程（英语：software process），是软件开发的开发生命周期（software development life cycle），其各个阶段实现了软件的需求定义与分析、设计、实现、测试、交付和维护。软件过程是在开发与构建系统时应遵循的步骤，是软件开发的路线图。

\n
\n\n

软件开发过程只是比较笼统的层面上，定义了一个软件开发可能涉及到的一些流程。

\n

软件开发模型更具体地定义了软件开发过程，对开发过程提供了强有力的理论支持。

\n

软件开发模型

\n

软件开发模型有很多种，比如瀑布模型（Waterfall Model）、快速原型模型（Rapid Prototype Model）、V 模型（V-model）、W 模型（W-model）、敏捷开发模型。其中最具有代表性的还是 瀑布模型 和 敏捷开发 。

\n

瀑布模型 定义了一套完整的软件开发周期，完整地展示了一个软件的生命周期。

\n

\n

敏捷开发模型 是目前使用的最多的一种软件开发模型。MBA 智库百科对敏捷开发的描述是这样的:

\n
\n

敏捷开发 是一种以人为核心、迭代、循序渐进的开发方法。在敏捷开发中，软件项目的构建被切分成多个子项目，各个子项目的成果都经过测试，具备集成和可运行的特征。换言之，就是把一个大项目分为多个相互联系，但也可独立运行的小项目，并分别完成，在此过程中软件一直处于可使用状态。

\n
\n

像现在比较常见的一些概念比如 持续集成、重构、小版本发布、低文档、站会、结对编程、测试驱动开发 都是敏捷开发的核心。

\n

软件开发的基本策略

\n

软件复用

\n

我们在构建一个新的软件的时候，不需要从零开始，通过复用已有的一些轮子（框架、第三方库等）、设计模式、设计原则等等现成的物料，我们可以更快地构建出一个满足要求的软件。

\n

像我们平时接触的开源项目就是最好的例子。我想，如果不是开源，我们构建出一个满足要求的软件，耗费的精力和时间要比现在多的多！

\n

分而治之

\n

构建软件的过程中，我们会遇到很多问题。我们可以将一些比较复杂的问题拆解为一些小问题，然后，一一攻克。

\n

我结合现在比较火的软件设计方法—领域驱动设计（Domain Driven Design，简称 DDD）来说说。

\n

在领域驱动设计中，很重要的一个概念就是领域（Domain），它就是我们要解决的问题。在领域驱动设计中，我们要做的就是把比较大的领域（问题）拆解为若干的小领域（子域）。

\n

除此之外，分而治之也是一个比较常用的算法思想，对应的就是分治算法。如果你想了解分治算法的话，推荐你看一下北大的《算法设计与分析 Design and Analysis of Algorithms》。

\n

逐步演进

\n

软件开发是一个逐步演进的过程，我们需要不断进行迭代式增量开发，最终交付符合客户价值的产品。

\n

这里补充一个在软件开发领域，非常重要的概念：MVP（Minimum Viable Product，最小可行产品）。

\n

这个最小可行产品，可以理解为刚好能够满足客户需求的产品。下面这张图片把这个思想展示的非常精髓。

\n

\n

利用最小可行产品，我们可以也可以提早进行市场分析，这对于我们在探索产品不确定性的道路上非常有帮助。可以非常有效地指导我们下一步该往哪里走。

\n

优化折中

\n

软件开发是一个不断优化改进的过程。任何软件都有很多可以优化的点，不可能完美。我们需要不断改进和提升软件的质量。

\n

但是，也不要陷入这个怪圈。要学会折中，在有限的投入内，以最有效的方式提高现有软件的质量。

\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/system-design/schedule-task/up-264f2750a3d30366e36c375ec3a30ec2775.png", "date_published": "2022-12-30T05:45:11.000Z", "date_modified": "2026-01-16T13:41:03.000Z", "authors": [], "tags": [ "系统设计" ] }, { "title": "Maven核心概念总结", "url": "https://javaguide.cn/tools/maven/maven-core-concepts.html", "id": "https://javaguide.cn/tools/maven/maven-core-concepts.html", "summary": "Apache Maven 的本质是一个软件项目管理和理解工具。基于项目对象模型 (Project Object Model，POM) 的概念，Maven 可以从一条中心信息管理项目的构建、报告和文档。", "content_html": "
\n

这部分内容主要根据 Maven 官方文档整理，做了对应的删减，主要保留比较重要的部分，不涉及实战，主要是一些重要概念的介绍。

\n
\n

Maven 介绍

\n

Maven 官方文档是这样介绍的 Maven 的：

\n
\n

Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

\n

Apache Maven 的本质是一个软件项目管理和理解工具。基于项目对象模型 (Project Object Model，POM) 的概念，Maven 可以从一条中心信息管理项目的构建、报告和文档。

\n
\n

什么是 POM？ 每一个 Maven 工程都有一个 pom.xml 文件，位于根目录中，包含项目构建生命周期的详细信息。通过 pom.xml 文件，我们可以定义项目的坐标、项目依赖、项目信息、插件信息等等配置。

\n

对于开发者来说，Maven 的主要作用主要有 3 个：

\n
    \n
  1. 项目构建：提供标准的、跨平台的自动化项目构建方式。
    2. \n
  2. 依赖管理：方便快捷的管理项目依赖的资源（jar 包），避免资源间的版本冲突问题。
    3. \n
  3. 统一开发结构：提供标准的、统一的项目结构。
    4. \n
\n

关于 Maven 的基本使用这里就不介绍了，建议看看官网的 5 分钟上手 Maven 的教程：Maven in 5 Minutes 。

\n

Maven 坐标

\n

项目中依赖的第三方库以及插件可统称为构件。每一个构件都可以使用 Maven 坐标唯一标识，坐标元素包括：

\n\n

只要你提供正确的坐标，就能从 Maven 仓库中找到相应的构件供我们使用。

\n

举个例子（引入阿里巴巴开源的 EasyExcel）：

\n
<dependency>\n    <groupId>com.alibaba</groupId>\n    <artifactId>easyexcel</artifactId>\n    <version>3.1.1</version>\n</dependency>
\n

你可以在 https://mvnrepository.com/ 这个网站上找到几乎所有可用的构件，如果你的项目使用的是 Maven 作为构建工具，那这个网站你一定会经常接触。

\n

\"Maven

\n

Maven 依赖

\n

如果使用 Maven 构建产生的构件（例如 Jar 文件）被其他的项目引用，那么该构件就是其他项目的依赖。

\n

依赖配置

\n

配置信息示例：

\n
<project>\n    <dependencies>\n        <dependency>\n            <groupId></groupId>\n            <artifactId></artifactId>\n            <version></version>\n            <type>...</type>\n            <scope>...</scope>\n            <optional>...</optional>\n            <exclusions>\n                <exclusion>\n                  <groupId>...</groupId>\n                  <artifactId>...</artifactId>\n                </exclusion>\n          </exclusions>\n        </dependency>\n      </dependencies>\n</project>
\n

配置说明：

\n\n

依赖范围

\n

classpath 用于指定 .class 文件存放的位置，类加载器会从该路径中加载所需的 .class 文件到内存中。

\n

Maven 在编译、执行测试、实际运行有着三套不同的 classpath：

\n\n

Maven 的依赖范围如下：

\n\n

传递依赖性

\n

依赖冲突

\n

1、对于 Maven 而言，同一个 groupId 同一个 artifactId 下，只能使用一个 version。

\n
<dependency>\n    <groupId>in.hocg.boot</groupId>\n    <artifactId>mybatis-plus-spring-boot-starter</artifactId>\n    <version>1.0.48</version>\n</dependency>\n<!-- 只会使用 1.0.49 这个版本的依赖 -->\n<dependency>\n    <groupId>in.hocg.boot</groupId>\n    <artifactId>mybatis-plus-spring-boot-starter</artifactId>\n    <version>1.0.49</version>\n</dependency>
\n

若相同类型但版本不同的依赖存在于同一个 pom 文件，只会引入后一个声明的依赖。

\n

2、项目的两个依赖同时引入了某个依赖。

\n

举个例子，项目存在下面这样的依赖关系：

\n
依赖链路一：A -> B -> C -> X(1.0)\n依赖链路二：A -> D -> X(2.0)
\n

这两条依赖路径上有两个版本的 X，为了避免依赖重复，Maven 只会选择其中的一个进行解析。

\n

哪个版本的 X 会被 Maven 解析使用呢?

\n

Maven 在遇到这种问题的时候，会遵循 路径最短优先 和 声明顺序优先 两大原则。解决这个问题的过程也被称为 Maven 依赖调解 。

\n

路径最短优先

\n
依赖链路一：A -> B -> C -> X(1.0) // dist = 3\n依赖链路二：A -> D -> X(2.0) // dist = 2
\n

依赖链路二的路径最短，因此，X(2.0)会被解析使用。

\n

不过，你也可以发现。路径最短优先原则并不是通用的，像下面这种路径长度相等的情况就不能单单通过其解决了：

\n
依赖链路一：A -> B -> X(1.0) // dist = 2\n依赖链路二：A -> D -> X(2.0) // dist = 2
\n

因此，Maven 又定义了声明顺序优先原则。

\n

依赖调解第一原则不能解决所有问题，比如这样的依赖关系：A->B->Y(1.0)、A-> C->Y(2.0)，Y(1.0)和 Y(2.0)的依赖路径长度是一样的，都为 2。Maven 定义了依赖调解的第二原则：

\n

声明顺序优先

\n

在依赖路径长度相等的前提下，在 pom.xml 中依赖声明的顺序决定了谁会被解析使用，顺序最前的那个依赖优胜。该例中，如果 B 的依赖声明在 D 之前，那么 X (1.0)就会被解析使用。

\n
<!-- A pom.xml -->\n<dependencies>\n    ...\n    dependency B\n    ...\n    dependency D\n</dependencies>
\n

排除依赖

\n

单纯依赖 Maven 来进行依赖调解，在很多情况下是不适用的，需要我们手动排除依赖。

\n

举个例子，当前项目存在下面这样的依赖关系：

\n
依赖链路一：A -> B -> C -> X(1.5) // dist = 3\n依赖链路二：A -> D -> X(1.0) // dist = 2
\n

根据路径最短优先原则，X(1.0) 会被解析使用，也就是说实际用的是 1.0 版本的 X。

\n

但是！！！这会一些问题：如果 C 依赖用到了 1.5 版本的 X 中才有的一个类，运行项目就会报NoClassDefFoundError错误。如果 C 依赖用到了 1.5 版本的 X 中才有的一个方法，运行项目就会报NoSuchMethodError错误。

\n

现在知道为什么你的 Maven 项目总是会报NoClassDefFoundError和NoSuchMethodError错误了吧？

\n

如何解决呢？ 我们可以通过exclusion标签手动将 X(1.0) 给排除。

\n
<dependency>\n    ......\n    <exclusions>\n      <exclusion>\n        <artifactId>x</artifactId>\n        <groupId>org.apache.x</groupId>\n      </exclusion>\n    </exclusions>\n</dependency>
\n

一般我们在解决依赖冲突的时候，都会优先保留版本较高的。这是因为大部分 jar 在升级的时候都会做到向下兼容。

\n

如果高版本修改了低版本的一些类或者方法的话，这个时候就不能直接保留高版本了，而是应该考虑优化上层依赖，比如升级上层依赖的版本。

\n

还是上面的例子：

\n
依赖链路一：A -> B -> C -> X(1.5) // dist = 3\n依赖链路二：A -> D -> X(1.0) // dist = 2
\n

我们保留了 1.5 版本的 X，但是这个版本的 X 删除了 1.0 版本中的某些类。这个时候，我们可以考虑升级 D 的版本到一个 X 兼容的版本。

\n

Maven 仓库

\n

在 Maven 世界中，任何一个依赖、插件或者项目构建的输出，都可以称为 构件 。

\n

坐标和依赖是构件在 Maven 世界中的逻辑表示方式，构件的物理表示方式是文件，Maven 通过仓库来统一管理这些文件。 任何一个构件都有一组坐标唯一标识。有了仓库之后，无需手动引入构件，我们直接给定构件的坐标即可在 Maven 仓库中找到该构件。

\n

Maven 仓库分为：

\n\n

Maven 远程仓库可以分为：

\n\n

Maven 依赖包寻找顺序：

\n
    \n
  1. 先去本地仓库找寻，有的话，直接使用。
    2. \n
  2. 本地仓库没有找到的话，会去远程仓库找寻，下载包到本地仓库。
    3. \n
  3. 远程仓库没有找到的话，会报错。
    4. \n
\n

Maven 生命周期

\n

Maven 的生命周期就是为了对所有的构建过程进行抽象和统一，包含了项目的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等几乎所有构建步骤。

\n

Maven 定义了 3 个生命周期META-INF/plexus/components.xml：

\n\n

这些生命周期是相互独立的，每个生命周期包含多个阶段(phase)。并且，这些阶段是有序的，也就是说，后面的阶段依赖于前面的阶段。当执行某个阶段的时候，会先执行它前面的阶段。

\n

执行 Maven 生命周期的命令格式如下：

\n
mvn 阶段 [阶段2] ...[阶段n]
\n

default 生命周期

\n

default生命周期是在没有任何关联插件的情况下定义的，是 Maven 的主要生命周期，用于构建应用程序，共包含 23 个阶段。

\n
<phases>\n  <!-- 验证项目是否正确，并且所有必要的信息可用于完成构建过程 -->\n  <phase>validate</phase>\n  <!-- 建立初始化状态，例如设置属性 -->\n  <phase>initialize</phase>\n  <!-- 生成要包含在编译阶段的源代码 -->\n  <phase>generate-sources</phase>\n  <!-- 处理源代码 -->\n  <phase>process-sources</phase>\n  <!-- 生成要包含在包中的资源 -->\n  <phase>generate-resources</phase>\n  <!-- 将资源复制并处理到目标目录中，为打包阶段做好准备。 -->\n  <phase>process-resources</phase>\n  <!-- 编译项目的源代码  -->\n  <phase>compile</phase>\n  <!-- 对编译生成的文件进行后处理，例如对 Java 类进行字节码增强/优化 -->\n  <phase>process-classes</phase>\n  <!-- 生成要包含在编译阶段的任何测试源代码 -->\n  <phase>generate-test-sources</phase>\n  <!-- 处理测试源代码 -->\n  <phase>process-test-sources</phase>\n  <!-- 生成要包含在编译阶段的测试源代码 -->\n  <phase>generate-test-resources</phase>\n  <!-- 处理从测试代码文件编译生成的文件 -->\n  <phase>process-test-resources</phase>\n  <!-- 编译测试源代码 -->\n  <phase>test-compile</phase>\n  <!-- 处理从测试代码文件编译生成的文件 -->\n  <phase>process-test-classes</phase>\n  <!-- 使用合适的单元测试框架（Junit 就是其中之一）运行测试 -->\n  <phase>test</phase>\n  <!-- 在实际打包之前，执行任何的必要的操作为打包做准备 -->\n  <phase>prepare-package</phase>\n  <!-- 获取已编译的代码并将其打包成可分发的格式，例如 JAR、WAR 或 EAR 文件 -->\n  <phase>package</phase>\n  <!-- 在执行集成测试之前执行所需的操作。 例如，设置所需的环境 -->\n  <phase>pre-integration-test</phase>\n  <!-- 处理并在必要时部署软件包到集成测试可以运行的环境 -->\n  <phase>integration-test</phase>\n  <!-- 执行集成测试后执行所需的操作。 例如，清理环境  -->\n  <phase>post-integration-test</phase>\n  <!-- 运行任何检查以验证打的包是否有效并符合质量标准。 -->\n  <phase>verify</phase>\n  <!-- \t将包安装到本地仓库中，可以作为本地其他项目的依赖 -->\n  <phase>install</phase>\n  <!-- 将最终的项目包复制到远程仓库中与其他开发者和项目共享 -->\n  <phase>deploy</phase>\n</phases>
\n

根据前面提到的阶段间依赖关系理论，当我们执行 mvn test命令的时候，会执行从 validate 到 test 的所有阶段，这也就解释了为什么执行测试的时候，项目的代码能够自动编译。

\n

clean 生命周期

\n

clean 生命周期的目的是清理项目，共包含 3 个阶段：

\n
    \n
  1. pre-clean
    2. \n
  2. clean
    3. \n
  3. post-clean
    4. \n
\n
<phases>\n  <!--  执行一些需要在clean之前完成的工作 -->\n  <phase>pre-clean</phase>\n  <!--  移除所有上一次构建生成的文件 -->\n  <phase>clean</phase>\n  <!--  执行一些需要在clean之后立刻完成的工作 -->\n  <phase>post-clean</phase>\n</phases>\n<default-phases>\n  <clean>\n    org.apache.maven.plugins:maven-clean-plugin:2.5:clean\n  </clean>\n</default-phases>
\n

根据前面提到的阶段间依赖关系理论，当我们执行 mvn clean 的时候，会执行 clean 生命周期中的 pre-clean 和 clean 阶段。

\n

site 生命周期

\n

site 生命周期的目的是建立和发布项目站点，共包含 4 个阶段：

\n
    \n
  1. pre-site
    2. \n
  2. site
    3. \n
  3. post-site
    4. \n
  4. site-deploy
    5. \n
\n
<phases>\n  <!--  执行一些需要在生成站点文档之前完成的工作 -->\n  <phase>pre-site</phase>\n  <!--  生成项目的站点文档作 -->\n  <phase>site</phase>\n  <!--  执行一些需要在生成站点文档之后完成的工作，并且为部署做准备 -->\n  <phase>post-site</phase>\n  <!--  将生成的站点文档部署到特定的服务器上 -->\n  <phase>site-deploy</phase>\n</phases>\n<default-phases>\n  <site>\n    org.apache.maven.plugins:maven-site-plugin:3.3:site\n  </site>\n  <site-deploy>\n    org.apache.maven.plugins:maven-site-plugin:3.3:deploy\n  </site-deploy>\n</default-phases>
\n

Maven 能够基于 pom.xml 所包含的信息，自动生成一个友好的站点，方便团队交流和发布项目信息。

\n

Maven 插件

\n

Maven 本质上是一个插件执行框架，所有的执行过程，都是由一个一个插件独立完成的。像咱们日常使用到的 install、clean、deploy 等命令，其实底层都是一个一个的 Maven 插件。关于 Maven 的核心插件可以参考官方的这篇文档：https://maven.apache.org/plugins/index.html 。

\n

本地默认插件路径: ${user.home}/.m2/repository/org/apache/maven/plugins

\n

\n

除了 Maven 自带的插件之外，还有一些三方提供的插件比如单测覆盖率插件 jacoco-maven-plugin、帮助开发检测代码中不合规范的地方的插件 maven-checkstyle-plugin、分析代码质量的 sonar-maven-plugin。并且，我们还可以自定义插件来满足自己的需求。

\n

jacoco-maven-plugin 使用示例：

\n
<build>\n  <plugins>\n    <plugin>\n      <groupId>org.jacoco</groupId>\n      <artifactId>jacoco-maven-plugin</artifactId>\n      <version>0.8.8</version>\n      <executions>\n        <execution>\n          <goals>\n            <goal>prepare-agent</goal>\n          </goals>\n        </execution>\n        <execution>\n          <id>generate-code-coverage-report</id>\n          <phase>test</phase>\n          <goals>\n            <goal>report</goal>\n          </goals>\n        </execution>\n      </executions>\n    </plugin>\n  </plugins>\n</build>
\n

你可以将 Maven 插件理解为一组任务的集合，用户可以通过命令行直接运行指定插件的任务，也可以将插件任务挂载到构建生命周期，随着生命周期运行。

\n

Maven 插件被分为下面两种类型：

\n\n

Maven 多模块管理

\n

多模块管理简单地来说就是将一个项目分为多个模块，每个模块只负责单一的功能实现。直观的表现就是一个 Maven 项目中不止有一个 pom.xml 文件，会在不同的目录中有多个 pom.xml 文件，进而实现多模块管理。

\n

多模块管理除了可以更加便于项目开发和管理，还有如下好处：

\n
    \n
  1. 降低代码之间的耦合性（从类级别的耦合提升到 jar 包级别的耦合）；
    2. \n
  2. 减少重复，提升复用性；
    3. \n
  3. 每个模块都可以是自解释的（通过模块名或者模块文档）；
    4. \n
  4. 模块还规范了代码边界的划分，开发者很容易通过模块确定自己所负责的内容。
    5. \n
\n

多模块管理下，会有一个父模块，其他的都是子模块。父模块通常只有一个 pom.xml，没有其他内容。父模块的 pom.xml 一般只定义了各个依赖的版本号、包含哪些子模块以及插件有哪些。不过，要注意的是，如果依赖只在某个子项目中使用，则可以在子项目的 pom.xml 中直接引入，防止父 pom 的过于臃肿。

\n

如下图所示，Dubbo 项目就被分成了多个子模块比如 dubbo-common（公共逻辑模块）、dubbo-remoting（远程通讯模块）、dubbo-rpc（远程调用模块）。

\n

\n

文章推荐

\n\n

参考

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/tools/maven/mvnrepository.com.png", "date_published": "2022-12-16T14:32:28.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "开发工具" ] }, { "title": "项目经验指南", "url": "https://javaguide.cn/interview-preparation/project-experience-guide.html", "id": "https://javaguide.cn/interview-preparation/project-experience-guide.html", "summary": "项目经验指南：针对没有项目/项目平淡的求职者，给出获取实战项目经验的方法与选择建议，并讲清如何做出项目亮点、如何复盘与表达，提升简历与面试竞争力。", "content_html": "
\n

友情提示

\n

本文节选自 《Java 面试指北》。这是一份教你如何更高效地准备面试的专栏，内容和 JavaGuide 互补，涵盖常见八股文（系统设计、常见框架、分布式、高并发 ……）、优质面经等内容。

\n
\n

没有项目经验怎么办?

\n

没有项目经验是大部分应届生会碰到的一个问题。甚至说，有很多有工作经验的程序员，对自己在公司做的项目不满意，也想找一个比较有技术含量的项目来做。

\n

说几种我觉得比较靠谱的获取项目经验的方式，希望能够对你有启发。

\n

实战项目视频/专栏

\n

在网上找一个符合自己能力与找工作需求的实战项目视频或者专栏，跟着老师一起做。

\n

你可以通过慕课网、哔哩哔哩、拉勾、极客时间、培训机构（比如黑马、尚硅谷）等渠道获取到适合自己的实战项目视频/专栏。

\n

\"慕课网实战课\"

\n

尽量选择一个适合自己的项目，没必要必须做分布式/微服务项目，对于绝大部分同学来说，能把一个单机项目做好就已经很不错了。

\n

我面试过很多求职者，简历上看着有微服务的项目经验，结果随便问两个问题就知道根本不是自己做的或者说做的时候压根没认真思考。这种情况会给我留下非常不好的印象。

\n

我在 《Java 面试指北》 的「面试准备篇」中也说过：

\n
\n

个人认为也没必要非要去做微服务或者分布式项目，不一定对你面试有利。微服务或者分布式项目涉及的知识点太多，一般人很难吃透。并且，这类项目其实对于校招生来说稍微有一点超标了。即使你做出来，很多面试官也会认为不是你独立完成的。

\n

其实，你能把一个单体项目做到极致也很好，对于个人能力提升不比做微服务或者分布式项目差。如何做到极致？代码质量这里就不提了，更重要的是你要尽量让自己的项目有一些亮点（比如你是如何提升项目性能的、如何解决项目中存在的一个痛点的），项目经历取得的成果尽量要量化一下比如我使用 xxx 技术解决了 xxx 问题，系统 qps 从 xxx 提高到了 xxx。

\n
\n

跟着老师做的过程中，你一定要有自己的思考，不要浅尝辄止。对于很多知识点，别人的讲解可能只是满足项目就够了，你自己想多点知识的话，对于重要的知识点就要自己学会去深入学习。

\n

实战类开源项目

\n

GitHub 或者码云上面有很多实战类别项目，你可以选择一个来研究，为了让自己对这个项目更加理解，在理解原有代码的基础上，你可以对原有项目进行改进或者增加功能。

\n

你可以参考 Java 优质开源实战项目 上面推荐的实战类开源项目，质量都很高，项目类型也比较全面，涵盖博客/论坛系统、考试/刷题系统、商城系统、权限管理系统、快速开发脚手架以及各种轮子。

\n

\"Java

\n

一定要记住：不光要做，还要改进，改善。不论是实战项目视频或者专栏还是实战类开源项目，都一定会有很多可以完善改进的地方。

\n

从头开始做

\n

自己动手去做一个自己想完成的东西，遇到不会的东西就临时去学，现学现卖。

\n

这个要求比较高，我建议你已经有了一个项目经验之后，再采用这个方法。如果你没有做过项目的话，还是老老实实采用上面两个方法比较好。

\n

参加各种大公司组织的各种大赛

\n

如果参加这种赛事能获奖的话，项目含金量非常高。即使没获奖也没啥，也可以写简历上。

\n

\"阿里云天池大赛\"

\n

参与实际项目

\n

通常情况下，你有如下途径接触到企业实际项目的开发：

\n
    \n
  1. 老师接的项目；
    2. \n
  2. 自己接的私活；
    3. \n
  3. 实习/工作接触到的项目；
    4. \n
\n

老师接的项目和自己接的私活通常都是一些偏业务的项目，很少会涉及到性能优化。这种情况下，你可以考虑对项目进行改进，别怕花时间，某个时间用心做好一件事情就好比如你对项目的数据模型进行改进、引入缓存提高访问速度等等。

\n

实习/工作接触到的项目类似，如果遇到一些偏业务的项目，也是要自己私下对项目进行改进优化。

\n

尽量是真的对项目进行了优化，这本身也是对个人能力的提升。如果你实在是没时间去实践的话，也没关系，吃透这个项目优化手段就好，把一些面试可能会遇到的问题提前准备一下。

\n

有没有还不错的项目推荐？

\n

《Java 面试指北》 的「面试准备篇」中有一篇文章专门整理了一些比较高质量的实战项目，包含业务项目、轮子项目、国外公开课 Lab 和视频类实战项目教程推荐，非常适合用来学习或者作为项目经验。

\n

\"优质

\n

这篇文章一共推荐了 15+ 个实战项目，有业务类的，也有轮子类的，有开源项目、也有视频教程。对于参加校招的小伙伴，我更建议做一个业务类项目加上一个轮子类的项目。

\n

我跟着视频做的项目会被面试官嫌弃不？

\n

很多应届生都是跟着视频做的项目，这个大部分面试官都心知肚明。

\n

不排除确实有些面试官不吃这一套，这个也看人。不过我相信大多数面试官都是能理解的，毕竟你在学校的时候实际上是没有什么获得实际项目经验的途径的。

\n

大部分应届生的项目经验都是自己在网上找的或者像你一样买的付费课程跟着做的，极少部分是比较真实的项目。 从你能想着做一个实战项目来说，我觉得初衷是好的，确实也能真正学到东西。 但是，究竟有多少是自己掌握了很重要。看视频最忌讳的是被动接受，自己多改进一下，多思考一下！就算是你跟着视频做的项目，也是可以优化的！

\n

如果你想真正学到东西的话，建议不光要把项目单纯完成跑起来，还要去自己尝试着优化！

\n

简单说几个比较容易的优化点：

\n
    \n
  1. 全局异常处理：很多项目这方面都做的不是很好，可以参考我的这篇文章：《使用枚举简单封装一个优雅的 Spring Boot 全局异常处理！》 来做优化。
    2. \n
  2. 项目的技术选型优化：比如使用 Guava 做本地缓存的地方可以换成 Caffeine 。Caffeine 的各方面的表现要更加好！再比如 Controller 层是否放了太多的业务逻辑。
    3. \n
  3. 数据库方面：数据库设计可否优化？索引是否使用使用正确？SQL 语句是否可以优化？是否需要进行读写分离？
    4. \n
  4. 缓存：项目有没有哪些数据是经常被访问的？是否引入缓存来提高响应速度？
    5. \n
  5. 安全：项目是否存在安全问题？
    6. \n
  6. ……
    7. \n
\n

另外，我在星球分享过常见的性能优化方向实践案例，涉及到多线程、异步、索引、缓存等方向，强烈推荐你看看：https://t.zsxq.com/06EqfeMZZ 。

\n

最后，再给大家推荐一个 IDEA 优化代码的小技巧，超级实用！

\n

分析你的代码：右键项目-> Analyze->Inspect Code

\n

\n

扫描完成之后，IDEA 会给出一些可能存在的代码坏味道比如命名问题。

\n

\n

并且，你还可以自定义检查规则。

\n

\n", "image": "https://oss.javaguide.cn/javamianshizhibei/mukewangzhiazhanke.png", "date_published": "2022-11-03T15:33:32.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "面试准备" ] }, { "title": "Java 17 新特性概览（重要）", "url": "https://javaguide.cn/java/new-features/java17.html", "id": "https://javaguide.cn/java/new-features/java17.html", "summary": "总结 JDK 17 的重要更新与 JEP，涵盖密封类、记录类与模式匹配等特性。", "content_html": "

Java 17 在 2021 年 9 月 14 日正式发布，是一个长期支持（LTS）版本。

\n

下面这张图是 Oracle 官方给出的 Oracle JDK 支持的时间线。可以看得到，Java 17 最多可以支持到 2029 年 9 月份。

\n

\n

Java 17 将是继 Java 8 以来最重要的长期支持（LTS）版本，是 Java 社区八年努力的成果。Spring 6.x 和 Spring Boot 3.x 最低支持的就是 Java 17。

\n

JDK 17 共有 14 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 16 每个版本的更新带来的新特性数量和更新时间：

\n

\n

相关阅读：OpenJDK Java 17 文档 。

\n

JEP 356: Enhanced Pseudo-Random Number Generators（增强的伪随机数生成器）

\n

JDK 17 之前，我们可以借助 Random、ThreadLocalRandom和SplittableRandom来生成随机数。不过，这 3 个类都各有缺陷，且缺少常见的伪随机算法支持。

\n

Java 17 为伪随机数生成器 （pseudorandom number generator，PRNG，又称为确定性随机位生成器）增加了新的接口类型和实现，使得开发者更容易在应用程序中互换使用各种 PRNG 算法。

\n
\n

PRNG 用来生成接近于绝对随机数序列的数字序列。一般来说，PRNG 会依赖于一个初始值，也称为种子，来生成对应的伪随机数序列。只要种子确定了，PRNG 所生成的随机数就是完全确定的，因此其生成的随机数序列并不是真正随机的。

\n
\n

使用示例：

\n
RandomGeneratorFactory<RandomGenerator> l128X256MixRandom = RandomGeneratorFactory.of(\"L128X256MixRandom\");\n// 使用时间戳作为随机数种子\nRandomGenerator randomGenerator = l128X256MixRandom.create(System.currentTimeMillis());\n// 生成随机数\nrandomGenerator.nextInt(10);
\n

JEP 398: Deprecate the Applet API for Removal（标记弃用 Applet API 以便移除）

\n

Applet API 用于编写在 Web 浏览器端运行的 Java 小程序，很多年前就已经被淘汰了，已经没有理由使用了。

\n

Applet API 在 Java 9 时被标记弃用（JEP 289），但不是为了删除。

\n

JEP 406: Pattern Matching for switch（switch 模式匹配，预览）

\n

正如 instanceof 一样， switch 也紧跟着增加了类型匹配自动转换功能。

\n

instanceof 代码示例：

\n
// Old code\nif (o instanceof String) {\n    String s = (String)o;\n    ... use s ...\n}\n\n// New code\nif (o instanceof String s) {\n    ... use s ...\n}
\n

switch 代码示例：

\n
// Old code\nstatic String formatter(Object o) {\n    String formatted = \"unknown\";\n    if (o instanceof Integer i) {\n        formatted = String.format(\"int %d\", i);\n    } else if (o instanceof Long l) {\n        formatted = String.format(\"long %d\", l);\n    } else if (o instanceof Double d) {\n        formatted = String.format(\"double %f\", d);\n    } else if (o instanceof String s) {\n        formatted = String.format(\"String %s\", s);\n    }\n    return formatted;\n}\n\n// New code\nstatic String formatterPatternSwitch(Object o) {\n    return switch (o) {\n        case Integer i -> String.format(\"int %d\", i);\n        case Long l    -> String.format(\"long %d\", l);\n        case Double d  -> String.format(\"double %f\", d);\n        case String s  -> String.format(\"String %s\", s);\n        default        -> o.toString();\n    };\n}
\n

对于 null 值的判断也进行了优化。

\n
// Old code\nstatic void testFooBar(String s) {\n    if (s == null) {\n        System.out.println(\"oops!\");\n        return;\n    }\n    switch (s) {\n        case \"Foo\", \"Bar\" -> System.out.println(\"Great\");\n        default           -> System.out.println(\"Ok\");\n    }\n}\n\n// New code\nstatic void testFooBar(String s) {\n    switch (s) {\n        case null         -> System.out.println(\"Oops\");\n        case \"Foo\", \"Bar\" -> System.out.println(\"Great\");\n        default           -> System.out.println(\"Ok\");\n    }\n}
\n

JEP 407: Remove RMI Activation（移除 RMI 激活机制）

\n

删除远程方法调用 (RMI) 激活机制，同时保留 RMI 的其余部分。RMI 激活机制已过时且不再使用。

\n

JEP 409: Sealed Classes（密封类）

\n

密封类由 JEP 360 提出预览，集成到了 Java 15 中。在 JDK 16 中， 密封类得到了改进（更加严格的引用检查和密封类的继承关系），由 JEP 397 提出了再次预览。

\n

在 Java 14 & 15 新特性概览 中，我有详细介绍到密封类，这里就不再做额外的介绍了。

\n

JEP 410: Remove the Experimental AOT and JIT Compiler（移除实验性的 AOT 和 JIT 编译器）

\n

在 Java 9 的 JEP 295 ,引入了实验性的提前 (AOT) 编译器，在启动虚拟机之前将 Java 类编译为本机代码。

\n

Java 17，删除实验性的提前 (AOT) 和即时 (JIT) 编译器，因为该编译器自推出以来很少使用，维护它所需的工作量很大。保留实验性的 Java 级 JVM 编译器接口 (JVMCI)，以便开发人员可以继续使用外部构建的编译器版本进行 JIT 编译。

\n

JEP 411: Deprecate the Security Manager for Removal（标记弃用安全管理器以便移除）

\n

弃用安全管理器以便在将来的版本中删除。

\n

安全管理器可追溯到 Java 1.0，多年来，它一直不是保护客户端 Java 代码的主要方法，也很少用于保护服务器端代码。为了推动 Java 向前发展，Java 17 弃用安全管理器，以便与旧版 Applet API ( JEP 398 ) 一起移除。

\n

JEP 412: Foreign Function & Memory API（外部函数和内存 API，孵化）

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。第二轮孵化由JEP 419 提出并集成到了 Java 18 中，预览由 JEP 424 提出并集成到了 Java 19 中。

\n

在 Java 19 新特性概览 中，我有详细介绍到外部函数和内存 API，这里就不再做额外的介绍了。

\n

JEP 414: Vector API（向量 API，第二次孵化）

\n

向量（Vector） API 最初由 JEP 338 提出，并作为孵化 API集成到 Java 16 中。第二轮孵化由 JEP 414 提出并集成到 Java 17 中，第三轮孵化由 JEP 417 提出并集成到 Java 18 中，第四轮由 JEP 426 提出并集成到了 Java 19 中。

\n

该孵化器 API 提供了一个 API 的初始迭代以表达一些向量计算，这些计算在运行时可靠地编译为支持的 CPU 架构上的最佳向量硬件指令，从而获得优于同等标量计算的性能，充分利用单指令多数据（SIMD）技术（大多数现代 CPU 上都可以使用的一种指令）。尽管 HotSpot 支持自动向量化，但是可转换的标量操作集有限且易受代码更改的影响。该 API 将使开发人员能够轻松地用 Java 编写可移植的高性能向量算法。

\n

在 Java 18 新特性概览 中，我有详细介绍到向量 API，这里就不再做额外的介绍了。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/4c1611fad59449edbbd6e233690e9fa7.png", "date_published": "2022-09-28T12:35:46.000Z", "date_modified": "2026-01-26T14:09:42.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Java 18 新特性概览", "url": "https://javaguide.cn/java/new-features/java18.html", "id": "https://javaguide.cn/java/new-features/java18.html", "summary": "概览 JDK 18 的更新与预览特性，理解新 API 带来的改进。", "content_html": "

Java 18 在 2022 年 3 月 22 日正式发布，非长期支持版本。

\n

JDK 18 共有 8 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\"

\n

相关阅读：

\n\n

JEP 400: UTF-8 by Default（UTF-8 作为默认字符集，转正）

\n

JDK 终于将 UTF-8 设置为默认字符集。

\n

在 Java 17 及更早版本中，默认字符集是在 Java 虚拟机运行时才确定的，取决于不同的操作系统、区域设置等因素，因此存在潜在的风险。就比如说你在 Mac 上运行正常的一段打印文字到控制台的 Java 程序到了 Windows 上就会出现乱码，如果你不手动更改字符集的话。

\n

JEP 408: Simple Web Server（简单 Web 服务器，转正）

\n

Java 18 之后，你可以使用 jwebserver 命令启动一个简易的静态 Web 服务器。

\n
$ jwebserver\nBinding to loopback by default. For all interfaces use \"-b 0.0.0.0\" or \"-b ::\".\nServing /cwd and subdirectories on 127.0.0.1 port 8000\nURL: http://127.0.0.1:8000/
\n

这个服务器不支持 CGI 和 Servlet，只限于静态文件。

\n

JEP 413: Code Snippets in Java API Documentation（API 文档代码片段，转正）

\n

在 Java 18 之前，如果我们想要在 Javadoc 中引入代码片段可以使用 <pre>{@code ...}</pre> 。

\n
<pre>{@code\n    lines of source code\n}</pre>
\n

<pre>{@code ...}</pre> 这种方式生成的效果比较一般。

\n

在 Java 18 之后，可以通过 @snippet 标签来做这件事情。

\n
/**\n * The following code shows how to use {@code Optional.isPresent}:\n * {@snippet :\n * if (v.isPresent()) {\n *     System.out.println(\"v: \" + v.get());\n * }\n * }\n */
\n

@snippet 这种方式生成的效果更好且使用起来更方便一些。

\n

JEP 416: Reimplement Core Reflection with Method Handles（方法句柄重构核心反射，转正）

\n

Java 18 改进了 java.lang.reflect.Method、Constructor 的实现逻辑，使之性能更好，速度更快。这项改动不会改动相关 API ，这意味着开发中不需要改动反射相关代码，就可以体验到性能更好的反射。

\n

OpenJDK 官方给出了新老实现的反射性能基准测试结果。

\n

\"新老实现的反射性能基准测试结果\"

\n

JEP 417: Vector API（向量 API，第三次孵化）

\n

向量（Vector） API 最初由 JEP 338 提出，并作为孵化 API集成到 Java 16 中。第二轮孵化由 JEP 414 提出并集成到 Java 17 中，第三轮孵化由 JEP 417 提出并集成到 Java 18 中，第四轮由 JEP 426 提出并集成到了 Java 19 中。

\n

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

\n

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

\n

这是对数组元素的简单标量计算：

\n
void scalarComputation(float[] a, float[] b, float[] c) {\n   for (int i = 0; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n   }\n}
\n

这是使用 Vector API 进行的等效向量计算：

\n
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;\n\nvoid vectorComputation(float[] a, float[] b, float[] c) {\n    int i = 0;\n    int upperBound = SPECIES.loopBound(a.length);\n    for (; i < upperBound; i += SPECIES.length()) {\n        // FloatVector va, vb, vc;\n        var va = FloatVector.fromArray(SPECIES, a, i);\n        var vb = FloatVector.fromArray(SPECIES, b, i);\n        var vc = va.mul(va)\n                   .add(vb.mul(vb))\n                   .neg();\n        vc.intoArray(c, i);\n    }\n    for (; i < a.length; i++) {\n        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;\n    }\n}
\n

在 JDK 18 中，向量 API 的性能得到了进一步的优化。

\n

JEP 418: Internet-Address Resolution SPI（互联网地址解析 SPI，转正）

\n

Java 18 定义了一个全新的 SPI（service-provider interface），用于主要名称和地址的解析，以便 java.net.InetAddress 可以使用平台之外的第三方解析器。

\n

JEP 419: Foreign Function & Memory API（外部函数和内存 API，第二次孵化）

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。第二轮孵化由JEP 419 提出并集成到了 Java 18 中，预览由 JEP 424 提出并集成到了 Java 19 中。

\n

在 Java 19 新特性概览 中，我有详细介绍到外部函数和内存 API，这里就不再做额外的介绍了。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2022-09-13T12:49:20.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "Java 19 新特性概览", "url": "https://javaguide.cn/java/new-features/java19.html", "id": "https://javaguide.cn/java/new-features/java19.html", "summary": "介绍 JDK 19 的预览特性与并发相关更新，为后续虚拟线程铺垫。", "content_html": "

JDK 19 于 2022 年 9 月 20 日正式发布，非长期支持版本。

\n

JDK 19 共有 7 个新特性，这篇文章会挑选其中较为重要的一些新特性进行详细介绍：

\n\n

下图是从 JDK 8 到 JDK 25 每个版本的更新带来的新特性数量和更新时间：

\n

\"

\n

JEP 424: 外部函数和内存 API（预览）

\n

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

\n

外部函数和内存 API 在 Java 17 中进行了第一轮孵化，由 JEP 412 提出。第二轮孵化由JEP 419 提出并集成到了 Java 18 中，预览由 JEP 424 提出并集成到了 Java 19 中。

\n

在没有外部函数和内存 API 之前：

\n\n

引入外部函数和内存 API 就是为了解决 Java 访问外部函数和外部内存存在的一些痛点。

\n

Foreign Function & Memory API (FFM API) 定义了类和接口：

\n\n

下面是 FFM API 使用示例，这段代码获取了 C 库函数的 radixsort 方法句柄，然后使用它对 Java 数组中的四个字符串进行排序。

\n
// 1. 在 C 库路径上查找外部函数\nLinker linker = Linker.nativeLinker();\nSymbolLookup stdlib = linker.defaultLookup();\nMethodHandle radixSort = linker.downcallHandle(\n                             stdlib.lookup(\"radixsort\"), ...);\n// 2. 分配堆上内存以存储四个字符串\nString[] javaStrings   = { \"mouse\", \"cat\", \"dog\", \"car\" };\n// 3. 分配堆外内存以存储四个指针\nSegmentAllocator allocator = implicitAllocator();\nMemorySegment offHeap  = allocator.allocateArray(ValueLayout.ADDRESS, javaStrings.length);\n// 4. 将字符串从堆上复制到堆外\nfor (int i = 0; i < javaStrings.length; i++) {\n    // 在堆外分配一个字符串，然后存储指向它的指针\n    MemorySegment cString = allocator.allocateUtf8String(javaStrings[i]);\n    offHeap.setAtIndex(ValueLayout.ADDRESS, i, cString);\n}\n// 5. 通过调用外部函数对堆外数据进行排序\nradixSort.invoke(offHeap, javaStrings.length, MemoryAddress.NULL, '\\0');\n// 6. 将（重新排序的）字符串从堆外复制到堆上\nfor (int i = 0; i < javaStrings.length; i++) {\n    MemoryAddress cStringPtr = offHeap.getAtIndex(ValueLayout.ADDRESS, i);\n    javaStrings[i] = cStringPtr.getUtf8String(0);\n}\nassert Arrays.equals(javaStrings, new String[] {\"car\", \"cat\", \"dog\", \"mouse\"});  // true
\n

JEP 425: 虚拟线程（预览）

\n

虚拟线程（Virtual Thread）是 JDK 而不是 OS 实现的轻量级线程（Lightweight Process，LWP），许多虚拟线程共享同一个操作系统线程，虚拟线程的数量可以远大于操作系统线程的数量。

\n

虚拟线程在其他多线程语言中已经被证实是十分有用的，比如 Go 中的 Goroutine、Erlang 中的进程。

\n

虚拟线程避免了上下文切换的额外耗费，兼顾了多线程的优点，简化了高并发程序的复杂，可以有效减少编写、维护和观察高吞吐量并发应用程序的工作量。

\n

知乎有一个关于 Java 19 虚拟线程的讨论，感兴趣的可以去看看：https://www.zhihu.com/question/536743167 。

\n

Java 虚拟线程的详细解读和原理可以看下面这两篇文章：

\n\n

JEP 426: 向量 API（第四次孵化）

\n

向量（Vector） API 最初由 JEP 338 提出，并作为孵化 API集成到 Java 16 中。第二轮孵化由 JEP 414 提出并集成到 Java 17 中，第三轮孵化由 JEP 417 提出并集成到 Java 18 中，第四轮由 JEP 426 提出并集成到了 Java 19 中。

\n

在 Java 18 新特性概览 中，我有详细介绍到向量 API，这里就不再做额外的介绍了。

\n

JEP 428: 结构化并发(孵化)

\n

JDK 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

\n

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

\n

结构化并发的基本 API 是StructuredTaskScope。StructuredTaskScope 支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

\n

StructuredTaskScope 的基本用法如下：

\n
    try (var scope = new StructuredTaskScope<Object>()) {\n        // 使用fork方法派生线程来执行子任务\n        Future<Integer> future1 = scope.fork(task1);\n        Future<String> future2 = scope.fork(task2);\n        // 等待线程完成\n        scope.join();\n        // 结果的处理可能包括处理或重新抛出异常\n        ... process results/exceptions ...\n    } // close
\n

结构化并发非常适合虚拟线程，虚拟线程是 JDK 实现的轻量级线程。许多虚拟线程共享同一个操作系统线程，从而允许非常多的虚拟线程。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/java/new-features/jdk8~jdk24.png", "date_published": "2022-09-13T01:11:51.000Z", "date_modified": "2026-01-27T07:16:00.000Z", "authors": [], "tags": [ "Java" ] }, { "title": "ARP 协议详解(网络层)", "url": "https://javaguide.cn/cs-basics/network/arp.html", "id": "https://javaguide.cn/cs-basics/network/arp.html", "summary": "讲解 ARP 的地址解析机制与报文流程，结合 ARP 表与广播/单播详解常见攻击与防御策略。", "content_html": "

每当我们学习一个新的网络协议的时候，都要把他结合到 OSI 七层模型中，或者是 TCP/IP 协议栈中来学习，一是要学习该协议在整个网络协议栈中的位置，二是要学习该协议解决了什么问题，地位如何？三是要学习该协议的工作原理，以及一些更深入的细节。

\n

ARP 协议，可以说是在协议栈中属于一个偏底层的、非常重要的、又非常简单的通信协议。

\n

开始阅读这篇文章之前，你可以先看看下面几个问题：

\n
    \n
  1. ARP 协议在协议栈中的位置？ ARP 协议在协议栈中的位置非常重要，在理解了它的工作原理之后，也很难说它到底是网络层协议，还是链路层协议，因为它恰恰串联起了网络层和链路层。国外的大部分教程通常将 ARP 协议放在网络层。
    2. \n
  2. ARP 协议解决了什么问题，地位如何？ ARP 协议，全称 地址解析协议（Address Resolution Protocol），它解决的是网络层地址和链路层地址之间的转换问题。因为一个 IP 数据报在物理上传输的过程中，总是需要知道下一跳（物理上的下一个目的地）该去往何处，但 IP 地址属于逻辑地址，而 MAC 地址才是物理地址，ARP 协议解决了 IP 地址转 MAC 地址的一些问题。
    3. \n
  3. ARP 工作原理？ 只希望大家记住几个关键词：ARP 表、广播问询、单播响应。
    4. \n
\n

MAC 地址

\n

在介绍 ARP 协议之前，有必要介绍一下 MAC 地址。

\n

MAC 地址的全称是 媒体访问控制地址（Media Access Control Address）。如果说，互联网中每一个资源都由 IP 地址唯一标识（IP 协议内容），那么一切网络设备都由 MAC 地址唯一标识。

\n

\"路由器的背面就会注明

\n

可以理解为，MAC 地址是一个网络设备真正的身份证号，IP 地址只是一种不重复的定位方式（比如说住在某省某市某街道的张三，这种逻辑定位是 IP 地址，他的身份证号才是他的 MAC 地址），也可以理解为 MAC 地址是身份证号，IP 地址是邮政地址。MAC 地址也有一些别称，如 LAN 地址、物理地址、以太网地址等。

\n
\n

还有一点要知道的是，不仅仅是网络资源才有 IP 地址，网络设备也有 IP 地址，比如路由器。但从结构上说，路由器等网络设备的作用是组成一个网络，而且通常是内网，所以它们使用的 IP 地址通常是内网 IP，内网的设备在与内网以外的设备进行通信时，需要用到 NAT 协议。

\n
\n

MAC 地址的长度为 6 字节（48 比特），地址空间大小有 280 万亿之多（$2^{48}$），MAC 地址由 IEEE 统一管理与分配，理论上，一个网络设备中的网卡上的 MAC 地址是永久的。不同的网卡生产商从 IEEE 那里购买自己的 MAC 地址空间（MAC 的前 24 比特），也就是前 24 比特由 IEEE 统一管理，保证不会重复。而后 24 比特，由各家生产商自己管理，同样保证生产的两块网卡的 MAC 地址不会重复。

\n

MAC 地址具有可携带性、永久性，身份证号永久地标识一个人的身份，不论他到哪里都不会改变。而 IP 地址不具有这些性质，当一台设备更换了网络，它的 IP 地址也就可能发生改变，也就是它在互联网中的定位发生了变化。

\n

最后，记住，MAC 地址有一个特殊地址：FF-FF-FF-FF-FF-FF（全 1 地址），该地址表示广播地址。

\n

ARP 协议工作原理

\n

ARP 协议工作时有一个大前提，那就是 ARP 表。

\n

在一个局域网内，每个网络设备都自己维护了一个 ARP 表，ARP 表记录了某些其他网络设备的 IP 地址-MAC 地址映射关系，该映射关系以 <IP, MAC, TTL> 三元组的形式存储。其中，TTL 为该映射关系的生存周期，典型值为 20 分钟，超过该时间，该条目将被丢弃。

\n

ARP 的工作原理将分两种场景讨论：

\n
    \n
  1. 同一局域网内的 MAC 寻址；
    2. \n
  2. 从一个局域网到另一个局域网中的网络设备的寻址。
    3. \n
\n

同一局域网内的 MAC 寻址

\n

假设当前有如下场景：IP 地址为137.196.7.23的主机 A，想要给同一局域网内的 IP 地址为137.196.7.14主机 B，发送 IP 数据报文。

\n
\n

再次强调，当主机发送 IP 数据报文时（网络层），仅知道目的地的 IP 地址，并不清楚目的地的 MAC 地址，而 ARP 协议就是解决这一问题的。

\n
\n

为了达成这一目标，主机 A 将不得不通过 ARP 协议来获取主机 B 的 MAC 地址，并将 IP 报文封装成链路层帧，发送到下一跳上。在该局域网内，关于此将按照时间顺序，依次发生如下事件：

\n
    \n
  1. \n

    主机 A 检索自己的 ARP 表，发现 ARP 表中并无主机 B 的 IP 地址对应的映射条目，也就无从知道主机 B 的 MAC 地址。

    \n
    2. \n
  2. \n

    主机 A 将构造一个 ARP 查询分组，并将其广播到所在的局域网中。

    \n

    ARP 分组是一种特殊报文，ARP 分组有两类，一种是查询分组，另一种是响应分组，它们具有相同的格式，均包含了发送和接收的 IP 地址、发送和接收的 MAC 地址。当然了，查询分组中，发送的 IP 地址，即为主机 A 的 IP 地址，接收的 IP 地址即为主机 B 的 IP 地址，发送的 MAC 地址也是主机 A 的 MAC 地址，但接收的 MAC 地址绝不会是主机 B 的 MAC 地址（因为这正是我们要问询的！），而是一个特殊值——FF-FF-FF-FF-FF-FF，之前说过，该 MAC 地址是广播地址，也就是说，查询分组将广播给该局域网内的所有设备。

    \n
    3. \n
  3. \n

    主机 A 构造的查询分组将在该局域网内广播，理论上，每一个设备都会收到该分组，并检查查询分组的接收 IP 地址是否为自己的 IP 地址，如果是，说明查询分组已经到达了主机 B，否则，该查询分组对当前设备无效，丢弃之。

    \n
    4. \n
  4. \n

    主机 B 收到了查询分组之后，验证是对自己的问询，接着构造一个 ARP 响应分组，该分组的目的地只有一个——主机 A，发送给主机 A。同时，主机 B 提取查询分组中的 IP 地址和 MAC 地址信息，在自己的 ARP 表中构造一条主机 A 的 IP-MAC 映射记录。

    \n

    ARP 响应分组具有和 ARP 查询分组相同的构造，不同的是，发送和接受的 IP 地址恰恰相反，发送的 MAC 地址为发送者本身，目标 MAC 地址为查询分组的发送者，也就是说，ARP 响应分组只有一个目的地，而非广播。

    \n
    5. \n
  5. \n

    主机 A 终将收到主机 B 的响应分组，提取出该分组中的 IP 地址和 MAC 地址后，构造映射信息，加入到自己的 ARP 表中。

    \n
    6. \n
\n

\n

在整个过程中，有几点需要补充说明的是：

\n
    \n
  1. 主机 A 想要给主机 B 发送 IP 数据报，如果主机 B 的 IP-MAC 映射信息已经存在于主机 A 的 ARP 表中，那么主机 A 无需广播，只需提取 MAC 地址并构造链路层帧发送即可。
    2. \n
  2. ARP 表中的映射信息是有生存周期的，典型值为 20 分钟。
    3. \n
  3. 目标主机接收到了问询主机构造的问询报文后，将先把问询主机的 IP-MAC 映射存进自己的 ARP 表中，这样才能获取到响应的目标 MAC 地址，顺利的发送响应分组。
    4. \n
\n

总结来说，ARP 协议是一个广播问询，单播响应协议。

\n

不同局域网内的 MAC 寻址

\n

更复杂的情况是，发送主机 A 和接收主机 B 不在同一个子网中，假设一个一般场景，两台主机所在的子网由一台路由器联通。这里需要注意的是，一般情况下，我们说网络设备都有一个 IP 地址和一个 MAC 地址，这里说的网络设备，更严谨的说法应该是一个接口。路由器作为互联设备，具有多个接口，每个接口同样也应该具备不重复的 IP 地址和 MAC 地址。因此，在讨论 ARP 表时，路由器的多个接口都各自维护一个 ARP 表，而非一个路由器只维护一个 ARP 表。

\n

接下来，回顾同一子网内的 MAC 寻址，如果主机 A 发送一个广播问询分组，那么 A 所在的子网内所有设备（接口）都将会捕获该分组，因为该分组的目的 IP 与发送主机 A 的 IP 在同一个子网中。但是当目的 IP 与 A 不在同一子网时，A 所在子网内将不会有设备成功接收该分组。那么，主机 A 应该发送怎样的查询分组呢？整个过程按照时间顺序发生的事件如下：

\n
    \n
  1. \n

    主机 A 查询 ARP 表，期望寻找到目标路由器的本子网接口的 MAC 地址。

    \n

    目标路由器指的是，根据目的主机 B 的 IP 地址，分析出 B 所在的子网，能够把报文转发到 B 所在子网的那个路由器。

    \n
    2. \n
  2. \n

    主机 A 未能找到目标路由器的本子网接口的 MAC 地址，将采用 ARP 协议，问询到该 MAC 地址，由于目标接口与主机 A 在同一个子网内，该过程与同一局域网内的 MAC 寻址相同。

    \n
    3. \n
  3. \n

    主机 A 获取到目标接口的 MAC 地址，先构造 IP 数据报，其中源 IP 是 A 的 IP 地址，目的 IP 地址是 B 的 IP 地址，再构造链路层帧，其中源 MAC 地址是 A 的 MAC 地址，目的 MAC 地址是本子网内与路由器连接的接口的 MAC 地址。主机 A 将把这个链路层帧，以单播的方式，发送给目标接口。

    \n
    4. \n
  4. \n

    目标接口接收到了主机 A 发过来的链路层帧，解析，根据目的 IP 地址，查询转发表，将该 IP 数据报转发到与主机 B 所在子网相连的接口上。

    \n

    到此，该帧已经从主机 A 所在的子网，转移到了主机 B 所在的子网了。

    \n
    5. \n
  5. \n

    路由器接口查询 ARP 表，期望寻找到主机 B 的 MAC 地址。

    \n
    6. \n
  6. \n

    路由器接口如未能找到主机 B 的 MAC 地址，将采用 ARP 协议，广播问询，单播响应，获取到主机 B 的 MAC 地址。

    \n
    7. \n
  7. \n

    路由器接口将对 IP 数据报重新封装成链路层帧，目标 MAC 地址为主机 B 的 MAC 地址，单播发送，直到目的地。

    \n
    8. \n
\n

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/cs-basics/network/router-back-will-indicate-mac-address.png", "date_published": "2022-08-28T07:18:49.000Z", "date_modified": "2026-01-16T13:04:11.000Z", "authors": [], "tags": [ "计算机基础" ] }, { "title": "分布式锁常见实现方案总结", "url": "https://javaguide.cn/distributed-system/distributed-lock-implementations.html", "id": "https://javaguide.cn/distributed-system/distributed-lock-implementations.html", "summary": "分布式锁常见实现方案详解，包括基于Redis SETNX、Redlock、ZooKeeper临时节点实现分布式锁的原理、优缺点对比及最佳实践。", "content_html": "

\"JavaGuide官方知识星球\"

\n

通常情况下，我们一般会选择基于 Redis 或者 ZooKeeper 实现分布式锁，Redis 用的要更多一点，我这里也先以 Redis 为例介绍分布式锁的实现。

\n

基于 Redis 实现分布式锁

\n

如何基于 Redis 实现一个最简易的分布式锁？

\n

不论是本地锁还是分布式锁，核心都在于“互斥”。

\n

在 Redis 中， SETNX 命令是可以帮助我们实现互斥。SETNX 即 SET if Not eXists (对应 Java 中的 setIfAbsent 方法)，如果 key 不存在的话，才会设置 key 的值。如果 key 已经存在， SETNX 啥也不做。

\n
> SETNX lockKey uniqueValue\n(integer) 1\n> SETNX lockKey uniqueValue\n(integer) 0
\n

释放锁的话，直接通过 DEL 命令删除对应的 key 即可。

\n
> DEL lockKey\n(integer) 1
\n

为了防止误删到其他的锁，这里我们建议使用 Lua 脚本通过 key 对应的 value（唯一值）来判断。

\n

选用 Lua 脚本是为了保证解锁操作的原子性。因为 Redis 在执行 Lua 脚本时，可以以原子性的方式执行，从而保证了锁释放操作的原子性。

\n
// 释放锁时，先比较锁对应的 value 值是否相等，避免锁的误释放\nif redis.call(\"get\",KEYS[1]) == ARGV[1] then\n    return redis.call(\"del\",KEYS[1])\nelse\n    return 0\nend
\n

\"Redis

\n

这是一种最简易的 Redis 分布式锁实现，实现方式比较简单，性能也很高效。不过，这种方式实现分布式锁存在一些问题。就比如应用程序遇到一些问题比如释放锁的逻辑突然挂掉，可能会导致锁无法被释放，进而造成共享资源无法再被其他线程/进程访问。

\n

为什么要给锁设置一个过期时间？

\n

为了避免锁无法被释放，我们可以想到的一个解决办法就是：给这个 key（也就是锁） 设置一个过期时间 。

\n
127.0.0.1:6379> SET lockKey uniqueValue EX 3 NX\nOK
\n
\n

一定要保证设置指定 key 的值和过期时间是一个原子操作！！！ 不然的话，依然可能会出现锁无法被释放的问题。

\n

这样确实可以解决问题，不过，这种解决办法同样存在漏洞：如果操作共享资源的时间大于过期时间，就会出现锁提前过期的问题，进而导致分布式锁直接失效。如果锁的超时时间设置过长，又会影响到性能。

\n

你或许在想：如果操作共享资源的操作还未完成，锁过期时间能够自己续期就好了！

\n

如何实现锁的优雅续期？

\n

对于 Java 开发的小伙伴来说，已经有了现成的解决方案：Redisson 。其他语言的解决方案，可以在 Redis 官方文档中找到，地址：https://redis.io/topics/distlock 。

\n

\"Distributed

\n

Redisson 是一个开源的 Java 语言 Redis 客户端，提供了很多开箱即用的功能，不仅仅包括多种分布式锁的实现。并且，Redisson 还支持 Redis 单机、Redis Sentinel、Redis Cluster 等多种部署架构。

\n

Redisson 中的分布式锁自带自动续期机制，使用起来非常简单，原理也比较简单，其提供了一个专门用来监控和续期锁的 Watch Dog（ 看门狗），如果操作共享资源的线程还未执行完成的话，Watch Dog 会不断地延长锁的过期时间，进而保证锁不会因为超时而被释放。

\n

\"Redisson

\n

看门狗名字的由来于 getLockWatchdogTimeout() 方法，这个方法返回的是看门狗给锁续期的过期时间，默认为 30 秒（redisson-3.17.6）。

\n
//默认 30秒，支持修改\nprivate long lockWatchdogTimeout = 30 * 1000;\n\npublic Config setLockWatchdogTimeout(long lockWatchdogTimeout) {\n    this.lockWatchdogTimeout = lockWatchdogTimeout;\n    return this;\n}\npublic long getLockWatchdogTimeout() {\n   return lockWatchdogTimeout;\n}
\n

renewExpiration() 方法包含了看门狗的主要逻辑：

\n
private void renewExpiration() {\n         //......\n        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {\n            @Override\n            public void run(Timeout timeout) throws Exception {\n                //......\n                // 异步续期，基于 Lua 脚本\n                CompletionStage<Boolean> future = renewExpirationAsync(threadId);\n                future.whenComplete((res, e) -> {\n                    if (e != null) {\n                        // 无法续期\n                        log.error(\"Can't update lock \" + getRawName() + \" expiration\", e);\n                        EXPIRATION_RENEWAL_MAP.remove(getEntryName());\n                        return;\n                    }\n\n                    if (res) {\n                        // 递归调用实现续期\n                        renewExpiration();\n                    } else {\n                        // 取消续期\n                        cancelExpirationRenewal(null);\n                    }\n                });\n            }\n         // 延迟 internalLockLeaseTime/3（默认 10s，也就是 30/3） 再调用\n        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);\n\n        ee.setTimeout(task);\n    }
\n

默认情况下，每过 10 秒，看门狗就会执行续期操作，将锁的超时时间设置为 30 秒。看门狗续期前也会先判断是否需要执行续期操作，需要才会执行续期，否则取消续期操作。

\n

Watch Dog 通过调用 renewExpirationAsync() 方法实现锁的异步续期：

\n
protected CompletionStage<Boolean> renewExpirationAsync(long threadId) {\n    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,\n            // 判断是否为持锁线程，如果是就执行续期操作，就锁的过期时间设置为 30s（默认）\n            \"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then \" +\n                    \"redis.call('pexpire', KEYS[1], ARGV[1]); \" +\n                    \"return 1; \" +\n                    \"end; \" +\n                    \"return 0;\",\n            Collections.singletonList(getRawName()),\n            internalLockLeaseTime, getLockName(threadId));\n}
\n

可以看出， renewExpirationAsync 方法其实是调用 Lua 脚本实现的续期，这样做主要是为了保证续期操作的原子性。

\n

我这里以 Redisson 的分布式可重入锁 RLock 为例来说明如何使用 Redisson 实现分布式锁：

\n
// 1.获取指定的分布式锁对象\nRLock lock = redisson.getLock(\"lock\");\n// 2.拿锁且不设置锁超时时间，具备 Watch Dog 自动续期机制\nlock.lock();\n// 3.执行业务\n...\n// 4.释放锁\nlock.unlock();
\n

只有未指定锁超时时间，才会使用到 Watch Dog 自动续期机制。

\n
// 手动给锁设置过期时间，不具备 Watch Dog 自动续期机制\nlock.lock(10, TimeUnit.SECONDS);
\n

如果使用 Redis 来实现分布式锁的话，还是比较推荐直接基于 Redisson 来做的。

\n

如何实现可重入锁？

\n

所谓可重入锁指的是在一个线程中可以多次获取同一把锁，比如一个线程在执行一个带锁的方法，该方法中又调用了另一个需要相同锁的方法，则该线程可以直接执行调用的方法即可重入 ，而无需重新获得锁。像 Java 中的 synchronized 和 ReentrantLock 都属于可重入锁。

\n

不可重入的分布式锁基本可以满足绝大部分业务场景了，一些特殊的场景可能会需要使用可重入的分布式锁。

\n

可重入分布式锁的实现核心思路是线程在获取锁的时候判断是否为自己的锁，如果是的话，就不用再重新获取了。为此，我们可以为每个锁关联一个可重入计数器和一个占有它的线程。当可重入计数器大于 0 时，则锁被占有，需要判断占有该锁的线程和请求获取锁的线程是否为同一个。

\n

实际项目中，我们不需要自己手动实现，推荐使用我们上面提到的 Redisson ，其内置了多种类型的锁比如可重入锁（Reentrant Lock）、自旋锁（Spin Lock）、公平锁（Fair Lock）、多重锁（MultiLock）、 红锁（RedLock）、 读写锁（ReadWriteLock）。

\n

\n

Redis 如何解决集群情况下分布式锁的可靠性？

\n

为了避免单点故障，生产环境下的 Redis 服务通常是集群化部署的。

\n

Redis 集群下，上面介绍到的分布式锁的实现会存在一些问题。由于 Redis 集群数据同步到各个节点时是异步的，如果在 Redis 主节点获取到锁后，在没有同步到其他节点时，Redis 主节点宕机了，此时新的 Redis 主节点依然可以获取锁，所以多个应用服务就可以同时获取到锁。

\n

\n

针对这个问题，Redis 之父 antirez 设计了 Redlock 算法 来解决。

\n

\n

Redlock 算法的思想是让客户端向 Redis 集群中的多个独立的 Redis 实例依次请求申请加锁，如果客户端能够和半数以上的实例成功地完成加锁操作，那么我们就认为，客户端成功地获得分布式锁，否则加锁失败。

\n

即使部分 Redis 节点出现问题，只要保证 Redis 集群中有半数以上的 Redis 节点可用，分布式锁服务就是正常的。

\n

Redlock 是直接操作 Redis 节点的，并不是通过 Redis 集群操作的，这样才可以避免 Redis 集群主从切换导致的锁丢失问题。

\n

Redlock 实现比较复杂，性能比较差，发生时钟变迁的情况下还存在安全性隐患。《数据密集型应用系统设计》一书的作者 Martin Kleppmann 曾经专门发文（How to do distributed locking - Martin Kleppmann - 2016）怼过 Redlock，他认为这是一个很差的分布式锁实现。感兴趣的朋友可以看看Redis 锁从面试连环炮聊到神仙打架这篇文章，有详细介绍到 antirez 和 Martin Kleppmann 关于 Redlock 的激烈辩论。

\n

实际项目中不建议使用 Redlock 算法，成本和收益不成正比，可以考虑基于 Redis 主从复制+哨兵模式实现分布式锁。

\n

基于 ZooKeeper 实现分布式锁

\n

ZooKeeper 相比于 Redis 实现分布式锁，除了提供相对更高的可靠性之外，在功能层面还有一个非常有用的特性：Watch 机制。这个机制可以用来实现公平的分布式锁。不过，使用 ZooKeeper 实现的分布式锁在性能方面相对较差，因此如果对性能要求比较高的话，ZooKeeper 可能就不太适合了。

\n

如何基于 ZooKeeper 实现分布式锁？

\n

ZooKeeper 分布式锁是基于 临时顺序节点 和 Watcher（事件监听器） 实现的。

\n

获取锁：

\n
    \n
  1. 首先我们要有一个持久节点/locks，客户端获取锁就是在locks下创建临时顺序节点。
    2. \n
  2. 假设客户端 1 创建了/locks/lock1节点，创建成功之后，会判断 lock1是否是 /locks 下最小的子节点。
    3. \n
  3. 如果 lock1是最小的子节点，则获取锁成功。否则，获取锁失败。
    4. \n
  4. 如果获取锁失败，则说明有其他的客户端已经成功获取锁。客户端 1 并不会不停地循环去尝试加锁，而是在前一个节点比如/locks/lock0上注册一个事件监听器。这个监听器的作用是当前一个节点释放锁之后通知客户端 1（避免无效自旋），这样客户端 1 就加锁成功了。
    5. \n
\n

释放锁：

\n
    \n
  1. 成功获取锁的客户端在执行完业务流程之后，会将对应的子节点删除。
    2. \n
  2. 成功获取锁的客户端在出现故障之后，对应的子节点由于是临时顺序节点，也会被自动删除，避免了锁无法被释放。
    3. \n
  3. 我们前面说的事件监听器其实监听的就是这个子节点删除事件，子节点删除就意味着锁被释放。
    4. \n
\n

\n

实际项目中，推荐使用 Curator 来实现 ZooKeeper 分布式锁。Curator 是 Netflix 公司开源的一套 ZooKeeper Java 客户端框架，相比于 ZooKeeper 自带的客户端 zookeeper 来说，Curator 的封装更加完善，各种 API 都可以比较方便地使用。

\n

Curator主要实现了下面四种锁：

\n\n
CuratorFramework client = ZKUtils.getClient();\nclient.start();\n// 分布式可重入排它锁\nInterProcessLock lock1 = new InterProcessMutex(client, lockPath1);\n// 分布式不可重入排它锁\nInterProcessLock lock2 = new InterProcessSemaphoreMutex(client, lockPath2);\n// 将多个锁作为一个整体\nInterProcessMultiLock lock = new InterProcessMultiLock(Arrays.asList(lock1, lock2));\n\nif (!lock.acquire(10, TimeUnit.SECONDS)) {\n   throw new IllegalStateException(\"不能获取多锁\");\n}\nSystem.out.println(\"已获取多锁\");\nSystem.out.println(\"是否有第一个锁: \" + lock1.isAcquiredInThisProcess());\nSystem.out.println(\"是否有第二个锁: \" + lock2.isAcquiredInThisProcess());\ntry {\n    // 资源操作\n    resource.use();\n} finally {\n    System.out.println(\"释放多个锁\");\n    lock.release();\n}\nSystem.out.println(\"是否有第一个锁: \" + lock1.isAcquiredInThisProcess());\nSystem.out.println(\"是否有第二个锁: \" + lock2.isAcquiredInThisProcess());\nclient.close();
\n

为什么要用临时顺序节点？

\n

每个数据节点在 ZooKeeper 中被称为 znode，它是 ZooKeeper 中数据的最小单元。

\n

我们通常是将 znode 分为 4 大类：

\n\n

可以看出，临时节点相比持久节点，最主要的是对会话失效的情况处理不一样，临时节点会话消失则对应的节点消失。这样的话，如果客户端发生异常导致没来得及释放锁也没关系，会话失效节点自动被删除，不会发生死锁的问题。

\n

使用 Redis 实现分布式锁的时候，我们是通过过期时间来避免锁无法被释放导致死锁问题的，而 ZooKeeper 直接利用临时节点的特性即可。

\n

假设不使用顺序节点的话，所有尝试获取锁的客户端都会对持有锁的子节点加监听器。当该锁被释放之后，势必会造成所有尝试获取锁的客户端来争夺锁，这样对性能不友好。使用顺序节点之后，只需要监听前一个节点就好了，对性能更友好。

\n

为什么要设置对前一个节点的监听？

\n
\n

Watcher（事件监听器），是 ZooKeeper 中的一个很重要的特性。ZooKeeper 允许用户在指定节点上注册一些 Watcher，并且在一些特定事件触发的时候，ZooKeeper 服务端会将事件通知到感兴趣的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。

\n
\n

同一时间段内，可能会有很多客户端同时获取锁，但只有一个可以获取成功。如果获取锁失败，则说明有其他的客户端已经成功获取锁。获取锁失败的客户端并不会不停地循环去尝试加锁，而是在前一个节点注册一个事件监听器。

\n

这个事件监听器的作用是：当前一个节点对应的客户端释放锁之后（也就是前一个节点被删除之后，监听的是删除事件），通知获取锁失败的客户端（唤醒等待的线程，Java 中的 wait/notifyAll ），让它尝试去获取锁，然后就成功获取锁了。

\n

如何实现可重入锁？

\n

这里以 Curator 的 InterProcessMutex 对可重入锁的实现来介绍（源码地址：InterProcessMutex.java）。

\n

当我们调用 InterProcessMutex#acquire方法获取锁的时候，会调用InterProcessMutex#internalLock方法。

\n
// 获取可重入互斥锁，直到获取成功为止\n@Override\npublic void acquire() throws Exception {\n  if (!internalLock(-1, null)) {\n    throw new IOException(\"Lost connection while trying to acquire lock: \" + basePath);\n  }\n}
\n

internalLock 方法会先获取当前请求锁的线程，然后从 threadData( ConcurrentMap<Thread, LockData> 类型)中获取当前线程对应的 lockData 。 lockData 包含锁的信息和加锁的次数，是实现可重入锁的关键。

\n

第一次获取锁的时候，lockData为 null。获取锁成功之后，会将当前线程和对应的 lockData 放到 threadData 中

\n
private boolean internalLock(long time, TimeUnit unit) throws Exception {\n  // 获取当前请求锁的线程\n  Thread currentThread = Thread.currentThread();\n  // 拿对应的 lockData\n  LockData lockData = threadData.get(currentThread);\n  // 第一次获取锁的话，lockData 为 null\n  if (lockData != null) {\n    // 当前线程获取过一次锁之后\n    // 因为当前线程的锁存在， lockCount 自增后返回，实现锁重入.\n    lockData.lockCount.incrementAndGet();\n    return true;\n  }\n  // 尝试获取锁\n  String lockPath = internals.attemptLock(time, unit, getLockNodeBytes());\n  if (lockPath != null) {\n    LockData newLockData = new LockData(currentThread, lockPath);\n     // 获取锁成功之后，将当前线程和对应的 lockData 放到 threadData 中\n    threadData.put(currentThread, newLockData);\n    return true;\n  }\n\n  return false;\n}
\n

LockData是 InterProcessMutex中的一个静态内部类。

\n
private final ConcurrentMap<Thread, LockData> threadData = Maps.newConcurrentMap();\n\nprivate static class LockData\n{\n    // 当前持有锁的线程\n    final Thread owningThread;\n    // 锁对应的子节点\n    final String lockPath;\n    // 加锁的次数\n    final AtomicInteger lockCount = new AtomicInteger(1);\n\n    private LockData(Thread owningThread, String lockPath)\n    {\n      this.owningThread = owningThread;\n      this.lockPath = lockPath;\n    }\n}
\n

如果已经获取过一次锁，后面再来获取锁的话，直接就会在 if (lockData != null) 这里被拦下了，然后就会执行lockData.lockCount.incrementAndGet(); 将加锁次数加 1。

\n

整个可重入锁的实现逻辑非常简单，直接在客户端判断当前线程有没有获取锁，有的话直接将加锁次数加 1 就可以了。

\n

总结

\n

在这篇文章中，我介绍了实现分布式锁的两种常见方式：Redis 和 ZooKeeper。至于具体选择 Redis 还是 ZooKeeper 来实现分布式锁，还是要根据业务的具体需求来决定。

\n\n

需要注意的是，无论选择哪种方式实现分布式锁，包括 Redis、ZooKeeper 或 Etcd（本文没介绍，但也经常用来实现分布式锁），都无法保证 100% 的安全性，特别是在遇到进程垃圾回收（GC）、网络延迟等异常情况下。

\n

为了进一步提高系统的可靠性，建议引入一个兜底机制。例如，可以通过 版本号（Fencing Token）机制 来避免并发冲突。

\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/distributed-system/distributed-lock/distributed-lock-setnx.png", "date_published": "2022-08-23T10:53:21.000Z", "date_modified": "2026-03-12T04:06:59.000Z", "authors": [], "tags": [ "分布式" ] }, { "title": "分布式锁入门介绍", "url": "https://javaguide.cn/distributed-system/distributed-lock.html", "id": "https://javaguide.cn/distributed-system/distributed-lock.html", "summary": "分布式锁基础概念详解，讲解为什么需要分布式锁、分布式锁的核心特性（互斥性、防死锁、可重入）、常见应用场景（秒杀、库存扣减）分析。", "content_html": "

\"JavaGuide官方知识星球\"

\n

网上有很多分布式锁相关的文章，写了一个相对简洁易懂的版本，针对面试和工作应该够用了。

\n

这篇文章我们先介绍一下分布式锁的基本概念。

\n

为什么需要分布式锁？

\n

在多线程环境中，如果多个线程同时访问共享资源（例如商品库存、外卖订单），会发生数据竞争，可能会导致出现脏数据或者系统问题，威胁到程序的正常运行。

\n

举个例子，假设现在有 100 个用户参与某个限时秒杀活动，每位用户限购 1 件商品，且商品的数量只有 3 个。如果不对共享资源进行互斥访问，就可能出现以下情况：

\n\n

\"共享资源未互斥访问导致出现问题\"

\n

为了保证共享资源被安全地访问，我们需要使用互斥操作对共享资源进行保护，即同一时刻只允许一个线程访问共享资源，其他线程需要等待当前线程释放后才能访问。这样可以避免数据竞争和脏数据问题，保证程序的正确性和稳定性。

\n

如何才能实现共享资源的互斥访问呢？ 锁是一个比较通用的解决方案，更准确点来说是悲观锁。

\n

悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。

\n

对于单机多线程来说，在 Java 中，我们通常使用 ReentrantLock 类、synchronized 关键字这类 JDK 自带的 本地锁 来控制一个 JVM 进程内的多个线程对本地共享资源的访问。

\n

下面是我对本地锁画的一张示意图。

\n

\"本地锁\"

\n

从图中可以看出，这些线程访问共享资源是互斥的，同一时刻只有一个线程可以获取到本地锁访问共享资源。

\n

分布式系统下，不同的服务/客户端通常运行在独立的 JVM 进程上。如果多个 JVM 进程共享同一份资源的话，使用本地锁就没办法实现资源的互斥访问了。于是，分布式锁 就诞生了。

\n

举个例子：系统的订单服务一共部署了 3 份，都对外提供服务。用户下订单之前需要检查库存，为了防止超卖，这里需要加锁以实现对检查库存操作的同步访问。由于订单服务位于不同的 JVM 进程中，本地锁在这种情况下就没办法正常工作了。我们需要用到分布式锁，这样的话，即使多个线程不在同一个 JVM 进程中也能获取到同一把锁，进而实现共享资源的互斥访问。

\n

下面是我对分布式锁画的一张示意图。

\n

\"分布式锁\"

\n

从图中可以看出，这些独立的进程中的线程访问共享资源是互斥的，同一时刻只有一个线程可以获取到分布式锁访问共享资源。

\n

分布式锁应该具备哪些条件？

\n

一个最基本的分布式锁需要满足：

\n\n

除了上面这三个基本条件之外，一个好的分布式锁还需要满足下面这些条件：

\n\n

分布式锁的常见实现方式有哪些？

\n

常见分布式锁实现方案如下：

\n\n

关系型数据库的方式一般是通过唯一索引或者排他锁实现。不过，一般不会使用这种方式，问题太多比如性能太差、不具备锁失效机制。

\n

基于 ZooKeeper 或者 Redis 实现分布式锁这两种实现方式要用的更多一些，我专门写了一篇文章来详细介绍这两种方案：分布式锁常见实现方案总结。

\n

总结

\n

这篇文章我们主要介绍了：

\n\n

写在最后

\n

感谢你能看到这里，也希望这篇文章对你有点用。

\n

JavaGuide 坚持更新 6 年多，近 6000 次提交、600+ 位贡献者一起打磨。如果这些内容对你有帮助，非常欢迎点个免费的 Star 支持下（完全自愿，觉得有收获再点就好）：GitHub | Gitee。

\n

如果你想要付费支持/面试辅导（比如实战项目、简历优化、一对一提问、高频考点突击资料等）的话，欢迎了解我的知识星球。已经坚持维护六年，内容持续更新，虽白菜价（0.4元/天）但质量很高，主打一个良心！

\n\"JavaGuide\n", "image": "https://oss.javaguide.cn/github/javaguide/distributed-system/distributed-lock/oversold-without-locking.png", "date_published": "2022-08-23T10:53:21.000Z", "date_modified": "2026-03-12T04:06:59.000Z", "authors": [], "tags": [ "分布式" ] } ] }