Posts on Coder_Studio

从 MSE 到交叉熵：一文搞懂损失函数

Sun, 21 Jun 2026 11:48:50 +0000

什么是损失函数？

机器学习模型究竟依靠什么完成"学习"？

它凭什么判断自身的表现是否达标、又该在哪些方面做出改进？

我们可以通过一个类比来理解——学生在完成课后作业时，老师会给出一个分数。无论是80分、90分还是不及格，学生都能通过这个分数发现自己哪里掌握得不够牢固，并据此调整后续的学习策略，争取下一次取得更好的成绩。

机器学习的模型同样具备类似的反馈机制，这个机制的名称就叫——损失函数。

损失函数在机器学习中占据着比较重要的位置。

如果无法理解损失函数的工作原理，就很难真正搞清楚模型是如何完成训练的。

因此，想要真正掌握机器学习的核心原理，损失函数是一个必须深入理解的基础概念。

从数学角度来讲，损失函数是用于衡量模型预测输出与真实标签之间差异的一种量化方法。

设想这样一个场景：

一个气象预报员，预测明天的气温是20℃，而实际观测值是22℃。

预测值与真实值之间的偏差是多少？

最直接的计算方式是用 20 减去 22 得到 -2，偏差为2℃。

但这里出现了一个问题：

如果有100次预报记录，将正偏差和负偏差直接相加会导致它们相互抵消，最终累加结果可能为零——意味着"零误差"，显然这与现实情况是不符的。

解决这一问题的方法是对每次偏差进行平方处理，使所有数值都变为正数，然后求取平均值。这就是"均方误差"（Mean Squared Error，简称 MSE）。

由此可见，损失函数的本质是一个"差距量化器"——它明确告诉模型：你的预测出现了偏差，偏差量为多少，需要做出调整。

然而，这种差距信号如何真正转化为模型的改进能力呢？

关键在于梯度。

具体而言，我们可以通过反向传播算法，利用链式法则逐层计算损失函数对各参数的梯度，得到的梯度方向指示了参数应该增大还是减小，梯度的大小则给出了调整的幅度。

模型根据这些梯度信息更新自身参数，持续缩小与真实值之间的距离。

这一优化过程被称为梯度下降。

需要明确的一个核心认知是：

驱动模型学习的根本动力，来源于损失函数所提供的梯度信号。

如果没有损失函数，就不会有梯度；

没有梯度，模型就只能在参数空间中盲目搜索。

因此，损失函数决定了模型能否有效学习，是整个学习过程的灵魂所在。

什么样的损失函数才算合格？

第一，可导性。

损失函数最好能够计算梯度，或者在不可导点存在次梯度（Subgradient），从而支持梯度优化算法。

第二，单调性。

模型的预测越接近真实值，损失值应当越小；

预测偏离真实值越远，损失值应当越大。

只有满足这一性质，模型才能形成明确的优化方向感，持续向最优解靠近。

第三，良好的优化性质。

理想情况下，损失函数及其对应优化目标具有良好的优化性质，能够帮助模型更稳定地收敛到低损失区域。

第四，计算高效。

在大规模数据集训练场景中，损失函数需要被频繁计算，因此计算效率十分重要。

在这四项特性中，前两项属于硬性约束，后两项则是理想层面的加分项。

具体损失函数分析

均方误差（MSE）

MSE 的全称为 Mean Squared Error，逐词拆解：Mean 表示"平均"，Squared 表示"平方"，Error 表示"误差"。

组合起来的含义即——误差平方的平均值。

其计算流程分为四个步骤：

对每个样本分别计算预测值与真实值之间的差值（也称为残差）。
对每个残差执行平方运算。
将所有平方后的残差累加求和。
除以样本总数 N，得到平均值。

为什么不直接使用残差的绝对值，而一定要选择平方？

第一个理由：消除符号干扰。

假设模型对样本 A 的预测偏高了 5 个单位，对样本 B 的预测偏低了 5 个单位。如果直接将两者相加，5 + (-5) = 0，表面上看起来误差为零，但实际上模型的两次预测都是错误的。

经过平方运算后，5² = 25，(-5)² = 25，两项均为正数相加，真实误差便无法被掩盖。

第二个理由：放大较大误差。

假设有三个样本的绝对误差分别为 1、2、3。

在不平方的情况下，误差总和为 6；

而经过平方后，1 + 4 + 9 = 14，其中误差为 3 的样本贡献了 9，占总损失的比重超过六成。

这说明平方机制天然地让模型更加重视那些预测严重失准的样本，尽量避免出现"离谱的错误"，这通常与实际需求相一致。

第三个理由：求导运算友好。

平方函数在其定义域内处处可导，导数形式为线性表达式 2x，结构简洁，使得梯度下降算法的运行非常顺畅。

第四个理由：拥有深厚的统计学根基。

在正态分布假设下，MSE 与最大似然估计在数学上是等价的。

它并非一种拍脑袋想出来的启发式技巧，而是建立在严格的概率论基础之上的。

MSE 的优势与局限

优势：

计算极为简洁——仅需减法、平方、加法和除法四步运算，即便面对千万级甚至亿级规模的数据也能快速处理。

在整个定义域内处处可导，梯度形式简洁干净，不存在任何断点或奇点来阻碍优化过程。

数学性质优良，许多优化算法的理论分析都建立在 MSE 这类凸函数的框架之上。

局限：

最突出的短板是对异常值（离群点）极度敏感。

平方的放大效应意味着一个极端异常值可能主导整个损失函数的值。

例如假设有 10 个样本的偏差均为 1，另有 1 个样本的偏差为 10。

前 10 个样本各自贡献 1，合计 10；

而异常样本贡献了 100，占总损失的约 91%。

模型因此可能被这一个异常样本带偏方向，从而忽略了大多数正常数据的分布特征。

另一个问题是量纲失真。

原始数据如果分布在 0 到 100 之间，MSE 的值域可能膨胀到 0 到 10000，损失值本身的直观含义变得模糊。

适用场景：

回归任务的首选方案——凡是预测连续型数值（如房价、气温、销量等），MSE 通常是最自然且最常用的选择。

但如果数据中存在较多异常值，建议考虑 MAE（平均绝对误差）或 Huber Loss，它们对噪声数据具有更强的鲁棒性。

梯度下降的训练循环

利用 MSE 的梯度来驱动模型参数更新，每一轮迭代包含以下四个步骤：

前向传播：使用当前参数对输入数据进行预测。
计算损失：通过 MSE 公式量化预测值与真实标签之间的差距。
反向传播：沿计算图从输出层向输入层逐层回溯，依次计算每个参数的梯度，明确每个参数应该朝哪个方向调整、调整的幅度有多大。
参数更新：沿着梯度的反方向对参数值进行微调——梯度为正值时减小参数，为负值时增大参数。

重复执行上述流程 50 次（或更多轮），模型便会在损失曲面上逐步滑动，不断逼近最优解。

交叉熵：分类问题的核心损失函数

接下来介绍第二个重要的损失函数——交叉熵（Cross Entropy），它是分类任务中最常用的损失函数。

设想这样一个应用场景：

向模型输入一张图片，要求它判断图片中的动物是猫、狗还是鸟。

有人可能会认为，模型直接输出一个整数编码即可——0 代表猫，1 代表狗，2 代表鸟，然后取最大值的对应类别就行了。

这种思路在逻辑上看似合理，但存在一个缺陷：

模型对自己的预测结果有多大把握？

这种确定性完全无法从单一整数编码中获知。

更为合理的方式是让模型输出一个概率向量。

例如：猫 0.7、狗 0.2、鸟 0.1，三个概率值之和为 1，构成一个完整的概率分布。

通过这种方式，我们不仅获得了模型的预测结果，还获得了衡量模型"自信程度"的依据。

在很多实际应用场景中，这种置信度信息至关重要。

例如医疗影像诊断：

模型 A 判定为恶性肿瘤，置信度 0.95。

模型 B 判定为恶性肿瘤，置信度 0.52。

虽然两者结论一致，但前者的预测可信度明显更高，因此更值得进一步关注。

那么问题就来了：

如何衡量模型输出的概率分布与真实标签之间的差异？

这就是交叉熵函数所要解决的问题。

交叉熵到底在计算什么？

交叉熵的核心思想其实非常简单：

如果模型把真实答案的概率预测得越高，那么损失就应该越小；

如果模型把真实答案的概率预测得越低，那么损失就应该越大。

例如有一个三分类任务：

真实答案是：

猫 = 1
狗 = 0
鸟 = 0

模型 A 的预测结果为：

猫：0.90
狗：0.05
鸟：0.05

由于模型给正确类别“猫”分配了 90% 的概率，说明模型非常有把握地预测正确，此时交叉熵损失会非常小。

而模型 B 的预测结果为：

猫：0.01
狗：0.98
鸟：0.01

虽然三个概率之和同样为 1，但模型几乎把全部概率都给了错误类别“狗”。

这意味着模型不仅预测错误，而且错得非常自信。

对于这种情况，交叉熵会给予极大的惩罚。

因此可以把交叉熵理解为一种专门衡量“预测概率质量”的损失函数。

它不仅关心模型有没有预测正确，更关心模型到底有多大的把握。

预测正确且越自信，损失越小；

预测错误且越自信，损失越大。

正因为这种特性，交叉熵能够为分类模型提供更加清晰有效的优化方向，因此成为分类任务中最主流的损失函数。

MSE 与交叉熵的核心差异

维度	MSE	交叉熵
适用任务	回归（预测连续值）	分类（预测离散类别）
输出形式	实数（如 3.5、-2.1）	概率（0~1 之间的值）
梯度特性	梯度受平方项影响较大，对异常敏感	梯度与误差成线性关系，传播更平稳
收敛行为	回归任务上收敛稳定	分类任务上收敛更快、更稳定

如何选择损失函数

判断任务类型

如果输出为连续数值 → 回归问题，如果输出为类别标签 → 分类问题。

回归任务看数据质量

如果数据包含较多异常值 → 选择 MAE 或 Huber Loss

如果数据较为干净、近似正态分布 → 选择 MSE

分类任务看类别数量

如果仅有两个类别 → 二元交叉熵（Binary Cross Entropy）

如果两个以上类别 → 多元分类交叉熵（Categorical Cross Entropy）

初学者常犯的三个错误

用 MSE 做分类任务。

这是新手最常犯的错误。

因为在分类任务中，当分类模型使用 sigmoid 或 softmax 输出概率时，如果再配合 MSE 作为损失函数，梯度在饱和区域会迅速衰减，导致训练速度明显变慢。

用交叉熵做回归任务。

交叉熵要求输出为合法的概率分布（非负且和为 1），回归任务的输出为任意实数，计算框架通常会直接报错；

即便绕过了框架检查，梯度也会完全失效，模型无法学到任何有效信息。

只监控训练损失，忽视验证损失。

许多初学者在训练过程中仅关注训练集损失持续下降这一现象便感到满意，却忽略了验证集损失可能已经开始反弹——这标志着过拟合正在发生。

正确的方法是同时监控训练损失和验证损失两条曲线，当验证损失不再下降甚至开始上升时，即使训练损失仍在降低，也应当停止训练或引入正则化手段来抑制过拟合。

Claude Code 免费接入讯飞星辰 Qwen3.6-35B-A3B 模型，白嫖攻略来了！

Tue, 09 Jun 2026 00:55:09 +0000

限时免费到6月30日，手慢无！

最近讯飞星辰 MaaS 平台可以免费领取Qwen3.6-35B-A3B、Qwen3.5-35B-A3B两个 Qwen 系列模型的调用权益，这意味着你可以零成本把这个强大的模型接入到 Claude Code 中，享受免费的高质量代码生成和智能编程体验。

本文就来手把手教你，如何把Qwen3.6-35B-A3B模型接入 Claude Code。

接入流程

1.在讯飞星辰平台找到模型

登录讯飞星辰 MaaS 平台，进入【模型集市】，找到 Qwen3.6-35B-A3B 模型卡片，点击【API调用】按钮。

2.创建 API 服务

在 API 调用页面，填写模型服务 API 名称（例如 Chatxunfei），选择要授权的应用。

重点来了——计费方式显示输入和输出费用均为 0 元/百万 tokens，免费有效期到 6月30日，7月1日10点后转为后付费。

所以趁现在赶紧用起来！

3.创建应用（如尚未创建）

如果你还没有应用，需要先前往讯飞开放平台创建一个应用。

填写应用名称、分类和功能描述，提交即可。

4.获取modelId和APIKey

创建完成后，在推理服务页面可以看到你部署的服务信息，包括：

modelId：xopqwen36v35b
APIKey：用于身份认证

5.在CC Switch 中配置模型

先进入CC Switch的网址： https://github.com/farion1231/cc-switch/releases/tag/v3.16.0

下载好CC Switch。

如果访问Github有困难，也可以通过以下方式下载

链接：https://pan.quark.cn/s/46e3a4a215bd

打开 CC Switch，添加新供应商：

参数填写可参考：

配置完成后，CC Switch 会自动将 Claude Code 的请求路由到讯飞星辰的 API 端点。

6.在 Claude Code 中测试

配置完成后，打开 Claude Code，测试一下：

如上图所示模型显示为：xopqwen36v35b，而且正常返回了结果，说明接入成功。

让 AI Agent 跨会话接住工作：一场对照实验

Sun, 07 Jun 2026 14:38:00 +0000

当 AI 编程助手越来越强大，一个关键问题浮出水面：它能接住别人（或昨天的自己）没干完的活吗？

问题的起源

真实开发不是一次会话就干完的。你昨天写了一半，今天开新会话，agent 需要从仓库状态里搞清楚：

项目是干什么的？
怎么启动？
哪些功能已经做了？
哪些还没做？
下一个该做什么？

如果 agent 要靠"猜"来回答这些问题，那它本质上是在重新发现已经存在的信息。这既浪费时间，又容易出错。

实验设计

我们在同一个 Electron 知识库应用上做了两组对照实验，任务完全一致——实现三个功能：

功能	描述
kb-005 文档导入	从本地导入 .txt/.md 文件
kb-006 文档详情视图	点击文档查看完整内容
kb-007 文档持久化	重启后文档仍在

两组实验的区别只在于：仓库里有没有"可读的上下文"。

实验组 A：弱 Harness（Baseline）

仓库里有什么？
├── main.js          # 代码
├── preload.js       # 代码
├── index.html       # 代码
├── renderer.js      # 代码
├── package.json     # 依赖
└── task-prompt.md   # 任务描述

仓库里没有什么？
✗ ARCHITECTURE.md    — 没有架构文档
✗ PRODUCT.md         — 没有产品文档
✗ session-handoff.md — 没有交接文件
✗ feature_list.json  — 有，但 agent 不知道要先读

会话 A：agent 完成了文档导入（kb-005），然后被中断。没有写任何交接文件。

会话 B：开全新会话，只说了一句：

继续开发。

发生了什么？

┌─────────────────────────────────────────────────────────┐
│  会话 B 的探索过程                                       │
│                                                         │
│  Step 1: 读 main.js          → 哦，这是 Electron 应用    │
│  Step 2: 读 package.json     → 启动命令是 npm start      │
│  Step 3: 读 preload.js       → 用 contextBridge 暴露 API │
│  Step 4: 读 index.html       → 这是 UI 布局              │
│  Step 5: 读 renderer.js      → 哦，已经有一个导入按钮了   │
│  Step 6: 读 feature_list.json → kb-001~004 已完成         │
│  Step 7: 对比代码差异        → 所以 kb-005 做完了？       │
│  Step 8: 终于开始写代码...    → 但已经过去很久了          │
└─────────────────────────────────────────────────────────┘

核心问题： agent 花了大量时间在重新发现——项目结构、启动方式、数据流、已完成的功能。这些都是会话 A 已经知道的信息。

实验组 B：强 Harness（Improved）

仓库里有什么？
├── ARCHITECTURE.md    # 项目架构、数据流、IPC 接口清单
├── PRODUCT.md         # 产品功能范围和当前阶段目标
├── AGENTS.md          # 启动命令、工作规则
├── feature_list.json  # 功能状态（已更新）
├── session-handoff.md # 本轮做了什么、没做什么、下一步
├── main.js            # 代码
├── preload.js         # 代码
├── index.html         # 代码
├── renderer.js        # 代码
└── task-prompt.md     # 任务描述

会话 A：同样完成了文档导入（kb-005），中断前更新了 session-handoff.md 和 feature_list.json。

会话 B 的 session-handoff.md：

## 本轮会话做了什么
- kb-005 文档导入：已完成并验证通过

## 没做什么（遗留功能）
- kb-006 文档详情视图：未开始
- kb-007 文档持久化：未开始

## 下一步
1. 实现 kb-006：文档详情视图
2. 实现 kb-007：文档持久化

会话 B：开全新会话，发送：

1
2

请先阅读 session-handoff.md、feature_list.json、ARCHITECTURE.md、PRODUCT.md，
然后继续开发未完成的功能。

发生了什么？

┌─────────────────────────────────────────────────────────┐
│  会话 B 的探索过程                                       │
│                                                         │
│  Step 1: 读 session-handoff.md  → 知道了！kb-005 已完成  │
│                                   下一步是 kb-006        │
│  Step 2: 读 feature_list.json   → 确认功能状态           │
│  Step 3: 读 ARCHITECTURE.md     → 确认项目结构           │
│  Step 4: 直接开始写代码！        → 零浪费                  │
└─────────────────────────────────────────────────────────┘

数据对比

                    弱 Harness          强 Harness
                    ─────────          ─────────
接手所需文件数      ████████ 6-8       ██ 2-3
重新发现次数        ██████ 6+          ░ 0~1
重复工作比例        ██████ ~30%        ░ ~5%
上下文理解准确度    可能有偏差          准确无误

关键洞察

1. 代码不是文档

代码能告诉你"怎么做"，但很难告诉你"做了什么、为什么没做、下一步做什么"。一个 500 行的 main.js 不会告诉你 kb-006 还没开始——agent 必须自己推断，而推断经常出错。

2. 交接文件是"会话的 checkpoint"

session-handoff.md 就像一个游戏存档。没有它，每次新会话都相当于从第一关重打。有了它，agent 可以直接从上次中断的地方继续。

3. 最重要的三行信息

1
2
3

做了什么：kb-005 文档导入 ✓
没做什么：kb-006 文档详情、kb-007 文档持久化
下一步：从 kb-006 开始

就这三行，节省了 agent 6+ 步探索。

4. 一份大指令文件不够

如果把所有规则塞进一个巨大的 system prompt，agent 会"迷失在细节里"。仓库中的多个小文件（ARCHITECTURE.md、PRODUCT.md、session-handoff.md）各司其职，按需读取，效果更好。

结论

仓库必须是唯一的事实来源。

不是某个 agent 的记忆，不是聊天记录，不是某个巨大的指令文件——而是仓库里的结构化文档。

当你的 agent 能在一分钟内搞清"这是哪、到哪了、下一步去哪"，你就有了一个真正可交接的 AI 工作流。

只写提示词让 agent 做，和定好规则再让它做，差多少

Sun, 07 Jun 2026 08:21:47 +0000

实验背景

AI Agent 写代码越来越强，但"强"不等于"可靠"。同样的模型、同样的提示词，为什么有时候一次就过，有时候反复翻车？答案往往不在模型本身，而在你给它的规则和约束。

这个实验用 Electron 搭建一个知识库应用壳子，跑两次：

弱 Harness：只给一段提示词，什么都不准备
强 Harness：提前准备好 AGENTS.md、feature_list.json、claude-progress.md，用结构化方式告诉 Agent 该干什么、怎么验证、什么时候算做完

任务定义

用 Electron 做一个知识库应用，包含四个核心功能：

编号	功能	要求
kb-001	窗口启动	`npm start` 后 Electron 窗口正常打开
kb-002	左侧文档列表	左侧面板显示文档列表区域
kb-003	右侧问答面板	右侧面板包含输入框和对话区域
kb-004	本地数据目录	应用启动时创建数据目录，包含 documents/、qa/ 子目录

Harness 是什么

Harness 不是代码，是一套告诉 Agent 怎么干活、怎么验证、什么时候算做完的规则文件。这个实验用的 Harness 核心包含三个文件，实际仓库中还会配合 init.sh 等辅助脚本：

AGENTS.md

定义 Agent 的核心行为规则：

- 一次只做一个功能
- 实现后必须运行 npm start 验证
- 不要因为"代码已经写了"就把功能标记为完成
- 验证证据记录在 feature_list.json 或 claude-progress.md
- 一个功能只有在目标行为已实现、npm start 成功、证据已记录才算完成

feature_list.json

每个功能的唯一事实来源，包含验收标准、证据槽位：

{
  "id": "kb-001",
  "title": "窗口启动",
  "status": "not_started",
  "verification": [
    "运行 npm start",
    "确认 Electron 窗口成功打开",
    "确认窗口标题显示应用名称"
  ],
  "evidence": []
}

claude-progress.md

会话进度日志，记录当前状态、已完成功能、已知风险、下一步动作。

第一次实验：弱 Harness

分支：p01-baseline

提示词：

用 Electron 做一个知识库应用，窗口左边是文档列表区域，右边是问答面板区域，应用需要创建并使用本地数据目录。

仓库状态：空的 package.json，没有 AGENTS.md，没有 feature_list.json

过程

Agent 自由发挥，一次性完成了所有四个功能。代码质量很好，UI 布局清晰，IPC 通信正确。

结果

功能	状态	备注
kb-001 窗口启动	✅ 完成	一次通过
kb-002 文档列表	✅ 完成	左侧 300px 面板
kb-003 问答面板	✅ 完成	右侧 flex 面板
kb-004 数据目录	✅ 完成	目录结构正确

应用截图

弱 Harness 的问题

虽然任务完成了，但存在以下问题：

没有验证证据：功能完成了，但没有记录"怎么验证的"、“验证结果是什么”
没有风险记录：遇到 EPERM 权限问题，但没有记录到任何地方
没有可接续性：下一轮会话必须重新理解代码，无法从上次中断的地方继续
没有完成定义：Agent 不知道"什么时候算做完"，全靠自己判断

第二次实验：强 Harness

分支：p01-improved

提示词：完全相同

仓库状态：AGENTS.md、CLAUDE.md、init.sh、feature_list.json、claude-progress.md 已就位

过程

Agent 严格按照 AGENTS.md 的流程执行：

读取 claude-progress.md → 确认 kb-001 为最高优先级
读取 feature_list.json → 获取 4 个功能的验收标准
发现状态不一致 → feature_list.json 中功能标为 passing，但代码已清空，先修复基础状态
逐功能实现 → 每完成一个功能，运行验证，记录证据
遇到 Blocker → Windows EPERM 阻止在 userData 目录创建子目录，按规则在窄范围修复
更新 Harness 文件 → 所有功能标记为 passing，记录风险

强 Harness 的行为差异

以下是 Agent 在关键决策点上的行为重构示意（非原始逐字日志）：

# Agent 读到的不一致状态时的反应：
"feature_list.json 中所有功能标为 passing，但 main.js 不存在。
 这违反了 AGENTS.md 规则。先修复基础状态。"

# 遇到 Blocker 时的反应：
"EPERM 权限错误。
 AGENTS.md 规则：窄范围修复，不扩大到其他功能。
 将数据目录路径改为项目根目录，功能行为不变。"

# 完成后的动作：
"更新 feature_list.json：
  - status → passing
  - evidence 字段填入验证证据
 更新 claude-progress.md：
  - 记录风险（EPERM）
  - 记录下一步动作"

结果

功能	状态	证据
kb-001 窗口启动	✅ passing	BrowserWindow 创建，index.html 加载
kb-002 文档列表	✅ passing	#left-panel 300px，border-right 边界
kb-003 问答面板	✅ passing	#right-panel flex:1，含输入交互
kb-004 数据目录	✅ passing	data/documents/ + data/qa/ 已创建

应用截图

对比分析

核心指标

指标	弱 Harness	强 Harness	备注
首次成功启动	一次通过	三次	强 Harness 因主动发现并修复 EPERM 权限问题而多次重启，非代码质量问题
遗漏项	无	无
过早停止	否	否
验证证据	无	feature_list.json 结构化证据
风险记录	无	claude-progress.md 记录 EPERM
可接续性	需重新理解代码	读 claude-progress.md 即可
状态一致性检查	无	主动发现并修复不一致

深层差异

这个实验里，两个版本最终都完成了任务，UI 效果完全一样。但这不代表 Harness 没用——恰恰相反，简单的任务看不出 Harness 的价值，复杂的任务看不出 Harness 的边界。

真正体现差异的地方：

1. 状态一致性检查

强 Harness 下，Agent 发现 feature_list.json 中功能标记为 “passing” 但代码不存在时，主动停下来修复基础状态。弱 Harness 下，Agent 不会注意到这种不一致，会在坏的起点上继续叠加代码。

2. Blocker 处理策略

强 Harness 下，遇到 EPERM 权限错误时，AGENTS.md 的"窄范围修复"规则防止了 Agent 去修改其他无关代码。弱 Harness 下，Agent 可能过度修改，也可能直接放弃。

3. 证据链

强 Harness 下，feature_list.json 每个功能都有 evidence 字段记录了验证证据。claude-progress.md 记录了风险和下一步动作。下一轮会话直接读这两个文件就能接续，不需要重新理解代码。

4. 完成定义

强 Harness 有明确的完成定义：目标行为实现 + npm start 成功 + 证据记录在案。弱 Harness 下，Agent 自己判断"差不多完成了"，没有外部验证标准。

关键结论

1. 简单任务中，Harness 的价值是"防御性"的

这次实验任务简单，两个版本都完成了。但 Harness 的价值在于防止意外——状态不一致、权限错误、风险遗漏，这些在简单任务中可能不致命，但在复杂任务中会累积成灾难。

2. Harness 解决的是"接续"问题，不是"完成"问题

Agent 的单次执行能力很强，但多轮会话之间的接续是短板。Harness 通过 feature_list.json（状态）和 claude-progress.md（上下文）让下一轮会话能无缝接续。

3. 规则的价值在于"约束行为"，不在于"提升质量"

Harness 不会让 Agent 写出更好的代码，但会让 Agent 的行为更可预测、更规范。feature_list.json 的验收标准不是为了让代码更好，而是为了让"完成"有一个客观的判断标准。

4. 好的 Harness 是"最小可行约束"

Harness 不是越多越好。AGENTS.md 的核心规则只有几条：一次一个功能、必须验证、证据必须记录。过多的规则会让 Agent 过度遵循流程，反而降低效率。

为什么 temperature=0，模型输出依然不完全一致？

Sat, 06 Jun 2026 17:50:42 +0000

很多人会觉得：

temperature 设成 0，结果应该绝对稳定才对。

因为从数学上看，逻辑似乎很简单。

当 temperature 趋近于 0 时，概率分布会迅速向最大值集中，最终接近一个 One-Hot 分布：最高概率的 token 概率接近 1，其余 token 接近 0。

理论上，这时候不再需要随机采样，而是直接选择分数最高的 token，也就是：

谁最大，就选谁。

既然最大值是确定的，那么输出自然也应该是固定的。

但问题在于：

数学世界是理想化的，而模型推理发生在真实硬件上。

大模型真正运行时，底层依赖的是 GPU 的并行计算架构，而不是一台计算器按顺序一步一步算。

GPU 为了追求吞吐量，会把大量运算同时展开。

比如一串数值求和，它往往不是严格按固定顺序相加，而是拆成多个部分并行计算，再汇总结果。

看起来只是执行顺序不同，但这里会引出一个关键问题：浮点数计算并不严格满足结合律。

在数学里：(a+b)+c 与 a+(b+c)结果一定完全一致。

但在计算机里，尤其是 FP16、BF16 这样的半精度计算中，由于精度截断和舍入误差：同样一组数字，不同计算顺序，最后结果可能会出现极小偏差。

这种偏差通常小到几乎无法察觉，但对于大模型来说，有时候已经足够改变最终输出。

因为模型最后预测 token 时，会得到一整个词表的 logits 分数。

而词表规模往往有几万甚至几十万个 token。

很多情况下，Top-1 和 Top-2 的分数差距极其接近。

例如：Token A=10.55555，Token B=10.55554。

正常情况下，A 排第一。

但如果因为 GPU 并行计算、低精度累积误差，导致某一步出现微小抖动，使得Token A=10.55553，Token B=10.55556，那么排名就可能直接翻转。

虽然变化微乎其微，但对于自回归模型来说，第一个 token 一旦不同，后续生成路径就会迅速分叉。

于是你看到的现象就是temperature 已经设为 0，输出仍然偶尔不一致。

那该怎么提高稳定性？

1. 直接使用 Argmax

这是最直接、也最有效的方法。

如果 temperature=0，就不要再经过 sampling 逻辑，而是直接取 logits 最大值。

也就是跳过随机采样，强制选择 Top-1。

这样可以减少一部分实现层面的不确定性。

2. 固定随机种子

一些推理框架内部，可能仍然存在随机逻辑。

例如：

某些层没有完全关闭随机机制
Tie（分数相同）时采用随机选择
底层实现依赖随机状态

因此固定 seed，可以显著提高复现能力。

但需要注意，固定 seed ≠ 绝对确定。

因为硬件层面的非确定性依然可能存在。

3. 开启确定性模式（Deterministic Mode）

主流框架通常会提供 deterministic 模式。

本质上就是牺牲一部分性能，换取更稳定的结果。

它会尽量避免某些并行乱序计算方式，优先使用可复现的计算路径。

代价是推理速度可能下降。

所以是否开启，需要看业务更重视性能还是稳定性。

4. 提高计算精度

既然误差来自低精度计算，那么一种思路就是在关键计算阶段提高精度。

例如，中间过程使用 FP16/BF16，最后一层 logits 计算切换到 FP32，这样能减少数值误差带来的排序抖动。

零基础看懂机器学习：不用数学，只要生活经验

Thu, 04 Jun 2026 21:56:12 +0000

小时候，爸爸是怎么教你认动物的？

爸爸会指着笼子里的家伙告诉你，这是老虎，身上有条纹；

然后又指着树上的说，那是猴子，尾巴老长。

看多了以后，下次去动物园，就算看到没见过的品种，你也能猜个八九不离十。

这就是机器学习的核心思想：

爸爸给你看的动物是训练数据，他说的名字是标签，你脑子里长出来的判断能力就是模型，你能认出新品那就是预测。

所有的学习都得有人教吗？

当然不是。

比如你第一次搬新家，打开衣柜，衣服扔得乱七八糟，没人帮你整理。

你会怎么办？

你可能会自己琢磨：

这几件都是厚外套，归一块儿；

那几件是短袖T恤，放一起；

这些全是运动裤，也堆一起。

没人告诉你该怎么分，是你自己看着像的放一堆。

这就引出了机器学习的两大类别：监督学习和无监督学习。

监督学习就像爸爸带你逛动物园，有老师有答案，数据带着标签，机器知道对错。

比如，判断快递包裹是不是易碎品，每个包裹事先都标好了，是易碎还是普通。

无监督学习就像你自己收拾衣柜，没老师没答案，数据没标签，机器自己找规律。

比如，把看视频的人分成几拨，机器自己发现哪些人爱好相似。

监督学习是有人教，有标准答案；

无监督学习是自己悟，没有标准答案。

监督学习能干啥

案例1——快递站怎么知道哪个包裹要轻拿轻放

其实是工作人员先收集了几万个包裹，人工标注这个易碎，那个不易碎。

机器从这些标好的包裹里学习。

如果箱子上贴着"玻璃"“瓷器"这些字，或者包装上有向上箭头的标识，大概率就是易碎件；

如果发货地是某个工艺品集中地，也要小心。

学完后，新包裹一到，机器就能自己判断要不要贴"轻放"标签。

案例2——外卖预估送达时间

你点了一份奶茶，距离3公里，中午高峰期，下雨天，骑手手上还有两单，你肯定想知道几点能送到？

以前是靠站长凭经验估算，但经验也常有偏差。

机器学习怎么做？它先看历史订单。

比如：

上周一，同样3公里、雨天、午高峰，送了35分钟；

上周三，2公里、晴天、平峰期，送了20分钟……

学完几千单规律后，你刚下单，它就能预测：这次大概需要38分钟。

无监督学习能干啥

案例1——视频平台用户分群

假设你是某短视频平台的运营，手里有800万用户的观看记录，点赞记录、停留时长、关注列表都有。

问题是，这800万人怎么运营？

你跑一遍无监督算法，机器自动发现，用户居然能分成这么几类：

第一类，专看搞笑段子，每天刷两小时，属于纯娱乐型；

第二类，只看知识科普和纪录片，属于学习型；

第三类，天天看美食和做饭视频，应该是生活爱好者；

第四类，刷的都是穿搭和美妆，大概率是时尚人群。

机器自己就把人分好了，不需要你提前说分几类、按什么分。

然后你就可以给不同人群推不同的内容。

案例2——音乐App自动建歌单

某音乐软件曲库里有上千万首歌，不可能靠编辑一首首归类。

这时候用无监督学习，机器自动分析歌曲。

这一批歌里都有强烈的鼓点和吉他，应该是摇滚；

那一批都是钢琴和弦乐，节奏舒缓，应该是轻音乐；

还有一批全是方言说唱，应该是嘻哈类。

整个过程没人教它什么是摇滚、什么是轻音乐，都是它自己听出来的规律。

这就是无监督学习的厉害之处，让机器自己从数据里挖模式。

怎么做一个机器学习项目

数据收集

首先，没数据就没机器学习。

而且，数据质量比数量更重要。

假设你想训练一个识别狗的模型，结果你找的照片里，狗全是柯基，那训练出来的模型看到哈士奇就不认识了。

所以数据得够多、够杂、够有代表性。

数据预处理

数据收回来就能直接用吗？

不能。

为啥？

因为真实数据一般都是乱糟糟的。

什么叫乱糟糟？

比如：

外卖订单里有一条记录，配送距离写了0.01公里，这显然不对；

有的重量单位是千克，有的是斤，得统一；

有的订单没填楼层信息，这也不行。

所以这一步要清洗数据，删掉明显瞎填的，处理缺信息的，要么删了，要么补上，把所有数据转成统一的标准。

特征工程

预测外卖送达时间的时候，哪些信息有用？

距离有用、天气有用、时段有用，但骑手的手机号有用吗？

没用，订单编号也没啥用。

所以咱们得挑出对预测有帮助的信息，扔掉那些没用的。

这还不够，有时候还得造新特征。

比如我们有店铺出餐速度和配送距离，能不能组合一下？

比如"每公里所需时间"这个指标，可能比单独的两个数字更有用，因为它能反映这段路到底堵不堵。

训练模型

这一步就是让机器开始学。

你要选个合适的算法，比如线性回归、决策树、随机森林，然后把训练数据喂给它：这是1万单历史数据，你好好学学，看看距离、天气、时段跟配送时间到底啥关系。

机器就开始疯狂计算，不断调整内部参数，试图找到最好的对应关系。

这就像学生刷题，刷得越多，理解越深，考试时发挥越好。

模型评估

模型练完了能直接上线吗？

不能，得先考试。

咱们得留一部分数据不给它看，专门用来测它，这叫测试集。

如果考得不好怎么办？

那就回头检查，是不是数据不够？

是的话再去多收点数据。

是不是特征没选好？

是的话重新做特征工程。

是不是算法不合适？

是的话换一个试试。

这就是个不断试错、不断优化的过程。

模型部署

这一步就是把模型放到真实业务里去跑。

比如把外卖预估模型接到点餐App里，用户一下单，系统就实时显示"预计38分钟送达”。

但上线不是结束，而是新的开始。

为什么这么说？

因为路况在变，今天和去年同时段的路况不一样，如果一直用老模型，预测就不准了。所以要持续盯着模型表现，定期拿新订单数据重新训练，这叫模型更新。

什么是特征？

简单说，特征就是描述一件事的各种属性，是模型的输入。

预测外卖时间时，距离、天气、时段就是特征；

判断快递时，包装文字、重量、发货地就是特征；

人脸识别时，眼睛大小、鼻子高低、脸型轮廓就是特征。

特征的类型

数值型

能用数字表示的，比如年龄25岁、价格35块、温度30度。

类别型

离散的类别。

比如：

性别，男、女；

城市，北京、广州；

布尔型

是或否。

比如：

是否雨天；

是否VIP；

是否有电梯；

其实，布尔型可以看作特殊的类别型。

什么是标签？

标签就是咱们想预测的结果，是模型的输出。

机器学习里：

预测外卖时间，标签就是"38分钟"；

判断快递，标签就是"易碎"或"普通"；

诊断疾病，标签就是"健康"或"生病"；

需要注意的是，标签只在监督学习里有。

什么是模型？

其实它就是一个函数。

啥函数？

从特征到标签的映射函数，数学上写成 y = f(x)。x是输入的特征，y是输出的标签，f就是模型这个映射关系。

模型就像一个送了十年外卖的老骑手，机器学习就是让机器通过大量订单积累这种经验，然后用到新订单上。

不同的算法就是不同的积累经验的方式。

怎么评估模型？

评估就是检验模型好不好，但用啥指标，得看任务类型。

分类任务

比如判断快递是不是易碎，最常用的是准确率，看预测对了多少。

比如100个包裹，你猜对了95个，准确率就是95%。

但有时候光看准确率不够。

比如做疾病筛查，1000个人里只有1个真的有病，模型偷懒，全预测成健康，准确率还有99.9%，但那个真有病的人被漏了，这能行吗？

所以还得看召回率，真正有病的人里，你找出来了多少？

这就是为啥需要多种指标一起看。

回归任务

比如预测外卖时间，常用的是平均绝对误差（MAE），预测时间和真实时间平均差多少？

比如：

预测时间平均误差3分钟，说明还挺靠谱；

如果平均误差20分钟，那就差太远了。

还有，R²系数取值通常在0到1之间，越接近1说明模型越好。

你的RAG系统是怎么进行Query改写的？

Thu, 04 Jun 2026 17:15:58 +0000

首先，为什么非得进行Query改写？

答案其实有以下三个维度：

1、弥补语言风格的断层

比如有这么一个场景，用户随口问了一句，那个东西咋操作呢？这是一种日常聊天的语气，但知识库存的通常是详实且专业的书面语，如果直接用原始提问去做向量检索，搜出来的结果基本都是虽然相关但不太对的垃圾内容。

而改写做的就是把口语化表达转换成书面语，让两个世界在向量空间里靠近，这样检索召回率就能显著提升。

2、补齐缺失的上下文信息

用户很多时候提问都不完整，比如有人直接问：应该怎么处理？

那具体处理什么呢？处理代码bug，处理模型精度问题，还是处理业务流程。。。

对于这种提问，模型也是一脸懵，因为就这几个字根本没办法精准检索。

改写器的职责就是把这种模糊提问，通过挖掘隐含的背景信息转化成一个具体且可检索的声明式描述。

3、解决多轮对话的连贯性问题

在多轮对话场景下，用户经常会使用代词（比如它，那个）来指代他前面提到的某件事，但是检索模块根本就听不懂这种表述，接下来对话进行到第四轮，第五轮，系统就开始出现记忆断裂，回复的内容就开始莫名其妙，导致的结果就是用户体验感直线下降。

改写这一环要做的就是执行“指代还原”，把所有的代词、模糊指示语都替换成明确的实体名称，这样即使用户只说：再谈谈刚才那个人的问题，系统也能自动理解那个人具体指的是谁，保证每一轮检索都逻辑清晰。

所以，改写根本不是简单的把话说一遍，它是连接用户表达和向量检索的一座桥梁。

接下来再看具体怎么做

业界验证过的方案有三种，每一种策略都有各自的适用场景。

策略一，反向生成法，学名叫HyDE

这个方法有点反向思维，核心是不直接拿用户提问去搜索库，而是让大模型先生成一个假设的符合用户需求的答案，然后用这个中间产物去做向量检索。

为什么这样效率更高？

因为用户的提问可能表述各异，风格多变，但知识库里的文档都是某种统一的风格，两者直接对比，在向量空间里可能相距甚远。

但如果你先生成一个假答案，这个假答案的语言风格往往会更接近真实的库文档。

假答案和真答案都是答案体，它们在向量空间里自然就靠得更近，这就是用相似的东西搜相似的东西的逻辑，由此一来，召回率能够明显提升。

策略二，任务拆解法

针对复杂综合性的问题，比如用户问：对比分析a公司和b公司过去三年的财务状况，如果你的系统尝试一次性搜索，结果会是什么？

可能会拿到一堆混乱的交叉的信息，最后汇总出来的对比分析就很别扭，聪明的做法是把这个大问题分解成多个子问题，分别执行搜索，最后再做整合。

流程大概是这样，独立搜索a公司财务数据，独立搜索b公司财务数据，提取关键指标，进行纵向对比，生成最终的对比报告。

这种分而治之的方法在复杂问题面前往往效果更好。

策略三，历史融合法

这个方法是专门针对多轮对话而设计的。

逻辑很直白，就是从对话历史自动提取有价值的信息，融合到当前的查询中，比如对话进行到第三轮，用户说：能说的更具体些吗？

系统不是直接拿这句话去搜，而是先回头看看前两轮的关键内容，然后把当前提问补充完整，变成关于之前讨论的推荐算法优化话题，能详细解释一下具体的实现细节吗？

这样每一次检索请求都变成了独立完整的句子，不需要依赖外部上下文。

实战难点与解决方案

响应延迟

改写意味着额外调用一次大模型，这直接导致响应延迟增加，用户可能就得多等上两三秒钟。

这听起来不多，但在互联网产品的世界里，两秒钟就可能造成用户流失，怎么破解？

有两条路线：

1.轻量化模型

别用GPT4这样的大模型来改写，用一个经过专项微调的小模型，速度更快，成本更低。

2.流水线并行

让改写和初步检索同时进行，不要串联执行，用异步处理把总时间压到最低。

查询漂移

语义偏移的风险模型有时候会过度创意，改着改着就把原意改变了。

比如，用户问：苹果怎么选购？

模型可能给你改成了iphone手机的性能对比，意思完全反了，这叫查询漂移，是Rag系统的大忌。

解决办法是设置相似度检测阈值，改写完成后，系统自动计算改写内容和原始提问的语义相似度，如果低于某个值，比如0.75，就放弃改写版本，直接用原始问题去检索，宁可保守一点，也不能让模型乱改。

成本开销

如果每一个用户请求都去改写，Token消耗就会直线上升。

解决办法是建立一个智能路由机制，设定规则。

比如：

简单直接的提问、打招呼、闲聊这些就直接跳过改写；

复杂冗长、表述模糊的提问，这时候才启动改写；

把有限的计算资源用在最需要的地方。

Prompt Engineering和context engineering有什么区别?为什么Transformer架构在处理超长上下文时会变慢？

Thu, 04 Jun 2026 17:14:35 +0000

Prompt Engineering和context engineering有什么区别?

Prompt是指导大模型怎么思考的机制，解决的是how的问题，怎么推理，怎么组织答案。

Context是为大模型提供信息的机制，解决的是what的问题，给模型什么知识，什么数据。

Prompt的核心技术包括CoT、few shot、角色扮演等，用来激发模型内部已有的知识；

Context的核心是RAG，通过检索将外部知识注入模型。

两者缺一不可，前者决定质量，后者决定准确性。

在实际工程中，Prompt面临脆弱性和幻觉问题，我们用自动优化和Self-Consistency来解决；

Context面临中间迷失和噪声问题，我们用重排策略和自反思来优化。

未来的发展方向是Agent，让系统动态地生成和管理这两者，实现真正的智能协作。

为什么Transformer架构在处理超长上下文时会变慢？它的瓶颈在哪里？我们该如何解决？

在Transformer的自注意力机制中，模型主要做的事情是让每一个Token都要去和整个序列里其他所有的Token进行交互，计算他们之间的相关度。

假设输入序列长度从n变成2n，计算量和显存占用不是简单的翻一倍，而是直接飙升4倍。这就是所谓的二次方爆炸，长度双倍增长，代价是4倍的计算量。

除了计算的瓶颈，还有一个关键的瓶颈是显存瓶颈，也就是常说的显存墙现象。

可以想象这样一个场景，GPU的计算核心就像一个吃饭飞快的人，但是显存的带宽就像是一根很细的吸管，搬运数据的速度远远跟不上计算的需求。

在推理阶段，这个问题更加明显，每次生成一个新的Token，模型都要反复去显存里搬取之前计算过的键值缓存KV cache，结果，计算核心大部分都在等数据这个动作上，而不是在真正算数据，这才是变慢的物理本质。

第三个问题就是外推性差，很多大模型其实是在相对较短的文本上训练的，如果给他塞进一个长文本，虽然物理硬件层面上可能扛得住，单模型内部的位置编码机制并不知道这些超长距离的Token之间应该如何交互，导致的结果就是深层内容开始乱套，困惑度PPL疯狂飙升。

所以，长文本变慢的本质其实是O(n^2)的计算复杂度和硬件IO访问瓶颈的双重碰撞，而我们的解决思路是：

首先，用Flash Attention在算子层面做融合和优化，直接解决IO的瓶颈；

其次，用GQA和MQA在架构层面做参数共享，显著压缩KV cache的体积；

同时，借助PagedAttention，在内存管理上做创新，消灭显存碎片；

最后，通过位置编码的数学手段，比如RoPE Scaling让模型具备外推能力。

GoCloud - 基于 WebSocket 的实时聊天应用

Wed, 03 Jun 2026 17:16:55 +0000

一个使用 Go 语言开发的多房间实时聊天应用，支持用户注册/登录、房间切换、聊天历史记录等功能。

📸 项目演示

登录界面

多人实时聊天

✨ 功能特点

✅ 用户注册/登录 - 支持用户名和密码注册，密码安全存储
✅ 多房间聊天 - 支持切换不同的聊天房间
✅ 实时消息 - 基于 WebSocket 的实时消息推送
✅ 在线用户列表 - 显示当前房间的在线用户
✅ 聊天历史记录 - 使用 SQLite 持久化存储聊天记录
✅ 系统通知 - 用户加入/离开房间的系统提示
✅ 登录状态保持 - 刷新页面后自动保持登录状态
✅ 密码验证 - 用户名和密码长度限制
✅ 精美的 UI 设计 - 渐变色主题，流畅的交互体验

🛠️ 技术栈

后端

Go 语言 - 高性能的服务端编程语言
Gin 框架 - 轻量级的 HTTP Web 框架
Gorilla WebSocket - WebSocket 通信库
SQLite - 轻量级关系型数据库
modernc.org/sqlite - SQLite 驱动（纯 Go 实现，无需 CGO）

前端

HTML5 + CSS3 - 现代网页标准
Vanilla JavaScript - 原生 JS，无需框架
LocalStorage - 浏览器本地状态存储

📁 项目结构

GoCloud/
├── cmd/
│   └── server/
│       └── main.go              # 主程序入口，包含前端页面
├── internal/
│   ├── chat/
│   │   ├── types.go             # 数据结构定义
│   │   ├── hub.go               # 核心逻辑：房间管理、消息广播
│   │   └── client.go            # WebSocket 客户端处理
│   ├── handler/
│   │   └── websocket.go         # HTTP API 处理器
│   └── database/
│       ├── database.go          # 数据库初始化
│       ├── user.go              # 用户数据库操作
│       ├── room.go              # 房间数据库操作
│       └── message.go           # 消息数据库操作
├── go.mod                       # Go 模块文件
├── go.sum                       # 依赖锁定文件
├── chat.db                      # SQLite 数据库文件（运行时生成）
└── README.md                    # 项目说明文档

🚀 快速开始

前置要求

Go 1.16 或更高版本

安装依赖

`1`	`go mod download`

运行项目

`1`	`go run cmd/server/main.go`

服务器将在 http://localhost:8080 启动。

使用说明

打开浏览器访问 http://localhost:8080
点击「注册」创建新账号
输入用户名（3-20字符）和密码（6-20字符）
登录后进入聊天界面
在左侧选择不同的聊天房间
在底部输入框输入消息并发送

🗄️ 数据库设计

users 表

字段	类型	说明
id	TEXT	用户ID（UUID）
username	TEXT	用户名（唯一）
password	TEXT	密码（哈希存储）
created_at	DATETIME	创建时间

rooms 表

字段	类型	说明
id	TEXT	房间ID
name	TEXT	房间名称
description	TEXT	房间描述
created_at	DATETIME	创建时间

messages 表

字段	类型	说明
id	INTEGER	消息ID（自增）
room_id	TEXT	房间ID
user_id	TEXT	用户ID
username	TEXT	用户名
type	TEXT	消息类型（message/system）
content	TEXT	消息内容
time	TEXT	时间戳
created_at	DATETIME	创建时间

📡 WebSocket 消息格式

消息类型

1. 用户加入房间

{
  "type": "join",
  "roomId": "general",
  "fromId": "user-uuid",
  "fromName": "username",
  "content": "加入了房间",
  "time": "2026-06-03T16:00:00Z"
}

2. 用户离开房间

{
  "type": "leave",
  "roomId": "general",
  "fromId": "user-uuid",
  "fromName": "username",
  "content": "离开了房间",
  "time": "2026-06-03T16:00:00Z"
}

3. 普通消息

{
  "type": "message",
  "roomId": "general",
  "fromId": "user-uuid",
  "fromName": "username",
  "content": "Hello, World!",
  "time": "2026-06-03T16:00:00Z"
}

4. 在线用户列表

{
  "type": "users",
  "roomId": "general",
  "users": ["user1", "user2", "user3"]
}

5. 切换房间

{
  "type": "change_room",
  "roomId": "tech"
}

🔌 HTTP API

1. 用户注册

POST /api/register
Content-Type: application/json

{
  "username": "testuser",
  "password": "123456"
}

响应:
{
  "success": true,
  "user": {
    "id": "user-uuid",
    "username": "testuser"
  }
}

2. 用户登录

POST /api/login
Content-Type: application/json

{
  "username": "testuser",
  "password": "123456"
}

响应:
{
  "success": true,
  "user": {
    "id": "user-uuid",
    "username": "testuser"
  }
}

3. 获取房间列表

GET /api/rooms

响应:
{
  "success": true,
  "rooms": [
    {
      "id": "general",
      "name": "大厅",
      "description": "欢迎来到大厅，大家可以在这里畅聊！"
    },
    {
      "id": "tech",
      "name": "技术交流",
      "description": "讨论技术问题、分享经验"
    },
    {
      "id": "game",
      "name": "游戏频道",
      "description": "一起聊游戏，找队友"
    }
  ]
}

4. WebSocket 连接

`1`	`GET /ws?userId={userId}&username={username}&roomId={roomId}`

💡 核心实现

Hub 模式

使用经典的 Hub 模式管理 WebSocket 连接：

Hub：中心管理器，负责管理所有房间和客户端
Room：房间，包含在线客户端和房间信息
Client：客户端连接，处理单个用户的 WebSocket 通信

消息广播流程

客户端发送消息到 Hub 的 Broadcast channel
Hub 根据消息的 RoomID 找到对应房间
Hub 将消息发送给房间内的所有客户端
同时将消息保存到 SQLite 数据库

数据持久化

使用 SQLite 数据库存储用户、房间和消息
用户加入房间时从数据库加载历史消息
新消息实时保存到数据库

📝 开发历程

主要问题解决

在线用户列表不同步 - 修复了用户列表的广播逻辑，确保所有客户端都能收到更新
消息显示不一致 - 调整消息发送顺序，优先发送用户列表，确保消息顺序正确
刷新页面状态丢失 - 使用 LocalStorage 保存登录状态和房间信息
数据不持久化 - 集成 SQLite 数据库，实现用户和消息的永久存储
WebSocket 消息拼接问题 - 修复 WritePump 消息发送逻辑，每条消息单独发送

优化改进

调整消息发送顺序，优先发送用户列表
添加更完善的错误处理和日志记录
实现房间状态的保存和恢复
优化 UI 设计，使用渐变色主题

🔮 未来优化方向

添加头像支持
支持私聊功能
添加消息已读状态
支持图片/文件发送
添加消息搜索功能
实现用户权限管理
添加房间创建/删除功能
支持消息撤回
添加表情支持
实现消息推送通知

注意：这是一个学习项目，用于演示 Go 语言 WebSocket 开发。生产环境使用时请加强安全措施。

完整源码：

源码

如果觉得这个项目对你有帮助，欢迎点赞 👍、收藏 ⭐、关注 👀！

Windows系统Codex 接入阿里云百炼的国产大模型

Tue, 02 Jun 2026 00:21:35 +0000

Codex作为 OpenAI 推出的终端级 AI 编程智能体，凭借其对 Responses API 的原生支持、强大的插件/技能系统和灵活的工具调用能力，迅速成为开发者日常编码的得力助手。

然而在国内使用 Codex 时，相信在通过Microsoft Store安装好Codex之后，很多人一定见过这个图片：

本文将介绍如何将 阿里云百炼 平台的国产大模型接入 Codex，配合开源增强工具 Codex++，实现更快、更稳、更低成本的编码体验。

具体步骤

获取百炼 API Key

登录阿里云百炼控制台
进入「API-KEY 管理」页面
创建并复制你的 API Key

安装和配置 Codex++

Codex++是一个基于 CDP (Chrome DevTools Protocol) 注入的第三方增强启动器，它不修改 Codex 原始文件，通过旁路注入方式为 Codex App 增添了丰富的附加功能。

先进入Codex++的网址下载 Codex++：

如果访问Github有困难，也可以通过以下方式下载：

链接：Codex++安装包

安装完成Codex++之后，会多出这两个东西：

先点击Codex++管理工具，依次进行以下操作，【供应商配置】→【添加供应商】：

之后点击【重启Codex】，Codex中就能显示阿里云百炼提供的国产大模型了。

这样一来，就将阿里云百炼接入了 Codex，不仅解决了网络访问问题，更带来了一个高性能、低成本、合规可控的国产 AI 编程体验。

配合 Codex++ 的强大增强功能，你获得的不仅仅是一个聊天机器人，而是一个真正懂你的编程伙伴。

小贴士

1.如果重启之后，还是没有显示国产的大模型或者一直显示Reconnecting，可以重启一下电脑试试。

2.如果开了上网代理的话，记得关掉，不然还是会出错。

3.后续可以直接使用Codex++启动Codex了。

SLKJ笔试题解析

Sun, 31 May 2026 00:09:30 +0000

括号中的数字应该选择多少（A）：0,4,18,(X),100

A.48

B.58

C.50

D.38

解析：

第n项 =n^2 ×(n−1)

int x='f';printf("%c\n",'a'+(x-'a'+1));输出结果是（B）

A.j

B.g

C.i

D.h

解析：

x - ‘a’ = ‘f’ - ‘a’ = 5（‘f’在 ASCII 表中比’a’大 5）

x - ‘a’ + 1 = 5 + 1 = 6

‘a’ + 6 = 字符’g’（‘a’往后数 6 个就是’g’）

C语言中，对下面一句声明，叙述正确的是（A）

int (*s_calc_func(char op))(int, int);

A.这是一个函数声明，这个函数接收**op**作为参数，返回一个接收两个**int**值作为参数，返回int型值的函数的指针

B.这是一个函数声明，这个函数接受两个int值作为参数，返回一个接收char作为参数返回int型值的函数的声明

C.这是一个函数声明，这个函数接收两个int值作为参数，返回一个接收op作为参数返回int型值得函数的声明

D.这是一个不合法的函数声明

解析：

等价写法：

1
2

typedef int (*func_t)(int, int);  // func_t 是"指向接收两个int、返回int的函数的指针"
func_t s_calc_func(char op);      // s_calc_func 接收char，返回 func_t

所以 s_calc_func 是一个函数，它接收 char op，返回一个函数指针；该指针指向的函数接收两个 int，返回 int。

某存储器数据总线宽度为32bit，存取周期为250ns，则该存储器的理带宽为：（B）

A.8MB/s

B.16MB/s

C.25MB/s

D.32MB/s

解析：

带宽 = 总线宽度（bit）÷ 8 ÷ 存取周期（s）

代入：32 ÷ 8 ÷ (250×10⁻⁹) = 4 ÷ (250×10⁻⁹) = 16×10⁶ B/s = 16 MB/s

如果一个递归函数最终会结束，那么这个函数一定是（B）

A.使用了局部变量

B.有一个分支不调用自身

C.使用了全局变量或者使用了至少一个参数

D.都不对

关于可重入函数,下面说法错误的是：（CD）

A.可重入函数可以由多个线程并发使用,而不必担心数据错误

B.可重入函数不可以调用任何不可重入函数

C.可重入函数时必需使用互斥手段对临界代码加以保护

D.可重入函数可以调用malloc()或者free()函数

解析：

可重入函数不依赖共享状态，多个线程并发调用不会产生数据错误。

一旦调用了不可重入函数，整个调用链就可能访问共享状态，破坏可重入性。

下面的C代码作用是反转一维数组。例如当输入为{1,2,3,4,5}时，输出是(5,4,3,2,1}。

int reverse_array(int* list, int len) {
    int* p1 = list, * p2 = list + len - 1;
    int temp;
    if (len <= 0) return -1;
    while (p1 != p2) {
        temp = *p1;
        *p1 = *p2;
        *p2 = temp;
        p1++;
        p2--;
    }
    return 0;
}

当编译并运行上述程序时，会发生什么情况：（C）
A.编译错误
B.程序运行正确
C.输入数组长度为奇数时运行正确
D.输入数组长度为偶数时运行正确
E.都不对

解析：

偶数长度时，p1 与 p2 的初始距离为 len-1（奇数），每次循环距离减 2，因此距离永远是奇数，不可能等于 0。

循环条件 p1 != p2 永远成立，最终导致越界访问。

奇数长度时，初始距离为偶数，距离最终会减到 0，循环正常终止。

单元测试的定义：通过模块(类/方法/函数)测试，使代码达到设计要求主要目的是针对编码过程中可能存在的各种错误，例如用户输入验证过程中的边界值的错误。（A）

A.True

B.False

假设你有8个球，其中一个略微重一些，但是找出这个球的唯一方法是将两个球放在天平上对比。最少要称多少次才能找出这个较重的球?

解析：

第一次称重：把 8 个球分成 3 个、3 个、2 个三组，将两组 3 个球分别放在天平两端。

若天平平衡：较重的球在剩下的 2 个球中。

若天平不平衡：较重的球在下沉的那 3 个球中。

第二次称重：

若在 2 个球中：直接把这两个球放在天平两端，下沉的就是较重的球。

若在 3 个球中：任取其中 2 个放在天平两端，若平衡则剩下的是较重球；若不平衡则下沉的是较重球。

所以，最优策略保证在至多2次内找出重球。

若第一次即不平衡，第二次从重的那3个中取2个上称即可确定，共 2 次；

若第一次平衡，第二次直接比较剩余2个，也是 2 次。

10 . Please list some command linux command eg. Show all process, show cpu usage,create new folder, change file attribute.

解析：

Show all process: ps aux

show cpu usage: top

create new folder: mkdir <folder_name>

change file attribute: chmod

11 . Shell 脚本中，[ $a == $b ] 和 [ $a -eq $b ] 有什么区别？

解析：

[ $a == $b ] 是字符串比较，按字面内容判断是否相等；

[ $a -eq $b ] 是整数比较，按数值大小判断是否相等，且要求操作数为整数。

12 . Please describe the common technique to avoid a header file being included for multiple times?

解析：

Include guard with #ifndef/#define/#endif (portable, standard method using a unique macro to skip repeated inclusion).

#pragma once (compiler-supported directive to mark the header as “include once”, simpler but slightly less portable).

13 . 数组边界溢出会导致什么?怎样防止数组边界溢出?

解析：

数组边界溢出会导致数据损坏、程序崩溃、安全漏洞等问题；

可通过边界检查、使用安全容器 / 函数、控制循环范围、工具检测等方式防止溢出。

14 . Heap与stack的内存分配和空间大小方面的差别?

解析：

内存分配：栈由系统自动分配释放、效率高、连续无碎片；

堆由程序员手动管理、效率较低、易产生碎片。

空间大小：栈空间固定且小；堆空间大且可动态扩展。

15 . What’s the difference between physical address and virtual address? Who in charge of translate between physical address and virtual address? Give brief description about the benefit of virtual address, and the general translate process from virtual address to physical address.

解析：

Physical address is the actual RAM address; virtual address is a logical address per process.

Translation is handled by the MMU (hardware) with OS page tables.

Virtual address enables isolation, extended memory, protection, and flexible management.

Translation splits the virtual address into VPN/offset, uses the page table to get PFN, then combines with offset to form the physical address (with page fault handling if needed).

16 . 程序的局部变量存在于（）中，动态申请的数据存在于（）中。

解析：

栈（stack）；堆（heap）

17 . What is problem of the following logic and how to modify it tomake it work correctly?

void allocate_mem(char* str) {
	str = (char*)malloc(100);
}
void test() {
	char *str = NULL;
	allocate_mem(str);
	strcpy(str, "Hello, World");
	printf(str);
}

解析：

偶数长度时，p1 与 p2 的初始距离为 len-1（奇数），每次循环距离减 2，因此距离永远是奇数，不可能等于 0。循环条件 p1 != p2 永远成立，最终导致越界访问。奇数长度时，初始距离为偶数，距离最终会减到 0，循环正常终止。

18 . Implement the following macro to clear a 32 bit register’s bit 4, 5 and 6.

1
2
3

#define ClrRegBit456(x) ?
Example:
		ClrRegBit456(REG_A);

To generalize the implementation above, implement the following macro to clear m bits of a 32 bit register’s, starting from bit n. (In the above case, m = 3, n=4).

1
2
3

#define ClrRegBitFields(x,m, n)
Example:
        ClrRegBit456(REG_A, 3, 4);

解析：

第一个宏 ClrRegBit456(x)

要清除寄存器的 bit 4、5、6，核心思路是构造一个掩码：这三位为0，其余位为1，再和原寄存器值做按位与操作。

先构造这三位的位模式：0x7（二进制111）左移 4 位，得到0x7 « 4（对应 bit4-6 为1，其余为0）

对该值取反，得到目标掩码：~(0x7 « 4)（bit4-6 为0，其余为1）

用原寄存器值和掩码按位与，即可清除这三位。

`1`	`#define ClrRegBit456(x) ((x) &= ~(0x7 << 4))`

解析：

第二个通用宏 ClrRegBitFields(x, m, n)

要清除从bit n开始的m位，步骤如下：

生成m个连续的1：(1 « (m)) - 1（比如m=3时，结果为0b111）

将这m个1左移n位，移动到目标位置：((1 « (m)) - 1) « (n)

取反得到掩码（目标位为0，其余为1），再和原寄存器值按位与

`1`	`#define ClrRegBitFields(x, m, n) ((x) &= ~(((1U << (m)) - 1U) << (n)))`

机器人Java后端算法笔试题解析

Fri, 22 May 2026 23:01:24 +0000

如何判断一个字符串变量a为空，包括null、空字符串、一个或多个空格、一个或多个whitespace?

if (a == null || a.isBlank()) {

}

Java新版本为什么要添加Instant?

Java 8 引入 Instant 主要是为了修复旧版日期时间类（如 java.util.Date）的设计缺陷，

原因如下：

不可变性与线程安全：

Instant 是不可变的（Immutable），天然线程安全；

而 Date 是可变的，在多线程环境下容易产生并发问题。

更高精度：

Instant 支持纳秒级（$ 10^{-9} $ 秒）精度；

而 Date 只能精确到毫秒。

语义清晰（机器时间）：

Instant 明确表示 UTC 时间线上的瞬时点（timestamp），语义清晰，适合机器时间处理（日志、分布式时间戳、事件时间）；

而 Date API 设计混乱，日期计算与格式化常依赖 Calendar、TimeZone 等类，易产生时区问题。

如何判断两个double类型的变量是否相等?例如doublea=1.2;doubleb=1.1 +0.1; 比较a和b是否相等。

public static boolean nearlyEqual(double a, double b, double epsilon) {
    return Math.abs(a - b) < epsilon;
}

// 使用
double a = 1.2;
double b = 1.1 + 0.1;
boolean equal = nearlyEqual(a, b, 1e-9);  // true
//epsilon 的取值取决于业务精度要求，常见取 1e-9 到 1e-6。

下面三条语句是否是合法的,如果不是原因是什么?

1
2
3

List<String> a = new ArrayList<String>();//1
List<Object> a = new ArrayList<String>();//2
List<?> a = new ArrayList<String>();//3

1.合法：左右类型完全匹配。

2.不合法：Java 泛型具有不变性，List 与 List 不存在父子关系。

若允许赋值，可通过 List 写入非 String 类型，破坏类型安全。

3.合法：? 是无界通配符，代表未知类型，ArrayList 是 List 的子类型。

但由于类型未知，只能读取不能写入（null 除外），因此编译器允许。

一个字符串String,如何转换为字节数组。反过来呢?

//1.String → byte[]
String str = "CodeEdge_Xu";

// 显式指定编码（避免平台差异）
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);

//2.byte[] → String
byte[] bytes = ...;

// 与编码时保持一致
String str = new String(bytes, StandardCharsets.UTF_8);

Java中,如果对象有循环引用,能否被GC。比如Path类里面有个字段reversedPath反向字段。两个Path对象因为这个字段相互引用。如果不能被GC,怎么解决。

能。

Java 主流 GC（G1、ZGC、CMS）用的是可达性分析，不是引用计数。

只要这两个 Path 对象整体从 GC Roots 不可达，循环引用不影响回收。

真正导致不能 GC 的是外部强引用，比如：静态字段持有，ThreadLocal 未 remove，未注销的监听器。

解决办法：

一般不需要特殊处理。

只要外部强引用断开，对象整体从 GC Roots 不可达即可回收。

真正的问题是被静态变量、线程、缓存、监听器等长期持有。

写正则表达式,从类似"10,12;A1@12|12:23|p=1|f=2"字符串中抽出变量:"{x},{y};{name}@{index}|{timeStart}|{timeEnd}p={id}"。其中,除了name外其余均是数字,name中有数字、字母、中划线、下划线。

1
2
3

Pattern pattern = Pattern.compile(
    "^(\\d+),(\\d+);([A-Za-z0-9_-]+)@(\\d+)\\|(\\d+:\\d+)(?:\\|(\\d+:\\d+))?\\|p=(\\d+)\\|f=(\\d+)$"
);

什么是大端(Big-endian),什么小端(Little-endian)?网络传输一般是大端还是小端?

大端：高位字节放前面，低位放后面。

小端：低位字节放前面，高位放后面。

网络传输一般是大端。

TCP/IP 协议规定数据包中的多字节整数必须按大端传输。

一个整数变量,如果只有一个线程修改它,但有多个线程读取它,有线程安全问题吗?

有线程安全问题，主要是可见性问题。

写线程修改后的值，其他线程不一定能立刻看到，可能一直读取旧值，因此通常需要使用 volatile 或同步机制保证可见性。

对于 long/double，早期 JVM 还存在非原子读写问题（现代 JVM 通常已解决）。

10 . Java的线程能被强制杀死吗？

不能安全地强制杀死。

Thread.stop() 可以强制终止，但已废弃（deprecated），因为会立即释放锁，导致对象状态损坏、资源泄漏。

11 . 如果想要一个线程安全的List,可以用List的哪些实现，或通过什么手段实现。

方式	特点
`Vector`	古老类，所有方法 `synchronized`，已不推荐
`Collections.synchronizedList(new ArrayList<>())`	包装器，全表锁，读也串行
`CopyOnWriteArrayList`	读多写少首选，写时复制新数组，读无锁
手动加锁	`synchronized` 或 `ReentrantReadWriteLock`，灵活但代码重

12 . 有一个List，其中的元素是监听器对象。在多线程环境下，需要对这个List进行添加、删除和遍历三个操作，如何线程安全地进行?除了对添加、删除和遍历加锁或同步的方式——因为如果对遍历加同步，可能会阻塞很长时间，因为遍历一遍可能要很久，会阻塞添加、删除等操作，也会阻塞其他线程的遍历操作。

用 CopyOnWriteArrayList。

它内部写操作（add/remove）时复制一份新数组，修改完后替换引用；

读/遍历直接读当前数组快照，完全不加锁。

所以遍历不会阻塞添加、删除，也不会阻塞其他线程遍历。

迭代器基于快照，不会抛 ConcurrentModificationException。

13 . Java核心库中创建线程池的方法是?通过核心库的线程池实现并发，比new Thread有哪些好处?

工具类工厂方法：

使用 java.util.concurrent.Executors 提供的静态方法（如 newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 等）。

直接构造对象：

通过 new ThreadPoolExecutor(...) 手动创建。

推荐直接使用 ThreadPoolExecutor 手动指定核心线程数、最大线程数、队列长度和拒绝策略，而不是直接使用 Executors 工厂方法，因为部分默认实现可能导致 OOM。

比 new Thread 的好处：

降低资源消耗：通过复用已创建的线程，减少频繁创建和销毁线程的 CPU 和内存开销。

提高响应速度：任务到达时，无需等待线程创建即可立即执行。

提高线程可管理性：能统一分配、调优和监控线程，防止无限制创建线程导致系统资源耗尽（如 OOM）。

14 . MySQL中，varchar(100)的列，能存多少个英文字母?多少个汉字?使用utf8mb4字符集。

100 个英文字母，100 个汉字。

MySQL 的 varchar(100) 中 100 是字符数，不是字节数。

utf8mb4 下英文字母通常 1 字节，中文常见汉字一般 3 字节，部分扩展字符可能占 4 字节，但 varchar(100) 限制的是字符数，因此最多依然存 100 个字符。

15 . MySQL中，datetime和timestamp有何不同，精度分别是毫秒还是秒，是否有时区?

datetime：

范围大（1000~9999 年）

不涉及时区

默认精度到秒

支持小数秒 datetime(fsp)，最多微秒（6位）

timestamp：

范围小（1970~2038 年）

有时区语义（存 UTC，读时按 session timezone 转换）

默认精度到秒

支持 timestamp(fsp)，最多微秒（6位）

16 . 写SQL：

订单表wms_order，单行表wms_order_line，一对多关系。

wms_order表有列id(单号)、create_on(创建时间)等字段，

wms_order_line有id、order_id(所属订单)、line_no(行号)、product_id (商品 ID)。

如何查询2021年12月内发生的含有A、B、C三个商品的订单。

SELECT o.id AS order_id, o.create_on
FROM wms_order o
INNER JOIN wms_order_line ol ON o.id = ol.order_id
WHERE 
  -- 筛选2021年12月的订单
  o.create_on >= '2021-12-01' 
  AND o.create_on < '2022-01-01'
  -- 筛选包含A、B、C任意一个商品的行
  AND ol.product_id IN ('A', 'B', 'C')
GROUP BY o.id, o.create_on
-- 确保订单同时包含这3个不同的商品
HAVING COUNT(DISTINCT ol.product_id) = 3;

17 . 如果有一张订单表,查询量最大的查询条件有两种:

根据某个创建人和创建时间(范围)查询。
根据某个类型和创建时间(范围)查询。

建议如何建立索引?

建立两个联合索引，并遵循“等值查询字段在前，范围查询字段在后”的原则：

索引一：(创建人, 创建时间)

索引二：(类型, 创建时间)

理由：

最左匹配原则：将等值条件（创建人/类型）放在首位，范围条件（时间）放在末位，可以使索引效率最高。

覆盖查询：联合索引可提高过滤效率；若查询字段被索引完全覆盖，还可减少回表。

18 . @Resource、@Autowired、@Inject的区别?

特性	@Autowired	@Resource	@Inject
来源	Spring 框架专用	JSR-250	JSR-330
默认匹配方式	按类型 (byType)	先 byName，再 byType	按类型 (byType)
找不到对应 Bean	报错（可设置 `required=false`）	报错	报错
指定特定名称	配合 `@Qualifier`	使用 `name` 属性	配合 `@Named`
注入位置	构造器、字段、Setter、方法	字段、Setter	构造器、字段、Setter

19 . @Transactional可以用于private方法吗，为什么?

private 方法不能生效，因为 Spring AOP 无法代理 private 方法；

其不能被子类覆盖，因此代理对象无法拦截。

同类内部 this.xxx() 调用也会绕过代理，因此事务同样不生效。

20 . 支付宝等接口，要求请求中对字段做签名，目的是什么?常见的签名算法有哪些?

目的：

保证请求数据不被篡改，并证明请求方身份（只有持有密钥的一方才能生成有效签名）。

常见签名算法：

算法	说明
RSA2 / `SHA256withRSA`	主流，支付宝等常用，私钥签名、公钥验签
RSA / `SHA1withRSA`	旧版兼容，安全性弱于 RSA2
HMAC-SHA256	双方共享密钥，常用于微信支付等
MD5	早期接口（如旧版支付宝），已不推荐，不安全
SM2	国密算法，政务/金融国产化场景

21 . 一种常见的攻击手段是huge body，比如请求报文是JSON，但构造一个很大的JSON字符串，几百M甚至几个G，解析JSON会把CPU干爆，甚至把内存用光。在Java体系下(Java Servlet、使用Spriing或不使用)，在哪一层怎么解决这个问题。

huge body 应采用分层治理，越靠前拦截越好：

网关 / Nginx 层（优先级最高）
限制请求体大小，例如：
client_max_body_size 10m;
超限直接返回 413，避免请求进入 Java 应用。

容器层（Tomcat/Jetty/Undertow）
限制 HTTP 请求体大小，例如 Tomcat：
maxPostSize=“10485760”
防止超大 body 被 Servlet 容器接收。

应用层（Spring / Servlet）
避免 @RequestBody 直接全量反序列化大 JSON。
可先检查 Content-Length，
或使用 Jackson JsonParser 流式解析（Streaming API），边读边处理，避免一次性占用大量内存。

安全治理
结合限流、超时、熔断，防止 DoS 攻击持续消耗 CPU 与内存。

22 . 把用户的密码明文存储到数据库里是不好的，那么如何存储比较好?

采用 加盐哈希 (Salted Hashing) 存储，具体做法如下：

使用强散列算法：不要使用 MD5 或 SHA-1（易破解），推荐使用 Argon2、BCrypt 或 SCrypt。

添加随机盐值 (Salt)：为每个用户生成一个唯一的、随机的“盐”，与密码拼接后再哈希。防止彩虹表攻击。

增加工作因子 (Work Factor)：通过调整迭代次数增加计算耗时，抵御暴力破解。

禁止可逆加密：密码应单向加密，不可被还原。

某些高安全场景还会增加 pepper（系统级密钥），保存在服务端配置或密钥系统中，而不是数据库。

分布式事务其实很简单：下单场景带你吃透核心原理

Sun, 03 May 2026 16:02:57 +0000

这个原理其实并不复杂，分布式事务，本质就是保证分布式架构下，跨多个服务、多个独立数据源的一组操作，具备和本地事务一致的核心诉求：原子性（要么全成功，要么全回滚）。

举个例子

用户下单，必然要经过【账户中心】扣减用户余额，还要经过【商品中心】扣减商品库存，这就是典型的分布式事务场景。
如果只扣了用户的钱，商品库存没扣，会出现用户付款却拿不到商品的问题；
如果钱没扣成功，却把商品库存扣了，就等于用户白嫖了商品，这两种情况都是业务绝对不能接受的。

为什么分布式事务不好处理？

核心原因是，跨服务的网络调用（HTTP/RPC）让多个服务的本地事务完全隔离，无法共享事务上下文：

账户中心本地事务的执行结果，商品中心无法实时感知；

商品中心的执行结果，账户中心也无法直接控制，无法像本地事务一样做到统一的提交和回滚。

而分布式系统的CAP定理，也决定了我们无法同时满足强一致性、高可用性和分区容错性，必须根据业务场景做取舍。

行业内主流的分布式事务实现方案，核心分为两大类：

一类是强一致性方案，代表是基于XA协议的2PC（两阶段提交），3PC是2PC的理论优化方案，几乎无生产落地；

另一类是最终一致性方案，也是互联网高并发场景的主流选择，代表有TCC、SAGA，以及最常用的基于RocketMQ事务消息的可靠消息方案。

什么是强一致性事务？

我们常说的分布式事务强一致性，核心是原子提交级的强一致：

分布式事务的提交对调用方是原子性的，要么所有分支事务全成功提交，要么全回滚，对外不存在部分成功的中间状态，调用方在事务完成前，不会读到部分修改的数据。

放到我们的下单场景里，就是账户中心扣钱和商品中心扣库存，两个操作对用户来说必须同时成功、同时失败，不会出现一个成功一个失败的情况。
但强一致性方案有天然的短板：

2PC的两阶段流程中，会在准备阶段锁定账户余额、商品库存等数据库资源，直到事务提交/回滚才释放，整个过程同步阻塞用户请求，资源锁定时间远长于本地事务，高并发下极易出现锁冲突、数据库连接池打满，吞吐量会受到严重限制，因此只适用于低并发、对数据一致性要求极高的场景。

最终一致性（非强一致性）是什么？

最终一致性的核心，是放宽了“瞬时强一致”的要求，允许系统存在短暂的中间状态，但保证经过一段时间后，所有节点的数据最终能达到一致状态，以此换取极高的可用性和并发能力。

基于RocketMQ事务消息的可靠消息方案，就是高并发场景下最经典的最终一致性方案：

账户中心先执行本地扣钱事务，事务完全提交成功后，再确保消息能被商品中心消费；

消息投递完成后，账户中心就可以直接结束当前请求，处理新的用户业务，完全不需要等待商品中心的任何执行结果；

商品中心只会监听目标业务Topic的消息，收到后再执行扣库存的操作，两个服务互不阻塞、可以并行处理请求，下单主流程的吞吐量完全由账户中心的处理能力决定，不会被商品中心阻塞，整体并发承载能力远高于强一致性同步方案。

RocketMQ事务消息的核心原理

整个流程核心分为两步，从根源上避免了“钱没扣、库存先扣”的问题：

半消息预投递

在执行账户扣钱的本地事务之前，先给RocketMQ发送一条半消息。

这条消息会被存储到RocketMQ内置的系统Topic RMQ_SYS_TRANS_HALF_TOPIC 中，业务侧的商品中心不会监听这个系统Topic，因此这条消息完全不可见、绝对不会被消费。

事务提交与消息投递

半消息投递成功后，执行账户扣钱的本地事务，以及事务内的其他关联业务操作。

如果本地事务执行成功，就给RocketMQ发送事务提交指令，RocketMQ会把半消息从系统Topic转储到目标业务Topic中，此时商品中心就能正常消费这条消息，执行扣库存操作；

如果本地事务执行失败，就发送回滚指令，RocketMQ会直接丢弃这条半消息，绝不会被消费。

除此之外，RocketMQ还有一套兜底的事务回查机制：

如果账户中心因为宕机、网络中断等原因，没有给MQ发送提交/回滚指令，MQ会定时（默认1分钟）回调账户中心的回查接口，查询对应本地事务的执行状态，根据回查结果决定提交还是回滚半消息，从机制上避免消息长期挂起、数据不一致的问题。

Spring Boot 核心就这 3 件事

Sun, 03 May 2026 10:53:23 +0000

Spring Boot 的本质

很多人把Spring Boot想得太过复杂，其实，Spring Boot 的核心底层就是 Spring IOC 容器，你完全可以把这个 IOC 容器，理解成一个 key 为 String 类型、value 为 Object 类型的 Map。

这个Map到底存了什么？

Spring Boot在启动的时候，会自动扫描指定的类，把这些类的实例（也就是我们常说的Bean）全部放进这个Map里。

其中，Map的key就是类名，value就是这个类的单例对象（Spring默认是单例模式）。

那Spring Boot怎么知道，哪些类需要被扫描放进这个Map里？

答案就是注解。

只要类上标注了对应的注解，Spring就会把这个类扫描进容器Map里。

最核心的就是@Component注解，而我们日常用的@Service、@Controller、@Repository（DAO层注解），本质上都是派生自@Component。

所以只要标注了这些注解的类，项目启动时都会被自动扫描进这个大Map里，成为Spring容器管理的Bean。

Spring MVC四层架构

Spring MVC的核心思想就两个字：分层。

说白了，就是把代码按功能拆分成4个模块，对应项目里的4个包，各司其职，互不干扰，既方便维护，也便于团队协作。

1. Entity层（实体层）

它的唯一作用，就是和数据库的表做映射。

数据库里有一张表，Entity层就对应一个类；

数据库里有100张表，这里就有100个对应的类。

类里的属性，就对应数据库表里的字段，就这么简单。

2. DAO层（数据访问层）

无论是手写 SQL 还是框架自动生成 SQL，所有访问数据库的入口定义，都集中在这一层。

3. Service层（业务层）

这是整个项目的核心，所有的业务逻辑都写在这里。

什么是业务逻辑？

举个最经典的银行转账例子：

你要给张三转1000块钱，这个业务的完整流程是：

先校验你的账户余额是否充足➡️余额充足的话给张三的账户加1000元➡️再从你的账户里扣除1000元。

这一整套连贯的业务流程，就写在Service层。

而这个流程里的每一步数据库操作，都是调用DAO层的方法来实现的，Service层本身不写SQL，只负责编排业务逻辑、处理业务规则。

4. Controller层（控制层）

这一层的作用非常纯粹，就是给前端提供可调用的接口，除此之外没有别的核心功能。

正常的Controller层，核心代码往往只有3行：

第一行定义接口地址和请求方式，

第二行调用对应的Service层方法，

第三行把执行结果返回给前端，仅此而已。

依赖注入和控制反转

在讲依赖注入之前，先搞懂控制反转（IOC），它和依赖注入是一体两面的关系，核心逻辑还是离不开那个容器Map。

什么叫“控制反转”？

我们先看“正转”是什么：

如果没有Spring，你想在Controller里用Service，就得自己手动写代码 UserService userService = new UserService();

去创建对象，对象的创建、生命周期、销毁，全都是你自己在代码里控制，这就是“控制正转”。

而有了Spring之后，这件事完全反过来了：

对象的创建、实例化、管理，全都交给Spring容器（也就是那个大Map）来做，你的代码里不用再手动new对象了，只需要等着Spring把你需要的对象给你送过来。

原本由你自己控制的对象管理权，交给了Spring容器，控制权发生了反转，这就是控制反转（IOC）。

而依赖注入（DI），就是Spring实现控制反转最核心的方式。

先看一个最常见的开发场景：

Controller层要调用Service层的方法，那Controller怎么找到Service类的实例？

别忘了，Spring Boot启动的时候，已经把所有标注了注解的类，都放进了那个大Map里。

也就是说，Service的实例早就已经在容器Map里存好了。

那Controller要想用这个Service实例，根本不用自己手动去new对象，只需要通过注解，告诉Spring：

我要这个Service的实例，你给我拿过来。

这个过程，就是依赖注入。

而实现依赖注入，最常用的就是两个注解：

@Autowired 和 @Resource，二选一即可。

你只需要在Controller里，给对应的Service属性加上这个注解，Spring 就会自动从容器 Map 里，按类型或类名找到对应的 Bean 实例，注入到Controller中，你就可以直接调用Service的方法了。

解决 Windows 虚拟内存迁移失败的全过程实录

Wed, 29 Apr 2026 23:49:57 +0000

最近发现C 盘空间告急，看了一下，有一个十几GB的虚拟内存（pagefile.sys）文件，于是，我打算把它搬到D盘去，给C盘腾出点空间来。

但是呢，我在【系统属性】里设置了N次，每次重启后都是弹出那句令人崩溃的：“由于启动计算机时出现了页面文件配置问题，Windows 在你的计算机上创建了一个临时页面文件…”

本文，主要是为了复盘一下这次的排坑经历，从底层彻底解决这个顽疾。

为什么常规迁移会失败？

通常我们通过【高级系统设置】➡️【性能】➡️【虚拟内存】来修改，但系统依然反复跳回 C 盘。其中的原因往往不在于你没点那个【设置】按钮：

而在于以下两点底层逻辑：

注册表强制开启了“仅在系统盘创建分页文件”的开关。
Windows 启动早期需要一个微小的空间记录崩溃日志，如果 C 盘完全消失，系统会感到“不安全”而强制回滚。

解决方案

如果你发现常规设置无效，请执行以下步骤：

1.按 Win + R 输入 regedit，定位到：

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management

在右侧找到并修改以下三项：

TempPageFile：数值改为 0（防止系统自作主张创建临时文件）。
PagefileOnOsVolume：数值改为 0（解锁“必须在系统盘”的限制）。
PagingFiles：检查数值，确保路径指向你的目标盘，例如 D:\pagefile.sys 16384 16384。

2.不要让 C 盘完全没有分页文件。

给C 盘手动设为自定义大小，初始 800MB，最大 800MB。

给D 盘手动设为你的目标大小，比如 16384MB。

这一步主要是给 C 盘留 800MB 作为“诱饵”，满足系统记录内核日志的刚需，系统就不会因为“无处落脚”而把整个 16GB 的大文件重新塞回 C 盘。

之后，我再重启电脑就没再出现那个烦人的页面了。

小贴士

有时候，如果你反复通过UI 界面的设置都解决不了的问题，可能就要考虑一下注册表中的设置了。

面试官：你有用过Java的流式吗？比如说一个列表.stream这种，然后以流式去处理数据。

Sat, 18 Apr 2026 15:03:48 +0000

面试官问：

你有用过Java的流式吗？比如说一个列表.stream这种，然后以流式去处理数据。

Stream是个啥？

说白了，Stream就是Java8给我们提供的、专门处理集合数据的流水线工具。
它不是集合，不存数据，也不改你原来的集合，就是给你搭了一条加工数据的流水线：

你把集合丢进去，经过过滤、转换、排序这些工序，最后输出你想要的结果。

两个特性

惰性求值（延迟执行）

你写的filter、map这些中间操作，写完不会立刻执行，只是记下来你要做什么。

只有你写了最后一步的collect、count这种终端操作，整个流水线才会一次性跑完。
好处就是性能好，不用多次遍历集合，还能做优化。

一次性消费

一个Stream流只能用一次，跑完终端操作就关了，想再用就得重新从集合创建新的流，不然会直接报错。

一个标准的Stream流程

创建流

从集合、数组里拿到Stream对象，最常用的就是list.stream()；

中间操作

加工数据，比如过滤、转换、排序，返回新的Stream，可以一直链式写下去；

终端操作

触发执行，拿到最终结果，比如收集成List、统计数量，跑完这步流就关了。

举个例子

就拿电商订单来说，需求是：

过滤已支付、金额大于100的订单，提取用户id去重，按金额倒序取前10，统计每个用户的总消费金额。

// 模拟订单列表
List<Order> orderList = initOrderList();

// 1. 过滤有效订单
List<Order> validOrderList = orderList.stream()
        .filter(order -> order.getStatus() == 1) // 已支付
        .filter(order -> order.getAmount().compareTo(new BigDecimal("100")) > 0) // 金额>100
        .collect(Collectors.toList());

// 2. 提取用户id去重
Set<Long> userIdSet = validOrderList.stream()
        .map(Order::getUserId)
        .collect(Collectors.toSet());

// 3. 按金额倒序取前10
List<Order> top10OrderList = validOrderList.stream()
        .sorted(Comparator.comparing(Order::getAmount).reversed())
        .limit(10)
        .collect(Collectors.toList());

// 4. 按用户分组统计总消费
Map<Long, BigDecimal> userTotalAmountMap = validOrderList.stream()
        .collect(Collectors.groupingBy(
                Order::getUserId,
                Collectors.reducing(BigDecimal.ZERO, Order::getAmount, BigDecimal::add)
        ));

面试官：SpringBoot里面会有一些注解，比如@Controller，这个是作什么用的？@Service呢？

Thu, 16 Apr 2026 18:02:39 +0000

面试官：

“我看你简历上写了SpringBoot，那SpringBoot里面会有一些注解，比如@Controller，这个是作什么用的？@Service呢？”

这个问题，如果你只是回答“一个是控制层，一个是业务层”，那是远远不够的。

首先，不管是 @Controller、@Service 还是 @Repository，它们的底层其实都是 @Component。

你可以把它们理解为给类打上的、带不同语义的 “标签”。

它们本质上都是@Component的派生注解，Spring 启动时会执行组件扫描，只要类上带着@Component及其派生注解，就会自动把这个类实例化、管理完整的生命周期，塞进 Spring 的 IoC 容器里，供其他类通过@Autowired/@Resource注入使用，这就是 Spring 核心的 IoC（控制反转）能力。

@Controller

@Controller 作用在控制层。

它的主要任务是负责处理用户发来的 HTTP 请求（如 GET、POST），解析参数，并决定跳转到哪个页面或者返回什么数据。

通常会配合 @RequestMapping 来指定 URL 路由。

@Controller 和 @RestController

@Controller默认返回一个“视图名称”（HTML/JSP 页面）。

如果你想直接回传 JSON 数据，得在方法上加个 @ResponseBody。

而@RestController是 @Controller + @ResponseBody 的组合拳，直接返回 JSON 对象。

@Service

@Service 作用在业务逻辑层。

这里是程序最核心的地方。

所有的计算逻辑、业务判断、多表关联操作都在这里完成。

它位于 Controller 和 Repository 之间，起到了承上启下的作用。

它不关心请求是怎么来的，只关心业务怎么跑。

为什么建议把事务（`@Transactional`）加在 Service 层而不是 Controller 层？

因为 Service 代表一个完整的业务单元。

比如“转账”，包含扣钱和加钱两个动作，这两个动作必须在一个事务里，要么都成功，要么都失败。

除此之外，@Service的语义化标签，还能让 Spring 的 AOP 切面实现精准切入。

比如我们要给所有业务逻辑加操作日志、权限校验、性能监控，只需要针对@Service注解的类做切面增强即可，完全不用侵入业务代码，这也是分层架构的核心优势。

@Repository 和 @Component

@Repository是持久层标签。

专门用来操作数据库的（DAO 层）。

它有个额外的小功能，能把数据库抛出的原生异常转换成 Spring 的 DataAccessException。

@Component是通用标签。

如果你这个类既不负责接请求，也不写业务逻辑，也不直接操作数据库，它是一个辅助性的、通用的、给三层提供支持的组件，那就用通用的 @Component来标注。

举个用户注册的例子

// 1. Controller层：负责接活
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/register")
    public String register(@RequestBody User user) {
        // 校验一下基本参数，然后丢给Service
        return userService.registerUser(user);
    }
}

// 2. Service层：负责干活（核心逻辑）
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    // 注入密码加密器
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Transactional // 保证业务原子性
    public String registerUser(User user) {
        // 1. 判断用户名是否存在
        if(userRepository.existsByName(user.getName())) {
            return "用户已存在";
        }
        
        // 2. 密码加密：绝对不能存明文！
        // BCrypt会自动生成随机盐值，每次加密结果都不一样，但验证时能匹配
        String encryptedPassword = passwordEncoder.encode(user.getPassword());
        user.setPassword(encryptedPassword);
        
        // 3. 保存到数据库
        userRepository.save(user);
        return "注册成功";
    }
}


// 3. Repository层：负责和数据库打交道
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Spring Data JPA会自动实现这个方法，根据用户名判断是否存在
    boolean existsByName(String name);
}

梳理一下

注解	推荐层级	主要职责	备注
@Controller	Web层（控制层）	接收HTTP请求，分发路由，返回视图	配合 `@ResponseBody` 返回数据
@Service	Service层（业务层）	编写核心业务逻辑，处理事务	系统的“大脑”
@Repository	DAO层（持久层）	数据库增删改查	自动异常转换
@Component	任意层	通用的组件声明	其他三者的“father”

面试官：String是基础类型吗？Object有哪些通用方法？

Thu, 16 Apr 2026 17:15:57 +0000

String 到底是不是基础类型？

先给结论：String 绝对不是基础类型，它是引用类型。

Java里的基础数据类型只有8个：

数值型：byte、short、int、long、float、double
字符型：char
布尔型：boolean

除了这8个，剩下的全是引用类型。

它继承于哪一个对象？

在Java的世界里，“万物皆对象”。
String 和所有的 Java 类一样，如果没有显式继承其他类，默认直接继承自 java.lang.Object。

Object 里面有哪些通用的方法？

Object 类一共有 11 个方法，除去几个私有的，平时最常打交道的有这么几个：

1. equals(Object obj)

指示其他某个对象是否与此对象“相等”。

在 Object 里，默认是用 == 比较，也就是比较两个对象的内存地址。

除非你重写它（比如 String 重写了它，改为比较内容），否则两个 new 出来的对象永远不相等。

2. hashCode()

返回对象的哈希码值（一个 int 整数）。

如果你重写了 equals，就必须重写 hashCode。

3. toString()

返回对象的字符串表示。

4. getClass()

返回此 Object 的运行时类。

它是反射的参加入场券。

通过这个方法，你可以拿到类的结构信息。

5. clone()

创建并返回此对象的一个副本。

需要注意的是，它是浅拷贝。

如果你的类没有实现 Cloneable 接口就调这个方法，会直接抛出 CloneNotSupportedException。

6. finalize()

垃圾回收器准备释放内存前调用的钩子方法。

小贴士：

千万别用它！ 在 JDK 9 之后它已经被标记为过时（Deprecated）了。它执行时机不可控，还会严重影响 GC 性能。

7. wait / notify / notifyAll

这三个是给多线程通信用的。

wait()：让当前线程释放锁并进入等待状态。
notify()：随机唤醒一个在该对象监视器上等待的线程。
notifyAll()：唤醒所有等待的线程。

这三个方法必须在 synchronized 代码块里调用。

总结一下

为了强化记忆，我给整理了一张表格：

方法	作用	备注
equals	比较对象是否相等	默认比地址，业务通常比内容
hashCode	获取哈希码	和 equals 是“连体的”，必须同时重写
toString	对象的字符串描述	方便调试和日志记录
getClass	获取类信息	反射的基石
clone	拷贝对象	注意深浅拷贝的区别
wait/notify	线程间通信	必须配合 synchronized 使用

量化Python笔试题

Tue, 14 Apr 2026 23:45:00 +0000

在Python中，下列哪个不是合法的变量名？（B）
A. my_var
B. 1_var
C. _var
D. var_1

解析：
Python 变量命名规则：变量名必须以字母或下划线开头，不能以数字开头（如 1_var）。

下列哪个不是Python的关键字？（C）
A. if
B. else
C. elseif
D. while

解析：
Python 使用 elif 作为 “else if” 的缩写，elseif 是其他语言（如 PHP）的关键字，在 Python 中使用会报错。

下列哪个函数可以用来计算列表中元素的个数？（D）
A. count()
B. length()
C. size()
D. len()
在Python中，如何打印输出 “Hello, World!"？（B）
A. console.log(“Hello, World!”)
B. print(“Hello, World!”)
C. echo “Hello, World!”
D. System.out.println(“Hello, World!”)
下列哪个选项可以用来删除字典中的一个键值对？（C）
A. remove()
B. delete()
C. pop()
D. discard()
下列哪个选项可以将一个字符串转换为小写？（B）
A. tolower()
B. lower()
C. lowercase()
D. casefold()

小贴士：

casefold() 也可用于字符串转小写（且对 Unicode 字符更友好），

只是lower() 是最常用方式，casefold() 适用于更严格的场景。

下列哪个选项是 Python 中正确的字符串拼接方式？（C）
A. str1 .concat(str2)
B. str1.append(str2)
C. str1 + str2
D. str1.add(str2)
在 Python 中，以下哪个选项用于移除列表中指定位置的元素？（B）
A. list.remove(index)
B. list.pop(index)
C. list.delete(index)
D. list[index] = None
在 Python 中，以下哪个选项用于创建一个字典并初始化其键值对？（A）
A. {key1: value1, key2: value2}
B. dict(key1=value1, key2=value2)
C. new dict(key1=value1, key2=value2)
D. dict([key1, value1], [key2, value2])

解析：

选项A和B都是创建字典的正确方式，两种方式均有效，只是字面量写法A更常用。

10 . 下列哪个选项可以用来循环遍历一个列表？（A）
A. for i in list:
B. foreach i in list:
C. iterate list:
D. for i from list:

11 . 在 Python 中，下列哪个选项用于创建一个生成器函数？（C）
A. def generator_function():
B. generator_function = lambda:
C. def generator_function(): yield
D. def generator_function(): return

解析：

只要函数体中包含 yield 关键字，该函数就变成一个生成器（Generator）。

12 . 在 Python 中，下列哪个选项用于将一个函数作为参数传递，并返回一个添加了额外功能的新函数？（A）
A. 装饰器（Decorator）
B. 生成器（Generator）
C. 闭包（Closure）
D. 装饰器工厂（Decorator Factory）

13 . 下列哪个选项可以用来在Python中打开一个文件以供读取？（B）
A. open_file(“file.txt”, “r”)
B. open(“file.txt”, “r”)
C. read_file(“file.txt”)
D. read(“file.txt”)

14 . 下列哪个选项可以用来在Python中写入文本到文件？（C）
A. write_file(“file.txt”, “Hello!”)
B. write(“file.txt”, “Hello!”)
C. open(“file.txt”, “w”).write(“Hello!”)
D. open_file(“file.txt”, “w”).write(“Hello!”)

15 . 在 Python 中，下列代码的输出是什么？（B）

x = 10
def func():
    global x
    x += 5
func()
print(x)

A. 10
B. 15
C. 函数调用失败
D. 错误：全局变量未定义

解析：
使用 global 关键字可以在函数内部修改全局作用域中的变量。

执行 func() 后，全局变量 x 由 10 变为 15。

16 . 下列哪个选项可以用来从列表中移除指定位置的元素？（C）
A. remove_at()
B. delete()
C. pop()
D. discard()

17 . 下列哪个选项可以用来创建一个空的集合？（B）
A. new_set = {}
B. new_set = set()
C. new_set = set([])
D. new_set = set({})

解析：
{} 在 Python 中默认用于创建空字典。

要创建空集合，必须使用 set()。

18 . 下列哪个选项可以用来判断一个字符串是否以特定子串开头？（B）
A. starts_with()
B. startswith()
C. begins_with()
D. start()

19 . 下列哪个选项可以用来将一个列表中的元素连接成一个字符串？（A）
A. join()
B. merge()
C. concat()
D. combine()

20 . 下列哪个选项可以用来在Python中引发一个自定义异常？（A）
A. raise Exception(“Custom Exception”)
B. throw “Custom Exception”
C. exception(“Custom Exception”)
D. custom_exception(“Custom Exception”)

解析：

Python 使用 raise 关键字抛出异常，throw 是 Java/C++/JS 的用法。

21 . 在 Python 中，下列哪个选项用于打开一个文件并在读取后自动处理资源释放？（A）
A. with open(‘filename.txt’, ‘r’) as file:
B. file.open(‘filename.txt’, ‘r’)
C. open(‘filename.txt’, ‘r’)
D. open(‘filename.txt’, ‘r’).close()

解析：

with 语句是上下文管理器，无论是否发生异常，都会在退出代码块时自动关闭文件。

22 . 在 Python 中，下列代码的输出是什么？（A）

a = [1, 2, 3]
b = [4, 5, 6]
result = list(map(lambda x, y: x * y, a, b))
print(result)

A. [4, 10, 18]
B. [1, 4, 9, 4, 5, 6]
C. [1, 2, 3, 4, 5, 6]
D. [1, 10, 36]

解析：
lambda x, y: x * y是一个匿名函数（没有名字的小函数），作用是：接收两个数 x 和 y，返回它们的乘积。

map 是一个 “映射工具”，主要是从 a 里按顺序取一个数，从 b 里按顺序取一个数，然后把这两个数扔给lambda定义的匿名函数做乘法。

23 . 下列哪个选项可以用来在Python中将一个函数作为另一个函数的参数传递？（D）
A. pass_function()
B. call_function()
C. apply_function()
D. higher_order_function()

解析：

接受函数作为参数或返回函数的函数被称为“高阶函数”（Higher-order function）。

24 . 下列哪个选项可以用来在Python中处理异常的最通用方式？（A）
A. try/except block
B. catch/throw block
C. handle/raise block
D. exception/finally block

解析：

Python 的异常处理结构是 try…except…finally。

25 . 下列哪个选项可以用来在Python中创建一个生成器？（D）
A. create_generator()
B. generator()
C. yield_generator()
D. yield

26 . 下列哪个选项可以用来在Python中进行多线程编程？（A）
A. threading module
B. multithread module
C. parallel module
D. thread module

27 . 下列哪个选项可以用来在Python中进行装饰器（Decorator）的应用？（A）
A. @decorator
B. apply_decorator()
C. use_decorator()
D. decorate()

28 . 下列哪个选项可以用来在Python中实现面向对象编程中的多重继承？（D）
A. multiple_inheritance()
B. inherit_from()
C. super()
D. class SubClass(BaseClass1, BaseClass2):

29 . 在 Python 中，下列哪个选项用于将一个函数的参数设置为可选，并提供一个默认值？（B）
A. 使用 Optional 类型
B. 使用 default 关键字参数
C. 使用 Optional 类型与 default 关键字参数的组合
D. 使用函数重载

30 . 下列代码的输出是什么？（B）

def add_to_list(item, lst=[]):
    lst.append(item)
    return lst
print(add_to_list(1))
print(add_to_list(2))

A. [1], [2]
B. [1], [1, 2]
C. [1], [2]
D. [1], [1]

解析：
Python 的默认参数在函数定义时仅评估一次。

由于 lst=[] 是可变对象，它在多次调用间共享。

第一次调用后列表变为 [1]，第二次调用在同一列表基础上变为 [1, 2]。

量化C++笔试题

Sun, 12 Apr 2026 12:12:49 +0000

1 . 在C++中，用于声明整数类型变量的是什么？（A）
A. int
B. float
C. char
D. double 2 . 下面哪种循环结构在C++中是无限循环？（D）
A. for
B. while
C. do-while
D. None of the above

解析：

在 C++ 中，for、while 和 do-while 都是循环控制结构，它们本身都不是无限循环。

只有当程序员为它们设置了永远为真（true）的条件时，它们才会变成无限循环。

3 . 在C++中，用于定义预处理器宏的符号是什么？（C）
A. $
B. &
C. #
D. * 4 . C++中，用于获取一个变量的地址的操作符是什么？（B）
A. *
B. &
C. ->
D. :: 5 . 在C++中，用于创建子类的关键字是什么？（D）
A. extends
B. implements
C. subclass
D. class

解析：
在C++中，创建子类并没有像 Java 那样的专用关键字（如 extends），而是继续使用 class（或 struct）关键字来定义新类，并通过冒号（:）符号来表示继承关系。

6 . 下面哪个关键字用于在C++中终止当前循环并立即执行下一次迭代？（C）
A. skip
B. next
C. continue
D. break 7 . 在C++中，通过 std::unique_ptr 管理的对象的所有权是？（B）
A. 可以被多个 std::unique_ptr 共享
B. 只能被一个 std::unique_ptr 拥有
C. 可以被 std::unique_ptr 和 std::shared_ptr 共享
D. 不能被 std::unique_ptr 管理 8 . 下面哪个关键字用于定义一个函数，该函数不返回任何值？（A）
A. void
B. null
C. none
D. empty 9 . 在C++中，std::vector 的 emplace_back() 和 push_back() 之间的主要区别是什么？（C）
A. emplace_back() 接受可变数量的参数，push_back() 只接受一个参数。
B. emplace_back() 会复制参数，push_back() 会移动参数。
C. emplace_back() 可以直接构造对象，push_back() 需要先创建对象再添加到容器中。
D. emplace_back() 会在容器的末尾添加元素，而 push_back() 则可以在任意位置添加。

10 . 在C++中，用于从标准输入流中读取用户输入的对象是什么？（A）
A. std::cin
B. std::cout
C. std::ifstream
D. std::ofstream 11 . 在C++中，下列哪种数据类型用于存储整数值？（C）
A. float
B. double
C. int
D. char 12 . 下列代码的输出是什么？（B）

#include <iostream>
int main() {
    int x = 10;
    int* p = &x;
    int** q = &p;
    std::cout << **q;
    return 0;
}

A. 0

B. 10

C. 编译错误

D. 运行时错误

解析：

p 指向 x，q 指向 p。* * q 等同于 * ( * q) ➡️ * ( p ) ➡️ x，所以输出 10。

13 . 下列哪种运算符用于获取变量的地址？（B）
A. *
B. &
C. %
D. / 14 . 在C++中，下列哪种关键字用于定义一个类？（A）
A. class
B. struct
C. private
D. public 15 . 下列哪种语句用于在C++中定义一个函数？（D）
A. method
B. function
C. def
D. void

解析：

严格来说，void 是一个数据类型（表示无类型），而不是一种“语句”，而C++ 定义函数时必须指定返回类型。

但在给出的选项（method, function, def, void）中，只有 void 是 C++ 的合法关键字并常用于函数定义。

16 . 下列哪个关键字用于在C++中表示在编译时替换的常量？（B）
A. static
B. constexpr
C. const
D. define

解析：

constexpr（C++11引入）明确要求表达式在编译时求值。

const 仅表示只读，不一定在编译时确定。

17 . 下列哪种数据结构用于按照先进先出（FIFO）的顺序存储元素？（B）
A. 栈（Stack）
B. 队列（Queue）
C. 链表（Linked List）
D. 树（Tree） 18 . 在C++中，下列哪种关键字用于终止循环并立即退出循环体？（A）
A. break
B. continue
C. return
D. exit 19 . 下列哪种语句用于在C++中引入一个外部头文件？（A）
A. #include
B. #import
C. #define
D. #using 20 . 下列代码的输出是什么？（B）

#include <iostream>
int main() {
    int x = 5;
    int& ref = x;
    ref++;
    std::cout << x;
    return 0;
}

A. 5
B. 6
C. 0（未定义行为）
D. 未定义

解析：

ref 是 x 的引用（别名），对 ref 的操作就是对 x 的操作。

21 . 在C++中，下列哪种关键字用于在类定义中指定一个成员函数只能由类的其他成员函数调用，而不能被外部调用？（A）
A. private
B. protected
C. public
D. friend 22 . 下列哪种语句用于在C++中抛出一个异常？（A）
A. throw exception;
B. raise exception;
C. catch(exception);
D. try { throw exception; } 23 . 在C++中，下列哪种关键字用于在派生类中重写基类的成员函数？（A）
A. override
B. virtual
C. super
D. extend 24 . 下列哪种数据结构在C++标准库中被实现为模板类？（C）
A. 栈（Stack）
B. 队列（Queue）
C. 向量（Vector）
D. 链表（Linked List）

解析：

实际上，选项 A（栈 std::stack）、B（队列 std::queue）和 D（链表 std::list）在 C++ 标准库（STL）中全部都是模板类。

但是，在大多数初级教材中，std::vector 是最典型的模板类示例。

25.在C++中，下列哪种关键字用于声明一个纯虚函数？（B）
A. abstract
B. virtual
C. pure
D. override

小贴士：

virtual 用于声明虚函数。

而纯虚函数是指在虚函数的基础上后面加了 = 0（比如 virtual void func() = 0;）。

26 . 下列哪种语句用于在C++中动态转换对象的类型？（A）
A. dynamic_cast<>
B. static_cast<>
C. reinterpret_cast<>
D. const_cast<> 27. 在C++中，下列哪种关键字用于防止类被继承？（B）
A. sealed
B. final
C. static
D. const 28. 下列哪种语句用于在C++中创建一个线程？（C）
A. start_thread()
B. create_thread()
C. thread()
D. spawn_thread() 29. 在C++中，下列哪种关键字用于将一个函数声明为内联函数？（A）
A. inline
B. fast
C. quick
D. rapid 30. 下列哪种语句用于在C++中实现多态性？（A）
A. virtual functions
B. abstract classes
C. friend functions
D. static functions

为什么基于Selenium实现浏览器自动化操作时,建议搭配WebDriverManager使用以及什么是WebDriver？

Sat, 11 Apr 2026 12:57:34 +0000

因为项目经历中写到基于 Selenium 和 WebDriverManager实现了自动化网页截图功能，出现了Selenium和WebDriver这两个东西，所以面试的时候，面试官让我解释一下这两个东西是干嘛用的。

本文就来理清一下。

什么是WebDriver？

Selenium是一套完整的Web自动化测试工具集，而 WebDriver 是其中最核心的组件。

简单说一下原理：

我们写的代码（比如 driver.getScreenshotAs(OutputType.FILE)），会被WebDriver转换成浏览器能识别的协议命令（比如W3C WebDriver协议）。
浏览器收到命令后执行操作（网页截图），再把结果通过WebDriver返回给我们的代码。

不同浏览器有专属的WebDriver：

Chrome → ChromeDriver
Firefox → GeckoDriver
Edge → EdgeDriver

这些驱动都是 Chrome、Firefox 等浏览器厂商官方维护发布的，而非 Selenium 官方提供，这也是浏览器版本更新后，对应驱动必须同步更新的原因。

为什么强烈建议搭配WebDriverManager？

WebDriverManager 是一个开源库，作用是自动管理浏览器驱动。

比如你电脑上Chrome是123版本，它会自动找对应的ChromeDriver 123版本，不用你手动去官网找链接、下文件，也不用写 System.setProperty 那行配置环境的代码，它会帮你搞定。

此外，它还自带驱动本地缓存能力，一次下载后会重复复用，不会每次运行脚本都重新下载，不影响自动化截图的执行效率。

举个例子

先在Maven里加依赖：

<dependency>
    <groupId>io.github.bonigarcia</groupId>
    <artifactId>webdrivermanager</artifactId>
    <version>6.1.0</version>
</dependency>

然后代码里直接用：

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class MyAutomationTest {
    public static void main(String[] args) {
        // 这一行，自动搞定ChromeDriver的版本、下载、配置
        WebDriverManager.chromedriver().setup();
        
        WebDriver driver = new ChromeDriver();
        driver.get("https://xxx.com");
        // 接下来写你的自动化操作...
    }
}

小贴士

WebDriver：Selenium和浏览器之间的“桥梁”，负责把代码指令翻译成浏览器动作。
WebDriverManager：桥梁的“管理员”，自动搞定驱动版本、下载、配置，让你专注写业务逻辑。

一文吃透TCP三次握手与四次挥手

Fri, 10 Apr 2026 20:10:09 +0000

TCP的三次握手和四次挥手，说实话，即使背了很多很多遍，还是容易搞忘。

本文，就用最直白的话梳理一下，强化记忆。

首先，TCP是面向连接、保证可靠的传输层协议，和“发出去就不管”的UDP完全不一样。

所以，它在正式传数据前，必须先建立可靠的连接，这就是三次握手；

数据传完要安全断开、不能丢数据，这就是四次挥手。

三次握手

TCP 三次握手的目标，是让客户端与服务端互相确认双方的收发能力正常、同步双方的初始化序列号，最终建立一条可靠的 TCP 连接。

第一次握手

客户端向服务端发送一个同步标志位（SYN=1）的同步报文，报文中携带了自己随机生成的初始化序列号。

发送完成后，客户端进入同步已发送（SYN_SENT）状态。

第二次握手

服务端收到客户端的同步请求后，会回复一个同步标志位（SYN=1）和确认标志位（ACK=1）都置1的同步确认报文。

这个报文里，确认号是客户端的初始化序列号 + 1，同时也会携带服务端自己随机生成的初始化序列号。

发送完成后，服务端进入同步已收到（SYN_RCVD）状态。

第三次握手

客户端收到服务端的同步确认报文后，会回复一个确认标志位（ACK=1）的确认报文，其中确认号是服务端的初始化序列号 + 1。

发送完成后，客户端直接进入连接已建立（ESTABLISHED）状态；

服务端收到这个确认报文后，也会同步进入连接已建立状态。

到这里，TCP连接就正式建立完成，双方可以开始正常传输业务数据了。

为什么是三次握手，不是两次？

两次握手只能保证客户端确认服务端的收发能力正常，服务端却没法确认客户端的接收能力是正常的。

官话那么多，举个例子好理解一点：

如果客户端发的同步标志位（SYN=1）报文在网络里滞留了，客户端自己都放弃了，但是，这个报文在滞留结束后，还是来到了服务端。

这种情况，如果是两次握手，服务端收到后就会直接建立连接，一直等着客户端发数据，但是，客户端根本就不认这个连接，也不会发数据，这样就白白浪费了服务端的资源。

而如果是三次握手，服务端收到滞留的SYN报文、回复SYN+ACK后，客户端根本不会回复第三次ACK，服务端收不到最终确认，就不会建立无效连接，完美规避了资源浪费的问题。

四次挥手

四次挥手的本质，是TCP全双工连接的双向关闭过程。

因为TCP连接是全双工的，双方都能独立发送和接收数据，所以，断开的时候，必须保证双方的数据都完全传输完毕后，再安全断开连接，不能单方面说断就断。

第一次挥手

客户端发送一个结束标志位（FIN=1）的结束包，告诉服务端：

我的业务数据已经全部发完了，之后不会再发送数据了。

发送完成后，客户端进入结束等待1（FIN_WAIT_1）状态。

第二次挥手

服务端收到客户端的结束包后，立刻回复一个确认标志位（ACK=1）的确认包，其中确认号是客户端 FIN 报文的序列号 + 1。

发送完成后，服务端进入关闭等待（CLOSE_WAIT）状态；

客户端收到这个确认包后，就会进入结束等待2（FIN_WAIT_2）状态。

这里要注意：

这个阶段，客户端已经不会再发送数据了，但服务端如果还有没发完的业务数据，依然可以正常给客户端发送，客户端也会正常接收。

第三次挥手

等服务端把所有剩余的数据都发送完毕后，也会给客户端发送一个结束标志位（FIN=1）的结束包，告诉客户端：我的数据也全部发完了，之后也不会再发送数据了。
发送完成后，服务端进入最后确认（LAST_ACK）状态。

第四次挥手

客户端收到服务端的结束包后，立刻回复一个确认标志位（ACK=1）的确认包，其中确认号是服务端FIN报文的序列号 + 1。

发送完成后，客户端进入时间等待（TIME_WAIT）状态，等待2MSL（最长报文寿命）的时间后，才会正式关闭连接；

而服务端只要收到这个确认包，就会直接关闭连接。

到这里，整个TCP连接就正式断开了。

为什么握手只要三次，挥手却要四次？

握手的时候，服务端的SYN（同步报文）和ACK（确认报文）可以合并在同一个包里发送，所以三次就够了；

但挥手的时候，服务端收到客户端的结束报文时，可能还有没发完的数据要继续传，所以只能先回复确认报文进行确认，等数据全部发完了，才能再发结束报文告诉客户端自己也可以关了。

ACK和FIN分开发送，自然就变成了四次。

面试官：你知道CAS，Compare and swap吗

Tue, 07 Apr 2026 19:38:44 +0000

聊CAS之前，得先说说写并发代码最头疼的事——多线程同时改一个共享变量，怎么保证线程安全？

最常用的就是加锁，比如synchronized或者Lock，但不管哪种锁，只要涉及到线程阻塞和唤醒，就有性能开销，尤其是高并发场景下，大量线程抢锁，CPU光花在上下文切换上了，很不划算。

那有没有无锁的线程安全方案呢？

有，这就是CAS。

CAS全称Compare-And-Swap，翻译一哈就是比较并交换，是CPU硬件层面支持的原子操作，核心逻辑特别简单，就3个核心值：

要读写的内存地址 V
我们预期的旧值 A
想要更新成的新值 B

它的执行规则只有一条：

只有当内存地址V里的真实值，等于我们预期的旧值A时，才会把V的值更新成B；
否则不执行更新，返回当前V的真实值。

整个操作是原子的，执行中途不会被其他线程打断。

上面扯了那么多官话，好像也不是太明白，那就举个例子吧。

举个例子

我银行卡里有100块钱（内存V=100），现在要转50块出去，预期账户里还是100（旧值A=100），转完之后应该剩50（新值B=50）。
这时候CAS就会先检查账户里是不是真的有100块，如果是，就直接改成50，转账成功；

如果中途被别的线程改了，比如已经被转走了30，只剩70了，和预期的100对不上，就不执行转账，返回当前的70，避免出错。

我们平时用的AtomicInteger、AtomicLong这些原子类，里面的getAndIncrement()、incrementAndGet()这些方法，底层全是靠CAS实现的。

它不用加锁，不会阻塞线程，并发量不极端的情况下，性能比重量级锁好太多了。

ABA问题

CAS虽然香，但它不是万能的，其中最经典、面试必问的坑，就是ABA问题。

先说说ABA问题到底是个甚：

线程1读取到内存V的值是A，正要执行CAS更新；

这时候线程2抢到了CPU，把V的值从A改成了B，然后又改回了A；

等线程1回来执行CAS的时候，发现V的值还是A，和自己预期的一样，就顺利完成了更新。

但实际上，这个A已经不是线程1最开始读到的那个A了，中间已经被其他线程改过一轮了，只是最终值又变回来了而已。这就是ABA问题。

再举个真实的例子

我们有一个栈，栈顶元素是A，A的下一个元素是B，现在我们想通过CAS把栈顶换成B，也就是弹出A。

线程1读取了栈顶的值A，预期旧值是A，要更新成B，这时候线程1被挂起了；
线程2抢到执行权，把A、B全都弹出栈，然后又把A重新压回栈里，现在栈里只有A，B已经不在栈里了；
线程1恢复执行，检查栈顶的值，发现还是A，和预期的一样，CAS执行成功，把栈顶换成了B。

问题来了：

B早就被线程2弹出栈了，现在栈里根本没有B这个元素，线程1的操作直接把整个栈的结构搞崩了。

ABA问题的解决方案

主流的解决方案就是版本号（时间戳）机制。

具体逻辑也很简单：

给每个变量额外加一个版本号，每次变量被修改，版本号就+1。

CAS操作的时候，不仅要对比变量的值，还要对比版本号，只有两个都和预期的一致，才执行更新。

还是拿刚才的栈例子来说：
初始状态，栈顶是A，版本号是1；
线程1的预期是：值=A，版本号=1，要更新成B；
线程2修改了栈，把A弹出又压回，这时候A的版本号已经变成3了；
线程1回来执行CAS，发现版本号1和当前的3对不上，直接更新失败，完美避开了ABA问题。

Spring Boot + Vue 前后端联调踩坑记录

Fri, 03 Apr 2026 18:24:30 +0000

最近在搞那个 AI 内容创作平台的前后端联调，踩了一堆坑，从 SSE 时序到参数类型，再到响应数据结构，一个接一个。

本文记录一下，大概有4个比较典型的。

SSE 连接时序竞争：Emitter 不存在

1
2

SSE Emitter 不存在, taskId=aef5eec7307b4532815a239c45cad95b
GET http://localhost:5173/api/article/progress/xxx 500 (Internal Server Error)

后端用 @Async 跑 AI 生成文章的异步任务，但频繁报 “SSE Emitter 不存在” 错误。

原因分析

这是一个典型的时序竞争问题。

流程如下：

1
2
3

1. POST /article/create → 返回 taskId，同时 @Async 启动异步任务
2. 异步线程立即开始执行 AI 生成，尝试通过 sseEmitterManager.send() 推送消息
3. 前端拿到 taskId 后才建立 SSE 连接 GET /article/progress/{taskId}

如果步骤 2 比步骤 3 先发生，emitterMap 中还没有该 taskId 对应的 Emitter，就会报错。

解决方案

在启动异步任务之前，先把 SSE Emitter 预创建好，放进 emitterMap 里，确保异步任务启动时，Emitter 已经存在了。

ArticleController.java 调整一下顺序：

@PostMapping("/create")
public BaseResponse<String> createArticle(...) {
    String taskId = articleService.createArticleTask(request.getTopic(), loginUser);

    // 关键：先预创建 SSE Emitter，放进 map 里
    sseEmitterManager.createEmitter(taskId);

    // 之后再启动异步任务，此时 Emitter 已经存在，可以安全发送
    articleAsyncService.executeArticleGeneration(taskId, request.getTopic());

    return ResultUtils.success(taskId);
}

然后在SseEmitterManager.java 的 createEmitter 方法加个幂等判断，防止重复创建：

public SseEmitter createEmitter(String taskId) {
    // 如果已经存在，直接返回已有的（支持预创建场景）
    SseEmitter existingEmitter = emitterMap.get(taskId);
    if (existingEmitter != null) {
        return existingEmitter;
    }
    // ... 原来的创建新 Emitter 的逻辑
}

修复后时序变为：

1
2
3

1. 创建任务 + 预创建 Emitter（放入 emitterMap）
2. 启动异步任务（此时 Emitter 已存在，可以安全发送）
3. 前端建立 SSE 连接（返回已预创建的 Emitter）

文章详情页参数传递类型错误

1
2

BusinessException: 文章不存在
at ArticleController.getArticle(ArticleController.java:106)

文章是创建成功了，但是，点击“查看文章”，前端页面却显示“文章不存在”。

原因分析

前端 API 函数 getArticle 期望接收一个对象 { taskId: string }，但是，我在页面里直接传了个字符串：

// articleController.ts — 函数签名明确要对象
export async function getArticle(params: API.getArticleParams) {
  const { taskId: param0, ...queryParams } = params
  return request(`/article/${param0}`, { ... })
}

// ArticleDetailPage.vue — 我直接传了字符串
const res = await getArticle(taskId)  // 传入字符串

对字符串做解构后 param0 为 undefined，最终请求变成了 /article/undefined。

解决方案

老老实实传对象就行：

`1`	`const res = await getArticle({ taskId }) // 传 { taskId: xxx }`

我的文章列表显示 “No data”

文章生成完成了，数据库里也有数据，但查看【我的文章】列表页却显示 “No data”。

原因分析

Axios 的完整响应结构是这样的：

1
2

res = AxiosResponse 对象
res.data = { code: 200, data: { records: [...], totalRow: 10 }, message: "ok" }

也就是说，实际的业务数据在 res.data.data 里，但我在前端直接取了 res.data.records：

1
2
3

// 错误写法 — res.data 是 { code, data, message }，根本没有 records 属性
dataSource.value = res.data.records || []
pagination.value.total = res.data.totalRow || 0

当然是空的。

解决方案

老老实实多写一层 .data：

1
2

dataSource.value = res.data.data.records || []
pagination.value.total = res.data.data.totalRow || 0

删除文章请求体格式错误

1
2

MismatchedInputException: Cannot construct instance of `DeleteRequest`
(no int/Int-argument constructor/factory method to deserialize from Number value (5))

点击删除文章，后端直接报 Jackson 反序列化错误。

原因

后端接口用的是 @RequestBody DeleteRequest，期望接收一个 JSON 对象，但我在前端直接传了个数字：

1
2

// 错误写法 — 请求体是数字 5
await deleteArticleApi(record.id)

Jackson 收到数字 5，当然没法反序列化成 DeleteRequest 对象。

解决方案

老老实实传对象就行：

1
2

// 正确写法 — 请求体是 { "id": 5 }
await deleteArticleApi({ id: record.id })

哈希、对称_非对称加密、数字签名，一次性讲清

Thu, 02 Apr 2026 18:43:59 +0000

不管是做用户密码存储、文件完整性校验、接口幂等设计，还是HTTPS通信、支付回调验签、敏感信息加密，总会绕不开哈希、加密、签名这些概念。

本文就把这些东西一次性理清楚，分清楚每个技术的核心作用、主流算法以及适用场景。

单向哈希摘要算法

不管你输入多长的内容，它都能生成固定长度的哈希摘要字符串；

相同的输入，永远会得到完全相同的输出；

最关键的是它单向不可逆，也就是说你没法从生成的哈希摘要，反推出原来的原始数据。

理论上它存在哈希碰撞的概率（也就是两个不同的输入，生成了相同的哈希值），但在正常的生产环境里，这个概率可以完全忽略不计。

主流算法

不安全已淘汰：MD5、SHA-1（已经被证实存在高效哈希碰撞的手段，安全场景绝对不能用）
生产环境推荐：SHA-256、SHA-512、bcrypt、Argon2、国密SM3

业务场景举例

1. 用户密码存储

如果用 SHA-256 这类普通哈希算法：

需要先生成全局唯一的随机盐值（salt），把【用户密码 + salt】拼接后做哈希运算，最终把哈希值+盐值一起存入数据库；

如果用 bcrypt/Argon2 这类慢哈希算法：

不用自己手动生成盐，算法会内置随机盐，并且自动把盐嵌入到最终的哈希结果里，直接传入用户密码生成哈希值，最终只需要把这一个哈希值存入数据库就行。

登录校验的逻辑也很简单：

用户提交账号密码后，后端根据账号从数据库取出对应的哈希值（SHA系列还要单独取出盐值），用相同的算法对用户输入的密码做哈希，比对两个哈希值是否一致，一致就校验通过。

2. 文件完整性校验

比如我们把后端服务打包成JAR包发布时，会提前计算JAR包的SHA-256哈希值，和安装包一起发布到服务器；

服务器下载完成后，会重新计算自身磁盘上该文件的哈希值，和发布时给出的官方哈希值比对，一致就说明文件在传输过程中没有被篡改、没有丢失内容。

3. 接口请求幂等性保证

比如用户下单接口，我们可以把用户ID、商品ID、订单号、请求时间戳等核心参数，按固定规则排序拼接后做SHA-256哈希，生成唯一的幂等号，存入Redis并设置过期时间；
当同一个重复请求第二次进来时，计算出的哈希值已经存在于Redis中，直接拒绝请求，保证接口幂等性。

小贴士

MD5、SHA-1已经被破解，存在明确的哈希碰撞风险，生产环境禁止用于密码存储等安全相关场景。
密码存储优先用bcrypt、Argon2这类慢哈希算法，别直接用SHA-256。

对称加密

哈希是不可逆的，只做摘要不做解密；

而加密的核心是可逆，有加密就一定有对应的解密。

对称加密指的是：

加密和解密用的是完全同一个密钥。

它的运算速度特别快，非常适合给大数据量的内容做加密，唯一的痛点就是密钥的安全分发与保管。

因为，一旦这个密钥泄露了，你所有加密的数据，都能被直接破解。

主流算法

不安全已淘汰：DES、3DES
生产环境推荐：AES-128/AES-256、国密SM4

业务场景举例

我们每天都在用的HTTPS，通信逻辑就是【非对称加密协商密钥+对称加密传输内容】的组合。

浏览器和服务器在HTTPS握手阶段，会通过非对称加密协商出一个临时的AES会话密钥；

握手完成后，后续所有的请求、响应数据，都用这个AES密钥做加密传输。

这样的话，既解决了密钥分发的安全问题，又利用对称加密速度快的优势，保证了大数据量传输的性能。

非对称加密

非对称加密，就是为了解决对称加密的密钥分发痛点诞生的。

它的特点是加密和解密用的不是同一个密钥，而是一对数学上强关联的密钥对：一个叫公钥，一个叫私钥。

公钥：可以完全公开给所有人，哪怕全网都知道，也没有任何泄露风险；
私钥：必须由持有者自己严格保密，绝对不能泄露给任何人。

这里有两个不能搞反的规则：

用公钥加密的内容，只有对应的私钥能解密；
用私钥加密的内容，只有对应的公钥能解密（这也是后面数字签名的核心原理）。

需要注意的是：

非对称加密的运算速度很慢，只适合给小数据量的内容做加密，绝对不适合用来加密大数据量的内容。

主流算法

生产环境推荐：RSA-2048、ECC椭圆曲线算法、国密SM2

业务场景举例

金融、支付场景中，用户身份证号、银行卡号、支付密码等核心敏感信息的传输，必须用非对称加密。

比如用户在平台绑定银行卡，前端页面会用平台提前公开的RSA公钥，对银行卡号、身份证号做加密后再传给后端；

后端用自己保管的私钥解密出明文，做合规校验和存储。

哪怕请求被中间人截获，没有对应的私钥，也绝对无法解密出用户的敏感信息，从根源上避免信息泄露。

数字签名与验签

数字签名与验签，是基于【非对称加密+单向哈希】实现的，它的目标不是数据保密，而是以下两个：

身份认证，证明这个数据的发送方是真的；
防篡改，证明这个数据在传输过程中没有被修改过。

很多人会把加密和签名的逻辑搞反，这里再梳理一遍：

普通加密是【公钥加密、私钥解密】，目标是数据保密，不让第三方看到内容；

数字签名是【私钥加密、公钥解密】，目标是身份认证+防篡改，核心逻辑和我们平时做密码校验的哈希比对，完全是一回事：

发送方先给要发送的原始数据，算一个唯一的哈希摘要，用自己持有的私钥给这个摘要加密，加密后的结果就是【数字签名】，和原始数据一起发给接收方；
接收方拿到数据和签名后，先用发送方公开的公钥解密签名，还原出发送方当初生成的原始哈希摘要——这个摘要，就是绝对可信的【基准哈希】，只有持有私钥的官方能生成，伪造不了；
最后，我们将收到的原始数据，用和发送方完全相同的算法，重新算一遍哈希摘要，比对两个摘要是否完全一致。

只要一致，就同时验证了两件事：

第一，这个数据一定是持有私钥的官方发送的，不是伪造的；

第二，数据在传输过程中没有被篡改过。

画个图加深理解

业务场景举例

电商系统里，微信/支付宝的支付结果回调，必须做验签，就是为了防止恶意伪造支付成功的回调。

用户支付完成后，支付平台会给我们的后端发送支付结果回调，回调参数里包含订单号、支付金额、支付状态等核心信息，同时支付平台会用自己的私钥，对回调参数做签名，和参数一起发给我们；

后端收到回调后，必须先按规范流程做验签，验签通过，才会认为这个回调是支付平台官方发出的，再去修改订单的支付状态。

哪怕攻击者伪造了支付成功的回调请求，没有支付平台的私钥，就绝对无法生成合法的签名，验签会直接失败，从根源上避免了恶意伪造支付成功的风险。

别再搞混了！Redis、Jedis、Lettuce、Spring Data Redis、Redisson、Spring Session Redis 一次讲透

Wed, 01 Apr 2026 19:17:35 +0000

平时做Java开发，只要引入Redis做缓存，pom.xml里总会看到一堆名字相似的东西：一会儿是jedis，一会儿是lettuce，还有Spring Data Redis、Redisson、Spring Session Redis……

刚接触的时候真的头大，甚至会把Redis服务端和Java客户端混为一谈，踩了不少坑。

今天就把这些东西理清楚，分清谁是底层、谁是封装、谁是专门解决某个场景的。

其实，这些东西根本不是平级的，而是有明确的上下层级依赖关系，从底层到上层的完整链路是：

先讲清每个东西的定位：

Redis

就是你装在服务器上的NoSQL数据库（服务端），所有东西最终都要和它打交道。

Jedis、Lettuce、Redisson

都是Java连接Redis服务端的客户端，只是定位和特性不同。

Spring Data Redis

Spring对Java客户端做的统一封装，屏蔽底层差异，让你用一套API就能操作Redis。

Spring Session Redis

基于Spring Data Redis做的专项场景组件，只干1件事：解决分布式系统的Session共享问题。

Redis 本身

首先，所有东西的核心，就是Redis——它是一个独立跑在服务器上的键值对NoSQL数据库，也就是我们常说的Redis服务端。

它完全独立于Java程序，你用Java、Python、Go都能连接它，和jedis这些Java客户端没有任何强绑定，作用就是提供数据存储、缓存、发布订阅、计数器这些能力。

Java客户端：Jedis、Lettuce、Redisson

这三个都是Java语言实现的Redis客户端，作用就是让Java程序通过TCP连接Redis服务端、发送命令、接收结果，项目里选其一即可，不用全引。

1. Jedis

Jedis应该是Java生态里最早流行的Redis客户端了，最大的特点就是轻量、简单，API完全贴合Redis的原生命令。

它的底层是阻塞式、直连模型：

每个连接对应一个物理TCP连接，多线程环境下是线程不安全的，所以多线程场景用的时候，必须搭配连接池使用。

适用场景

小项目、简单的Redis缓存场景，对性能没有极致要求，就想快速上手用Redis，选Jedis完全够用。

小贴士

Spring Boot 1.x版本，Spring Data Redis默认的客户端就是Jedis，2.x之后换成了Lettuce。

2. Lettuce

现在用Spring Boot 2.x/3.x，只要引了redis的starter，默认集成的就是Lettuce，它是基于Netty实现的非阻塞、响应式客户端。

和Jedis最大的区别就是：

它是线程安全的，一个连接实例就能在多线程环境下安全使用，不用额外配置连接池；

底层用Netty的NIO模型，支持异步、响应式编程，高并发场景下的性能比Jedis好很多，同时也完美支持Redis哨兵、集群、管道这些高级特性。

适用场景

高并发、需要异步操作Redis的场景，还有Spring WebFlux响应式编程项目。

Redisson

Jedis和Lettuce的核心是：

封装Redis命令，让你能操作Redis。

分布式微服务项目里，需要实现跨节点的Session共享、单点登录，用它非常方便，几行配置就能搞定，不用自己手写逻辑。

Java线程与操作系统线程的生命周期

Wed, 01 Apr 2026 14:12:15 +0000

平时不管是面试还是线上排查问题，线程生命周期都是绕不开的点，但我发现Java线程的状态和操作系统（OS）底层的线程状态很容易搞混，本文就来理清楚二者的区别。

先说个大前提：

我们常用的HotSpot虚拟机，采用的是1:1线程模型——也就是说，你在Java代码里new的一个Thread，会直接映射到操作系统的一个内核线程，JVM本身不参与线程的调度，调度权完全在操作系统内核手里。

JVM只是对内核线程的状态做了一层封装和抽象，这也是两者状态不一样的根本原因。

操作系统的线程生命周期

操作系统里，线程是CPU调度的最小单位，它的所有状态流转，完全围绕CPU的使用权来设计，主流的Linux/Windows系统，通用的是五态模型。

1. 新建（New）

就是刚通过系统API创建了线程，只完成了最基础的资源初始化，还没被加到内核的调度队列里，根本没资格抢CPU，自然也没法执行。

2. 就绪（Ready）

这个状态的线程，已经拿到了除CPU之外的所有运行需要的资源，已经进入内核的就绪队列，就等调度器给它分配CPU时间片了。
这里要注意：

同一时间，就绪队列里会有一堆线程，哪个能拿到CPU，全看操作系统的调度策略，上层代码根本管不了。

3. 运行（Running）

线程正在CPU核心上执行指令，这是唯一一个能占用CPU的状态。

4. 阻塞（Blocked）

线程因为要等某个事件（比如磁盘IO、网络响应、锁释放），主动放弃了CPU使用权，暂停执行。

这个状态的线程，调度器根本不会给它分配CPU时间片，除非它等的事件完成了。

5. 终止（Terminated）

线程正常执行完毕，或者被强制终止、出现未捕获的异常，内核会回收这个线程的所有资源，生命周期彻底结束，再也无法回退到其他状态。

状态流转图

Java线程的生命周期

Java线程的所有状态，都在java.lang.Thread.State这个枚举里明确定义了，一共6种，是JVM对底层OS线程状态的封装，但是和OS状态并非一一对应。

1. NEW（新建）

这个和OS的新建态完全对应，就是代码里用new Thread()创建了线程对象，但还没调用start()方法。
需要注意的是：

这个时候它就是堆里一个普通的Java对象，根本没和OS的内核线程绑定，连调度的资格都没有，千万别重复调用start()，会直接抛出异常。

2. RUNNABLE（可运行）

这是Java线程里最核心、最容易和OS状态搞混的复合状态！
JVM直接把OS里的【就绪态】+【运行态】，甚至包括【本地IO阻塞的场景】，全部打包封装成了RUNNABLE状态。

什么意思呢？

调用start()之后，线程进了内核就绪队列排队等CPU，JVM里标记为RUNNABLE；
线程拿到CPU正在执行代码，JVM里还是标记为RUNNABLE；
线程执行阻塞的本地IO（比如文件读写），OS层面线程已经阻塞了，但JVM里依然标记为RUNNABLE。

为什么JVM要这么设计？

其实很简单，JVM不关心底层CPU的调度细节，它只关心这个线程是不是【可运行的】，哪怕你在等IO，JVM也认为这是运行过程中的必要环节，等IO完成了你就能继续跑，所以不会把它标记成阻塞状态。

3. BLOCKED（阻塞）

Java里的BLOCKED状态，只有一种情况会进入：

线程等待获取synchronized监视器锁，而这个锁刚好被其他线程持有了，这时候线程才会进入BLOCKED状态。
容易混淆的是Lock锁，但是Lock锁底层是用LockSupport.park()实现的，进入的是WAITING状态，不是BLOCKED。

4. WAITING（无限等待）

这个状态的线程，进入了没有超时时间的等待，必须由其他线程主动唤醒，否则会一直等下去，不会自动唤醒。

常见的触发场景有：

Object.wait()（无超时参数）、Thread.join()（无超时参数）、LockSupport.park()。

5. TIMED_WAITING（计时等待）

和上面的WAITING的区别就是，这个带了明确的超时时间，时间一到，JVM会自动把它唤醒，不用等其他线程操作。
常见的触发场景有：

Thread.sleep(long)、Object.wait(long)、Thread.join(long)、LockSupport.parkNanos()。

小贴士：

Thread.sleep () 只会让出 CPU 时间片，不会释放持有的锁；

而 Object.wait () 会同时释放 CPU 和持有的锁。

6. TERMINATED（终止）

和OS的终止态完全对应，线程的run()方法正常执行完毕，或者抛出了未捕获的异常，生命周期彻底结束。

这个状态再也回不到其他状态，哪怕再次调用start()，也会直接抛出IllegalThreadStateException。

状态流转图

两者的关系与区别

操作系统线程状态	Java线程状态	说明
新建（New）	NEW	完全对应，都是创建后未启动的状态
就绪（Ready）+ 运行（Running）	RUNNABLE	JVM不区分“排队等CPU”和“正在CPU上执行”，统一封装为RUNNABLE，屏蔽了内核调度细节
阻塞（Blocked）	BLOCKED / WAITING / TIMED_WAITING	OS里单一的阻塞态，被JVM细分成3种，分别对应不同的等待场景，这三个状态在OS层面都拿不到CPU时间片
终止（Terminated）	TERMINATED	完全对应，生命周期结束，资源回收

一篇搞懂：Java包名、Maven artifactId、Spring application.name到底有啥区别？

Fri, 27 Mar 2026 21:33:09 +0000

项目文件夹叫codeedge-backend，Java包名是codeedgebackend，Maven的artifactId是codeedge-backend，Spring配置里还有个spring.application.name叫codeedge-backend。

这几个到底有啥区别？必须要对上吗？

其实，这几个是完全不同维度、不同作用、没有任何强制绑定关系的配置，给谁用、管什么、能不能乱改，差别还是挺大的。

我就用 codeedge-backend 项目当例子，先从最核心、最容易踩语法坑的 Java 包名说起。

Java包名 `com.codeedgexu.codeedgebackend`

这是Java语言强制规范的代码组织方式，是给Java编译器、JVM、Spring Boot看的，用来唯一标识代码类，和项目功能强绑定。

作用

唯一标识代码类，避免重名冲突

你的controller、config、service这些类，全在com.codeedgexu.codeedgebackend这个包下面。

Java编译器靠【包名+类名】唯一确定一个类，比如你的启动类全限定名是com.codeedgexu.codeedgebackend.CodeEdgeBackendApplication，这个名字全局唯一，不会和别人的项目重名冲突。

决定Spring Boot的Bean扫描范围

Spring Boot启动的时候，默认只会扫描启动类所在的包以及它的子包。

比如你的启动类在com.codeedgexu.codeedgebackend下面，那它只会扫这个包下面的controller、service，把它们注册成Bean。

如果改了代码的包名，但启动类没跟着搬到新包，Spring 就扫不到新包里的 controller、service 这些类，导致这些类不会被注册成 Bean，项目启动失败。

小贴士

Java包名里，绝对不能用横杠-。

因为横杠在Java里是减号运算符，不能出现在包名、类名、变量名里，编译器会直接报错。

这也是为什么我文件夹名可以叫codeedge-backend，但包名必须写成codeedgebackend的根本原因——不是我不想写一样的，是Java语法不允许。

Java包名的所有部分必须全小写。

这是Java的行业通用规范，虽然语法允许大写，但不专业，且很多代码规范检查工具会报错。

Maven artifactId `codeedge-backend`

这是Maven项目的唯一标识，在同一个groupId下必须唯一，用来在Maven仓库里找到你的项目、打包发布、管理依赖。

作用

唯一标识你的Maven项目，和别人的项目区分开；
项目打包、发布到Maven仓库，全靠这个artifactId；
以后别人要引用你的项目，就是靠这个artifactId写依赖：

<dependency>
    <groupId>com.codeedgexu</groupId>
    <artifactId>codeedge-backend</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

小贴士

上线后如果修改了 artifactId，项目打包出来的jar包名字会变，别人引用你的项目也要同步改artifactId，不然就找不到依赖。

推荐用kebab-case短横线分隔的格式（比如codeedge-backend），可读性好，Maven全兼容，是行业里90%的项目都会用的写法。

`application.yml`文件中的`codeedge-backend`

1
2
3

spring:
  application:
    name: codeedge-backend

这是Spring Boot应用的官方服务名，核心作用是给微服务注册中心（Nacos）看的，是你这个服务在微服务集群里的唯一标识。

作用

Nacos服务注册的唯一标识

你的服务启动时，会去Nacos登记，登记的名字就是这个spring.application.name；

微服务之间调用的标识

以后有其他服务要调用你的接口，就是靠这个名字在Nacos里找到你的服务地址；

小贴士

同样地，上线后如果修改了这个服务名，Nacos里注册的服务名就变了，其他服务再用旧名字找你，就完全找不到了，微服务调用直接报错。

推荐和Maven的artifactId保持一致（比如也叫codeedge-backend），这样你在看Nacos控制台的时候，一眼就能对应上“这个服务对应Maven里的哪个项目”，不会混乱。

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

Thu, 26 Mar 2026 20:42:49 +0000

结构化输出、TokenStream、SSE、Flux、Reactor这几个概念刚接触时感觉很混乱，本文就来理一理，我用【AI生成一个电商商品详情页】的真实项目场景，把这些概念串起来，从业务需求到底层技术，一次性搞明白。

LangChain4j结构化输出

结构化输出是LangChain4j里的一个核心功能，能强制大模型返回标准的JSON/POJO组件树对象，而不是一段诸如“我给你加个按钮、加个图片”的自然语言。

之前你让AI生成商品详情页，它可能返回：

“好的，我帮你生成了一个详情页，顶部有个轮播图放3张商品图，中间有商品标题、价格、库存，底部有个‘立即购买’的红色按钮…”

然后你还得写自己大量文本解析逻辑，甚至还要用正则去提取轮播图数量、按钮颜色，又繁琐又容易出错，而且根本没法直接渲染成 Web 组件。

用了结构化输出，AI 会直接返回标准 JSON，之后 LangChain4j 会自动把 JSON 转成 Java 对象。底层默认使用 Jackson（Java 最主流的 JSON 库），只需要提前定义好页面结构的模板类，系统就能自动完成字段映射，完全不用写任何解析代码，直接就能喂给前端的渲染引擎。

TokenStream + SSE

TokenStream是LangChain4j提供的流式API，大模型生成一个Token（大概是一个字、半个JSON键或值），就立刻推给你，不用等整个组件树JSON生成完；

SSE（Server-Sent Events），把TokenStream里的JSON片段，实时推给前端的渲染引擎，实现“轮播图先出来、标题再出来、按钮最后出来”的逐个渲染效果。

之前你让AI生成一个复杂的Web应用，要等10-30秒整个JSON生成完，才能一次性渲染给用户，用户需要在空白的预览区页面长时间等待。

用了TokenStream + SSE，AI生成完一个完整的组件JSON片段，前端就立刻渲染这个组件，用户能实时看到进度。

Flux & Reactor

Reactor是Spring官方的响应式编程框架，专门用来处理高并发、异步、流式的场景；

Flux是Reactor的核心类之一，代表0到N个元素的异步序列，刚好对应AI生成的JSON片段流（一个JSON片段就是一个元素）。

如果用传统的同步编程，几百个用户同时请求生成Web应用，你需要开几百个线程，每个线程都要等10-30秒AI生成完，服务器的CPU、内存直接就爆了，根本扛不住。

用了 Flux + Reactor，就能彻底解决这个问题：

它是完全异步非阻塞 + 事件驱动的模型 —— 发起 AI 调用后，线程立刻释放去处理其他请求，绝不死等；等 AI 生成 Token 后，再主动通知线程来处理推送，1 个线程能同时管理几百个请求，所以只用 10-20 个线程就能扛住几百甚至上千的并发。

另外，它还自带背压机制：前端网速慢，服务端就自动放慢推送速度；前端快，就加快推送，永远不会让前端浏览器因为数据堆积而卡死。

一张图搞懂

【面试真题拆解】十万用户并发下，Caffeine+Redis+MySQL多级缓存怎么设计？

Thu, 26 Mar 2026 14:59:06 +0000

面试官问了这么一道场景题：

“平台用了Caffeine本地缓存、Redis分布式缓存、MySQL数据库，现在有十万个用户同时访问，相当于每个用户对应一个请求，这多级缓存该怎么设计？”

多级缓存就是“分层扛压”，把十万用户的请求，从快到慢、从近到远，一层层分流，别让所有请求都直接打MySQL。

设计方案

定好每一层的职责

缓存层级	职责	放什么数据	容量/速度
Caffeine本地缓存	扛超级热点中的超级热点，大幅减少 Redis 压力	访问频率 Top10 的极致热门数据（比如首页轮播爆款、正在进行的秒杀活动）	容量小（几百MB）、速度极快（纳秒级）
Redis分布式缓存	扛全局通用数据，挡MySQL	全平台的业务数据（比如商品详情、用户信息、订单数据）	容量大（几十GB）、速度快（毫秒级）
MySQL数据库	数据最终兜底，保证数据不丢	所有的原始业务数据	容量无限、速度慢（秒级）

缓存预热

平台刚启动的时候，Caffeine和Redis里都是空的，如果这时候十万用户同时进来，所有请求都会直接打MySQL，直接把数据库打垮。

为了解决这个问题，考虑采用缓存预热：

平台启动前，先做两级缓存预热：

把访问频率最高的Top1000 个全量热门 Key（比如全平台热门商品、活动规则），提前从 MySQL 里查出来，全量加载到 Redis；
把其中访问频率最高的Top10 个超级热点 Key（比如首页轮播商品、正在进行的爆款活动），额外加载到每台服务器的 Caffeine 本地缓存，作为最外层的扛压层。

缓存雪崩、击穿、穿透

缓存雪崩：十万个Key同时过期

比如你给所有Key都设置了“1小时过期”，结果十万个Key在同一时间全部过期，所有请求直接打MySQL。

解决这个问题的话，就是别给所有Key都设一样的过期时间，可以设置“1小时 + 0~30分钟的随机值”，让Key的过期时间分散开，避免同时过期；

对于首页Top10商品这种超级热点数据，还可以设置成“永不过期”，只在数据更新的时候主动删除缓存。

缓存击穿：超级热门Key突然过期

比如“双11爆款商品详情”这个Key，每秒有十万个请求，结果它突然过期了，十万个请求同时打Redis，发现没有，又同时打MySQL，直接把两者都打垮。

这个问题也可以对超级热点Key不设过期时间，只在更新时主动删；

或者加Redis 分布式互斥锁：

如果 Key 真的过期了，只让第一个抢到锁的请求去查 MySQL，查出来后更新缓存并释放锁；

其他没抢到锁的请求，每隔 100ms 重试一次查缓存，直到缓存更新完成，彻底避免十万请求同时打 MySQL。

缓存穿透：查根本不存在的Key

比如有人恶意攻击，每秒发十万个请求查“id=999999999”的商品（这个商品根本不存在），缓存里没有，直接打MySQL，把数据库打垮。

这个问题优先采用布隆过滤器拦截：

平台启动时，提前把 MySQL 里所有商品的 id 全量加载到布隆过滤器里完成预热；
用户请求进来，先过布隆过滤器，如果布隆过滤器判定这个商品 id 不存在，直接返回【商品不存在】，完全不会打到缓存和 MySQL；
只有布隆过滤器判定 id 存在，才会继续走【Caffeine→Redis→MySQL】的查询流程。

兜底方案：

缓存空值。如果查 MySQL 发现这个 Key 真的不存在，就把【空值】缓存到 Redis 里（设置 5 分钟短过期时间），下次再查这个 Key，直接从 Redis 里拿空值返回，避免重复打 MySQL。

小贴士：

空值缓存必须设置短过期时间（3-5 分钟），同时限制单 IP 的请求频率，避免恶意攻击生成大量空值缓存撑爆 Redis 内存。

十万并发下的 Redis 压力分摊方案

十万个请求同时进来，如果都打到单实例 Redis 上，大概率会直接把 Redis 打宕机，必须做以下 3 件事分摊压力：

热点隔离，本地优先扛压：把访问频率 Top10 的极致超级热点 Key（比如首页轮播爆款、正在进行的秒杀活动），全量放在每台服务器的 Caffeine 本地缓存里。十万请求里 90% 都能直接在本地命中，Redis 的压力直接降 90%。
用 Redis Cluster 集群，把数据分片存储在多个节点上，每个节点只扛一部分请求，避免单节点压力过载；
Redis 主节点只负责数据更新的写请求，多个从节点负责处理十万级的读请求，把读压力分摊到多个从节点上。

多实例下的本地缓存一致性

服务基本都是多实例集群部署的（比如 10 台服务器），每台服务器都有自己独立的 Caffeine 本地缓存，很容易出现数据不一致的问题：

比如在 A 实例更新了商品价格，删了 A 实例的 Caffeine 和 Redis 缓存，但 B 实例的 Caffeine 里还存着旧价格，用户访问 B 实例就会看到脏数据。

考虑用延迟双删 + Redis 发布订阅的组合方案解决这个问题：

延迟双删：保证 Redis 和 MySQL 的数据一致

① 先删除 Redis 缓存，让缓存失效；

② 再更新 MySQL 数据库，写入新数据；

③ 等待 1 秒（延迟时间必须略大于你的业务接口平均耗时，根据实际压测结果调整，不能盲目设置），再次删除 Redis 缓存。

延迟的目的是等其他实例已经从 MySQL 读到旧数据、更新到缓存后，再删一次缓存，避免脏数据回写。

Redis 发布订阅：保证多实例 Caffeine 的数据一致

①A实例更新完数据、完成延迟双删后，通过 Redis 的发布订阅功能，给集群里所有服务实例广播一条消息：商品 id=123 的缓存已失效，请删除本地缓存；

②所有实例收到消息后，立刻删除自己本地Caffeine里对应的Key；

③下次用户访问任何实例，都会去 Redis 里查询新数据，再更新到本地 Caffeine，保证全集群所有实例的数据一致。

完整的请求+数据更新全流程

【面试真题拆解】你知道登录用到的Token是什么吗？

Thu, 26 Mar 2026 12:06:32 +0000

用户注册登录模块几乎是每一个项目都有的，有一次面试的时候，面试官问：

你既然说到了登录，那你知道Token是什么吗？

一句话：

Token = 用户登录成功后，服务器给你颁发的一张加密的临时电子通行证，最常用的就是 JWT 格式的 Token。

它本质上就是一段加密字符串，作用就是证明三件事：你是谁、你已登录、你有权限访问这个接口。

为什么登录必须用 Token？

因为 HTTP 请求是无状态的——服务器记不住你上一秒是不是登录过。
每一次请求，对服务器来说都是“陌生人”。

所以必须给你发一张 Token，让你每次访问都带着，证明你已登录。

不然你每次点一下页面都要重新输账号密码，根本没法用。

Token 的工作流程

Token 的作用

Token 和 Session 的区别

存的地方不一样
Session 把你的身份信息全存在服务器，用户一多就特别占内存；
Token 是把“电子通行证”直接存在你自己的前端设备里，服务器不用存任何用户状态，只需要验一下通行证的真假就行，几乎没额外负担。
分布式场景的适配能力不一样
Session 不适合多服务器的分布式场景——就像你在1号窗口办的会员，2号窗口根本不认，得来回同步数据，麻烦得很；
Token 就没这个烦恼，你手里的通行证全平台通用，不管哪个服务器，只要能验过真伪就直接放行，天生就适配分布式。

说白了，Token 就是为了解决 HTTP 无状态的痛点，给前端和后端之间搭了一座信任的桥梁，不用每次都输账号密码，不用服务器存储大量用户状态，还能完美适配现在的分布式项目。

一篇搞懂前后端所有的“器”

Wed, 25 Mar 2026 20:58:53 +0000

用一个电商场景中常见的用户下单流程，把前后端的所有“器”串起来：

前后端对比

层级	前端“器”	作用	后端“器”	作用
第一道关卡	路由守卫	页面访问权限控制	过滤器	跨域、编码、协议级过滤
第二道关卡	请求/响应拦截器	统一加Token、统一报错	拦截器	登录校验、权限验证
业务层	-	-	Controller	执行核心业务逻辑
业务增强层	-	-	AOP切面	日志、监控、事务增强，不侵入主业务代码
执行层	-	-	执行器	异步任务、线程池调度

其实啊，所有的“器”，本质上都是“关注点分离”的体现，即主业务代码只关心“下单”本身，而登录、跨域、日志、异步这些“脏活累活”，交给各种“器”去做。

【面试真题拆解】为什么用SSE做流式输出？和WebSocket有啥区别？

Wed, 25 Mar 2026 17:41:32 +0000

面试官问：

“你项目里用了SSE做流式输出，为什么选SSE？它的原理你知道吗？为什么不用WebSocket？”

为什么用SSE做流式输出？

一句话：

SSE 是为服务器单向给客户端推数据的场景量身定做的，完美匹配 AIGC 流式打字机的需求，开发简单、好用、运维成本低。

类比：

SSE 就像广播电台：电台单向给你播新闻、播音乐，你只能听，不能对着电台说话；
WebSocket 就像打电话：你和对方可以双向说话，你一句我一句，实时互动。

SSE流式输出的原理

SSE是Server-Sent Events（服务器发送事件），本质上是一条由服务器控制生命周期的持久化 HTTP 长连接，在数据推送周期内保持打开，不会像普通 HTTP 请求一样响应完成就立刻关闭。

完整的流程就是：

客户端发起请求

浏览器向服务器发起一个普通的HTTP GET请求，但请求头里要加 Accept: text/event-stream，告诉服务器：“我要接收流式数据，别给我返回普通网页”；

服务器建立长连接

服务器收到请求后，不立刻返回完整响应，而是保持这条HTTP连接一直打开，不关闭；

服务器持续推数据

服务器有新数据了（比如AI生成了一个字），就通过这条打开的连接，把数据推给客户端；

SSE 有固定的标准文本格式，每段数据以data:开头、\n\n结尾，刚好适配大模型逐 Token 生成的流式输出，后端生成一个 Token 就推一次，前端无需额外做格式解析，直接渲染成打字机效果；

客户端解析数据

浏览器收到数据后，自动解析，触发 onmessage 事件，前端把数据展示出来；

连接结束或自动重连

如果数据推完了，服务器就会主动关闭连接；

如果连接意外断开（非手动关闭、非服务器返回 204 状态码），SSE 自带自动重连机制，浏览器会自动重新发起请求，还会通过请求头Last-Event-ID带上最后接收的消息 ID，后端可据此补发丢失的内容，避免 AI 回答断句缺失，建立新连接后继续接收数据。

为什么不用WebSocket？

WebSocket 是为双向实时交互场景设计的，对于 AI 流式输出这个纯服务器单向推数据的场景，有点那什么杀鸡用牛刀了，并且额外增加了开发、运维成本，完全没有必要。

对比项	SSE（Server-Sent Events）	WebSocket
通信模式	单工，纯单向通信：仅支持服务器向客户端主动推送数据，客户端只能被动接收	全双工，双向通信：客户端和服务器可以同时、双向主动发送数据，无请求 - 响应的限制
协议本质	标准 HTTP 应用层协议，完全兼容所有 HTTP 基础设施（Nginx、CDN、网关、防火墙），无需额外配置	独立的应用层协议，底层基于 TCP，仅握手阶段复用 HTTP，握手完成后需协议升级，部分内网网关、WAF 会拦截升级请求
开发复杂度	极低：浏览器原生提供`EventSource` API，前端几行代码即可实现；后端仅需开发普通 HTTP 接口保持连接推送数据，无需额外处理协议逻辑	较高：需要自行处理连接握手、心跳保活、断线重连、TCP 粘包拆包、帧解析等逻辑，前后端都需要额外的开发工作量
自动重连	原生支持：浏览器内置自动断线重连机制，无需额外开发	无原生支持：需要自行实现心跳检测和断线重连逻辑
适用场景	服务器单向推送场景：AIGC 流式打字机效果、股票行情推送、直播弹幕、新闻实时更新	双向实时交互场景：即时通讯、实时多人游戏、视频会议、物联网设备双向控制

【面试真题拆解】平时会收发短信吧？你知道短信里那种 `CodeEdge` 的短链接，点击之后是怎么跳转到长链接的？它是怎么生成的？

Tue, 24 Mar 2026 21:34:02 +0000

面试官问：

“平时会收发短信吧？你知道短信里那种 xxxxx 的短链接，点击之后是怎么跳转到长链接的？它是怎么生成的？”

点击短链接后发生了什么？

两个字：重定向。

用户点击短链接

比如用户点击 t.cn/xu0324；

浏览器请求短链接服务器

浏览器向 t.cn 的服务器发送HTTP请求，要访问 /xu0324 这个路径；

服务器查映射关系

服务器去数据库或者Redis里查，发现 xu0324 对应的原始长链接是 https://www.CodeEdge.com/xxx；

服务器返回重定向响应

服务器不返回网页内容，而是返回一个 HTTP 302状态码，并在响应头 Location 里填上原始长链接；

浏览器自动跳转

浏览器收到302状态码，看到 Location 里的长链接，自动发起新的请求，访问原始长链接；

之后，用户就看到了原始长链接的页面。

那个短链接是怎么生成的？

目前主流的生成算法有3种：

自增ID + Base62编码

用分布式ID生成器（比如雪花算法），生成一个全局唯一的自增数字ID（比如 1, 2, 3, …），再把这个10进制的数字ID，转换成62进制的字符串（Base62）。

这种方案因为是自增ID，每个ID对应唯一的Base62字符串，所以绝对唯一，没有哈希冲突，而且不涉及复杂的哈希计算，生成速度极快。

小贴士

什么是Base62呢？平时用的是10进制（0-9），Base62其实是0-9（10个）、a-z（26个）、A-Z（26个），加起来总共62个字符，所以叫Base62。

哈希算法+截取

对原始长链接做MD5或SHA-1哈希，得到一个32位（或更长）的哈希字符串，再截取哈希字符串的前6位或8位，作为短链接后缀。

这种方案对于两个不同的长链接，哈希后的前6位可能会一样，从而导致映射错误；如果发现了冲突，需要换一种截取方式（比如截取中间6位），或者加盐重新哈希，但这样也增加了复杂度。

随机字符串生成

直接随机生成一个6位的Base62字符串，再去数据库里查，如果这个字符串已经被占用了，就重新生成，直到生成一个没有被占用的。

这种方案会随着链接越来越多，冲突概率越来越大，可能要重试很多次才能生成一个可用的；并且高并发下，多个请求可能会同时生成同一个随机字符串，导致数据库唯一键冲突，所以不适合高并发场景。

为什么要用短链接？

1. 短信的字数限制

因为一条短信最多只能发70个汉字（或160个英文字符），如果直接发一个几百个字符的长链接，一条短信根本发不下，要拆成好几条，成本也会相应增加；如果用短链接，只需要十几个字符，就能完美解决字数限制的问题。

2. 防拦截、防屏蔽

长链接里经常包含很多参数，很容易被运营商、手机安全软件识别为“营销链接”或“钓鱼链接”，直接拦截，但如果用短链接的话，看起来很干净，被拦截的概率就会大大降低。

3. 数据统计和追踪

短链接服务器可以记录谁在什么时候、通过什么设备、点击了这个链接，企业通过这些数据，可以分析营销效果、用户画像、转化率等等。

Spring Boot + 通义千问 AI 数据分析助手：一句话生成 SQL + 图表 + 智能结论

Tue, 24 Mar 2026 16:19:59 +0000

需求分析

在数据爆炸的时代，业务人员最痛苦的事就是：不会写 SQL，却每天都要查数据。

我用 Spring Boot 3.2 + 通义千问 API打造了一个AI 数据分析助手，实现了“一句话搞定一切”：

用户输入一句自然语言 → 系统自动解析意图 → 智能生成 SQL → 执行查询 → 自动出图表 + 专业分析结论

项目效果演示

1. 自动生成的 SQL

2. 查询结果数据表

3. ECharts 自动可视化 + 智能结论

技术栈

后端：Spring Boot 3.2 + MyBatis-Plus + JdbcTemplate + FastJSON2 + Lombok
AI：通义千问 Qwen（RestTemplate 调用）
前端：Vue3（CDN）+ Element Plus + ECharts 5（单文件 index.html）
数据库：MySQL 8（附 schema.sql + 200 条演示数据）
其他：SSE 流式响应、动态数据源、SQL 安全正则校验

核心功能

智能 SQL 生成：结合表结构元数据 + Few-Shot Prompt，准确率大幅提升
SQL 安全校验：自动拦截 DROP/DELETE 等危险操作
流式 SSE 实时推送：意图解析 → SQL 生成 → 查询执行 → 结论生成，每一步都有进度条
ECharts 自动适配：柱状图、折线图、饼图、表格智能选择
智能分析结论：通义千问生成 2-3 句专业总结
支持动态数据源：可随时接入企业已有业务数据库

3 步快速上手

下载项目（文末附源码）
配置环境变量：

`1`	`QWEN_API_KEY=你的通义千问密钥`

启动：

1
2

# 先执行 sql/schema.sql 初始化数据库
mvn spring-boot:run

浏览器打开：http://localhost:8080

可以作为学习 LLM + 数据库落地的案例。

完整源码 + schema.sql + 使用文档 已打包好，详见文末。

【面试真题拆解】Java里面的线程池都有哪些参数？

Sun, 22 Mar 2026 15:09:10 +0000

那下一个问题，面试官接着问：

“ Java里面的线程池都有哪些参数？”

我当时就记得“核心线程数、最大线程数”，其他的应该还有5个，支支吾吾答不上来，直接就凉了。

线程池是用来管理线程的，避免频繁创建和销毁线程带来的性能开销。

类比一下工厂招工：

不用线程池

来一个任务就招一个新工人（创建线程），任务干完就辞退（销毁线程），频繁招工辞退，效率极低，还费钱；

用线程池

工厂提前招好一批固定工人（核心线程），任务来了直接让固定工人干，固定工人忙不过来就把任务放待办队列（工作队列），队列也满了就临时招几个临时工（非核心线程），临时工没活干了过段时间就辞退，效率高，还省钱。

线程池的7个核心参数

Java线程池的核心类是 ThreadPoolExecutor，它的构造方法有7个参数：

1. corePoolSize：核心线程数

工厂的正式工数量。

正式工是工厂的“长期工”，默认情况下，就算没活干，也不会被辞退；

任务来了，先让正式工干，正式工没满的话，直接创建正式工执行任务。

2. maximumPoolSize：最大线程数

工厂的正式工+临时工的总数量。

正式工忙不过来，待办队列也满了，就会招临时工；

正式工+临时工的总数，不能超过最大线程数。

3. keepAliveTime：空闲线程存活时间

工厂的临时工没活干的时候，多久会被辞退。

只有临时工（非核心线程）会被回收，正式工（核心线程）默认不会被回收；

但是，如果设置了 allowCoreThreadTimeOut(true)，正式工没活干了，过了这个时间也会被辞退。

4. unit：时间单位

空闲线程存活时间的单位。

比如 TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分钟）、TimeUnit.HOURS（小时）。

5. workQueue：工作队列

工厂的待办任务队列。

正式工（corePoolSize）都在忙，新任务来了就先放进待办队列，等正式工有空了再从队列里拿任务干。

6. threadFactory：线程工厂

给工厂的工人起名字的。

用来创建新线程，给线程设置名字、优先级、是否是守护线程等。

7. handler：拒绝策略

工厂的任务太多了，正式工、临时工、待办队列都满了，怎么处理新任务，就是靠这个参数定义的。

线程池的执行流程

提交新任务

工厂来了一个新任务；

判断核心线程数

先看正式工（corePoolSize）有没有满，没满的话，直接招一个正式工（创建核心线程）执行任务；

判断工作队列

如果正式工满了，就看待办队列（workQueue）有没有满，没满的话，把任务放进队列，等正式工有空了再拿；

判断最大线程数

如果队列也满了，就看正式工+临时工的总数（maximumPoolSize）有没有满，没满的话，招一个临时工（创建非核心线程）执行任务；

执行拒绝策略

如果最大线程数也满了，就执行拒绝策略（handler），处理这个新任务；

任务执行完

线程执行完任务，会从队列里拿下一个任务继续干；

空闲线程回收

如果是临时工（非核心线程），没活干的时间超过了 keepAliveTime，就会被回收（辞退）。

4种默认拒绝策略

拒绝策略	作用	适用场景
AbortPolicy（默认）	直接抛出RejectedExecutionException异常，拒绝执行新任务	对数据一致性要求高的场景，任务不能丢，必须让调用者知道任务被拒绝了
CallerRunsPolicy	由提交任务的线程（调用者线程）自己执行这个任务	对性能要求不高，任务不能丢的场景，比如日志记录
DiscardPolicy	直接丢弃新任务，不抛异常，也不做任何处理	对数据一致性要求不高，丢几个任务没关系的场景，比如非核心的监控数据上报
DiscardOldestPolicy	丢弃队列里最老的任务（等待时间最长的任务），然后把新任务放进队列	对数据一致性要求不高，但想尽量执行新任务的场景

ThreadPoolExecutor 的构造方法

import java.util.concurrent.*;

/**
 * 线程池示例
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 定义线程池的7个核心参数
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5, // corePoolSize：核心线程数（5个正式工）
                10, // maximumPoolSize：最大线程数（5个正式工+5个临时工）
                60, // keepAliveTime：空闲线程存活时间（60秒）
                TimeUnit.SECONDS, // unit：时间单位（秒）
                new ArrayBlockingQueue<>(100), // workQueue：有界队列（容量100）
                Executors.defaultThreadFactory(), // threadFactory：默认线程工厂
                new ThreadPoolExecutor.AbortPolicy() // handler：默认拒绝策略（抛异常）
        );

        // 提交任务
        for (int i = 0; i < 200; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务：" + taskId);
            });
        }

        // 关闭线程池
        threadPool.shutdown();
    }
}

【面试真题拆解】Java的Static关键字到底怎么用？

Sun, 22 Mar 2026 13:06:05 +0000

面试官上来就问：

“ 那个Java里面的Static关键字，一般是怎么用？”

一句话：

Static是“类级别的”，不是“实例级别的”。

被Static修饰的东西，属于整个类，所有实例共用一份，不用new对象就能直接用；

而没被Static修饰的东西，属于单个实例，每个实例有自己的一份，必须new对象才能用。

对比项	静态（Static）	实例（非Static）
归属	属于整个类	属于单个实例
内存位置	方法区（JDK8 之后叫元空间）	堆内存
访问方式	类名.（变量/方法），或（实例.变量/方法）（不推荐）	必须通过实例.变量/方法访问
共享性	所有实例共用一份	每个实例有自己的一份
初始化时机	类加载时初始化	创建实例时初始化
访问限制	只能直接访问静态成员	可以访问静态成员和实例成员

1. 静态变量

静态变量就像是整个类共享的“公共储物柜”，所有实例共用这一个柜子，你放进去的东西，别人也能拿到；而实例变量是每个实例自己的“私人储物柜”，互不干扰。

举个例子，用静态变量做全局计数器

/**
 * 网站访问计数器
 */
public class WebsiteCounter {
    // 静态变量：所有实例共用，统计总访问次数
    public static int totalVisitCount = 0;
    // 实例变量：每个实例自己的，统计单个用户的访问次数
    public int userVisitCount = 0;

    /**
     * 访问方法
     */
    public void visit() {
        // 修改静态变量：总访问次数+1
        totalVisitCount++;
        // 修改实例变量：单个用户访问次数+1
        userVisitCount++;
    }

    public static void main(String[] args) {
        // 用户1访问
        WebsiteCounter user1 = new WebsiteCounter();
        user1.visit();
        user1.visit();
        System.out.println("用户1访问次数：" + user1.userVisitCount); // 输出2
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出2

        // 用户2访问
        WebsiteCounter user2 = new WebsiteCounter();
        user2.visit();
        System.out.println("用户2访问次数：" + user2.userVisitCount); // 输出1
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出3
    }
}

2. 静态方法

静态方法是属于类的“公共工具”，不用new对象，直接通过【类名.方法名】就能调用，而实例方法是属于单个实例的，必须new对象之后才能调用。

举个例子，用静态方法做工具类

/**
 * 字符串工具类
 */
public class StringUtils {
    // 私有构造方法：从根源上禁止外部代码 new StringUtils()
    // 工具类全是静态方法，完全不需要实例化，这样做能强制大家用[类名.方法名]的正确用法
    private StringUtils() {}

    /**
     * 静态方法：判断字符串是否为空
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    /**
     * 静态方法：字符串反转
     */
    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法，不用new对象
        System.out.println(StringUtils.isEmpty("")); // 输出true
        System.out.println(StringUtils.reverse("hello")); // 输出olleh
    }
}

3. 静态代码块

静态代码块是类加载的时候执行一次，且只执行一次的代码块，用来初始化静态变量或者做一些类级别的准备工作（比如加载配置文件、初始化数据库连接池）。

举个例子，用静态代码块初始化静态配置

/**
 * 配置类
 */
public class Config {
    // 静态变量：数据库连接地址
    public static String dbUrl;
    public static String dbUsername;
    public static String dbPassword;

    // 静态代码块：类加载时执行一次，初始化静态变量
    static {
        System.out.println("静态代码块执行，开始初始化配置...");
        // 模拟从配置文件读取配置
        dbUrl = "jdbc:mysql://localhost:3306/test";
        dbUsername = "root";
        dbPassword = "123456";
    }

    // 实例代码块：创建实例时执行，每次new都执行
    {
        System.out.println("实例代码块执行...");
    }

    // 构造方法：创建实例时执行，每次new都执行
    public Config() {
        System.out.println("构造方法执行...");
    }

    public static void main(String[] args) {
        // 第一次访问Config类，触发类加载，静态代码块执行
        System.out.println("数据库地址：" + Config.dbUrl);
        System.out.println("---");
        // new第一个实例，实例代码块和构造方法执行
        new Config();
        System.out.println("---");
        // new第二个实例，实例代码块和构造方法执行，但静态代码块不再执行
        new Config();
    }
}

小贴士

静态代码块只在类第一次被加载时执行一次，之后不管new多少个实例，都不会再执行。

4. 静态内部类

静态内部类是属于外部类的“独立房间”，不用依赖外部类的实例就能直接创建，而非静态内部类是属于外部类实例的“附属房间”，必须先有外部类实例才能创建。

静态内部类的作用是：

利用 Java 的类加载时机，实现了懒加载（用的时候才创建）+ 线程安全（JVM 保证）+ 不用加锁（性能高）的完美单例。

举个例子，用静态内部类实现线程安全的单例模式

/**
 * 单例模式：静态内部类实现
 */
public class Singleton {
    // 私有构造方法：从根源上禁止外部代码直接 new Singleton()
    private Singleton() {}

    // 静态内部类：只有第一次被访问时才会加载（实现懒加载，用的时候才创建实例，不占内存）
    // 因为是在 Singleton 类内部，所以可以访问上面的 private 构造方法
    private static class SingletonHolder {
        // 静态变量：JVM 类加载过程是天然线程安全的，这里初始化唯一的单例实例（不用加锁，性能高）
        private static final Singleton INSTANCE = new Singleton();
    }

    // 全局唯一的访问点：外部代码只能通过这里获取单例实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        // 获取单例实例
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        // 两个实例是同一个，完美实现单例
        System.out.println(instance1 == instance2); // 输出true
    }
}

小贴士

静态变量存放在JVM的方法区（元空间），不是堆内存。
静态变量可以通过【类名.变量名】直接访问，也可以通过【实例.变量名】访问（不过，不推荐，因为容易混淆）。
因为所有线程共用同一个静态变量，多线程同时修改会出现并发问题，需要加锁保证线程安全。
因为实例变量和方法依赖具体的实例，静态方法调用时可能还没new对象，所以，静态方法只能直接访问静态变量和静态方法，不能直接访问实例变量和实例方法。
this 代表当前实例，静态方法属于类，调用时可能还没创建实例，this 根本不存在，所以，静态方法不能用 this。
静态内部类只能直接访问外部类的静态变量和静态方法，不能直接访问实例变量和实例方法。

【面试真题拆解】你知道ThreadLocal是什么吗

Sat, 21 Mar 2026 17:34:29 +0000

ThreadLocal 是线程专属的本地变量，它的设计是给每个线程创建一份独立的变量副本，线程之间完全不共享数据，天然实现线程隔离，全程无锁竞争，性能远高于加锁保证线程安全的方案。

每个 Thread 内部都有一个专属的成员变量 ThreadLocalMap（不是 ThreadLocal 的！），Key 是 ThreadLocal 实例本身（弱引用），Value 是存的变量（强引用）。

官话太多，直接上例子。

以用户上下文传递举个例子

/**
 * 用户上下文工具类
 * 用ThreadLocal存当前登录用户的ID，避免层层传参
 */
public class UserContextHolder {
    // 定义ThreadLocal，存用户ID
    private static final ThreadLocal<Long> USER_ID_THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 设置用户ID
     */
    public static void setUserId(Long userId) {
        USER_ID_THREAD_LOCAL.set(userId);
    }

    /**
     * 获取用户ID
     */
    public static Long getUserId() {
        return USER_ID_THREAD_LOCAL.get();
    }

    /**
     * 必须手动调用！清理ThreadLocal，防止内存泄漏
     */
    public static void clear() {
        USER_ID_THREAD_LOCAL.remove();
    }
}

和加锁保证线程安全的区别

对比项	加锁	ThreadLocal
思想	多线程排队用同一个变量，保证同一时间只有一个线程能访问	每个线程用自己的专属变量，完全不共享
性能	有锁竞争，高并发下性能差	无锁竞争，性能高
适用场景	多线程必须共享同一个变量的场景（比如共享计数器、共享资源修改）	每个线程需要独立变量副本的场景（比如用户上下文、SimpleDateFormat 线程安全）

小贴士

很多人以为ThreadLocalMap的Key是“线程ID”，其实Key是ThreadLocal实例本身，而不是线程ID。

一个线程可以有多个ThreadLocal实例，每个实例对应一个Value，存到同一个ThreadLocalMap里，Key不同，互不干扰。

ThreadLocal内存泄漏问题

Java中的4种引用强度

强引用

我们平时写的 Object obj = new Object() 就是强引用，只要强引用还在，GC就不会回收这个对象。

软引用

用 SoftReference 包装的引用，只有当内存不够用的时候，GC 才会回收这个对象。

弱引用

用 WeakReference 包装的引用，只要GC一运行，不管内存够不够，都会回收这个对象。

虚引用

用 PhantomReference 包装的引用，完全不影响对象的生命周期，只是用来在对象被 GC 回收前收到一个通知，做一些收尾工作。

ThreadLocalMap的Entry结构

ThreadLocalMap的Entry是继承自WeakReference的，结构如下：

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k); // Key是弱引用
        value = v; // Value是强引用
    }
}

假设创建了一个 ThreadLocal 实例，有外部强引用指向它，同时把它作为 Key 存到了线程的 ThreadLocalMap 里；

当用完 ThreadLocal 后，没有手动 remove，而且外部的强引用也没了（比如 threadLocal = null），因为 Key 是弱引用，GC 一运行，Key 就被回收了，变成了 null。

但是， Value 是强引用，只要线程还活着，Value 就不会被 GC 回收，这就导致了内存泄漏。

更严重的还有，如果用了线程池，线程会被长期复用，不仅内存泄漏，还会导致用户信息串号、数据错误等严重的业务问题。

怎么避免内存泄漏

使用完ThreadLocal后，手动调用 remove() 方法。

举个例子，在Spring Boot的拦截器里：

@Component
public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从Token里解析出用户ID，存到ThreadLocal
        Long userId = parseUserIdFromToken(request.getHeader("Authorization"));
        UserContextHolder.setUserId(userId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 在这里清理，不管请求成功失败，都要清理。
        UserContextHolder.clear();
    }
}

【面试真题拆解】被问懵的计算机网络7层_5层_4层模型

Sat, 21 Mar 2026 09:04:13 +0000

好几次面试都被问了计算机网络模型，一次是让我讲讲7层模型，还有让我讲讲5层模型，4层模型的。

这群面试官完全不按套路出牌，昨天刚问完 7 层模型，今天就换成了 4 层模型。

我当场脑子一片空白，支支吾吾说不清楚，直接就凉了。

首先，为什么会有三个版本？

且看：

7层模型（OSI参考模型）

这是国际标准化组织定的理论学术标准，是网络分层的“祖宗”，但实际互联网几乎不用。

4层模型（TCP/IP模型）

互联网实际在用的工业落地标准，我们现在上网、写代码用的HTTP、TCP、IP，全是基于这个模型跑的，是真正“干活”的模型。

5层模型（教材简化模型）

国内计算机教材最常用的简化教学版，把4层模型的最底层拆成了2层，方便理解学习。

面试的时候，不管面试官问哪个模型，可以先把下面这张对应关系表讲出来，这样就能把三个模型的边界划清楚，也不容易搞混。

7 层 OSI 参考模型	5 层教材简化模型	4 层 TCP/IP 工业模型	作用
应用层	应用层	应用层	给用户/应用提供服务，比如浏览器、APP
表示层	（合并到应用层）	（合并到应用层）	数据加密、格式转换、统一编码
会话层	（合并到应用层）	（合并到应用层）	建立和维持应用之间的会话连接
传输层	传输层	传输层	给数据标端口，控制端到端的传输方式
网络层	网络层	网际层	给数据标 IP，规划端到端的传输路线
数据链路层	数据链路层	网络接口层	给数据标 MAC 地址，相邻节点之间的传输
物理层	物理层	（合并到网络接口层）	电信号、光信号的物理传输

7层OSI参考模型

7. 应用层

应用层主要是给用户/应用提供可操作的服务，定义数据的业务含义。

统称为消息/报文 (Message)。

我们写代码天天接触的HTTP、HTTPS、DNS、FTP、WebSocket、RPC协议，全在这一层。

浏览器发请求、APP调接口，都是在应用层完成的。

6. 表示层

表示层主要是统一数据格式，保证收发双方能看懂对方的数据，核心负责数据的加密解密、格式转换、压缩解压、编码统一。

理论上 OSI 模型把加密解密放在表示层；

但在实际 TCP/IP 模型中，TLS/SSL 属于应用层实现，工作在应用层与传输层之间。

5. 会话层

会话层主要是管理应用之间的会话，保证数据不会串线。

负责建立、维持、有序断开应用之间的会话连接，提供会话同步、全双工 / 半双工切换等管理能力；

该层仅存在于 OSI 理论模型中，实际 TCP/IP 体系中无独立对应层，相关会话逻辑由应用层 + 传输层共同实现。

4. 传输层

传输层是端到端的传输控制，保证数据能准确送到对应的应用程序。

数据单位称为段 (Segment)。

TCP（可靠传输）、UDP（不可靠传输），还有端口号（HTTP的80端口、HTTPS的443端口），都在这一层。

3. 网络层

作用是网络寻址和路由选择，保证数据能从源主机送到目标主机。

数据单位称为包 (Packet) 或分组。

IP 协议（IPv4/IPv6）、ARP（IP 转 MAC 地址）、ICMP（ping/tracert 命令）、OSPF/RIP 路由协议，都在这一层。

2. 数据链路层

相邻节点之间的可靠传输，负责成帧 (Framing)、差错检测和流量控制。

数据单位称为帧 (Frame)。
MAC地址、以太网协议、交换机转发，都在这一层。

给 IP 数据包加上 MAC 头部，标上源 MAC 和下一跳的 MAC 地址，保证相邻节点之间能准确传输。

1. 物理层

物理介质上的比特流传输。只负责传输0和1的比特流，不管数据是什么含义。

数据单位称为比特 (Bit)。

网线、光纤、网卡、集线器、电信号、光信号，都在这一层。

4层TCP/IP模型

OSI模型太理想化、太复杂，实际互联网落地的时候，做了两层合并，就成了现在真正在用的4层模型：

应用层：合并了OSI的应用层+表示层+会话层
传输层：同OSI的传输层
网际层：同OSI的网络层
网络接口层：合并了OSI的数据链路层+物理层

我们现在上网、写代码的所有网络请求，全是跑在这个4层TCP/IP模型上的，是真正的工业标准。

5层教材简化模型

国内教材为了兼顾教学易懂性和底层逻辑完整性，以 OSI 7 层模型为基础做简化，保留应用层、传输层、网络层，同时将底层拆分为数据链路层 + 物理层，形成了教学通用的 5 层简化模型。

这个模型既保留了底层的物理传输逻辑，又简化了上层的复杂分层。

举个例子

在浏览器输入网址，到页面显示出来，经过了网络模型的哪些层？

(1)客户端发送请求（从上到下封装数据包）

应用层

浏览器解析网址，先通过 DNS 协议解析域名，拿到服务器的 IP 地址，再生成对应的 HTTP 请求。

传输层

先通过三次握手与服务器建立 TCP 连接，再给 HTTP 请求加上 TCP 头部，标上源端口和目标端口，完成传输层封装。

网络层

给TCP数据包加上IP头部，标上源IP和目标IP，路由器根据IP地址规划路由，找到服务器的网络地址。

数据链路层

给IP数据包加上MAC头部，标上源MAC和下一跳的MAC地址，交换机根据MAC地址完成相邻节点转发。

物理层

把数据包转换成电信号/光信号，通过网线、光纤、基站等物理介质，传输到目标服务器。

(2)服务器接收并处理请求（从下到上解析数据包）

服务器收到数据后，从下到上逐层解包：物理层➡️数据链路层➡️网络层➡️传输层➡️应用层，最终解析 HTTP 请求、执行业务逻辑并返回响应。

(3) 客户端渲染页面

浏览器收到响应后，解析HTML/CSS/JS，渲染页面并显示给用户。

每层对应的协议

层级名称	协议
应用层	HTTP、HTTPS、DNS、FTP、SMTP（邮件发送）、POP3/IMAP（邮件接收）、WebSocket、SSH、Dubbo 等 RPC 协议
传输层	TCP（可靠传输）、UDP（不可靠传输）
网络层	IPv4、IPv6、ARP（IP 转 MAC 地址）、ICMP（ping/tracert）、OSPF、RIP 等路由协议
数据链路层	以太网协议、PPP 点对点协议、VLAN 协议、MAC 地址规范
物理层	无专属网络协议，相关规范：网线、光纤、网卡、集线器、RJ45 接口

小贴士：

ARP 协议逻辑上属于网络层（核心为 IP 协议提供地址解析服务，是 TCP/IP 网际层的核心配套协议），仅从报文封装形式来看，它被直接封装在以太网帧中，因此也有观点认为它属于数据链路层。

【面试真题拆解】5秒内限10次HTTP接口访问，结合数据结构和算法说说你的思路

Fri, 20 Mar 2026 15:00:00 +0000

面试官问：

做Web项目的时候，会暴露出一些HTTP接口，我现在想对它进行限流，限制5秒内只能访问10次，结合数据结构和算法，看如何实现，说说你的思路

当时只说了个滑动窗口就没说其他的，然后就没有然后了。。。

首先，为什么要限流？

主要有以下三个原因：

防止恶意刷接口，比如爬虫爬数据、黑客DDoS攻击。
保护服务器不被压垮，比如一个接口挂了，拖垮整个服务。
保证核心业务的可用性，比如大促场景下，支付接口优先，对普通接口进行限流。

技术选型

方案	数据结构+算法	核心思想	优缺点	适用场景
固定窗口计数器	数组/Map + 时间戳	把时间分成固定的窗口，每个窗口内计数	简单易实现；有临界问题（比如4.9秒刷10次，5.1秒又刷10次，实际0.2秒内刷了20次）	对精度要求不高的场景
滑动窗口计数器	本地：LinkedList（双向链表）分布式：Redis ZSet（有序集合） + 时间戳	窗口是“滑动”的，只保留当前窗口内的请求	解决了固定窗口的临界问题；本地版 LinkedList 删头加尾 O (1)，分布式版 ZSet 按时间范围操作高效；本地版不适合分布式集群	固定时间窗口内精确计数的场景
漏桶算法	队列 + 定时器	像漏桶一样，请求先存到队列里，然后匀速处理	可以削峰填谷；突发流量处理不了（秒杀时很多请求直接被拒）	对流量稳定性要求高的场景（比如消息队列）
令牌桶算法	队列 + 定时器	像令牌桶一样，匀速生成令牌，请求拿到令牌才能通过	可以削峰填谷，也可以处理突发流量	对流量稳定性和突发流量都有要求的场景（比如API网关）

滑动窗口计数器

滑动窗口的核心，是窗口不再是静止分段的，而是随当前时间连续移动、互相重叠的：

比如固定窗口，窗口是死的，0-5秒、5-10秒，边界固定不变。

而滑动窗口，窗口的右边界永远是当前请求的时间，左边界永远是当前时间 - 窗口大小，窗口会跟着每一次请求一直往前滑。

数据结构选型

本地：LinkedList（双向链表）

选择双向链表是因为我们需要频繁删除链表头部的过期时间戳，并且还需要频繁在链表尾部新增新的请求时间戳，而双向链表的删头、加尾操作时间复杂度都是O(1)，效率极高。

分布式：Redis ZSet（有序集合）

Web项目基本都是集群部署，本地计数器无法多实例同步，考虑用Redis实现。

选择Redis中的ZSet数据结构，ZSet的score字段可以存请求的时间戳，天然支持按时间范围排序。

实现逻辑

每次请求进来，执行 3 步：

删掉所有早于当前时间 - 窗口大小的请求
统计当前窗口内的请求数，超过 10 次直接拒绝
把当前请求的时间戳加入数据结构，放行请求

小贴士

令牌桶的令牌生成速度要合理

不能太快（等于没限流），也不能太慢（很多请求被拒），要根据业务场景调整。

Redis ZSet的过期时间要设置对

要设置成窗口大小+一点缓冲（比如1秒），防止数据提前过期，导致计数不准确。

【面试真题拆解】Spring事务机制

Fri, 20 Mar 2026 09:06:26 +0000

之前面试的时候还真的有一个面试官问过我：

什么是事务？

事务，说人话就是：

把多个数据库操作打包成一个“不可分割的整体”，要么全成功，要么全失败并回滚到最初状态，绝对不会出现“只做了一半”的情况。

以生活中最经典的银行转账举个例子那是再合适不过了。

且看：

A给B转100块钱，这一笔转账业务，其实是由两步独立的数据库操作组成的：

A的账户扣100块

B的账户加100块

这两步必须同时成功、一起生效。

如果A扣了钱B没收到，或者B收到了钱A没扣，那银行就乱套了。

事务的四大特性

用银行转账的例子加深理解：

特性	解释	银行转账例子
原子性（Atomicity）	要么全做，要么全不做，就像“原子”一样不可分割	A扣钱和B加钱必须同时成功，不能A扣了B没加
一致性（Consistency）	事务前后，数据要保持“一致”，总金额不变	转账前A有1000，B有0，总和是1000；转账后A有900，B有100，总和还是1000
隔离性（Isolation）	多个事务同时执行时，互相不干扰，就像“隔离开”一样	两个转账操作同时改A的账户，不能互相影响，不然钱就不对了
持久性（Durability）	事务提交后，数据就永久保存了，就算数据库挂了也不会丢	转账成功后，就算银行服务器断电重启，A和B的钱数也不会变

隔离级别

为什么要有隔离级别呢？

如果多个事务同时执行，没有隔离的话，会出现3个问题：

脏读

脏读就是读到了别人还没提交的数据。

比如A转给B100块，还没提交，B就查到自己多了100块，结果A回滚了，B白高兴一场。

不可重复读

不可重复读的意思是同一个事务里，两次读同一条数据的结果是不一样的。

比如A查自己有1000块，中间B转给了A100块提交了，A再查就变成1100了。

幻读

幻读就是同一个事务里，两次查的数量不一样。

比如A查账户里有10条记录，中间B插了一条提交了，A再查就变成11条了，就像“幻觉”一样。

这么看，不可重复读和幻读是由别的事务提交后导致的错误，而脏读是读到了别人还没提交的临时数据。

那不可重复读和幻读两者的区别在哪呢？

不可重复读是盯着一条记录看，发现这条记录的内容变了。

而幻读是盯着一堆记录数看，发现总数量变了。

类比一下就是不可重复读是你看自己的银行卡余额，钱数变了；而幻读是你数银行有多少张卡，卡的数量变了。

隔离级别	解决的问题	解释
读未提交（Read Uncommitted）	啥都解决不了	能读到别人没提交的数据，脏读、不可重复读、幻读都有，一般不用
读已提交（Read Committed）	脏读	只能读到别人提交后的数据，但会有不可重复读、幻读
可重复读（Repeatable Read）	脏读、不可重复读	Spring默认的隔离级别。同一个事务里，两次读同一个数据一样，但会有幻读（MySQL InnoDB用MVCC解决了幻读）
串行化（Serializable）	所有问题	事务一个接一个执行，就像“排队”一样，性能最差，一般不用

传播行为

传播行为就是：

当一个事务方法调用另一个事务方法时，这两个事务该怎么协作？是直接加入原事务？还是新建一个独立的事务？还是先挂起原事务，等新事务执行完再继续？

以下是3 个常用的传播行为:

传播行为	解释	适用场景
REQUIRED（默认）	有事务就加入，没有就新建一个事务	最常用，比如转账服务
REQUIRES_NEW	新建一个事务，挂起原事务，等新事务执行完再继续原事务	比如记录日志，不管主事务成功失败，日志都要记录
NESTED	嵌套事务，有一个保存点： 1. 子事务回滚：只回滚自己，不影响父事务和其他子事务 2. 父事务回滚：带着所有子事务一起回滚	系统批量发福利：某一个用户的福利发放失败，不影响其他用户；但整体回滚，所有用户的福利都会被收回

小贴士

Spring AOP 是基于代理的，@Transactional 只能用在 public 方法上，不然不生效。不管是 JDK 动态代理还是 CGLIB 代理，Spring 都只保证 public 方法的事务生效，非 public 的写了也白写。
内部调用不会走代理类，直接调用this.method()，所以，同一个类里方法调用，@Transactional不生效。
Spring默认只回滚非受检异常（RuntimeException、Error），受检异常（Exception）不回滚。如果要所有异常都回滚，需要在 @Transactional 里加rollbackFor = Exception.class。
MySQL的MyISAM引擎不支持事务，只有InnoDB支持。

告别腾讯云 COS，用 GitHub + jsDelivr 搭建零成本图床

Thu, 19 Mar 2026 17:10:48 +0000

我的个人项目中有这么一个功能，就是个人作品页面需要显示详情页的预览截图，这样会显得更专业一点。

但是，截图之前是存在腾讯云COS中的，最近我的腾讯云 COS 到期了，我就开始寻找替代方案。

想换 Cloudflare R2 吧，听说很香零费用，结果还要信用卡验证，我这种没有国际信用卡的人直接被拒之门外。

经过一番调研和实践，我锁定了一个纯白嫖、零成本、高速度的方案：

GitHub 仓库存储 + jsDelivr CDN 加速

本文将介绍一下如何在 Spring Boot 项目中集成这一方案。

技术选型

维度	腾讯云 COS	GitHub + jsDelivr
存储费用	按量计费/资源包（需续费）	完全免费 (建议单仓库 < 1GB，单文件 < 50MB，GitHub 有软限制)
流量费用	下行流量贵（容易被盗链刷爆）	完全免费 (jsDelivr 提供的全球加速)
支付门槛	需实名、绑定支付方式	仅需一个 GitHub 账号
国内访问	速度快，但费钱	通过 jsDelivr 加速，速度极快

准备工作

创建一个新的公开仓库（Public），例如 ObjectStorage。
生成 Personal Access Token (PAT)

在Github账户进入【Settings】➡️【Developer settings】➡️【Personal access tokens】➡️【 Tokens (classic)】。

小贴士

创建Token时必须要勾选 repo 权限，并且创建的时候就得保存好生成的 Token，因为它只会出现一次。

图片截图上传成功后，访问链接格式为：
https://cdn.jsdelivr.net/gh/用户名/仓库名@分支名/文件路径

代码实现

引入依赖

需要 OkHttp 处理网络请求，FastJSON 处理 JSON 数据。

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>

application-local

为了开源安全，将敏感信息放在 application-local.yml 中，并确保该文件在 .gitignore 中。

# application-local.yml
github:
  owner: github用户名
  repo: ObjectStorage
  branch: main
  token: ghp_你的TOKEN

GithubConfig

讲原CosConfig加上@Deprecated，新增GithubConfig

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "github")
public class GithubConfig {
    private String owner;
    private String repo;
    private String branch;
    private String token;
}

GithubManager

为了模仿对象存储的 SDK，将文件转为 Base64 并调用 GitHub API 进行 PUT 上传。

将原CosManager加上@Deprecated，新增GithubManager

@Component
@Slf4j
public class GithubManager {

    @Resource
    private GithubConfig githubConfig;

    private final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(15, TimeUnit.SECONDS)
            .readTimeout(15, TimeUnit.SECONDS)
            .build();

    /**
     * 上传文件到 GitHub 仓库
     *
     * @param key  存储路径
     * @param file 本地文件
     * @return jsDelivr CDN 访问地址
     */
    public String uploadFile(String key, File file) {
        // 1. 读取文件并转为 Base64
        byte[] fileBytes = FileUtil.readBytes(file);
        String base64Content = Base64.getEncoder().encodeToString(fileBytes);

        // 2. 构建 GitHub API 请求体
        JSONObject json = new JSONObject();
        json.put("message", "upload screenshot: " + file.getName());
        json.put("content", base64Content);
        json.put("branch", githubConfig.getBranch());

        // 注意：GitHub API 路径开头不能有 /
        if (key.startsWith("/")) {
            key = key.substring(1);
        }

        String url = String.format("https://api.github.com/repos/%s/%s/contents/%s",
                githubConfig.getOwner(), githubConfig.getRepo(), key);

        RequestBody body = RequestBody.create(
                json.toJSONString(),
                MediaType.parse("application/json; charset=utf-8")
        );

        Request request = new Request.Builder()
                .url(url)
                .addHeader("Authorization", "token " + githubConfig.getToken())
                .put(body)
                .build();

        // 3. 发送请求
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                // 返回 jsDelivr CDN 链接
                return String.format("https://cdn.jsdelivr.net/gh/%s/%s@%s/%s",
                        githubConfig.getOwner(),
                        githubConfig.getRepo(),
                        githubConfig.getBranch(),
                        key);
            } else {
                log.error("GitHub 上传失败, 错误码: {}, 详情: {}", response.code(), response.body().string());
                return null;
            }
        } catch (IOException e) {
            log.error("GitHub 上传网络异常", e);
            return null;
        }
    }
}

GithubScreenshotServiceImpl

为了保留原ScreenshotServiceImpl的逻辑，新增一个GithubScreenshotServiceImpl同样也实现ScreenshotService 接口。

/**
 * GithubScreenshotServiceImpl类实现了ScreenshotService接口，提供网页截图生成并上传到 GitHub 的服务
 */
@Service("githubScreenshotService") // 指定 Bean 名称，防止和原 COS 实现冲突
@Slf4j
public class GithubScreenshotServiceImpl implements ScreenshotService {

    @Resource
    private GithubManager githubManager; // 注入新写的 GithubManager

    @Override
    public String generateAndUploadScreenshot(String webUrl) {
        ThrowUtils.throwIf(StrUtil.isBlank(webUrl), ErrorCode.PARAMS_ERROR, "网页URL不能为空");
        log.info("开始生成网页截图(GitHub方案)，URL:{}", webUrl);

        // 1. 调用工具方法保存网页截图到本地
        String localScreenshotPath = WebScreenshotUtils.saveWebPageScreenshot(webUrl);
        ThrowUtils.throwIf(StrUtil.isBlank(localScreenshotPath), ErrorCode.OPERATION_ERROR, "本地截图生成失败");

        try {
            // 2. 调用方法将本地截图上传到 GitHub
            String githubUrl = uploadScreenshotToGithub(localScreenshotPath);
            ThrowUtils.throwIf(StrUtil.isBlank(githubUrl), ErrorCode.OPERATION_ERROR, "截图上传 GitHub 失败");

            log.info("网页截图生成并上传 GitHub 成功: {} -> {}", webUrl, githubUrl);
            return githubUrl;
        } finally {
            // 3. 清理本地文件
            cleanupLocalFile(localScreenshotPath);
        }
    }

    private String uploadScreenshotToGithub(String localScreenshotPath) {
        if (StrUtil.isBlank(localScreenshotPath)) {
            return null;
        }

        File screenshotFile = new File(localScreenshotPath);
        if (!screenshotFile.exists()) {
            log.error("截图文件不存在: {}", localScreenshotPath);
            return null;
        }

        // 生成文件名
        String fileName = UUID.randomUUID().toString().substring(0, 8) + "_compressed.jpg";
        // 生成 GitHub 存储路径
        String githubKey = generateScreenshotKey(fileName);

        // 调用 GitHub 管理器
        return githubManager.uploadFile(githubKey, screenshotFile);
    }

    private String generateScreenshotKey(String fileName) {
        String datePath = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
        // 注意：GitHub 路径不建议以 / 开头
        return String.format("screenshots/%s/%s", datePath, fileName);
    }

    private void cleanupLocalFile(String localFilePath) {
        File localFile = new File(localFilePath);
        if (localFile.exists()) {
            File parentDir = localFile.getParentFile();
            FileUtil.del(parentDir);
            log.info("本地截图临时文件已清理: {}", localFilePath);
        }
    }
}

小贴士

这里有一个问题需要注意，@Deprecated 只是给程序员看的“警告”标签，它并不能阻止 Spring 扫描并加载这个 Bean。

所以，为了避免Spring 在启动时发现有两个类都实现了 ScreenshotService 接口，并且都加上了 @Service 注解。

当其他地方需要注入 ScreenshotService 时，Spring 不知道该选哪一个的问题。

需要在ScreenshotServiceImpl类中添加@Deprecated 的同时，把@Service 注解注释掉。

// @Service  <-- 把这个注释掉，Spring 就不会把它当成一个 Bean 加载了
@Slf4j
@Deprecated
public class ScreenshotServiceImpl implements ScreenshotService {
    // ... 原有的代码
}

之后项目的预览界面就可以看到截图了：

23种设计模式，一次性讲明白

Thu, 19 Mar 2026 12:50:01 +0000

设计模式其实就是前辈们写代码踩了无数坑，总结出来的代码编写最佳实践，专门用来解决特定场景下的代码复用、解耦、扩展性问题。

可以分为创建型模式、结构型模式、行为型模式三类。

分类	核心作用	包含的设计模式	数量
创建型模式	解决对象怎么创建的问题，解耦对象的创建和使用	单例、工厂方法、抽象工厂、建造者、原型	5种
结构型模式	解决类/对象怎么组合的问题，不修改原有代码实现功能扩展	适配器、桥接、组合、装饰、外观、享元、代理	7种
行为型模式	解决类/对象之间怎么交互、职责怎么分配的问题，实现灵活的通信和流程控制	模板方法、命令、迭代器、观察者、中介者、备忘录、解释器、状态、策略、职责链、访问者	11种

记忆口诀

创建型口诀（5种）

单身汉在工厂抽象建原型。

一个单身汉，在工厂里用抽象方法，建造了一个原型。

结构型口诀（7种）

桥上代理卖装饰，组合适配享外观。

桥上的代理商在卖装饰品，把零件组合适配好，让你享受精美外观。

行为型口诀（11种）

访客观察定策略，模板迭代改状态，备忘命令交中介，解释责任一条链。

访客观察后定下策略，按模板迭代改变状态，把备忘录和命令交给中介，出了问题沿责任链逐一解释。

创建型模式

不让你自己new对象，把对象创建的逻辑封装起来，和业务代码解耦。

1. 单例模式

整个系统里，这个类有且只有一个实例对象，不管你在哪获取，拿到的都是同一个东西。

类比

就像公司里只有一个 CEO，不管哪个部门找，对接的都是同一个人。

适用场景

Spring容器里的单例Bean、全局配置类、日志对象

代码示例

public class Singleton {
    // 1. 私有构造方法：禁止外部new对象
    private Singleton() {}

    // 2. 私有静态实例，volatile禁止指令重排
    private static volatile Singleton instance;

    // 3. 公共静态方法，获取唯一实例
    public static Singleton getInstance() {
        // 第一次校验：实例已存在就直接返回，不用抢锁
        if (instance == null) {
            // 加锁，保证线程安全
            synchronized (Singleton.class) {
                // 第二次校验：防止多线程同时进入第一个if，重复创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂方法模式

定义一个创建对象的工厂接口，让子类决定创建哪个对象，把对象的创建延迟到子类。

类比

就像奶茶店是工厂接口，蜜雪冰城、喜茶是子类工厂，你去哪个店，就喝哪个店的奶茶，不用管奶茶是怎么做的。

适用场景

不知道要创建的对象具体类型，交给子类决定
把对象创建和业务代码解耦
Spring的FactoryBean

代码示例

// 1. 产品接口：奶茶
public interface MilkTea {
    void make();
}

// 2. 具体产品：蜜雪冰城奶茶
public class MixueMilkTea implements MilkTea {
    @Override
    public void make() {
        System.out.println("蜜雪冰城奶茶做好了！");
    }
}

3. 抽象工厂模式

工厂方法的升级版，一个工厂可以创建一系列相关的产品，而不是只创建一个。

和工厂方法的区别是：

工厂方法是单个产品，而抽象工厂是一套相关产品。

类比

就像蜜雪冰城不仅能做奶茶，还能做冰淇淋、圣代，一个工厂搞定同品牌的一系列产品。

适用于需要创建一系列相关联的产品，而不是单个产品的场景（比如同一品牌的奶茶 + 冰淇淋 + 圣代）。

4. 建造者模式

把一个复杂对象的创建和表示分离，一步一步构建出复杂对象，不用管内部组装细节。

类比

就像组装电脑，你只需要告诉装机店你要什么 CPU、显卡、内存，装机店帮你一步步组装好，不用你自己焊主板。

适用场景

复杂对象的创建，参数特别多（比如超过4个参数）
Lombok的@Builder注解

代码示例

// 电脑类（复杂对象）
public class Computer {
    private String cpu;
    private String gpu;
    private int memory;
    private int storage;

    // 私有构造方法，只能通过Builder创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.memory = builder.memory;
        this.storage = builder.storage;
    }

    // 建造者静态内部类
    public static class Builder {
        private String cpu;
        private String gpu;
        private int memory;
        private int storage;

        // 链式调用设置参数
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder memory(int memory) {
            this.memory = memory;
            return this;
        }

        public Builder storage(int storage) {
            this.storage = storage;
            return this;
        }

        // 构建最终对象
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 链式调用，一步一步构建对象
        Computer computer = new Computer.Builder()
                .cpu("i7-14700K")
                .gpu("RTX4070")
                .memory(32)
                .storage(1024)
                .build();
    }
}

5. 原型模式

基于一个已有的对象，克隆出一个一模一样的新对象，不用重新new和初始化。

类比

就像打印机复印文件，不用重新手写一遍，直接复印一份一模一样的。

适用场景

对象创建成本很高（比如初始化要查数据库、调接口）
想要和原对象一模一样的新对象，又不想重新初始化
Spring的Bean的原型作用域

就像出行，你可以选骑自行车、坐地铁、开车、坐飞机，这些都是不同的出行策略，你可以根据目的地、预算随便换，不用改变你要出门的目标。

适用场景

一个业务有多种实现方式，需要动态切换
想要避免大量的if-else/switch分支
Spring的Resource接口、BeanNameGenerator

代码示例

// 1. 策略接口：出行方式
public interface TravelStrategy {
    void travel();
}

// 2. 具体策略：坐地铁
public class SubwayStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("坐地铁出行，便宜又快");
    }
}

// 3. 具体策略：开车
public class CarStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("开车出行，自由方便");
    }
}

// 4. 用户
public class Traveler {
    private TravelStrategy strategy;

    // 动态设置策略
    public void setStrategy(TravelStrategy strategy) {
        this.strategy = strategy;
    }

    // 执行出行
    public void goTravel() {
        strategy.travel();
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Traveler traveler = new Traveler();
        // 今天坐地铁
        traveler.setStrategy(new SubwayStrategy());
        traveler.goTravel();
        // 明天开车
        traveler.setStrategy(new CarStrategy());
        traveler.goTravel();
    }
}

2. 观察者模式

定义了对象之间一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。

类比

就像你关注了一个技术博主，博主更新文章了，所有关注他的粉丝都会收到推送通知。

适用场景

事件驱动、消息通知、发布订阅
Spring的ApplicationEvent事件机制
Java的EventListener

适用场景

对象的行为由状态决定，运行时状态变化会改变行为
代码里有大量和状态相关的if-else/switch分支

小贴士

状态模式和策略模式容易混淆，不过两者的区别是：

状态模式是状态决定行为，对象的行为由当前状态决定；而策略模式是算法可替换，封装一系列平级算法，想换哪个换哪个。
状态模式有明确的状态流转图，状态之间不能随便跳，必须按规则流转；策略模式没有流转关系，策略之间是平级的，想换就换。
状态模式关注的是对象状态的变化以及状态变化带来的行为变化；策略模式关注的是算法的选择和替换，不关心算法之间的关系。

扯了那么多官话，好像没多大用，举个例子套一下大概就是：

比如电梯是状态模式，开门、上下行、关门有明确的流转规则；

撤销、回滚操作
数据库的事务回滚
IDE的撤销操作

10. 访问者模式

在不修改数据结构的前提下，定义对数据结构中元素的新操作，把数据结构和操作分离。

类比

比如电商订单系统，数据结构是固定的订单和订单明细，操作是经常变化的计算总价、打印发票、生成物流单、发送短信通知。不用修改订单 / 订单明细的代码，只要新增一个访问者（比如生成电子发票），就能给订单增加新操作。

适用于想要给数据结构里的元素增加新操作，又不想修改数据结构的场景。

11. 解释器模式

给定一个语言，定义它的语法规则，然后定义一个解释器，用这个解释器来解释语言中的句子。

类比

就像翻译官，你说中文，翻译官根据中英文的语法规则，把你的话翻译成英文。

适用场景

SQL解析、正则表达式解析
Spring的SpEL表达式

【面试真题拆解】电商高并发场景下商品详情页系统设计

Wed, 18 Mar 2026 12:32:01 +0000

很多面试官早就对“Redis缓存、MySQL分库分表”这些东西形成免疫了，他们更想要听到的是一个完整的链路，比如从服务到数据、从接入到落地的全流程设计。

当时面试官问我：

一家电商公司，它主要是面向消费者的，公司的一些业务场景流量会很高，比如说展示商品的那个页面，它的流量就很高，假设现在由你来做这个系统，负责商品详情页的展示，你能从服务的层面，数据的层面等多个维度来设计一下，让它能够支持一个更高的查询能力。

场景梳理

业务背景
电商商品详情页，面对百万级QPS的高并发流量（比如大促、爆款商品）。

需求分析

性能：支持高并发查询，响应时间 < 100ms
一致性：商品价格、库存、标题修改后，能及时更新
高可用：服务挂了、Redis挂了，系统不崩
可扩展：新增商品、新增规格，能快速接入

关键数据
商品基本信息（标题、主图、详情图）、价格（实时/活动）、库存、规格参数、促销信息（优惠券/秒杀）、评价统计。

设计思路

以“多级缓存”为核心，配合“服务分层+数据分层+异步更新”，构建“读多写少”的高并发详情页系统。

系统架构

服务层面

采用前后端分离+网关层+服务分层架构：

层级	作用
CDN层	静态资源加速（图片、js、css、详情页HTML）
网关层	路由、限流、鉴权、接口聚合
API网关聚合层	聚合多个微服务接口（比如商品基础信息、价格、库存、评价），减少请求次数
商品服务层	核心业务逻辑（查商品、查库存、查价格）
数据服务层	专门做数据查询（缓存+数据库）

商品详情页是典型的读多写少场景，考虑服务层本地缓存 + 分布式缓存。

采用Caffeine作为服务层本地缓存，缓存极热点商品（比如爆款商品），避免每次请求都走Redis，

采用Redis作为分布式缓存，作为核心缓存层，缓存所有商品的详情数据。

调用流程：

先查本地缓存（Caffeine），如果命中就直接返回；

如果本地未命中，查 Redis，命中则写入本地缓存，返回；

如果Redis 未命中，查数据库，查到则写入 Redis + 本地缓存，返回。

数据层面

商品数据分为3类，不同类型用不同策略：

数据类型	例子	缓存策略
静态数据	商品标题、主图、详情图、规格参数	永久缓存（不过期），更新时主动删除
半动态数据	商品价格、促销信息（优惠券、满减）	短期缓存（5-10分钟），更新时主动删除
动态数据	库存（实时）、实时销量	单独缓存，库存用Redis原子操作；实时销量异步更新

缓存更新的原则：

为了避免高并发下的缓存不一致问题，采用的是先更新数据库，再删除缓存的方式。

高并发优化

1.热点数据预热

大促前，把热门商品（如销量TOP100）写入Redis和本地缓存。

限流+熔断+降级

对商品详情接口设置限流。

考虑使用服务熔断，当Redis/数据库不可用时，快速失败，避免系统雪崩。

或者考虑使用降级策略，当Redis挂了，降级到直接查数据库，如果数据库也挂了，降级返回默认商品信息。

页面静态化

对于完全静态的商品（比如虚拟商品或者不参与促销的商品），生成静态HTML页面，直接存到CDN，这样的话用户请求直接由CDN返回，不经过任何服务。

【面试真题拆解】高并发场景下“恶意登录设备识别”系统设计

Wed, 18 Mar 2026 10:41:34 +0000

这是面试遇到的一道场景题。

面试官问我：

有这么一个场景，现在有一个网站，这个网站访问的人非常多，在登录的时候有些坏人来这里捣乱，怎么去设计一个系统实现把这些坏人找到的逻辑。

条件说一下：

登录的时候你要的用户userid，时间，设备deviceid这些信息都有；

坏人的定义是：最近十分钟之内，一个设备上登录了大于等于5个user，我就认为这个是坏人。

场景梳理

输入信息：用户登录时的 userId（用户ID）、timestamp（登录时间戳）、deviceId（设备ID）；
坏人定义：最近10分钟（600秒）内，同一个deviceId上登录了≥5个不同的userId；
输出结果：标记该deviceId为“恶意设备”，后续可以做拦截、验证码、风控等处理。

实现方案

考虑用Redis ZSet实现滑动窗口。

为什么选Redis？

主要是因为：

单线程高性能，适合高并发场景
内存数据库，读写速度极快
支持丰富的数据结构（比如这次场景需要的ZSet）
支持过期时间，自动清理数据

为什么选ZSet？

ZSet（有序集合）是 Redis 中最适合做 “时间窗口、排行榜、去重 + 排序” 的数据结构。

它有以下几个特点：
Member（成员）唯一，Member 不能重复，天然去重；
每个 Member 对应一个 Score（分数），Score 是一个浮点数，用来排序；
ZSet 会自动按 Score 从小到大进行排序，如果Score 相同则按 Member 字典序排序。

ZSet 的底层是哈希表 + 跳表，哈希表保证 Member 唯一、O (1) 查找，跳表保证有序、O (log n) 范围查询。

数据模型

维度	说明
Key	`login:device:{deviceId}`（比如 `login:device:abc123`）
Value（ZSet Member）	`userId`（用户ID，保证唯一性，去重）
Score（ZSet Score）	`登录时间戳`（用于滑动窗口）

理一下整个流程

用户发起登录请求：携带 userId、deviceId、timestamp；
先查黑名单：如果已经是恶意设备，直接拦截；
写入登录记录到Redis ZSet：以 deviceId 为Key，userId 为Member，timestamp 为Score，写入ZSet；
清理过期数据：删除ZSet中Score < 当前时间 - 10分钟的元素；
统计最近10分钟内的不同userId数量：用 ZCard 命令统计ZSet的元素个数；
判断是否为坏人：如果数量≥5，标记该deviceId为恶意设备，存入Redis黑名单；
返回登录结果：如果是恶意设备，返回“请完成验证码”或“登录失败”；否则正常登录。

简化版的代码实现

用Spring Boot + RedisTemplate写一个简化版的实现，加深理解一下：

（1）先定义Redis Key的前缀和常量

public class RedisKeyConstants {
    // 设备登录记录Key前缀
    public static final String LOGIN_DEVICE_KEY_PREFIX = "login:device:";
    // 恶意设备黑名单Key前缀
    public static final String MALICIOUS_DEVICE_KEY_PREFIX = "malicious:device:";
    // 滑动窗口大小：10分钟（600秒）
    public static final int WINDOW_SIZE_SECONDS = 600;
    // 坏人阈值：≥5个不同userId
    public static final int MALICIOUS_THRESHOLD = 5;
    // 过期时间：10分钟
    public static final int EXPIRE_TIME_SECONDS = 600;
}

（2）服务实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class LoginRiskControlService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 检查是否为恶意设备
     * @param userId 用户ID
     * @param deviceId 设备ID
     * @return true-是恶意设备，false-正常设备
     */
    public boolean checkMaliciousDevice(String userId, String deviceId) {
        // 1. 构造Redis Key
        String loginKey = RedisKeyConstants.LOGIN_DEVICE_KEY_PREFIX + deviceId;
        String maliciousKey = RedisKeyConstants.MALICIOUS_DEVICE_KEY_PREFIX + deviceId;

        // 2. 先查黑名单：如果已经是恶意设备，直接返回true
        if (Boolean.TRUE.equals(redisTemplate.hasKey(maliciousKey))) {
            return true;
        }

        // 3. 获取当前时间戳（秒）
        long currentTime = System.currentTimeMillis() / 1000;
        // 计算窗口起始时间：当前时间 - 10分钟
        long windowStartTime = currentTime - RedisKeyConstants.WINDOW_SIZE_SECONDS;

        // 4. 写入当前登录记录到ZSet：Member=userId，Score=当前时间戳
        redisTemplate.opsForZSet().add(loginKey, userId, currentTime);

        // 5. 清理过期数据：删除Score < 窗口起始时间的元素
        redisTemplate.opsForZSet().removeRangeByScore(loginKey, 0, windowStartTime);

        // 6. 统计最近10分钟内的不同userId数量（ZSet的元素个数）
        Long count = redisTemplate.opsForZSet().zCard(loginKey);

        // 7. 设置Key的过期时间：10分钟（防止内存泄漏）
        redisTemplate.expire(loginKey, RedisKeyConstants.EXPIRE_TIME_SECONDS, TimeUnit.SECONDS);

        // 8. 判断是否为坏人：数量≥5
        if (count != null && count >= RedisKeyConstants.MALICIOUS_THRESHOLD) {
            // 标记为恶意设备，存入黑名单，过期时间可以设长一点（比如24小时）
            redisTemplate.opsForValue().set(maliciousKey, "1", 24, TimeUnit.HOURS);
            return true;
        }

        // 9. 正常设备，返回false
        return false;
    }
}

（3）在登录接口中调用

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/login")
public class LoginController {

    @Autowired
    private LoginRiskControlService riskControlService;

    @PostMapping
    public String login(String userId, String deviceId) {
        // 1. 先检查是否为恶意设备
        boolean isMalicious = riskControlService.checkMaliciousDevice(userId, deviceId);
        if (isMalicious) {
            return "登录失败：检测到异常设备，请完成验证码验证";
        }

        // 2. 正常登录逻辑（校验账号密码、生成Token等）
        // ...

        return "登录成功";
    }
}

高并发场景的优化

在访问量非常大的场景下，上面的代码肯定扛不住，所以还需要做一些优化。

1. 布隆过滤器快速过滤正常设备

如果每个登录请求都查Redis，Redis的压力会很大。

可以考虑用布隆过滤器先快速过滤：

在布隆过滤器里只存“潜在恶意设备”（比如最近10分钟内登录过≥3个userId的设备），登录时先查布隆过滤器，如果不在里面，直接放行，不查Redis；如果在里面，再查Redis确认。

2. 异步处理

如果Redis查询慢，会阻塞主登录流程，影响用户体验。

考虑把“写入ZSet、清理过期数据、统计数量、判断坏人”这些步骤用线程池或消息队列异步执行，这样的话主登录流程只做“账号密码校验、生成Token”，用户体验会更好一点。

小贴士：

异步会有极短的延迟，但是风控允许这种小误差。

3. 本地缓存+Redis双层缓存

如果恶意设备黑名单查询很频繁，每次都查Redis还是会有压力。

考虑用本地缓存（比如Caffeine）+ Redis 的双层缓存。

这样一来本地缓存存“最近1分钟内的恶意设备黑名单”，登录时先查本地缓存，命中直接返回，没命中再查Redis，查到后写入本地缓存。

小贴士：

本地缓存不能设 10 分钟，因为多实例部署时，本地缓存互不同步，会导致风控失效。

设 1 分钟既能减轻 Redis 压力，又能保证安全可控。

【面试真题拆解】Spring中的注解

Wed, 18 Mar 2026 08:53:48 +0000

面试官没有直接问我“@Autowired和@Resource的区别”这种题，而是：

先让我举几个Spring注解的例子，再问“Spring注解定义为什么都挺短，不会有大量代码”，直接考察你对注解本质和Spring AOP/IOC底层的理解。

举几个Spring注解的例子

1. IOC依赖注入类注解

注解	作用	区别
@Autowired	Spring原生注解，按类型（byType）自动注入依赖	优先byType，找不到唯一Bean时，会尝试按变量名（byName）匹配；可以配合 `@Qualifier` 指定Bean名称；可以用 `required=false` 允许依赖为空
@Qualifier	配合 `@Autowired` 使用，强制按名称（byName）注入依赖	当容器中有多个同类型Bean时，必须用它指定具体用哪个
@Resource	按名称（byName）优先注入，找不到再按类型（byType）匹配	JSR-250标准，跨框架兼容性好；可以用 `name` 属性显式指定Bean名称

2. IOC组件注册类注解

注解	作用
@Component	通用组件注册注解，把任意类标记为Spring容器的Bean
@Controller	`@Component` 的子类，专门标记Web控制器层的Bean
@Service	`@Component` 的子类，专门标记业务逻辑层的Bean
@Configuration	`@Component` 的子类，专门标记Java配置类，替代XML配置文件
@Repository	@Component 的子类，专门标记数据访问层的 Bean；还能把数据库的异常（如 SQLException）转换成 Spring 的 DataAccessException（非受检异常）

3. AOP切面类注解

横切关注点就是“和业务逻辑无关，但很多地方都要用的功能”，比如日志、事务、权限校验、性能监控这些。

注解	作用
@Aspect	把类标记为切面类
@Pointcut	定义切入点表达式，告诉Spring“哪些方法需要被增强”
@Before	前置通知：在目标方法执行之前执行增强逻辑
@After	后置通知：在目标方法执行之后（不管有没有异常）执行增强逻辑
@AfterReturning	返回通知：在目标方法正常返回之后执行增强逻辑
@AfterThrowing	异常通知：在目标方法抛出异常之后执行增强逻辑
@Around	环绕通知：最强大的通知，可以完全控制目标方法的执行（比如不执行目标方法、修改参数、修改返回值）

Lombok的常用注解

Lombok是一种代码简化工具，通过注解自动生成代码。

虽然不是Spring原生注解，但Lombok的注解是Java开发中经常会用到的。

注解	作用
@Slf4j	自动生成 SLF4J日志对象
@Data	自动生成 getter/setter、toString、equals、hashCode、无参构造器
@NoArgsConstructor	自动生成无参构造器
@AllArgsConstructor	自动生成全参构造器

Spring 注解定义为什么通常都挺短，不会有大量代码？

面试官这么问主要是想考察你对注解本质和Spring容器底层的理解。

先明确一下元数据（Metadata）的定义，元数据就是“描述数据的数据”，本身不是数据的内容，只是给数据打标签、加属性。

根本原因在于注解只是元数据标记，本身不包含任何逻辑。

举个Spring注解的例子，比如 @Transactional：

// @Transactional的核心定义（简化版，去掉了很多元注解和属性）
@Target({ElementType.METHOD, ElementType.TYPE}) // 元注解：标记这个注解能用在方法/类上
@Retention(RetentionPolicy.RUNTIME) // 元注解：标记这个注解保留到运行时
@Inherited // 元注解：标记这个注解可以被子类继承
@Documented // 元注解：标记这个注解会被生成到JavaDoc里
public @interface Transactional {
    // 只有属性，没有任何方法/逻辑！
    String value() default ""; // 事务管理器的名称
    Propagation propagation() default Propagation.REQUIRED; // 传播行为
    Isolation isolation() default Isolation.DEFAULT; // 隔离级别
    int timeout() default -1; // 超时时间
    boolean readOnly() default false; // 是否只读
}

可以看到@Transactional 的定义里只有属性，没有任何一行业务逻辑或容器逻辑。

它只是告诉Spring容器：“这个方法/类需要开启事务，传播行为是REQUIRED，隔离级别是DEFAULT…”，真正开启/提交/回滚事务的逻辑，全在Spring的事务管理器和AOP切面里。

除此之外，Spring注解的定义比较短，还有一个原因是Spring大量使用了元注解（Meta-Annotation）。

那什么是元注解呢？

元注解就是“标记注解的注解”，可以复用已有注解的功能，不用重复写代码。

比如上面的 @Transactional，它上面有@Target、@Retention、@Inherited、@Documented这4个元注解。

怎么自定义一个Spring注解？

简单来说有以下3步：

定义注解

用 @interface 定义，加上JDK原生元注解（至少需要 @Target 和 @Retention(RUNTIME)）；

编写后置处理器

实现 BeanPostProcessor 或 BeanFactoryPostProcessor 接口，或者用 AOP 切面（更适合方法级别的拦截，比如权限校验、记录执行时间），处理自定义注解的逻辑；

注册后置处理器

把自定义后置处理器交给Spring容器管理（比如用 @Component 标记）。

举个例子@AuthCheck：

@Target(ElementType.METHOD)
//规定这个标签能贴在哪里,ElementType.METHOD 意思是“只能贴在方法上面”。
@Retention(RetentionPolicy.RUNTIME)
//规定这个标签的有效期,RUNTIME的意思是“程序运行的时候，这个标签依然存在”
public @interface AuthCheck {

    /**
     * @interface 不是接口（interface），而是专门用来定义注解的语法。
     * String mustRole()：表示用这个标签时，
     * 你可以写上一个角色名，比如 @AuthCheck(mustRole = "admin")。
     * default ""：如果你只写了 @AuthCheck
     * 而没填角色，那默认值就是一个空字符串 ""
     * （表示不需要特定角色，只要登录就行，具体看你怎么实现业务逻辑）。
     *
     */
    String mustRole() default "";
}

【面试真题拆解】Java文件操作的异常类型与受检_非受检异常

Tue, 17 Mar 2026 21:09:31 +0000

以往面试的时候问Java异常好像背一背题就行，但是这个面试官水平还是很高的，换了一种问法，大概是这么问的：

Java中写了一个函数，打开了一个文件，读这个文件然后关闭，中间没有写try-catch，保存之后，编辑器自动在这个函数声明后面加了throws exception，你觉得这些exception会有哪些呢？

如果把这个函数进行修改，不读写文件，只进行简单的数据处理，这时保存之后，发现函数声明的后面没有throws这些异常了，在这种情况下是不是就不会抛出异常了？

有点懵了，完犊子。。。

主要有以下几点，掌握了应该问题不大：

文件操作的异常主要是IOException及其子类，属于受检异常，必须显式处理（要么 try-catch，要么 throws）；

简单数据处理的异常多是RuntimeException 及其子类（如空指针、数组越界），属于非受检异常，无需强制 throws 或 try-catch；

受检异常要求“编译时必须处理”，非受检异常是“运行时才可能出现”，编译器不强制要求。

文件操作会抛出哪些异常？

复现一下面试题里的场景：

写一个文件读写函数，没加 try-catch，编辑器自动加了 throws Exception。

import java.io.*;

public class FileReadExample {
    // 编辑器自动加了 throws Exception，因为里面有受检异常
    public void readFile(String filePath) throws Exception {
        // 1. 打开文件流
        FileInputStream fis = new FileInputStream(filePath);
        // 2. 读取文件内容
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
        // 3. 关闭文件流
        fis.close();
    }
}

有以下几种文件操作中常见的异常

异常类型	触发场景
FileNotFoundException	文件路径不存在、文件是目录、没有读权限
IOException	读取文件时IO错误（如磁盘损坏、网络文件系统（NFS）的连接意外中断）
EOFException	读取到文件末尾仍尝试读取

小贴士：

FileNotFoundException 是 IOException 的子类，如果 throws IOException，也能覆盖 FileNotFoundException。

为什么简单数据处理不需要 `throws`？

面试题里的第二个场景：

把函数改成只做简单数据处理，编辑器就不加 throws 了。

复现一下这个场景：

public class SimpleDataProcessExample {
    // 编辑器不会加 throws，因为里面都是非受检异常
    public void processData(int[] arr, String str) {
        // 1. 数组越界：ArrayIndexOutOfBoundsException（非受检）
        int num = arr[10];
        // 2. 空指针：NullPointerException（非受检）
        int len = str.length();
        // 3. 非法参数：IllegalArgumentException（非受检）
        if (arr.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }
    }
}

这里的主要原因是：

简单数据处理的异常都是 RuntimeException 的子类，是非受检异常，编辑器不会强制要求 throws 或 try-catch。

受检异常 vs 非受检异常

对比维度	受检异常（Checked Exception）	非受检异常（Unchecked Exception）
定义	编译时必须处理的异常，不处理编译不通过	运行时才可能出现的异常，编译器不强制要求处理
所属类	`Exception` 及其子类（除了 `RuntimeException` 及其子类）	`RuntimeException` 及其子类、`Error` 及其子类
典型例子	`IOException`、`FileNotFoundException`	`NullPointerException`、`ArrayIndexOutOfBoundsException`、`IllegalArgumentException`
处理要求	必须 `try-catch` 或 `throws`	可以不处理，也可以处理
设计目的	提醒开发者“这里可能有外部不可控的错误，必须处理”	提醒开发者“这里有代码逻辑错误，需要修复代码”

实际开发中，文件操作的异常怎么处理？

不要直接 throws Exception，推荐显式抛出具体异常（如 throws IOException）或者 try-catch 处理，记录日志并给出友好提示。

举个例子：

public void readFile(String filePath) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(filePath);
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
    } catch (FileNotFoundException e) {
        System.err.println("文件不存在：" + filePath);
        e.printStackTrace();
    } catch (IOException e) {
        System.err.println("文件读取失败");
        e.printStackTrace();
    } finally {
        // 必须在 finally 里关闭流，防止内存泄漏
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前后端分离+微服务架构下的用户认证

Tue, 17 Mar 2026 19:38:35 +0000

先明确一些核心组件：

组件	作用
前端	页面展示、用户交互、存储Token
API网关	统一入口、路由转发、Token校验
认证中心	用户登录验证、生成/刷新Token
微服务	处理业务逻辑、获取用户信息
数据库	存储用户账号密码、权限信息

当时面试官跟我说，你可以从前端打开一个页面开始讲。

那我们就举个例子：

以用户打开一个电商网站首页➡️跳转登录➡️输入账号密码登录➡️携带Token请求商品列表为例，说一下这个完整的流程。

1.前端打开页面，检查本地是否有Token

用户在浏览器输入 https://www.example.com，前端代码首先检查本地存储中是否存在有效的Token。

2.没有Token，前端跳转登录页，用户输入账号密码

如果本地没有Token，前端路由跳转到 /login 登录页，用户输入账号和密码，点击【登录】按钮。

3.前端发送登录请求到API网关

前端将账号密码封装成POST请求，发送到API网关。

需要注意的是：前端不直接请求认证中心，所有请求都走网关统一入口。

4.API网关转发登录请求到认证中心

API网关收到 /auth/login 请求，根据路由规则，将请求转发到认证中心服务。

5.认证中心验证用户信息，生成JWT Token

认证中心做以下3件事：

从数据库查询用户信息，验证账号密码是否正确；
验证通过后，生成 JWT Token（分为 Access Token 和 Refresh Token）；
将 Token 返回给前端。

那什么是JWT呢？

JWT（JSON Web Token）是一种无状态的Token，由三部分组成，用 . 分隔：

Header：头部，存算法和类型；
Payload：载荷，存用户信息（比如userId、username、过期时间）；
Signature：签名，用密钥对Header和Payload签名，防止Token被篡改。

6.前端收到Token，存储到本地

前端收到认证中心返回的 access_token 和 refresh_token，存到本地存储中。

7.前端携带Token请求业务接口

用户登录成功后，前端请求商品列表接口，在请求头 Authorization 中携带 Bearer Token。

Bearer 这个单词的意思是“持票人”、“持有者”。

Bearer Token 就是：“谁持有这个 Token，谁就是合法的访问者，服务器就认谁”。

8.API网关校验Token

API网关收到 /product/list 请求，通过全局过滤器校验Token的有效性：

从请求头 Authorization 中取出Token；
验证Token的签名是否正确；
验证Token是否过期；
校验通过后，将用户信息（比如userId）放入请求头，转发给微服务；
如果校验失败，直接返回401未授权。

9.微服务获取用户信息，处理业务逻辑

微服务（比如商品服务）收到网关转发的请求，从请求头 X-User-Id 中取出userId，处理业务逻辑（比如查询该用户的商品列表）。

10.Token过期，前端用Refresh Token刷新

Access Token有效期比较短（比如只有2小时），过期后前端请求会收到401；

此时前端不用让用户重新登录，而是用Refresh Token去认证中心刷新Access Token。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

只有一个线程多次获取同一把锁，没有其他线程竞争。
第一个线程获取锁时，会在对象头的 Mark Word 里记录【偏向线程ID】，这个线程以后再次获取锁时，只需要检查偏向线程ID是不是自己，如果是，直接获取锁。
当有第二个线程来竞争这把锁时，偏向锁会撤销，升级为轻量级锁。

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

线程在自己的栈帧里创建一个锁记录（Lock Record），用 CAS（Compare And Swap，比较并交换）操作，尝试把对象头的 Mark Word 替换成指向自己栈中锁记录的指针。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Redis的8种内存淘汰策略

Mon, 16 Mar 2026 22:54:44 +0000

Redis 内存淘汰策略共 8 种，分两大类：不淘汰和淘汰数据；

纯缓存场景优先选 allkeys-lru，混合场景选 volatile-lru，数据不能丢的话选 noeviction。

`maxmemory` 参数

只有设置了 maxmemory（Redis 最大内存限制），内存淘汰策略才会生效。

设置 `maxmemory`的两种方式

配置文件 redis.conf：

1
2

# 限制 Redis 最大使用 1GB 内存
maxmemory 1gb

命令行动态设置（重启后会失效）：

`1`	`127.0.0.1:6379> CONFIG SET maxmemory 1gb`

Redis 的8种内存淘汰策略

可以分为两大类：

大类	策略名称	含义
不淘汰数据	`noeviction`	内存满了，新写入直接报错，不淘汰任何数据
淘汰过期键	`volatile-lru`	淘汰设置了过期时间的键中，最近最少使用的
	`volatile-lfu`	淘汰设置了过期时间的键中，最不经常使用的
	`volatile-ttl`	淘汰设置了过期时间的键中，即将过期的
	`volatile-random`	随机淘汰设置了过期时间的键
淘汰所有键	`allkeys-lru`	淘汰所有键中，最近最少使用的
	`allkeys-lfu`	淘汰所有键中，最不经常使用的
	`allkeys-random`	随机淘汰所有键

1. `noeviction`

当内存满了，新写入的请求（比如 SET、LPUSH）会直接报错 (error) OOM command not allowed when used memory > 'maxmemory'，不淘汰任何数据。

适用于数据绝对不能丢，且有完善的内存监控和扩容机制（比如金融级核心数据）的场景。

2. 淘汰过期键的4种策略

这类策略只淘汰设置了 expire 过期时间的键，不会碰永久键，适合“缓存+持久化”混合的场景（比如永久键存重要数据，过期键存缓存）。

`volatile-lru`

LRU = Least Recently Used（最近最少使用）。

在设置了过期时间的键中，淘汰最久没被访问过的键。

比如缓存场景，往往会希望保留“最近刚用过的热数据”。

`volatile-lfu`

LFU = Least Frequently Used（最不经常使用）。

在设置了过期时间的键中，淘汰访问次数最少的键。

`volatile-ttl`

TTL = Time To Live（剩余生存时间）。

在设置了过期时间的键中，淘汰剩余时间最短、即将过期的键。

`volatile-random`

在设置了过期时间的键中，随机淘汰一个。

3. 淘汰所有键的3种策略

这类策略不管键有没有设置过期时间，都会淘汰，适合纯缓存场景（所有数据都是缓存，丢了也没关系，可以从数据库重新加载）。

`allkeys-lru`

在所有键中，淘汰最近最少使用的键。

比较适合电商商品缓存、用户Session缓存这些纯缓存场景。

`allkeys-lfu`

在所有键中，淘汰访问次数最少的键。

`allkeys-random`

在所有键中，随机淘汰一个。

LRU vs LFU，到底有啥区别？

对比维度	LRU（最近最少使用）	LFU（最不经常使用）
核心依据	看最近多久没被访问	看访问次数多少
优点	实现简单，符合“热数据最近常用”的直觉	更精准，能识别“真正的热数据”（比如某个键虽然最近没被访问，但总访问次数极高）
缺点	可能误删“偶尔访问一次的冷数据，但其实总访问次数很高”	实现复杂，需要额外空间记录访问次数

举个例子

假设键A昨天被访问100次，今天没被访问；

键B今天被访问1次。

因为最近没被访问，所以LRU会删键A。

但是，因为总访问次数只有1次，所以LFU会删键B。

【手撕真题】合并区间

Mon, 16 Mar 2026 17:02:46 +0000

题目意思很好理解：

给定一个区间集合，每个区间由 [start, end] 组成，要求合并所有重叠的区间，返回一个不重叠的区间数组，且这个数组要恰好覆盖输入中的所有区间。

思路

首先，先按每个区间的起始值从小到大排序，这样重叠的区间就会挨在一起，方便后续合并；

然后初始化一个结果列表，把排序后的第一个区间放进去，作为初始的待合并区间；

接着遍历剩下的所有区间，每次取出结果列表的最后一个区间和当前区间比较：

如果当前区间的起始值小于等于最后一个区间的结束值，说明两个区间重叠，就把最后一个区间的结束值更新为两者的最大值，完成合并；

如果不重叠，就直接把当前区间加入结果列表；

最后把结果列表转换成二维数组返回即可。

代码实现

    public int[][] merge(int[][] intervals) {
        // 区间个数为0或1，直接返回
        if (intervals.length <= 1) {
            return intervals;
        }

        // 1. 按区间的start值从小到大排序
        // a[0]-b[0]表示按start升序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        // 2. 初始化结果列表，存储合并后的区间
        List<int[]> res = new ArrayList<>();
        // 先将排序后的第一个区间加入结果列表，作为初始合并区间
        res.add(intervals[0]);

        // 3. 遍历剩下的所有区间，逐个合并
        for (int i = 1; i < intervals.length; i++) {
            // 取出结果列表中最后一个区间
            int[] last = res.get(res.size() - 1);
            // 取出当前遍历的区间
            int[] curr = intervals[i];

            // 判断是否重叠：当前区间的start <= 最后一个区间的end
            if (curr[0] <= last[1]) {
                // 重叠：合并区间，更新最后一个区间的end为两者最大值
                last[1] = Math.max(last[1], curr[1]);
            } else {
                // 不重叠：直接将当前区间加入结果列表
                res.add(curr);
            }
        }

        // 4. 将List<int[]>转换为int[][]
        return res.toArray(new int[res.size()][]);
    }

MySQL的三层B+树能存多少数据？

Mon, 16 Mar 2026 13:09:19 +0000

InnoDB读写磁盘的最小单位是页（Page），默认大小16KB。
而MySQL的主键索引B+树，每一个树节点（不管是根节点、中间节点、叶子节点），本质上就是一个16KB的页。
所有计算，都是围绕【1个16KB的页，能存多少东西】展开的。

节点类型	存的内容	特点
非叶子节点（根节点、中间层节点）	只存主键值 + 指向下一层页的指针	不存完整用户数据，体积极小，一个页能存上千个
叶子节点（最底层节点）	存用户的完整一行行数据	存真实业务数据，体积大，一个页能存的行数有限

1.先算1个非叶子节点，能存多少个索引项

非叶子节点存的是「主键值 + 指针」，我们先算单个索引项的大小：

主键大小：假设主键是bigint类型，MySQL里bigint固定占8字节；
指针大小：InnoDB里指向页的指针，固定占6字节；
单个索引项总大小：8字节（主键） + 6字节（指针） = 14字节。

一个页是16KB，换算成字节是 16 × 1024 = 16384字节。
所以一个非叶子页能存的索引项数量：
16384 ÷ 14 ≈ 1170个

2.再算1个叶子节点，能存多少行数据

叶子节点存的是用户的完整一行行数据，假设一行业务数据占1KB（比如一张表有id、name、age、create_time等字段，加起来差不多1KB）。

一个页是16KB，所以一个叶子页能存的行数：
16KB ÷ 1KB/行 = 16行

3.最后算三层B+树的总数据量

顺着三层结构，从根节点往下算：

第一层（根节点）：1个非叶子页，能存1170个索引项 → 能指向1170个第二层的页；
第二层（中间非叶子节点）：1170个非叶子页，每个页又能存1170个索引项 → 能指向 1170 × 1170 = 1368900 个第三层的叶子页；
第三层（叶子节点）：每个叶子页能存16行数据。

最终总数据量 = 叶子页总数 × 每个叶子页的行数：
1170 × 1170 × 16 ≈ 2190万条

所以，三层B+树大约能存2000万条记录。

【面试真题拆解】Java字节流、字符流

Mon, 16 Mar 2026 10:00:59 +0000

Java IO流的分类

Java IO流主要从两个维度分类：

分类维度	分类结果	说明
按数据流向分	输入流（Input）	从磁盘/网络/内存「读」数据到程序
	输出流（Output）	从程序「写」数据到磁盘/网络/内存
按处理单元分	字节流（Byte Stream）	以「字节（byte）」为单位处理数据，是万能流
	字符流（Character Stream）	以「字符（char）」为单位处理数据，专门处理文本

字节流

什么是字节流？

计算机里所有数据（图片、视频、音频、文本、PDF）本质上都是字节（0和1的组合），所以字节流是万能流，可以处理任何类型的数据。

字节流的核心类

字节流的抽象基类是 InputStream（输入流）和 OutputStream（输出流），开发中最常用的是它们的子类：

类名	作用
`FileInputStream`	从文件中读取字节
`FileOutputStream`	向文件中写入字节
`BufferedInputStream`	带缓冲的字节输入流，提升读性能
`BufferedOutputStream`	带缓冲的字节输出流，提升写性能

举个例子

字节流典型的应用——复制非文本文件（图片、视频、PDF）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 源文件路径（一张图片）
        String srcPath = "C:/test/photo.jpg";
        // 目标文件路径
        String destPath = "C:/test/photo_copy.jpg";

        // 用try-with-resources自动关闭流，避免内存泄漏
        try (
            // 1. 创建文件字节输入流：从源文件读字节
            FileInputStream fis = new FileInputStream(srcPath);
            // 2. 创建文件字节输出流：向目标文件写字节
            FileOutputStream fos = new FileOutputStream(destPath)
        ) {
            // 3. 定义一个字节数组作为缓冲区（一次读1024字节，即1KB，提升性能）
            byte[] buffer = new byte[1024];
            int len; // 记录每次实际读到的字节数

            // 4. 循环读写：fis.read(buffer)返回-1表示读到文件末尾
            while ((len = fis.read(buffer)) != -1) {
                // 只写实际读到的len个字节，避免最后一次写多余的空字节
                fos.write(buffer, 0, len);
            }
            System.out.println("图片复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

什么是字符流？

字符流是专门处理文本数据的流，它以【字符】为单位处理数据，内部会自动处理编码转换（比如把UTF-8编码的字节转成Java的char字符）。

为什么不用字节流处理文本？

因为中文等非ASCII字符占多个字节（比如UTF-8编码的中文占3个字节）。

如果用字节流读，可能会把一个汉字的3个字节截断，从而导致乱码；

而字符流会自动识别编码，按字符读取，不会乱码。

字符流的核心类

字符流的抽象基类是 Reader（输入流）和 Writer（输出流），开发中最常用的是它们的子类：

类名	作用
`FileReader`	从文件中读取字符
`FileWriter`	向文件中写入字符
`BufferedReader`	带缓冲的字符输入流
`BufferedWriter`	带缓冲的字符输出流
`InputStreamReader`	转换流：字节流转字符流
`OutputStreamWriter`	转换流：字符流转字节流

举个例子

BufferedReader的readLine()方法可以按行读取文本，非常方便。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class CharacterStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/test/中文文章.txt";

        // 用转换流InputStreamReader，显式指定UTF-8编码，避免乱码
        try (
            // 1. 先创建字节输入流
            FileInputStream fis = new FileInputStream(filePath);
            // 2. 用转换流把字节流转成字符流，显式指定UTF-8编码
            InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
            // 3. 用缓冲流包装，提升性能，且有readLine()方法
            BufferedReader br = new BufferedReader(isr)
        ) {
            String line;
            int lineNum = 1;
            // readLine()返回null表示读到文件末尾
            while ((line = br.readLine()) != null) {
                System.out.println("第" + lineNum + "行：" + line);
                lineNum++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

【面试真题拆解】Java类加载过程+双亲委派机制

Sun, 15 Mar 2026 22:44:04 +0000

什么是类加载？

简单来说，类加载就是把.class文件（编译后的字节码）从磁盘/网络加载到JVM内存里，并生成对应的Class对象的过程。

Java类加载的5个核心阶段

类加载不是一步到位的，而是分成了5个阶段： 加载➡️验证➡️准备➡️解析➡️初始化，其中加载、验证、准备、初始化的顺序是固定的，解析可能在初始化之后（为了支持动态绑定）。

1. 加载（Loading）

这是类加载的第一步，举个例子：假如你要加载User类，JVM会先找到User.class文件，把它的信息存到方法区，然后在堆里生成一个Class对象，以后你要访问User类的信息，都通过这个Class对象。

2. 验证（Verification）

这一步是为了保证JVM的安全，防止恶意或不规范的.class文件搞破坏，主要验证四个方面：

文件格式验证：检查.class文件的魔数（开头的CAFEBABE）、版本号（JDK版本兼容）等；
元数据验证：检查类的继承关系（比如不能继承final类）、方法重写是否合法等；
字节码验证：检查字节码指令是否安全（比如不会跳转到非法指令、不会访问越界的数组）；
符号引用验证：检查符号引用（比如类名、方法名）是否能找到对应的类/方法。

3. 准备（Preparation）

这一步是在方法区里为类的静态变量（static修饰的变量）分配内存，并设置初始默认值。

需要注意的是：不是代码里写的初始值，而是以下这些初始值：

数据类型	默认值
int	0
long	0L
float	0.0f
double	0.0d
boolean	false
引用类型	null

4. 解析（Resolution）

这一步是把常量池里的符号引用（比如类名com.example.User、方法名getUser），转换成直接引用（比如内存地址、指针）。

解析的话，主要针对的是类、接口、字段、方法等符号引用。

举个通俗一点的例子：

符号引用就是一个“代号”，比如你用“张三”指代一个人，不管他在哪，“张三”这个代号都能用；

而直接引用就是“具体的地址”，比如张三现在在“XX小区XX号楼XX室”，你可以直接找到他。

5. 初始化（Initialization）

这是类加载的最后一步，也是真正执行程序员写的代码的阶段。

这一步只做一件事：执行类构造器<clinit>()方法。

<clinit>()方法是编译器自动生成的，它会把类里的静态变量赋值语句和静态代码块（static {}）按顺序合并起来执行。

举个例子

public class User {
    static int num = 10; // 静态变量赋值
    static { // 静态代码块
        num = 20;
        System.out.println("静态代码块执行");
    }
}

以上代码在初始化阶段，JVM会执行<clinit>()方法：

先把num设为10，再设为20，然后打印“静态代码块执行”。

什么时候会触发类的初始化？

有以下6种情况：

创建类的实例（new User()）；
访问类的静态变量或静态方法（User.num、User.getUser()）；
用Class.forName("com.example.User")反射加载类；
初始化子类时，会先初始化父类；
JVM启动时，会先初始化包含main()方法的主类；
JDK 7+的动态语言支持，MethodHandle解析结果为REF_getStatic/REF_putStatic/REF_invokeStatic的句柄，且对应的类未初始化。

双亲委派机制（Parent Delegation Model）

什么是类加载器？

类加载器（ClassLoader）就是负责加载类的工具，JVM内置了三种类加载器：

启动类加载器（Bootstrap ClassLoader）

用C++写的，不是ClassLoader的子类，开发者无法直接获取它的引用。

负责加载JDK核心类库（比如java.lang.Object、java.lang.String），这些类在jre/lib/rt.jar里。

扩展类加载器（Extension ClassLoader）

是ClassLoader的子类，开发者可以获取它的引用，负责加载JDK扩展类库（比如jre/lib/ext目录下的类）。

应用程序类加载器（Application ClassLoader）

是ClassLoader的子类，也是默认的类加载器。负责加载用户自己写的类（比如com.example.User），也就是classpath下的类。

什么是双亲委派机制？

这里的“双亲”不是指“父母”，而是指“父类加载器”，是翻译的问题，理解成“父委派机制”更准确一点。

双亲委派机制的核心规则是：“向上委托，向下加载”

当一个类加载器收到加载类的请求时，它不会自己先加载，而是把请求委托给父类加载器去加载；
如果父类加载器能加载这个类，就由父类加载器加载；
如果父类加载器加载不了（比如在它的加载范围内找不到这个类），才会向下交给子类加载器自己加载。

举个例子

比如说：加载java.lang.Object

应用程序类加载器收到加载Object的请求，它不自己加载，委托给扩展类加载器；
扩展类加载器也不自己加载，委托给启动类加载器；
启动类加载器在rt.jar里找到了Object类，直接加载它；
加载完成，返回Class对象，不会再向下交给子类加载器。

为什么需要双亲委派机制？

双亲委派机制的目的是保证Java程序的安全性和稳定性，主要解决了两个问题：

避免类的重复加载

如果没有双亲委派，用户自己写一个java.lang.Object类，应用程序类加载器就会加载它，导致JVM里有两个Object类，程序就乱了。

保证核心类库的安全

防止用户恶意篡改核心类库（比如写一个恶意的java.lang.String类），因为核心类库只会由启动类加载器加载，用户写的同名类不会被加载。

破坏双亲委派机制的情况

常见的破坏双亲委派机制的场景：

JDBC的DriverManager

JDBC需要加载不同数据库的驱动（比如MySQL驱动），但驱动类是用户写的，启动类加载器加载不了，所以DriverManager用了线程上下文类加载器（Thread Context ClassLoader），打破了双亲委派，让启动类加载器能委托应用程序类加载器加载驱动。

Tomcat的类加载器

Tomcat需要隔离不同Web应用的类（比如两个应用都用了不同版本的Spring），所以它有自己的类加载器结构，每个Web应用有独立的类加载器，优先加载自己的类，而不是向上委托。

【面试真题】能讲讲MySQL的锁机制吗

Sun, 15 Mar 2026 16:44:46 +0000

MySQL的锁按两个维度分，刚好对应开发中最常遇到的问题：

按解决并发冲突的思路分，是悲观锁和乐观锁——这俩决定了“你是先占坑再干活，还是先干活最后再检查”；

按锁的范围大小分，是表锁、行锁，还有 InnoDB 特有的间隙锁 + 临键锁 —— 这三类锁决定了 “你是锁整个仓库（表锁）、只锁你要的那一件商品（行锁），还是锁仓库里的某个货架区间（间隙锁 + 临键锁）”。

先建一张最简单的电商商品表 product，插几条测试数据，等会更好理解举的例子：

CREATE TABLE `product` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `name` varchar(100) NOT NULL COMMENT '商品名称',
  `stock` int(11) NOT NULL DEFAULT '0' COMMENT '库存',
  `version` int(11) NOT NULL DEFAULT '0' COMMENT '乐观锁版本号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

-- 插入测试数据：id=1是iPhone，库存100；id=3是华为，库存200；id=5是小米，库存150
INSERT INTO `product` (`id`, `name`, `stock`, `version`) VALUES
(1, 'iPhone 17', 100, 0),
(3, 'Mate 70', 200, 0),
(5, 'Xiaomi 15', 150, 0);

悲观锁

举个电商秒杀扣库存的真实例子，也是悲观锁最典型的应用：

比如有两个用户同时秒杀iPhone 17，库存100。

如果不用锁，俩人同时查出来库存100，都扣减1，就超卖了。
用悲观锁的话，就是在查库存的时候用 SELECT ... FOR UPDATE 显式加排他锁——

第一个用户的事务先把这行数据锁住，第二个用户的查询就会阻塞，等第一个用户扣减完库存、提交事务释放锁，第二个用户才能拿到最新的库存，这样就保证了不超卖。

乐观锁

这也是开发中很常见的场景：两个运营同时修改同一件商品的标题。

这种场景并发冲突概率很低（因为很少会有两个人同时改同一个商品的标题），如果用悲观锁，每次修改都要加锁，太影响性能了，所以用乐观锁更合适。

乐观锁的意思就是：我假设没人跟我抢，所以我先直接修改，最后提交的时候再检查一下：

在我修改的这段时间里，有没有别人也改过这条数据？

如果没有，就修改成功；

如果有，就提示用户“数据已被修改，请刷新后重试”。

举个具体的SQL操作实例

我们打开两个命令行窗口，分表代表两个会话。

1.会话A（运营A先查商品）

1
2

-- 1. 运营A查出来iPhone的信息，此时 version = 0
SELECT * FROM product WHERE id = 1;

2.会话B（运营B同时查商品）

1
2

-- 1. 运营B也查出来iPhone的信息，此时 version 也是 0
SELECT * FROM product WHERE id = 1;

3.会话A（运营A先提交修改）

-- 1. 运营A把标题改成“iPhone 17 Pro Max”，WHERE条件带上 version = 0
UPDATE product 
SET name = 'iPhone 17 Pro Max', version = version + 1 
WHERE id = 1 AND version = 0;
-- 现象：返回更新行数为 1，修改成功！此时数据库里的 version 变成了 1

4.会话B（运营B后提交修改）

-- 1. 运营B把标题改成“iPhone 17 特价版”，WHERE条件也带上 version = 0
UPDATE product 
SET name = 'iPhone 17 特价版', version = version + 1 
WHERE id = 1 AND version = 0;
-- 现象：返回更新行数为 0，修改失败！
-- 因为数据库里的 version 已经变成 1 了，找不到 id=1 AND version=0 的行
-- 此时业务代码就可以提示用户：“商品已被其他运营修改，请刷新页面后重试”

表锁

直接锁整张表，其他会话对这张表的任何读写（不管是查哪一行、改哪一行）都会被阻塞。

举个例子

-- 会话A：给全表商品库存+10，显式加表锁
LOCK TABLES product WRITE;
UPDATE product SET stock = stock + 10;

-- 此时会话B想查id=1的商品，会直接阻塞！
SELECT * FROM product WHERE id = 1;

-- 会话A提交事务并释放表锁后，会话B才能执行
UNLOCK TABLES;

表锁的优点是加锁开销小、速度快，不会死锁，但缺点就是并发度极低，一锁全表，电商场景下用它会直接让网站卡死。

行锁

只锁具体的某一行数据，其他行完全不受影响，是InnoDB支持高并发的核心。

需要注意的是行锁的前提是【走索引】。

如果你的查询没走索引，InnoDB会退化成表锁。

举两个例子对比一下

先看走索引的情况（行锁生效）：

-- 会话A：用主键id=1查，加排他锁（走主键索引，只锁id=1这行）
BEGIN;
SELECT * FROM product WHERE id = 1 FOR UPDATE;

-- 会话B：查id=3的商品，完全不阻塞！直接拿到锁
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 执行成功

-- 会话B：查id=1的商品，会阻塞！需要等会话A释放锁
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 阻塞

再看没走索引的情况（退化成表锁）：

-- 先确认name字段没加索引（前面建表的时候只给id加了主键）
-- 会话A：用name='iPhone 17'查，加排他锁（没走索引，锁全表！）
BEGIN;
SELECT * FROM product WHERE name = 'iPhone 17' FOR UPDATE;

-- 会话B：查id=3的商品，居然也阻塞了！因为锁了全表
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 阻塞

行锁的优点是并发度极高，只锁需要的行，不影响其他操作；但缺点是加锁开销大、速度慢，可能产生死锁。

间隙锁+临键锁

这俩是InnoDB特有的，专门用来解决【幻读】问题的。

先举个电商场景的例子说明一下什么是幻读？

-- 会话A：查id>1的所有商品（此时表里只有id=1、3、5）
BEGIN;
SELECT * FROM product WHERE id > 1 FOR UPDATE; -- 第一次查：查到id=3、5两条

-- 会话B：插了一条id=2的商品，提交事务
INSERT INTO product (id, name, stock, version) VALUES (2, 'OPPO Find X8', 100, 0);
COMMIT;

-- 会话A：再查id>1的商品，居然查到了id=2、3、5三条！
SELECT * FROM product WHERE id > 1 FOR UPDATE; -- 第二次查：多了一条，像产生了幻觉

这就是幻读：同一个事务里，两次相同的范围查询，结果却是不一样的。

间隙锁（Gap Lock）

间隙锁，间隙锁，顾名思义，它不锁具体的行，锁的是两个索引值之间的“间隙”，也就是只锁两个相邻索引值之间的空白区间，以防止别人在这个区间里插数据。

以刚开始建的那个product表为例：

id=1、3、5，间隙就是：(-∞,1)、(1,3)、(3,5)、(5,+∞)。

临键锁（Next-Key Lock）

临键锁其实是【行锁】+【间隙锁】的组合，锁的是左开右闭的区间。

比如(1,3]（锁id=3这一行，同时锁1到3之间的间隙）。

还是以刚开始建的那个product表为例，临键区间就是：(-∞,1]、(1,3]、(3,5]、(5,+∞)。

举个例子

-- 会话A：用id=3查，加排他锁（走主键索引，加临键锁(1,3]）
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE;

-- 会话B：想插id=2的商品，直接阻塞！因为间隙(1,3)被锁了
INSERT INTO product (id, name, stock, version) VALUES (2, 'OPPO Find X8', 100, 0); -- 阻塞

-- 会话B：想插id=6的商品，不阻塞！因为(5,+∞)没被锁
INSERT INTO product (id, name, stock, version) VALUES (6, 'Vivo X200', 100, 0); -- 执行成功

小贴士

间隙锁 + 临键锁只在 InnoDB 的默认隔离级别【可重复读（RR）】下生效。

如果是【读提交（RC）】隔离级别，会关闭间隙锁，只保留行锁。

夺命连环问：什么是死锁？又怎么避免呢？

两个或多个会话，互相持有对方需要的锁，都在等待对方释放，导致谁都执行不下去，形成“死循环”，这就是死锁。

举个例子

-- 会话A：先锁id=1，再想锁id=3
BEGIN;
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 持有id=1的锁
-- 此时会话A想拿id=3的锁，但被会话B持有了，阻塞
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 阻塞

-- 会话B：先锁id=3，再想锁id=1
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 持有id=3的锁
-- 此时会话B想拿id=1的锁，但被会话A持有了，阻塞
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 阻塞

-- 结果：死锁！

死锁的四个必要条件

只要破坏其中任意一个，就能避免死锁：

互斥条件：一个锁只能被一个会话持有（行锁就是这样，没法破坏）；
请求与保持条件：持有一个锁的同时，又请求另一个锁；
不剥夺条件：锁只能由持有者主动释放，不能被别人强行抢走；
循环等待条件：会话之间形成循环等待链（A等B，B等A）。

怎么避免死锁？

① 按固定顺序加锁

所有会话都按相同的顺序加锁，比如都先锁id小的，再锁id大的，这样就不会形成循环等待。

② 减少锁的范围和持有时间

尽量用行锁不用表锁；

事务尽量小，不要在事务里做无关操作（比如不要在事务里调第三方接口、查无关表），锁持有时间越短，死锁概率越低。

③ 避免大事务

大事务持有锁的时间长，涉及的行多，更容易死锁，把大事务拆成多个小事务。

小贴士

InnoDB 有自动死锁检测机制，它会实时扫描锁等待链，一旦发现死锁，会自动回滚其中一个，一般是代价较小的那个事务，比如更新行数少的那个，让另一个事务继续执行，不会让系统无限期卡死。

TCP的核心参数-MTU、MSS、RTT、RTO、cwnd、ssthresh

Sun, 15 Mar 2026 11:36:23 +0000

MTU和MSS，管【单个TCP包到底发多大最合适】，是整个传输的基础；

RTT和RTO，管【包发出去之后，怎么保证对方一定收到，丢包了怎么办】，是TCP可靠传输的核心；

cwnd和ssthresh，管【一次能连续发多少个包，怎么既跑满带宽，又不把网络堵死】，是TCP拥塞控制的核心。

MTU & MSS

MTU（最大传输单元，Maximum Transmission Unit）

平时用的以太网、WiFi，硬件层面就规定了一个完整的IP数据包，最大不能超过1500字节，这个上限就是MTU。
如果IP包超过MTU，就会被拆成好几个小分片传输，只要有一个分片丢了，整个包就得全量重传，特别影响效率，还可能被防火墙拦截。

MSS（最大报文段长度，Maximum Segment Size）

这是基于MTU算出来的、TCP包里真正能装的业务数据的最大长度——要把IP头、TCP头的空间提前扣掉。
以太网默认MTU1500字节，标准IP头和TCP头各占20字节，所以默认MSS就是1460字节。

它是TCP三次握手的时候，客户端和服务端协商出来的，最终取两边的最小值，目的就是从源头避免IP拆包。

RTT & RTO

RTT（往返时延，Round-Trip Time）

我发一个TCP包出去，到我收到对方回的【我收到了】的ACK确认包，这一来一回花的时间，就是RTT。
它是网络环境决定的客观值，网络越拥堵、跨的路由越多，RTT就越长，会实时波动，是算RTO的唯一基础。

RTO（重传超时时间，Retransmission TimeOut）

我发出去一个包，会设一个定时器，要是超过这个时间还没收到ACK，我就认为这个包丢了，马上重发一个，这个定时器的时间就是RTO。
RTO完全是基于RTT算出来的，不是固定死的。

它必须比RTT大一点。

如果太小了，ACK还在路上就瞎重传，浪费带宽；

但太大了，真丢包了半天不重传，传输变慢。

所以，网络波动RTT变了，RTO也会跟着实时调整。

cwnd & ssthresh

这两个参数是TCP拥塞控制的核心，TCP刚建连的时候，根本不知道当前网络能扛住多大流量，发少了浪费带宽，发多了直接把网络堵死，所以用这两个参数控制发送节奏。

cwnd（拥塞窗口，Congestion Window）

TCP发送端自己维护的【油门】，单位是MSS。这个参数决定了在没收到对方ACK之前，我最多能连续发多少个包。

比如cwnd=10，就是最多连续发10个MSS大小的包，不用等ACK。
需注意的是，cwnd不是固定的，网络越好、丢包越少，cwnd就越大，发送速度就越快；一旦丢包，就会马上降下来。

ssthresh（慢启动阈值，Slow Start Threshold）

cwnd的【换挡开关】，用来划分两个发送阶段，单位也是MSS。
当cwnd ＜ ssthresh时，进入慢启动阶段，cwnd每过一个RTT就直接翻倍，指数级快速涨速，尽快把带宽跑满；

当cwnd ≥ ssthresh时，进入拥塞避免阶段，cwnd每过一个RTT才加1，线性慢慢涨，避免冲太猛把网络堵死。
一旦检测到网络拥堵丢包，ssthresh会立刻降到当前cwnd的一半，再根据丢包的严重程度调整cwnd，重新控制发送节奏。

【面试真题】讲讲JVM的垃圾回收机制？

Sat, 14 Mar 2026 19:26:46 +0000

为什么需要垃圾回收？

首先得说清楚，JVM的垃圾回收（GC）到底是干嘛的。

其实就像租房子住，时间长了会产生垃圾，要是不打扫，房子就没法住了。

在Java里，我们写代码会创建很多对象（比如new Person()、new ArrayList()），这些对象都存在堆内存里。

但是，堆内存是有限的，要是对象用完了不清理，内存就会被占满，最后报OutOfMemoryError（OOM），程序就挂了。

所以GC的作用就是：自动找到堆里那些“没人用的垃圾对象”，把它们清理掉，腾出内存空间。

堆内存划分

JVM把堆分成了新生代和老年代两大块：

新生代：刚创建的对象优先放在这里。就像“幼儿园”，大部分对象“朝生夕死”（比如方法里的临时变量，方法执行完就没用了）。
老年代：在新生代里“熬过好几次GC”的对象，会被放到这里。就像“养老院”，这里的对象大多活得比较久（比如Spring容器里的单例Bean）。

那为什么要这么划分呢？

主要还是因为不同生命周期的对象，用不同的回收算法，效率会更高一点。

各代用什么垃圾回收算法？

我当时面试的时候突然懵了，说的不知道，裂开。。。

对新生代来说，它的特点是：垃圾多，存活对象少（比如100个对象里，可能只有2个活着）。

采用的是复制算法。

JVM把新生代分成三块：

1个Eden区（占80%）和2个Survivor区（From和To，各占10%）。

平时只用Eden区和其中一个Survivor区（比如From）。

新对象先在Eden区分配，当Eden区满了，触发Minor GC（新生代GC），把Eden和From区里活着的对象，复制到To区，然后直接清空Eden和From区，From和To交换角色（下次用Eden和新的From区）。

对老年代来说，它的特点是：存活对象多，垃圾少，而且没有额外的大空间做复制担保，所以不用复制算法，采用的是**标记-清除 **或 标记-整理算法。

标记-清除算法（Mark-Sweep）

这种算法的实现逻辑是，从“GC Roots”（比如主线程、静态变量这些“根”）出发，找到所有活着的对象，做上标记，然后遍历堆内存，把没标记的对象（垃圾）清理掉。

优点是实现简单，但是会产生内存碎片（比如清理后剩下很多小空间，大对象可能放不下）。

标记-整理算法（Mark-Compact）

为了解决内存碎片问题，在“标记-清除”基础上加了个“整理”步骤。

实现逻辑和标记清除算法一样，先标记存活对象，把所有存活对象往内存的一端移动，按顺序排好，最后，直接清空边界以外的内存。

这种算法的优点是没有内存碎片，但缺点是需要移动对象，效率比“标记-清除”低。

常见的垃圾回收器

Serial：单线程回收，适合客户端应用（比如桌面软件）；
ParNew：Serial的多线程版，常和CMS配合用；
CMS（Concurrent Mark Sweep）：主打低延迟（垃圾回收时尽量不让程序停顿太久），适合互联网应用（比如电商后台），用的是“标记-清除”算法；
G1（Garbage-First）：把堆分成很多小区域，优先回收垃圾多的区域，平衡了吞吐量和延迟。

【面试真题】Java中什么是反射

Sat, 14 Mar 2026 12:16:58 +0000

首先，官方的定义是这样的：

Java反射（Reflection）是指在程序运行时，动态获取类的完整结构信息（如构造方法、字段、方法），并能直接操作对象的属性或方法的机制。

正射 vs 反射

用【创建对象并调用方法】举个例子：

正射

就是我们平时写代码的方式，编译期就知道要操作的类是什么，直接 new 对象调用方法：

1
2
3

// 正射：编译期就确定是User类
User user = new User();
user.setName("张三"); // 直接调用方法

反射

动态的方式**，编译期**不知道要操作的类是什么，运行期才通过类名字符串动态获取类信息并操作：

// 反射：运行期才通过字符串"com.example.User"获取类
Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance(); // 动态创建对象
Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
setNameMethod.invoke(user, "张三"); // 动态调用方法

原理

反射的底层，其实是操作JVM加载类后生成的 Class对象。

先回顾一下类的加载过程：

编译期：.java文件被编译成 .class字节码文件；
类加载期：JVM的类加载器（ClassLoader）把 .class文件加载到内存，生成一个 java.lang.Class对象（这个对象包含了类的所有结构信息）；
运行期：反射就是通过这个 Class对象，逆向获取类的构造方法、字段、方法等信息，并进行操作。

说人话就是：Class对象是反射的入口，所有反射操作都从获取Class对象开始。

手撕一下，加深理解

1. 获取Class对象的3种方式

// 方式1：类名.class（最常用，编译期就能获取）
Class<User> clazz1 = User.class;

// 方式2：对象.getClass()（已有对象时用）
User user = new User();
Class<? extends User> clazz2 = user.getClass();

// 方式3：Class.forName("全类名")（最灵活，框架常用）
Class<?> clazz3 = Class.forName("com.example.User");

2. 操作构造方法：动态创建对象

Class<?> clazz = Class.forName("com.example.User");

// 获取无参构造方法并创建对象
Constructor<?> noArgConstructor = clazz.getDeclaredConstructor();
Object user1 = noArgConstructor.newInstance();

// 获取有参构造方法并创建对象
Constructor<?> argConstructor = clazz.getDeclaredConstructor(String.class, int.class);
Object user2 = argConstructor.newInstance("张三", 25);

3. 操作字段：动态获取/设置属性

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public字段并赋值
Field nameField = clazz.getField("name");
nameField.set(user, "张三");

// 获取private字段并赋值（需打破封装）
Field ageField = clazz.getDeclaredField("age");
ageField.setAccessible(true); // 关键：打破private访问限制
ageField.set(user, 25);

4. 操作方法：动态调用方法

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public方法并调用
Method setNameMethod = clazz.getMethod("setName", String.class);
setNameMethod.invoke(user, "张三");

// 获取private方法并调用（需打破封装）
Method getAgeMethod = clazz.getDeclaredMethod("getAge");
getAgeMethod.setAccessible(true);
int age = (int) getAgeMethod.invoke(user);

实际应用场景

Java生态里的核心框架几乎都用到了反射，比如：

1. Spring框架的IOC/DI

Spring的IOC容器就是通过反射创建对象并注入依赖的：

在XML里写 <bean id="user" class="com.example.User"/>➡️Spring读取XML，拿到全类名 com.example.User➡️Spring通过 Class.forName() 获取Class对象，动态创建Bean对象➡️如果Bean有依赖（比如 userService 依赖 userDao），Spring再通过反射注入依赖。

2. JDBC加载数据库驱动

Class.forName("com.mysql.cj.jdbc.Driver")，底层就是反射：首先加载驱动类到JVM，接下来驱动类的静态代码块会自动执行，把驱动注册到 DriverManager 里。

3. 注解处理

比如JUnit的 @Test 注解：JUnit启动后，通过反射扫描所有类，找到带 @Test 注解的方法，再通过反射动态调用这些方法执行测试。

反射的优缺点

优点

灵活性高：运行期才确定要操作的类，不需要在编译期写死；
动态性强：适合开发通用框架（如Spring、MyBatis），框架不需要知道用户会写什么类，通过反射就能动态适配。

缺点

性能低：反射比直接调用方法慢10-100倍（因为需要动态解析类信息），所以高频调用的场景（比如循环里）尽量不用反射；
破坏封装性：可以通过 setAccessible(true) 访问private字段/方法，破坏了Java的封装原则；
安全性问题：反射可以执行任意代码，可能被恶意利用。

【面试真题】缓存和数据库的一致性问题如何保证？

Fri, 13 Mar 2026 14:14:10 +0000

坦白说，这个问题本质上不是个纯技术方案题，而是高并发场景下，平衡【性能、可用性、一致性强度】的工程题。

核心是先看业务的一致性容忍度，再选对应方案，而且必须做好异常兜底，不然线上一定会出永久脏数据。

在电商场景中，绝大多数情况下优先保证最终一致性，只有金融级核心链路才会考虑强一致性。

先说标准流程：

读请求：先查缓存，命中直接返回；没命中就读数据库，把结果写回缓存再返回。
写请求：先更新数据库，再删除缓存。

为什么是【删除缓存】，而不是【更新缓存】？

一是并发写场景下，更新缓存一定会有数据覆盖的风险；

二是电商场景很多缓存值是多表关联算出来的，更新缓存的成本极高，不如删除后懒加载；

三是写多读少的场景，频繁更新缓存全是无效操作，浪费性能。

为什么是【先更库，再删缓存】，不能反过来？

如果你刚把缓存删了，数据库还没更新完，这时候高并发的读请求进来，缓存查不到，直接去数据库拉了旧数据，还写回了缓存。

等你数据库更新完，缓存里的旧数据就一直躺在那，除非缓存过期，不然用户一直看到的是错的数据。

但是，如果是先更库再删缓存，只有极小概率会出问题，比如：

读请求缓存没命中，正在读数据库的瞬间，写请求更新了数据库并删了缓存，之后读请求把旧数据写回缓存。

但是，但是啊，这个场景发生的条件太苛刻了，因为写数据库的耗时远大于读数据库，基本卡不中这个时间窗口，线上出问题的概率几乎可以忽略。

就算真的撞上了，还有缓存 TTL 兜底，最多就是短时间不一致，绝对不会出永久脏数据。

其实，这个方案最大的风险，是第二步删缓存失败。

同步删缓存如果失败，立刻把这个key丢到消息队列里做异步指数退避重试，设置最大重试次数，绝对不让缓存操作阻塞主流程。

高并发下的两个进阶方案

第一个是延迟双删，解决基础方案的极端并发问题。
“针对商品详情、营销活动这种超高并发读的场景，用延迟双删做加固，流程是：

先删除缓存➡️更新数据库➡️延迟500ms-1s，二次删除缓存。
第二次延迟删除，刚好能覆盖掉【数据库更新过程中，读请求写回缓存的旧数据】，彻底解决极端并发的脏数据问题。
其中，延迟时间必须大于【业务读请求的最大耗时 + 数据库主从同步延迟】。

第二个是基于Binlog的异步缓存淘汰。
用Binlog异步淘汰缓存，完全解耦业务和缓存操作。

业务代码只做一件事：更新数据库，完全不碰缓存。

然后用Canal监听数据库的binlog增量日志，只有主库事务提交成功，才会拿到数据变更事件，再异步去删除对应的缓存key。如果删除失败，就丢进死信队列重试，超过阈值直接触发告警。

强一致性方案

只有像支付账户余额、核心库存扣减这种，一分钱都不能错、零容错的场景，才会考虑强一致性方案，因为它的性能代价极大。
用Redisson的分布式读写锁，写请求加写锁，读请求加读锁，读写互斥，强制串行化，彻底避免并发问题。

但这个方案会严重降低系统吞吐量，高并发下很容易出现锁等待、超时问题，所以非核心场景，绝对不会用。

兜底机制

不管方案设计得多完美，线上一定会有意外，比如：

缓存集群炸了、消息队列挂了、binlog消费延迟了，没有兜底，就等着出线上事故。
可以采用以下兜底策略：

TTL兜底：所有缓存key必须设置合理的过期时间，哪怕所有机制都失效了，最多就是一段时间的不一致，缓存一过期，就自动拉取最新数据，绝对不会出现永久脏数据。
失败重试机制：所有缓存删除操作，必须有异步重试兜底，不能一次失败就放任脏数据存在。
降级开关：大促场景下，如果缓存集群扛不住了，直接开降级开关，所有请求切到读数据库，先保证用户能下单，别的都好说。

手撕真题-计算二叉树中两个节点之间的距离

Wed, 11 Mar 2026 22:26:31 +0000

思路

求解代码

 public class TreeDistance {

        /**
         * 计算两个节点在二叉树中的距离
         *
         * @param root 二叉树的根节点
         * @param p    第一个节点
         * @param q    第二个节点
         * @return 两个节点之间的距离
         */
        public int distanceBetweenNodes(TreeNode root, TreeNode p, TreeNode q) {
            // 首先找到两个节点的最近公共祖先(LCA)
            TreeNode lca = findLCA(root, p, q);
            // 计算节点p到LCA的深度
            int depthP = findDepth(lca, p);
            // 计算节点q到LCA的深度
            int depthQ = findDepth(lca, q);
            // 两个节点之间的距离等于它们到LCA的深度之和
            return depthP + depthQ;
        }

        /**
         * 查找二叉树中两个节点的最近公共祖先(LCA)
         *
         * @param root 二叉树的根节点
         * @param p    第一个目标节点
         * @param q    第二个目标节点
         * @return 最近公共祖先节点，如果其中一个节点是根节点，则返回该节点；如果两个节点分别在左右子树中，则返回它们的根节点
         */
        private TreeNode findLCA(TreeNode root, TreeNode p, TreeNode q) {
            // 如果根节点为空，或者根节点是p或q中的一个，直接返回根节点
            if (root == null || root == p || root == q) {
                return root;
            }
            // 递归查找左子树中的LCA
            TreeNode left = findLCA(root.left, p, q);
            // 递归查找右子树中的LCA
            TreeNode right = findLCA(root.right, p, q);
            // 如果左右子树都找到了非空节点，说明p和q分别在左右子树中，当前节点就是LCA
            if (left != null && right != null) {
                return root;
            }
            // 如果左子树找到非空节点，则返回左子树的结果，否则返回右子树的结果
            return left != null ? left : right;
        }


        /**
         * 查找目标节点在给定祖先节点下的深度
         *
         * @param ancestor 起始祖先节点
         * @param target   目标节点
         * @return 目标节点相对于祖先节点的深度，如果未找到则返回-1
         */
        private int findDepth(TreeNode ancestor, TreeNode target) {
            // 如果祖先节点为空，说明无法找到目标节点，返回-1
            if (ancestor == null) {
                return -1;
            }
            // 如果当前节点就是目标节点，深度为0
            if (ancestor == target) {
                return 0;
            }
            // 递归查找左子树
            int left = findDepth(ancestor.left, target);
            // 如果在左子树中找到目标节点，返回左子树深度+1
            if (left != -1) {
                return left + 1;
            }
            // 递归查找右子树
            int right = findDepth(ancestor.right, target);
            // 如果在右子树中找到目标节点，返回右子树深度+1，否则返回-1
            return right != -1 ? right + 1 : -1;
        }
    }

BISHI103 【模板】有依赖的背包问题

Tue, 10 Mar 2026 20:41:45 +0000

思路

求解代码

// 存储并查集中节点 i 的父节点
    private static int[] parent;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价钱
    private static int[] cost;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价值
    private static int[] value;

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取基础配置：n 朵云, m 个搭配关系, w 现有的钱
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);
        int w = Integer.parseInt(strA[2]);

        parent = new int[n + 1];
        cost = new int[n + 1];
        value = new int[n + 1];

        // 2. 初始化每朵云的属性，并初始化并查集（每个节点初始父节点为自己）
        for (int i = 1; i <= n; i++) {
            String[] strB = br.readLine().trim().split("\\s+");
            cost[i] = Integer.parseInt(strB[0]);
            value[i] = Integer.parseInt(strB[1]);
            parent[i] = i;
        }

        // 3. 处理搭配购买关系：使用并查集将必须一起买的云“联通”起来
        for (int i = 0; i < m; i++) {
            String[] strC = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(strC[0]);
            int v = Integer.parseInt(strC[1]);
            union(u, v);
        }

        // 4.将同一集合内所有云的价钱和价值全部累加到该集合的“根节点”上
        for (int i = 1; i <= n; i++) {
            int root = find(i);
            // 如果当前节点不是根节点，则将其属性转移给根节点
            if (root != i) {
                cost[root] += cost[i];
                value[root] += value[i];
                // 清空当前非根节点的属性，防止在后续背包计算中被重复统计
                cost[i] = 0;
                value[i] = 0;
            }
        }

        // 5. 执行 0/1 背包算法
        // dp[j] 表示在花费 j 元钱的情况下能获得的最大价值
        int[] dp = new int[w + 1];
        for (int i = 1; i <= n; i++) {
            // 只处理根节点（代表一个完整的“捆绑商品组”）
            if (parent[i] == i) {
                // 0/1 背包内层循环必须“逆序遍历”，防止同一商品被多次购买
                for (int j = w; j >= cost[i]; j--) {
                    // 状态转移方程：不买当前组 vs 买当前组（消耗钱，加价值）
                    dp[j] = Math.max(dp[j], dp[j - cost[i]] + value[i]);
                }
            }
        }

        // 6. 输出预算 w 内能获得的最大总价值
        out.println(dp[w]);

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 查找根节点（带路径压缩优化）
     */
    private static int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        // 将查找路径上的所有节点直接挂在根节点下，加速后续查找
        return parent[i] = find(parent[i]);
    }

    /**
     * 合并两个集合
     */
    private static void union(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI != rootJ) {
            // 将 I 树合并到 J 树下
            parent[rootI] = rootJ;
        }
    }

BISHI102 【模板】并查集

Tue, 10 Mar 2026 20:04:55 +0000

思路

求解代码

// 存储节点 i 的父节点编号；当 parent[i] == i 时，i 为该集合的根节点
    private static int[] parent;
    // 仅在 i 为根节点时有效，记录以 i 为根的集合中包含的元素总数
    private static int[] size;

    public static void main(String[] args) throws IOException {
        // 使用高性能输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 解析输入首行的 n (元素总数) 和 q (操作总数)
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        parent = new int[n + 1];
        size = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            // 初始状态下，每个元素自成一个集合，父节点指向自己
            parent[i] = i;
            // 每个初始集合的大小均为 1
            size[i] = 1;
        }

        while (q-- > 0) {
            String[] strB = br.readLine().trim().split("\\s+");
            int op = Integer.parseInt(strB[0]); // 操作类型编号

            switch (op) {
                case 1: {
                    // 合并操作：将 i 和 j 所在的两个集合合并为一个
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    union(i, j);
                    break;
                }
                case 2: {
                    // 判断 i 和 j 是否属于同一个集合
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    // 若两者的根节点相同，则在同一集合，输出 YES
                    out.println(find(i) == find(j) ? "YES" : "NO");
                    break;
                }
                case 3: {
                    // 获取 i 所在集合的元素总数
                    int i = Integer.parseInt(strB[1]);
                    // 必须先通过 find(i) 找到根节点，因为只有根节点的 size 是准确的
                    out.println(size[find(i)]);
                    break;
                }
            }
        }

        // 刷新缓冲区并释放 IO 资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 查找元素 i 所在集合的根节点
     * 在递归查找过程中，将路径上所有节点的父节点直接指向根节点
     */
    private static int find(int i) {
        // 如果自己就是根节点，直接返回
        if (parent[i] == i) {
            return i;
        }
        // 将查找到的根节点赋值给当前节点的 parent 数组
        return parent[i] = find(parent[i]);
    }

    /**
     * 将包含 i 和 j 的两个集合合并
     *
     * @param i 第一个元素
     * @param j 第二个元素
     */
    private static void union(int i, int j) {
        // 分别获取两个元素当前的根节点
        int rootI = find(i);
        int rootJ = find(j);

        // 如果根节点不同，说明处于不同集合，执行合并
        if (rootI != rootJ) {
            // 将 I 集合的根节点挂载到 J 集合的根节点之下
            parent[rootI] = rootJ;
            // 将被合并集合的规模累加到新的根节点 (rootJ) 上
            size[rootJ] += size[rootI];
        }
    }

BISHI101 世界树上找米库

Mon, 09 Mar 2026 22:05:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取树的节点数n
            int n = Integer.parseInt(br.readLine().trim());
            // 创建邻接表表示树
            List<Integer>[] adj = new ArrayList[n + 1];
            // 初始化邻接表
            for (int i = 1; i <= n; i++) {
                adj[i] = new ArrayList<>();
            }
            // 创建度数数组
            int[] deg = new int[n + 1];

            // 读取n-1条边，构建邻接表和度数数组
            for (int i = 0; i < n - 1; i++) {
                String[] edge = br.readLine().trim().split("\\s+");
                int u = Integer.parseInt(edge[0]);
                int v = Integer.parseInt(edge[1]);
                // 无向图，双向添加边
                adj[u].add(v);
                adj[v].add(u);

                // 更新节点的度数
                deg[u]++;
                deg[v]++;
            }
            // 创建距离数组，初始化为-1
            int[] dist = new int[n + 1];
            Arrays.fill(dist, -1);
            // 创建队列用于BFS
            Queue<Integer> queue = new LinkedList<>();

            // 将所有度为1的节点（叶子节点）加入队列，距离设为0
            for (int i = 1; i <= n; i++) {
                if (deg[i] == 1) {
                    dist[i] = 0;
                    queue.add(i);
                }
            }

            // BFS遍历树，计算每个节点到最近叶子节点的距离
            while (!queue.isEmpty()) {
                int u = queue.poll();
                // 遍历当前节点的所有邻接节点
                for (int v : adj[u]) {
                    if (dist[v] == -1) {
                        // 更新距离并加入队列
                        dist[v] = dist[u] + 1;
                        queue.add(v);
                    }
                }
            }

            // 找到最大距离
            int maxDist = -1;
            for (int i = 1; i <= n; i++) {
                // 只考虑非叶子节点
                if (deg[i] > 1) {
                    maxDist = Math.max(maxDist, dist[i]);
                }
            }

            // 收集所有距离为最大距离的非叶子节点（中心点）
            List<Integer> mikuPoints = new ArrayList<>();
            for (int i = 1; i <= n; i++) {
                if (deg[i] > 1 && dist[i] == maxDist) {
                    mikuPoints.add(i);
                }
            }

            // 输出中心点的数量
            out.println(mikuPoints.size());

            // 输出所有中心点
            for (int i = 0; i < mikuPoints.size(); i++) {
                out.print(mikuPoints.get(i) + (i == mikuPoints.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

BISHI100 【模板】二分图结构Ⅰ-A ‖ 染色判定：DFS

Mon, 09 Mar 2026 20:51:45 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入的第一行，包含两个整数n和m，分别表示顶点数和边数
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 顶点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表表示的无向图
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // color数组用于记录每个顶点的颜色，0表示未染色，1和2表示两种不同的颜色
        int[] color = new int[n + 1];
        boolean flag = true;  // 标记是否为二分图

        // 使用队列实现BFS
        Queue<Integer> queue = new LinkedList<>();

        // 从顶点1开始染色，并将其加入队列
        queue.add(1);
        color[1] = 1;

        // BFS遍历图
        while (!queue.isEmpty()) {

            int cur = queue.poll();  // 取出队首顶点

            // 遍历当前顶点的所有邻接顶点
            for (int neighbor : adj[cur]) {

                // 如果邻接顶点未被染色
                if (color[neighbor] == 0) {

                    // 将邻接顶点染成与当前顶点不同的颜色
                    color[neighbor] = 3 - color[cur];
                    queue.add(neighbor);  // 将邻接顶点加入队列
                } else if (color[neighbor] == color[cur]) {
                    // 如果邻接顶点与当前顶点颜色相同，则不是二分图
                    flag = false;
                    break;
                }
            }
        }

        // 输出结果：如果是二分图输出"YES"，否则输出"NO"
        out.println(flag ? "YES" : "NO");
        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

BISHI99 我朋友的朋友不是我的朋友

Sun, 08 Mar 2026 21:13:49 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取成员数 n 和 好友关系数 m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);

        // nameToID: 将字符串姓名映射为整数 ID，方便作为数组下标处理
        HashMap<String, Integer> nameToID = new HashMap<>();
        // idToName: 将整数 ID 映射回姓名，用于最后的结果输出
        String[] idToName = new String[n];
        // adj: 邻接表，存储每个人的好友列表
        List<Integer>[] adj = new ArrayList[n];
        // deg: 存储每个人的“社牛指数”（即节点的度数）
        int[] deg = new int[n];
        int idCount = 0; // 记录当前已分配的 ID 数量

        // 2. 构建图结构
        for (int i = 0; i < m; i++) {
            String[] pair = br.readLine().trim().split("\\s+");

            // 处理每一对好友关系中的两个姓名
            for (String name : pair) {
                // 如果是第一次见到的姓名，分配一个新的 ID 并初始化其邻接表
                if (!nameToID.containsKey(name)) {
                    idToName[idCount] = name;
                    adj[idCount] = new ArrayList<>();
                    nameToID.put(name, idCount++);
                }
            }

            // 获取两个好友对应的 ID
            int u = nameToID.get(pair[0]);
            int v = nameToID.get(pair[1]);

            // 无向图：双方互相添加进对方的好友列表
            adj[u].add(v);
            adj[v].add(u);

            // 双方的度数各加 1
            deg[u]++;
            deg[v]++;
        }

        // 3. 判定“社牛”成员
        List<String> res = new ArrayList<>();
        for (int i = 0; i < idCount; i++) {
            // 孤立点（没有好友的人）不符合社牛定义
            if (deg[i] == 0) {
                continue;
            }

            // sum: 累计该成员所有好友的度数总和
            long sum = 0;
            for (int neighbor : adj[i]) {
                sum += deg[neighbor];
            }

            /**
             * 判定公式推导：
             * 原条件：deg(x) > (sum_of_friends_deg / deg(x))
             * 变形得：deg(x) * deg(x) > sum_of_friends_deg
             *
             * 优点：避免浮点数除法导致的精度丢失。
             * 注意：deg 最大为 10^5，平方后达 10^10，超过了 int 范围，必须强转为 long 计算。
             */
            if ((long) deg[i] * deg[i] > sum) {
                res.add(idToName[i]);
            }
        }

        // 4. 输出处理
        if (res.isEmpty()) {
            // 若不存在任何社牛，输出 None
            out.println("None");
        } else {
            // 题目要求按字典序升序输出
            Collections.sort(res);
            for (int i = 0; i < res.size(); i++) {
                // 格式化输出：姓名之间用单个空格分隔
                out.print(res.get(i) + (i == res.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 5. 刷新缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

BISHI98 谍中谍中谍中谍中谍.

Sun, 08 Mar 2026 20:21:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取学生总人数 n
        int n = Integer.parseInt(br.readLine().trim());

        // 2. 读取指认关系字符串并按空格拆分
        String[] strA = br.readLine().trim().split("\\s+");

        // p[i] 存储学生 i 指认的学生编号
        // 使用 n+1 大小以便让下标 1~n 对应学生编号 1~n，符合直觉
        int[] p = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            p[i] = Integer.parseInt(strA[i - 1]);
        }

        // 3. 题目要求：假设老师最初抓到的是第 i 个学生
        // 我们需要对 1 到 n 每一个起点都模拟一遍追踪过程
        for (int i = 1; i <= n; i++) {
            // 获取从起点 i 开始追踪，最后被老师劝退的学生编号
            int res = findStu(i, p, n);

            // 格式化输出：除了最后一个数，后面都加空格
            out.print(res + (i == n ? "" : " "));
        }

        // 4. 刷新缓冲区确保数据完整写出，并按规范关闭流资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 追踪退学警告的过程
     *
     * @param start 老师最初抓到的学生编号
     * @param p     指认关系数组（图的邻接关系）
     * @param n     学生总数
     * @return      第一个收到两次警告（即导致退学）的学生编号
     */
    private static int findStu(int start, int[] p, int n) {
        // visited[i] 记录学生 i 是否已经收到过一次警告
        // 每一轮新起点都需要一个全新的标记数组
        boolean[] visited = new boolean[n + 1];

        int cur = start; // 从老师抓到的第一位学生开始

        // 由于学生数量有限且出度为 1，追踪过程必然会进入一个环并死循环
        // 我们通过 while(true) 配合内部 return 退出
        while (true) {
            // 如果当前学生 cur 的 visited 标记已经是 true，
            // 说明这是他第二次被抓到了，触发“劝说退学”逻辑，直接返回他
            if (visited[cur]) {
                return cur;
            }

            // 第一次抓到该学生，打上标记（发出第一次退学警告）
            visited[cur] = true;

            // 根据供述，抓取下一个被指认的人
            cur = p[cur];
        }
    }

BISHI97旺仔哥哥走迷宫

Sat, 07 Mar 2026 20:12:40 +0000

思路

求解代码


    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，获取节点数n和边数m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数量
        int m = Integer.parseInt(strA[1]);  // 边的数量
        int[] t = new int[n + 1];  // 存储每个节点的类型，索引从1开始
        // 读取第二行输入，获取每个节点的类型
        String[] strB = br.readLine().trim().split("\\s+");

        // 将节点类型数据存入数组t，索引从1开始
        for (int i = 1; i <= n; i++) {
            t[i] = Integer.parseInt(strB[i - 1]);
        }

        // 创建邻接表表示的图结构
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // 检查起点或终点是否为类型1，如果是则直接输出"No"
        if (t[1] == 1 || t[n] == 1) {
            out.println("No");
        } else {
            // 调用BFS算法判断路径是否可行
            if (bfs(n, adj, t)) {
                out.println("Yes");
            } else {
                out.println("No");
            }
        }

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索(BFS)算法判断从节点1到节点n是否存在有效路径
     *
     * @param n   节点总数
     * @param adj 邻接表，表示图的连接关系
     * @param t   数组，标记节点的状态(0表示可通过，非0表示不可通过)
     * @return 如果存在从节点1到节点n的有效路径则返回true，否则返回false
     */
    private static boolean bfs(int n, List<Integer>[] adj, int[] t) {
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();
        // 创建访问标记数组，记录节点是否被访问过
        boolean[] visited = new boolean[n + 1];

        // 从节点1开始搜索
        queue.add(1);
        visited[1] = true;

        // 当队列不为空时，继续搜索
        while (!queue.isEmpty()) {
            // 取出队首节点
            int cur = queue.poll();
            // 如果到达目标节点n，返回true
            if (cur == n) {
                return true;
            }

            // 遍历当前节点的所有邻接节点
            for (int neighbor : adj[cur]) {
                // 如果邻接节点可通过且未被访问过
                if (t[neighbor] == 0 && !visited[neighbor]) {
                    // 标记为已访问并入队
                    visited[neighbor] = true;
                    queue.add(neighbor);
                }
            }
        }
        // 队列已空未到达目标节点，返回false
        return false;
    }

BISHI96 先序遍历、中序遍历和后序遍历

Sat, 07 Mar 2026 19:38:45 +0000

思路

求解代码

// 使用数组模拟指针，lc[i] 存储节点 i 的左孩子，rc[i] 存储右孩子
    private static int[] lc, rc;

    // 使用 StringBuilder 缓存结果
    private static StringBuilder preOrder = new StringBuilder();
    private static StringBuilder inOrder = new StringBuilder();
    private static StringBuilder postOrder = new StringBuilder();

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        // 边界情况：空树
        if (n == 0) {
            return;
        }

        // 初始化结构：n+1 长度是为了匹配从 1 开始的节点编号
        lc = new int[n + 1];
        rc = new int[n + 1];
        boolean[] hasParent = new boolean[n + 1]; // 用于寻找根节点（根节点没有父节点）

        // 使用邻接表暂时存储“父 -> 子”的原始指向关系，随后再按规则分配左右
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取 n-1 条边，构建树的层级关系
        for (int i = 0; i < n - 1; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]); // 父节点
            int v = Integer.parseInt(edge[1]); // 子节点
            adj[u].add(v);
            hasParent[v] = true; // 只要被指向，就说明该节点不是根节点
        }

        /**
         * 根据题目定义的规则，将 adj 里的子节点分配到 lc 或 rc
         */
        for (int i = 1; i <= n; i++) {
            // 父节点拥有两个孩子
            if (adj[i].size() == 2) {
                int c1 = adj[i].get(0);
                int c2 = adj[i].get(1);
                // 编号小者为左，大者为右
                lc[i] = Math.min(c1, c2);
                rc[i] = Math.max(c1, c2);
            }
            // 父节点仅有一个孩子
            else if (adj[i].size() == 1) {
                int child = adj[i].get(0);
                // 子节点编号 > 父节点编号 ➜ 视为左孩子；反之 ➜ 视为右孩子
                if (child > i) {
                    lc[i] = child;
                } else {
                    rc[i] = child;
                }
            }
        }

        // 寻找整棵树的唯一根节点
        int root = 1;
        for (int i = 1; i <= n; i++) {
            if (!hasParent[i]) {
                root = i;
                break;
            }
        }

        // 从根节点开始DFS
        traverse(root);

        // 格式化输出
        out.println(preOrder.toString().trim());
        out.println(inOrder.toString().trim());
        out.println(postOrder.toString().trim());

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 深度优先遍历 (DFS) 方法
     *
     * @param cur 当前正在访问的节点索引
     */
    private static void traverse(int cur) {
        // 基准情形：如果当前节点为 0，说明触碰到了空叶子节点，停止向下延伸
        if (cur == 0) {
            return;
        }

        /**
         * 1. 先序遍历 (Pre-order)：[中] -> 左 -> 右
         * 刚进入当前节点时立即记录。
         */
        preOrder.append(cur).append(" ");

        // 向左延伸
        traverse(lc[cur]);

        /**
         * 2. 中序遍历 (In-order)：左 -> [中] -> 右
         * 当左子树全部处理完毕回溯到当前点时记录。
         */
        inOrder.append(cur).append(" ");

        // 向右延伸
        traverse(rc[cur]);

        /**
         * 3. 后序遍历 (Post-order)：左 -> 右 -> [中]
         * 当左右子树全部处理完毕，即将彻底离开当前点时记录。
         */
        postOrder.append(cur).append(" ");
    }

BISHI95 【模板】链式前向星

Fri, 06 Mar 2026 21:04:50 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割字符串并转换为整数n和m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表，大小为n+1（节点从1开始编号）
        List<Integer>[] adj = new ArrayList[n + 1];
        // 初始化每个节点的邻接表
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取m条边，构建无向图的邻接表
        for (int i = 0; i < m; i++) {

            // 读取边的两个端点
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            // 无向图，两个方向都添加
            adj[u].add(v);
            adj[v].add(u);
        }

        // 遍历每个节点，输出其邻接节点
        for (int i = 1; i <= n; i++) {
            // 如果节点没有邻接节点，输出"None"
            if (adj[i].isEmpty()) {
                out.println("None");
            } else {
                // 对邻接节点进行排序
                Collections.sort(adj[i]);

                // 输出排序后的邻接节点
                for (int j = 0; j < adj[i].size(); j++) {
                    // 如果是最后一个节点，直接输出，否则输出空格
                    out.print(adj[i].get(j) + (j == adj[i].size() - 1 ? "" : " "));
                }
                out.println();
            }
        }


        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

BISHI94 【模板】马拉车算法

Fri, 06 Mar 2026 20:32:16 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果，提高IO效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入字符串并去除首尾空格
        String s = br.readLine().trim();

        // 处理空字符串或null值的情况
        if (s == null || s.length() == 0) {
            out.println(0);  // 输出0
            out.flush();     // 确保所有输出都被刷新
            return;          // 提前返回
        }

        // 调用manacher算法处理字符串并输出结果
        out.println(manacher(s));
        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();   // 关闭输入流
    }

    /**
     * Manacher算法实现，用于查找字符串中的最长回文子串的长度
     * 该算法通过预处理字符串和利用回文对称性来高效地找到最长回文子串
     *
     * @param s 输入的字符串
     * @return 返回最长回文子串的长度
     */
    private static int manacher(String s) {
        // 构造新的字符串，以^开头，$结尾，并在每个字符间插入#，这样可以统一处理奇数和偶数长度的回文
        StringBuilder sb = new StringBuilder("^");

        // 在原字符串的每个字符前后添加特殊字符#
        for (char c : s.toCharArray()) {
            sb.append("#").append(c);
        }

        // 添加结尾标记
        sb.append("#$");

        // 将构造好的字符串转换为字符数组
        char[] t = sb.toString().toCharArray();

        // 获取新字符串的长度
        int n = t.length;
        // 创建数组p，p[i]表示以t[i]为中心的最长回文半径
        int[] p = new int[n];
        // c表示当前回文中心，r表示当前回文右边界
        int c = 0, r = 0;
        // 记录最长回文半径
        int maxLen = 0;

        // 遍历字符串，跳过首尾的特殊字符
        for (int i = 1; i < n - 1; i++) {
            // 利用回文对称性，如果i在当前回文范围内，则获取其对称位置的回文半径
            p[i] = r > i ? Math.min(r - i, p[2 * c - i]) : 0;

            // 尝试扩展以i为中心的回文
            while (t[i + p[i] + 1] == t[i - p[i] - 1]) {
                p[i]++;
            }

            // 如果当前回文右边界超过了r，更新中心和右边界
            if (i + p[i] > r) {
                c = i;
                r = i + p[i];
            }

            // 更新最大回文半径
            maxLen = Math.max(maxLen, p[i]);
        }

        // 返回最长回文半径，也就是最长回文子串的长度
        return maxLen;
    }

BISHI93 【模板】Trie 字典树

Thu, 05 Mar 2026 22:07:17 +0000

思路

求解代码

/**
     * trie[p][i]: 字典树的节点存储。
     * 第一维 p 代表节点的编号（行号）；
     * 第二维 i 代表字符的映射索引（0-51）。
     * 值存储的是该字符指向的下一个节点的编号。
     */
    private static int[][] trie = new int[1000005][52];

    /**
     * count[p]: 前缀统计的核心。
     * 记录有多少个模式串在插入过程中经过了编号为 p 的节点。
     * 因为我们要统计“以某串为前缀的个数”，所以每经过一个点都要加1。
     */
    private static int[] count = new int[1000005];

    /**
     * nodes: 记录当前字典树已经创建的节点总数。
     * 编号 0 始终代表根节点（不存储具体字符）。
     */
    private static int nodes = 0;

    public static void main(String[] args) throws IOException {
        // 使用高效的输入输出流处理百万级数据，防止超时
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行：模式串数量 n 和查询次数 q
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        // 1. 构建字典树阶段
        for (int i = 0; i < n; i++) {
            insert(br.readLine().trim());
        }

        // 2. 查询阶段
        for (int i = 0; i < q; i++) {
            // 直接输出以该文本串为前缀的模式串数量
            out.println(query(br.readLine().trim()));
        }

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 将字符映射到 0-51 的索引空间。
     * 区分大小写：'A'-'Z' 映射到 0-25，'a'-'z' 映射到 26-51。
     */
    private static int getIndex(char c) {
        return c >= 'A' && c <= 'Z' ? c - 'A' : c - 'a' + 26;
    }

    /**
     * 模式串插入方法
     * 核心逻辑：沿着路径在每个经过的节点打标记计数。
     */
    private static void insert(String s) {
        int p = 0; // 从根节点 (编号 0) 开始
        for (char c : s.toCharArray()) {
            int i = getIndex(c);
            // 如果当前字符在当前节点下没有对应的子节点，则新建一个
            if (trie[p][i] == 0) {
                trie[p][i] = ++nodes;
            }
            // 移动到子节点
            p = trie[p][i];
            /**
             * 关键：只要经过这个节点，count 就自增。
             * 这样 count[p] 就代表了有多少个单词是以“从根到当前点”这一串字符为前缀的。
             */
            count[p]++;
        }
    }

    /**
     * 文本串查询方法
     * 核心逻辑：在字典树中顺着文本串寻找路径，若能走完路径，返回最后的 count。
     */
    private static int query(String t) {
        int p = 0; // 从根节点开始
        for (char c : t.toCharArray()) {
            int i = getIndex(c);
            /**
             * 如果在路径中发现某个字符没有对应的分支，
             * 说明没有任何一个模式串包含这个前缀，直接返回 0。
             */
            if (trie[p][i] == 0) {
                return 0;
            }
            p = trie[p][i]; // 顺着路径向下走
        }
        /**
         * 成功走完文本串 t 的所有字符，
         * 此时节点 p 的 count 值就是在插入阶段经过该点的字符串总数。
         */
        return count[p];
    }

BISHI92 【模板】前缀函数（kmp）

Thu, 05 Mar 2026 20:58:37 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 创建缓冲读取器，用于从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 创建打印输出器，用于向标准输出打印数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        // 读取测试用例的数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取一行输入并分割成字符串数组
            String[] s = br.readLine().trim().split("\\s+");
            // 获取字符串的长度n
            int n = Integer.parseInt(s[0]);

            // 计算前缀函数数组
            int[] pi = computePre(s[1], n);

            // 输出前缀函数数组，元素间用空格分隔
            for (int i = 0; i < n; i++) {
                out.print(pi[i] + (i == n - 1 ? "" : " "));
            }
            // 换行
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 计算字符串的前缀函数（Prefix Function）
     * 前缀函数pi[i]表示字符串s[0..i]的最长相等前后缀的长度（不包括s[0..i]本身）
     *
     * @param s 输入的字符串
     * @param n 字符串的长度
     * @return 返回前缀函数数组pi，其中pi[i]表示s[0..i]的最长相等前后缀长度
     */
    private static int[] computePre(String s, int n) {
        int[] pi = new int[n];  // 初始化前缀函数数组，长度为n

        // 从第二个字符开始遍历字符串
        for (int i = 1; i < n; i++) {
            int j = pi[i - 1];  // 初始化j为前一个字符的前缀函数值

            // 当j大于0且当前字符不匹配时，通过前缀函数回退
            while (j > 0 && s.charAt(i) != s.charAt(j)) {
                j = pi[j - 1];  // 回退到前一个可能匹配的位置
            }

            // 如果当前字符匹配，则增加匹配长度
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }

            // 将当前字符的前缀函数值存入数组
            pi[i] = j;
        }
        return pi;  // 返回计算得到的前缀函数数组
    }

【DFS+剪枝】BISHI91 拼接木棍

Wed, 04 Mar 2026 22:20:09 +0000

思路

求解代码

// n: 小木棒总数, sum: 所有木棒总长度, targetL: 目标原始长度, numbers: 目标原始木棒根数
    private static int n, sum, targetL, numbers;
    private static Integer[] a; // 存储砍断后的小木棒长度

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        n = Integer.parseInt(br.readLine().trim());
        String[] s = br.readLine().trim().split("\\s+");
        a = new Integer[n];
        boolean[] used = new boolean[n]; // 标记每根小木棒是否已被乔治使用
        sum = 0;
        int maxL = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
            sum += a[i];
            maxL = Math.max(maxL, a[i]); // 原始长度至少要等于最长的那根小木棒
        }

        // 【剪枝优化 1】：降序排序。
        // 优先尝试长木棒。因为长木棒对位置要求更苛刻，如果它拼不通，能更早触发回溯。
        Arrays.sort(a, (x1, x2) -> (x2 - x1));

        // 枚举原始木棒可能的长度 targetL
        // 范围：从最长的那根开始，直到所有木棒的总和
        for (targetL = maxL; targetL <= sum; targetL++) {

            // 【条件约束】：原始长度必须能被总长度整除，否则乔治不可能拼成同样长的木棒
            if (sum % targetL != 0) {
                continue;
            }

            numbers = sum / targetL; // 计算在当前 targetL 下应该拼出多少根

            // 尝试拼凑，初始：已完成0根，当前长度0，从第0个小木棒开始找
            if (dfs(0, 0, 0, used)) {
                out.println(targetL); // 找到第一个可行的最小长度，即为答案
                break;
            }
        }
        out.flush();
        out.close();
        br.close();
    }

    /**
     * DFS 拼凑过程
     *
     * @param completed 已完整拼好的原始木棒根数
     * @param currentL  当前正在拼的那根原始木棒已经达到的长度
     * @param idx       为了避免重复组合，从数组的哪一个下标开始挑选下一根小木棒
     * @param used      使用情况记录
     */
    private static boolean dfs(int completed, int currentL, int idx, boolean[] used) {
        // 【递归出口】：如果乔治拼好了所有原始木棒，大功告成
        if (completed == numbers) {
            return true;
        }

        // 如果当前这根拼满了，开启下一根木棒的拼凑
        if (currentL == targetL) {
            return dfs(completed + 1, 0, 0, used);
        }

        for (int i = idx; i < n; i++) {
            // 如果这根用过了，或者放进去就超过了目标长度，跳过
            if (used[i] || currentL + a[i] > targetL) {
                continue;
            }

            // 【做选择】：尝试放这根木棒
            used[i] = true;
            if (dfs(completed, currentL + a[i], i + 1, used)) {
                return true;
            }

            // 【撤销选择】：刚才的尝试失败了，拿出来
            used[i] = false;

            // --- 核心剪枝策略 (极其关键) ---

            // 【剪枝优化 2】：首棒失败判定
            // 如果此时 currentL 为 0，说明我们正在尝试拼一根新木棒的第一部分。
            // 如果第一部分用这根最长的木棒都拼不出来，那后面更拼不出来了。

            // 【剪枝优化 3】：末棒失败判定
            // 如果加上这根木棒刚好填满了 targetL，但在后续递归中失败了，
            // 说明用这根刚好填满的方案不行，那么换用几根更碎的小木棒来填这个坑也肯定不行。
            if (currentL == 0 || currentL + a[i] == targetL) {
                return false;
            }

            // 【剪枝优化 4】：去重剪枝
            // 如果当前长度的木棒不行，那后面相同长度的木棒也肯定不行，直接跳过。
            while (i + 1 < n && a[i + 1].equals(a[i])) {
                i++;
            }
        }
        return false;
    }

BISHI90 【模板】记忆化搜索

Wed, 04 Mar 2026 20:51:44 +0000

思路

求解代码

 private static final int MOD = 1000000007;
    private static long[][][] memory = new long[101][101][101];

    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String[] s = br.readLine().trim().split("\\s+");
            int a = Integer.parseInt(s[0]);
            int b = Integer.parseInt(s[1]);
            int c = Integer.parseInt(s[2]);
            out.println(solve(a, b, c));
        }


        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

    /**
     * 这是一个递归求解函数，使用记忆化技术来优化性能
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @param c 第三个参数
     * @return 返回计算结果，类型为long
     */
    private static long solve(int a, int b, int c) {
        // 如果任一参数小于等于0，返回1
        if (a <= 0 || b <= 0 || c <= 0) {
            return 1;
        }

        // 如果结果已经计算过并存储在memory中，直接返回存储的结果
        if (memory[a][b][c] != 0) {
            return memory[a][b][c];
        }

        long res; // 用于存储计算结果

        // 当a<b且b<c时，使用特定的递归公式计算
        if (a < b && b < c) {
            res = (solve(a, b, c - 1) + solve(a, b - 1, c - 1)) % MOD;
            res = (res - solve(a, b - 1, c) + MOD) % MOD;
        } else {
            res = (solve(a - 1, b, c) + solve(a - 1, b - 1, c)) % MOD;
            res = (res + solve(a - 1, b, c - 1)) % MOD;
            res = (res - solve(a - 1, b - 1, c - 1) + MOD) % MOD;
        }
        return memory[a][b][c] = res;
    }

零成本上线个人项目 ——ngrok 仅穿透前端实现公网访问

Wed, 04 Mar 2026 17:39:43 +0000

开发个人项目时，想让他人访问往往需要购买服务器、配置域名解析，成本高且流程繁琐。

本文介绍一种零成本方案 —— 仅穿透前端即可实现内网个人项目的公网访问。

ngrok 账号注册与工具准备

首先在https://ngrok.com/ 官网注册一个账号，就能获得一个免费的dev结尾的域名。

注册好之后，下载对应的zip压缩包

在官网个人后台 / 仪表盘（Dashboard）可直接复制个人专属的 Authtoken。

分框架适配配置

如果前端是用 Vite + React 的项目，需要在 vite.config.js 文件加上allowedHosts这一行代码：

// vite.config.js
export default defineConfig({
  server: {
    allowedHosts: ['xxx.dev']  // ngrok 域名
  }
})

如果前端是基于 Umi Max + Ant Design Pro 的项目，前端默认是跑在 localhost:8000（umi dev），则需要修改2个文件。

1.config/config.ts

在文件里加上如下 proxy 部分：

// config/config.ts
export default defineConfig({
  // ... 其他配置 ...

  proxy: {
    '/api/': {
      target: 'http://localhost:[项目后端的端口号]',
      changeOrigin: true,
      // 根据后端实际路由决定是否 rewrite
      // 如果后端接口路径就是 /api/xxx 开头 → 不要 rewrite
      // 如果后端是 /user/xxx（无 /api 前缀） → 加下面这行
      // pathRewrite: { '^/api': '' },
    },
  },

  // ... 其他配置 ...
});

这段只在 umi dev / npm run dev 时生效。

2.src/app.tsx

找到 request 配置，把 baseURL 相关全部注释或删除：

// src/app.tsx

export const request: RequestConfig = {
  // ！！！ 下面这整段注释掉或删除 ！！！
  // baseURL: "http://localhost:[项目后端的端口号]",

  // 保持这两个（ngrok 警告页绕过 + cookie 跨域）
  withCredentials: true,
  headers: {
    'ngrok-skip-browser-warning': 'true',
  },

  ...errorConfig,
};

项目启动与公网访问

接下来，依次启动后端和前端，将之前下载好的压缩包解压后直接双击 exe 即可打开命令行，执行以下命令：

1
2
3

ngrok config add-authtoken [YourAuthtoken]

ngrok http [项目前端的端口号]

private static int N, M;  // 网格的行数和列数
    private static int[][] grid;  // 存储网格数据的二维数组
    private static boolean[][] used;  // 标记网格位置是否被使用过的二维数组
    private static long ans;  // 存储最终答案的最大值

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            N = Integer.parseInt(str[0]);
            M = Integer.parseInt(str[1]);

            grid = new int[N][M];  // 初始化网格数组
            used = new boolean[N][M];  // 初始化使用标记数组
            ans = 0;  // 重置答案为0

            // 读取网格数据
            for (int j = 0; j < N; j++) {
                String[] gridStr = br.readLine().trim().split("\\s+");
                for (int k = 0; k < M; k++) {
                    grid[j][k] = Integer.parseInt(gridStr[k]);  // 将字符串转换为整数存入网格
                }
            }
            backtrack(0, 0);  // 从第一个位置开始回溯
            out.println(Math.max(ans, 0));  // 输出最大答案，至少为0
        }

        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();  // 关闭输入流


    }


    /**
     * 回溯算法方法，用于在网格中寻找最大可能值
     *
     * @param index  当前处理的位置索引，从0到N*M-1
     * @param curAns 当前累计的答案值
     */
    private static void backtrack(int index, long curAns) {
        // 基本情况：如果已经处理完所有网格位置
        if (index == N * M) {
            // 更新最大答案值
            ans = Math.max(ans, curAns);
            return;
        }

        // 计算当前索引对应的行和列
        int row = index / M;  // 计算当前行号
        int col = index % M;  // 计算当前列号

        // 情况1：不选择当前网格位置，直接处理下一个位置
        backtrack(index + 1, curAns);

        // 情况2：如果当前位置可以安全选择
        if (isSafe(row, col)) {
            // 标记当前位置为已使用
            used[row][col] = true;
            // 选择当前位置，累加其值并处理下一个位置
            backtrack(index + 1, curAns + grid[row][col]);
            // 回溯：撤销当前位置的使用标记
            used[row][col] = false;
        }
    }

    /**
     * 检查指定位置是否安全，即其周围8个方向（包括自身）是否都没有被使用过
     *
     * @param row 当前行索引
     * @param col 当前列索引
     * @return 如果周围8个方向都没有被使用过，返回true；否则返回false
     */
    private static boolean isSafe(int row, int col) {
        // 遍历当前位置的周围8个方向（包括自身）
        for (int drow = -1; drow <= 1; drow++) {
            for (int dcol = -1; dcol <= 1; dcol++) {
                // 计算下一个位置的行索引
                int nextRow = row + drow;
                // 计算下一个位置的列索引
                int nextCol = col + dcol;

                // 检查下一个位置是否在有效范围内
                if (nextRow >= 0 && nextRow < N && nextCol >= 0 && nextCol < M) {
                    // 如果下一个位置已经被使用过，则返回false
                    if (used[nextRow][nextCol]) {
                        return false;
                    }
                }

            }
        }
        // 如果周围8个方向都没有被使用过，则返回true
        return true;
    }

BISHI78 全排列

Thu, 26 Feb 2026 20:32:41 +0000

思路

【回溯】没有重复项数字的全排列这个是核心代码模式的题解。现在这题是ACM模式的题解。

求解代码

/**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取整数n，并去除可能的空白字符
        int n = Integer.parseInt(br.readLine().trim());

        // 初始化一个长度为n的数组，用于存储排列结果
        int[] track = new int[n];
        // 初始化一个长度为n+1的布尔数组，用于标记数字是否已被使用
        boolean[] used = new boolean[n + 1];

        // 调用回溯方法生成全排列
        backtrack(n, 0, track, used, out);
        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();


    }

    /**
     * 回溯法生成全排列
     *
     * @param n     排列的数字范围，1到n
     * @param depth 当前递归的深度，即已经确定的前几个数字的数量
     * @param track 当前排列的路径，存储已经确定的数字序列
     * @param used  标记数组，记录数字是否已经在当前排列中使用过
     * @param out   用于输出结果的打印流
     */
    private static void backtrack(int n, int depth, int[] track, boolean[] used, PrintWriter out) {
        // 如果当前深度等于n，说明已经生成了一个完整的排列
        if (depth == n) {
            // 输出当前排列
            for (int i = 0; i < n; i++) {
                // 如果是最后一个数字，直接输出，否则输出数字加空格
                out.print(track[i] + (i == n - 1 ? "" : " "));
            }
            // 换行，准备输出下一个排列
            out.println();
            // 返回上一层递归
            return;
        }

        // 遍历所有可能的数字
        for (int i = 1; i <= n; i++) {
            // 如果数字i还没有被使用过
            if (!used[i]) {
                // 标记数字i为已使用
                used[i] = true;
                // 将数字i放入当前深度的位置
                track[depth] = i;

                // 递归处理下一个位置
                backtrack(n, depth + 1, track, used, out);

                // 回溯，撤销选择，将数字i标记为未使用，以便尝试其他可能性
                used[i] = false;
            }
        }
    }

【DFS】BISHI77数水坑

Wed, 25 Feb 2026 22:45:37 +0000

思路

求解代码

 /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        int ans = 0;  // 用于记录找到的'W'的数量

        // 遍历网格中的每个元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前元素是'W'，则增加计数器并执行深度优先搜索
                if (gridStr[i][j] == 'W') {
                    ans++;  // 增加计数器
                    dfs(gridStr, i, j);  // 执行深度优先搜索，标记相邻的'W'
                }

            }
        }

        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索(DFS)方法，用于遍历网格中的连通区域
     *
     * @param grid 二维字符网格
     * @param i    当前处理的行坐标
     * @param j    当前处理的列坐标
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前格子是'.'，表示已经是访问过的格子，直接返回
        if (grid[i][j] == '.') {
            return;
        }

        // 将当前格子标记为已访问（用'.'表示）
        grid[i][j] = '.';

        // 遍历当前格子的8个相邻方向（包括对角线方向）
        for (int di = -1; di <= 1; di++) {
            for (int dj = -1; dj <= 1; dj++) {
                // 跳过当前格子本身
                if (di == 0 && dj == 0) {
                    continue;
                }
                // 递归处理相邻格子
                dfs(grid, i + di, j + dj);
            }
        }

    }

【DFS】BISHI76 迷宫寻路

Wed, 25 Feb 2026 21:45:53 +0000

思路

求解代码

private static String ans = "No";

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        // 从起点(0,0)开始深度优先搜索
        dfs(gridStr, 0, 0);
        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索（DFS）方法，用于在二维网格中寻找从起点到终点的路径
     *
     * @param grid 二维字符网格，包含可走的路径和障碍物
     * @param i    当前搜索的行索引
     * @param j    当前搜索的列索引
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 检查当前单元格是否是障碍物（已访问过的标记为'#'）
        if (grid[i][j] == '#') {
            return;
        }

        // 检查是否到达终点（右下角）
        if (i == grid.length - 1 && j == grid[0].length - 1) {
            ans = "Yes";  // 找到路径，设置答案为"Yes"
            return;
        }

        // 标记当前单元格为已访问（使用'#'作为标记）
        grid[i][j] = '#';
        // 向上搜索
        dfs(grid, i - 1, j);
        // 向下搜索
        dfs(grid, i + 1, j);
        // 向左搜索
        dfs(grid, i, j - 1);
        // 向右搜索
        dfs(grid, i, j + 1);
    }

开源必备：Git 仓库敏感日志文件清理与脱敏教程

Wed, 25 Feb 2026 19:45:42 +0000

在做个人项目的时候，有时为了开源需要对数据进行脱敏，尤其是一些log文件。

先确认代码里还有没有其他“XXX”？

执行这条精准排除命令：

`1`	`git grep -w "XXX" $(git rev-list --all) -- ":!*.log"`

如果没有输出，证明没有包含相关字符串的文件，如果有输出则需要进行如下操作，彻底删除文件的历史。

⚠️警告，以下操作会改写所有 Commit 的 Hash 值，必须强制推送！

1.在项目根目录执行清洗命令

1
2
3

git filter-branch --force --index-filter \
'git rm --cached --ignore-unmatch "*/hs_err_pid*.log"' \
--prune-empty --tag-name-filter cat -- --all

执行过程中终端会疯狂滚动 “Rewriting …”，耐心等待即可。

2. 清理 Git 内部备份

1
2
3

rm -rf .git/refs/original/
git reflog expire --expire=now --all
git gc --prune=now

3. 防止再次犯错，在 `.gitignore` 中永久屏蔽

1
2
3

# JVM 崩溃日志
hs_err_pid*.log
*.log

4.删除本地log文件，强制推送覆盖远程仓库

# 删除当前文件
git rm --force hs_err_pid*.log
git add .gitignore
git commit -m "chore: 删除误上传的JVM崩溃日志 + 屏蔽所有.log文件提交"
git push origin --force --all

5.验证是否彻底干净

`1`	`git grep -w "XXX" $(git rev-list --all)`

如果没有任何输出，则大功告成。

BISHI75 阶幂

Tue, 24 Feb 2026 21:40:06 +0000

如果 $a^b \ge m$，返回 $(a^b \bmod m) + m$；否则直接返回 $a^b$。

思路

代码实现

 private static long MOD = 1000000007;  // 定义模数常量，用于取模运算
    private static List<Long> mList = new ArrayList<>();  // 存储欧拉函数值的列表

    /**
     * 主方法，处理输入输出并计算结果
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入的长整型数值n
        long n = Long.parseLong(br.readLine().trim());

        // 初始化tmp为MOD值，并添加到mList列表中
        long tmp = MOD;
        mList.add(tmp);

        // 计算欧拉函数值直到tmp为1，并将结果添加到mList中
        while (tmp > 1) {
            tmp = getPhi(tmp);
            mList.add(tmp);
        }

        // 调用solve方法计算结果并输出，取模MOD
        out.println(solve(n, 0) % MOD);


        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 递归求解模幂运算的结果
     *
     * @param curN 当前处理的数字
     * @param idx  当前处理的mList中的索引位置
     * @return 返回模幂运算的结果
     */
    private static long solve(long curN, int idx) {
        // 获取当前索引对应的模数
        long m = mList.get(idx);
        // 如果模数为1，任何数对1取模结果都是1
        if (m == 1) {
            return 1;
        }

        // 如果当前数字为1，1的任何次幂都是1
        if (curN == 1) {
            return 1;
        }

        // 递归计算指数部分，curN-1和idx+1表示递归处理下一个数字和下一个模数
        long exp = solve(curN - 1, idx + 1);

        // 计算curN的exp次幂对m取模的结果
        return safePow(curN, exp, m);
    }

    /**
     * 安全的幂运算函数，计算 a^b mod m，并处理可能的溢出情况
     *
     * @param a 底数
     * @param b 指数
     * @param m 模数
     * @return 计算结果，如果发生溢出则返回结果加上模数后的值
     */
    private static long safePow(long a, long b, long m) {
        long res = 1;        // 初始化结果为1
        boolean overflow = false;  // 溢出标志，初始为false

        // 如果底数大于等于模数，进行取模操作，并标记可能溢出
        if (a >= m) {
            overflow = true;
            a %= m;
        }

        // 使用快速幂算法计算幂运算
        while (b > 0) {
            // 如果当前指数的二进制最低位为1（即指数为奇数）
            if ((b & 1) == 1) {
                res = res * a;   // 将当前底数乘入结果
                // 如果结果大于等于模数，进行取模操作，并标记可能溢出
                if (res >= m) {
                    overflow = true;
                    res %= m;
                }
            }

            b >>= 1;   // 指数右移一位，相当于除以2
            // 如果指数还有剩余位
            if (b > 0) {
                a = a * a;   // 底数平方
                // 如果平方后的底数大于等于模数，进行取模操作，并标记可能溢出
                if (a >= m) {
                    overflow = true;
                    a %= m;
                }
            }
        }
        // 根据溢出标志返回结果，如果溢出则加上模数
        return overflow ? (res + m) : res;
    }

    /**
     * 计算欧拉函数Phi(n)的值
     * 欧拉函数Phi(n)表示小于n的正整数中与n互质的数的个数
     *
     * @param n 需要计算欧拉函数的正整数
     * @return 返回n的欧拉函数值
     */
    private static long getPhi(long n) {
        long res = n;  // 初始化结果为n

        // 遍历2到sqrt(n)的所有整数
        for (long i = 2; i * i <= n; i++) {
            // 如果i是n的因数
            if (n % i == 0) {
                // 应用欧拉函数的公式：res = res * (1 - 1/p)
                res = res / i * (i - 1);
                // 去除n中所有的i因子
                while (n % i == 0) {
                    n /= i;
                }
            }
        }

        // 如果n大于1，说明n本身是一个质数
        if (n > 1) {
            res = res / n * (n - 1);
        }
        return res;
    }

BISHI74 【模板】非质模数下的乘法逆元

Tue, 24 Feb 2026 20:34:31 +0000

乘法逆元 $a^{-1} \equiv x \pmod m$ 等价于求解线性同余方程：

$ax \equiv 1 \pmod m \implies ax + my = 1$

根据裴蜀定理，该方程有解的充要条件是 $\gcd(a, m) = 1$。
扩展欧几里得算法可以在计算 $\gcd(a, m)$ 的同时，求出一组整数 $(x, y)$ 满足 $ax + my = \gcd(a, m)$。

思路

实现代码

    private static long x;
    private static long y;

    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {

            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long m = Long.parseLong(str[1]);

            exgcd(a, m);
            long ans = (x % m + m) % m;
            out.println(ans);
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 扩展欧几里得算法，用于求解形如 ax + by = gcd(a,b) 的方程
     * 同时返回最大公约数和x、y的值
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @return a和b的最大公约数
     */
    private static long exgcd(long a, long b) {

        // 当b为0时，递归结束，此时a就是最大公约数
        if (b == 0) {
            x = 1;    // x初始化为1
            y = 0;    // y初始化为0
            return a;
        }

        // 递归调用，计算b和a mod b的最大公约数
        long d = exgcd(b, a % b);
        // 通过递归结果更新x和y的值
        long tmp = x;
        x = y;
        y = tmp - (a / b) * y;

        // 返回最大公约数
        return d;
    }

BISHI73 【模板】欧拉函数计算Ⅰ ‖ 朴素求值：试除法

Mon, 23 Feb 2026 21:59:20 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            long x = Long.parseLong(br.readLine().trim());
            out.println(euler(x));  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 使用欧拉函数计算小于等于x的正整数中与x互质的数的个数
     * 欧拉函数公式：φ(n) = n * (1 - 1/p1) * (1 - 1/p2) * ... * (1 - 1/pk)
     * 其中p1, p2, ..., pk是n的质因数
     *
     * @param x 需要计算欧拉函数的正整数
     * @return 小于等于x的正整数中与x互质的数的个数
     */
    private static long euler(long x) {
        // 如果x为1，直接返回1，因为1与1互质
        if (x == 1) {
            return 1;
        }
        // 初始化结果为x
        long res = x;
        // 遍历从2到√x的所有数，寻找x的质因数
        for (long i = 2; i * i <= x; i++) {
            // 如果i是x的因数
            if (x % i == 0) {
                // 应用欧拉函数公式，乘以(1-1/i)
                res = res / i * (i - 1);

                // 去除x中所有的i因子
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        // 如果x大于1，说明x本身是一个质数，应用欧拉函数公式
        if (x > 1) {
            res = res / x * (x - 1);
        }

        return res;
    }

BISHI72 中位数之和

Mon, 23 Feb 2026 21:10:27 +0000

由于数组 $a$ 仅包含 $0$ 和 $1$，对于长度为奇数 $k$ 的子序列，其中位数是 $1$ 的充要条件是：子序列中 $1$ 的个数不少于 $\frac{k+1}{2}$。

因此，求“中位数之和”等价于求“中位数为 $1$的子序列个数”。

思路

代码实现

   // 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 1000001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];


    /**
     * 主方法，处理输入输出并计算组合数学问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 预计算阶乘和逆元，为后续计算做准备
        precompute();

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            // 读取每行输入并分割，获取n和k的值
            String[] str = br.readLine().split("\\s+");
            int n = Integer.parseInt(str[0]);  // 总数
            int k = Integer.parseInt(str[1]);  // 选择数

            // 统计输入中"1"的数量
            int c1 = 0;
            String[] strA = br.readLine().split("\\s+");
            for (int j = 0; j < n; j++) {
                if (strA[j].equals("1")) {
                    c1++;  // 统计"1"的个数
                }
            }
            int c0 = n - c1;  // 计算"0"的个数

            // 计算至少需要选择的"1"的数量
            int m = (k + 1) / 2;
            long ans = 0;
            // 遍历所有可能的"1"的选择数量
            for (int j = m; j <= Math.min(k, c1); j++) {
                // 检查剩余的选择数是否不超过"0"的数量
                if (k - j <= c0) {
                    // 计算组合数并累加结果
                    long res = (nCr(c1, j) * nCr(c0, k - j)) % MOD;
                    ans = (ans + res) % MOD;
                }
            }
            out.println(ans);  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }