Core's ink

广东·潮州

Fri, 03 Apr 2026 00:00:00 GMT

连夜逃离厦门，流放岭南

那天真的下暴雨了

岭南太苦了，我希望你不懂

特种兵半日之旅

走过潮州古城

2026.03.23

Mon, 23 Mar 2026 00:00:00 GMT

去年的时候，我想 26 年只要干完俩件事就行：第一是能顺利毕业，第二是试用期通过。但前年，或者大前年的时候，我还是规划了很多事情的...

但是走到这个节点的时候，已全然想不出来下一年有什么好做的事情了

我有在继续往前走，只是这些年走得会慢一些

你要说现在这个时代很烂没红利也不绝对，比如晚买了五年房，相当于少奋斗十年

在这里，35 岁以后，读书、跳槽、结婚等等，干什么都是太老了，只有突然离世，大家才会说，这么年轻就走了

上班让我感到最可怕的地方是，它居然让我因为期盼退休而期待衰老，让我完全不珍惜我剩余人生里，最年轻的每一天

其实我根本就没啥追求

早些年，梦到和一些很好的朋友在海边散步，四五点钟的样子，有点夕阳又不是很暗，海边就在我家的门口，我感觉这样就很好，比挣很多钱都要好

我对于日后买一辆十万的车还是二十万、三十万、五十万的车没有任何兴趣，倒是时常会幻想，要是本科的时候有一辆破面包车该多爽，最好能拉六个人那种，把我们一宿舍人都拉上，三轮车也行

人是逃离不了焦虑的，特别如果是一个喜欢攀比，或者争强好胜的人，所以我们这行大家都很焦虑，这太正常了，因为大家都是卷上来的，这让我也想起来了刚入学厦大的时候，备战老师说你们居然都没挂过科，我当时就很想吐槽，我要是挂过科，你能在这里见到我吗

实习的时候总在想要刷多少段大厂实习，是不是算法 > 后端 > 前端 > 测试，秋招的时候想自己拿了多少 ssp，身边的朋友又拿了多少 ssp

回顾我的本科，保研，读研，实习，秋招，至今，其实并没有做出太多有意义的事情，没有人会在很多年后翻开一个陌生人的动态，去看他当年拿了多少 offer，开了多少钱，这是一件很无聊的事情，我也不相信会有人在很多年后，依旧吹嘘自己当年的成就

所以比起其他事，我更满意的是在本科的时候写了一些推文，帮到了一些学弟学妹，在读研的时候写了一些秋招指南，同样公开了出来，也比较满意这些年不断记录着，虽然这段时间里，更新速度大不如前

其实能做完上面的事情，全都是偶然或者巧合，我最初只想写一篇我的故事，但一直没想好怎么写，所以在这过程中，杂七杂八的写了很多别的

暮然回首，突然发现我的青春有些太过安静，以至于等到它结束我都没有反应过来

我当年，没有不良习惯，没怎么逃课，也没有多么优秀的成绩，更没有什么可以拿的出手的故事，没有出众的才艺，没有开朗的性格，没有偷偷藏起的忧愁，没有肆意而为的潇洒

干净得像一张白纸，过完了整个青春，我的高中，我的本科

为什么不说研究生呢，因为研究生我就经常逃课了哈哈，其实不是，因为研究生不是在外地实习，就是在工位打杂，就谈不上青春什么的了

如果要形容去年的话，应该是改变，我和以前有些不一样了，但也有不变的地方

当然，对于上面，我并不打算细究些什么。人生在世，不断地被各种人亏欠，又不断的亏欠着别人，不断被各种人伤害着，又承受了其他人的良善与馈赠

究竟谁欠谁，谁该感激谁呢？可能早已说不清

一生很长，很多人不会永远在我的生活里，但会永远在我的故事里

远程服务器启用 Codex 插件

Thu, 26 Feb 2026 00:00:00 GMT

⚠️ 提示：请严格遵守公司或组织的数据安全红线

在进行下述操作前，请务必确认您的单位允许使用 SSH 隧道、端口转发以及代理转发等技术。某些公司/机构明确禁止以下行为：

SSH 端口转发（LocalForward / RemoteForward）

利用远程服务器通过本地代理访问互联网

传输敏感代码、令牌的重要数据

如违反安全规范，后果自负，请谨慎操作。

TL;DR：把本地的 Codex 登录信息复制到服务器，并让服务器的 Codex 流量通过 SSH 转发到本地代理，从而实现服务器远程环境下的 Codex 正常可用。

为了在远程服务器（如 GPU 服务器）中正常使用 IDE（VSCode / Cursor）中的 Codex 插件，需要将本机的 Codex 登录信息同步到服务器，并配置代理转发，使远程服务器能够通过本地代理访问 Codex 服务。以下是完整的配置步骤：

1. 上传本地 Codex 授权信息到服务器

当你在本地 IDE 成功登录 Codex 插件后，插件会在你的用户目录下生成目录：

~/.codex

$ ls -alh ~/.codex/
total 392
drwxr-xr-x  16 coooredump  staff   512B  2 26 01:42 .
drwxr-x---+ 87 coooredump  staff   2.7K  2 26 02:36 ..
-rw-r--r--@  1 coooredump  staff   2.7K  2 26 01:39 .codex-global-state.json
-rw-r--r--   1 coooredump  staff     3B  2  4 03:01 .personality_migration
-rw-------@  1 coooredump  staff   4.3K  2 26 01:37 auth.json
-rw-------   1 coooredump  staff   135B  2 26 01:42 config.toml
-rw-------@  1 coooredump  staff    85B  9 14 09:52 history.jsonl
drwxr-xr-x@  3 coooredump  staff    96B  9 14 09:52 log
-rw-r--r--@  1 coooredump  staff   165K  2 26 02:11 models_cache.json
drwxr-xr-x   4 coooredump  staff   128B  1  2 17:28 sessions
drwxr-xr-x   4 coooredump  staff   128B  2 26 01:42 shell_snapshots
drwxr-xr-x   3 coooredump  staff    96B  2 26 01:41 skills
drwxr-xr-x@  3 coooredump  staff    96B  2  6 22:54 sqlite
drwxr-xr-x   4 coooredump  staff   128B  2  6 22:54 tmp
drwxr-xr-x@  2 coooredump  staff    64B  2 26 01:37 vendor_imports
-rw-r--r--@  1 coooredump  staff    76B  9 14 09:52 version.json

为了在远程服务器启用 Codex，需要将这个目录复制到服务器上。

1️⃣ 在本地打包 ~/.codex：

tar -cf codex.tar ~/.codex

2️⃣ 上传到你服务器的用户目录（~/），然后在服务器上解压：

tar -xf codex.tar -C ~/

最后确认目录 ~/.codex 是否存在即可。

2. 配置 IDE 桥接本地代理（SSH 端口转发）

由于远程服务器通常不能直接访问 Codex 服务，所以需要通过 本地代理（🪜） 转发请求，让服务器通过 SSH 隧道访问本地代理。

2.1 在 IDE SSH 中配置端口转发

先确认本地🪜的端口（此处以 7890 为例）：

然后在 SSH 配置（VSCode / Cursor 的 SSH Host）中，加入端口转发：

即修改 /Users/xxx/.ssh/config：

Host 8001
    HostName xxx
    Port xxx
    User xxx
    # codex 端口转发
    RemoteForward 7890 localhost:7890

2.2 确保本地代理允许局域网访问

打开🪜设置，勾选：「允许来自局域网的连接」

修改完成后，再通过 IDE 远程登录服务器。

3. 服务器代理配置

在远程服务器上，让所有 HTTP/HTTPS 请求都走刚才通过 SSH 映射的代理。

3.1 服务器代理设置

在服务器的 ~/.bashrc 添加以下内容

export http_proxy=http://127.0.0.1:7890
export https_proxy=http://127.0.0.1:7890

然后执行：

source ~/.bashrc

3.2 在 IDE 中设置远程工作空间的代理

注意，此处设置需要在远程服务器的工作空间设置，而非本地工作空间设置。

IDE 中按下Cmd/Ctrl + Shift + P，输入Open Remote Settings，进入远程服务器的设置面板，搜索 "proxy"，将： http-proxy 设置为 http://127.0.0.1:7890，如下图

然后关闭并重新连接 Remote：Cmd/Ctrl + Shift + P → Close Remote Connection

4. 安装并启动 Codex 插件

重新连接服务器后，在插件市场安装 Codex（如果未安装），打开 Codex 插件，此时应该能显示正常的登录界面，并且运行命令不会出现反复 Reconnect 的错误。

「2025 年终总结」在所有失去的人中，我最怀念我自己

Sat, 07 Feb 2026 00:00:00 GMT

在 2026 的开始，我并没有许下什么新年愿望，似乎每一年都没有，但每一年都会经历很多难忘的事情。

这一年终究要过去了，我对 2025 的唯一感觉就是：年费会员快要到期了，该交钱了。

今年比往年要好很多，烟花凌空绽放，整座城市隆隆作响，极尽所能地宣告新年的到来，往年只有电视机里主持人带着职业假笑，高声呐喊这的倒计时，现在打开窗户，迎面扑来的是久违的焰火气息，让我想起遥远的过去。

尤记得初春的厦门，微雨悄然而至，零星的雨滴中，傍晚树下自行车的铃声随风轻轻荡漾，街角的灯光微黄，宛如一位老友向我低语，有些东西，永远的遗留在了过去。可能是在留在了初高中，或者本科，亦或者是研究生，无从知晓。

那时西边红霞满天，我却只顾东行。

#01 夏

暑期实习挺不顺利的，人很丧，没自信，没目标，也错过了很多机会...

想回到暑期前重新开始，但没办法，回不去了，这就是人生，只有错过点什么，你才学得会珍惜

就好像我这辈子也回不到大一大二的学习状态一样，或者说，人这一生，都不能走回头路

很多年来，我一直持续在问自己一个问题，怎么就变成这样了呢？

最近，这个问题变成了，害，那又能有什么办法呢 😮‍💨

屡战屡败，屡败屡战，找暑期实习哪有不疯的

暑期实习面经复盘

除了保研那段时间，这应该算是我第一次真正意义上高强度投递简历、参加面试了，这一年从暑期实习到秋招结束这段时间，基本都是在自我怀疑中度过的，愈发觉得自己不适合互联网。

人生失意，莫过于此

暑期最有希望也是最想去的华子也泡死在池子里了，那个组的方向我是真感兴趣，可惜最后还是没能等来 offer。

看到一个北大的哥们，比我晚入池，过几天就开奖了，HR 和我说，或许这就是北大的魅力吧。

也不知道为什么，这些年，身边的人总会有种觉得我很厉害的错觉，拜托，我要是真厉害，我还用发愁这些毕业、就业的事么，这样我就不用吃生活的苦了

有时候就觉得自己活得很荒谬，三天两头垂头丧气跟失恋似的

朋友问我怎么情绪不对，我总不能告诉他最近暑期挂麻了，看不到未来吧

我也渐渐萌发退缩的心理，想到国企或者体制内躺平（其实我也考不上），这样度过一生好像也蛮不错的。只不过没想到今年秋招的国企，反倒是历年来最黑暗的一年，往年触手可及的国家电网也因为高层换人重置考核方式，厦门所在的国企进面 baseline 骤增，亦或是 HC 骤减，亦或是停招一年。

突然想明白了为什么互联网公司互相称呼同学，国企互相称呼老师，因为同学会毕业，早晚而已

这并不是一份多么值得让人羡慕和追逐的工作

在这里，人也并没有太多的时间想以前和以后

甚至于为了安慰自己，还认真写过一篇博客来研究分析近几年的国企和私企。

那段颓废在宿舍刷视频的时间，经常刷到蜡笔小新和海绵宝宝，不得不说在那个年代，做得是真好

小学的时候是最应该看蜡笔小新的时候
高中的时候是最应该看斗破苍穹的时候
但我研究生的时候才开始沉迷这俩玩意

不过仔细一想，我现在和高中时候确实有点不一样了，比如高中时候我玩英雄联盟宁死不投，现在我看打不过了 15 分钟就上票了，不能让对面虐菜爽

能打过我的人，我不给他们打 ...

人总应该是有点变化的，但我最近又有些新的理解了，成长是一件很难的事，它甚至意味着从头去修改你的一部分人生意义

打个比方：你连体重都控制不了，怎么能控制自己的人生呢？

朋友说没办法，现在大伙都找着了工作，体重确实不好减

真不好减，最近东子、团子和阿里打外卖价格战，快给我喝出糖尿病了

暑期有个好朋友跑北京实习了，还有一个去了杭州，在厦门读书时哥几个总是经常打哈哈，不过一到上班，感受又不一样了

出发前几天，我说了一句“今日一别，小半年又见不到了，不过咱们的学生生涯好像也就一年多了”，他们没说话，也许是我们经历这寻常的分别太多了，本来早就习惯了，这时候突然来了个人对你说：

嘿，你已经和这么多人走散了呀

大多数人分开后就不会再见了，而有些人或许还有再见的机会

回忆会陪你一生，即使再模糊，你还是忘不掉

聚散离合，此乃常态，你要习惯

纵观个人的命运，当然要靠自我奋斗，但也要考虑到历史的行程，但不幸的是，现在历史的进程并不乐观。

在比较小的时候，大约就是初中高中吧，我对自己人生结果充满幻想和期待。但慢慢长大之后，方才意识到生活是如此复杂，我不得不学着对内心的期望放手，曾经的梦想在残酷的现实面前变得褪色。慢慢发现有些事并不是一件需要被解决的事情，而是一件需要被接受的事情，或者说，绝大多数的事情，都只是需要接受的事情，你解决不了。

比如在地球 online 度过的这二十几年来看，改变的话起码要拿年来衡量，或者十年来衡量。

此时，怜悯自己显得很重要，或许你可以对自己说“我也想要做得更好”以及“就让它这样吧，其实这样也好”。

是的，我已经做得足够好了，因为至少现在我还爱着自己｡

#02 秋

其实，我从来没想过要如何准备才能在秋招拿到大厂的 offer，或是白菜，或是 SP、SSP

我一直以来去实习，一是想顺道去别的城市看一看，二来，也是一直都想真正的写出一些好的代码，被重视的代码，听起来很理想化，但这也让我阴差阳错的实习了不少段

在我过往的十年中，凡是我努力追逐的事，往往都无法实现，而那些真正实现的，其实都是意料之外

所以我觉得如果一件事有 100% 的把握，就没有去做的兴致了

🧑‍💻面试官：这就是你笔试只做出来一半的原因吗？

后来看到个段子，很后悔没给面试官发：

“这代码我有三不写”

第一：不能复制的我不写，因为别人的轮子写好了我干嘛不用

第二：不让我用 ChatGPT "辅助"的我不写，因为基础的东西我都会，写了没意义

第三：太难写的我不写，因为我还没有到那个境界，写不明白

现实就是这么残酷，还没来得及从暑期实习的失落中走出来，秋招就开始了，比 emo 更难受的事情是，不能 emo 太久。

朋友说，当一个人过得不好时，才会怀念过去。难怪秋天刚开始，我就已经在怀念夏天了。

这过日子就是问题叠着问题，我唯一能做的，就是迎接这些问题。 ——《士兵突击》

也就投递了 187 次

秋招 vlog

秋招面经复盘

秋招，是一场无休止的 dating

这种盛况，从 8 月持续到 11 月

几十年前，似乎呢群领图灵奖的巨佬总会在领奖的时候很自豪的说，我是一名程序员

但现在提起程序员，我总会想到 CSDN 上那只秃头虚弱无力的猿猴趴在电脑前，用巨大的手敲打着键盘

所以我很不喜欢 CSDN，当然 CSDN 也确实做的很烂，也算没有辜负我的感情

我没那么喜欢互联网，互联网是一种很割裂的存在，特别是在国内，比如互联网的 OKR，很有意思的是，在互联网 OKR 本来就是要完不成的，如果有一天你完成了你的 OKR，不是说你超出预期，而是说明你的 OKR 制定的有问题

我很想说这个行业病了，但其实我也改变不了啥，唯一改变的就是工作越来越难找了，同龄人之间要更卷了而已

没有乌托邦，只有维也纳在等我们

但我喜欢编程，我就想工作得能开心点，从来没想过在互联网待一辈子，而且即使我想，我的老板可能也不想

面试很短，这几十钟其实是看不出来我的优点的，我每次面完都感觉没有发挥得尽兴，没有展示出来给面试官最好的一面

但我的缺点还是一览无余的

有一次面 HR 面的时候，HR 让我给一个词来形容自己，我说的是重感情

HR 说第一次见到这样的回答，让我举个例子

我想了想，说如果你司招我，那我会先考虑你司

也不知道 HR 满不满意这个回答

想起来本科的老学长，从闲鱼跳去了美团，换了个 base，最近经常加班，有人问是为了什么

学长说是为了爱情，真好，那时候有那么一瞬间，我很羡慕，似乎这一切都和技术没有关系，与世俗的荣誉，权力都没有关系

我喜欢纯粹的东西，面试也是

我如果觉得一个面试官不真诚，我就不会去这家公司，如果我有选择的话

以前觉得做选择时兴趣没有那么重要，但现在看来，那一点平日里微不足道的热爱，会成为在动摇时至关重要的那一份权重

有时候想毕业直接回到老家，又觉得辜负了自己的初心和一身技术

朋友说不对，你现在没啥技术，谈不上辜负

说的也对，走一步看一步算了😄

不过程序员有一大悲哀就是，成为了程序员就会只把自己当成程序员，因为身在这个环境中，但其实如果跳出这个环境，发现还是正常生活的人多。

计算机是严格理性与规范的学科，但我觉得也很浪漫，我们穷尽所有去提高技术，无论是设计模式，还是渐渐的模块化，微服务化，容器化，都是为了在未来一天，我们可以更好的被取代，这个工作，在一开始，便注定了悲壮和浪漫。

但有时我会想，这个行业，值不值得我投入如此的热忱，我是个没有梦想也能生存的人，高中的朋友总喜欢找一个梦想中的学校，一个梦想中追赶的人，一个梦想中的行业。但我这些都没有，朋友总觉得我是靠意志力撑过高三那段艰苦的岁月，其实不是，有没有梦想对我来说并不是那么重要。

朋友说，假设阳的挂掉一半，全国会失去大概 50% 的人口，不过很快又会恢复如初（生物小知识嗷：种群数量达到环境容纳量一半，即 K / 2 时，种群的增长速率最大），最终无数人的喜怒哀乐，生死离别，成为历史书上的轻如鸿毛的一笔，无论描写的多么惨绝人寰，也只是一笔罢了，而地球上所有惊天动地的大事，也不及宇宙中的一粒尘埃。

有时候在想生命的意义是什么，我想不明白，就像高三老师问我的梦想一样，问我想要当一个什么职业，成为一个什么样的人，我说我不知道，但一定不是以后拿 20w 年薪，30w 年薪，50w 年薪或者 100w 年薪。

因此不想卷了，是因为没有了卷的动力，其实最终不就是为了拿一份高薪的工作，我连对这个结果都没了兴致，又何谈过程，倒不是懒得奋斗，只不过什么时候奋斗渐渐的成了一种贬义词，我只是觉得途中的代价太大，不只是我一个人付出的，而是和我的朋友们一同付出的。

无论是什么样的结果，我都觉得难以配得上这一路走来的失去

人行走江湖，就是不断的相遇和失去，第一次相遇是自己的生命，最后一次失去也是，有始有终

我已经不喜欢再和别人卷了，但是到了一定程度后，身在其中，由不得我，不过，也算是一种磨练心境吧，倒也未必不是好事。

所以生命的意义是什么，我不知道，但是我会期待下一次和朋友相遇，在大学中遇到新的朋友，新的乒乓球友，我会和以前一样期待，但是不会再像以前一样严格规划我的人生了，比如某个时间点非做某件事不可，非要达到某个成就不可。

在学校的时候，如果不是很忙我就喜欢到外面去吃个鸡锅，如果忙的话就推到明天去吃，明天忙就推到后天，人总是寄希望于后来，也习惯把这辈子没有得到的人和事寄予到下辈子，总会说我下辈子要怎样怎样。可如果这辈子就是你上辈子说的下辈子，那怎么办呢？

所以我现在选择想吃鸡锅的时候就直接去吃😋

那我会呆在哪里呢？HR 也问过我这个问题。

我说大概是厦门吧，我的爱人、挚友都在那里，或者是在那里陪伴过我一段很长很长的时间，比我在杭州西安待的时间加起来还要长很多

面试官笑得有些深意

几年后被末尾淘汰的那一天，一切都将作废，之前的加班作废，之前从池子中挣扎出来的惊喜作废，之前的领导同事作废，之前的薪资待遇也作废，鼠标也会作废，键盘也会作废，所有的承诺也统统作废。从那一天开始，我不再需要电脑，不再需要八股，我的人生不再有 hello world。我知道是秋招那年的那场大雪覆盖了我前半生的荒唐，覆盖了我本科的学历，我和 985 硕一起进入阿里，我仿佛从其中看到了希望，但生活在无边的大雪中又何尝不是一种荒唐，当我真正走出这片大雪后，我肚子有些饿了，此时我才意识到，原来码农烧烤才是人生的归属。

其实我也经常黑厦门的，我很难喜欢上某个城市，比起城市的高低贵贱，电子博弈，我更在意的是我与谁一起经历过什么，到过哪里，见过哪里的风景

我经常说厦门那地方，典型的工资低，物价高

朋友说他不是本地人，每次买海鲜都感觉买的很贵很贵，听厦大的学长说去码头买能便宜很多

我说不是，码头有一定概率买到新鲜的，而且很难买到便宜的

为什么说有概率买到新鲜的，因为那海鲜，你不清楚是刚从海里拉上来的，还是昨天搁市场溜了一圈又拉回去的，反正在人看来，都是刚从船上拉下去，带着新鲜的海水和被折腾的半死不活的鱼

至于价格，人们一般都会吹鼓自己的是野生的，众所周知的道理，野生的更贵，也没有手段证明它是不是真的野生鱼，除了价格

#03 厦

读了好多年书，如果能顺利毕业的话我就要毕业了，这话看起来没什么信息量，和我读的硕士一样。

看树洞有人问保研和考研哪个更辛苦，我不用点开都知道评论区铁定开战了

一个老哥说的很有意思，差点看破防了

读研更辛苦

记得有一天发研究生补助的时候我还在和朋友聊天

朋友说他感觉人生只剩下了银行卡里的一串串数字，收入和支出，感觉像是把灵魂卖给了社会，照镜子的时候感觉双眼都变得浑浊了

我看了眼屏幕里那一堆减号里面的醒目的“➕600”，还是国家赏饭，我应该是肉身和灵魂都卖给了学校，还是那种 19 世纪美国南方黑哥摘棉花的价格

和朋友闲聊，如果能再选一次的话我一定不会读研，哈哈

但怎么说呢，一切都是最好的安排，如果不是这样，我也不会遇到现在这位让我死心塌地爱着的女朋友

人就是这样，总会在某个时期觉得自己曾经做的事情不正确，说不定再过几年我又觉得现在做的不正确了

不过话说回来，当年觉得自己能保研可厉害了，现在想想就和网上那种看着小时候一面墙的奖状一样，叹息之墙

现在知道累了，当初喊我玩以为跟害我一样

人还是不要美化从未走过的那条路，不然就会一直纠结和后悔，然后发现这辈子然后很快就过去了

也慢慢觉得自己老了，因为回过头看，发现自己已经配不上过去的自己了

如果在当年知道未来是这样，或许根本撑不过高考那段时光

多年之后，我又梦到那天，画面遥远，仿佛回到高考那一天

感觉，稍微有点生不逢时罢了

想起来前段时间公司宣讲，说我们赶上了一个很好的时代，因为有 AI，可是 AI 并没有发挥它应有的作用，并没有让工作量减少，工作时长减少，也没有降低生活成本，房价物价，看病还是一样昂贵，大家的压力也都还是很大，甚至更焦虑了，我们并没有因此变得更幸福

长期来讲，我很看好 AI，但此时此刻，并不觉得这是一个多么好的时代，即使见证了从传统 CV、NLP 到大模型的蜕变。大模型发展得太快了，还记得 22 年刚出 GPT-3.5 的时候，有人感慨涌现就像宇宙给的礼物一样神奇，现在已经没有人再发出这种感慨了，默认大模型就存在和人类差不多甚至更强的智力了，没有上古时期 NLP 用 BERT 胡言乱语的折磨

想起个很好笑的事，以前研究生方向不是 CV 就是 NLP，现在 CV 还有点，感觉 NLP 已经绝迹了，虽然大模型也算是一种 NLP 吧，但已经没有哪个老师招生的时候会给你说：同学，我的研究方向是 NLP 🤣

现在已经到 AI Agent 时代了，国内外的 AI 产品层出不穷抢占市场，也不得不感叹国内 AI 大战的朴素，一代人有一代人的鸡蛋要领

感觉我们的世界对慢节奏的人很不友好，那种田园牧歌的时代早就一去不复返了。我曾经对科研的憧憬完全来自于牛顿和苹果树，康德漫步于小径，梭罗隐居瓦尔登湖，而不是坐在电脑面前，脊柱侧弯、屁股很酸、眼睛散光，和计算机打交道，未来只有吃不完的苦。

我曾经觉得我是会喜欢科研的，在我想出老师也没想出来的课题的时候，提出不一样的见解的时候，在组会分享论文的时候，做出耳目一新的 PPT 的时候。

也许我确实是，但是我连打游戏都没法一天八小时持续一个月，社交不行，跑步不行，吉他也不行，唯一成功坚持过的看似也只有读书，读高中的时候，但也得考虑到咱们学六门课呢，而且真是差点就死了。

我不喜欢科研，至少暂时不喜欢

人擅长什么领域，就会在心中的价值天平上给它加码，以确保自己的价值在自己心中过得去。我想高考之于我几乎所有的意义就在于此了。我确认自己的才能、价值、潜力，我知道我的头脑不会背叛我。

不过我也因此发现，无论一篇论文写得多好，总能挑出来毛病，只要我想挑毛病

不是我有多么丰富的知识和见解，而是我必须得挑，因为组会轮到我分享论文了

我时常惊叹于我朋友的学习能力和科研水平，也惊叹于我朋友为人处事的八面玲珑。

从小到大我见过的成绩好的人太多了，然而天下英雄如过江之鲫，即使你万里挑一，在这里也有 14 万个，更何况世界不止中国。

然而幸福是一种独立于客观存在的能力，就像物债二分法，所有权的变动无效并不意味着买卖合同无效 —— 你看到什么，听到什么，感受到什么，才是最重要的，跟客观世界是什么样的、跟别人怎么看你无关。

所以幸福不是那种一下被人流推到癫狂的短暂欢乐，而是一种长期平和的满足。就按一线城市人均寿命 80 岁来算，扣除最后几年没有质量的生命，再扣除已经过去的 18 年，以及 4 年本科、3 年硕士占据现有生命的份额，又能剩下多少年的人生呢？

既然人生永远没有岸，你的体验难道就不重要吗？

有时会想，到底什么样的人生是幸福的人生呢？

有项研究表明，一个人在年老的时候身体和灵魂都很健康，还对自己很满意的话，他的人生就是幸福的。这里既包含了个人对自己的评估，也要考量医生和心理学家的评估。

这个研究的好处是把幸福的人生具体化了。不过，研究也表明，你可能等不及到退休的时候再来评估自己的一生。

所以朋友说他在犹豫交不交养老保险，他感觉活不到退休，即使活到了，按当前生育率推断，也是大概率没人给我们交养老金。

总觉得人生路很长，未来还可以做很多事，我想了想也未必很长，人很难说什么时候会死，朝生夕死也并非不可能

我们总是以对未来美好的憧憬，来假释当下的苦难，只是美好一直没有到来，竞争倒是永无止息

我不想这样，但有时候又没得选

#04 愛

几岁的时候，我以为，我将来会是一个很厉害的人。比如别人需要好久才能掌握的自行车，我几分钟就学会了。后来才发现我不是。走在河山林间里，就像是一块鹅卵石置于潮海之中，并没有什么不同。

十几岁的时候，我意气风发。每当我爬到山顶的时候，跑向海边的时候，以为我不再是我的时候。我总以为山顶的石头不一样，升起的太阳不一样。我总以为海边吹的风不一样，尽头的那边不一样。我总觉得未来还有无限的可能。

二十几岁的时候，我以为生活锤得我满是伤痕，我也会开朗乐观地面对。但是更多时候，我胆怯，我拘谨，我犹豫。我害怕认识陌生人，害怕自己没出息，害怕自己买不起房子车子，害怕遇不到双向奔赴的爱情。难过的时候，一个人难过，开心的时候，一个人开心。心情低落的时候，写些蹩脚的文字。

比起一事无成，我还体会过很多糟糕的感觉，比如努力了好久的面试却被轻易挂掉了，非常期待的计划却突然落了空，曾经亲密的好友不再联系，至亲离别时的泪水。太多太多了，就像是一只耷拉着脑袋行走的小狗。

庆幸的是，这些年来，我也读了很多书，去了很多地方，结交了许多挚友，写下了一些见闻，从波澜壮阔的景观，到至今馋味的各式美食。我还有着一些渺小的心愿，并一直在为它偷偷努力着，尽管可能遥遥无期。我也知道在这个世界上，有很多我穷尽一生都难以望其项背的人。我希望我的坚持，可以弥补运气和先天的不足。

在大多数情况下，没人愿意聆听我的琐碎。所以，我很沉默，一直都很沉默，沉浸在自己的世界里。直到后来我慢慢遇到了一些好朋友，到如今遇到了与我同频共振的女朋友，我才真正像只刺猬一样敞开心扉，让彼此看到内心深处，那些不为人知的优雅和温柔。我想要变得有趣，变得特别，变得开朗，还想变成王小波说的那样，在这个一生的黄金时代，我有好多奢望，我想爱你，想同你一起去经历，还想在一瞬间变成天上半明半暗的云。

说真的，在遇见你之前，我从没有傻到会相信一个人能在另一个人身上找到所有他期望的。

但是在你身上，我找到了所有，一眼万年也有了实感。

不知道这份爱意会不会让你惊诧，其实，我才是那个被惊艳到的人。

你善良，温柔，知书达礼，善解人意，言语中透露的一丝稚气显得格外可爱。

你太好了，好到我觉得无法用语言去形容你，词不达意。

以至于我开始变得更为贪心，开始想牵你的手，想常伴在你左右。

我所幻想的四季，蓝天白云，清风野草，星空斑斓，树影婆娑。

我才发现我所见到的美好，身边有趣的事物，只需要有你分享就足够。

原来一个人可以完成的事，其实两个人做完也不赖。

原来我所憧憬的春夏秋冬，都有一个前置条件：与你。

那些我曾以为需要跋山涉水，花费很多心思的快乐，有时候或许只要有了你就能轻松抵达。

我喜欢你，也喜欢和你在一起的我自己。那样子的我勇敢快乐、热烈赤诚，内心一触碰都是柔软。

即使生活已经磨掉了我一部分的勇气和温柔，但是你依然让我相信，失去的还会再长回来，新长出来的依旧闪闪发亮。

是你让我不再害怕逃避，心有所依。

是你让我明白了勇气并不是无所畏惧，而是懂得了有除了畏惧以外更重要的事。

在晚风吹拂的地方，我想要趁着窗外的月光，趁着满天的繁星，拥抱你、亲吻你...

当我真实地爱上你，意味着除了家人朋友，我还拥有了另一种完全不同的爱。

我在某本书上曾经看到过，懂一个人是要花五百顿饭，五百瓶酒，五百个日夜，去一点点接近的，因此可以说懂一个人是要付出生命的。

我想给你我所有明亮又炽热的喜欢，想和你牵手走过鼓浪屿的巷子，在潮声漫过的白城沙滩等一场日落；想和你在观音山的海岸边看烟花绽放，像星星跌进眼眸；想和你在沙坡尾的影院看一部温柔的老电影，散场后吹着夏夜的晚风慢慢回家；还想在每个黄昏和你坐在环岛路的咖啡店门口，看橘色的光一点点把云朵染成绯红，把世间的浪漫都藏进厦门的晚霞里。

现在我要花我的生命去懂你爱你了。

我希望你永远做自己，我来填补你的空缺。

怎样过一生，这一生都会过去。

这是我的选择，我愿意过这样的一生。

一个人可以给另一个人，最贵重的礼物，就是时间

愛

#05 倒带人生

从我记事起，就记得姥姥家的院子里，种着一颗大银杏树。每年春夏，枝头总是挂着一片绿意。等秋天一到，金灿灿的叶子就在风中招摇。风将落叶带去远方，天空飘着的云很是明亮。我只是安静地看着，邻居家那只爱趴在我家屋檐上，呼呼大睡的猫咪，就能虚度一下午的时光。

我这人很简单

如果有星巴克和瑞幸，我一定会去喝瑞幸，因为我喝不出他们有什么区别

但如果是瑞幸和库迪，我一定会去喝瑞幸，哪怕瑞幸十几块一瓶，因为我喝得出来区别

我喜欢没有意义的东西，或者说纯粹的东西，比如喜剧片或悬疑片，我不喜欢对我说教的，蕴含深刻道理的喜剧，这种还不如让我去看黑马程序员网课和国考 980 系统班

小时候我看了好几次东邪西毒，但当时看不懂，所以更喜欢东成西就这样纯粹的荒谬与欢笑，大话西游这样的刻骨铭心的感情

在王家卫的电影哲学里，武侠、江湖皆成摆设，唯有爱与孤独才是亘古不变的精神主题

父母总说长大后就能看懂，但我已经很久没有再看了，因为我觉得我还是看不懂

有些东西，我并不觉得会随着阅历或者经验的增长而改变

一次偶然，初中同学聊天，他说我变了，其实好多人也说过，到初中之后就开始了

不过他们总会对外貌成绩一类的感兴趣，或者感到惊讶

其实人真正改变的是内心，内心的改变是几乎不会表露在外的

所以我一般都把他们的话当耳旁风

因为从来没有人问过我经历过什么

我有时会想到一个高中时很好的朋友身前，一个和我在大大小小的考试中对于名次较劲的人

我曾经很想问问他，你看我有几分像从前

但是已经觉得有些意兴阑珊，坚如磐石的友谊也会在岁月下磨损，最终消逝

极少数人属于木桶中的美酒，岁月流逝后，反而越发醇香

很明显，即使是他，也属于前者

我一直觉得，我以前和现在，本质上并没有太大的变化，直到我看到曾经自己写的日寄

我需要承认，我和以前不一样了

我不再敢打敢拼，不再义无反顾，我会犹豫，会权衡利弊，会害怕未来，会怀疑自己

很久以前看 anlin 老师的文章，记得评论区有句话说，说是如果有一天 anlin 老师不再更新文章了，说不定不是一件坏事，因为这说明 anlin 老师在努力生活，或者过得不错，所以不再写日寄了

可我不是

我想把这句话改改，我的日寄大多数时候都很丧，其中虽然有我个人的原因在，但也有深夜写文章的 buff 加成，我希望有一天，大家都能过得不错，这样就不用看我的文章来找一些什么精神共鸣了，但我还是希望提供一些其他东西在，比如我的失败经历、我的踩坑经验，也希望对你有些帮助

有时候总在想人到底为了什么而活

我问家里一个长辈，他说是为了他女儿，我觉得太俗套

我问还在上高中快要高考的表妹，她说是为了自己，我觉得太热血

我问了不少人，大多说法都很千篇一律

我想到问一个大学时候很中二的朋友，他说我脑子是不是进水了

我说我在思考人生，这是个大事

他说福州有家日料自助打折了，准备找空去吃

我也在看自助，但是自助的价格总是很贵

但是要是能睡前买一张自助餐票，然后睡醒了去坐一段不长不短的地铁，狠狠地吃一顿

这样活着也还不错

但人总会告别这个世界，如果是生病的话，应该会有一个时间周期，如果真有这么一天，我不希望你遇到我时，和我说你有多舍不得我，什么没我不行，什么明明知道没有希望还鼓励我的话，什么没有你日子怎么过，你有什么事情还没有做，等你好了我们一起去怎样怎样...

我更想听的是，你有多么怀念我，我这辈子已经完成了什么，告诉我接下来的日子没有我你们仍然会好好过

这就足够了

最近贼有意思，朋友和对象吵架要分手，朋友的对象问：那我们之前的回忆算什么？

TA 说这算你记性好

女生又说：如果未来再相见呢？

TA 说那算你运气好

我的运气就挺点背的，说了再见的人基本没能再见过

有些缘分就像北平的秋雨，不贪心便是落叶轻覆的思念，过分执着就成了望不穿的绵绵水帘

一生很长，很多人不会永远在我的生活里，但会永远在我的故事里

朋友说酒是万能的，配什么都能喝，也没什么忌口

我说也不一定，和头孢就能起反应

最近快放假了，我朋友说好久没来见过我了，问我有没有空，说是想我了

我发现人可以用懒这个词解释很多事情，特别是在现代社会

比如懒得起了，懒得学了，懒得卷了，懒得见了

摆烂这个词挺好，可以称得上是立体防御

什么时候等我摆明白了，或许就看开了

有时也会想在寒假去见一见多年未见的朋友，有时又觉得不值得

比如舍弃一些实习的机会，科研的时间

为了所谓的正确、成功，人们不断失去

我是那种会因为预料到将来的离别而去珍惜与当下朋友相处时间的人

但不是所有人都这样，所以大多数情况下我都是在浪费感情

这是一个流行离开的世界，但是我们都不擅长告别，时间不会抚平悲伤，只会让人淡然

我是个计划性比较强的人，但唯一不可能计划的便是生命的长度，我们往往在追寻其中忽视了它的宽度，忘记去创造更多的价值，我们不知道自己生命的长短，但我们现在还在这个世界上，就应该好好生活。生命本来就不长，焦虑也是一天，开心也是一天，为何不开开心心的过

最近看过一句话，不知道出自哪里，说是“今天可以死，明天也可以活”，这种境界是很高的

当我在写这篇年终时，正在为学习和生活上的一地鸡毛而烦恼着。

不知你们会不会也像我一样，在过去或未来的某个时刻，也在怀念着那个无忧的年代。

落叶随着风一阵摆动，家乡的银杏树一直都在，可是我已经回不去了

#06 生活碎片

人的烦恼就是记性太好，如果可以把所有事都忘掉，以后每一天都是个新开始，你说多好

时间改变了太多东西了

很荣幸能出现在别人的故事里 @zyu

总要做点什么自己认为正确的事

依旧 Eason

JayChou 今年倒是听少了

GitHub 2025

LeetCode 2025

📷 摄影是我割舍不去的爱好

略懂些游戏

和女友的 steam 家庭，有时间一定玩

应该没有女生不喜欢花，我妈妈也是

翔安唯一的美，就在他的晚霞

XMU 跨年晚会

厦门夏季的天气很不错，夜晚有风，但不冷，白天的余温还没散去，风吹来只觉得凉爽

很像大三刚保研完在湖边吹风的那个夜晚，意气风发

不过意气风发这个词仿佛永远都不再适合我了

2026.01.01

Thu, 01 Jan 2026 00:00:00 GMT

在 2026 的开始，我并没有许下什么新年愿望，似乎每一年都没有，但每一年都会经历很多难忘的事情

我的生活像支离破碎的镜面，然后我在其中寻找着相遇与感动，所幸，仍有值得留恋的地方

这几年不怎么想和不少朋友见面了，可能是因为老了些，朋友和技术一样，终究会出来新的，淘汰旧的，但也终究能有留存下来的人

这一年终究是过去了，我对 2025 的唯一感觉就是，年费会员快要到期了，该交钱了

还是艰难地走过了这一年，也终究迎来了一些未曾有过的改变，我或许会这样走过很多年，也许不会，这大概是一个普通人的历程

今年比往年要好很多，烟花凌空绽放，整座城市隆隆作响，极尽所能地宣告新年的到来，往年只有电视机里主持人带着职业假笑，高声呐喊这的倒计时，现在打开窗户，迎面扑来的是久违的焰火气息，让我想起遥远的过去

怀古切勿伤今，希望我们能够在未来再见，我的朋友

2025.08.30 京东笔试题

Sat, 30 Aug 2025 00:00:00 GMT

题解链接：https://mp.weixin.qq.com/s/M-YBVRdoGuKu9ZS9roUFVA

测评链接：https://niumacode.com/training/184

1. 定向越野

现在有赛事要在一山区举行，山区内有 $n$ 个打卡点（编号为 1~n），打卡点之间有 $m$ 条可供通行的山路，每条山路都需要花费确定的通行时间（单位：分钟）。赛事要求选手从“起点打卡点”出发，最终到达“终点打卡点”。组委会在某两个打卡点 A 和 B 之间设置了一条特殊索道，选手可以通过该索道在这两个打卡点之间瞬间往返（不消耗时间）。请计算选手从起点到终点的最短通行时间（保证存在可达路径）。

输入描述

第一行两个正整数 $n, m$ ，分别表示打卡点总数和山路数量。
第二行两个正整数，分别表示“起点打卡点”和“终点打卡点”的编号。
第三行两个正整数，分别表示设有特殊索道的两个打卡点的编号。
接下来 $m$ 行，每行三个正整数 $u, v, t$，分别表示打卡点 $u$ 和 $v$ 之间有一条山路，双向通行，通过该山路需要耗时 $t$ 分钟。
$1 ≤ n ≤ 100, 1 ≤ m ≤ 2 * n$，每条道路的时间花费在 $[1, 10]$ 之间。

输出描述

一个整数表示最短通行时间。

输入

输出

代码 1：Floyd 算法

把“索道”视为一条权值为 0 的无向边 (A, B)。用 Floyd-Warshall 求全源最短路，直接得到所有点对最短距离。最终答案就是 dist[s][e]。

复杂度：

时间：$O(n^3)$（n ≤ 100，可承受）
空间：$O(n^2)$

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    if (!(cin >> n >> m))
        return 0;
    int s, e, A, B;
    cin >> s >> e >> A >> B;

    const long long INF = (long long)1e15;
    vector<vector<long long>> d(n + 1, vector<long long>(n + 1, INF));
    for (int i = 1; i <= n; i++)
        d[i][i] = 0;

    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        if (w < d[u][v]) {
            d[u][v] = w;
            d[v][u] = w; // 无向边
        }
    }

    // 索道 0 费用
    d[A][B] = d[B][A] = 0;

    // Floyd
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            if (d[i][k] == INF)
                continue;
            for (int j = 1; j <= n; j++) {
                long long v = d[i][k] + d[k][j];
                if (v < d[i][j])
                    d[i][j] = v;
            }
        }
    }

    cout << d[s][e] << "\n";
    return 0;
}

代码 2：堆优化版的 Dijkstra 算法

直接使用 dijkstra 直接计算带权无向图单源最短路径，索道就是 0 权重的边。

这里使用的是「堆优化版的 dijkstra 算法」

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

typedef pair<int, int> pii; // (distance, node)

void dijkstra(int start, vector<vector<pii>>& graph, vector<int>& dist) {
    int n = graph.size();
    dist.assign(n, INT_MAX);
    priority_queue<pii, vector<pii>, greater<pii>> pq;
    dist[start] = 0;
    pq.push({0, start});
    while (!pq.empty()) {
        int u = pq.top().second;
        int d = pq.top().first;
        pq.pop();
        if (d != dist[u]) continue;
        for (auto& edge : graph[u]) {
            int v = edge.first;
            int w = edge.second;
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    int S, T;
    cin >> S >> T;
    int A, B;
    cin >> A >> B;
    
    vector<vector<pii>> graph(n+1);
    for (int i = 0; i < m; i++) {
        int u, v, t;
        cin >> u >> v >> t;
        graph[u].push_back({v, t});
        graph[v].push_back({u, t});
    }
    
    // 添加特殊索道：A和B之间双向0成本
    graph[A].push_back({B, 0});
    graph[B].push_back({A, 0});
    
    vector<int> dist;
    dijkstra(S, graph, dist);
    
    cout << dist[T] << endl;
    
    return 0;
}

2. 上升子序列

给定一个长为 $n$ 的排列 ${a}$，排列是指 ${a}$ 中包含 $1～n$ 的所有正整数恰好一次。

回顾一下， ${a}$ 的一个子序列是从 ${a}$ 中若干个元素（不一定连续）按取出顺序不改变相对位置形成的序列。

对于 ${a}$ 的一个子序列 ${b}$，如果 ${b}$ 中的元素单调递增，就称 ${b}$ 是 ${a}$ 的一个上升子序列。

对于 ${a}$ 的一个 ${c}$上升子序列，如果找不到比 ${c}$ 元素个数更多的上升子序列了，就称 ${c}$ 是 ${a}$ 的一个最长上升子序列。显然，${a}$ 可以有多个最长上升子序列。

请你对每个 $i∈[1,n]$ ，求出有多少个不同的 ${a}$ 的最长上升子序列包含 $a_i$。

输入描述

第一行一个正整数 $n$。
第二行 $n$ 个正整数，以空格分隔，表示 $a_i$。
保证 ${a}$ 是一个 $1～n$ 的排列。
$1≤n≤2*10^5$

输出描述

输出 $n$ 行，每一行一个非负整数，第 $i$ 行的输出表示包含 $a_i$ 的最长上升子序列个数。
因为答案可能很大，所以你只需要输出答案对 $998244352$ 取模的结果。

输入

5
3 1 4 2 5

输出

解释

对于输入的排列，其最长上升子序列长度为，所有不同的最长上升子序列如下：

$1,2,5$
$1,4,5$
$3,4,5$

以 $a_4=2$ 为例，包含了 $a_4=2$ 的最长上升子序列有 1 个，故答案为 1。包含了 $a_2=1$ 的最长上升子序列有 2 个，故答案为 2。

代码 1：涉及最长上升子序列（LIS）长度与计数的组合、前向/后向 DP、线段树（或树状数组）维护 <最长长度, 计数> 的区间合并规则（长度优先、同长计数相加）

这个问题要求我们求出每个元素 $a_i$ 在所有最长上升子序列中出现的次数。题目核心是通过动态规划与线段树结合来解决，具体思路如下：

计算正向 DP（从左到右）
- 使用 Fenwick 树来高效计算以每个位置结尾的 LIS 长度和数量。
- dp[i]：以 a[i] 结尾的 LIS 长度。
- cnt[i]：以 a[i] 结尾且长度为 dp[i] 的 LIS 数量。
计算反向 DP（从右到左）
- 将数组反转并映射值（a[i] = n - a[i] + 1），以便计算从右向左的 LIS（实际上是最长下降子序列的逆）。
- dp_rev[i]：从 a[i] 开始（到末尾）的最长下降子序列的长度（实际上是从右向左的 LIS）。
- cnt_rev[i]：相应的数量。
判断每个元素是否在 LIS 中
- 整个序列的 LIS 长度为 L。
- 对于元素 a[i]，如果 dp[i] + dp_rev[i] - 1 == L，则它出现在某个 LIS 中。
- 此时，包含 a[i] 的 LIS 数量为 cnt[i] \* cnt_rev[i] % MOD。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 998244353;
const int N = 200005;

int n;
int a[N];
int dp[N], dp_rev[N];
ll cnt[N], cnt_rev[N];

struct Fenw {
    int len;
    vector<int> max_val;
    vector<ll> cnt_val;
    
    Fenw(int n) : len(n), max_val(n + 1, 0), cnt_val(n + 1, 0) {}
    
    void update(int i, int val, ll c) {
        for (; i <= len; i += i & -i) {
            if (val > max_val[i]) {
                max_val[i] = val;
                cnt_val[i] = c;
            } else if (val == max_val[i]) {
                cnt_val[i] = (cnt_val[i] + c) % MOD;
            }
        }
    }
    
    pair<int, ll> query(int i) {
        int res_val = 0;
        ll res_cnt = 0;
        for (; i > 0; i -= i & -i) {
            if (max_val[i] > res_val) {
                res_val = max_val[i];
                res_cnt = cnt_val[i];
            } else if (max_val[i] == res_val) {
                res_cnt = (res_cnt + cnt_val[i]) % MOD;
            }
        }
        return {res_val, res_cnt};
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    
    Fenw fenw(n);
    for (int i = 1; i <= n; i++) {
        auto [val, c] = fenw.query(a[i] - 1);
        dp[i] = val + 1;
        cnt[i] = max(1LL, c);
        fenw.update(a[i], dp[i], cnt[i]);
    }
    
    int LIS = 0;
    for (int i = 1; i <= n; i++) LIS = max(LIS, dp[i]);
    
    reverse(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++) a[i] = n - a[i] + 1;
    
    Fenw fenw_rev(n);
    for (int i = 1; i <= n; i++) {
        auto [val, c] = fenw_rev.query(a[i] - 1);
        dp_rev[i] = val + 1;
        cnt_rev[i] = max(1LL, c);
        fenw_rev.update(a[i], dp_rev[i], cnt_rev[i]);
    }
    
    reverse(dp_rev + 1, dp_rev + n + 1);
    reverse(cnt_rev + 1, cnt_rev + n + 1);
    
    vector<ll> ans(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        if (dp[i] + dp_rev[i] - 1 == LIS) {
            ans[i] = cnt[i] * cnt_rev[i] % MOD;
        }
    }
    
    for (int i = 1; i <= n; i++) {
        cout << ans[i] << "\n";
    }
    
    return 0;
}

秋招的终局之战：意向书、offer 选择与三方

Mon, 25 Aug 2025 00:00:00 GMT

关于校招，我发现目前网上可参考的资料一般都是面试注意事项和面试经验，关于面试通过之后要怎么做的经验特别少。比方说面完 hr 面我该干嘛？谈薪的时候是怎么谈的？收到意向书是不是就可以什么都不管了？有这么多 offer 我该怎么选？我要拒绝 offer 最好什么时候说？怎么说？有没有模板？等等。

对于大多数人来说，我们都是第一次拿到 offer，甚至是第一次参加面试，对于这些相关的流程一窍不通。但是用人单位呢，他们大多已经举办了多届招聘，对于应届生的心态了如指掌，关键时刻打电话给你这么一催，你就容易上头，本来还在犹豫的 offer 也不等了。这就造成同学们前期不知道进行到哪一步了，下一步要做什么该做什么，整天检查邮箱生怕到手的 offer 因为没完成某个步骤而丢掉了，后期在面对多个 offer 的时候不知道该用什么标准来选择，被 hr 忽悠了去，错失了 argue 的机会或者跳到坑里去。

所以我写这篇文章的目的很简单，就是整理一下互联网秋招后期，主要是拿到 offer 之后的攻略，为大家的 offer 锦上添花。

HR 面结束后的全流程

这里只列举秋招面完hr面之后的流程，从投递到面试的过程不考虑在这篇文章之内，并且不同公司和不同学校的要求可能有所不同。

hr 面结束
做测评（百度华为等才会有）：测评主要是测试你的性格和一些行测题目，认真做就行，只要不是非常离谱都会过的，测评很少有卡人的。收到测评一般来说就意味着你面试通过了。
hr 打电话问你愿不愿意去实习（百度、快手等）：如果加了 hr 微信可能会在微信上问。比较缺人的组就会有这样子问，实习一般都不是必须，不过能去实习的话用人单位会比较喜欢，对于你上手工作也比较快，有的公司会将这一段实习时间算在晋升考核时间里，也就是晋升会更快。
hr 打电话发口头 offer（也就是 oc）：口头 offer 就是你通过了所有面试，这个口头 offer 约束力没那么强，也不会透露你的薪资，但是有 hr 会问你期望薪资是多少（比如 shopee），这个时候建议做好准备，给 hr 报一个年薪下限。我的经验是去找小伙伴，找到同样投这个公司的小伙伴的 QQ 群或者微信群，大家信息互通一下（不是说让你交流薪资啊！高压线），看看大家对于期望薪资是怎么报的，参考一下，然后也可以互相交流一下。
- 找这些群的渠道有：在牛客网上这个公司的话题里面找帖子，或者发帖求组团；问身边已经加入群组的人拉你进去。
- 第二个是看看 offershow，看往年相同职位的薪资，然后参考今年的整体情况报一下，给 hr 报的时候不能报具体数字，也不要报上限，建议就报一个下限，比如说我希望公司能给我不低于 30 万的年薪。但这个薪资不是最终的，这个时候除非是特别不想去的公司，一般建议都接下口头 offfer（或者说养鱼）。
座谈会（只有 TP-LINK 有）：座谈会就是发一封邮件约定某个时间参与一个线上会议，同一批次很多个候选人一起参加，主要是 hr 宣讲公司情况，福利待遇，和接下来的流程。座谈会上不会透露薪资情况，因为通常这个时候当年的薪酬方案还没做出来（薪酬方案每年都要重新做，因为市场薪酬价格一直在变）。就是了解一下公司的，只需要听就行，不听也行。云证信息（只有腾讯有）。会发一封邮件让你验证身份，就是扫码通过微信小程序做一下人脸识别，不需要准备其他手续材料。
邮件意向书：一般邮件意向书会在 oc 之后，你接受 oc 之后才有。注意，意向书也不能和 offer 划等号，这个意向书只是说我们公司承诺给你这个 offer，并且意向书上通常不会有薪资情况。有的公司会要求回复意向书，因为这个意向书可以视作两方协议，关于两方协议，相关工作里面有介绍，没有法律约束力，可以随意毁两方，并且通常是没有违约金的。注意看意向书邮件的末尾是否说了需要回复，或者点击链接确认，以及有效期，否则没有及时回复或确认可能会错失 offer！通常来说，收到意向书就 99% 稳了，一般很少有毁意向书的。这个时候除非特别不想去或者说明确说明两方违约要交违约金，一般建议接下意向书（或者说养鱼）。
谈薪：也就是俗称的“开奖”，通常形式是 hr 打电话过来跟你聊你的薪资情况。有几点需要注意的：
- 第一，hr 会问你手头都有什么 offer，薪资分别是多少，这个时候如果有其他的，就报一下，hr 可能会让你发意向书邮件截图或者带薪 offer 的薪资截图，如果你的其他 offer 确实很好，hr 会考虑给你重新确定薪酬方案（因为薪酬方案是已经确定的，要改的话要重新定），但一般不会因为你只有他一家 offer 立马 pua 压价（薪酬方案一般做出来了就不会临时改动）。
- 第二，有很多公司虽然说是谈薪，其实只是通知你一下你的薪酬方案是多少，不要以为 hr 会像面试一样花半个小时跟你讨论你的薪资该怎么分配。他把台词读完了之后会问你对 offer 有什么问题吗，要接 offer 吗，这时候如果你有更好的 offer 要 argue，就要在这个时候提出你的要求，比如不能比某某公司的薪酬低，总包不能低于多少多少等等，记住不要说确定的数字比如我要总包 42W，一定要说一个范围或者下限。如果你觉得这个 offer 不 ok，直接说很抱歉我不能接受这个薪酬或者我已经有更好的 offer 了。
- 第三，谈薪时间是不会提前约定的，谈薪电话通常会毫无征兆的打过来，如果漏接了也没关系，hr 会过几个小时再打一次，如果一直打不通，会给你发邮件的（亲测 TP-LINK 在多次打不通我的电话之后给我发了一封邮件约谈薪时间），如果你有加等开奖群，你会发现群里会一个接一个的有人开奖，如果开奖的跟你是同一个部门的，那你就要做好接电话的准备了。并且一个谈薪电话通常很短，没有 argue 环节的话通常不超过 5 分钟，hr 语速拉满，仿佛台词烫嘴，这个时候如果听不清，最好的方法是开启通话录音。并且如果公司 hr 收到拒 offer 反馈太多了还会二次谈薪（比如 2020 年秋招的百度、shopee 等等，第一次谈薪后又涨了一波，给所有人又打电话谈了一次薪），甚至你都已经接了还会再谈薪一次。如果有些公司催你接 offer 而另一些公司还没有到谈薪的地步，那你要拖一下，另外用这个已经谈薪的 offer 去催那个没谈薪的，一般你跟 hr 说一下有效期，对方会很快给你谈薪的。
- 签三方：这是最重要的一步！三方的形式有网签三方和纸质三方，根据发起方不同有学校发起和公司发起，这个要看学校，对，这是学校定的而不是公司规定的。比如广东的高校采用的就是网签三方的形式，且无需公司发起，通过小程序“广东大学生就业创业”来完成。
- 带薪 offer（大部分银行没有带薪 offer）：很多公司是在收到三方之后才会发放带薪 offer。带薪 offer 这个就是最终的 offer 啦，这个带薪 offer 会详细写明你的职位，福利和薪资，offer 上面数据可能会和三方不同或者跟 hr 跟你讲的不同，比方说签字费总包房补啥的，数字都需要好好看一下。这个带薪 offer 一般都是不需要确认的，但是为了稳妥起见，建议通读 offer 邮件全文。
- 填入职信息（比如腾讯）和申请实习：有的公司在带薪 offer 里面会提供入职信息填写的链接，这个时候就要填你的入职信息了，通常需要准备工牌照、英文名、毕业时间、入职时间等等。有些信息确实太早没法确定，可以问一下师兄师姐往年情况或者 hr 这种不确定的情况怎么处理。

选择 offer 考虑因素

更多参考链接：分享 offer 选择

这个东西非常主观的其实，因人而异，因为每个人考虑问题的时候最关心的点不同，比如有的人面向薪资编程，有的人家里不缺钱就想找个稳定的工作融入社会，有的人想跟 npy 待的近些，有的人非大厂不去，等等。我在这里结合自身心路历程和相关资料总结列举一下可能需要考虑的因素，具体每个因素怎么看待要看同学们了。其实适合自己的自己喜欢就行，没有必要掂量来掂量去的，比别人好也不见得是永远都好，以下各条因素之间并无排序，并不表示某一个比较重要，看个人偏好。

薪资（offershow）：一般来说这个具体看自己得到的薪酬跟同年同岗位应届生相比是什么水平（这个可以在 offershow 小程序里面看得到），跟往年同岗位相比什么水平，以及跟自己同实验室或者水平相当的同学相比什么水平，如果相差的比较大，先考虑能不能 argue，不能 argue 基本可以确定是公司开给你的劝退价，别去了。还要看薪资的构成，总包具体包括哪些？分几年给？加班费另外算还是算在了月薪里面？是不是把房补餐补也算在里面了？年终有多大的比例能拿满？通常来说薪资=base+签字费+股票（+房补+餐补+加班费+人才补贴），base 就是基本工资，通常是 M×N 的形式，以 32×16 为例，这个 base 的意思就是每个月月薪 32000，16 是一年发 16 个月，因为一年只有 12 个月，那么也就是说年终奖金是 16-12=4 个月的月薪，也就是 128000 元的年终。签字费也在很多公司里面有，意思就是你在劳动合同上签字我就给你这笔钱，一次性的。
base 地：base 地就是你将在哪个城市工作。base 地我们要考虑什么呢，通常来说同学们都会选择离家比较近的，或者当地有人才补贴的，落户比较方便的，房价比较低的，跟好朋友或者 npy 比较近的，这个 base 是不是总部，这个城市互联网产业发展好不好，机会多不多，气候怎么样。通常来说在总部比较好一些，年会什么的在总部举办的活动要大一些，总部的设施要完善一些，leader 一般都在总部。如果你打算在哪里工作哪里买房定居，那么户口和房价应该好好考虑一下，当然如果打算干两年回老家就不用了。
公司规模：看公司的平台大不大，对于应届生来说，第一份工作最好选平台比较大的，大公司流程比较规范，以后跳槽的时候简历上有一条比较加分的工作经历。并且大公司一般来说不会出现不良行为。在牛客文章「分享 offer 选择」中就有比较小公司之间的 offer 该怎么选和大公司之间的 offer 该怎么选的建议，在这里就不多说了，我觉得这篇文章总结的就很好。
是不是核心业务：每个大公司都有自己主打的业务，或者公司的营收主要靠某项业务支撑，那么最好了解一下自己的 team 是不是这项业务的。如果自己的业务是核心业务的话，能得到公司的重视，做的事情都不是小儿科，能够得到极大的锻炼机会，并且核心业务通常赚钱多，相应的绩效和年终也会很多。不过最近技术中台的职位也是比较受欢迎的，这种职位一般都是为各个业务提供接口，做业务的通常就是 ToC 的，技术中台则通常是 ToB 的，并且一般 ToB 的没有 ToC 的赚钱多，但是也没有 ToC 这么累。
公司文化（脉脉）：看个人对公司文化的喜好吧，可以问问身边一些已经在公司入职的学长学姐们，毕竟坊间的一些传闻多是添油加醋的，分分钟让你感觉像火坑，但是实际上感觉如何还是看个人的。具体就是你要去的那个组好不好了，可以让已经在公司工作的人内部打听一下，也可以到脉脉上看看（btw 脉脉上的东西建议不要过于迷信）

薪资组成结构

年包：base (基本工资 + 绩效 + 年终奖) + 期权/股票 + 签字费

⚠️ 互联网没有绩效，华为有绩效

薪资结构：薪资通常由基本工资 + 绩效工资构成。有些公司会将绩效工资设的较高，这虽然可能赚的更多，但也意味着更大的不确定性，往往比较卷。
五险一金：尤其关注社保和公积金的缴纳基数与比例。多数私企不会按全额月薪缴纳，但缴纳基数和比例越高对个人越有利。
年终奖：了解年终奖的评估标准，如是否固定发放、基于个人或公司绩效等，并询问普通员工的一般绩效水平。年终奖通常以 15 薪、16 薪等形式体现，表现突出者可获得更高奖金。
补贴：确认是否有餐补、交通补助、季节性补贴、住房补贴及生日福利等额外补贴，这些都是收入的一部分。
福利：健身房（建议考察其设施规模）、食堂、茶水间零食饮料、夜宵以及员工折扣等福利也挺重要的。
其他福利：留意是否有签字费、安家费或政府人才补贴等一次性或阶段性奖励。比如杭州就有人才补贴，相当于变相提高了收入。

如何谈薪？

参考链接：

如何谈薪

HR 常见压价话术 + 谈薪公式

2025 届秋招谈薪急救指南

如何跟 hr 聊薪资，argue 薪资的技巧全在这里

谈薪时间及基本常识

谈薪时间（HR 面后还需要确定是否给你发放 offer，发放 offer 后一段时间才会统一约谈薪资）
- 互联网企业大致在 10 月底 / 11 月初高峰统一谈薪，逼签三方
- 如果是体制内 / 国企，一般是直接面试完现场谈薪，而且这个薪资基本无法谈（argue）
⚠️ 互联网没有绩效（月薪 = base），华为才有绩效（月薪 = base + 绩效）
期望薪资：顾名思义就是你自己期望在这份工作中得到的薪资，通常有两种说法，不同公司 hr 方式不一样
- 一种是月薪，比如 30k
- 还有一种就是总包，比如年薪 50w
签字费：签字费就是签订了三方入职之后，公司会直接发到你账户一笔费用，这也是近些年公司们对人才争夺的一种方式。
白菜价（校招中最基础的 offer）、sp (special offer)、ssp (super special offer)
...

谈薪谈的是什么？

薪资中的固定部分：基本月薪如何发放？有没有拆分？如果有，不算绩效、补贴、提成的话，写在合同里的基本月薪是多少？
薪资中的浮动部分：绩效奖金、提成的发放标准是什么？计算逻辑是怎样的？公司有百分之几的人能够拿到全额奖金？有没有机会拿到超额奖金？
几险几金？缴纳基数是多少？缴纳比例是多少？有没有额外的商业保险？
其他福利待遇：有没有餐补、房补、交通补、出差补、医疗补、生日福利、节日福利等等？
公司的考勤制度是怎样的？每天工作几个小时？是不是双休？有没有全勤奖金？请假扣不扣钱？有没有带薪休假？年假不休的话能否折算成奖金发放？
有无签字费？签字费怎么发放？合约期是多少？发生违约该怎么办？

谈薪避坑

非常不建议说“自己找工作主要是积累经验，更看重机会，薪资不是那么重要”。这点非常致命，这很明显给了 HR 后续压你薪资的借口，属于是自己给自己画饼了
不要直接给出你的心理预期薪资，可以先反问对方“请问公司给咱们这个岗位的预算是多少”或“咱们的薪资结构大概是怎样一个构成呢”
- 月 base 多少？发多少个月？
- 多少个月是年终奖？
- 年终奖的计算逻辑是怎样的？
- 有没有绩效津贴？
- 薪酬的支付周期和具体到账时间？
不要用城市生活成本高、压力大之类的话术要求更高工资，因为公司给你更高薪资取决于你的能力而非生活成本
不要直接说出自己期望薪资的底线，往往会造成薪资低于这个数。可以先不说具体数字，先和 HR 沟通公司的薪资结构，福利待遇等，最后稍加思考后，适当抬高你的期望薪资

谈薪必问合集

薪资结构一定要了解清楚

固薪发几个月？几月发？
年终奖范围？几月发？
月薪包含绩效吗？
社保公积金缴纳比例？
工资以外的福利？
公司加班是发加班费还是调休呢？

谈薪模板

✅ 万能报价语句：准确报数字 + 缓和气氛 + 综合考虑

🔥 参考薪资公式：目标薪资 + 15% 报价

HR 一定会压价，所以需要还价

✅ 万能还价语句：理解 + 阐述优势 + 加入意愿 + 再次报价 + 请求协助

比如说你的底线薪资是 20K，市场平均薪资是 25K，你的目标薪资是 27K，就直接说：

1️⃣ 我的期望薪资是月薪 31K，我之前做了一些市场调查，还有我在这个岗位师兄师姐进行了解和反馈，这个薪资我觉得是一个市场的平均值；

2️⃣ 回归到胜任能力上，同时在前面几轮的面试中，我相信面试官你们也是充分了解了我的能力；而这个岗位所需要的 XX、XX 能力，在我过往的经历中是可以体现的，因此这个岗位我是完全能够胜任的；

3️⃣ 另外我手上也有其它公司的面试机会 / offer，但在此前面试中我也感受到贵公司的企业氛围/福利/文化是我比较喜欢的，所以在同等情况前提下我更愿意来贵公司；

4️⃣ 同时因为我从学校出来要考虑到租房、出行等费用，综合考虑下我觉得这个薪资是比较合理的。

5️⃣ 希望 HR 您能帮我争取一下！

如何 argue

寒暄环节：客套一下，感谢公司发 offer，快速切入正题；
核心模板：先表达你来该公司的强烈意愿，然后表示你拿了什么什么厂的什么价位的 offer，白菜就别说了，如果 sp 可以说，然后表示如果能在这个价位基础之上加多少钱就更合适了，自己未来还是想来这边发展的，希望这边可以帮忙申请一下。
最后等待结果，并再次感谢对方给与这次机会。
一般来说，如果第一次没有 argue 下来，又特别想试试，可以二次 argue，但不建议事过三。

当然以上的方式有点强硬，对于没有高薪 offer 的同学也想得到稍微比较高的薪资的 offer，态度可以换一种。

沟通的时候依旧去表达一下自己的期望薪资，也许期望薪资会在 hr 给你开出具体薪资之后才说，并且这两者之间有一定的出入，那么可以尝试性的沟通一下，我这边对薪资也有了一定的了解，结合我个人能力来评估，希望能够你在开出的薪资上面提升一些，跟我的预期更符合一些，同时我也有一些其他的 offer 的在手上，他们有些开了薪资，有些会在之后谈薪资，但是如果贵公司能够达到我的期望值，我会立马下定决心去这里。

当然特别需要注意自己的语气和行为方式，所谓知己知彼方能百战不殆，之前也出现过 argue offer 将 offer 弄没了的，也有些公司如果需要 argue sp offer 需要进行加面，不成功也许 offer 就没了，去年身边有同学就在加面中挂了，血的教训所以对于那些你比较想去的公司，需要合理的去评估自己的实力。现在大家都会有一种心态，就是比较。在没拿到公司的 offer 之前，特别想通过面试，拿到 offer，拿到 offer 之后，发现身边的同学薪资都比较高，心理多少会出现不平衡的状态，然后可能就会导致在和 hr 谈薪资的过程中会犯错误，没有合理的去评估实力就进行 argue，如果只是 argue 失败，保持一开始的薪资还好，如果被收回 offer 就追悔莫及。

另外，脱离公司、岗位、部门比较薪资本身就是一种错误的行为，例如近两年火热的算法岗，一部分公司区别对待，算法和开发工资有点差别，有些公司就是无差别对待。

另外要注意 offer 提供的地点。举个例子，小米在北京和武汉开出的薪资就是不一致的，可千万别看见 offershow 北京的工资去和公司谈武汉的薪资，因为一线城市和二线城市消费水平本身就有一定的差距，二线城市对于许多人来说，离家近，所以也一定程度上牺牲了薪资。

总结：

argue 薪资有可能需要出示证明，所以没有备用 offer 原则上不建议编造
通过 offershow 提前知道公司开出的 offer 薪资大致的区间，同时也给自己制定一个期望薪资
需要有同级别公司的 offer（白菜、sp、ssp）才能去 argue 大公司的 offer。例如百度的签字费去年是针对拿到字节、阿里、腾讯的人可以 argue
有些公司 sp、白菜是在面试的时候就已经确定了的，这个是根据面试表现来给，argue 的话更多的是要签字费
阿里（杭州）第一年对于应届生有 10w 补贴，所以在拿阿里 offer 去和别的公司 argue，自己也可以算上
对于不那么想去的公司，argue 可以强硬一点，对于特别想去的公司，如果薪资还满意的话，符合自己的实力，不建议盲目的上去 argue
部分公司可以在谈完薪资之后继续谈，如果不成，大不了不去
如果想留多个 offer 进行比较，还是那句话，argue 要注意分寸，不要把原来的 offer 给 argue 没了
有些公司薪资是可以谈的（比如美团），有些公司的薪资对于大部分的人来说谈不了（比如字节），所以了解清楚你要去谈薪资的公司是否可以谈
argue 有风险、合理评估实力再决定

毁约或拒绝 offer 话术

什么时候放弃 offer，一般来说有两个阶段（意向书阶段 or 谈薪阶段）：

一个是公司发下来意向书的时候，在意向书的末尾都需要点击链接确认或者放弃意向书，这个时候点击放弃，或者等待意向书有效期过自动放弃，又或者要求回复该意向书邮件，这时候回复邮件里就表明放弃就可以了。不过这样的话无论你是点击放弃还是过了有效期自动放弃，hr 都会打一个电话过来向你了解情况，防止你忘了或者误操作之类的。这个时候一般都会问你为啥放弃这个 offer 呢，你就说你的理由就可以了，不过需要注意的是这个时候一般还没有谈薪，你不知道你将要放弃的公司会开给你多少钱，或者你的 dream offer 会开给你多少钱。
第二个阶段就是 hr 打电话来谈薪的时候，谈完薪资，就基本上一切都确定了，你再考虑是不是要放弃，这个时候可以直接在电话里头跟 hr 说你要拒绝。当然还有一种委婉的方式是在 hr 给你的考虑期限内，给 hr 发一封邮件拒绝。如果拒绝的很早，也是可以的，但是一般不建议在口头 offer 或者意向书之后就拒绝，因为你还没有薪资信息给你参考，这个时候就拒绝的话难免有考虑不周的可能。

开头感谢：对方的机会、认可和时间付出

表明态度：说明无法接受 offer，态度诚恳且明确

简述原因：原因简洁，避免负面评价（如职业规划调整、家庭原因等）

表达歉意：对浪费的时间与资源表示歉意

表达期望：祝福对方，并表达未来合作的可能性

电话/微信/短信

如果是打电话或者发微信，发短信的话，你可以说:

“很感谢你们给我的宝贵机会，我已经有更好的 offer 了，所以暂时不考虑其他 offer，希望将来有机会再合作，非常抱歉给贵公司的招聘工作带来不便，祝你们招聘顺利！”。

或者：

“非常感谢你们对我的认可，但是我现在已经拿到了更合适我的 offer，综合考虑之后，我认为这个 offer 跟我的职业规划并不是十分匹配（适用于不喜欢这个岗位，这个 base 的情况）/我认为贵公司的薪资不符合我的预期（适用于薪资太低的情况），因此我决定放弃这个 offer，很抱歉给贵公司的招聘工作带来的不便，祝你们招聘顺利！希望将来有机会再合作！”

或者：

“面试官您好，了解完贵团队的相关业务之后，我觉得我还是不太适合这个方面的开发工作，所以我打算放弃这个机会，感谢贵公司给我的宝贵机会（这个是我在面完某公司二面之后，面试官觉得这个职位跟我的背景不是很符合，加微信让我考虑考虑，之后我给面试官发的微信消息）”

或者：

“面试官您好，我已经慎重考虑过了，综合 XX 的价值观和 base 薪资等因素，我觉得目前来说 XX 公司不是很适合我。非常感谢 XX 公司对我的认可，希望以后有机会再合作。”（这是我面试时加了 XX 公司面试官的微信，谈完薪后在微信上把决定告诉面试官，由面试官传达 hr 的）

或者：

“面试官您好，很抱歉这么晚来打扰您。我很认真的思考过了，因为我目前已经拿到了十分合适我的 offer 啦，因此并不打算考虑其他机会，也不想浪费面试官们宝贵的时间。XXXX 我有一点了解，您的部门有很光明的前景和潜力，但是我个人觉得并不是很适合这个方向，所以还是不打算继续接下来的流程啦。”（这是我已经拿到 Y 公司的意向书后，XX 公司的面试官加我微信邀请我面试，我给面试官发的拒绝消息，仅供不打算继续面试流程的同学们参考）

邮件

而如果你是发邮件拒绝的话，可以这么说：

尊敬的 TT 公司 hr 您好！我是 YYYY 年校园招聘提前批中获得贵公司 offer 的候选人 XXX。非常感谢 TT 公司给我的 offer，由于本人获得了另外更适合我的 offer，根据自己的职业期望与规划，思考良久，认为目前 TT 公司不是十分符合自己的专业方向与职业规划，故决定放弃贵公司的录用邀请。祝愿贵公司能找到更加适合这个职位的人选，我很抱歉给贵公司的工作带来的不便，若今后有机会也非常希望能再次合作。

三方与毁三方流程

三方实际就是毕业生就业协议。其实是全国普通高等学校就业协议书，哪三方呢，有毕业生，用人单位和学校。能够解决应届毕业生的一些福利待遇等，具体根据双方谈的条件来定，正常来讲会有五险一金，有的公司涉及档案，户籍等等，等到正式入职之后这个三方就自动终止了，说白了对我们就没有用了。

毁三方的流程：如果不是因为特别的原因一般不要毁三方，因为一个是时间会拖的很长，一个是需要违约金，因为我也没有毁过三方，所以这里引用牛客帖子「offer、三方、两方、毁约，这些你需要知道的事」中关于毁三方的详细流程：

与原单位协商，向原单位接收违约，按照三方协议规定，交纳违约金（有些单位不收违约金），从原单位开出退函。
从新单位获取接收函。
拿着原单位退函和新单位接收函到就业指导中心领新三方（有时也不需要接收函）。
拿新三方与新单位签约。

这个过程中，关键在于第一步：如何与原单位协商，拿到退函。具体的情况，不同单位不一样，有的单位可能会拖很久。所以，如果新单位的签约时间很紧，而原单位又不会很快给你开退函的话，那结果很可能是你两家单位都签不了。

技术面反问环节与 HR 面常见套路与反问

Sun, 24 Aug 2025 00:00:00 GMT

本文主要罗列一下技术面/主管面的反问环节参考问题，以及 HR 面的常见问题和反问参考。

首先，作为求职者而言，要清楚面试是一个双向选择的过程，刚刚被面试官一通提问过后，权力的棒子就交回你手中了。所以在这个环节，要基于你自身实际的需求，充分挖掘这家公司你在意的点。如果什么也不问，等于你就错失了一次通过内部渠道熟悉公司的好机会，还可能会跳进一些不知道的坑。对于招聘方而言，清晰、有条理的提问不仅会提高你在面试人员心中的好感度，也能让面试方觉得你对他们感兴趣、是真的想来他们公司，而不是把公司当做自己池子里的鱼。

下面我将按照不同轮次的面试去分类，分别介绍一下反问环节的技巧。注意面试之前要还是要通过各种信息途径对公司去有一个基本的了解，所谓知己知彼者，百战不殆。

预期使用方式

检查一下哪些问题你感兴趣
检查一下哪些是你可以自己在网上找到答案
找不到的话就向面试官提问

绝对不要想把这个列表里的每个问题都问一遍（尊重面试官的时间）

⚠️ 注意：无论哪一轮的面试，一定要做到不卑不亢，不能怯场，特别是 HR 面。

HR 面一定要做到：自信！自信！还是 tmd 自信！

HR 不懂技术，这时候可以狠狠地吹。

聊天时言语中可以带有真诚的语气，但回答的内容不要过于老实。

正所谓真诚是必杀技，但是只有真诚那是杀必。

个人推荐的问题 🙋

技术面 / 主管面

组内的业务与技术栈？
可以再详细介绍一下这个岗位的具体职责吗？
组内的 Code Review 是怎么做的？
公司/部门对于实习生/校招生有没有技术栈上的要求？计算机基础、项目经历和编程能力怎么考量？
您能介绍一下你们部门在整个业务环节中扮演的角色吗？（用于试探是不是边缘部门）
工作节奏是怎样的呢/是否加班？（这个问题我觉得问一线员工比问 HR 靠谱）
你们部门的工作是预研还是解决现有需求？
对接人/乙方/客户主要是谁？
生产环境发生事故了怎么办？
新员工入职的培训流程/培养机制？
团队总共有多少人？
部门未来会逐渐拓展新的业务吗？

HR 面

按以下 3 个模块顺序问，因为薪资在后续还会再提及，如果 hr 没问预期薪资，则不需要/不该（在 hr 面）主动咨询具体给到的薪资范围，但是一定要问问薪资结构的组成、福利等。

个人发展
- 培养机制？晋升渠道？涨薪途径？
- 每年几月份调薪？调薪幅度是？
- 试用期多久？转正要求是什么？试用期薪资打折吗？
- 岗位稳定性如何、是否会裁员？
休假
- 工作节奏如何？午休多久？双休吗？
- 年假有多久？带薪休假时间有多久？
- 病假和事假是分开的还是一起算？
- 加班是调休还是双倍薪资呢？
薪资福利
- 薪资结构是怎样的？
- 年终奖情况与绩效评定？
- 有五险一金或者其他退休养老金等福利吗？
- 公积金按多少比例缴纳？
- 公司是否有食堂，是否提供餐补/房补/交通补贴？

技术/主管面【反问环节】

该轮面试的特点是面试方对具体的工作业务流程都很熟悉，所以可以问以下内容：

工作内容：主要针对技术面，包括不限于岗位职责、具体工作形式等，可结合自己对部门的了解去问，越详细越好，最好能接着面试官的话题去问，他们会认为你对这份工作有着深入的理解，也方便你判断自己对岗位是否感兴趣、契合度高不高。常见提问形式：
- 可以再详细介绍一下这个岗位的具体职责吗？
- 我们部门的工作是预研还是解决现有需求？
- 对接人/乙方/客户主要是谁？
- 工作时间如何/是否加班？（这个问题我觉得问一线员工比问 HR 靠谱）
公司层面：主要针对主管面，相比于基层员工，主管对于业务和整个公司战略的层面有更深入的理解。常见提问形式：
- 您能介绍一下我们部门在整个业务环节中扮演的角色吗？（用于试探是不是边缘部门）
- 公司/部门的氛围如何？工作节奏怎么样？
- 新员工入职的培训流程/培养机制？
- 团队总共有多少人？
- 会逐渐拓展新的业务吗？
- 行业未来前景如何？

其它也可以接着技术面觉得没问充分的点继续深入，下列是所有反问合集，仅供参考。

职责

On-call （电话值班）的计划或者规定是什么？值班或者遇到问题加班时候有加班费吗？
我的日常工作是什么？
有给我设定的特定目标吗？
团队里面初级和高级工程师的比例是多少？（有计划改变吗）
入职培训 (onboarding) 会是什么样的？
每个开发者有多大的自由来做出决定？
在你看来，这个工作做到什么程度算成功？
你期望我在最初的一个月 / 三个月能够完成什么？
试用期结束的时候，你会怎么样衡量我的绩效？
自己单独的开发活动和按部就班工作的比例大概是怎样的？
一个典型的一天或者一周的工作是怎样安排的？
对我的申请你有什么疑虑么？
在这份工作上，我将会和谁紧密合作？
我的直接上级他们的上级都是什么样的管理风格？（事无巨细还是着眼宏观）
我在这个岗位上应该如何发展？会有哪些机会？
每天预期 / 核心工作时间是多少小时？
我入职的岗位是新增还是接替之前离职的同事？（是否有技术债需要还）？
入职之后在哪个项目组，项目是新成立还是已有的？

技术

公司常用的技术栈是什么？
你们怎么使用源码控制系统？
你们怎么测试代码？
你们怎么追踪 bug？
你们怎样监控项目？
你们怎么集成和部署代码改动？是使用持续集成和持续部署吗 (CI/CD)？
你们的基础设施搭建在版本管理系统里吗？或者是代码化的吗？
从计划到完成一项任务的工作流是什么样的？
你们如何准备故障恢复？
有标准的开发环境吗？是强制的吗？
你们需要花费多长时间来给产品搭建一个本地测试环境？（分钟 / 小时 / 天）
你们需要花费多长时间来响应代码或者依赖中的安全问题？
所有的开发者都可以使用他们电脑的本地管理员权限吗？
介绍一下你们的技术原则或者展望。
你们的代码有开发文档吗？有没有单独的供消费者阅读的文档？
你们有更高层次的文档吗？比如说 ER 图，数据库范式
你们使用静态代码分析吗？
你们如何管理内部和外部的数字资产？
你们如何管理依赖？
公司是否有技术分享交流活动？有的话，多久一次呢？
你们的数据库是怎么进行版本控制的？
业务需求有没有文档记录？是如何记录的？
你们是如何面对和解决技术债的？是否有专门的时间或者预算用于重构？
你们如何进行单元测试呢，是否都有单元测试的习惯？

团队

工作是怎么组织的？
团队内 / 团队间的交流通常是怎样的？
你们使用什么工具来做项目组织？你的实际体会是什么？
如果遇到不同的意见怎样处理？
谁来设定优先级 / 计划？
如果团队没能赶上预期发布日期怎么办？
每周都会开什么类型的会议？
会有定期的和上级的一对一谈话吗？
产品 / 服务的规划是什么样的？（n 周一发布 / 持续部署 / 多个发布流 / ...）
生产环境发生事故了怎么办？是否有不批评人而分析问题的文化？
有没有一些团队正在经历还尚待解决的挑战？
你们如何跟踪进度？
预期和目标是如何设定的？谁来设定？
Code Review 如何实施？
给我介绍下团队里一个典型的 sprint
你们如何平衡技术和商业目标？
你们如何共享知识？
团队有多大？
公司技术团队的架构和人员组成？
团队内开发、产品、运营哪一方是需求的主要提出方？哪一方更强势？

问未来的同事

开发者倾向于从哪里学习？
你对在这里工作最满意的地方是？
最不满意的呢？
如果可以的话，你想改变哪里？
团队最老的成员在这里多久了？
在小团队中，有没有出现成员性格互相冲突的情况？最后是如何解决的？

公司

公司为什么在招人？（产品发展 / 新产品 / 波动...）
有没有会议 / 旅行预算？使用的规定是什么？
晋升流程是怎样的？要求 / 预期是怎样沟通的？
绩效评估流程是怎样的？
技术和管理两条职业路径是分开的吗？
对于多元化招聘的现状或者观点是什么？
有公司级别的学习资源吗？比如电子书订阅或者在线课程？
有获取证书的预算吗？
公司的成熟度如何？（早期寻找方向 / 有内容的工作 / 维护中 / ...）
我可以为开源项目做贡献吗？是否需要审批？
你认为公司未来五年或者十年会发展成什么样子？
公司的大多数员工是如何看待整洁代码的？
你上次注意到有人成长是什么时候？他们在哪方面成长了？
在这里成功的定义是什么？如何衡量成功？
有体育活动或者团建么？
有内部的黑客马拉松活动吗？
公司支持开源项目吗？
有竞业限制或者保密协议需要签吗？
你们认为公司文化中的空白是什么？
能够跟我说一公司处于不良情况，以及如何处理的故事吗？
您在这工作了多久了？您觉得体验如何？
大家为什么会喜欢这里？
公司的调薪制度是如何的？
公司有没有申请调岗的制度？
公司对于员工的心理健康和福祉有什么具体措施？
你对在这里工作最满意的地方是？你为什么留在这家公司？

社会问题

你们关于多元化招聘什么看法？
你们的公司文化如何？你认为有什么空白么？
这里的工作生活平衡地怎么样？
公司对气候变化有什么态度吗？

冲突

不同的意见如何处理？
如果被退回了会怎样？（“这个在预计的时间内做不完”）
当团队有压力并且在超负荷工作的时候怎么处理？
如果有人注意到了在流程或者技术等其他方面又改进的地方，怎么办？
当管理层的预期和工程师的绩效之间有差距的时候如何处理？
能给我讲一个公司深处有毒环境以及如何处理的故事吗？
如果在公司内你的同事因侵犯他人而被调查，请问你会如何处理？
假设我自己很不幸是在公司内的受害者，在公司内部有没有争取合法权益的渠道？

商业

你们现在盈利吗？
如果没有的话，还需要多久？
如果有的话，年度营业额是大概有多少？（我现在的公司年度营业额是 5 亿）
公司的资金来源是什么？谁影响或者制定高层计划或方向？
你们如何挣钱？
什么阻止了你们挣更多的钱？
公司未来一年的增长计划怎样？五年呢？
你们认为什么是你们的竞争优势？
你们的竞争优势是什么？
公司未来的商业规划是怎样的？有上市的计划吗？
都在做副业吗？

远程工作

远程工作和办公室工作的比例是多少？
公司提供硬件吗？更新计划如何？
使用自己的硬件办公可以吗？现在有政策吗？
额外的附件和家具可以通过公司购买吗？这方面是否有预算？
有共享办公或者上网的预算吗？
多久需要去一次办公室？
公司的会议室是否一直是视频会议就绪的？

办公室布局

办公室的布局如何？（开放的 / 小隔间 / 独立办公室）
有没有支持 / 市场 / 或者其他需要大量打电话的团队在我的团队旁边办公？

终极问题

该职位为何会空缺？
公司如何保证人才不流失？
这份工作 / 团队 / 公司最好和最坏的方面是？
你最开始为什么选择了这家公司？
你为什么留在这家公司？

HR 面【常见问题】

HR 面之前一定要背调公司以及相关部门，对公司有一个大概的了解。

还有个大伙常见的疑问：公司 HR 面会刷人吗？

首先很多大厂的 HR 权限很大，拥有一票否决权，真的会刷人

小厂的 HR 来说权限不大，一般不太会刷人

一般来说，只要 HR 面你表现得像个正常人/人一样，然后自信一点，对公司价值观认可点，问题都不大，很多时候你挂了不一定是 HR 面挂了，可能是 HR 面之后的排序挂了

1. 你为什么选择我们公司？

想和优秀的人（前几轮面试官）做有挑战的事（业务与未来发展契合）

🔥 回答这个问题的前提：提前了解了公司的主营业务、核心产品、行业地位、文化价值观（如官网、新闻稿、社交媒体），仔细阅读 JD，提炼岗位关键词，针对性准备案例。

高分逻辑：体现对企业的深度了解 + 个人职业规划的契合（有理有据即可，体现你对公司的向往和理解）

【示例】我注意到贵司近年来在大模型领域的技术投入（如 xxx 项目），这与我的专业背景和长期关注的行业方向高度匹配。同时，我也想和优秀的人做有挑战的事，通过前几轮面试，我感受到了贵公司技术有深度，氛围好，让我坚信在这里能快速成长。

2. 职业规划/你对未来有什么规划？

不要假大空，说做几年然后升架构师...

我的未来规划是，我觉得人应该两条腿走路，一条腿是技术，一条腿是业务。技术是为业务服务的，你脱离了业务，技术就没有意义了；脱离了技术，业务就没法实现了。

业务层面：我了解咱们公司，（举个例子）咱们部门是搞本地生活的，本地生活涉及到了人的衣食住行，至关重要，有一天可能短视频/游戏/xxx 业务都没了，但是人的衣食住行一定是存在的，所以我觉得公司的业务是很有价值的，我希望未来在公司中深挖业务，能够提升自己对整个行业的理解，我之前实习/工作的时候，有个 xxx 需求没解决/报错了，但是半个月都没人发现，为什么，因为当时我们做的是伪需求，我们解决的问题不是痛点问题，我希望我的技术能够为业务赋能，去挖掘用户痛点，解决用户的痛点问题，以此创造价值。
技术层面：我希望深入了解公司的技术，陪着公司一起成长，...（了解公司的技术的话可以吹一波）

希望我后面无论是在技术方面还是在业务方面，都能做到在公司独当一面。

这样回答，既有技术又有业务，还有你对公司行业的思考，中间甚至吹了一波公司，比那些假大空的回答好多了。

3. 你怎么看待加班 / 996，是否接受加班？

不卑不亢，尽显男儿本色 [doge]

我可以接受加班，尤其是在紧急需求下，工作分内之事我肯定义不容辞，但是这一定是要建立在高效的工作之上，而不是为了加班而加班，所以我会提高自己的工作效率，避免不必要的加班。

因人而异地追问：想问下贵公司一般都是什么原因导致加班呢？其他小伙伴加班频率怎样？加班有没有调休制度呢？方便我提前做准备。

4. 你有什么优点/特点？

如果 HR 问你有什么特点/优点，请记住一定要说出一个词“靠谱”。

为什么要一面、二面、HR面，往宽泛了说就是，往往学历越高的人都是越有能力的，面试表现得越好就越有能力，越有能力的人越能干成事儿，能干成事的人他就靠谱，就能放心的把事情交给你。

参考词汇：靠谱、目标感强、有规划、主动性强、不拖沓、有责任心

可根据以上几个词举实际场景佐证。

5. 你有什么缺点？

选择与岗位无关且可改善的点，避免暴露致命短板。

⚠️ 别和优点矛盾

下列举几个例子

1️⃣ 我有时候会对细节过于苛求，希望把事情做得尽善尽美，这可能导致在项目初期花费较多时间进行打磨。但我已经意识到，在追求质量的同时也需要兼顾效率，完成比完美来得重要。后来我会在项目开始前设定清晰的时间节点和优先级标准，确保在关键细节上投入主要精力，同时不影响整体的进度。这个方法让我既能保证工作输出质量，又能按时完成任务。

2️⃣ 我过去在大型会议或面对不熟悉的群体做 presentation 时容易紧张，不过我们实验室每周会固定开组会分享论文，我都会主动在组会上争取更多的分享机会来锻炼自己，挑战自己的软肋，因为我清楚这对于职业发展很重要。导师也会带我们出去各种大型会议参加活动和做 presentation，现在我已经能更自信、有条理地表达自己的观点了，虽然还存在不足，但是已经有所进步了。

3️⃣ 在读研的期间，我对很多新任务都充满热情，所以有时会不自觉地承接过多任务，导致自己的核心项目受到影响。后来我学会了更高效地进行优先级管理，并且定期和我的导师对齐工作重点，确保我的时间精力都投入在最重要的事情上。这不仅提高了我的个人效率，也保证了主线和所有支线的平稳推进。

4️⃣ 我的缺点是缺乏自信，...

5️⃣ 我是个急性子，有时候没有特别想清楚就开始干了，可能会导致过程中和团队同事有一些往复的讨论和确认，耽误时间，造成团队同事的困惑。

6. 目前手上有没有其他 offer？

无论什么面试，一定要扬长避短，当 HR 询问你是否手头有其他 offer 时，回答这个问题需要既展示你的市场竞争力，也要表现出对当前面试公司的高度兴趣。

你有其他公司的 offer 说明你能力强、价值高、比较抢手，但同时也说明了你没那么稳定，你有可能去其他公司。候选人的稳定性是非常重要的，你有其他 offer，价值上去了，稳定性就下来了。

⚠️ 如果没有 offer，HR 面可以说有 offer，但是谈薪阶段不能编造 offer，有些需要提供证明才能 argue。

个人战略：

对于「小厂」就说没有 offer 或者提及几个体量差不多的公司；

对于大厂则必须说有 offer，用于 argue 和体现自己价值。

✅ 有 offer 的话术：

1️⃣ 现在 xxx 公司给我发了 offer，但是我觉得你们公司很不错，业务前景很好，（此处省略一段，这里可以吹一波公司的业务），但是他那边已经发了 offer，如果说你们这边能够尽快发 offer 的话，我收到 offer 之后我就把那边拒了。
2️⃣ 目前我确实收到了几个公司的 offer。这些公司虽然各有千秋，但我发现它们与我的职业发展规划并不完全吻合。相比之下，贵公司的职位更符合我的长远职业目标。我对贵公司的发展潜能非常感兴趣，因此我非常期待能有机会加入您的团队。
3️⃣ 是的，我已经拿到了两个 offer，这些公司与贵公司在行业定位上有不少相似之处。然而，通过今天的了解，无论是从公司的发展前景、职业成长空间，还是面试过程中体验到的公司氛围来看，贵公司都给我留下了更为深刻的印象。我会在您做出决定之后，认真考虑是否接受其他 offer。

核心是表达出我有后手有退路，但只要你们给，一定是选你们。而且别搞得太生硬，整些什么仰慕公司文化之类的就太假太尬了（除非一些企业文化印象深刻 / 广为流传，比如鹅厂），尽量给一些软理由（信服力比较强）：

xx 公司路程远，贵公司的路程比较方便；

我男/女朋友要去你们那里发展/拿了那边公司的 offer，我不想异地恋；

我有个 xx 亲戚在你们那 xx 城市，可以给我点帮助，这样我不用租房；

看中 xx 城市户口，希望给未来自己孩子 xx 条件。

⚠️ 但是如果两家公司差距过大，就不要提了，比如你在面一个小公司，你告诉 HR 说你拿到了字节的 offer，但是我更想去你们这个小公司，别说 HR 不信了，你自己都不相信这是你说的。

✅ 没 offer 的话术：

1️⃣ 我近期才开始积极寻找工作机会，之前参与过两家公司的面试，并且已经进入最后阶段。尽管还未收到正式 offer，但我对贵公司的职位特别感兴趣。我认为贵公司的岗位职责和未来的发展潜力与我的职业规划高度契合。因此，我非常希望有机会加入贵公司的团队。
2️⃣ 我最近才开始面试，对于求职过程持谨慎态度，并没有广泛投递简历，而是选择性地申请了几家我特别感兴趣的公司。目前有两家公司正在进行中，但尚未接到具体 offer。我对贵公司所在行业的前景感到非常乐观，并认为这是一个能够促进我职业发展的绝佳机会。因此，我非常倾向于加入贵公司。

7. 你的期望薪资是多少？

⚠️ 并非每一场 HR 面都会问你期望薪资，一般在 10~11 月谈薪。

参考视频：2025 届秋招谈薪急救指南

不要直接给出你的心理预期薪资，可以先反问对方“请问公司给咱们这个岗位的预算是多少”或“咱们的薪资结构大概是怎样一个构成呢”
- 月 base 多少？发多少个月（几薪）？
- 月薪有没有包含绩效？
- 多少个月是年终奖？
- 年终奖的计算逻辑是怎样的？
- 薪酬的支付周期和具体到账时间？
非常不建议说“自己找工作主要是积累经验，更看重机会，薪资不是那么重要”，这点非常致命，这很明显给了 HR 后续压你薪资的借口，属于是自己给自己画饼了
HR 直接问候选人期望薪资是多少，一般有「月薪」或者「总包」两种说法，可以先咨询下 hr 问的是月薪还是年包（如果说都可以，那还是说月 base 吧，年包容易被坑）
参考往年和今年的整体情况报一下，给 hr 报的时候不能报具体数字，也不要报上限，建议就报一个下限，比如说我希望公司能给我不低于 50 万的年薪，但这个薪资不是最终的
至于该公司往年市场薪资如何，可以根据「OfferShow」提供的数据，让你对各公司各岗位（各 bg 下）的市场价位有一个大致的了解

✅ 回答模板（以月薪为例）

比如说你的底线薪资是 23k，市场平均薪资是 25k，你的目标薪资是 27k，就直接说我的期望薪资是 29k。原因如下：

1️⃣ 我之前做了一些市场调查，还有我在这个岗位师兄师姐进行了解和反馈，这个薪资我觉得是一个市场的平均值；

3️⃣ 另外我手上也有其它公司的面试机会，但在此前面试中我也感受到贵公司的企业氛围/福利/文化是我比较喜欢的，所以在同等情况前提下我更愿意来贵公司；

4️⃣ 同时因为我从学校出来要考虑到租房、出行等费用，综合考虑下我觉得这个薪资是比较合理的。

5️⃣ 希望 HR 您能帮我争取一下！

具体谈薪时间（并非 HR 面，而是接收 offer 后（一段时间 / 立刻）到谈薪环节）

互联网企业大致在 10 月底 / 11 月初高峰统一谈薪，逼签三方
如果是体制内 / 国企，一般是直接面试完现场谈薪，而且这个薪资基本无法谈（argue）
...

8. 你有没有女/男朋友？家庭情况如何？

主要是确定你的稳定性，你到底会不会来，知道 HR 的目的后，你就可以根据自己的情况灵活作答。

9. 敬请期待

...

HR 面【反问环节】

该轮面试的重要性不用我多说了吧，求职者最关注的薪资待遇等关键信息都会在这轮中体现。

薪资待遇
- 工资及工资构成？
- 五险一金基数分别是多少？
- 年终奖情况与绩效评定？
- 年假？
- 食宿/房补餐补？
- 落户政策？
工作方面
- 工作时间？工作地点？通勤是否方便？办公环境如何？
- 加班 and 出差情况？
- 试用期多久？转正要求是什么？试用期工资/年终奖情况？
个人发展方面
- 培养机制？晋升渠道？涨薪途径？
- 往年公司营收如何？
- 岗位稳定性如何、是否会裁员？

🧑🏻‍💻 鉴于裁员是咱应届生都比较关注的一点，直接问会不会裁员可能得到一个模棱两可的答复，可以像这样问：

在网上看到一些关于贵司裁员的消息，请问这些消息是否属实？如果属实，方便告知一下是什么原因吗？毕竟我更希望和贵司成为长期的合作伙伴（这样 HR 就能感受到你的真诚，会给予更多对你有用的信息）

🧑🏻‍💻 另外，对于手头有多个 offer 的大佬，面的这家 HR 对你也很感兴趣的情况下，出于怕你是海投的考虑一般会问为什么没有选择之前的 offer？可以这么回答，得体又能给自己加分：

我觉得找工作是人生的一件大事，所以会深思熟虑，如果随便就签约一个不满足自己期望的公司导致后面又走违约流程，这样对公司对自己都是极其不负责任的。遇到合适的机会再签约，也是对招聘方的尊重。如果您觉得我满足您这边的招聘要求，麻烦您给我一些考虑的时间。

下列是所有反问合集，仅供参考。

待遇

如果有奖金计划的话，奖金如何分配？
如果有奖金计划的话，过去的几年里通常会发百分之多少的奖金？
有五险一金或者其他退休养老金等福利吗？
五险一金中，补充公积金一般交多少比例？我可以自己选择这一比例吗？
有什么医疗保险吗？如果有的话何时开始？
有额外商业保险吗？例如人寿保险和额外的养老/医疗保险？
商业保险可以给家人办理吗？成年人/未成年人？
更换工作地点，公司付费吗？
是否可以申请更换工作地点？
是否愿意协助海外应聘者申请工作签证？

休假

带薪休假时间有多久？
病假和事假是分开的还是一起算？
我可以提前使用假期时间吗？也就是说应休假期是负的？
假期的更新策略是什么样的？也就是说未休的假期能否滚入下一周期？
照顾小孩的政策如何？
无薪休假政策是什么样的？
学术性休假政策是怎么样的？
孕产假政策具体是怎样的？

福利

公司提供 Mac 开发吗？
使用自带电脑有补贴吗？
公积金多少比例缴纳？
公司是否有食堂，是否有餐饮福利补贴？
是否提供租房补贴？
是否提供话费补贴？
是否有交通补贴？

人才培养

升职加薪条件是否量化？
每年给团队安排多少费用用于学习培训？
每年组织多少次关于技术能力提升的讲座/论坛？

八股文 @ 智力题

Sat, 23 Aug 2025 00:00:00 GMT

其实互联网招聘中，有一类型考察是考察你的临场反应速度，比如脑筋急转弯这种智力题或者情景题，比如很知名的腾讯赛马问题。

1. 三人三鬼过桥

有三个人跟三个鬼要过河，河上没桥只有条小船，然后船一次只能渡一个人和一个鬼，或者两个鬼或者两个人，无论在哪边岸上，只有是人比鬼少的情况下（如两鬼一人，三鬼两人，三鬼一人）人会被鬼吃，然而船又一定需要人或鬼操作才能航行（要有人或鬼划船），问如何安全的把三人三鬼渡过河对岸?

参考回答

先两鬼过去。在一鬼回来。对面有一鬼。这边有三人两鬼。
再两鬼过去。在一鬼回来。对面有两鬼。这边有三人一鬼。
再两人过去。一人一鬼回来。对面一人一鬼。这边两人两鬼。
最后两人过去。一鬼回来。对面三人。这边三鬼。
剩下的就三个鬼二个过去一个回来在接另外个就OK了。

2. 赛马找最快的马匹（Tencent）

一般有这么几种问法：

25 匹马 5 条跑道找最快的 3 匹马，需要跑几次？参考回答：7 次
64 匹马 8 条跑道找最快的 4 匹马，需要跑几次？参考回答：11 次
25 匹马 5 条跑道找最快的 5 匹马，需要跑几次？参考回答：最少 8 次，最多 9 次

建议画图表来看，将问题简单化一点，将大问题化成小问题即可，同时 B 站有个讲解视频还不错。

Q1：25 匹马 5 条跑道找最快的 3 匹马，需要跑几次？

将 25 匹马分成 ABCDE 共 5 组，假设每组的排名就是 A1>A2>A3>A4>A5,用边相连，这里比赛 5 次

第 6 次，每组的第一名进行比赛，可以找出最快的马，这里假设 A1>B1>C1>D1>E1

D1，E1 肯定进不了前 3，直接排除掉

第 7 次，B1 C1 A2 B2 A3 比赛，可以找出第二，第三名

所以最少比赛需要 7 次

Q2：64 匹马 8 条跑道找最快的 4 匹马，需要跑几次？

第一步：全部马分为 8 组，每组 8 匹，每组各跑一次，然后淘汰掉每组的后四名，如下图（需要比赛 8 场）

第二步：取每组第一名进行一次比赛，然后淘汰最后四名所在组的所有马，如下图（需要比赛 1 场）

这个时候总冠军已经诞生，它就是 A1（它不需要比赛了）。

而其他可能跑得最快的三匹马只可能是下图中的黄域了（A2，A3，A4，B1，B2，B3，C1，C2，D1，共 9 匹马）

第三步：只要从上面的 9 匹马中找出跑得最快的三匹马就可以了，但是现在只要 8 个跑道，那就随机选出 8 匹马进行一次比赛吧（需要比赛一场）

第四步：上面比赛完，选出了前三名，但是 9 匹马中还有一匹马没跑呢，它可能是一个潜力股啊，那就和前三名比一比吧，这四匹马比一场，选出前三名。最后加上总冠军，跑得最快的四匹马诞生了！

最后，一共需要比赛的场次：8 + 1 + 1 + 1 = 11 场

Q3：25 匹马 5 条跑道找最快的 5 匹马，需要跑几次？

通过前 6 场决出第一名的方式不变，第 7 场才是关键，能否同时决出第 2、3 名次的马。

在上面的方法中，第 7 场比赛 [A2、B1、C1、D1、E1] 是为了决定第 2 名的马。但是在第 6 场比赛中我们已经得到 (B1>C1>D1>E1)，试问？有 B1 在的比赛，C1、D1、E1 还有可能争夺第 2 名吗？当然不可能，也就是说第 2 名只能在 A2、B1 中出现。实际上只需要 2 条跑道就可以决出第 2 名，剩下 C1、D1、E1 的 3 条跑道都只能用来凑热闹的吗？

能够优化的关键出来了，我们是否能够通过剩下的 3 个跑道来决出第 3 名呢？当然可以，我们来进一步分析第 3 名的情况？

如果 A2>B1 (即第 2 名为 A2)，那么根据第 6 场比赛中的 (B1>C1>D1>E1)。可以断定第 3 名只能在 A3 和 B1 中产生。
如果 B1>A2 (即第 2 名为 B1)，那么可以断定的第 3 名只能在 A2, B2, C1 中产生。

好了，结论也出来了，只要我们把 [A2、B1、A3、B2、C1] 作为第 7 场比赛的马，那么这场比赛的第 2，3 名一定是整个 25 匹马中的第 2，3 名。

我们在这里列举出第 7 场的 2，3 名次的所有可能情况：

① 第 2 名=A2，第 3 名=A3
② 第 2 名=A2，第 3 名=B1
③ 第 2 名=B1，第 3 名=A2
④ 第 2 名=B1，第 3 名=B2
⑤ 第 2 名=B1，第 3 名=C1

第 8 场比赛很复杂，我们要根据第 7 场的所有可能的比赛情况进行分析。

① 第 2 名=A2，第 3 名=A3。那么此种情况下第 4 名只能在 A4 和 B1 中产生。

如果第 4 名=A4，那么第 5 名只能在 A5、B1 中产生。
如果第 4 名=B1，那么第 5 名只能在 A4、B2、C1 中产生。
不管结果如何，此种情况下，第 4、5 名都可以在第 8 场比赛中决出。其中比赛马匹为 [A4、A5、B1、B2、C1]。

② 第 2 名=A2，第 3 名=B1。那么此种情况下第 4 名只能在 A3、B2、C1 中产生。

如果第 4 名=A3，那么第 5 名只能在 A4、B2、C1 中产生。
如果第 4 名=B2，那么第 5 名只能在 A3、B3、C1 中产生。
如果第 4 名=C1，那么第 5 名只能在 A3、B2、C2、D1 中产生。
那么，第 4、5 名需要在马匹 [A3、B2、B3、C1、A4、C2、D1] 七匹马中产生，则必须比赛两场才行，也就是到第 9 场角逐出全部的前 5 名。

③ 第 2 名=B1，第 3 名=A2。那么此种情况下第 4 名只能在 A3、B2、C1 中产生。

情况和 ② 一样，必须角逐第 9 场

④ 第 2 名=B1，第 3 名=B2。那么此种情况下第 4 名只能在 A2、B3、C1 中产生。

如果第 4 名=A2，那么第 5 名只能在 A3、B3、C1 中产生。
如果第 4 名=B3，那么第 5 名只能在 A2、B4、C1 中产生。
如果第 4 名=C1，那么第 5 名只能在 A2、B3、C2、D1 中产生。
那么，第 4、5 名需要在马匹 [A2、B3、B4、C1、A3、C2、D1] 七匹马中产生，则必须比赛两场才行，也就是到第 9 场角逐出全部的前 5 名。

⑤ 第 2 名=B1，第 3 名=C1。那么此种情况下第 4 名只能在 A2、B2、C2、D1 中产生。

如果第 4 名=A2，那么第 5 名只能在 A3、B2、C2、D1 中产生。
如果第 4 名=B2，那么第 5 名只能在 A2、B3、C2、D1 中产生。
如果第 4 名=C2，那么第 5 名只能在 A2、B2、C3、D1 中产生。
如果第 4 名=D1，那么第 5 名只能在 A2、B2、C2、D2、E2 中产生。
那么，第 4、5 名需要在马匹 [A2、B2、C2、D1、A3、B3、C3、D2、E1] 九匹马中产生，因此也必须比赛两场，也就是到第 9 长决出胜负。

总结：最好情况可以在第 8 场角逐出前 5 名，最差也可以在第 9 场搞定。

3. 给定随机函数，生成别的随机数（Tencent）

基本都是小生成大：

小生成大：给定生成 1 到 7 的随机数 Rand7()，如何得到生成 1 到 10 的随机数函数 Rand10()？
大生成小：给定生成 1 到 7 的随机数 Rand7()，如何得到生成 1 到 5 的随机数函数 Rand5()？

1️⃣ 如果是大生成小的就比较容易，比如 Rand7() 生成 Rand5()，直接取前 5 个值即可。

2️⃣ 如果是小生成大的，我们可以先构造一个大于 7 的随机数生成函数。记住以下式子： $$ RandNN=(RandN()-1)*N+RandN() $$ 以上式子是「等概率」生成 $1$ 到 $N^2$ 之间的随机数，等概率很重要。

式子以看作是在数轴上撒豆子：

$N$ 是跨度/步长，是 RandN() 生成的数的范围长度
RandN() - 1 的目的是生成 $0$ 到 $N-1$ 的数，是跳数
后面 + RandN() 的目的是填满中间的空隙

比如 Rand49 = (Rand7() - 1) * 7 + Rand7() 可以等概率生成 1～49 之间的随机数，然后大生成小的话只需要取 1～40 (4 * 10) 之间的数字。代码如下：

LeetCode 原题：470. 用 Rand7() 实现 Rand10()

// The rand7() API is already defined for you.
// int rand7();
// @return a random integer in the range 1 to 7

class Solution {
public:
    int rand10() {
        while (true) {
            int v = (rand7() - 1) * 7 + rand7(); // equal prob [1 ~ 49]
            if (v >= 1 && v <= 40)
                return v % 10 + 1;
        }
    }
};

4. 砝码称轻重，找出最轻的

其实这都是一类题，这里列举几个经典的：

Q1：有一个天平，九个砝码，其中一个砝码比另八个要轻一些，问至少要用天平称几次才能将轻的那个找出来？

A1：至少 2 次。第一次，一边 3 个，哪边轻就在哪边，一样重就是剩余的 3 个；第二次，一边 1 个，哪边轻就是哪个，一样重就是剩余的那个；至少称 2 次．

Q2：十组砝码每组十个，每个砝码都是 10g 重，但是现在其中有一组砝码每个都只有 9g 重，现有一个能显示克数的秤，最少称几次能找到轻的那组？

A2：至少 1 次。将砝码分组 1~10，第一组拿一个，第二组拿两个以此类推。。第十组拿十个放到秤上称出克数 x，则 y = 550 - x，第 y 组就是轻的那组。

5. 利用空瓶换饮料，最多喝几瓶

Q：1000 瓶饮料，3 个空瓶子能够换 1 瓶饮料，问最多能喝几瓶？

思路 1

拿走 3 瓶，换回 1 瓶，相当于减少 2 瓶。

但是最后剩下 4 瓶的时候例外，这时只能换 1 瓶！

所以我们计算 1000 减 2 能减多少次，直到剩下 4（1000-4=996，996/2=498），所以 1000 减 2 能减 498 次直到剩下 4 瓶，最后剩下的 4 瓶还可以换一瓶。

所以总共是 1000+498+1=1499 瓶。

思路 2 —— 动态规划

3 个瓶子时将发生一次交换，因此前 3 个视为特殊情况
之后每增加 2 个瓶子又可以再换 1 瓶
即 dp[i] = dp[i - 2] + 2 + 1：增加 2 瓶饮料可以再换 1 瓶饮料

int dp(int n) {
    vector<int> f(n + 1);
    f[0] = 0;
    f[1] = 1;
    f[2] = 2;
    for(int i = 3; i <= n; i++) {
        f[i] = f[i - 2] + 2 + 1;
    }
    return f[n];
}

6. 毒药毒白鼠，找出哪个瓶子中是毒药

有 1000 个一模一样的瓶子，其中有 999 瓶是普通的水，有 1 瓶是毒药。任何喝下毒药的生命都会在一星期之后死亡。现在你只有 10 只小白鼠和 1 个星期的时间，如何检验出哪个瓶子有毒药？

参考答案

涉及位运算思想，首先一共有 1000 瓶，2 的 10 次方是 1024，刚好大于 1000，也就是说，1000 瓶药品可以使用 10 位二进制数就可以表示。从第一个开始：

第 1 瓶： 00 0000 0001
第 2 瓶： 00 0000 0010
第 3 瓶： 00 0000 0011
…
第 999 瓶： 11 1111 0010
第 1000 瓶： 11 1111 0011

需要十只老鼠，如果按顺序编号，ABCDEFGHIJ 分别代表从低位到高位每一个位。每只老鼠对应一个二进制位，如果该位上的数字为 1，则给老鼠喝瓶里的药。

观察，若死亡的老鼠编号为：ACFGJ，一共死去五只老鼠，则对应的编号为 10 0110 0101，则有毒的药品为该编号的药品，转为十进制数为：613 号。

类似问题还有：8 瓶酒一瓶有毒，用小老鼠测试。每次测试结果 8 小时后才会得出，而你只有 8 个小时的时间。最少需要（）老鼠测试？ A、2 B、3 C、4 D、6

答案：$8 = 2^3$，所以选 B

7. 利用烧绳子计算时间

现有若干不均匀的绳子，烧完这根绳子需要一个小时，问如何准确计时 15 分钟，30 分钟，45 分钟，75 分钟 ...

15 分钟：对折之后两头烧（如果不能对折，那就参考 45 分钟的解法）

30 分钟：两头烧

45 分钟：准备两根绳子，一根两头烧，一根一头烧，同时进行，两头烧完过了 30 分钟，立即将另一根的另一头点燃，等烧完又过了 15 分钟，加起来 45 分钟

75 分钟：30 + 45

...

8. 在 24 小时内时针、分针、秒针可以重合几次

⚠️ 前提是模拟最真实的时钟走法（2 次），而非只会停留在整数（22 次）

❌ 错误答案：24 小时中时针走 2 圈，而分针走 24 圈，时针和分针重合 24-2=22 次，而只要时针和分针重合，秒针一定有机会重合，所以总共重合 22 次。

✅ 正确答案：在 24 小时内（不包含 24 点），也就只有两次重合，分别为 0 点和 12 点。

时针和分针重合的时候，秒针根本就不在重合的地方，而是在其他地方，以下是数学推导：

9. 100 个囚犯猜帽子颜色

一百个囚犯站成一纵列，每人头上随机带上黑色或白色的帽子，每个人都不知道自己帽子的颜色，但是能看见自己前面所有人帽子的颜色．然后从最后一个囚犯开始，每人只能用同一种声调和音量说一个字："黑"或"白"，如果说中了自己帽子的颜色，就存活，说错了就拉出去斩了，说的参考回答所有囚犯都能听见。是否说对，其他囚犯不知道。在这之前，所有囚犯可以聚在一起商量策略，问如果囚犯都足够聪明而且反应足够快，100 个人最大存活人数是多少？

如果增加限制条件，每个囚犯只能看见前面一个人帽子颜色：那么方法 (3) 就失效了，只能用方法 (2)，即存活 50 人。

(1) 所有人凭运气乱猜 [50]

最坏情况下所有人都猜错，平均有 50 人猜对。

(2) 一半人凭运气 [75]

很显然，坐在最后面的囚犯是不可能保证自己猜对的，他猜黑猜白都只有一半的几率猜对，似乎没什么区别；但囚犯可以事先约定好一种暗号，即最后一个囚犯猜黑表示什么意思，猜白表示什么意思。比如，最后一个囚犯可以猜测和他前面的囚犯的帽子一样的颜色，这就相当于用他的猜测告诉了他前面那个囚犯该猜什么，于是坐倒数第二的囚犯可以保证被释放；此时，坐在倒数第三个位置上的囚犯面对与刚才坐最后的囚犯相同的处境，他同样可以用他的猜测提示出他前面那个人的帽子颜色。

相当于 50 人（偶数索引位置）给前一个报点，保证活 50 个（奇数索引位置），这样可以保证至少 50 个人猜对，平均情况则有 75 个人猜对。但这不是最佳的策略。

(3) 最佳策略 [99]

最佳策略可以保证，除了坐在最后面的囚犯以外，其余 99 个囚犯都能猜对。

最后的囚犯他完全可以透露出与全局相关的一些信息，因此以后所有的人都可以用这条信息：

比如，他可以数一数他前面 99 个人一共有多少顶白帽子，并约定他猜“黑”表示他前面共有偶数顶白帽，他猜“白”表示他前面共有奇数顶白帽。
坐倒数第二的那个人也数一数他前面 98 个人的白帽子个数：如果他数出来的个数与先前透露出的个数一奇一偶，则他自己肯定戴的是白帽子；如果他数出来的和先前透露的结果奇偶性相同，则他自己戴的肯定是黑帽子。
这样，坐倒数第二的保证可以猜对了。那接下来咋办呢？不要忘了，其他囚犯能听到刚才那人猜的是什么，并且知道他的猜测保证是对的。这相当于每个人：
- 不仅能看到坐他前面的所有人的帽子颜色
- 还知道他背后那些人的帽子颜色
- 结合最初的那个奇偶性信息
接下来的每一个人都可以猜出自己脑袋上的帽子颜色。这样下去，至少 99 个囚犯可以保证被释放。这种策略显然是最佳的，不可能再有什么策略能保证所有人都被释放，因为至少坐最后的那个人不可能保证自己猜对。

总结：等价于最后一个囚犯报全局信息，往前每一个囚犯根据全局信息、自己数得到的信息、背后那些囚犯的信息，这三条信息可以保证自己一定猜对。

10. 小猴子搬香蕉

一个小猴子边上有 100 根香蕉，它要走过 50 米才能到家，每次它最多搬 50 根香蕉，多了就被压死了，它每走 1 米就要吃掉一根，请问它最多能把多少根香蕉搬到家里？

提示：他可以把香蕉放下往返的走，但是必须保证它每走一米都能有香蕉吃。也可以走到 n 米时，放下一些香蕉，拿着 n 根香蕉走回去重新搬 50 根。

参考回答：这种试题通常有一个迷惑点，让人看不懂题目的意图。此题迷惑点在于

走一米吃一根香蕉，一共走 50 米，那不是把 50 根香蕉吃完了吗？
如果要回去搬另外 50 根香蕉，则往回走的时候也要吃香蕉，这样每走一米需要吃掉三根香蕉，走 50 米岂不是需要 150 根香蕉？

其实不然，本题关键点在于：猴子搬箱子的过程其实分为两个阶段：

第一阶段：来回搬，当香蕉数目大于 50 根时，猴子每搬一米需要吃掉三根香蕉。
第二阶段：香蕉数 ≤ 50，直接搬回去。每走一米吃掉 1 根。

我们分析第一阶段：假如把 100 根香蕉分为两箱。一箱 50 根。

第一步，把 A 箱搬一米，吃一根。
第二步，往回走一米，吃一根。
第三步，把 B 箱搬一米，吃一根。

这样，把所有香蕉搬走一米需要吃掉三根香蕉。

这样走到第几米的时候，香蕉数刚好小于 50 呢？

$100-(n*3) < 50\ &&\ 100-((n-1)*3)>50$，n 取整数只能是 17。

走到 16 米的时候，吃掉 48 根香蕉，剩 52 根香蕉。

16 这步很有意思，它可以直接搬 50 往前走：50 - (50 -16) = 16 根

也可以再来回搬一次（即 17 这种），结果都是一样的。

到 17 米的时候，猴子还有 49 根香蕉。这时猴子就轻松啦，直接背着 49 根走就行，把剩下的 50 - 17 = 33 米走完，还剩 49 - 33 = 16 根香蕉。

11. 高楼扔鸡蛋（经典）

有 2 个鸡蛋，从 100 层楼上往下扔，以此来测试鸡蛋的硬度。比如鸡蛋在第 9 层没有摔碎，在第 10 层摔碎了，那么鸡蛋不会摔碎的临界点就是 9 层。

问：如何用最少的尝试次数，测试出鸡蛋不会摔碎的临界点？

首先要说明的是这道题你要是一上来就说出正确参考回答，那说明你的智商不是超过 160 就是你做过这题。

所以建议你循序渐进的回答，一上来就说最优解可能结果不会让面试官满意。

(1) 暴力法

按楼层顺序逐层扔，但是在最坏情况下，这个方法需要扔 100 次。

(2) 二分法

类似于二分查找的方法，这个方法在最坏情况下，需要尝试 50 次。

(3) 均匀法

如何让第一枚鸡蛋和第二枚鸡蛋的尝试次数尽可能均衡呢？

只需对 100 做一个平方根运算，$\sqrt{100}=10$。

因此，尝试每 10 层扔一次：

第一次从第 10 层扔
第二次从第 20 层扔
...
第九次从第 90 层扔
第十次从第 100 层扔

这样最好的情况是第 10 层碎掉，尝试次数为 1 + 9 = 10 次；

最坏的情况是在第 100 层碎掉，尝试次数为 10 + 9 = 19 次。

优化点

可以从 15 层开始扔，接下来是 25、35、...、95，这样最坏情况是在第 95 层碎掉，尝试次数为 9 + 9 = 18 次。

(4) 最优解法

我们需要一种策略，使得无论临界楼层在哪，最坏情况下的尝试次数都相同。这意味着我们需要平衡每次扔鸡蛋后可能的后续尝试次数。

最优解法是反向思考的经典：如果最优解法在最坏情况下需要扔 X 次，那第一次在第几层扔最好呢？

参考回答是：从 X 层扔。

反向证明：

假设最优的尝试次数的 x 次，为什么第一次扔就要选择第 x 层呢？

假设第一次扔在第 x+1 层：如果第一个鸡蛋碎了，那么第二个鸡蛋只能从第 1 层开始一层一层扔，一直扔到第 x 层。这样一来，我们总共尝试了 x+1 次，和假设尝试 x 次相悖。由此可见，第一次扔的楼层必须小于 x+1 层。

假设第一次扔在第 x-1 层：如果第一个鸡蛋碎了，那么第二个鸡蛋只能从第 1 层开始一层一层扔，一直扔到第 x-2 层。这样一来，我们总共尝试了 x-2+1 = x-1 次，虽然没有超出假设次数，但似乎有些过于保守。

假设第一次扔在第 x 层：如果第一个鸡蛋碎了，那么第二个鸡蛋只能从第 1 层开始一层一层扔，一直扔到第 x-1 层。这样一来，我们总共尝试了 x-1+1 = x 次，刚刚好没有超出假设次数。

因此，要想尽量楼层跨度大一些，又要保证不超过假设的尝试次数 x，那么第一次扔鸡蛋的最优选择就是第 x 层。

如何求 x ？

设最优策略下，第一次在第 x 层扔鸡蛋：

如果碎了，用第二个鸡蛋从第 1 层到第 x-1 层逐层测试，最多需要 x 次（第一次 + (x-1)次）。
如果没碎，下一步从第 x + (x-1)层扔（因为已经用了一次尝试，所以下一步减少一层来保持次数平衡）。
- 如果这次碎了，用第二个鸡蛋从第 x+1 层到第 x + (x-1) - 1 层逐层测试，最多需要 2 + (x-2) = x 次。
- 如果没碎，下一步从第 x + (x-1) + (x-2)层扔，依此类推。

这样，我们需要找到一个 x，使得 $x + (x-1) + (x-2) + ... + 1 ≥ 100$。即，$x(x + 1)/2 ≥ 100$。

解这个不等式：$x² + x - 200 ≥ 0$

使用求根公式：$x = \frac{-1 ± \sqrt{1 + 800}}{2} = \frac{-1 ± \sqrt{801}}{2} ≈ \frac{-1 ± 28.3}{2}$

正根约为 13.65，所以 x 至少为 $14$。

因此，最优解在最坏情况的尝试次数是 14 次，第一次扔鸡蛋的楼层也是 14 层。

最后，让我们把第一个鸡蛋没碎的情况下，所尝试的楼层数完整列举出来：14，27， 39， 50， 60， 69， 77， 84， 90， 95， 99， 100。

12. N 只蚂蚁走树枝，问总距离或者总时间

问题：放 N 只蚂蚁在一条长度为 M 树枝上，蚂蚁与蚂蚁之间碰到就各自往反方向走，问所有蚂蚁离开树枝的总时间是多少？

这个问题看起来复杂，但有一个非常巧妙的等价转换 —— 蚂蚁相遇掉头的等效性：

当两只蚂蚁相遇并掉头时，可以认为它们互相穿过而不改变方向。
这是因为：
- 从蚂蚁个体的角度看，掉头后继续走的方向和直接穿过是一样的。
- 从整体角度看，蚂蚁的位置和离开树枝的时间不会改变。
所以可以忽略碰到往反方向走这个条件。

所以答案就很简单了，就是离开树枝时间最长的那只蚂蚁所需的时间： $$ T=max(max(x_i),max(M-x_i)) $$

13. N 个强盗分配 M 个金币，求方案使得自己分配最多

海盗分金博弈 🏴‍☠️

5 个海盗抢到了 100 枚金币，每一颗都一样的大小和价值。他们决定这么分：

抽签决定自己的号码（1，2，3，4，5）
首先，由 1 号提出分配方案，然后大家 5 人进行表决，当半数以上的人同意时（不包括半数，这是重点），按照他的提案进行分配，否则将被扔入大海喂鲨鱼。
如果 1 号死后，再由 2 号提出分配方案，然后大家 4 人进行表决，当且仅当半超过半数的人同意时，按照他的提案进行分配，否则将被扔入大海喂鲨鱼。
依次类推......

假设每一位海盗都足够聪明，并且利益至上，能多分一枚金币绝不少分，那么 1 号海盗该怎么分金币才能使自己分到最多的金币呢？

思路

从后向前推，如果 1 至 3 号强盗都喂了鲨鱼，只剩 4 号和 5 号的话，5 号一定投反对票让 4 号喂鲨鱼，以独吞全部金币。所以，4 号惟有支持 3 号才能保命。

3 号知道这一点，就会提出“100，0，0”的分配方案，对 4 号、5 号一毛不拔而将全部金币归为已有，因为他知道 4 号一无所获但还是会投赞成票，再加上自己一票，他的方案即可通过。

不过，2 号推知 3 号的方案，就会提出“98，0，1，1”的方案，即放弃 3 号，而给予 4 号和 5 号各一枚金币。由于该方案对于 4 号和 5 号来说比在 3 号分配时更为有利，他们将支持他而不希望他出局而由 3 号来分配。这样，2 号将拿走 98 枚金币。

同样，2 号的方案也会被 1 号所洞悉，1 号并将提出（97，0，1，2，0）或（97，0，1，0，2）的方案，即放弃 2 号，而给 3 号一枚金币，同时给 4 号（或 5 号）2 枚金币。由于 1 号的这一方案对于 3 号和 4 号（或 5 号）来说，相比 2 号分配时更优，他们将投 1 号的赞成票，再加上 1 号自己的票，1 号的方案可获通过，97 枚金币可轻松落入囊中。这无疑是 1 号能够获取最大收益的方案了！

✅ 参考回答是：1 号强盗分给 3 号 1 枚金币，分给 4 号或 5 号强盗 2 枚，自己独得 97 枚。分配方案可写成（97，0，1，2，0）或（97，0，1，0，2）。

此题还有变种：就是只需要一半人同意即可，不需要一半人以上同意方案就可以通过，在其他条件不变的情况下，1 号该怎么分配才能获得最多的金币？

参考回答：类似的推理过程

4 号：4 号提出的方案的时候肯定是最终方案，因为不管 5 号同意不同意都能通过，所以 4 号 5 号不必担心自己被投入大海。那此时 5 号获得的金币为 0，4 号获得的金币为 100。

5 号：因为 4 号提方案的时候，自己获取的金币为 0 。所以只要 4 号之前的人分配给自己的金币大于 0 就同意该方案。

4 号：如果 3 号提的方案一定能获得通过（原因：3 号给 5 号的金币大于 0， 5 号就同意因此就能通过），那自己获得的金币就为 0，所以只要 2 号让自己获得的金币大于 0 就会同意。

3 号：因为到了自己提方案的时候可以给 5 号一金币，自己的方案就能通过，但考虑到 2 号提方案的时候给 4 号一个金币，2 号的方案就会通过，那自己获得的金币就为 0。所以只要 1 号让自己获得的金币大于 0 就会同意。

2 号：因为到了自己提方案的时候只要给 4 号一金币，就能获得通过，根本就不用顾及 3 号 5 号同意不同意，所以不管 1 号怎么提都不会同意。

1 号：2 号肯定不会同意。但只要给 3 号一块金币，5 号一块金币（因为 5 号如果不同意，那么 4 号分配的时候，他什么都拿不到）就能获得通过。

所以参考回答是 98，0，1，0，1。

类似的问题也可用类似的推理即可。

14. 火枪手决斗，谁活下来等概率大

彼此痛恨的甲、乙、丙三个枪手准备决斗。

甲枪法最好，十发八中；
乙枪法次之，十发六中；
丙枪法最差，十发四中。

如果三人同时开枪，并且每人每轮只发一枪；那么枪战后，谁活下来的机会大一些？

一般人认为甲的枪法好，活下来的可能性大一些。但合乎推理的结论是，枪法最糟糕的丙活下来的几率最大。那么我们先来分析一下各个枪手的策略。

如同田忌赛马一般，枪手甲一定要对枪手乙先。因为乙对甲的威胁要比丙对甲的威胁更大，甲应该首先干掉乙，这是甲的最佳策略。同样的道理，枪手乙的最佳策略是第一枪瞄准甲。乙一旦将甲干掉，乙和丙进行对决，乙胜算的概率自然大很多。枪手丙的最佳策略也是先对甲。乙的枪法毕竟比甲差一些，丙先把甲干掉再与乙进行对决，丙的存活概率还是要高一些。
我们根据分析来计算一下三个枪手在上述情况下的存活几率：
- 第一轮：甲射乙，乙射甲，丙射甲。
  - 甲的活率为24%（40% X 60%）
  - 乙的活率为20%（100% - 80%)
  - 丙的活率为100%（无人射丙）
- 由于丙 100％存活率，因此根据上轮甲乙存活的情况来计算三人第二轮的存活几率：
  - 情况 1：甲活乙死（24% X 80% = 19.2%）
    - 甲射丙，丙射甲：甲的活率为 60%，丙的活率为 20%
  - 情况 2：乙活甲死（20% X 76% = 15.2%）
    - 乙射丙，丙射乙：乙的活率为 60%，丙的活率为 40%
  - 情况 3：甲乙同活（24% X 20% = 4.8%）
    - 重复第一轮
  - 情况 4：甲乙同死（76% X 80% = 60.8%）
    - 枪战结束

据此来计算三人活率：

甲的活率为 (19.2% X 60%) + (4.8% X 24%) = 12.672%
乙的活率为 (15.2% X 60%) + (4.8% X 20%) = 10.08%
丙的活率为 (19.2% X 20%) + (15.2% X 40%) + (4.8% X 100%) + (60.8% X 100%) = 75.52%

通过对两轮枪战的详细概率计算，我们发现枪法最差的丙存活的几率最大，枪法较好的甲和乙的存活几率却远低于丙的存活几率。

15. 先手必胜问题

100 本书，每次能够拿 1～5 本，怎么拿能保证最后一次是你拿？

寻找每个回合固定的拿取模式，最后一次是我拿，那么上个回合最少剩下 $6(5_{max} + 1_{min})$ 本。那么只要保持每个回合结束后都剩下 6 的倍数，并且在这个回合中我拿的和对方拿的加起来为 6（这样这个回合结束后剩下的还是 6 的倍数），就必胜。

关键是第一次我必须先手拿（100 % 6 = 4）本（这不算在第一回合里面），剩下 96 本对方先手，只需我每次都维持当前回合共取 6 本即可，经过 16 回合即可获胜。

16. 掰巧克力问题或者参加辩论赛

掰巧克力问题

Q：我们有一块由 N×M 个小方块组成的巧克力。每次操作，可以选择一块当前的巧克力，然后沿着一行或一列将其掰开（即水平或垂直切割）。最少需要多少次操作，才能将所有巧克力掰成 1×1 的小块？

A：模拟题，即 $N - 1 + N * (M - 1) = (M*N - 1) 次$

辩论赛问题

Q：1000 个人参加辩论赛，1V1，输了就退出，需要安排多少场比赛？

A：999 场。

每场比赛有 2 人对决，1 人胜出，1 人被淘汰。因此，每场比赛都会淘汰 1 人。
最终要淘汰 999 人。因此，需要 999 场比赛，因为每场比赛淘汰 1 人。

八股文 @ 面试手撕

Sat, 23 Aug 2025 00:00:00 GMT

415. 大数相加

腾讯 WXG 一面

✅ LeetCode: 415. 字符串相加

给定两个字符串形式的非负整数 num1 和 num2 ，计算它们的和并同样以字符串形式返回。

你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。

示例 1：

输入：num1 = "11", num2 = "123"
输出："134"

示例 2：

输入：num1 = "456", num2 = "77"
输出："533"

1️⃣ 解法一：对位数较短的数字进行了补零操作（预处理）：self-AC

class Solution {
public:
    string addStrings(string num1, string num2) {
        int m = num1.length(), n = num2.length();
        int len = abs(m - n);
        string zero(len, '0');
        if (m < n)
            num1 = zero + num1;
        else if (m > n)
            num2 = zero + num2;
        int mx = max(m, n);
        int remain = 0;
        string ans;
        // cout << num1 << ", " << num2 << endl;
        for (int i = mx - 1; i >= 0 || remain; i--) {
            if (i < 0 && remain) {
                ans.push_back('1');
                break;
            }
            char ch = num1[i] + (num2[i] - '0') + remain;
            if (ch > '9') {
                ch = ch - 10;
                remain = 1;
            } else {
                remain = 0;
            }
            ans.push_back(ch);
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

2️⃣ 解法二：去除预处理的过程，直接模拟

class Solution {
public:
    string addStrings(string num1, string num2) {
        int i = num1.length() - 1, j = num2.length() - 1, add = 0;
        string ans = "";
        while (i >= 0 || j >= 0 || add) {
            int x = i >= 0 ? num1[i] - '0' : 0;
            int y = j >= 0 ? num2[j] - '0' : 0;
            int result = x + y + add;
            ans.push_back('0' + result % 10);
            add = result / 10;
            i--;
            j--;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

43. 大数相乘

小鹏汽车智驾一面

✅ LeetCode: 43. 字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

**注意：**不能使用任何内置的 BigInteger 库或直接将输入转换为整数。

示例 1:

输入: num1 = "2", num2 = "3"
输出: "6"

示例 2:

输入: num1 = "123", num2 = "456"
输出: "56088"

1️⃣ 解法一思路（竖式相加）：建立在「大数相加」的基础上，因为多个数之间需要累加（这段代码自己 AC 的，容易理解）

class Solution {
public:
    // 大数相加
    string addStrings(string num1, string num2) {
        int i = num1.length() - 1, j = num2.length() - 1, add = 0;
        string ans = "";
        while (i >= 0 || j >= 0 || add) {
            int x = i >= 0 ? num1[i] - '0' : 0;
            int y = j >= 0 ? num2[j] - '0' : 0;
            int result = x + y + add;
            add = result / 10;
            ans.push_back('0' + result % 10);
            i--;
            j--;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }

    // 大数相乘
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0")
            return "0";
        int multiply = 0;
        int m = num1.length(), n = num2.length();
        string ans = "0";
        for (int i = m - 1; i >= 0; i--) {
            int x = num1[i] - '0';
            string num;
            int add = 0;
            for (int j = n - 1; j >= 0 || add; j--) {
                if (x == 0) {
                    num = "0";
                    break;
                }
                if (j < 0) {
                    num.push_back('0' + add);
                    break;
                }
                int y = num2[j] - '0';
                int result = x * y + add;
                add = result / 10;
                num.push_back('0' + result % 10);
            }
            reverse(num.begin(), num.end());
            if (num != "0")
                ans = addStrings(ans, num + string(multiply, '0'));
            multiply++;
        }
        return ans;
    }
};

2️⃣ 解法二：直接做乘法，长度分别为 m 和 n 的数字相乘，值长度不超过 m + n，vector<int> ansArr(m + n)

/**	 	E x a m p l e
 *
 *               9   9   9
 *         ×     6   7   8
 *  ----------------------
 *              72  72  72
 *          63  63  63
 *      54  54  54
 *  ----------------------
 *      54 117 189 135  72
 *  ----------------------
 *      54 117 189 142   2
 *  -----------------------
 *      54 117 203   2   2
 *  -----------------------
 *      54 137   3   2   2
 *  -----------------------
 *      67   7   3   2   2
 *  -----------------------
 *   6   7   7   3   2   2
 */
class Solution {
public:
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0") {
            return "0";
        }
        int m = num1.length(), n = num2.length();
        vector<int> ansArr(m + n);
        for (int i = m - 1; i >= 0; i--) {
            int x = num1[i] - '0';
            for (int j = n - 1; j >= 0; j--) {
                int y = num2[j] - '0';
                ansArr[i + j + 1] += x * y;
            }
        }
        for (int i = m + n - 1; i > 0; i--) {
            ansArr[i - 1] += ansArr[i] / 10;
            ansArr[i] %= 10;
        }
        int idx = ansArr[0] == 0 ? 1 : 0;
        string ans;
        while (idx < m + n) {
            ans.push_back('0' + ansArr[idx]);
            idx++;
        }
        return ans;
    }
};

239. 滑动窗口最大值

腾讯 WXG 一面

✅ LeetCode: 239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

1️⃣ 优先队列 priority_queue（记录最大值） + 哈希表（记录删除元素）：self-AC

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<int, vector<int>, less<int>> pq;
        int n = nums.size();
        unordered_map<int, int> cnt;
        for (int i = 0; i < k; i++)
            pq.push(nums[i]);
        vector<int> ans{pq.top()};
        for (int i = k; i < n; i++) {
            cnt[nums[i - k]]++;
            pq.push(nums[i]);
            while (pq.size() > k && cnt[pq.top()] > 0) {
                cnt[pq.top()]--;
                pq.pop();
            }
            ans.push_back(pq.top());
        }
        return ans;
    }
};

2️⃣ 优先队列 priority_queue<pair<int, int>>，通过记录索引值判断 pq.top() 元素是否在定长窗口内

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<pair<int, int>> pq;
        for (int i = 0; i < k; i++) {
            pq.emplace(nums[i], i);
        }
        vector<int> ans{pq.top().first};
        for (int i = k; i < nums.size(); i++) {
            pq.emplace(nums[i], i);
            while (pq.top().second < i - k + 1) {
                pq.pop();
            }
            ans.push_back(pq.top().first);
        }
        return ans;
    }
};

206. 反转链表

腾讯 WXG 一面

✅ LeetCode: 206. 反转链表

相关例题 —— 92. 反转链表 II：反转部分区间，找到区间 leftNode 与 rightNode，以及 leftNode 左节点 pre 与 rightNode 右节点 nxt，独立区间（断开连接）后反转再接回。

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

1️⃣ 解法一：递归

// 手写链表（LeetCode 已经定义，题目若需要则自己定义）
struct ListNode {
    int val;
    ListNode* next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode* next) : val(x), next(next) {};
};

class Solution {
public:
    // 递归
    ListNode* reverseList(ListNode* head) {
        if (!head || !head->next) {
            return head;
        }
        ListNode* new_head = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return new_head;
    }
};

2️⃣ 解法二：三指针迭代（pre = nullptr, cur = head, nxt = cur->next）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
};

146. LRU 缓存

腾讯 WXG 一面｜腾讯 CSIG 一面｜腾讯 PCG 一面

据说是所有面试中出现概率的 No.1

✅ LeetCode: 146. LRU 缓存、面试题 16.25. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存约束的数据结构。

实现 LRUCache 类：

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该逐出最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

LRUCache：循环双向链表 + 哈希表

循环：方便获取末尾节点进行 LRU 逐出/删除
双向链表
哈希表：快速找到 key 对应的节点

// LRUCache = 循环双向链表 + 哈希表
class Node {
public:
    int key;
    int value;
    Node* prev;
    Node* next;
    Node(int k = 0, int v = 0) : key(k), value(v) {}
};

class LRUCache {
private:
    int capacity;
    Node* dummy;
    unordered_map<int, Node*> key_to_node;

    // 删除一个节点
    void remove(Node* x) {
        x->prev->next = x->next;
        x->next->prev = x->prev;
    }

    // 在链表头添加一个节点
    void push_front(Node* x) {
        x->prev = dummy;
        x->next = dummy->next;
        x->prev->next = x;
        x->next->prev = x;
    }

    // 获取 key 对应的节点, 同时把该节点移到链表头部
    Node* get_node(int key) {
        auto it = key_to_node.find(key);
        if (it == key_to_node.end()) {
            return nullptr;
        }
        Node* node = it->second;
        remove(node);
        push_front(node);
        return node;
    }

public:
    LRUCache(int capacity) : capacity(capacity), dummy(new Node()) {
        // 循环双向链表: 方便取末尾值进行删除
        dummy->prev = dummy;
        dummy->next = dummy;
    }

    int get(int key) {
        Node* node = get_node(key);
        return node ? node->value : -1;
    }

    void put(int key, int value) {
        Node* node = get_node(key);
        if (node) {
            node->value = value;
            return;
        }
        node = new Node(key, value);
        key_to_node[key] = node;
        push_front(node);
        if (key_to_node.size() > capacity) {
            Node* back_node = dummy->prev;
            key_to_node.erase(back_node->key);
            remove(back_node);
            delete back_node;
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

460. LFU 缓存

华为机考

✅ LeetCode: 460. LFU 缓存

相关例题：146. LRU 缓存

请你为最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
int get(int key) - 如果键 key 存在于缓存中，则获取键的值，否则返回 -1 。
void put(int key, int value) - 如果键 key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最久未使用 的键。

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入：
["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
输出：
[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释：
// cnt(x) = 键 x 的使用计数
// cache=[] 将显示最后一次使用的顺序（最左边的元素是最近的）
LFUCache lfu = new LFUCache(2);
lfu.put(1, 1);   // cache=[1,_], cnt(1)=1
lfu.put(2, 2);   // cache=[2,1], cnt(2)=1, cnt(1)=1
lfu.get(1);      // 返回 1
                 // cache=[1,2], cnt(2)=1, cnt(1)=2
lfu.put(3, 3);   // 去除键 2 ，因为 cnt(2)=1 ，使用计数最小
                 // cache=[3,1], cnt(3)=1, cnt(1)=2
lfu.get(2);      // 返回 -1（未找到）
lfu.get(3);      // 返回 3
                 // cache=[3,1], cnt(3)=2, cnt(1)=2
lfu.put(4, 4);   // 去除键 1 ，1 和 3 的 cnt 相同，但 1 最久未使用
                 // cache=[4,3], cnt(4)=1, cnt(3)=2
lfu.get(1);      // 返回 -1（未找到）
lfu.get(3);      // 返回 3
                 // cache=[3,4], cnt(4)=1, cnt(3)=3
lfu.get(4);      // 返回 4
                 // cache=[3,4], cnt(4)=2, cnt(3)=3

LFU 缓存 = 循环双向链表 + key_to_node 哈希表 + freq_to_dummy 哈希表

class Node {
public:
    int key;
    int value;
    int freq = 1; // default
    Node* prev;
    Node* next;

    Node(int k = 0, int v = 0) : key(k), value(v) {}
};

class LFUCache {
private:
    int min_freq;
    int capacity;
    unordered_map<int, Node*> key_to_node;
    unordered_map<int, Node*> freq_to_dummy; // 每个 freq 代表一个链表的头节点

    // 创新一个新的双向链表
    Node* new_list() {
        Node* dummy = new Node(); // 哨兵节点
        dummy->prev = dummy;
        dummy->next = dummy;
        return dummy;
    }

    void remove(Node* node) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

    void push_front(int freq, Node* node) {
        auto it = freq_to_dummy.find(freq);
        if (it == freq_to_dummy.end()) {
            // pair<iterator, bool> emplace()
            it = freq_to_dummy.emplace(freq, new_list()).first;
        }
        Node* dummy = it->second;
        node->prev = dummy;
        node->next = dummy->next;
        node->prev->next = node;
        node->next->prev = node;
    }

    Node* get_node(int key) {
        auto it = key_to_node.find(key);
        if (it == key_to_node.end()) {
            return nullptr;
        }
        Node* node = it->second;
        remove(node);
        Node* dummy = freq_to_dummy[node->freq];
        if (dummy->prev == dummy) { // 如果该 freq 对应的链表移除 node 后为空时
            freq_to_dummy.erase(node->freq);
            delete dummy;
            if (min_freq == node->freq) { // node->freq 为最小记数
                min_freq++;
            }
        }
        push_front(++node->freq, node);
        return node;
    }

public:
    LFUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        Node* node = get_node(key);
        return node ? node->value : -1;
    }

    void put(int key, int value) {
        Node* node = get_node(key);
        if (node) {
            node->value = value;
            return;
        }
        if (key_to_node.size() == capacity) {
            Node* dummy = freq_to_dummy[min_freq];
            Node* last_node = dummy->prev;
            key_to_node.erase(last_node->key);
            remove(last_node);
            delete last_node;
            if (dummy->prev == dummy) {
                freq_to_dummy.erase(min_freq);
                delete dummy;
            }
        }
        node = new Node(key, value);
        key_to_node[key] = node;
        push_front(1, node);
        min_freq = 1;
    }
};

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache* obj = new LFUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

560. 和为 k 的子数组

Momenta 一面

✅ LeetCode: 560. 和为 K 的子数组

给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。

子数组是数组中元素的连续非空序列。

示例 1：

输入：nums = [1,1,1], k = 2
输出：2

示例 2：

输入：nums = [1,2,3], k = 3
输出：2

1️⃣ 前缀和 + 哈希表

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> preSum(n + 1);
        for(int i = 1; i <= n; i++)
            preSum[i] = nums[i - 1] + preSum[i - 1];
        int ans = 0;
        unordered_map<int, int> cnt;
        for(int num : preSum) {
            ans += cnt.contains(num - k) ? cnt[num - k] : 0;
            cnt[num]++;
        }
        return ans;
    }
};

93. 复原 IP 地址

腾讯 PCG 一面

✅ LeetCode: 93. 复原 IP 地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你不能重新排序或删除 s 中的任何数字。你可以按任何顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

1️⃣ 解法一：四层循环迭代，简单易懂暴力

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        int n = s.length();
        vector<string> ans;
        for (int a = 1; a <= 3; a++) {
            for (int b = 1; b <= 3; b++) {
                for (int c = 1; c <= 3; c++) {
                    for (int d = 1; d <= 3; d++) {
                        if (a + b + c + d == n) {
                            int numA = stoi(s.substr(0, a));
                            int numB = stoi(s.substr(a, b));
                            int numC = stoi(s.substr(a + b, c));
                            int numD = stoi(s.substr(a + b + c, d));
                            if (numA <= 255 && numB <= 255 && numC <= 255 && numD <= 255) {
                                string ip = to_string(numA) + "." +
                                            to_string(numB) + "." +
                                            to_string(numC) + "." +
                                            to_string(numD);
                                if (ip.length() == n + 3) {
                                    ans.push_back(ip);
                                }
                            }
                        }
                    }
                }
            }
        }
        return ans;
    }
};

2️⃣ 回溯法｜递归

// 代码1
class Solution {
public:
    vector<string> ans;
    string ip;

    void backtracking(string s, int i, int segment) {
        if (i == s.length() && segment == 4) {
            ip = ip.substr(0, ip.length() - 1);
            ans.push_back(ip);
            return;
        }
        if (segment > 4) {
            return;
        }
        for (int j = 1; j <= 3 && i + j - 1 < s.length(); j++) {
            if (j > 1 && s[i] == '0') {
                return;
            }
            string subIP = s.substr(i, j);
            int numIP = stoi(subIP);
            if (numIP > 255)
                break;
            int len = ip.length();
            ip = ip + subIP + '.';
            backtracking(s, i + j, segment + 1);
            ip = ip.substr(0, len);
        }
    }

    vector<string> restoreIpAddresses(string s) {
        int n = s.length();
        if (n < 4) {
            return {};
        }
        backtracking(s, 0, 0);
        return ans;
    }
};

// 代码2
class Solution {
public:
    vector<string> ans;
    vector<string> path;

    vector<string> restoreIpAddresses(string s) {
        int n = s.length();
        if (n < 4 || n > 12) {
            return {};
        }

        function<void(int)> dfs = [&](int i) {
            if (i == n && path.size() == 4) {
                string ip = path[0] + "." + path[1] + "." + path[2] + "." + path[3];
                ans.push_back(ip);
                return;
            }
            for (int j = 1; j <= 3 && i + j - 1 < n; j++) {
                string sub = s.substr(i, j);
                if ((j > 1 && s[i] == '0') || stoi(sub) > 255)
                    break;
                path.push_back(sub);
                dfs(i + j);
                path.pop_back();
            }
        };

        dfs(0);

        return ans;
    }
};

25. K 个一组反转链表

腾讯 WXG 一面

✅ LeetCode: 25. K 个一组翻转链表

相关例题 1：24. 两两交换链表中的节点

迭代｜四指针

递归｜三指针

相关例题 2：206. 反转链表

相关例题 3：92. 反转链表 II

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

1️⃣ 解法一：利用「206. 反转链表」+「92. 反转链表 II」完成

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    // 206. 反转链表
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    // 92. 反转链表 II
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode dummy(0, head);
        ListNode* pre = &dummy;
        for (int i = 0; i < left - 1; i++) {
            pre = pre->next;
        }
        ListNode* leftNode = pre->next;
        ListNode* rightNode = leftNode;
        for (int i = left; i < right; i++) {
            rightNode = rightNode->next;
        }
        ListNode* nxt = rightNode->next;
        rightNode->next = nullptr;
        reverseList(leftNode);
        pre->next = rightNode;
        leftNode->next = nxt;
        return dummy.next;
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        int n = 0;
        ListNode* cur = head;
        while (cur) {
            n++;
            cur = cur->next;
        }
        if (n < k) {
            return head;
        }
        ListNode* new_head = head;
        int times = n / k;
        for (int i = 0; times--; i += k) {
            ListNode* node = reverseBetween(new_head, i + 1, i + k);
            if (i == 0) {
                new_head = node;
            }
        }
        return new_head;
    }
};

2️⃣ 解法二｜0x3f：从反转链表直接到「K 个一组翻转链表」

反转过程同「反转链表」代码，从 while (cur) 变成 for (int i = 0; i < k; i++)；其次每处理 k 个一组后，节点之间需要切换（🌟）。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        // 统计节点个数
        int n = 0;
        for (ListNode* cur = head; cur; cur = cur->next) {
            n++;
        }
        ListNode dummy(0, head);
        ListNode* p0 = &dummy;
        ListNode* pre = nullptr;
        ListNode* cur = head;
        // k 个一组处理
        for (; n >= k; n -= k) {
            // 同 [206. 反转链表]
            for (int i = 0; i < k; i++) {
                ListNode* nxt = cur->next;
                cur->next = pre;
                pre = cur;
                cur = nxt;
            }
            ListNode* nxt = p0->next;
            p0->next->next = cur;
            p0->next = pre;
            p0 = nxt;
        }
        return dummy.next;
    }
};

234. 回文链表

✅ LeetCode: 234. 回文链表

相关例题：

876. 链表的中间结点

206. 反转链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：head = [1,2,2,1]
输出：true

先找到中间节点（类 876 题使用快慢指针），然后反转后半段的链表（206 题反转链表），之后逐个比较即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    // 876. 链表的中间结点
    ListNode* middleNode(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    // 206. 反转链表｜迭代
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    // 206. 反转链表｜递归
    ListNode* recursion_reverseList(ListNode* head) {
        if (!head || !head->next) {
            return head;
        }
        ListNode* new_head = recursion_reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return new_head;
    }

    bool isPalindrome(ListNode* head) {
        // 中间节点 (偶数则为后一个节点)
        ListNode* middle = middleNode(head);
        ListNode* node = reverseList(middle);
        while (node) {
            if (head->val != node->val) {
                return false;
            }
            head = head->next;
            node = node->next;
        }
        return true;
    }
};

23. 合并 K 个升序链表

快手搜广推一面

✅ LeetCode: 23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

1️⃣ 最小堆

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](const ListNode* a, const ListNode* b) {
            return a->val > b->val;
        };
        // decltype 推断表达式类型
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq;
        for (auto head : lists) {
            if (head) {
                pq.push(head);
            }
        }
        ListNode dummy{};
        auto cur = &dummy;
        while (!pq.empty()) {
            ListNode* nxt = pq.top();
            pq.pop();
            cur->next = nxt;
            cur = cur->next;
            if (nxt->next) {
                pq.push(nxt->next);
            }
        }
        return dummy.next;
    }
};

2️⃣ 分治法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode dummy{};
        ListNode* cur = &dummy;
        while (list1 && list2) {
            if (list1->val < list2->val) {
                cur->next = list1;
                list1 = list1->next;
            } else {
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return dummy.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists, int l, int r) {
        if (l == r)
            return lists[l];
        if (l > r)
            return nullptr;
        int m = (l + r) >> 1;
        auto left = mergeKLists(lists, l, m);
        auto right = mergeKLists(lists, m + 1, r);
        return mergeTwoLists(left, right);
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return mergeKLists(lists, 0, lists.size() - 1);
    }
};

445. 两数相加 II

腾讯 CDG 一面

✅ LeetCode: 445. 两数相加 II

前置题目：

2. 两数相加

206. 反转链表

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例1：

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

反转链表 + 两数相加 = 秒杀

class Solution {
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        auto new_head = reverseList(head->next);
        head->next->next = head; // 把下一个节点指向自己
        head->next = nullptr; // 断开指向下一个节点的连接，保证最终链表的末尾节点的 next 是空节点
        return new_head;
    }

    // l1 和 l2 为当前遍历的节点，carry 为进位
    ListNode* addTwo(ListNode* l1, ListNode* l2, int carry = 0) {
        if (l1 == nullptr && l2 == nullptr) { // 递归边界：l1 和 l2 都是空节点
            return carry ? new ListNode(carry) : nullptr; // 如果进位了，就额外创建一个节点
        }
        if (l1 == nullptr) { // 如果 l1 是空的，那么此时 l2 一定不是空节点
            swap(l1, l2); // 交换 l1 与 l2，保证 l1 非空，从而简化代码
        }
        carry += l1->val + (l2 ? l2->val : 0); // 节点值和进位加在一起
        l1->val = carry % 10; // 每个节点保存一个数位
        l1->next = addTwo(l1->next, (l2 ? l2->next : nullptr), carry / 10); // 进位
        return l1;
    }

public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2); // l1 和 l2 反转后，就变成【2. 两数相加】了
        auto l3 = addTwo(l1, l2);
        return reverseList(l3);
    }
};

24. 两两交换链表中的节点

腾讯 CSIG 一面

✅ LeetCode: 24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

四个指针秒了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (!head)
            return head;
        ListNode dummy(0, head);
        ListNode* node0 = &dummy;
        ListNode* node1 = head;
        while (node1 && node1->next) {
            ListNode* node2 = node1->next;
            ListNode* node3 = node2->next;
            node2->next = node1;
            node1->next = node3;
            node0->next = node2;
            node0 = node1;
            node1 = node3;
        }
        return dummy.next;
    }
};

72. 编辑距离

腾讯 CDG 一面

✅ LeetCode: 72. 编辑距离

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

递推｜注意边界初始化值

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.length(), n = word2.length();
        vector<vector<int>> f(m + 1, vector<int>(n + 1));
        for (int i = 0; i <= m; i++)
            f[i][0] = i;
        for (int j = 0; j <= n; j++)
            f[0][j] = j;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                f[i + 1][j + 1] = word1[i] == word2[j] ? f[i][j] : min({f[i][j], f[i + 1][j], f[i][j + 1]}) + 1;
            }
        }
        return f[m][n];
    }
};

4. 寻找两个正序数组的中位数

字节 AML 一面

✅ LeetCode: 4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

🧐 分析

本质上，我们需要在两个有序数组中，查找第 k 小的数，其中 k = (m + n) / 2 取上整。

如果 m+n 是奇数，返回第 k 小的数。
如果 m+n 是偶数，返回第 k 小的数和第 k+1 小的数的平均值。

先从最暴力的「排序」做法开始，然后讲解「双指针」做法，最后过渡到「二分查找」做法。

🙋 答疑

1️⃣ 相向双指针｜均匀分组｜当条件「第一组最大值 ≤ 第二组最小值」满足

class Solution {
public:
    // 相向双指针｜均匀分组｜当条件「第一组最大值 <= 第二组最小值」满足
    // Hot 100 中最难的一题
    double findMedianSortedArrays(vector<int>& a, vector<int>& b) {
        if (a.size() > b.size())
            swap(a, b);
        int m = a.size(), n = b.size();
        a.insert(a.begin(), INT_MIN);
        b.insert(b.begin(), INT_MIN);
        a.push_back(INT_MAX);
        b.push_back(INT_MAX);

        int i = 0, j = (m + n + 1) / 2;
        while (true) {
            if (a[i] <= b[j + 1] && b[j] <= a[i + 1]) {
                int max1 = max(a[i], b[j]);         // 第一组最大值
                int min2 = min(a[i + 1], b[j + 1]); // 第二组最小值
                return (m + n) % 2 ? max1 : (max1 + min2) / 2.0;
            }
            i++;
            j--;
        }
    }
};

2️⃣ 用二分查找优化：由于满足点只有一个, 所以判断条件为 $a[i] ≤ b[j + 1]$

class Solution {
public:
    // 二分优化, 由于满足点只有一个, 所以判断条件为 a[i] <= b[j + 1]
    double findMedianSortedArrays(vector<int>& a, vector<int>& b) {
        if (a.size() > b.size())
            swap(a, b);
        int m = a.size(), n = b.size();
        a.insert(a.begin(), INT_MIN);
        b.insert(b.begin(), INT_MIN);
        a.push_back(INT_MAX);
        b.push_back(INT_MAX);

        int left = 0, right = m + 1;
        while (left + 1 < right) {
            int i = (left + right) / 2;
            int j = (m + n + 1) / 2 - i;
            if (a[i] <= b[j + 1]) {
                left = i;
            } else {
                right = i;
            }
        }

        // left == right - 1
        int i = left;
        int j = (m + n + 1) / 2 - i;
        int max1 = max(a[i], b[j]);
        int min2 = min(a[i + 1], b[j + 1]);
        return (m + n) % 2 ? max1 : (max1 + min2) / 2.0;
    }
};

230. 二叉搜索树中第 K 小的元素

腾讯 WXG 一面

✅ LeetCode：230. 二叉搜索树中第 K 小的元素

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 小的元素（从 1 开始计数）。

示例 1：

输入：root = [3,1,4,null,2], k = 1
输出：1

1️⃣ 中序遍历：在中序遍历，即「左-根-右」的过程中，每次递归完左子树，就把 k 减少 1，表示我们按照中序遍历访问到了一个节点。如果减一后 k 变成 0，那么答案就是当前节点的值，用一个外部变量 ans 记录。

class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        int ans;
        auto dfs = [&](this auto&& dfs, TreeNode* node) -> void {
            if (node == nullptr) {
                return;
            }
            dfs(node->left); // 左
            if (--k == 0) {
                ans = node->val; // 根
            }
            dfs(node->right); // 右
        };
        dfs(root);
        return ans;
    }
};

2️⃣ 中序遍历：直接将所有答案记录到 vector 数组中，返回对应索引值即可。

class Solution {
public:
    vector<int> ans;

    void preOrder(TreeNode* node) {
        if (node == nullptr)
            return;
        preOrder(node->left);
        ans.push_back(node->val);
        preOrder(node->right);
    }

    int kthSmallest(TreeNode* root, int k) {
        preOrder(root);
        return ans[k - 1];
    }
};

354. 俄罗斯套娃信封问题

腾讯 WXG 一面

✅ LeetCode：354. 俄罗斯套娃信封问题

给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。

当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。

注意：不允许旋转信封。

示例 1：

输入：envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出：3
解释：最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。

示例 2：

输入：envelopes = [[1,1],[1,1],[1,1]]
输出：1

0️⃣ DP 会超时，只能用二分查找。

1️⃣ 贪心 + 二分查找：先排序，再按照 LIS 二分贪心模板求最长递增子序列。因为二者都必须是递增的，所以第二维度需要逆序排序，使得第一维度相同的多个数，最后一个插入的一定是最小值，这样能嵌套的信封最多。

class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        sort(envelopes.begin(), envelopes.end(), [](const auto& a, const auto& b) {
            return a[0] < b[0] || (a[0] == b[0] && a[1] > b[1]);
        });
        vector<int> g;
        for (auto& e : envelopes) {
            auto it = lower_bound(g.begin(), g.end(), e[1]);
            if (it == g.end()) {
                g.push_back(e[1]);
            } else {
                *it = e[1];
            }
        }
        return g.size();
    }
};

八股文 @ 计算机网络

Sat, 23 Aug 2025 00:00:00 GMT

1. 键入网址到网页显示，期间发生了什么？

超参数一面、腾讯 WXG 测开一面

回答模板

当您在浏览器中输入网址并按下回车后，整个过程涉及 TCP/IP 协议栈的每一层协作，具体过程如下：

应用层：浏览器解析 URL，生成 HTTP 请求报文（包含请求方法、路径、头部字段等）。随后触发 DNS 查询（通过 UDP 协议），将域名解析为 IP 地址。若访问 HTTPS 站点，还会触发 TLS 握手协商加密参数。
传输层：获取目标 IP 后，操作系统通过 TCP 协议与服务器建立连接（三次握手：SYN → SYN-ACK → ACK）。TCP 为 HTTP 数据提供分段、序列号、确认应答和重传机制，确保可靠传输。连接建立后，HTTP 请求被封装为 TCP 数据段发送。
网络层：TCP 数据段交给 IP 协议处理，添加源/目标 IP 地址构成 IP 数据包，通过路由选择算法决定转发路径。可能经过多个路由器（跳数递增、TTL递减），最终抵达目标服务器。
网络接口层：IP 数据包被封装为帧（如以太网帧），添加 MAC 地址头部。通过 ARP 协议查询下一跳路由器或目标服务器的 MAC 地址，经物理网络（如交换机、光纤）传输至下一节点。
服务器端处理：服务器反向解封装帧→IP 包→TCP 段→HTTP 请求，处理后生成 HTTP 响应（状态码、响应头、HTML 等内容），再沿协议栈封装返回。
客户端解析与渲染：浏览器接收响应后，解析 HTML 构建 DOM 树，加载 CSS/JS 等子资源（可能触发多次 TCP 连接复用或并发），最终完成页面渲染。
TCP 连接释放：数据传输完成后，通过 TCP 四次挥手（FIN-ACK）安全关闭连接。

详细的过程如下

想必不少小伙伴面试过程中，会遇到「当键入网址后，到网页显示，其间发生了什么」的面试题。

这问题真挺常问的，好几家公司问了这个问题。

接下来以下图较简单的网络拓扑模型作为例子，探究探究期间发生了什么？

(1) HTTP

浏览器做的第一步工作就是解析 URL

首先浏览器做的第一步工作就是要对 URL 进行解析，从而生成发送给 Web 服务器的请求信息。

让我们看看一条长长的 URL 里的各个元素的代表什么，见下图：

所以图中的长长的 URL 实际上是请求服务器里的文件资源。

要是上图中的蓝色部分 URL 元素都省略了，那应该是请求哪个文件呢？

当没有路径名时，就代表访问根目录下事先设置的默认文件，也就是 /index.html 或者 /default.html 这些文件，这样就不会发生混乱了。

生产 HTTP 请求信息

对 URL 进行解析之后，浏览器确定了 Web 服务器和文件名，接下来就是根据这些信息来生成 HTTP 请求消息了。

(2) DNS

通过浏览器解析 URL 并生成 HTTP 消息后，需要委托操作系统将消息发送给 Web 服务器。

但在发送之前，还有一项工作需要完成，那就是查询服务器域名对应的 IP 地址，因为委托操作系统发送消息时，必须提供通信对象的 IP 地址。

有一种服务器就专门保存了 Web 服务器域名与 IP 的对应关系，它就是 DNS 服务器。

域名的层级关系

DNS 中的域名都是用句点来分隔的，比如 www.server.com，这里的句点代表了不同层次之间的界限。

在域名中，越靠右的位置表示其层级越高。
毕竟域名是外国人发明，所以思维和中国人相反，比如说一个城市地点的时候，外国喜欢从小到大的方式顺序说起（如 XX 街道 XX 区 XX 市 XX 省），而中国则喜欢从大到小的顺序（如 XX 省 XX 市 XX 区 XX 街道）。
实际上域名最后还有一个点，比如 www.server.com.，这个最后的一个点代表根域名。
也就是，. 根域是在最顶层，它的下一层就是 .com 顶级域，再下面是 server.com。

所以域名的层级关系类似一个树状结构：

根 DNS 服务器（.）
顶级域 DNS 服务器（.com）
权威 DNS 服务器（server.com）

根域的 DNS 服务器信息保存在互联网中所有的 DNS 服务器中。

这样一来，任何 DNS 服务器就都可以找到并访问根域 DNS 服务器了。

因此，客户端只要能够找到任意一台 DNS 服务器，就可以通过它找到根域 DNS 服务器，然后再一路顺藤摸瓜找到位于下层的某台目标 DNS 服务器。

域名解析的工作流程

客户端首先会发出一个 DNS 请求，问 www.server.com 的 IP 是啥，并发给本地 DNS 服务器（也就是客户端的 TCP/IP 设置中填写的 DNS 服务器地址）。
本地域名服务器收到客户端的请求后，如果缓存里的表格能找到 www.server.com，则它直接返回 IP 地址。如果没有，本地 DNS 会去问它的根域名服务器：“能告诉我 www.server.com 的 IP 地址吗？” 根域名服务器是最高层次的，它不直接用于域名解析，但能指明一条道路。
根 DNS 收到来自本地 DNS 的请求后，发现后置是 .com，说“www.server.com 这个域名归 .com 区域管理”，我给你 .com 顶级域名服务器地址给你，你去问问它吧。”
本地 DNS 收到顶级域名服务器的地址后，发起请求问“你能告诉我 www.server.com 的 IP 地址吗？”
顶级域名服务器说：“我给你负责 www.server.com 区域的权威 DNS 服务器的地址，你去问它应该能问到”。
本地 DNS 于是转向问权威 DNS 服务器：“www.server.com 对应的 IP 是啥呀？” server.com 的权威 DNS 服务器，它是域名解析结果的原出处。
权威 DNS 服务器查询后将对应的 IP 地址 X.X.X.X 告诉本地 DNS。
本地 DNS 再将 IP 地址返回客户端，客户端和目标建立连接。

至此，我们完成了 DNS 的解析过程。现在总结一下，整个过程我画成了一个图。

那是不是每次解析域名都要经过那么多的步骤呢？

当然不是了，还有缓存这个东西的嘛。

浏览器会先看自身有没有对这个域名的缓存，如果有，就直接返回；
如果没有，就去问操作系统，操作系统也会去看自己的缓存，如果有，就直接返回；
如果没有，再去 hosts 文件看；
也没有，才会去问「本地 DNS 服务器」

(3) 协议栈

通过 DNS 获取到 IP 后，就可以把 HTTP 的传输工作交给操作系统中的协议栈。

协议栈的内部分为几个部分，分别承担不同的工作。上下关系是有一定的规则的，上面的部分会向下面的部分委托工作，下面的部分收到委托的工作并执行。

应用程序（浏览器）通过调用 Socket 库，来委托协议栈工作。

协议栈的上半部分有两块，分别是负责收发数据的 TCP 和 UDP 协议，这两个传输协议会接受应用层的委托执行收发数据的操作。

协议栈的下面一半是用 IP 协议控制网络包收发操作，在互联网上传数据时，数据会被切分成一块块的网络包，而将网络包发送给对方的操作就是由 IP 负责的。

此外 IP 中还包括 ICMP 协议和 ARP 协议。

ICMP 用于告知网络包传送过程中产生的错误以及各种控制信息。
ARP 用于根据 IP 地址查询相应的以太网 MAC 地址。

IP 下面的网卡驱动程序负责控制网卡硬件，而最下面的网卡则负责完成实际的收发操作，也就是对网线中的信号执行发送和接收操作。

(4) TCP —— 可靠传输

HTTP 是基于 TCP 协议传输的，所以在这我们先了解下 TCP 协议。

TCP 包头格式

我们先看看 TCP 报文头部的格式：

首先，源端口号和目标端口号是不可少的，如果没有这两个端口号，数据就不知道应该发给哪个应用。

接下来有包的序号，这个是为了解决包乱序的问题。

还有应该有的是确认号，目的是确认发出去对方是否有收到。如果没有收到就应该重新发送，直到送达，这个是为了解决丢包的问题。

接下来还有一些状态位。例如 SYN 是发起一个连接，ACK 是回复，RST 是重新连接，FIN 是结束连接等。TCP 是面向连接的，因而双方要维护连接的状态，这些带状态位的包的发送，会引起双方的状态变更。

还有一个重要的就是窗口大小。TCP 要做流量控制，通信双方各声明一个窗口（缓存大小），标识自己当前能够的处理能力，别发送的太快，撑死我，也别发的太慢，饿死我。

除了做流量控制以外，TCP 还会做拥塞控制，对于真正的通路堵车不堵车，它无能为力，唯一能做的就是控制自己，也即控制发送的速度。不能改变世界，就改变自己嘛。

TCP 传输数据之前，要先三次握手建立连接

在 HTTP 传输数据之前，首先需要 TCP 建立连接，TCP 连接的建立，通常称为三次握手。

这个所谓的「连接」，只是双方计算机里维护一个状态机，在连接建立的过程中，双方的状态变化时序图就像这样。

一开始，客户端和服务端都处于 CLOSED 状态。先是服务端主动监听某个端口，处于 LISTEN 状态。
然后客户端主动发起连接 SYN，之后处于 SYN-SENT 状态。
服务端收到发起的连接，返回 SYN，并且 ACK 客户端的 SYN，之后处于 SYN-RCVD 状态。
客户端收到服务端发送的 SYN 和 ACK 之后，发送对 SYN 确认的 ACK，之后处于 ESTABLISHED 状态，因为它一发一收成功了。
服务端收到 ACK 的 ACK 之后，处于 ESTABLISHED 状态，因为它也一发一收了。

所以三次握手目的是保证双方都有发送和接收的能力。

如何查看 TCP 的连接状态？

TCP 的连接状态查看，在 Linux 可以通过 netstat -napt 命令查看。

TCP 分割数据

如果 HTTP 请求消息比较长，超过了 MSS 的长度，这时 TCP 就需要把 HTTP 的数据拆解成一块块的数据发送，而不是一次性发送所有数据。

MTU：一个网络包的最大长度，以太网中一般为 1500 字节。
MSS：除去 IP 和 TCP 头部之后，一个网络包所能容纳的 TCP 数据的最大长度。

数据会被以 MSS 的长度为单位进行拆分，拆分出来的每一块数据都会被放进单独的网络包中。也就是在每个被拆分的数据加上 TCP 头信息，然后交给 IP 模块来发送数据。

注：HTTP 头部和消息体是作为一个整体被 TCP 分割的。

TCP 报文生成

TCP 协议里面会有两个端口，一个是浏览器监听的端口（通常是随机生成的），一个是 Web 服务器监听的端口（HTTP 默认端口号是 80， HTTPS 默认端口号是 443）。

在双方建立了连接后，TCP 报文中的数据部分就是存放 HTTP 头部 + 数据，组装好 TCP 报文之后，就需交给下面的网络层处理。

至此，网络包的报文如下图。

(5) IP —— 远程定位

TCP 模块在执行连接、收发、断开等各阶段操作时，都需要委托 IP 模块将数据封装成网络包发送给通信对象。

IP 包头格式

我们先看看 IP 报文头部的格式：

在 IP 协议里面需要有源地址 IP 和目标地址 IP：

源地址 IP，即是客户端输出的 IP 地址
目标地址，即通过 DNS 域名解析得到的 Web 服务器 IP

因为 HTTP 是经过 TCP 传输的，所以在 IP 包头的协议号，要填写为 06（十六进制），表示协议为 TCP。

假设客户端有多个网卡，就会有多个 IP 地址，那 IP 头部的源地址应该选择哪个 IP 呢？

当存在多个网卡时，在填写源地址 IP 时，就需要判断到底应该填写哪个地址。这个判断相当于在多块网卡中判断应该使用哪个一块网卡来发送包。

这个时候就需要根据路由表规则，来判断哪一个网卡作为源地址 IP。

在 Linux 操作系统，我们可以使用 route -n 命令查看当前系统的路由表。

举个例子，根据上面的路由表，我们假设 Web 服务器的目标地址是 192.168.10.200。

首先先和第一条目的子网掩码（Genmask）进行与运算，得到结果为 192.168.10.0，但是第一个条目的 Destination 是 192.168.3.0，两者不一致所以匹配失败。
再与第二条目的子网掩码进行与运算，得到的结果为 192.168.10.0，与第二条目的 Destination 192.168.10.0 匹配成功，所以将使用 eth1 网卡的 IP 地址作为 IP 包头的源地址。

那么假设 Web 服务器的目标地址是 10.100.20.100，那么依然依照上面的路由表规则判断，判断后的结果是和第三条目匹配。

第三条目比较特殊，它目标地址和子网掩码都是 0.0.0.0，这表示默认网关，如果其他所有条目都无法匹配，就会自动匹配这一行。并且后续就把包发给路由器，Gateway 即是路由器的 IP 地址。

IP 报文生成

至此，网络包的报文如下图。

(6) MAC —— 两点传输

生成了 IP 头部之后，接下来网络包还需要在 IP 头部的前面加上 MAC 头部。

MAC 包头格式

MAC 头部是以太网使用的头部，它包含了接收方和发送方的 MAC 地址等信息。

在 MAC 包头里需要发送方 MAC 地址和接收方目标 MAC 地址，用于两点之间的传输。

一般在 TCP/IP 通信里，MAC 包头的协议类型只使用：

0800 ： IP 协议
0806 ： ARP 协议

MAC 发送方和接收方如何确认?

发送方的 MAC 地址获取就比较简单了，MAC 地址是在网卡生产时写入到 ROM 里的，只要将这个值读取出来写入到 MAC 头部就可以了。

接收方的 MAC 地址就有点复杂了，只要告诉以太网对方的 MAC 的地址，以太网就会帮我们把包发送过去，那么很显然这里应该填写对方的 MAC 地址。

所以先得搞清楚应该把包发给谁，这个只要查一下路由表就知道了。在路由表中找到相匹配的条目，然后把包发给 Gateway 列中的 IP 地址就可以了。

既然知道要发给谁，按如何获取对方的 MAC 地址呢？

不知道对方 MAC 地址？不知道就喊呗。

此时就需要 ARP 协议帮我们找到路由器的 MAC 地址。

ARP 协议会在以太网中以广播的形式，对以太网所有的设备喊出：“这个 IP 地址是谁的？请把你的 MAC 地址告诉我”。

然后就会有人回答：“这个 IP 地址是我的，我的 MAC 地址是 XXXX”。

如果对方和自己处于同一个子网中，那么通过上面的操作就可以得到对方的 MAC 地址。然后，我们将这个 MAC 地址写入 MAC 头部，MAC 头部就完成了。

好像每次都要广播获取，这不是很麻烦吗？

放心，在后续操作系统会把本次查询结果放到一块叫做 ARP 缓存的内存空间留着以后用，不过缓存的时间就几分钟。

也就是说，在发包时：

先查询 ARP 缓存，如果其中已经保存了对方的 MAC 地址，就不需要发送 ARP 查询，直接使用 ARP 缓存中的地址。
而当 ARP 缓存中不存在对方 MAC 地址时，则发送 ARP 广播查询。

查看 ARP 缓存内容

在 Linux 系统中，我们可以使用 arp -a 命令来查看 ARP 缓存的内容。

MAC 报文生成

至此，网络包的报文如下图。

(7) 网卡

网络包只是存放在内存中的一串二进制数字信息，没有办法直接发送给对方。因此，我们需要将数字信息转换为电信号，才能在网线上传输，也就是说，这才是真正的数据发送过程。

负责执行这一操作的是网卡，要控制网卡还需要靠网卡驱动程序。

网卡驱动获取网络包之后，会将其复制到网卡内的缓存区中，接着会在其开头加上报头和起始帧分界符，在末尾加上用于检测错误的帧校验序列。

起始帧分界符是一个用来表示包起始位置的标记
末尾的 FCS（帧校验序列）用来检查包传输过程是否有损坏

最后网卡会将包转为电信号，通过网线发送出去。

(8) 交换机

下面来看一下包是如何通过交换机的。交换机的设计是将网络包原样转发到目的地。交换机工作在 MAC 层，也称为二层网络设备。

交换机的包接收操作

首先，电信号到达网线接口，交换机里的模块进行接收，接下来交换机里的模块将电信号转换为数字信号。

然后通过包末尾的 FCS 校验错误，如果没问题则放到缓冲区。这部分操作基本和计算机的网卡相同，但交换机的工作方式和网卡不同。

计算机的网卡本身具有 MAC 地址，并通过核对收到的包的接收方 MAC 地址判断是不是发给自己的，如果不是发给自己的则丢弃；相对地，交换机的端口不核对接收方 MAC 地址，而是直接接收所有的包并存放到缓冲区中。因此，和网卡不同，交换机的端口不具有 MAC 地址。

将包存入缓冲区后，接下来需要查询一下这个包的接收方 MAC 地址是否已经在 MAC 地址表中有记录了。

交换机的 MAC 地址表主要包含两个信息：

一个是设备的 MAC 地址，
另一个是该设备连接在交换机的哪个端口上。

举个例子，如果收到的包的接收方 MAC 地址为 00-02-B3-1C-9C-F9，则与图中表中的第 3 行匹配，根据端口列的信息，可知这个地址位于 3 号端口上，然后就可以通过交换电路将包发送到相应的端口了。

所以，交换机根据 MAC 地址表查找 MAC 地址，然后将信号发送到相应的端口。

当 MAC 地址表找不到指定的 MAC 地址会怎么样？

地址表中找不到指定的 MAC 地址。这可能是因为具有该地址的设备还没有向交换机发送过包，或者这个设备一段时间没有工作导致地址被从地址表中删除了。

这种情况下，交换机无法判断应该把包转发到哪个端口，只能将包转发到除了源端口之外的所有端口上，无论该设备连接在哪个端口上都能收到这个包。

这样做不会产生什么问题，因为以太网的设计本来就是将包发送到整个网络的，然后只有相应的接收者才接收包，而其他设备则会忽略这个包。

有人会说：“这样做会发送多余的包，会不会造成网络拥塞呢？”

其实完全不用过于担心，因为发送了包之后目标设备会作出响应，只要返回了响应包，交换机就可以将它的地址写入 MAC 地址表，下次也就不需要把包发到所有端口了。

局域网中每秒可以传输上千个包，多出一两个包并无大碍。

此外，如果接收方 MAC 地址是一个广播地址，那么交换机会将包发送到除源端口之外的所有端口。

以下两个属于广播地址：

MAC 地址中的 FF:FF:FF:FF:FF:FF
IP 地址中的 255.255.255.255

(9) 路由器 —— 出境大门

路由器与交换机的区别

网络包经过交换机之后，现在到达了路由器，并在此被转发到下一个路由器或目标设备。

这一步转发的工作原理和交换机类似，也是通过查表判断包转发的目标。

不过在具体的操作过程上，路由器和交换机是有区别的。

因为路由器是基于 IP 设计的，俗称三层网络设备（物理层 + 链路层 + 网络层），路由器的各个端口都具有 MAC 地址和 IP 地址；
而交换机是基于以太网设计的，俗称二层网络设备（物理层 + 链路层），交换机的端口不具有 MAC 地址。

路由器基本原理

路由器的端口具有 MAC 地址，因此它就能够成为以太网的发送方和接收方；同时还具有 IP 地址，从这个意义上来说，它和计算机的网卡是一样的。

当转发包时，首先路由器端口会接收发给自己的以太网包，然后路由表查询转发目标，再由相应的端口作为发送方将以太网包发送出去。

路由器的包接收操作

首先，电信号到达网线接口部分，路由器中的模块会将电信号转成数字信号，然后通过包末尾的 FCS 进行错误校验。

如果没问题则检查 MAC 头部中的接收方 MAC 地址，看看是不是发给自己的包，如果是就放到接收缓冲区中，否则就丢弃这个包。

总的来说，路由器的端口都具有 MAC 地址，只接收与自身地址匹配的包，遇到不匹配的包则直接丢弃。

查询路由表确定输出端口

完成包接收操作之后，路由器就会去掉包开头的 MAC 头部。

MAC 头部的作用就是将包送达路由器，其中的接收方 MAC 地址就是路由器端口的 MAC 地址。因此，当包到达路由器之后，MAC 头部的任务就完成了，于是 MAC 头部就会被丢弃。

接下来，路由器会根据 MAC 头部后方的 IP 头部中的内容进行包的转发操作。

转发操作分为几个阶段，首先是查询路由表判断转发目标。

具体的工作流程根据上图，举个例子：

假设地址为 10.10.1.101 的计算机要向地址为 192.168.1.100 的服务器发送一个包，这个包先到达图中的路由器。
判断转发目标的第一步，就是根据包的接收方 IP 地址查询路由表中的目标地址栏，以找到相匹配的记录。
路由匹配和前面讲的一样，每个条目的子网掩码和 192.168.1.100 IP 做 & 与运算后，得到的结果与对应条目的目标地址进行匹配，如果匹配就会作为候选转发目标，如果不匹配就继续与下个条目进行路由匹配。
如第二条目的子网掩码 255.255.255.0 与 192.168.1.100 IP 做 & 与运算后，得到结果是 192.168.1.0，这与第二条目的目标地址 192.168.1.0 匹配，该第二条目记录就会被作为转发目标。
实在找不到匹配路由时，就会选择默认路由，路由表中子网掩码为 0.0.0.0 的记录表示「默认路由」。

路由器的发送操作

接下来就会进入包的发送操作。

首先，我们需要根据路由表的网关列判断对方的地址。

如果网关是一个 IP 地址，则这个IP 地址就是我们要转发到的目标地址，还未抵达终点，还需继续需要路由器转发。
如果网关为空，则 IP 头部中的接收方 IP 地址就是要转发到的目标地址，也是就终于找到 IP 包头里的目标地址了，说明已抵达终点。

知道对方的 IP 地址之后，接下来需要通过 ARP 协议根据 IP 地址查询 MAC 地址，并将查询的结果作为接收方 MAC 地址。

路由器也有 ARP 缓存，因此首先会在 ARP 缓存中查询，如果找不到则发送 ARP 查询请求。

接下来是发送方 MAC 地址字段，这里填写输出端口的 MAC 地址。还有一个以太类型字段，填写 0800 （十六进制）表示 IP 协议。

网络包完成后，接下来会将其转换成电信号并通过端口发送出去。这一步的工作过程和计算机也是相同的。

发送出去的网络包会通过交换机到达下一个路由器。由于接收方 MAC 地址就是下一个路由器的地址，所以交换机会根据这一地址将包传输到下一个路由器。

接下来，下一个路由器会将包转发给再下一个路由器，经过层层转发之后，网络包就到达了最终的目的地。

不知你发现了没有，在网络包传输的过程中，源 IP 和目标 IP 始终是不会变的，一直变化的是 MAC 地址，因为需要 MAC 地址在以太网内进行两个设备之间的包传输。

(10) 服务器与客户端

数据包抵达了服务器，于是服务器开始扒数据包的皮！

数据包抵达服务器后，服务器会先扒开数据包的 MAC 头部，查看是否和服务器自己的 MAC 地址符合，符合就将包收起来。
接着继续扒开数据包的 IP 头，发现 IP 地址符合，根据 IP 头中协议项，知道自己上层是 TCP 协议。
于是，扒开 TCP 的头，里面有序列号，需要看一看这个序列包是不是我想要的，如果是就放入缓存中然后返回一个 ACK，如果不是就丢弃。
TCP 头部里面还有端口号， HTTP 的服务器正在监听这个端口号。于是，服务器自然就知道是 HTTP 进程想要这个包，于是就将包发给 HTTP 进程。
服务器的 HTTP 进程看到，原来这个请求是要访问一个页面，于是就把这个网页封装在 HTTP 响应报文里。
HTTP 响应报文也需要穿上 TCP、IP、MAC 头部，不过这次是源地址是服务器 IP 地址，目的地址是客户端 IP 地址。
穿好头部衣服后，从网卡出去，交由交换机转发到出城的路由器，路由器就把响应数据包发到了下一个路由器，就这样跳啊跳。
最后跳到了客户端的城门把守的路由器，路由器扒开 IP 头部发现是要找城内的人，于是又把包发给了城内的交换机，再由交换机转发到客户端。
客户端收到了服务器的响应数据包后，开始扒皮，把收到的数据包的皮扒剩 HTTP 响应报文后，交给浏览器去渲染页面，一份特别的数据包快递，就这样显示出来了！
最后，客户端要离开了，向服务器发起了 TCP 四次挥手，至此双方的连接就断开了。

总结

TCP/IP 网络模型共有 4 层，分别是应用层、传输层、网络层和网络接口层，每一层负责的职能如下：

应用层，负责向用户提供一组应用程序，比如 HTTP、DNS、FTP 等;
传输层，负责端到端的通信，比如 TCP、UDP 等；
网络层，负责网络包的封装、分片、路由、转发，比如 IP、ICMP 等；
网络接口层，负责网络包在物理网络中的传输，比如网络包的封帧、 MAC 寻址、差错检测，以及通过网卡传输网络帧等；

网络通信是分层进行的，每一层都只与另一端的对等层进行对话。下层为上层提供服务。这个过程就像寄信：

应用层 (HTTP)：你写好信的内容（HTTP 请求/响应）。这包括了 HTTP 头部（如 Content-Type: text/html) 和消息体（如 HTML 代码）。
传输层 (TCP)：TCP 层拿到这封完整的“信”（HTTP 数据），但它发现这封信太长了，一个信封装不下。于是它把信拆分成几个小份，每一份都塞进一个 TCP 信封里。每个 TCP 信封上都写着信息（TCP 头部），比如“这是第几份”、“总共有几份”、“发送方和接收方的端口号”。
网络层 (IP)：IP 层不管 TCP 拆成了几份，它只管拿来一个 TCP 信封，就把它塞进一个更大的 IP 信封里。IP 信封上写着更大的地址信息（IP 头部），比如发送方和接收方的 IP 地址，用于在整个网络上路由。
数据链路层 (MAC)：最后，MAC 层把 IP 信封再塞进一个帧信封里，这个信封上写着在当前局域网内下一站设备的地址（MAC 头部），比如下一个路由器或者交换机的 MAC 地址。这个帧信封的大小受 MTU 限制。

2. 如果 URL 请求的网页响应很慢，可能在哪个环节出现问题？

腾讯 WXG 测开一面

当 URL 请求的网页响应很慢时，问题可能出现在多个环节，包括客户端、网络传输、服务器端以及内容本身。以下是可能的问题点：

在客户端层面
- 浏览器缓存过多或配置错误可能拖慢页面加载
- 操作系统网络栈异常（如 TCP 连接数限制或缓冲区设置不当）也可能导致连接建立缓慢
- DNS 客户端缓存污染或硬件资源（如 CPU、内存）不足会进一步加剧延迟
DNS 解析环节可能出现问题
- 例如本地 DNS 服务器响应缓慢、递归查询超时，或域名解析记录未正确缓存。如果 DNS 服务器故障或域名配置错误，会导致域名到 IP 地址的转换耗时过长
网络传输过程中
- 路由路径不佳可能导致数据包经过过多跳数，从而增加延迟
- 带宽瓶颈在用户本地网络或服务器接入端可能成为限制因素，尤其是在传输大文件时
- 数据包丢失或网络抖动会触发 TCP 重传，降低有效吞吐量，而防火墙或中间设备策略也可能意外丢弃合法流量
服务器端问题包括
- 负载过高，例如 CPU、内存或 I/O 资源饱和，导致无法及时处理请求
- 应用逻辑性能差，如低效的数据库查询、代码执行缓慢或缓存未命中，会直接拖慢响应速度
- 后端依赖服务（如第三方 API 或数据库）延迟也可能阻塞整体处理流程
- Web 服务器配置不当（如进程数不足或保持连接超时设置不合理）会影响请求处理效率
协议与连接方面
- TCP 三次握手或 TLS 协商在高延迟网络中可能显著增加连接建立时间
- HTTP/1.1 的队头阻塞问题（未启用并行连接时）会导致单个请求延迟影响后续资源加载
- CDN 或代理服务器配置错误可能造成请求转发效率低下或缓存失效
内容本身的问题也不容忽视，例如未压缩的大资源（如图片、视频）会增加传输时间，过多阻塞渲染的 JavaScript 或同步加载策略会延迟页面呈现，而重复请求或未优化的资源链接受限於浏览器并发限制。

3. UDP 通信：如果 client 端 sendto 一段 1024 字节的 buf，server 端循环调用 `recvfrom(fd,buf,64,0)`，能否收完？能的话需要调用几次？不能收完原因是什么？

腾讯面试题

在 UDP 通信中，sendto() 发送的每一次数据都是一个完整的独立报文，接收端使用 recvfrom(fd, buf, 64, 0) 时，每次只能接收一个完整报文的最多 64 字节，如果报文长度超过了缓冲区大小（如发送端发送了 1024 字节），则接收端只会接收到前 64 字节，超出部分会被系统直接丢弃，无法通过多次 recvfrom() 调用将同一个报文拆分接收，因此在这种情况下接收端无法收完整个报文。

4. tcp 通信：client 端循环调用 `send(fd,buf,1)` 1024 次发给 server，从 server 端捉包，客户端总共发了几个包过来？

腾讯面试题

在 TCP 通信中，尽管客户端调用了 1024 次 send(fd, buf, 1) 每次仅发送 1 字节的数据，但由于 TCP 是面向字节流的协议，发送的数据会被内核缓冲区聚合后再发送，而不会直接对应为 1024 个网络包。特别是在默认启用 Nagle 算法的情况下，TCP 会将多次小的数据发送请求进行合并，直到缓冲区满或收到 ACK 才会实际发送出去，因此从服务端抓包来看，最终接收到的数据通常会被合并成更少数量的 TCP 包，远少于 1024 个。这种行为由操作系统的 TCP 堆积机制和网络状况共同决定，即使应用层调用了 1024 次 send()，网络中实际传输的包数可能只有几十个或几百个。

5. 应用层有哪些协议？

HTTP：超文本传输协议
HTTPS：HTTP 的安全版本，在 HTTP 下加入 SSL/TLS 层，用于对通信进行加密、认证，确保数据的安全性和完整性
FTP：文件传输协议，用于在客户端和服务器之间进行双向文件传输（上传和下载）。
SMTP：简单邮件传输协议，用于发送邮件以及将邮件从发送人的邮件服务器转发到接收人的邮件服务器
POP3：邮局协议第 3 版，用于从邮件服务器下载邮件到本地计算机，通常下载后会删除服务器上的邮件
IMAP：互联网消息访问协议，更高级的邮件接收协议，允许用户在本地管理服务器上的邮件（如创建、删除、移动邮箱文件夹），邮件始终保留在服务器上
SSH：远程连接协议，用于通过加密的连接安全地远程登录到另一台计算机，并执行命令，是 Telnet 的安全替代品
DNS：域名系统协议，它不是直接为用户服务的，而是为其他应用层协议服务的。它将人类可读的域名（如 www.google.com）转换为机器可读的 IP 地址（如 142.251.42.206）
DHCP：动态主机配置协议，自动为网络中的设备分配 IP 地址、子网掩码、默认网关和 DNS 服务器地址，即“插网线就能上网”的基础
SIP：会话发起协议，用于创建、修改和终止包含视频、语音、即时消息等在内的多媒体会话，是很多 VOIP（网络电话）系统的基础
RTP：实时传输协议，通常与 SIP 等协议配合使用，负责实际传输音频和视频流数据

6. TCP 是什么，怎么保证可靠性的？

腾讯 TEG 一面

TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

它主要通过以下核心机制来保证可靠性的：

确认和重传机制
- 确认 (ACK)：接收方在成功收到数据包后，会向发送方返回一个确认报文（ACK）。ACK 中包含了期望收到的下一个字节的序列号。
- 超时重传：发送方发送一个数据包后会启动一个定时器。如果在定时器超时前没有收到对应的 ACK，发送方就认为该数据包丢失，会重新发送它。
- 快速重传：如果发送方连续收到 3 个相同的 ACK（意味着接收方收到了乱序的包，一直在重复索要某个丢失的包），发送方会立即重传那个被认为丢失的数据包，而不必等待超时。
序列号和确认号：每个字节的数据都被赋予一个唯一的序列号。确认号告诉发送方“我已经成功收到了确认号之前的所有数据，期望下一个收到的数据序列号是这个确认号”。这解决了数据包乱序和确认丢失的问题。
校验和：TCP头部和数据部分都包含一个校验和。接收方会计算校验和，如果与报文中的校验和不匹配，则丢弃该数据包。发送方会因为收不到 ACK 而触发重传，从而解决了数据错误的问题。
流量控制：使用滑动窗口协议来实现。接收方通过 TCP 头部的“窗口大小”字段告诉发送方自己还有多少缓冲区可以接收数据。这防止了发送方发送数据过快，导致接收方缓冲区溢出，从而解决了数据淹没的问题。
拥塞控制：通过一套复杂的算法（如慢启动、拥塞避免、快速恢复）来探测网络当前的承载能力。当发现网络出现拥塞（如丢包）时，会主动降低发送速率，从而减轻网络负担，避免整个网络崩溃。

总结： TCP 通过序列号/确认号确保数据有序、不丢；通过校验和确保数据正确；通过流量控制保护接收方；通过拥塞控制保护网络。其可靠性是这一整套机制协同工作的结果。

7. 三次握手如果改成两次握手会怎样？

腾讯 TEG 一面

核心问题： 无法防止已失效的连接请求报文突然又传送到服务器，从而导致错误和资源浪费。

TCP 三次握手改为两次握手会导致可靠性严重下降，主要引发两个问题：已失效的连接请求和无法同步初始序列号。若只有两次握手，当客户端发送的 SYN 报文因网络延迟而滞留，客户端会重发新 SYN 并建立连接；但延迟的旧 SYN 之后到达服务端时，服务端会误以为是新的连接请求并直接响应，导致服务端资源被无效占用（半连接状态）。此外，两次握手无法确保双方对初始序列号的确认达成一致：服务端无法确认客户端是否收到自己的 SYN-ACK 响应，若该响应丢失，客户端无法感知连接已建立，而服务端却认为连接有效，导致数据单向传输失败。因此，第三次握手的 ACK 是防止历史连接混乱和确保序列号同步的关键。

8. 如果网络条件特别好，能不能两次握手？

腾讯 TEG 一面

即使在网络条件特别好的环境下，TCP 也不能改为两次握手，原因在于两次握手无法解决历史连接和初始序列号同步确认这两个根本性问题。

首先，历史连接问题无法避免。假设客户端发送了一个 SYN 报文后由于某种原因（如应用层重启）决定放弃连接，但该 SYN 报文因网络延迟稍后才到达服务器。在两次握手模型下，服务器收到后会立即回复 SYN-ACK 并认为连接已建立，分配资源并等待数据传输。然而客户端早已放弃这个连接，不会发送数据，导致服务器资源被长期无效占用（直到超时）。三次握手中的第三次 ACK 是关键：客户端通过它来确认本次连接的有效性，若连接已失效（如收到旧的 SYN-ACK），客户端会发送 RST 复位报文来终止服务端的无效连接。

其次，序列号同步的可靠性无法保证。TCP 依赖序列号来保证数据有序性和可靠性，而初始序列号（ISN）的同步需要双方确认。在两次握手中，服务器无法确认客户端是否成功接收到了自己发送的 SYN-ACK（包含服务器的 ISN）。如果这个 SYN-ACK 丢失，客户端根本不知道服务器已准备就绪，而服务器却认为连接已建立并开始等待数据，此时双方状态不一致。第三次握手的 ACK 正式确认了双方对初始序列号的认可，确保了连接状态的双向同步。

因此，即使网络完美无缺，两次握手在协议设计层面仍存在本质缺陷，无法保证连接的可靠性和一致性。TCP 的三次握手是基于逻辑必要性而非网络质量的设计。第三次握手的开销（一个 ACK 包）极小，与它所带来的连接可靠性保障相比，是完全可以接受的。为了节省这微不足道的开销而引入巨大的连接混乱风险，是绝对不值得的。

9. UPD 传输的数据是不是一个完整报文

网易游戏一面

UDP 是面向报文的传输协议，它以报文（Datagram）为单位进行传输，不分割也不合并。
应用层交给 UDP 一个报文，UDP 添加头部后交给 IP 层发送。接收端收到的数据也一定是一个完整的报文（不会被分片成多个）。
如果报文超过网络传输路径的最大传输单元（MTU），则 IP 层（非 UDP）会对报文分片传输，并在接收端自动重组后再交给 UDP。

10. UDP 如何保证传输效率又不丢包

网易游戏一面

UDP 本身不保证可靠性，也就是说它不会主动处理丢包或重传。

如果应用层需要在 UDP 基础上实现高效可靠传输，需要自己实现：
- ACK 应答机制（确认重传）
- 序列号机制（识别丢包、乱序）
- 流量控制、拥塞控制
实践中，比如实时音视频通话、游戏等场景，更倾向于使用 UDP，偶尔丢包可接受，但延迟必须低，可靠性可以通过应用层算法进行补偿（如丢帧插值、快速重传策略）。

因此 UDP 本身仅保证效率，可靠性需要应用层自己设计补偿机制。

11. TCP 和 UDP 粘包分包，怎么解决？

网易游戏一面

粘包

分包/半包

粘包、分包问题的原因：

TCP 是面向流的协议，没有报文边界的概念，数据会合并、分割。
UDP 是面向报文的协议，有天然的报文边界，不存在粘包问题，但仍可能因报文超过 MTU 而发生分片（IP 层分片重组）。

TCP 解决粘包分包的常见方案：

长度字段法：报文头部增加一个字段表示当前报文长度，接收方按长度拆分数据。
分隔符法：在报文末尾增加特殊分隔符标记报文结束（如 HTTP 协议中 \r\n）。
固定长度法：每个消息长度固定。
协议约定：使用标准协议（如 HTTP、Protobuf）明确消息结构。

UDP 是否有粘包问题：

UDP 天然不存在粘包问题，但应保证数据小于 MTU，避免 IP 分片。
即使数据报被 IP 层分片，在 UDP 层也会被重组好再交给应用层。

这是一个非常经典的网络编程问题，接下来我会用清晰易懂的方式解释 TCP 粘包和分包。

首先要理解最关键的一点：TCP 是面向字节流的协议，它不关心应用层数据的边界。

想象一下 TCP 连接就像一根水管，发送方不断地往里面倒水（数据），接收方从另一端接水。TCP 保证水的顺序是对的，并且不丢失，但它不保证你每次接起来的一瓢水，正好是发送方每次倒进去的那一壶。你可能一次接到两壶水（粘包），也可能只接到半壶水（分包）。

(1) TCP 粘包

定义：指发送方发送的多个数据包，在接收方接收时被“粘”在了一起，变成一个大的数据包。

通俗比喻：发送方分别发送了“Hello”和“World”两个包。接收方一次读取可能收到的是“HelloWorld”，两个包粘在了一起。

产生原因：

Nagle 算法：为了优化网络效率，TCP 默认会使用 Nagle 算法。该算法会将多个小的、发送间隔短的数据包合并成一个大的数据包再发送，从而减少网络上的小包数量。
接收方缓冲区积累：发送方发送数据包的速度快于接收方应用层读取数据的速度，导致多个数据包在接收方的缓冲区中堆积在一起，当应用层一次读取足够大的缓冲区时，就把多个包读出来了。

发送方：
[Packet A] [Packet B] [Packet C]
      |          |          |
      v          v          v
TCP 发送流： |--A--|--B--|--C--|
                    |
                    v
接收方缓冲区： |-----A+B+C-----|  <- 应用一次读取到了合并的数据

(2) TCP 分包

定义：指发送方发送的一个数据包，在接收方接收时被拆分成多个数据包接收。

通俗比喻：发送方发送了一个“HelloWorld”包。接收方可能第一次读取到“Hel”，第二次读取到“loWo”，第三次读取到“rld”。

产生原因：

MSS 限制：TCP 有一个最大报文段长度。如果应用层下发的数据包大小超过了 MSS，TCP 层在发送前必须对这个数据包进行拆分。
MTU 限制：在数据链路层，网络接口有一个最大传输单元。如果 IP 数据包（包含 TCP 头和数据）超过了 MTU，它也会被分片传输。虽然这对 TCP 是透明的，但本质也是一种分包。
接收方缓冲区不足：当接收方的 TCP 缓冲区大小小于来的数据包时，TCP 只会将缓冲区满的部分数据交付给应用层，剩下的数据要等应用层读取腾出空间后再继续交付。

发送方：
[Packet A (很大)]
      |
      v
TCP 发送流： |--A1--|--A2--|--A3--|
                    |
                    v
接收方缓冲区： |--A1--| <- 应用第一次读取
然后： |--A2--| <- 应用第二次读取
然后： |--A3--| <- 应用第三次读取

(3) 为什么 UDP 没有粘包和分包问题？

作为对比，UDP 是面向数据报的协议。

🔥保护消息边界：UDP 每次发送都是一个完整的、独立的数据报。接收方每次接收也必须以一个完整的 UDP 数据报为单位。即使数据报被 IP 层分片，在 UDP 层也会被重组好再交给应用层。
要么收全，要么丢包：如果接收方的缓冲区放不下一个完整的 UDP 数据报，这个数据报就会被直接丢弃。

所以，对于 UDP：

发送多少次 sendto，接收方就需要多少次 recvfrom。
每次 recvfrom 得到的数据，必然是且仅是一次 sendto 发送的完整数据。

(4) 如何解决粘包和分包问题？

既然 TCP 本身不维护边界，就需要应用层自己来定义通信协议，以便能从字节流中正确地拆分出原始的数据包。

常见的解决方案有：

1. 定长消息

每个数据包都固定长度。例如，规定每个包都是 100 字节。如果发送的数据不足 100 字节，就用空格或 0x00 填充。

优点：处理简单。
缺点：浪费带宽，不灵活。

2. 分隔符

在每个数据包的结尾加上一个特殊的分隔符，例如换行符 \n。接收方通过这个分隔符来切分数据流。HTTP 协议的头部分就是用 \r\n 来分隔的。

优点：简单直观。
缺点：如果消息体本身包含分隔符，需要转义处理，增加复杂性。

3. 长度前缀（最常用、最标准的方法）

在数据包的首部加上一个固定长度的字段，用来表示包体的长度。

处理流程：

应用层协议定义一个头部，比如前 4 个字节 (uint32_t) 表示包体长度。
发送时，先计算包体长度，写入头部，再写入包体数据。
接收时：

a. 先读取固定长度的头部（例如 4 字节）。

b. 解析头部，得到后面包体的真实长度 N。

c. 继续从缓冲区读取至少 N 个字节，这样就得到了一个完整的数据包。

应用层数据包结构：
[ 4字节长度头 (0x00000005) ] [ 5字节包体 ("Hello") ]

(5) 为什么要解决 TCP 粘包和分包/半包问题？

解决粘包和分包问题根本目的是为了能让接收方正确地、无歧义地还原出发送方发出的原始业务消息。

如果不解决，会导致通信完全无法正常进行。

1. 业务逻辑的完整性被破坏

应用程序是基于“消息”或“请求”来工作的。每个数据包通常代表一个完整的业务指令。

例子：一个在线游戏，客户端发送了两个指令：“攻击A”和“使用药水”。
- 粘包后果：服务器可能一次性收到“攻击A使用药水”，它无法理解这个合并的字符串是什么指令，导致逻辑错误。
- 分包后果：服务器先收到“攻击”，它不知道要攻击谁，等下一个包“A”到来时，逻辑已经混乱。

不解决的后果：应用程序无法理解对方在说什么，业务逻辑无法执行。

2. 数据解析失败

很多标准的数据格式（如 JSON, XML）和序列化协议（如 Protobuf）要求一个完整的数据块才能被正确解析。

例子：客户端发送了一个 JSON 字符串 {"action": "login", "user": "alice"}。
- 粘包后果：接收方可能收到 {"action": "login", "user": "alice"}{"action": "logout", "user": "bob"}，这根本不是合法的 JSON，解析器会直接报错。
- 分包后果：接收方第一次只收到 {"action": "login"，这同样是一个残缺的、非法的 JSON，解析也会失败。

不解决的后果：数据反序列化失败，程序可能崩溃或抛出异常。

3. 状态同步混乱

在客户端-服务器模型中，通信双方都维护着一定的状态。消息的顺序和完整性对状态同步至关重要。

例子：金融交易系统，服务器依次发送两条消息：“余额=100元” 和 “扣款20元”。
- 粘包后果：客户端收到“余额=100元扣款20元”，无法解析，不知道当前余额是多少。
- 分包后果：客户端先收到“余额=100”，然后卡住了，它以为余额就是100，但随后收到的“元扣款20元”又无法理解，导致UI显示错误。

不解决的后果：客户端和服务器状态不一致，用户体验受损，甚至造成数据错误。

4. 协议本身无法工作

很多标准的应用层协议（如 HTTP、FTP、Redis 协议）都内置了解决粘包/分包的机制。如果你自己设计的协议不处理这个问题，那就等同于这个协议是无效的。

以 HTTP 为例：
- 它的“长度前缀”就是 Content-Length 头。浏览器读取到 HTTP 头部，发现 Content-Length: 1024，就知道在头部之后，还需要读取 1024 字节才能得到一个完整的响应体。
- 它的“分隔符”就是 \r\n。通过读取头部的 \r\n\r\n 来分隔头部和主体。

如果 HTTP 不解决粘包/分包，网页将永远无法正常加载。

(6) 总结

理解 TCP 粘包和分包是进行可靠网络编程的基础。在实践中，几乎总是使用“长度前缀”的方法来设计应用层协议，例如 Google 的 Protocol Buffers 和许多消息队列的通信协议都采用这种方式。

12. TCP 为什么是四次挥手

网易游戏一面

TCP 四次挥手的原因：TCP 连接是全双工通信，数据在两个方向上可以独立传输，需要分别关闭。

四次挥手的过程：

主动方                被动方
  |------- FIN ------>|
  |                   |
  |<------ ACK -------|
  |                   |
  |                   |（被动方可能仍有数据要发送）
  |<------ FIN -------|
  |                   |
  |------- ACK ------>|

第一次挥手：主动关闭方发出 FIN，表示我方数据发送完毕。
第二次挥手：被动方发送 ACK，确认收到对方的关闭请求，但此时被动方可能还有数据未发送完。
第三次挥手：被动方发完数据后再发送 FIN，通知主动方自己数据也发送完毕。
第四次挥手：主动方再发送 ACK，确认收到被动方的关闭请求。

13. 在浏览器中访问一个 http 服务器，这里面会经过哪些协议？

快手一面

当你在浏览器里输入一个 http://... 地址访问服务器时，整个过程会涉及到一系列分层的协议，每一层负责不同的功能。整体遵循的是 TCP/IP 协议栈，从应用层到物理层逐层完成通信。可以这样理解：

在最顶层，浏览器使用 HTTP 协议 发出请求。HTTP 是应用层协议，规定了请求报文和响应报文的格式，例如 GET /index.html HTTP/1.1。如果用的是 HTTPS，那么在 HTTP 之前会先进行 TLS/SSL 握手，加密后才传输数据。
HTTP 请求需要依赖 TCP 协议 提供可靠的字节流传输。浏览器和服务器之间首先通过三次握手建立 TCP 连接，之后 HTTP 报文就会作为 TCP 的数据部分发送。TCP 协议保证了数据的有序性和完整性，丢包时会自动重传。
TCP 连接又要通过 IP 协议 来实现跨主机的数据包传递。IP 协议定义了地址和路由机制，确保数据从浏览器所在的主机能够正确送达目标服务器的 IP 地址。如果访问的是一个域名，浏览器会先用 DNS 协议 把域名解析成 IP 地址，这一步也是不可或缺的。
在链路上传输时，IP 报文会被封装在 以太网协议（或 Wi-Fi 协议） 的帧里，通过物理层的比特流传输。为了更高效地在局域网找到目标设备，还会用到 ARP 协议 来把 IP 地址解析为 MAC 地址。

所以整体过程是：

DNS：把域名解析为服务器 IP。
ARP（如果需要）：在局域网内解析 IP 到 MAC。
TCP：通过三次握手建立连接。
HTTP：浏览器发出请求，服务器返回响应。
IP/以太网/物理层：底层负责把数据包真正送到服务器。

如果是 https://，还要加上 TLS/SSL 层，建立加密通道后才开始传输 HTTP 数据。

14. 为什么不直接用 tcp 协议，还需要用 http 协议？

快手一面

这是个非常经典的问题。我们完全可以用 TCP 在两台机器之间收发字节流，但光靠 TCP，还缺少很多“应用层语义”。HTTP 就是为了解决这些问题而存在的。

首先，TCP 只是传输层协议。它提供的功能是：建立可靠的、双向的字节流通道，保证数据顺序不乱、不丢、不重。它并不知道字节流里是什么内容，也没有规定数据要如何划分、如何解释。你完全可以在 TCP 上自己定义一套格式来交流，但如果没有标准，不同的应用之间就无法互通。

HTTP 是应用层协议，它定义了浏览器和服务器之间通信的统一格式。比如：

如何表示“我要获取某个资源”（GET 请求）；
如何附带参数、发送表单或文件（POST 请求）；
如何在请求头里写出数据类型、压缩方式、认证信息（Header）；
如何让服务器告诉客户端返回的状态（200 OK、404 Not Found）。

有了这些约定，不同厂商的浏览器、服务器都能在一个共同的语义上交流，而不仅仅是传输字节。

如果我们直接用 TCP，理论上也能实现浏览器和服务器交互，但必须自己再设计一整套协议，比如：如何表示一个请求的开始和结束，怎么传递参数，怎么返回错误码，怎么处理长连接。这些 HTTP 已经帮我们定义好了，相当于是建立在 TCP 之上的一个通用“语言”。

再进一步看，HTTP 还解决了 扩展性和兼容性 的问题。随着需求变化，它不断引入新特性：从 HTTP/1.0 的简单请求，到 HTTP/1.1 的持久连接、管道化，再到 HTTP/2 的多路复用、头部压缩，HTTP/3 甚至换到了 QUIC（基于 UDP）。如果只用裸 TCP，这些机制都需要自己重新造轮子。

15. 如何查看 HTTP 丢包的情况？

HTTP 基于 TCP，因此 HTTP 丢包实质是网络层或传输层的问题。排查步骤如下：

使用 ping 命令：检测到目标服务器的基本连通性和网络延迟，看是否有包丢失（packet loss）
使用 traceroute（Windows 是 tracert）：追踪数据包经过的路径，定位在哪个网络节点出现丢包或高延迟
使用 curl -v 或 wget：详细输出 HTTP 请求/响应过程，观察连接建立、SSL握手、数据传输各阶段是否超时或失败
专业工具：使用 tcpdump 抓包，然后用 Wireshark 分析，可以精确看到 TCP 重传（Retransmission），这是判断丢包的最直接证据

16. GET 请求和 POST 请求二者有什么区别？分别什么场景下使用？

根本区别：

GET 是幂等的（多次执行效果相同）且安全的（不修改服务器数据），主要设计用于获取资源。
POST 是非幂等的，主要设计用于提交数据并可能修改服务器状态。

具体差异：

参数位置：GET 参数在 URL 查询字符串中，POST 在请求体内。
安全性：GET 参数暴露在 URL 和浏览器历史中，不适合传敏感信息。
数据长度：GET 受 URL 长度限制（通常2KB-8KB），POST 可传输更大数据。
缓存与书签：GET 可被缓存、可收藏为书签，POST 一般不会。

使用场景：

GET 用于搜索、筛选、跳转页面等获取数据的操作。
POST 用于登录、注册、下单、支付等修改数据的操作。

17. 在淘宝下浏览，cookie 是在淘宝域这边，那如果从淘宝跳到支付宝，怎么处理中间这些过程呢？

非常好、非常核心的一个问题！这个问题涉及到单点登录（SSO, Single Sign-On）的核心流程。下面我以一个清晰、分步骤的方式为你解释整个处理过程。

核心问题：为什么淘宝的Cookie不能直接用于支付宝？

简单回答：浏览器基于安全原因实施的“同源策略”（Same-origin policy）。

淘宝的域名可能是 taobao.com。
支付宝的域名是 alipay.com。

它们的域名不同，因此浏览器在向支付宝的服务器发送请求时，绝不会携带淘宝域名下的Cookie。这是至关重要的安全机制，防止恶意网站窃取你在其他网站的登录状态。

解决方案：基于信任的“授权”流程

既然Cookie不能共享，淘宝就需要用一种“信物”告诉支付宝：“这个用户是我这儿来的，他已经在我这儿登录了，你也要让他登录。” 这个流程的核心是令牌（Token） 的传递和验证。

整个过程可以概括为以下几个关键步骤：

第1步：用户点击支付，发起跳转

用户在淘宝选好商品，点击“付款”按钮。此时，淘宝后端会生成一个临时的、一次性的令牌，我们通常称之为 授权码（Auth Code）。然后，淘宝会将用户浏览器重定向到支付宝的登录/授权页面。

跳转的URL看起来会像这样： https://auth.alipay.com/authorize?client_id=淘宝在支付宝注册的ID&redirect_uri=淘宝的回调地址&state=一个随机字符串（防CSRF攻击）&auth_code=刚刚生成的临时令牌

关键点： 这个 auth_code 就是淘宝给支付宝的“介绍信”。

第2步：浏览器跳转到支付宝

用户的浏览器根据上一步的URL，跳转到了支付宝的域名下。此时，浏览器会携带支付宝自己的Cookie（如果用户之前登录过支付宝且Cookie未过期，那么他已经是登录状态）。

第3步：支付宝验证授权码

支付宝的服务器接收到这个请求后，会做几件事：

验证用户登录状态：检查浏览器请求中携带的支付宝Cookie。如果用户已登录，支付宝就知道当前用户是谁。如果未登录，会先引导用户输入账号密码登录。
联系淘宝进行验证：支付宝的服务器会在后台（服务器到服务器），通过一个安全的API接口，联系淘宝的服务器。它会说：“我收到了一个授权码 auth_code=xxx，请问这个码是有效的吗？它对应的是哪个用户？”

第4步：淘宝确认授权码有效性

淘宝的服务器在后台收到支付宝的查询请求后，会：

验证这个 auth_code 是否是自己刚生成的、是否在有效期内、是否已经被使用过。
如果一切有效，淘宝会告诉支付宝：“这个码有效，它对应的用户ID是 TB123456。”

关键点： 这个服务器对服务器的通信是绝对安全的，因为它们之间有预先约定好的身份验证方式（例如使用App Secret），避免了中间人伪造请求。

第5步：支付宝建立本地会话并重定向回淘宝

支付宝确认了用户身份后：

在自己的系统中，为这个用户（TB123456对应的支付宝用户）创建一个支付宝域的登录会话（Session），并生成一个支付宝的令牌（比如叫 alipay_token）。
通常，它会通过Set-Cookie头部，将这个会话信息设置为支付宝域名下的Cookie。
然后，支付宝将浏览器重定向回第一步中 redirect_uri 指定的淘宝回调地址，并附上成功的信号和这个 alipay_token。

回跳的URL像这样： https://www.taobao.com/callback?from=alipay&result=success&alipay_token=支付宝生成的令牌

第6步：淘宝确认最终状态，完成支付流程

用户的浏览器跳回淘宝的页面。

淘宝的后端收到 alipay_token 后，会再次在后台向支付宝验证这个令牌的有效性（同样是安全的服务器间通信）。
验证通过后，淘宝就知道：“好了，用户已经在支付宝那边登录成功了，支付环节可以继续了。”
随后，淘宝会展示支付页面，用户输入密码完成支付。

技术总结与关键点

核心思想： 通过浏览器重定向传递一次性临时令牌（Auth Code），再通过后端服务器之间的安全通信来验证用户真实身份，最终在目标网站（支付宝）上建立独立的本地会话。

这种模式是OAuth 2.0等标准授权协议的精髓。对于用户来说，如果他已经登录了支付宝，整个过程几乎是无感的，点击“付款”后直接就到了支付界面，实现了流畅的单点登录体验。

18. TCP 为什么“四次挥手”，三次不行？

关键点：TCP 全双工，两条方向独立关闭。

步骤：A 发 FIN → B 回 ACK（A→B 方向关闭）；B 还有数据要发，等发完再发 FIN → A 回 ACK。
若“三次”把 B 的 ACK 和 FIN 合并，无法覆盖“半关闭继续发送”的常见场景（B 可能还有尾包）。
TIME_WAIT（最后 ACK 的一方进入）：防止旧包影响后续连接，确保对端能重传 FIN 时仍可应答。

八股文 @ 场景题

Sat, 23 Aug 2025 00:00:00 GMT

记录高频场景题，部分内容自行搜索

快排存在的问题，如何优化？

3 种快排基准选择方法：

随机（rand 函数）
固定（队首、队尾）
三数取中（队首、队中和队尾的中间数）

4 种优化方式：

优化 1：当待排序序列的长度分割到一定大小后，使用插入排序
优化 2：在一次分割结束后，可以把与 key 相等的元素聚在一起，继续下次分割时，不用再对与 key 相等元素分割
优化 3：优化递归操作
优化 4：使用并行或多线程处理子序列

写三个线程交替打印 ABC

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
int turn = 0;

void print(char c, int id) {
    for (int i = 0; i < 5; i++) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [id] { return turn == id; });
        std::cout << c;
        turn = (turn + 1) % 3;
        cv.notify_all();
    }
}

int main() {
    std::thread A(print, 'A', 0);
    std::thread B(print, 'B', 1);
    std::thread C(print, 'C', 2);
    
    A.join(); B.join(); C.join();
    std::cout << std::endl;
    return 0;
}

不使用临时变量实现 swap 函数

void swap_xor(int a, int b) {
    a ^= b;
    b ^= a;
    a ^= b;
}

✍️ Top K 问题（可以采取的方法有哪些，各自优点）

...

✍️ 8G 的 int 型数据，计算机的内存只有 2G，怎么对它进行排序？

...

✍️ 手撕线程安全的单例模式

...

手撕 shared_ptr（线程安全）

非线程安全的简单实现

#include <memory>

template<typename T>
class smartPtr {
private:
    T *_ptr;
    size_t* _count;

public:
    smartPtr(T *ptr = nullptr):_ptr(ptr) {
        if (_ptr) {
            _count = new size_t(1);
        } else {
            _count = new size_t(0);
        }
    }

    smartPtr(const smartPtr &ptr) {
        if (this != &ptr) {
            this->_ptr = ptr._ptr;
            this->_count = ptr._count;
            ++(*this->_count)   ;
        }
    }

    smartPtr& operator=(const smartPtr &ptr) {
        if (this->_ptr == ptr._ptr)
            return *this;

        if (this->_ptr) {
            --(*this->_count);
            if (this->_count == 0) {
                delete this->_ptr;
                delete this->_count;
            }
        }

        this->_ptr = ptr._ptr;
        this->_count = ptr._count;
        ++(*this->_count);

        return *this;
    }

    ~smartPtr() {
        --(*this->_count);
        if (0 == *this->_count) {
            delete this->_ptr;
            delete this->_count;
        }
    }

    size_t use_count() {
        return *this->_count;
    }

    T& operator*() {
        assert(this->_ptr == nullptr);
        return *(this->_ptr);
    }

    T* operator->() {
        assert(this->_ptr == nullptr);
        return this->_ptr;
    }
};

基于原子操作的线程安全实现

#pragma once

#include <atomic>  // 引入原子操作

template <typename T>
class shared_ptr {
private:
  T* ptr;                               // 指向管理的对象
  std::atomic<std::size_t>* ref_count;  // 原子引用计数

  // 释放资源
  void release() {
    // P.S. 这里使用 std::memory_order_acq_rel 内存序，保证释放资源的同步
    if (ref_count && ref_count->fetch_sub(1, std::memory_order_acq_rel) == 1) {
      delete ptr;
      delete ref_count;
    }
  }

public:
  // 默认构造函数
  shared_ptr() : ptr(nullptr), ref_count(nullptr) {}

  // 构造函数
  // P.S. 这里使用 explicit 关键字，防止隐式类型转换
  // shared_ptr<int> ptr1 = new int(10);  不允许出现
  explicit shared_ptr(T* p) : ptr(p), ref_count(p ? new std::atomic<std::size_t>(1) : nullptr) {}

  // 析构函数
  ~shared_ptr() { release(); }

  // 拷贝构造函数
  shared_ptr(const shared_ptr<T>& other) : ptr(other.ptr), ref_count(other.ref_count) {
    if (ref_count) {
      ref_count->fetch_add(1, std::memory_order_relaxed);  // 引用计数增加，不需要强内存序
    }
  }

  // 拷贝赋值运算符
  shared_ptr<T>& operator=(const shared_ptr<T>& other) {
    if (this != &other) {
      release();  // 释放当前资源
      ptr = other.ptr;
      ref_count = other.ref_count;
      if (ref_count) {
        ref_count->fetch_add(1, std::memory_order_relaxed);  // 引用计数增加
      }
    }
    return *this;
  }

  // 移动构造函数
  // P.S. noexcept 关键字表示该函数不会抛出异常。
  // 标准库中的某些操作（如 std::swap）要求移动操作是 noexcept 的，以确保异常安全。
  // noexcept 可以帮助编译器生成更高效的代码，因为它不需要为异常处理生成额外的代码。
  shared_ptr(shared_ptr<T>&& other) noexcept : ptr(other.ptr), ref_count(other.ref_count) {
    other.ptr = nullptr;
    other.ref_count = nullptr;
  }

  // 移动赋值运算符
  shared_ptr<T>& operator=(shared_ptr<T>&& other) noexcept {
    if (this != &other) {
      release();  // 释放当前资源
      ptr = other.ptr;
      ref_count = other.ref_count;
      other.ptr = nullptr;
      other.ref_count = nullptr;
    }
    return *this;
  }

  // 解引用运算符
  // P.S. const 关键字表示该函数不会修改对象的状态。
  T& operator*() const { return *ptr; }

  // 箭头运算符
  T* operator->() const { return ptr; }

  // 获取引用计数
  std::size_t use_count() const { return ref_count ? ref_count->load(std::memory_order_acquire) : 0; }

  // 获取原始指针
  T* get() const { return ptr; }

  // 重置指针
  void reset(T* p = nullptr) {
    release();
    ptr = p;
    ref_count = p ? new std::atomic<std::size_t>(1) : nullptr;
  }
};

✍️ 手撕线程池

...

✍️ 手撕 string

...

✍️ 手撕 ringbuffer

...

✍️ 实现一个线程安全的带过期时间的 FIFO Cache

...

✍️ 实现一个线程安全的带过期时间的 LRU

...

✍️ 一致性哈希

...

✍️ 海量数据的 bitmap 使用原理

...

✍️ 布隆过滤器原理与优点

...

高并发情况下对 LRU 的优化方案

痛点

全局锁/链表热点：经典 LRU 的 head/tail 在高并发下极易形成热点。

每次访问都要“提到头”：更新双向链表成本高，频繁 CAS/锁冲突。

淘汰路径阻塞读写：命中/写入与淘汰耦合，尾部扫描占用临界区。

冷热抖动/缓存污染：短瞬热键把冷数据顶走。

优化思路（从易到难逐级上车）

1) 分片化 + 本地 LRU

做法：按 key 的 hash 做分片（shard），每片一个独立 LRU（或近似 LRU），容量按权重均分或动态调。
锁策略：每片用细粒度锁/读写锁；读命中尽量无锁，写与晋升仅锁所在分片。
优点：消除全局热点，线性提升吞吐；工程复杂度低。
要点：分片数 ≈ 2–4×CPU 核数；用 striped LongAdder 做指标计数，减少原子热点。

2) 近似 LRU，降低更新成本

CLOCK/CLOCK-Pro：用环形指针+访问位替代双向链表，晋升成本 O(1)，冲突小。
2Q/SLRU：新到/短热进 A 队列；稳定热留在 B 队列（或 Probation/Protected），抑制一次性流量污染。
优点：命中率接近 LRU，且更抗“瞬时热键”；实现简单，晋升轻。

3) Admission + TinyLFU（高命中率方案，参考 Caffeine 思路）

做法：把淘汰决策拆成两步：
1. Admission：用 Count-Min Sketch 统计最近频次，只有当新键的估计频次 ≥ 牺牲者时才接纳（W-TinyLFU）。
2. 分层缓存：Window（短热）+ Protected（稳定热）+ Probation（候选）三层滑动窗口。
优点：在长尾流量、穿透流量下显著提高命中率；减少无效写入。
代价：实现复杂一点，需要周期性衰减 Sketch。

4) 访问路径“无锁化”，把晋升/淘汰异步化

核心手法：
- 读路径只做 O(1) 查表（ConcurrentHashMap/lock-free map），把“命中事件”写入每分片的 MPSC ring buffer。
- 独立 单线程维护者（per-shard maintainer） 从队列批量消费事件，顺序更新近似 LRU 的元数据与淘汰。
效果：读路径彻底避开链表/锁；写放大被批处理吸收，减少抖动。
实现提示：
- ring buffer 长度按峰值 QPS×延迟上限估算；丢弃策略用 coalesce（只保留最近一次命中标记）。
- 淘汰与值回收放在维护线程，避免在读线程做内存管理。

5) 批量淘汰 & 背景回收

做法：容量接近阈值时，维护线程一次淘汰 N 个（例如 1–2% 容量）而不是逐个淘汰。
好处：减少频繁进入临界区；尾部扫描可顺序内存访问，CPU 友好。

6) 多级/多层缓存

本地 L1（进程内） + 远端 L2（Redis/MC）：L1 用近似 LRU + Admission，L2 用简单 LRU/TTL。
跨核/跨机：本地每核分片 + 机内共享 L2，减少跨 NUMA 抖动。
跨机一致性：允许短暂不一致，配合 stale-while-revalidate。

7) 数据结构与内存优化

索引：map 索引 + 紧凑元数据（指针压缩、索引 offset）；避免频繁分配（对象池/arena/slab）。
计数器：热点计数用 LongAdder/striped；Sketch 用 uint32 环形衰减。
Java 场景：尽量 off-heap 存元数据/大 value；避免大对象导致频繁 GC。
回收：RCU/epoch-based 回收，减少停顿；避免 ABA 可用带版本的指针或 tag。

8) 防击穿/雪崩/穿透的配套

singleflight：同 key 的 miss 合并成一次回源。
自适应 TTL + 负缓存：短暂缓存“未命中/404”，降低穿透。
退避/限流：上游慢时降低 admission、缩短 window；必要时降级只读旧值。

高德地图导航网络架构设计

场景题：现在导航功能越来越丰富了，现在对云端的依赖越来越强，在这个背景下，我们有大量的网络业务要去做相关的业务请求，但是我们测试的车在路上跑，他的网络性能带宽相对来说不稳定性会比较强，基于费用的考虑这个整体的流量也是一个需要考虑的事情，所以整体网络上大模块的设计要考虑几个因素：

第一个就是并发量的问题，如果并发量过大，性能负载非常高，但是车机系统给我们导航的性能负载是有限的，所以会存在瓶颈的问题

第二个就是网络的好坏差异也会影响成功率

第三个就是我们有那么多的业务去做变化，然后流量这方面也是一个负担，那如何去进一步降低流量这方面的消耗

基于以上几点，你要怎么去设计一个网络并发请求管理的模块，使得整体达到一个符合业务需要的效果，你会从几个方面进行切入设计呢？

好的，这是一个非常经典且实际的工程问题。结合您提出的车载导航系统场景，我将从一个资深架构师的角度，系统地阐述如何设计这样一个网络并发请求管理模块。

这个设计的核心目标是：在有限的车机资源和不稳定的网络环境下，通过智能的请求管理，确保高优先级业务的成功率和实时性，同时最大限度地降低流量消耗和系统负载。

我们可以从以下几个核心方面进行切入设计：

一、核心架构：分层与队列管理

首先，模块不应该让业务方直接发起请求，而应该通过一个中心化的管理器。这使我们能够实施统一的策略。

1. 请求池/队列管理器

分级队列：将业务请求按照优先级进行分类。例如：
- 实时关键队列： 路线计算、交通事件、实时路况更新。这些请求必须低延迟、高成功率。
- 普通队列： 沿途搜索、地址详情查询。可以容忍一定延迟。
- 批量/延迟队列： 地图瓦片预加载、日志上报、非关键数据同步。可以等待网络良好时批量发送。
并发控制器：设置一个全局的并发请求数上限（例如，根据车机性能定为 4-6 个）。管理器从高优先级队列中取出请求执行，只有当高优先级队列为空时，才处理低优先级队列。这直接解决了并发量过大导致的性能瓶颈问题。

2. 智能调度器：调度器是大脑，它根据当前系统状态决定何时发送何请求。

网络状态感知： 模块需要实时监听网络类型（5G/4G/Wi-Fi）和信号强度。可以定义几个状态：EXCELLENT, GOOD, POOR, DISCONNECTED。
动态策略调整：
- 网络 GOOD 以上：正常处理所有队列。
- 网络 POOR：自动降级。例如，只发送实时关键队列的请求；降低实时路况更新的频率；暂停批量队列。
- 网络 DISCONNECTED：缓存所有可缓存的请求，并提示用户。

二、流量优化：减少不必要的数据传输

这是降低流量负担的关键。

1. 请求去重与合并

去重： 在短时间内，如果有多个完全相同的请求（例如，同一路段的实时路况），只发送一个，返回的结果共享给所有请求者。
合并： 对于批量队列中的小请求（例如，多个POI的详情查询），可以将它们在客户端打包成一个批量请求发送到云端，云端处理后返回一个合并的响应。这大大减少了HTTP头等冗余数据的传输。

2. 数据压缩与差分更新

压缩： 请求和响应体都使用高效的压缩算法（如 GZIP, Brotli）。
差分更新： 这是流量优化的“大杀器”。
- 原理： 客户端本地缓存已有数据（如旧版地图数据、之前的路线信息）。当需要更新时，客户端将当前数据的版本号或哈希值发给服务端。
- 服务端： 计算新旧数据之间的“差异”（Delta），只将这个很小的差异包返回给客户端。
- 客户端： 根据差异包和本地数据，合成最新数据。
- 应用场景： 路线变更、地图增量更新、交通信息流。这能减少高达90%的流量。

3. 缓存策略

多级缓存： 实现内存缓存 + 磁盘缓存。
- 对于静态或半静态数据（如地图瓦片、城市基础信息），设置很长的过期时间。
- 对于动态数据（如实时路况），设置较短的过期时间（如30秒）。在过期时间内，直接使用缓存，不发请求。
缓存有效性： 通过服务端返回的 ETag 或 Last-Modified 头，在请求时进行验证，如果数据未变，则返回304 Not Modified，节省响应体流量。

三、容错与稳定性：提升弱网下的成功率

1. 重试与退避机制

智能重试： 不是所有失败都重试。仅对网络错误、5xx服务器错误等进行重试，而对4xx客户端错误则不重试。
指数退避： 重试的时间间隔逐渐延长（如1s, 2s, 4s, 8s...），避免在服务器临时故障时加剧其压力。
优先级关联： 高优先级请求的重试次数可以更多，间隔更短；低优先级请求则相反。

2. 请求超时与熔断

动态超时： 根据网络状况和请求优先级设置不同的超时时间。弱网环境下，适当延长超时时间。
熔断器模式：
- 当某个服务端接口失败率超过阈值时，熔断器会“跳闸”。
- 在接下来的一段时间内，所有对该接口的请求会立即失败，而不再真正发出网络请求。
- 经过一个冷却时间后，熔断器进入“半开”状态，试探性地放一个请求过去，如果成功则关闭熔断器，恢复流量。
- 作用： 防止因某个后端服务故障而导致客户端资源（线程、连接）被耗尽和流量浪费。

八股文 @ 操作系统

Sat, 23 Aug 2025 00:00:00 GMT

1. 进程、线程、协程的区别？

进程提供强隔离但开销大，线程平衡了资源共享和调度效率，协程则以极低开销实现高并发但局限于单线程内。

实际应用中可根据任务需求（计算密集型 vs. I/O 密集型）、隔离性要求和性能目标选择合适机制。

进程

进程是操作系统进行资源分配和保护的基本单位。

每个进程拥有独立的虚拟地址空间、文件描述符、系统资源（如打开的文件和信号处理程序）以及安全上下文（例如用户 ID 和权限）。

进程之间的内存空间是隔离的，一个进程的崩溃通常不会直接影响其他进程，这种隔离性提高了系统的稳定性和安全性。

进程间的通信（IPC）需要借助操作系统提供的机制，如管道、消息队列、共享内存或套接字，这些方式通常涉及较高的开销。

进程的创建和销毁需要分配或回收大量资源（如页表和文件描述符表），上下文切换时需保存和恢复完整的 CPU 状态（包括寄存器、内存映射等），因此效率较低。

🔥【场景】进程适用于需要强隔离性的任务，例如运行独立的应用程序或服务。

线程

线程是进程内的执行单元，一个进程可以包含多个线程。

所有线程共享同一进程的地址空间和系统资源（如全局变量、打开的文件和堆内存），但每个线程拥有独立的栈空间、寄存器状态和线程局部存储。

由于共享内存，线程间可以直接读写同一数据，但这也引入了竞态条件和数据一致性问题，因此必须使用同步机制（如互斥锁、信号量或条件变量）来协调访问。

线程的创建和上下文切换由操作系统内核调度器管理，切换时只需保存和恢复线程独有的状态（如栈指针和寄存器），开销比进程小，但仍需在用户态和内核态之间切换。

🔥【场景】线程适合用于需要共享数据的并发任务，例如图形界面应用中的后台计算或 I/O 操作。

协程

协程是一种用户态的轻量级线程，其调度完全由程序控制（而非操作系统内核）。

协程在同一个线程内执行，共享该线程的所有资源，但拥有独立的栈上下文（通常大小可自定义且远小于线程栈）。

协程的切换无需陷入内核，而是通过代码中的显式让步（yield）或事件循环来触发，仅需保存和恢复少量寄存器状态（如程序计数器和栈指针），因此开销极低，每秒可支持百万次切换。

然而，协程无法利用多核 CPU 的并行能力，若需跨核执行仍需结合多线程或多进程。

🔥【场景】协程适用于高并发的 I/O 密集型任务（如网络服务或异步编程），通过非阻塞操作和协作式调度最大化 CPU 利用率。

2. 进程通信的方式是什么？

进程间通信（IPC）用于在不同进程之间传递数据和信号，常见的 IPC 方式包括：

管道（匿名/命名）
消息队列
共享内存
信号量
信号
Socket 套接字

匿名管道是一种半双工的通信方式，数据只能单向流动，通常用于具有亲缘关系的进程之间，例如父子进程。它可以看成是一种特殊的文件，但只存在于内存中。

命名管道与管道类似，但它提供了一个路径名与之关联，允许无亲缘关系的进程之间进行通信。

消息队列是消息的链表，存放在内核中并由消息队列标识符标识。它允许一个或多个进程向队列中写入消息，其他进程从队列中读取消息，克服了管道只能承载无格式字节流以及缓冲区大小受限等缺点。

共享内存允许多个进程访问同一块内存空间，这是最快的一种进程通信方式，因为数据不需要在进程之间复制。但需要配合信号量等同步机制来避免多个进程同时读写时造成的冲突。

信号量是一个计数器，用于控制多个进程对共享资源的访问，通常作为一种锁机制来防止多个进程同时访问一个共享资源。

信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生，比如中断处理。

套接字是一种通用的进程间通信机制，不仅可用于同一台机器上的进程通信，也可用于不同机器之间的网络通信。它支持多种协议，如 TCP 和 UDP，提供了灵活而强大的通信能力。

3. 线程通信/同步的方式是什么？

Linux 系统提供了五种用于线程通信的方式：互斥锁、读写锁、条件变量、自旋锁和信号量。

互斥锁（Mutex）：互斥量从本质上说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁以后，任何其他试图再次对互斥锁加锁的线程将会阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为运行状态的线程可以对互斥锁加锁，其他线程将会看到互斥锁依然被锁住，只能回去再次等待它重新变为可用。
条件变量（Condition Variables）：条件变量是在多线程程序中用来实现 "等待-->唤醒" 逻辑常用的方法。条件变量利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使“条件成立”。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。线程在改变条件状态前必须首先锁住互斥量，函数 pthread_cond_wait 把自己放到等待条件的线程列表上，然后对互斥锁解锁（这两个操作是原子操作）。在函数返回时，互斥量再次被锁住。
自旋锁（Spinlock）：自旋锁通过 CPU 提供的 CAS 函数（Compare And Swap），在「用户态」完成加锁和解锁操作，不会主动产生线程上下文切换，所以相比互斥锁来说，会快一些，开销也小一些。一般加锁的过程，包含两个步骤：第一步，查看锁的状态，如果锁是空闲的，则执行第二步；第二步，将锁设置为当前线程持有。使用自旋锁的时候，当发生多线程竞争锁的情况，加锁失败的线程会「忙等待」，直到它拿到锁。CAS 函数就把这两个步骤合并成一条硬件级指令，形成原子指令，这样就保证了这两个步骤是不可分割的，要么一次性执行完两个步骤，要么两个步骤都不执行。这里的「忙等待」可以用 while 循环等待实现，不过最好是使用 CPU 提供的 PAUSE 指令来实现「忙等待」，因为可以减少循环等待时的耗电量。
信号量（Semaphores）：信号量可以是命名的（有名信号量）或无名的（仅限于当前进程内的线程），用于控制对资源的访问次数。通常信号量表示资源的数量，对应的变量是一个整型（sem）变量。另外，还有两个原子操作的系统调用函数来控制信号量的，分别是：P 操作：将 sem 减 1，相减后，如果 sem < 0，则进程/线程进入阻塞等待，否则继续，表明 P 操作可能会阻塞；V 操作：将 sem 加 1，相加后，如果 sem ≤ 0，唤醒一个等待中的进程/线程，表明 V 操作不会阻塞；
读写锁（Read-Write Locks）：读写锁从字面意思我们也可以知道，它由「读锁」和「写锁」两部分构成，如果只读取共享资源用「读锁」加锁，如果要修改共享资源则用「写锁」加锁。所以，读写锁适用于能明确区分读操作和写操作的场景。读写锁的工作原理是：当「写锁」没有被线程持有时，多个线程能够并发地持有读锁，这大大提高了共享资源的访问效率，因为「读锁」是用于读取共享资源的场景，所以多个线程同时持有读锁也不会破坏共享资源的数据。但是，一旦「写锁」被线程持有后，读线程的获取读锁的操作会被阻塞，而且其他写线程的获取写锁的操作也会被阻塞。所以说，写锁是独占锁，因为任何时刻只能有一个线程持有写锁，类似互斥锁和自旋锁，而读锁是共享锁，因为读锁可以被多个线程同时持有。知道了读写锁的工作原理后，我们可以发现，读写锁在读多写少的场景，能发挥出优势。
屏障（Barrier）：同步多个线程的执行阶段，所有线程到达屏障点后才继续执行（如 pthread_barrier_wait）。

总结，线程通信方式主要依赖于共享内存下的各种同步原语和消息传递机制，这些机制协同工作保证了线程间数据的正确性和程序的并发性。

4. 进程上下文切换会发生什么？进程上下文切换场景有哪些？

发生进程切换时操作系统会：

保存当前进程上下文：操作系统将当前运行进程的 CPU 状态（包括程序计数器、寄存器内容、栈指针、内存映射表等）保存到其进程控制块（PCB）中。
调度新进程：调度器从就绪队列中选择下一个要运行的进程，并加载其 PCB 中存储的上下文信息。
恢复新进程上下文：将新进程的寄存器值、程序计数器、栈指针等重新载入 CPU，并切换内存地址空间（更新页表寄存器或 TLB）。
切换内核栈：将内核栈指针指向新进程的内核栈，确保系统调用和中断处理能正确执行。
更新系统状态：刷新进程调度相关数据（如时间戳、优先级），并可能处理信号或待处理中断。

进程上下文切换有哪些场景：

时间片耗尽：当前进程用完调度器分配的时间片（如 CFS 调度器），被迫让出 CPU。
更高优先级进程就绪：高优先级进程进入可运行状态（如实时任务），抢占当前低优先级进程。
主动阻塞：进程因等待资源（如 I/O 操作完成、互斥锁释放、信号量申请）主动放弃 CPU。
中断处理：硬件中断（如磁盘读写完成、网络包到达）触发中断服务程序，可能唤醒其他高优先级进程。
系统调用返回：某些系统调用（如阻塞式 read）返回时，内核可能调度其他进程。
异常事件：进程触发异常（如缺页故障），需等待操作系统处理完毕后再恢复执行。

5. 平时会看哪些系统指标？

常看这些核心系统指标：

CPU 相关指标：CPU 使用率（包括用户态、内核态、空闲时间）、负载平均值（load average）反映系统整体负载压力，上下文切换次数（context switches）和中断频率（interrupts）可帮助判断调度开销和硬件活动。
内存相关指标：内存使用率、可用内存（available memory）、交换分区使用情况（swap usage）以及页错误率（page faults）和内存换入/换出（swap in/out）能揭示内存压力与潜在瓶颈。
磁盘 I/O 指标：磁盘利用率、读写吞吐量（throughput）、IOPS（每秒 I/O 操作数）以及响应时间（latency）和队列深度（queue depth）可用于评估存储性能是否达标。
网络相关指标：网络接口的带宽使用率、数据包发送/接收速率、错误包和丢包率（packet loss）、TCP 连接数及重传率能反映网络连通质量和负载。
进程与线程指标：运行中进程数量、线程数量、僵尸进程（zombie processes）以及关键进程的 CPU 和内存占用情况。
系统整体指标：启动时间、系统调用频率（system calls）、文件描述符使用量（file descriptors）以及温度与电源状态（适用于物理机）。

可通过 top、vmstat、iostat、netstat、dstat、htop、pidstat、sar 等工具查看。

6. CPU 中断数量怎么看？如果 CPU 中断数量分配不均匀怎么办？

一、如何查看中断数量？

cat /proc/interrupts

每一行是一个中断源（如网卡、定时器、磁盘等）
每列是一个 CPU 核心
数字表示该中断在某 CPU 上被处理的次数

二、什么是“中断不均匀”？

某个中断（特别是网卡）集中在某个 CPU 上处理
导致该核负载高、其他核闲置
常见于 网卡中断（eth0）偏向 CPU 0

三、怎么解决中断不均匀？

一句话：可以绑中断到线程还是进程，然后再绑核。

方法一：中断绑定（IRQ Affinity）

绑定中断到特定 CPU 核，或进行负载均衡：

echo 2 > /proc/irq/XX/smp_affinity  # 绑定到 CPU1

2 表示 CPU1，1 表示 CPU0，3 表示 CPU0+CPU1（按位）

可以用脚本自动平衡多个中断源到多个核上。

方法二：使用 RPS / RFS（软中断调度）

RPS：Receive Packet Steering，用于软中断在多核间分散
配置 /sys/class/net/eth0/queues/rx-*/rps_cpus 指定核

方法三：开启多队列网卡（RSS）

RSS（Receive Side Scaling）：硬件级多队列分发中断
需网卡和驱动支持，查看：

ethtool -l eth0    # 查看队列
ethtool -x eth0    # 查看中断队列分配

CPU 中断不均衡会导致某核过载，通过 IRQ 绑定、RPS/RFS、RSS 技术可将中断负载均衡到多个 CPU，提高性能。

7. 用户态和内核态的区别？

内核态和用户态是操作系统中的两种运行模式。它们的主要区别在于权限和可执行的操作：

在用户态下，进程仅能执行非特权指令，无法直接访问硬件设备或敏感的内核资源（如内存管理单元、I/O 端口），若需执行特权操作（如文件读写、网络通信）必须通过系统调用接口向内核发起请求，由内核代理完成。这种模式限制了用户程序的行为，防止其意外破坏系统或其他进程。
在内核态下，代码可执行所有CPU指令（包括特权指令），直接操作硬件资源（如内存分配、设备驱动管理），并完全控制系统关键数据结构（如进程调度表、文件系统缓存）。操作系统内核及部分底层驱动运行于此模式，确保核心任务的完整性和高效性。

内核态的底层操作主要包括：内存管理、进程管理、设备驱动程序控制、系统调用等。这些操作涉及到操作系统的核心功能，需要较高的权限来执行。

两种模式的切换通过硬件陷阱机制（如软中断、系统调用）触发：当用户程序发起系统调用时，CPU 自动从用户态切换到内核态，内核完成请求后返回结果并切换回用户态。这种设计既隔离了用户程序的错误影响，又保证了系统服务的可控提供。

分为内核态和用户态的原因主要有以下几点：

安全性：通过对权限的划分，用户程序无法直接访问硬件资源，从而避免了恶意程序对系统资源的破坏。
稳定性：用户态程序出现问题时，不会影响到整个系统，避免了程序故障导致系统崩溃的风险。
隔离性：内核态和用户态的划分使得操作系统内核与用户程序之间有了明确的边界，有利于系统的模块化和维护。

8. 你说到进程是分配资源的基本单位，那么这个资源指的是什么？

虚拟内存、CPU 时间片、文件句柄、信号量等资源。

9. 进程切换和线程切换的区别？

进程切换涉及完整的上下文切换，包括保存和恢复进程的私有资源，如虚拟内存地址空间（需切换页表或刷新 TLB）、寄存器状态、内核栈、文件描述符表以及信号处理设置等。因为进程拥有独立的地址空间，切换后需要更新内存管理单元（MMU）的映射关系，这一操作通常需要较长时间且可能因 TLB 失效导致性能下降。此外，进程切换必然需要从用户态陷入内核态，由操作系统调度器完成。

线程切换则发生在同一进程内部，因此无需切换虚拟地址空间（页表保持不变）、文件描述符表等进程级资源。只需保存和恢复线程的私有上下文，如寄存器值、栈指针以及线程局部存储。由于资源共享，线程切换的开销显著低于进程切换，且在某些情况下（如用户级线程）甚至无需陷入内核，由用户空间的线程库即可完成调度。

10. 进程的五种状态如何切换（进程状态图）？

一个完整的进程状态的变迁如下图：

再来详细说明一下进程的状态变迁：

NULL -> 创建状态：一个新进程被创建时的第一个状态；
创建状态 -> 就绪状态：当进程被创建完成并初始化后，一切就绪准备运行时，变为就绪状态，这个过程是很快的；
就绪态 -> 运行状态：处于就绪状态的进程被操作系统的进程调度器选中后，就分配给 CPU 正式运行该进程；
运行状态 -> 结束状态：当进程已经运行完成或出错时，会被操作系统作结束状态处理；
运行状态 -> 就绪状态：处于运行状态的进程在运行过程中，由于分配给它的运行时间片用完，操作系统会把该进程变为就绪态，接着从就绪态选中另外一个进程运行；
运行状态 -> 阻塞状态：当进程请求某个事件且必须等待时，例如请求 I/O 事件；
阻塞状态 -> 就绪状态：当进程要等待的事件完成时，它从阻塞状态变到就绪状态；

11. 64 bits 的 Linux 默认栈大小？

在 64 位的 Linux 系统上，默认的线程栈大小通常是 8 MB。这个值并不是由内核直接规定的，而是取决于具体的 pthread 线程库的实现（比如 glibc），大多数主流发行版都将其默认设置为 8 MB。

你可以通过命令 ulimit -s 来查看当前 shell 环境下线程栈的默认大小（以 KB 为单位），通常它显示为 8192。需要注意的是，这个 ulimit 设置是针对进程的主线程以及由当前 shell 启动的程序的新线程的默认值，而在程序中通过 pthread_create 创建新线程时，如果不显式指定栈大小，也会默认使用这个 8 MB 的值。

12. 进程调度算法有哪些？

1️⃣ 先来先服务调度算法

最简单的一个调度算法，就是非抢占式的先来先服务算法。每次从就绪队列选择最先进入队列的进程，然后一直运行，直到进程退出或被阻塞，才会继续从队列中选择第一个进程接着运行。这似乎很公平，但是当一个长作业先运行了，那么后面的短作业等待的时间就会很长，不利于短作业。 FCFS 对长作业有利，适用于 CPU 繁忙型作业的系统，而不适用于 I/O 繁忙型作业的系统。

2️⃣ 最短任务优先调度算法

最短作业优先调度算法同样也是顾名思义，它会优先选择运行时间最短的进程来运行，这有助于提高系统的吞吐量。这显然对长作业不利，很容易造成一种极端现象。比如，一个长作业在就绪队列等待运行，而这个就绪队列有非常多的短作业，那么就会使得长作业不断的往后推，周转时间变长，致使长作业长期不会被运行（饥饿）。

3️⃣ 高响应比优先调度算法

前面的「先来先服务调度算法」和「最短作业优先调度算法」都没有很好的权衡短作业和长作业。

而高响应比优先调度算法主要是权衡了短作业和长作业。

每次进行进程调度时，先计算「响应比优先级」，然后把「响应比优先级」最高的进程投入运行，「响应比优先级」的计算公式： $$ 优先权=\frac{等待时间+要求服务时间}{要求服务时间} $$ 从上面的公式，可以发现：

如果两个进程的「等待时间」相同时，「要求的服务时间」越短，「响应比」就越高，这样短作业的进程容易被选中运行；
如果两个进程「要求的服务时间」相同时，「等待时间」越长，「响应比」就越高，这就兼顾到了长作业进程，因为进程的响应比可以随时间等待的增加而提高，当其等待时间足够长时，其响应比便可以升到很高，从而获得运行的机会。

4️⃣ 时间片轮转调度算法

最古老、最简单、最公平且使用最广的算法就是时间片轮转调度算法。

每个进程被分配一个时间段，称为时间片（Quantum)，即允许该进程在该时间段中运行。

如果时间片用完，进程还在运行，那么将会把此进程从 CPU 释放出来，并把 CPU 分配另外一个进程；
如果该进程在时间片结束前阻塞或结束，则 CPU 立即进行切换；

另外，时间片的长度就是一个很关键的点：

如果时间片设得太短会导致过多的进程上下文切换，降低了 CPU 效率；
如果设得太长又可能引起对短作业进程的响应时间变长。

通常时间片设为 20ms~50ms 通常是一个比较合理的折中值。

5️⃣ 最高优先级调度算法

前面的「时间片轮转算法」做了个假设，即让所有的进程同等重要，也不偏袒谁，大家的运行时间都一样。

但是，对于多用户计算机系统就有不同的看法了，它们希望调度是有优先级的，即希望调度程序能从就绪队列中选择最高优先级的进程进行运行，这称为最高优先级调度算法。进程的优先级可以分为，静态优先级或动态优先级：

静态优先级：创建进程时候，就已经确定了优先级了，然后整个运行时间优先级都不会变化；
动态优先级：根据进程的动态变化调整优先级，比如如果进程运行时间增加，则降低其优先级，如果进程等待时间（就绪队列的等待时间）增加，则升高其优先级，也就是随着时间的推移增加等待进程的优先级。

该算法也有两种处理优先级高的方法，非抢占式和抢占式：

非抢占式：当就绪队列中出现优先级高的进程，运行完当前进程，再选择优先级高的进程。
抢占式：当就绪队列中出现优先级高的进程，当前进程挂起，调度优先级高的进程运行。

但是依然有缺点，可能会导致低优先级的进程永远不会运行。

6️⃣ 多级反馈队列调度算法

多级反馈队列调度算法是「时间片轮转算法」和「最高优先级算法」的综合和发展。

顾名思义：

「多级」表示有多个队列，每个队列优先级从高到低，同时优先级越高时间片越短
「反馈」表示如果有新的进程加入优先级高的队列时，立刻停止当前正在运行的进程，转而去运行优先级高的队列

来看看，它是如何工作的：

设置了多个队列，赋予每个队列不同的优先级，每个队列优先级从高到低，同时优先级越高时间片越短；
新的进程会被放入到第一级队列的末尾，按先来先服务的原则排队等待被调度，如果在第一级队列规定的时间片没运行完成，则将其转入到第二级队列的末尾，以此类推，直至完成；
当较高优先级的队列为空，才调度较低优先级的队列中的进程运行。如果进程运行时，有新进程进入较高优先级的队列，则停止当前运行的进程并将其移入到原队列末尾，接着让较高优先级的进程运行；

可以发现，对于短作业可能可以在第一级队列很快被处理完。

对于长作业，如果在第一级队列处理不完，可以移入下次队列等待被执行，虽然等待的时间变长了，但是运行时间也会更长了，所以该算法很好的兼顾了长短作业，同时有较好的响应时间。

13. 除了互斥锁你还知道什么锁？分别应用于什么场景？

还有读写锁、自旋锁、条件变量、信号量。

读写锁：读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。适用于读操作频繁、写操作较少的场景，可以提高并发性能。
自旋锁：自旋锁是一种忙等待锁，线程在获取锁时不会进入阻塞状态，而是循环忙等待直到获取到锁。适用于临界区很小且锁的持有时间很短的场景，避免线程频繁切换带来的开销。
条件变量：条件变量用于线程间的同步和通信。它通常与互斥锁一起使用，线程可以通过条件变量等待某个条件满足，当条件满足时，其他线程可以通过条件变量发送信号通知等待线程。
信号量：信号量是一种计数器，用于控制对共享资源的访问。它可以用来限制同时访问资源的线程数量，或者用语线程间的同步。

14. 死锁发生条件是什么？

死锁只有同时满足以下四个条件才会发生：

互斥条件：互斥条件是指多个线程不能同时使用同一个资源。
持有并等待条件：持有并等待条件是指，当线程 A 已经持有了资源 1，又想申请资源 2，而资源 2 已经被线程 C 持有了，所以线程 A 就会处于等待状态，但是线程 A 在等待资源 2 的同时并不会释放自己已经持有的资源 1。
不可剥夺条件：不可剥夺条件是指，当线程已经持有了资源，在自己使用完之前不能被其他线程获取，线程 B 如果也想使用此资源，则只能在线程 A 使用完并释放后才能获取。
环路等待条件：环路等待条件指的是，在死锁发生的时候，两个线程获取资源的顺序构成了环形链。

15. 如何避免死锁？

避免死锁问题就只需要破环其中一个条件就可以，最常见的并且可行的就是使用资源有序分配法，来破环环路等待条件。

那什么是资源有序分配法呢？线程 A 和线程 B 获取资源的顺序要一样，当线程 A 是先尝试获取资源 A，然后尝试获取资源 B 的时候，线程 B 同样也是先尝试获取资源 A，然后尝试获取资源 B。也就是说，线程 A 和线程 B 总是以相同的顺序申请自己想要的资源。

16. 聊一聊银行家算法

系统发生死锁是很正常的，我们需要主动去预防死锁，即进行有序的资源分配，使用银行家算法。

银行家算法是最有代表性的避免死锁的算法。

为什么叫银行家算法呢？就是这个算法的逻辑很像银行放贷的逻辑，也就是尽可能避免坏账的出现。

银行家算法的业务逻辑如下。

不负荷执行：一个进程的最大需求量不超过系统拥有的总资源数，才会被接纳执行。
可分期：一个进程可以分期请求资源，但总请求书不可超过最大需求量。
推迟分配：当系统现有资源数小于进程需求时，对进程的需求可以延迟分配，但总让进程在有限时间内获取资源。

听起来有点绕，我们还是举个例子来说明：假如系统中有三类互斥资源 R1、R2、R3，可用资源数分别是 9、8、5，在指定时刻有 P1、P2、P3、P4 和 P5 这五个进程，这些进程的对三类互斥资源的最大需求量和已分配资源数如下表所示，那么系统如何先后运行这五个进程，不会发生死锁问题？

| 进程 | 最大需求量（R1、R2、R3） | 已分配资源数（R1、R2、R3） | | ---- | ------------------------ | -------------------------- | | P1 | 6 5 2 | 1 2 1 | | P2 | 2 2 1 | 2 1 1 | | P3 | 8 1 1 | 2 1 0 | | P4 | 1 2 1 | 1 2 0 | | P5 | 3 4 4 | 1 1 3 |

首先分析首次需求的资源，系统剩余可用资源数分别是 2、1、0，各进程需要的资源数如下表所示。

资源 R1 的剩余可用资源数 = 9 - 1 - 2 - 2 - 1 - 1 = 2。
资源 R2 的剩余可用资源数 = 8 - 2 - 1 - 1 - 2 - 1 = 1。
资源 R3 的剩余可用资源数 = 5 - 1 - 1 - 0 - 0 - 3 = 0。

| 进程 | 最大需求量 | 已分配资源数 | 首次分配需要的资源数（前者-后者） | | ---- | ---------- | ------------ | --------------------------------- | | P1 | 6 5 2 | 1 2 1 | 5 3 1 | | P2 | 2 2 1 | 2 1 1 | 0 1 0 | | P3 | 8 1 1 | 2 1 0 | 6 0 1 | | P4 | 1 2 1 | 1 2 0 | 0 0 1 | | P5 | 3 4 4 | 1 1 3 | 2 3 1 |

根据银行家算法不负荷原则【一个进程的最大需求量不超过系统拥有的总资源数，才会被接纳执行】，优先给进程 P2 执行，因为剩余的 0 1 0 资源够让 P2 执行。

经过一系列分析和资源试分配后... 得到安全执行顺序为 p2 => p4 => p5 => p1 => p3 或 p2 => p4 => p5 => p3 => p1。

银行家算法的核心思想，就是在分配给进程资源前，首先判断这个进程的安全性，也就是预执行，判断分配后是否产生死锁现象。如果系统当前资源能满足其执行，则尝试分配，如果不满足则让该进程等待。

通过不断检查剩余可用资源是否满足某个进程的最大需求，如果可以则加入安全序列，并把该进程当前持有的资源回收；不断重复这个过程，看最后能否实现让所有进程都加入安全序列。安全序列一定不会发生死锁，但没有死锁不一定是安全序列。

17. 乐观锁和悲观锁有什么区别？

乐观锁（不加锁、匹配版本号或时间戳、适用读多写少、无锁编程）：

基本思想：乐观锁假设多个事务之间很少发生冲突，因此在读取数据时不会加锁，而是在更新数据时检查数据的版本（如使用版本号或时间戳），如果版本匹配则执行更新操作，否则认为发生了冲突。
使用场景：乐观锁适用于读多写少的场景，可以减少锁的竞争，提高并发性能。例如，数据库中的乐观锁机制可以用于处理并发更新同一行数据的情况。

悲观锁（加锁、适用写多）：

基本思想：悲观锁假设多个事务之间会频繁发生冲突，因此在读取数据时会加锁，防止其他事务对数据进行修改，直到当前事务完成操作后才释放锁。
使用场景：悲观锁适用于写多的场景，通过加锁保证数据的一致性。例如，数据库中的行级锁机制可以用于处理并发更新同一行数据的情况。

乐观锁适用于读多写少的场景，通过版本控制来处理冲突；而悲观锁适用于写多的场景，通过加锁来避免冲突。

互斥锁、自旋锁、读写锁，都是属于悲观锁。

这里举一个场景例子：在线文档。

我们都知道在线文档可以同时多人编辑的，如果使用了悲观锁，那么只要有一个用户正在编辑文档，此时其他用户就无法打开相同的文档了，这用户体验当然不好了。

那实现多人同时编辑，实际上是用了乐观锁，它允许多个用户打开同一个文档进行编辑，编辑完提交之后才验证修改的内容是否有冲突。

怎么样才算发生冲突？这里举个例子，比如用户 A 先在浏览器编辑文档，之后用户 B 在浏览器也打开了相同的文档进行编辑，但是用户 B 比用户 A 提交早，这一过程用户 A 是不知道的，当 A 提交修改完的内容时，那么 A 和 B 之间并行修改的地方就会发生冲突。

服务端要怎么验证是否冲突了呢？通常方案如下：

由于发生冲突的概率比较低，所以先让用户编辑文档，但是浏览器在下载文档时会记录下服务端返回的文档版本号；

当用户提交修改时，发给服务端的请求会带上原始文档版本号，服务器收到后将它与当前版本号进行比较，如果版本号不一致则提交失败，如果版本号一致则修改成功，然后服务端版本号更新到最新的版本号。

实际上，我们常见的 SVN 和 Git 也是用了乐观锁的思想，先让用户编辑代码，然后提交的时候，通过版本号来判断是否产生了冲突，发生了冲突的地方，需要我们自己修改后，再重新提交。

乐观锁虽然去除了加锁解锁的操作，但是一旦发生冲突，重试的成本非常高，所以只有在冲突概率非常低，且加锁成本非常高的场景时，才考虑使用乐观锁。

18. 虚拟内存？虚拟地址空间？使用虚拟内存的优点？

虚拟内存是一种内存管理技术，它会使程序自己认为自己拥有一块很大且连续的内存，而实际上这些内存可能分布在物理内存和磁盘上，在需要时进行数据交换。

优点：
- 通过分页和交换技术，将暂时不用的内存页暂存到磁盘，可以弥补物理内存大小的不足；
- 保证进程之间的隔离性和安全性（检测并防止内存访问越界等）；
- 虚拟内存空间连续，简化了编程和内存管理，无需关心物理内存的实际分布情况；
- 支持共享内存，不同进程的虚拟地址可映射到相同的物理内存页，实现高效的数据共享。
缺点：
- 当系统物理内存不足时，操作系统需要将部分页面写入磁盘（换出）并从磁盘中加载需要的页面（换入），这会带来较高的磁盘 I/O 开销，严重时会导致“抖动”，使系统响应速度下降；
- 虚拟内存还需要维护页表来管理虚拟地址与物理地址之间的映射，这也会占用一定的内存和 CPU 资源。

虚拟地址空间是针对于每个单一进程所能访问的内存地址范围，通常被划分为代码段、数据段、堆、栈和内存映射区域等部分。

19. 介绍一下操作系统内存管理

操作系统设计了虚拟内存，每个进程都有自己的独立的虚拟内存，我们所写的程序不会直接与物理内打交道。Linux 是通过对内存分页的方式来管理内存，分页是把整个虚拟和物理内存空间切成一段段固定尺寸的大小，每一页的大小为 4KB，虚拟地址与物理地址之间通过页表来映射，页表是存储在内存里的，内存管理单元（MMU）就做将虚拟内存地址转换成物理地址的工作。而当进程访问的虚拟地址在页表中查不到时，系统会产生一个缺页异常，进入系统内核空间分配物理内存、更新进程页表，最后再返回用户空间，恢复进程的运行。

20. 程序的内存布局是怎样的？

通过这张图你可以看到，用户空间内存，从低到高分别是 6 种不同的内存段：

代码段：包括二进制可执行代码，通常只读，还可共享（多个进程运行同一程序时只存一份）；

静态存储区：数据段 + BSS 段
数据段：包括已初始化的静态常量和全局变量；
BSS 段：包括未初始化的静态变量和全局变量；
堆（比如 malloc/new）：包括动态分配的内存，从低地址开始向上增长，程序员负责管理，容易泄露；
文件映射区（比如 mmap）：包括共享库、文件映射、匿名映射、共享内存等；
栈：包括局部变量和函数调用的上下文（参数、返回地址）等，函数调用或返回会自动分配与释放后。栈的大小是固定的，一般是 8 MB。当然系统也提供了参数，以便我们自定义大小；
内核空间（对用户程序不可见）

上图中的内存布局可以看到，代码段下面还有一段内存空间的（灰色部分），这一块区域是「保留区」，之所以要有保留区这是因为在大多数的系统里，我们认为比较小数值的地址不是一个合法地址，例如，我们通常在 C 的代码里会将无效的指针赋值为 NULL。因此，这里会出现一段不可访问的内存保留区，防止程序因为出现 bug，导致读或写了一些小内存地址的数据，而使得程序跑飞。

🔥 在这 7 个内存段中，堆和文件映射段的内存是动态分配的。比如说，使用 C 标准库的 malloc() 或者 mmap()，就可以分别在堆和文件映射段动态分配内存。

21. 堆与栈的区别，以及各自优缺点？

栈由编译器自动管理，内存分配和释放通过指针的移动完成，速度极快。它用于存储局部变量、函数参数和返回地址，数据遵循后进先出的顺序，生命周期与函数调用周期一致，函数结束时自动释放。栈的大小通常有限，过度使用可能导致栈溢出。

堆由程序员手动管理，内存分配和释放需要显式操作，速度相对较慢。它用于动态分配的内存，生命周期由程序员控制，数据无需遵循特定顺序，但管理不当可能导致内存泄漏或碎片化。堆的大小受系统虚拟内存限制，容量远大于栈。

栈的优点是高效且无碎片，但容量有限且灵活性低；堆的优点是容量大且灵活，但管理复杂且容易引发错误。

22. `fork()` 会复制哪些东西

当调用 fork() 创建子进程时，操作系统会复制父进程的整个虚拟地址空间（包括代码、数据、堆和栈）、执行上下文（如寄存器状态）、打开的文件描述符表、信号处理设置、进程权限属性以及资源限制配置，形成一份几乎完全相同的副本。不过，子进程会拥有独立的进程 ID 和父进程 ID，且不会继承父进程的未决信号、定时器或文件锁。

现代系统通过写时复制 COW 技术优化性能：初始时父子进程共享物理内存页，仅当任一进程尝试修改某页时，内核才为该页创建实际副本，从而避免不必要的内存复制开销。

23. 写时复制是什么？节省了哪些资源？

写时复制（Copy-on-Write, COW）是一种高效的内存管理优化技术，其核心思想是允许多个进程或线程共享同一份物理内存数据，直到其中某个进程试图修改这些数据时，系统才会为该进程分配新的物理内存并复制原始数据，从而避免不必要的提前复制开销。

在具体实现中，当父进程调用 fork() 创建子进程时，操作系统并不会立即复制父进程的整个地址空间到新的物理内存中，而是让子进程共享父进程的物理内存页，同时将这些页标记为写时复制状态。此时，父子进程的页表项均指向相同的物理内存页，但权限被设置为只读。当任一进程（父进程或子进程）尝试对共享页进行写操作时，会触发页错误异常（page fault），内核中的页错误处理程序会识别这是由写时复制引起的，随后为执行写操作的进程分配一个新的物理页，复制原始数据内容，并更新该进程的页表以指向新页且恢复可写权限，最后重新执行导致异常的写指令。

写时复制技术显著减少了进程创建（如 fork()）和内存复制（如 mmap() 私有映射）的开销，尤其在大内存进程中效果明显，因为它延迟了实际复制操作到真正需要时才发生，节省了时间和物理内存资源。典型的应用场景包括快速进程创建、内存快照、虚拟机管理及某些数据结构（如字符串实现中的共享缓冲区）。

24. malloc 1KB 和 1MB 有什么区别？

1KB（小内存）：通常通过 glibc 的 ptmalloc 分配器从线程的本地缓存（fast bins 或 small bins） 中直接分配，这些缓存来源于预先从堆（heap）中申请的内存块（chunk）。分配速度快，无需直接与内核交互。

1MB（大内存）：可能超过 mmap 阈值（默认一般为 128KB），分配器会直接使用 mmap 系统调用从操作系统中申请独立的内存映射区域，而非从堆区分配。释放时同样通过 munmap 直接返还操作系统。

25. free 释放内存会归还给操作系统吗？

free() 的行为并不是由 C 语言标准直接规定的，而是由底层的内存管理器（通常是 glibc 的 malloc 实现，即 ptmalloc2）决定的。它的核心目标是平衡性能（减少系统调用和锁竞争）和内存效率。

当我们调用 free 函数释放一块动态分配的内存时，这个过程并非简单直接地将内存交还给操作系统，而是由底层的内存管理器（如 glibc 中的 ptmalloc）负责处理。具体来说，内存管理器会将被释放的内存块标记为空闲状态，并保留在进程的堆空间中，ptmalloc 将其加入到自己的空闲内存双向链表中。这样做的目的是为了优化性能：如果程序后续再次申请类似大小的内存，管理器可以迅速从空闲链表中分配一块，避免了频繁向操作系统申请内存的系统调用开销，同时 ptmalloc 也会尝试对小块内存进行合并，避免过多的内存碎片。
只有在某些特定条件下，内存管理器才会将内存真正归还给操作系统。例如，当释放的内存块非常大（比如超过 128KB，这类大块内存通常由 mmap 分配而非堆分配）时，管理器可能会直接使用 munmap 系统调用将其释放回操作系统。此外，如果堆顶（即堆空间的末端）存在大量连续的空闲内存，管理器也可能通过 sbrk 系统调用来降低堆顶指针，从而缩减进程的堆空间，将这部分空闲内存返还给系统。但需要注意的是，由于内存碎片的存在，堆中部即使有空闲内存也难以被归还，因为操作系统要求归还的内存必须是地址连续的。因此，free 的行为是内存管理器在性能和系统资源占用之间的一种权衡策略。

26. malloc 是如何分配内存的（介绍一下 brk 和 mmap）？

malloc 是 C 标准库中用于动态分配内存的函数，其具体实现依赖于底层的内存分配器（如 glibc 的 ptmalloc）。它的分配通过多级缓存和堆/mmap 混合策略优化不同尺寸的内存分配，在用户态管理内存池以减少系统调用次数，同时尝试平衡性能与碎片化问题。

以下是其核心分配机制：

1. 小内存分配（通常 ≤ 128KB）

线程本地缓存（Tcache）：首先检查线程本地缓存（每个线程独享的无锁结构），从中快速获取所需大小的内存块。若命中则直接返回，避免全局锁竞争。
Fast Bins / Small Bins：若 Tcache 未命中，则根据请求大小从对应的 Fast Bins（小内存单链表，LIFO）或 Small Bins（固定大小链表）中查找空闲块。Fast Bins 通常不合并碎片以提升分配速度。
堆区分配：若以上缓存均无可用块，分配器会通过 brk() 系统调用扩展进程的堆空间，从堆顶申请一大块内存，并将其分割为所需尺寸返回给用户。

2. 大内存分配（通常 > 128KB）

直接使用 mmap() 系统调用：分配器会绕过堆管理，直接通过 mmap 从操作系统申请独立的内存映射区域。此类内存释放时通过 munmap 立即归还系统，避免堆碎片化。

3. 分配器的优化策略

内存块（chunk）对齐：返回的内存块通常按 16 字节对齐（64 位系统），满足硬件和算法效率需求。
碎片管理：释放后的内存块会根据邻居是否空闲进行合并，减少内存碎片。但 Fast Bins 中的块暂不合并以加速小内存分配。
多级缓存：通过 Tcache、Fast Bins、Unsorted Bins、Small Bins、Large Bins 等多级链表缓存不同尺寸的空闲块，适配不同分配模式。

4. brk 与 mmap

brk()：用于扩展或收缩堆空间，频繁调用可能引发内存碎片。
mmap()：用于大内存或匿名映射，每次调用涉及内核态切换，开销较大但隔离性好。

brk

mmap

27. 操作系统内存不足的时候会发生什么（如何避免预读失效和缓存污染）

触发内核回收机制
- 页面回收（Page Reclaim）：内核优先回收干净页（Clean Page，如文件读缓存）和空闲页，直接丢弃或重新关联。
- 脏页回写（Writeback Dirty Pages）：将脏页（Dirty Page，被修改过的缓存）异步写入磁盘，然后回收为空闲页。
- 交换（Swapping）：将不活跃的匿名页（进程堆栈数据）换出到磁盘交换分区（Swap），释放物理内存。
OOM Killer（Out-of-Memory Killer）：若回收后仍不足，内核根据进程的 oom_score（基于内存占用、优先级等）强制终止某些进程，释放内存。

应用程序通过 malloc 函数申请内存的时候，实际上申请的是虚拟内存，此时并不会分配物理内存。

当应用程序读写了这块虚拟内存，CPU 就会去访问这个虚拟内存，这时会发现这个虚拟内存没有映射到物理内存， CPU 就会产生缺页中断，进程会从用户态切换到内核态，并将缺页中断交给内核的 Page Fault Handler（缺页中断函数）处理。

缺页中断处理函数会看是否有空闲的物理内存，如果有，就直接分配物理内存，并建立虚拟内存与物理内存之间的映射关系。

如果没有空闲的物理内存，那么内核就会开始进行回收内存的工作，回收的方式主要是两种：直接内存回收和后台内存回收。

后台内存回收（kswapd）：在物理内存紧张的时候，会唤醒 kswapd 内核线程来回收内存，这个回收内存的过程异步的，不会阻塞进程的执行。
直接内存回收（direct reclaim）：如果后台异步回收跟不上进程内存申请的速度，就会开始直接回收，这个回收内存的过程是同步的，会阻塞进程的执行。

如果直接内存回收后，空闲的物理内存仍然无法满足此次物理内存的申请，那么内核就会放最后的大招了 —— 触发 OOM（Out of Memory）机制。

OOM Killer 机制会根据算法选择一个占用物理内存较高的进程，然后将其杀死，以便释放内存资源，如果物理内存依然不足，OOM Killer 会继续杀死占用物理内存较高的进程，直到释放足够的内存位置。

申请物理内存的过程如下图：

系统内存紧张的时候，就会进行回收内存的工作，那具体哪些内存是可以被回收的呢？

🔥 主要有两类内存可以被回收，而且它们的回收方式也不同。

文件页（File-backed Page）：内核缓存的磁盘数据（Buffer）和内核缓存的文件数据（Cache）都叫作文件页。大部分文件页，都可以直接释放内存，以后有需要时，再从磁盘重新读取就可以了。而那些被应用程序修改过，并且暂时还没写入磁盘的数据（也就是脏页），就得先写入磁盘，然后才能进行内存释放。所以，回收干净页的方式是直接释放内存，回收脏页的方式是先写回磁盘后再释放内存。
匿名页（Anonymous Page）：这部分内存没有实际载体，不像文件缓存有硬盘文件这样一个载体，比如堆、栈数据等。这部分内存很可能还要再次被访问，所以不能直接释放内存，它们回收的方式是通过 Linux 的 Swap 机制，Swap 会把不常访问的内存先写到磁盘中，然后释放这些内存，给其他更需要的进程使用。再次访问这些内存时，重新从磁盘读入内存就可以了。

文件页和匿名页的回收都是基于 LRU 算法，也就是优先回收不常访问的内存。LRU 回收算法，实际上维护着 active 和 inactive 两个双向链表，其中：

active_list 活跃内存页链表，这里存放的是最近被访问过（活跃）的内存页；
inactive_list 不活跃内存页链表，这里存放的是很少被访问（非活跃）的内存页（预取页）；

有了这两个 LRU 链表后，预读页就只需要加入到 inactive_list 区域的头部，当页被真正访问的时候，才将页插入 active_list 的头部，同时将 active_list 尾部页淘汰到 inactive_list 头部中；如果预读的页一直没有被访问，就会从 inactive_list 移除，这样就不会影响 active_list 中的热点数据。

越接近链表尾部，就表示内存页越不常访问。这样，在回收内存时，系统就可以根据活跃程度，优先回收不活跃的内存。

但是如果还是使用「只要数据被访问一次，就将数据加入到活跃 LRU 链表头部」这种方式的话，那么还存在缓存污染的问题：当我们在批量读取数据的时候，由于数据被访问了一次，这些大量数据都会被加入到「活跃 LRU 链表」里，然后之前缓存在活跃 LRU 链表里的热点数据全部都被淘汰了，如果这些大量的数据在很长一段时间都不会被访问的话，那么整个活跃 LRU 链表就被污染了。

前面的 LRU 算法只要数据被访问一次，就将数据加入活跃 LRU 链表，这种 LRU 算法进入活跃 LRU 链表的门槛太低了！正是因为门槛太低，才导致在发生缓存污染的时候，很容易就将原本在活跃 LRU 链表里的热点数据淘汰了。所以，只要我们提高进入到活跃 LRU 链表的门槛，就能有效地保证活跃 LRU 链表里的热点数据不会被轻易替换掉。

Linux 操作系统是这样提高门槛的：在内存页被访问第二次的时候，才将页从 inactive_list 升级到 active_list 里。

提高了进入活跃 LRU 链表的门槛后，就很好了避免缓存污染带来的影响。在批量读取数据时候，如果这些大量数据只会被访问一次，那么它们就不会进入到活跃 LRU 链表，也就不会把热点数据淘汰，只会待在非活跃 LRU 链表中，后续很快也会被淘汰。

28. 页面置换算法有哪些？

页面置换算法的功能是，当出现缺页异常，需调入新页面而内存已满时，选择被置换的物理页面，也就是说选择一个物理页面换出到磁盘，然后把需要访问的页面换入到物理页。

那其算法目标则是尽可能减少页面的换入换出的次数，常见的页面置换算法有如下几种：

最佳页面置换算法（OPT）
先进先出置换算法（FIFO）
最近最久未使用的置换算法（LRU）
时钟页面置换算法（Clock）
最不常用置换算法（LFU）

1️⃣ 最佳页面置换算法（OPT）

最佳页面置换算法基本思路是，置换在「未来」最长时间不访问的页面。

所以，该算法实现需要计算内存中每个逻辑页面的「下一次」访问时间，然后比较，选择未来最长时间不访问的页面。

我们举个例子，假设一开始有 3 个空闲的物理页，然后有请求的页面序列，那它的置换过程如下图：

在这个请求的页面序列中，缺页共发生了 7 次（空闲页换入 3 次 + 最优页面置换 4 次），页面置换共发生了 4 次。这很理想，但是实际系统中无法实现，因为程序访问页面时是动态的，我们是无法预知每个页面在「下一次」访问前的等待时间。所以，最佳页面置换算法作用是为了衡量你的算法的效率，你的算法效率越接近该算法的效率，那么说明你的算法是高效的。

2️⃣ 先进先出置换算法（FIFO）

既然我们无法预知页面在下一次访问前所需的等待时间，那我们可以选择在内存驻留时间很长的页面进行中置换，这个就是「先进先出置换」算法的思想。还是以前面的请求的页面序列作为例子，假设使用先进先出置换算法，则过程如下图：

在这个请求的页面序列中，缺页共发生了 10 次（页面置换共发生了 7 次），跟最佳页面置换算法比较起来，性能明显差了很多。

3️⃣ 最近最久未使用的置换算法（LRU）

最近最久未使用（LRU）的置换算法的基本思路是，发生缺页时，选择最长时间没有被访问的页面进行置换，也就是说，该算法假设已经很久没有使用的页面很有可能在未来较长的一段时间内仍然不会被使用。

这种算法近似最优置换算法，最优置换算法是通过「未来」的使用情况来推测要淘汰的页面，而 LRU 则是通过「历史」的使用情况来推测要淘汰的页面。还是以前面的请求的页面序列作为例子，假设使用最近最久未使用的置换算法，则过程如下图：

在这个请求的页面序列中，缺页共发生了 9 次（页面置换共发生了 6 次），跟先进先出置换算法比较起来，性能提高了一些。

虽然 LRU 在理论上是可以实现的，但代价很高。为了完全实现 LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是，在每次访问内存时都必须要更新「整个链表」。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作。所以，LRU 虽然看上去不错，但是由于开销比较大，实际应用中比较少使用。

4️⃣ 时钟页面置换算法（Clock）

那有没有一种即能优化置换的次数，也能方便实现的算法呢？

时钟页面置换算法就可以两者兼得，它跟 LRU 近似，又是对 FIFO 的一种改进。

该算法的思路是，把所有的页面都保存在一个类似钟面的「环形链表」中，一个表针指向最老的页面。

当发生缺页中断时，算法首先检查表针指向的页面：

如果它的访问位位是 0 就淘汰该页面，并把新的页面插入这个位置，然后把表针前移一个位置；
如果访问位是 1 就清除访问位，并把表针前移一个位置，重复这个过程直到找到了一个访问位为 0 的页面为止；

时钟页面置换算法的工作流程图：

5️⃣ 最不常用置换算法（LFU）

最不常用（LFU）算法，这名字听起来很调皮，但是它的意思不是指这个算法不常用，而是当发生缺页中断时，选择「访问次数」最少的那个页面，并将其淘汰。

它的实现方式是，对每个页面设置一个「访问计数器」，每当一个页面被访问时，该页面的访问计数器就累加 1。在发生缺页中断时，淘汰计数器值最小的那个页面。

看起来很简单，每个页面加一个计数器就可以实现了，但是在操作系统中实现的时候，我们需要考虑效率和硬件成本的。

要增加一个计数器来实现，这个硬件成本是比较高的，另外如果要对这个计数器查找哪个页面访问次数最小，查找链表本身，如果链表长度很大，是非常耗时的，效率不高。

但还有个问题，LFU 算法只考虑了频率问题，没考虑时间的问题，比如有些页面在过去时间里访问的频率很高，但是现在已经没有访问了，而当前频繁访问的页面由于没有这些页面访问的次数高，在发生缺页中断时，就会可能会误伤当前刚开始频繁访问，但访问次数还不高的页面。

那这个问题的解决的办法还是有的，可以定期减少访问的次数，比如当发生时间中断时，把过去时间访问的页面的访问次数除以 2，也就说，随着时间的流失，以前的高访问次数的页面会慢慢减少，相当于加大了被置换的概率。

29. 什么是中断？

中断是计算机系统中一种重要的事件处理机制，当硬件设备或软件程序需要处理器立即处理某个事件时，会向 CPU 发送一个信号，强制暂停当前正在执行的程序，转而去执行与该事件相关的特定处理程序（称为中断处理程序或中断服务例程），待该程序执行完毕后再恢复之前被暂停的任务。

中断的核心目的是提高处理器的效率，使其不必持续轮询设备状态，而是由外设在需要时主动通知 CPU，从而实现异步事件处理和并发执行。中断可分为两类：

硬件中断：由外部设备（如键盘、鼠标、磁盘控制器、网卡）通过物理信号线触发，例如用户按下键盘按键或网卡接收到数据包时，会立即向 CPU 发送中断请求（IRQ），CPU 根据中断编号查找并执行对应的驱动处理程序。
软件中断：由程序执行特定指令（如系统调用、陷阱或异常）触发，例如应用程序请求操作系统服务（如读写文件）时通过软中断陷入内核，或发生除零错误等异常时强制切换处理流程。

中断处理过程涉及保存当前执行上下文（如寄存器状态）、跳转到中断向量表指定的地址、执行处理程序，最后恢复上下文并返回原任务。这一机制是现代操作系统实现多任务、设备驱动和实时响应的基础。

30. 讲讲中断的流程

中断触发：硬件设备（如键盘、网卡）或软件（通过 int 指令）发出中断信号。硬件中断通过中断控制器（如 APIC）汇总后发送给 CPU。
中断响应：CPU 在每个指令执行结束后检查是否有中断请求。若有且未被屏蔽（可屏蔽中断），则暂停当前程序，保存当前执行上下文（包括程序计数器 PC、寄存器等状态到内核栈），并关闭中断（防止嵌套中断干扰现场保存）。
中断路由：CPU 根据中断号查询中断描述符表（IDT），找到对应的中断服务程序（ISR）的入口地址。
执行中断处理程序：跳转到 ISR 执行具体的中断处理逻辑（如从键盘缓冲区读取按键值、处理网络数据包）。此时可能分为两部分：
- 上半部：在中断关闭状态下执行紧急任务（如响应硬件、拷贝数据），要求快速完成。
- 下半部：通过软中断、任务队列或工作队列等机制延迟处理非紧急任务（如数据处理），此时会重新开启中断。
恢复现场：ISR 执行完毕后，从内核栈恢复之前保存的上下文（寄存器等状态）。

31. 中断的类型有哪些？

中断可以根据其来源和触发方式分为以下几类：

硬件中断：由外部硬件设备触发，通过中断请求线（IRQ）向 CPU 发送信号。例如键盘输入、鼠标移动、磁盘 I/O 完成或网络数据包到达。硬件中断可进一步分为：
- 可屏蔽中断：可通过设置 CPU 标志位（如 IF 位）临时屏蔽，例如大多数外设中断。
- 非可屏蔽中断：用于处理硬件紧急事件（如内存错误、电源故障），无法通过软件屏蔽。
软件中断：由程序执行特定指令主动触发，用于实现系统调用或异常处理。例如：
- 系统调用：用户程序通过 int 0x80 或 syscall 指令陷入内核，请求操作系统服务。
- 陷阱：用于调试（如断点中断 int 3）或功能调用。
异常：由 CPU 在执行指令时检测到错误或特殊条件时自动触发，属于同步中断。例如：
- 故障：可修复的错误（如缺页异常），处理后可重新执行指令。
- 陷阱：执行后继续下一条指令（如调试断点）。
- 中止：严重错误（如硬件故障），导致进程终止。
伪中断：由硬件错误或信号干扰导致的无效中断请求，中断控制器需过滤此类信号。

32. 你了解过哪些 I/O 模型？

阻塞 I/O：这是最基础的模型。当应用程序发起一个 I/O 操作（如 read 系统调用）时，线程会被挂起（阻塞），直到操作系统内核将数据完全准备好并复制到用户空间缓冲区后，线程才被唤醒继续执行。在此期间，该线程无法执行任何其他任务。模型简单，但并发性能差，需要为每个连接创建大量线程。
非阻塞 I/O：应用程序发起 I/O 操作后，如果数据尚未就绪，内核会立即返回一个错误（如 EWOULDBLOCK），而不是阻塞线程。应用程序需要不断地轮询（polling）内核，询问数据是否准备就绪。这种方式避免了线程阻塞，但轮询会消耗大量 CPU 资源，效率低下。
I/O 多路复用：这是目前高并发网络应用中最主流的模型。应用程序通过调用 select, poll, 或 epoll 等系统函数，将一个或多个文件描述符（socket）的监听委托给内核。内核会监视这些描述符，当其中任何一个有数据就绪时，就通知应用程序。应用程序收到通知后再进行实际的 I/O 操作（如 recv）。这使得一个线程可以同时管理多个 I/O 连接，极大地提高了系统的并发能力。它常被称为 Reactor 模式。
信号驱动 I/O：应用程序通过 fcntl 系统调用为一个文件描述符开启信号驱动模式，并指定一个信号（如 SIGIO）。当内核数据就绪时，它会向应用程序发送一个信号。应用程序在信号处理函数中进行 I/O 操作。这种方式避免了轮询，但信号处理本身比较复杂，且在大流量场景中信号队列可能溢出，因此并不常用。
异步 I/O：这是真正的异步模型。应用程序发起一个 I/O 操作（如 aio_read）后立即返回，内核会负责完成包括数据准备和从内核空间拷贝到用户空间在内的所有工作。整个操作完成后，内核会通过信号或回调函数通知应用程序。这与信号驱动 I/O 的关键区别在于：信号驱动 I/O 是内核通知我们“何时可以开始”进行 I/O 操作，而异步 I/O 是内核通知我们“I/O 操作已经完成”。Linux 原生 AIO 支持有限，更多使用像 io_uring 这样的新一代异步接口。

33. 讲一讲 I/O 多路复用，以及 select、poll、epoll 的区别？

wxg 一面

视频链接：腾讯面试:请描述 select、poll、epoll 这三种 I/O 多路复用技术的执行原理

推荐阅读：图解 | 深入揭秘 epoll 是如何实现 IO 多路复用的！

I/O 多路复用是一种 I/O 的处理方式，指的是复用一个线程处理多个 socket 中的事件。能够复用资源，防止创建过多线程导致的上下文切换的开销。

我们熟悉的 select/poll/epoll 内核提供给用户态的多路复用系统调用，进程可以通过一个系统调用函数从内核中获取多个事件。

select/poll/epoll 是如何获取网络事件的呢？在获取事件时，先把所有连接（文件描述符）传给内核，再由内核返回产生了事件的连接，然后在用户态中再处理这些连接对应的请求即可。

select、poll

✅ select 图解

✅ poll 图解

select 实现多路复用的方式是，将已连接的 Socket 都放到一个文件描述符集合，然后调用 select 函数将文件描述符集合拷贝到内核里，让内核来检查是否有网络事件产生，检查的方式很粗暴，就是通过遍历文件描述符集合的方式，当检查到有事件产生后，将此 Socket 标记为可读或可写，接着再把整个文件描述符集合拷贝回用户态里，然后用户态还需要再通过遍历的方法找到可读或可写的 Socket，然后再对其处理。

所以，对于 select 这种方式，需要进行 2 次「遍历」文件描述符集合，一次是在内核态里，一个次是在用户态里，而且还会发生 2 次「拷贝」文件描述符集合，先从用户空间传入内核空间，由内核修改后，再传出到用户空间中。

select 使用固定长度的 BitsMap，表示文件描述符集合，而且所支持的文件描述符的个数是有限制的，在 Linux 系统中，由内核中的 FD_SETSIZE 限制，默认最大值为 1024，只能监听 0~1023 的文件描述符。

poll 不再用 BitsMap 来存储所关注的文件描述符，取而代之用动态数组，以链表形式来组织，突破了 select 的文件描述符个数限制，当然还会受到系统文件描述符限制。

但是 poll 和 select 并没有太大的本质区别，都是使用「线性结构」存储进程关注的 Socket 集合，因此都需要遍历文件描述符集合来找到可读或可写的 Socket，时间复杂度为 O(n)，而且也需要在用户态与内核态之间拷贝文件描述符集合，这种方式随着并发数上来，性能的损耗会呈指数级增长。

epoll

Linux 2.6 版本诞生了 epoll 模型，彻底解决了 select/poll 性能不足的问题

✅ epoll 图解

先复习下 epoll 的用法。如下的代码中，先用 epoll_create 创建一个 epoll 对象 epoll_fd，再通过 epoll_ctl 将需要监视的 socket 添加到 epoll_fd 中，最后调用 epoll_wait 等待数据。

int s = socket(AF_INET, SOCK_STREAM, 0);
bind(s, ...);
listen(s, ...);

// epoll_fd
int epfd = epoll_create(...);
epoll_ctl(epfd, ...); //将所有需要监听的socket添加到epfd中

while(1) {
    int n = epoll_wait(...);
    for(接收到数据的socket){
        //处理
    }
}

epoll 通过两个方面，很好解决了 select/poll 的问题：

第一点，epoll 在内核里使用「红黑树」来跟踪进程所有待检测的文件描述字，把需要监控的 socket 通过 epoll_ctl() 函数加入内核中的红黑树里，红黑树是个高效的数据结构，增删改一般时间复杂度是 $O(logn)$。而 select/poll 内核里没有类似 epoll 红黑树这种保存所有待检测的 socket 的数据结构，所以 select/poll 每次操作时都传入整个 socket 集合给内核，而 epoll 因为在内核维护了红黑树，可以保存所有待检测的 socket ，所以只需要传入一个待检测的 socket，减少了内核和用户空间大量的数据拷贝和内存分配。
第二点，epoll 使用事件驱动的机制，内核里维护了一个链表来记录就绪事件，当某个 socket 有事件发生时，内核通过回调函数将其加入到这个就绪事件列表中，当用户调用 epoll_wait() 函数时，只会返回有事件发生的文件描述符的个数，不需要像 select/poll 那样轮询扫描整个 socket 集合，大大提高了检测的效率。

从下图你可以看到 epoll 相关的接口作用：

epoll 的方式即使监听的 Socket 数量越多的时候，效率不会大幅度降低，能够同时监听的 Socket 的数目也非常的多了，上限就为系统定义的进程打开的最大文件描述符个数。因而，epoll 被称为解决 C10K 问题（服务器同时处理10,000个客户端连接的挑战）的利器。

34. epoll 的边缘触发和水平触发有什么区别？

epoll 支持两种事件触发模式，分别是边缘触发（edge-triggered，ET）和水平触发（level-triggered，LT）。

这两个术语还挺抽象的，其实它们的区别还是很好理解的。

使用边缘触发模式时，当被监控的 Socket 描述符上有可读事件发生时，服务器端只会从 epoll_wait 中苏醒一次，即使进程没有调用 read 函数从内核读取数据，也依然只苏醒一次，因此我们程序要保证一次性将内核缓冲区的数据读取完；
使用水平触发模式时，当被监控的 Socket 上有可读事件发生时，服务器端不断地从 epoll_wait 中苏醒，直到内核缓冲区数据被 read 函数读完才结束，目的是告诉我们有数据需要读取；

举个例子，你的快递被放到了一个快递箱里，如果快递箱只会通过短信通知你一次，即使你一直没有去取，它也不会再发送第二条短信提醒你，这个方式就是边缘触发；如果快递箱发现你的快递没有被取出，它就会不停地发短信通知你，直到你取出了快递，它才消停，这个就是水平触发的方式。

这就是两者的区别，边缘触发的意思是只有第一次满足条件的时候才触发，之后就不会再传递同样的事件了；水平触发的意思是只要满足事件的条件，比如内核中有数据需要读，就一直不断地把这个事件传递给用户。

如果使用边缘触发模式，I/O 事件发生时只会通知一次，而且我们不知道到底能读写多少数据，所以在收到通知后应尽可能地读写数据，以免错失读写的机会。因此，我们会循环从文件描述符读写数据，那么如果文件描述符是阻塞的，没有数据可读写时，进程会阻塞在读写函数那里，程序就没办法继续往下执行。所以，边缘触发模式一般和非阻塞 I/O 搭配使用，程序会一直执行 I/O 操作，直到系统调用（如 read 和 write）返回错误，错误类型为 EAGAIN 或 EWOULDBLOCK。

如果使用水平触发模式，当内核通知文件描述符可读写时，接下来还可以继续去检测它的状态，看它是否依然可读或可写。所以在收到通知后，没必要一次执行尽可能多的读写操作。

一般来说，边缘触发的效率比水平触发的效率要高，因为边缘触发可以减少 epoll_wait 的系统调用次数，系统调用也是有一定的开销的的，毕竟也存在上下文的切换。

35. coredump 是什么，什么时候触发 coredump

coredump 是程序由于异常或者 bug 在运行时异常退出或者终止，在一定的条件下生成的一个叫做 core 的文件，这个 core 文件会记录程序在运行时的内存，寄存器状态，内存指针和函数堆栈信息等等。对这个文件进行分析可以定位到程序异常的时候对应的堆栈调用信息。

coredump 产生的条件：

shell 资源控制限制，使用 ulimit -c 命令查看 shell 执行程序时的资源，如果为 0，则不会产生 coredump。可以用 ulimit -c unlimited 设置为不限大小。
读写越界，包括：数组访问越界，指针指向错误的内存，字符串读写越界
使用了线程不安全的函数，读写未加锁保护
错误使用指针转换
堆栈溢出

36. 什么是零拷贝？

传统 IO 的工作方式，从硬盘读取数据，然后再通过网卡向外发送，我们需要进行 4 上下文切换，和 4 次数据拷贝，其中 2 次数据拷贝发生在内存里的缓冲区和对应的硬件设备之间，这个是由 DMA 完成，另外 2 次则发生在内核态和用户态之间，这个数据搬移工作是由 CPU 完成的。

为了提高文件传输的性能，于是就出现了零拷贝技术，它通过一次系统调用（sendfile 方法）合并了磁盘读取与网络发送两个操作，降低了上下文切换次数。另外，拷贝数据都是发生在内核中的，天然就降低了数据拷贝的次数。

零拷贝技术的文件传输方式相比传统文件传输的方式，减少了 2 次上下文切换和数据拷贝次数，只需要 2 次上下文切换和数据拷贝次数，就可以完成文件的传输，而且 2 次的数据拷贝过程，都不需要通过 CPU，2 次都是由 DMA 来搬运。

总体来看，零拷贝技术可以把文件传输的性能提高至少一倍以上。

37. Linux I/O 栈

参考链接：

Linux 系统中 I/O 操作的数据读写流程介绍

Linux I/O 栈｜读写流程

程序的内存分布，其中包括内核空间（在内存中），联想一下即可理解。

linux I/O 存储栈分为 7 层:

VFS 虚拟文件层: 在各个具体的文件系统上建立一个抽象层，屏蔽不同文件系统的差异。
PageCache 层: 为了缓解内核与磁盘速度的巨大差异。
映射层 Mapping Layer: 内核必须从块设备上读取数据，Mapping layer 要确定在物理设备上的位置。
通用块设备层: 通用块层处理来自系统其他组件发出的块设备请求，包含了块设备操作的一些通用函数和数据结构。
I/O 调度层： IO 调度层主要是为了减少磁盘 IO 的次数，增大磁盘整体的吞吐量，队列中多个 bio 进行排序和合并。
块设备驱动层: 每一类设备都有其驱动程序，负责设备的读写。
物理设备层: 物理设备层有 HDD、SSD、Nvme 等磁盘设备。

38. 一次完整的 I/O 读请求处理链路

🔥 下面是一个完整的、详细的 I/O 请求处理链路（以一次文件读取操作为例）：

应用调用 read() → 触发系统调用进入内核。
VFS 根据文件类型调用文件系统的 read_iter 方法。
文件系统检查 Page Cache：
- 命中：直接拷贝数据到用户缓冲区。
- 未命中：创建 bio 请求，提交到块层。
I/O 调度器合并/排序请求后，下发到 SCSI 中层。
设备驱动将请求转换为硬件命令，提交给控制器。
设备通过 DMA 读取数据到内存，触发中断通知完成。
中断处理程序唤醒原始请求，数据被填入 Page Cache 并返回用户态。

1. 系统调用接口（VFS 层）

作用：为用户空间（如 libc 库）提供统一的系统调用接口（如 read(), write(), io_uring_enter）。
关键组件：虚拟文件系统（VFS）。它抽象了所有文件系统和设备的操作，为上层提供统一的 file_operations 函数指针接口（如 read_iter, write_iter）。

2. 文件系统层

作用：处理与特定文件系统（如 ext4、XFS、Btrfs）相关的逻辑，如路径解析、权限检查、元数据管理。
关键步骤：
- 将文件的偏移量和大小转换为块设备上的逻辑块地址（LBA）。
- 通过 Page Cache 缓存文件和目录数据，减少直接磁盘访问。
- 若请求的数据已在 Page Cache 中（缓存命中），则直接返回；否则触发缺页异常，发起 I/O 请求。

3. 块 I/O 层

作用：管理 I/O 调度、合并请求，并转换为统一的块 I/O 请求（struct bio）。
关键组件：
- Page Cache：通过 address_space 操作与文件系统交互。
- I/O 调度器（如 mq-deadline、Kyber、BFQ）：对 I/O 请求进行排序、合并（Merge）、重排（Sort），以减少磁盘寻道时间并保证公平性。
- 块设备映射：处理分区、软件 RAID（如 mdadm）或逻辑卷（LVM）。

4. SCSI/设备映射层

作用：将块 I/O 请求转换为特定设备驱动可理解的格式。
关键组件：
- SCSI 子系统：为 SATA、SAS、NVMe 等设备提供统一的中层抽象（即使是非 SCSI 设备也通常接入此框架）。
- 设备映射器（Device Mapper）：支持加密（dm-crypt）、快照（dm-snapshot）、多路径（dm-multipath）等高级功能。

5. 设备驱动层

作用：直接与物理硬件控制器（如 NVMe、SATA AHCI）交互，通过 DMA 将数据从内存传输到设备。
关键步骤：
- 将 I/O 请求转换为设备特定的命令描述符。
- 通过写入控制器的寄存器或门铃（Doorbell）来提交命令。
- 处理设备完成中断，并向上层通知 I/O 完成。

6. 硬件层

物理设备：如 NVMe SSD、SATA HDD、网络存储（通过 iSCSI 等）。
数据传输：通常通过 DMA（直接内存访问）在设备和内存之间传输数据，无需 CPU 参与。

新范式：io_uring

作用：提供高性能异步 I/O 接口，绕过传统内核路径的部分开销。
核心机制：
- 通过一对环形队列（提交队列 SQ 和完成队列 CQ）在用户态和内核态之间传递请求和结果。
- 支持轮询模式（Polling），避免中断开销，进一步降低延迟。

39. write 怎么保证写入的持久性？

在 Linux 中，一个简单的 write() 系统调用并不能保证数据真正持久化到物理存储设备上。要确保写入的持久性，必须理解内核的缓存机制并显式地采取额外措施。

1. 为什么 `write()` 不能保证持久性？

Page Cache 缓冲：write() 系统调用默认会将数据写入内核的 Page Cache 后就立即返回成功。这意味着数据并未立刻写入磁盘，而是停留在易失性内存中。
延迟写入 Write Back：内核通过“延迟写入”策略来优化性能：定期（由 dirty_writeback_centisecs 控制）或根据内存压力，将脏页异步刷回磁盘。在此期间若系统崩溃（断电、内核恐慌），这些数据会丢失。

2. 如何保证写入持久性？

方法 1：同步写入（O_SYNC）

在打开文件时使用 O_SYNC 标志：

fd = open("file.txt", O_WRONLY | O_SYNC);

作用：每次 write() 都会阻塞调用者，直到数据及其元数据（如 inode 大小、修改时间）完全写入物理磁盘后才返回。
缺点：性能极差，每次写入都需等待磁盘 I/O 完成（延迟通常为毫秒级）。

方法 2：显式刷盘（fsync() / fdatasync()）

在 write() 后调用：

write(fd, data, size);
fsync(fd);  // 或 fdatasync(fd);

fsync()：确保文件数据和元数据都持久化到磁盘。
fdatasync()：仅保证数据持久化，元数据（如访问时间）可能不立即刷盘，性能稍好。
优点：可批量写入后一次性刷盘，比 O_SYNC 性能更好。

方法 3：直接 I/O（O_DIRECT）

在打开文件时使用 O_DIRECT 标志：

fd = open("file.txt", O_WRONLY | O_DIRECT);

作用：绕过 Page Cache，直接与磁盘交换数据。但需用户自行处理对齐限制（缓冲区地址、大小需对齐磁盘扇区，通常 512B/4KB）。
注意：O_DIRECT 仅避免缓存，但写入成功返回仅表示数据已提交到磁盘驱动器的缓存（可能仍在易失性缓存中）。若要真正持久化，仍需结合 fsync()。

40. Linux 内存布局

Linux 进程内存分布

在 Linux 操作系统中，虚拟地址空间的内部又被分为内核空间和用户空间两部分，不同位数的系统，地址空间的范围也不同。比如最常见的 32 位和 64 位系统，如下所示。通过这里可以看出：

32 位系统的内核空间占用 1G，位于最高处，剩下的 3G 是用户空间；
64 位系统的内核空间和用户空间都是 128T，分别占据整个内存空间的最高和最低处，剩下的中间部分是未定义的。

虽然每个进程都各自有独立的虚拟内存，但是每个虚拟内存中的内核地址，其实关联的都是相同的物理内存。这样，进程切换到内核态后，就可以很方便地访问内核空间内存。

接下来，进一步了解虚拟空间的划分情况，用户空间和内核空间划分的方式是不同的，内核空间的分布情况就不多说了。我们看看用户空间分布的情况，以 32 位系统为例，用一张图来表示它们的关系：

通过这张图你可以看到，用户空间内存从低到高分别是 6 种不同的内存段：

代码段，包括二进制可执行代码；
数据段，包括已初始化的静态常量和全局变量；
BSS 段，包括未初始化的静态变量和全局变量；
堆段，包括动态分配的内存，从低地址开始向上增长；
文件映射段，包括动态库、共享内存等，从低地址开始向上增长（跟硬件和内核版本有关 (opens new window)）；
栈段，包括局部变量和函数调用的上下文等。栈的大小是固定的，一般是 8 MB。当然系统也提供了参数，以便我们自定义大小；

在这 7 个内存段中，堆和文件映射段的内存是动态分配的。比如说，使用 C 标准库的 malloc() 或者 mmap() ，就可以分别在堆和文件映射段动态分配内存。

41. malloc 分配的是物理内存吗？

不是的，malloc() 分配的是虚拟内存。

如果分配后的虚拟内存没有被访问的话，虚拟内存是不会映射到物理内存的，这样就不会占用物理内存了。

只有在访问已分配的虚拟地址空间的时候，操作系统通过查找页表，发现虚拟内存对应的页没有在物理内存中，就会触发缺页中断，然后操作系统会建立虚拟内存和物理内存之间的映射关系。

42. 在 4GB 物理内存的机器上，申请 8GB 内存会发生什么？

腾讯 CSIG 一面

在 32位/64位操作系统环境下，申请的虚拟内存超过物理内存后会怎么样？

在 32 位操作系统，因为进程最大只能申请 3 GB 大小的虚拟内存，所以直接申请 8G 内存，会申请失败。
在 64 位操作系统，因为进程最大只能申请 128 TB 大小的虚拟内存，即使物理内存只有 4GB，申请 8G 内存也是没问题，因为申请的内存是虚拟内存。

程序申请的虚拟内存，如果没有被使用，它是不会占用物理空间的。当访问这块虚拟内存后，操作系统才会进行物理内存分配。

如果申请物理内存大小超过了空闲物理内存大小，就要看操作系统有没有开启 Swap 机制：

如果没有开启 Swap 机制，程序就会直接 OOM；
如果有开启 Swap 机制，程序可以正常运行。

43. 生产者消费者问题

腾讯 WXG 一面

下面讨论的是「单生产者单消费者」问题，那如果是「多生产者多消费者」问题呢？

生产者之间的竞争（互斥）：多个生产者可能同时尝试向缓冲区写入数据。

消费者之间的竞争（互斥）：多个消费者可能同时尝试从缓冲区读取数据。

生产者-消费者问题描述：

生产者在生成数据后，放在一个缓冲区中；
消费者从缓冲区取出数据处理；
任何时刻，只能有一个生产者或消费者可以访问缓冲区；
缓冲区空时，消费者必须等待生产者生成数据；
缓冲区满时，生产者必须等待消费者取出数据。说明生产者和消费者需要同步。

那么我们需要三个信号量，分别是：

互斥信号量 mutex：用于互斥访问缓冲区，初始化值为 1；
资源信号量 fullBuffers：用于消费者询问缓冲区是否有数据，有数据则读取数据，初始化值为 0（表明缓冲区一开始为空）；
资源信号量 emptyBuffers：用于生产者询问缓冲区是否有空位，有空位则生成数据，初始化值为 n （缓冲区大小）；

代码

44. 哲学家就餐问题

方案一

只要有一个哲学家进入了「临界区」，也就是准备要拿叉子时，其他哲学家都不能动，只有这位哲学家用完叉子了，才能轮到下一个哲学家进餐。

方案二

让偶数编号的哲学家「先拿左边的叉子后拿右边的叉子」，奇数编号的哲学家「先拿右边的叉子后拿左边的叉子」。

45. 读者-写者问题

前面的「哲学家进餐问题」对于互斥访问有限的竞争问题（如 I/O 设备）一类的建模过程十分有用。

另外，还有个著名的问题是「读者-写者」，它为数据库访问建立了一个模型。

读者-写者的问题描述：

「读-读」允许：同一时刻，允许多个读者同时读
「读-写」互斥：没有写者时读者才能读，没有读者时写者才能写
「写-写」互斥：没有其他写者时，写者才能写

读者优先

使用信号量的方式来尝试解决：

信号量 wMutex：控制写操作的互斥信号量，初始值为 1；
读者计数 rCount：正在进行读操作的读者个数，初始化为 0；
信号量 rCountMutex：控制对 rCount 读者计数器的互斥修改，初始值为 1；

上面的这种实现，是读者优先的策略，因为只要有读者正在读的状态，后来的读者都可以直接进入，如果读者持续不断进入，则写者会处于饥饿状态。

写者优先

那既然有读者优先策略，自然也有写者优先策略：

只要有写者准备要写入，写者应尽快执行写操作，后来的读者就必须阻塞；
如果有写者持续不断写入，则读者就处于饥饿；

在方案一的基础上新增如下变量：

信号量 rMutex：控制读者进入的互斥信号量，初始值为 1；
信号量 wDataMutex：控制写者写操作的互斥信号量，初始值为 1；
写者计数 wCount：记录写者数量，初始值为 0；
信号量 wCountMutex：控制 wCount 互斥修改，初始值为 1；

46. 磁盘调度算法

每个扇区是 512 字节，多个具有相同编号的磁道形成一个圆柱，称之为磁盘的柱面。

磁盘调度算法的目的很简单，就是为了提高磁盘的访问性能，一般是通过优化磁盘的访问请求顺序来做到的。

寻道的时间是磁盘访问最耗时的部分，如果请求顺序优化的得当，必然可以节省一些不必要的寻道时间，从而提高磁盘的访问性能。

假设有下面一个请求序列，每个数字代表磁道的位置：

98，183，37，122，14，124，65，67

初始磁头当前的位置是在第 53 磁道。

接下来，分别对以上的序列，作为每个调度算法的例子，那常见的磁盘调度算法有：

先来先服务算法
最短寻道时间优先算法
扫描算法
循环扫描算法
LOOK 与 C-LOOK 算法

1️⃣ 先来先服务

先来先服务（First-Come，First-Served，FCFS），顾名思义，先到来的请求，先被服务。

请求顺序：98，183，37，122，14，124，65，67

先来先服务算法总共移动了 640 个磁道的距离，这么一看这种算法，比较简单粗暴，但是如果大量进程竞争使用磁盘，请求访问的磁道可能会很分散，那先来先服务算法在性能上就会显得很差，因为寻道时间过长。

2️⃣ 最短寻道时间优先

最短寻道时间优先（Shortest Seek First，SSF）算法的工作方式是，优先选择从当前磁头位置所需寻道时间最短的请求

请求顺序：65，67，37，14，98，122，124，183

磁头移动的总距离是 236 磁道，相比先来先服务性能提高了不少。

但这个算法可能存在某些请求的饥饿，因为本次例子我们是静态的序列，看不出问题，假设是一个动态的请求，如果后续来的请求都是小于 183 磁道的，那么 183 磁道可能永远不会被响应，于是就产生了饥饿现象，这里产生饥饿的原因是磁头在一小块区域来回移动。

3️⃣ 扫描算法

最短寻道时间优先算法会产生饥饿的原因在于：磁头有可能再一个小区域内来回得移动。

为了防止这个问题，可以规定：磁头在一个方向上移动，访问所有未完成的请求，直到磁头到达该方向上的最后的磁道，才调换方向，这就是扫描（Scan）算法。

这种算法也叫做电梯调度算法，比如电梯保持按一个方向移动，直到在那个方向上没有请求为止，然后改变方向。

那么，假设扫描调度算先朝磁道号减少的方向移动，具体请求则会是下列从左到右的顺序：37，14，0，65，67，98，122，124，183

磁头先响应左边的请求，直到到达最左端（0 磁道）后，才开始反向移动，响应右边的请求。

扫描调度算法性能较好，不会产生饥饿现象，但是存在这样的问题，中间部分的磁道会比较占便宜，中间部分相比其他部分响应的频率会比较多，也就是说每个磁道的响应频率存在差异。

4️⃣ 循环扫描算法

扫描算法使得每个磁道响应的频率存在差异，那么要优化这个问题的话，可以总是按相同的方向进行扫描，使得每个磁道的响应频率基本一致。

循环扫描（Circular Scan, CSCAN ）规定：只有磁头朝某个特定方向移动时，才处理磁道访问请求，而返回时直接快速移动至最靠边缘的磁道，也就是复位磁头，这个过程是很快的，并且返回中途不处理任何请求，该算法的特点，就是磁道只响应一个方向上的请求。

请求顺序：65，67，98，122，124，183，199，0，14，37

磁头先响应了右边的请求，直到碰到了最右端的磁道 199，就立即回到磁盘的开始处（磁道 0），但这个返回的途中是不响应任何请求的，直到到达最开始的磁道后，才继续顺序响应右边的请求。

循环扫描算法相比于扫描算法，对于各个位置磁道响应频率相对比较平均。

5️⃣ LOOK 与 C-LOOK 算法

我们前面说到的扫描算法和循环扫描算法，都是磁头移动到磁盘「最始端或最末端」才开始调换方向。

那这其实是可以优化的，优化的思路就是磁头在移动到「最远的请求」位置，然后立即反向移动。

那针对 SCAN 算法的优化则叫 LOOK 算法，它的工作方式，磁头在每个方向上仅仅移动到最远的请求位置，然后立即反向移动，而不需要移动到磁盘的最始端或最末端，反向移动的途中会响应请求。

而针对 C-SCAN 算法的优化则叫 C-LOOK，它的工作方式，磁头在每个方向上仅仅移动到最远的请求位置，然后立即反向移动，而不需要移动到磁盘的最始端或最末端，反向移动的途中不会响应请求。

47. 内存对齐？内存对齐发生在哪一层？我可以不对齐吗？

字节跳动 · 基础架构一面

腾讯 TEG 一面

内存对齐的本质目的是：为了让 CPU 访问内存时更加高效，避免跨越多个存储单元（比如 cache line 或总线周期），减少访问次数和性能开销。

不对齐会导致：

读取数据跨多个内存块或 cache line；
可能需要多次访存、数据拼接；
某些平台（如 ARM）甚至直接报错。

为什么内存对齐能减少访存次数？

现代 CPU 是以“块”单位读取数据的，比如 64 字节的 cache line。

如果数据起始地址对齐，就能在一个 cache line 内读完，一次访问就搞定；但如果不对齐，数据可能跨两个块，就会导致：

CPU 需要 两次访问 才拿到完整数据；
多占用一次 cache、总线带宽；
增加延迟、降低效率。

所以对齐能保证数据落在一个块内，提高命中率，减少访存。

内存对齐是在哪一存储层次对齐的？

主要是在这两个层次【🔥字节面试官说是在 L1 Cache，主要还是为了在同一个 cacheline 中访问】：

内存 → Cache（尤其是 L1 Cache）之间：为了避免数据跨多个 cache line（通常是 64 字节）导致多次 cache 访问
总线传输层（memory bus）：CPU 和内存之间的数据传输有对齐要求，总线通常按 4 字节、8 字节或更大位宽传输数据，不对齐可能增加传输次数或触发异常

不是针对寄存器本身，寄存器只是最终使用数据的地方。对齐主要作用在数据加载阶段（load from memory），不是计算阶段。

48. CPU 读取数据的工作流？

CPU 读取数据时，首先在高速缓存（L1/L2/L3）中查找，若命中则直接返回；若未命中，则通过内存管理单元（MMU）将虚拟地址转换为物理地址，并访问主存（DRAM）加载数据块（缓存行），同时将其填入缓存。

若数据不在主存，会触发缺页异常，由操作系统从磁盘交换空间调入所需内存页，再重新执行访问。

49. 计算机存储层次结构各层的典型访问粒度和时延

| 存储层次 | 访问粒度 | 访问时延 | 备注 | | :-------------- | :---------------- | :---------- | :---------------------------------- | | CPU 寄存器 | 4-8 字节 | ~0.3-0.5 ns | 直接与ALU交互，速度最快 | | L1 缓存 | 64 字节（缓存行） | ~0.5-1 ns | 分指令与数据缓存，核心独享 | | L2 缓存 | 64 字节（缓存行） | ~3-10 ns | 通常为核心独享或共享 | | L3 缓存 | 64 字节（缓存行） | ~10-20 ns | 多核心共享，容量更大 | | 主存 (DRAM) | 4KB (页) / 64字节 | ~50-100 ns | 通过内存总线访问，需MMU转换虚拟地址 | | SSD (NVMe) | 4KB (页) | ~10-100 μs | 需通过PCIe总线，涉及驱动和中断处理 | | HDD (磁盘) | 512B-4KB (扇区) | ~5-10 ms | 含寻道时间和旋转延迟，机械操作慢 | | 网络存储 | 可变 (通常≥1KB) | ~1-100 ms | 受网络延迟和协议开销影响极大 |

50. fork 16 GB 会发生什么？

小红书搜广推 C++ 一面

主要考察写时复制

当进程调用 fork 时，操作系统会创建原进程的完整副本，包括 16 GB 内存空间，但由于写时复制（Copy-on-Write）机制，实际物理内存不会立即翻倍，而是父子进程共享同一物理内存，仅当任一进程尝试修改内存页时，才会为该页创建独立副本，因此 fork 后初始内存占用几乎不变，但后续可能因写入操作导致内存逐渐增加。

51. 进程启动流程

高德 C++ 一面

进程启动流程是操作系统将磁盘上的可执行文件加载到内存并开始执行的完整过程，主要包括以下步骤：Shell 解析命令后调用 fork 创建新进程，接着通过 exec 系列函数加载可执行文件，操作系统读取文件头获取代码段、数据段等信息，分配内存空间并建立虚拟内存映射，将程序段加载到指定内存地址，初始化 BSS 段为零，设置程序计数器指向入口点（如 C 语言的 main 函数），最后从用户态跳转到程序入口开始执行。

1. 完整的进程启动流程

// 以执行 ./myprogram arg1 arg2 为例的完整流程

用户输入命令
    ↓
Shell解析命令和参数
    ↓  
fork() 创建子进程
    ↓
子进程调用 execve() 系统调用
    ↓
操作系统加载器工作：
   - 验证可执行文件格式
   - 读取程序头表
   - 分配虚拟地址空间
   - 建立内存映射
   - 加载代码段、数据段
   - 初始化BSS段为0
    ↓
设置进程上下文：
   - 初始化寄存器
   - 设置栈指针
   - 传递环境变量和参数
    ↓
动态链接（如果需要）：
   - 加载共享库
   - 重定位符号地址
    ↓
跳转到程序入口 _start
    ↓
调用 __libc_start_main
    ↓  
调用 main() 函数
    ↓
程序开始执行用户代码

2. 关键阶段详细说明

阶段1：创建进程 - fork()

#include <unistd.h>
#include <iostream>

// Shell 中执行的大致等价代码
void shell_execute(const char* program, char* const argv[]) {
    pid_t pid = fork();  // 创建子进程副本
    
    if (pid == 0) {
        // 子进程
        execve(program, argv, environ);  // 加载新程序
        // 如果execve成功，不会返回
        std::cerr << "执行失败" << std::endl;
        exit(1);
    } else {
        // 父进程 (Shell) 等待子进程
        waitpid(pid, nullptr, 0);
    }
}

阶段2：加载程序 - execve()

// execve 系统调用的核心工作：
// 1. 验证文件格式（ELF、Mach-O等）
// 2. 替换当前进程的地址空间
// 3. 设置新的内存映射
// 4. 初始化堆栈段

// 内存映射建立过程：
// +---------------------+
// |       栈段          | ← 包含 argc, argv, envp
// +---------------------+
// |       堆段          | ← 初始为空
// +---------------------+
// |       BSS段         | ← 未初始化数据（清零）
// +---------------------+
// |      数据段         | ← 已初始化全局变量
// +---------------------+
// |      代码段         | ← 程序指令
// +---------------------+

阶段3：程序初始化 - _start 到 main

// 实际的启动顺序（由链接器安排）：
// _start (汇编入口) → __libc_start_main → main

// 典型的 _start 实现（简化）：
void _start() {
    // 初始化基础环境
    long argc = *((long*)((char**)&argc - 1));
    char** argv = (char**)((char**)&argc + 1);
    char** envp = argv + argc + 1;
    
    // 调用libc初始化
    __libc_start_main(main, argc, argv, 
                      __libc_csu_init, 
                      __libc_csu_fini, 
                      NULL);
}

3. 实际代码示例

完整的进程创建示例

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char* argv[], char* envp[]) {
    std::cout << "父进程 PID: " << getpid() << std::endl;
    
    pid_t pid = fork();
    
    if (pid == -1) {
        std::cerr << "fork 失败" << std::endl;
        return 1;
    } else if (pid == 0) {
        // 子进程
        std::cout << "子进程 PID: " << getpid() << std::endl;
        
        // 准备新程序的参数
        char* new_argv[] = {"/bin/ls", "-l", nullptr};
        char* new_envp[] = {"PATH=/usr/bin", nullptr};
        
        // 执行新程序（替换当前进程映像）
        execve("/bin/ls", new_argv, new_envp);
        
        // 只有execve失败才会执行到这里
        std::cerr << "execve 失败" << std::endl;
        return 1;
    } else {
        // 父进程
        std::cout << "父进程等待子进程 " << pid << std::endl;
        waitpid(pid, nullptr, 0);
        std::cout << "子进程执行完毕" << std::endl;
    }
    
    return 0;
}

理解程序参数传递

#include <iostream>

// 观察启动时的参数和环境变量
int main(int argc, char* argv[], char* envp[]) {
    std::cout << "参数个数: " << argc << std::endl;
    
    // 打印所有参数
    for (int i = 0; i < argc; ++i) {
        std::cout << "argv[" << i << "]: " << argv[i] << std::endl;
    }
    
    // 打印环境变量（前10个）
    std::cout << "\n环境变量:" << std::endl;
    for (int i = 0; envp[i] != nullptr && i < 10; ++i) {
        std::cout << "envp[" << i << "]: " << envp[i] << std::endl;
    }
    
    return 0;
}

// 编译后运行：./program arg1 arg2
// 输出：
// 参数个数: 3
// argv[0]: ./program
// argv[1]: arg1  
// argv[2]: arg2

4. 动态链接过程

// 对于动态链接的程序，启动还包括：

// 1. 加载动态链接器 (ld-linux.so)
// 2. 解析程序依赖的共享库
// 3. 重定位符号地址
// 4. 执行共享库的初始化代码

// 可以使用 ldd 查看依赖：
// $ ldd /bin/ls
//     linux-vdso.so.1
//     libselinux.so.1 => /lib/x86_64-linux-gnu/libselinux.so.1
//     libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6

5. 内存布局初始化

// 进程启动后的典型内存布局：

#include <iostream>
#include <cstdlib>

int global_var = 100;                    // 数据段
const int const_global = 200;            // 只读数据段  
int uninit_global;                       // BSS段

int main() {
    int local_var = 300;                 // 栈
    static int static_local = 400;       // 数据段
    int* heap_var = new int(500);        // 堆
    
    std::cout << "代码段: " << (void*)main << std::endl;
    std::cout << "数据段: " << &global_var << std::endl;
    std::cout << "只读数据: " << &const_global << std::endl;
    std::cout << "BSS段: " << &uninit_global << std::endl;
    std::cout << "栈: " << &local_var << std::endl;
    std::cout << "堆: " << heap_var << std::endl;
    
    delete heap_var;
    return 0;
}

6. 关键系统调用

// 进程启动涉及的主要系统调用：

// 1. fork() - 创建进程副本
// 2. execve() - 加载新程序
// 3. mmap() - 内存映射（文件、堆等）
// 4. brk()/sbrk() - 调整堆大小
// 5. mprotect() - 设置内存保护

// 可以使用 strace 跟踪：
// $ strace -f ./myprogram

总结要点

进程启动的核心步骤：

进程创建 - fork() 复制当前进程
程序加载 - execve() 替换地址空间
内存初始化 - 建立代码段、数据段、堆栈段
动态链接 - 加载共享库并重定位
环境设置 - 传递参数和环境变量
执行跳转 - 从 _start 到 main

面试回答关键点：

理解 fork + execve 的分工
知道内存各段的初始化顺序
了解参数和环境变量的传递机制
清楚动态链接的基本过程
明白用户态到程序执行的转换

52. 动态库文件结构

动态库（共享库）的文件结构是基于标准格式（如ELF on Linux, Mach-O on macOS, PE on Windows）组织的，它包含代码段、数据段、符号表、重定位表、动态段和依赖信息等部分，使得库可以在运行时被多个进程共享加载。其核心特点是代码位置无关（PIC），通过过程链接表（PLT）和全局偏移表（GOT）实现延迟绑定，从而支持动态链接和内存共享。

53. 动态链接过程

动态链接流程是程序运行时将可执行文件与其依赖的共享库进行连接的过程，主要分为加载时链接和运行时链接两个阶段：首先动态链接器加载程序依赖的所有共享库并解析符号引用，通过全局偏移表（GOT）和过程链接表（PLT）实现延迟绑定，在首次调用函数时进行符号解析和重定位，最终建立完整的执行环境。

程序启动
    ↓
内核加载可执行文件
    ↓
检查 .interp 段找到动态链接器 (ld-linux.so)
    ↓
将控制权交给动态链接器
    ↓
链接器自举初始化
    ↓
加载程序本身的动态段 (.dynamic)
    ↓
递归加载所有依赖的共享库
    ↓
符号解析和重定位：
   - 建立符号哈希表
   - 解析未定义符号
   - 重定位 GOT/PLT 条目
    ↓
执行共享库的初始化函数 (.init)
    ↓
将控制权交回程序入口 (_start)
    ↓
程序开始执行，使用延迟绑定：
   - 首次调用函数 → PLT → 动态链接器解析
   - 解析结果填入 GOT
   - 后续调用直接跳转

54. 进程 vs 线程

地址空间：进程有独立虚拟地址空间；同一进程内的线程共享地址空间与大部分资源（堆、静态区、文件描述符等）。
资源/隔离：进程隔离强、崩溃不互相影响；线程隔离弱、一个线程越界可能拖垮整个进程。
调度/开销：创建/切换进程开销普遍高于线程；线程更轻量，适合密集并发。
通信：进程需 IPC；线程直接读写共享内存但必须同步（锁/原子/条件变量等）。

55. 进程间通信（IPC）& 常用的

管道/命名管道（pipe/FIFO）：简单、单主机、字节流；父子/同机进程。
UNIX 域套接字：同机、支持数据+FD 传递、语义和 TCP 类似；服务化常用。
TCP/UDP 套接字：跨机器通信；TCP 有序可靠，UDP 低延迟。
共享内存（POSIX shm/System V）+ 同步原语（信号量/互斥量/futex）：最高吞吐，但自己保证并发正确性。
消息队列（POSIX/System V）：内核队列，结构化消息。
mmap/内存映射文件：文件即内存，适合大文件、零拷贝。
更上层：gRPC/Thrift、DBus 等做序列化与服务发现。

工程里最常用：UNIX 域套接字、共享内存+锁、TCP、mmap、gRPC。

56. 操作系统分配给进程的资源

虚拟地址空间（代码/数据/堆/栈、mmap 区域）、页表
打开的文件描述符/套接字、工作目录、umask
进程号/父子关系、凭据（uid/gid/capabilities）
信号处置表、定时器、线程与它们的栈
IPC 对象（共享内存、信号量、消息队列）
调度份额/优先级、cgroup/命名空间限制（在容器场景）

57. 为什么采用分页而不是分段？

结论：现代通用 OS 以分页为主，段仅用于极少量兼容/逻辑标记。

分页（固定大小，如 4KiB）优势
- 无外部碎片（只在最后一页可能有内部碎片）。
- 硬件简单：页表 + TLB；易做按需分配/缺页换入/写时复制。
- 保护与共享粒度统一（页为单位映射/权限）。
分段（可变长）劣势
- 易产生外部碎片，需要紧缩/搬移。
- 硬件复杂（段表 + 段间跨越处理），与换页/缓存局部性冲突。
- x86-64 实际上把大多数段功能弱化/屏蔽，保护依赖分页。
折中：逻辑上“分段”（代码/数据/堆/栈），实现上“分页”。

追问：大页（2MiB/1GiB）？——仍是分页，只是页更大以降低 TLB 压力；映射策略而非分段回潮。

58. 断电下如何保证数据完整性（非原子操作）

按层分：应用 → 文件系统 → 块设备/存储。

应用层模式
- 写临时文件 + fsync + rename 原子替换：write(tmp) → fsync(tmp) → rename(tmp, real)；POSIX 保证 rename 原子。
- 双写/版本号：旧版本保留，新版本落盘并写入更高版本号，恢复时选最大有效版本。
文件系统层
- Journaling（ext4/XFS/NTFS）：先把元数据变化（可选含数据）写入日志区并 fsync，再应用到主区；崩溃后重放日志。
  - ext4 模式：journal（数据+元数据）、ordered（默认：元数据入日志，数据先落盘）、writeback（只记元数据，吞吐高、风险大）。
- COW（btrfs/ZFS）：写新位置、最后原子切换根指针，天生避免部分写撕裂；配合校验和端到端检测损坏。
存储层
- 写屏障/缓存刷写：强制控制顺序（FUA/flush），避免控制器缓存丢电。
- 带断电保护的设备（电容/电池）避免 cache 丢失。

误区：只 fsync(fd) 不 fsync(dir)。——创建/rename 后应 fsync 其所在目录，确保目录项持久。

59. 写前日志（WAL）详细机制（ARIES 思想）

目标：崩溃后保证持久化一致性，支持 Steal/No-Force（页可被偷刷，提交不强制写页）。

核心规则（WAL rule）：日志先于数据落盘。任何页写出前，相关日志记录（含 LSN）必须已稳定落盘。
日志记录（物理/生理混合）：事务 id、页 id、偏移、旧值/新值、LSN；每个数据页保存 pageLSN（最新应用日志的 LSN）。
提交路径：
1. 事务产生修改 → 生成日志（append-only）。
2. fsync(log) 成功即提交完成（No-Force），数据页稍后异步刷。
Checkpoint（“模糊”快照）：记录脏页表（DPT）与活跃事务表，无需停世界。
崩溃恢复三阶段：
1. Analysis：扫描日志，重建 DPT/活跃事务集。
2. Redo（重复历史）：从最早需要的 LSN 开始，只对 pageLSN < record.LSN 的页重做，保证持久化到崩溃点。
3. Undo：对未提交事务按时间倒序回滚，写**补偿日志（CLR）**以实现幂等/可重入回放。
页写出判定：写页时带上其 pageLSN；重做阶段据此判“是否需要重放”。
优化：组提交（group commit）、对齐日志块、校验和、日志切段/归档。

常见坑：未严格保证“日志先行”导致撕裂页不可重做；把日志与数据放同一易丢电缓存而缺少写屏障。

2025 互联网秋招进行时指南

Fri, 22 Aug 2025 00:00:00 GMT

面试篇

精简化回答

一般面试主要由以下几个环节组成：

自我介绍
个人项目
项目介绍
重点难点新颖点
知识点深挖
八股文问答
手撕算法题

并不是每一场面试都会按照这几个环节来，不同的公司可能各自的侧重点不同，比如腾讯会把重点放在八股文问答环节，考察你对基础知识的掌握。

但不管怎样，我们在面试前都可以按照这个流程来去准备，并且在这个过程中，我们一定要养成一个能力：用最精练的语言回答问题。

这句话很好理解，例如自我介绍时，要尽可能在 1 分钟左右将自己的背景、荣誉、论文、奖项等有助于突出个人优势的经历展现出来，这点相信大家都有所准备。但是对于个人项目介绍环节，有些人可能会因为项目体量稍大、涉及知识点稍多等原因开始进行长篇大论式的介绍，这是非常忌讳的，过多的阐述反而会让人找不到重点，大部分面试官也都没有耐心听你讲很多，所以建议大家私下准备时可以手动对项目做个精简的总结，比较推荐的做法是「仿照论文」的写法：

XX 是一个关于 XX 方面的项目，主要实现了 XX（挑最核心的）能力，该项目实现过程中遇到的重点难点为 XX，为了解决该问题，本文采用了 XX 的方法，对比业内现有方案，本项目的优势主要在于 XX。

当然简历上项目的写法也可以按照这个格式，不过纵使项目涉及的点很多也不要写过多内容，挑最核心的就可以，其余内容在面试官深入挖掘该项目时再进行补充即可。

精简化回答的能力体现出的是个人思维的敏捷性以及言语表达能力，面试官也尤为在意，因此面试者应该日常注重培养该能力。

记录并总结每一场面试

中国的学生们最擅长的就是考试，每一场考试后我们会总结出错题和遗漏的知识点来查漏补缺，同时还会购买一些辅助资料来学习专家为我们总结的知识点，又或是买一些真题卷来为考试做模拟演练，不管怎样，我们的目的只有一个，那就是在下一场考试做得更好。

面试也是同样的道理，在秋招中我们可能会经历数十场面试，在每一次面试结束后我们都应该回顾这场面试的主要内容并记录下答得不好的地方，面试后再通过搜集资料对这些问题进行修正，在之后的每一场面试前我们都应该重新回顾这些内容。

除开从亲身参与的面试中获取经验外，我们还可以在牛客等平台去看别人分享的面试记录，如果发现有自己不懂的地方也应该及时记录下来，并且在空余的时间，我们可以发散思维，从自己记录的内容里引申出一些面试可能会涉及的别的认识点，这样可以逐步扩充我们的知识库。

上述记录并总结的过程推荐借助 AI 来高效完成。

总结

offer 选择篇

具体岗位方向的决定（技术➕业务）

虽然我们在面试前已经确定了未来就业的一个大致方向，例如是算法岗还是研发岗，但对于具体细致的方向很多人没有一个明确的想法，实际上岗位投递时我们能选择某个岗位但至于具体做哪方面的内容也是不确定的，这样就会导致大家在收到多个 offer 后会很纠结到底该怎么选择。

但不管怎么样，任何岗位的职责都可以被定义为业务➕技术的组合，这里可以拿抖音举例，大公司一般都会建设一套庞大的研发体系，上层重业务，下层重技术，其对应的发展路线也是截然不同的。

对于基础架构岗位比如数据库内核分布式存储等，业务与技术是高度重合的，你需要 follow 业内最先进的技术并想办法应用到你的工作中，因此掌握并应用技术就是你的业务。
对于业务研发岗位技术与业务重合度要小很多，你的工作中可能不会涉及到很高大上的技术（代码主要涉及 crud），但你的重心需要 focus 在业务模型中，对于重业务的岗位其业务模型是相当复杂的，你在工作中的成长主要是对整个业务模型有更深入的了解。

关于二者孰好孰坏很难给个结论，有人觉得做纯技术岗完全是给业务打工，毕竟技术是要服务于业务的，但也有很多人觉得业务岗纯 crud 岗，没什么技术含量，当然实际情况是复杂的，我这里主要是想给大家做一个更细致的说明，至于具体的抉择大家可以参考下图给出的三个关注点，另外我们拿到 offer 后最好让 hr 安排一个员工跟我们对接了解一下具体工作内容，而不是直接在网上求助，网友只能给一个模糊的答案。

当然，我觉得校招方向的选择也不用太过于纠结，职业生涯才刚开始，未来还有很多机会，所以放心大胆的做决定吧。

薪资 argue

关于薪资的等级普遍被划分为「白菜、SP、SSP」三个等级，那如何拿到高等级呢？本人特别优异是一方面，学会与 hr 博弈是另一方面，hr 的绩效就是用尽可能少的钱招到优秀的人力，如果你别无选择，哪怕你真的很优秀 hr 也会压低你的薪资，因此建议 offer 能多拿就多拿。

致 2026 年毕业正在秋招的你

下文链接：timeErrors

秋招并非完全和它的名字一样，秋招并非是只有秋天才招聘，近些年来夏天也会招聘

我是 25 年毕业的，当年拿过一些 ssp，比如阿里云啥的，当然是比较久远的事了，现在进厂了，虽然才入职一个来月，但和当年很不一样了，时间就很紧张，一些准备上的东西我就不说了，比如什么时候投递，简历怎么写，怎么准备笔试，八股等等，牛客上都有很好的经验贴之类，我挑一些我认为很重要的点来讲吧，下面是个人感受和观点，并不一定正确，仅供参考。

简单来讲就是：想好目的，降低预期，接受现实。

最重要的就是心态，不要过度提高自己的预期，也不要因为一两次失利而气馁。

于秋招而言，特别是从业于互联网，根据我院我熟知的周围起码二三十人去大厂的人来看，几乎没有人可以最终选出来一个满意的 offer，大部分人都是选了个差不多可以接受的，尽管大家基本都是 5、6 个 offer 往上，且基本都有 ssp，而且非常普遍的一个现象就是来互联网的大家都很累，只是谁更累而已，据我观察，十点左右走是一个比较符合大家从公司跑路的时间，不乏有干到 1、2 点甚至 3、4 点的人。

所以去互联网，只有钱多累，和钱少累两种，而且要么是心累，要么身体累，更有甚者两者都累，两者都累建议尽早跑。

于工作而言，因为去哪里都很累，所以其他因素就不得不考虑，这些年进厂的感受，应该着重考虑下面几点：

心累 > 身体累，即组里的氛围是很需要看中的，如果你的老板或者同事天天 pua 你，总是告诉你你什么都干不好，那我想干起来也是相当难受的。但恰巧这一点是最难判断的，你问老板组里氛围怎么样，就和问买水果的老板这瓜甜不甜一样，老板肯定说没有不甜的瓜。身体累顾名思义，就是加班，这里建议问问 HR，加班是调休还是双倍薪资，给自己卖一个合适的预期，比如有人就喜欢双倍薪资，有人就喜欢调休，当然绝大多数人都不喜欢加班，但这不是没办法吗
业务稳定/上升，业务稳定，意味着你要做的工作不会特别赶，简称你可以早点下班，少加点班，因为需求不会那么多和那么着急，反正业务用了很多年，也不差这一会，但这也有可能意味着你的晋升或者跳槽认可度略低，这点很容易理解，晋升是因为前面可能有很多老兵排着，跳槽和工作量某种程度上挂钩，产出少了自然不好包装自己。业务上升又是另一个极端，产品迭代快，需求多，需求高强度的加班。但在互联网，并不是你干的多就升的快，只是业务稳定/上升代表着这个部门突然消失的概率要小些，也意味着你不容易试用期就被裁掉（如果业务稳定的部门突然招了很多人，需要警惕下，老板估计是要整什么大活了）
拥抱变化，互联网总是很喜欢拥抱变化，即你曾经或许实习的组氛围什么都不错，但你真正入职可能就变了，一年在互联网里是很长的一段时间，一年前京东还不搞外卖，淘宝还没有闪购，deepseek 还没有出世，百度还在讲闭源模型一定比开源牛逼，gpt 还是稳压 gemini。身边有不少人，要么入职的时候组没了，要么那个组多发了 hc，结果 ta 入职到别的组去了等等。当然这种事情也可以和老板 HR 确认，只是说怎么确认都会有不确定性，做好拥抱变化的准备，随遇而安吧

offer 选择

如果决定来互联网，有大厂选大厂，这意味着你的机动性会更高些，谁也不知道入职后会不会踩坑，大厂会比中小厂在跳槽的时候容错会更高些，如果都是大厂，除了上面几点外，其余就是向钱看了，至于什么大厂间不同的 title，toc/tob，核不核心，其实没那么重要，自己干的舒服是最重要的，舒服这个定义现在很廉价，就是一个正常的老板，正常的业务，正常的同事而已，但实现这一点很难。

所以我建议，一定要想好自己为什么要来互联网，你的目标是什么，这一点很重要，人还是需要一点理想主义的，如果为了狠狠赚一笔来，其实会在工作中怀疑自己：我真的需要这么多钱吗？因为大多数人是没有时间花掉这些钱的，至于白菜，sp，ssp 的分级，其实在扣完一大堆税到手后，并没有想象中差距那么大。

✍️ 比较是偷走幸福的贼~

以及脉脉等平台上的消息需要甄别下，很多老哥喜欢反串，很多消息保真，但更多消息是不保真的，工作是没有十全十美的，现在想要找一个晋升快，氛围好，不累，没杂活的组，几乎是不存在的。就是大家最终选的 offer 一定是或多或少有坑的，只是看最终能接受什么样的坑。此外针对于大部门的好坏评价基本上和自己无关，大部门可以理解为 +3 及以上这种，这种体量下，不可能有任何一个大部门永远保持无差评，但自己的入职后体验基本上只取决于你的 +1 和 mt 怎么样。

一年前的时候面百度，当时刚从阿里出来，面试管说，别因为某些人/事把自己对技术的一份热爱磨灭了，那样生活就失去了很多乐趣，不好的地方可以尽早换，不管是在福报厂还是宇宙厂还是兄弟厂，人活的自在开心有价值是最重要的，否则都是浮云了。

个人的命运，当然要靠自我奋斗，但也要考虑到历史的行程，但不幸的是，现在历史的进程并不乐观。

我引用一段话作为结尾吧：在比较小的时候，大约就是初中高中吧，我对自己人生结果充满幻想和期待。但慢慢长大之后，方才意识到生活是如此复杂，我不得不学着对内心的期望放手，曾经的梦想在残酷的现实面前变得褪色。此时，怜悯自己显得很重要，或许你可以对自己说“我也想要做得更好”以及“就让它这样吧，其实这样也好”。

是的，我已经做得足够好了，因为至少现在我还爱着自己｡

八股文 @ C++

Fri, 22 Aug 2025 00:00:00 GMT

✍️ C++ 11 新特性大全：https://zhuanlan.zhihu.com/p/139515439

1. GCC 编译流程｜编译与汇编的区别

参考链接：https://developer.aliyun.com/article/1650283

一段高级语言代码经过四个阶段的处理形成可执行的目标二进制代码。

预处理器→编译器→汇编器→链接器：最难理解的是编译与汇编的区别。

这里采用《深入理解计算机系统》的说法。

预处理阶段：预处理阶段主要处理 #include 指令、宏替换、条件编译等，生成 .i 文件。

展开头文件：将 #include 指定的文件插入到源代码中
宏替换：替换所有 #define 定义的宏
条件编译：根据预处理指令（如 #ifdef）选择性地编译代码
去除注释：删除源代码中的注释内容

写好的高级语言的程序文本比如 hello.c，预处理器根据 # 开头的命令，修改原始的程序，如 #include<stdio.h> 将把系统中的头文件插入到程序文本中，通常是以 .i 结尾的文件。

gcc -E source.c -o source.i

编译阶段：编译阶段对源代码进行语法语义检查，生成汇编代码，产生 .s 文件。

编译器将 hello.i 文件翻译成汇编语言程序 hello.s，不同的高级语言翻译的汇编语言相同。

gcc -S source.i -o source.s

汇编阶段：汇编阶段将汇编代码翻译成机器码（机器可识别的目标代码），生成 .o 目标文件。

汇编器将汇编代码 hello.s 翻译成机器语言指令。把这些指令打包成可重定位目标程序，即 .o 文件。hello.o 是一个二进制文件，它的字节码是机器语言指令，不再是字符，前面两个阶段都还有字符。

gcc -c source.s -o source.o

链接阶段：链接阶段将多个目标文件和库文件链接在一起，生成最终的可执行文件，链接过程还可能会调用外部的动态或静态库。

比如 hello 程序调用 printf 程序，它是每个 C 编译器都会提供的标准库 C 的函数。这个函数存在于一个名叫 printf.o 的单独编译好的目标文件中，这个文件将以某种方式合并到 hello.o 中。链接器就负责这种合并，得到的是可执行目标文件。

gcc source.o -o executable

关于编译优化：

GCC 和 G++ 提供了多种优化选项，开发者可以根据项目需求选择合适的优化级别

| 优化级别 | 描述 | | -------- | ------------------------------------------ | | -O0 | 无优化（默认） | | -O1 | 基本优化 | | -O2 | 在不显著增加编译时间的前提下进行进一步优化 | | -O3 | 启用所有优化选项，可能导致代码体积增加 | | -Os | 优化代码体积，适用于存储受限的设备 |

2. C 和 C++ 区别（函数/类/struct/class）

首先，C 和 C++ 在基本语句上没有过大的区别。

C++ 有新增的语法和关键字：

语法的区别有头文件的不同和命名空间的不同，C++ 允许我们自己定义自己的空间，C 中不可以。
关键字方面比如 C++ 与 C 动态管理内存的方式不同，C++ 中在 malloc 和 free 的基础上增加了 new和 delete，而且 C++ 中在指针的基础上增加了引用的概念，关键字例如 C++中还增加了 auto，explicit 体现显示转换和隐式转换上的概念要求，还有 dynamic_cast 增加类型安全方面的内容。

函数方面 C++ 中有重载和虚函数的概念：

C++ 支持函数重载而 C 不支持，是因为 C++ 函数的名字修饰与 C 不同，C++ 函数名字的修饰会将参数加在后面，例如，int func(int, double) 经过名字修饰之后会变成 _func_int_double，而 C 中则会变成_func，所以 C++ 中会支持不同参数调用不同函数。
C++ 还有虚函数概念，用以实现多态。

类方面，C 的 struct 和 C++ 的类也有很大不同：

C++ 中的 struct 不仅可以有成员变量还可以成员函数，而且对于 struct 增加了权限访问的概念，struct 的默认成员访问权限和默认继承权限都是 public，C++ 中除了 struct 还有 class 表示类，struct 和 class 还有一点不同在于 class 的默认成员访问权限和默认继承权限都是 private。

C++ 中增加了模板来重用代码，提供了更加强大的 STL 标准库。

最后补充一点就是 C 是一种结构化的语言，重点在于算法和数据结构。C 程序的设计首先考虑的是如何通过一个代码，一个过程对输入进行运算处理输出。而 C++ 首先考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题领域，这样就能通过获取对象的状态信息得到输出。

C 的 struct 更适合看成是一个数据结构的实现体，而 C++ 的 class 更适合看成是一个对象的实现体。

3. C++ 和 JAVA 区别（语言特性、垃圾回收、应用场景等）

本人 C++ 和 Java 都有染指。

指针：Java 让程序员没法找到指针来直接访问内存，没有指针的概念，并且有自动内存管理功能，从而有效地防止了 C++ 语言中的指针操作失误的影响。但并非 Java 中没有指针，Java 虚拟机内部中还是使用了指针，保证了 Java 程序的安全性。

多重继承：C++ 支持多重继承但 Java 不支持，但支持一个类继承多个接口，实现 C++ 中多重继承的功能，又避免了 C++ 的多重继承带来的不便。

数据类型和类：Java 是完全面向对象的语言，所有的函数和变量必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，对象将数据和方法结合起来，把他们封装在类中，这样每个对象都可以实现自己的特点和行为。Java 中取消了 C++ 中的 struct 和 union。

自动内存管理：Java 程序中所有对象都是用 new 操作符建立在内存堆栈上，Java 自动进行无用内存回收操作，不需要程序员进行手动删除。而 C++ 中必须由程序员释放内存资源，增加了程序设计者的负担。Java 中当一个对象不再被使用时，无用内存回收器将给他们加上标签，Java 里无用内存回收程序是以线程方式在后台运行，利用空闲时间工作来删除。

Java 不支持操作符重载，操作符重载是 C++ 的突出特性。

Java 不支持预处理功能，C++ 在编译过程中都有一个预编译阶段，Java 没有预处理器，但它提供了 import，与 C++ 预处理器具有类似功能。

类型转换：C++ 中有数据类型隐含转换的机制，Java 中需要显式强制类型转换。

字符串：C++ 中字符串是以 NULL 终止符代表字符串的结束，而 Java 的字符串是用类对象（string 和 stringBuffer）来实现的。

Java 中不提供 goto 语句，虽然指定 goto 为关键字，但不支持使用它。

Java 的异常机制用于捕获例外事件，增强系统容错能力。

4. C++ 中 const 和 static 关键字的作用

static

static 作用：控制变量的存储方式和可见性。

1️⃣ 局部静态变量

一般情况下，对于局部变量在程序中是存放在栈区的，并且局部的生命周期在包含语句块执行结束时便也结束了。但是如果用 static 关键字修饰，该变量会存放在静态数据区，作用域仍为局部作用域，但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变。

2️⃣ 全局静态变量

即 static 限制了全局变量的作用域（本文件）

对于一个全局变量，它既可以在本文件中被访问到，也可以在同一个工程其它源文件被访问（添加 extern 进行声明即可）；而使用 static 对全局变量进行修饰改变了其作用域范围，由原来整个工程可见变成了本文件可见，同时也是存放在静态数据区，在整个程序运行期间一直存在。

3️⃣ 静态函数

函数的定义和声明在默认情况下都是 extern 的，但静态函数只是在声明它的文件当中可见（与全局静态变量类似）

4️⃣ 类的静态成员/函数

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此静态成员/函数是类中所有对象共享的成员/函数，而不是某个对象的成员/函数。

在模块内的 static 全局变量可以被模块内所有函数访问，但不能被模块外其它函数访问；
在类中的 static 成员变量属于整个类所拥有，对类的所有对象只有一份拷⻉；
在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的 static 成员变量；
static 类对象必须要在类外进行初始化，static 修饰的变量先于对象存在，所以 static 修饰的变量要在类外初始化；
由于 static 修饰的类成员属于类，不属于对象，因此 static 类成员函数是没有 this 指针，this 指针是指向本对象的指针，正因为没有 this 指针，所以 static 类成员函数不能访问非 static 的类成员，只能访问 static 修饰的类成员；
static 成员函数不能被 virtual 修饰，static 成员不属于任何对象或实例，所以加上 virtual 没有任何实际意义；静态成员函数没有 this 指针，虚函数的实现是为每一个对象分配一个 vptr 指针，而 vptr 是通过 this 指针调用的，所以不能为 virtual；虚函数的调用关系，this->vptr->ctable->virtual function。

const

1️⃣ const 修饰基本数据类型

修饰符 const 可以用在类型说明符前，也可以在类型说明符后，结果都是一样的，使用这些常量时，只要不改变这些常量的值即可。

2️⃣ const 修饰指针变量和引用变量

引用同理

如果 const 位于 const T* 左侧，则 const 就是用来修饰指针所指向的变量，即指针指向为常量。

如果 const 位于 T* const 右侧，则 const 就是修饰指针本身，即指针本身是常量。

3️⃣ const 应用到函数中

作为参数的 const 修饰符：调用函数时，用相应的变量初始化 const 常量，则在函数体中，按照 const 所修饰的部分进行常量化，保护了原对象的属性。
作为函数返回值的 const 修饰符：声明了返回值后，它意味着这个返回值是一个常量，不能被修改。

注意：参数 const 通常用于参数为指针或引用的情况。

4️⃣ const 在类中的用法

const 成员变量：只在某个对象生命周期内是常量，而对于整个类而言是可以改变的（因为类可以创建多个对象，不同对象其 const 数据成员值可以不同，所以不能在类的声明中初始化 const 数据成员，因为类对象在没有创建的时候，编译器不知道 const 数据成员的值是什么，const 数据成员的初始化只能在类的构造函数初始化列表中进行）
const 成员函数：防止成员函数修改对象的内容，要注意，const 和 static 对于成员函数来说是不能同时使用的，因为 static 关键字修饰静态成员函数不含有 this 指针，即不能实例化，const 成员函数又必须具体到某一个函数。

补充：

const 成员函数如果实在想修改某个变量，可以使用 mutable 进行修饰；
成员变量中如果想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现或者 static const。

5️⃣ const 修饰类对象、定义常量函数

const 常量对象只能调用 const 常量函数，非 const 成员函数都不能调用。

原因：对象调用成员函数时，在形参列表的最前面加一个形参 this，但这是隐式的。this 指针是默认指向调用函数的当前对象的，所以很自然，this 是一个常量指针 test * const，因为不可以修改 this 指针代表的地址。但当成员函数的参数列表后加了 const 关键字（void print() const;），此成员函数为常量成员函数，此时它的隐式 this 形参为 const test * const，表示指向常量对象的常量指针，即不可以通过 this 指针来改变指向对象的值。

非常量对象可以调用类中的 const 成员函数，也可以调用非 const 成员函数。

#include <iostream>

class Test {
public:
    Test(int val) : value(val) {}

    // 常量成员函数
    void print() const {
        std::cout << "Value: " << value << std::endl;
    }

    // 非常量成员函数
    void setValue(int val) {
        value = val;
    }

private:
    int value;
};

int main() {
    const Test obj(10);
    obj.print(); // OK，调用常量成员函数
    // obj.setValue(20); // 错误，`const`对象不能调用非常量成员函数
    return 0;
}

⚠️ 注意区别 int print() const; 和 const int print();：

前者为常量成员函数，const 位于函数声明的末尾，只能由 const 常量对象来调用该 const 常量函数。
后者为普通成员函数，但是返回值为 const int（注意不能用 const 修饰 void，即 const void print() 会编译错误，所以这里用了 int）

5. 说一说 C++ 中四种 cast 转换

C++ 中四种类型转换是：static_cast、dynamic_cast、const_cast、reinterpret_cast

const_cast

用于将 const 变量转为非 const 变量：常量指针转换为⾮常量指针，并且仍然指向原来的对象；常量引⽤被转换为⾮常量引⽤，并且仍然指向原来的对象。const_cast 去掉类型的 const 或 volatile 属性。

static_cast

用于各种隐式转换，但是没有运行时类型检查来保证转换的安全性。

比如非 const 转 const，void* 转指针等，static_cast 还可以用于多态向上转换（如 Derived 转 Base，即子类转基类）

进行向上转换（把派生类指针或引用转换为基类）是安全的
进行向下转换（把基类指针或引用转换为派生类），由于没有运行时类型检查，所以是不安全的

// Base 是 Derived 的基类/父类
int main() {
    Derived* d;
    Base* base = static_cast<Base*>(d);	// 向上类型转换
    base->show();
    
    return 0;
}

dynamic_cast

在进行向下转换时，dynamic_cast 具有类型检查（信息在虚函数中）的功能，比 static_cast 更安全。

只能用于含有虚函数的类，用于类层次间的向上和向下转换（基类转子类），只能转指针或引用，向下转换时：

对于指针，转换失败则返回 nullptr
对于引用，转换失败则抛异常

int main() {
    Base* base = new Derived; // 不使用 static_cast 也可以隐式向上转换
    Derived* derive = dynamic_cast<Derived*>(base);	// 向下类型转换，使用 dynamic_cast
    if (derive) {
        derive->show();
    } else {
        std::cout << "Conversion failed!" << std::endl;
    }

    delete base;
    return 0;
}

reinterpret_cast

几乎什么都可以转，比如将 int 转指针，可能会出问题，尽量少用。

WARNING：reinterpret_cast 本质上依赖于机器，要想安全地使用 reinterpret_cast 必须对涉及的类型和编译器实现转换的过程都非常了解。

为什么不使用 C 的强制转换？

C 的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

static_cast 与 dynamic_cast 之间的区别？

dynamic_cast 和 static_cast 的主要区别在于类型检查的时间点和安全性：

类型检查时间点：static_cast在编译时进行类型检查，而dynamic_cast在运行时进行类型检查。
安全性：static_cast不执行运行时类型检查，因此如果在类层次结构中进行不安全的向下转换，可能导致未定义行为。相反，dynamic_cast 会在运行时检查转换的安全性，如果转换不安全，则返回nullptr或抛出异常，提供更高的安全性。

6. C/C++ 的四大内存分区和常量的存储位置

四大内存分区：栈、堆、静态存储区（全局变量 + 静态变量 + 常量）和代码区。

1️⃣ 栈区

由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自动释放栈区内存，不需要用户管理，整个程序的栈区大小可以在编译器中由用户自行设定，VS 中默认的栈区大小为 1M，可以通过 VS 手动更改栈的大小。64 bits 的 Linux 默认栈大小为 10MB，可通过 ulimit -s 临时修改，可通过 ulimit -a 查看。

2️⃣ 堆区

由程序员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。使用 malloc 或者 new 进行堆的申请，堆的总大小为机器的虚拟内存的大小。

说明：new 操作符本质上是使用了 malloc 进行内存的申请，new 和 malloc 的区别如下：

malloc 是 C 语言中的函数，而 new 是 C++ 中的操作符。
malloc 申请之后返回的类型是 void*，而 new 返回的指针带有类型。
malloc 只负责内存的分配而不会调用类的构造函数，而 new 不仅会分配内存，而且会自动调用类的构造函数。

堆和栈的区别

申请方式不同：

栈是系统自动分配
堆是自己申请和释放的

申请大小限制不同：

栈空间默认 10 MB；栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改
堆区一般是 1G~4G；堆向高地址扩展，是不连续的内存区域，大小可以灵活调整

申请效率不同：

栈由系统分配，速度快，不会有碎片
堆由程序员分配，速度慢，且会有碎片

栈快还是堆快？

毫无疑问是栈快一点。

因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。

而堆的操作是由 C/C++ 函数库提供的，在分配堆内存的时候需要一定的算法寻找合适大小的内存。并且获取堆的内容需要两次访问，第一次访问指针，第二次根据指针保存的地址访问内存，因此堆比较慢。

3️⃣ 静态存储区

静态存储区 = 全局数据区 + 常量区

全局数据区：全局变量 + 静态变量，该区域会被自动初始化

常量区：存放常量，不允许修改

静态存储区内的变量在程序编译阶段已经分配好内存空间并初始化。这块内存在程序的整个运行期间都存在，它主要存放 static 静态变量、全局变量和 const 常量。

区分：static 修饰「局部变量」在静态存储区中；const 修饰「局部变量」则是在栈区中。

注意：

这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。
静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。
字符串常量存储在静态存储区的常量区，字符串常量的名称即为它本身，属于常变量。
数据区的具体划分，有利于我们对于变量类型的理解。不同类型的变量存放的区域不同。后面将以实例代码说明这四种数据区中具体对应的变量。

4️⃣ 代码区

存放程序体的二进制代码，比如我们写的函数都是在代码区。

int a = 0;//静态全局变量区
char *p1; //编译器默认初始化为NULL
void main()
{
    int b; //栈
    char s[] = "abc";//栈
    char *p2 = "123456";//123456在字符串常量区，p2在栈上
    static int c =0; //c在静态变量区，0为文字常量，在代码区
    const int d=0; //栈
    static const int d;//静态常量区
    p1 = (char *)malloc(10);//分配得来得10字节在堆区。
    strcpy(p1, "123456"); //123456放在字符串常量区，编译器可能会将它与p2所指向的"123456"优化成一个地方
}

7a. C++ 中 class 的大小由哪些因素决定？

在 C++ 中，类的大小由多个因素决定，主要包括：

普通成员变量：类中定义的非静态成员变量会直接影响类的大小。每个成员变量都会占用相应的内存空间。
虚函数：如果类包含虚函数，编译器会为该类添加一个虚函数表（vtable），并在每个对象中添加一个指向该表的指针（vptr），这会增加每个对象的大小。
继承：类的继承关系也会影响其大小。
- 单一继承：派生类会继承基类的成员变量和成员函数，但不会直接增加对象的大小。
- 多重继承：派生类继承多个基类时，可能会导致对象中包含多个基类的子对象，从而增加对象的大小。
- 虚拟继承：为了解决菱形继承问题，编译器可能会在派生类中引入虚拟基类指针，增加对象的大小。
内存对齐：编译器通常会对类的成员变量进行内存对齐，以提高访问效率。这可能导致类的实际大小大于成员变量总和。
- 分配内存的顺序是按照声明的顺序。
- 每个变量相对于起始位置的偏移量必须是该变量类型大小的整数倍，不是整数倍空出内存，直到偏移量是整数倍为止。
- 最后整个结构体的大小必须是里面变量类型最大值的整数倍。

⚠️ 需要注意的是，类的构造函数、析构函数、静态成员变量、静态成员函数和普通成员函数不会直接影响类的大小。

构造函数和析构函数：
- 构造函数和析构函数是特殊的成员函数，用于对象的初始化和销毁。
- 它们的存在不会增加类的实例大小，因为它们在对象创建和销毁时被调用，但并不占用对象的内存空间。
静态成员变量：
- 静态成员变量属于类本身，而不是类的实例。
- 它们在类的所有实例之间共享，只有一份存储空间（静态存储区）。
静态成员函数：
- 静态成员函数也属于类本身，而不是类的实例。
- 它们在类的所有实例之间共享，只有一份存储空间。
普通成员函数：
- 普通成员函数是类的成员，但普通成员函数的代码通常存储在程序的代码段中，而不是对象的内存中。
- 因此，普通成员函数不会影响类的实例大小。

7b. [7a 类似问题] C++ 的对象存储空间是怎么安排的？

C++ 中对象的存储取决于：

对象的类型（普通对象、继承对象、虚函数表等）
存储方式（栈、堆、静态存储区）
对齐方式

具体来说：

1️⃣ 普通对象

（1）非静态成员变量

普通对象的非静态成员变量按照 声明顺序 在内存中存储。
编译器会根据 CPU 架构和优化需求进行 内存对齐（alignment），可能会插入填充字节（padding）。
类的大小通常是 最大成员类型的对齐倍数。

示例：

#include <iostream>

struct A {
    char c;   // 1 字节
    int i;    // 4 字节
};

int main() {
    std::cout << sizeof(A) << std::endl;  // 输出可能是 8（对齐）
    return 0;
}

内存布局（假设 4 字节对齐）：

| c (1B) | padding (3B) | i (4B) |

（2）静态成员变量：不属于对象本身，放在静态存储区，在程序启动时分配。

2️⃣ 继承

（1）非虚继承：没有 virtual

派生类对象包括基类的成员变量，存储顺序是：

基类子成员
派生类新增成员
对齐填充

struct Base {
    int a;
};

struct Derived : public Base {
    char b;
};

int main() {
    std::cout << sizeof(Derived) << std::endl;  // 可能是 8（对齐）
}

内存分布：| Base::a (4B) | Derived::b (1B) | padding (3B) |

（2）虚继承：基类含有 virtual 方法

**虚基类**存储方式不同，编译器会创建虚基类指针 vptr 以及虚基类表 vtable 来管理它
可能会多一个指向虚基类表的指针，因此对象的大小会变大

struct Base {
    int a;
    virtual void func() {}  // 引入虚表
};

struct Derived : public Base {
    char b;
};

int main() {
    std::cout << sizeof(Derived) << std::endl;  // 可能是 16（虚表指针 + 对齐）
}

// 假设指针 8 字节
| vptr (8B) | Base::a (4B) | padding (3B) | Derived::b (1B) |

3️⃣ 多重继承

非虚多重继承：派生类按继承顺序依次存储多个基类的成员变量。
虚多重继承：对象中会存储多个虚表指针，可能引入 虚基类偏移表。

struct A {
    int a;
};

struct B {
    double b;
};

struct C : public A, public B {
    char c;
};

int main() {
    std::cout << sizeof(C) << std::endl;  // 可能是 24（对齐 + 多继承）
}

| A::a (4B) | padding (4B) | B::b (8B) | C::c (1B) | padding (7B) |

4️⃣ 对象存储方式

栈上对象：普通局部对象，生命周期受到作用域控制
堆上对象：使用 new 关键词分配的对象存储在堆区，需要手动 delete
静态存储区：static 变量存储在静态存储区

5️⃣ 虚函数和 vtable 虚表

如果类中有 虚函数，编译器会为该类生成 虚表（vtable），并在对象中存储 虚指针（vptr），指向该虚表。
虚表存储在静态区，而 vptr 存储在对象头部（通常是对象的第一个成员）。
vptr 使得多态调用能够动态绑定。

⚠️ 虚指针存储在对象头部；虚表存储在静态存储区。

8. new/delete 和 malloc/free 有什么区别和联系？

更多内容（讲得很好）：C++ 种内存管理之 new/delete

联系：都可以用来在堆上分配和回收空间，new/delete 是操作符，malloc/free 是库函数。

执行 new 实际上执行两个过程：

调用 malloc 分配未初始化的内存空间
使用对象的构造函数对空间进行初始化，并返回空间的首地址

执行 delete 实际上也有两个过程：

使用析构函数对对象进行析构
调用 free 释放指针所指向空间的内存

二者区别：new 得到的是经过初始化的空间，而 malloc 得到的是未初始化的空间，所以 new 是 new 一个类型，而 malloc 则是 malloc 一个字节长度的空间。delete 和 free 同理，delete 不仅释放空间还析构对象，delete 一个类型，free 一个字节长度的空间。

对象的自动删除

通过之前的分析我们知道，new关键字创建对象并非一步完成，而是通过先分配未初始化内存和调用构造函数初始化两步实现的。那么在这个过程中如果是第一步出错，那么内存分配失败不会调用构造函数，这是没有问题的。但是如果第一步已经完成在堆中已经成功分配了内存之后，在第二步调用构造函数时异常导致创建对象失败（抛出 std::bad_alloc），那么就应该将第一步中申请的内存释放。C++中规定，如果一个对象无法完全构造，那么这个对象就是一个无效对象，也不会调用析构函数。因此为了保证对象的完整性，当通过 new 分配的堆内存对象在构造函数执行过程中出现异常时，就会停止构造函数的执行并且自动调用对应的 delete 运算符来对已经分配好的对内存执行销毁处理，即对象的自动删除技术。

🔥 为什么有了 malloc/free 还需要 new/delete

因为对于非内部数据类型而言，光用 malloc/free 无法满足动态对象的要求。对象在创建的同时需要自动执行构造函数，对象在消亡以前要自动执行析构函数。由于 malloc/free 是库函数而不是操作符，不在编译器控制权限之内，不能够把执行的构造函数和析构函数的任务强加于 malloc/free，所以在 C++ 中需要一个能完成动态内存分配和初始化工作的运算符 new，以及一个能完成清理和释放内存工作的运算符 delete。而且在对非基本数据类型的对象使用的时候，对象创建的时候还需要执行构造函数，销毁的时候要执行析构函数。而 malloc/free 是库函数，是已经编译的代码，所以不能把构造函数和析构函数的功能强加给 malloc/free，所以 new/delete 是必不可少的。

既然 new/delete 的功能完全覆盖了 malloc/free，为什么 C++ 不把 malloc/free 淘汰出局呢？这是因为 C++ 程序经常要调用 C 函数，而 C 程序只能用 malloc/free 管理动态内存。

🔥 malloc 与 free 的实现原理（`brk()`、`mmap()`）

1、在标准 C 库中，提供了 malloc/free 函数分配释放内存，这两个函数底层是由 brk、mmap、munmap 这些系统调用实现的;

brk 是将「堆顶」指针向高地址移动，获得新的内存空间；
mmap 是在进程的虚拟地址空间中（堆和栈中间，称为文件映射区域的地方）找一块空闲的虚拟内存。

这两种方式分配的都是虚拟内存，没有分配物理内存。在第一次访问已分配的虚拟地址空间的时候，发生缺页中断，操作系统负责分配物理内存，然后建立虚拟内存和物理内存之间的映射关系。

2、malloc 分配阈值

malloc 小于 128k 的内存，使用 brk 分配内存，将「堆顶」指针往高地址推；
malloc 大于 128k 的内存，使用 mmap 分配内存，在堆和栈之间找一块空闲内存分配；

brk 分配的内存需要等到高地址内存释放以后才能释放，而 mmap 分配的内存可以单独释放。当最高地址空间的空闲内存超过 128K（可由 M_TRIM_THRESHOLD 选项调节）时，执行内存紧缩操作（trim）。在上一个步骤 free 的时候，发现最高地址空闲内存超过 128K，于是内存紧缩。

3、空闲地址链表：malloc 是从堆里面申请内存，也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。

🔥 被 free 回收的内存是立即返回给操作系统吗？

更详细的内容：

深入理解 glibc malloc: 内存分配器实现原理

xiaolincoding

不一定。被 free 的内存不一定会立刻返回给操作系统，具体行为取决于操作系统的内存管理机制以及 C 语言运行时库（如 glibc）的实现方式。

对于「malloc 申请的内存，free 释放内存会归还给操作系统吗？」这个问题，我们可以做个总结：

malloc 通过 brk() 方式申请的内存，free 释放内存的时候，并不会把内存归还给操作系统，而是缓存在 malloc 的内存池中，待下次使用；
malloc 通过 mmap() 方式申请的内存，free 释放内存的时候，会把内存归还给操作系统，内存得到真正的释放。

什么场景下 malloc() 会通过 brk() 分配内存？又是什么场景下通过 mmap() 分配内存？

malloc() 源码里默认定义了一个阈值：

如果用户分配的内存小于 128 KB，则通过 brk() 申请内存；
如果用户分配的内存大于 128 KB，则通过 mmap() 申请内存；

注意，不同的 glibc 版本定义的阈值也是不同的。

1. 内存释放流程

当你在 C/C++ 中使用 free(ptr) 释放一块内存时：

内存被标记为“空闲”，表示这块内存可以被后续的 malloc 或 calloc 重用。
但它通常不会立即归还给操作系统，而是由内存分配器（如 glibc 的 ptmalloc）保留在用户进程中，用于后续分配。

2. 什么时候会真正返回给操作系统？

如果释放的是堆顶的内存块（即堆的末端），且满足一定条件，glibc 可能会调用 brk 或 mmap 对应的释放机制（如 munmap）来将这部分内存返回给操作系统。
使用 mmap 分配的大块内存（通常大于一定阈值，比如 128KB），在被 free 时通常会直接使用 munmap 归还给操作系统。

3. glibc 的行为（以 Linux 为例）

glibc 的 malloc 有一套复杂的内存池机制，常见策略：

小块内存来自内部的 arena，free 后不会归还操作系统，而是缓存起来以便重用。
大块内存通过 mmap 分配，free 后可能会立即调用 munmap 释放给系统。

4. 查看内存是否释放

可以使用工具如：

top 或 htop 查看内存使用趋势
valgrind 检查内存泄漏
pmap 查看进程的内存映射情况
mallinfo()（旧）或 malloc_info()（新）来观察 glibc 的内存使用状况

🔥 malloc、realloc、calloc 的区别？

1️⃣ malloc 函数

void* malloc(unsigned int num_size);

int *p = malloc(20*sizeof(int)); // 申请 20 个 int 类型的空间；

2️⃣ calloc 函数：省去了人为空间计算；malloc 申请的空间的值是随机初始化的，calloc 申请的空间的值是初始化为 0 的；

void* calloc(size_t n,size_t size);

int *p = calloc(20, sizeof(int));

3️⃣ realloc 函数：给动态分配的空间分配额外的空间，用于扩充容量。

void realloc(void *p, size_t new_size);

9. 异常/错误处理有几种方法，为什么有些场合要禁用？

C++ 提供了多种错误处理机制，主要包括：

返回码：函数通过返回值指示成功或失败，调用者需要检查返回值以确定操作结果。
错误码：使用全局或静态变量存储错误码，调用者需要在每个步骤后检查错误码。
异常处理：使用 try、catch 和 throw 关键字捕获和处理异常，提供结构化的错误处理方式。

在某些场合，可能需要禁用异常处理，原因包括：

性能要求高的场合：异常处理可能引入性能开销，影响程序的执行效率。
嵌入式系统：资源有限，可能不支持异常处理。
编译器不支持：某些编译器可能不支持异常处理。

禁用异常处理可以通过编译器选项实现，例如在 Sun Studio 中使用 -features=no%except 来禁用异常处理。

10. C 相关的问题，什么是野指针，有哪些野指针？

野指针是指向「未初始化」或「已释放内存」的指针，使用野指针会导致未定义行为，常见野指针：

未初始化的指针：指针声明后未被初始化，默认值不确定，可能指向任意内存地址
悬垂指针：指向已释放内存的指针，释放内存后未将指针置为 NULL，导致指针仍指向已回收的内存地址
空指针：指针被初始化为 NULL，但在后续使用前未被赋予有效地址，导致解引用时发生错误

为避免野指针，应该在声明指针时进行初始化，并在释放内存后将指针置为 NULL。

在更多结构化的解决方案中，一种流行的避免悬垂指针的技术是使用智能指针，一个智能指针通常使用引用技术来收回对象。还有些技术包括 tombstones 方法和 locks-and-keys 方法。另一个方法是使用 Boehm 垃圾收集器，一种保守的垃圾收集器，取代 C 和 C++ 中的标准内存分配函数。此法通过禁止内存释放函数来完全消除悬垂指针引发的错误，通过收集垃圾来回收对象。

11. 你平常怎么调试代码，你能想到多少方法？

调试代码是开发过程中非常重要的一部分，尤其是当出现问题时。调试的方式有很多种，下面是我能想到的常见调试方法：

使用调试器 (Debugger)

调试器是一种强大的工具，可以让你在程序运行时暂停执行，检查变量的值、调用堆栈等信息，逐行执行代码来找出错误。常见的调试器包括：

GDB (GNU Debugger)：适用于 C/C++ 等语言，通过命令行进行调试。
Visual Studio Debugger：适用于 Windows 上的 C++ 和 .NET 程序。
LLDB：用于 macOS 或 Linux 的调试器。
Xcode Debugger：适用于 macOS 和 iOS 应用的调试器。

使用调试器，你可以：

设置断点：暂停程序执行，以检查变量状态和函数调用。
逐步执行代码：逐行执行，查看每一行代码的效果。
检查栈信息和变量的值：实时查看变量的值、函数调用栈、内存内容等。

例如，使用 GDB 调试 C++ 代码时，可以使用以下命令：

gdb ./your_program 启动调试器。
break main 在 main() 函数处设置断点。
run 启动程序执行。
step 或 next 逐步执行代码。

插入日志输出 (Logging)

在代码中添加日志输出是调试程序的常见方法。你可以在代码中插入 printf、std::cout 或日志库（如 log4cpp, spdlog, glog 等）来输出变量值、函数执行状态和程序流程。

常见做法包括：

输出函数进入与退出的日志。
打印变量值、数据结构的内容。
打印程序的状态和执行的分支。

例如：

std::cout << "Value of x: " << x << std::endl;

优点：

非常直接和简单。
可以在生产环境中使用（例如在开发版和发布版中配置不同的日志级别）。

缺点：

可能会遗漏某些地方，导致调试信息不够全面。
需要在最终代码中删除或关闭冗余的日志输出。

单元测试 (Unit Testing)

单元测试是一种自动化的方式，可以帮助你验证代码的正确性。使用框架如 Google Test（C++）、JUnit（Java）、pytest（Python）等，可以编写测试用例，自动运行测试，并在代码发生变化时及时捕捉错误。

单元测试的优点：

确保代码的每个模块都按预期工作。
能够提前发现潜在问题，特别是在修改代码时。

缺点：

测试用例需要编写和维护，可能需要额外的时间。
需要有较好的测试覆盖率，才能检测到更多的错误。

静态分析工具 (Static Analysis)

静态分析工具可以在代码运行之前，扫描代码并检查潜在的错误、内存泄漏、资源管理问题等。例如：

Clang Static Analyzer
CppCheck
SonarQube
Coverity

静态分析工具能够检测到：

未初始化的变量。
内存泄漏。
潜在的并发问题。
错误的代码模式等。

代码审查 (Code Review)

代码审查是与团队成员或同事一起查看和讨论代码的过程。其他开发者可以帮助你发现代码中的潜在问题或逻辑错误。

代码审查的优点：

多人的视角能够发现更多问题。
通过讨论，能够提升代码质量和团队合作。

集成测试 (Integration Testing)

集成测试是测试多个组件（或模块）一起工作时的行为。在多个模块组合工作时，问题可能不是单独模块内部，而是它们之间的交互。集成测试帮助你检查模块之间的接口和数据流。

集成测试通常用来发现：

模块之间的兼容性问题。
数据格式错误。
不正确的模块交互等。

内存泄漏检测工具

如果你的程序存在内存泄漏问题，可以使用专门的工具来检测内存的分配和释放：

🔥 Valgrind：广泛用于检测内存泄漏、内存错误等问题，适用于 C/C++ 程序。
AddressSanitizer：现代编译器（如 Clang、GCC）提供的工具，可以检测内存相关的错误，包括越界访问、内存泄漏等。

这些工具帮助你找出内存泄漏和错误的内存访问问题，并给出详细的报告。

运行时分析工具

运行时分析工具通过收集程序运行时的信息来进行调试和优化。例如：

gprof：用于性能分析，查看程序中哪些函数占用了最多的时间。
perf：Linux 下的性能分析工具，帮助查看程序在系统层面的性能瓶颈。
VisualVM：Java 应用程序的性能分析工具，能够分析内存、CPU 和线程使用情况。

条件断点和日志断点

在调试过程中，有时你希望仅在满足特定条件时暂停程序。这时可以使用条件断点或日志断点：

条件断点：只有当某个条件成立时，调试器才会停止程序执行。
日志断点：调试器在不停止程序执行的情况下，记录断点信息。

回滚与分支 (Git Bisect)

如果你无法确定错误是在哪次提交中引入的，使用 Git 提供的 git bisect 命令来回滚到历史提交并逐步测试，可以帮助定位问题的来源。

通过二分查找算法，git bisect 可以帮助你快速定位到错误引入的那一行代码。

故障注入 (Fault Injection)

故障注入是故意在程序中引入故障，以测试程序在面对错误时的反应。例如，可以通过随机生成异常、模拟网络延迟或中断等方式，检查系统的健壮性和错误处理能力。

动态分析与跟踪 (Dynamic Analysis)

使用跟踪工具（如 strace, ltrace, dtrace 等）来实时观察程序执行过程中的系统调用和函数调用。这种方式帮助你了解程序在运行时的行为，找出性能瓶颈或其他问题。

12. 什么是 C++ 多态？

C++ 多态即使用基类指针或引用来调用子类的重写方法，从而使得同一接口表现不同的行为。

多态优势：

代码复用：通过基类指针或引用，可以操作不同类型的派生类对象，实现代码复用
扩展性：新增派生类时，不需要修改依赖于基类的代码，只需要确保新类正确重写了虚函数
解耦：多态允许程序更加模块化，降低类之间的耦合度

🔥 面试一定要回答「静态多态」+「动态多态」

多态一般就是指继承 + 虚函数实现的多态，对于重载来说，实际原理是编译器为函数生成符号表时的不同规则，重载只是一种语言特性，与多态无关，与面向对象无关，所以如果非要说重载算是多态的一种，那 C++ 中多态可以分为「静态多态」和「动态多态」两种：

静态多态：在编译时期就决定了调用哪个函数，根据参数列表来决定，主要通过函数重载和模板实现
动态多态：通过子类重写父类的虚函数来实现，是运行期间决定调用的函数

动态多态的实现与虚函数表（V-Table），虚函数指针（V-Ptr）相关：

虚函数表（V-Table）：C++ 运行时使用虚函数表来实现多态，每个包含虚函数的类都有一个虚函数表，表中存储了指向类中所有虚函数的指针。
虚函数指针（V-Ptr）：对象中包含一个指向该类虚函数表的指针。

扩展：子类是否要重写父类的虚函数？子类继承父类时，父类的纯虚函数必须重写，否则子类也是一个虚类不可实例化。定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

13. 什么是虚函数与虚函数指针，C++ 虚函数的实现原理？

首先说一下 C++ 中多态的表象：在基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数：

如果对象类型是派生类，就调用派生类的函数
如果是基类，就调用基类的函数

虚函数 `vtable` 与虚函数指针 `vptr`

实际上，当一个类中包含虚函数 virtual 时，编译器就会为该类生成一个虚函数表 vtable，保存该类中虚函数的地址。同样，派生类继承基类，派生类中自然一定有虚函数，所以编译器也会为派生类生成自己的虚函数表 vtable。当我们定义一个派生类对象时，编译器检测到该类型有虚函数，就会为这个派生类对象生成一个虚函数指针 vptr，指向该类型的虚函数表 vtable，虚函数指针 vptr 的初始化是在构造函数中完成的。后续如果有一个基类类型的指针指向派生类，那么当调用虚函数时，就会根据所指真正对象的虚函数表指针 vptr 去寻找虚函数的地址，也就可以调用派生类的虚函数表中虚函数以此实现多态。

补充：如果基类中没有定义成 virtual（只有继承），那么在这种情况调用的则是 Base 中的 func()。因为如果基类和派生类中都没有虚函数 virtual 的定义，那么编译器就会认为不用留给动态多态的机会，就事先进行函数地址的绑定（早绑定 —— 静态绑定），具体过程：

定义了派生类对象，首先构造基类的空间，然后构造派生类的自身内容，形成一个派生类对象
进行类型转换时，直接截取基类的部分内存，编译器认为类型就是基类，那么函数符号表（不同于虚函数表）绑定的函数地址也就是基类中的函数地址，执行的就是基类函数

// 🌟只有 virtual 存在，编译器才会认为存在「多态」
class Base {
public:
    // virtual 不存在则只调用 ~Base()
    virtual ~Base() { // 虚析构函数
        // 释放 Base 的资源
        cout << "释放 Base 的资源" << endl;
    }

    // virtual 不存在则只调用 Base func()
    virtual void func() {
        cout << "Base_func()" << endl;
    }
};

class Derived : public Base {
public:
    // override 可加可不加，有助于编译器检查
    ~Derived() override {
        // 释放 Derived 的资源
        cout << "释放 Derived 的资源" << endl;
    }

    // override 可加可不加，有助于编译器检查
    void func() override {
        cout << "Derived_func()" << endl;
    }
};

int main() {
    Base* ptr = new Derived;
    ptr->func();
    delete ptr;  // 调用时，先执行 Derived::~Derived()，再执行 Base::~Base()
    return 0;
}

Derived_func()
释放 Derived 的资源
释放 Base 的资源

C++ 虚函数的内存分布 & 实现原理

以上简要介绍了「虚函数」相关内容（简要介绍了原理），接下来详细阐述实现原理

更多信息：C++ 虚函数的实现基本原理

class A {
  public:
    virtual void v_a(){}
    virtual ~A(){}
    int64_t _m_a;
};

int main(){
    A* a = new A();
    return 0;
}

如以上代码所示，在 C++ 中定义一个对象 A，那么在内存中的分布大概是如下图这个样子。

首先在主函数的栈帧上有一个 A 类型的指针指向堆里面分配好的对象 A 实例。
对象 A 实例的头部是一个 vtable 指针，紧接着是 A 对象按照声明顺序排列的成员变量（当我们创建一个对象时，便可以通过实例对象的地址，得到该实例的虚函数表，从而获取其函数指针）
vptr 指针指向的是代码段中的 A 类型的虚函数表中的第一个虚函数起始地址。
虚函数表 vtable 的结构其实是有一个头部的，叫做 vtable_prefix ，紧接着是按照声明顺序排列的虚函数。
注意到这里有两个虚析构函数，因为对象有两种构造方式，栈构造和堆构造，所以对应的，对象会有两种析构方式，其中堆上对象的析构和栈上对象的析构不同之处在于，栈内存的析构不需要执行 delete 函数，会自动被回收。
typeinfo 存储着 A 的类基础信息，包括父类与类名称，C++关键字 typeid 返回的就是这个对象。
typeinfo 也是一个类，对于没有父类的 A 来说，当前 tinfo 是 class_type_info 类型的，从虚函数指针指向的 vtable 起始位置可以看出。

1️⃣ Example-1｜如果是多继承情况下，编译器如下处理虚函数表｜虚函数的实现原理

拷贝基类的虚函数表，多继承则拷贝每个虚函数基类的虚函数表
多继承会存在一个基类虚函数表和派生类自身虚函数表合并共用，该基类称为派生类的主基类
派生类重写基类虚函数，则替换重写后的虚函数地址
如果有自身虚函数，则追加自身虚函数到自身的虚函数表

其中 D 对象 vptr1 指向的虚函数表合并了「某个基类虚函数表」和「派生类自身虚函数表」，vptr2 则指向另一个基类的虚函数表

2️⃣ Example-2

class A{
private:
    uint64_t a;
public:
    virtual void A_a(){std::cout << __func__;}
};
class C{
private:
    uint64_t c;
public:
    virtual void C_a(){std::cout << __func__;}
};

class D : public A,public C{
private:
    uint64_t d;
public:
    virtual void D_a(){std::cout << __func__;}
};

class D 的虚函数表

14. 析构函数可以是虚函数吗？什么情况下析构函数必须是虚函数？

🪞镜像问题：

为什么需要虚析构？虚析构实现原理？

析构函数一般写成虚函数的原因？

析构函数可以是虚函数。将析构函数声明为 virtual 虚函数，确保在删除基类指针指向的派生类对象时，能够正确调用派生类的析构函数，避免内存泄漏。

举例来说，一个基类的指针指向一个派生类的对象，在使用完毕准备销毁时，如果基类的析构函数没有定义成 virtual 虚函数，那么编译器根据指针类型就会认为当前对象类型是基类，仅调用基类的析构函数（该对象的析构函数的函数地址早就被绑定为基类的析构函数——静态绑定 / 早绑定），派生类的自身内容将无法被析构，造成内存泄漏。如果基类的析构函数定义为虚函数，那么编译器就可以根据实际对象，执行派生类的析构函数，再执行基类的析构函数，成功释放内存。

注释助于理解

// 🌟只有 virtual 存在，编译器才会认为存在「多态」
class Base {
public:
    // virtual 不存在则只调用 ~Base()
    virtual ~Base() { // 虚析构函数
        // 释放 Base 的资源
        cout << "释放 Base 的资源" << endl;
    }

    // virtual 不存在则只调用 Base func()
    virtual void func() {
        cout << "Base_func()" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        // 释放 Derived 的资源
        cout << "释放 Derived 的资源" << endl;
    }

    void func() {
        cout << "Derived_func()" << endl;
    }
};

int main() {
    Base* ptr = new Derived;
    ptr->func();
    delete ptr;  // 调用时，先执行 Derived::~Derived()，再执行 Base::~Base()
    return 0;
}

Derived_func()		// func() 没定义 virtual 则输出 Base_func()
释放 Derived 的资源	 // ~Base() 没定义 virtual 则不输出
释放 Base 的资源

⚠️ C++ 默认的析构函数不是虚函数，是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。

当类被设计为「基类」，并且可能被继承时，析构函数应当声明为虚函数。如果类不会被继承，则析构函数可以不声明为虚函数。然而，为了代码的健壮性和可维护性，通常建议将基类的析构函数声明为虚函数，即使该类当前不会被继承。

15. 构造函数为什么一般不定义为虚函数

1️⃣ 虚函数调用只需要知道“部分信息”，即只需要知道函数接口，而不需要知道对象的具体类型。但是创建对象时，是需要知道对象的完整信息，特别是需要知道创建对象的确切类型，因此构造函数不应该被定义为虚函数。

2️⃣ 从编译器实现虚函数进行多态的方式来看，虚函数调用时通过实例化之后对象的虚函数表指针 vptr 来找到虚函数地址进行调用的，如果说构造函数是虚的，那么虚函数表指针则不存在（因为虚函数指针 vptr 的初始化是在构造函数中完成的），无法找到对应的虚函数表 vtable 来调用虚函数，那么这个调用实际上也是违反了先实例化后调用的准则。

16. 构造函数的执行顺序？析构函数的执行顺序？

1️⃣ 构造函数顺序

基类构造函数：如果有多个基类，则构造函数调用顺序是某类在「类派生列表」中出现的顺序，而不是它们在成员初始化表中的顺序
成员类对象构造函数：如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序
派生类构造函数

类派生列表

class 派生类名:类派生列表 {
	成员列表
}

class Derived : public Base1, public Base2 {
	成员列表
}

2️⃣ 析构函数顺序

调用派生类的析构函数
调用成员类对象的析构函数
调用基类的析构函数

17. 静态绑定和动态绑定

我们首先要知道静态类型和动态类型：

静态类型：在程序中被声明时所采用的类型，在编译期间确定
动态类型：目前所指对象的实际类型，在运行期间确定

关于静态绑定和动态绑定：

静态绑定，又称早绑定，绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期间。
动态绑定，又称晚绑定，绑定的是动态类型，所对应的函数或属性依赖于动态类型，发生在运行期间。

比如说，virtual 函数是动态绑定的，非虚函数是静态绑定的，缺省参数值也是静态绑定的。

⚠️ 注意，我们不应该重新定义继承而来的缺省参数，因为即使我们重定义了，也不会起到效果。因为一个基类的指针指向一个派生类对象，在派生类的对象中针对虚函数的参数缺省值进行了重定义，但是缺省参数值是静态绑定的，静态绑定绑定的是静态类型相关的内容。

18. 纯虚函数

纯虚函数是在基类中「声明但不实现」的虚函数，其声明方式是在函数声明的结尾处添加 = 0，类中如果至少包含一个纯虚函数，则该类称为抽象类，抽象类是不能实例化对象的。

纯虚函数的主要作用是定义接口规范，强制要求派生类必须实现这些函数，从而实现借口的统一和标准化。派生类中必须实现继承于基类的纯虚函数，否则含有纯虚函数的类又会是抽象类，无法实例化。

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    // 必须实现，否则该派生类为抽象类，不能实例化
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

int main() {
    Shape* shape = new Circle();
    shape->draw(); // 输出：Drawing a circle
    delete shape;
    return 0;
}

19. 深拷贝和浅拷贝的区别（举例说明深拷贝的安全性）

1️⃣ 浅拷贝：

当出现类的等号 = 赋值时，会调用拷贝构造函数，在未显式定义拷贝构造函数的情况下，系统会调用默认的拷贝函数 —— 即浅拷贝，它能够完成成员的复制，当数据成员中没有指针时，浅拷贝是可行的；
但当数据成员中有指针时，如果采用简单的浅拷贝，则两个类中的两个指针指向同一个地址，当对象快要结束时，会调用两次析构函数，从而导致野指针的问题。

class ShallowCopy {
private:
    int* data;
public:
    ShallowCopy(int d) : data(new int(d)) {}
    // 而且在对象结束时，会调用两次析构函数，从而导致野指针问题
    ~ShallowCopy() { delete data; }
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 默认拷贝构造函数（浅拷贝）
    ShallowCopy(const ShallowCopy& source) : data(source.data) {}
};

int main() {
    ShallowCopy obj1(10);
    ShallowCopy obj2 = obj1; // 使用默认拷贝构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据也被修改了

    return 0;
}

2️⃣ 深拷贝：在数据成员含有指针时，必须采用深拷贝（自定义拷贝构造函数），在拷贝构造函数中创建一个全新对象，与原对象完全独立。深拷⻉与浅拷⻉之间的区别就在于，深拷⻉会在堆内存中另外申请空间来存储数据，从而解决来野指针的问题。简而言之，当数据成员中有指针时，必需要用深拷⻉更加安全。

class DeepCopy {
private:
    int *data;
public:
    DeepCopy(int d) : data(new int(d)) {}
    ~DeepCopy() { delete data; }
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 自定义拷贝构造函数（深拷贝）
    DeepCopy(const DeepCopy &source) : data(new int(*source.data)) {}
};

int main() {
    DeepCopy obj1(10);
    DeepCopy obj2 = obj1; // 使用自定义拷贝构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据没有变化

    return 0;
}

20. 说一下你理解的 C++ 四种智能指针｜shared_ptr 的简易实现

更多信息：C++ 智能指针、知乎 C++ 智能指针

看这两篇，取取交集

在使用 C++ 开发过程中，最容易也是最麻烦的问题便是内存泄漏。相较于 Java、Python 或者 Go 语言都拥有垃圾回收机制，在对象没有引用时就会被系统自动回收而且基本上没有指针的概念，但是 C++ 则要求程序员自己管理内存，这一方面让程序员有更大的自由度但是也会很大影响程序员的开发效率。因此 C++11 标准中新推出了 shared_ptr、unique_ptr 和 weak_ptr 三个智能指针来帮助管理内存。

智能指针就是一个类，当超出了类的作用域时，类会自动调用析构函数，析构函数会自动释放资源，所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放。

T* get();
T& operator*();
T* operator->();
T& operator=(const T& val);
T* release();
void reset (T* ptr = nullptr);

常用接口：

T 是模板参数，即传入的类型
get() 用来获取 auto_ptr 封装在内部的指针，也就是获取原生指针
operator*() 重载 *，operator->() 重载 ->，operator=() 重载 =
release() 将 auto_ptr 封装在内部的指针置为 nullptr，但不会破坏指针所指向的内容，函数返回的是内部指针置空之前的值
reset() 直接释放封装的内部指针所指向的内存，如果指定了 ptr 的值，则将内部指针初始化为该值

接下来说说哪四种智能指针：

auto_ptr 为 C++98 的方案，C++11 已抛弃
C++11 引入
1. std::shared_ptr
2. std::weak_ptr
3. std::unique_ptr

0️⃣ auto_ptr

C++98 方案，C++11 已抛弃

auto_ptr<std::string> p1(new string("string"));
auto_ptr<std::string> p2;
p2 = p1;	// auto_ptr 不会报错

p2 剥夺了 p1 的所有权，但是当程序运行时访问 p1 将会报错，所以 auto_ptr 缺点就是存在潜在的内存崩溃问题。

1️⃣ shared_ptr 共享式智能指针

彻底理解：shared_ptr 是有两层析构：

shared_ptr 本身析构会使得指向的共享对象的引用数 -1，当共享对象引用数为 0 时，则调用共享对象本身的析构函数

这样就可以理解循环引用了：共享对象引用还是 1，未调用共享对象本身的析构函数，其中成员 shared_ptr 的析构函数也不会被调用

shared_ptr 能够自动记录共享对象的引用次数，并且在引用计数降至零时自动删除对象，从而防止内存泄漏。每个 shared_ptr 的拷贝都指向相同的内存，在最后一个 shared_ptr 析构的时候其指向的内存资源才会被释放。

shared_ptr 初始化方式：

构造函数
std::make_shared() 辅助函数
reset()

std::shared_ptr<int> p(new int(1));
std::shared_ptr<int> p2 = p;
std::shared_ptr<A> ap = std::make_shared<A>();

std::shared_ptr<int> ptr;
ptr.reset(new int(1));

不能将一个原始指针直接赋值给一个智能指针，如：std::shared_ptr<int> p = new int(1)。

对于一个未初始化的智能指针，可以通过调用 reset 方法初始化，当智能指针中有值的时候，调用 reset 方法会使引用计数减 1。当需要获取原指针的时候可以通过 get 方法返回原始指针：

std::shared_ptr<int> p(new int(1));
int *ptr = p.get();

智能指针初始化时也可以指定删除器，当其引用计数为 0 时将自动调用删除器来释放对象，删除器可以是一个函数对象。如当使用 shared_ptr 管理动态数组时，需要指定删除器，因为 shared_ptr 默认删除器不支持数组对象：

// lambda 表达式作为删除器
std::shared_ptr<int> p(new int[10], [](int *p) { delete []p; })

关于 shared_ptr 的注意事项：

不要用一个裸指针初始化多个 shared_ptr，会出现 double_free 导致程序崩溃
通过 shared_from_this() 返回 this 指针，不要把 this 指针作为 shared_ptr 返回出来，因为 this 指针本质就是裸指针，通过 this 返回可能会导致重复析构，不能把 this 指针交给智能指针管理。

class A {
  	shared_ptr<A> GetSelf() {
    	return shared_from_this();
  		// return shared_ptr<A>(this); 错误，会导致 double free
	}  
};

尽量使用 std::make_shared<T>()，少用 new
不要 delete get() 返回的裸指针
不是 new 出来的空间要自定义删除器
要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> ap = std::make_shared<A>();
    std::shared_ptr<B> bp = std::make_shared<B>();
    ap->b = bp;
    bp->a = ap;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

🌟 解释说明循环引用：

首先循环引用导致 shared_ptr 指向的共享对象 A 和 B 的引用计数都是 2；
在离开作用域后，根据栈后进先出的特点，首先 shared_ptr<B> bp 析构时只减少 B 的引用次数为 1（这里是对象 shared_ptr 析构而非对象 B 析构），由于此时对象 B 的引用次数仍为 1（减为 0 的 B 才会被释放），所以不会调用（对象 B）内部智能指针 a 的析构函数来减少引用，所以也就无法减少 A 的引用次数了。
接着 ap 析构时减少 A 的引用次数为 1，此时 A 的引用仍为 1 不会被析构，所以无法析构其成员对象 b；
最终导致指针永远不会析构，产生了内存泄漏（解决方案就是使用 weak_ptr）

2️⃣ weak_ptr 弱引用智能指针

weak_ptr 是一种不控制对象生命周期的智能指针，它指向一个 shared_ptr 管理的对象，它不管理 shared_ptr 内部指针，进行该对象的内存管理的是那个强引用的 shared_ptr。

weak_ptr 只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作，纯粹是作为一个旁观者监视 shared_ptr 中管理的资源是否存在，它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造，它的构造和析构不会引起引用记数的增加或减少。

weak_ptr 是用来解决 shared_ptr 相互引用时的死锁问题，如果说两个 shared_ptr 相互引用，那么这两个指针的引用计数永远不可能下降为 0，也就是资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和 shared_ptr 之间可以相互转化：

shared_ptr 可以直接赋值给它
它也可以通过调用 lock 函数来获得 shared_ptr

循环引用是当两个智能指针都是 shared_ptr 类型的时候，析构时两个资源引用计数会减 1，但是两者引用计数还是为 1，导致跳出函数时资源没有被释放（析构函数没有被调用），解决办法就是把其中一个改为 weak_ptr 就可以。

总之 weak_ptr 可以用来返回 this 指针和解决循环引用问题。

作用 1：返回 this 指针，上面介绍的 shared_from_this() 其实就是通过 weak_ptr 返回的 this 指针

Q：shared_from_this() 是如何实现的？

A：使用 shared_from_this() 的类需要继承 enable_shared_from_this 类，enable_shared_from_this 类中持有一个类型为 weak_ptr 的成员 _M_weak_this，调用 shared_from_this() 就是将内部持有的 weak_ptr 转成了 shared_ptr。

class enable_shared_from_this
{
    shared_ptr<const _Tp> shared_from_this() const
    {
        return shared_ptr<const _Tp>(this->_M_weak_this);
    }

    mutable weak_ptr<_Tp> _M_weak_this;
};

作用 2：解决循环引用问题

class A {
    std::shared_ptr<B> bptr;
    
    ~A() {
        cout << "A delete" << endl;
    }
    
    void Print() {
        cout << "A" << endl;
    }
};

class B {
    std::weak_ptr<A> aptr; 		// 这里改成 weak_ptr
    
    // B 对象销毁时才调用（即引用计数为 0 时）
    ~B() {
        cout << "B delete" << endl;
    }
    
    void PrintA() {
        if (!aptr.expired()) { 	// 监视 shared_ptr 的生命周期
            auto ptr = aptr.lock();
            ptr->Print();
        }
    }
};

int main() {
    auto aaptr = std::make_shared<A>();
    auto bbptr = std::make_shared<B>();
    aaptr->bptr = bbptr;
    bbptr->aptr = aaptr;
    bbptr->PrintA();
    return 0;
}

// 输出：
// A
// A delete
// B delete

🔥 代码解释：尽管局部变量的析构顺序是按照后进先出的原则，但关键在于“对象的销毁时机”是由引用计数决定的，而不是直接由局部变量析构的顺序决定的：

局部变量析构顺序：在 main 函数中，aaptr 先创建、bbptr 后创建，因此在退出作用域时，bbptr 会先析构，随后 aaptr 析构。
引用计数的影响
- 创建时，aaptr 持有 A 对象，bbptr 持有 B 对象。
- A 对象内部的成员变量 bptr 又持有 B 对象的 shared_ptr，因此 B 对象的引用计数为 2。
- B 对象内部的 weak_ptr 不会影响 A 对象的引用计数。
析构过程
- 当 bbptr 析构时，仅仅减少了 B 对象的引用计数，从 2 变为 1，但 B 对象并没有被销毁，因为 aaptr->bptr 仍然持有它。
- 随后 aaptr 析构，导致 A 对象的引用计数从 1 变为 0，从而触发 A 的析构函数，输出 “A delete”。
- 在 A 的析构过程中，其成员变量 bptr 被析构，从而使 B 对象的引用计数从 1 减为 0。此时，B 对象的析构函数被调用，输出 “B delete”。

3️⃣ unique_ptr 独占式智能指针（替换 `auto_ptr`）

unique_ptr 是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针：

不允许通过赋值将一个 unique_ptr 拷贝/赋值给另外一个 unique_ptr
但是允许通过函数返回给其他的 unique_ptr 或者通过 std::move 来转移到其他的 unique_ptr，这样的话它本身就不再拥有原指针的所有权了

与 shared_ptr 相比，unique_ptr 除了独占性的特点外，还能够指向一个数组：std::unique_ptr<int []> p(new int[10]);。

shared_ptr 与 unique_ptr 的使用需要根据场景决定，如果希望只有一个智能指针管理资源或者管理数组就使用 unique_ptr，如果希望使用多个智能指针管理同一个资源就使用 shared_ptr。

🔥 实现简易的 `shared_ptr`

#include <memory>

template<typename T>
class smartPtr {
private:
    T *_ptr;
    size_t* _count;

public:
    smartPtr(T *ptr = nullptr):_ptr(ptr) {
        if (_ptr) {
            _count = new size_t(1);
        } else {
            _count = new size_t(0);
        }
    }

    smartPtr(const smartPtr &ptr) {
        if (this != &ptr) {
            this->_ptr = ptr._ptr;
            this->_count = ptr._count;
            ++(*this->_count)   ;
        }
    }

    smartPtr& operator=(const smartPtr &ptr) {
        if (this->_ptr == ptr._ptr)
            return *this;

        if (this->_ptr) {
            --(*this->_count);
            if (this->_count == 0) {
                delete this->_ptr;
                delete this->_count;
            }
        }

        this->_ptr = ptr._ptr;
        this->_count = ptr._count;
        ++(*this->_count);

        return *this;
    }

    ~smartPtr() {
        --(*this->_count);
        if (0 == *this->_count) {
            delete this->_ptr;
            delete this->_count;
        }
    }

    size_t use_count() {
        return *this->_count;
    }

    T& operator*() {
        assert(this->_ptr == nullptr);
        return *(this->_ptr);
    }

    T* operator->() {
        assert(this->_ptr == nullptr);
        return this->_ptr;
    }
};

21. shared_ptr 的实现，shared_ptr 一定不会导致内存泄漏吗？

std::shared_ptr 的实现基于引用计数，每个 shared_ptr 实例持有一个指向控制块的指针，控制块中包含引用计数和所管理对象的指针。当 shared_ptr 的引用计数降为零时，控制块会删除所管理的对象。然而，shared_ptr 并非在所有情况下都能防止内存泄漏。当存在循环引用时，shared_ptr 的引用计数永远不会降为零，导致内存无法被释放，从而引发内存泄漏。

#include <memory>

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = b;
    b->a = a;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

为了解决循环引用问题，可以使用 std::weak_ptr，它是一种不增加引用计数的智能指针。 std::weak_ptr 用于打破循环引用，避免内存泄漏。

#include <memory>

class A;
class B;

class A {
public:
    std::weak_ptr<B> b; // 使用 weak_ptr 打破循环引用
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = b;
    b->a = a;
    // 此时，a 和 b 之间的循环引用被 weak_ptr 打破
    // 程序结束时，a 和 b 的引用计数会降为零，内存会被正确释放
    return 0;
}

或者如果在类之间的引用是单向的（即不会形成循环引用），可以考虑使用 std::unique_ptr。std::unique_ptr 不会引起引用计数问题，因为它是独占的，每个对象只有一个拥有者。

#include <memory>

class A;
class B;

class A {
public:
    std::unique_ptr<B> b; // 改为 unique_ptr
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = std::move(b); // 转移所有权
    // 使用 unique_ptr 的情况下，没有循环引用问题
    return 0;
}

22. STL 中 vector、list、map 的底层原理实现和适用场景？

关于 STL 库中所有的结构的底层实现原理：https://zhuanlan.zhihu.com/p/542115773

顺带了解了 set、map、unordered_map、unordered_set 之间区别：

set、map：底层使用红黑树实现，有序，插入、查找、删除的时间复杂度为 $O(logn)$

优点：有序性，内部实现红黑树使得很多操作都在 $O(logn)$ 时间复杂度下完成

缺点：空间占用率高，需要额外保存父节点、孩子节点和红/黑性质

unordered_set、unordered_map：底层使用哈希表实现，无序，查找的时间复杂度为 $O(1)$

优点：因为内部实现了哈希表，因此其查找速度非常的快

缺点：哈希表的建立比较费时

1️⃣ vector 动态数组

vector 底层是动态数组，元素连续存储在堆上
自动扩容机制：
- vector 采用几何增长策略（通常是 2 倍扩容）
- 当 size() == capacity() 时，会申请更大的内存空间，然后拷贝旧数据到新空间
- 由于 realloc 可能导致数据搬移，push_back() 的均摊时间复杂度为 $O(1)$，但最坏情况 $O(n)$（扩容时）
❓所以有可能 vector 的插入操作可能导致迭代器失效：因为 vector 动态增加大小时，并不是在原空间后增加新空间，而是以原大小两倍在开辟另外一片较大空间，然后将内容拷贝过来，并释放原有空间，所以迭代器失效。

适用场景：

✅ 高效的随机访问（O(1)）。 ✅ 批量尾部插入/删除（push_back()）。 ❌ 不适合频繁插入/删除中间元素（O(n)）。 ❌ 扩容会导致数据搬移（不适合超大数据集）。

2️⃣ list 双向链表

list 底层是双向链表，每个节点存储数据和两个指针
插入和删除操作非常高效，不影响其他元素
不支持随机访问，必须顺序遍历才能找到某个元素 $O(n)$
不会发生扩容问题，适合频繁插入/删除的场景

适用场景：

✅ 高效插入/删除（O(1)，特别是中间位置）。 ✅ 不关心随机访问，仅需遍历。 ❌ 不适合频繁随机访问（O(n)）。 ❌ 额外的指针开销（内存占用比 vector 高）。

3️⃣ map 红黑树

map 底层实现是红黑树（Red-Black Tree），一种自平衡二叉搜索树
key 是有序的
插入、删除、查找 $O(logn)$，因为树的高度是 $O(logn)$
迭代遍历按照 key 顺序进行

| 操作 | 时间复杂度 | 说明 | | --------------- | ---------- | ---------------------- | | 插入 insert() | $O(log n)$ | 需要维护红黑树平衡 | | 删除 erase() | $O(log n)$ | 删除节点后可能需要旋转 | | 查找 find() | $O(log n)$ | 通过 BST 进行搜索 |

适用场景：

✅ 需要有序存储的数据结构（默认按照 key 递增）。 ✅ 需要高效查找、插入、删除（O(log n)）。 ❌ 不适合频繁变更 key（因为 key 作为 BST 节点的一部分）。 ❌ 遍历效率比 unordered_map 低（有序存储开销大）。

23. 菱形继承会出现二义性问题，C++ 中如何解决这个问题？

❓镜像问题：一个派生类继承两个父类，这两个父类同时有一个共同基类，如果你去调用两个父类的基类对象函数，会有问题吗？怎么解决？

注：在 Java 中，由于 Java 不支持多重继承，所以菱形继承问题也不存在。 Java 使用接口来替代多重继承，接口只定义了一些抽象的方法，而没有具体的实现。

这是 C++ 多重继承造成的菱形继承问题，如果一个派生类继承了两个拥有相同基类的父类，那么基类的成员会被继承两次，这会导致 “二义性问题” 和 “冗余存储”。

❌ 编译错误！

#include <iostream>

class Base {
public:
    void show() { std::cout << "Base::show()" << std::endl; }
};

class Parent1 : public Base {};  // 继承自 Base
class Parent2 : public Base {};  // 继承自 Base

// 多重继承
class Derived : public Parent1, public Parent2 {};

int main() {
    Derived d;
    d.show();  // ⚠️ 编译错误：二义性
    return 0;
}

1️⃣ 解决方案一：使用作用域解析符

缺点：Derived 仍然包含 两个 Base 实例，数据冗余，而且每次调用 show() 需要手动指定作用域，不优雅。

int main() {
    Derived d;
    d.Parent1::show();  // 访问 Parent1 继承的 Base
    d.Parent2::show();  // 访问 Parent2 继承的 Base
    return 0;
}

2️⃣ 使用虚继承｜最佳方案 ✅

虚继承是为了让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就是虚基类

多继承除了造成命名冲突，还有数据冗余等问题，为了解决这些问题，C++ 引进了「虚继承」

这样能够保证 Derived 只含有一个唯一的 Base 实例。

#include <iostream>

class Base {
public:
    void show() { std::cout << "Base::show()" << std::endl; }
};

// 让 Parent1 和 Parent2 进行虚继承
class Parent1 : virtual public Base {};
class Parent2 : virtual public Base {};

// 继承 Parent1 和 Parent2
class Derived : public Parent1, public Parent2 {};

int main() {
    Derived d;
    d.show();  // ✅ 现在可以直接调用，不会有二义性
    return 0;
}

不使用 virtual 时

Derived 会有两个 Base 对象，导致二义性问题。
内存浪费（两个 Base 子对象的冗余）。

使用 virtual 继承

Parent1 和 Parent2 不会各自包含 Base 的副本，而是共享同一个 Base 实例。
Derived 只会有一个 Base 实例，所以调用 show() 时不会有二义性。

🔥虚继承是为了让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就是虚基类！

使用虚继承解决菱形继承中的命名冲突问题

🔥 虚继承在 C++ 标准库中的实际应用

再看个虚继承的例子，彻底明白虚继承：

#include <iostream>
using namespace std;

class Base0 {
public:
	int var0;
	void fun0() { cout << "Member of Base0" << endl; }
};

class Base1 : virtual public Base0 {
public:
	int var1;
};

class Base2 : virtual public Base0 {
public:
	int var2;
};

class Derived : public Base1, public Base2 {
	//定义派生类Derived 
public:
	int var;
	void fun() {
		cout << "Member of Derived" << endl;
	}
};

int main() {
	Derived d;
	d.var0 = 2; //直接访问虚基类的数据成员
	d.fun0();   //直接访问虚基类的函数成员
	return 0;
}

⁉️将 Base0 类作为它的直接派生类 Base1 和 Base2 的虚基类，即 Base1 虚继承 Base0，Base2 虚继承 Base0。之后 Derived 再继承 Base1 和 Base2，在 Derived 对象里面就不会存在 Base0 类的双份的成员。

Derived 对象包含着从 Base1 继承的成员和从 Base2 继承的成员，但是从 Base1 继承的 Base0 成员实际上这个地方放了一个指针，这个指针指向真正的 Base0 成员，Base2 的也是。所以实质上从最远的基类继承过来的成员，在最远派生类中只有一份。

24. 动态编译 vs 静态编译，动态链接 vs 静态链接？

在编译和链接过程中，我们可以分为以下几个阶段：

编译（Compilation）：将源代码 .cpp 转换为目标文件 .o。
链接（Linking）：将多个目标文件和库组合成一个可执行文件。

(1) 静态编译 vs 动态编译

静态编译（Static Compilation）：所有代码都在 编译时 确定，并编译成完整的 可执行文件。
动态编译（Dynamic Compilation）：代码可以在 运行时动态生成或加载，例如 JIT（Just-In-Time）编译。

(2) 静态链接 vs 动态链接

静态链接（Static Linking）：
- 编译时 将所有 库的代码 直接复制到可执行文件中。
- 生成的可执行文件较大，但不依赖外部动态库。
动态链接（Dynamic Linking）：
- 运行时按需加载动态库（.so/.dll）。
- 可执行文件更小，可以更新动态库而无需重新编译整个程序。

25. 拷贝构造函数与 `operator=()` 的区别？

在 C++ 中，拷贝构造函数 和 赋值运算符 (operator=) 主要区别在于 调用时机和行为。

(1) 拷贝构造函数

作用：用于创建新对象时，用已有对象进行初始化。
调用时机：
1. 用已有对象初始化新对象
2. 函数按值传递参数
3. 函数返回对象（优化前的 NRVO）

示例：

class MyClass {
public:
    int data;
    MyClass(int d) : data(d) {}
    
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        data = other.data;
        std::cout << "Copy Constructor\n";
    }
};

int main() {
    MyClass obj1(10);
    MyClass obj2 = obj1;  // 拷贝构造
}

输出：

CopyEdit
Copy Constructor

(2) 赋值运算符 operator=

作用：用于 已有对象之间赋值，即一个对象的内容 被另一个对象替换。
调用时机：
- 两个已存在对象进行赋值时
- 🔥 a = b; 而不是 MyClass a = b;

示例：

class MyClass {
public:
    int data;
    MyClass(int d) : data(d) {}

    // 赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this == &other) return *this;  // 防止自赋值
        data = other.data;
        std::cout << "Assignment Operator\n";
        return *this;
    }
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);
    obj2 = obj1;  // 赋值运算符调用
}

输出：

Assignment Operator

(3) 主要区别

| 对比项 | 拷贝构造函数 | 赋值运算符 (operator=) | | ------------------ | ---------------- | ---------------------------- | | 作用 | 初始化新对象 | 赋值给已有对象 | | 调用时机 | MyClass a = b; | a = b; | | 是否创建新对象 | ✅ 是 | ❌ 否 | | 默认行为 | 成员逐一拷贝 | 成员逐一赋值 |

(4) 特殊情况

避免自赋值

if (this == &other) return *this;

支持链式赋值

MyClass& operator=(const MyClass& other) {
    this->data = other.data;
    return *this;
}

obj1 = obj2 = obj3;  // 链式赋值

26. 右值引用的主要用途？

等价于问题：什么情况下会用到右值引用。

右值引用是 C++11 引入的新特性，用于实现移动语义和完美转发：

1️⃣ 实现移动语义

在传统 C++ 中，对象的赋值和传递通常涉及深拷贝，这会带来性能开销，通过右值引用，可以触发移动构造函数将资源所有权从一个对象转移到另一个对象（将资源从临时对象移动到新对象），无需深拷贝，避免了不必要的复制和销毁操作。

当一个临时对象或不再使用的资源，需要被高效地“移动”而不是拷贝时，就用到右值引用

std::vector<int> v1 = {1,2,3};
std::vector<int> v2 = std::move(v1); // 此时v1内容转移给v2，避免深拷贝

2️⃣ 完美转发

用于函数模板的完美转发，将参数以原始的形式传递给下一个函数，避免了不必要的复制和类型转换。

模板中利用万能引用（forwarding reference）配合std::forward实现任意类型参数的原始性质传递

template<typename T>
void wrapper(T&& arg) {
    func(std::forward<T>(arg));  // 原样传递arg（左值传左值，右值传右值）
}

针对「完美转发」，请看如下例子

假设我们有两个重载的函数 process，一个接收左值引用，另一个接收右值引用：

void process(int& i) {
    std::cout << "左值引用处理: " << i << std::endl;
}

void process(int&& i) {
    std::cout << "右值引用处理: " << i << std::endl;
}

现在，我们希望编写一个模板函数 forwarding，它能够将传入的参数完美地转发给 process，即保持参数的左值或右值属性不变。

不使用完美转发的情况：如果我们直接在模板函数中调用 process(param)，无论传入的是左值还是右值，param 在函数内部都是一个左值，这会导致总是调用接收左值引用的 process 函数：

template <typename T>
// void forwarding(T param) 也是如此，即右值无法传递进去导致参数不匹配
void forwarding(T&& param) {
    process(param); // param 被视为左值，即右值无法传递进去导致参数不匹配
}

使用完美转发的情况：为了实现完美转发，我们需要：
- 使用万能引用：在模板参数中使用 T&&，使得函数能够同时接收左值和右值。
- 为了解决这个问题，引入了 std::forward, 将模板函数改成如下形式就可以了, forward 被称为完美转发，根据参数的类型（左值或右值）进行条件转发，保持其原有的值类别。语义上：数据是左值就转发成左值，右值就转发成右值，哪怕在万能引用中也是如此。

实现如下：

#include <utility> // std::forward

template <typename T>
void forwarding(T&& param) {
    process(std::forward<T>(param));
}

测试代码：

int main() {
    int a = 10;
    forwarding(a);        // 传入左值
    forwarding(20);       // 传入右值
    forwarding(std::move(a)); // 将左值转换为右值
    return 0;
}

输出结果：

左值引用处理: 10
右值引用处理: 20
右值引用处理: 10

补充：左值引用（&）与右值引用（&&）

在 C++11 中提出了右值引用，作用是为了和左值引用区分开来，其作用是: 右值引用限制了其只能接收右值，可以利用这个特性从而提供重载，这是右值引用有且唯一的特性，限制了接收参数必为右值, 这点常用在 move construct 中，告诉别人这是一个即将消失的对象的引用，可以瓜分我的对象东西，除此之外，右值引用就没有别的特性了。

class Base{
public:
      Base(const Base& b){...} //copy construct 
      Base(Base&& b){...}      //move construct
};

然后，一个右值引用变量在使用上就变成了左值，已经不再携带其是右引用这样的信息，只是一个左值，这就是引用在c++中特殊而且复杂的一点，引用在 c++ 中是一个特别的类型，因为它的值类型和变量类型不一样, 左值/右值引用变量的值类型都是左值, 而不是左值引用或者右值引用。

int val = 0;
int& val_left_ref = val;      
int&& val_right_ref = 0;

// 引用必须在初始化时绑定到一个有效的对象，且绑定后无法更改
val_left_ref = 0;      // val_left_ref 此时是 int，而不是 int&
val_right_ref = 0;     // val_right_ref 此时是 int， 而不是 int&&

🔥 补充：万能引用（T&&）

模板中的 T&& 不同于普通的右值引用，而是万能引用，其既能接收左值又能接收右值。

template<typename T>
void emplace_back(T&& arg) {
}

Class Base {
};

int main() {
    Base a;
    emplace_back(a);      // ok
    emplace_back(Base()); // also ok
    return 0;
}

这种特性常用在容器元素的增加上，利用传参是左值还是右值进而在生成元素的时候调用 copy construct 还是 move construct，比如说 vector 的 emplace_back。

所以为什么需要 std::forwad？

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 如果不使用 forward，直接按照下面的方式写就会导致问题。

template <typename T>
// void forwarding(T param) 也是如此，即右值无法传递进去导致参数不匹配
void forwarding(T&& param) {
    process(param); // param 被视为左值，即右值无法传递进去导致参数不匹配
}

所以为了解决这个问题引入了 std::forward，将模板函数改成如下形式，即可实现完美转发：

template <typename T>
void forwarding(T&& param) {
    process(std::forward<T>(param));
}

27. C++ 中有哪些锁？

更多参考：如何避免死锁、介绍几种经典的锁

从种类上分：普通锁、读写锁、递归锁
从实现上分：互斥锁、自旋锁、信号量、条件变量

互斥锁（Mutex）

🌟互斥锁是在抢锁失败的情况下主动放弃 CPU 进入睡眠状态直到锁的状态改变时再唤醒，而操作系统负责线程调度，为了实现锁的状态发生改变时唤醒阻塞的线程或者进程，需要把锁交给操作系统管理，所以互斥锁在加锁操作时涉及上下文的切换。互斥锁实际的效率还是可以让人接受的，加锁的时间大概 100ns 左右，而实际上互斥锁的一种可能的实现是先自旋一段时间，当自旋的时间超过阀值之后再将线程投入睡眠中，因此在并发运算中使用互斥锁（每次占用锁的时间很短）的效果可能不亚于使用自旋锁。

互斥锁（Mutex）：用于保护共享资源，确保任一时刻只有一个线程访问资源。
信号量（Semaphore）：一种特殊的计数器，可以同时允许多个线程访问有限的共享资源。

互斥锁相当于信号量初值为 1 的特殊情况；信号量允许多个线程并发访问资源（初值 > 1）。

std::mutex mtx;

void foo() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区操作
}

应用场景：

保护关键资源（如共享变量）
控制资源的访问量

条件锁/条件变量（Condition Variable）

🌟互斥锁一个明显的缺点是他只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，他常和互斥锁一起使用，以免出现竞态条件。当条件不满足时，线程往往解开相应的互斥锁并阻塞线程然后等待条件发生变化。一旦其他的某个线程改变了条件变量，他将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。总的来说互斥锁是线程间互斥的机制，条件变量则是同步机制。

条件变量用于线程间通信，当某个条件满足后再唤醒等待线程。

#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [](){ return ready; });  // 等待条件满足
    // 执行后续任务
}

void signal_thread() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 修改条件
    }
    cv.notify_one();  // 通知等待线程
}

应用场景：

生产者-消费者模型
线程等待某条件满足才能执行

自旋锁（Spin Lock）

🌟如果线程无法取得锁，线程不会立刻放弃 CPU 时间片，而是一直循环尝试获取锁，直到获取为止。如果别的线程长时期占有锁那么自旋就是在浪费 CPU 做无用功，但是自旋锁一般应用于加锁时间很短的场景，这个时候效率比较高。

线程在等待资源时不会挂起或睡眠，而是不断循环检测锁状态（忙等待）

#include <atomic>

class SpinLock {
    std::atomic_flag lock_ = ATOMIC_FLAG_INIT;
public:
    void lock() {
        while (lock_.test_and_set(std::memory_order_acquire));
    }
    void unlock() {
        lock_.clear(std::memory_order_release);
    }
};

应用场景：

临界区非常短小
多核 CPU、短暂等待资源的情况

读写锁（Read-Write Lock）

允许多个线程同时进行读操作，但写操作必须独占访问。

特点：

读锁共享：多个读线程并发执行
写锁独占：写线程执行时不能有其他读、写线程存在

// C++17 的 shared_mutex
#include <shared_mutex>

std::shared_mutex rw_mutex;
int shared_data = 0;

void reader() {
    std::shared_lock<std::shared_mutex> lock(rw_mutex);
    // 读取shared_data
}

void writer() {
    std::unique_lock<std::shared_mutex> lock(rw_mutex);
    shared_data++;  // 写操作
}

应用场景：大量读、少量写的场景（如配置文件读取，缓存数据等）

递归锁（Recursive Mutex）

同一线程可以多次获取同一个锁，但必须释放相同次数后才完全解锁。

特点：

避免了同一线程递归调用中因反复加锁而引起的死锁问题
相比普通锁，多了一些额外开销

#include <mutex>

std::recursive_mutex r_mutex;

void recursive_function(int n) {
    std::lock_guard<std::recursive_mutex> lock(r_mutex);
    if (n > 0) {
        recursive_function(n - 1); // 递归调用
    }
    // 临界区操作
}

应用场景：函数递归调用或函数间的相互调用都可能再次尝试获取同一锁

28. 如何用 C++ 实现一个读写锁

#include <mutex>
#include <condition_variable>

class RWLock {
private:
    std::mutex mtx_;
    std::condition_variable cv_;
    int readers_;          // 正在读取的线程数量
    int writers_waiting_;  // 等待写入的线程数量
    bool writing_;         // 当前是否有写线程

public:
    RWLock() : readers_(0), writers_waiting_(0), writing_(false) {}

    // 读锁定
    void lock_read() {
        std::unique_lock<std::mutex> lock(mtx_);
        // 当有写操作进行中或等待中的写操作时等待
        cv_.wait(lock, [this]() {
            return !writing_ && writers_waiting_ == 0;
        });
        ++readers_;
    }

    // 读解锁
    void unlock_read() {
        std::unique_lock<std::mutex> lock(mtx_);
        if (--readers_ == 0) {
            cv_.notify_all();
        }
    }

    // 写锁定
    void lock_write() {
        std::unique_lock<std::mutex> lock(mtx_);
        ++writers_waiting_;
        cv_.wait(lock, [this]() { return !writing_ && readers_ == 0; });
        --writers_waiting_;
        writing_ = true;
    }

    // 写解锁
    void unlock_write() {
        std::unique_lock<std::mutex> lock(mtx_);
        writing_ = false;
        cv_.notify_all();
    }
};

使用实例：

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

RWLock rwlock;
int shared_data = 0;

void reader(int id) {
    rwlock.lock_read();
    std::cout << "Reader " << id << " reads value: " << shared_data << "\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    rwlock.unlock_read();
}

void writer(int id) {
    rwlock.lock_write();
    ++shared_data;
    std::cout << "Writer " << id << " updated value to: " << shared_data << "\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
    rwlock.unlock_write();
}

int main() {
    std::vector<std::thread> threads;

    // 启动读线程
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(reader, i);
    }

    // 启动写线程
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(writer, i);
    }

    for (auto &t : threads) {
        t.join();
    }

    return 0;
}

以上实现倾向于写优先（有写操作等待时，不允许新的读操作）。
可以通过修改逻辑实现读优先或公平性策略，例如：
- 去除 writers_waiting_ == 0 的约束实现读优先。
- 更复杂的公平策略则需要额外的数据结构管理等待顺序。
实际应用中，推荐使用现有的成熟实现，例如：
- C++17 起的标准库提供的 std::shared_mutex（标准的读写锁实现）：

#include <shared_mutex>

std::shared_mutex rw_mutex;

void reader() {
    std::shared_lock lock(rw_mutex); // 读锁
    // 读取数据
}

void writer() {
    std::unique_lock lock(rw_mutex); // 写锁
    // 修改数据
}

29. 引用和指针的区别，是否能加 `const`，作用是什么？

指针：存储变量的内存地址，可以为空（nullptr），需要通过解引用操作符*访问指针指向的值。指针可以在运行时重新指向不同的对象。指针可以有多级。

引用：是变量的别名，必须在初始化时绑定到一个有效的对象，且绑定后无法更改。引用不能为空，始终指向初始化时绑定的对象。引用只有一级。

const修饰：

指针：const可以修饰指针本身或指针指向的对象。
- 指向常量的指针：const int* ptr / int const* ptr 表示指针指向的值是常量，不能通过该指针修改值，但可以改变指针本身的指向。
- 常量指针：int* const ptr表示指针本身是常量，不能改变指针的指向，但可以通过指针修改指向的值。
- 指向常量的常量指针：const int* const ptr表示指针本身和指针指向的值都是常量，既不能修改指针的指向，也不能修改指向的值。
引用：引用本身不能是常量，但可以引用一个常量对象。
- 指向常量的引用：const int& ref表示引用绑定到一个常量值，不能通过该引用修改值。常量引用常用于函数参数，允许函数接受常量或非常量实参而不进行拷贝。

30. 哈希桶满了怎么办？

哈希表（如 unordered_map）在插入元素后，如果负载因子（load_factor，即元素个数/桶数量）超过阈值（通常是1.0左右），将触发扩容（rehash）：

重新分配更多的 bucket（一般是原来容量的2倍或更多）。
重新计算元素位置（rehash），将原有元素重新插入新的 bucket 中。
扩容时性能开销较大 $O(n)$。

因此，为了减少扩容次数，可以提前使用 reserve 或 rehash 提高效率。

unordered_map<int, int> umap;
umap.reserve(1000); // 提前预留空间，避免频繁扩容

31. AVL vs. 红黑树

AVL 树（严格平衡二叉树）：

左右子树高度差绝对不能超过1。
插入删除频繁时，旋转调整成本较高（严格的平衡限制）。
查询效率略优于红黑树（更平衡），但插入删除的开销稍高。
适用于对查询操作要求极高，但修改频率较低的场景。

红黑树（弱平衡二叉树）：

平衡规则相对宽松，允许一定的高度差异。
插入删除操作旋转调整较少，综合效率更高。
广泛应用于 C++ 中的 STL map、set 等数据结构中。
更适用于插入删除较频繁的场景。

如果场景读多写少，要求非常严格的平衡，AVL 树适合。

如果场景写操作频繁，对读写整体性能要求更均衡，红黑树更合适。

32. `move()` 底层原理

std::move() 的底层原理实际上非常简单，它本身并不真正执行移动，而是一个类型转换工具，用来将左值（lvalue）强制转换为右值引用（rvalue reference），从而允许移动语义发生。

一、源码分析（典型实现）

在C++标准库中，std::move() 一般可实现为如下模板函数：

template <typename T>
constexpr std::remove_reference_t<T>&& move(T&& arg) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(arg);
}

上述代码可以解析为：

T&& arg：这是一个万能引用（forwarding reference），能够绑定到左值或右值。
remove_reference_t<T>：移除模板参数 T 可能带有的引用限定符，保证返回的确实是一个右值引用类型。
static_cast<remove_reference_t<T>&&>：进行强制类型转换，将传入参数从左值转换为右值引用。

二、原理分析

std::move() 本身没有发生移动动作，它只是一个类型转换工具：

转换前：变量（对象）本身是左值，只能调用拷贝构造函数或拷贝赋值。
转换后：变量变为右值引用，具备调用移动构造函数或移动赋值的资格。

本质是告诉编译器：“这里的对象我不再需要了，可以放心进行资源的移动操作。”

例如：

std::string str1 = "Hello";
std::string str2 = std::move(str1);  
// str1 的内容被“窃取”，str2 可能直接接管内部缓冲区，而非复制

三、实际的“移动”如何发生？

实际的移动（资源转移）是通过被调用对象的移动构造函数或移动赋值运算符实现的，而不是通过std::move()实现：

例如，std::string 的移动构造函数的伪代码：

// 移动构造函数示意
string(string&& other) noexcept {
    data_ = other.data_;
    size_ = other.size_;
    other.data_ = nullptr;  // 原对象失去所有权
    other.size_ = 0;
}

std::move() 提供右值引用，而真正资源转移的逻辑，由类的移动构造或移动赋值完成。

四、注意事项

std::move()不会清空对象：
- 调用std::move()后的对象处于有效但未指定状态（valid but unspecified state），通常对象变为空或默认状态。
- 你可以继续赋值或析构，但不应该继续访问对象原先的资源。
移动语义要求类本身支持移动构造或移动赋值：
- 若类本身未定义移动构造或移动赋值，调用std::move() 仍然可能降级成拷贝。

| 问题 | 结论 | | -------------------------- | -------------------------------- | | std::move()本质是什么？ | 类型转换函数，从左值转为右值引用 | | 真正的移动操作在哪里发生？ | 类的移动构造函数或移动赋值运算符 | | 调用后原对象的状态？ | 有效但未指定 |

std::move() 本身几乎没有开销，它只是一个编译期的类型转换工具，真正的开销和行为由类型本身的移动构造和赋值函数决定。

33. 可执行文件加载到内存里，其内存布局是怎样的？

当可执行文件（如Linux ELF格式）加载到内存中运行时，其典型内存布局为：

从低地址到高地址顺序：

| 内存段 | 功能说明 | | -------------------------- | -------------------------------------- | | 代码段（text segment） | 存放程序的机器指令（只读、可执行） | | 数据段（data segment） | 已初始化的全局变量和静态变量 | | BSS段（bss segment） | 未初始化或初值为零的全局变量和静态变量 | | 堆（Heap） | 动态分配的内存（由低地址向高地址增长） | | ↕️ | （动态增长空间） | | 栈（Stack） | 函数调用栈帧（由高地址向低地址增长） |

代码段：函数指令
数据段：全局或静态变量（初值不为0）
BSS段：全局或静态变量（初值为0或未初始化）
堆段：动态内存（malloc/new）
栈段：函数调用的局部变量、调用返回地址、临时变量等
文件映射段：包括动态库、共享内存等，从低地址开始向上增长（跟硬件和内核版本有关）

34. 宏定义与函数的区别？

宏在预处理阶段完成替换，之后被替换的文本参与编译，相当于直接插入了代码，运行时不存在函数调用，执行起来更快；函数调用在运行时需要跳转到具体调用函数。
宏定义属于在结构中插入代码，没有返回值；函数调用具有返回值。
宏定义参数没有类型，不进行类型检查；函数参数具有类型，需要检查类型。

35. 宏定义 `define` 与 `typedef` 的区别？

宏主要用于定义常量及书写复杂的内容；typedef 主要用于定义类型别名。
宏替换发生在编译阶段之前（预处理阶段），属于文本插入替换；typedef 是编译的一部分。
宏不检查类型；typedef 会检查数据类型。
注意对指针的操作，typedef char * p_char 和 #define p_char char * 区别巨大。

36. 变量声明与定义的区别？

声明仅仅是把变量的声明的位置及类型提供给编译器，并不分配内存空间
定义要在定义的地方为其分配存储空间

相同变量可以在多处声明（外部变量 extern），但只能在一处定义。

37. strlen 和 sizeof 的区别？

sizeof 参数可以是任何数据的类型或者数据（sizeof 参数不退化）
strlen 参数只能是字符指针且结尾是'\0'的字符串

int main() {
    const char* str = "Hello World";
    cout << sizeof(str) << endl;    // 指针字节：8
    cout << strlen(str) << endl;    // 字符串长度(不包含'\0')：11
    return 0;
}

38. final 和 override

override：指定了子类的这个虚函数是重写的父类的，如果你名字不小心打错了的话，编译器是不会编译通过的
final：当某个类不希望被继承，或者某个虚函数不希望被重写，那么可以在类名和虚函数后添加 final 关键字，添加 final 关键字后被继承或重写，编译器会报错

class Base {
    virtual void foo();
};
 
class A : public Base {
    void foo() final; // foo 被 override 并且是最后一个 override，在其子类中不可以重写
};

// 指明 B 是不可以被继承的
class B final : public A {
    void foo() override; // Error: 在 A 中已经被 final 了
};

// Error: B is final
class C : public B {
};

39. C 与 C++ 的类型安全

类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言，其根据在于该门编程语言是否提供保障类型安全的机制；有的时候也用“类型安全”形容某个程序，判别的标准在于该程序是否隐含类型错误。

类型安全的编程语言与类型安全的程序之间，没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序，相反的，差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。

C 的类型安全

C 只在局部上下文中表现出类型安全，比如试图从一种结构体的指针转换成另一种结构体的指针时，编译器将会报告错误，除非使用显式类型转换。然而，C 中相当多的操作是不安全的。以下是两个十分常见的例子：

1️⃣ printf 格式输出：下述代码中，使用 %d 控制整型数字的输出，没有问题，但是改成 %f 时，明显输出错误，再改成 %s 时，运行直接报 segmentation fault 错误

#include <stdio.h>
int main() {
    printf("%d\n", 10);	// 10
    printf("%f\n", 10);	// 0.00
    return 0;
}

2️⃣ malloc 函数返回值：malloc 是 C 中进行内存分配的函数，它的返回类型是 void* 即空类型指针，常常有这样的用法 char* pStr = (char*)malloc(100 * sizeof(char))，这里明显做了显式的类型转换。类型匹配尚且没有问题，但是一旦出现 int* pInt = (int*)malloc(100 * sizeof(char)) 就很可能带来一些问题，而这样的转换 C 并不会提示错误。

C++ 类型安全

如果 C++ 使用得当，它将远比 C 更有类型安全性。相比于 C 语言，C++ 提供了一些新的机制保障类型安全：

操作符 new 返回的指针类型严格与对象匹配，而不是 void*
C 中很多以 void* 为参数的函数可以改写为 C++ 模板函数，而模板是支持类型检查的
引入 const 关键字代替 #define constants，它是有类型、有作用域的，而 #define constants 只是简单的文本替换
一些 #define 宏可被改写为 inline 函数，结合函数的重载，可在类型安全的前提下支持多种类型，当然改写为模板也能保证类型安全
C++ 提供了 dynamic_cast 关键字，使得转换过程更加安全，因为 dynamic_cast 比 static_cast 涉及更多具体的类型检查

40. 内联函数 `inline` 和宏定义 `define` 的区别？

在使用时，宏只做简单字符串替换（预处理，即编译前）；而内联函数可以进行参数类型检查（编译时），且具有返回值
内联函数在编译时直接将函数代码嵌入到目标代码中，省去函数调用的开销来提高执行效率，并且进行参数类型检查，具有返回值，可以实现重载
宏定义时要注意书写（参数要括起来）否则容易出现歧义，内联函数不会产生歧义
内联函数有类型检测、语法判断等功能，而宏没有

内联函数适用场景:

使用宏定义的地方都可以使用 inline 函数
作为类成员接口函数来读写类的私有成员或者保护成员，会提高效率

41. 什么是大小端存储，以及如何用代码判断大小端？

大端存储：字数据的高字节存储在低地址中

小端存储：字数据的低字节存储在低地址中

例如：32bit 的数字 0x12345678

所以在 Socket 编程中，往往需要将操作系统所用的小端存储的 IP 地址转换为大端存储，这样才能进行网络传输

小端模式中的存储方式为

大端模式中的存储方式为

了解了大小端存储的方式，如何在代码中进行判断呢？

#include <iostream>
using namespace std;
int main()
{
    int a = 0x1234;
    //由于 int 和 char 的长度不同，借助 int 型转换成 char 型，只会留下低地址的部分
    char c = (char)(a);
    if (c == 0x12)
        cout << "big endian" << endl;
    else if(c == 0x34)
        cout << "little endian" << endl;
}

42. C++ 中有几种类型的 `new`？

(1) plain new

言下之意就是普通的new，就是我们常用的new，在C++中定义如下：

void* operator new(std::size_t) throw(std::bad_alloc);
void operator delete(void *) throw();

因此 plain new 在空间分配失败的情况下，抛出异常 std::bad_alloc 而不是返回 NULL，因此通过判断返回值是否为 NULL 是徒劳的。

(2) nothrow new

nothrow new 在空间分配失败的情况下是不抛出异常，而是返回 NULL，定义如下：

void * operator new(std::size_t, const std::nothrow_t&) throw();
void operator delete(void*) throw();

(3) placement new

字节校招问题：placement new 是什么？

一般来说，使用 new 申请空间时，是从系统的“堆”中分配空间。申请所得的空间的位置是根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在已分配的特定内存创建对象，这就是所谓的 “定位放置 new” （placement new）操作。定位放置 new 操作的语法形式不同于普通的 new 操作。例如，一般都用如下语句 A* p = new A; 申请空间，而 placement new 操作则使用如下语句 A* p = new (ptr)A; 申请空间，其中 ptr 就是程序员指定的内存首地址。

用定位放置 new 操作，既可以在栈（stack）上生成对象，也可以在堆（heap）上生成对象，如本例就是在栈上生成一个对象。

优势：复用已有内存空间；

场景题：如果有这样一个场景，我们需要大量的申请一块类似的内存空间，然后又释放掉，比如在一个 Server 中对于客户端的请求，每个客户端的每一次上行数据我们都需要为此申请一块内存，当我们处理完请求给客户端下行回复时释放掉该内存，表面上看者符合 C++ 的内存管理要求，没有什么错误，但是仔细想想很不合理，为什么我们每个请求都要重新申请一块内存呢，要知道每一次内存的申请，系统都要在内存中找到一块合适大小的连续的内存空间，这个过程是很慢的（相对而言)，极端情况下，如果当前系统中有大量的内存碎片，并且我们申请的空间很大，甚至有可能失败。为什么我们不能共用一块我们事先准备好的内存呢？可以的，我们可以使用 placement new 来构造对象，那么就会在我们指定的内存空间中构造对象。

这种 new 允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new 不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

void* operator new(size_t, void*);
void operator delete(void*, void*);

使用 placement new 需要注意两点：

palcement new 的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组
placement new 构造起来的对象数组，要显式的调用他们的析构函数来销毁（析构函数并不释放对象的内存），千万不要使用 delete，这是因为 placement new 构造起来的对象或数组大小并不一定等于原来分配的内存大小，使用 delete 会造成内存泄漏或者之后释放内存时出现运行时错误

#include <iostream>
#include <string>
using namespace std;

class ADT {
	int i;
	int j;
public:
	ADT() {
		i = 10;
		j = 100;
		cout << "ADT construct i=" << i << " j="<<j <<endl;
	}
	~ADT() {
		cout << "ADT destruct" << endl;
	}
};

int main() {
	char *p = new(nothrow) char[sizeof ADT + 1];
	if (p == NULL) {
		cout << "alloc failed" << endl;
	}
	ADT *q = new(p) ADT;  //placement new:不必担心失败，只要p所指对象的的空间足够ADT创建即可
	//delete q;//错误!不能在此处调用delete q;
	q->ADT::~ADT();//显示调用析构函数
	delete[] p;
	return 0;
}

//ADT construct i=10 j=100
//ADT destruct

43. C++ 11 新特性有哪些？

自动类型推导（auto 关键字）：编译器可根据变量初始化表达式自动推导其类型，简化代码编写。
decltype 关键字：用于获取表达式的类型，常与 auto 结合使用，以推导复杂类型。
右值引用和移动语义、move 函数：通过右值引用（&&）支持移动构造和移动赋值，提高资源管理和程序性能。
初始化列表：引入统一的列表初始化语法，允许使用花括号对变量进行初始化，增强初始化的灵活性和可读性。
nullptr 关键字：引入新的空指针常量，替代原有的 NULL，提高类型安全性。
强类型枚举（enum class）：提供作用域限定的枚举类型，避免与其他标识符冲突，并增强类型安全性。
constexpr 关键字：允许在编译期计算常量表达式，提高程序效率。
Lambda 表达式：支持匿名函数，方便定义内联的回调或操作，简化代码结构。
范围 for 循环：引入基于范围的 for 循环，简化对容器或数组的遍历操作。
智能指针：新增 std::unique_ptr 和改进的 std::shared_ptr，提供安全的资源管理机制，减少内存泄漏风险。
线程支持库：标准库中加入多线程支持，包括线程管理、互斥量、条件变量等，方便进行并发编程。
std::tuple：提供固定大小的多元组，允许存储多个不同类型的值，增强数据结构的表达能力。
正则表达式库：标准库新增正则表达式支持，方便进行字符串匹配和处理。
std::array：提供固定大小的数组封装，结合了数组的性能和容器的功能性。
std::unordered_map 和 std::unordered_set：新增无序关联容器，基于哈希表实现，提供平均常数时间的查找和插入性能。
std::chrono 时间库：引入时间处理库，提供时钟、时间点、时间间隔等功能，方便进行时间相关的操作。
static_assert：在编译期进行断言检查，确保代码满足特定条件，提高代码的可靠性。
std::function 和 std::bind：提供通用的函数包装器和绑定器，支持函数对象、成员函数和自由函数的统一调用。
用户定义字面量：允许为标准类型和自定义类型定义字面量后缀，增强代码的可读性和表达能力。
alignas 和 alignof 关键字：提供对齐控制和查询功能，确保数据在内存中的对齐方式符合特定要求。
explicit 关键字：体现显示转换和隐式转换上的概念要求
std::atomic<T> 是 C++11 引入的原子类型，用于在多线程中安全地读写变量
还有虚函数 override、容器非成员函数 swap、新的 bitset 位运算...

44. C++ class 与 C struct 的区别？

C 语言不支持继承和多态

1️⃣ 默认访问权限不同

C struct 默认权限为 public
C++ class 默认权限为 private
C++ struct 默认权限 public

2️⃣ 成员函数

C++ 中的 struct 和 class 都可包含成员函数
C 中的 struct 只能包含数据，不能包含成员函数

C++ 的 class 与 struct 都支持模板、虚函数、多态、构造函数、析构函数、重载操作符等高级特性，这些都是 C 中 struct 不具备的功能。

以上谈论的是 C struct 和 C++ class 的区别，接下来聊一聊 C++ struct 和 C++ class 的区别。

在 C++ 中，class 和 struct 的功能几乎是等价的（除了默认访问权限不同），继承时：

struct 的继承默认是 public 继承
class 的继承默认是 private 继承

通常情况下，如果类主要用于表示数据结构，不需要封装和访问控制，且所有成员均为 public，则常用 struct；如果强调封装、访问控制，需要私有或受保护成员时，则倾向于用 class。

45. 怎么优化系统性能

合理使用缓存机制，如内存缓存、Redis 等
利用多线程或多进程技术，让更多的处理器核心参与计算，提升吞吐量
选择高效的算法和数据结构可以显著提升系统性能
编写高质量的代码，避免冗余计算，减少函数调用和内存分配，合理使用同步和异步操作
采用集群等高可用架构，避免单点故障，确保系统在高负载下仍能稳定运行
负载均衡，通过将请求分配到多台服务器上，避免单一服务器的性能瓶颈
使用消息队列实现高并发下的异步处理，削峰填谷，缓解系统压力
perf 工具查看系统性能瓶颈
开启编译优化 -O2、-O3

以下展开介绍几个主要的优化点。

内存管理优化

减少内存分配与释放次数： 频繁的堆内存分配和释放会严重拖慢程序，甚至导致内存碎片。应尽量重用对象、使用内存池等技术来降低分配开销。例如，在 C++ 中可以实现对象池，预先分配一定数量的对象，在需要时复用它们而不是每次 new 和 delete。对于生命周期较短且数量巨大的对象，尽可能分配在栈上而非堆上，因为栈上的分配/回收开销远小于堆（注意栈有大小限制，过大的对象还是要放在堆上）。在 Java/Python 等有垃圾回收的语言中，无法手动管理内存，但可以通过减少不必要的临时对象创建来减轻 GC 压力。

避免不必要的数据拷贝：数据拷贝不仅耗费 CPU 时间，还增加内存占用。在C/C++中，尽量通过指针、引用传递大对象，或使用移动语义（std::move）来避免昂贵的深拷贝。例如，将函数参数改为 const std::vector<T>& 引用而不是传值，可以省去一遍拷贝的成本。

提高内存访问局部性： 尽量使用连续内存的数据结构，有利于 CPU 缓存命中率。例如，相比链表，数组或动态数组（如 std::vector）在遍历时连续访问内存，对缓存更友好。访问内存时，如果数据分散，CPU缓存无法有效预取，性能会下降。因此，应尽量使常用的数据在内存中连续存放。对于需要处理大批量数据的场景，可以考虑将“数组的结构”转变为“结构的数组”以提高向量化和缓存性能。这种优化在需要对大量对象的某个字段进行批量操作时特别有效，因为连续的内存布局可以充分利用 SIMD 指令和缓存行。

控制内存使用与回收： 注意避免内存泄漏和不必要的内存占用。未释放的内存不仅浪费资源，还可能导致系统频繁进行垃圾回收或交换，从而严重影响性能。应使用恰当的数据结构来节省内存，例如在需要存储大量布尔值时使用位图/位集而不是布尔数组。

I/O 优化

尽量减少 I/O 调用次数：外部I/O（磁盘读写、网络通信）往往比内存操作慢几个数量级。优化I/O的一个基本原则是减少系统调用频次。例如，与其逐字节写入文件，不如积累一定数据后一次写入（批处理）；读文件时尽量使用批量读取或流式读取来降低调用开销。将零散的小I/O操作合并为较少的几次大操作，可以大幅降低每次调用的固定成本，提高总体吞吐量。

使用缓冲和缓存：

缓冲是在内存中暂存数据，凑够一定量再进行 I/O
缓存则是将经常访问的数据暂存内存，以避免重复从慢速存储获取

异步和并行 I/O：传统同步I/O会阻塞执行线程，等待操作完成。通过异步 I/O，程序可以在等待I/O的同时去处理其他任务，从而提高整体效率和响应性。另外，对于磁盘 I/O 密集型任务，合理利用操作系统的内存映射文件（mmap）也能提升效率，因为操作系统会自动预读和缓存文件内容，且内存映射减少了用户态/内核态的数据拷贝。

性能分析与瓶颈定位

在展开具体优化工作之前，识别性能瓶颈是关键的一步。盲目优化往往事倍功半，甚至优化了非瓶颈部分而徒增代码复杂度。因此建议利用各种分析工具（Profiler）来定位程序中的“热区”和问题点。

CPU Profiling：常用 GNU gprof 工具对应用程序进行采样分析，生成函数级别的耗时报告。在Linux上可以使用 perf 工具对程序采集更底层的性能数据（如CPU周期、缓存未命中等）。跨平台的工具如 Intel VTune, AMD uProf 提供更高级的性能分析（包括线程并发、微架构瓶颈）。另外，Valgrind 的 Callgrind 模块也能分析代码热点和调用关系，并可借助KCachegrind等可视化工具查看分析结果。
内存和资源分析：使用 Valgrind 的 Memcheck 工具可以检测内存泄漏和非法内存访问，这有助于消除由于内存问题导致的异常行为和性能下降。Massif 是 Valgrind 的堆分析器，可以跟踪程序堆内存使用随时间的变化，找出高峰时占用大的代码路径。对于更复杂的内存分析，可以借助 Google Perf Tools（gperftools）中的 heap profiler 或 Dr. Memory 等工具。在需要分析缓存行为时，Valgrind 的 Cachegrind 模块可以模拟CPU缓存，报告缓存命中率，帮助调整数据结构以提高缓存友好度。

46. 说说移动构造函数与拷贝构造函数

我们用对象 a 初始化对象 b，之后对象 a 我们就不再使用了，但是对象 a 的空间还在（在析构之前），既然拷贝构造函数实际上就是把 a 对象的内容复制一份到 b 中，那么为什么我们不能直接使用 a 的空间呢？这样就避免了新的空间的分配，大大降低了构造的成本。这就是移动构造函数设计的初衷。
‼️拷贝构造函数中，对于指针，我们一定要采用深拷贝；而移动构造函数中，对于指针，我们采用浅拷贝。
移动构造函数的参数 && 和拷贝构造函数 & 不同：拷贝构造函数的参数是一个左值引用，但是移动构造函数的初值是一个右值引用。意味着，移动构造函数的参数是一个右值或者将亡值的引用。也就是说，只用一个右值或者将亡值初始化另一个对象的时候，才会调用移动构造函数。而那个 move() 语句，就是将一个左值变成一个将亡值。

#include <iostream>
#include <string>

class MyString {
public:
    // 构造函数
    MyString() : str(nullptr), len(0) {}

    // 构造函数
    MyString(const char* s) : str(nullptr), len(0) {
        if (s != nullptr) {
            len = strlen(s);
            str = new char[len + 1];
            strcpy(str, s);
        }
    }

    // 拷贝构造函数: 有指针则采用深拷贝
    MyString(const MyString& other) : str(nullptr), len(0) {
        if (other.str != nullptr) {
            len = other.len;
            str = new char[len + 1];
            strcpy(str, other.str);
        }
    }

    // 移动构造函数: 采用浅拷贝
    MyString(MyString&& other) noexcept {
        str = other.str;
        len = other.len;
        other.str = nullptr;
        other.len = 0;
    }

    // 析构函数
    ~MyString() {
        if (str != nullptr) {
            delete[] str;
            str = nullptr;
            len = 0;
        }
    }

private:
    char* str;
    size_t len;
};

int main() {
    MyString s1("Hello");  		 // 调用构造函数
    MyString s2(s1);      		 // 调用拷贝构造函数
    MyString s3(std::move(s1));  // 调用移动构造函数
    return 0;
}

47. C++ 中指针参数传递和引用参数传递有什么区别？底层原理是什么？

恍然大悟

(1) 指针参数传递本质上是值传递，它所传递的是一个地址值

值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，会在栈中开辟内存空间以存放由主调函数传递进来的实参值，从而形成了实参的一个副本（替身）。

值传递的特点是，被调函数对形式参数的任何操作都是作为局部变量进行的，不会影响主调函数的实参变量的值（即使是形参指针地址变了，实参指针地址都不会变）。

#include <iostream>
using namespace std;

void changePointer(int* ptr) {
    int b = 20;
    ptr = &b;  // 仅改变了形参指针的指向，实参指针不变
}

int main() {
    int a = 10;
    int* p = &a;

    cout << "Before function call: " << *p << endl;  // 输出 10
    changePointer(p);
    cout << "After function call: " << *p << endl;   // 仍然输出 10，不是 20

    return 0;
}

(2) 引用参数传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址

被调函数对形参（本体）的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量（根据别名找到主调函数中的本体）。

因此，被调函数对形参的任何操作都会影响主调函数中的实参变量。

二者区别

1) 引用传递和指针传递是不同的，虽然他们都是在被调函数栈空间上的一个局部变量：

但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。
而对于指针传递的参数，如果改变被调函数中的指针地址，它将应用不到主调函数的相关变量。🔥 如果想通过指针参数传递来改变主调函数中的相关变量（地址），那就得使用指向指针的指针或者指针引用。

2) 从编译的角度来讲，程序在编译时分别将指针和引用添加到符号表上，符号表中记录的是变量名及变量所对应地址。

指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值（与实参名字不同，地址相同）。
符号表生成之后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。

48. C++ 中类成员的访问权限和继承权限问题

访问权限

① public: 用该关键字修饰的成员表示公有成员，该成员不仅可以在类内可以被访问，在类外也是可以被访问的，是类对外提供的可访问接口；

② private: 用该关键字修饰的成员表示私有成员，该成员仅在类内可以被访问，在类体外是隐藏状态；

③ protected: 用该关键字修饰的成员表示保护成员，保护成员在类体外同样是隐藏状态，但是对于该类的派生类来说，相当于公有成员，在派生类中可以被访问。

继承方式

① 若继承方式是 public，基类成员在派生类中的访问权限保持不变，也就是说，基类中的成员访问权限，在派生类中仍然保持原来的访问权限；

② 若继承方式是 private，基类所有成员在派生类中的访问权限都会变为私有 (private) 权限；

③ 若继承方式是 protected，基类的共有成员 public 和保护成员 protected 在派生类中的访问权限都会变为保护 (protected) 权限，私有成员在派生类中的访问权限仍然是私有 (private) 权限。

49. 定义与声明的区别

如果是指「变量」的声明和定义：

从编译原理上来说，声明是仅仅告诉编译器，有个某类型的变量会被使用，但是编译器并不会为它分配任何内存。
而定义就是分配了内存。

如果是指「函数」的声明和定义：

声明：一般在头文件里，对编译器说我有一个函数叫 function() 让编译器知道这个函数的存在。
定义：一般在源文件里，具体就是函数的实现过程写明函数体。

50. 你知道 strcpy 与 memcpy 的区别吗

1、复制的内容不同：

strcpy 只能复制字符串
而 memcpy 可以复制任意内容，例如字符数组、整型、结构体、类等

2、复制的方法不同：

strcpy 不需要指定长度，它遇到被复制字符的串结束符 "\0" 才结束，所以容易溢出
memcpy 则是根据其第 3 个参数决定复制的长度。

3、用途不同：

通常在复制字符串时用 strcpy
而需要复制其他类型数据时则一般用 memcpy

51. volatile 关键字的作用

面试回答

volatile 的意思是“脆弱的”，表明它修饰的变量的值十分容易被改变，所以编译器就不会对这个变量进行优化（CPU 的优化是让该变量存放到 CPU 寄存器而不是内存），进而提供稳定的访问。每次读取 volatile 的变量时，系统总是会从内存中读取这个变量，并且将它的值立刻保存。

解释

C/C++ 中的 volatile 关键字和 const 对应，用来修饰变量，通常用于建立语言级别的 memory barrier。

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。声明时语法：int volatile vInt; 当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

#include <stdio.h>
 
void main()
{
    volatile int i = 10;
    int a = i;
 
    printf("i = %d", a);
    __asm {
        mov dword ptr [ebp-4], 20h
    }
 
    int b = i;
    printf("i = %d", b);
}

i = 10
i = 32	// 如果没有 volatile 关键字修饰则该值为 10

✅ volatile 用在如下的几个地方：

中断服务程序中修改的供其它程序检测的变量需要加 volatile。
多任务环境下各任务间共享的标志应该加 volatile：当两个线程都要用到某一个变量且该变量的值会被改变时，应该用 volatile 声明，该关键字的作用是防止优化编译器把变量从内存装入 CPU 寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。volatile 的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。
存储器映射的硬件寄存器通常也要加 volatile 说明，因为每次对它的读写都可能有不同意义。

52. 如果有一个空类，它会默认存在哪些函数？

Empty(); // 缺省构造函数 //
Empty( const Empty& ); // 拷贝构造函数 //
~Empty(); // 析构函数 //
Empty& operator=( const Empty& ); // 赋值运算符 //

53. const char* 与 string 之间的区别

string 是 C++ 标准库里面其中一个，封装了对字符串的操作，实际操作过程我们可以用 const char* 给 string 类初始化。

三者之间的转化关系如下：

// 1. string 转 const char*
string s = “abc”;
const char* c_s = s.c_str();

// 2. const char* 转 string, 直接赋值即可
const char* c_s = “abc”;
string s(c_s);

// 3. string 转 char* 
string s = “abc”;
const int len = s.length();
char* c;
c = new char[len + 1];
strcpy(c, s.c_str());

// 4. char* 转 string, 直接赋值即可
char* c = “abc”;
string s(c);

// 5. const char* 转 char*
const char* cpc = “abc”;
char* pc = new char[strlen(cpc) + 1];
strcpy(pc, cpc);

// 6. char* 转 const char*, 直接赋值即可
char* pc = “abc”;
const char* cpc = pc;

54. static_cast 比 C 语言中的转换好在哪里？

更加安全；
更直接明显，能够一眼看出是什么类型转换为什么类型，容易找出程序中的错误；可清楚地辨别代码中每个显式的强制转；可读性更好，能体现程序员的意图。

55. delete 和 delete[] 区别？

delete 只会调用一次析构函数。
delete[] 会调用数组中每个元素的析构函数。

56. 为什么不把所有函数写成内联函数？

内联函数以代码复杂为代价，它以省去函数调用的开销来提高执行效率。所以一方面如果内联函数体内代码执行时间相比函数调用开销较大，则没有太大的意义；另一方面每一处内联函数的调用都要复制代码，消耗更多的内存空间，因此以下情况不宜使用内联函数：

函数体内的代码比较长，将导致内存消耗代价
函数体内有循环，函数执行时间要比函数调用开销大

57. 哪些函数不能是虚函数？

构造函数：构造函数初始化对象，派生类必须知道基类函数干了什么，才能进行构造；当有虚函数时，每一个类有一个虚表，每一个对象有一个虚表指针，虚表指针在构造函数中初始化。
内联函数：内联函数表示在编译阶段进行函数体的替换操作，而虚函数意味着在运行期间进行类型确定，所以内联函数不能是虚函数。
静态函数：静态函数不属于对象属于类，静态成员函数没有 this 指针，因此静态函数设置为虚函数没有任何意义。
友元函数：友元函数不属于类的成员函数，不能被继承。对于没有继承特性的函数没有虚函数的说法。
普通函数：普通函数不属于类的成员函数，不具有继承特性，因此普通函数没有虚函数。

58. 什么原因造成内存泄露，你怎么避免/解决内存泄露？

1️⃣ 什么是内存泄露？

在程序运行过程中不再使用的对象没有被正确释放，从而导致程序使用的内存不断增加，最终导致程序异常退出或内存分配失败。

2️⃣ 什么原因造成内存泄露？

忘记释放内存：分配了内存但没有释放
异常 / 逻辑处理不当：写了内存释放代码，但最后未执行到
循环引用：使用智能指针 shared_ptr 造成内存泄露

3️⃣ 如何避免/解决内存泄露 ‼️

内存泄露一般是因为分配了内存但没有释放，要解决这个问题，我通常从以下几个层面入手：

我会用 RAII 机制管理资源（构造时分配，析构时释放）
能用智能指针（unique_ptr, shared_ptr）的地方绝不手动 new/delete，同时要注意避免循环引用（使用弱引用）
对于资源管理比较复杂的类，我会写好析构函数，并考虑拷贝/移动语义，防止资源重复释放或泄露
正确捕获处理异常 / 回滚式编程：编写异常安全的代码非常困难

解决内存泄露本质上就是：该释放的要释放，生命周期清楚，用好工具，写好代码。我平时更倾向于用智能指针来管理资源，基本上能从根上避免大部分内存泄露问题。

4️⃣ 如何定位内存泄露

🔗参考链接：

Linux内存泄露定位1：valgrind篇

Linux内存泄露定位2：mtrace篇

Linux内存泄露定位3：hook+backtrace篇

Linux内存泄露定位4：eBPF+uprobes篇

静态检测工具：检查代码中是否出现内存泄露，
- cppcheck
- clang-tidy
valgrind
- 需要调试信息 -g
- valgrind --leak-check=full 可执行程序
- 可视 valgrind 为虚拟机，将可执行程序当作文件来处理，读取二进制文件的内容，进行指令解析并执行
hook + backtrace：侵入式（可能会引起程序异常）
- hook 住内存分配和释放接口
- 每次申请内存都记录一下，每次释放时也记录一下，然后再把这两种记录进行一个对比，把相同的去掉，剩下就是
eBPF + uprobes：非侵入式（内核中进行统计，不会影响程序）
- 不需要调试信息
- 原理与上一种相同，但是不是侵入式，运行在内核

59. C++ 写了析构函数，系统会帮我们生成默认移动构造函数这些吗（介绍 C++ 六个特殊成员函数）

写了析构函数，系统可能不再自动生成“移动构造”和“移动赋值”函数了，但拷贝构造和拷贝赋值通常还是会生成的。

在 C++ 里，有六个所谓的“特殊成员函数”：

默认构造函数 MyClass()
析构函数 ~MyClass()
拷贝构造函数 MyClass(const MyClass& other)
拷贝赋值函数 MyClass& operator=(const MyClass& other)
移动构造函数（C++11 起）MyClass(MyClass&& other) noexcept
移动赋值函数（C++11 起）MyClass& operator=(MyClass&& other) noexcept

如果你自己写了一个析构函数，那编译器就认为你要自己管理资源了。所以出于安全考虑，它不会再自动生成移动构造函数和移动赋值函数了，你得自己写，或者用 = default 显式声明。

MyClass(MyClass&&) = default;
MyClass& operator=(MyClass&&) = default;

60. C++ 右值引用和移动拷贝(赋值)函数的作用

右值引用和移动语义是在 C++11 之后引入的，目的是优化性能，避免不必要的资源拷贝。

以前在 C++98 里，如果你把一个对象传给另一个对象，哪怕那个对象马上就要销毁了，编译器也只能做拷贝，哪怕里面的数据非常大，比如堆上几百 MB 的数组，也得老老实实拷贝一份，非常浪费性能。

而右值引用的出现，让编译器能识别出“这是一个临时对象”，你可以放心地把它的资源“抢过来”用，而不是复制一份。

移动构造函数 MyClass(MyClass&& a) noexcept 和移动赋值操作符 MyClass& operator=(MyClass&& a) noexcept 的作用就是：

移动构造：当一个临时对象要变成另一个对象时，直接“接管”它的内部资源，比如把指针地址拿过来，然后把原对象的指针清空，这样就不需要重新分配和复制内存。
移动赋值：和移动构造类似，不过是用于对象已经存在的情况下，把另一个临时对象的资源拿过来，原来的资源先释放，然后再接管。

61. C++ 线程 thread_local 的作用是什么？

它是线程单独拥有的资源，没办法作为共享资源

thread_local 是 C++11 引入的存储类型说明符，用于为每个线程创建独立的变量副本。

使用场景：

每个线程都需要使用一个自己的变量（如缓存、计数器等），避免同步。
类似于线程的“全局变量”，但互不干扰。

示例：

thread_local int counter = 0;

✅ 示例场景：日志系统中用 thread_local 缓存上下文

在多线程程序中，很多系统会给每个线程维护一份独立的日志信息，比如线程 ID、调用栈、临时日志缓存等。如果所有线程都用一个共享变量，会导致锁竞争、效率低下。

这时候就可以用 thread_local 给每个线程一份独立副本！

#include <iostream>
#include <thread>
#include <string>

class Logger {
public:
    static void log(const std::string& message) {
        log_context += message + "\n";
    }

    static void flush() {
        std::cout << "[Thread " << std::this_thread::get_id() << "]\n";
        std::cout << log_context << std::endl;
        log_context.clear();
    }

private:
    static thread_local std::string log_context; // 每个线程一份
};

thread_local std::string Logger::log_context;

void thread_task(int id) {
    Logger::log("Start work in thread " + std::to_string(id));
    Logger::log("Doing some work...");
    Logger::log("Finish work in thread " + std::to_string(id));
    Logger::flush();
}

int main() {
    std::thread t1(thread_task, 1);
    std::thread t2(thread_task, 2);
    t1.join();
    t2.join();
    return 0;
}

62. 如何定义一个只能在堆上（栈上）生成对象的类？

只能在堆上

方法：将析构函数设置为私有

原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。

只能在栈上

方法：将 new 和 delete 重载为私有

原因：在堆上生成对象，使用 new 关键词操作，其过程分为两阶段：第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。将 new 操作设置为私有，那么第一阶段就无法完成，就不能够在堆上生成对象。

63. 递归过深会造成什么问题，OOM 吗？

递归过深确实可能引发一些严重问题，但不一定是 OOM（Out of Memory）。更常见的问题是栈溢出（Stack Overflow）。

✅ 栈溢出（Stack Overflow）

每次函数调用都会在调用栈上分配一块内存来保存函数的执行上下文（如局部变量、返回地址等）。
如果递归层级太深，调用栈不断增长，最终会超过系统分配给程序的栈空间上限（跟默认「线程栈」大小相关）。
此时程序会抛出 StackOverflowError（Java）或 Segmentation Fault（C/C++），或者 RecursionError（Python）。

❌ 而不是 OOM（Out of Memory）

OOM 通常是指 堆内存 耗尽，例如大量创建对象、数组或内存泄漏。
除非每层递归都分配了大量堆内存（比如在每层递归里 new 很大的对象），否则递归本身并不会直接造成 OOM。

递归过深导致的栈溢出，和线程的栈大小直接相关：每个线程在启动时，操作系统会为它分配一块固定大小的栈内存（线程栈），专门用于保存函数调用帧，如果递归太深，每层调用都占用一点栈空间，栈就会被用完，最终导致栈溢出。线程栈大小是有限的，不同语言/平台有不同的默认值如下：

Java 一般是 1MB（可通过 -Xss 参数设置）
Linux 上的原生线程（如 pthread）默认栈大小通常是 8MB
Python 受限于解释器的默认递归深度（sys.getrecursionlimit()）

64. 如何获取前 K 个最大元素？

这个问题是数据结构与算法中的经典题目之一，常用于考察排序、堆、优先队列的应用。以下是几种常见的解法及其时间复杂度分析：

解法一：排序法（适合数据量不大）

思路：

直接对数组进行排序
取前 K 个元素

#include <vector>
#include <algorithm>

std::vector<int> topKSort(std::vector<int>& nums, int k) {
    std::sort(nums.begin(), nums.end(), std::greater<int>());
    return std::vector<int>(nums.begin(), nums.begin() + k);
}

时间复杂度：

排序时间复杂度：O(n log n)
空间复杂度：O(1)

解法二：最小堆（推荐，适合大数据）

思路：

使用大小为 K 的最小堆来保存当前最大的 K 个元素
遍历整个数组，若当前元素比堆顶大，则替换堆顶

#include <vector>
#include <queue>

std::vector<int> topKHeap(const std::vector<int>& nums, int k) {
    if (k == 0)
        return {};

    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;

    for (int num : nums) {
        if (minHeap.size() < k) {
            minHeap.push(num);
        } else if (num > minHeap.top()) {
            minHeap.pop();
            minHeap.push(num);
        }
    }

    std::vector<int> result;
    while (!minHeap.empty()) {
        result.push_back(minHeap.top());
        minHeap.pop();
    }

    std::sort(result.rbegin(), result.rend()); // 可选：从大到小排序
    return result;
}

时间复杂度：

时间复杂度：O(n log k)
- 构建堆：O(k)
- 遍历其余 $n - k$ 个元素，每次 O(log k)：总共 O((n-k) log k)
空间复杂度：O(k)

🔥 解法三：快排的思想（Top-K 问题，适合不要求完整排序）

思路：

类似快速排序中的分区（partition），选定一个“枢轴”，将大于 pivot 的放左边，小于的放右边
不断递归，直到找到第 K 个最大的数为止

#include <vector>
#include <cstdlib> // for rand()

int partition(std::vector<int>& nums, int left, int right) {
    int pivot = nums[right], i = left;
    for (int j = left; j < right; ++j) {
        if (nums[j] >= pivot) {
            std::swap(nums[i], nums[j]);
            ++i;
        }
    }
    std::swap(nums[i], nums[right]);
    return i;
}

void quickSelect(std::vector<int>& nums, int left, int right, int k) {
    if (left >= right)
        return;
    int pivotIndex = partition(nums, left, right);
    if (pivotIndex == k)
        return;
    else if (pivotIndex < k)
        quickSelect(nums, pivotIndex + 1, right, k);
    else
        quickSelect(nums, left, pivotIndex - 1, k);
}

std::vector<int> topKQuickSelect(std::vector<int>& nums, int k) {
    quickSelect(nums, 0, nums.size() - 1, k);
    return std::vector<int>(nums.begin(), nums.begin() + k);
}

时间复杂度：

平均：O(n)
- 最坏（退化成链表）：O(n^2)
空间复杂度：O(1)（递归栈不计）

✅ 总结对比

| 方法 | 时间复杂度 | 空间复杂度 | 适用场景 | | -------- | ---------- | ---------- | ----------------------- | | 排序法 | O(n log n) | O(1) | 数据量小，代码简单 | | 最小堆 | O(n log k) | O(k) | 数据量大，k 远小于 n | | 快速选择 | 平均 O(n) | O(1) | 不关心顺序，只要前 K 大 |

65. 堆和栈在操作系统底层的实现？

堆与栈、进程虚拟内存空间分布

【速度、安全】栈是用于管理函数调用、局部变量等的高效内存区域，由操作系统自动管理

【动态、灵活】堆是用于动态分配的内存区域，由程序员手动管理（或者通过垃圾回收机制管理 — java）

⚙️ 在 32 位机器上，进程虚拟内存空间分布如下：

栈为什么适合函数调用：严格的顺序性，嵌套调用不会乱。

递归调用过深，栈会发生什么：栈溢出、触发 SIGSEGV 信号，程序崩溃。

🔥 栈在操作系统底层的实现

线程创建时，操作系统为其创建栈空间（默认 8 MB）—— 分成进程栈与线程栈
1. 进程栈（主线程栈）在进程启动时创建
2. 线程栈通过 pthread_create、clone 系统调用创建
栈的使用：只需要移动栈指针
硬件支持：寄存器 x86 下
1. 栈顶指针 rsp
2. 栈底指针 rbp
操作系统管理：
1. 函数调用时，先将参数压栈
2. 执行 call 指令，将返回地址（返回上一级函数的下一条指令）压栈
3. 创建栈帧，保存旧的 rbp，设置新的 rbp
4. 可能为局部变量分配空间（清理局部变量等的栈空间）
5. 恢复之前的 rbp 和 rsp，ret 指令弹出返回地址

🔥 堆在操作系统底层的实现

本质为 malloc 机制：

当分配内存的大小 $\lt 128KB$ 时，先从内存池获取，否则通过 brk 系统调用从堆区分配内存，回收时则回收到内存池
当分配内存的大小 $\ge 128KB$ 时，通过 mmap 系统调用从文件映射区分配内存，回收时通过 munmap 释放内存

为什么栈的分配速度比堆快？

栈只需要移动指针，堆需要查找空闲块、处理碎片和系统调用

多线程程序中，堆和栈如何隔离？

栈是线程私有的，无需隔离；

堆是进程共享的，需同步机制如锁🔒

66. C++ mutable 关键字

腾讯 wxg 一面

1️⃣ C++ mutable 用于修饰非静态成员函数，使得该成员变量可以在 const 成员函数中允许被修改

2️⃣ 同时也可以用于修饰 lambda 表达式，可以去掉函数调用操作符后 const 关键字，从而可以在 lambda 函数体内可以修改按值捕获的外部变量。

67. 详解内存对齐（如何 padding）及其原因

腾讯 csig 一面

求 sizeof(S) 的大小并解析，以及为什么进行内存对齐。

struct B {
    int b;
    char c;
};

typedef struct {
    int a;
    char b;
    short c;
    char d;
    B e;
} S;

在 C/C++ 中，结构体的大小与成员排列不仅取决于每个成员的大小，还受到**内存对齐（Alignment）**的影响，具体规则如下：

每个成员变量的地址必须是其类型对齐大小（对齐边界）的整数倍。
结构体本身的总大小必须是其最大对齐单位的整数倍。
编译器会在必要的位置插入 **padding（填充字节）**来满足上述要求，以提高内存访问效率。

对结构体 S 的内存布局分析

结构体 B 的分析：

struct B {
    int b;   // 4 bytes, offset 0
    char c;  // 1 byte, offset 4
             // padding 3 bytes to align struct B size to 8
};

成员 int b 对齐为 4 字节，偏移量为 0。
成员 char c 占 1 字节，偏移量为 4。
为满足结构体 B 总大小为最大对齐成员（4 字节）的倍数，需要在末尾添加 3 字节填充。

所以 sizeof(B) == 8

结构体 S 的分析：

typedef struct {
    int a;    // 4 bytes, offset 0
    char b;   // 1 byte, offset 4
              // padding 1 byte, to align next 'short' to 2 bytes
    short c;  // 2 bytes, offset 6
    char d;   // 1 byte, offset 8
              // padding 3 bytes, to align next 'B' to 4 bytes
    B e;      // 8 bytes, offset 12
} S;

int a: 占 4 字节，从 offset 0 开始。
char b: 占 1 字节，offset = 4。
- padding 1 字节，使得 short c 对齐到 2 的倍数（offset = 6）。
short c: 占 2 字节，offset = 6。
char d: 占 1 字节，offset = 8。
- padding 3 字节，使得结构体 B e 对齐到 4 字节边界（offset = 12）。
B e: 占 8 字节（因为 sizeof(B) == 8），offset = 12。
最后 offset = 12 + 8 = 20

因此： sizeof(S) == 20（假设最后总大小为 21 字节，需要 padding 到 24 字节）

68. `(int )0 = 0` 的含义？

*(int *)0 = 0; 这行代码的意思是：将整数值 0 写入内存地址 0 所指向的地方，也就是将值 0 存储到内存的 地址 0。

(int *) 0：把整数 0 强转为 int* 类型的指针
*(int *) 0：对地址 0 进行解引用，访问该地址存储的内容
*(int *) 0 = 0：对地址 0 存储的内容赋值为 0，试图写入值 0 到地址 0

在几乎所有现代操作系统中，地址 0 是无效的地址，属于操作系统保留的内存区域。

尝试访问（特别是写入）地址 0 会导致段错误（Segmentation Fault），程序异常终止。

在某些低层次编程或嵌入式开发中，地址 0 可能用于特殊用途，但在普通用户态程序中，这样写没有任何合法理由，通常是：

故意制造崩溃（例如测试信号处理）。
调试用，或者模拟空指针解引用的错误。
考察面试者对指针、内存访问的理解（比如本题）。

69. 宏定义展开

#define SQR(x) (x * x)
int main()
{
	int a, b = 3;
	a = SQR(b + 2);
	printf("a = %d\n", a);
	return 0;
}

输出为 a = 11 而非 a = 25，宏展开后为 a = (b + 2 * b + 2)，所以结果为 a = 11

70. 假设有一个位图数据结构定义为 `uint32_t bitmap[BSIZE];`，请写出用于判断位图中第 bit 位是否为 1 的如下宏的实现

#define is_bit_set(bit) ((bitmap[(bit)/32] & (1U << ((bit)%32))) != 0)

解释：一个 uint32_t 只能表示 32 位，题目 bitmap 用的是 uint32_t 数组，所以采用 /32 找到在第几个 uint32_t 中，%32 找到在第几位。

71. 读写锁与读优先/写优先

读写锁和传统互斥锁的区别在于，能支持多个读线程并发执行

在多线程编程中，读锁和写锁通常是配合**读写锁（读写互斥锁）**使用的，目的是在多个线程并发访问共享资源时提供更高的效率。简单来说，**读锁（共享锁）允许多个线程同时读取资源，但不允许写操作；而写锁（独占锁）**则是排他的，同一时间只能有一个线程持有写锁，且写锁期间不允许任何其他线程读或写这个资源。

这个机制的好处在于：在读多写少的场景下，我们不必像传统互斥锁那样每次都加排它锁，而是可以让多个读线程并发执行，提升性能。

具体的使用场景比如：

读锁适合的场景：多个线程同时查询一个共享缓存、配置文件、数据库快照等，数据是只读的，不会被修改。
写锁适合的场景：当某个线程需要更新缓存、修改配置或写入日志文件等操作时，为了避免其他线程读到不一致的数据，就需要加写锁。

在 C++ 中，像 std::shared_mutex 就是一个典型的读写锁实现，可以配合 std::shared_lock 和 std::unique_lock 分别实现读锁和写锁。

读/写优先是基于读写锁中的策略选择而已，不要搞混了

在使用读写锁时，读优先和写优先指的是当读线程和写线程同时竞争锁资源时，系统会优先允许哪一类线程先获取锁。

读优先的策略意味着：如果当前有读线程在读，或者有新的读线程请求读锁，就会优先满足它们，哪怕有写线程已经在等待。这种策略的好处是读性能非常高，适合“读远远多于写”的场景。但问题是如果读操作持续不断，写线程可能会长时间得不到执行，造成“写饥饿”。

写优先则反过来：一旦有写线程在等待，新的读线程就要等写线程先执行完。这种方式能保证写操作不会被饿死，但也意味着读线程可能会频繁被阻塞，尤其在写比较多时，整体并发度会下降。

还有一种是公平策略，就是无论读还是写，谁先请求谁先执行。这种方式平衡了读写，防止任何一方饿死，但也可能带来一点性能损耗。

实际使用中，选择哪种策略要看业务特点：

如果系统是典型的读多写少，比如缓存、配置系统，用读优先可以提升整体吞吐；
如果写操作比较关键，比如数据库更新或者日志记录，写优先更合适；
如果两者都重要，或者对延迟比较敏感，可以用公平策略。

C++ 标准库里的 std::shared_mutex 是不保证写优先的，如果确实要实现写优先或者公平策略，可能需要第三方库（比如 Boost）或者平台相关的原语。

72. 多线程之间是如何通信的？线程之间怎么交互的？

<mutex> 和 <condition_variable>

答案就是条件变量

多线程之间的通信和交互主要是通过共享内存来实现的，也就是说多个线程可以访问同一个进程的内存空间，从而读写同一份数据。但因为线程可能同时访问同一块数据，会产生竞态条件，所以通常需要同步机制来保证数据的一致性和正确性。

常用的同步方式包括互斥锁（mutex）、读写锁（rwlock）、信号量（semaphore）、条件变量（condition variable）等，这些机制帮助线程协调访问顺序，防止数据冲突。

此外，线程间还可以通过消息队列、事件通知等方式传递信息，尤其在异步或生产者-消费者模式中常见。现代操作系统和语言运行时通常提供了丰富的线程同步和通信工具，确保线程间可以高效且安全地交互和协作。

73. 关于使用 `==` 比较 `double` 类型

在 C++ 中处理double类型时，我们需要理解：

为什么不能直接用==比较浮点数（浮点数为什么是近似存储的）
如何正确比较浮点数

1. 为什么不能直接用 `==` 比较

浮点数在计算机中的存储是近似值而非精确值，double 通常使用 64 位存储（1 符号位 + 11 指数位 + 52 尾数位)，像 0.1 这样的十进制小数无法精确表示为二进制分数，存储时必须进行舍入（截断无限循环部分），导致微小误差。

#include <iostream>
#include <cmath>
#include <iomanip>

int main() {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;
    
    std::cout << std::setprecision(20);
    std::cout << "0.1 in memory: " << a << std::endl;
    std::cout << "0.2 in memory: " << b << std::endl;
    std::cout << "0.1 + 0.2 = " << sum << std::endl;
    std::cout << "0.3 in memory: " << 0.3 << std::endl;
    
    return 0;
}

输出可能类似于：

0.1 in memory: 0.10000000000000000555
0.2 in memory: 0.2000000000000000111
0.1 + 0.2 = 0.30000000000000004441
0.3 in memory: 0.2999999999999999889

所以使用 == 比较是容易出错的。

#include <iostream>

int main() {
    double x = 0.1 + 0.2;
    double y = 0.3;
    
    if (x == y) {
        std::cout << "Exactly equal\n";
    } else {
        std::cout << "Not exactly equal\n";  // 通常会输出这个
    }
    
    return 0;
}

2. 正确的浮点数比较方法

绝对误差比较

#include <iostream>
#include <cmath>
#include <cfloat> // 对于 DBL_EPSILON

bool nearlyEqual(double a, double b, double absEpsilon = 1e-12) {
    return std::fabs(a - b) <= absEpsilon;
}

int main() {
    double x = 0.1 + 0.2;
    double y = 0.3;
    
    if (nearlyEqual(x, y)) {
        std::cout << "Equal within tolerance\n";  // 会输出这个
    } else {
        std::cout << "Not equal\n";
    }
    
    return 0;
}

3. 什么时候可以使用 `==` 直接比较

在C++中，虽然大多数情况下不推荐直接用==比较浮点数，但在以下特定情况下可以安全使用（当你能 100% 确定数值来源和没有经过任何浮点运算时，才用==）：

比较精确赋值的相同字面值

double a = 5.0;
double b = 5.0;
if (a == b) { /* 总是true */ }

比较整数范围内的值

double x = 42.0;  // 没有小数部分
double y = 42.0;
if (x == y) { /* 总是true */ }

比较特殊浮点值

// 比较正负无穷大
double inf1 = std::numeric_limits<double>::infinity();
double inf2 = std::numeric_limits<double>::infinity();
if (inf1 == inf2) { /* 总是true */ }

// 比较零值
if (0.0 == -0.0) { /* 总是true，尽管符号不同 */ }

比较编译期常量表达式：

constexpr double PI = 3.141592653589793;
constexpr double PI_2 = PI / 2;
if (PI_2 == 1.5707963267948966) { /* 编译期计算，总是true */ }

比较未经过算术运算的相同变量：

double val = getValue();  // 假设返回固定值
if (val == val) { /* 检测NaN的惯用方法 */ }
// 如果val是NaN，这个条件会是false

⚠️ 特别注意，以下情况绝不应该使用==：

// 经过算术运算的结果
if (0.1 + 0.2 == 0.3) { /* 可能false */ }

// 从不同计算路径得到的结果
double a = calculateA();
double b = calculateB();
if (a == b) { /* 危险 */ }

// 循环累积的结果
double sum = 0.0;
for (int i = 0; i < 10; ++i) {
    sum += 0.1;
}
if (sum == 1.0) { /* 可能false */ }

74. 堆与栈的优缺点比较

栈 - Stack

优点：

快速分配/释放：栈内存的分配和释放只是移动栈指针，速度快
自动管理：函数返回时自动释放，无需手动管理
缓存友好：栈数据通常位于缓存热点区域，访问速度快
不会产生碎片：严格的 LIFO 顺序避免了内存碎片问题
线程安全：每个线程有自己的栈，无需同步

缺点

大小有限：栈空间通常较小（几 MB），不适合大对象
生命周期固定：只能在函数调用期间存在，不能跨函数使用
灵活性差：无法动态调整大小，必须是编译时已知的大小
容易溢出：递归过深或大对象可能导致栈溢出（stack overflow）

堆 - Heap

优点：

大容量：可用内存通常远大于栈空间
动态分配：可以在运行时决定分配大小和生命周期
全局可访问：分配的内存可以被程序任何部分访问
灵活性高：可以动态调整大小(如realloc)
适合大数据：能够处理大型数据结构

缺点：

分配速度慢：需要寻找合适的内存块，可能涉及系统调用
手动管理特性：堆内存需要显式分配 (new/malloc) 和释放 (delete/free)，存在内存泄漏风险
内存碎片：频繁分配释放可能导致碎片
同步开销：多线程环境下需要同步机制
缓存不友好：堆分配的数据可能分散在内存各处

使用建议

优先使用栈：适合小型、短生命周期的数据
必要时用堆：大型数据或需要长生命周期时使用

75. 关于 `shared_ptr` 的注意事项（20. 智能指针）

关于 shared_ptr 的注意事项：

不要用一个裸指针初始化多个 shared_ptr，会出现 double_free 导致程序崩溃
通过 shared_from_this() 返回 this 指针，不要把 this 指针作为 shared_ptr 返回出来，因为 this 指针本质就是裸指针，通过 this 返回可能会导致重复析构，不能把 this 指针交给智能指针管理。
尽量使用 std::make_shared<T>()，少用 new
不要 delete get() 返回的裸指针
不是 new 出来的空间要自定义删除器
要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏（不在赘述）

1. 不要用一个裸指针初始化多个 `shared_ptr`（会导致 double free）

问题场景：

int* raw_ptr = new int(42);
std::shared_ptr<int> sp1(raw_ptr);
std::shared_ptr<int> sp2(raw_ptr);  // 危险！

两个独立的 shared_ptr 会各自维护一个引用计数控制块（相互独立）
当 sp1 和 sp2 销毁时都会尝试释放 raw_ptr，导致 双重释放（double free）
结果通常是程序崩溃或未定义行为

正确做法：

// 方法1：直接使用 make_shared
// make_shared 一次性分配内存，包含控制块（引用计数、弱引用计数等）；对象存储空间（存储实际值 42）
auto sp1 = std::make_shared<int>(42);
auto sp2 = sp1;  // 只是复制指针并增加引用计数，两个 shared_ptr 指向同一个控制块，共享所有权

// 方法2：如果必须从裸指针创建，确保只创建一次 shared_ptr
int* raw_ptr = new int(42);
std::shared_ptr<int> sp1(raw_ptr);
std::shared_ptr<int> sp2 = sp1;  // 复制的是控制块指针，不是重新创建控制块，共享同一个控制块

2. 正确使用 `shared_from_this()` 而不是直接返回 `this` 指针

问题场景：

class BadExample {
public:
    std::shared_ptr<BadExample> get_this() {
        return std::shared_ptr<BadExample>(this);  // 危险！
    }
};

auto obj = std::make_shared<BadExample>();
auto another_ref = obj->get_this();  // 创建了独立的控制块

这会创建两个独立的 shared_ptr 控制块
当两个 shared_ptr 销毁时都会尝试析构同一个对象

正确做法：

class GoodExample : public std::enable_shared_from_this<GoodExample> {
public:
    std::shared_ptr<GoodExample> get_this() {
        return shared_from_this();  // 安全
    }
};

auto obj = std::make_shared<GoodExample>();
auto another_ref = obj->get_this();  // 共享同一个控制块

3. 优先使用 `std::make_shared<T>()` 而不是 `new`

问题场景：

// 不推荐
std::shared_ptr<MyClass> sp(new MyClass(arg1, arg2));

// 推荐
auto sp = std::make_shared<MyClass>(arg1, arg2);

优势：

性能更好：单次内存分配（对象 + 控制块）
异常安全：不会在 new 和 shared_ptr 构造之间发生泄漏
代码更简洁：不需要重复类型名称
缓存友好：对象和控制块内存相邻

例外情况：

需要自定义删除器时
需要指定特殊的内存分配方式时

4. 不要 `delete` `get()` 返回的裸指针

问题场景：

auto sp = std::make_shared<int>(42);
int* raw_ptr = sp.get();
delete raw_ptr;  // 灾难性错误！

// 当 sp 超出作用域时，会再次尝试删除已删除的内存

shared_ptr 仍然拥有内存所有权
手动 delete 会导致：
- double free
- 控制块状态不一致
- 未定义行为（通常崩溃）

正确做法：

auto sp = std::make_shared<int>(42);
int* raw_ptr = sp.get();
// 仅使用 raw_ptr 进行读取/写入操作，绝不手动删除它

5. 非 `new` 分配的内存需要自定义删除器

问题场景：

// 从 malloc 分配的内存
void* mem = malloc(1024);
std::shared_ptr<void> sp(mem);  // 错误！会用 delete 而不是 free

// 文件指针
FILE* fp = fopen("file.txt", "r");
std::shared_ptr<FILE> sp(fp);  // 错误！会用 delete 而不是 fclose

正确做法：

// 使用自定义删除器（lambda 表达式作为删除器）
void* mem = malloc(1024);
std::shared_ptr<void> sp(mem, free);  // 使用 free 作为删除器

FILE* fp = fopen("file.txt", "r");
std::shared_ptr<FILE> sp(fp, [](FILE* f) { fclose(f); });

// 对于数组
int* arr = new int[10];
std::shared_ptr<int> sp(arr, [](int* p) { delete[] p; });

常见删除器场景：

C 风格内存分配（malloc/calloc/realloc）→ 使用 free
文件操作（fopen）→ 使用 fclose
系统资源（套接字、句柄等）→ 使用对应的释放函数
数组 → 使用 delete[]

6. 避免循环引用导致的内存泄露

问题场景 1

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> ap = std::make_shared<A>();
    std::shared_ptr<B> bp = std::make_shared<B>();
    ap->b = bp;
    bp->a = ap;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

问题场景 2

class Node {
public:
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;  // 双向链表导致循环引用
    ~Node() { std::cout << "Node destroyed\n"; }
};

auto node1 = std::make_shared<Node>();
auto node2 = std::make_shared<Node>();
node1->next = node2;
node2->prev = node1;  // 循环引用形成！

当 node1 和 node2 离开作用域时：
- node1 的引用计数从 1→0？不，因为 node2->prev 还持有引用（实际从 2→1）
- node2 的引用计数同样从 2→1
结果：两者引用计数永远不为 0，内存永远不会释放

node1 [refcount=2] --> Node1对象
  ↑next               ↓prev
Node2对象 <-- [refcount=2] node2

解决方案：weak_ptr

class SafeNode {
public:
    std::shared_ptr<SafeNode> next;
    std::weak_ptr<SafeNode> prev;  // 使用weak_ptr
    
    ~SafeNode() { std::cout << "SafeNode destroyed\n"; }
};

auto node1 = std::make_shared<SafeNode>();
auto node2 = std::make_shared<SafeNode>();
node1->next = node2;
node2->prev = node1;  // weak_ptr不会增加引用计数

何时会出现循环引用？

双向链表、树结构等复杂数据结构
对象相互持有对方的 shared_ptr
父子对象互相强引用
观察者模式中主体和观察者互相持有

76. `std::shared_ptr` 可以通过 `std::make_shared` 和直接使用 `new` 表达式构造，二者有什么区别？

在 C++ 中，std::shared_ptr 可以通过 std::make_shared 和直接使用 new 表达式构造，但二者在内存管理、性能和异常安全性方面有显著区别：

// 推荐方式：高效且安全
auto sp1 = std::make_shared<int>(42);

// 不推荐：性能更低且可能泄漏
std::shared_ptr<int> sp2(new int(42));

1. 内存分配方式

make_shared：一次性分配内存，同时存储对象本身和控制块（引用计数等）。这是更高效的内存布局，减少了内存碎片和分配次数
```
auto sp = std::make_shared<Widget>(args...); // 单次分配
```
new + shared_ptr 构造函数：需要两次内存分配，一次为对象（new），另一次为控制块（由 shared_ptr 构造函数触发）
```
std::shared_ptr<Widget> sp(new Widget(args...)); // 两次分配
```

2. 性能差异

make_shared 更快：单次内存分配减少了开销，尤其当频繁创建/销毁 shared_ptr 时更明显。
new 额外开销：两次分配可能引入性能损耗（尤其是对小型对象）。

解释

每次 new/malloc 都是一次系统调用：操作系统需要查找合适的内存块、更新内存管理数据结构（如空闲链表），可能触发缺页中断或内核态切换，这些操作本身就有固定开销。两次分配就会有双倍开销。

从内存局部性角度来看：

make_shared 的内存是连续的，对象和控制块在单块内存中紧密排列，缓存命中率更高。
new 的内存可能是分散的，对象和控制块位于不同内存区域，访问时可能触发多次缓存加载，同时产生更多内存碎片。

3. 异常安全性

make_shared 是异常安全的：若构造函数抛出异常，不会发生内存泄漏（因为内存已由智能指针系统托管）。
```
process(std::make_shared<Widget>(a, b), may_throw()); // 安全
```
new 可能泄漏：如果 new 成功但 shared_ptr 构造前发生异常，对象不会被释放：
```
process(std::shared_ptr<Widget>(new Widget(a, b)), may_throw()); // 可能泄漏
```

4. 对象生命周期的影响

make_shared 的延迟释放：对象内存和控制块是连续的，即使引用计数归零，对象占用的内存可能直到控制块也被释放时才归还（例如弱引用 weak_ptr 仍存在时）。
new 的独立释放：对象内存和控制块分离，对象内存会在引用计数归零时立即释放，控制块则等待所有 weak_ptr 释放后才回收。

5. 使用场景限制

必须用 new 的情况：需要自定义删除器或需从已有裸指针构造时。
```
std::shared_ptr<Widget> sp(new Widget, custom_deleter);
```
优先用 make_shared：默认情况下推荐使用，除非有特殊需求。

总结

| 特性 | make_shared | new + shared_ptr | | ------------ | -------------------- | ------------------------ | | 内存分配次数 | 1 次 | 2 次 | | 异常安全 | 是 | 否（可能泄漏） | | 内存释放时机 | 对象和控制块一起释放 | 对象先释放，控制块后释放 | | 自定义删除器 | 不支持 | 支持 |

最佳实践：默认使用 make_shared，除非需要自定义删除器或特殊内存管理。

77. `shared_ptr` 的引用计数是在栈还是堆？

在 std::shared_ptr 的实现中，引用计数（控制块）存储在堆上，为了共享这个这个 reference count 值。

shared_ptr 和 weak_ptr 可能被拷贝、传递到不同的作用域（如函数调用、线程间共享）。如果引用计数在栈上，它会在栈帧销毁时被释放，导致其他指针无法正确跟踪计数。
- make_shared 会将对象数据和引用计数分配在同一块堆内存中
- new + shared_ptr 则是将对象数据和引用计数分配在两块独立的堆内存
虽然引用计数本身在堆上，但 shared_ptr 的实例（即指针对象本身）可以存储在栈上

总结

| 存储位置 | 内容 | 原因 | | :--------- | :--------------------------- | :----------------------------------------------------------- | | 堆内存 | 引用计数（控制块）、对象数据 | 需要动态生命周期管理，支持多指针共享，跨作用域存活。 | | 栈内存 | shared_ptr 实例本身 | 栈对象自动析构，通过析构函数减少堆上的引用计数，必要时释放对象内存。 |

78. 基类的虚函数可以声明为 private 吗

基类的虚函数可以声明为 private，但这会影响其可访问性和多态行为的使用方式。

语法允许，但访问受限

从语法层面，C++ 允许虚函数为 private，编译器不会报错。

派生类不能通过基类指针/引用直接访问 private 虚函数（违反访问控制规则）

多态行为仍然有效

如果基类提供公有方法调用私有虚函数，派生类重写该私有虚函数后，多态仍能正常工作。

派生类重写 foo() 时也必须为 private（访问权限可以更宽松，但不能更严格）。

class Base {
public:
    void callFoo() { foo(); }  // 公有接口调用私有虚函数
private:
    virtual void foo() { std::cout << "Base::foo"; }
};

class Derived : public Base {
private:
    void foo() override { std::cout << "Derived::foo"; }  // 重写私有虚函数
};

int main() {
    Base* ptr = new Derived;
    ptr->callFoo();  // 输出 "Derived::foo"（多态生效）
    delete ptr;
}

对比其他权限

| 虚函数权限 | 派生类能否直接调用 | 派生类能否重写 | 外部代码能否调用 | | :---------- | :----------------- | :-------------------- | :--------------- | | public | ✅ | ✅ | ✅ | | protected | ✅ | ✅ | ❌ | | private | ❌ | ✅（需同权限或更宽松） | ❌ |

79. 如果有 100 个对象，vector、list、map 哪个占用内存高

这个问题本质上考察 STL 容器的内存占用特性。假设我们存放 100 个对象（比如大小相同的自定义类对象），不同容器的内存开销差别主要来自于元素存储方式和额外的结构体开销。

1. `vector`

存储方式：底层是 动态数组，所有元素连续存放。
额外开销：
- 仅仅是 vector 自身维护的三个指针（begin/end/capacity_end），常见实现 24 字节左右。
- 可能有 容量冗余（capacity ≥ size），但不是很大。
内存占用：
- 接近 100 × sizeof(对象)，几乎没有额外 per-element 的开销。
- 在三者中最节省内存。

2. `list`

存储方式：双向链表，每个节点独立分配。
额外开销：
- 每个节点除了存放对象，还要存放两个指针（prev/next），常见实现 16 字节或更多。
- 由于频繁分配，可能带来额外的 堆分配和内存碎片开销。
内存占用：
- 大约 100 × (sizeof(对象) + 2 × sizeof(指针))，比 vector 高不少。
- 在这三者里通常是最浪费内存的。

3. `map`（通常是红黑树）

存储方式：红黑树节点，每个节点存放 (key, value)，还有指针和颜色信息。
额外开销：
- 一个节点要维护 父、左、右指针（3 个指针 = 24 字节）+ 颜色位（通常填充到 4 字节）。
- 还要存放键和值对象。
内存占用：
- 大约 100 × (sizeof(key) + sizeof(value) + 3 × sizeof(指针) + padding)。
- 如果 key/value 很小（比如 int/int），开销主要是结构体本身，比 list 更大。

结论（内存占用比较）

在存放 100 个对象时，三者大致的内存占用从低到高为：vector < list < map

vector：最节省空间，几乎没有额外 per-element 开销。
list：由于链表节点指针和堆分配，开销中等。
map：红黑树节点开销更大（指针 + 平衡因子等），通常是最高的。

80. 虚函数表和虚函数指针存储在哪里？

虚函数表（vtable）

位置：
- 编译器生成的全局静态表，在程序的 只读数据区（.rodata） 或类似的静态存储区域。
- 每个包含虚函数的类（以及其派生类）通常对应一张或多张虚函数表。
- 表的内容是 函数指针数组，指向该类对应的虚函数实现。
特点：
- 程序运行时不会修改表的位置，只会改变对象中的指针指向哪一张表。
- 继承 + 覆盖虚函数时，子类的 vtable 会覆盖父类条目。

虚函数指针（vptr）

位置：
- 在 对象实例的内存中，通常存放在对象的头部。
- 每个对象都有一个 vptr，指向对应类的 vtable。
- 如果类有多个虚继承/多继承，可能会有多个 vptr。
初始化：
- 编译器在构造函数中插入代码，把对象的 vptr 指向正确的 vtable。
- 析构时，也会相应调整 vptr 以保证多态析构正确。

举例与总结

class Base {
public:
    virtual void foo();
};

class Derived : public Base {
public:
    void foo() override;
};

程序里会生成两张 vtable：
- Base 的 vtable，里面有 &Base::foo
- Derived 的 vtable，里面有 &Derived::foo
Base 或 Derived 对象实例的内存中，都会有一个 vptr 指针，指向相应的 vtable。

总结

虚函数表（vtable）：编译器生成的全局静态表，存放在只读数据段。
虚函数指针（vptr）：存放在对象实例内存中（通常在开头），指向该对象对应的 vtable。

81. 多线程编程一般用哪些库函数？

C 语言层面

POSIX Threads (pthread)：pthread_create、pthread_join、pthread_mutex_lock、pthread_cond_wait 等，Linux/Unix 常用。
C11 标准库：thrd_create、mtx_lock（但在实际项目里用得少）。

C++ 层面

C++11 标准库：
- std::thread（线程创建/管理）
- std::mutex、std::recursive_mutex、std::timed_mutex（互斥量）
- std::lock_guard、std::unique_lock（RAII 封装锁）
- std::condition_variable（条件变量）
- std::future / std::promise / std::async（任务并发模型）

82. 为什么需要锁？什么时候需要多线程？举个例子

为什么需要锁

多线程共享内存 → 存在 竞态条件（race condition）。
如果两个线程同时读写同一变量，可能导致数据不一致。
锁（mutex） 的作用就是保证某段代码在同一时刻只有一个线程能进入，维持数据一致性。

什么时候需要多线程

计算密集型任务：利用多核 CPU，提高吞吐量（例如矩阵运算、图像处理）。
I/O 密集型任务：一个线程阻塞 I/O 时，其他线程可以继续执行（例如服务器同时处理多个客户端请求）。

举例

写一个多线程日志系统：

多个工作线程处理业务逻辑，把日志消息写入一个共享队列。
一个单独线程从队列取日志写文件。
共享队列必须加锁，否则多线程写入会导致数据错乱。

83. 多线程场景下出现内存泄漏怎么调试解决？

原因

某些线程申请的内存没有释放，线程退出后仍然占用。
使用 TLS（线程局部存储）或全局变量，线程结束时忘记清理。
线程之间交互复杂，某些分支忘记释放内存。

常见调试手段

工具：
- valgrind --tool=memcheck（Linux）
- asan（AddressSanitizer）
- gdb
策略：
- 用 RAII（C++）避免手动 new/delete。
- 尽量使用智能指针（std::unique_ptr、std::shared_ptr）。
- 保证线程退出时执行清理逻辑（析构函数/pthread_cleanup_push）。
分而治之：把怀疑的线程单独跑，缩小问题范围。

下文详细介绍下「gdb 多线程调试」与「打日志 + 线上定位 + 复现副本」这两种方式。

当然能用 gdb 调多线程，而且线上定位常常要配合“打日志 + 复现副本”的办法一起用。下面给你一套“面试可讲、实际可用”的流程和要点。

(1) 用 gdb 调多线程的实用套路

1) 基本操作（本地或 attach 线上进程）

# 运行时调试
gdb ./your_program
(gdb) run ...

# 附加到线上/本地正在跑的进程
gdb -p <PID>

# 一次性抓所有线程的栈
(gdb) thread apply all bt
(gdb) thread apply all bt full     # 带局部变量
(gdb) info threads                 # 线程列表
(gdb) thread <id>                  # 切换线程
(gdb) bt                           # 当前线程回溯

2) 让单步/断点更可控（避免线程乱切）

(gdb) set scheduler-locking on     # 单步时不让其它线程抢占（on/step可选）
(gdb) set pagination off

3) 条件断点 / 竞争点观察

# 只在指定线程/条件触发
(gdb) break file.cpp:123 if pthread_self() == target_tid && counter < 0

# 监视内存写（找“谁改了这个变量/指针”）
(gdb) watch some_global_ptr
(gdb) rwatch x   # 读监视
(gdb) awatch x   # 读写监视

4) 线程与锁问题的专招

死锁/卡住：先 gdb -p PID，再 thread apply all bt full 看各线程卡在什么锁/条件变量处；很多时候能直接看出两个线程的互相等待链。
条件变量：在 pthread_cond_wait、pthread_mutex_lock 处下断点或打条件断点，确认唤醒与加锁顺序。

跟踪线程创建：记录是谁创建了问题线程。

(gdb) break pthread_create
(gdb) commands
> bt
> c
> end

5) 核心转储（coredump）事后排查

ulimit -c unlimited
# 触发崩溃后
gdb ./your_program core
(gdb) thread apply all bt full

也可以线上“留存一份 core”，再在离线环境慢慢剖析。

6) 录制/重放

rr（Linux）：rr record ./prog，复现后用 rr replay 进 gdb，可时间回溯到变量被改写的一刻，定位数据竞争/时序问题非常好用。
gdb 的 record full 也能用，但 rr 更稳定。

(2) 打日志→线上定位→复现副本→看日志

这是大厂很常见、也很靠谱的生产级排障方法：

打结构化日志（并带上标识）
- 必带：时间戳、线程ID、请求ID/traceID、关键状态（队列长度、锁等待时长、对象地址/指针等）。
- 在锁关键点打点：lock acquire start/ok/timeout、cond wait/signal、enqueue/dequeue、state transition。
- 遇到潜在死锁，记录锁名/顺序和持有时长，方便识别锁顺序反转。
定位线上问题副本
- 用日志把异常请求/异常时间窗圈出来（比如特定用户、某个 shard、某台机器）。
- 从线上环境抽一个最小有问题的副本（相同配置/数据切片/版本/流量）到灰度或隔离环境。
- 这样能在不影响大盘的情况下复现，同时你可以随意加日志、开更高日志级别、甚至 attach gdb。
看日志 + 还原时序
- 通过 traceID 串起多个线程/模块的跨调用链，按照时间戳排序，重放“谁先拿了哪个锁、谁等在 cond 上”，从而定位竞态/死锁/饥饿。
- 日志中记录的内存地址/对象ID可以让你把若干条看似无关的日志对应到同一对象实例。
必要时动用在线栈
- 现场卡死时，用 gdb -p PID 或运维脚本（比如发送信号触发 backtrace() dump 全线程栈）把全线程栈打印出来，和日志时间窗对比，锁点一目了然。
修复后再灰度验证
- 在副本/灰度环境验证“日志告警消失、锁等待时长下降、吞吐恢复”，再全量。

这套方法的核心是：用日志重建并发时序，用副本规避线上风险，用 gdb/栈/录制补齐细节。

84. 程序的内存布局是怎样的？

一个典型 C/C++ 程序在内存里的分布大致如下：

代码段：包括二进制可执行代码，通常只读，还可共享（多个进程运行同一程序时只存一份）；

静态存储区：数据段 + BSS 段
数据段：包括已初始化的静态常量和全局变量；
BSS 段：包括未初始化的静态变量和全局变量；
堆（比如 malloc/new）：包括动态分配的内存，从低地址开始向上增长，程序员负责管理，容易泄露；
文件映射区（比如 mmap）：包括共享库、文件映射、匿名映射、共享内存等；
栈：包括局部变量和函数调用的上下文（参数、返回地址）等，函数调用或返回会自动分配与释放后。栈的大小是固定的，一般是 8 MB。当然系统也提供了参数，以便我们自定义大小；
内核空间（对用户程序不可见）

在这 7 个内存段中，堆和文件映射段的内存是动态分配的。比如说，使用 C 标准库的 malloc() 或者 mmap()，就可以分别在堆和文件映射段动态分配内存。

85. delete 释放内存的时候并不知道内存大小，如何释放？

涉及 new 和 delete 源码及流程

链接：pdd 二面

delete 运算符在释放内存时确实不需要显式指定大小，因为它依赖底层的内存管理器来跟踪分配块的信息。当使用 new 分配内存时，内存管理器（如 glibc 的分配器）会在返回给用户的内存块前端或尾部存储额外的元数据（如分配大小、cookie 等），这些信息对用户透明。调用 delete 时，运算符会根据传入的指针向前偏移一定位置来读取这些元数据，从而确定需要释放的内存块实际大小和边界，确保正确释放。因此，用户无需手动传递大小，所有细节由内存管理器和编译器生成的代码处理。

86. 一个空类大小是多少？如果有构造函数和析构函数呢？如果有虚函数？

腾讯 TEG 一面

Q1：一个空类大小是多少？

在 C++ 中，一个空类（没有任何非静态成员变量和虚函数）的大小通常为 1 字节。这是因为编译器需要为每个对象分配一个唯一的地址标识，以确保不同对象在内存中拥有 distinct 的地址。如果大小为 0，可能导致多个对象地址相同，违反语言标准。需要注意的是，如果空类作为基类被继承，可能会发生空基类优化（EBO），此时基子对象不占用额外空间，从而节省内存。

Q2：如果空类只有构造函数和析构函数，该类大小是多少？

大小仍然是 1 个字节。 构造函数和析构函数是普通的成员函数，它们的代码并不存储在每一个对象实例中。这些函数在编译后位于代码段，所有该类的对象共享同一份函数代码。调用它们时，编译器会隐式地传入一个指向当前对象的 this 指针。因此，添加普通的成员函数（包括构造和析构）不会影响对象实例的大小。

Q3：如果空类只有虚函数，该类大小是多少？

在 64 位系统上，大小通常是 8 字节（一个指针的大小）；在 32 位系统上，通常是 4 字节。

一旦一个类拥有虚函数，它就会拥有一个虚函数表（vtable），并且编译器会自动为该类的每一个对象实例添加一个隐藏的成员变量 —— 虚表指针（vptr）。这个 vptr 指向类的 vtable，用于在运行时实现多态（动态绑定）。因此，对象的大小会增加一个指针的开销。

87. 指针的大小是多少？

指针的大小不取决于它指向的数据类型，而完全取决于目标平台的寻址能力。

在 32 位平台上，指针的大小是 4 字节，因为它需要能表示 $2^{32}$ 个不同的内存地址。
在 64 位平台上，指针的大小是 8 字节，用于表示 $2^{64}$ 个地址空间。

无论是指向 int、char 还是一个拥有虚函数的复杂类对象，所有数据指针的大小都遵循这个规则（函数指针可能在某些平台上有所不同）。

88. 内存对齐了解过吗，我如果不想对齐，怎么办？

腾讯 TEG 一面

内存对齐是编译器和硬件为了提升访问效率而实施的策略。

如果不想对齐，可以通过编译器指令强制取消填充（如 GCC/Clang 的 __attribute__((packed)) 或 MSVC 的 #pragma pack(1)），使结构体成员紧凑排列。但这样做有风险：未对齐访问在 x86 架构上会导致性能下降（多次内存访问），在其他架构（如 ARM）上可能直接触发硬件异常造成崩溃。除非有特殊需求（如协议解析或节省内存），否则不建议禁用对齐。

89. 讲讲 unordered_map 和 map 的底层实现和区别

腾讯 TEG 一面

区别

底层实现详解

`map` - 基于红黑树 (Red-Black Tree)

数据结构：
- 本质上是一颗二叉搜索树 (BST)，这意味着任何节点的左子树所有节点的 key 都小于该节点的 key，右子树所有节点的 key 都大于该节点的 key。这使得中序遍历树时，可以得到有序的 key 序列。
- 它更具体地是一颗红黑树。红黑树是一种自平衡的二叉搜索树。它通过为节点添加颜色属性（红或黑）和定义一系列旋转和重新着色的规则，来确保树始终保持大致平衡（没有一条路径会比其他路径长两倍以上）。
如何工作：
1. 插入：首先像普通的 BST 一样找到插入位置。插入新节点后（初始为红色），可能会破坏红黑树的平衡性质（如出现两个连续的红色节点）。这时需要通过旋转（左旋、右旋）和重新着色来恢复平衡。
2. 查找：从根节点开始，与当前节点的 key 比较。如果小于，进入左子树；如果大于，进入右子树；如果相等，则找到。由于树是平衡的，查找路径长度最多为树的高度 O(log n)。
3. 删除：同样先找到节点，执行 BST 删除操作后，可能会破坏平衡，需要再次通过旋转和重新着色来调整。
优点：元素始终有序，支持范围查询（如lower_bound()），提供了稳定的 O(log n) 操作时间。
缺点：平均速度比哈希表慢，因为常数因子较大（需要多次比较和可能的内存跳跃）。

`unordered_map` - 基于哈希表 (Hash Table)

数据结构：
- 一个数组（通常称为“桶”bucket 数组），数组的每个元素是一个链表的头指针（或一棵小红黑树的根节点）。
- 在 C++11 中，标准要求使用“开链法”解决哈希冲突。在极端情况下（一个桶里元素太多），标准允许该桶用树 instead of 链表来实现，以避免最坏性能。
如何工作：
1. 插入：
  - 对 key 进行哈希函数计算，得到一个整型的哈希值。
  - 用这个哈希值 % 桶的数量 来确定元素应该放在哪个桶里（即数组的哪个索引）。
  - 将键值对添加到这个桶对应的链表（或树）的末尾。
2. 查找：
  - 同样先计算 key 的哈希值，找到对应的桶。
  - 然后遍历这个桶里的链表（或树），使用operator== 进行精确匹配。
3. 重新哈希 (Rehashing)：
  - 当元素数量超过负载因子(load factor) * 桶的数量时，容器会自动进行重新哈希。
  - 这会创建一个新的、更大的桶数组，然后将所有现有元素重新计算哈希并插入到新的数组中。
  - 这个过程会使所有迭代器失效！
优点：平均情况下的查找、插入、删除速度极快，接近常数时间 O(1)。
缺点：
- 元素无序。
- 最坏情况下的性能是 O(n)（例如所有 key 都哈希到同一个桶里）。
- 迭代器不稳定（重新哈希会导致失效）。
- 需要为 key 类型提供良好的哈希函数。

如何选择？

使用 std::map 当：
- 你需要元素按 key 排序。
- 你需要按顺序遍历元素。
- 你无法定义一个好的哈希函数 for your key type。
- 你非常关心最坏情况的性能（保证 O(log n)），而不是平均情况。
使用 std::unordered_map 当：
- 查找速度是首要任务。
- 你不需要维护元素的任何顺序。
- 你愿意并且能够为你的 key 类型定义一个高效的哈希函数（例如，基本类型和std::string已有内置哈希）。

90. 介绍一下B树/B+树/红黑树及其对应的应用场景有哪些

B 树

B 树是一种多路平衡搜索树，它的每个节点可以拥有多于两个的子节点，这使得它能够保持矮胖的树形结构。

B 树的设计核心是为了减少磁盘 I/O 次数，因为它一个节点的大小通常设置为一个磁盘页的大小，一次磁盘读取就能加载一个包含多个键的巨大节点，然后在内核中进行高效的二分查找。

所以它特别适合用于文件系统和数据库（如 MySQL 的 InnoDB 存储引擎）的索引，这些场景下数据量巨大无法全部装入内存，需要频繁与磁盘交换数据。

B+ 树

B+树是 B 树的一种变体，也是目前数据库和文件系统索引的事实标准。

它与 B 树的主要区别在于：首先，它的所有数据记录都只存储在叶子节点上，内部节点只存放键作为导航用的索引；其次，叶子节点之间通过指针相连形成了一个有序链表。

这样的设计带来了几个巨大优势：一是内部节点能存放更多的键，使得树更矮，查询需要的磁盘 I/O 更少；二是范围查询性能极高，一旦找到范围的起点，只需顺着叶子节点的链表遍历即可，而不需要像 B 树那样回溯到上层节点。

所以 MySQL 的 InnoDB 引擎、MongoDB、以及几乎所有关系型数据库的索引都在用 B+树。

红黑树

红黑树则是一种二叉平衡搜索树，它通过复杂的旋转和变色规则来维持大致的平衡，确保从根到任意叶子节点的最长路径不会超过最短路径的两倍，从而保证了最坏情况下搜索、插入、删除操作的时间复杂度都是 $O(log n)$。

它的主要优势在于内存中操作的效率非常高，且维护平衡的代价相对于严格的 AVL 树更小（旋转次数更少）。

因此，它的应用场景主要集中在内存计算领域，比如 C++ STL 中的 map 和 set 就是用红黑树实现的，此外还有 Linux 系统的进程调度器 Completely Fair Scheduler (CFS) 也用红黑树来管理进程队列。

91. 智能指针申请的空间是在堆上还是在栈上？

智能指针（unique_ptr、shared_ptr）本身是一个栈上的对象，但它所管理的内存是在堆上申请的。

92. 介绍下 `vector` 动态扩容机制

std::vector 的动态扩容机制是其核心特性之一，旨在平衡内存使用与操作效率。

其本质在于管理三个核心属性：size（当前元素数量）、capacity（当前分配的内存可容纳的元素数量）和分配策略（通常按固定因子增长，如2倍或1.5倍）。

当执行 push_back 或 emplace_back 等插入操作时，若当前 size 已达到 capacity，则触发扩容流程：

计算新容量：根据预定义的增长因子（Growth Factor，通常为2）确定新的容量值（new_capacity = old_capacity * growth_factor）。
分配新内存：在自由存储区（堆）上申请一块更大的、连续的内存空间，其大小足以容纳 new_capacity 个元素。
迁移数据：将原有内存中的所有元素移动（若移动构造函数为 noexcept）或拷贝到新内存的起始位置。此步骤会调用各元素的构造函数，是扩容过程中开销最大的操作，时间复杂度为 O(N)。
释放旧内存：销毁原内存中的对象并释放原有内存块。
更新内部状态：将内部指针指向新内存块，并将 capacity 更新为 new_capacity，最后在尾部构造新插入的元素。

此机制确保了插入操作的摊还时间复杂度为 O(1)。尽管单次扩容成本较高，但由于容量呈指数级增长，扩容频率迅速下降，从而将总成本均摊到多次操作上。

需要注意的是，扩容会使所有指向原 vector 元素的迭代器、指针和引用失效，因为数据的存储地址已发生改变。因此，在已知元素数量的场景下，使用 reserve() 预先分配足够容量是避免多次冗余扩容、提升性能的最佳实践。

93. `vector` 的 `push_back` 和 `emplace_back` 的区别？

push_back 和 emplace_back 的核心区别在于构造对象的时机和方式。

push_back 接受一个已存在的对象，并将其拷贝（左值）或移动（右值）到容器末尾，这个过程中可能产生临时对象的开销。
emplace_back 则直接接受构造参数，通过完美转发在容器末尾的内存中原地构造对象，省去了创建临时对象的步骤，避免了不必要的拷贝或移动操作，因此性能更高。

在大多数情况下，尤其是插入临时对象或构造代价较高的对象时，应优先选用 emplace_back。

94. 关于 `vector` 迭代器失效

当 vector 的底层存储发生改变，尤其是内存重新分配时，指向其元素的迭代器、指针和引用都会变得不可用。

以下是导致 vector 迭代器失效的几种主要情况：

1. 插入元素 (`insert`, `emplace`, `push_back`, `emplace_back`)

插入操作是否导致迭代器失效，取决于是否触发了重新分配（Reallocation）。

导致重新分配：如果插入新元素后，size() 超过了 capacity()，vector 会申请一块新的更大的内存，并将所有现有元素移动或拷贝到新内存中，然后释放旧内存。
- 后果：所有迭代器、指针、引用都会失效，包括 begin(), end() 以及所有指向元素的迭代器。
未导致重新分配：如果插入后 size() <= capacity()，则只需要将插入点之后的所有元素向后移动。
- 后果：所有指向插入点之后元素的迭代器、指针、引用都会失效。插入点之前的迭代器仍然有效。

2. 删除元素 (`erase`, `pop_back`)

删除元素会改变序列，为了保持内存连续，需要将被删除元素之后的所有元素向前移动。

后果：所有指向被删除元素及其之后元素的迭代器、指针、引用都会失效。被删除元素之前的迭代器仍然有效。
特别注意：erase() 函数会返回一个指向被删除元素之后第一个有效元素的新迭代器，你可以利用它来安全地继续遍历。

3. 改变容量 (`reserve`, `resize`, `shrink_to_fit`)

任何可能改变 vector 容量（capacity）的操作都可能引起内存重新分配。

reserve(n)：如果 n > capacity()，则会申请新内存并进行数据迁移，导致全部失效。
shrink_to_fit()：请求减少容量以匹配大小，实现可能会进行重新分配，导致全部失效。
resize(n)：
- 如果 n > capacity()（需要扩容），则全部失效。
- 如果只是增大 size() 但未触发重分配，则 end() 迭代器会失效。
- 如果是减小 size()，则被“抹去”的那些元素的迭代器会失效。

4. 交换 (`swap`)

当两个 vector 进行交换时，它们的底层数据指针会互换。

迭代器、指针、引用不会失效，但它们会交换归属。原来指向容器 A 中元素的迭代器，在交换后指向的是容器 B 中的元素，反之亦然。

5. 清空 (`clear`)

clear() 函数会移除所有元素，并将 size() 设为 0。它不保证会改变 capacity()。

所有指向被清除元素的迭代器、指针、引用都会失效。因为元素对象已经被销毁了。

95. C++ 不同权限继承分别会有怎样的表现？

C++ 的继承有 public、protected、private 三种方式：

public 继承：基类的 public 成员仍然是 public，protected 成员仍然是 protected；
protected 继承：基类的 public 和 protected 成员都变成 protected；
private 继承：基类的 public 和 protected 成员都变成 private。

96. 单例模式的概念和实现？懒汉式/饿汉式？线程安全？

概念

单例模式（Singleton）是一种创建型设计模式，保证一个类在系统中只有一个实例，并提供一个全局访问点。

典型实现方式是将构造函数设为 private，在类内维护一个静态指针或引用，并通过一个 static 方法获取实例。
这样可以确保外部无法随意构造对象，而只能通过该方法获得同一个实例。

懒汉式：在第一次调用 getInstance() 时才创建实例，节省内存，但需要考虑多线程时的同步问题。

饿汉式：在程序启动时就初始化实例，线程安全且实现简单，但可能造成资源浪费。通常通过加锁（如 mutex）或使用双重检查锁（DCLP）来保证多线程下实例只被创建一次，同时避免每次访问都加锁带来的性能损耗。

前者加锁在 C++11 后一般都是利用 函数内静态变量 的线程安全初始化，而非加锁

懒汉式（线程安全）

特点：进程启动阶段就构造实例；首次使用时无需加锁；简单、安全（依赖静态对象初始化顺序规则）。

饿汉式之所以能保证线程安全，核心原因在于静态对象的初始化时机：

EagerSingleton::s_instance 是一个 静态存储期对象（全局 / namespace 作用域静态变量，或类中的静态成员）。 C++ 标准规定：

静态存储期对象的构造在 main 函数执行之前 完成。

这个初始化过程是由运行时（Runtime）在单线程环境下完成的。换句话说，在进入 main() 之前，s_instance 就已经被安全地构造好了。

因此，在程序运行的并发环境里，任何线程调用 EagerSingleton::instance() 时，s_instance 已经是构造完成的对象，不存在“多个线程同时构造”的竞争条件。

#include <iostream>

class EagerSingleton {
public:
    static EagerSingleton& instance() {
        return s_instance;               // 已在程序启动时构造完成
    }

    void hello() const { std::cout << "Eager\n"; }

    // 禁用拷贝/移动
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;
    EagerSingleton(EagerSingleton&&) = delete;
    EagerSingleton& operator=(EagerSingleton&&) = delete;

private:
    EagerSingleton() { /* 初始化资源 */ }
    ~EagerSingleton() = default;

    static EagerSingleton s_instance;    // 定义见 .cpp
};

// 若放在同一翻译单元（示例用），需提供定义：
EagerSingleton EagerSingleton::s_instance;

int main() {
    EagerSingleton::instance().hello();
}

要点：

s_instance 是静态全局对象，程序启动期构造、退出时析构。
如果跨多个翻译单元，建议把定义放进唯一的 .cpp 中，避免 ODR 冲突。

饿汉式（线程安全）

方式 A：Meyers Singleton（推荐）

特点：利用 函数内静态变量 的线程安全初始化（C++11 起标准保证），写法最简洁。

#include <iostream>

class LazySingleton {
public:
    static LazySingleton& instance() {
        static LazySingleton inst;   // 首次调用时构造，线程安全
        return inst;
    }

    void hello() const { std::cout << "Lazy (Meyers)\n"; }

    LazySingleton(const LazySingleton&) = delete;
    LazySingleton& operator=(const LazySingleton&) = delete;
    LazySingleton(LazySingleton&&) = delete;
    LazySingleton& operator=(LazySingleton&&) = delete;

private:
    LazySingleton() { /* 初始化资源 */ }
    ~LazySingleton() = default;
};

int main() {
    LazySingleton::instance().hello();
}

优点：简洁、可靠、由标准保证一次性初始化；缺点：析构顺序不受你精细控制（通常不是问题）。

方式 B：双重检查锁（DCLP）+ `std::atomic`（展示用）

在需要手动控制生命周期（如显式 destroy()）的场景可用；写法更复杂，需小心内存序语义。多数情况下 A 足够。

#include <atomic>
#include <mutex>
#include <iostream>

class LazySingletonDCLP {
public:
    static LazySingletonDCLP* instance() {
        LazySingletonDCLP* p = ptr.load(std::memory_order_acquire);
        if (!p) {
            std::lock_guard<std::mutex> lk(mtx);
            p = ptr.load(std::memory_order_relaxed);
            if (!p) {
                p = new LazySingletonDCLP();
                ptr.store(p, std::memory_order_release);
            }
        }
        return p;
    }

    static void destroy() {               // 若需要显式销毁（可选）
        std::lock_guard<std::mutex> lk(mtx);
        LazySingletonDCLP* p = ptr.load(std::memory_order_relaxed);
        if (p) {
            delete p;
            ptr.store(nullptr, std::memory_order_release);
        }
    }

    void hello() const { std::cout << "Lazy (DCLP)\n"; }

    LazySingletonDCLP(const LazySingletonDCLP&) = delete;
    LazySingletonDCLP& operator=(const LazySingletonDCLP&) = delete;
    LazySingletonDCLP(LazySingletonDCLP&&) = delete;
    LazySingletonDCLP& operator=(LazySingletonDCLP&&) = delete;

private:
    LazySingletonDCLP() { /* 初始化资源 */ }
    ~LazySingletonDCLP() = default;

    static std::atomic<LazySingletonDCLP*> ptr;
    static std::mutex mtx;
};

std::atomic<LazySingletonDCLP*> LazySingletonDCLP::ptr{nullptr};
std::mutex LazySingletonDCLP::mtx;

int main() {
    LazySingletonDCLP::instance()->hello();
    LazySingletonDCLP::destroy();
}

首选：懒汉式的 Meyers Singleton（方式 A）或饿汉式静态对象，代码最简、标准保证线程安全。
仅当需要手动销毁或自定义分配策略时，再考虑 DCLP/std::call_once 等更复杂写法。

97. 虚函数定义为析构函数能避免内存泄露的实现原理是什么？

当基类指针指向派生类对象并通过 delete 释放时，如果基类的析构函数不是虚函数，那么只会调用基类析构函数，派生类部分无法正确析构，导致资源未释放从而造成内存泄露。而将析构函数声明为虚函数后，析构时会触发虚函数表的动态绑定，先调用派生类的析构函数，再调用基类析构函数，确保对象的所有资源被正确释放。

98. 为什么哈希表不适合做索引结构？

阿里面试 · 数据库

参考链接：

一个视频带你了解常用存储引擎数据结构

深入理解 B+ 树原理

这是一个非常核心的【数据库】问题。

哈希表虽然拥有 O(1) 的极致点查询性能，但它固有的特性使其在大多数情况下不适合作为数据库的主流索引结构。

数据库索引的核心需求不仅仅是“快”，更是灵活性和高效地支持多种查询模式。哈希表在这一点上存在致命缺陷。

以下是哈希表不适合做（主流的）数据库索引结构的几个关键原因：

(1) 无法支持范围查询 (Range Queries)

这是哈希索引的最大死穴。

哈希表的工作方式：基于哈希函数将键映射到特定的存储位置。这个映射是分散的、无序的。id=100 和 id=101 的记录可能被哈希到完全不相干的两个桶（bucket）里。
数据库的常见需求：查询如 WHERE id > 100 AND id < 200、WHERE name LIKE 'A%'、ORDER BY date。这些查询需要数据是有序的。
哈希表的困境：为了完成一个范围查询，哈希表必须扫描表中的每一项，因为数据在存储上是没有顺序的。这相当于全表扫描（O(n)），完全丧失了索引的意义。而 B+树等有序索引可以高效地定位范围的起点，然后通过叶子节点的链表顺序遍历即可。

(2) 无法支持排序 (ORDER BY) 和前缀匹配 (LIKE 'abc%')

排序：ORDER BY 子句需要数据有序。哈希表输出的数据是杂乱无章的，要排序就必须将所有结果集放入内存或进行磁盘排序，成本极高。
前缀匹配：LIKE 'abc%' 本质上也是一个范围查询（从'abc'到'abd'），同样需要索引是有序的。哈希函数会把 'abc' 和 'abcd' 哈希成完全不同的值，无法利用索引。

(3) 哈希冲突与性能退化

冲突处理：再好的哈希函数也可能存在冲突（两个不同的键被映射到同一个位置）。需要额外的机制来处理（如链表法），这会在冲突发生时增加查询时间。
最坏情况：如果哈希函数设计不佳或数据有特定模式，大量键可能被哈希到少数几个桶中，导致某些链变得非常长。最坏情况下，查询性能会退化为 O(n)，这与设计初衷背道而驰。

(4) 哈希函数的选择至关重要且困难

选择一个能均匀分散数据的哈希函数非常关键，但这并非易事，需要根据具体的数据分布来决定。
一旦数据特征发生变化，原先合适的哈希函数可能不再高效，而更换哈希函数意味着要重建整个索引，成本巨大。

(5) 不支持部分索引（最左匹配原则）

对于复合索引（如索引 (last_name, first_name)），B+树可以支持只查询 last_name 的查询（最左匹配）。
哈希索引必须使用所有键来计算哈希值。如果你只知道 last_name 而不知道 first_name，哈希函数将无法计算，索引也就完全失效。

(6) 内存使用效率

为了避免频繁冲突，哈希表通常需要保持较大的空闲空间（较低的负载因子，如 70%），这会导致内存/磁盘空间的浪费。
B+树的页面填充率通常可以很高（如 70%-100%），空间利用率更好。

99. B-Tree、B+ Tree、LSM-Tree

详细探讨一下在数据库和存储系统中至关重要的三种数据结构：B 树、B+ 树和 LSM 树。

它们都是为了解决不同场景下，如何高效地管理和访问磁盘上的大量数据而设计的。

1. B 树

B 树是一种自平衡的多路搜索树，它允许每个节点有多个子节点（超过两个）。它旨在最大限度地减少磁盘 I/O 操作，因为从磁盘读取一个节点（即一个页面或块）通常需要一次 I/O，而节点内键的比较则在内存中进行，速度很快。

核心特性与结构

多路平衡：一个节点可以拥有多个子节点（通常是上百甚至上千个），这大大降低了树的高度。树的高度与磁盘 I/O 次数直接相关，矮胖的树比高瘦的二叉树性能好得多。
排序节点：每个节点中的键（Key）都是按顺序存储的。
节点容量：一个m 阶的 B 树（order-m）满足以下属性：
1. 每个节点最多有 m 个子节点。
2. 每个内部节点（非根非叶）至少有 ⌈m/2⌉ 个子节点。
3. 根节点至少有两个子节点（除非它是叶子节点）。
4. 所有叶子节点都位于同一层，显示出完美的平衡。
数据存储：在经典的 B 树定义中，所有节点（包括内部节点）都可以存储数据。

操作

查询：从根节点开始，在节点内部进行二分查找，找到合适的区间，然后递归地进入对应的子节点，直到找到目标键或确认键不存在。
插入：
1. 找到应插入的叶子节点。
2. 如果该节点有空间，则直接插入并排序。
3. 如果节点已满，则进行分裂（Split）：将中间键提升到父节点，原节点分裂成两个。这个分裂过程可能会一直向上传播到根节点，导致树增高。
删除：稍微复杂一些，可能涉及从兄弟节点借键（借用）或者与兄弟节点合并，以保持树的平衡和节点的最小度数要求。

优点

自动保持平衡，保证查询、插入、删除的时间复杂度为 O(log n)。
矮胖的结构减少了磁盘访问次数。

缺点（尤其是在数据库索引场景下）

区间查询效率相对较低：由于数据可能分布在所有节点（包括内部节点），进行范围查询（如SELECT * FROM table WHERE key BETWEEN 10 AND 100）时需要在树中进行多次中序遍历，效率不高。
节点结构相对浪费空间：每个节点既存储键，也可能存储数据，导致每个节点能存放的键数量相对减少，树的高度可能略高于 B+树。

2. B+树

B+ 树是 B 树的一种变体，是现代关系型数据库（如 MySQL 的 InnoDB、PostgreSQL）索引的事实标准。它针对 B 树在数据库应用中的缺点进行了优化。

核心特性与结构（与 B 树的主要区别）

数据只存储在叶子节点：内部节点只存储键（索引信息）和指向子节点的指针。这使得内部节点可以容纳更多的键，从而进一步降低树的高度。
叶子节点通过指针串联：所有叶子节点构成一个有序双向链表。这是实现高效区间查询的关键。

操作

插入和删除过程与 B 树类似，也涉及分裂和合并，但规则稍有不同，因为要维护叶子节点的链表结构。

优点（相较于 B 树）

更低的树高：内部节点不存储数据，可以容纳更多的键，因此在相同数据量下，B+树比 B 树更矮胖，I/O 次数更少。
更稳定的查询性能：任何查询都必须到达叶子节点，因此每次查找的路径长度都是相同的（O(log n)）。
极高的区间查询效率：这是 B+树最大的优势。一旦在叶子节点上找到了范围的起始点，就可以通过叶子节点的链表指针顺序扫描，无需回溯到上层节点。

缺点

由于数据只存在于叶子节点，每次查询都必须到达叶子节点，单点查询性能可能略逊于 B 树（如果数据在 B 树的内部节点就找到的话），但这种差异微乎其微。

3. LSM 树

LSM 树的设计理念与 B+树完全不同。它牺牲了部分的读性能，来换取极高的写吞吐量。它广泛应用于写多读少的场景，如 Google Bigtable、HBase、Cassandra、LevelDB、RocksDB 等 NoSQL 数据库中。

设计哲学

磁盘的顺序写入速度远快于随机写入。B+ 树需要原地更新数据，可能涉及随机写入（如分裂节点）。LSM 树则通过以下方式将随机写入转换为顺序写入：

先写入内存和日志。
在后台合并和排序。

核心结构与工作流程

LSM 树通常由两个或多个主要组件构成：

MemTable：
- 一个常驻内存的数据结构（通常是跳表 SkipList 或平衡树）。
- 所有新的写入操作首先被写入 MemTable，同时也会被追加到一个预写日志（Write-Ahead Log, WAL） 中用于崩溃恢复。
- 读操作需要同时查询 MemTable 和后续的 SSTable，然后合并结果。
Immutable MemTable：
- 当 MemTable 的大小达到阈值时，它会变为只读状态（Immutable），并准备被刷写到磁盘。同时，一个新的 MemTable 会被创建来接收新的写入操作。
- 这个设计避免了读写锁冲突，保证了持续的写入性能。
SSTable (Sorted String Table)：
- Immutable MemTable 被顺序、批量地写入磁盘，形成一个 SSTable 文件。
- SSTable 是不可变的（Immutable），其中的数据是按键排序的。
- 随着写入不断进行，磁盘上会积累多个 SSTable 文件。
Compaction（压缩合并）：
- 这是 LSM 树的核心后台进程。它会将多个较小的、可能有键重叠的 SSTable 合并（Merge-Sort） 成一个更大的、新的 SSTable，并在这个过程中丢弃已删除或过时的数据。
- 这个过程保证了数据的有序性和减少了文件数量，从而优化读性能。

优点

极高的写入吞吐量：写入几乎是纯顺序 I/O（写 WAL 和刷写 SSTable），速度极快，远超 B+树的随机写入。
良好的压缩效率：由于 SSTable 是不可变且有序的，可以采用高效的压缩算法，节省磁盘空间。

缺点

读放大（Read Amplification）：一次读操作可能需要检查 MemTable 和多个 SSTable 文件（使用布隆过滤器等优化技术来减少不必要的文件查找），延迟可能不如 B+树稳定且通常更高。
写放大（Write Amplification）：Compaction 过程会反复重写数据，带来额外的磁盘写入。
空间放大（Space Amplification）：在 Compaction 发生前，重复的数据（不同版本）或已删除的数据可能同时存在于多个 SSTable 中，暂时占用额外空间。

总结与对比

如果你的应用是传统的 OLTP 业务，有大量随机读和范围查询（如电商、ERP），B+ 树是首选。
如果你的应用是监控、日志采集、物联网传感器数据等海量写入的场景，对写入速度要求极高，并能接受稍慢的读速度，LSM 树是更优的选择。

100. `placement new` 的使用场景及其内存分配约束

字节面试题、华为面试题

C++ 中 placement new 的使用场景和内存分配约束。这是一个高级但非常重要的特性，常用于需要精细控制内存管理的场景。

核心概念：将“内存分配”与“对象构造”分离

通常，new 运算符做了两件事：

分配内存：在堆上分配足够大小的内存以容纳该类型的对象。
构造对象：在刚刚分配的内存上调用对象的构造函数。

delete 运算符则做了相反的两件事：

析构对象：调用对象的析构函数。
释放内存：释放对象所占用的内存。

placement new 允许你将这两个步骤分离开来。它只执行第二步（构造对象），而不分配任何内存。你负责提前提供一块内存，placement new 只是在这块你提供的内存上调用构造函数。

它的标准形式如下：

#include <new> // 必须包含的头文件

void* preallocatedMemory = ...; // 你事先获得的一块内存
MyClass* obj = new (preallocatedMemory) MyClass(constructorArgs);

这里的 (preallocatedMemory) 就是“placement”参数。placement new 是 operator new 的一个重载版本。

主要使用场景

placement new 的应用几乎总是围绕着性能、自定义内存管理或特殊需求。

1. 内存池和自定义内存分配器

这是最常见和最重要的用途。

场景：在性能关键的系统中（如游戏引擎、高频交易），频繁地使用默认的 new 和 delete 会导致堆碎片和分配开销（因为需要查找合适的内存块、维护堆数据结构等）。
做法：程序启动时，一次性分配一大块内存（“内存池”）。当需要创建对象时，从这块大内存中手动划分出一小块空闲内存，然后使用 placement new 在这小块内存上构造对象。对象销毁时，手动调用析构函数，然后将内存标记为空闲并归还给内存池，而不是调用 delete。
优点：
- 极快的分配/释放速度：只是移动指针或操作空闲链表。
- 避免内存碎片：所有对象都从连续的大块内存中分配。
- 更好的局部性：连续分配的对象在物理内存上也很可能连续，提高缓存命中率。

2. 在特定内存地址构造对象

场景：需要与硬件或特定系统接口交互时。例如，在嵌入式系统中，你可能需要将一个对象直接构造在某个已知的硬件寄存器地址或共享内存段上。
做法：直接将硬件地址或共享内存地址作为 placement new 的参数。
```
volatile HardwareRegister* reg = new (0xFFFF0000) HardwareRegister;
```

3. 非标准内存布局（例如：数组的精确控制）

场景：你想手动管理一个对象数组的生命周期，或者需要绕过 new[] 和 delete[] 可能带来的额外开销（例如存储数组大小的开销）。
做法：先分配一个足够大的 char 数组（sizeof(MyClass) * N），然后使用循环和 placement new 在正确的位置逐个构造对象。销毁时，必须手动逆序调用每个对象的析构函数，最后释放整个 char 数组。

#include <new>
class MyClass {...};

// 1. 分配原始内存（不构造对象）
void* memory = operator new[](sizeof(MyClass) * 10);
MyClass* objects = static_cast<MyClass*>(memory);

// 2. 使用 placement new 构造对象
for (std::size_t i = 0; i < 10; ++i) {
    new (&objects[i]) MyClass(...); // 在指定地址构造
}

// 3. 手动调用析构函数
for (std::size_t i = 10; i > 0; ) {
    --i;
    objects[i].~MyClass(); // 显式析构
}

// 4. 释放原始内存
operator delete[](memory);

4. 实现类似 `std::vector` 和 `std::make_shared` 的容器和智能指针

标准库容器（如 std::vector）在底层使用 allocator 来分配原始内存，然后使用 placement new 在已分配的内存中构造元素。这使它们能够在重新分配时（reserve）将“分配新内存”和“移动/构造元素”分离开来。

类似地，std::make_shared 通常在一次分配中同时获得控制块（引用计数）和对象本身所需的内存，然后使用 placement new 在内存的正确偏移处构造对象。

内存分配约束与注意事项（极其重要）

使用 placement new 意味着你接管了部分编译器的职责，因此必须严格遵守以下约束：

1. 内存必须提前分配且足够大

你提供的指针 preallocatedMemory 必须指向一块已经分配好的内存，并且这块内存的大小至少为 sizeof(MyClass) 字节。如果内存不足，构造函数的行为是未定义的（通常是灾难性的崩溃或数据损坏）。

2. 内存对齐必须正确

你提供的内存地址必须满足该类型 MyClass 的内存对齐要求。C++11 之后可以使用 alignof(MyClass) 来查询对齐要求，使用 alignas(MyClass) char buf[sizeof(MyClass)]; 来声明一个正确对齐的缓冲区。

错误示例：

char buffer[sizeof(MyClass)]; // 一个普通的char数组，可能只按1字节对齐
MyClass* obj = new (buffer) MyClass; // 如果MyClass要求4或8字节对齐，此行为未定义！

正确做法：

// C++11 之前：使用编译器扩展或union技巧
// C++11 之后：
alignas(MyClass) std::byte buffer[sizeof(MyClass)]; // 正确对齐的缓冲区
MyClass* obj = new (buffer) MyClass; // 安全

3. 必须手动调用析构函数

由于 placement new 不分配内存，所以标准的 delete obj; 不能使用。delete 会尝试释放内存，但你提供的内存并不是由 new 分配的，释放它会导致未定义行为。

你必须显式地调用析构函数来销毁对象：

obj->~MyClass(); // 正确：只执行析构，不释放内存

之后，你提供的原始内存如何处理（是复用、归还给内存池还是直接释放）取决于你最初是如何分配它的。

4. 生命周期管理的责任完全在程序员

你需要确保：

对象在其生命周期内，其底层内存保持有效且未被覆盖。
不要对使用 placement new 创建的对象调用 delete。
在底层内存被释放或重用之前，必须调用析构函数。

总结

总而言之，placement new 是一个强大的工具，它将对象的构造与内存分配解耦，为你提供了极致的内存控制能力。然而，这种能力也带来了巨大的责任，你必须严格遵守内存对齐和生命周期管理的规则，否则极易引发难以调试的未定义行为。在大多数日常应用开发中，你不需要直接使用它，但它却是许多高性能库和系统底层实现的基石。

101. 智能指针的应用场景和线程安全问题

应用场景

智能指针用于自动化资源（尤其是动态内存）的生命周期管理，防止内存泄漏。

std::unique_ptr（独占所有权）：
- 场景：适用于资源在任何时刻都只能被一个所有者拥有的情况。是资源管理的默认选择。
- 例子：作为类的成员变量、在函数内部管理动态分配的对象、作为工厂函数的返回值。它替代了需要手动 delete 的原始指针。
std::shared_ptr（共享所有权）：
- 场景：适用于多个对象需要共享同一个资源，并且只有在最后一个所有者被销毁时资源才能被释放的情况。
- 例子：实现缓存机制（多个客户端可能共享同一个缓存对象）、在复杂的数据结构中（如图、节点之间可能共享所有权）、需要将指针存入多个容器中。
std::weak_ptr（弱引用）：
- 场景：与 std::shared_ptr 搭配使用，解决 shared_ptr 的循环引用问题。它提供对共享资源的“非拥有”引用，不会增加引用计数。
- 例子：观察者模式（主题持有观察者的 weak_ptr，避免观察者无法析构）、缓存（持有缓存对象的 weak_ptr，当主所有者释放对象后，缓存自动失效）、打破循环引用（如双链表节点中，父节点对子节点用 shared_ptr，子节点对父节点用 weak_ptr）。

线程安全问题

智能指针本身的引用计数操作是线程安全的，但其指向的对象的读写需要用户自己同步。

引用计数的线程安全：
- std::shared_ptr 的引用计数控制块（control block）是原子操作的。因此，在多线程中复制或析构 shared_ptr 本身是安全的，不会导致引用计数混乱。这是一个非常重要的保证。
指向数据的线程不安全：
- 多个线程同时读写同一个 shared_ptr 实例（例如，对其赋值或重置）是不安全的，需要加锁。这涉及到指针本身（get() 返回的值）的更改。
- 多个线程通过不同的 shared_ptr 实例（它们指向同一个对象）去访问和修改其指向的对象是不安全的。这属于典型的数据竞争，也是必须使用互斥锁（如 std::mutex）或其他同步机制来保护对对象本身的操作。

102. 介绍下布隆过滤器的工作原理和实现

布隆过滤器（Bloom Filter）是一个高效的概率型数据结构，用于快速判断一个元素是否存在于一个超大规模集合中。其核心特点是极其节省空间，但代价是存在一定的误判率（False Positive）。

工作原理/工作流

布隆过滤器的目标不是存储元素本身，而是用一个很小的位数组和一组哈希函数来表示一个集合，从而快速判断一个元素是否绝对不存在或可能存在于集合中。

1. 初始化

创建一个长度为 m 的位数组，所有位初始化为 0。
选择 k 个彼此独立的哈希函数（h1, h2, ..., hk），每个函数能将输入元素映射到位数组的某个位置（范围在 [0, m-1]）。

2. 添加元素：假设要添加元素 "X"。

将 "X" 分别输入 k 个哈希函数，得到 k 个哈希值：h1(X), h2(X), ..., hk(X)。
将位数组中这 k 个位置的值都设置为 1。

3. 查询元素：假设要查询元素 "Y" 是否存在。

将 "Y" 分别输入同样的 k 个哈希函数，得到 k 个哈希值。
检查位数组中这 k 个位置的值：
- 如果这 k 个位置中有任何一个为 0，那么元素 "Y" 肯定不存在（Definitely No）于集合中。
- 如果这 k 个位置全部为 1，那么元素 "Y" 可能存在（Probably Yes）于集合中。

影响因子：m 与 k

布隆过滤器的大小 m（即比特数组的长度）是一个关键的设计参数，它直接影响了过滤器两个最重要的性能指标：误判率和空间效率。这是一个典型的空间换精度的权衡。

1. 对误判率的影响

m 越大，误判率越低。

原因：更大的比特数组意味着更多的“坑位”，k 个哈希函数映射到的位置更分散，不容易发生冲突。
反面： m 越小，比特数组很快就会被填满（更多的位被置为1），导致“假阳性”的概率急剧上升。

2. 对空间效率的影响

m 越大，空间开销越大。

3. 与哈希函数数量 `k` 的相互作用

这是一个联动效应。最优的 k 值取决于 m 和要插入的元素数量 n。
公式：最优的哈希函数数量 $k_{opt} = \frac{m}{n} \ln 2$。
解释：
- 如果 m 很大，但 k 很小（比如只有 1 个哈希函数），那么每个元素设置的位置很少，缺乏“冗余”，仍然容易发生冲突。
- 如果 m 很小，但 k 很大，会导致一个元素设置太多的位，迅速将小的比特数组“填满”，使得几乎每次查询都会碰到所有位都是1的情况，误判率会接近 100%，过滤器也就失效了。
所以不能孤立地谈 m 的大小，必须结合计划存储的元素数量 n 和选择的哈希函数个数 k 来综合设计。

4. 对性能（查询/添加）的轻微影响

影响很小，但存在。添加和查询操作都需要进行 k 次哈希计算和内存访问。
m 的大小本身不影响计算速度（k 次哈希和 k 次内存访问是固定的）。
但是，如果 m 特别大，超出了 CPU 缓存的范围，可能会导致缓存缺失，使得每次内存访问的速度变慢。但在绝大多数应用中，这个影响微乎其微，性能瓶颈主要在哈希计算上。

那你如何决定布隆过滤器的大小？

如果面试官追问：“那你如何决定布隆过滤器的大小？”

在实际工程中，我们通常遵循以下步骤：

确定容量 n：首先预估要存入过滤器的元素最大数量是多少。
设定目标误判率 p：根据业务场景，确定一个可接受的误判率上限（例如 1%， 0.1%）。
计算所需的比特数 m：使用公式 $m = -\frac{nlnp}{(ln2)^2}$。这给出了在理论上达到目标误判率所需的最小的 m。
计算最优哈希函数数 k：再根据公式 $k = \frac{m}{n}\ln2$ round 到最近的整数。
向上取整：最后，我会将计算出的 m 向上取整到最接近的机器字长（例如64的倍数）的整数，以便内存对齐，实现高效的位操作。”

Bloom filter 代码

以下是注释详细的 C++ 布隆过滤器实现，包含了添加、查询、误判率计算和性能测试。

#include <iostream>
#include <vector>
#include <bitset>
#include <functional>
#include <cmath>
#include <string>

/**
 * @brief 布隆过滤器 (Bloom Filter) 实现类
 * 
 * @tparam Size 位数组的大小，以比特为单位。必须是编译期常量。
 */
template <size_t Size>
class BloomFilter {
private:
    std::bitset<Size> bits; // 位数组，用于存储元素的存在信息
    std::vector<std::function<size_t(const std::string&)>> hashFunctions; // 哈希函数集合

public:
    /**
     * @brief 构造函数，初始化指定数量的哈希函数
     * @param numHashes 哈希函数的数量
     */
    BloomFilter(size_t numHashes) {
        // 使用简单的哈希函数种子来生成不同的哈希函数
        for (size_t i = 0; i < numHashes; ++i) {
            // 使用lambda捕获不同的种子来创建不同的哈希函数
            hashFunctions.emplace_back([i](const std::string& item) {
                std::hash<std::string> hasher;
                return hasher(item + std::to_string(i)); // 通过添加不同的后缀来创建不同的哈希函数
            });
        }
    }

    /**
     * @brief 向布隆过滤器中添加一个元素
     * @param item 要添加的元素（字符串形式）
     */
    void add(const std::string& item) {
        for (const auto& hashFunc : hashFunctions) {
            size_t hashValue = hashFunc(item);
            size_t index = hashValue % Size; // 映射到位数组的位置
            bits.set(index, true); // 将对应位置设为1
        }
    }

    /**
     * @brief 检查元素是否可能存在于布隆过滤器中
     * @param item 要检查的元素
     * @return true - 元素可能存在（有误判可能）
     * @return false - 元素肯定不存在
     */
    bool possiblyContains(const std::string& item) const {
        for (const auto& hashFunc : hashFunctions) {
            size_t hashValue = hashFunc(item);
            size_t index = hashValue % Size;
            if (!bits.test(index)) { // 如果任何一个位为0
                return false; // 肯定不存在
            }
        }
        return true; // 所有位都为1，可能存在
    }

    /**
     * @brief 计算当前布隆过滤器的理论误判率
     * @param insertedItems 已插入元素的数量
     * @return double 预期的误判率 (0.0 ~ 1.0)
     */
    double expectedFalsePositiveRate(size_t insertedItems) const {
        if (insertedItems == 0) return 0.0;
        
        // 理论误判率公式: (1 - e^(-k*n/m))^k
        double exponent = -static_cast<double>(hashFunctions.size() * insertedItems) / Size;
        return std::pow(1 - std::exp(exponent), hashFunctions.size());
    }

    /**
     * @brief 获取位数组的使用率（已置为1的位数比例）
     * @return double 使用率 (0.0 ~ 1.0)
     */
    double getUsageRatio() const {
        return static_cast<double>(bits.count()) / Size;
    }

    /**
     * @brief 重置布隆过滤器，清空所有数据
     */
    void reset() {
        bits.reset();
    }

    /**
     * @brief 获取位数组大小
     */
    size_t size() const {
        return Size;
    }

    /**
     * @brief 获取哈希函数数量
     */
    size_t hashCount() const {
        return hashFunctions.size();
    }
};

/**
 * @brief 运行特定配置的测试
 */
template <typename BloomFilterType>
void runConfigurationTest(BloomFilterType& bloomFilter, 
                         const std::string& sizeDesc, 
                         size_t k, 
                         size_t testItems) {
    // 添加测试元素
    for (int i = 0; i < testItems; ++i) {
        bloomFilter.add("item_" + std::to_string(i));
    }
    
    // 测试误判率
    int falsePositives = 0;
    for (int i = 0; i < testItems; ++i) {
        if (bloomFilter.possiblyContains("test_" + std::to_string(i))) {
            falsePositives++;
        }
    }
    
    double fpr = static_cast<double>(falsePositives) / testItems;
    std::cout << "Size: " << sizeDesc << ", Hashes: " << k 
              << ", FPR: " << (fpr * 100) << "%, Usage: " 
              << (bloomFilter.getUsageRatio() * 100) << "%" << std::endl;
}

/**
 * @brief 比较不同配置下的布隆过滤器性能
 */
void compareDifferentConfigurations() {
    std::cout << "\n\n===== 不同配置性能比较 =====" << std::endl;
    
    const size_t TEST_ITEMS = 1000;
    const size_t sizes[] = {5000, 10000, 20000}; // 不同的位数组大小
    const size_t hashes[] = {3, 7, 11};          // 不同的哈希函数数量
    
    for (size_t size : sizes) {
        for (size_t k : hashes) {
            // 使用模板特化来支持不同大小
            if (size == 5000) {
                BloomFilter<5000> bf(k);
                runConfigurationTest(bf, "5K bits", k, TEST_ITEMS);
            } else if (size == 10000) {
                BloomFilter<10000> bf(k);
                runConfigurationTest(bf, "10K bits", k, TEST_ITEMS);
            } else if (size == 20000) {
                BloomFilter<20000> bf(k);
                runConfigurationTest(bf, "20K bits", k, TEST_ITEMS);
            }
        }
    }
}

/**
 * @brief 测试布隆过滤器性能的函数
 */
void testBloomFilter() {
    std::cout << "===== 布隆过滤器性能测试 =====" << std::endl;
    
    const size_t BLOOM_FILTER_SIZE = 10000; // 位数组大小：10,000 位
    const size_t NUM_HASHES = 7;            // 哈希函数数量：7个
    const size_t TEST_ITEMS = 1000;         // 测试元素数量：1000个
    
    // 创建布隆过滤器实例
    BloomFilter<BLOOM_FILTER_SIZE> bloomFilter(NUM_HASHES);
    
    // 生成测试数据
    std::vector<std::string> insertedItems;
    std::vector<std::string> testItems;
    
    for (int i = 0; i < TEST_ITEMS; ++i) {
        insertedItems.push_back("item_" + std::to_string(i));
        testItems.push_back("test_" + std::to_string(i)); // 这些是不会被插入的测试项
    }
    
    // 1. 添加元素
    std::cout << "正在添加 " << TEST_ITEMS << " 个元素..." << std::endl;
    for (const auto& item : insertedItems) {
        bloomFilter.add(item);
    }
    
    // 2. 检查已插入的元素（应该全部"可能存在"）
    std::cout << "\n检查已插入的元素：" << std::endl;
    int truePositives = 0;
    for (const auto& item : insertedItems) {
        if (bloomFilter.possiblyContains(item)) {
            truePositives++;
        }
    }
    std::cout << "真正例数: " << truePositives << "/" << TEST_ITEMS 
              << " (" << (truePositives * 100.0 / TEST_ITEMS) << "%)" << std::endl;
    
    // 3. 检查未插入的元素（测量误判率）
    std::cout << "\n检查未插入的元素（测量误判率）：" << std::endl;
    int falsePositives = 0;
    for (const auto& item : testItems) {
        if (bloomFilter.possiblyContains(item)) {
            falsePositives++;
        }
    }
    
    double actualFPR = static_cast<double>(falsePositives) / TEST_ITEMS;
    double expectedFPR = bloomFilter.expectedFalsePositiveRate(TEST_ITEMS);
    
    std::cout << "误判数: " << falsePositives << "/" << TEST_ITEMS << std::endl;
    std::cout << "实际误判率: " << (actualFPR * 100) << "%" << std::endl;
    std::cout << "理论误判率: " << (expectedFPR * 100) << "%" << std::endl;
    
    // 4. 显示使用情况
    std::cout << "\n布隆过滤器使用情况：" << std::endl;
    std::cout << "位数组大小: " << bloomFilter.size() << " bits (" 
              << (bloomFilter.size() / 8) << " bytes)" << std::endl;
    std::cout << "哈希函数数量: " << bloomFilter.hashCount() << std::endl;
    std::cout << "位数组使用率: " << (bloomFilter.getUsageRatio() * 100) << "%" << std::endl;
    
    // 5. 演示"肯定不存在"的特性
    std::cout << "\n演示'肯定不存在'特性：" << std::endl;
    std::string nonExistentItem = "definitely_not_inserted_12345";
    bool result = bloomFilter.possiblyContains(nonExistentItem);
    std::cout << "检查未添加的元素 '" << nonExistentItem << "': " 
              << (result ? "可能存在" : "肯定不存在") << std::endl;
}

int main() {
    // 运行基本测试
    testBloomFilter();
    
    // 运行配置比较
    compareDifferentConfigurations();
    
    std::cout << "\n===== 测试完成 =====" << std::endl;
    return 0;
}

Output

 ~/Desktop  ./bloom_filter 
===== 布隆过滤器性能测试 =====
正在添加 1000 个元素...

检查已插入的元素：
真正例数: 1000/1000 (100%)

检查未插入的元素（测量误判率）：
误判数: 4/1000
实际误判率: 0.4%
理论误判率: 0.819372%

布隆过滤器使用情况：
位数组大小: 10000 bits (1250 bytes)
哈希函数数量: 7
位数组使用率: 50.25%

演示'肯定不存在'特性：
检查未添加的元素 'definitely_not_inserted_12345': 肯定不存在


===== 不同配置性能比较 =====
Size: 5K bits, Hashes: 3, FPR: 8.7%, Usage: 45.2%
Size: 5K bits, Hashes: 7, FPR: 14.4%, Usage: 75.5%
Size: 5K bits, Hashes: 11, FPR: 31.2%, Usage: 88.94%
Size: 10K bits, Hashes: 3, FPR: 1.4%, Usage: 26.09%
Size: 10K bits, Hashes: 7, FPR: 0.4%, Usage: 50.25%
Size: 10K bits, Hashes: 11, FPR: 1.3%, Usage: 66.44%
Size: 20K bits, Hashes: 3, FPR: 0.1%, Usage: 13.955%
Size: 20K bits, Hashes: 7, FPR: 0%, Usage: 29.425%
Size: 20K bits, Hashes: 11, FPR: 0%, Usage: 41.945%

===== 测试完成 =====

103. 常量数组和数组常量的区别？

常量数组指数组元素是常量（如 const int arr[5]），内容不可修改；

数组常量指数组本身是常量（如 int* const arr），指针不可指向其他地址。

构造方式：常量数组用 const 类型名[] 声明并初始化；数组常量需用 类型* const 声明并固定指向已分配内存。

104. 常量指针和指针常量区别？

常量指针通常有两种表示方法：

const int* ptr
int const* ptr

指针常量通常表示为：

double *const ptr

区分：从左往右读/看

const 读作常量， * 读作指针；const* 就是常量指针，*const 就是指针常量。

const 靠近谁就是谁不变；const char *p1 靠近 char * 所以是内容不可变，char *const p2 靠近 p2 所以是指针指向不可变。

常量指针：指向常量的指针，与下面相反，指针地址的内容值不能修改，但指针地址指向可以改。

指针常量：指的是指针本身就是个常量，注意这里说的是指针本身是常量，指针是用来指向某个对象的（指针也就是这个对象的地址）指针本身是常量，就是这个地址是个常量，不能更换，但是可以更换这个地址存放的值。

#include <iostream>
using namespace std;

int main() {
  char ch = 'h';
  char s = 'm';
  const char *p1 = &ch;  // 常量指针: 可以通过它更换指向的对象，但是不能改变指向对象的值；
  char *const p2 = &ch;  // 指针常量: 可以通过它更改对象的值，但是不能更改指向的对象；
  p1 = &s;               // 正确;
  *p1 = 'k';             // 错误;
  *p2 = 'k';             // 正确;
  p2 = &s;               // 错误;
}

105. C++ 模板的原理？

C++ 模板的原理本质上是一种编译期的代码生成机制，其核心是参数化多态。

当编译器遇到模板定义（如一个函数模板或类模板）时，它并不会立即生成任何实际的机器代码，而是将其视为一种生成代码的“蓝图”或“配方”存储在编译单元中。只有当编译器在源代码中看到模板被实例化（即提供了具体的模板参数，如 MyClass<int>）时，它才会执行模板实例化这个过程：将模板定义中的每个模板参数（如 typename T）替换为提供的具体类型（如 int），从而生成一个全新的、普通的类或函数的源代码副本（称为特化或实例）。这个过程是静态的，发生在编译阶段，因此不同的实例化会生成完全独立的类型（例如，vector<int> 和 vector<string> 是两个毫无关联的类），这导致了著名的“代码膨胀”现象，但也确保了类型安全和极高的运行时效率。最终，编译器再像处理普通手写代码一样，对这些生成的特化代码进行编译和优化，生成目标代码。

106. 命名空间的作用？

命名空间用于解决标识符（变量、函数、类名）冲突问题，将代码逻辑分组封装，形成独立作用域。通过 namespace 关键字定义，使用时需指定命名空间（如 std::vector）或使用 using 声明，避免全局作用域污染。

107. 迭代器在 STL 中的作用？

迭代器是 STL 中抽象化的指针，提供统一访问容器元素的方式（如遍历、修改），实现算法与容器的解耦。

它分为输入、输出、前向、双向、随机访问等类别，支持泛型算法（如 sort）无需关心底层容器实现。

108. 指针 `*` 和引用 `&` 的区别（进阶版）

一、引用和指针的区别

引用和指针本质上都是间接访问和操作其他对象的方式，但它们在语法、安全性和灵活性上有显著区别。

二、二者的应用场景

引用的主要应用场景

函数参数传递（按引用传递）：这是最常见用途。用于避免大型对象拷贝的开销，并允许函数修改传入的实参。

void swap(int& a, int& b) { // 修改实参
    int temp = a;
    a = b;
    b = temp;
}

void printLargeObject(const BigClass& obj) { // 避免拷贝，且不允许修改
    // ... 只读操作
}

函数返回值（返回引用）：常用于返回函数调用者可以修改的对象，如重载赋值运算符=、下标运算符[]、流运算符<</>>。
```
class MyVector {
    int data[100];
public:
    int& operator[](size_t index) { return data[index]; } // 返回引用，允许v[i] = 5;
};
```

范围for循环：需要修改容器元素时，必须使用引用。

for (auto& element : myVector) {
    element *= 2; // 修改容器内的元素
}

指针的主要应用场景

动态内存管理：使用 new/delete 或 malloc/free 在堆上分配资源时，必须用指针来管理。
```
int* array = new int[100];
delete[] array;
```

多态和面向对象：通过基类指针来管理派生类对象，实现运行时多态。

class Base { virtual void func(); };
class Derived : public Base { void func() override; };

Base* ptr = new Derived();
ptr->func(); // 调用的是Derived::func()
delete ptr;

需要表示“可选”或“可为空”的语义：当需要一个可能不指向任何对象的变量时，必须使用指针。
```
TreeNode* parent = nullptr; // 根节点的父节点为空
```
需要显式处理地址或进行底层操作：如操作硬件、数据结构（链表、树等）等。
```
struct ListNode {
    int val;
    ListNode* next; // 指向下一个节点的指针
};
```

三、函数传递引用和传递指针的区别？

这个问题更准确的表述是：函数按引用传递（Pass-by-Reference）和按值传递（Pass-by-Value）的区别？

代码示例对比：

#include <iostream>
using namespace std;

// 1. 按值传递 - 拷贝副本
void byValue(int x) {
    x = 100; // 只修改了副本，外部的num1不变
}

// 2. 按引用传递 - 传递别名
void byReference(int& x) {
    x = 200; // 直接修改外部的num2
}

// 3. 按指针传递（本质也是按值传递，但传递的是地址的值） - 传递地址
void byPointer(int* x) {
    *x = 300; // 解引用，修改x所指向的外部num3的值
}

int main() {
    int num1 = 1, num2 = 2, num3 = 3;

    byValue(num1);
    byReference(num2);
    byPointer(&num3); // 需要显式取地址

    cout << num1 << endl; // 输出 1
    cout << num2 << endl; // 输出 200
    cout << num3 << endl; // 输出 300

    return 0;
}

总结：

按值传递：适用于不需要修改实参，且参数是内置类型（int, double等）或小型结构体的情况。
按引用传递：适用于需要修改实参，或参数是大型对象需要避免拷贝开销的情况。使用 const引用（如 const BigObj&）可以同时实现避免拷贝 + 不允许修改，是最佳的只读参数传递方式。
按指针传递：在C++中，除非需要表达“可选”语义（可能为nullptr）或需要重新指向其他对象，否则优先使用引用。按指针传递在语法上更繁琐（需要&和*），且安全性更低。

109. `noexcept` 原理，`noexcept` 修饰函数内抛出异常怎么办？

帮助编译器对“非抛出函数”进行优化
影响标准库的行为
异常传播处理

1. 帮助编译器对“非抛出函数”进行优化

noexcept 关键字首先是一个给编译器的指令和承诺。当一个函数被标记为 noexcept（或 noexcept(true)），编译器会基于这个承诺进行两方面的优化：

简化异常处理代码生成：在通常情况下，编译器需要为可能抛出异常的函数生成复杂的“栈展开（Stack Unwinding）”代码。这套机制负责在异常抛出时，自动调用所有已构造的局部对象的析构函数，以保证资源的正确释放。对于 noexcept 函数，编译器可以确信该函数执行过程中不会有异常抛出，因此完全可以省略这部分栈展开代码的生成。这使得生成的机器码更小、更紧凑。
启用更激进的代码优化：由于异常路径不存在，编译器的优化器可以更自由地对 noexcept 函数的代码进行重组和简化。它不需要考虑在异常发生时保持一种可回滚的状态，从而可以更专注于优化正常的执行路径，这有可能带来性能上的提升。

核心思想：noexcept 通过提供一份“绝不会抛出异常”的保证，允许编译器生成更精简、更高效的代码。

2. 影响标准库的行为

noexcept 更显著的作用是它会影响标准库组件的算法选择和行为，尤其是在与移动语义和资源管理相关的操作上。标准库会利用 noexcept 说明符在“强异常安全”和“性能”之间做出权衡。

移动操作与拷贝操作的抉择：最经典的例子是 std::vector 的重新分配（reallocation）过程。当 vector 需要扩容时，它需要将旧元素移动到新内存中。如果元素的移动构造函数是 noexcept 的，vector 会安全地使用移动操作，因为这绝不会失败，效率极高。如果移动构造函数不是 noexcept 的，vector 为了保持“强异常安全”保证（如果移动中抛出异常，旧容器状态不变），则会保守地使用拷贝操作，即使拷贝通常更耗时。
std::move_if_noexcept：这个工具函数是上述行为的直接体现。它会在类型移动操作为 noexcept 时返回右值引用（以启用移动），否则返回常量左值引用（以禁用移动，促使调用拷贝操作）。
其他标准库操作：类似的行为也存在于 std::swap、std::sort 等算法中，它们可能会在内部使用不同的策略来确保异常安全，而 noexcept 信息是决策的关键依据。

核心思想：noexcept 是标准库选择更高效算法（特别是移动操作）而非更安全但低效算法（拷贝操作）的“许可证”。

3. 异常传播处理

这是关于契约违反后的处理机制，是面试中的关键考察点。

契约与承诺：将函数声明为 noexcept 是程序员向编译器和用户做出的一个坚定承诺，保证该函数的执行绝不会导致异常传播到函数体外。
运行时行为：如果这个承诺在运行时被打破（即函数内部抛出了异常），C++ 标准规定程序必须立即调用 std::terminate() 函数来终止执行。这个过程是不可捕获、不可恢复的。std::terminate() 的默认行为是中止程序（abort），可能不会调用局部对象的析构函数。
设计哲学：这种行为背后的哲学是，违反 noexcept 承诺是一个严重的逻辑错误，其后果是不可预期的。与其让异常在缺乏正确异常处理机制的上下文中传播，导致未定义行为，不如以一种明确、果断的方式终止程序，这保证了程序行为的确定性。

核心思想：在 noexcept 函数中抛出异常会导致程序立即强制终止（std::terminate()），这是一种“契约违反”的严厉惩罚机制，旨在防止更糟糕的未定义行为。

110. 虚函数表底层原理实现

C++ 中的虚函数表（vtable）是实现运行时多态（动态绑定）的核心机制。

其底层原理是：编译器会为每个包含虚函数的类（或从该类继承的子类）秘密地创建一个虚函数表。这个表本质上是一个函数指针数组，其中的每个条目都指向该类的一个虚函数的具体实现。当一个类对象被创建时，编译器会自动在对象的内存布局的开头（或末尾，取决于编译器实现）插入一个隐藏的指针成员（vptr），该指针被初始指向这个类相应的虚函数表。当通过基类指针或引用调用虚函数时，代码会通过对象的 vptr 找到对应的 vtable，然后在 vtable 中查找并调用正确偏移量处的函数指针。这个过程是在运行时进行的，因此能够根据对象的实际类型来决定调用哪个函数，从而实现多态。如果子类重写了虚函数，那么子类的 vtable 中对应条目就会指向子类的函数，而非父类的。

111. `async` 和 `thread pool` 你在使用的时候是怎么选择的

async 是一个关键字或概念，用于声明一个函数是异步函数。它是现代编程语言（如 JavaScript, Python, C#, Rust, C++ 等）中处理并发操作的核心特性，其目的是为了更高效、更简洁地编写非阻塞的、基于 I/O 操作的代码。

其核心思想是：让一个耗时的操作（如网络请求、文件读写、数据库查询）在后台等待完成，而不阻塞主线程的执行。程序可以在此期间去做其他工作，当那个耗时操作完成后，再回来处理它的结果。

一个用 async 标记的函数，通常被称为协程 (Coroutine)。它与普通函数和线程都不同：

不同于普通函数：普通函数是“一路走到黑”的，从调用开始直到 return 语句返回结果，期间调用者必须等待。而异步函数被调用时，会立即返回一个承诺对象（通常叫 Promise, Future, 或 Task），而不是最终结果。这个承诺对象代表一个“未来会完成的操作”。

不同于线程：协程是单线程下的并发技术。多个协程在一个线程上交替运行，由事件循环 (Event Loop) 调度。当一个协程遇到 await（等待）关键字时，它会主动挂起（Suspends），将控制权交还给事件循环，事件循环 then 可以去执行其他就绪的协程。这避免了多线程带来的上下文切换开销和复杂的同步问题（如锁、死锁）。

关键搭档：await

async 总是与 await 关键字配对使用。

async：用于声明一个函数是异步的。

await：用于调用一个异步操作。它只能在 async 函数内部使用。当执行到 await expression 时，它会做两件事：

挂起当前 async 函数的执行。

等待 expression（通常是一个 Promise/Future）完成。

在等待期间，线程不会被阻塞，事件循环可以去执行其他代码。一旦等待的操作完成，事件循环会唤醒这个被挂起的协程，并从 await 之后的地方继续执行，并获取最终结果。

我的选择标准主要基于任务的性质、对性能的控制需求以及资源的生命周期：

使用 std::async 的场景：对于简单的、一次性的异步任务，我会优先选择 std::async。它通过 std::future 提供了便捷的获取结果的机制，并且由标准库自动管理线程的创建和销毁（虽然可以通过启动策略 std::launch::async 强制创建新线程，或用 std::launch::deferred 延迟执行），代码非常简洁。这非常适合“发射后不管”或需要简单等待结果的任务，例如前端快速发起一个后台计算或查询。
使用 thread pool 的场景：在高性能、高并发或需要精细控制的场景下，我一定会选择线程池。线程池的核心优势在于线程复用，它预先创建并维护一组工作线程，避免了频繁创建和销毁线程带来的巨大开销。这非常适合处理大量、短小、频繁的任务队列，例如 Web 服务器处理海量短连接请求。此外，线程池给予我更大的控制权，我可以明确管理线程数量、任务队列的饱和策略等，从而防止系统资源被无限增长的线程耗尽。

112. Python 和 C++ 语言区别和特点，什么时候用 Python 什么时候用 C++？

Python 和 C++ 是两种设计哲学和应用领域截然不同的语言。

区别与特点：

C++：是一种编译型、静态类型的系统级语言。它追求零开销抽象（Zero-overhead Abstraction），提供对硬件和内存的精细控制，性能极高。但代价是语法复杂，需要开发者手动管理内存等资源，开发迭代速度较慢。
Python：是一种解释型、动态类型的高级语言。它强调代码的可读性和开发效率，语法简洁，拥有庞大的开源库生态。但其运行时性能远低于 C++，由于其全局解释器锁（GIL）和动态特性。

选择标准：

使用 C++：当性能是首要目标，或需要直接与操作系统/硬件交互时。典型场景包括：游戏引擎、高频交易系统、浏览器/数据库等大型基础软件、嵌入式系统、性能关键的中间件等。
使用 Python：当开发速度和易用性更重要时。典型场景包括：Web 后端（Django/Flask）、数据科学/机器学习（NumPy/Pandas/TensorFlow/PyTorch）、自动化运维脚本、快速原型验证、以及作为“胶水语言”将各种 C++库粘合起来。

113. 有没有在 Window 上编译开发的经验

我有在 Windows 平台上进行编译和开发的丰富经验。我的主要工具链是Visual Studio及其集成的 MSVC 编译器，我熟悉其项目属性配置、调试器以及各种构建选项。此外，为了保持项目的跨平台兼容性，我广泛使用 CMake 来生成 Visual Studio 的解决方案（.sln）文件。我也接触过 MinGW-w64 和 Cygwin 这样的 GCC 移植版本，以便在 Windows 上获得类 Unix 的编译环境。对于构建过程的管理，我除了使用 Visual Studio IDE，也熟练使用 MSBuild 命令行动态进行自动化构建和持续集成流程。

114. Linux 下用什么工具去编译

在 Linux 下，编译的核心工具是 GCC（GNU Compiler Collection）和 Clang。它们是实际的编译器前端/后端，负责将源代码编译成目标文件。

GCC：是 Linux 生态系统的传统标准，支持语言广泛，非常成熟。
Clang：以其更快的编译速度、更友好的错误/警告信息以及作为 LLVM 项目的一部分而闻名，近年来应用非常广泛。
在实际开发中，我很少直接调用这些编译器，而是通过构建工具来管理复杂的编译过程：
- Make：是最基础和最通用的构建工具。它通过读取 Makefile 文件来定义源文件之间的依赖关系和构建规则，然后调用 GCC/Clang 等编译器进行增量编译和链接。
- CMake：是一个更高级的跨平台构建系统生成器。它读取开发者编写的CMakeLists.txt文件，然后为底层构建工具（如 Make、Ninja）生成相应的构建文件（如 Makefile）。这使得项目可以轻松地在不同平台和 IDE 之间迁移。
- Ninja：是一个专注于速度的小型构建系统，其构建文件通常由 CMake 或 GN 等高级工具生成，在大型项目（如 Chrome）中能显著提升构建速度。

115. makefile 有什么格式

Makefile的基本格式由一系列规则组成，每条规则定义了如何从一个或多个源文件（依赖）构建出目标文件。其标准结构如下：

target ... : prerequisites ...
    recipe
    ...
    ...

target（目标）：通常是需要生成的文件名（如main.o）或一个动作的名称（伪目标，如clean）。
prerequisites（前置条件/依赖）：是生成target所需要的文件或另一个目标。如果任何前置条件比目标新，make 就会重新构建目标。
recipe（配方/命令）：是make为了构建目标而需要执行的一条或多条Shell命令。这些命令必须以 Tab 字符开头，而不能是空格。
此外，Makefile还支持变量（如CC = gcc）、自动变量（如$@代表当前目标，$^代表所有依赖）、隐含规则和指令（如include），用于使 Makefile 更简洁、更易于维护。

116. Linux 下的 `select` 和 `epoll`，这两个有什么不一样

select和epoll都是 Linux 上用于 I/O 多路复用的系统调用，允许一个进程同时监视多个文件描述符（如 socket）的就绪状态，但它们在设计和性能上差异巨大。

select

机制：采用轮询和线性扫描的方式。每次调用时，内核需要将所有用户传入的文件描述符集合从用户态拷贝到内核态，然后内核线性扫描所有描述符以检查就绪状态。调用返回后，用户程序也需要线性扫描整个集合来找出就绪的描述符。
缺点：
- 文件描述符数量有上限（通常为 1024）
- 每次调用都需要重复的拷贝和扫描开销，性能随描述符数量增加而线性下降；
- 需要用户程序自己遍历所有描述符来查找就绪项。

epoll

机制：采用事件回调（基于红黑树和就绪链表）的方式。它通过epoll_create创建一个上下文，通过epoll_ctl单独地添加或移除要监视的描述符（只需拷贝一次）。epoll_wait调用则等待事件发生，返回时只提供已经就绪的描述符列表，无需扫描全部。
优点：
- 支持的文件描述符数量是系统级别的，非常大；
- 避免了每次调用时重复的文件描述符集合拷贝和内核扫描，性能不会随描述符数量增加而显著下降，非常适合连接数巨大的场景；
- 直接返回就绪的描述符，用户程序无需遍历。

总结：

select是 POSIX 标准，跨平台性好，适用于连接数少且对兼容性要求高的场景。
epoll是 Linux 特有的高性能机制，是现代高并发网络服务器（如 Nginx, Redis）的首选。

117. `malloc` 和 `mmap` 有什么区别，分别在什么场景下使用

malloc 和 mmap 都用于分配内存，但它们是不同层次的机制，适用于不同场景。

malloc

是 C 库提供的用户层内存分配函数
原理：它管理的是堆内存。malloc 通常会先通过系统调用（如 brk 或 sbrk）从操作系统申请一大块内存作为堆，然后使用自己的算法（如 ptmalloc）将这块大内存分割、管理，分配给应用程序。它处理的是相对小块的内存分配请求。
场景：适用于程序运行过程中频繁分配和释放中小块内存的通用场景，例如创建链表节点、临时字符串、小型数据结构等。它是程序员日常开发中最常用的分配方式。

mmap

是直接由操作系统提供的系统调用
原理：它可以在进程的虚拟地址空间中直接创建一个新的内存映射。这个映射可以是匿名映射（不关联文件，只用于分配大块内存，相当于向操作系统直接要内存），也可以是文件映射（将文件直接映射到内存，便于对文件进行随机访问）。
场景：
- 分配大块内存：当需要分配的内存非常大（例如几十 MB 甚至 GB 级别）时，使用 mmap 直接映射比通过 malloc 在堆上分配更高效，且避免碎片化问题。
- 文件 IO：用于实现内存映射文件，将文件直接映射到内存空间，这样对内存的读写操作就相当于对文件进行读写，非常高效。
- 进程间共享内存：通过映射同一个文件，可以实现多个进程间的共享内存通信。

118. 虚表是一个类有一个还是一个对象有一个？

类与虚表的关系

一个类有一个虚表！

编译器在编译期为每个含有虚函数的类生成一张虚表，里面存放该类所有虚函数（以及可能的 RTTI 信息）的函数指针。

如果子类重写（override）了某个虚函数，那么编译器在子类的虚表中把对应槽位替换为子类的函数指针。

对象与虚表的关系

每个对象有一个虚表指针（vptr）！

当对象被构造时，构造函数会把 vptr 设置为指向该对象所属类的虚表。

因此，同一个类的所有对象共享同一张虚表，只是它们各自的 vptr 都指向这张表。

内存示意图

struct Base {
    virtual void foo();
    virtual void bar();
};
struct Derived : Base {
    void foo() override;
};

编译器会生成两张虚表：Base::vtable 和 Derived::vtable。

在 Base::vtable 里，槽 0 → Base::foo，槽 1 → Base::bar。

🔥 在 Derived::vtable 里，槽 0 → Derived::foo（覆盖了），槽 1 → Base::bar。

每个 Base 或 Derived 对象的起始位置存放一个 vptr，分别指向对应的虚表。

119. 查虚表的时间复杂度是多少

在 C++ 中，虚函数调用通过虚表实现，其查找过程只需要：从对象中取出虚表指针 vptr，根据已知的偏移量在虚表中找到对应的函数指针，然后执行间接跳转。由于这些步骤都是固定次数的指针访问和寻址操作，与对象数量或虚函数多少无关，所以查虚表的时间复杂度是 O(1)，只比普通函数调用多一次间接寻址。

在多继承或虚拟继承中，一个对象可能有多个 vptr。这种情况下，调用某些虚函数时，编译器可能需要多一次指针调整（偏移修正）。但仍然是固定次数的操作，复杂度依然是 O(1)。

120. `std::move` 的原理（涉及移动吗）

在 C++ 中，std::move 的作用是将一个对象显式地转换为右值引用，从而让编译器有机会调用该对象的移动构造函数或移动赋值运算符，而不是拷贝版本。

std::move 并不会真的“移动”数据，它只是做了一个 static_cast<T&&> 的强制类型转换，把传入的左值转为右值引用。

一旦对象被当作右值使用，如果该类型定义了移动构造或移动赋值函数，就会发生资源所有权的“转移”，通常只需要指针交换，效率比深拷贝高。

使用 std::move 后，被转移的对象仍然处于有效但未指定状态（可以析构或赋新值，但不能假设它保留旧值）。

121. 智能指针原理

智能指针是 C++ 标准库中用来自动管理对象生命周期的类模板，本质上是一个“带有内存管理功能的指针包装器”。它的原理可以从以下几个方面理解。

核心思想

普通指针需要手动 delete，容易造成内存泄漏或悬垂指针。
智能指针通过 RAII 原则，在智能指针对象析构时自动释放资源。
它对指针的操作符 *、-> 进行了重载，看起来像普通指针，但有更安全的内存管理机制。

`std::unique_ptr`

独占所有权：同一时间只能有一个 unique_ptr 拥有某个对象。
原理：
- 内部保存一个裸指针。
- 禁止拷贝（拷贝构造和赋值被 delete），但支持 移动语义（转移所有权）。
- 析构时自动 delete 管理的对象。

简化实现

template <typename T>
class unique_ptr {
    T* ptr;
public:
    explicit unique_ptr(T* p = nullptr) : ptr(p) {}
    ~unique_ptr() { delete ptr; }

    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

    unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    unique_ptr& operator=(unique_ptr&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }

    T& operator*()  { return *ptr; }
    T* operator->() { return ptr; }
};

`std::shared_ptr`

共享所有权：多个智能指针可以共同管理一个对象。
原理：
- 除了指针，还维护一个 引用计数（control block）。
- 每次拷贝 shared_ptr 时，计数 +1；析构时，计数 -1；当计数归零，释放对象。

简化实现

template <typename T>
class shared_ptr {
    T* ptr;
    int* count;
public:
    explicit shared_ptr(T* p = nullptr) : ptr(p), count(new int(1)) {}
    ~shared_ptr() {
        if (--(*count) == 0) {
            delete ptr;
            delete count;
        }
    }

    shared_ptr(const shared_ptr& other) : ptr(other.ptr), count(other.count) {
        ++(*count);
    }

    shared_ptr& operator=(const shared_ptr& other) {
        if (this != &other) {
            if (--(*count) == 0) {
                delete ptr;
                delete count;
            }
            ptr = other.ptr;
            count = other.count;
            ++(*count);
        }
        return *this;
    }
};

`std::weak_ptr`

弱引用：不影响对象生命周期，避免 shared_ptr 的循环引用问题。
原理：
- 持有指向控制块的弱引用计数。
- 不能直接解引用，需要通过 lock() 临时获取 shared_ptr。
- 当对象已销毁时，lock() 返回空指针。

122. 假设有一个 1KB 的大对象，`move` 能节省拷贝吗

当我们在 C++ 中处理一个 1KB 甚至更大的对象时，是否使用 std::move 对性能会有明显影响。如果只进行拷贝，编译器会调用拷贝构造函数或拷贝赋值函数，把这 1KB 的数据逐字节复制到新的内存空间里，这个过程的复杂度是 O(n)，而且对象越大，时间和内存消耗就越高。但如果使用 std::move，它会把对象转化为右值引用，从而触发类型的移动构造函数或移动赋值运算符。在标准库容器和大多数现代类的实现中，移动操作通常只是把内部资源的指针或句柄“偷走”，并将源对象的指针清空，这样就避免了逐字节拷贝，复杂度降为 O(1)。换句话说，std::move 并不是直接完成“移动”的动作，而是告诉编译器“这个对象可以被当作右值处理”，从而让类的移动语义生效。结果是：对于像 std::string、std::vector 这样内部依赖堆内存的大对象，使用 std::move 能显著节省拷贝成本，把原本昂贵的内存复制过程简化为一次指针交换，从而大幅提高效率。

123. new 和 malloc 有什么区别呢

1. 类型安全与返回值

new：返回的是指定类型的指针，不需要强制类型转换，例如 int* p = new int;。
malloc：返回 void*，必须显式转换为目标类型，例如 int* p = (int*)malloc(sizeof(int));。

2. 构造/析构函数调用

new：除了分配内存，还会自动调用对象的 构造函数，初始化对象；delete 会调用 析构函数。
malloc：只分配原始内存块，不会调用构造函数；对应的 free 也不会调用析构函数。

3. 异常与错误处理

new：分配失败时会抛出 std::bad_alloc 异常（除非用 new(std::nothrow) 版本），所以更符合 C++ 的异常处理方式。
malloc：分配失败时返回 NULL，需要手动检查指针是否为空。

4. 内存大小计算

new：不需要显式写 sizeof，编译器根据类型自动计算内存大小。
malloc：必须手动传入字节数，例如 malloc(sizeof(MyClass) * 10)。

5. 重载与自定义

new/delete：可以被用户重载，支持自定义内存分配策略（如内存池）。
malloc/free：是 C 语言库函数，不能被重载，只能按标准方式分配。

6. 使用场景

推荐使用 new/delete：管理 C++ 对象，保证构造/析构函数的调用。
malloc/free 主要用于 C 接口：或者需要与 C 库交互的场景。

124. 用 `new` 生成的对象，可以用 `free` 释放吗

在 C++ 中，内存管理是成对出现的：

new 必须对应 delete
new[] 必须对应 delete[]
malloc 必须对应 free

原因

构造/析构函数
- new 不仅分配内存，还调用对象的构造函数。
- delete 在释放内存之前，会先调用析构函数，再释放内存。
- 如果用 free 去释放 new 出来的对象，析构函数不会被调用，会造成资源泄漏（比如没有关闭文件、释放锁、释放堆内存等）。
运行时实现不同
- C++ 编译器对 new/delete 可能有自己的内存分配策略（比如对象对齐、内存池）。
- malloc/free 走的是 C 语言标准库的堆分配接口。
- 混用可能导致堆结构损坏，甚至程序崩溃。

正确做法

用 new 分配 → 用 delete 释放。
用 new[] 分配数组 → 用 delete[] 释放。
用 malloc 分配 → 用 free 释放。

125. 如果 `new` 基础类型，比如整型，可以用 `free` 释放吗

即使是 int 这样的基础类型，用 new 分配的对象也必须用 delete 来释放，而不能用 free，因为在 C++ 中 new/delete 与 malloc/free 属于两个完全不同的内存管理体系，虽然 int 没有构造和析构函数，看似没有区别，但 new 在分配时可能会附加一些编译器特定的元信息，释放时需要 delete 正确处理，否则就会触发未定义行为；因此，哪怕是最简单的基础类型，也要严格遵循成对使用 new/delete、malloc/free 的规则，才能保证程序的正确性和可移植性。

126. 用 `new` 创建数组时，释放的时候需要写出元素个数吗

用 new 创建数组时，释放的时候并不需要写出元素个数，只要保证使用 delete[] 而不是 delete 即可。比如：

int* arr = new int[10];  
delete[] arr;  // 不需要写 10

这是因为编译器在用 new[] 分配数组时，通常会在分配的内存块里额外保存数组的大小信息（比如在头部存储元素数量），这样在执行 delete[] 时，它就能自动知道有多少个元素需要调用析构函数。反过来，如果你错误地用 delete arr; 来释放一个 new[] 出来的数组，就只会对第一个元素调用析构函数，其余元素不会被正确销毁，导致资源泄漏或未定义行为。

127. `std::map` 和 B+ tree 有什么区别呢

std::map 多用于内存里的有序关联容器，底层常用红黑树实现，而 B+ 树是数据库和文件系统常用的磁盘友好型索引结构，前者注重通用性和内存效率，后者注重降低磁盘 I/O 和范围查询性能。

数据结构和实现

std::map：在 C++ 标准库里通常实现为 红黑树（自平衡二叉查找树）。它的每个节点存储一个键值对 (key, value)，树高大约是 O(log n)，支持快速查找、插入和删除。
B+ 树：属于多路平衡查找树，常用于数据库和文件系统。B+ 树的节点可以存放多个键，非叶子节点只保存索引信息，所有数据都放在叶子节点，叶子节点之间用链表相连，便于范围查询和磁盘顺序访问。

时间复杂度

两者在理论上的查找、插入、删除复杂度都是 O(log n)。区别在于：

std::map 的红黑树一般是二叉树，高度相对较高（大约 log₂ n）。
B+ 树是多路的（阶数可达上百甚至上千），树高很低（大约 logₘ n，m 通常远大于 2），因此在磁盘 I/O 场景下效率更高。

内存和存储

std::map 是内存型数据结构，适合内存中存储少量到中等规模数据。
B+ 树设计初衷就是面向磁盘，节点大小通常和磁盘页对齐（比如 4KB），减少磁盘 I/O 次数，特别适合大规模数据的索引结构。

范围查询

std::map 可以通过迭代器顺序遍历，但元素分布在树节点里，缓存局部性较差。
B+ 树所有数据存储在叶子节点，并且叶子节点通过链表连接，天然支持高效的范围查询和顺序扫描，非常适合数据库中的 BETWEEN 查询。

使用场景

std::map：内存中需要有序字典映射的场景，如符号表、配置表等。
B+ 树：数据库索引、文件系统目录、键值存储引擎等大规模、基于磁盘的数据管理。

128. 红黑树与 B+ Tree 的性能、内存空间占用对比

从性能角度比较 std::map（红黑树） 和 B+ 树，主要差异在于它们设计时针对的场景不同：

性能

1. 内存场景

在内存中存放数据时：

std::map 往往更合适。它是二叉平衡树，节点存储较紧凑，指针操作简单；对查找、插入、删除的复杂度都是 O(log n)，常数因子较小。
B+ 树 在内存里因为是多路节点，访问时需要在节点内部做一次线性查找或二分查找，常数因子比红黑树大一些，在数据量不算特别大时反而不如红黑树快。

2. 磁盘/大数据场景

当数据量非常大、不能完全放入内存，需要频繁访问磁盘时：

B+ 树 更高效。它的节点大小和磁盘页对齐（比如 4KB 一页），一次磁盘 I/O 可以读入几十甚至几百个键，树高非常低（常见情况下只有 2~4 层），大大减少了磁盘访问次数。
std::map 设计时并没有考虑磁盘访问，二叉树节点很分散，局部性差，如果把它用在磁盘数据结构上，I/O 开销会非常大。

3. 范围查询

B+ 树 的叶子节点用链表串联起来，做范围查询或顺序遍历时几乎是顺序扫描，效率很高，适合数据库中的 WHERE x BETWEEN ...。
std::map 也能用迭代器遍历，但因为节点分散在内存，缓存命中率差，性能不如 B+ 树。

空间占用

1. `std::map`（红黑树）

每个节点只保存一个键值对 (key, value)，外加几个指针（父、左、右，可能还有颜色位）。
因为是二叉树，指针开销相对较大，尤其是当 key 和 value 本身比较小的时候，指针反而成了主要开销。
节点分散在堆上分配，内存局部性差，缓存命中率低。

举例：一个 std::map<int, int> 节点，数据只占 8 字节，但可能要额外存储 3–4 个指针（24–32 字节），加上对齐，内存开销可能是实际数据的几倍。

2. B+ 树

一个节点存储多个键和子指针，通常会填满一个固定大小的页（比如 4KB）。
因为是多路树，树高更低，指针数量远少于红黑树。
数据集中存放在叶子节点，且叶子节点通过链表连接，空间利用率更高，局部性也更好。
在数据库中，B+ 树的节点大小一般和磁盘页对齐，因此不仅节省内存，还能最大化磁盘 I/O 的效率。

3. 对比总结

内存占用上：红黑树（std::map）因为每个节点只存一个元素，加上大量指针，空间效率偏低；B+ 树每个节点存很多元素，指针摊薄，空间效率明显更好。
局部性上：B+ 树更紧凑、连续，缓存命中率高；红黑树分散，缓存命中率差。

129. 为什么数据库里选择 B+Tree 而不是红黑树？

数据库里选择 B+Tree 而不是红黑树，核心原因是二者的设计目标不同：

1. 磁盘访问成本

数据库面对的是远超内存容量的大规模数据，数据通常存放在磁盘里。

B+Tree：多路搜索树，一个节点可以容纳上百甚至上千个关键字，正好对应一个磁盘页（如 4KB）。一次磁盘 I/O 就能读入很多关键字，树的高度非常低（常常 2~4 层），意味着一次查询只需要少量磁盘访问。
红黑树：二叉树，每个节点只存一个关键字，树高约为 log₂n，高度远高于 B+Tree。查找时要访问更多的节点，对应更多的磁盘 I/O，性能会非常差。

2. 顺序访问和范围查询

数据库里非常常见的操作是范围查询，比如 WHERE age BETWEEN 20 AND 30。

B+Tree：所有数据都在叶子节点，叶子节点之间用链表相连，顺序遍历或范围扫描时只需要顺着链表走，效率极高。
红黑树：虽然中序遍历可以得到有序结果，但节点分散，指针跳转频繁，对磁盘和缓存都不友好，顺序扫描效率低。

3. 空间与局部性

B+Tree：节点内的数据是连续存放的，空间利用率高，局部性好，CPU 缓存和磁盘预读都能发挥作用。
红黑树：每个节点单独分配，指针开销大，内存局部性差，缓存和预读效果差。

4. 实际应用

B+Tree：被广泛用于数据库索引（MySQL、PostgreSQL、Oracle）和文件系统（NTFS、HFS+ 等），因为它能有效减少磁盘 I/O 并支持高效范围查询。
红黑树：常用于内存场景，比如 C++ STL 的 std::map、std::set，在内存里做有序字典或集合很合适。

130. 在 STL 里，内存池是怎么实现的，有怎样的结构？

在 SGI STL 中，内存分配器分了两层。第一层直接调用 malloc/free，主要处理大块内存（一般大于 128 字节），这种情况下它不再做额外优化。第二层才是所谓的 内存池机制，专门用来管理小对象（≤128 字节）。

这层内存池内部维护了 16 个自由链表（free lists），每个链表对应固定大小的内存块，大小从 8 字节到 128 字节，按 8 字节递增。比如需要分配 20 字节时，分配器会把它“上调”到 24 字节，然后从 24 字节对应的自由链表中取一个小块。如果链表里有可用内存，就直接返回；如果为空，就调用一个名为 refill 的函数。

refill 的作用是一次性从堆里申请一大块内存（比如 4KB），把它切成若干个小块挂到自由链表上，供后续使用。这样下一次再分配同样大小的小对象时，就可以直接从链表里取，而不必再调用 malloc。这种批量获取、切分、回收的方式大大减少了系统调用次数。

在结构设计上，每个小块内存的前几个字节都会存储一个指针，指向同类下一个空闲小块，从而形成单链表。释放对象时，并不会真的把内存交还给系统，而是把小块重新挂回对应的链表，等待下次复用。这样回收操作也只需要修改指针，几乎是 O(1) 的操作。

除了自由链表，SGI STL 的内存池还维护一个全局的“内存起始指针”和“内存结束指针”，用来追踪尚未切分的小块。当某个自由链表需要补充小块时，就从这段区域里分配，如果不够再向系统申请更大的内存块。

对比现代 C++ 标准库的 std::allocator，它通常只是对 ::operator new 的简单封装，不会自带复杂的池化机制。但由于 STL 容器都通过分配器抽象来管理内存，所以你完全可以自己实现类似 SGI STL 的 allocator，然后把它作为模板参数传给容器，从而让 STL 容器使用内存池。

其结构和工作原理如下：

核心结构：自由链表
- 内存池维护一个自由链表数组（例如16个），每个链表管理一种特定大小（8B, 16B, 24B...通常为8的倍数）的内存块。
- 每个空闲内存块的开头是一个指向下一个空闲块的指针（union _Obj { _Obj* _M_free_list_link; ... }），将这些块串成一个链表。
分配过程（allocate）：
- 计算所需内存大小，对齐后找到对应的自由链表。
- 如果链表不为空，直接从链表头取出一块内存返回给用户。这只需要修改几个指针，速度极快。
- 如果链表为空，则调用 _S_refill 函数向内存池“申请批发”。
  - 内存池会一次性分配一大块内存（例如20个对象的大小）。
  - 将这大块内存切割成一个个小块，并用指针串起来，形成新的自由链表。
  - 然后从这条新链表中取出一块返回给用户。
释放过程（deallocate）：
- 收到用户释放的指针，根据其大小找到对应的自由链表。
- 直接将这块内存插回对应链表的头部（修改指针即可）。它不会立即归还给操作系统，而是留在链表中以备下次分配。

131. 执行 `vector<int> v(4, 100)` 会发生什么，在栈上还是堆上分配？

当你写下 vector<int> v(4, 100); 时，首先会调用 std::vector 的构造函数，它接收两个参数 (size_type n, const T& value)，表示创建一个长度为 n 的向量并将所有元素初始化为 value。在这个例子里，n = 4，value = 100，所以最终生成的是一个长度为 4 的向量，内容为 [100, 100, 100, 100]。

需要注意的是，v 本身是一个局部变量，它作为一个对象存放在栈上，其中保存着三个核心信息：指向存储区的指针、当前元素个数 size 和当前容量 capacity。而那 4 个 int 元素并不是直接放在栈里的，而是由 vector 内部通过动态内存分配（通常使用 new）在堆上申请一块连续的内存空间来存放的。这样做的好处是容器可以根据需要扩容，而不受栈空间大小的限制。

因此，整体过程可以总结为：vector<int> v(4, 100); 会生成一个长度为 4、所有元素值都为 100 的向量，其中容器对象本身在栈上，而实际存储元素的空间在堆上。

132. 那如果是 `new vector<int>(4,100)` 呢

当你写成 new vector<int>(4, 100) 时，和直接 vector<int> v(4, 100) 的区别主要在于 容器对象本身的位置。

在 vector<int> v(4, 100); 这种形式里，v 是一个局部变量，它作为对象存放在栈上，里面包含了三个核心成员：指向堆上元素存储区的指针、size、capacity。而那 4 个 int 元素依然是通过 new 在堆上分配的一块连续内存保存的。

而在 new vector<int>(4, 100) 这种形式里，情况就变成了两层堆分配：

new vector<int> 本身会在堆上生成一个 vector 对象，这个对象里包含指针、size 和 capacity。
在构造函数执行过程中，vector 内部还会在堆上再分配一块内存，存放那 4 个 int 元素，并全部初始化为 100。

因此，可以总结为：

vector<int> v(4, 100); → 对象在栈上，元素在堆上。
new vector<int>(4, 100) → 对象本身在堆上，元素依然在堆上。

使用 new 的版本返回的是一个指针（类型为 vector<int>*），所以一般需要用 delete 手动释放，否则会造成内存泄漏；而直接定义在栈上的 vector，在作用域结束时会自动调用析构函数，释放堆上的元素存储区，更加安全。

133. 如何拿到类中私有成员变量的值？

在语法层面，私有成员就是不能直接访问的，这是 C++ 的语言设计。你如果真要拿到值，只能靠友元（正规的方式）或者通过 指针偏移、调试器、反射库 之类的手段绕过，但这些都破坏了封装性，容易出问题。

正规途径

提供访问接口：最推荐的做法是类内部提供 getter 方法，或者通过友元（friend）函数/类来获取。这样遵循语法规则，保证代码可维护性。
友元机制：可以显式指定某个函数或类为友元，从而访问私有成员。

非正规途径（绕过语法限制）

这些方法属于“黑科技”，更多是为了学习/调试用，工程里一般不建议：

通过指针偏移（内存布局）

类对象的内存里，私有成员和公有成员是按编译器布局存放的，访问权限只存在于编译阶段。拿到对象地址后，可以通过 reinterpret_cast 或指针算偏移，直接读到对应位置的数据。

class Test {
private:
    int a = 42;
};

int main() {
    Test t;
    int* p = (int*)&t;   // 直接把对象地址转成 int* 
    std::cout << *p << std::endl;  // 打印出私有成员 a
}

这种做法利用了内存布局，但属于未定义行为，不可移植。

宏/模板技巧

有些人会用模板 + 偏特化或者宏展开来“欺骗”编译器访问私有成员，不过实现复杂，常用于 C++ 奇技淫巧展示。

gdb

在调试环境下，可以通过 gdb/lldb 等调试器直接读取对象内存，或者用 Boost.PFR（Precise Function Reflection）等库在编译期推断对象的字段布局。

134. 有一个二维数组里面都有值，想要给每个数都加 100，行遍历和列遍历有什么区别？

在一个二维数组里，如果你要给每个元素都加 100，从结果上看，无论是按行遍历还是按列遍历，数组中的所有数都会变大 100，结果完全相同。但这两种遍历方式在底层运行效率上差别很大。

二维数组在 C/C++ 中是 行优先存储（row-major order）的，也就是说，一整行的数据在内存中是连续存放的，不同行之间是隔开的。行遍历时，访问顺序与内存布局一致，CPU 每次加载的缓存行和虚拟内存页都会被充分利用，缓存命中率高，虚拟内存的局部性原理得以发挥，性能较好。而列遍历则不同，相邻元素在内存中相隔一个整行的大小，访问时会“跳着走”。这导致 CPU 每次加载的缓存行里只有极少数数据被使用，缓存利用率低，大数组时还会频繁触发新的虚拟页调入和缓存替换，带来额外的开销。

所以，从虚拟内存和缓存的角度看，行遍历符合空间局部性，效率高；列遍历破坏局部性，效率低。在数据量小的时候差别可能不明显，但在大规模数组或矩阵计算里，性能差距会非常显著，这也是科学计算和数据库引擎里都特别强调数据访问模式与存储布局匹配的原因。

135. 关于静态多态和动态多态原理 (Leelham)

静态多态

静态多态都是通过 name mangling 实现的。name mangling 是一种编译器技术，用于为程序中的变量和函数生成唯一的内部名称。mangling 规则具体看编译器。

具体包括：

函数重载：指在同一个作用域内，名称相同的函数参数类型或参数个数不同，从而可以根据调用时提供的实参来确定实际调用的函数

函数重载实现参数多样性。函数返回值多样性可以用 variant（可以再传一个模板参数，内部基于模板参数对 variant 进行转化）
隐藏：指在子类中定义父类同名同参数函数
模板：指编译时根据传递的模板参数不同，生成不同的代码
CRTP（奇异模板递归）：通过继承自己（在子类中使用父类模板），允许在编译时进行多态操作，避免动态分发查虚表的开销。std::enable_shared_from_this 即通过 CRTP 实现。

玄学：就像在心理学中，自我认知（Self-awareness）是理解个体行为的关键一样，CRTP 通过使基类能够“意识”到其派生类的类型，从而在编译时实现多态性
- interface 内部可以配合 if constexpr 和 std::is_same_v 对某些类型做特殊处理
```
// CRTP 基类
template<typename Derived>
class Base {
public:
    void interface() {
        // 静态多态：在编译时调用Derived的implementation
        static_cast<Derived*>(this)->implementation();
    }
    // 一些公共的接口和实现...
};
// CRTP 派生类
class Derived : public Base<Derived> {
public:
    void implementation() {
        // 特定于Derived的实现...
    }
};
int main() {
    Derived d;
    d.interface(); // 调用Derived的implementation
}
```

动态多态

动态多态原理：虚函数实现，底层通过虚函数表实现。
- 对于含有虚函数的类，编译器会在编译阶段创建一个虚函数表 vftable（按照虚函数的声明顺序保存虚函数的地址），并在创建类对象时插入一个虚函数表指针 vfptr，该指向 vftable 的首地址（也就是第一个虚函数的地址）。
- 虚函数表是静态的，供该类的所有对象共享，在编译期确定，存放在全局（静态）变量区的 .rodata 段。
- 虚函数表指针是动态的，该类的每个对象都有一个，在运行期确定，存放位置和对象的存放位置相同（堆区/栈区）。
- 继承时，子类会深拷贝一份父类的虚函数表，如果子类重写了虚函数，那么子类的虚函数表中对应的虚函数地址会被覆盖为重写的虚函数地址。
为什么多态函数传参是传指针或者引用，按值传大概率不行？
- 按值传递会导致切片问题，对象的派生特征都会被截切掉，导致派生类的信息丢失，从而无法实现多态；
- 按值传递需要拷贝副本，性能开销大；
构造函数和析构函数可以定义为虚函数吗？
- 构造不可以：在继承中，先构造基类再构造子类。如果构造函数是虚函数，则需要通过虚函数表调用，但是此时对象还没有实例化，没有虚函数表指针 vfptr，无法访问虚函数表
- 析构可以：父类不是虚析构，使用父类指针指向子类，就只会调用父类的析构函数，导致子类动态分配的资源无法释放（如果子类数据成员都是基本类型，不使用虚析构函数不会内存泄漏）
哪些函数不能是虚函数？
- 构造函数、静态成员函数（编译期确定，不能动态绑定）、友元函数（不能继承）、内联函数（编译器展开，不能动态绑定）
菱形继承
- virtual 关键字虚继承，保证派生类只保留一份间接基类的成员。
- 继承多个类，会导致具有多个 vptr

136. 构造函数和析构函数可以定义为虚函数吗？

构造不可以：在继承中，先构造基类再构造子类。如果构造函数是虚函数，则需要通过虚函数表调用，但是此时对象还没有实例化，没有虚函数表指针 vfptr，无法访问虚函数表
析构可以：父类不是虚析构，使用父类指针指向子类，就只会调用父类的析构函数，导致子类动态分配的资源无法释放（如果子类数据成员都是基本类型，不使用虚析构函数不会内存泄漏）

137. 哪些函数不能是虚函数？

构造函数、静态成员函数（编译期确定，不能动态绑定）、友元函数（不能继承）、内联函数（编译器展开，不能动态绑定）

138. 关于构造函数

拷贝构造/赋值函数

默认构造函数、有参构造函数、拷贝构造函数（传参必须是引用方式，否则会无穷递归，因为按值传递时候会继续调用拷贝构造函数）
移动构造/赋值函数
- 移动构造函数（必须要加 noexcept，否则如 vector 之类的在扩容时不会调用移动构造，只会调用拷贝构造）。
- 用于将资源所有权从一个对象转移到另一个对象
深拷贝与浅拷贝
- 浅拷贝：仅复制对象的基本数据类型和指针成员的值，但是不会赋值指针指向的资源，可能导致两个对象共享相同资源；
- 深拷贝：不仅拷贝对象的基本数据类型和指针成员的值，还会拷贝指针所指向的资源。
右值引用与完美转发
- 值分为左值（可以取地址，有名字）和右值（不可以取地址，无名字）。std::move 用于将左值引用强制转变为右值引用（而非所有权转移）。
- 右值赋值给右值引用变量就有了名字，变为左值，可以被左值引用捕获。std::forward 用于保证函数参数的左值或右值特性被保留，允许函数将参数以几乎完全相同的形式转发给其他函数。

139. 关于关键字

const
- 修饰变量：只读变量，不能修改
- 修饰函数：修饰函数的返回值，表示函数的返回值只读，不能被修改；
- 修饰指针：常量指针（int* const）、指向常量的指针（const int*）
- 修饰成员函数：不能修改任何成员变量，因此也只能调用常成员函数
violate：指示变量可能被外部因素更改，防止编译器优化。常见场景：
- 多任务环境下各任务间共享的标志应该加 volatile；
- 存储器映射的硬件寄存器通常也要加 volatile 说明，因为每次对它的读写都可能有不同意义
define 和 inline
- define宏定义只在预处理阶段起作用，仅仅是简单的文本替换，没有类型检查；
- inline 在编译阶段进行替换，有类型检查
内联的好处
- 减少函数调用开销，函数调用涉及压栈、传参、弹栈，内联展开避免了这些开销，直接在调用点插入函数体；
- 减少跳转和缓存不命中
static
1. 修饰全局变量
  1. 将变量作用域限制在当前文件中，其他文件无法访问；
  2. static 变量可以定义在头文件中，并不破坏单一定义原则
2. 修饰局部变量：静态局部变量在函数调用结束后并不会被销毁，而是保留其值，并在下一次调用该函数时继续使用；
3. 修饰成员变量：成为静态成员变量，属于整个类，在所有实例之间共享；
4. 修饰成员函数：静态成员函数，可以直接通过类名来访问，而无需创建对象，没有 this 指针。
extern
- 声明外部变量或函数，使得不同的源文件共享相同的变量或者函数
- extern “C”：可以让 C++ 来调用 C 语言当中的变量或函数（因为 C++ 函数会进行 name mangling，C 的不会，所以不能直接调用）。不使用该关键字，直接调用 C 语言中的变量或函数会发生链接错误。
类型转化（static_cast 用于编译期安全的类型转换（如基本类型转换、父类子类指针转换）；dynamic_cast 用于多态类型的向下转换，在运行时检查类型安全性，失败返回空指针；const_cast 用于移除或添加 const/volatile 属性；reinterpret_cast 用于低层次的强制类型转换（如指针转整数），不进行类型检查，需谨慎使用）
1. static_cast：基本数据类型间转换，如 int 转为 double，也可以用于基类和派生类间的上行转换（派生类指针—>基类指针）。
2. dynamic_cast：主要用于基类和派生类间的安全类型转换，运行时执行安全检查，要求基类必须有虚函数。流程：
  - 首先，dynamic_cast 通过查询对象的 vptr 来获取其 RTTI；
  - 然后，dynamic_cast 比较请求的目标类型与从 RTTI 获得的实际类型。如果目标类型是实际类型或其基类，则转换成功；
  - 如果目标类型是派生类，dynamic_cast 会检查类层次结构，以确定转换是否合法；
  - 如果在类层次结构中找到了目标类型，则转换成功；否则，转换失败。
3. const_cast：去 const 属性，常量指针转换为非常量指针，并且仍然指向原来的对象。不可以用在 const 成员方法里复用非 const 成员方法
4. reinterpreter_cast：仅仅重新解释类型，但没有进行二进制的转换
struct 和 class 区别：
- struct：结构体中的成员和继承默认都是 public 属性的。
- class：结构体中的成员和继承默认都是 private 属性的，且可以用于定义模板参数
noexcept：表示函数内部不会抛出异常，有助于简化调用该函数的代码，而且编译器确认函数不会抛出异常，它就能执行某些特殊的优化操作。
new/delete 和 malloc/free 区别
- new/delete 是 C++ 风格，分配/回收空间同时会调用构造/析构，而 malloc/free 仅管理原始内存，不会自动初始化对象
- malloc 需要传入分配的大小返回一个 void 指针。大多数中 malloc 分配的内存前加一个头部，用于存储分配大小以进行 free；new 传入类型信息会自动计算构造对象的大小，delete 不需要额外存储长度，但 delete[] 可能会在内存前存储数组大小。
- 内存不足时，malloc 返回空指针；默认版本 new 会抛出异常 std::bad_alloc，或者使用 new(std::nothrow) 不抛出异常
- new 可以 placement new 就地构造（emplace 相关方法实现原理）
mutable
- 修饰类的成员变量，表示可以在 const 成员函数中修改
- 修饰 lambda 函数，表示可以修改值捕获的成员
auto 与 decltype（C++ 11）：编译器在编译期自动推导表达式类型
thread_local：指示对象拥有线程存储期，指示对象的存储在线程开始时分配，在线程结束时析构
- 可以与 static 和 extern 用于指定内部或外部链接（除了静态数据成员始终拥有外部链接），但附加的 static 不影响存储期
- 只用于于命名空间作用域的对象、块作用域的对象、静态数据成员

补充 push_back 和 emplace_back

// vector emplace_back 和 push_back 实现原理
template<typename T>
class Vector {
private:
    T* data_;
    size_t size_;
    size_t capacity_;

public:
    template<typename... Args>
    void emplace_back(Args&&... args) {
        if (size_ >= capacity_) {
            reserve(capacity_ == 0 ? 1 : capacity_ * 2);
        }
        
        // 使用 placement new 在末尾直接构造对象
        new (data_ + size_) T(std::forward<Args>(args)...);
        ++size_;
    }
    
    void push_back(const T& value) {
        if (size_ >= capacity_) {
            reserve(capacity_ == 0 ? 1 : capacity_ * 2);
        }
        
        // 需要拷贝构造（可能产生不必要的拷贝）
        data_[size_] = value;  // 或者 new (data_ + size_) T(value);
        ++size_;
    }
};

140. 关于内存管理

内存空间（从低到高）
1. 代码段：存放程序的二进制机器码
2. 数据段 data：存放初始化的全局变量、静态变量和常量
3. bss 区：存放未初始化的全局变量和静态变量
4. mmap 区：存放动态库（共享库）、匿名映射（malloc 大块内存）和文件映射（mmap 文件）；动态内存管理
5. 堆区：由低向高增长。用于动态分配内存（malloc/free，new/delete），如果没有及时释放内存会造成内存泄漏。因为存在内存管理、地址映射等复杂操作，故效率较低。此外还会产生内存碎片影响效率。但空间大
6. 栈区：由高向低增长。存放局部变量、函数参数值、形参等。由编译器分配和释放，栈区只需要改变栈指针的位置，因此效率高。但栈区空间小
各种变量存放位置
- 直接声明的变量、函数实参存储在栈区；
- new 创建的对象，较小的对象存放在堆区，较大的对象存放在共享内存区；
- 常量和静态变量存放在静态存储区中的非代码区；
- 所有函数存放在静态存储区中的代码区；
- 字符常量也存放在代码区。
allocator 与 placement_new：原来，new = 内存分配 + 调用构造函数，借助这两个工具实现内存分配与对象构造分离。
- allocator 可以实现自定义内存分配回收的逻辑，分配回收不会调用构造/析构
  
  http://www.cnblogs.com/wpcockroach/archive/2012/05/10/2493564.html
  - stl 容器支持传入自定义的 allocator。
- placement_new 用于在指定的内存地址上构造对象，需要保证可用空间 ≥ 对象实际大小
  - 可用于实现标准库的 emplace 方法，原地构造对象
内存泄漏：申请了一块内存空间，使用完毕后没有释放掉。
- 设计上：基于 RAII，借助智能指针避免资源泄露。
- 检测方法：
  - 使用 GDB，执行某个函数前后，call malloc_stats()，对比 in use bytes 大小是否变化
  - 使用 valgrind，valgrind --leak-check=yes program arg1 arg2
  - 修改代码，在 new/delete 处加一个计数器检测
如何区分 32 位机器和 64 位机器？用 sizeof(void*)
- 在 32 位系统 中，指针是 4 字节，可以寻址 4GB 内存。
- 在 64 位系统 中，指针是 8 字节，可以寻址 16GB 内存。

141. 关于内存对齐

对齐系数
1. 绝对对齐系数：每种类型数据在内存中的首地址必须是绝对对齐系数内存系数的整数倍。在默认情况下，绝对对齐系数等于该类型数据的默认对齐系数。
2. 相对对齐系数：结构体内的数据相对于结构体起始地址的偏移量，单位为字节，结构体成员在结构体中的偏移量必须是该成员相对对齐系数的整数倍。在默认情况下，相对对齐系数等于该类型数据的默认对齐系数。
默认对齐系数：绝对对齐系数和相对对齐系数等于默认对齐系数（数据的固有属性）。
1. 对于基本数据类型，默认对齐系数等于该数据类型占用字节大小。在内存中的地址必须是其自身大小（以字节为单位）的整数倍；
2. 对于结构体类型：(1) 结构体的起始地址必须是结构体成员中占用空间最大的基本数据类型的整数倍，且结构体大小也必须是其整数倍；(2) 结构体内的成员，在结构体中的偏移量必须是该成员相对对齐系数的整数倍。
  
  由于默认对齐的原因，struct {char a; int b; } 的 size 是 8 字节
显式内存对齐
1. #pragma pack(N)（编译器支持）：N 需要为 2 的正数
  - 当N大于该结构体的默认对齐系数时候，结构体绝对对齐系数被设置为N，当N小于该结构体的默认对齐系数时候，结构体绝对对齐系数维持为默认对齐系数。
  - 当N小于该结构体的默认对齐系数时候，结构体内所有成员的相对对齐系数被设置为N，当N大于该结构体的默认对齐系数时候，结构体内成员的相对对齐系数维持为默认对齐系数。
2. alignas(N)：仅指定结构体的绝对对齐系数（规则同上），不能指定相对对齐系数
3. alignof(T)：用于获取指定类型的对齐系数
4. std::aligned_storage：创建固定大小和满足对齐要求的未初始化内存
用途
1. 提高性能：字是 CPU 在一次内存读写操作中能处理的最大数据块。变量占据内存大小等于字长，如果其首地址在字长的整数倍处，CPU只需要读内存一次；如果其首地址不在字长整数倍处，CPU则需要读地址两次，影响程序性能。
2. 避免伪共享问题：多个 CPU 同时对同一个缓存行的数据进行修改，导致 CPU cache 的数据不一致，缓存失效，需要频繁从内存中重新读取数据
  
  为什么伪共享只发生在多线程的场景，而多进程的场景不会有问题？这是因为 linux 虚拟内存的特性，各个进程的虚拟地址空间是相互隔离的，也就是说在数据不进行缓存行对齐的情况下，CPU 执行进程 1 时加载的一个缓存行的数据，只会属于进程 1，而不会存在一部分是进程 1、另外一部分是进程 2。
3. SIMD 指令需要内存对齐
  
  x86 平台下的 SSE （Streaming SIMD Extensions）指令为例来说明内存对齐在 SIMD 中的应用。该架构使用128位的向量寄存器，数据总线长度位128位，每次能读取16字节。
```
alignas(16) float A[4];
alignas(16) float B[4];
alignas(16) float C[4];

for (int i = 0; i < 4; i++) {
    C[i] = A[i] + B[i];
}
```
  由于浮点数默认是按照 4 字节对齐的，数组的首地址是4的倍数，因此如果数组没有进行显式对齐，那么每次计算4个浮点数可能就需要进行两次内存读写。然而，由于数组已经按照16字节对齐，每次计算4个浮点数就只需要进行一次内存读写。
4. direct I/O 需要内存对齐

142. 关于异常

异常处理：当异常发生时，会进行栈展开 stack unwinding：
- 将暂停当前函数的执行，开始查找匹配的 catch 子句：首先检查 throw 本身是否在 try 块内部，如果是，检查与该 try 相关的 catch 子句，看是否有匹配的 catch。如果不能处理，就退出当前函数，并且释放当前函数的局部对象，继续到上层的调用函数中查找，直到找到一个可以处理该异常的 catch 。当处理该异常的 catch 结束之后，紧接着该 catch 之后的点继续执行。
- 未捕获的异常将终止程序：如果找不到匹配的 catch，程序就会调用库函数 std::terminate
异常安全：stack unwinding 只对栈上的变量进行析构，堆上的动态分配的 new 不会自动析构，所以可能内存泄漏
不希望抛出异常的函数
1. 析构函数（会导致异常不安全）
  1. 析构函数往往不仅仅释放一个资源。当前一个资源释放时抛出异常，此时跳过异常点后面的代码，使得后一块资源没有释放，造成内存泄漏。
  2. vector 析构所有元素时，那么当有一个元素抛出异常，此时 catch 之后的处理显然是继续销毁剩下的元素，但是假设运气很不好，又有一个元素抛出异常，c++此时无能为力，要么结束执行，要么发生不预期的行为
2. 移动赋值函数
  - 在 STL 标准库中很多容器在 resize 时都会通过std::move_if_noexcept模板来判断元素是否提供了 noexcept 的移动赋值，如果提供那么 move，否则调用拷贝赋值函数。所以不抛出异常的移动赋值函数效率会更高。
3. swap 函数
  - 根据 copy and swap 惯用法，swap 是移动赋值基时。swap 不抛异常，移动赋值才不抛异常。
析构函数发生错误（c++11 之后，默认会把析构函数看成noexcept(true)，这意味着如果析构函数抛出异常，直接std::terminal）：
1. try catch 吞下异常，除记录日志外，不做任何事
2. 直接终止程序
3. 释放会失败的资源，释放放在非析构函数中，由程序手动操作
copy - and -swap
- 好处：强异常安全、自复制安全、代码复用
  - 强异常安全：如果 new 失败，即在值传递时，创建新的副本就会发生异常，此时 this*被没有被 delete。不会出现 this * 被 delelte，而 new 失败导致对象不完整的情况
  - 自复制安全：因为值传递是开辟新的副本，所以赋值没有问题，至于自拷贝的效率问题，一般不怎么出现自拷贝，所以在其他优点下，这点效率小瑕疵就忽略不计
  - 代码复用：拷贝赋值运算、移动赋值运算符、swap 函数共用一份代码。对于赋值函数只需写值传递的operator=(T)，无需同时写operator=(const T&)和operator=(T&&)。
- swap 实现：分为 member和non-memeber。
  - member：由于 non-member 不能访问类成员，所以我们先实现 member，然后 non-member 调用
```
friend void swap(dumb_array& first, dumb_array& second) noexcept {
   using std::swap;

   swap(first.mSize, second.mSize);
   swap(first.mArray, second.mArray);
   // std::swap这里是非常高效的，只是换指针
}
```
  - non-member：非模板类可以直接全特化 std::swap；模板类由于 std::swap 不支持偏特化，需实现第三方 swap。在外界调用 swap 时，拒绝直接写std::swap，而应该写using std::swap; swap(item1,item2);，得益于 ADL（argument dependent lookup）机制，总是能匹配正确的 swap。通过 using，把 std::swap，还有参数的类型 widget 所在命名空间下的 swap 都纳入函数候选集，在这个候选集中找到最优匹配的函数：class template 类匹配到 WidgetStuff 命名空间的 swap，而其他会匹配到 std::swap。
```
 int main(){
     Widget widget1,widget2;
     using std::swap;
     swap(widget1,widget2);
 }
```
- 实现：实现参数构造和拷贝构造，用 swap 实现移动构造，用 operator=(T) 同时实现 operator=(const T&)和operator=(T&&)。如果是左值那么会调用拷贝构造函数去初始化函数参数；如果是右值那么会调用移动构造函数去初始化函数参数。

143. 关于编译/链接

误区 1：区分动态/静态链接 and 动态/静态库。前者是一个过程，包括合并符号、复制代码段、利用重定位表回填外部符号等；后者是可链接的文件，由于静态/动态链接需要，有不同的数据结构。

误区 2：静态库含义是说链接时，其代码会拷贝到最终可执行文件中，而不是说其存储自身依赖库的代码。其只是在符号表中记录依赖关系，链接静态库时仍然需要链接静态库本身依赖的库。

符号重定义（Symbol Redefinition）：指的是在同一个作用域内多次定义同名标识符（包括变量、函数、类等）
- 预处理阶段错误：同名宏
- 编译错误
  - 名称冲突：同一作用域或不同作用域内出现了相同的符号名定义
  - 头文件多重包含：当一个源文件包含多个头文件时，某个头文件可能会包含一个已经包含过的头文件，导致同一个函数或变量的定义被重复包含
- 链接错误：多个编译单元中出现了相同的符号定义而导致的。这种错误会在链接时被检测到，表示无法解析符号引用，因为有多个定义存在。目标文件头 ELF Header 内存放有符号信息，把多个目标文件链接到一起的时候，若发现文件头内有同名符号，就会报链接期符号重定义错误。符号表结构如下：
- 运行期错误：在动态链接库或共享对象中，函数或变量可以在运行时加载和卸载。如果在两个动态链接库中定义了相同名称的函数或变量，它们可能会导致符号重定义错误。
解决符号重定义方法
- 命名空间：解决同名宏、名称冲突
- #pragma once 或者使用 #ifdef 包裹 #include：解决头文件多重包含
- 解决链接冲突
  - static 关键字：将变量或函数限制在当前文件的作用域内，即使两个目标文件有同名变量，也不会报符号重定义错误。
    
    在目标文件 ELF 符号表中，被 static 修饰的变量会被标记为本地符号 (Local Symbols)，链接器检测到两个或者多个目标文件 ELF 符号表内有同名符号，若这个符号是本地符号，则认为它们是不同变量。
  - inline关键字：将函数或者变量声明为内联类型时，即使两个目标文件有同名变量，也不会报符号重定义错误。
    
    在 ELF 符号表中，被inline修饰的函数会被标记为弱符号(Weak Symbol)，链接器检测到两个或者多个目标文件 ELF 符号表内有同名符号，那么选择其中占用空间最大的那一个，比如变量 a 在目标文件 A 中是 int，在目标文件 B 中是 double，那么选择 double 型的符号进行链接。
  - extern 关键字：在一个编译单元中使用 extern关键字来声明一个变量或函数，并在另一个编译单元中定义该变量或函数，在链接时不会发生符号重定义的问题。
    
    在 ELF 符号表中，被 extern 声明的符号会被标记为未定义，链接器检测到两个或者多个目标文件 ELF 符号表内有同名符号，若这些符号只有一个已定义，其余都是未定义，则认为这些符号共用这一个已定义的值。
  - const 关键字：将变量或函数限制在当前文件的作用域内，即使两个目标文件有同名变量，也不会报符号重定义错误。
    
    在目标文件 ELF 符号表中，默认情况下，被const修饰的变量会被标记为本地符号 (Local Symbols)，链接器检测到两个或者多个目标文件 ELF 符号表内有同名符号，若这个符号是本地符号，则认为它们是不同变量。
编译流程
- 预处理（gcc -E）：主要处理 #include 指令，宏替换，条件编译等，生成 .i 文件
- 编译（gcc -S）：对源代码进行语法分析、词法分析，生成汇编代码，产生 .s 文件，
- 汇编（gcc -c）：将汇编代码翻译成机器码，生成 .o 目标文件
- 链接（gcc）：将目标文件和库文件链接在一起，生成最终的可执行文件
ELF 文件：分为可执行文件和可链接文件。可链接文件有：目标文件、动态链接库、静态链接库
- ELF Header（ELF 文件头）：文件的开头部分，记录了文件的基本信息，通过其中的字段信息可以找到 Section Header Table 的位置；
- Section Header Table（节区头表）：描述 ELF 文件中所有 section 的位置信息；
- 用于链接的 Section
  - Symbol Table（符号表）存放有当前文件内所有符号——文件内定义的符号，以及在当前文件内被使用但未定义的符号。符号表记录了每个符号的符号名以及符号值，即与这个符号对应的函数或者变量地址。
  - Relocation Table（重定位表）只存放了当前文件内被使用但未定义的符号。重定位表记录了这些符号的符号名以及地址。和符号表中的地址不同，这里的地址，指的是需要被重定位的指令（或数据）在代码段（或数据段）中的偏移位置。例如，需要对跳转指令callq xxxx进行重定位，这里的地址指的是xxxx所在位置的地址，而不是xxxx指向的地址。
- 动态库的 Section
  - GOT 表（Global Offset Table）全局地址偏移量表：在动态链接库被加载时被填充。GOT 表用于保存所有用到的函数或者变量地址。
  - PLT 表（Procedure Linkage Table）代码段表：每个外部符号在 PLT 表中都有一个对应的代码段，这些的执行逻辑都是一样的，负责延迟绑定。
动态链接与静态链接
- 静态链接：静态库中的代码和数据是链接时复制到可执行文件中的，而不是运行时加载到进程中的。
  - 读取每个可链接文件中的符号表，将所有符号表合并到一张总的符号表中，并且对符号表进行排序和去重；
  - 将可链接文件合并；
  - 遍历每个可链接文件中的重定位表，然后对于每个重定位项：根据符号名从总的符号表中查找到与符号名对应的函数或者变量的实际地址，将重定位项的地址信息替换成实际地址。
- 动态链接：动态库的代码和数据运行时加载到进程中。可执行文件只包含了程序本身的代码和一些对共享库函数的调用，但是并未复制共享库代码到可执行文件中。
  - 读取每个可链接文件中的符号表，将所有符号表合并到一张总的符号表中，并且对符号表进行排序和去重；
  - 把各个可链接文件，映射到同一个虚拟地址空间中；
  - 遍历每个可链接文件中的重定位表，然后对于每个重定位项：将重定位项的地址信息替换成 PLT 表某一项的地址；
  - 当程序第一次调用某个外部函数时，跳转到 PLT 表，执行 PLT 表项内的代码，PLT 代码段会先根据总的符号表信息，查找到外部函数地址，填写到 GOT 表中，并跳转到外部函数所在地址，执行函数；
  - 当程序再次调用该外部函数时，仍然是先跳转到 PLT 表，执行 PLT 表项内的代码，不同的是它会从 GOT 表中获取外部函数地址，然后跳转到外部函数所在地址，执行函数。
- 区别：本质、执行效率、空间占用、可维护性
gcc 链接库时注意顺序问题

为什么 gcc/g++编译链接静态库，会有顺序问题呢？
- 链接器在考察库文件 (.a) 的时候，不是把库文件看做一个整体，而是将打包在其中的目标文件(.o)作为考察单元。连接时，每个库只扫描一遍，每个库中没用任何符号被使用的 .o 文件会被丢弃。
链接器在工作过程中，维护 3 个集合：需要参与连接的目标文件集合 E、一个未解析符号集合 U、一个在 E 中所有目标文件定义过的所有符号集合 D。目标文件按照顺序解析, 如果目标文件没有包含任何一个集合 U 中的符号就会被丢弃。扫描结束时如果 U 非空就会编译错误。

因此需要基于依赖的拓扑序排列 -l（前面库依赖后面库）。如果存在循环依赖，gcc 提供 Xlinker 选项。
强制使用静态库编译（可能导致出错，因为有些库只有动态库从而出现 undefined symbol 错误）
- 默认是优先链接动态库，动态库不存在链接静态库
- -static：指定全用静态链接，但可能有些库只有动态链接，会出现问题。
- -Wl,-Bstatic … -Bdynamic：局部开关。-Wl 用于传递链接器参数，-Bstatic 指定接下来优先使用 static 链接，直到遇到 -Bdynamic

144. 关于并发编程

join() 和 detach()

join() 或 detach() 和线程的资源释放问题有关:
- 线程的资源将在调用 t.join() 后且线程执行完成后被回收。
- t.detach() 会将线程 t_thread 与当前线程分离。但其归属权和控制权都将转移给 C++ 运行时库（runtime library，又名运行库），由此保证线程退出时与之关联的资源可以被正确回收。
如果没有调用过 join() 或 detach()，也没有转移 std::thread 对象的所有权，那么它的 joinable() 返回值为 true。直接调用析构会导致整个进程结束。
```
~thread() {
  if (joinable()) std::terminate();
}
```
线程对象何时是 joinable 的？
1. 其是默认构造的。
2. 如果其已经被用来使用移动构造或赋值构造创建了另一个 std::thread 对象。
3. 其成员函数 join() 或 detach() 已经被调用过。
注意点
1. 被创建的 std::thread 需要调用 join() 或者 detach()
2. 有关联的线程仍然活跃（是 joinable 的）的 std::thread 不能被销毁，否则报错 “terminate called without an active exception”
3. std::thread 参数必须是可调用的或者可以转成右值，传入非常量引用需要 std::ref 套一下
  
  线程是有自己的内存存储空间的，在 std::thread 类的构造中，参数会先按照默认方式复制到线程的存储空间中，然后新创建的线程才能访问它们。这些副本被当做临时变量，以右值的方式传递给新线程上的函数或者可调用对象。即便函数相关的参数按设想应该是引用。

145. 怎么设计哈希表，负载因子设置为多少，有什么办法提高哈希表的填充率？

小红书搜广推 C++ 一面

设计哈希表需要综合考虑哈希函数、冲突解决机制、扩容策略和内存管理。

哈希函数应具有良好的分布性和计算效率，常见的有 MurmurHash、CityHash 等；冲突解决可采用链地址法（链表存储冲突元素，简单稳定）或开放寻址法（线性探测、二次探测、双哈希，缓存友好但易产生聚集）。

扩容因子（负载因子） 是哈希表中已存储元素数量与哈希表总容量的比值，用于衡量哈希表的填充程度和触发扩容的时机。

一般是达到 0.75 后，直接扩容为原来的 2 倍

负载因子通常设置为 0.75，这是经验证能在时间效率和空间利用率间取得最佳平衡的阈值——超过此值冲突概率急剧上升，低于此值则内存浪费明显。

提高填充率的核心方法包括：优化哈希函数减少冲突，使用二次探测或双哈希降低初级聚集，实现动态扩容（通常翻倍扩容并重哈希），采用布谷鸟哈希通过多个哈希函数和踢出机制提升空间利用率至 95%+，以及实现渐进式 rehash 避免扩容时的服务中断，这些技术能显著提升哈希表在保持高性能的同时的空间利用效率。

146. 哪些设计模式利用了虚函数的特点？

高德 C++ 一面

设计模式中，模板方法、策略、工厂方法、抽象工厂、观察者、装饰器、访问者、状态、职责链和命令等模式都深度依赖于虚函数实现的运行时多态性：这些模式通过在基类或接口中定义抽象的虚函数，并在各个具体子类中提供不同的实现，使得相同的接口调用能在运行时表现出不同的行为。这种机制使得程序架构能够将稳定的框架逻辑与易变的具体实现解耦，让算法骨架（模板方法）、对象创建（工厂）、行为策略（策略模式）、事件响应（观察者）、功能扩展（装饰器）等核心要素可以在不修改现有代码的前提下灵活扩展和替换，从而实现了面向接口而非实现的编程范式，为软件设计提供了强大的灵活性和可维护性。

147. 多重继承下（C 继承 A 和 B），C 类的对象内存布局是怎样的？

🔥 虚函数必知前提

一个虚函数表对应一个类（前提有 virtual）
一个类可能不止一个虚函数表（多重继承的情况下）
派生类和基类都有各自的虚函数表（派生类拷贝基类虚函数表后，重写虚函数则覆盖函数地址，新增虚函数则增加函数地址）
多重继承下 C 类有两个虚函数表：第一个 vptr_a 指向的虚函数表包含 A 和 C 的虚函数，第二个 vptr_b 指向的虚函数表包含 B 和 C 的虚函数

多继承场景的内存布局（C 类有 2 张虚函数表，其中 1 张为主表）

C 对象的内存布局：
+----------------+  <-- C* 指针, A* 指针
| AC的虚表指针    |  --> C 虚函数表 1: [ &C::funcA, &A::~A, &C::funcC ]
+----------------+
| A::a_data      |
+----------------+
| BC的虚表指针    |  --> C 虚函数表 2: [ &thunk_to_C::funcB, &C::~C ]
+----------------+
| B::b_data      |
+----------------+
| C::c_data      |
+----------------+

A 的虚函数表：
[0] &C::funcA    // C重写的funcA
[1] &A::~A       // 析构函数  
[2] &C::funcC    // C自己的虚函数

B 的虚函数表：
[0] &thunk_to_C::funcB  // 需要调整this指针的跳转函数
[1] &B::~B              // 析构函数

为什么要调整 this 指针

不调整 Base2 的 this 指针时，默认是直接指向第二个虚函数表指针的位置（因为这样 Base2 可以直接在首地址访问到第二个虚表指针，快速调用自己重写的虚函数，但是对象首地址应该是第一个虚函数表指针的位置 —— 整体对象首地址），这会造成所有成员访问都会错位！

让我详细解释为什么非首基类调用需要调整this指针。

1. 根本原因：内存布局导致的指针偏移

class Base1 {
public:
    int b1_data;
    virtual void func() { /* 期望this指向Base1开始 */ }
};

class Base2 {
public:
    int b2_data; 
    virtual void func() { /* 期望this指向Base2开始 */ }
};

class Derived : public Base1, public Base2 {
public:
    int d_data;
    void func() override { /* 需要访问所有数据：b1_data, b2_data, d_data */ }
};

2. 具体内存布局分析

Derived对象内存布局：
+----------------+  <-- Derived* = 0x1000 (完整对象起始地址)
| Base1虚表指针   |  
+----------------+
| Base1::b1_data |  // 偏移量 +0
+----------------+
| Base2虚表指针   |  <-- Base2* = 0x1008 (Base2子对象起始地址)
+----------------+
| Base2::b2_data |  // 偏移量 +8 (相对于Base2*)
+----------------+
| Derived::d_data| // 偏移量 +16 (相对于Base2*)
+----------------+

3. 问题所在：this 指针不匹配

通过不同指针调用时

Derived derived;
Base1* b1_ptr = &derived;  // b1_ptr = 0x1000
Base2* b2_ptr = &derived;  // b2_ptr = 0x1008 (偏移了8字节!)

b1_ptr->func();  // 传入的this = 0x1000 ✓
b2_ptr->func();  // 传入的this = 0x1008 ✗ 问题！

Derived::func() 需要访问的数据：

void Derived::func() {
    // 这些访问都基于完整的Derived对象地址
    cout << b1_data;   // 在偏移量 +8 处
    cout << b2_data;   // 在偏移量 +16 处  
    cout << d_data;    // 在偏移量 +20 处
}

4. 如果不调整 this 指针，所有成员访问都会错位！

// 假设不调整this指针，直接调用：
b2_ptr->func();  // this = 0x1008

// 在Derived::func()中：
cout << b1_data;   // 实际访问 0x1008 + 8 = 0x1010 (错误！应该是0x1008)
cout << b2_data;   // 实际访问 0x1008 + 16 = 0x1018 (错误！应该是0x1010)  
cout << d_data;    // 实际访问 0x1008 + 20 = 0x101C (错误！应该是0x1014)

148. 当 C 类继承 A 类时，A 和 C 的构造函数与对象的虚函数表指针之间存在什么样的交互关系？

我们来详细拆解 C 类继承 A 类时，构造函数和虚函数表指针的关系。简单来说，构造函数负责为本类及其基类“初始化”虚函数表指针，使其指向正确的虚表。

下面是详细的步骤和关系：

1. 对象的内存布局（继承时）

假设我们有如下代码：

class A {
public:
    virtual void vfunc1() { }
    virtual void vfunc2() { }
    int a_data;
};

class C : public A {
public:
    virtual void vfunc1() override { } // 重写
    virtual void vfunc3() { }          // 新的虚函数
    int c_data;
};

一个 C 类对象在内存中的典型布局如下：

|------------------------|
| A::vptr (虚函数表指针) |  <- 对象开头，通常只有一个vptr
|------------------------|
| A::a_data              |
|------------------------|
| C::c_data              |
|------------------------|

关键点：在单继承情况下，派生类对象通常只包含一个虚函数表指针，这个指针位于对象的起始位置，由基类 A 引入。

2. 构造函数的执行过程与 vptr 的初始化

当你创建一个 C 对象时（C* obj = new C();），构造函数的调用和 vptr 的设置流程如下：

步骤 1: 分配内存

操作系统为 C 类对象分配足够的内存（包含 A 部分 + C 部分）。

步骤 2: 进入 C 的构造函数

在进入 C 的构造函数体之前，编译器会插入代码，将对象的 vptr 设置为指向 C 类的虚函数表。
然后调用基类 A 的构造函数。

步骤 3: 进入 A 的构造函数

在进入 A 的构造函数体之前，编译器会插入代码，将对象的 vptr 设置为指向 A 类的虚函数表。
执行 A 的构造函数体。

步骤 4: 返回 C 的构造函数

A 的构造函数执行完毕后，返回到 C 的构造函数。
此时，编译器会再次将对象的 vptr 重新设置为指向 C 类的虚函数表。
最后执行 C 的构造函数体。

3. 虚函数表指针的变化流程

这个过程中，vptr 的变化可以用以下伪代码表示：

// 创建 C 对象时的幕后代码
C* obj = operator new(sizeof(C));  // 1. 分配内存

// 2. 开始构造 C
obj->vptr = &C::vtable;            // 先指向C的虚表（临时）
A::A(obj);                         // 3. 调用基类构造函数
    // 在 A::A 内部:
    obj->vptr = &A::vtable;        // 指向A的虚表
    // ... 执行A的构造函数体 ...
// 从 A::A 返回后
obj->vptr = &C::vtable;            // 重新指向C的虚表（最终）
// ... 执行C的构造函数体 ...

4. 重要结论和影响

为什么要在构造函数中这样设置 vptr？

类型安全：在 A 的构造函数中调用虚函数时，应该调用 A 版本的实现，而不是可能依赖 C 中未初始化数据的 C 版本重写。
构造顺序：对象是从基类到派生类依次构造的，在构造 A 时，C 还没有构造完成。

虚函数表的内容

A 的虚表：{ A::vfunc1, A::vfunc2 }
C 的虚表：{ C::vfunc1, A::vfunc2, C::vfunc3 } （注意 vfunc1 被替换了）

在构造函数中调用虚函数

class A {
public:
    A() { 
        vfunc1(); // 这里调用的是 A::vfunc1，不是 C::vfunc1！
    }
    virtual void vfunc1() { cout << "A's vfunc1\n"; }
};

class C : public A {
public:
    virtual void vfunc1() override { cout << "C's vfunc1\n"; }
};

// 执行：
C obj; // 输出 "A's vfunc1"，而不是 "C's vfunc1"

总结

构造函数和虚函数表指针的关系：

构造顺序决定 vptr 设置：在进入每个类的构造函数体之前，vptr 被设置为指向当前类的虚表。
vptr 会多次变化：在构造过程中，vptr 会随着构造流程在基类和派生类的虚表之间切换。
最终指向派生类：构造完成后，vptr 最终指向最派生类（本例中的 C）的虚表。
保证构造安全：这种机制确保了在构造函数中调用虚函数时，不会调用到尚未构造完成的派生类重写版本。

这就是 C++ 对象构造与多态机制协同工作的精妙之处。

149. 在基类构造函数中调用虚函数，此时是调用基类还是派生类？那如果在派生类构造函数中调用虚函数呢？（上一个问题有提及）

类型安全：在 A 的构造函数中调用虚函数时，应该调用 A 版本的实现，而不是可能依赖 C 中未初始化数据的 C 版本重写。

构造顺序：对象是从基类到派生类依次构造的，在构造 A 时，C 还没有构造完成。

基类构造函数中调用虚函数：基类（此时派生类还没有构造好，因为构造顺序是先父类再派生类）

派生类构造函数中调用虚函数：

调用的是派生类重写的虚函数：派生类
调用的是派生类未重写的虚函数：基类（因为未重写，虚函数表未覆盖原有的虚函数地址，仍然指向基类的虚函数地址）

150. 你知道可重入锁吗？如何实现可重入锁？具体的字段和函数如何设计？

“重入”指的是同一个线程，在已经持有某个锁的前提下，可以再次成功获取该锁，而不会被自己阻塞。

可重入锁允许同一个线程多次获取锁而不被自己阻塞，但这不影响锁的基本互斥特性——其他线程仍然必须等待当前线程完全释放锁后才能获取。

#include <mutex>
#include <thread>
#include <condition_variable>
#include <atomic>
#include <stdexcept>

class ReentrantLock {
private:
    std::thread::id owner_;           // 当前持有锁的线程ID
    std::atomic<int> count_;          // 重入计数
    std::mutex mutex_;                // 保护内部状态
    std::condition_variable cond_;    // 等待条件变量

public:
    ReentrantLock() : count_(0) {}
    
    // 获取锁
    void lock() {
        std::unique_lock<std::mutex> lock(mutex_);
        std::thread::id this_thread = std::this_thread::get_id();
        
        // 如果锁被其他线程持有，等待
        while (count_ > 0 && owner_ != this_thread) {
            cond_.wait(lock);
        }
        
        // 现在可以获取锁
        owner_ = this_thread;
        count_++;
    }
    
    // 释放锁
    void unlock() {
        std::unique_lock<std::mutex> lock(mutex_);
        std::thread::id this_thread = std::this_thread::get_id();
        
        if (count_ <= 0 || owner_ != this_thread) {
            throw std::logic_error("Attempt to unlock a lock not owned by current thread");
        }
        
        count_--;
        if (count_ == 0) {
            owner_ = std::thread::id();  // 清空所有者
            cond_.notify_one();          // 唤醒一个等待线程
        }
    }
    
    // 尝试获取锁
    bool try_lock() {
        std::unique_lock<std::mutex> lock(mutex_);
        std::thread::id this_thread = std::this_thread::get_id();
        
        if (count_ == 0 || owner_ == this_thread) {
            owner_ = this_thread;
            count_++;
            return true;
        }
        return false;
    }
    
    // 获取重入次数（主要用于调试）
    int get_count() const {
        return count_.load();
    }
    
    // 检查当前线程是否持有锁
    bool is_owned_by_current_thread() const {
        return count_ > 0 && owner_ == std::this_thread::get_id();
    }
};

151. 常见的内存安全问题有哪些？

内存安全问题主要源于程序对计算机内存（如堆、栈）的错误访问或管理，通常会导致程序崩溃、数据损坏或严重的安全漏洞（如被攻击者利用以执行任意代码）。

以下是常见的内存安全问题分类和详解：

1. 缓冲区溢出

这是最经典、最危险的内存安全问题之一。当程序向一个分配好大小的缓冲区（如数组）写入数据时，写入的数据量超过了缓冲区的容量，导致覆盖了相邻的内存区域。

栈缓冲区溢出：溢出发生在栈上，可能会覆盖函数的返回地址。攻击者可以精心构造数据，将返回地址指向其注入的恶意代码，从而控制程序流程。
堆缓冲区溢出：溢出发生在堆上，可能会破坏堆中相邻的数据结构（如堆块头、其他对象等），导致程序行为异常或为攻击者提供利用机会。

示例：

void copy_string(char *input) {
    char buffer[16]; // 栈上分配一个16字节的缓冲区
    strcpy(buffer, input); // 如果input长度超过15字节（+1个结束符），就会发生溢出！
}

2. 解引用空指针或野指针

空指针解引用：试图访问内存地址 0x0（通常表示空指针）的内容。这会导致程序立即崩溃（段错误）。
野指针解引用：指针指向的内存已被释放或未初始化，但其值未被置空。此时解引用它，行为是未定义的——可能读到垃圾数据、写入到已不属于它的内存，导致难以调试的错误。

示例：

int *ptr = NULL;
*ptr = 5; // 解引用空指针，崩溃！

int *wild_ptr = (int*)malloc(sizeof(int));
free(wild_ptr); // 内存已释放...
*wild_ptr = 10; // ...但指针仍指向那里，现在是一个野指针，解引用它行为未定义！

3. 使用后释放

这是野指针问题的一种常见形式。内存被释放后，指向它的指针仍然存在。如果该内存被重新分配用于其他用途，那么通过野指针修改它就会破坏新数据，造成信息泄露或控制流劫持。

示例：

char *ptr = (char*)malloc(100);
free(ptr); // 内存释放，ptr现在是野指针
// ... 一段时间后，系统可能将这块内存分配给另一个对象
strcpy(ptr, "Hello"); // 破坏了新对象的数据！

4. 双重释放

对同一块动态分配的内存进行多次 free() 操作。这会破坏内存管理器的数据结构（如glibc的堆元数据），可能导致程序崩溃或让攻击者插入恶意代码。

示例：

int *ptr = (int*)malloc(sizeof(int));
free(ptr);
free(ptr); // 错误：双重释放！

5. 内存泄漏

程序动态分配了内存（如使用 malloc, new），但在使用完毕后忘记释放。不断的内存泄漏会逐渐消耗掉系统的所有可用内存，最终导致程序或系统变慢甚至崩溃。虽然它不直接让攻击者利用，但会降低系统稳定性。

示例：

void leak_memory() {
    while(1) {
        int *ptr = (int*)malloc(1024); // 每次循环都分配1KB，但从不释放
        // ... 使用ptr ...
        // 忘记 free(ptr);
    }
}

6. 未初始化的内存读取

变量（尤其是栈或堆上的变量）在分配后没有赋初值就直接读取。此时读到的内容是之前留在内存中的随机值（垃圾值），会导致程序逻辑错误和不稳定。

示例：

int value; // 未初始化
printf("%d", value); // 可能输出任意值，行为不确定

7. 整数溢出与回绕

在进行算术运算时，结果超出了该整数类型所能表示的范围。这可能导致缓冲区大小的计算错误，进而引发缓冲区溢出。

无符号整数回绕：UINT_MAX + 1 会变成 0。
有符号整数溢出：行为在C/C++标准中是未定义的，但常见实现是回绕。

示例：

uint32_t buffer_size = count * sizeof(int); // 如果count很大，乘法可能回绕成一个很小的数
int *buffer = (int*)malloc(buffer_size); // 现在分配的空间远小于所需
// 后续向buffer写入数据会导致堆缓冲区溢出

8. 迭代器失效

在C++等语言中，当修改容器（如 vector, deque）时（例如插入、删除元素），指向容器元素的迭代器可能会变得无效。继续使用这些失效的迭代器会导致未定义行为。

示例：

std::vector<int> vec = {1, 2, 3};
auto it = vec.begin();
vec.push_back(4); // 可能导致vector重新分配内存，使所有迭代器失效
*it = 5; // 错误！使用已失效的迭代器

152. vector 扩容采用深拷贝还是浅拷贝？

深拷贝，避免资源 double free。

std::vector 在扩容时（例如，当 push_back 新元素导致 size() > capacity() 时），会执行以下步骤：

分配新内存：在自由存储区（堆）上分配一块新的、更大的内存空间。
拷贝（或移动）元素：将旧内存空间中的所有元素逐个转移到新的内存空间中。
释放旧内存：销毁旧内存空间中的对象并释放内存。

关键在于第2步：“逐个转移”。

如果 vector 中存储的是 内置类型 或 可平凡拷贝的类型，这个“拷贝”在行为上和 “逐位浅拷贝” 效果相同，但因为调用的是对象的拷贝构造函数或移动构造函数，所以从语言机制上，我们依然称之为“拷贝”（一种高效的、按值复制的深拷贝）。
如果 vector 中存储的是 自定义类对象，那么这个过程会明确地调用每个对象的拷贝构造函数 或 移动构造函数。此时 vector 分配新内存，然后简单地将旧内存中的 MyObject 指针（即 data 成员）复制到新内存中。现在，两个 MyObject 对象（旧内存和新内存中的）的 data 成员指向了同一块堆内存。vector 紧接着会释放旧内存。在释放过程中，它会调用旧内存中每个 MyObject 对象的析构函数，导致 delete data;。结果就是，新内存中的 MyObject 对象的 data 指针变成了一个悬空指针。当你后续尝试通过它访问数据时，行为未定义（通常是程序崩溃）。更糟糕的是，当这个 vector 最终被销毁时，它会再次 delete 同一块内存，导致双重释放。

如果你的对象支持移动语义，vector 在扩容时会优先使用移动构造函数，这比深拷贝更高效，因为它“窃取”旧对象的资源，而不是复制它们。对于这样的类，vector 扩容时会调用“移动构造”，只是转移了指针所有权，没有进行昂贵的内存分配和值复制。

class MyObject {
public:
    int* data;
    MyObject(int value) {
        data = new int(value);
    }

    // 深拷贝拷贝构造函数
    MyObject(const MyObject& other) {
        data = new int(*(other.data)); // 分配新内存，并复制值
        std::cout << "拷贝构造被调用" << std::endl;
    }
    // 深拷贝拷贝赋值运算符 (通常还需要实现)
    MyObject& operator=(const MyObject& other) {
        if (this != &other) {
            delete data; // 释放原有资源
            data = new int(*(other.data));
        }
        std::cout << "拷贝赋值被调用" << std::endl;
        return *this;
    }

    // 移动构造函数 (noexcept 很重要，便于vector优化)
    MyObject(MyObject&& other) noexcept : data(other.data) {
        other.data = nullptr; // 使旧对象处于有效但可析构的状态
        std::cout << "移动构造被调用" << std::endl;
    }

    // ... 相应的移动赋值运算符 ...

    ~MyObject() {
        delete data;
    }
};

153. 析构函数什么情况下才需要设置为虚析构？什么时候可以不用？

需要虚析构函数的情况：

✅ 类被设计为基类，且可能通过基类指针删除派生类对象
✅ 类包含虚函数（有虚函数通常意味着多态使用）
✅ 类有派生类且派生类需要资源清理（避免资源泄漏）

不需要虚析构函数的情况：

❌ 类不会被继承（如工具类、值类型）
❌ 类标记为 final
❌ 不会通过基类指针删除对象
❌ 类没有虚函数且不打算多态使用

经验法则：如果一个类有任何一个虚函数，那么它的析构函数也应该是虚的。

154. 钻石继承（虚继承）的内存布局

class Base {
public:
    int base_data = 0xBB;
    virtual void base_func() { cout << "Base::base_func" << endl; }
};

class Mid1 : virtual public Base {  // 虚继承
public:
    int mid1_data = 0xM1;
    virtual void mid1_func() { cout << "Mid1::mid1_func" << endl; }
};

class Mid2 : virtual public Base {  // 虚继承  
public:
    int mid2_data = 0xM2;
    virtual void mid2_func() { cout << "Mid2::mid2_func" << endl; }
};

class Bottom : public Mid1, public Mid2 {
public:
    int bottom_data = 0xBT;
    void base_func() override { cout << "Bottom::base_func" << endl; }
};

Bottom对象内存布局：
+----------------+  <-- Bottom*, Mid1* 
| Mid1虚表指针   |  --> [ &Mid1::mid1_func, ... + 虚基类信息 ]
+----------------+
| mid1_data      |
+----------------+
| Mid2虚表指针   |  --> [ &Mid2::mid2_func, ... + 虚基类信息 ]
+----------------+
| mid2_data      |
+----------------+
| bottom_data    |
+----------------+
| Base虚表指针   |  --> [ &Bottom::base_func, ... ]
+----------------+
| base_data      |
+----------------+

虚表数量：3张
1. Mid1部分的虚表
2. Mid2部分的虚表  
3. Base部分的虚表（共享）

155. delete 和 delete[] 有什么区别？

delete vs delete[]

delete p：销毁一个对象，调用其析构，随后调用对应的 operator delete 释放内存。
delete[] p：销毁数组中的每个元素（通常逆序调用析构），再调用 operator delete[]。
成对使用：new→delete，new[]→delete[]；混用是未定义行为（无法知道元素个数）。

delete[] 的释放过程

运行时需要知道元素个数以逐个析构——常见实现会在分配块前留“数组 cookie”记录个数（标准不强制，但做法通行）。
调用每个元素的析构（通常逆序）。
调 operator delete[] 释放整块内存。

156. delete[] 怎么知道删除几个元素？额外记录元素个数不会影响索引访问吗？

不会出问题的。数组 “cookie” 放在内存块起始处，返回给你的指针仍然指向第 0 个元素，所以用下标访问完全正常。更具体点：

p = new T[n]; 的典型内存布局大致是 [ cookie | 可能的对齐填充 | T(0) | T(1) | ... | T(n-1) ] 这里 p 等于 &T(0)，而不是指向 cookie。你做 p[i]、*(p+i) 都是在元素区间里算术，和 cookie 没有任何交集。
cookie 仅供 delete[] p 使用：实现会在删除时把 p 向前回退到隐藏头（或使用“带大小”的 delete 接口），取出元素个数，按需要逐个析构，再释放整块内存。正常访问阶段你看不到它。
对齐不会被破坏：分配器会多分配一些字节，确保把 p 调整到满足 alignof(T)（对于超对齐类型还会用到对齐版的 operator new[]），因此 p 的对齐是正确的。
一些实现/场景甚至不需要 cookie（例如使用“带大小”的 operator delete[](void*, std::size_t) 或 trivially destructible 的类型），但这对你的索引访问没有影响。

真正会出问题的情况是未定义行为：

用 new T[n] 却配 delete p，或 new T 配 delete[] p——删除路径不匹配，运行时找不到正确的元素个数，轻则泄漏，重则崩溃。
对 p 做越界/负向指针运算（例如试图访问 *(p-1) 想“看到 cookie”）——这是未定义行为。
自己实现/重载 operator new[]/delete[] 却没有正确处理对齐与大小信息。

总结：正常写法下，索引访问只落在元素区域内，和 cookie 完全隔离；记得 new/delete、new[]/delete[] 要成对使用就行。

157. 什么是右值引用？必须用 move 才能转为右值吗吗？

不必须。std::move 只是把一个左值显式地“转成将亡值(xvalue)” 的工具（本质是 static_cast<T&&> 的封装），以便命中移动重载。得到右值/触发移动还有很多途径：

什么时候不必用 `move` 也会移动

临时对象/返回值（prvalue）

std::string s = std::string("hi"); // 直接构造/拷贝省略；不需要 move
std::string f() { return std::string("hi"); } // 返回值是右值
auto t = f(); // 若未省略拷贝，则优先用移动构造

C++17 起很多场景保证拷贝消除，连“移动”都省了。

return 局部对象（隐式移动）

std::string g() {
  std::string x = "hi";
  return x;            // x 是本地对象、同类型返回——隐式当成右值（或直接省略）
}

“值传参再返回”/sink 参数

void set_name(std::string s) { name_ = std::move(s); } // 调用处传实参时会移动
set_name(std::move(tmp));   // 显式
set_name(f());              // f() 返回值本就是右值

容器的 emplace_\* / 工厂函数

v.emplace_back(100, 'x'); // 直接就地构造，没有 move 的必要
auto p = std::make_unique<Foo>(); // 返回右值

迭代器适配器

std::vector<std::string> a, b;
b.insert(b.end(),
         std::make_move_iterator(a.begin()),
         std::make_move_iterator(a.end()));  // 把范围“视作右值”

确实需要 `move` 的典型场景

把一个“有名字的对象”（左值）当右值用

std::string s = "hi";
v.push_back(std::move(s));  // 不写 move 就会拷贝

类内转移所有权
```
holder(ptr p) : p_(std::move(p)) {}
```

模板里应当用 `forward`（而非一律 `move`）

完美转发：只在参数本来是右值时才转成右值

template<class T, class... Args>
T make(Args&&... args) {
  return T(std::forward<Args>(args)...);
}

常见误区 & 边界

std::move 不会“移动”，它只是一个无开销的强制类型转换；是否真的走移动构造/赋值，要看目标类型是否提供相应重载。
对 const 对象用 std::move 往往没有意义：得到的是 const T&&，大多数类型的移动构造签名是 T(T&&)（非常量），因此会退化为拷贝。
```
const std::string s = "hi";
std::string t = std::move(s); // 通常走拷贝，而不是移动
```
移动后对象仍然有效但处于“资源被转移”的状态，只保证可析构/可赋新值，不保证内容。

结论

右值不等于必须 std::move。临时对象、返回值、隐式移动、emplace/工厂函数、move_iterator 等都能产生/利用右值。
当且仅当你手里是一个左值且你确实要把它的资源转移时，才需要写 std::move；模板里用 std::forward 保留原本的值类别。

158. 内存上的问题：一种代码有好几种写法，他可能实现的功能都差不多，但是性能可能会有很大的差异，关于这点具体有什么要注意的地方，或者说你有什么要分享给我的？

1) 数据布局（决定缓存命中）

高性能往往从“内存长相”开始：把 AoS（struct{...} 的数组）改成 SoA（每个字段单独一块连续数组），让 CPU 一次线性扫到成批需要的字段，利于向量化与硬件预取；把“总被一起用”的字段挪到相邻位置，把大而冷的成员（如 std::string/std::vector）拆出去，形成“热-冷分离”，减少不必要的 cache line 装载；按自然对齐排布字段，避免错误使用 #pragma pack 或位域导致跨行和非对齐访问；利用小对象优化（SBO）减少堆分配，但要盯住对象尺寸别超过 SBO 阈值；在构造路径用 emplace/拷贝省略、在读路径用 string_view/span 等无拷贝视图（同时记住生命周期边界），这些都能显著降低 L1/L2 Miss 和内存带宽压力。

2) 分配与生命周期（降低 malloc/free 压力）

频繁的小分配是吞吐杀手：容器预留容量（vector::reserve/string::reserve）能一次到位，避免指数扩容的反复搬运；对“批量创建—一次性丢弃”的工作负载（解析、编译、RPC）用 Arena/Pool，把释放从“逐个 free”变成“批量 reset”；用 PMR（polymorphic_allocator）或自定义分配器，让一批相关容器共享内存资源，减少碎片和锁争用；同型小对象密集创建销毁用 slab/pool 固定大小块加速；跨层传递数据优先“指针/视图”而非拷贝（I/O 路径上用 readv/writev、sendfile、splice、mmap）实现零拷贝；写入容器使用 emplace 或 push_back(std::move(x))，把昂贵的深拷贝变为常数级的指针交换。

3) Cache/CPU 友好（L1/L2/TLB/分支）

让访问“像读磁带”而不是“打地鼠”：尽量把热点算法改成顺序扫描，超大数组分块（tiling）匹配 L1/L2 容量；避免链表/指针森林等随机追指，用扁平数组+索引（压平）减少跳转；可预测的遍历可加 __builtin_prefetch 让硬件提前搬运；大数据吞吐可选 2MB hugepage 降 TLB Miss；分支方面把常走路径写成“卫语句”提早返回，结合 likely/unlikely 提示，减少 BTB 失误；能内联就别虚函数，必要时去虚化（CRTP/静态多态）；数据已 SoA 时再开启 -O3 -march=native，很多循环可自动向量化，或用 intrinsics 明确使用 SIMD 指令，I-cache 命中与指令级并行都能上一个台阶。

4) 并发与假共享（false sharing）

多线程下的“无形开销”常来自 cache line 抖动：对不同线程各自频繁写的计数/状态，结构体上用 alignas(std::hardware_destructive_interference_size)（常见 64B）或手动填充把它们“隔一行”；队列/环形缓冲尽量批处理 push/pop 降低同步频率，避免在共享结构上长时间自旋；跨 NUMA 机器要做“first-touch”初始化并绑定线程亲和，尽量让线程就近访问本地内存；原子操作别一律用 seq_cst，看依赖选择 release/acquire/relaxed，弱化内存屏障带来的流水线冲刷；高争用路径可以用 MPSC/SPSC 队列、分片计数（per-thread 计数+汇总）等结构，既稳又快。

5) I/O 与系统层（与页缓存配合）

顺序大读可用 mmap 配合 madvise(MADV_SEQUENTIAL) 让内核预读更积极，随机大写用 pwrite 加 posix_fadvise(DONTNEED) 避免脏页把缓存顶爆；网络/磁盘路径善用零拷贝原语（sendfile、splice、readv/writev）减少用户态-内核态往返与内存拷贝；对延迟敏感的落盘要意识到 fsync/barrier 极贵，采用写前日志+组提交（group commit）把多次同步合并成一次；离线/批处理任务可显式调大 readahead，在线请求则要避免“把冷数据抖进页缓存”影响热点；若 I/O 成为瓶颈，优先做批量与合并（coalescing），其次再考虑线程/异步模型切换。

6) 语言/库层面的易错点（以 C++ 为例）

容器与抽象的选择影响巨大：中小规模、读多改少的映射用 flat_map（排序向量 + 二分）常优于 unordered_map/map，因为 cache 友好且无哈希/指针追逐；shared_ptr 的原子引用计数在高频路径很贵，能用 unique_ptr 别上共享，或采用侵入式计数/分离控制块减少原子写；循环中逐个 erase 容器元素会导致 O(n²) 搬运，改为“打标签→一次性 stable_partition/erase_if”；std::function 捕获大对象导致隐式堆分配，性能关键路径用模板/可调用对象直传或小型闭包；异常不应走热路径（抛掷与栈展开昂贵且破坏预测），把可预期分支改成状态返回或 expected 类型更稳。

7) 度量方法（别猜，用数据说话）

优化从测量开始：先用 perf record -g + 火焰图找前两大热点（80/20 原则），再用 perf stat -e cycles,instructions,LLC-load-misses,branch-misses 看指令/CPI/缓存/分支画像；需要定位缓存行为时跑 valgrind --tool=cachegrind 得到每函数/每行的 I/D-cache 失效率；内存分配与泄漏用 heaptrack 或 Valgrind Massif 观察分配次数与峰值；遇到偶发长尾，结合 perf top 抽样、反复 gdb -p 抓多份线程栈，或上 eBPF/系统跟踪（lttng、bcc）给出系统调用与调度视角；所有实验都要可复现（固定数据/随机种子/并发度）并记录参数与版本，用基线对比量化收益。

8) 一个“改法对比”的实操范式

将“慢但易写”的实现按层次替换：①把链表/树改为 vector 扁平结构并 reserve；②把结构体数组拆成 SoA，循环里只取必要字段；③移除虚派发，改模板/策略类让编译器内联；④把元素处理改成块内循环（block size≈几 KB）以提升局部性；⑤若算法是简单算子（加减比较），尝试向量化（自动或 intrinsics）并适当 prefetch 下一块；⑥若还不够，把内存管理切到 arena/池、把 I/O 改为批量/零拷贝。每一步做小型 A/B，对照 perf stat 与火焰图，定位收益来自哪一层，避免“盲目堆技巧”。

9) 优先级与工作流程（落地打法）

别想一次把所有细节做满：先跑基准拿火焰图，只盯 Top2 热点；先改数据布局（SoA/压平/reserve），通常直接带来 2×—10×；若热点在并发/锁上，优先拆分成 per-thread 数据加批处理；若热点在 I/O，同步落盘合并到后台队列并组提交；每改一次都跑同一基准核实收益与正确性（单测+长时间 stress），收益达标就收工并写下原因/结论，避免“继续优化反而回退”；最后把关键开关做成可配置（SBO 阈值、块大小、是否 hugepage 等），便于在不同机器与负载上快速调参。

159. 还有哪些对内存强相关的且影响性能的点？

高性能分配器的选择与争用

系统默认的 malloc（如 glibc malloc）在多线程下容易产生锁争用与碎片。服务端场景优先试 jemalloc 或 tcmalloc：它们用线程局部/分级缓存降低加锁和跨核流量，明显减少分配/释放抖动。配合对象池/arena，把“高频小对象”从通用分配器挪走，进一步降低碎片与 TLB 压力。排查方法：统计分配次数与尺寸分布，观察 CPU 在 malloc/free 上的火焰图占比。

缺页开销（minor/major fault）与预热

初次触碰页会触发 minor fault，冷热数据回收后再触碰可能变 major fault（磁盘 I/O），两者都能拉高尾延迟。批量初始化（first-touch）把数据预热到内存；对大块内存启动阶段做“线性预读”或后台预热，把故障集中到启动期而不是请求关键路径。

THP/大页与 TLB 命中

透明大页（Transparent Huge Pages）或显式 2MB/1GB 大页能显著降低 TLB miss，适合大数组/长循环。但 THP 的自动折叠在写放大场景可能抖；对延迟敏感业务考虑手动 madvise(MADV_HUGEPAGE) 或显式大页分配，并监控 THP 命中率与折叠开销。

NUMA 本地性与跨节点访问

跨 NUMA 读写等同“远程内存”，延迟/带宽大幅劣化。采用“线程绑核 + first-touch 初始化”，让每个工作线程初始化并处理自己的数据分区；共享结构按节点分片，避免频繁跨节点写。必要时用 numactl/mbind 固定内存到本地节点，监控远程访问比例。

写分配（write-allocate）与非临时写

普通写 miss 会先把整行读入（write-allocate），对“仅写一次”的大数组是浪费。能预测是“流式一次写”的路径可用非临时存储（如 _mm_stream* 或 std::hardware_constructive_interference_size 配合布局优化），减少读放大；相反，对会被很快读到的数据保留默认策略更好。

预取策略（硬件+软件）

硬件预取器偏好线性/规律访问。跨 stride 大、间隔不稳定、间接寻址时就会失效。把循环改成规则访问（SoA/压平/分块），在稳定模式下用 __builtin_prefetch(addr, rw, locality) 提前装入下一块。别到处乱加预取：只在高 cache miss 的热点里加，且要基准验证。

拷贝路径与 `memcpy/memset` 微优化

反复小拷贝（几十到几百字节）会吃掉大量周期。把“拷贝-处理-丢弃”的流水改成就地处理或视图（string_view/span），把多次小拷贝合并为一次大拷贝；初始化大对象尽量延迟到真正需要时，避免“无意义 memset”。编译器通常会内联小 memcpy，但跨 cache line、未对齐时收益骤降，关注结构体对齐与大小。

COW（写时复制）与 fork 的隐形成本

使用 COW 的 fork+exec 模式在父进程频繁写（尤其是大堆）时会触发大量页级写时复制，造成 TLB 抖动与页故障。上线前把大对象移动到子进程初始化阶段，或用 posix_spawn/vfork 降低 COW 写放大；把“写多”的共享页分离到单独映射，避免 fork 后的写爆炸。

页回收策略与 swappiness/overcommit

内核回收策略不合适，会让热点页被回收、触发频繁 major fault。对在线服务，降低 swappiness、避免与大批量离线作业争内存；限制 overcommit 或为大分配使用 mmap(MAP_NORESERVE) 的权衡清晰可控。监控 pgfault/pgmajfault、kswapd CPU 占比来发现问题。

缓存一致性与跨核写放大

多核共享数据频繁写会触发 MESI/CHI 的行失效风暴。把“写多”的计数/队列分片为 per-thread/per-core，再做周期性汇总；写少读多的数据用 RCU/复制-更新（copy-on-write）模式，把写入改成构建新副本后原子切换，避免不断对共享行做写入。

对象大小与 cache line 对齐

让热点对象恰好“装进一行”能把命中率拉满；超过一行就会带来多次装载。对热结构体做字段重排/拆分，让“常用字段”落在前 64B 内；需要并发写隔离的成员，用 alignas(64) 单独放一行避免假共享。

容器增长策略与重新散列

unordered_map 重hash 与 vector 扩容搬运都可能成为尖刺。对“已知规模”的工作负载在构造时给足 reserve(N)/rehash(N)；对长寿命容器采用几何增长的默认策略通常更优，但对短生命周期/可预估尺寸的容器，改为一次性预留最省。

页着色/冷热分离与指令缓存

除了数据缓存，I-cache 也会成为瓶颈。把“热循环”与“慢路径/错误处理”分离到不同函数，减少 I-cache 抖动；数据侧做冷热分离，把日志/元信息等冷字段挪出热点结构。大代码基下，开启 LTO/PGO（基于配置文件优化）让编译器按真实热点布局代码和数据。

内存屏障与原子序语义的成本

seq_cst 在多核上会导致全局序列化，性能代价极高。按需选择 acquire/release/relaxed，用更弱的序保证实现正确性；对复合操作用“单生产者/单消费者”结构避免重栅栏；跨核通信用一次性发布-订阅（std::atomic<T*> 指针发布 + 不变量）替代频繁的强序列化。

压缩/解压与解引用延迟的权衡

在“内存带宽”受限的场景，用轻量压缩（如 LZ4、Zstd 低等级）把冷数据压缩后驻留内存，减少带宽与 cache 占用；热路径先解压再批量处理，往往比直接扫未压缩冷数据更快。关键是分层：热数据常驻、温数据轻压缩、冷数据更高压缩。

监控与门槛值（阈值要暴露为配置）

把关键内存参数做成可调：分配器种类、arena/池块大小、对象池上限、容器 reserve 值、块处理大小（tile size）、是否启用 THP、是否对齐到 cache line。不同机器与负载特征差异巨大，参数可调 + 基准脚本比硬编码更能长久保证性能。

160. 你了解过哪些锁（或同步机制）？这些锁的应用场景分别是哪些？

🔥互斥锁（mutex）/ 递归锁 / 带超时的 mutex

最常用的排它同步；临界区较长、需要睡眠等待时首选阻塞型 mutex。递归锁仅在“同线程可重入”老代码里兜底，能不用尽量不用；带超时用在避免死等（比如调用外部组件）或做降级/回退策略。

自旋锁（spinlock）/ ticket spinlock

临界区极短、线程之间切换成本高或在内核/中断上下文中使用；适合“锁住就几条指令”的场景。若临界区可能阻塞或调度，禁止使用；在多核竞争高时用 ticket/队列式自旋锁减少饥饿。

读写锁（rwlock、shared_mutex）

读多写少；读者共享、写者独占。写者饥饿要注意（选择公平策略或写优先）；若读临界区很短、竞争高，rwlock 可能比 mutex 还慢，此时更适合 RCU/版本化读。

条件变量（condvar）/ 事件（event/futex）

等待“状态变化”的典型工具：生产者-消费者、工作队列、状态机推进等。要配合外层 mutex；避免“丢信号”靠“while + 条件检查”。Linux 用户态可用 futex 走快速路径。

信号量（semaphore、counting/binary）

计数控制并发度（连接池、限流“令牌桶”），或跨进程同步（POSIX sem）。和条件变量相比，信号量更像“资源票据”，支持先 post 后 wait。

原子操作（atomic）与内存序（relaxed/acquire/release/seq_cst）

构建轻量同步或无锁结构的基石：计数器、标志位、一次性发布。选择恰当的内存序能显著降低屏障成本：大多场景 release/acquire 足够，seq_cst 少用。

RCU（Read-Copy-Update）/ Epoch 回收 / Hazard Pointers

读密集写稀少：读路径无锁、写时复制并原子切换指针；回收由 epoch/hazard 保障安全。典型用于只追加或少量更新的配置、路由表、元数据快照。

Seqlock（序列锁）/ 版本化读

读方乐观读取两次版本号一致即成功，写方独占更新并递增版本。适合写少且读可重试的结构（时间戳、统计信息）；缺点是读可能反复重试。

屏障（barrier）/ 栅栏

阶段性并行任务的“对齐点”，常见在并行算法的阶段切换；要避免过度细分导致闲等。

锁分片 / 分区锁（sharding / striping）

把一个大热点拆成多把锁（或 per-core/per-thread 数据），大幅降低竞争：哈希桶、分片计数器、分段 LRU。

文件锁 / 进程间锁（flock/fcntl、named semaphore、共享内存 + futex）

跨进程协调：单实例守护、批处理互斥、文件轮转。注意 flock 和 fcntl 语义差异与 NFS 兼容性。

分布式锁（ZK/etcd/Redis RedLock）

跨主机/服务实例的互斥：任务选主、全局限流。要考虑 租约（TTL）、时钟/网络分区与“最少一次/至多一次”的副作用，尽量设计成可重入、幂等的业务操作。

161. 你遇到最复杂的多线程场景是什么？你具体怎么解决？对于你今后在分析问题有什么考量？

代表性案例（读多写少的热点索引 + 多生产者/多消费者队列 + NUMA）

症状：QPS 上不去且尾延迟抖动。Perf/火焰图显示 30% CPU 烧在 pthread_mutex_lock，锁等待和 cache miss 居高；top -H 与 thread apply all bt 暴露热点是“全局索引读路径用同一把大锁”，加上队列端有假共享（多个线程写同一 cache line 的队头/队尾），在双路 NUMA 上跨节点访问严重。

诊断步骤

1）稳定复现与基准：固定负载与数据集，记录 P50/P99、CPU/LLC miss/TLB miss。

2）轮廓画像：perf record -g + 火焰图定位锁热点、perf stat 看 CPI/branch/TLB；TSan 验证无数据竞争。

3）锁分析：统计加锁点的平均持有时间与竞争度（埋点或 eBPF uprobes），确认“读路径被大锁覆盖”。

4）硬件/拓扑：numactl --hardware 查看节点，hwloc-ls 看 CPU/内存拓扑，采样远程内存比例。

重构与优化

读路径去锁化（RCU/版本化）：把热索引改为“不可变快照 + 写时复制”，读线程直接读当前指针；写线程构建新副本并一次性切换。读延迟大幅降低且几乎无竞争。
分片锁 + 局部化：对仍需加锁的子结构按 key 哈希分段（64/128 把锁），并将每段数据绑定到 NUMA 节点；读写都尽量落在同核/同节点。
队列无锁化与假共享修复：MPSC 改为 per-producer 环 + 单汇聚 或使用经过验证的 MPMC（如 moodycamel），并对头尾指针用 alignas(64) 隔离，避免 false sharing。
批处理与背压：消费者批量出队、合并写 I/O（group commit），用条件变量或信号量替自旋，减少无效轮询。
内存管理：对象池/arena 降低 malloc/free 抖动；对大数组启用 hugepage 降 TLB miss。
锁顺序与死锁预案：明确全局锁级别与获取顺序，跨组件使用 try_lock + 回退策略，配合超时与诊断日志避免“无声死锁”。

效果与验收：读路径 P99 从毫秒级降到百微秒内，锁等待时间下降 >90%，LLC/TLB miss 显著减少；在 NUMA 绑定后远程访问下降，尾延迟收敛。留下一套基准与回归测试（压力 + 混沌/抖动），并把关键参数（分片数、批大小、是否 RCU）做成可调。

今后分析问题的考量清单

选择最弱同步：能原子就不加锁，能分片就不全局，能读重试就不阻塞。
读写比/临界区长度：读多写少优先 RCU/版本化；短临界区可自旋，长临界区用阻塞。
竞争度与可分割性：先量化锁竞争，再考虑分区/分层；避免把“不可分”的资源放进热路径。
NUMA 与内存亲和：first-touch、线程绑核、数据分区；跨节点代价要显式评估。
可恢复与可观测：超时、降级、try_lock 回退，日志能定位“谁拿着锁、持有多久”。
正确性优先：无锁/乐观结构要配套内存回收（epoch/hazard）与 ABA 防护；单测 + TSan/模型检查覆盖边界。
度量驱动：每一次改动都用同一基准验证 P50/P99 与 CPU/缓存计数，避免“感觉良好型优化”

162. 手撕无锁队列

设计要点

结构：单向链表 + 虚拟哑元（dummy）头结点；两个原子指针：head、tail。
入队（enqueue）：尝试把 tail->next 从 nullptr CAS 成新结点；成功后再把 tail 向后推进（CAS）。若 tail->next 非空，先帮助推进 tail。
出队（dequeue）：读 head、tail、head->next；若 head == tail 且 next==nullptr 队列空；否则把 head CAS 到 next，返回 next->value。并延迟释放旧头（见回收）。
ABA & 回收：
- ABA：由于我们只单向推进，不会把已删除的节点再插回队列，可用epoch-based reclamation (EBR) 避免悬挂回收；或用 Hazard Pointers（更复杂）。
- 这里实现一个轻量 EBR：每线程进入“临界区”时标记活跃 epoch，退出现有“安全点”；只有当所有活跃线程都不可能再见到某些旧节点时，才回收它们。

注意：真实生产可引入成熟 HP/EBR 库；此处给出教学用、可工作的极简 EBR。

163. 手撕并发哈希表，如何设计细粒度锁

设计要点

结构：分 S 个分片（segment/stripe）；每片包含若干桶（拉链法），每片一把 shared_mutex。
- 查找：读锁该片，遍历桶链。
- 插入/更新/删除：写锁该片，操作对应桶。
扩容（再哈希）：
- 简洁稳妥做法：全局写锁（短时）阻止并发写，重建 buckets 并迁移；查找可用读锁和版本号防止看到中间态。
- 或做增量迁移（复杂）：分阶段把旧桶迁到新表，读写需能同时查两处。这里给工程友好的“全局写锁扩容”。
负载因子：达到阈值（如 0.75）触发 rehash(2x)。
注意：锁分片比“每桶一把锁”更经济，也更容易控制扩容一致性；热键均衡取决于哈希质量。

代码

// striped_hash_map.hpp
#pragma once
#include <vector>
#include <shared_mutex>
#include <optional>
#include <functional>
#include <atomic>
#include <list>
#include <utility>

template<class K, class V,
         class Hash = std::hash<K>,
         class KeyEq = std::equal_to<K>>
class StripedHashMap {
    struct BucketKV { K k; V v; };

    struct Segment {
        mutable std::shared_mutex mtx;
        std::vector<std::list<BucketKV>> buckets; // separate chaining
        size_t size = 0; // 元素数（仅此 segment）
        Segment(size_t nb=8): buckets(nb) {}
    };

    std::vector<Segment> segs;
    Hash hasher;
    KeyEq eq;
    std::atomic<size_t> total{0};
    float max_load = 0.75f;

    // 一把全局写锁，仅用于 rehash（频度低）与全局操作
    mutable std::shared_mutex global_rw;

public:
    explicit StripedHashMap(size_t segments = 64, size_t buckets_per_seg = 8)
      : segs(segments, Segment(buckets_per_seg)) {}

    // 不存在则插入，存在则更新，返回是否新插入
    bool upsert(const K& k, const V& v) {
        auto [seg_idx, b_idx] = index_of(k);
        Segment& s = segs[seg_idx];
        {
            std::unique_lock lk(s.mtx);
            auto& lst = s.buckets[b_idx];
            for (auto& kv : lst) {
                if (eq(kv.k, k)) { kv.v = v; return false; }
            }
            lst.push_front(BucketKV{ k, v });
            ++s.size;
            ++total;
        }
        maybe_rehash(); // 放锁后尝试触发扩容
        return true;
    }

    // 如果键不存在则构造，存在则不变，返回 (引用, 是否新插入)
    template<class... Args>
    std::pair<V&, bool> get_or_emplace(const K& k, Args&&... args) {
        auto [seg_idx, b_idx] = index_of(k);
        Segment& s = segs[seg_idx];
        {
            std::unique_lock lk(s.mtx);
            auto& lst = s.buckets[b_idx];
            for (auto& kv : lst) {
                if (eq(kv.k, k)) return { kv.v, false };
            }
            lst.emplace_front(BucketKV{ k, V(std::forward<Args>(args)...) });
            ++s.size; ++total;
            return { lst.front().v, true };
        }
    }

    std::optional<V> find(const K& k) const {
        auto [seg_idx, b_idx] = index_of(k);
        Segment const& s = segs[seg_idx];
        std::shared_lock lk(s.mtx);
        for (auto const& kv : s.buckets[b_idx]) {
            if (eq(kv.k, k)) return kv.v;
        }
        return std::nullopt;
    }

    bool erase(const K& k) {
        auto [seg_idx, b_idx] = index_of(k);
        Segment& s = segs[seg_idx];
        std::unique_lock lk(s.mtx);
        auto& lst = s.buckets[b_idx];
        for (auto it = lst.begin(); it != lst.end(); ++it) {
            if (eq(it->k, k)) {
                lst.erase(it);
                --s.size; --total;
                return true;
            }
        }
        return false;
    }

    size_t size() const noexcept { return total.load(std::memory_order_acquire); }

private:
    std::pair<size_t,size_t> index_of(const K& k) const {
        size_t h = hasher(k);
        size_t seg_idx = h % segs.size();
        size_t b_idx = (h / segs.size()) % segs[seg_idx].buckets.size();
        return { seg_idx, b_idx };
    }

    void maybe_rehash() {
        // 轻量判断是否需要扩容（近似全局负载）
        size_t n = total.load(std::memory_order_acquire);
        size_t total_buckets = 0;
        for (auto& s : segs) total_buckets += s.buckets.size();
        if (static_cast<float>(n) / static_cast<float>(total_buckets) < max_load) return;

        // 全局写锁，避免与并发 find/upsert 的重入扩容冲突
        std::unique_lock gL(global_rw);
        // Double-check
        n = total.load(std::memory_order_acquire);
        total_buckets = 0;
        for (auto& s : segs) total_buckets += s.buckets.size();
        if (static_cast<float>(n) / static_cast<float>(total_buckets) < max_load) return;

        // 扩容：每个 segment 加独占锁，重建桶并迁移
        for (auto& s : segs) s.mtx.lock();
        auto unlock_all = [&]{ for (auto& s : segs) s.mtx.unlock(); };

        for (auto& s : segs) {
            size_t new_nb = s.buckets.size() * 2;
            std::vector<std::list<BucketKV>> nb(new_nb);
            for (auto& lst : s.buckets) {
                for (auto& kv : lst) {
                    size_t h = hasher(kv.k);
                    size_t bidx = (h / segs.size()) % new_nb;
                    nb[bidx].push_front(std::move(kv));
                }
            }
            s.buckets.swap(nb);
        }
        unlock_all();
    }
};

2025.08.09 网易雷火笔试题

Sat, 09 Aug 2025 00:00:00 GMT

题解链接：https://mp.weixin.qq.com/s/b2qohQxoMJk8Kysswtc7mQ

测评链接：https://niumacode.com/training/143

1. 部门旅游

今年小师妹将再次组织大家进行一次精彩的部门旅游。为了确保每位员工能够顺利参与，现有三个不同的旅游团可供选择。每个旅游团的人数限制各不相同，员工可根据自己的喜好选择报名的旅游团。为了公平起见，系统将采用先到先得的原则进行处理。报名规则如下：

每位员工可以根据喜好报名参加1到3个旅游团。
报名时，如果首选的旅游团已满员，系统将自动尝试加入员工的次选旅游团。
如果员工所选择的所有旅游团均已满员，则该员工无法参加此次旅游。

输入描述

第一行包含一个整数 N，表示员工的数量（1 ≤ N ≤ 10000）。
第二行包含三个整数，分别表示旅游团 A、B、C 的最大名额（1 ≤ A, B, C ≤ 10000）。
接下来的 N 行，每行包含：
- 一个字符串，表示员工的 ID（由字母和数字组成，并且互不相同） ID 长度 ≤ 13。
- 一个整数 X（1 ≤ X ≤ 3），表示该员工选择的旅游团数量。
- X 个字符（A/B/C），表示员工选择的旅游团的优先级，优先级高的选择在前。

输出描述

按 A,B,C 三个团的顺序输出三行，每行一个整数，表示这个团最终的人数 a，接下来是 a 个字符串，表示进入这个团的员工 ID，请按照报名顺序输出。

示例 1

输入：

4
2 1 1
zhang01 2 A B
chen01 1 B
li02 3 B C A
yang 2 B A

输出：

2 zhang01 yang
1 chen01
1 li02

示例 2

输入：

4
2 1 1
zhang01 2 A B
chen01 2 A B
li02 3 A B C
yang 2 B A

输出：

2 zhang01 chen01
1 li02
0

代码：模拟

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    int employeeCount;
    cin >> employeeCount;
    
    int maxA, maxB, maxC;
    cin >> maxA >> maxB >> maxC;
    
    vector<string> groupA, groupB, groupC;
    
    for (int i = 0; i < employeeCount; ++i) {
        string employeeID;
        int choiceCount;
        cin >> employeeID >> choiceCount;
        
        vector<char> choices(choiceCount);
        for (auto& choice : choices) {
            cin >> choice;
        }
        
        for (char choice : choices) {
            if (choice == 'A' && groupA.size() < maxA) {
                groupA.push_back(employeeID);
                break;
            }
            else if (choice == 'B' && groupB.size() < maxB) {
                groupB.push_back(employeeID);
                break;
            }
            else if (choice == 'C' && groupC.size() < maxC) {
                groupC.push_back(employeeID);
                break;
            }
        }
    }
    
    cout << groupA.size();
    for (const string& id : groupA) {
        cout << " " << id;
    }
    cout << "\n";
    
    cout << groupB.size();
    for (const string& id : groupB) {
        cout << " " << id;
    }
    cout << "\n";
    
    cout << groupC.size();
    for (const string& id : groupC) {
        cout << " " << id;
    }
    cout << "\n";
    
    return 0;
}

2. 战力极差的最小值

在《无主星渊》的竞技宇宙中，来自各个星系的顶尖战队齐聚一堂，准备迎战传说中的最终 BOSS。每个星系派出了最精锐的战队，共 n 支战队，每支战队有 m 名成员，每位成员的战力值分别为 $p_1, p_2, ..., p_m$。为了组成最强的终极挑战队，你需要从每支战队中各选 1 名成员（共 n 人），但团队配合至关重要。经过无数次模拟战斗，联盟科学家发现：战力越均衡的团队，越能激发协同共鸣。因此，选拔规则如下：在所有可能的组队方案中，选择战力极差（最大值 - 最小值）最小的方案，确保团队以最平衡的状态迎战 BOSS。

你的任务：计算所有可能的组队方案中，战力极差的最小值。

输入描述

第一行两个正整数 $n (0 < n ≤ 3000)$、$m (0 < m ≤ 100)$，分别表示队伍数量与每只战队中的成员数量。
之后 $n$ 行，每行输入 $m$ 个数字 $p_i (0 < p_i < 1e9)$，代表战队中成员的战力值。

输出描述

所有可能的组队方案中，战力极差的最小值

示例 1

输入：

1 1
1

输出：

示例 2

输入：

3 4
10 15 24 26
0 9 12 20
5 18 22 30

输出：

代码：滑动窗口

我们需要从 n 支战队中各选 1 名成员，组成一个 n 人团队。在所有可能的组队方案中，找到战力极差（最大值 - 最小值）最小的方案。

解题思路

暴力法不可行：直接枚举所有可能的组合（共 $m^n$ 种）显然不现实，因为 n 和 m 可能较大（n ≤ 3000，m ≤ 100）。
排序 + 滑动窗口：
- 将每支战队的成员战力值排序。
- 将所有战队的成员合并到一个列表，并记录每个成员所属的战队。
- 对这个合并后的列表按战力值排序。
- 使用滑动窗口，找到一个窗口，其中包含所有 n 支战队的至少一个成员，且窗口的极差最小。

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <unordered_map>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> teams(n, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> teams[i][j];
        }
        sort(teams[i].begin(), teams[i].end()); // 每支战队内部排序
    }

    // 合并所有成员，并记录所属战队
    vector<pair<int, int>> members; // (value, team_id)
    for (int i = 0; i < n; ++i) {
        for (int val : teams[i]) {
            members.emplace_back(val, i);
        }
    }
    // 按战力值排序
    sort(members.begin(), members.end());

    int left = 0;
    unordered_map<int, int> team_count;
    int min_diff = INT_MAX;

    for (int right = 0; right < members.size(); ++right) {
        int team = members[right].second;
        team_count[team]++;

        // 当窗口包含所有战队时，尝试移动left
        while (team_count.size() == n) {
            int current_diff = members[right].first - members[left].first;
            if (current_diff < min_diff) {
                min_diff = current_diff;
            }
            // 移动left
            int left_team = members[left].second;
            team_count[left_team]--;
            if (team_count[left_team] == 0) {
                team_count.erase(left_team);
            }
            left++;
        }
    }

    cout << min_diff << endl;
    return 0;
}

3. 金矿采集

在《无主星渊》的太空战场中，玩家需操控飞船从起点 (S) 出发，在 n×m 的网格中以最短时间采集所有的金矿。飞船每次仅能向上下左右四个方向移动一个网格，金矿可以以任何先后顺序被采集，飞船到达金矿后可以选择立即采集也可以选择路过。一共有 k 个金矿，金矿初始的矿产值为 Xi，当飞船采集到 a(0 ≤ a ≤ k) 个金矿后，每移动一步，所有未被采集的金矿都会减少 a 点矿产值，当金矿的矿产值减少到 1 的时候将不再减小。需要你帮玩家算一下，玩家最多可以采集到金矿的总价值。

网格包含以下元素：

#：不可穿越的障碍物
.：可自由航行的太空区域
1~5：表示 $k$ 个金矿的编号
S：飞船起点

输入描述

首行：n m k (1 ≤ n, m ≤ 50, 1≤ k ≤5)
后续 $n$ 行，每行 $m$ 个字符表示 $n*m$ 的网格的信息
最后一行是 $k$ 个整数，第 $i$ 个数表示编号为 $i$ (1 ≤ i ≤ k) 的金矿的初始矿产值 Xi (1 ≤ Xi ≤ 1000)

输出描述

玩家最多可以采集到的金矿总矿产值，数据保证所有金矿都可以到达

示例 1

输入：

5 7 3
S.....3
##.....
..##...
..1....
2..#...
10 20 30

输出：

示例 2

输入：

4 4 1
....
.##.
.##.
S##1
100

输出：

示例 3

输入：

5 7 3
S.....3
##.....
..##...
..1....
2..#...
40 1 1

输出：

代码：BFS + 全排列枚举

(1) 数据输入与预处理

读取网格地图，记录起点 S 和金矿的位置（保存到 positions 数组）。
金矿编号为 1 到 goldCount，起点编号为 0。

(2) BFS 计算最短路径

对每个金矿（包括起点）运行 BFS，计算到其他所有金矿的最短路径步数：
- 使用 distances[i][j] 表示从位置 i 到位置 j 的最短步数。
- 通过BFS遍历地图，跳过障碍物和边界。

(3) 全排列搜索最优顺序

生成所有金矿的排列顺序（1 到 goldCount的全排列）。
对每种顺序计算总得分：
1. 从起点（last = 0）出发。
2. 对于第 k 个金矿 order[k]：
  - 累加步数惩罚：minus += stepCount * k。
  - 计算当前金矿得分：max(initialValues[order[k]] - minus, 1)。
  - 更新当前位置 last。
3. 记录所有顺序中的最大得分 maxTotal。

#include <bits/stdc++.h>
using namespace std;

vector<string> grid;
int rows, cols, goldCount;
const int INF = 0x3f3f3f3f;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> rows >> cols >> goldCount;
    grid.resize(rows);
    for (auto& row : grid) {
        cin >> row;
    }
    
    vector<int> initialValues(goldCount + 1);
    for (int i = 1; i <= goldCount; ++i) {
        cin >> initialValues[i];
    }
    
    vector<pair<int, int>> positions(goldCount + 1, {-1, -1});
    pair<int, int> startPos;
    
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            if (grid[i][j] == 'S') {
                startPos = {i, j};
            }
            else if (isdigit(grid[i][j])) {
                int goldId = grid[i][j] - '0';
                positions[goldId] = {i, j};
            }
        }
    }
    
    auto bfs = [](int startX, int startY) {
        vector<vector<int>> dist(rows, vector<int>(cols, INF));
        queue<pair<int, int>> q;
        q.push({startX, startY});
        dist[startX][startY] = 0;
        
        vector<vector<int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        
        while (!q.empty()) {
            auto [x, y] = q.front();
            q.pop();
            
            for (auto& dir : directions) {
                int newX = x + dir[0];
                int newY = y + dir[1];
                
                if (newX < 0 || newX >= rows || newY < 0 || newY >= cols) {
                    continue;
                }
                if (grid[newX][newY] == '#' || dist[newX][newY] != INF) {
                    continue;
                }
                
                dist[newX][newY] = dist[x][y] + 1;
                q.push({newX, newY});
            }
        }
        return dist;
    };
    
    positions[0] = startPos;
    int totalPoints = goldCount + 1;
    vector<vector<int>> distances(totalPoints, vector<int>(totalPoints));
    
    for (int i = 0; i < totalPoints; ++i) {
        auto dist = bfs(positions[i].first, positions[i].second);
        for (int j = 0; j < totalPoints; ++j) {
            distances[i][j] = dist[positions[j].first][positions[j].second];
        }
    }
    
    vector<int> order(goldCount);
    iota(order.begin(), order.end(), 1);
    int maxTotal = 0;
    
    do {
        int minus = 0, total = 0, last = 0;
        for (int i = 0; i < goldCount; ++i) {
            int currentGold = order[i];
            int stepCount = distances[last][currentGold];
            minus += stepCount * i;
            total += max(initialValues[currentGold] - minus, 1);
            last = currentGold;
        }
        maxTotal = max(maxTotal, total);
    } while (next_permutation(order.begin(), order.end()));
    
    cout << maxTotal << endl;
    
    return 0;
}

4. 篮球游戏

你正在篮球场上与其他玩家玩一场游戏。你需要站在看台边，用推车接住从看台上扔下来的篮球。

篮球上标有不同的积分，你接到后就获得了对应的积分。但是其中有一部分玩家他们会扔其他种类的球，如果你不小心接到了这些球，你就需要停在原地 3 秒。期间你只能等待时间过去，或者正好有球进入车筐中。如果你在停止期间又接到了非篮球的球类，不论之前你的停止时间还剩多少，它都会重新刷新为 3 秒。

所有的球类都会在1 秒的时间里下落 1 格高度，而你也可以在 1s 时间里向左或者向右移动一格，或者不动。当车筐与球重合时，表示你接到了球，你可以在一个位置同时接到多个球。

一开始，你可以选择任意的位置，那么你怎么规划你的移动路线，能够使得接到的球总积分最高呢？

输入描述

第一行有两个整数 n (1 ≤ n ≤ 100)，m (1 ≤ m ≤ 1000)，n 表示可以接到的球以及人可以站立的横向长度，m 表示扔出的球的总数
接下来 m 行，每行四个整数 $v_i (0 ≤ v_i ≤ 1e5)，x_i (0 ≤ x_i < n)，y_i (0 < y_i ≤ 1000)，t_i (0 < t_i ≤ 1000)$，$v_i$ 表示球的积分，$x_i$ 表示物品的横向坐标，$y_i$ 表示物品的初始高度，$t_i$ 表示物品开始掉落的时间。当接收到 $v_i==0$ 的球时，会使你困在原地 3 秒，如果此时已经处于被困住的状态，则时间会重置为 3 秒

输出描述

一个整数，表示可以接到的球的最大总积分

示例 1

输入：

输出：

示例 2

输入：

10 1
0 3 2 1

输出：

代码：动态规划

这是一个动态规划问题，我们需要在时间和空间维度上规划接球路线，最大化获得的积分，同时处理"定身"状态的干扰。

时间处理：所有球的下落时间被预处理为 time_start + height，即球到达底部的时间。

状态表示：dp[pos][stun] 表示在位置 pos 且剩余定身时间为 stun 时的最大得分

定身状态有 4 种可能：0(无定身),1,2,3

状态转移：

无定身时：可以左移、右移或不动
有定身时：只能不动，定身时间减 1
接到非篮球 (v=0) 时：强制将定身时间设为 3

#include <bits/stdc++.h>
using namespace std;

constexpr int MAX_TIME = 2000;
constexpr long long NEG_INF = -(1LL << 60);

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int positions, events;
    cin >> positions >> events;

    // scores[time][pos]: 当前时刻和位置能获得的分数总和
    vector<vector<int>> scores(MAX_TIME + 1, vector<int>(positions, 0));
    // traps[time][pos]: 是否存在非篮球，触发定身
    vector<vector<bool>> traps(MAX_TIME + 1, vector<bool>(positions, false));

    for (int i = 0; i < events; ++i) {
        int value, pos, height, time_start;
        cin >> value >> pos >> height >> time_start;
        int landing_time = time_start + height;
        scores[landing_time][pos] += value;
        if (value == 0) {  // 非篮球触发定身
            traps[landing_time][pos] = true;
        }
    }

    // dp[pos][stun]: 最大得分，stun表示剩余定身秒数（0~3）
    vector<vector<long long>> dp(positions, vector<long long>(4, NEG_INF));
    // 初始状态：任何位置未定身，分数为0
    for (int i = 0; i < positions; ++i) {
        dp[i][0] = 0;
    }

    long long answer = 0;

    for (int time = 0; time <= MAX_TIME; ++time) {
        vector<vector<long long>> next_dp(positions, vector<long long>(4, NEG_INF));

        for (int pos = 0; pos < positions; ++pos) {
            for (int stun = 0; stun <= 3; ++stun) {
                long long curr_score = dp[pos][stun];
                if (curr_score == NEG_INF) continue;

                int new_stun = (stun == 0) ? 0 : stun - 1;

                // 如果没有被定身，可以移动
                if (stun == 0) {
                    if (pos > 0) {
                        next_dp[pos - 1][new_stun] = max(next_dp[pos - 1][new_stun], 
                                                        curr_score + scores[time][pos - 1]);
                    }
                    if (pos + 1 < positions) {
                        next_dp[pos + 1][new_stun] = max(next_dp[pos + 1][new_stun], 
                                                        curr_score + scores[time][pos + 1]);
                    }
                }
                // 原地等待
                next_dp[pos][new_stun] = max(next_dp[pos][new_stun], 
                                            curr_score + scores[time][pos]);
            }
        }

        // 处理定身刷新逻辑
        for (int pos = 0; pos < positions; ++pos) {
            // 更新答案
            for (int stun = 0; stun <= 3; ++stun) {
                if (next_dp[pos][stun] > answer) {
                    answer = next_dp[pos][stun];
                }
            }

            if (traps[time][pos]) {
                // 非篮球出现，所有未满3秒定身状态强制变成3秒定身
                long long max_stun3 = next_dp[pos][3];
                for (int stun = 0; stun < 3; ++stun) {
                    if (next_dp[pos][stun] != NEG_INF) {
                        max_stun3 = max(max_stun3, next_dp[pos][stun]);
                        next_dp[pos][stun] = NEG_INF;
                    }
                }
                next_dp[pos][3] = max_stun3;
                if (next_dp[pos][3] > answer) {
                    answer = next_dp[pos][3];
                }
            }
        }

        dp = move(next_dp);
    }

    cout << answer << "\n";

    return 0;
}

从一次 double free 深入理解 shared_ptr 的原理与最佳实践

Sat, 02 Aug 2025 00:00:00 GMT

笔者在排查一个 double free 问题时，重新回顾了 shared_ptr 的工作原理，以及列出一些注意事项，本文着重介绍 shared_ptr，其他智能指针不过多赘述。

`shared_ptr` 本质

shared_ptr 能够自动记录共享对象的引用次数，并且在引用计数降至 $0$ 时自动删除对象，从而防止内存泄漏。每个 shared_ptr 的拷贝都指向相同的内存，在最后一个 shared_ptr 析构的时候其指向的内存资源才会被释放。

本质上 shared_ptr 是有两层析构：

shared_ptr 本身析构会使得指向的共享对象的引用数 $-1$，当共享对象引用数为 $0$ 时，则调用共享对象本身的析构函数
这样就可以理解循环引用了：共享对象引用还是 $1$ 时，未调用共享对象本身的析构函数，其中成员 shared_ptr 的析构函数也不会被调用

shared_ptr 初始化方式：

构造函数
std::make_shared() 辅助函数
reset()

std::shared_ptr<int> p(new int(1));
std::shared_ptr<int> p2 = p;
std::shared_ptr<A> ap = std::make_shared<A>();

// 对于一个未初始化的智能指针，可以通过调用 reset 方法初始化
std::shared_ptr<int> ptr;
ptr.reset(new int(1));

不能将一个原始指针直接赋值给一个智能指针，如：std::shared_ptr<int> p = new int(1)。

对于一个未初始化的智能指针，可以通过调用 reset 方法初始化，当智能指针中有值的时候，调用 reset 方法会使引用计数减 $1$。当需要获取原指针的时候可以通过 get 方法返回原始指针：

std::shared_ptr<int> p(new int(1));
int *ptr = p.get();

智能指针初始化时也可以指定删除器，当其引用计数为 $0$ 时将自动调用删除器来释放对象，删除器可以是一个函数对象。

比如当使用 shared_ptr 管理动态数组时，需要指定删除器，因为 shared_ptr 默认删除器不支持数组对象：

// lambda 表达式作为删除器
std::shared_ptr<int> p(new int[10], [](int *p) { delete []p; })

`shared_ptr` 注意事项

关于 shared_ptr 的注意事项：

不要用一个裸指针初始化多个 shared_ptr，会出现 double_free 导致程序崩溃
通过 shared_from_this() 返回 this 指针，不要把 this 指针作为 shared_ptr 返回出来，因为 this 指针本质就是裸指针，通过 this 返回可能会导致重复析构，不能把 this 指针交给智能指针管理。
尽量使用 std::make_shared<T>()，少用 new
不要 delete get() 返回的裸指针
不是 new 出来的空间要自定义删除器
要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏（不在赘述）

1. 不要用一个裸指针初始化多个 `shared_ptr`（会导致 double free）

问题场景：

int* raw_ptr = new int(42);
std::shared_ptr<int> sp1(raw_ptr);
std::shared_ptr<int> sp2(raw_ptr);  // 危险！

两个独立的 shared_ptr 会各自维护一个引用计数控制块（相互独立）
当 sp1 和 sp2 销毁时都会尝试释放 raw_ptr，导致 双重释放（double free）
结果通常是程序崩溃或未定义行为

正确做法：

// 方法1：直接使用 make_shared
// make_shared 一次性分配内存，包含控制块（引用计数、弱引用计数等）；对象存储空间（存储实际值 42）
auto sp1 = std::make_shared<int>(42);
auto sp2 = sp1;  // 只是复制指针并增加引用计数，两个 shared_ptr 指向同一个控制块，共享所有权

// 方法2：如果必须从裸指针创建，确保只创建一次 shared_ptr
int* raw_ptr = new int(42);
std::shared_ptr<int> sp1(raw_ptr);
std::shared_ptr<int> sp2 = sp1;  // 复制的是控制块指针，不是重新创建控制块，共享同一个控制块

2. 正确使用 `shared_from_this()` 而不是直接返回 `this` 指针

问题场景：

class BadExample {
public:
    std::shared_ptr<BadExample> get_this() {
        return std::shared_ptr<BadExample>(this);  // 危险！
    }
};

auto obj = std::make_shared<BadExample>();
auto another_ref = obj->get_this();  // 创建了独立的控制块

这会创建两个独立的 shared_ptr 控制块
当两个 shared_ptr 销毁时都会尝试析构同一个对象

正确做法：

class GoodExample : public std::enable_shared_from_this<GoodExample> {
public:
    std::shared_ptr<GoodExample> get_this() {
        return shared_from_this();  // 安全
    }
};

auto obj = std::make_shared<GoodExample>();
auto another_ref = obj->get_this();  // 共享同一个控制块

3. 优先使用 `std::make_shared<T>()` 而不是 `new`

问题场景：

// 不推荐
std::shared_ptr<MyClass> sp(new MyClass(arg1, arg2));

// 推荐
auto sp = std::make_shared<MyClass>(arg1, arg2);

优势：

性能更好：单次内存分配（对象 + 控制块）
异常安全：不会在 new 和 shared_ptr 构造之间发生泄漏
代码更简洁：不需要重复类型名称
缓存友好：对象和控制块内存相邻

例外情况：

需要自定义删除器时
需要指定特殊的内存分配方式时

4. 不要 `delete` `get()` 返回的裸指针

问题场景：

auto sp = std::make_shared<int>(42);
int* raw_ptr = sp.get();
delete raw_ptr;  // 灾难性错误！

// 当 sp 超出作用域时，会再次尝试删除已删除的内存

shared_ptr 仍然拥有内存所有权
手动 delete 会导致：
- double free
- 控制块状态不一致
- 未定义行为（通常崩溃）

正确做法：

auto sp = std::make_shared<int>(42);
int* raw_ptr = sp.get();
// 仅使用 raw_ptr 进行读取/写入操作，绝不手动删除它

5. 非 `new` 分配的内存需要自定义删除器

问题场景：

// 从 malloc 分配的内存
void* mem = malloc(1024);
std::shared_ptr<void> sp(mem);  // 错误！会用 delete 而不是 free

// 文件指针
FILE* fp = fopen("file.txt", "r");
std::shared_ptr<FILE> sp(fp);  // 错误！会用 delete 而不是 fclose

正确做法：

// 使用自定义删除器（lambda 表达式作为删除器）
void* mem = malloc(1024);
std::shared_ptr<void> sp(mem, free);  // 使用 free 作为删除器

FILE* fp = fopen("file.txt", "r");
std::shared_ptr<FILE> sp(fp, [](FILE* f) { fclose(f); });

// 对于数组
int* arr = new int[10];
std::shared_ptr<int> sp(arr, [](int* p) { delete[] p; });

常见删除器场景：

C 风格内存分配（malloc/calloc/realloc）→ 使用 free
文件操作（fopen）→ 使用 fclose
系统资源（套接字、句柄等）→ 使用对应的释放函数
数组 → 使用 delete[]

6. 避免循环引用导致的内存泄露

问题场景 1

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> ap = std::make_shared<A>();
    std::shared_ptr<B> bp = std::make_shared<B>();
    ap->b = bp;
    bp->a = ap;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

问题场景 2

class Node {
public:
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;  // 双向链表导致循环引用
    ~Node() { std::cout << "Node destroyed\n"; }
};

auto node1 = std::make_shared<Node>();
auto node2 = std::make_shared<Node>();
node1->next = node2;
node2->prev = node1;  // 循环引用形成！

当 node1 和 node2 离开作用域时：
- node1 的引用计数从 1→0？不，因为 node2->prev 还持有引用（实际从 2→1）
- node2 的引用计数同样从 2→1
结果：两者引用计数永远不为 0，内存永远不会释放

node1 [refcount=2] --> Node1对象
  ↑next               ↓prev
Node2对象 <-- [refcount=2] node2

解决方案：weak_ptr

class SafeNode {
public:
    std::shared_ptr<SafeNode> next;
    std::weak_ptr<SafeNode> prev;  // 使用weak_ptr
    
    ~SafeNode() { std::cout << "SafeNode destroyed\n"; }
};

auto node1 = std::make_shared<SafeNode>();
auto node2 = std::make_shared<SafeNode>();
node1->next = node2;
node2->prev = node1;  // weak_ptr不会增加引用计数

何时会出现循环引用？

双向链表、树结构等复杂数据结构
对象相互持有对方的 shared_ptr
父子对象互相强引用
观察者模式中主体和观察者互相持有

手撕 `shared_ptr`｜面试高频场景题

1. 非线程安全的简单实现

#include <memory>

template<typename T>
class smartPtr {
private:
    T *_ptr;
    size_t* _count;

public:
    smartPtr(T *ptr = nullptr):_ptr(ptr) {
        if (_ptr) {
            _count = new size_t(1);
        } else {
            _count = new size_t(0);
        }
    }

    smartPtr(const smartPtr &ptr) {
        if (this != &ptr) {
            this->_ptr = ptr._ptr;
            this->_count = ptr._count;
            ++(*this->_count)   ;
        }
    }

    smartPtr& operator=(const smartPtr &ptr) {
        if (this->_ptr == ptr._ptr)
            return *this;

        if (this->_ptr) {
            --(*this->_count);
            if (this->_count == 0) {
                delete this->_ptr;
                delete this->_count;
            }
        }

        this->_ptr = ptr._ptr;
        this->_count = ptr._count;
        ++(*this->_count);

        return *this;
    }

    ~smartPtr() {
        --(*this->_count);
        if (0 == *this->_count) {
            delete this->_ptr;
            delete this->_count;
        }
    }

    size_t use_count() {
        return *this->_count;
    }

    T& operator*() {
        assert(this->_ptr == nullptr);
        return *(this->_ptr);
    }

    T* operator->() {
        assert(this->_ptr == nullptr);
        return this->_ptr;
    }
};

2. 基于原子操作的线程安全实现

#pragma once

#include <atomic>  // 引入原子操作

template <typename T>
class shared_ptr {
private:
  T* ptr;                               // 指向管理的对象
  std::atomic<std::size_t>* ref_count;  // 原子引用计数

  // 释放资源
  void release() {
    // P.S. 这里使用 std::memory_order_acq_rel 内存序，保证释放资源的同步
    if (ref_count && ref_count->fetch_sub(1, std::memory_order_acq_rel) == 1) {
      delete ptr;
      delete ref_count;
    }
  }

public:
  // 默认构造函数
  shared_ptr() : ptr(nullptr), ref_count(nullptr) {}

  // 构造函数
  // P.S. 这里使用 explicit 关键字，防止隐式类型转换
  // shared_ptr<int> ptr1 = new int(10);  不允许出现
  explicit shared_ptr(T* p) : ptr(p), ref_count(p ? new std::atomic<std::size_t>(1) : nullptr) {}

  // 析构函数
  ~shared_ptr() { release(); }

  // 拷贝构造函数
  shared_ptr(const shared_ptr<T>& other) : ptr(other.ptr), ref_count(other.ref_count) {
    if (ref_count) {
      ref_count->fetch_add(1, std::memory_order_relaxed);  // 引用计数增加，不需要强内存序
    }
  }

  // 拷贝赋值运算符
  shared_ptr<T>& operator=(const shared_ptr<T>& other) {
    if (this != &other) {
      release();  // 释放当前资源
      ptr = other.ptr;
      ref_count = other.ref_count;
      if (ref_count) {
        ref_count->fetch_add(1, std::memory_order_relaxed);  // 引用计数增加
      }
    }
    return *this;
  }

  // 移动构造函数
  // P.S. noexcept 关键字表示该函数不会抛出异常。
  // 标准库中的某些操作（如 std::swap）要求移动操作是 noexcept 的，以确保异常安全。
  // noexcept 可以帮助编译器生成更高效的代码，因为它不需要为异常处理生成额外的代码。
  shared_ptr(shared_ptr<T>&& other) noexcept : ptr(other.ptr), ref_count(other.ref_count) {
    other.ptr = nullptr;
    other.ref_count = nullptr;
  }

  // 移动赋值运算符
  shared_ptr<T>& operator=(shared_ptr<T>&& other) noexcept {
    if (this != &other) {
      release();  // 释放当前资源
      ptr = other.ptr;
      ref_count = other.ref_count;
      other.ptr = nullptr;
      other.ref_count = nullptr;
    }
    return *this;
  }

  // 解引用运算符
  // P.S. const 关键字表示该函数不会修改对象的状态。
  T& operator*() const { return *ptr; }

  // 箭头运算符
  T* operator->() const { return ptr; }

  // 获取引用计数
  std::size_t use_count() const { return ref_count ? ref_count->load(std::memory_order_acquire) : 0; }

  // 获取原始指针
  T* get() const { return ptr; }

  // 重置指针
  void reset(T* p = nullptr) {
    release();
    ptr = p;
    ref_count = p ? new std::atomic<std::size_t>(1) : nullptr;
  }
};

AI Infra 与 Infra

Fri, 01 Aug 2025 00:00:00 GMT

随着大模型技术的爆发，AI Infra 已成为基础设施领域的核心战场。过去 1 年多的时间，QQ 基础架构算法工程团队落地了多个大模型应用，包括语音合成大模型、内容理解多模态大模型、生成式推荐大模型，跑通大模型训练到推理的全链路。那 AI Infra 真的是和传统 Infra 差异很大的新体系吗，还是说它其实是过去 Infra 经验的演化？

本文将分享传统后台工程师积累的技术栈和方法论，如何延续并迁移到 AI 系统，并系统性拆解 AI Infra 的硬件、软件、训练和推理挑战。

硬件演进

经济基础决定上层建筑。软件层面的架构设计，无法脱离硬件约束。了解现代 AI 硬件特性非常有必要。

一台高性能的 GPU 服务器可以换一套深圳房子

从 CPU 为中心到 GPU 为中心

传统基础设施以 CPU 为核心，通过多线程和微服务构建分布式系统，处理高并发请求（如 Web 服务），这些都有成熟的方法论了（如“海量服务之道”），主要工作是逻辑事务的处理，瓶颈在网络 I/O 和 CPU 核心数量。发展到今天，硬件已经很少是制约 CPU 系统设计的瓶颈。

而 AI Infra 以 GPU 为核心，其设计目标从逻辑事务处理转向高吞吐浮点计算。

此时 CPU 多线程被 GPU 并行计算替代，内存被显存替代。

如下图所示，H20 单卡 96GB 显存，可以提供 44TFLOPS 的单精度浮点运算，算力和访存带宽是主流 CPU 数十倍甚至数百倍。每台机器安装 8 卡 = 768GB 显存，另外还有 CPU 192 核 384 线程 + 2.3 TB 内存。

GPU 成为核心是因为 LLM 大模型每次生成一个 token，都需要读取全量的模型参数。传统的【CPU + 内存】的算力和带宽无法满足如此恐怖的计算密度，计算和通信都必须转移（offload）到 GPU 内完成。

CPU 成为数据搬运工和“辅助处理器”。

为了更直观地理解这个计算密度，做一个简单的计算。不考虑计算的延时，LLM 大模型生成一个 token 的耗时公式计算为：

$$ 计算耗时=\frac{模型参数量*数据精度}{显存带宽} $$

以 DeepSeek-R1-671B-A37B-FP8 模型为例，计算一个 token 耗时：

H20：37B × 1byte ÷ 4000GB/s = 9 ms
CPU：37B × 1byte ÷ 64GB/s = 578 ms

从“去 IOE”到“AI 大型机”

显而易见，我们的现在身处新的一轮烈火烹油的硬件革命的历史进程中，各种专用硬件、专用网络层出不穷。DeepSeek-R1 和 QWen3-235B 千亿级参数训练需千卡 GPU 集群协同，通过专用网络互联构建“AI 超算”，其设计逻辑与以前的 IBM 大型机惊人相似——以硬件集中化换取极致性能与可靠性。

IBM 大型机

传统 Infra 的分布式理念貌似在 AI 时代失效了？

传统 Infra 追求横向扩展，而 AI Infra 呈现“AI 大型机”特性，是因为传统后台服务的可以容忍毫秒级延迟，但 AI 集群不行，GPU 的算力是 CPU 的数百倍，微秒级的延时等待也会造成很大的算力损耗，需要硬件的高度集成。在可预见的 1-3 年的未来，这样的专用硬件 + 网络的集中式架构很难发生比较大的改变。

回顾历史，我们总是在寻求科技平权。前人推动“去 IOE”（IBM 小型机、Oracle 数据库、EMC 存储），用分布式廉价 x86 PC 机替代集中式高端硬件，本质上是利用软件创新重构一个高可用 + 低成本的互联网基础设施。"AI 大型机"是技术发展必由之路，但不是终极形态。长期（5 年）来看，必然会出现 "AI 去 NVIDIA 化"，重演“去 IOE”的历史。

软件演进

说完硬件体系的革命，接下来再关注下软件层面的变化。

相比传统后台应用的增删查改，AI 应用的新范式是模型训练和推理

模型训练：通过海量数据拟合出一个复杂的神经网络模型
模型推理：利用训练好的神经网络模型进行运算，输入的新数据来获得新的结论

举个例子，训练就是根据 <年龄, 身高> 的分布使用最小二乘法拟合模型 y = ax + b，推理就是利用这个模型 y = ax + b，输入一个新的年龄，预测身高。

深度学习框架

工欲善其事，必先利其器

传统后台应用依赖 tRPC 或 Spring 等微服务框架，帮助我们屏蔽负载均衡、网络通信等底层细节，我们可以把精力放在业务实现上。

与之相似，AI 应用则依赖深度学习框架。如果没有深度学习框架，我们就可能陷入在茫茫的数学深渊中，挣扎于痛苦的 GPU 编程泥潭里。有了深度学习框架，我们才可以把所有精力花在设计模型和创新本身上，而不用关注底层的实现细节，极大降低了 AI 应用的门槛。

大家可能听说过不同的深度学习框架——Tensorflow，PyTorch。现在是 2025 年，不用纠结选哪个，因为 PyTorch 就是 AI 模型训练、推理的深度学习框架的事实标准，开源模型和代码都是 PyTorch 一边倒。

得益于动态计算图、自动微分和丰富的 Tensor 操作算子，PyTorch 能帮助我们快速实现模型设计。如下图所示，只需要描述模型结构 + 待学习的网络参数，不需要关心数学计算和 GPU 编程的细节。

GPU 编程

绝大部分的 AI 应用，的确不需要我们手写数学计算的 GPU 代码。但为了满足模型创新的需求，有必要学习 GPU 编程。

例如 Meta 发布的 HSTU 生成式推荐模型，核心的 hstu_attn 计算：

如果直接用 PyTorch 框架算子组合实现，则时间复杂度为 $O(M * N^2)$ ，其中 $M$ 和 $N$ 是一个数量级，相当于 $O(N^3)$
但是通过自定义内核，可以优化到 $O(N^2)$

在 GPU 核心上运行的代码片段称为内核。编写高性能的 CUDA 内核需要丰富的经验，并且学习曲线陡峭。

如何理解 SIMD 和 SIMT

因为我们习惯于传统 CPU 编程处理串行的计算任务（即 SIMD, Single Instruction Multiple Data），通过多线程提高并发度。而 GPU 采用 SIMT (Single Instruction Multiple Thread) 架构，有大量计算单元（CUDA Cores）和数万个线程，但是被分组后的线程同一时刻只能执行相同的指令。这与传统 CPU 的串行思维、不同线程处理不同任务，存在根本性冲突，导致 GPU 编程学习难度大。

现实生活中的 SIMT 架构

现在推荐使用 Triton 编程语言完成 GPU kernel 的开发，它提供类似 Python 的语法，无需深入理解 GPU 硬件细节（如线程调度、共享内存管理），而且和 PyTorch 深度学习框架的生态结合更好。推荐这个 Triton-Puzzles-Lite 项目用作 Triton 的入门学习。

Python 编程

正如客户端开发离不开 Kotlin/Objective-C，AI Infra 编程的第一公民就是 Python。

PyTorch 深度学习框架的设计哲学强调 Python 优先。

以前大部分模型还可以轻松导出 ONNX、TorchScript 等用 C++ 部署，现在随着对模型的细粒度优化和控制越来越多，比如 KV Cache、MoE/模型并行、复杂的 if/for 控制流、自定义 Triton 算子等，模型越来越难以脱离 Python 的控制部署。

模型训练 de 挑战

我们一直追求更大的模型，DeepSeek-R1 有数千亿参数，使用了数十万亿 token 的训练数据，涉及算力、存储、通信等多维度的工程挑战。有了 PyTorch 深度学习框架，只是 AI 应用落地的万里长征第一步。接下来我们将讨论深度学习框架之上的模型训练的挑战。

存得下

DeepSeek-R1 模型大小为 670GB，而一台 GPU 服务器有 8 张 H20 卡，提供 768GB 显存，足够存下一个完整的 DeepSeek 模型。那整个行业为什么还投入大量的人力物力，顶着通信延时造成的算力损耗，也要建设分布式 GPU 集群？

核心原因是单台 GPU 服务器“存不下”。

显存刺客：中间激活

如下图所示的模型，x1/x2/x3/x4 这些中间变量就是“中间激活”。它们是神经网络前向传播的“堆栈帧”—— 记录每一层处理后的数据快照，确保反向传播可回溯梯度，根据预测误差调整模型权重，最小化损失函数。

这些中间激活为什么会成为“显存刺客”？是因为中间激活的空间复杂度是和输入数据长度正相关的，特别的，对于 LLM 来说是 $O(N^2)$，正比于输入数据长度的平方，这是一个指数爆炸式增长的数字。类似函数递归不断增长的“堆栈帧”导致的内存溢出，我们遇到了 AI Infra 的 OOM（Out of Memory）挑战。

借助 PyTorch 的 profiler 工具，我们可以直观地看到这个 OOM。下图是训练过程中不同阶段的显存分配，包括：

模型参数（Parameter）
优化器状态（Optimizer State）
中间激活（Activation）
梯度（Gradient）

在前向传播结束后出现一个显存占用（中间激活）的尖峰，远大于模型参数本身。

模型并行

传统后台服务使用分片（Sharding）策略解决单机存不下的问题。与之相似，AI Infra 提出“模型并行”，就是将单个大模型拆分为多个子模块，并分布到不同 GPU 上协同工作，通过通信来共享数据。有不同的“拆分模型”策略，例如按模型模块划分，按张量（Tensor）划分的，也可以将多种拆分方法结合起来一起使用。PyTorch 深度学习框架和开源方案 Megatron 都能帮助我们高效地实现模型并行。

不同的模型并行策略

算得快

建设分布式 GPU 集群的原因，一个是因为“单机存不下”，另外一个是提升训练速度。但简单的机器堆叠，算力不一定有线性的增长。因为分布式训练并不是简单地把原来一个 GPU 做的事情分给多个 GPU 各自做。需要协调多个 GPU 机器计算任务分配，GPU 机器之间的数据传输会引入网络 I/O 和通信开销，降低训练速度。

通信计算重叠

如下图所示的常规训练时序是串联式的，存在许多网络 I/O，GPU 利用率低，训练速度慢。我们希望 GPU 大部分时间都在计算，而不是花在数据传输或等待其他 GPU 的工作上。

传统后台服务我们通过多线程或异步 I/O 避免阻塞 CPU 主线程。与之相似，AI Infra 提出通信计算重叠的方法论。

GPU 编程模型中有流（stream）的概念，一个流表示一个 GPU 操作队列，该队列中的操作将以添加到流中的先后顺序而依次执行。不同流之间可以并行执行，那么通过令计算和通信操作加入不同的流中，可以做到二者的执行在时间上重叠。例如 TorchRec 的训练流水线能帮助我们实现高效的通信计算重叠。

模型推理 de 挑战

AI 模型训练成本很高，优秀如 DeepSeek 也要烧掉 500 万美金，但再贵也只是一劳永逸的。而模型推理的成本更高，因为用户越多，AI 模型推理次数越多，总成本越高。AI Infra 模型推理面对的挑战和传统 Infra 非常相似，主要是 2 个挑战：

高吞吐（降本）
低延时（增效）

降低延时

现在的 AI 模型越来越多地直面终端用户，需要和用户进行实时的交互，例如文本对话和语音合成。模型推理耗时过高，会直接造成用户体验受损，用户流失与转化率下降。

传统后台服务我们使用链接复用、缓存、柔性等技术降低系统响应时间。AI Infra 也有相似的做法。

CUDA Graph

在 GPU 编程模型中，CPU 和 GPU 是异构的，CPU 通过 API（例如 CUDA API）向 GPU 提交任务，然后异步等待 GPU 的计算结果返回。GPU 收到任务后，会执行内核启动、内存拷贝、计算等操作。这个过程中，涉及到 CPU 与 GPU 之间的通信、驱动程序的处理以及 GPU 任务的调度等环节，会产生一定的延迟。

CPU 与 GPU 通信

模型推理需要执行大量重复的 GPU 操作，每个的 GPU 操作都要重复执行上述环节，这些非核心的 GPU 开销会成倍数地放大，影响最终响应时间。

在传统后台服务，我们使用 Redis 的 Lua 脚本封装多个 Redis 操作和计算逻辑，一次提交，减少网络开销。与之相似，AI Infra 利用 CUDA Graph 技术将多个 GPU 操作转化为一个有向无环图（DAG），然后一次性提交整个 DAG 提交到 GPU 执行，由 GPU 自身来管理这些操作的依赖关系和执行顺序，从而减少 CPU 与 GPU 之间的交互开销。

多个 GPU 内核启动转化为 CUDA Graph

KV Cache —— 空间换时间

LLM 大模型推理存在大量矩阵乘法运算，且高度依赖上下文信息。每次推理都需要将之前生成过的词重新输入模型进行计算（即上下文）。这种计算方式使得复杂度达到了 $O(N^2)$，其中必然存在大量的重复计算。

例如，给定“天气”，模型会逐个预测剩下的字，假设接下来预测的两个字为“真好。

将“真”拼接到“天气”的后面，即新的输入为“天气真”，再预测“好”。

KV Cache 的部分

观察到，经过多次预测后，X @ W_K 和 X @ W_V 的结果上半部分都是相同的，这是由于 LLM 模型结构的特殊设计导致的。这些重复计算的结果可以缓存（即 KV Cache）下来，空间换时间，减少计算量。几乎所有的 LLM 推理框架都支持了 KV Cache，例如 vLLM 。

流式响应

有时候模型推理延时实在避免不了，可以从工程交互上想办法。

传统后台服务的 RPC 通信是一问一答方式，这种方式不太适合语音合成或者文本对话的场景。因为大模型推理需要几秒～几十秒，如果等待模型推理结束才展示结果，用户会等待较长的时间，体验很差。

流式响应就是当模型推理计算得到第一个 token 或者第一个音频帧的时候，立马展示或者播放给用户，同时后续的模型推理结果在已经建立的 TCP 流上继续顺序传输。工程上从关注模型推理的整体耗时，改为关注首 token 或首个音频帧的耗时。几乎所有的 LLM 推理框架都支持了流式响应。

提高吞吐量

提高吞吐量是程序员在传统 Infra 领域孜孜不倦的追求，因为更高的吞吐量意味着更低的机器成本。实现 AI 应用的高吞吐本质上就是提高昂贵的 GPU 的利用率，让 GPU 单位时间能完成更多的任务。

尽管模型推理需要执行万亿次浮点运算，但 GPU 有大量的计算单元（CUDA Cores），单个请求的模型推理很难令 GPU 利用率达到饱和。

提高 GPU 利用率有 2 个方法：传统批处理和连续批处理。这里的“传统批处理”是相对于“连续批处理”这样的新型批处理方式而言的。

传统批处理

其实传统后台服务也大量使用了批处理，例如 Redis 的 MGet 命令，单次请求就完成所有 key 的获取，将 N 次网络往返（RTT）压缩为1次。
与之相似，模型推理的批处理就是将多个输入样本打包（batch），将原本串行的 N 次轻量的推理计算，合并为 1 次重量的计算，实现单位时间内处理更多的请求，提高了 GPU 利用率。

“打包输入样本”是一个共性需求，大部分推理框架都提供该功能，例如 Triton Inference Server 的 Batcher.

模型批量推理流程图

连续批处理

传统批处理类似“固定班次的公交车”：乘客（请求）必须等待发车时间（组建一个 batch），发车后所有乘客同步前进。即使有乘客提前下车（短请求完成），车辆仍需等待所有乘客到达终点（长请求完成）才能返程接新乘客。传统批处理存在着资源浪费：GPU 要等待长请求处理完，不能处理新的请求而空闲。

这个问题在 LLM 应用领域显得特别突出，因为不同用户请求 Prompt，模型的回答结果长度差异巨大，如果使用传统批处理，GPU 空闲率很高。这个本质上是个任务调度问题，传统后台服务我们使用工作窃取算法（Work Stealing）解决线程空闲问题，与之相似，AI Infra 提出“连续批处理”解决这个问题。

连续批处理类似“随时随地拼车的顺风车”，每辆车（GPU）在行程中可随时上/下客：

新乘客（请求）直接加入当前车辆的空位（空闲计算单元）
已完成的乘客立即下车（释放资源）

几乎所有的 LLM 推理框架都支持了连续批处理能力，例如 vLLM 的 Continuous Batching.

连续批推理流程图

AI Infra vs. Infra

AI Infra 入门教程：https://github.com/stas00/ml-engineering/

关于传统 Infra 和 AI Infra 的差异，总的来说就是觉得这套东西和传统 Infra 差太远了。很多熟悉网络，计算，存储等传统 infra 的工程师，会觉得自己原来的经验在 AI 场景里难以直接利用，尤其是看到 GPU，KV Cache，3D parallelism 这些新概念时，容易产生一种感觉完全换了一套体系的落差感。

我个人感觉这些看法其实挺有代表性的，反映出很多工程师对 AI Infra 的第一印象：陌生，高门槛，甚至有些割裂感。下文就想聊聊我的一些粗浅的理解。AI Infra 真的是和传统 Infra 差异很大的新体系吗，还是说它其实是过去 Infra 经验的演化？

传统 Infra 与 AI Infra 概念

✅ 我的答案是：差异其实不大。AI Infra 是对传统 Infra 在新场景下的重构与延展。AI Infra 面对的工程挑战，例如计算、存储、通信，大部分是新时代的老问题，我们在传统 Infra 领域都能找到对应的场景和解决思路。差异只在于战场从 CPU 转移到 GPU，传统后台工程师积累的方法论，依然可以衔接到 AI Infra。

🌟 如果从表面看起来，传统 Infra 和 AI Infra 确实很不一样：

设计目标从逻辑事务处理转向高吞吐浮点计算
- 传统 Infra 处理的是 web request，数据存储，和分布式服务协调
- 而 AI Infra（特别是大模型）更多围绕的是 GPU 推理，KV Cache 管理，以及大模型训练框架等全新领域
请求形态也不一样
- web request 通常是毫秒级的 request，stateless
- 而 LLM 推理一个 session 往往持续数秒甚至更久（随着 context window 和模型大小增加），还要动态维护 token-level 的上下文状态
tech stack 看起来也不同
- 传统用的是 Kubernetes + Docker
- 现在大家在用 GPU, vLLM, DeepSpeed, FlashAttention, Triton, NCCL 这些仅仅从名字上听起来就很高大上的架构

从这点来看，说传统经验无法直接迁移确实没错，但这只是表面的现象，不是本质。

🔥 本质其实没变，仍然是系统设计和资源调度的问题

回到工程本身，其实我们仍然在面对和传统 Infra 极其类似的问题：

如何调度资源（从 CPU/内存 变成了 GPU 显存）
如何处理高并发请求（从 http resource request ，变成了 prompt request）

我们来看一组对比：

| 传统 Infra 概念 | AI Infra 相对应概念 | | --------------- | ------------------------- | | Data Sharding | Data Parallelism | | Load Balancer | MoE Router | | OS Paging | vLLM 的 KV Cache 分页机制 |

MoE Router：将 token 分发给多个 expert network，保证某一些 expert 不会overload（Deepseek，llama-4 使用的架构）

这些机制其实都是传统 Infra 思维方式在 AI 场景中的利用。

🌰 拿 vLLM 举个例子：它像是给 LLM 写了一个操作系统，用来调度页面（KV Cache），管理进程（Request），本质上是引用了 OS 的内存管理 Principles 用来管理 KV Cache。

Infra 的“三大难题”：Scaling & Sharding & Copying

所有系统的底层挑战，基本都绕不开这三个关键词：

Scaling（扩展）：系统如何支持更大的规模和更高的并发？
- 在传统 Infra 中，这意味着如何横向扩展服务器，部署更多容器，使用负载均衡（load balancing）来分散请求
- 在 AI Infra 中，这些问题转化为如何通过数据并行，模型并行，流水线并行来分布和执行 GPU workload，以支持超大模型的训练以及 large number of inference requests
Sharding（切片）：系统如何切分状态和计算，以实现并行处理？
- 在数据库系统中，这是将数据按照主键或范围切分到不同的分区，以支持高吞吐访问
- 在 AI Infra 中，sharding 变成了对模型参数，KV Cache，activation，gradients，以及 optimizer states 的 split，比如 tensor parallelism 和 KV Paging 等，是实现分布式推理和训练的前提
Copying（复制）：系统如何高效同步数据或状态？
- 传统系统中，复制体现在数据库副本同步或者缓存预热，以及 Kafka Replication
- 在 AI Infra 中，复制的代价更加显著，比如 data parallelism 怎么 copy model to different GPUs（所以会有 ZeRO optimization 来 shard 参数，gradient 等等），通常需要依赖高性能通信机制（比如 RDMA 和 NCCL）

这些挑战的本质没有变：仍然是如何高效并且低成本地协调跨不同机器的资源。但在 AI Infra 中，由于 GPU 显存 limited，large context window，以及模型参数量大，它们变得更加脆弱和重要，也更需要更好的工程策略去解决这些问题。

The Core of Infra: Cost Estimation and Identifying Key Issues after Deployment (from Jeff Dean)

Google 的 Jeff Dean 曾整理出一份广为流传的延迟参考 Key Numbers Every Programmer Should Know。这些数据强调：在设计基础设施时，需要通过 estimate latency 来部署基础 system。

深入理解这些延迟数据，能让你在系统设计时更加 aware 真正的 bottleneck 是什么，这样也能在部署后迅速找到性能 bottleneck，然后及时修复。

延迟参考值

| 操作 | 延迟范围 | | ----------------------- | -------- | | L1 缓存访问 | ~0.5 ns | | L2 缓存访问 | ~7 ns | | 主内存访问 | ~100 ns | | 压缩 1 KB（Snappy） | ~3 µs | | 通过 1 Gbps 网络发 1 KB | ~10 µs | | SSD 随机读 4 KB | ~150 µs | | 数据中心内往返延迟 | ~0.5 ms | | 顺序读取 1 MB SSD 数据 | ~1 ms | | 磁盘 seek | ~10 ms | | 读取 1 MB 磁盘数据 | ~20 ms | | 跨洋网络延迟 | ~150 ms |

这些数值会随硬件不同而略有不同，但是相对的数量级非常值得记住，这是做系统设计时最基本的参考。

在 AI Infra 中的 mapping

Token-level KV Cache：GPU 全局显存访问
多个 GPU 通信：通过 NCCL/RDMA 进行同步
跨机（cross server）通信：比如在多个 server 之间调度推理任务

为什么会估算很重要？

就像在基础数据结构与算法课程中，我们必须熟练掌握各种数据结构以及算法的时间与空间复杂度，如：

哈希查找 Average Time Complexity 是 $O(1)$
快排是 $O(nlogn)$

在数据库系统中，需要算 disk I/O 次数以及 index cost estimate。或者像以上的这些延迟参考值，应该是每一位做传统 infra 都应该牢牢记住并且经常会用到的。

🕙 在 AI Infra，我们也同样也需要估算大致**延迟（Latency）与带宽（Bandwidth）**方面的数字，以便：

事前估算：训练一个模型需要多少时间，推理吞吐量，token latency 都应基于这些 latency numbers 进行初步估计
事后诊断：部署之后，如果性能不是很好，理解这些延迟能帮助你快速定位瓶颈究竟在哪里（是 communication，memory bandwidth，or compute bound？）
案例参考：据说 Meta 在训练 LLaMA 系列模型时，GPU 报错或任务失败每几十分钟就会发生一次。因此，高质量的 log, error tracing 和 profiling 工具，对 LLM training Infra 稳定性至关重要。

🔥 非常推荐大家看一下李博杰的这篇博客（4090 适合做 training or inference 吗？）。这篇博客通过数据/模型大小以及 gpu compute/memory/通讯层面，讲解了为什么 4090 不适合用于 training，但适合用于 inference。

🔥 真正有经验的 Infra 工程师，不仅仅是能搭件一个 working 的系统，而是有能力去从头到尾追踪每一个延迟点，把系统之间的关联和可能存在的 bottleneck 拆解成一系列可量化的问题，并在上线后持续做 cost/performance profiling。这正是 AI Infra （或者传统 Infra）对工程基本功要求极高的原因。

结语

感觉现在有很多讨论 AI Infra，并且有点把它过度“神化”了。

是的，LLM 的发展带来了新形态，新需求，和新的资源瓶颈（主要是 GPU memory 和 communication bottleneck，GPU 本身设计就是算力非常强，因为有非常多的 cores）。但是，解决这些问题的工程本质从来没有变：系统的目标仍然是优化资源利用（降低成本），保障 service 的稳定性，提升吞吐量以及响应能力。

而这些问题，在传统 Infra 中我们已经解决过很多次了。只不过这次，我们需要重新设计整个框架，让它在 GPU 上，高并发 LLM 请求下，仍然能够跑得快，跑得稳。

AI Infra 的门槛确实高，但是它的高门槛不在于你熟不熟悉神经网络，而在于你能不能把已有的工程能力（system design thinking and implementation skills）转化为新的问题的视角。

如果你做过网络通信：你会发现 NCCL 的 ring topology 其实跟设计高性能集群异构调度非常像
如果你知道缓存以及 OS Paging，你会非常快地理解 KV Cache 的重要性以及管理思路
如果你写过服务调度器，那 dynamic batching 会让你产生一种这是流水线并发的熟悉感

我越来越觉得，AI Infra 是对传统 Infra 知识体系的一种融合以及拓展，是一些旧的问题在新的范式中的 rephrasing；真正有竞争力的 AI Infra 工程师，不是只懂如何调个 prompt 或者跑个 inference/finetuning，而是能把底层系统逻辑与模型特性融合起来的人

这种 shift of thinking 并不容易，但如果你愿意去搭建起传统 Infra → AI infra 的 mental map，会发现很多传统经验看起来和 AI 毫不相干的东西，其实都有非常相似的部分（俗话说，换汤不换药）。

所以，传统 Infra 的经验/思维同样适用于 AI Infra，它们两之间有很多关联。

堆（优先队列）

Sun, 20 Jul 2025 00:00:00 GMT

✅ 优先队列 `priority_queue`

更多关于优先队列的知识，请跳转至：https://en.oi-wiki.org/lang/pb-ds/pq/

大顶堆：priority_queue<int> pq
小顶堆：priority_queue<int, vector<int>, greater<>> pq

相关例题：

1046. 最后一块石头的重量
347. 前 K 个高频元素
🔥239. 滑动窗口最大值（还可以手动构造一个单调队列，使用 deque 数据结构）
🔥295. 数据流的中位数
🔥480. 滑动窗口中位数

`__gnu_pbds :: priority_queue`

附：官方文档地址——复杂度及常数测试

#include <ext/pb_ds/priority_queue.hpp>
using namespace __gnu_pbds;
__gnu_pbds ::priority_queue<T, Compare, Tag, Allocator>

模板形参：

T : 储存的元素类型
Compare : 提供严格的弱序比较类型
Tag 是 __gnu_pbds 提供的不同的五种堆，Tag 参数默认是 pairing_heap_tag，这五种分别是：
- pairing_heap_tag ：配对堆，官方文档认为在非原生元素（如自定义结构体/ std :: string / pair ) 中，配对堆表现最好
- binary_heap_tag ：二叉堆，官方文档认为在原生元素中二叉堆表现最好，不过我测试的表现并没有那么好
- binomial_heap_tag ：二项堆，二项堆在合并操作的表现要优于配对堆*但是其取堆顶元素的
- rc_binomial_heap_tag ：冗余计数二项堆
- thin_heap_tag ：除了合并的复杂度都和 Fibonacci 堆一样的一个 tag
Allocator ：空间配置器，由于 OI 中很少出现，故这里不做讲解

由于本篇文章只是提供给学习算法竞赛的同学们，故对于后四个 tag 只会简单的介绍复杂度，第一个会介绍成员函数和使用方法。

经作者本机测试堆的基础操作，结合 GNU 官方的复杂度测试，Dijkstra 测试，都表明：至少对于 OIer 来讲，除了配对堆（即默认 tag）的其他四个 tag 都是鸡肋，要么没用，要么常数大到不如 std 的，且有可能造成 MLE，故这里只推荐用默认的配对堆。同样，配对堆也优于 algorithm 库中的 make_heap() 。

构造方式

要注明命名空间因为和 std 的类名称重复。

__gnu_pbds ::priority_queue<int> __gnu_pbds::priority_queue<int, greater<int> >
__gnu_pbds ::priority_queue<int, greater<int>, pairing_heap_tag>
__gnu_pbds ::priority_queue<int>::point_iterator id; // 迭代器
// 在 modify 和 push 的时候都会返回一个 point_iterator，下文会详细的讲使用方法
id = q.push(1);

成员函数

push() : 向堆中压入一个元素，返回该元素位置的迭代器。
pop() : 将堆顶元素弹出。
top() : 返回堆顶元素。
size() 返回元素个数。
empty() 返回是否非空。
modify(point_iterator, const key) : 把迭代器位置的 key 修改为传入的 key ，并对底层储存结构进行排序。
erase(point_iterator) : 把迭代器位置的键值从堆中擦除。
join(__gnu_pbds :: priority_queue &other) : 把 other 合并到 *this 并把 other 清空。

时间复杂度

使用的 tag 决定了每个操作的时间复杂度：

239. 滑动窗口最大值

返回滑动窗口中的最大值。

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        // entry: <val, idx (whether_expired)>
        priority_queue<pair<int, int>, vector<pair<int, int>>, less<>> pq;
        for (int i = 0; i < k; i++) {
            pq.emplace(nums[i], i);
        }
        vector<int> ans{pq.top().first};
        for (int i = k; i < nums.size(); i++) {
            pq.emplace(nums[i], i);
            while (pq.top().second <= i - k) {
                pq.pop();
            }
            ans.push_back(pq.top().first);
        }
        return ans;
    }
};

295. 数据流的中位数

中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

例如 arr = [2,3,4] 的中位数是 3 。
例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。

实现 MedianFinder 类:

MedianFinder() 初始化 MedianFinder 对象。
void addNum(int num) 将数据流中的整数 num 添加到数据结构中。
double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]

解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

class MedianFinder {
private:
    priority_queue<int> left;                          // 大顶堆
    priority_queue<int, vector<int>, greater<>> right; // 小顶堆

public:
    MedianFinder() {}

    void addNum(int num) {
        // 分类讨论, 并且合并为最终两种情况
        if (left.size() == right.size()) {
            right.push(num);
            left.push(right.top());
            right.pop();
        } else {
            left.push(num);
            right.push(left.top());
            left.pop();
        }
    }

    double findMedian() {
        return (left.size() + right.size()) % 2
                   ? left.top()
                   : static_cast<double>(left.top() + right.top()) / 2;
    }
};

480. 滑动窗口中位数

中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。

例如：

[2,3,4]，中位数是 3
[2,3]，中位数是 (2 + 3) / 2 = 2.5

给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。

给出 nums = [1,3,-1,-3,5,3,6,7]，以及 k = 3。

窗口位置                      中位数
---------------               -----
[1  3  -1] -3  5  3  6  7       1
 1 [3  -1  -3] 5  3  6  7      -1
 1  3 [-1  -3  5] 3  6  7      -1
 1  3  -1 [-3  5  3] 6  7       3
 1  3  -1  -3 [5  3  6] 7       5
 1  3  -1  -3  5 [3  6  7]      6

因此，返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。

1️⃣ 哈希表 + 逻辑删除

class Solution {
public:
    priority_queue<int> left;                          // 滑动窗口中左半部分
    priority_queue<int, vector<int>, greater<>> right; // 滑动窗口中右半部分
    unordered_map<int, int> mp;                        // 用于逻辑删除

    double get(int k) {
        if (k % 2)
            return left.top();
        else
            return ((long long)left.top() + right.top()) / 2.0;
    }

    vector<double> medianSlidingWindow(vector<int>& nums, int k) {
        for (int i = 0; i < k; i++) {
            int x = nums[i];
            if (left.size() == right.size()) {
                right.push(x);
                left.push(right.top());
                right.pop();
            } else {
                left.push(x);
                right.push(left.top());
                left.pop();
            }
        }
        vector<double> ans{get(k)};

        for (int i = k; i < nums.size(); i++) {
            int balance = 0; // right.size() - left.size()

            // [fake] delete
            int l_num = nums[i - k];
            mp[l_num]++;
            if (!left.empty() && l_num <= left.top()) {
                balance++;
            } else {
                balance--;
            }

            // add
            if (!left.empty() && nums[i] <= left.top()) {
                left.push(nums[i]);
                balance--;
            } else {
                right.push(nums[i]);
                balance++;
            }

            // adjust
            if (balance > 0) {
                left.push(right.top());
                right.pop();
            } else if (balance < 0) {
                right.push(left.top());
                left.pop();
            }

            // delete
            while (!left.empty() && mp[left.top()] > 0) {
                mp[left.top()]--;
                left.pop();
            }
            while (!right.empty() && mp[right.top()] > 0) {
                mp[right.top()]--;
                right.pop();
            }

            ans.push_back(get(k));
        }
        return ans;
    }
}

2️⃣ 懒删除堆

本题等价于：295. 数据流的中位数 + 懒删除堆

template<typename T, typename Compare = less<T>>
class LazyHeap {
    priority_queue<T, vector<T>, Compare> pq;
    unordered_map<T, int> remove_cnt; // 每个元素剩余需要删除的次数
    size_t sz = 0; // 实际大小

    // 正式执行删除操作
    void apply_remove() {
        while (!pq.empty() && remove_cnt[pq.top()] > 0) {
            remove_cnt[pq.top()]--;
            pq.pop();
        }
    }

public:
    size_t size() {
        return sz;
    }

    // 删除
    void remove(T x) {
        remove_cnt[x]++; // 懒删除
        sz--;
    }

    // 查看堆顶
    T top() {
        apply_remove();
        return pq.top();
    }

    // 出堆
    T pop() {
        apply_remove();
        sz--;
        T x = pq.top();
        pq.pop();
        return x;
    }

    // 入堆
    void push(T x) {
        if (remove_cnt[x] > 0) {
            remove_cnt[x]--; // 抵消之前的删除
        } else {
            pq.push(x);
        }
        sz++;
    }

    // push(x) 然后 pop()
    T push_pop(T x) {
        apply_remove();
        pq.push(x);
        x = pq.top();
        pq.pop();
        return x;
    }
};

class Solution {
public:
    vector<double> medianSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        vector<double> ans(n - k + 1);
        LazyHeap<int> left; // 最大堆
        LazyHeap<int, greater<int>> right; // 最小堆

        for (int i = 0; i < n; i++) {
            // 1. 进入窗口
            int in = nums[i];
            if (left.size() == right.size()) {
                left.push(right.push_pop(in));
            } else {
                right.push(left.push_pop(in));
            }

            int l = i + 1 - k;
            if (l < 0) { // 窗口大小不足 k
                continue;
            }

            // 2. 计算答案
            if (k % 2) {
                ans[l] = left.top();
            } else {
                ans[l] = ((long long) left.top() + right.top()) / 2.0;
            }

            // 3. 离开窗口
            int out = nums[l];
            if (out <= left.top()) {
                left.remove(out);
                if (left.size() < right.size()) {
                    left.push(right.pop()); // 平衡两个堆的大小
                }
            } else {
                right.remove(out);
                if (left.size() > right.size() + 1) {
                    right.push(left.pop()); // 平衡两个堆的大小
                }
            }
        }

        return ans;
    }
};

LLM 黄金时代下的 AI Infra

Fri, 18 Jul 2025 00:00:00 GMT

类比计算机系统的基础软件层以及云计算三层架构的 PaaS 层级，我们认为，AI 产业链中也有层级相似，定位于算力与应用之间的“桥梁”角色的基础软件设施层即 AI Infra。新一轮生成式 AI 浪潮，对于上层应用而言机遇与挑战并存，而 AI Infra 作为必要的基础设施，我们认为其技术及商业发展前景的确定性或更强。本文我们聚焦 AI Infra，揭示其内涵并总结目前国内外项目的商业化进展，再从工作流视角详细梳理各环节及代表厂商。我们认为，AI Infra 是 AI 产业必不可少的基础软件堆栈，“掘金卖铲”逻辑强、商业潜质高，建议投资者持续关注 AI Infra 相关投资机会。

摘要

在预训练大模型时代，我们可以从应用落地过程里提炼出标准化的工作流，AI Infra 的投资机会得以演绎。传统 ML 时代 AI 模型通用性较低，项目落地停留在“手工作坊”阶段，流程难以统一规范。而大规模预训练模型统一了“从 0 到 1”的技术路径，具备解决问题的泛化能力，能够赋能“从 1 到 100”的各类应用，并存在相对标准化的工作流，由此衍生出 AI Infra 投资机会。GPT-4 的开发经验也体现专业分工的必要性：根据 OpenAI 的披露，在 GPT-4 的开发过程中，其对 249 人研发团队进行了明确分工，并使用了数据标注、分布式计算框架、实验管理等点工具。

我们认为这也说明了在大模型时代应用基础软件的必要性。目前，AI Infra 产业处于高速增长的发展早期，我们预计未来几年内各细分赛道空间或保持 30%+ 的高速增长，且各方向均有变现实践与养成独角兽企业的潜力。

“AI = Data + Code”，组织 AI 所需的养料即数据，管理 AI 模型的训练部署过程，以及支持从模型到应用的整合是 AI Infra 工具的关键能力。

数据准备：无论是支持经典的机器学习模型还是大规模预训练模型，数据准备都是耗时较久、较为关键的一环。我们认为，LLM 浪潮下高质量的标注数据和特征库需求将持续增长，未来海量训练数据的需求或由合成数据满足。此外，我们强调 Data + AI 平台厂商的关键卡位。
模型训练：预训练模型的获取使得模型库更加流行，LLM 大规模训练需求也驱动底层分布式计算引擎和训练框架的迭代。此外，我们认为实验管理工具重要性较高。
模型部署：LLM 模型端的突破释放出大规模应用落地的潜能，更多模型从实验走向生产环境，我们认为有望整体提振模型部署和监控的需求。
应用整合：LLM 赋能应用催生对向量数据库和应用编排工具等的新需求。我们观察到经典的机器学习时代与大模型时代工具栈需求侧重点有所不同，同时，部分点工具正在拓宽产品功能边界，LLMOps 平台型产品的可及市场空间天花板或更高。

AI Infra 是连接算力和应用的 AI 中间层基础设施

资料来源：Grand View Research，Foresight News，Gartner，MarketsandMarkets，拾象科技，Firstmark，a16z，各公司官网，中金公司研究部

本章主要讨论：

AI Infra 在 AI 时代 IT 生态中的定位
为什么大模型浪潮下需要格外关注 AI Infra 投资机会
AI Infra 基础软件工具栈涵盖内容
AI Infra 商业化初探

AI Infra 是 AI 时代的中间层基础设施

从类比的角度理解 AI Infra：AI 时代连接硬件和上层应用的中间层基础设施。

✅ 传统本地部署时代：三大基础软件（数据库、操作系统、中间件）实现控制硬件交互、存储管理数据、网络通信调度等共性功能，抽象并隔绝底层硬件系统的复杂性，让上层应用开发者能够专注于业务逻辑和应用功能本身的创新实现。

☁️ 云时代同理，形成了 IaaS、PaaS、SaaS 三层架构，其中 PaaS 层提供应用开发环境和基础的数据分析管理服务。

🤖 所以类比来看，我认为，进入 AI 时代也有承担类似功能的、连接算力和应用的基础设施中间层即 AI Infra，提供基础模型服务、赋能模型微调和应用开发。

LLM 催生 AI Infra 投资机会

LLM 流行前，AI 模型通用性较低，项目落地停留在“手工作坊”阶段，流程难以统一规范。人工智能已有数十年的发展历史，尤其是 2006 年以来以深度学习为代表的训练方法的成熟推动第三波发展浪潮。然而，由于传统的机器学习模型没有泛化能力，大部分 AI 应用落地以定制化项目的形式，包括需求、数据、算法设计、训练评估、部署和运维等阶段，其中，数据和训练评估阶段往往需要多次循环，较难形成一套标准化的端到端的流程和解决方案，也由此造成了边际成本高、重复造轮子等问题。

大规模预训练模型完成了“从 0 到 1”的技术统一，泛化能力和通用性释放出“从 1 到 100”的落地需求，且存在相对标准化的流程，衍生出 AI Infra 投资机会。基于 Transformer 算法、超大参数量的预训练模型拥有泛化能力，一定程度上解决了原先需要按项目定制训练的问题，过去正因为 ML 模型的非标和项目制，下游需求并未被完全激发出来，LLM 模型端的突破释放出更大规模的应用落地潜能。而后续的应用过程中主要涉及：高质量样本数据的准备、基础模型获取、模型微调及部署监控、应用编排开发上线等环节，工作流较为标准化，我们建议投资者持续关注 AI Infra 投资机会。

AI Infra 基础软件工具栈

参考海外 OpenAI 的率先尝试，工作流分工、点工具加持助力成功。一方面，OpenAI 在《GPT-4 Technical Report》论文中披露了参与 GPT-4 开发的人员分工，共 249 人，角色分工明确，预训练、强化学习和对齐、部署等 6 个大方向下又拆分成不同小组，其中数据集/数据基础设施、分布式训练基础设施、推理基础设施等分别对应工作流中的数据准备、模型训练、部署应用等环节；另一方面，OpenAI 使用了 Scale 数据标注服务、Ray 分布式计算框架和 Weights and Biases（W&B）实验管理工具，且 W&B 的创立灵感就来自于其创始人之一在 OpenAI 的实习经历。我们认为，OpenAI 的率先尝试经验一定程度上说明专业分工和 AI Infra 基础软件堆栈在大模型时代的必要性。

AI Infra 广义上包含了基础模型和基础软件栈两层，本篇报告核心关注其中和工作流相关的基础软件工具栈。工作流的视角下，LLM 的开发应用主要涉及数据准备、模型训练、模型部署、产品整合四个主要环节，每个环节都有对应的点工具，亦有集大成的 LLMOps 平台型产品，我们将在下一章详细解读。

AI Infra 商业化

商业化起步中，已有变现实践，细分赛道或均有长出独角兽的潜力

商业化起步阶段，有望在未来几年快速成长为百亿美元量级的产业。我们认为，AI Infra 整体处于高速增长的发展早期，根据第三方数据，目前大部分细分赛道规模在几亿至几十亿美元量级，我们预计在未来几年内或将保持 30+% 的高速增长。同时，Data + AI、MLOps/LLMOps 等平台型产品的市场空间天花板可能更高，我们也观察到点工具厂商正在积极拓展产品边界。我们认为，AI Infra 是 AI 时代不可或缺的基础设施中间层，“掘金卖铲”逻辑的确定性高，有望持续受益于 LLM、AI 应用的繁荣。

海外厂商积极探索变现，细分赛道或均有长出独角兽的潜力。从微观的视角，我们整理了 AI Infra 各细分赛道海外代表公司的商业模式，基本遵循按使用量付费的定价模式。大多数创业公司成立时间较短，目前收入体量在数千万至小几亿美元量级，其中数据相关的、平台型的厂商起步较早、已初具规模，我们认为这也符合数据需要前置于 AI 模型投入、平台型厂商收入天花板更高的逻辑。此外，我们认为 LLM 模型端突破将释放出更大规模应用落地的潜能，有望带动模型部署、应用整合等后续环节的逐步起量。

从工作流视角梳理 AI Infra 投资机会

大模型时代和传统机器学习时代工具栈侧重点有所不同

本章从企业训练模型、构建 AI 赋能应用的工作流视角出发，详解涉及的主要环节，并关注 LLMOps 和 MLOps 在流程上的侧重点差异。我们认为 AI = Data + Code，历经数据准备、模型训练、模型部署、产品整合，分环节看：

► 数据准备：高质量标注数据、特征库需求持续，合成数据或成未来趋势。数据准备无论在传统的 MLOps 还是 LLMOps 中都是耗时较久、较为重要的一环。无监督学习降低对标注数据的需求，但 RLHF 机制体现了高质量标注数据的重要性，我们认为未来超大参数量模型对海量训练数据的需求或由合成数据满足。此外，Data + AI 平台厂商卡位关键。

► 模型训练：模型库更加刚需，训练框架持续迭代，软件工具协助实验管理。基于通用的 LLM 大模型微调、蒸馏出小模型成为高性价比的落地方式，因此需要能够高效便捷地获取预训练模型的模型库；也催生更适应 LLM 大规模训练需求的底层分布式计算引擎和训练框架。此外，我们认为实验管理工具的重要性或始终较高。

► 模型部署：更多模型从实验走向真实业务环境，部署和监控需求提升。我们认为，LLM 模型端的突破释放出大规模应用落地的潜能，更多的模型从实验环境走向生产环境，有望整体提振模型部署和监控的需求。

► 应用整合：催生向量数据库和应用编排框架新需求。LLM 赋能应用催生出对应用产品整合相关工具产品的需求，其中较为关键的是向量数据库和应用编排工具。

数据准备：高质量标注数据、特征库需求持续，合成数据或成未来趋势

数据是模型的起点，一定程度上决定了模型的效果和质量，数据准备无论在传统的 MLOps 还是 LLMOps 中都是耗时较久、较为重要的一环。LLM 带来的新变化主要包括：

虽然 LLM 的无监督学习机制降低了对标注数据的需求，但 OpenAI 的 RLHF 体现了高质量标注数据重要性；
模型规模大幅提升，带来日益增长的训练数据需求，长期看可能无法仅通过真实世界数据满足，合成数据提供一种 AIGC 反哺 AI 的解法。此外，数据基础管理软件平台的卡位始终关键，Data + AI 平台化趋势持续演进。

数据标注

GPT 的成功说明了高质量标注数据对提升模型效果的重要性

数据标注位于模型开发的最上游，对图像、视频、文本、音频等非结构化原始数据添加标签，为 AI 提供人类先验知识的输入。近年，无监督学习、强化学习等不需要标注数据的机器学习分支方法论的出现引发市场对于数据标注必要性的讨论与担忧。

不过，OpenAI 通过 RLHF 即基于人类反馈的强化学习来优化模型，且从 OpenAI 披露的分工中能看到有很多负责预训练、强化学习等的 AI 科学家也参与到数据准备中；开源的 LLAMA 2 的论文中也有一段强调高质量数据对模型训练结果影响的表述，Meta 与第三方供应商合作收集了近 3 万个高质量标注，又向市场证明了高质量数据标注工作的重要性。

数据标注厂商正在寻求智能化转型、减少对人力的依赖。在数据标注助力 AI 快速发展的同时，AI 也将反哺数据标注更加自动化、智能化，如利用模型进行数据预处理再人工审核等。Meta AI 发布的 Segment Anything Model 的训练数据集 SA-1B，就是通过智能数据引擎来辅助自动化生成的，该数据引擎经历了辅助手动标注-半自动标注-自动化标注的训练过程。

特征库

特征库（Feature Store）：高质量特征库持续受益

特征是预测模型的输入信号，可以简单理解为模型中的自变量 X，需要经过特征工程从原始数据中筛选得到。而特征库则是生产、管理、运营 ML 过程中所需数据及特征的系统，主要实现：

运行各类数据管道（Pipeline）将原始数据转换为特征值；
存储和管理特征和数据；
为训练和推理提供一致的特征服务

目前该领域的代表性产品包括：开源项目如 Feast，独立商业化公司如 Tecton，大型科技厂商的 ML 平台如 Databricks、SageMaker 等中亦有相应模块。数据和特征的质量决定了机器学习的上限，我们认为高质量特征库有望持续受益，同时国内数据要素市场的蓬勃发展长期看有望为 AI 模型供应更多高质量的数据燃料。

合成数据

合成数据：做真实数据的“平替”，用 AIGC 反哺 AI

一项来自 Epoch AI Research 团队的研究预测存量的高质量语言数据将在 2026 年耗尽，低质量的语言和图像数据存量也将在未来的数十年间枯竭。面对潜在的数据瓶颈，合成数据即运用计算机模拟生成的人造数据，提供了一种成本低、具有多样性、规避了潜在隐私安全风险的解决方法，生成式 AI 的逐渐成熟进一步提供技术支撑。比如，自然语言修改图片的 Instruct-Pix2Pix 模型在训练的时候就用到 GPT-3 和 Stable Diffusion 来合成需要的提示词和图像的配对数据集；Amazon 也利用合成数据来训练智能助手 Alexa，以避免用户隐私问题。合成数据市场参与者较多，独立公司/项目如 gretel、MOSTLY AI、datagen、hazy 等，数据标注厂商如 Scale 亦推出相关产品，此外主流科技公司英伟达、微软、亚马逊等均有不同场景的尝试。

Data + AI 是行业趋势

数据科学基础平台：数据卡位始终关键，Data + AI 是行业趋势

广义的数据科学涵盖利用各类工具、算法理解数据蕴藏含义的全过程，机器学习可以视为其中的一种方式和手段；狭义的数据科学也可以仅指代机器学习的前置步骤，包括准备、预处理数据并进行探索性分析等。

正如我们从报告《人工智能十年展望（八）：探索 ChatGPT 根基——数据与人工智能如何相互成就？》开始一直强调的观点，数据和 AI 一体两翼，数据是模型的起点、且一定程度上决定了模型的最终效果和质量，数据基础设施厂商卡位关键，从 Data 向 AI 布局是技术能力和业务逻辑的自然延伸。LLM 等大模型的渗透发展不仅额外增加了数据平台上 AI 相关的工作流负载，还可以带动底层 Data 基础设施的需求。

模型训练：模型库更加刚需，训练框架持续迭代，软件工具协助实验管理

大模型具有一定通用性，开发者们可以“站在巨人的肩膀上”，在预训练模型的基础上通过少量增量训练蒸馏出专精的小模型以解决垂类场景的需求。

LLM 带来的新变化主要包括：

要想高效便捷地获取模型，则需要一个集成托管各类模型的社区也即模型库；
催生更适应 LLM 大规模训练需求的底层分布式计算引擎和训练框架。

此外，模型训练过程涉及多次往复的修改迭代，无论是 ML 还是 LLM 都需要借助实验管理工具进行版本控制和协作管理。

模型库

模型库（Model Hub）：把握从数据到模型的工作流入口

模型库顾名思义是一个托管、共享了大量开源模型的平台社区，供开发者下载各类预训练模型，除模型外，主流的 Model Hub 平台上还同时提供各类共享的数据集、应用程序 Demo 等，是 AI、ML 细分领域的“GitHub”。

典型代表厂商包括：

海外的 Hugging Face、Replicate
国内关注 Gitee（开源中国推出的代码托管平台）和 ModelScope（阿里达摩院推出的 AI 开源模型社区）等项目

在商业模型上，Model Hub 厂商一般选择切入下游的 AutoTrain（自动创建、优化、评估模型）或模型推理服务，也在尝试就 Model Hub 功能收取订阅制会员费用。

分布式计算和深度学习框架

分布式计算和深度学习框架：大模型“炼丹炉”

分布式计算引擎方面，LLM 的训练过程需要大规模的 GPU 分布式计算集群，过去大数据已带动了以 MapReduce、Spark 为代表的分布式计算引擎的发展，但以 Ray 为代表的近年在 AI 大潮下兴起的分布式计算框架则更贴合 AI 需求（Ray 的首篇论文名为《Ray: A Distributed Framework for Emerging AI Applications》），其核心模块 Ray Tune、Ray Rllib、Ray Train 分别对应机器学习调参、强化、深度学习调参的流程。Ray 在官网的用户案例中表示“Ray 是使 OpenAI 能够增强其训练 ChatGPT 和类似模型能力的关键”。此外，Ray 作为更底层的分布式计算引擎，和 TensorFlow、PyTorch 等深度学习框架兼容，而 DeepSpeed、ColossalAI 等则是在 PyTorch 等基础框架之上针对 LLM 的优化训练设计的新一代框架。

实验管理

实验管理：记录实验元数据，辅助版本控制，保障结果可复现

模型训练是一种实验科学，需要反复的修改与迭代，同时由于无法提前预知实验结果往往还涉及版本回溯、多次往复，因此模型的版本控制和管理就较为必要，实验管理软件可以辅助技术人员和团队追踪模型版本、检验模型性能。该领域代表厂商为 Weights and Biases（W&B）和 Neptune，跟踪机器学习实验，记录实验元数据，包括训练使用数据集、框架、进度、结果等，支持以可视化的形式展现结果、多实验结果对比、团队协作共享等。此外，实验管理也是 LLMOps/MLOps 平台型产品如星环科技 Sophon、Google Vertex AI 等产品中的重要模块之一。

模型部署：更多模型从实验走向真实业务环境，部署和监控需求提升

模型部署是让模型从实验环境走向真实生产环境的重要环节，借助模型部署工具能够解决模型框架兼容性差的问题并提升模型运行速度。

模型监控通过对模型输出结果和性能指标的追踪，保障模型上线后的可用性。

我们认为，过去由于 ML 模型的非标和项目制，大规模、持续性的模型部署和监控需求未被完全激发出来，LLM 模型端的突破释放出大规模应用落地的潜能，更多的模型从实验环境走向生产环境，我们认为有望整体提振模型部署和监控的需求。

模型部署

模型部署：从实验走向生产的重要环节

模型部署指把训练好的模型在特定环境中运行，需要尽量最大化资源利用效率，保证用户使用端的高性能。模型部署领域参与者较多，比如 Ray、Tensorflow、PyTorch 等训练框架都提供配套的模型部署功能，模型库厂商如 Hugging Face、实验管理厂商如 W&B 也有相关产品，此外还有如 Seldon、BentoML、OctoML 等独立项目/产品。和训练框架自带的部署模块相比，三方的综合性产品能够为不同框架下训练出来的模型提供一套相对统一的部署方式。以 Seldon 为例，在复杂的多模型推理场景下，Seldon 通过模型可解释性、异常值检测等模块，最终选出表现最好的模型进行结果反馈。

模型监控

模型监控：模型可观测性保障可靠可用

可观测性在传统 IT 系统运维中就是重要的数智化手段之一，通过监控各类机器、系统的运行数据对故障和异常值提前告警。模型监控同理，监测模型上线后的数据流质量以及表现性能，关注模型可解释性，对故障进行根因分析，预防数据漂移、模型幻觉等问题。

模型可观测性领域有较多创业公司，包括 Fiddler、WhyLabs、Evidently AI 等，实验管理厂商如 W&B、模型部署厂商如 Seldon 也有所涉及，此外，传统的 IT 运维可观测性厂商也有机会切入 AI 模型监控领域，海外如 Datadog 已经尝试将 Open AI 的模型服务加入纳管范畴，我们也建议关注国内相关厂商的后续进展。

应用整合：催生向量数据库和应用编排框架新需求

正如前文提及，LLM 模型端的突破释放出更多应用落地的潜能，由此催生出对应用产品整合相关工具产品的需求，其中较为关键的是向量数据库和 LLM 应用编排工具。

向量数据库

向量数据库：LLM 的外部知识库

让通用大模型具备专业知识主要有两种途径，一是通过微调将专有知识内化到 LLM 中；另一种则是利用向量数据库给 LLM 增加外部知识库，后者成本更低。

向量数据库和 LLM 的具体交互过程为：用户首先将企业知识库的全量信息通过嵌入模型转化为向量后储存在向量数据库中，用户输入 prompt 时，先将其同样向量化，并在向量数据库中检索最为相关的内容，再将检索到的相关信息和初始 prompt 一起输入给 LLM 模型，以得到最终返回结果。

向量化技术本身已较为成熟，海外模型如 Word2Vec、FastText 等，国内中文 Embedding 模型有 MokaAI 开源的 M3E、IDEA CCNL 开源的二郎神系列。向量数据库厂商/产品主要包括 Pinecone、Zilliz、星环科技 Hippo 等，另外也有传统数据库、大数据平台厂商如 PGSQL、Databricks 通过增加向量查询引擎插件来实现支持。我们认为，向量数据库是 AI Answers 类应用落地的刚需，同时本土厂商在中文 Embedding 方面可能更具优势。

应用编排框架

应用编排框架：LLM 应用“粘合剂”

LLM 应用编排框架是一个封装了各种大语言模型应用开发所需逻辑和工具的代码库，LangChain 是当下最流行的框架之一，还有 Anarchy、Dust、AutoGPT、LlamaIndex 等。初始化的大模型存在无法联网、无法调用其他 API、无法访问本地文件、对 Prompt 要求高、生成能力强但内容准确度无法保证等问题，应用编排框架提供了相应功能模块，帮助实现从 LLM 到最终应用的跨越。

以 LangChain 为例，它主要包含以下几个模块：

Prompt 实现指令的补全和优化；
Chain 调用外部数据源、工具链；
Agent 优化模块间的调用顺序和流程；
Memory 增加上下文记忆。

集成开发环境

集成开发环境：交互式 Notebook 逐渐流行

在上述 AI 建模流程中，开发者需要处理大量代码编写、分析、编译、调试等工作，可以直接在对应环节或平台型产品的内置环境中进行，也可以使用专门的集成开发环境并调取所需功能。其中，Notebook 是一种交互式的开发环境，和传统的非交互式开发环境相比，Notebook 可以逐单元格（Cell）编写和运行程序，出现错误时，仅需调整并运行出现错误的单元格，大大提升开发效率，因此近年逐渐流行、深受数据科学家和算法工程师的喜爱，被广泛应用于 AI 算法开发训练领域。

LLMOps 一站式解决方案或更适应国内市场

前文我们详细介绍了模型训练、构建应用工作流涉及的主要环节及各环节点工具厂商，事实上，这些厂商在强项环节之外亦不断拓宽产品能力边界，比如：

数据标注厂商 Scale AI 拓展合成数据业务并正在投入 LLMOps 领域的 Scale Spellbook（做一个基于大语言模型的开发者工具平台）；
模型库厂商 Hugging face 切入 AutoTrain 和模型部署；
实验管理厂商 W&B 切入模型部署和模型监控等。

MLOps/LLMOps 提供一站式平台解决方案，可及市场空间更大，多采取 Data + AI 一体化战略。除此之外还有平台型的 MLOps/LLMOps 产品，基本涵盖了上述流程的主要环节，大型科技企业、数据基础软件厂商均参与其中。

我们认为，基于整体数字化进程和软件付费意愿习惯判断，海外企业客户可能倾向于选取各环节点工具自组工具栈，而国内客户可能倾向于一站式的解决方案。此外，从目前 AI Infra 领域独角兽的估值水平来看，平台型厂商多采取 Data + AI 一体化战略，起步较早、规模天花板更高。

一文详解 26 届各大厂人才计划

Fri, 18 Jul 2025 00:00:00 GMT

一、大厂人才项目认知：卷上天的技术圈入场券

大厂越来越卷战略级人才项目了，这类项目我个人觉得，本质上是企业技术护城河的人才储备计划。

根据我的发现，在互联网大厂的人才争夺战中，核心技术人才项目应该是已经成为战略储备：

腾讯青云计划聚焦 AI 算法与云计算，侧重基础研究能力；
字节筋斗云人才计划覆盖大模型应用等前沿领域，强调快速迭代创新；
阿里星计划通过滚动招聘锁定多模态大模型与自动驾驶人才，注重技术落地效率；
今年的京东 TGT 主要研究方向包括多模态大模型与应用、机器学习、搜索推荐广告、空间与具身智能等，比较聚焦技术突破和有社会价值的前沿课题。

「腾讯青云计划」高门槛的技术理想主义

项目定位：升级后聚焦 AI 大模型、基础设施等十大领域，要求候选人有技术执着且能穿透技术本质。

适合人群：适合铁心走技术专家路线、能扛高压的学术派，双非学生基本没戏。

年薪范围：70-200w

招聘规模：每年约 80人

「字节筋斗云计划」创新压力下的极限挑战

课题设置：2025 年开放 42 个前沿课题，涵盖大模型应用、AI Coding 等方向，要求博士在顶会发表过论文。

适合人群：之前听过牛客社区大佬提到，项目考核还挺严苛的严苛，适合抗压能力强且追求快速产出的实战派。

年薪范围：100-150w

招聘规模：每年约 20 人

「阿里星计划」学术派的终极战场

选拔标准：仅招顶尖博士生，要求在 AI、云计算等领域有突破性成果，入职即参与达摩院核心项目。

适合人群：学术顶会、工程实践高手、技术大神，压力是比较大的，需要长期闭关搞科研。

年薪范围：120-140w

招聘规模：每年约 40 人

「京东 TGT 计划」技术与应用的实战主义

选拔标准：招聘范围本硕博，近百个课题可选择，技术专家带教，直接参与智能仓储系统优化、物流机器人路径规划等落地项目。

适合人群：薪资不设上限是今年京东 TGT 的亮点之一，与其他大厂项目侧重实验室研发不同，TGT 学员从入职起即深度参与京东核心业务场景，目前项目也在进行中，上车时机比较不错。

年薪范围：不设上限

招聘规模：今年第一年尚未明确，不过看了一下京东 TGT 有近百个课题，我觉得招聘量级应该不小

二、选择大厂人才项目的考量因素

作为学生党，选大厂项目就像选赛道，没有绝对的好坏，只有适配与否。通过整理了牛客社区内一些大佬的帖子以及我的对大厂项目的了解，在选择大厂人才项目上可以关注的因素。

1. 项目定位与职业规划的匹配度

商业融合类（如腾讯青云）：适合技术与管理结合的复合人才，需平衡技术深度与商业化落地能力

业务融合类（如京东 TGT）：适合学术背景强、技术应用于业务的学生，以及关注新兴领域（如零售技术）、希望技术快速落地，需适应业务场景驱动的研发节奏。

2. 上车门槛与自身履历的匹配度

学历与成果要求：

阿里星侧重顶尖学术成果（如顶会论文、专利），双非学生几乎无机会
京东 TGT 对学历包容性更高，本硕博学生均可以申请

另外从招聘规模来看，普遍是低于秋招，但京东 TGT 在几个大厂项目中招聘规模最大，竞争压力会低于其他项目。

3. 资源支持与未来规划的匹配度

导师配置：

腾讯青云提供 “岗位导师 + 发展导师 + 项目顾问” 三轨制，导师多为首席科学家
京东 TGT 首创 “技术 + 业务 + 成长” 三导师制

薪酬方面：盘点了一下，基本上所有大厂都能给到年薪百万的水平，但今年京东 TGT 提出的薪酬不设上限还是挺值得期待一波的。

C++ 性能优化

Tue, 08 Jul 2025 00:00:00 GMT

Preface

最近看了 CppCon24 的一个分享 "When Nanoseconds Matter: Ultrafast Trading Systems in C++"，是顶级量化交易公司 Optiver 的工程师 David Gross 分享了构建低延时交易系统的一些思考与做法，列出了一些性能优化的指导原则。看完之后感觉干货满满，学到了很多 C++ 优化技巧，于是加入自己的理解，整理记录一下。

Principle #1: "Most of the time, you don't want node containers"

作者首先以一个订单簿 (Order Book) 的实现为例。订单簿由不同价格档位 (<price, volume>) 组成，需按 price 排序，并支持高频的插入、修改和删除。正常第一反应就是使用 std::map 数据结构来实现。

Ok，先用 std::map 实现一个基准版本。这里学到的一点是，跑基准要尽量模拟生产环境的情况。在生产环境中，分配给 std::map 节点的内存往往是分散的，因此在基准实现时要加入一些内存分配的扰动。

在得到基准后，可以想想，这些 node containers 的数据结构如 std::map、std::set、std::unordered_map 等，数据节点在内存中是离散存储的，数据缓存局部性比较差的。追求高性能应优先选择连续内存的 std::vector + std::lower_bound 实现。测试发现在该场景下，使用 std::vector 性能更好，但是一样有较大的长尾延迟。

Principle #2: "Understanding your problem (by looking at data)"

长尾的原因很简单，使用 std::vector 在插入和删除数据会移动数据。作者分析了业务数据特征，发现频繁操作的数据集中在 std::vector 的头部，导致移动数据成本较高。所以只需简单将反转数据存储顺序，就能减少数据移动成本，长尾延迟显著降低。

Principle #3: "Hand tailored (specialized) algorithms are key to achieve performance"

对上述实现运行 perf 看看有什么瓶颈。

这里又学到了一个技巧，使用 fork + execlp 在基准测试主要逻辑运行前启动 perf，能避免初始化等无关函数干扰测试。又是一个 fork 的骚操作！

通过 perf 发现该版本在调用 std::lower_bound 时有不少分支预测错误，为此，作者实现了一个无分支的二分查找，核心是使用算术运算和条件移动指令 (CMOV) 替代条件跳转。性能得到进一步提升！

这里也学习到一个 libpapi C++ 库的使用，可在代码中直接读取 CPU 硬件性能计数器，如指令数、周期数、缓存缺失、分支误预测等，方便量化优化效果。

Principle #4: "Simplicity is the ultimate sophistication"

Principle #5: "Mechanical sympathy"

二分查找会随机访问内存，如果直接简单使用顺序查找会如何？作者测试发现性能更好。所以有时最简单的算法在特定数据和规模下可能是最优的。

数据缓存优化得差不多了，接着看看指令缓存。

使用 [[likely]] 属性提示编译器将高频分支的代码放在主执行路径附近，优化指令缓存局部性。

使用 [[unlikely]],noinline,cold 这些属性标记低频分支的代码。这些代码不会被内联到热点路径中，放得远远滴，避免它们污染指令缓存。真细啊！

优先使用 lambda，比 std::function 性能更优，后者可能有类型擦除和间接调用开销。

原则里的 Mechanical sympathy 翻译叫“机械共情”。我的理解就是编写高性能代码必须站在机器的角度思考，深刻理解机器的运行方式，如各级缓存，流水性指令、分支预测等，充分利用好其特性。

Principle #6: "True efficiency is found not in the layers of complexity we add, but in the unnecessary layers we remove"

作者接着开了另一个话题，主要讲网络和并发。

网络通信上，尽量绕过内核，减少数据拷贝和用户态内核态的切换。这里介绍了一些工具。

如果多进程在同一机器通信，那就没必要使用 Socket，直接使用共享内存。使用共享内存的话，一般需要有个高并发的消息队列。消息队列种类很多，设计前需明确需求边界。

Principle #7: "Choose the right tool for the right task"

基于需求，作者设计了一个名为 FastQueue 的单生产者多消费者共享内存无锁队列，主要通过两个原子变量 mReadCounter 和 mWriteCounter 来实现无锁。

整体实现值得好好学习下

这里值得学习是，这些变量都做了 CACHE_LINE_SIZE 内存对齐，避免 False Sharing。

Writer 具体实现

Reader 的具体实现

第一版实现的性能比不上一些开源的库。于是作者又做了几个优化。

第一：缓存写计数器 mCachedWriteCounter，只有写入累积超过阈值，才更新 mWriteCounter，避免频繁访问 mWriteCounter 原子变量。注意这里也做了内存对齐，可以学学如何使用位运算进行高效的对齐计算。

第二：对每条消息做内存对齐。

第三：缓存读计数器 mCachedReadCounter，避免频繁访问 mReadCounter原子变量。

优化后，FastQueue 实现性能优于一些著名开源实现。为什么作者一开始不直接使用开源库呢？因为作者贯彻“Simplicity is the ultimate sophistication”，觉得简单才是高效的额，开源的都太“重”了。

最后作者还提出了 api 设计的零拷贝优化，重新设计接口，允许调用者直接在队列的内部缓冲区进行序列化，能避免了一次内存拷贝。

Principle #8: "Being fast is good – staying fast is better"

性能优化非一劳永逸，需持续监控。这里又学到一种新的统计函数信息的方式，就是 Clang Xray Instrumentation。

这是一种低开销的函数级追踪工具，可以动态地给函数入口和出口打桩。作者提到程序只需编译一次，在运行时选择是否开始追踪。如果不开启，打桩的代码只会运行空指令，开销极低。

Principle #9: "Thinking about the system as a whole"

Principle #10: "The performance of your code depends on your colleagues' code as much as yours"

作者通过一个随机访问内存的基准测试程序，展示了 CPU 多级缓存的容量效应和缓存竞争的问题：

当数据集能完全放入 L1/L2 Cache (私有) 时，单核与多核 (6 核) 的吞吐量几乎线性扩展。
当数据集增长到 L3 Cache (共享) 大小时，6 核并行时的总吞吐量显著下降，接近单核吞吐量。因为多个核在激烈争抢共享的 L3 Cache。

所以如果在同一台机器里，即使你的程序优化到极致，但是其他程序对 L3 Cache 滥用，也会拖慢你的程序。

总结

整个分享下来，学到不少东西，ns 级延迟优化真的很细！作者贯彻的原则就是尽量简单！less is more !

结合演讲和个人理解，提炼以下优化原则：

基准测试尽量符合生产环境情况。
在性能优化前，分析好业务特性，数据分布。
在性能优化前，分析性能瓶颈，定位关键路径。
多考虑缓存的重要性，如数据缓存，指令缓存。做好数据结构的选择、数据内存对齐，原子变量的 Cache Line 对齐。
尝试在业务中减少使用 node containers，做好性能对比。
标准库和通用算法虽好，但在热点路径上，针对数据和场景尝试自己实现一些算法。
一些著名开源库功能丰富但可能臃肿。在明确边界的需求下，自研简洁高效的组件。
根据实际需求来明确设计边界。
简单设计和实现通常更易维护且性能更好。
移除非必要的抽象层和复杂性。
建立持续性能监控。
考虑整个系统乃至整机的资源共享和竞争。

2025.07.08

Tue, 08 Jul 2025 00:00:00 GMT

感觉我们的世界对慢节奏的人很不友好，再怎么想求知，如果要我以高强度、高精神压力的状态去做的话，我自己觉得没有什么知识值得我放弃悠闲平和的生活。有一句话说得很对，哲学是从闲暇中诞生的。既然如此，找不到故乡的孩子也是相当的可怜。

那种田园牧歌的时代早就一去不复返了。我曾经对科研的憧憬完全来自于牛顿与苹果树，康德漫步于小径，梭罗隐居瓦尔登湖，而不是坐在电脑面前，脊柱侧弯、屁股久坐、眼睛散光，和计算机打交道，未来只有吃不完的苦。我曾经觉得我是会喜欢科研的，在我做出老师也不会做的题目的时候，压轴题答案对出来一样的时候，在每个新学期，发下的课本还弥散着油墨香和新知识香味的时候。

也许我确实是，但是我连打游戏都没法一天八小时持续一个月，看书不行，跑步不行，吉他也不行，唯一成功做到过的只有读书，读高中的时候。但也得考虑到咱们学六门课呢，而且真是差点就死了。

人擅长什么领域，就会在心中的价值天平上给它加码，以确保自己的价值在自己心中过得去。我想高考之于我几乎所有的意义就在于此了。我确认自己的才能、价值、潜力，我知道我的头脑不会背叛我。我所适应的这条路，它的走向大概就是科研吧？我也曾经这样想过。

但好像不是的。

严谨的逻辑，科学的思维方法，阴云之下的大厦，真理海边的贝壳，我现在也仍然憧憬着。可我不想走那条路。它也许确实延伸到美丽的景色边，可是车票呢？或者是昂贵到大部分人支付不起，或者是以其他的美景代为支付。后者是否值当，我不好说，这只能是个人的判断。

那么，我要走到哪条路上去呢？

走到无论怎样人烟稀少、终究是广袤的那片原野上。独属于我的这一条小径或是平原，独属于我的这一片湖海。我是离群的鸟，冒着饥饿受冻的风险，也要看一看规划以外的人生。生活节奏越来越快、越来越机械化、科技化、去诗意化是无法避免的现实，我无法接受这样的生活，也是无法避免的现实。我需要自己的空间和时间，而且必须以此为最高优先级。

其实我潜意识里始终在以此为标准做选择。小到必须要看闲书、熬大夜、睡大觉，大到咱们学个理科玩玩就可以了。以前很喜欢 ilem 的白鸟过河滩，白鸟白鸟不要回头望，你要替我飞去那地方。现在一想，为什么呢？我又不是被笼子束缚的鸟，更不应该是被笼子束缚的人。

或多或少早就明白这些，最早可追溯至我十一二岁对着王尔德童话，想象自己去森林里砍树盖小木屋的时候。花了八年向自己证明了自己的能力，又花了四年试探这个世界的底线。结果是这个世界根本没有底线。

我时而惊叹于我朋友的文笔，也惊叹于我朋友与我价值观的一致。

从小到大我见过的成绩好的人太多了，然而天下英雄如过江之鲫，即使你万里挑一，在这里也有 14 万个，更何况世界不止中国。

然而幸福是一种独立于客观存在的能力，就像物债二分法，所有权的变动无效并不意味着买卖合同无效：你看到什么，听到什么，感受到什么，才是最重要的，跟客观世界是什么样的、跟别人怎么看你无关。

所以幸福不是那种一下被人流推到癫狂的短暂欢乐，而是一种长期平和的满足。就按一线城市人均寿命 80 岁来算，再扣除最后几年没有质量的生命、扣除已经过去的 18 年，4 年本科、3 年硕士占据现有生命的份额不少。

既然人生永远没有岸，你的体验不重要吗？

选择互联网大厂还是央国企？

Thu, 03 Jul 2025 00:00:00 GMT

近些年互联网发展

站在 2025 年的今天，我真实感受到了通缩所带来的压力。从我短暂的学生时代所看见的：

2018-2020 互联网大厂的疯狂。BAT 大厂非常乐意接受本科生，并且当时就算是没有经验的只要会一些基本算法中小厂都是可以进入的。签完三方还有 2-4 万的签字费；
2020-2022 笛子和华子的时代，这时候的比亚迪、华为、tplink、海康、大华都是应届毕业生保底的 offer。互联网在逐渐收缩，但是还没有开始大面积裁员，更多的是业务调整，出来的人也可以很快找到工作；
2022-2023 这时候的华子、笛子难度逐渐增加但是还处于毕业生保底的 offer，互联网大厂开始裁员，减去没有增量的业务，仅保留营收正常、具有未来前景的业务；
2023-2025 这时候互联网大厂大面积裁员已经成为常态，包括不限于海康威视解散多处研发基地；tplink 解散张江 wifi 芯片团队；美团砍掉优选业务；中电成都某所子公司裁员；
2026+ 最近看到很多 26 届的同学拿到了大厂实习的 offer，我原本是感到开心的，第一反应是互联网回暖，但是回头想来，这并不是一个好兆头，因为当前互联网大厂主攻的 AI 大模型并没有真正盈利没有实际增量，结合 2024 全年阿里的财报显示出来的在职人数，我得到了一个可怕的结论：互联网大厂正在加速内部末位淘汰和部门裁撤，通过快速循环的方式接收和裁撤应届毕业生，可能不到一个合同期就会裁走大部分人

最近也看到很多，从芯片行业、自动化电气行业、新能源行业、工业软件行业和互联网行业，越来越萧条。当我还抱有侥幸心理，认为已经到底了，但是种种迹象表明远没有结束。

华为部分产品线将大量 24 届研发人员输送一线，说明市场在收缩，只能相互之间进行存量竞争
IC 设计今年也是遇冷，岗位急剧减少
比亚迪也传出裁撤智驾部门的消息
58 同城大量裁员

就程序员可选的行业来说，包括半导体、新能源和互联网都在萎缩，而且速度超乎我们的想象。

大厂 or 央国企

当然这不是本次讨论的核心，今天讨论的核心是软件开发还值得进入吗？

个人答案是：不值得，除非能够起薪一线年入 45W，并且每三年涨薪 30%。因为只有这样才能够在 35 岁之前攒够 500W，够以后养老的需要。否则二线 20W 的半垄断型央国企将会是更好的选择。

进一步讨论如何实现应届起薪 45W

现在单纯做开发只能够实现一线收入在 30-40W，是无法达到一线 45W 年薪的。只有算法岗，包括大模型、nlp、cv 等才能够达到这样的薪资。并且这样的薪资多数只能由大厂开具，因此需要一至两篇的相关领域 B 以上论文➕一至两家大厂实习，这样的机会更大。

从长远来看，半垄断型央国企更具有性价比

稳定的细水长流，将提升生活的幸福感，有时候人生追求的不是钱越多越好，而是不受金钱窘迫的束缚，细水长流在没有增量的当下何尝不是一种选择。当然这里所说的更多是央国企当中的二级单位也就是省分/区域分公司。

从另一个角度看，十年前 2015 入行的程序员现在 35 岁要离开行业了，经历过行业的上行与下降，才有了现在的积累，你又如何能保证在只有下行的当下，能够坚持到他们的年龄，得到相同的财富积累？现在选择程序员在我看来是一个十分不明智的行为，缩量竞争将会像光伏产业一样，竞争越来越激烈，收益越来越微薄。

半垄断型央国企有哪些？

包括：

石油（中石油、中石化、中海油）
发电（五大六小）
供电（南网、国网）
烟草（烟草局、卷烟厂）
通信（联通、移动、电信不包括三产）
国有行（中、农、工、建、交、邮）
中证登、中债登、中国结算、北交所、资源性央国企二线研究院、四大资产管理公司
还有地方性的交通、港口等等

半垄断型央国企适合哪些人？

适合小镇做题家，可以将普通人维持在中产位置不滑落，等经济好转可以为自己的下一代提供稳定富足的基本生活，完成阶级跃迁。一代人有一代人的使命，绝不能一口吃成胖子。完成阶级跃迁从来都是从农民到城市中产再到富裕阶层，稳定的中产才是小镇做题家的最优选择。

银行类

体系很大、数量也多，薪资也高，招聘季都会到各大高校或社会招聘大量的专业人才。

计算机专业在银行对口的岗位是金融科技岗，对应的岗位有软件开发、网络信息安全、系统运维和运维工具研发等。

金融科技岗在银行招聘中，一般以市分行、省分行为起点，可分为总行及其直属机构、软件开发中心以及数据中心等。

现在银行的科技子公司很盛行，比如建信金科、兴业数金等等，优点是薪酬较高，招聘量大，但是稳定性差，压力大，加班多，技术一般（不推荐）

【第一梯队】监管机关：中国人民银行（人行）、中国银行保险监督管理委员会（银保监会），人行是有专门的考试，银保监会属于国考序列，竞争都很激烈
【第二梯队】三大政策行：国开行、进出口、农发展，竞争惨烈，相对商业银行来讲，工作压力不大
【第三梯队】六大国有行：工农中建交邮储，建行属于薪资更高些，邮储处于薪资中下游（但是业务扩张后薪资有所上涨）
【第四梯队】十二家股份制：招商银行、中信银行、浦发银行、平安银行、中国光大银行、华夏银行、中国民生银行、广发银行、浙商银行、恒丰银行、兴业银行、渤海银行
【第五梯队】一百余家城市商业行：比如北京银行、上海银行、苏州银行、杭州银行、南京银行等等，好的城商行比当地的六大行的薪酬会更高些
【第六梯队】一千余家农商行/农信社：上海农商行、农信社、山西农商行、江苏农商行等等

证券类

证券公司程序员岗位上可以分为量化，算法，开发。

量化人员的学历要求很高，博士与海归、名校硕士比例非常高。

证券公司程序员薪资蛮高的：

中信证券，北京，base 17k，年终第一年很少，2-3 个月吧，第二年正常情况下 6-10 个月
华泰证券，南京，base 22k，总包 38-40

在证券公司做程序员，不仅要注重专业技术，也要重视业务逻辑，需要了解很多金融类相关的专业知识。

烟草 / 电网

烟草

烟草公司包括各省烟草专卖局和各省中烟工业，是中国最赚钱的企业。

烟草公司懂的都懂，是真的香。烟草公司每年基本上只招应届生，想进入烟草公司的应届生一定要抓住机会！

但是烟草录用名单，硕士占比很高。

电网

电网首先选择的是输电卖电的国家电网、南方电网。

另外还有发电的央企：国家能源、大唐集团、中国华能、国家电投、三峡集团、华润集团、国投集团、中核集团等等。

国家电网的话，不是双一流的话或者研究生其实要进市公司是很难的，而且一般城市对计算机专业的需求量其实很少。

计算机类的入职后，主要是到各省的信通公司，或者各地市供电公司的信通部门。待遇方面也很不错的，和同岗级的电气类工资接近。由于是计算机类，不用和电气专业一样经常去一线生产岗位。

石油类（中石油、中石化、中海油）

我国三大石油公司中石油、中石化、中海油，每个省都有分公司。

三桶油每年计算机专业岗位也很多，薪资待遇很不错。举个 2022 届校招生的例子：中石化新星新能源研究院郑州分公司，地点郑东新区，不包住，试用期半年 2600/月，转正后往年是第一年 10+，第二年 13+，计算机岗。

军工所

军工相关的央企有航天科技，航天科工，中电科，航空工业，中国兵器和中船。

中电科里面待遇排第一梯队的有 28 所，29 所等，可能和民企的 IT 公司不相上下，在军工单位里算是很好的了（个人了解之后不推荐）。
航天科技的，待遇好的有航天一院，三院，五院相应的部，和排头的所（卡学历）。

举几个校招生薪资的例子：

中国船舶 722 所，武汉，试用期 6 个月，每月 11k，转正第一年 25w
中国兵器 202 所，咸阳，事业编，试用期三个月每月 8k，转正后直接获得 10w 安家费，承诺每年不低于 18w
中电 28 所（不推荐）
中电 14 所（推荐，注意签约合同内容）

通讯类

通信行业可以说是一个很吃香的行业，三大运营商，移动、电信、联通作为我国通信行业的垄断国企，其运营的效益有多高更不用多说。

选择运营商要注意区县公司绝对不要去，最低也要混在市公司一级，能去省公司则尽量去（不推荐区县级的全员营销）

举两个校招生薪资的例子：

浙江移动市级公司，系统开发岗位，据说待遇 16w-18w
中国移动研究院，产品岗，待遇 24w

地方国企

地方国企有省属国企、市属国企、区县属国企。

省属国企通常有交通投资集团、文化旅游集团、农业发展集团等等，省属国企的待遇都是很不错的

其他

假国企（国企包含央企）：求职者在真国企能享受到的很多福利待遇在假国企是享受不到的，钱少事多加班多。找到国家认证好的国企名单，直接在名单里面查就好了，严格意义上的国企就两种，就是国有独资公司和国有控股公司（参股也可）
权力是自上而下的，能去省局不去市局，能去市局不去县局。层级低的单位，非常不利于个人发展
普通员工 < 领导关系户 < 总部领导关系户 < 甲方领导关系户
垄断国企滋润 > 一级集团或者二级公司日子还好点 > 三级子公司国企鱼龙混杂 > 基层（也有相反的，比如党建办公室，以学校为例）
烟草、供电、供水、燃气、供暖 > 城投、水利泵站（垄断化的国企） > "中字头"地区地产、施工（也就是参与市场竞争市场化的国企：这种盈利不佳可能会恶心人走）
国企在市场竞争上没有优势，但是民用资源一定不会倒闭，也就是相当于铁饭碗，因为国企的目的是为了保障经济命脉在国家手里
地铁比铁路局钱少，没有货运业务来赚钱。地铁能留城里，铁路局难留，所以地铁会压价，压的价就相当于留城的代价了
国企房地产来历：政府拿不出钱承担项目，把地产抵押，国企地产再盖楼
进国企不要想着升职加薪，毕竟关系户在那里，建议另辟蹊径，比如搞副业
社招进国企都是顶雷或者拉马的，干事创业规避国企，大佬背书才走社招，民企打法别存幻想，集体决策神鬼难清（招聘会社招，其实早就内定了，做样子看的，其他人陪跑）
大专、非全日制本科和往届几乎没有希望
现在只有公务员和事业编有编制，国企都没有编制
- 备案制员工（多为应届生）：纳入工资总额，人员国资委备案
- 合同制员工：不纳入工资总额，不在国资委备案
- 劳务派遣员工非“编制”，不属于国企人员
- 论级别，国企有：地方，市级，省级，央企
- 论所有制，有全资，独资，股权多元化，混改
- 论岗位，有财务岗，战略岗，人资岗，技术岗，还有 xxx 生产一线岗
- 论职级，同一个岗位有专员，主办，主管等级别
- 论薪酬，要看你是公益类，还是市场类；营业能力，收入能力 ...
家里没钱的，别来银行（拉存款，完成任务，这么一想出大钱赚死工资，诈骗和它一比都算和蔼可亲）
国聘网，大部分单位也就是挂一下（也有个别），主要招聘名额还是各校线下宣讲会
网申大部分是硕士起步，本科多试试宣讲会

参考链接：

选调生备考计划

Sat, 28 Jun 2025 00:00:00 GMT

福建选调须知

这里插一句话，不同于一般省份的“定向选调生“和”普通选调生”分类，福建并没有严格意义上的定向选调生，只有“选调生”和“引进生”两种分类。

其中讲述了「选调生」和「引进生」的细节

还不太清楚的同学可以先看看这篇文章补课：最偏爱本地人的省份？2022 年福建选调生全方位解读！

备战计划与资料

行测（资料）

花生十三笔记总结

粉笔 980 系统课

行测 5000

福建选调生招录考试专用教材

粉笔 APP：

智能组卷
题库
每周模考

申论（资料）

申论背诵规范词

人民时评 45 篇

2025 人民日报时评 12 个月｜电子版（每月更新）

人民日报·精读

计划

参考 PPT 和两位选调学长/学姐的建议，找优公老师/观澜公考咨询（福建选调）

🥕第一阶段：打基础（5-7 月）

每天：言语 30、判断 30、数资 25、常识 15

1、FB980 跟系统课程至少过一遍，对各个模块内容、重难点、出题逻辑有清晰的认知

2、晨读背诵：《实词辦析 1500 个》、《常识 4600 问》

3、错题不同颜色笔做好标记，方便后期复盘

4、申论同时进行，每天 2h

🥕第二阶段：转项拔高（8-10月）根据自己的薄弱模块去找固定的老师听课

每天：言语 30 题＋判断 30 题＋数资 30 题＋常识 15 题

1、判断：花生十三判断刷题、龙飞图推刷题

2、言语：郭熙 100 题、欣说、阿里木江刷题

3、数量：花生十三数量 1200 题、齐麟刷题

4、资料：高照超大杯、齐麟、花生十三

5、常识：FB（分模块刷）

6、申论：李梦圆、站长申论刷题（每天一套，每周一篇大作文）

🥕第三阶段：考前冲刺（11月-考试前）

1、严格按照考试时间，早上一套行测，下午一套申论，晚上复盘，状态保持到考前

2、错题集完完整整的再过至少 3 遍，不同颜色重新标记难点和知识模糊点，对于变型较多/复杂的题型，重点关注各模块用时及正确率

行测

推荐 UP：

网友红领巾：每期粉笔模考解析

拥抱昔日温度：第一视角做题

行测刷题建议

最初期，可以随便写一套，不用计时，做完就好，熟悉一下题型的同时也看下自己的水平在哪里。

刷的卷子可以用粉笔 app 的“智能组卷”功能来生成。

每次做，都要把手机开飞行，对各部分计时。

做题时打印出来做纸质版。

尽量每天都拿出两小时，完整刷一套套题，保持手感。

粉笔每周模考，有空的话也可以参加一下。岗位排名做个参考，不用太放在心上，以免被搞心态。

要形成自己最舒服的做题顺序

常错的题，要善于积累。

（一）常识

性价比最低的部分。但福建选调常识有 30 题，整体难度不难，但还是值得一点点的重视。

当年度的大事一定要熟悉，例如我们去年的二十大。网络上有些常识蒙题法，我觉得还是值得一看。一是能够知道在出常识题时，最容易在什么地方设置考点、挖坑；二是在犹豫不决时可以交给蒙题。(刚刚已经说过了，犹豫不决是大忌)。

最后，一些机构针对福建选调整理的福建相关的常识，在其它部分读累了的时候，也是可以看看的。

（二）言语

很重要的部分。多刷题，多积累。

【逻辑填空】

善于积累，遇到了就记录，形成自己的记录本
难题偏题不过多纠结，有时候机构之间答案都不一样
个人比较推荐的老师：阿里木江（B站）。但找到适合自己的老师才是最重要的。
“中心理解”这个东西一定要尽可能弄懂，懂了之后做言语会豁然开朗。

（三）判断推理

很重要的部分。敢于放弃，回头再看。一定不要纠结!!!!

【图推】

要听课也要刷题，知晓命题点。
个人比较推荐「花生十三」和「刘文超」。花生十三的六面体方法让我印象很深刻。

【定义】

听课知晓命题点。
善用排除法。

【类比】

听课熟悉命题点。
积累。如果选项都看不懂那肯定很难做出来，

【逻辑推理】

个人推荐花生十三的加强削弱
*福建选调在这部分的题可能会非常恶心，一定要果断跳。

判断推理总结：再强调一下，判断推理，不管是哪类题型最重要的是做到这两点!

看课，熟悉题型与命题点
不纠结!不纠结!不纠结!可以圈起来有空回头再看但一定不要纠结。

（四）资料分析

非常非常重要。言语和判断是保底，资料是拉开差距的

最好每次做套题都计时。资料对时间的把控特别重要。

技巧性强。因此做得快与慢，准确与否，就差得非常多

掌握技巧，尽量熟悉；刷题做题，保持手感。

资料这部分可以多看一些老师，因为不同老师有不同老师的技巧。个人认为多学一些是没坏处的（但是还是要形成自己的体系，避免技巧太多不知道用哪个）

推荐老师:

刘文超、齐麟、高照、花生十三
小红书 @拥抱昔日温度：第一视角做题，非常强，看厉害的人是怎么做题的，然后尽可能去模仿，对自己的提升会非常大。

（五）数量关系

“内幕”：不同于国考，福建选调的数量非常简单，至少 2023。年是这样。

因此，定要留时间给数量，把分拿下。

因此，做其它部分更要尽可能快。

申论

推荐：人民日报申论精读（小红书）

仅针对福建选调

标点不占格

分点作答

多写对策

注意时间，尽量写快点

...

福建选调生申论考试时间为 90 分钟，总分为 100 分，近几年题量均为 2 题，而且更注重结合基层问题、民生问题、福建省省情的相关材料进行考察。

内容与普通公考申论类似，考查综合分析题、归纳概括题、写作题（议论文），其中乡村振兴是常考题。

注

（1）篇幅：选调笔试中申论材料一般为 6~9 则，字数在 7000 左右，这就意味着材料字数相对较多，对于考生在材料的阅读理解能力的要求更高，同时提醒各位报考选调的考生需要合理安排时间，在思考全面的同时提高作答效率，做到事半功倍。

（2）题材：申论题材常与选调生到基层工作的内容联系密切，与福建本地的实际情况密切联系，具有较强的实际意义，所以大家可以关注一些本地的新闻时事。

面试

考察人选从最低合格分数线以上的人员中确定。本、硕选调生考察人选按报考地区计划数 1 : 2，从高分到低分依次确定。

1. 面试方式

选调生面试为半结构化面试，即面对面交谈模式，面试时长不固定，有点像企业面试。省委组织部会到各高校进行考察，考察分为两轮。每轮时间一般为 5-10 分钟不等，也有学员出现面谈达 30 分钟的情况。

2. 考察对象

选调考察会安排分管学生工作的领导、班级辅导员、班干部 (1-2 名) 以及同学舍友 (1-2 名) 进行谈话。一般谈话结束后进行考生面谈，根据高校的不同，会出现顺序调换的情况。

3. 面试真题

2025.06.28

Sat, 28 Jun 2025 00:00:00 GMT

前阵子暑期实习挺不顺利的，人很丧，没自信，没目标，也错过了很多机会...

唯一有希望的华子也泡死在池子里了

想回到暑期前重新开始，但没办法，回不去了，这就是生活

就好像我这辈子也回不到大一/大二的学习状态一样

或者说，人这一生，都不能走回头路

很多年来，我一直持续在问自己一个问题，怎么就变成这样了呢？

最近，这个问题变成了，害，那又能有什么办法呢 😮‍💨

看到一个北大的哥们，比我晚入池，前几天就开奖了

hr 和我说，或许这就是北大的魅力吧

颓废在宿舍刷视频的时候，经常刷到蜡笔小新和海绵宝宝，不得不说在那个年代，做的是真好

小学的时候是最应该看蜡笔小新的时候

高中的时候是最应该看斗破苍穹的时候

但我研究生的时候才开始沉迷这俩玩意

不过仔细一想，我现在和高中时候确实有点不一样了，比如高中时候我玩 LOL 宁死不投，现在我看打不过了 15 分钟就上票了，不能让对面虐菜爽

能打过我的人，我不给他们打

人总应该是有点变化的，但我最近又有些新的理解了，成长是一件很难的事，它甚至意味着从头去修改你的一部分人生意义

打个比方：你连体重都控制不了，怎么能控制自己的人生呢？

朋友说没办法，现在大伙都找着了工作，体重确实不好减

真不好减，最近东子、团子和阿里打外卖价格战，快给哥们喝出糖尿病了

哈哈哈

有个好朋友跑北京实习了，还有一个去了杭州，在厦门读书时哥几个总是经常打哈哈，不过一到上班，感受又不一样了

嘿，你已经和这么多人走散了呀

大多数人分开后就不会再见了，大多数人或许还有再见的机会

聚散离合，此乃常态，你要习惯

回忆会陪你一生，即使再模糊，你还是忘不掉

有些事并不是一件需要被解决的事情，而是一件需要被接受的事情，或者说，绝大多数的事情，都只是需要接受的事情，你解决不了

比如在地球 online 度过的这二十来年来看，目前我就这样一人，改变的话起码要拿年来衡量，或者十年来衡量

最近大模型发展的太快了，还记得 22 年刚出 GPT-3.5 的时候，有人感慨涌现就像宇宙给的礼物一样神奇，现在已经没有人再发出这种感慨了，默认大模型就存在和人类差不多甚至更强的智力了，没有上古时期 NLP 用 BERT 胡言乱语的折磨

也不知道为什么，这些年，身边的人总会有种觉得我很厉害的错觉，拜托，我要是真厉害，我还用发愁这些毕业、就业的事么，这样鼠鼠就不用吃生活的苦了，本就不好的胃也可以吃软饭度日了

有时候就觉得自己活得很荒谬，明明近来也没谈恋爱，三天两头垂头丧气跟失恋似的

朋友问我怎么情绪不对，我总不能告诉他最近暑期挂麻了，看不到未来吧

可我不是

It is still summer, but mine is over

没记错的话，是某一年高考的完形填空

如何利用「人民日报」提升申论？

Wed, 25 Jun 2025 00:00:00 GMT

Link: https://www.zhihu.com/question/288739522

已购资料：

电子版｜2025 年人民日报时评（2025.01 ~ 2025.12）

纸质版｜人民日报时评 45 篇（2024.05 ~ 2025.04）

纸质版｜申论背诵规范词

总有公考大神和培训老师跟你说，学写申论就看人民日报。但实际上，如果你不懂看人民日报的技巧，你去刷人民日报 app 纯粹是浪费时间！

今天就专门讲讲人民日报 app 应该怎么用。

看人民日报 APP 什么内容？

我们只需要点击“人民日报”四个字，就会有电子版的人民日报。

只看第五版的《评论》

只看第五版的《评论》

只看第五版的《评论》

评论版块里的文章还可以点击，然后变成更加方便阅读的网页格式。

重点选看对象

评论这个版块涉及的话题范围比较广，不是每一种话题都要重点研究。

🔥重点看：民生、教育、医疗、养老、住房、食品药品安全、生态环保、文化、放管服改革、精准扶贫和乡村振兴等。

这些话题都有可能成为申论考试内容，一定要条分缕析地去研究。

🥚粗略看：政治建设、司法改革，还有特别专业的比如金融。

这些话题一般不会成为申论素材，只要大概看看文章结构、论证方式就行了。

在评论这个版块里面，大家要特别留意“人民时评”类文章，就是下文箭头所指的。

人民时评文章主要针对社会热点，作及时、准确、深刻的评论，其观点鲜明正统，文风清新流畅，是我们学习的主要对象。

要想跟人民日报学习申论，其实最有效的方法不是通过 app 来看，而是应该把人民日报评论文章都收集起来，当成申论教材，系统研究。

下文会继续讲解如何系统研究，从而临摹人民时评，形成自己的高分申论文章。

怎么看才有用

时评文章与今日头条、新浪新闻那些庸脂俗粉不一样，不能一看而过，而是要再三品尝。

每篇时评文章要从粗到细看 4 遍，就像拍电影，先远镜头拍个轮廓，再慢慢拉近，拍细节。

阅读前，要准备好本子和笔，边看边写。

第 1 次：看大概，从头到尾浏览，了解文章基本内容；
第 2 次：看结构，提炼思维导图，写在本子上；
第 3 次：看段落，分析独特、可借鉴的论据和论证方法，标注在思维导图上；
第 4 次：看语句，摘抄万能句和文采句。

空说无益，我们举个栗子。

第 1 次：看大概，了解基本内容

读完第一遍，我们知道：这篇文章主要讲了青少年网络沉迷的相关问题。

准备看第二遍，记得边看边画思维导图。

第 2 次：看结构，画思维导图

思维导图不用非常精确，更不用讲究是否美观，只要能让你回忆起整篇文章就好。

第 3 次：看段落，分析论据和论证方法

现在我们准备进行第三遍。细看每一段，具体用了哪些论据和论证方式？哪些值得我们写申论文章时候照抄？

为了方便阅读，大家可以把每段值得借鉴和模仿的地方标注在段落的后面。

大家在做自己的读书笔记时，可以把这些内容，用不同颜色的笔迹，简要标注在你的思维导图上。

遇到特别典型、特别适合搬到申论试卷上的时评文章，还可以把文章打印出来，贴在读书笔记旁边，并把你对优秀段落、语句的分析标注在文章上。

第 4 次：看语句，摘抄万能句和文采句

现在准备开始第四遍阅读。

这一遍要找万能句——那种换个主题词，就能直接搬到我们申论文章里的句子。

不但要找出万能句，还要弄明白这种万能句要怎么用。

按照上图的要求，把万能句分类摘抄到本子上。

阅读一定数量的时评文章后，各类万能句也会越积越多。

到时，你可以把相同作用的句子汇总起来：

比如引出总论点的句子，全部汇总到一个文档里；
引出原因的，全部汇总到一个文档，如下图 ↓ ↓

最后一步：感悟分析

上了考场，随便从你这个积累文档中挑出几个句子，就能写出一篇行云流水般的申论。

四遍读下来，你的本子上已经有了思维导图、论证标注和语句摘抄。

此时你还有最后一个任务 —— 写“感悟分析”。

“感悟分析”没有字数要求。有话则长，无话则短。

既可以分析文章的亮点和值得借鉴学习的地方，比如第三遍阅读，你收获的论证方式和论据，也可以是你对文章话题的思考。

很多人都有这种感觉，看过的书或者文章，不管看的时候多认真，隔几天或者几小时，就全忘了。

时评文章不是普通的故事或小说！

你一定要想方设法让自己记住。

通过写感悟分析，一方面加深你对文章的理解，防止看过就忘，另一方面倒逼你勤动脑多动笔，慢慢提升文字水平和思想深度。

综上，阅读人民时评的方法，

今天唯一的知识点：“3个一”！！！

一个思维导图、一些摘抄和一段感悟分析。

比如例文最后完成的“3个一”，如下图 ↓ ↓

时评文章不是每一篇都结构清晰，建议大家实践“3个一”时，从易到难。

2025.06.18

Wed, 18 Jun 2025 00:00:00 GMT

离开学校越久越感觉到，努力和运气，好像运气更重要

在学校里不管是找工作还是上课大多都是单线程的赛跑，努力大多数是能得到反馈

但工作后才慢慢意识到，努力和实现目标并不是 causal relationship，更像是 multivariate regression

努力并不能解释一切，但现实是还有一大堆变量和你控制不了的 noise

你拼了命优化自己的 loss function，结果人家模型早就加了一个隐藏变量叫「时机」或「运气」

2025.06.17

Tue, 17 Jun 2025 00:00:00 GMT

从小到大，没穿过什么名牌衣服，没去过什么名胜场所，没学过任何才艺，也没坐飞机出过国。

中学后，我的成绩就一直不好，高考发挥不尽人意，去了家乡附近一所普通大学。四年里，也没意识到学习的重要性，成绩平淡，目光短浅。

庆幸的是，这些年来，我也读了很多书，去了很多地方，结交了几个挚友，写下了一些见闻，从波澜壮阔的星空，到至今馋味的寿喜烧。我还有着一些渺小的心愿，并一直在为它偷偷努力着。即使遥遥无期。我希望我的坚持，可以弥补运气和先天的不足。我也知道在这个世界上，有很多我穷尽一生都难以望其项背的人。但是我希望自己再普通，也要活出一点点不一样的光芒。我讨厌以前的自己，我想要变得有趣，变得特别，变得开朗。变成王小波说的那样，有好多奢望，一瞬间天上忽明忽暗的云。在这个一生的黄金时代，年轻人如果你感到现在很辛苦，就快要坚持不下去了，请为未来感同深受的自己，再坚持一下吧。

一事无成并不要紧，重要的是：拜托别像以前的我那样，每天丧气满怀、无精打采的，这个世界也是亮晶晶的。

太阳明亮，水波温柔，街道车如流水马如龙，每个人都在为了更好地自己奔波着。

树木蓬郁，微风和煦，这个少年，你也可以有着不一样的梦想。

2025.06.14

Sat, 14 Jun 2025 00:00:00 GMT

前几天，有个好久不联系的朋友问我，“这些年，你过得还好吗？”

哈哈哈，当然过得很好呀。

因为在绝大多数情况下，我过得不好，也没有勇气说出来。

有时候晚上一个人漫步在晚风里，月光落在身前，夜幕下的路灯和飞虫都显得落寞。

今年过了生日，我就二十五岁了。

这个年纪，身边的人好像都在往前走。毕业工作，买车买房，甚至是结婚生子，似乎只有自己留在了原地。

我以为二十五岁的我，会像个大人一样，在风里雨里奔跑，却没想到喜怒哀乐仍在脸上。

走在路上被小朋友叫叔叔了，会不开心。

常常在路边和偶遇的猫咪对叫，望着天空漂浮的云朵，发呆、思考，想着一些不切实际的事情。

只是有时候，想找人出去散散步时，却发现好像已经没了，可以约出来的朋友了。

恍惚间发现，原来自己真的不是个孩子了。尤其是看着身边的同学、朋友陆续结婚生子，会莫名地感到心慌。

爸妈，好像也已没了当初的活力，自己却还不能好好地照顾自己。时间只是让我成长了年岁，却还没让我成为一个合格的大人。

以前，我不能理解年轻人的丧。在我的认知里，从小到大的教育就在告诉我，要用自己热爱的方式过这一生。

后来，我才明白，这只是一个理想的状态。

我们绝大多数的人，最终都会回到世俗的生活里，为家长里短，为柴米油盐烦恼着。

不知从哪一天开始，只是简单熬一下夜，第二天起来做事，就会浑身没劲。我知道那个曾经炙热的少年，就已经与我渐行渐远了。

可能成长，就是在不断地放下着东西。

后来，我渐渐学会了收起自己的锋芒，把委屈藏在心中，说话做事都有所顾虑。在处理问题时，早没了当初初生牛犊不怕虎的干劲……

隐忍妥协，但有时候又会庆幸自己，依旧有着世俗无法改变的东西。比如说学不会抽烟喝酒，学不会逢迎欺骗，也有着自己的清高与小傲娇，还是那样喜欢沉浸在自己的世界里。

还是会有孩子的心性，比如说贪玩懒惰。

看着别人事业有成的时候，又会陷入焦虑，觉得自己这个样子不思进取，但却没了耐心和心思去学习。

其实，自己并不是个不喜欢分享的人。只是在大多数情况下，没人愿意聆听我的琐碎。

所以，我很沉默，一直都沉默。

朋友圈已经慢慢没了生活的痕迹。

身边的绝大多数人，好像都选择了三天可见。

我觉得挺好的，因为现实里很少有人会真正关心你。大部分的人，根本不会多看一眼你的动态。

我们这一生，注定会被很多人路过，也会路过很多人。

可能只有等到哪天，真正遇见同频共振的那个人，才会像只刺猬样敞开心扉，让彼此看看内心深处，不为人知的优雅。

或许相遇的那天，我会因为历经孤独，而格外懂得珍惜。

以前我总以为，人生最美好的是相遇。后来才明白，其实最美好的可能是重逢。

因为人生里的很多告别，都是毫无征兆的。那些悄无声息的离开，或许是永久的沉默和不回头。

后来的我们，不再去追问心知肚明的答案，也不再轻易地将自己的情绪表露出来，开始尝试去做一个不动声色的人。

那些曾以为生命之不能承受的事，就像是散落在风中的银杏叶，随着成长亦被岁月带走。

那些曾以为刻骨铭心的经历，或是痛苦难捱的日子。后来提及，两个字就足以概括。

从前，从前。

其实，自己这些年来，也并不是过得一点都不快乐。

比如说在路上遇见的快乐小狗，久违的文章动态还有人给我点赞，这些就足够让我快乐。

但又好像不算是真的快乐，只是在一阵短暂的欢愉后，就没了动静。再也没了那种小时候，可以为一件事期待好久好久，就算是得到了还会一直回味的感觉。

小时候的我无忧无虑，却总想着长大。长大后，却又开始怀恋小时候，或许是我还未做好准备，接纳成年人这个身份罢了。

我记得小时候，姥姥家的院子里，种着一颗大银杏树。每年春夏，枝头总是挂着一片绿意。等秋天一到，金灿灿的叶子就在风中招摇。

风将落叶带去远方，天空飘着的云很是明亮。

我只是安静地看着，邻居家那只爱趴在我家屋檐上，呼呼大睡的肥猫，就能虚度一下午的时光。

不知那时候，我们在树下一起追逐玩闹的孩子们。现在，你们怎么样了？这些年来，过得还好吗？

当我在写这篇日寄时，正在为学习和生活上的一地鸡毛而烦恼着。不知你们会不会也像我一样，在过去或未来的某个时刻，也在怀念着那个无忧的年代。

落叶随着风一阵摆动，家乡的银杏树一直都在，可是我已经回不去了。

老友记

福建·福州

Sat, 14 Jun 2025 00:00:00 GMT

老友记

2025.06.11

Wed, 11 Jun 2025 00:00:00 GMT

我一直觉得，我以前和现在，本质上并没有太大的变化，直到我看到曾经自己写的日寄

我需要承认，我和以前不一样了

我不再敢打敢拼，不再义无反顾，我会犹豫，会权衡利弊，会害怕未来，会怀疑自己

厦门今天的天气很不错，夜晚有风，但一点不冷，白天 30 度的余热还没散去，风吹来只觉得凉爽

很像大三刚保研完在湖边吹风的那个夜晚，意气风发

哎，这一路走来，给过去的我丢人了

我在想，人总会告别这个世界，如果是生病的话，应该会有一个时间周期，如果真有这么一天，我不希望你遇到我时，和我说你有多舍不得我，什么没我不行，什么明明知道没有希望还鼓励我的话，什么没有你日子怎么过，你有什么事情还没有做，等你好了我们一起去xxx怎样

我更想听的是，你有多么怀念我，我这辈子已经完成了什么，告诉我接下来的日子没有我你们仍然会好好过

这就足够了

《悉达多》

Wed, 11 Jun 2025 00:00:00 GMT

1919年，赫尔曼·黑塞开始写《悉达多》，当时他40多岁，刚结束了战俘救济的工作，唯一的经济来源是出版社的资助。

当时的环境对黑塞乃至整个世界的作家来说，都是一次巨大的冲击。

与此同时，他的妻子因为精神分裂经常需要住院，在这样的情况下，他不得不把自己的三个孩子寄养到朋友家。

毫无疑问，此时黑塞的人生正在走夜路，人在陷入困境的时候，难免会想：自己为什么来到这世间要受苦，人来到这世间究竟是为了什么？我们来世间走一趟真正重要的是什么？

带着这样的疑问，黑塞用三年时间写出了《悉达多》，他把自己的人生经历融入到悉达多的经历里，追问世界的真相，探寻人生的意义。

悉达多这一生经历的困惑，年轻时期的叛逆，中年时期的沉沦，晚年与孩子的别离之苦，这也是千千万万普通人会经历的一生。

《悉达多》的译者姜乙曾经这样评价黑塞以及他的作品：他永远能找到他的读者，读者也永远能在100年前写的书里找到我们当代的生活。

普通人和悉达多唯一不同的是，悉达多一直经历着，一直感悟着，最终他证悟涅槃了。

悉达多离开父母，离开家乡，和乔文达跟沙门们出发去修行，他们是很纯正的修行人，每日除了打坐、化斋，听师父们讲经文、讲道义，无它。

修行初期的悉达多认为，这世间一切都是欺骗，一切都是谎言，欲望、幸福、美丽都是虚的，活着就是一种折磨。他觉得只要达到无我的境地，他就能觉醒，继而发现那个更大的秘密。

看起来这样的修行才离涅槃更近，可为什么悉达多最终选择入世呢？

因为有一天他突然发现事情不对劲，他出世的时候确实学到思考、等待、斋戒、三个本领，但这三个本领真的必须要在沙门队伍中学得吗？

答案当然是未必。禅定和斋戒都是暂时从“我”中逃离出来，这种逃离通过喝酒也能获得。

悉达多跟乔文达说，他觉得修行和求知欲并没有让他们离解脱更近，他们一直在原地踏步。

每次读到这里我都大为震撼，一语惊醒梦中人啊，现实中也有些修行人，会专门腾出一段时间去寺庙吃斋饭、打坐，可是回到现实，他依然是原来的他。

还有些修行人，他们不用去修行团，每天在家冥想一段时间，剩下的时间就好好经营生活，有问题就处理问题，没问题就去思考关于自身的问题。

其实，真正的修行不在别处，而在生活的每时每刻中。

智慧无法通过学习得来，只有通过自己经历、觉知、感悟，才能真正转化成自己内在的东西。

悉达多和乔文达找到乔达摩后，听了乔达摩的法义后，乔文达决定跟随乔达摩，但悉达多决定开启自己的求道之路，走之前他跟乔达摩说，您的法义让我敬佩，它如此清晰，没有瑕疵，但中间却有断裂之处。

也就说，这些法义并没有能解决悉达多内心的疑惑，他没法证实通过学习这些法义，就能脱离苦海。

我们每个人都是如此，听过很多道理，却过不好这一生，因为这道理是别人从生活里悟出来的，而我们只是道听途说，真正用的时候，要么想不起来，要么根本不会用。

众所周知，人要对家人耐心一点，毕竟他们才是这世间除了自己之外最亲的人。

但现实中很多人总是把和颜悦色留给外人，把最狠最毒的话刺进家人的身体里。

有人吃了亏才能懂得一些道理，有人撞了南墙才能学到智慧，有人被骗过才能人间清醒，所有的道理只有通过检验才能转化成自己的经验，反复练习才能成为自己的行为模式，最终达到知行合一的效果。

每个人的内心都有很多执念，我们渴望家人的爱，想要朋友常伴身边，希望和爱人相守，也渴望跟儿女长久相伴，互不生厌。

随着时光的流逝，父母离开我们，朋友渐渐走散，相爱的人渐渐疏离，孩子们会径直走入自己的世界，所以，有人说，长大就是失去的过程。

但再想想，这些执念不过是我们一厢情愿的臆想，而世间万物有自己的运行规则。

你有你的安排，世界另有安排。

小时候，我们总以为自己是世界的中心，长大后才发现，人这一生都在一个巨大的游乐场里，甚至这个游乐场都不是由时间和空间构成的二维空间，它可能是三维甚至更大的空间在主宰着。

正如《正见》里的一句话：我们的血肉，我们所有的情绪，我们所有的觉受，都是由两个以上的元素组合而成。

也就是所谓的世间万物都是由因缘和合构成的，所以无常才是常态。

我们很容易遗忘它，继而进入一种痛苦的轮回。假如我们时时刻刻带着因缘和合觉知，就会明白自己经历的一切都是合理的。

父母为什么会离我们而去，因为人一旦出生，死亡就是固定的结局。

朋友为什么会渐渐走散，因为当初维系你们之前关系的纽带已经不在，渐行渐远也就不足为奇。

爱人间之所以会渐渐疏离，因为每个人都在变化，关系模式不调，就是会越来越远。

孩子们为什么离我们越来越远，因为他们对世界充满好奇，而我们总是跟他们讲旧故事。

且不说这么人际关系这么复杂的事情，即便是你想在家吃个白水煮蛋，都需要讲究因缘和合。

首先你要有一个鸡蛋，还要确保家里没停水，燃气可以使用，煮蛋的锅是完好无损的，最后你还要确保你有把鸡蛋煮熟的时间，然后才能拿到一个煮熟的鸡蛋。

悉达多跟乔文达曾经因为有共同的目标，所以同行了一段时间，之后悉达多觉醒了，他走向了另外一条路，所以，他告别了朋友。

他遇上了船夫，渡过那条河，继而遇上迦摩罗，学习爱经，遇到商人，学会经商，遇见赌徒，成为赌徒，当他发现自己沦陷到世俗中时，他选择再次出世，这一切都是因缘和合，也都是无常。

普通人的生命也是这样，孤独地从生命的每个角落走过，承受不一样的玷污，承担属于自己的罪过，反反复复地跟自己和解，寻找一条属于自己的出路。

这世界上没有两片相同的叶子，也没有两个相同的人，我们都是由无数人的碎片组成的独一无二的个体，生命里经历的人和事情都是合理的。

史铁生有句话非常完美的印证了这样的观点：其实我们每时每刻都是幸运的，因为任何灾难的前面都可以再加上一个“更”字。

所以，生而为人，一旦体认因缘和合，接纳无常，人就不用费劲去跟事情本身对抗，也就可以少受很多苦。

既然无常是常态，那无论当下处于何种困境，只要你一直有在做些什么，就有极大的概率能从中走出来。

悉达多曾经期待过人生圆满的状态，而乔文达这一生都在等着自己证悟涅槃那一刻。

人类真的很喜欢谈未来，总觉得未来会更好，世界会更美好，人生也会更圆满。

于是，我们从小到大一直在等，小学等到中学，中学等到大学，大学等到工作，工作等到退休......

或早或晚，我们都会发现：哎，不对啊，万一我们活不到退休，之前的等待不就是在浪费生命吗？

原来我期待的圆满的人生，不会到来，换句话说，每一个当下就是圆满。

在悉达多生命的最后阶段，他跟乔文达说：一切皆有定数，一切只需要我的赞赏、顺从和爱的默许。

老年时期的悉达多跟船夫一起渡人，有一天他遇见了迦摩罗带着他们的孩子来到河边，去追随乔达摩，但却死在了他的身边。

他本想把孩子留在身边，好好照顾，但孩子想要回到富丽堂皇的家乡，享受佣人的照顾，享用锦衣玉食，他试图挽留孩子，但船夫让他去问问河水，河水只是笑他，颤抖着笑他的愚蠢。

最终，他选择放手，让年轻人归于年轻人。

每当他想要去找回儿子，船夫都让他去听听河水的意见，经过多次重复后，悉达多不再和命运搏斗，也不再和自己的想法作对，他脸上才呈现出真正喜悦。

其实，人生没有所谓的遗憾，一切经历都是最好的安排，生命的每个瞬间都是独特的，美妙的。

失业意味着有时间好好做个总结，梳理自我的得与失，也可以趁机想清楚下个阶段人生究竟要去向哪儿？

结束一段亲密关系，意味着可以回顾自己在亲密关系里的行为模式究竟被什么控制，找到爱自己的方式，再去思考自己需要什么样的爱人？

不要只是探求目标，而是要去发现，发现生活的要义，生命的有趣之处，自由、敞开、没有目的地沉浸在当下，发现生活给我们的启示。

我特别喜欢史铁生在《病隙碎笔》中的一句话：

人可以走向天堂，但不可以走到天堂。走向，意味着彼岸的成立。走到，岂非彼岸的消失。彼岸的消失即信仰的终结、拯救的放弃。因为天堂不是一处空间，不是一种物质性存在，而是道路，是精神的恒途。

生命是一个过程，而不是一种结果，抱着凡事发生皆有利于我的态度认真生活，就会发现任何体验都是财富，也都是命运附赠的礼物。

无论世事如何变迁，都要爱生活，爱命运，毕竟我们也只来这世间一次，要好好体验，才不算浪费。

《悉达多》并非佛陀的故事，而是讲述了一个普通人一生的经历。悉达多经历了学习、苦行、聆听教义、觉醒、堕入世俗、悔恨、修行、学会爱，最终在内心平静中修得圆满。这也是每个人追寻自我生命意义的过程。一个人必须亲身去经历，任何教义和知识都无法让人真正明白道之真意，任何言辞也无法替代自身的体悟。用心去感受一切，不拘于表象，总有一天，我们都会找到自己。

📷 相机与摄影的知识科普

Wed, 11 Jun 2025 00:00:00 GMT

2024 最佳相机

关于相机，可以先看看影视飓风 2024 相机颁奖频道。

影响相机成像质量的因素

大体来讲，相机拍照只需要两个部件：镜头和传感器。其他部分都只是起到辅助功能，而这两个部件几乎决定了画质水平。

镜头

判断镜头的标准有很多，总的来说，定焦镜头的画质比变焦镜头好，小变焦镜头画质比大变焦镜头好。但镜头变焦能力越强，使用场景就越丰富，能拍摄到更多画面，所以变焦和定焦并没有绝对的好坏标准。

镜头的最大光圈则是越大越好，大光圈镜头一次可接受更多光线，暗光拍摄效果好，最重要的是大光圈能带来更好的背景虚化效果，凸显主体，拍摄出梦幻的画面。定焦镜头通常体积也更小，光圈也容易做到更大。

传感器 · CMOS

首先我得科普一下传感器也就是 CMOS 相关的知识，摄影圈经常有一句话：底大一级压死人（底，一般指 CMOS 传感器）。

传感器方面，像素数量决定了清晰度，但最重要的还是传感器尺寸，这也是一台相机最容易直观比较的部分。同技术条件下，大尺寸传感器相比小尺寸传感器拥有更大的单像素尺寸和更高的像素数量，暗光下拍摄噪点更少，画面更清晰。

常见的相机传感器尺寸由小到大依次为：

1/2.3 英寸
1 英寸
M4/3 画幅
APS-C 画幅
全画幅
中画幅

1/2.3 英寸传感器相当于手机传感器的尺寸，如今我们并不太推荐购买 1/2.3 英寸的相机，他们的画质水平已经赶不上拥有先进双摄算法的手机了。

提升传感器尺寸能非常直观地提升画质，画质出众的相机，无不采用大传感器。但传感器也不能无限制地做大，镜头的体积和传感器尺寸是三次方的关系，需要在画质和便携性上作出取舍。大多数采用大型传感器的相机都采用体积小巧的定焦镜头，牺牲了变焦能力，这也是为了体积和画质作出的妥协。

单反相机中全画幅与中画幅的区别，如何选择合适的画幅？

画幅指的就是感光原件的大小（胶片就是指胶卷的尺寸，数码就是指传感器的尺寸）。对于画幅我们可以用 135 全画幅（或者称 35mm 全画幅）作为标准。

比 135 全画幅更大的，就是中画幅和大画幅了。如果是数码的中画幅，非常贵，只有职业的风光或者商业摄影师才会选择。至于大画幅，数码的简直就是天价，一般都是特殊定制。玩中画幅和大画幅胶片也不会太便宜。所以几乎没有从这入门的。建议你拍到一定程度再考虑。

135 全画幅（35mm 全画幅）又是怎么回事呢？话说很久很久以前，有个叫奥斯卡巴纳克的人做了一台叫徕卡的相机，后来这相机一直活到今天。这台相机就是用 35mm 宽的打孔电影胶片做底片的。所以这种相机叫 35mm 相机，一张底片的大小就叫 35mm 全画幅。后来柯达看着事儿能挣钱，就搞了一个一次性胶卷盒，于是大家就有了简单方便的胶卷。1 表示一次性，35 表示 35mm，于是这种胶卷就代号为 135 胶卷。使用这种胶卷的相机就叫 35mm 相机或者 135 相机。这种画幅尺寸除了叫 35mm 全画幅，也叫 135 全画幅。

135 全画幅的传感器尺寸大小就是 36mm × 24mm，就是我们曾经用的最常见的胶卷的一张底片的大小。虽然曾经的胶卷叫 35mm（宽）胶卷，但是因为两边有打孔，所以实际成像的宽度就是 24mm。

135 相机在胶片时代可以说是用的最广的。

相机进入数码化之后，理所当然所有的数码相机应该也是 135 全画幅相机。但是因为电子传感器曾经很贵，于是很多厂商向成本妥协，推出了小传感器尺寸的各种版本相机。

主流的就是 APS-C、M43 和 1 英寸。

大家记住一点，不管厂商怎么宣传自己的传感器尺寸更加合理，凡是比 135 全画幅小的都是要么向体积妥协，要么向成本妥协。如果这相机体积没有特别小，一定就是向成本妥协了！

同时代的数码相机，传感器尺寸越大，成像越好，这是一定的。所以我们尽量选择大尺寸传感器。另一方面，中画幅的数码相机因为其往往针对特殊领域，所以画质特别好，但是机身性能一般。

目前这两年最好的选择就是 135 全画幅数码相机，各个方面比较平衡，一定要选择这样的产品。如果您因为暂时的预算问题，无法购买 135 全画幅相机，那么也要做好未来购买的准备——毕竟相机价格越来越低了。

基于这一点，我们选择相机就不难了。

中画幅其实是比全画幅（35mm 全画幅）更大的传感器尺寸。目前主流中画幅传感器大小是 44mm × 33mm。

更大的传感器，意味着什么呢？一般来说：

1、更加优异的画质 ✅

2、更加出色的背景虚化能力 ✅

3、更大更加不便携的体积 ❌

4、更贵的价格 ❌

在我看来，如果未来中画幅 645（44mm × 33mm）体积控制下来的话，将是民用神器。不过可见的未来，135 全画幅才是王道。

记住，底大就是正义（底，一般指传感器），底大一级压死人。所以其实选择画幅的话，理论上肯定是越大越好，但是越大的画幅其实意味着相机越大越重，所以目前的话如果是刚入门或者刚学习摄影，我认为全画幅的可玩性还是更强的，价格也是更便宜一些。

如果说你对于画质像素等有更高的追求，那么我觉得你可以选择中画幅。

焦距/焦段是什么，如何选择合适的镜头？

焦距是镜头上最重要的参数之一。

比如一支镜头：Canon EF 70-200mm f/2.8L IS II USM

其中 70-200mm 就是表示了这支镜头的焦距，是从 70mm 开始的，到 200mm 结束
焦距有两个数字表示这是一支变焦镜头，焦距覆盖了从 70mm 到 200mm 的整个焦距段
200÷70≈2.86：所以这是一支 2.86 倍的变焦镜头

再比如：Canon 50mm F1.4 USM。

其中 50mm 就是这支镜头的焦距，只有一个数字表示这是一支定焦镜头

焦距一般是一个以 mm 为单位的数字，这个数字又是干嘛的呢？

这个数字越小，我们叫焦距越短，我们的视野就越宽，取景范围就越广，画面中容纳的景物也就越多，但是每个景物在画面中占的面积就越小
这个数字越大，我们叫焦距越长，我们的视野就越窄，取景范围就越窄，画面中容纳的景物也就越少，但是每个景物在画面中占得面积就越大

超广角

超广角一般指的是 24mm 以下的焦距，因为视角大，所以适合拍摄大场景，建筑，风景，都是可以的。因为往往可以离很近拍摄，所以有很强视觉冲击力，也很适合新闻摄影拍摄

24mm 和 28mm

这就是一个标准的广角焦距，主要就是用来拍摄风景。当然拍摄到此一游照也是很好的。如果你非抬杠说也能拍人像，确实也能，但是这个焦距的风光片要远远多于其它题材。24mm 相比 28mm 来说，就是更广一点，所以更好。

35mm

有人说这是大师的焦距，也被称为人文眼。简单地说就是拍摄人文最好的焦距。之前有人问我：你之前不是说 85mm 不是拍摄人像最好的嘛？为什么又说 35mm 是拍人文的？恰恰一字之差，有了这个区别。拍摄人像是要突出人，自然要弱化背景——要么裁切出画面，要么背景虚化掉。85mm 擅长的就是这个。而拍摄人文照片的时候需要主体和背景环境的关系，所以小广角的 35mm 既能够将背景囊括进来，又可以保留足够的景深。

50mm（标准镜头）

这被称为标准镜头，人文、人像都是很好的，也是大师的焦距。对于 50mm 标头的表述实在太多太多。我只说一点吧，我遇到过的人大多数要么喜欢 35mm（比如我），要么喜欢 50mm（比如布列松），这种差异基本上都是表现在人文拍摄时你习惯的视角。所以我觉得这俩焦距用好一个就不易，挑一个，一直坚持下去吧。

85mm

说得很多了，就是拍摄人像的镜头。能有很好的背景虚化效果，很好地画面裁切能力，还能保持和模特之间适当的交流距离。

标准变焦镜头

一般就是 24mm 或者 28mm 起跳，70mm、85mm、120mm 左右截止。基本上就是你日常挂机的镜头，适合的题材很广。

100mm

这个焦距左右集中了最热门的一些微距镜头，因为拍摄距离适中。

135mm

也是拍摄人像的焦距，就是需要离人远一点。

200mm 和 300mm

这就是妥妥的长焦了，拍摄鸟类啊，荷花啊，运动啊，那种离得不是很远的就可以打得到了。同时也有不少用这个拍摄人像的，因为大光圈的背景虚化效果超级强烈。

超长焦

300mm 以上，野生动物、运动题材等等。也用于狗仔偷拍什么的。拍日出日落，满月弦月什么的也挺好的。初学者别觉得超长焦多牛，基本上不是做这类型题材的，很少用得到。

最后的最后

最后说一句，没什么是一定的，所以别和我抬杠非说我就要用广角拍人像，长焦拍风景。其实都可以，只是从出片量来说，某个焦距确实适合某些题材。

📷 摄影作品集

Wed, 11 Jun 2025 00:00:00 GMT

2025.05.21 华为笔试题

Wed, 21 May 2025 00:00:00 GMT

题解链接：https://mp.weixin.qq.com/s/DawyjMfoNpKxmRfqqJR9hg

测评链接：https://niumacode.com/training/127

1. 开发一个简单任务调度系统

你需要开发一个简单的任务调度系统，该系统按任务优先级调度，优先级范围是 $(0, 99)$，数值越小优先级越高。只有高优先级任务执行完成后，低优先级任务才能执行，同等优先级的任务按照 $FIFO$ 原则，先进入调度系统的任务会优先调度，当优先级任务执行时，如果新增高优先级任务，高优先级任务会抢占低优先级任务。

请你实现一个程序，模拟这个任务调度系统。

添加任务：将一个新任务添加到任务调度系统。任务包含一个唯一ID（task_id）、优先级（priority）$[0,99]$，运行时间（time）$[1,10000]$。
执行任务：任务调度系统按照调度策略，调度任务并执行。调度系统调度任务，并消耗对应时间片，时间片范围 $[1,100000]$。

Input

程序需要处理以下类型的输入：

添加任务 add task_id priority time
执行任务 run time

注：

输入命令总行数不超过 10000 行
run 命令可以有多个
空行即命令结束

Output

显示任务调度系统当前执行的任务 ID。若无任何任务，则显示 idle。

Sample 1

输入：

add 101 0 10
add 20 1 3
add 300 0 1
run 11

输出：

样例 1 解释：

add 101 0 10：添加任务 101，其优先级为 0，运行时间为 0 个时间片
add 20 1 3：添加任务 20，其优先级为 1，运行时间为 3 个时间片
add 300 0 1：添加任务 30，其优先级为 0，运行时间为 1 个时间片
run 11：调度系统调度任务并执行。首先调度任务 101，运行了 10 个时间片，任务完成。接下来调度任务 300（其优先级高于任务 20），运行了 1 个时间片，任务完成。此时消耗完全部运行时间片（即 11）。
此时调度系统要运行的任务 id 即为 20

Sample 2

输入：

add 1 0 10
run 11

输出：

idle

样例 2 解释：

add 1 0 10：添加任务 1，优先级 0，运行时间为 10 个时间片
run 11：调度系统调度任务，并运行 11 个时间片。选择任务 1 运行了 10 个时间片，任务 1 完成。无任务待调度。
调度系统无任何任务，因此显示 idle。

Solution (False)

每执行一次 run 则输出一次结果

#include <bits/stdc++.h>
using namespace std;

struct Task {
    int id;
    int priority;
    int remain;  // 剩余时间片
};

// 每个优先级维护一个FIFO队列, 下标0是最高优先级
queue<Task> slots[100];

// 添加任务
void addTask(int id, int priority, int time) {
    slots[priority].push({id, priority, time});
}

// 获取下一个待执行任务, 如果无任务则返回{-1,-1,-1}
Task getNext() {
    for (int p = 0; p < 100; ++p) {
        if (!slots[p].empty()) {
            Task t = slots[p].front();
            slots[p].pop();
            return t;
        }
    }
    return {-1, -1, -1};
}

int getCurrentTaskId() {
    for (int p = 0; p < 100; ++p) {
        if (!slots[p].empty()) {
            return slots[p].front().id;
        }
    }
    return -1;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string cmd;
    while (getline(cin, cmd)) {
        if (cmd.empty())
            break;
        stringstream ss(cmd);
        ss >> cmd;
        if (cmd == "add") {
            int id, pr, t;
            ss >> id >> pr >> t;
            addTask(id, pr, t);
        } else if (cmd == "run") {
            int time;
            ss >> time;
            while (time > 0) {
                Task cur = getNext();
                if (cur.id == -1)
                    break;  // 无任务
                if (cur.remain <= time) {
                    time -= cur.remain;  // 任务完成, 消耗所有剩余时间
                } else {
                    cur.remain -= time;  // 任务未完成
                    time = 0;
                    slots[cur.priority].push(cur);  // 重新排队
                }
            }
            int nid = getCurrentTaskId();
            if (nid == -1)
                cout << "idle";
            else
                cout << nid;
            cout << "\n";
        }
    }
    return 0;
}

Solution (True)

只输出最后一次 run

✅ 参考链接：https://codefun2000.com/p/P2972

#include <bits/stdc++.h>
using namespace std;

// 任务结构体
struct Task {
    int id;     // 任务ID
    int prio;   // 优先级（越小越先）
    int rem;    // 剩余时间片
    int order;  // 到达顺序
};

// 优先队列比较器
struct Cmp {
    bool operator()(const Task &a, const Task &b) const {
        if (a.prio != b.prio)
            return a.prio > b.prio;
        return a.order > b.order;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    priority_queue<Task, vector<Task>, Cmp> pq;
    string cmd;
    int next_order = 0;
    vector<pair<string, vector<int>>> ops;

    // 读取所有操作
    while (getline(cin, cmd)) {
        if (cmd.empty())
            break;
        stringstream ss(cmd);
        string op;
        ss >> op;
        if (op == "add") {
            int id, p, t;
            ss >> id >> p >> t;
            ops.push_back({op, {id, p, t}});
        } else if (op == "run") {
            int T;
            ss >> T;
            ops.push_back({op, {T}});
        }
    }

    // 模拟所有操作，只在最后一次 run 后输出
    int last_run_idx = -1;
    for (int i = 0; i < (int)ops.size(); i++) {
        if (ops[i].first == "run")
            last_run_idx = i;
    }

    for (int i = 0; i < (int)ops.size(); i++) {
        auto &op = ops[i];
        if (op.first == "add") {
            // 入队一个新任务
            pq.push({op.second[0], op.second[1], op.second[2], next_order++});
        } else {
            int T = op.second[0];
            while (T > 0 && !pq.empty()) {
                Task t = pq.top();
                pq.pop();
                if (t.rem <= T) {
                    T -= t.rem;  // 任务完成，消耗全部剩余时间
                } else {
                    t.rem -= T;  // 任务未完成，更新剩余时间
                    T = 0;
                    pq.push(t);  // 重新入队
                }
            }
            // 如果是最后一次 run，输出结果
            if (i == last_run_idx) {
                if (pq.empty())
                    cout << "idle\n";
                else
                    cout << pq.top().id << "\n";
            }
        }
    }
    return 0;
}

2. 地震救灾路线

某市发生地震，为了尽快将救援物质输送到受灾乡镇，需要你设计出从救援物质集结点（有仅有一个）到某一个受灾乡镇的最短线路

应急部门通过无人机助察了受灾地区地形，提供了各乡镇之间以及乡镇到救援物质集结点的距离，请你算出救援物质集结点到受灾多镇的最短路径。

Input

第一行，N，受灾乡镇个数，3 ≤ N ≤ 20

第二行至第 N+2 行，救援物质集结点以及各乡镇之间的距离矩阵（即 N+1 个节点之间的相互距离矩阵），距离取值范围是 $[0,100]$。序号 0 的节点表示救援物质集结点，序号 1 ~ N 的节点表示各个受灾乡镇。0 表示两个节点不相邻。

第 N+3 行，m，要抵达的乡镇序号（范围 1~N）

Output

从物质集结点（节点 0）到乡镇 m（节点 m）的最短路径长度

Sample 1

输入：

5
0 5 13 0 0 0
5 0 12 0 75 0
13 12 0 25 0 0
0 0 25 0 35 20
0 75 0 35 0 40
0 0 0 20 40 0
3

输出：

样例 1 解释：

从 0 到 3 的最短路径为 $0-2-3$，长度为 $13 + 25 = 38$

Sample 2

输入：

5
0 5 13 0 0 0
5 0 12 0 75 0
13 12 0 25 0 0
0 0 25 0 35 20
0 75 0 35 0 40
0 0 0 20 40 0
5

输出：

样例 2 解释：

从 0 到 5 的最短路径为 $0-2-3-5$，长度为 $13+25+20=58$

Solution

✅ 参考链接：https://codefun2000.com/p/P2973

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N; // 受灾乡镇个数
    int total = N + 1;
    vector<vector<int>> d(total, vector<int>(total));
    // 读入距离矩阵，节点 0 为物资集结点，1~N 为乡镇
    for (int i = 0; i < total; i++) {
        for (int j = 0; j < total; j++) {
            cin >> d[i][j];
        }
    }
    int m;
    cin >> m; // 目标乡镇编号

    const int INF = 1e9;
    vector<int> dist(total, INF);
    vector<bool> vis(total, false);

    dist[0] = 0; // 源点到自己的距离为 0

    // Dijkstra 算法主循环
    for (int i = 0; i < total; i++) {
        int u = -1, minDist = INF;
        // 找到未访问且 dist 最小的节点 u
        for (int j = 0; j < total; j++) {
            if (!vis[j] && dist[j] < minDist) {
                u = j;
                minDist = dist[j];
            }
        }
        if (u == -1) break; // 剩余节点不可达
        vis[u] = true;
        // 松弛以 u 为起点的所有边
        for (int v = 0; v < total; v++) {
            if (!vis[v] && d[u][v] > 0 && dist[v] > dist[u] + d[u][v]) {
                dist[v] = dist[u] + d[u][v];
            }
        }
    }

    cout << dist[m] << endl; // 输出从 0 到 m 的最短距离
    return 0;
}

补充｜Dijkstra 算法

Dijkstra 算法是一种求解非负权图上单源最短路径的算法。

算法思路‼️

将结点分成两个集合：已确定最短路长度的点集（记为 $S$ 集合）的和未确定最短路长度的点集（记为 $T$ 集合）。一开始所有的点都属于 $T$ 集合。

初始化 $dis(s) = 0$，其他点的 $dis$ 均为 $+∞$。

然后重复这些操作：

从 $T$ 集合中，选取一个最短路长度最小的结点，移到 $S$ 集合中。
对那些刚刚被加入 $S$ 集合的结点的所有出边执行松弛操作。

直到 $T$ 集合为空，算法结束。

时间复杂度

朴素的实现方法为每次「操作 2」执行完毕后，直接在 $T$ 集合中暴力寻找最短路长度最小的节点。「操作 2」总时间复杂度为 $O(m)$，「操作 1」总时间复杂度为 $O(n^2)$，全过程的时间复杂度为 $O(n^2+m)=O(n^2)$。

可以用「堆」来优化这一过程：每松弛一条边 $(u,v)$，就将 $v$ 插入堆中（如果 $v$ 已经在堆中，直接执行 Decrease-key），「操作 1」直接取堆顶节点即可。共计 $O(m)$ 次 Decrease-key，$O(n)$ 次 pop，堆优化能做到的最优复杂度为 $O(nlogn+m)$。特别地，可以用优先队列 priority_queue 维护，此时无法执行 Decrease-key 操作，但可以通过每次松弛时重新插入该节点，且弹出时检查该节点是否已被松弛过，若是则跳过，复杂度 $O(mlogn)$，优点是实现比较简单。

这里的堆也可以用线段树实现，复杂度为 $O(mlogn)$，在一些特殊的非递归线段树实现下，该做法常数比堆更小。并且线段树支持的操作更多，在一些特殊图问题上只能用线段树来维护。

✅ 在稀疏图（邻接矩阵）中，$m=O(n)$，堆优化的 Dijkstra 算法具有较大的效率优势；

✅ 而在稠密图（邻接图）中，$m=O(n^2)$，这时候使用朴素实现更优。

代码实现

这里同时给出 $O(n^2)$ 的暴力做法实现和 $O(m·logm)$ 的优先队列做法实现。

dijkstra 算法推荐练习题：

1️⃣ 朴素实现｜稠密图（邻接图）

struct edge {
  int v, w;
};

vector<edge> e[MAXN];
int dis[MAXN], vis[MAXN];

void dijkstra(int n, int s) {
  memset(dis, 0x3f, (n + 1) * sizeof(int));
  dis[s] = 0;
  for (int i = 1; i <= n; i++) {
    int u = 0, mind = 0x3f3f3f3f;
    for (int j = 1; j <= n; j++)
      if (!vis[j] && dis[j] < mind) u = j, mind = dis[j];
    vis[u] = true;
    for (auto ed : e[u]) {
      int v = ed.v, w = ed.w;
      if (dis[v] > dis[u] + w) dis[v] = dis[u] + w;
    }
  }
}

2️⃣ 优先队列实现｜稀疏图（邻接矩阵）

struct edge {
  int v, w;
};

struct node {
  int dis, u;

  bool operator>(const node& a) const { return dis > a.dis; }
};

vector<edge> e[MAXN];
int dis[MAXN], vis[MAXN];
priority_queue<node, vector<node>, greater<node>> q;

void dijkstra(int n, int s) {
  memset(dis, 0x3f, (n + 1) * sizeof(int));
  memset(vis, 0, (n + 1) * sizeof(int));
  dis[s] = 0;
  q.push({0, s});
  while (!q.empty()) {
    int u = q.top().u;
    q.pop();
    if (vis[u]) continue;
    vis[u] = 1;
    for (auto ed : e[u]) {
      int v = ed.v, w = ed.w;
      if (dis[v] > dis[u] + w) {
        dis[v] = dis[u] + w;
        q.push({dis[v], v});
      }
    }
  }
}

3. 云计算服务器 GPU 分配

某云计算服务商为客户提供 M 数量 GPU 核数的 GPU 分时租用服务，租用计费规则为：允许客户在每个时间单位按需租用不同的 GPU 核数，每个时间单位每个 GPU 核数的费用为 R。现有 N 个客户，每个客户有多个不重叠时间租用一定数量的 GPU 核数租用需求。对于有需求的客户，服务商可选择签约或不签约，若选择签约则需要满足租用需求中的所有时间段所需的 GPU 核数。

为了实现租金最大化收益，服务商需在确保任意时间单位内分配的 GPU 核数总数不超过 M 的基础上选择与哪些客户签约租用协议。

请输出租金最大化收益下的租金最大值。

Input

第一行为 M、N、R 的数值，依次用空格隔开，输入格式为 M N R。

从第二行开始，每行为一个客户的租用需求，共 N 行。每行的第一个数字为该客户端的时间段个数 timeSegmentNum，后续为 timeSegmentNum 个时间段及所需的 GPU 核数，时间段个数 timeSegmentNum 与时间段之间、多个时间段之间均用空格分割，同一个客户多个时间段已按起始时间增序排序给出。同个客户多个时间段不会重叠。同一个客户多个时间段已按起始时间增序排序给出。

每个时间段及所需的 GPU 核数格式为 start 起始时间编号:end 结束时间编号:needcores 该时间段所需的 GPU 核数。

变量取值范围：

$1≤ M ≤ 100000$
$1≤ N ≤ 10$
$1≤ R ≤ 10$
$0≤ start ≤ end ≤ 10^9$
$0≤ start ≤ end ≤ 10^9$
$1≤ needCores ≤ 10000$
$1≤ timeSegmentNum ≤ 100$

客户的租用需求样例 $2$、$0:0:1$、$3:6:10$ 的含义是共有 2 个时间段，0:0:1 表示在第 0 个时间单位需要 1 个 GPU 核，3:6:10 表示从 3 到 6 的时间单位（包含 3 和 6）每个时间单位均需 10 个 GPU 核。

图例为：

Output

总租金最大值。如果任意一个客户的需求都无法满足，则输出 0

Sample 1

输入：

10 3 2
2 0:8:5 9:23:10
2 0:8:5 9:18:10
1 0:8:5

输出：

样例 1 解释：

共 3 个客户。

由于第一个客户和第二个客户在 $9:18$ 时间范围段内总核数为 20 超过了 10，所以无法同时接受。

最大日租金方案为：接纳第一个客户和第三个客户的需求。

第一个客户共需要的GPU核数为 $9 * 5 + 15*10=195$

第三个客户共需要的GPU核数为 $9 * 5=45$

Sample 2

输入：

10 2 1
1 0:3:6
1 3:10:6

输出：

样例 2 解释：

最大 GPU 核数为 10，共 2 个客户。

第一客户和第二个客户在3时间点，总核数为 12 超过了 10，所以无法同时接受。

第一个客户共需要的GPU核数为 $4 * 6=24$

第二个客户共需要的GPU核数为 $8 * 6=48$

为满足最大租金，采纳第二个客户，最大租金值为（48）* 1=48

Sample 3

输入：

10 1 1
1 0:5:20

输出：

样例 3 解释：

最大 GPU 核数为 10，共 1 个客户。在 $0-5$ 时间段需要 20 个 GPU 核数，无法满足。

Sample 4

输入：

10000 1 10
1 0:1000000000:10000

输出：

1000000000100000

样例 4 解释：

最大 GPU 核数为 10000，共 1 个客户。

客户在 $0-100000000$ 时间段需要 10000 个GPU核数，可以满足。

租金最大值为 1000000000100000

Solution

✅ 参考链接：https://codefun2000.com/p/P2974

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    // 读入 M, N, R
    ll M; int N; ll R;
    cin >> M >> N >> R;

    // 存储每个客户的时间段需求
    vector<vector<tuple<ll,ll,ll>>> segs(N);
    for (int i = 0; i < N; i++) {
        int t; cin >> t;
        while (t--) {
            ll s, e, c;
            char ch;
            cin >> s >> ch >> e >> ch >> c;  // 读入格式 s:e:c
            segs[i].emplace_back(s, e, c);
        }
    }

    ll ans = 0;
    // 枚举所有子集
    for (int mask = 0; mask < (1<<N); mask++) {
        vector<ll> xs;
        ll W = 0;
        // 收集边界
        for (int i = 0; i < N; i++) if (mask & (1<<i)) {
            for (auto &seg: segs[i]) {
                ll s,e,c; tie(s,e,c) = seg;
                xs.push_back(s);
                xs.push_back(e+1);
                W += (e - s + 1) * c;
            }
        }
        if (xs.empty()) continue;
        // 离散化
        sort(xs.begin(), xs.end());
        xs.erase(unique(xs.begin(), xs.end()), xs.end());
        vector<ll> diff(xs.size()+1);
        // 差分数组构造
        for (int i = 0; i < N; i++) if (mask & (1<<i)) {
            for (auto &seg: segs[i]) {
                ll s,e,c; tie(s,e,c) = seg;
                int l = lower_bound(xs.begin(), xs.end(), s) - xs.begin();
                int r = lower_bound(xs.begin(), xs.end(), e+1) - xs.begin();
                diff[l] += c;
                diff[r] -= c;
            }
        }
        // 扫描检查容量
        ll cur = 0;
        bool ok = true;
        for (int i = 0; i+1 < (int)xs.size(); i++) {
            cur += diff[i];
            if (cur > M) { ok = false; break; }
        }
        if (ok) ans = max(ans, W * R);
    }

    cout << ans;
    return 0;
}

从 POSIX pthread 到 C++11 thread

Fri, 16 May 2025 00:00:00 GMT

推荐阅读：https://chengxumiaodaren.com/docs/concurrent/

在 C++ 开发中，原生的线程库主要有两个，一个是 Linux 下的 <pthread.h>，另一个是 C++11 提供的 <thread>。

以前一直用的是 pthread 的 API 写 C++ 的多线程程序，直到听说从 C++11 开始的标准库已经包含了对线程的支持。

pthread

pthread 中的 p 是 POSIX (Portable Operating System Interface) 的缩写，是 IEEE 为了在各种 UNIX 操作系统上运行软件，而定义 API 的一系列互相关联的标准总称。相比于 std::thread 的简便易用，pthread 功能比较强大。

线程的创建和管理

创建线程｜`pthread_create`

每个线程都有一个在进程中唯一的线程标识符，用一个数据类型 pthread_t 表示，该数据类型在 Linux 中就是一个无符号长整型数据。

int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

若创建成功，返回 0；若出错，则返回错误编号：

thread 是线程标识符，但这个参数不是由用户指定的，而是由 pthread_create 函数在创建时将新线程的标识符放到这个变量中
attr 指定线程的属性，可以用 NULL 表示默认属性
start_routine 指定线程开始运行的函数
arg 是 start_routine 所需的参数，是一个无类型指针

默认地，线程在被创建时要被赋予一定的属性，这个属性存放在数据类型 pthread_attr_t 中，它包含了线程的调度策略，堆栈的相关信息，join or detach 的状态等。

pthread_attr_init 和 pthread_attr_destroy 函数分别用来创建和销毁 pthread_attr_t，具体函数声明可参考 man 手册帮助。

结束线程｜`pthread_exit`、`pthread_cancel`

当发生以下情形之一时，线程就会结束：

线程运行的函数 return 了，也就是线程的任务已经完成；
线程调用了 pthread_exit()；
其他线程调用 pthread_cancel() 结束了线程；
进程调用 exec() 或 exit() 结束；
main() 函数先结束了，而且 main() 自己没有调用 pthread_exit() 来等所有线程完成任务。

更抽象地说，线程结束执行的方式共有 3 种，分别是：

线程将指定函数体中的代码执行完后自行结束；
线程执行过程中，遇到 pthread_exit() 函数结束执行。
线程执行过程中，被同一进程中的其它线程（包括主线程）强制终止；

当然，一个线程结束，并不意味着它的所有信息都已经消失，后面会看到僵尸线程的问题。

下面介绍两个函数：

void pthread_exit(void *retval);

retval 是由用户指定的参数，pthread_exit 完成之后可以通过这个参数获得线程的退出状态/信息。

int pthread_cancel(pthread_t thread);

一个线程可以通过调用 pthread_cancel 函数来请求取消同一进程中的线程，这个线程由 thread 参数指定。
如果操作成功则返回 0，失败则返回对应的错误编码。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>  // sleep() 函数

// 线程执行的函数
void* thread_Fun(void* arg) {
    printf("新建线程开始执行\n");
    sleep(10);
}

int main() {
    pthread_t myThread;
    void* mess;
    int value;
    int res;

    // 创建 myThread 线程
    res = pthread_create(&myThread, NULL, thread_Fun, NULL);
    if (res != 0) {
        printf("线程创建失败\n");
        return 0;
    }
    sleep(1);

    // 向 myThread 线程发送 Cancel 信号
    res = pthread_cancel(myThread);
    if (res != 0) {
        printf("终止 myThread 线程失败\n");
        return 0;
    }

    // 获取已终止线程的返回值
    res = pthread_join(myThread, &mess);
    if (res != 0) {
        printf("等待线程失败\n");
        return 0;
    }
    
    // 如果线程被强制终止，其返回值为 PTHREAD_CANCELED
    if (mess == PTHREAD_CANCELED) {
        printf("myThread 线程被强制终止\n");
    } else {
        printf("error\n");
    }
    return 0;
}

$ ./pthread
新建线程开始执行
myThread 线程被强制终止

一个简单的多线程实现

这是一个非常简单的基于 pthread 的多线程实现：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS 5

void *printHello(void *thread_id) {
  long tid;
  tid = (long)thread_id;
  printf("Hello World! It's me, thread #%ld!\n", tid);
  pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
  pthread_t threads[NUM_THREADS];
  int rc;
  long t;
  for (t = 0; t < NUM_THREADS; t++) {
    printf("In main: creating thread %ld\n", t);
    rc = pthread_create(&threads[t], NULL, printHello, (void *)t);
    if (rc) {
      printf("ERROR; return code frome pthread_create() is %d\n", rc);
      exit(-1);
    }
  }
  // Last thing that main() should do
  pthread_exit(NULL);
}

gcc -Wall _pthread.c -lpthread -o pthread
./pthread

In main: creating thread 0
In main: creating thread 1
Hello World! It's me, thread #0!
In main: creating thread 2
Hello World! It's me, thread #1!
In main: creating thread 3
Hello World! It's me, thread #2!
In main: creating thread 4
Hello World! It's me, thread #3!
Hello World! It's me, thread #4!

注意输出的顺序可能不同，要特别注意的是，main() 显示地调用了 pthread_exit() 来等待其他线程的结束（如果不使用这个函数的话，可能 main() 函数结束了也有线程没有执行完毕）

给线程传入初始化参数

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS 8

char *messages[NUM_THREADS];

struct thread_data {
  int tid;
  int sum;
  char *msg;
};

struct thread_data _datas[NUM_THREADS];

void *printHello(void *thread_arg) {
  int task_id, sum;
  char *hello_msg;
  struct thread_data *my_data;
  
  my_data = (struct thread_data *)thread_arg;
  task_id = my_data->tid;
  sum = my_data->sum;
  hello_msg = my_data->msg;
  
  // sleep(1);
  printf("Thread %d: %s Sum = %d\n", task_id, hello_msg, sum);
  pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
  pthread_t threads[NUM_THREADS];
  int *task_ids[NUM_THREADS];
  int rc, t, sum;

  sum = 0;
  messages[0] = "English: Hello World!";
  messages[1] = "French: Bonjour, le monde!";
  messages[2] = "Spanish: Hola al mundo";
  messages[3] = "Klingon: Nuq neH!";
  messages[4] = "German: Guten Tag, Welt!";
  messages[5] = "Russian: Zdravstvytye, mir!";
  messages[6] = "Japan: Sekai e konnichiwa!";
  messages[7] = "Latin: Orbis, te saluto!";

  for (t = 0; t < NUM_THREADS; t++) {
    sum = sum + t;
    _datas[t].tid = t;
    _datas[t].sum = sum;
    _datas[t].msg = messages[t];
    printf("Creating thread %d\n", t);
    rc = pthread_create(&threads[t], NULL, printHello, (void *)&_datas[t]);
    if (rc) {
      printf("ERROR; return code from pthread_create() is %d\n", rc);
      exit(-1);
    }
  }
  pthread_exit(NULL);
}

Creating thread 0
Creating thread 1
Thread 0: English: Hello World! Sum = 0
Creating thread 2
Thread 1: French: Bonjour, le monde! Sum = 1
Creating thread 3
Thread 2: Spanish: Hola al mundo Sum = 3
Creating thread 4
Thread 3: Klingon: Nuq neH! Sum = 6
Creating thread 5
Thread 4: German: Guten Tag, Welt! Sum = 10
Creating thread 6
Thread 5: Russian: Zdravstvytye, mir! Sum = 15
Creating thread 7
Thread 6: Japan: Sekai e konnichiwa! Sum = 21
Thread 7: Latin: Orbis, te saluto! Sum = 28

对线程的阻塞｜`pthread_join`、`pthread_detach`

阻塞时线程之间「同步」的一种方法。

int pthread_join(pthread_t thread_id, void **value_ptr);

pthread_join 函数会让调用它的线程等待 thread_id 线程运行结束之后再运行（如果是 main() 调用，则阻塞 main 线程，直到 join 的所有线程执行结束 —— 常用于等待 main 中创建的所有线程执行完毕）
value_ptr 存放了其他线程的返回值

一个可以被 join 的线程，仅仅可以被另一个线程 join，如果同时有多个线程尝试 join 同一个线程时，最终结果是未知的；另外，线程不能 join 自己。上面提到过，创建一个线程时，要赋予它一定的属性，这其中就包括 joinable or detachable 的属性，只有被声明称 joinable 的线程才可以被其他线程 join。

POSIX 标准的最终版本指出线程应该被设置成 joinable 的，显式设置一个线程为 joinable，需要以下四个步骤：

Declare a pthread attribute variable of the pthread_attr_t data type
Initialize the attribute variable with pthread_attr_init()
Set the attribute detached status with pthread_attr_setdetchstate()
When done, free library resources used by the attribute with pthread_attr_destroy()

pthread_join() 函数会一直阻塞调用它的线程，直至目标线程执行结束（接收到目标线程的返回值），阻塞状态才会解除。如果 pthread_join() 函数成功等到了目标线程执行结束（成功获取到目标线程的返回值），返回值为数字 0；反之如果执行失败，函数会根据失败原因返回相应的非零值，每个非零值都对应着不同的宏，例如：

EDEADLK：检测到线程发生了死锁。
EINVAL：分为两种情况，要么目标线程本身不允许其它线程获取它的返回值，要么事先就已经有线程调用 pthread_join() 函数获取到了目标线程的返回值。
ESRCH：找不到指定的 thread 线程。

再次强调，一个线程执行结束的返回值只能由一个 pthread_join() 函数获取，当有多个线程调用 pthread_join() 函数获取同一个线程的执行结果时，哪个线程最先执行 pthread_join() 函数，执行结果就由那个线程获得，其它线程的 pthread_join() 函数都将执行失败。

对于一个默认属性的线程 A 来说，线程占用的资源并不会因为执行结束而得到释放。而通过在其它线程中执行pthread_join(A,NULL);语句，可以轻松实现“及时释放线程 A 所占资源”的目的。

#include <errno.h>  //使用宏 ESRCH
#include <pthread.h>
#include <stdio.h>

// 线程执行的函数
void *ThreadFun(void *arg) { pthread_exit("test_msg"); }

int main() {
    int res;
    void *thread_result;
    pthread_t myThread;
    // 创建 myThread 线程
    res = pthread_create(&myThread, NULL, ThreadFun, NULL);
    if (res != 0) {
        printf("线程创建失败");
        return 0;
    }
    // 阻塞主线程，等待 myThread 线程执行结束
    res = pthread_join(myThread, &thread_result);
    if (res != 0) {
        printf("1：等待线程失败");
    }
    // 输出获取到的 myThread 线程的返回值
    printf("%s\n", (char *)thread_result);

    // 尝试再次获取 myThread 线程的返回值
    res = pthread_join(myThread, &thread_result);
    if (res == ESRCH) {
        printf("2：等待线程失败，线程不存在\n");
    }
    return 0;
}

$ ./pthread
test_msg
2：等待线程失败，线程不存在

__detachstate 属性值用于指定线程终止执行的时机，该属性的值有两个，分别是：

PTHREAD_CREATE_JOINABLE（默认值）：线程执行完函数后不会自行释放资源；
PTHREAD_CREATE_DETACHED：线程执行完函数后，会自行终止并释放占用的资源。

还有 pthread_detach() 函数，可以直接将目标线程的 __detachstate 属性改为 PTHREAD_CREATE_DETACHED，语法格式如下：

int pthread_detach(pthread_t thread);

关于 __detachstate 属性，<pthread.h> 头文件中提供了 2 个与它相关的函数，分别是：

int pthread_attr_getdetachstate(const pthread_attr_t * attr,int * detachstate);
int pthread_attr_setdetachstate(pthread_attr_t *sttr，int detachstate);

可以如下创建 detach 状态的线程：

pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, THREAD_FUNCTION, arg);

⚠️ 值得注意的是：僵尸线程（zombie thread）是一种已经退出了的 joinable 线程，但是等待其他线程调用 pthread_join 来 join 它，以收集它的退出信息。如果没有其他线程调用 pthread_join 来 join 它的话，它占用的一些系统资源不会被释放，比如堆栈。如果 main() 函数需要长时间运行，并且创建大量 joinable 的线程，就有可能出现堆栈不足的 error。

⚠️ 对于那些不需要 join 的线程，最好利用 pthread_detach，这样它运行结束后，资源就会及时得到释放。注意一个线程被使用 pthread_detach 之后，它就不能再被改成 joinable 的了。

⚠️ 总而言之，创建的每一个线程都应该使用 pthread_join 或者 pthread_detach 其中一个，以防止僵尸线程的出现。

Linux 线程属性之线程栈大小｜`pthread_attr_t`

线程的属性用 pthread_attr_t 类型的变量表示，使用此变量前，必须调用 pthread_attr_init() 函数进行初始化：

int pthread_attr_init(pthread_attr_t * attr);

pthread_attr_t 是一种结构体类型，内部包含多种线程属性（更多内容请看参考资料）：

typedef struct
{
   int __detachstate;	// 用于指定线程终止执行的时机
   int __schedpolicy;	// 指定系统调度该线程所用的算法
   struct sched_param __schedparam;		// 设置线程的优先级
   int __inheritsched;	// 默认遵循父线程的属性, 用于自定义线程的调度属性
   int __scope;			// 用于指定目标线程和哪些线程抢夺 CPU 资源
   size_t __guardsize;	// 用来设置警戒缓冲区的大小
   int __stackaddr_set;
   void* __stackaddr;
   size_t __stacksize;	// 每个线程都有属于自己的内存空间, 线程执行如果需要较大的栈内存，就需要自定义线程拥有的栈大小
} pthread_attr_t;

POSIX 标准没有规定一个线程的堆栈大小，安全可移植的程序不会依赖于具体实现默认的堆栈限制，而是显式地调用 pthread_attr_setstacksize 来分配足够的堆栈空间。

关于堆栈大小的一个例子：

#include <pthread.h>

#define N_THREADS 5
#define N 1000
#define MEGEXTRA 1000000

pthread_attr_t _attr;

void* do_work(void* thread_id) {
    double A[N][N];
    int i, j;
    long tid;
    size_t my_stack_size;
    tid = (long)thread_id;
    pthread_attr_getstacksize(&_attr, &my_stack_size);
    printf("Thread %ld: stack size = %ld bytes \n", tid, my_stack_size);
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            A[i][j] = ((i * j) / 3.452) + (N - i);
        }
    }
    pthread_exit(NULL);
}

int main(int argc, char* argv[]) {
    pthread_t threads[N_THREADS];
    size_t stack_size;
    int rc;
    long t;

    pthread_attr_init(&_attr);
    pthread_attr_getstacksize(&_attr, &stack_size);
    printf("Default stack size = %li\n", stack_size);  // 线程栈大小: 8 MB

    stack_size = sizeof(double) * N * N + MEGEXTRA;
    printf("Amount of stack needed per thread = %li\n", stack_size);

    pthread_attr_setstacksize(&_attr, stack_size);
    printf("Creating threads with stack size = %li bytes\n", stack_size);

    for (t = 0; t < N_THREADS; t++) {
        rc = pthread_create(&threads[t], &_attr, do_work, (void*)t);
        if (rc) {
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }
    printf("Creating %ld threads.\n", t);
    pthread_exit(NULL);
}

$ ./pthread 
Default stack size = 8388608
Amount of stack needed per thread = 9000000
Creating threads with stack size = 9000000 bytes
Creating 5 threads.
Thread 1: stack size = 9000000 bytes 
Thread 2: stack size = 9000000 bytes 
Thread 0: stack size = 9000000 bytes 
Thread 3: stack size = 9000000 bytes 
Thread 4: stack size = 9000000 bytes

其他相关函数：

// 返回 thread ID
pthread_self();
// 比较两个线程的 ID, 如果不同则返回 0, 否则返回一个非零值
pthread_equal(thread_1, thread_2);

互斥锁 Mutex

Mutex 常常被用来保护那些可以被多个线程访问的共享资源，比如可以防止多个线程同时更新同一个数据时出现混乱。

使用互斥锁的一般步骤是：

创建一个互斥锁，即声明一个 pthread_mutex_t 类型的数据，然后初始化，只有初始化之后才能使用；
多个线程尝试锁定这个互斥锁；
只有一个成功锁定互斥锁，成为互斥锁的拥有者，然后进行一些指令；
拥有者解锁互斥锁；
其他线程尝试锁定这个互斥锁，重复上面的过程；
最后互斥锁被显式地调用 pthread_mutex_destroy 来进行销毁。

有两种方式初始化一个互斥锁：

1️⃣ 第一种，利用已经定义的常量初始化，例如：

pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;

2️⃣ 第二种方式是调用 pthread_mutex_init(mutex, attr) 进行初始化。

当多个线程同时去锁定同一个互斥锁时，失败的那些线程

如果是用 pthread_mutex_lock 函数，那么会被阻塞，直到这个互斥锁被解锁，它们再继续竞争；
如果是用 pthread_mutex_trylock 函数，那么失败者只会返回一个错误。

最后需要指出的是，保护共享数据是程序员的责任。程序员要负责所有可以访问该数据的线程都使用 mutex 这种机制，否则，不使用 mutex 的线程还是有可能对数据造成破坏。

Example

下面是一个利用多线程进行向量点乘的程序，其中需要对 dotstr.sum 这个共同读写的数据进行保护。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

/*
The following structure contains the necessary information
to allow the function "dotprod" to access its input data and
place its output into the structure.  This structure is
unchanged from the sequential version.
*/

typedef struct {
    double *a;
    double *b;
    double sum;
    int veclen;
} DOTDATA;

/* Define globally accessible variables and a mutex */

#define NUMTHRDS 4
#define VECLEN 100000
DOTDATA dotstr;
pthread_t callThd[NUMTHRDS];
pthread_mutex_t mutexsum;

/*
The function dotprod is activated when the thread is created.
As before, all input to this routine is obtained from a structure
of type DOTDATA and all output from this function is written into
this structure. The benefit of this approach is apparent for the
multi-threaded program: when a thread is created we pass a single
argument to the activated function - typically this argument
is a thread number. All  the other information required by the
function is accessed from the globally accessible structure.
*/

void *dotprod(void *arg) {
    /* Define and use local variables for convenience */

    int i, start, end, len;
    long offset;
    double mysum, *x, *y;
    offset = (long)arg;

    len = dotstr.veclen;
    start = offset * len;
    end = start + len;
    x = dotstr.a;
    y = dotstr.b;

    /*
    Perform the dot product and assign result
    to the appropriate variable in the structure.
    */
    mysum = 0;
    for (i = start; i < end; i++) {
        mysum += (x[i] * y[i]);
    }

    /*
    Lock a mutex prior to updating the value in the shared
    structure, and unlock it upon updating.
    */
    pthread_mutex_lock(&mutexsum);
    dotstr.sum += mysum;
    printf("Thread %ld did %d to %d: mysum=%f global sum=%f\n", offset, start, end, mysum, dotstr.sum);
    pthread_mutex_unlock(&mutexsum);
    pthread_exit((void *)0);
}

/*
The main program creates threads which do all the work and then print out result
upon completion. Before creating the threads, The input data is created. Since
all threads update a shared structure, we need a mutex for mutual exclusion.
The main thread needs to wait for all threads to complete, it waits for each one
of the threads. We specify a thread attribute value that allow the main thread to
join with the threads it creates. Note also that we free up handles  when they
are no longer needed.
*/

int main(int argc, char *argv[]) {
    long i;
    double *a, *b;
    void *status;
    pthread_attr_t attr;

    /* Assign storage and initialize values */

    a = (double *)malloc(NUMTHRDS * VECLEN * sizeof(double));
    b = (double *)malloc(NUMTHRDS * VECLEN * sizeof(double));

    for (i = 0; i < VECLEN * NUMTHRDS; i++) {
        a[i] = 1;
        b[i] = a[i];
    }

    dotstr.veclen = VECLEN;
    dotstr.a = a;
    dotstr.b = b;
    dotstr.sum = 0;

    pthread_mutex_init(&mutexsum, NULL);

    /* Create threads to perform the dotproduct  */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    for (i = 0; i < NUMTHRDS; i++) {
        /* Each thread works on a different set of data.
         * The offset is specified by 'i'. The size of
         * the data for each thread is indicated by VECLEN.
         */
        pthread_create(&callThd[i], &attr, dotprod, (void *)i);
    }

    pthread_attr_destroy(&attr);

    /* Wait on the other threads */
    for (i = 0; i < NUMTHRDS; i++) {
        pthread_join(callThd[i], &status);
    }
    /* After joining, print out the results and cleanup */

    printf("Sum = %f \n", dotstr.sum);
    free(a);
    free(b);
    pthread_mutex_destroy(&mutexsum);
    pthread_exit(NULL);
}

$ ./pthread 
Thread 0 did 0 to 100000: mysum=100000.000000 global sum=100000.000000
Thread 2 did 200000 to 300000: mysum=100000.000000 global sum=200000.000000
Thread 1 did 100000 to 200000: mysum=100000.000000 global sum=300000.000000
Thread 3 did 300000 to 400000: mysum=100000.000000 global sum=400000.000000
Sum = 400000.000000

条件变量 Condition Variable

互斥锁只有两种状态，这限制了它的用途。条件变量允许线程在阻塞的时候等待另一个线程发送的信号，当收到信号后，阻塞的线程就被唤醒并试图锁定与之相关的互斥锁。条件变量要和互斥锁结合使用。

条件变量的声明和初始化

通过声明 pthread_cond_t 类型的数据，并且必须先初始化才能使用。

初始化的方法也有两种：

1️⃣ 第一种，利用内部定义的常量，例如：

pthread_cond_t myconvar = PTHREAD_COND_INITIALIZER;

2️⃣ 第二种，利用函数 pthread_cond_init(cond, attr)，其中 attr 由 pthread_condattr_init() 和 pthread_condattr_destroy() 创建和销毁；可以用 pthread_cond_destroy() 销毁一个条件变量。

Example

下面是一个例子，三个线程共同访问 count 变量，thread 2 和 thread 3 竞争地对其进行加 1 的操作，thread 1 等 count 达到 12 的时候，一次性加 125 。然后 thread 2 和 thread 3 再去竞争 count 的控制权，直到完成自己的对 count 加 10 次的任务。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS 3
#define TCOUNT 10
#define COUNT_LIMIT 12

int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t) {
    int i;
    long my_id = (long)t;

    for (i = 0; i < TCOUNT; i++) {
        pthread_mutex_lock(&count_mutex);
        count++;

        /*
        Check the value of count and signal waiting thread when condition is
        reached.  Note that this occurs while mutex is locked.
        */
        if (count == COUNT_LIMIT) {
            printf("inc_count(): thread %ld, count = %d  Threshold reached. ", my_id, count);
            pthread_cond_signal(&count_threshold_cv);
            printf("Just sent signal.\n");
        }
        printf("inc_count(): thread %ld, count = %d, unlocking mutex\n", my_id, count);
        pthread_mutex_unlock(&count_mutex);

        /* Do some work so threads can alternate on mutex lock */
        sleep(1);
    }
    pthread_exit(NULL);
}

void *watch_count(void *t) {
    long my_id = (long)t;

    printf("Starting watch_count(): thread %ld\n", my_id);

    /*
    Lock mutex and wait for signal.  Note that the pthread_cond_wait routine
    will automatically and atomically unlock mutex while it waits.
    Also, note that if COUNT_LIMIT is reached before this routine is run by
    the waiting thread, the loop will be skipped to prevent pthread_cond_wait
    from never returning.
    */
    pthread_mutex_lock(&count_mutex);
    while (count < COUNT_LIMIT) {
        printf("watch_count(): thread %ld Count= %d. Going into wait...\n", my_id, count);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf("watch_count(): thread %ld Condition signal received. Count= %d\n", my_id, count);
        printf("watch_count(): thread %ld Updating the value of count...\n", my_id, count);
        count += 125;
        printf("watch_count(): thread %ld count now = %d.\n", my_id, count);
    }
    printf("watch_count(): thread %ld Unlocking mutex.\n", my_id);
    pthread_mutex_unlock(&count_mutex);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    int i, rc;
    long t1 = 1, t2 = 2, t3 = 3;
    pthread_t threads[3];
    pthread_attr_t attr;

    /* Initialize mutex and condition variable objects */
    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    /* For portability, explicitly create threads in a joinable state */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);

    /* Wait for all threads to complete */
    for (i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("Main(): Waited and joined with %d threads. Final value of count = %d. Done.\n", NUM_THREADS, count);

    /* Clean up and exit */
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit(NULL);
}

$ ./pthread 
Starting watch_count(): thread 1
inc_count(): thread 2, count = 1, unlocking mutex
inc_count(): thread 3, count = 2, unlocking mutex
watch_count(): thread 1 Count= 2. Going into wait...
inc_count(): thread 2, count = 3, unlocking mutex
inc_count(): thread 3, count = 4, unlocking mutex
inc_count(): thread 2, count = 5, unlocking mutex
inc_count(): thread 3, count = 6, unlocking mutex
inc_count(): thread 2, count = 7, unlocking mutex
inc_count(): thread 3, count = 8, unlocking mutex
inc_count(): thread 2, count = 9, unlocking mutex
inc_count(): thread 3, count = 10, unlocking mutex
inc_count(): thread 2, count = 11, unlocking mutex
inc_count(): thread 3, count = 12  Threshold reached. Just sent signal.
inc_count(): thread 3, count = 12, unlocking mutex
watch_count(): thread 1 Condition signal received. Count= 12
watch_count(): thread 1 Updating the value of count...
watch_count(): thread 1 count now = 137.
watch_count(): thread 1 Unlocking mutex.
inc_count(): thread 2, count = 138, unlocking mutex
inc_count(): thread 3, count = 139, unlocking mutex
inc_count(): thread 2, count = 140, unlocking mutex
inc_count(): thread 3, count = 141, unlocking mutex
inc_count(): thread 2, count = 142, unlocking mutex
inc_count(): thread 3, count = 143, unlocking mutex
inc_count(): thread 3, count = 144, unlocking mutex
inc_count(): thread 2, count = 145, unlocking mutex
Main(): Waited and joined with 3 threads. Final value of count = 145. Done.

std::thread

在 C++11 中引入的线程库 std::thread 实际是基于 pthread 实现的，后续主要介绍：

如何使用 std::thread 创建线程
深入剖析 std::thread 的设计原理

使用 std::thread

当你创建了一个（非空的）线程对象时，对应线程就会执行，不需要显式的调用 start 或者 run（pthread 也是）。如果之前你没有用过 pthread，也许不会理解何为“方便得出人意料”：

pthread_create 只接受 void *f(void *)，所以如果你想调用现成的函数，还需要包装一下；
而且 pthread_create 其函数接受参数（第四个参数）类型为 void *arg，如果要传多个参数，还需要定义结构体，接着将结构体转为 void * 类型再传递进去；
这还没完，传递进去的参数还需要在其内部函数中，重新转型成（可能是一次性的）某个结构体，最后才能取出其中的变量；

创建线程后，调用 Thread.join 就会阻塞到线程执行结束为止（相当于pthread_join）。你也可以选择 detach 该线程，这时候线程会独立执行，不会随调用者终止而结束。

在如下的 demo 中，主线程中使用 std::thread 创建 3 个子线程，线程入口函数是 do_some_work，在主线程运行结束前等待子线程的结束。

注：在构造线程对象 std::thread{do_some_work, i} 的时候，还是建议使用 {} 而不是 ()，以防止编译器产生错误的决议，具体原因可以参考文章（深入了解 C++：别再徘徊于 {} 与 () 之间了）

// #include <bits/stdc++.h>
#include <iostream>
#include <thread>
#include <vector>

const int N_THREADS = 3;

void do_some_work(int num) { std::cout << "thread: " << num << std::endl; }

int main(int argc, char const* argv[]) {
    std::vector<std::thread> thread_list;
    thread_list.reserve(N_THREADS);

    // start thread
    for (int i = 0; i < N_THREADS; i++) {
        // 🆗 thread_list.push_back(std::thread{do_some_work, i});
        // 🆗 thread_list.push_back(std::thread(do_some_work, i));
        thread_list.emplace_back(do_some_work, i);
    }
    std::cout << "work in main thread" << std::endl;

    // main() thread will waiting other threads
    for (int i = 0; i < N_THREADS; i++) {
        thread_list[i].join();
    }
    std::cout << "main thread end" << std::endl;
    return 0;
}

三个子线程共享输出缓冲区 std::cout，此时没有采取任何机制保护线程间共享数据，因此上面 demo 的输出可能不符合你的预期，即很可能不是按照如下格式输出：

$ ./thread
thread: 0
thread: 1
thread: 2

实际输出结果（非常混乱）：

$ ./thread
thread: work in main thread
thread: 0
2
thread: 1
main thread end

从输出可以看出：

先创建的线程，未必就先运行；
而且几个线程之间是互相抢 CPU 资源的

线程间数据共享问题及其应对措施，留到后文讲解，下面讲解 std::thread 的设计。

深入剖析 std::thread

在 g++ 中，thread 是基于 pthread 实现的。本次主要从以下三个方面分 std::thread：

std::thread 对象不可复制，只具有移动属性
每个线程具有唯一的标志，即线程 id
创建子线程（即构造 std::thread）

1. 移动属性

有很多书籍说，std::thread 对象的所有权只能传递不能复制。实际上，就 std::thread 对象，只具有移动属性，不具有复制属性。std::thread 的构造函数如下：

class thread {
   private:
    id _M_id;

   public:
    thread() noexcept = default;

    template <typename _Callable, typename... _Args, typename = _Require<__not_same<_Callable>>>
    explicit thread(_Callable&& __f, _Args&&... __args) {
        //...
    }

    ~thread() {
        if (joinable()) std::terminate();
    }
    // 禁止复制（复制构造、复制赋值）
    thread(const thread&) = delete;
    thread& operator=(const thread&) = delete;

    // std::thread 只具有移动属性（移动构造、移动赋值）
    thread(thread&& __t) noexcept { swap(__t); }

    thread& operator=(thread&& __t) noexcept {
        if (joinable()) std::terminate();
        swap(__t);
        return *this;
    }
    //...
}

可以发现，std::thread 禁止了复制构造函数、复制赋值表达式，只留下了移动构造函数、移动赋值，使得 std::thread 对象只能移动，不能复制。这就是之前 demo 中使用 emplace_back 函数添加 std::thread 对象的原因，防止触发复制构造函数。所以向 thread_list 中添加 std::thread 对象有以下几种方式：

当 push_back 接受的是右值，底层调用的还是 emplace_back 函数，因此 4 和 5 是等价的。

thread_list.push_back(std::thread{do_some_work, i});	// 1.ok

thread_list.emplace_back(do_some_work, i);	 			// 2.ok
thread_list.emplace_back(std::thread{do_some_work, i});	 // 2.ok

std::thread trd{do_some_work, i};
thread_list.push_back(trd);					// 3.error❌

thread_list.push_back(std::move(trd));		 // 4.ok
thread_list.emplace_back(std::move(trd));	 // 5.ok

第三种办法报错：

/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = std::thread; _Args = {std::thread&}; _Tp = std::thread]’:
/usr/include/c++/9/bits/alloc_traits.h:483:4:   required from ‘static void std::allocator_traits<std::allocator<_CharT> >::construct(std::allocator_traits<std::allocator<_CharT> >::allocator_type&, _Up*, _Args&& ...) [with _Up = std::thread; _Args = {std::thread&}; _Tp = std::thread; std::allocator_traits<std::allocator<_CharT> >::allocator_type = std::allocator<std::thread>]’
/usr/include/c++/9/bits/vector.tcc:115:30:   required from ‘void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {std::thread&}; _Tp = std::thread; _Alloc = std::allocator<std::thread>]’
_thread.cpp:22:37:   required from here
/usr/include/c++/9/ext/new_allocator.h:146:4: error: use of deleted function ‘std::thread::thread(const std::thread&)’
  146 |  { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
      |    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from _thread.cpp:3:
/usr/include/c++/9/thread:142:5: note: declared here
  142 |     thread(const thread&) = delete;

2. std::thread::id

可以发现，在 std::thread 对象中，只有一个成员变量 _M_id。

这个类 id 全称是 std::thread::id，实现如下：

class id {
    // // _M_thread 即 pthread_t 对象，线程的唯一辨识标志
    native_handle_type _M_thread;

   public:
    // _M_thread 默认值是 0
    id() noexcept : _M_thread() {}

    explicit id(native_handle_type __id) : _M_thread(__id) {}

   private:
    friend class thread;
    friend class hash<thread::id>;
    // 为 std::thread::id 对象重载了 == 运算
    friend bool operator==(thread::id __x, thread::id __y) noexcept;

    friend bool operator<(thread::id __x, thread::id __y) noexcept;
    // 为 std::thread::id 对象重载了 << 操作
    template <class _CharT, class _Traits>
    friend basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
};

因此，这个 std::thread::id 实际上就是封装了 pthread_t 对象，用作每个线程的标志。

在构造 std::thread 对象的时候，如果没有设置线程入口函数，则线程 _M_id._M_thread 的值是 0

比如下面的 demo，trd 没有设置线程入口函数，trd 调用默认构造函数时，trd 的 _M_id._M_thread 会被初始化为 0

int main(int argc, char const* argv[]) {
    std::thread trd;
    std::cout << trd.get_id() << std::endl;
    return 0;
}

但是，打印线程标志 trd.get_id()，输出的是却不是0。这仅仅是 std::thread::id 在重载 << 操作符时的设定，用于提示调用者线程没有启动。

$ g++  thread_.cc -o thread_ && ./thread_
thread::id of a non-executing thread

可以到 std::thread::id 重载的 << 操作符的函数中一探究竟：

template<class _CharT, class _Traits>
inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id) {
    // 线程未启动 
    if (__id == thread::id())
    return __out << "thread::id of a non-executing thread";
    // 线程成功启动
    else
    return __out << __id._M_thread;
}

// id的相等判断 
inline bool operator==(thread::id __x, thread::id __y) noexcept {
    return __x._M_thread == __y._M_thread;
}

因此判断一个线程是否启动，可如下检测：

bool thread_is_active(const std::thread::id& thread_id) { 
    return thread_id != std::thread::id();
}

设置了线程入口函数，_M_id._M_thread 才是线程的tid值，由 pthread_create(&tid, NULL, ...) 函数设置：

int main(int argc, char const* argv[]) {
    std::thread trd{[] { std::cout << "work in sub-thread\n"; }};

    std::cout << trd.get_id() << std::endl;
    trd.join();
    return 0;
}

$ ./thread 
140203273147968
work in sub-thread

by the way

在创建 std::thread 对象 trd 时：

如果设置了线程入口函数，那么就必须使用 trd.join() 或者 trd.detach() 来表达子线程与主线程的运行关系，否则在 std::thread 对象析构时，整个程序会被 std::terminate() 中止。
如果没有设置线程入口函数，trd.joinable() 返回值就是 false，因此不会触发 std::terminate()。

~thread() {
  if (joinable())
    std::terminate();
}

3. 创建子线程

当构造 std::thread 对象时，设置了线程入口函数，会在相匹配的构造函数里调用 pthread_create 函数创建子线程。先看整体实现：

// std::thread 构造函数
template<typename _Callable, 
         typename... _Args,
         typename = _Require<__not_same<_Callable>>>
explicit thread(_Callable&& __f, _Args&&... __args)
{
    static_assert( __is_invocable<typename decay<_Callable>::type, 
                                  typename decay<_Args>::type...>::value,
                  "std::thread arguments must be invocable after conversion to rvalues");

    // Create a reference to pthread_create, not just the gthr weak symbol.
    auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
    // 启动线程
    _M_start_thread(_S_make_state(__make_invoker(std::forward<_Callable>(__f), 
                                                 std::forward<_Args>(__args)...)),
                    __depend);
}

再细看构造函数执行流程：

在编译期判断构造 std::thread 对象时设置的线程入口函数 __f 及其参数 __args 能否调用。

比如，下面的 demo 中，线程入口函数 thread_func 有个 int 类型的参数 arg，如果传入的参数 __args 无法隐式转换为 int 类型，或者没有设置 __args，都会触发 std::thread 构造函数中的静态断言 static_assert。

报错：error: static assertion failed: std::thread arguments must be invocable after conversion to rvalues

void thread_func(int arg) { }

int main(int argc, char const *argv[]) {
    std::thread trd_1{thread_func, "str"};  // arg 类型不对
    std::thread trd_2{thread_func};	 	    // 缺少 arg

    // ...
    return 0;
}

将线程入口函数 __f 及其参数 __args 进一步封装起来。

这里是使用 __make_invoker 完成的：

__make_invoker(std::forward<_Callable>(__f), std::forward<_Args>(__args)...);

__make_invoker 的作用是返回一个 _Invoker 对象，_Invoker 是个仿函数，通过 _Invoker() 就可以以指定的参数 __args 直接执行线程入口函数 __f。类似于 std::bind：

 void print_num(int i) {
     std::cout << i << '\n';
 }

 int main(int argc, const char* argv[]) {
    // wrapper
    auto invoker =  std::bind(print_num, -9);
    // 直接调用 invoker() 就可以以指定参数 -9 调用 print_num
    invoker();
 }

启动子线程

在调用 _M_start_thread 函数启动子线程前，执行过程：

创建 _State_ptr 的对象，来封装 _Invoker 对象，再传递给 _M_start_thread 函数。
传递 _M_start_thread 函数的过程，由 _S_make_state 函数完成，_S_make_state 最终返回 _State_ptr 对象。

// 基类
struct _State {
   virtual ~_State();          // 虚析构函数
   virtual void _M_run() = 0;  // 线程运行函数
};
using _State_ptr = unique_ptr<_State>;	// 父类指针

// 子类
template<typename _Callable>
struct _State_impl : public _State {
   _Callable		_M_func;	// 线程入口函数

   _State_impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
   { }

   void _M_run() { _M_func(); } // 执行线程入口函数
};

// 传入_Invoker对象，返回 _State_ptr 对象
template<typename _Callable>
static _State_ptr _S_make_state(_Callable&& __f)  {
   using _Impl = _State_impl<_Callable>;
   // 使用子类对象来初始化父类
   return _State_ptr{new _Impl{std::forward<_Callable>(__f)}};
}

_S_make_state 函数，将线程入口函数 __f 及其参数 __args 封装到 _State_ptr 对象 _State_ptr_obj 中，这样最后可以通过 _State_ptr_obj->_M_run() 来调用 __f。

下面到了 _M_start_thread 函数：

void thread::_M_start_thread(_State_ptr state, void (*)())
{
  const int err = __gthread_create(&_M_id._M_thread,
                                    &execute_native_thread_routine, // 线程执行函数
                                    state.get());
  if (err)
    __throw_system_error(err);
  state.release();
}

// 内部调用的是 pthread_create 函数
static inline int __gthread_create(pthread_t *__threadid, void *(*__func) (void*), void *__args)
{
  return pthread_create(__threadid, NULL, __func, __args);
}

// 内部执行线程入口函数
static void* execute_native_thread_routine(void* __p)
{
  thread::_State_ptr __t{static_cast<thread::_State*>(__p)};
  __t->_M_run();		// 运行线程入口函数
  return nullptr;
}

因此，在执行完 _M_start_thread 函数后，才具有 _M_start_thread != 0。

Mutex

有时候需要限制多个线程对同一资源的访问，这时候一般会使用 Mutex。Mutex 就是一把锁，只有某些线程可以同时占用它（通过 lock 操作）。当线程不用的时候，就得通过 unlock 操作来释放它。

对于 Mutex，std::thread 和 pthread 差不多，无非是 pthread_mutex_lock(&mutex) 变成了 mutex.lock() 等等。

不过在 std::thread 中，mutex 往往和 lock 系列模板一起使用。这是因为 lock 系列模板包装了 mutex 类，提供了 RAII 风格的加锁解锁。

{
    // 加锁
    std::lock_guard<std::mutex> guard(mutex);
    ...

    // 自动解锁
}

mutex 有四种：

std::mutex：独占的互斥量，不能递归使用，不带超时功能
std::recursive_mutex：递归互斥量，可重入，不带超时功能
std::timed_mutex：带超时的互斥量，不能递归
std::recursive_timed_mutex：带超时的互斥量，可以递归使用

加解锁方式有三种：

std::lock_guard：可以RAII方式加锁
std::unique_lock：比 lock_guard 多了个手动加解锁的功能
std::scoped_lock：防止多个锁顺序问题导致的死锁问题而出世的一把锁

Condition Variable

有时候线程之间需要某种同步：当某些条件不满足时，停止执行直到该条件被满足。

这时候需要引入 condition variable —— 状态变量。

在经典的「生产者消费者模式」下，生产者和消费者就是通过 condition variable 来实现同步的。

当有限的生产力无法满足日益增长的消费需求时，消费者进程就会去睡一觉，直到它想要的东西生产出来才醒来。

std::condition_variable condvar;

consumer:
        std::unique_lock<std::mutex> ulock(mutex);
        condvar.wait(ulock, []{ return msgQueue.size() > 0;});

producer:
        condvar.notify_all();

condition_variable 需要和 unique_lock 搭配使用
在一个线程调用 wait 之前，它必须持有 unique_lock 锁
当 wait 被调用时，该锁会被释放，线程会陷入沉睡，等待着生产者发过来的唤醒信号
当生产者调用同一个 condition_variable 的 notify_all 方法时，所有沉睡在该变量前的消费者会被唤醒，并尝试重新获取之前释放的 unique_lock，继续执行下去（注意这里发生了锁争用，只有一个消费者能够获得锁，其他消费者得等待该消费者释放锁）
如果只想叫醒一个线程，可以用 notify_one
pthread 中也提供了对应的方法，分别是 pthread_cond_wait, pthread_cond_broadcast, pthread_cond_signal

wait 可以接受两个参数，此时第二个参数用于判断当前是否要沉睡。

[]{ return msgQueue.size() > 0;});

相当于

while (msgQueue.size() <= 0) {
    condvar.wait()
}

为了防止线程无限等待（可能一直没有唤醒），通过 wait_until 和 wait_for，你可以设定线程的等待时间。设置 notify_all_at_thread_exit 也许能帮得上忙。

在 pthread 中，对应的调用是 pthread_cond_timedwait。

C++11 的线程库还提供了其他多线程编程的概念，比如 future 和 atomic。

future

future 位于头文件 <future> 下，包装了未来某个计算结果的期诺。

当你对所获得的 future 调用 get 时，程序会一直阻塞直到 future 的值被计算出来（如果 future 的值已经计算出来了，get 调用会立刻获得返回值），而这一切都是在后台执行的。

#include <chrono>
#include <iostream>
#include <future>

using namespace std;

int main()
{
    future<int> f1 = async(launch::async, [](){
        std::chrono::milliseconds dura(2000);
        std::this_thread::sleep_for(dura);
        return 0; 
    });
    
    future<int> f2 = async(launch::async, [](){
        std::chrono::milliseconds dura(2000);
        std::this_thread::sleep_for(dura);
        return 1; 
    });
    
    cout << "Results are: " << f1.get() << " " << f2.get() << "\n";
    return 0;
}

$ g++ -std=c++11 -pthread ./future.cpp

$ time ./a.out 
Results are: 0 1
./a.out  0.00s user 0.00s system 0% cpu 2.012 total # 是两秒左右而不是四秒

除了 async， packaged_task 和 promise 也都返回一个 future。

atomic

atomic 位于头文件 <atomic> 下，实现了类似于 java.util.concurrent.atomic 的功能。它提供了一组轻量级的、作用在单个变量上的原子操作，是 volatile 的替代品，有些时候你也可以用它来替换掉 lock（假如整个 race condition 中只有单个变量）

下面这个例子解释了什么叫做原子操作：

#include <atomic>
#include <iostream>
#include <thread>

using namespace std;

const int NUM = 100;

int target = 0;
atomic<int> atomicTarget(0);

template<typename T>
void atomicPlusOne(int trys)
{
    while (trys > 0) {
        atomicTarget.fetch_add(1);
        --trys;
    }
}

void plusOne(int trys)
{
    while (trys > 0) {
        ++target;
        --trys;
    }
}

int main()
{
    thread threads[NUM];
    thread atomicThreads[NUM];
    for (int i = 0; i < NUM; i++) {
        atomicThreads[i] = thread(atomicPlusOne<int>, 10000);
    }
    for (int i = 0; i < NUM; i++) {
        threads[i] = thread(plusOne, 10000);
    }

    for (int i = 0; i < NUM; i++) {
        atomicThreads[i].join();
    }
    for (int i = 0; i < NUM; i++) {
        threads[i].join();
    }

    cout << "Atomic target's value : " << atomicTarget << "\n";
    cout << "Non-atomic target's value : " << target << "\n";

    return 0;
}

# atomicTarget 的值总是固定的，而 target 的值每次运行时各不相同
$ g++ -std=c++11 -pthread ./atom.cpp
Atomic target's value : 1000000
Non-atomic target's value : 842480

Pros & Cons

最后总结下 std::thread 对比于 pthread 的优缺点：

优点：

简单，易用
跨平台，pthread 只能用在 POSIX 系统上（其他系统有其独立的 thread 实现）
提供了更多高级功能，比如 future
更加 C++（与匿名函数，std::bind，RAII 等 C++ 特性更好的集成）

缺点：

没有 RWlock：有一个类似的 shared_mutex，不过它属于 C++14，你的编译器很有可能不支持
操作线程和 Mutex 等的 API 较少：毕竟为了跨平台，只能选取各原生实现的子集。如果你需要设置某些属性，需要通过 API 调用返回原生平台上的对应对象，再对返回的对象进行操作。

生产者消费者（pthread & thread 版本）

附上我自己写的，分别用 std::thread 和 pthread 实现的多生产者多消费者程序。

注意行数上的差距。

pthread 版本

#include <pthread.h>
#include <queue>
#include <stdio.h>
#include <unistd.h>

// 注意 pthread_* 函数返回的异常值，为了简单（偷懒），我没有去处理它们

pthread_mutex_t mutex;
pthread_cond_t condvar;

std::queue<int> msgQueue;
struct Produce_range {
    int start;
    int end;
};

void *producer(void *args)
{
    int start = static_cast<Produce_range *>(args)->start;
    int end = static_cast<Produce_range *>(args)->end;
    for (int x = start; x < end; x++) {
        usleep(200 * 1000);
        pthread_mutex_lock(&mutex);
        msgQueue.push(x);
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&condvar);
        printf("Produce message %d\n", x);
    }
    pthread_exit((void *)0);
    return NULL;
}

void *consumer(void *args)
{
    int demand = *static_cast<int *>(args);
    while (true) {
        pthread_mutex_lock(&mutex);
        if (msgQueue.size() <= 0) {
            pthread_cond_wait(&condvar, &mutex);
        }
        if (msgQueue.size() > 0) {
            printf("Consume message %d\n", msgQueue.front());
            msgQueue.pop();
            --demand;
        }
        pthread_mutex_unlock(&mutex);
        if (!demand) break;
    }
    pthread_exit((void *)0);
    return NULL;
}


int main()
{
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&condvar, NULL);

    pthread_t producer1, producer2, producer3, consumer1, consumer2;

    Produce_range range1 = {0, 10};
    pthread_create(&producer1, &attr, producer, static_cast<void *>(&range1));
    Produce_range range2 = {range1.end, range1.end + 10};
    pthread_create(&producer2, &attr, producer, static_cast<void *>(&range2));
    Produce_range range3 = {range2.end, range2.end + 10};
    pthread_create(&producer3, &attr, producer, static_cast<void *>(&range3));

    int consume_demand1 = 20;
    int consume_demand2 = 10;
    pthread_create(&consumer1, &attr, consumer, static_cast<void *>(&consume_demand1));
    pthread_create(&consumer2, &attr, consumer, static_cast<void *>(&consume_demand2));

    pthread_join(producer1, NULL);
    pthread_join(producer2, NULL);
    pthread_join(producer3, NULL);
    pthread_join(consumer1, NULL);
    pthread_join(consumer2, NULL);
}

std::thread 版本

#include <chrono>
#include <condition_variable>
#include <future>
#include <mutex>
#include <queue>

// 注意某些调用可能会抛出std::system_error， 为了简单（偷懒），我没有去捕获
std::mutex mutex;
std::condition_variable condvar;

std::queue<int> msgQueue;

void producer(int start, int end)
{
    for (int x = start; x < end; x++) {
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        {        
            std::lock_guard<std::mutex> guard(mutex);
            msgQueue.push(x);
        }
        printf("Produce message %d\n", x);
        condvar.notify_all();
    }
}

void consumer(int demand)
{
    while (true) {
        std::unique_lock<std::mutex> ulock(mutex);
        condvar.wait(ulock, []{ return msgQueue.size() > 0;});
        // wait的第二个参数使得显式的double check不再必要
        printf("Consume message %d\n", msgQueue.front());
        msgQueue.pop();
        --demand;
        if (!demand) break;
    }
}


int main()
{
    std::thread producer1(producer, 0, 10);
    std::thread producer2(producer, 10, 20);
    std::thread producer3(producer, 20, 30);
    std::thread consumer1(consumer, 20);
    std::thread consumer2(consumer, 10);

    producer1.join();
    producer2.join();
    producer3.join();
    consumer1.join();
    consumer2.join();
}

二叉树匹配问题｜子树匹配？子结构匹配？

Mon, 28 Apr 2025 00:00:00 GMT

✅ 二叉树匹配类题目总结

匹配类二叉树可以使用一种套路相对固定的递归函数，这类题目与字符串匹配有些神似，求解过程大致分为两步：

先将根节点匹配；
根节点匹配后，对子树进行匹配。

相关例题：

100. 相同的树

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (!p || !q)
            return p == q;
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

101. 对称二叉树

class Solution {
public:
    bool check(TreeNode* a, TreeNode* b) {
        if (a == nullptr && b == nullptr)
            return true;
        if (a == nullptr || b == nullptr)
            return false;
        return a->val == b->val && check(a->left, b->right) && check(a->right, b->left);
    }

    bool isSymmetric(TreeNode* root) {
        return check(root->left, root->right);
    }
};

1367. 二叉树中的链表

题意：「链表」在「二叉树」中的匹配

输入：head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
输出：true
解释：树中蓝色的节点构成了与链表对应的子路径。

class Solution {
public:
    bool check(ListNode* head, TreeNode* root) {
        if (head == nullptr)
            return true;
        if (root == nullptr)
            return false;
        return head->val == root->val && (check(head->next, root->left) || check(head->next, root->right));
    }

    bool isSubPath(ListNode* head, TreeNode* root) {
        if (root == nullptr)
            return false;
        return check(head, root) || isSubPath(head, root->left) || isSubPath(head, root->right);
    }
};

572. 另一棵树的子树 & 面试题 04.10. 检查子树（匹配子树）

这道题的题意是这样的：输入两棵二叉树 A 和 B，判断 B 是不是 A 的子结构，且约定空树不是任意一个树的子结构。

比如上面这个例子，我们发现 B 是 A 的子结构，因为它们的结构相同，且节点值相等。

求解思路可以分解为以下两步：

匹配根节点：首先在 A 中找到与 B 的根节点匹配的节点 C；

匹配其他节点：验证 C 的子树与 B 的子树是否匹配。

class Solution {
public:
    bool check(TreeNode* a, TreeNode* b) {
        // 以下四行代码也可以改成: if (a == nullptr || b == nullptr) { return a == b; }
        if (a == nullptr && b == nullptr)
            return true;
        if (a == nullptr || b == nullptr)
            return false;
        return a->val == b->val && check(a->left, b->left) && check(a->right, b->right);
    }

    bool checkSubTree(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr || t2 == nullptr)
            return false;
        return check(t1, t2) || checkSubTree(t1->left, t2) || checkSubTree(t1->right, t2);
    }
};

LCR 143. 子结构判断（匹配子结构）

输入：tree1 = [3,6,7,1,8], tree2 = [6,1]
输出：true
解释：tree2 与 tree1 的一个子树拥有相同的结构和节点值。即 6 - > 1。

对于本题来讲，与「面试题 04.10. 检查子树」很像，不同的是 B 属于 A 的一部分也可以，没必要一直匹配到叶子节点，因此只需对 check 函树的基本条件进行修改即可。

class Solution {
public:
    bool check(TreeNode* a, TreeNode* b) {
        if (b == nullptr)
            return true;
        if (a == nullptr)
            return false;
        return a->val == b->val && check(a->left, b->left) && check(a->right, b->right);
    }

    bool isSubStructure(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr || t2 == nullptr)
            return false;
        return check(t1, t2) || isSubStructure(t1->left, t2) || isSubStructure(t1->right, t2);
    }
};

根据（前中后序）构造二叉树系列

Mon, 28 Apr 2025 00:00:00 GMT

✅ 构造二叉树系列

相关例题：

1008. 前序遍历构造二叉搜索树

题意：根据前序遍历结果构造二叉搜索树

输入：preorder = [8,5,1,7,10,12]
输出：[8,5,10,1,7,null,12]

1️⃣ buildTree · 递归

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, int left, int right) {
        if (left > right) {
            return nullptr;
        }
        int i;
        for (i = left + 1; i <= right; i++) {
            if (preorder[i] > preorder[left])
                break;
        }
        TreeNode* _left = buildTree(preorder, left + 1, i - 1);
        TreeNode* _right = buildTree(preorder, i, right);
        return new TreeNode(preorder[left], _left, _right);
    }

    TreeNode* bstFromPreorder(vector<int>& preorder) {
        if (preorder.empty())
            return nullptr;
        return buildTree(preorder, 0, preorder.size() - 1);
    }
};

class Solution {
public:
    TreeNode* bstFromPreorder(vector<int>& preorder) {
        if (preorder.empty())
            return nullptr;
        int i = upper_bound(preorder.begin() + 1, preorder.end(), preorder[0]) - preorder.begin();
        vector<int> preleft(preorder.begin() + 1, preorder.begin() + i);
        vector<int> preright(preorder.begin() + i, preorder.end());
        TreeNode* left = bstFromPreorder(preleft);
        TreeNode* right = bstFromPreorder(preright);
        return new TreeNode(preorder[0], left, right);
    }
};

106. 从中序与后序遍历序列构造二叉树

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

1️⃣ 递归

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.empty())
            return nullptr;
        int i = ranges::find(inorder, postorder.back()) - inorder.begin();
        vector<int> in1(inorder.begin(), inorder.begin() + i);
        vector<int> in2(inorder.begin() + i + 1, inorder.end());
        vector<int> post1(postorder.begin(), postorder.begin() + i);
        vector<int> post2(postorder.begin() + i, postorder.end() - 1);
        TreeNode* left = buildTree(in1, post1);
        TreeNode* right = buildTree(in2, post2);
        return new TreeNode(postorder.back(), left, right);
    }
};

105. 从前序与中序遍历序列构造二叉树


输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

1️⃣ 递归

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.empty())
            return nullptr;
        int i = ranges::find(inorder, preorder[0]) - inorder.begin();
        vector<int> pre1(preorder.begin() + 1, preorder.begin() + i + 1);
        vector<int> pre2(preorder.begin() + i + 1, preorder.end());
        vector<int> in1(inorder.begin(), inorder.begin() + i);
        vector<int> in2(inorder.begin() + i + 1, inorder.end());
        TreeNode* left = buildTree(pre1, in1);
        TreeNode* right = buildTree(pre2, in2);
        return new TreeNode(preorder[0], left, right);
    }
};

889. 根据前序和后序遍历构造二叉树

如果存在多个答案，您可以返回其中任何一个。

输入：preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]
输出：[1,2,3,4,5,6,7]

1️⃣ 递归

首先说明，如果只知道前序遍历和后序遍历，这棵二叉树不一定是唯一的，如下图。

题目说，如果存在多个答案，我们可以返回其中任何一个。那么不妨规定：无论什么情况，在前序遍历中，preorder[1] 都是左子树的根节点值。

递归边界：

如果 preorder 的长度是 0，对应着空节点，返回空。
如果 preorder 的长度是 1，对应着二叉树的叶子，创建一个叶子节点并返回。

class Solution {
public:
    TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
        if (preorder.empty()) {
            return nullptr;
        }
        if (preorder.size() == 1) {
            return new TreeNode(preorder[0]);
        }
        int left_size = find(postorder.begin(), postorder.end(), preorder[1]) - postorder.begin() + 1;
        vector<int> pre1(preorder.begin() + 1, preorder.begin() + left_size + 1);
        vector<int> pre2(preorder.begin() + left_size + 1, preorder.end());
        vector<int> post1(postorder.begin(), postorder.begin() + left_size);
        vector<int> post2(postorder.begin() + left_size, postorder.end() - 1);
        TreeNode* root = new TreeNode(preorder[0]);
        root->left = constructFromPrePost(pre1, post1);
        root->right = constructFromPrePost(pre2, post2);
        return root;
    }
};

差分数组

Mon, 28 Apr 2025 00:00:00 GMT

✅ 差分数组

相关例题：

难点：如何快速地「把区间内的数都加一」呢？

2848. 与车相交的点（一维差分数组）

给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。

返回数轴上被车 任意部分 覆盖的整数点的数目。

示例 1：

输入：nums = [[3,6],[1,5],[4,7]]
输出：7
解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7 。

示例 2：

输入：nums = [[1,3],[5,8]]
输出：7
解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7 。

1️⃣ 差分数组

核心思路：计算每个点被覆盖了多少次。统计覆盖次数大于 0 的点，即为答案。

假设一开始有一个全为 0 的数组 a，用来保存每个点被覆盖了多少次。

对于示例 1，我们可以把 a 中下标在 [3,6] 的元素都加一，下标在 [1,5] 的元素都加一，下标在 [4,7] 的元素都加一。

然后，统计 a[i] > 0 的个数，即为答案。

如何快速地「把区间内的数都加一」呢？

这可以用差分数组实现。

class Solution {
public:
    int numberOfPoints(vector<vector<int>>& nums) {
        int max_end = ranges::max(nums, {}, [](const auto& a) { return a[1]; })[1];
        vector<int> diff(max_end + 2);
		// 首尾两点做标记
        for (auto& interval : nums) {
            diff[interval[0]]++;
            diff[interval[1] + 1]--;
        }
        // s += d
        int s = 0, ans = 0;
        for (int d : diff) {
            s += d;
            ans += s > 0;
        }
        return ans;
    }
};

1094. 拼车

车上最初有 capacity 个空座位。车只能向一个方向行驶（也就是说，不允许掉头或改变方向）

给定整数 capacity 和一个数组 trips , trip[i] = [numPassengersi, fromi, toi] 表示第 i 次旅行有 numPassengersi 乘客，接他们和放他们的位置分别是 fromi 和 toi 。这些位置是从汽车的初始位置向东的公里数。

当且仅当你可以在所有给定的行程中接送所有乘客时，返回 true，否则请返回 false。

示例 1：

输入：trips = [[2,1,5],[3,3,7]], capacity = 4
输出：false

示例 2：

输入：trips = [[2,1,5],[3,3,7]], capacity = 5
输出：true

1️⃣ 差分数组

class Solution {
public:
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        // ranges::max(list, comp, proj)
        int max_end = ranges::max(trips, {}, [](const auto& a) { return a[2]; })[2];
        vector<int> diff(max_end + 1);
        for (auto& trip : trips) {
            int num = trip[0], from = trip[1], to = trip[2];
            diff[from] += num;
            // 不一定要 +1，根据题目情况而变
            diff[to] -= num;
        }
        int s = 0;
        for (int d : diff) {
            s += d;
            if (s > capacity)
                return false;
        }
        return true;
    }
};

高频「大数相加」面试题

Mon, 28 Apr 2025 00:00:00 GMT

这是一种经常考察的思维：大数相加。一般有以下几种数据结构类型的考察方式：

数组：66. 加一
字符串：415. 字符串相加
链表：
- 2. 两数相加｜顺序➕
- 445. 两数相加 II｜逆序➕（腾讯 CDG 一面）
二进制：67. 二进制求和
大数相乘：43. 字符串相乘

66. 加一｜数组版

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int n = digits.size(), add = 1;
        for (int i = n - 1; i >= 0 && add; i--) {
            int res = digits[i] + 1;
            digits[i] = res % 10;
            add = res / 10;
        }
        if (add) {
            digits.insert(digits.begin(), 1);
        }
        return digits;
    }
};

415. 字符串相加｜字符串版

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。

你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。

示例 1：

输入：num1 = "11", num2 = "123"
输出："134"

class Solution {
public:
    string addStrings(string num1, string num2) {
        int i = num1.length() - 1, j = num2.length() - 1, add = 0;
        string ans = "";
        while (i >= 0 || j >= 0 || add) {
            int x = i >= 0 ? num1[i] - '0' : 0;
            int y = j >= 0 ? num2[j] - '0' : 0;
            int result = x + y + add;
            ans.push_back('0' + result % 10);
            add = result / 10;
            i--;
            j--;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

2. 两数相加｜链表版 · 从头开始➕

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

1️⃣ 迭代

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode dummy;
        ListNode* cur = &dummy;
        int carry = 0;
        while (l1 || l2 || carry) {
            int res = 0;
            if (l1) {
                res += l1->val;
                l1 = l1->next;
            }
            if (l2) {
                res += l2->val;
                l2 = l2->next;
            }
            res += carry;
            carry = res / 10;
            cur = cur->next = new ListNode(res % 10);
        }
        return dummy.next;
    }
};

2️⃣ 递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2, int carry = 0) {
        if (!l1 && !l2) {
            return carry ? new ListNode(carry) : nullptr;
        }
        if (!l1) {
            swap(l1, l2);
        }
        int sum = carry + l1->val + (l2 ? l2->val : 0);
        l1->val = sum % 10;
        l1->next = addTwoNumbers(l1->next, (l2 ? l2->next : nullptr), sum / 10);
        return l1;
    }
};

445. 两数相加 II｜链表版 · 从尾开始➕

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

✅ 两数相加 II = 两数相加 + 反转链表

1️⃣ 迭代｜206. 反转链表（迭代）+ 2. 两数相加（迭代）

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2);
        ListNode dummy;
        ListNode* cur = &dummy;
        int carry = 0;
        while (l1 || l2 || carry) {
            int res = carry;
            if (l1) {
                res += l1->val;
                l1 = l1->next;
            }
            if (l2) {
                res += l2->val;
                l2 = l2->next;
            }
            carry = res / 10;
            cur = cur->next = new ListNode(res % 10);
        }
        return reverseList(dummy.next);
    }
};

2️⃣ 递归｜206. 反转链表（递归）+ 2. 两数相加（递归）

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (!head || !head->next) {
            return head;
        }
        ListNode* new_head = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return new_head;
    }

    ListNode* addTwo(ListNode* l1, ListNode* l2, int carry = 0) {
        if (!l1 && !l2) {
            return carry ? new ListNode(carry) : nullptr;
        }
        if (!l1) {
            swap(l1, l2);
        }
        int sum = carry + l1->val + (l2 ? l2->val : 0);
        l1->val = sum % 10;
        l1->next = addTwo(l1->next, (l2 ? l2->next : nullptr), sum / 10);
        return l1;
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2);
        ListNode* head = addTwo(l1, l2, 0);
        return reverseList(head);
    }
};

67. 二进制求和｜二进制版

给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

示例 1：

输入:a = "11", b = "1"
输出："100"

示例 2：

输入：a = "1010", b = "1011"
输出："10101"

class Solution {
public:
    string addBinary(string a, string b) {
        int carry = 0;
        int i = a.length() - 1, j = b.length() - 1;
        string ans;
        while (i >= 0 || j >= 0 || carry) {
            int x = i >= 0 ? a[i--] - '0' : 0;
            int y = j >= 0 ? b[j--] - '0' : 0;
            int s = x + y + carry;
            carry = s / 2;
            ans.push_back(s % 2 + '0');
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

43. 字符串相乘｜大数相乘✖️

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

**注意：**不能使用任何内置的 Big Integer 库或直接将输入转换为整数。

示例 1:

输入: num1 = "2", num2 = "3"
输出: "6"

示例 2:

输入: num1 = "123", num2 = "456"
输出: "56088"

1️⃣ 竖式相加

思路：建立在「大数相加」的基础上，因为多个数之间需要累加（容易理解）

class Solution {
public:
    // 大数相加
    string addStrings(string num1, string num2) {
        int i = num1.length() - 1, j = num2.length() - 1, add = 0;
        string ans = "";
        while (i >= 0 || j >= 0 || add) {
            int x = i >= 0 ? num1[i] - '0' : 0;
            int y = j >= 0 ? num2[j] - '0' : 0;
            int result = x + y + add;
            add = result / 10;
            ans.push_back('0' + result % 10);
            i--;
            j--;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }

    // 大数相乘
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0")
            return "0";
        int multiply = 0;
        int m = num1.length(), n = num2.length();
        string ans = "0";
        for (int i = m - 1; i >= 0; i--) {
            int x = num1[i] - '0';
            string num;
            int add = 0;
            for (int j = n - 1; j >= 0 || add; j--) {
                if (x == 0) {
                    num = "0";
                    break;
                }
                if (j < 0) {
                    num.push_back('0' + add);
                    break;
                }
                int y = num2[j] - '0';
                int result = x * y + add;
                add = result / 10;
                num.push_back('0' + result % 10);
            }
            reverse(num.begin(), num.end());
            if (num != "0")
                ans = addStrings(ans, num + string(multiply, '0'));
            multiply++;
        }
        return ans;
    }
};

2️⃣ 相乘

思路：直接做乘法，长度分别为 m 和 n 的数字相乘，值长度不超过 m + n，vector<int> ansArr(m + n)

class Solution {
public:
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0") {
            return "0";
        }
        int m = num1.length(), n = num2.length();
        vector<int> ansArr(m + n);
        for (int i = m - 1; i >= 0; i--) {
            int x = num1[i] - '0';
            for (int j = n - 1; j >= 0; j--) {
                int y = num2[j] - '0';
                ansArr[i + j + 1] += x * y;
            }
        }
        for (int i = m + n - 1; i > 0; i--) {
            ansArr[i - 1] += ansArr[i] / 10;
            ansArr[i] %= 10;
        }
        int idx = ansArr[0] == 0 ? 1 : 0;
        string ans;
        while (idx < m + n) {
            ans.push_back('0' + ansArr[idx]);
            idx++;
        }
        return ans;
    }
};

高频「链表」面试题

Mon, 28 Apr 2025 00:00:00 GMT

✅ 高频链表面试题

相关例题：

141. 环形链表

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

1️⃣ 快慢指针

class Solution {
public:
    bool hasCycle(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
                return true;
        }
        return false;
    }
};

142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

1️⃣ 快慢指针

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                // a = k(b + c) + c
                ListNode* node = head;
                while (node != slow) {
                    node = node->next;
                    slow = slow->next;
                }
                return slow;
            }
        }
        return nullptr;
    }
};

160. 相交链表

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode *p = headA, *q = headB;
        while (p != q) {
            p = p ? p->next : headB;
            q = q ? q->next : headA;
        }
        return p;
    }
};

206. 反转链表

1️⃣ 迭代｜三指针

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
};

2️⃣ 递归

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (!head || !head->next)
            return head;
        ListNode* new_head = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;   // 为了反转后的末节点
        return new_head;
    }
};

92. 反转链表 II

反转链表进阶：反转部分区间，找到区间 leftNode 与 rightNode，以及 leftNode 左节点 pre 与 rightNode 右节点 nxt，独立区间（断开连接）后反转再接回。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode dummy(0, head);
        ListNode* pre = &dummy;
        int t = left;
        while (--t) {
            pre = pre->next;
        }
        ListNode* leftNode = pre->next;
        ListNode* rightNode = leftNode;
        t = right - left;
        while (t--) {
            rightNode = rightNode->next;
        }
        ListNode* nxt = rightNode->next;
        // 断开链接
        pre->next = nullptr;
        rightNode->next = nullptr;
        // 反转链表
        ListNode* node = reverseList(leftNode);
        // 重新链接
        pre->next = node;
        leftNode->next = nxt;
        return dummy.next;
    }
};

876. 链表的中间结点

输入：head = [1,2,3,4,5]
输出：[3,4,5]
解释：链表只有一个中间结点，值为 3 。

输入：head = [1,2,3,4,5,6]
输出：[4,5,6]
解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。

1️⃣ 快慢指针

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

234. 回文链表

1️⃣ 回文链表判断 = 寻找中间节点 + 反转链表

前置题目：

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    ListNode* reverseList(ListNode* head) {
        ListNode *pre = nullptr, *cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    bool isPalindrome(ListNode* head) {
        ListNode* mid = middleNode(head);
        ListNode* head2 = reverseList(mid);
        while (head2) {
            if (head->val != head2->val) {
                return false;
            }
            head = head->next;
            head2 = head2->next;
        }
        return true;
    }
};

21. 合并两个有序链表

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

1️⃣ 迭代（常用）

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode dummy{};
        ListNode* cur = &dummy;
        while (list1 && list2) {
            if (list1->val < list2->val) {
                cur->next = list1;
                list1 = list1->next;
            } else {
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return dummy.next;
    }
};

2️⃣ 递归

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (list1 == nullptr) return list2; // 注：如果都为空则返回空
        if (list2 == nullptr) return list1;
        if (list1->val < list2->val) {
            list1->next = mergeTwoLists(list1->next, list2);
            return list1;
        }
        list2->next = mergeTwoLists(list1, list2->next);
        return list2;
    }
};

2. 两数相加｜从头开始相加

1️⃣ 迭代

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode dummy;
        ListNode* cur = &dummy;
        int carry = 0;
        while (l1 || l2 || carry) {
            if (l1) {
                carry += l1->val;
                l1 = l1->next;
            }
            if (l2) {
                carry += l2->val;
                l2 = l2->next;
            }
            cur = cur->next = new ListNode(carry % 10);
            carry /= 10;
        }
        return dummy.next;
    }
};

2️⃣ 递归

class Solution {
public:
    // l1 和 l2 为当前遍历的节点，carry 为进位
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2, int carry = 0) {
        if (l1 == nullptr && l2 == nullptr) { // 递归边界：l1 和 l2 都是空节点
            return carry ? new ListNode(carry) : nullptr; // 如果进位了，就额外创建一个节点
        }
        if (l1 == nullptr) { // 如果 l1 是空的，那么此时 l2 一定不是空节点
            swap(l1, l2); // 交换 l1 与 l2，保证 l1 非空，从而简化代码
        }
        int sum = carry + l1->val + (l2 ? l2->val : 0); // 节点值和进位加在一起
        l1->val = sum % 10; // 每个节点保存一个数位（直接修改原链表）
        l1->next = addTwoNumbers(l1->next, (l2 ? l2->next : nullptr), sum / 10); // 进位
        return l1;
    }
};

445. 两数相加 II｜从尾开始相加

1️⃣ 迭代｜反转链表 + 两数相加

class Solution {
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr, *cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    ListNode* addTwo(ListNode* l1, ListNode* l2) {
        ListNode dummy; // 哨兵节点
        auto cur = &dummy;
        int carry = 0; // 进位
        while (l1 || l2 || carry) { // 有一个不是空节点，或者还有进位，就继续迭代
            if (l1) carry += l1->val; // 节点值和进位加在一起
            if (l2) carry += l2->val; // 节点值和进位加在一起
            cur = cur->next = new ListNode(carry % 10); // 每个节点保存一个数位
            carry /= 10; // 新的进位
            if (l1) l1 = l1->next; // 下一个节点
            if (l2) l2 = l2->next; // 下一个节点
        }
        return dummy.next; // 哨兵节点的下一个节点就是头节点
    }

public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2);
        auto l3 = addTwo(l1, l2);
        return reverseList(l3);
    }
};

2️⃣ 递归｜反转链表 + 两数相加

class Solution {
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        auto new_head = reverseList(head->next);
        head->next->next = head; // 把下一个节点指向自己
        head->next = nullptr; // 断开指向下一个节点的连接，保证最终链表的末尾节点的 next 是空节点
        return new_head;
    }

    // l1 和 l2 为当前遍历的节点，carry 为进位
    ListNode* addTwo(ListNode* l1, ListNode* l2, int carry = 0) {
        if (l1 == nullptr && l2 == nullptr) { // 递归边界：l1 和 l2 都是空节点
            return carry ? new ListNode(carry) : nullptr; // 如果进位了，就额外创建一个节点
        }
        if (l1 == nullptr) { // 如果 l1 是空的，那么此时 l2 一定不是空节点
            swap(l1, l2); // 交换 l1 与 l2，保证 l1 非空，从而简化代码
        }
        carry += l1->val + (l2 ? l2->val : 0); // 节点值和进位加在一起
        l1->val = carry % 10; // 每个节点保存一个数位
        l1->next = addTwo(l1->next, (l2 ? l2->next : nullptr), carry / 10); // 进位
        return l1;
    }

public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2); // l1 和 l2 反转后，就变成【2. 两数相加】了
        auto l3 = addTwo(l1, l2);
        return reverseList(l3);
    }
};

19. 删除链表的倒数第 N 个结点

1️⃣ 快慢指针

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode dummy(0, head);
        ListNode *fast = &dummy, *slow = &dummy;
        while (n--) {
            fast = fast->next;
        }
        while (fast->next) {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* d = slow->next;
        slow->next = d->next;
        delete d;
        return dummy.next;
    }
};

24. 两两交换链表中的节点

1️⃣ 迭代｜四指针

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode dummy(0, head); // 用哨兵节点简化代码逻辑
        ListNode* node0 = &dummy;
        ListNode* node1 = head;
        while (node1 && node1->next) { // 至少有两个节点
            ListNode* node2 = node1->next;
            ListNode* node3 = node2->next;

            node0->next = node2; // 0 -> 2
            node2->next = node1; // 2 -> 1
            node1->next = node3; // 1 -> 3

            node0 = node1; // 下一轮交换，0 是 1
            node1 = node3; // 下一轮交换，1 是 3
        }
        return dummy.next; // 返回新链表的头节点
    }
};

2️⃣ 递归

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }

        ListNode* node1 = head;
        ListNode* node2 = head->next;
        ListNode* node3 = node2->next;

        node1->next = swapPairs(node3); // 1 指向递归返回的链表头
        node2->next = node1; // 2 指向 1

        return node2; // 返回交换后的链表头节点
    }
};

25. K 个一组翻转链表

1️⃣ 从「反转链表 · 迭代版」到「K 个一组翻转链表」

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        int n = 0;
        for (ListNode* cur = head; cur; cur = cur->next) {
            n++;
        }
        ListNode dummy(0, head);
        ListNode* p0 = &dummy;
        ListNode* prev = nullptr;
        ListNode* cur = head;
        for (; n >= k; n -= k) {
            for (int i = 0; i < k; i++) {
                ListNode* nxt = cur->next;
                cur->next = prev;
                prev = cur;
                cur = nxt;
            }
            ListNode* last = p0->next;
            p0->next = prev;
            last->next = cur;
            p0 = last;
        }
        return dummy.next;
    }
};

2️⃣「206. 反转链表」+「92. 反转链表 II」

class Solution {
public:
    // 206. 反转链表
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    // 92. 反转链表 II
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode dummy(0, head);
        ListNode* pre = &dummy;
        for (int i = 0; i < left - 1; i++) {
            pre = pre->next;
        }
        ListNode* leftNode = pre->next;
        ListNode* rightNode = leftNode;
        for (int i = left; i < right; i++) {
            rightNode = rightNode->next;
        }
        ListNode* nxt = rightNode->next;
        rightNode->next = nullptr;
        reverseList(leftNode);
        pre->next = rightNode;
        leftNode->next = nxt;
        return dummy.next;
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        int n = 0;
        ListNode* cur = head;
        while (cur) {
            n++;
            cur = cur->next;
        }
        if (n < k) {
            return head;
        }
        ListNode* new_head = head;
        int times = n / k;
        for (int i = 0; times--; i += k) {
            ListNode* node = reverseBetween(new_head, i + 1, i + k);
            if (i == 0) {
                new_head = node;
            }
        }
        return new_head;
    }
};

23. 合并 K 个升序链表

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

✅ 快手一面，面试官来一题简单题😊，最后还问了时间复杂度：假设 k 个链表，共 n 个节点，那时间复杂度为 $O(k·logk+n·logk)$ 即 $O(n·logk)$。

1️⃣ 最小堆

时间复杂度分析：假设 $k$ 个链表, 共 $n$ 个节点, 最小堆单次操作 $O(log k)$, 初始化堆需要 $O(k·logk)$, 那时间复杂度为 $O(k·logk + n·logk)$，即 $O(n·logk)$。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](const ListNode* a, const ListNode* b) {
            return a->val > b->val;
        };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq;
        for (auto& head : lists) {
            if (head) {
                pq.push(head);
            }
        }
        ListNode dummy{};
        ListNode* head = &dummy;
        while (!pq.empty()) {
            ListNode* node = pq.top();
            pq.pop();
            head->next = node;
            head = head->next;
            if (node->next)
                pq.push(node->next);
        }
        return dummy.next;
    }
};

2️⃣ 分治法

前置题目：21. 合并两个有序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode dummy{};
        ListNode* cur = &dummy;
        while (list1 && list2) {
            if (list1->val < list2->val) {
                cur->next = list1;
                list1 = list1->next;
            } else {
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return dummy.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists, int l, int r) {
        if (l == r)
            return lists[l];
        if (l > r)
            return nullptr;
        int m = (l + r) >> 1;
        auto left = mergeKLists(lists, l, m);
        auto right = mergeKLists(lists, m + 1, r);
        return mergeTwoLists(left, right);
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return mergeKLists(lists, 0, lists.size() - 1);
    }
};

146. LRU 缓存

struct Node {
    int key;
    int value;
    Node* prev;
    Node* next;
    Node(int k = 0, int v = 0) : key(k), value(v) {}
};

class LRUCache {
private:
    Node* dummy;
    int capacity;
    unordered_map<int, Node*> key_to_node;

    void remove(Node* node) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

    void push_front(Node* node) {
        node->next = dummy->next;
        node->prev = dummy;
        dummy->next->prev = node;
        dummy->next = node;
    }

    Node* get_node(int key) {
        if (!key_to_node.count(key)) {
            return nullptr;
        }
        Node* node = key_to_node[key];
        remove(node);
        push_front(node);
        return node;
    }

public:
    LRUCache(int capacity) : capacity(capacity), dummy(new Node()) {
        dummy->next = dummy;
        dummy->prev = dummy;
    }

    int get(int key) {
        Node* node = get_node(key);
        return node == nullptr ? -1 : node->value;
    }

    void put(int key, int value) {
        Node* node = get_node(key);
        if (node != nullptr) {
            node->value = value;
            return;
        }
        node = new Node(key, value);
        if (key_to_node.size() == capacity) {
            Node* last = dummy->prev;
            remove(last);
            key_to_node.erase(last->key);
            delete last;
        }
        key_to_node[key] = node;
        push_front(node);
    }
};

138. 随机链表的复制

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;

    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> cacheNode;

    Node* copyRandomList(Node* head) {
        if (head == nullptr)
            return nullptr;
        if (!cacheNode.count(head)) {
            Node* newHead = new Node(head->val);
            cacheNode[head] = newHead;
            newHead->next = copyRandomList(head->next);
            newHead->random = copyRandomList(head->random);
        }
        return cacheNode[head];
    }
};

82. 删除排序链表中的重复元素 II

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode dummy(0, head);
        auto cur = &dummy;
        while (cur->next && cur->next->next) {
            int val = cur->next->val;
            if (cur->next->next->val == val) {
                while (cur->next && cur->next->val == val) {
                    cur->next = cur->next->next;
                }
            } else {
                cur = cur->next;
            }
        }
        return dummy.next;
    }
};

61. 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

思路：我们可以先将给定的链表连接成环，然后将指定位置断开。

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (k == 0 || !head || !head->next) {
            return head;
        }
        int n = 1;
        ListNode* iter = head;
        while (iter->next) {
            iter = iter->next;
            n++;
        }
        int t = n - k % n;
        if (t == n)
            return head;
        iter->next = head; // 连成环
        while (t--) {
            iter = iter->next;
        }
        ListNode* ret = iter->next;
        iter->next = nullptr;
        return ret;
    }
};

86. 分隔链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

1️⃣ 模拟

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode largeDummy(0);
        ListNode* large = &largeDummy;
        ListNode smallDummy(0);
        ListNode* small = &smallDummy;
        while (head) {
            if (head->val < x) {
                small->next = head;
                small = small->next;
            } else {
                large->next = head;
                large = large->next;
            }
            head = head->next;
        }
        small->next = largeDummy.next;
        large->next = nullptr;
        return smallDummy.next;
    }
};

148. 排序链表

1️⃣ 归并排序（分治法）｜链表的中间结点 + 合并两个有序链表

class Solution {
public:
    // 876. 链表的中间结点（快慢指针）
    ListNode* middleNode(ListNode* head) {
        ListNode* pre = head;
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next) {
            pre = slow;
            slow = slow->next;
            fast = fast->next->next;
        }
        pre->next = nullptr; // 断开 slow 与前一个节点的连接
        return slow;
    }

    // 21. 合并两个有序链表 (双指针)
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode dummy;
        ListNode* cur = &dummy;
        while (list1 && list2) {
            if (list1->val < list2->val) {
                cur->next = list1;
                list1 = list1->next;
            } else {
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return dummy.next;
    }

    ListNode* sortList(ListNode* head) {
        if (!head || !head->next)
            return head;
        ListNode* mid = middleNode(head);
        ListNode* head1 = sortList(head);
        ListNode* head2 = sortList(mid);
        return mergeTwoLists(head1, head2);
    }
};

快手一面｜合并 K 个升序链表

Mon, 28 Apr 2025 00:00:00 GMT

快手一面 & 时间复杂度

快手一面，面试官说来一题简单题😊，最后还问了时间复杂度：假设 k 个链表，共 n 个节点，那时间复杂度为 $O(k·logk+n·logk)$ 即 $O(n·logk)$。

23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

1️⃣ 最小堆

时间复杂度分析：假设 $k$ 个链表, 共 $n$ 个节点, 最小堆单次操作 $O(log k)$, 初始化堆需要 $O(k·logk)$, 那时间复杂度为 $O(k·logk + n·logk)$，即 $O(n·logk)$。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](const ListNode* a, const ListNode* b) {
            return a->val > b->val;
        };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq;
        for (auto& head : lists) {
            if (head) {
                pq.push(head);
            }
        }
        ListNode dummy{};
        ListNode* head = &dummy;
        while (!pq.empty()) {
            ListNode* node = pq.top();
            pq.pop();
            head->next = node;
            head = head->next;
            if (node->next)
                pq.push(node->next);
        }
        return dummy.next;
    }
};

2️⃣ 分治法

前置题目：21. 合并两个有序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode dummy{};
        ListNode* cur = &dummy;
        while (list1 && list2) {
            if (list1->val < list2->val) {
                cur->next = list1;
                list1 = list1->next;
            } else {
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return dummy.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists, int l, int r) {
        if (l == r)
            return lists[l];
        if (l > r)
            return nullptr;
        int m = (l + r) >> 1;
        auto left = mergeKLists(lists, l, m);
        auto right = mergeKLists(lists, m + 1, r);
        return mergeTwoLists(left, right);
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return mergeKLists(lists, 0, lists.size() - 1);
    }
};

复习「堆排序」

class Solution {
public:
    // 向下调整
    void heapify(vector<int>& nums, int i, int n) {
        int largest = i;
        int left = i * 2 + 1;
        int right = i * 2 + 2;
        if (left < n && nums[left] > nums[largest])
            largest = left;
        if (right < n && nums[right] > nums[largest])
            largest = right;
        if (largest != i) {
            swap(nums[largest], nums[i]);
            heapify(nums, largest, n);
        }
    }

    void heapsort(vector<int>& nums) {
        int n = nums.size();
        // i = n / 2 也可, 多判断一次而已
        // 向上初始化构建, 获取数组最大值
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(nums, i, n);
        }
        // 最大值不断调整到末尾, 并对新元素 nums[0] 向下进行调整
        for (int i = n - 1; i >= 0; i--) {
            swap(nums[i], nums[0]);
            heapify(nums, 0, i);    // 每次都从 0 开始调整
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        heapsort(nums);
        return nums;
    }
};

动态规划｜子数组或子序列的乘积最大值

Mon, 28 Apr 2025 00:00:00 GMT

字节面试原题⁉️

「子数组」乘积最大值：152. 乘积最大子数组
「子序列」乘积最大值：2708. 一个小组的最大实力值
「三维子数组」乘积最大值：1594. 矩阵的最大非负积（本题为「鹅厂」与「字节」面试算法题，也是「152. 乘积最大子数组」的升维算法题）

「子数组」乘积最大值：152. 乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size();
        vector<long> mx(nums.begin(), nums.end()), mn(nums.begin(), nums.end());
        for (int i = 1; i < n; i++) {
            mx[i] = max({mx[i - 1] * nums[i], (long)nums[i], mn[i - 1] * nums[i]});
            mn[i] = min({mn[i - 1] * nums[i], (long)nums[i], mx[i - 1] * nums[i]});
        }
        return *max_element(mx.begin(), mx.end());
    }
};

「子序列」乘积最大值：2708. 一个小组的最大实力值

给你一个下标从 0 开始的整数数组 nums ，它表示一个班级中所有学生在一次考试中的成绩。老师想选出一部分同学组成一个非空小组，且这个小组的 实力值 最大，如果这个小组里的学生下标为 i0, i1, i2, ... , ik ，那么这个小组的实力值定义为 nums[i0] * nums[i1] * nums[i2] * ... * nums[ik] 。

请你返回老师创建的小组能得到的最大实力值为多少。

输入：nums = [3,-1,-5,2,5,-9]
输出：1350
解释：一种构成最大实力值小组的方案是选择下标为 [0,2,3,4,5] 的学生。实力值为 3 * (-5) * 2 * 5 * (-9) = 1350 ，这是可以得到的最大实力值。

输入：nums = [-4,-5,-4]
输出：20
解释：选择下标为 [0, 1] 的学生。得到的实力值为 20 。我们没法得到更大的实力值。

class Solution {
public:
    long long maxStrength(vector<int>& nums) {
        long long mn = nums[0], mx = mn;
        for (int i = 1; i < nums.size(); i++) {
            long long x = nums[i];
            long long tmp = mn;
            mn = min({mn, x, mn * x, mx * x});
            mx = max({mx, x, tmp * x, mx * x});
        }
        return mx;
    }
};

「三维子数组」乘积最大值：1594. 矩阵的最大非负积

给你一个大小为 m x n 的矩阵 grid 。最初，你位于左上角 (0, 0) ，每一步，你可以在矩阵中向右或向下移动。

在从左上角 (0, 0) 开始到右下角 (m - 1, n - 1) 结束的所有路径中，找出具有 最大非负积 的路径。路径的积是沿路径访问的单元格中所有整数的乘积。

返回 最大非负积 对 10^9 + 7 取余的结果。如果最大积为负数，则返回 -1 。

注意：取余是在得到最大积之后执行的。

示例 1：

输入：grid = [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]
输出：-1
解释：从 (0, 0) 到 (2, 2) 的路径中无法得到非负积，所以返回 -1 。

示例 2：

输入：grid = [[1,-2,1],[1,-2,1],[3,-4,1]]
输出：8
解释：最大非负积对应的路径如图所示 (1 * 1 * -2 * -4 * 1 = 8)

✅ 本题为「鹅厂」与「字节」面试算法题，也是「152. 乘积最大子数组」的升维算法题

1️⃣ 三维数组

第三维度记录 min 与 max，需要单独初始化第一行和第一列。

由于过程中无法确定最大值的由来，那么需要「左」和「上」的最大最小值来乘于当前值 grid[i][j]，与「乘积最大子数组」思路一致。

class Solution {
public:
    int maxProductPath(vector<vector<int>>& grid) {
        const int MOD = 1e9 + 7;
        int m = grid.size(), n = grid[0].size();
        // [0]: min; [1]: max
        vector f(m, vector(n, vector(2, 0LL)));
        f[0][0] = {grid[0][0], grid[0][0]};
        for (int j = 1; j < n; j++) {
            f[0][j][0] = f[0][j - 1][0] * grid[0][j];
            f[0][j][1] = f[0][j - 1][1] * grid[0][j];
        }
        for (int i = 1; i < m; i++) {
            f[i][0][0] = f[i - 1][0][0] * grid[i][0];
            f[i][0][1] = f[i - 1][0][1] * grid[i][0];
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                int x = grid[i][j];
                f[i][j][0] = min({f[i - 1][j][0] * x, f[i - 1][j][1] * x,
                                  f[i][j - 1][0] * x, f[i][j - 1][1] * x});
                f[i][j][1] = max({f[i - 1][j][0] * x, f[i - 1][j][1] * x,
                                  f[i][j - 1][0] * x, f[i][j - 1][1] * x});
            }
        }
        return f[m - 1][n - 1][1] >= 0 ? f[m - 1][n - 1][1] % MOD : -1;
    }
};

2️⃣ 两个二维数组

相当于将方法一三维数组的第三维度拆分成两个二维数组，与「乘积最大子数组」思路一致。

class Solution {
public:
    int maxProductPath(vector<vector<int>>& grid) {
        const int MOD = 1e9 + 7;
        int m = grid.size(), n = grid[0].size();
        vector<vector<long long>> mx(m, vector<long long>(n));
        vector<vector<long long>> mn(m, vector<long long>(n));
        mx[0][0] = mn[0][0] = grid[0][0];
        for (int j = 1; j < n; j++)
            mx[0][j] = mn[0][j] = mx[0][j - 1] * grid[0][j];
        for (int i = 1; i < m; i++)
            mx[i][0] = mn[i][0] = mx[i - 1][0] * grid[i][0];
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                int x = grid[i][j];
                mx[i][j] = max({mx[i - 1][j] * x, mn[i - 1][j] * x,
                                mx[i][j - 1] * x, mn[i][j - 1] * x});
                mn[i][j] = min({mx[i - 1][j] * x, mn[i - 1][j] * x,
                                mx[i][j - 1] * x, mn[i][j - 1] * x});
            }
        }
        return mx[m - 1][n - 1] >= 0 ? mx[m - 1][n - 1] % MOD : -1;
    }
};

模运算

Mon, 28 Apr 2025 00:00:00 GMT

✅ 模运算

代码实现时，加减乘除如下：

MOD = 1_000_000_007

// 加‼️
(a + b) % MOD = ((a % MOD) + (b % MOD)) % MOD

// 减
(a - b + MOD) % MOD

// 把任意整数 a 取模到 [0,MOD-1] 中，无论 a 是正是负
(a % MOD + MOD) % MOD

// 乘（注意使用 64 位整数）‼️
a * b % MOD = ((a % MOD) * (b % MOD)) % MOD

// 多个数相乘，要步步取模，防止溢出
a * b % MOD * c % MOD

// 除（MOD 是质数且 b 不是 MOD 的倍数）
a * qpow(b, MOD - 2, MOD) % MOD

其中 qpow 为快速幂，具体请看【图解】一张图秒懂快速幂。

注：Python 内置快速幂函数 pow(x, y, m) 用于计算 $x^y\ mod\ m$。特别地，除法也可以写成 a * pow(b, -1, MOD) % MOD

总之，如果发现解答错误，可以检查下代码，看看是不是哪里漏掉取模了。

取模练习题｜3379. 转换数组

给你一个整数数组 nums，它表示一个循环数组。请你遵循以下规则创建一个大小相同的新数组 result ：

对于每个下标 i（其中 0 <= i < nums.length），独立执行以下操作：

如果 nums[i] > 0：从下标 i 开始，向右移动 nums[i] 步，在循环数组中落脚的下标对应的值赋给 result[i]。
如果 nums[i] < 0：从下标 i 开始，向左移动 abs(nums[i]) 步，在循环数组中落脚的下标对应的值赋给 result[i]。
如果 nums[i] == 0：将 nums[i] 的值赋给 result[i]。

返回新数组 result。

**注意：**由于 nums 是循环数组，向右移动超过最后一个元素时将回到开头，向左移动超过第一个元素时将回到末尾。

示例 1：

输入： nums = [3,-2,1,1]

输出： [1,1,1,3]

解释：

对于 nums[0] 等于 3，向右移动 3 步到 nums[3]，因此 result[0] 为 1。
对于 nums[1] 等于 -2，向左移动 2 步到 nums[3]，因此 result[1] 为 1。
对于 nums[2] 等于 1，向右移动 1 步到 nums[3]，因此 result[2] 为 1。
对于 nums[3] 等于 1，向右移动 1 步到 nums[0]，因此 result[3] 为 3。

class Solution {
public:
    vector<int> constructTransformedArray(vector<int>& nums) {
        // 由于数组是循环数组，把下标对 n 取模
        int n = nums.size();
        vector<int> result(n);
        for (int i = 0; i < n; i++) {
            result[i] = nums[((i + nums[i]) % n + n) % n];
        }
        return result;
    }
};

单调栈

Mon, 28 Apr 2025 00:00:00 GMT

✅ 单调栈相关例题

84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

示例 1:

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

1️⃣ 单调栈

class Solution {
public:
    int largestRectangleArea(vector<int> &heights) {
        int n = heights.size();
        vector<int> left(n, -1);
        stack<int> st;
        for (int i = 0; i < n; i++) {
            while (!st.empty() && heights[i] <= heights[st.top()]) {
                st.pop();
            }
            if (!st.empty()) {
                left[i] = st.top();
            }
            st.push(i);
        }

        vector<int> right(n, n);
        st = stack<int>();
        for (int i = n - 1; i >= 0; i--) {
            while (!st.empty() && heights[i] <= heights[st.top()]) {
                st.pop();
            }
            if (!st.empty()) {
                right[i] = st.top();
            }
            st.push(i);
        }

        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans = max(ans, heights[i] * (right[i] - left[i] - 1));
        }
        return ans;
    }
};

42. 接雨水（常用「相向双指针」方法）

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

1️⃣ 前后缀分离

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        vector<int> pre_max(n); // pre_max[i] 表示从 height[0] 到 height[i] 的最大值
        pre_max[0] = height[0];
        for (int i = 1; i < n; i++) {
            pre_max[i] = max(pre_max[i - 1], height[i]);
        }

        vector<int> suf_max(n); // suf_max[i] 表示从 height[i] 到 height[n-1] 的最大值
        suf_max[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            suf_max[i] = max(suf_max[i + 1], height[i]);
        }

        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += min(pre_max[i], suf_max[i]) - height[i]; // 累加每个水桶能接多少水
        }
        return ans;
    }
};

2️⃣ 相向双指针（谁小谁移动）

利用这个思路可以完成「3D 接雨水」

注意 while 循环可以不加等号，因为在「谁小移动谁」的规则下，相遇的位置一定是最高的柱子，这个柱子是无法接水的。

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0, left = 0, right = height.size() - 1, pre_max = 0, suf_max = 0;
        while (left < right) {
            pre_max = max(pre_max, height[left]);
            suf_max = max(suf_max, height[right]);
            ans += pre_max < suf_max ? pre_max - height[left++] : suf_max - height[right--];
        }
        return ans;
    }
};

3️⃣ 单调栈

上面的方法相当于「竖着」计算面积，单调栈的做法相当于「横着」计算面积。

这个方法可以总结成 16 个字：找上一个更大元素，在找的过程中填坑。

注意 while 中加了等号，这可以让栈中没有重复元素，从而在有很多重复元素的情况下，使用更少的空间。

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        stack<int> st;
        for (int i = 0; i < height.size(); i++) {
            while (!st.empty() && height[i] >= height[st.top()]) {
                int bottom_h = height[st.top()];
                st.pop();
                if (st.empty()) {
                    break;
                }
                int left = st.top();
                int dh = min(height[left], height[i]) - bottom_h; // 面积的高
                ans += dh * (i - left - 1);
            }
            st.push(i);
        }
        return ans;
    }
};

407. 接雨水 II（短板效应）

给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。

示例 1:

输入: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]
输出: 4
解释: 下雨后，雨水将会被上图蓝色的方块中。总的接雨水量为1+2+1=4。

示例 2:

输入: heightMap = [[3,3,3,3,3],[3,2,2,2,3],[3,2,1,2,3],[3,2,2,2,3],[3,3,3,3,3]]
输出: 10

1️⃣ 优先队列 priority_queue 维护短板

哪个格子的接水量，在一开始就能确定？

最外面一圈的格子是无法接水的。
假设 (0,1) 的高度是最外面一圈的格子中最小的，且高度等于 5，那么和它相邻的 (1,1)，我们能知道：
- (1,1) 的水位不能超过 5，否则水会从 (0,1) 流出去。
- (1,1) 的水位一定可以等于 5，这是因为 (0,1) 的高度是最外面一圈的格子中最小的，(1,1) 的水不可能从其他地方流出去。

我们从最外面一圈的格子开始。想象成一个木桶，最外面一圈格子的高度视作木板的高度。

接着上面的讨论：

如果 (1,1) 的高度 ≥ 5，那么 (0,1) 这块木板就没用了，我们去掉 (0,1) 这块木板，改用 (1,1) 这块木板。
如果 (1,1) 的高度 < 5，假设我们接的不是水，是水泥。那么把 (1,1) 的高度填充为 5，仍然可以去掉 (0,1) 这块木板，改用 (1,1) 这块（填充水泥后）高为 5 的木板水泥板。

继续，从当前木板中，找到一根最短的木板。假设 (1,1) 是当前所有木板中最短的，那么其邻居 (1,2) 和 (2,1) 的水位就是 (1,1) 的高度，因为超过 (1,1) 高度的水会流出去。然后，去掉 (1,1) 这块木板，改用 (1,2) 和 (2,1) 这两块木板。依此类推。

由于每次都要找最短的木板，所以用一个最小堆维护木板的高度。按照上述做法，不断循环，直到堆为空。

为方便实现，代码在初始化堆的时候，直接遍历了整个矩阵。

「42. 接雨水」那题需要维护左右两个指针，本题相当于维护了“一圈”指针。42 那题每次取左右最小的指针，然后移动到相邻位置上；本题也是取最小的指针（出堆），往周围的邻居移动（入堆）。

class Solution {
    static constexpr int DIRS[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

public:
    int trapRainWater(vector<vector<int>>& heightMap) {
        int m = heightMap.size(), n = heightMap[0].size();
        priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, greater<>> pq;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
                    pq.push({heightMap[i][j], i, j});
                    heightMap[i][j] = -1;
                }
            }
        }
        int ans = 0;
        while (!pq.empty()) {
            auto [min_height, i, j] = pq.top();
            pq.pop();
            for (auto& [dx, dy] : DIRS) {
                int x = i + dx;
                int y = j + dy;
                if (x >= 0 && y >= 0 && x < m && y < n && heightMap[x][y] != -1) {
                    ans += max(min_height - heightMap[x][y], 0);
                    pq.push({max(min_height, heightMap[x][y]), x, y});
                    heightMap[x][y] = -1;
                }
            }
        }
        return ans;
    }
};

907. 子数组的最小值之和

给定一个整数数组 arr，找到 min(b) 的总和，其中 b 的范围为 arr 的每个（连续）子数组。

由于答案可能很大，因此 返回答案模 10^9 + 7 。

示例 1：

输入：arr = [3,1,2,4]
输出：17
解释：
子数组为 [3]，[1]，[2]，[4]，[3,1]，[1,2]，[2,4]，[3,1,2]，[1,2,4]，[3,1,2,4]。 
最小值为 3，1，2，4，1，1，2，1，1，1，和为 17。

1️⃣ 单调栈

解法等价于「84. 柱状图中最大的矩形」，本题计算以 arr[i] 为最小值的子数组的个数：

class Solution {
    const int MOD = 1e9 + 7;

public:
    // 类似题目: 84. 柱状图中最大的矩形
    int sumSubarrayMins(vector<int>& arr) {
        int n = arr.size();
        // 左边界 left[i] 为左侧严格小于 arr[i] 的最近元素位置（不存在时为 -1）
        vector<int> left(n, -1);
        stack<int> st;
        for (int i = 0; i < n; i++) {
            while (!st.empty() && arr[st.top()] >= arr[i])
                st.pop();
            if (!st.empty())
                left[i] = st.top();
            st.push(i);
        }

        st = stack<int>();
        // 右侧找 <= 是为了避免重复统计
        // 右边界 right[i] 为右侧小于等于 arr[i] 的最近元素位置（不存在时为 n）
        vector<int> right(n, n);
        for (int i = n - 1; i >= 0; i--) {
            while (!st.empty() && arr[st.top()] > arr[i])
                st.pop();
            if (!st.empty())
                right[i] = st.top();
            st.push(i);
        }
        long ans = 0l;
        for (int i = 0; i < n; i++) {
            ans += (long)arr[i] * (i - left[i]) * (right[i] - i);
        }
        return ans % MOD;
    }
};

1793. 好子数组的最大分数

给你一个整数数组 nums **（下标从 0 开始）**和一个整数 k 。

一个子数组 (i, j) 的分数定义为 min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1) 。一个好子数组的两个端点下标需要满足 i <= k <= j 。

请你返回好子数组的最大可能分数。

示例 1：

输入：nums = [1,4,3,7,4,5], k = 3
输出：15
解释：最优子数组的左右端点下标是 (1, 5) ，分数为 min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15 。

1️⃣ 背向双指针

我们尝试从 $i=k, j=k$ 出发，通过不断移动指针来找到最大矩形。比较 nums[i−1] 和 nums[j+1] 的大小，谁大就移动谁（一样大移动哪个都可以）。

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int max_score = nums[k], n = nums.size(), mn = nums[k];
        int l = k, r = k;
        for (int t = 1; t < n; t++) {
            if (r == n - 1 || (l && nums[l - 1] > nums[r + 1])) {
                mn = min(mn, nums[--l]);
            } else {
                mn = min(mn, nums[++r]);
            }
            max_score = max(max_score, mn * (r - l + 1));
        }
        return max_score;
    }
};

2️⃣ 单调栈

本题要计算的分数，和「84. 柱状图中最大的矩形」是一样的，计算的是最大矩形面积，只不过多了一个约束：矩形必须包含下标 k。

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> left(n), right(n);
        stack<int> st;
        for (int i = 0; i < n; i++) {
            while (!st.empty() && nums[st.top()] >= nums[i]) {
                st.pop();
            }
            left[i] = st.empty() ? -1 : st.top();
            st.push(i);
        }
        st = stack<int>();
        for (int i = n - 1; i >= 0; i--) {
            while (!st.empty() && nums[st.top()] >= nums[i]) {
                st.pop();
            }
            right[i] = st.empty() ? n : st.top();
            st.push(i);
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            // 分数的定义其实就是矩形面积: 同「84. 柱状图中最大的矩形」
            int score = nums[i] * (right[i] - left[i] - 1);
            // 仅仅加一个判断条件即可
            if (left[i] < k && right[i] > k)
                ans = max(ans, score);
        }
        return ans;
    }
};

快速幂

Mon, 28 Apr 2025 00:00:00 GMT

✅ 快速幂

快速幂相关题目：

2961. 双模幂运算 [1451]
2550. 猴子碰撞的方法数 [1663]
372. 超级次方 [算术评级 5]
50. Pow(x, n) [算术评级 5]

# python 自带快速幂库函数用于计算 x^y mod m
pow(x, y, m)

CPP 手撕「快速幂」库函数

// 本题 mod 很小，即使平方也不会超过 int 范围，所以不需要用 long long
int pow(int x, int n, int mod) {
    // long long res
    int res = 1;
    while (n) {
        if (n & 1) {
            res = res * x % mod;
        }
        x = x * x % mod;
        n >>= 1;
    }
    return res;
}

快速幂实现思路（workflow）如下图：

代码实现时，注意 n=−$2^{31}$ 的情况，取反后 n=$2^{31}$ 超出 int 最大值。可以转成 64 位 int 解决（即 long long）

50. Pow(x, n)（包含负数与浮点数）

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，$x^n$ ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

1️⃣ 快速幂（模板代码）

class Solution {
public:
    double myPow(double x, int N) {
        double ans = 1;
        long long n = N;
        if (n < 0) { // x^-n = (1/x)^n
            n = -n;
            x = 1 / x;
        }
        while (n) { // 从低到高枚举 n 的每个比特位
            if (n & 1) { // 这个比特位是 1
                ans *= x; // 把 x 乘到 ans 中
            }
            x *= x; // x 自身平方
            n >>= 1; // 继续枚举下一个比特位
        }
        return ans;
    }
};

372. 超级次方

你的任务是计算 $a^b$ 对 1337 取模，a 是一个正整数，b 是一个非常大的正整数且会以数组形式给出。

示例 1：

输入：a = 2, b = [3]
输出：8

示例 2：

输入：a = 2, b = [1,0]
输出：1024

1️⃣ DFS + 快速幂

class Solution {
public:
    int MOD = 1337;

    int qpow(int x, int n) {
        int res = 1;
        // due to dfs()
        x %= MOD;
        while (n) {
            if (n & 1) {
                res = res * x % MOD;
            }
            x = x * x % MOD;
            n >>= 1;
        }
        return res;
    }

    int dfs(int a, vector<int>& b, int idx) {
        if (idx == -1)
            return 1;
        return qpow(a, b[idx]) * qpow(dfs(a, b, idx - 1), 10) % MOD;
    }

    int superPow(int a, vector<int>& b) {
        return dfs(a, b, b.size() - 1);
    }
};

2550. 猴子碰撞的方法数

现在有一个正凸多边形，其上共有 n 个顶点。顶点按顺时针方向从 0 到 n - 1 依次编号。每个顶点上 正好有一只猴子 。下图中是一个 6 个顶点的凸多边形。

每个猴子同时移动到相邻的顶点。顶点 i 的相邻顶点可以是：

顺时针方向的顶点 (i + 1) % n ，或
逆时针方向的顶点 (i - 1 + n) % n 。

如果移动后至少有两只猴子停留在同一个顶点上或者相交在一条边上，则会发生碰撞。

返回猴子至少发生 一次碰撞 的移动方法数。由于答案可能非常大，请返回对 109+7 取余后的结果。

注意，每只猴子只能移动一次。

示例 1：

输入：n = 3
输出：6
解释：共计 8 种移动方式。
下面列出两种会发生碰撞的方式：
- 猴子 1 顺时针移动；猴子 2 逆时针移动；猴子 3 顺时针移动。猴子 1 和猴子 2 碰撞。
- 猴子 1 逆时针移动；猴子 2 逆时针移动；猴子 3 顺时针移动。猴子 1 和猴子 3 碰撞。
可以证明，有 6 种让猴子碰撞的方法。

1️⃣ 正难则反｜快速幂

只有全部顺时针和全部逆时针这 2 种不会碰撞，所以只需要计算 $2^n-2$，这就需要用到快速幂。

C++：手搓快速幂
Python：使用内置 pow(x, n, mod) 快速幂库函数

class Solution {
public:
    int MOD = 1e9 + 7;

    int qpow(long long x, int n) {
        int res = 1;
        while (n) {
            if (n & 1) {
                res = ((res % MOD) * (x % MOD)) % MOD;
            }
            x = ((x % MOD) * (x % MOD)) % MOD;
            n >>= 1;
        }
        return res;
    }

    int monkeyMove(int n) {
        int ans = qpow(2, n);
        return (ans - 2 + MOD) % MOD;
    }
};

class Solution:
    def monkeyMove(self, n: int) -> int:
        MOD = 1_000_000_007
        return (pow(2, n, MOD) - 2) % MOD

质数筛法（暴力、埃式筛、欧拉筛）

Mon, 28 Apr 2025 00:00:00 GMT

如何判断一个数是不是质数，现在求区间 $[1,1e7]$ 内所有质数，学习「埃式筛法」和「欧拉筛法」之前，先介绍下暴力筛选。

可借此题验证下：204. 计数质数

1. 暴力筛选

0 表示质数，1 表示合数。

static final int N = 1e7 + 5;
int st[N]; // 初始化为0，0表示质数，1表示合数

for(int i = 2; i <= n; i++){
	for(int j = 2; j * j <= i; j++){ //试除法
		if(i % j == 0){
			st[i] = 1; // 合数，标记为1
            break;
		}
	}
}

2. 埃式筛法

这种方法无疑是最慢的，换一种思路：一个质数的倍数一定是合数。

所以假设 P 是质数，我们可以筛选掉区间 $[1,1e7]$ 中所有 P 的倍数。

为什么这样能筛去所有的合数呢，因为一个合数一定能被分解为几个质数的幂的乘积，并且这个数的质因子一定是小于它本身的，所以当我们从小到大将每个质数的倍数都筛去的话，当遍历到一个合数时，它一定已经被它的质因子给筛去了。

#include <iostream>
#include <vector>

const int N = 1e7 + 5;
int st[N]; // st[i] == 1 表示 i 是合数；0 表示 i 是素数

void E_sieve(int n) {
    for (int i = 2; i <= n; i++) {
        if (st[i] == 0) {
            for (int j = 2 * i; j <= n; j += i) {
                st[j] = 1; // j 是 i 的倍数，是合数，标记为 1
            }
        }
    }
}

我们还可以对其进行优化：

我们会先筛 2 的所有倍数，然后筛 3 的所有倍数，但筛除3的倍数时，我们还是从 3 的 2 倍开始筛，其实 $3 * 2$ ，已经被 $2 * 3$ 时筛过了。又比如说筛 5 的倍数时，我们从 5 的 2 倍开始筛，但是 $5 * 2$ 会先被 $2 * 5$ 筛去，$5 * 3$ 会先被 $3 * 5$ 筛去，$5 * 4$ 会先被 $2 * 10$ 筛去，所以我们每一次只需要从 $i * i$ 开始筛，因为 $(2，3,…,i - 1)$ 倍已经被筛过了。
另外，判断一个数 n 是不是质数，我们只需要判断 $[2,\sqrt{n}]$ 内有没有它的因子，在筛选合数时，我们也可以这样做，因为一个合数的最小质因子一定小于等于 $\sqrt{n}$。

优化后的埃式筛法：

#include <iostream>

const int N = 1e7 + 5;
int st[N]; // st[i] == 1 表示 i 是合数，0 表示 i 是素数

void E_sieve(int n) {
    for (int i = 2; i <= n / i; i++) {
        if (st[i] == 0) {
            for (int j = i * i; j <= n; j += i) {
                st[j] = 1; // j 是 i 的倍数，标记为合数
            }
        }
    }
}

时间复杂度可以近似看成 $O(n)$

但是我们还可以更快，那就是欧拉筛，又称为线性筛。

3. 欧拉筛法/线性筛法

欧拉筛的核心思想就是确保每个合数只被最小质因数筛掉，或者说被合数的最大因子筛掉。

比如 $120 = 2^3 * 3 * 5$，120 会被 2 筛一次，3 筛一次，5 筛一次。

多做了两次不必要的操作，如何确保 120 只 2 筛选掉。

时间复杂度：$O(n)$

#include <iostream>

const int N = 1e7 + 5;
int st[N];           // st[i] == 1 表示 i 是合数
int primes[N];       // 存所有质数
int cnt = 0;         // 质数的个数

void ola(int n) {
    for (int i = 2; i <= n; i++) {
        if (st[i] == 0) {
            primes[cnt++] = i; // i 是质数，加入 primes 数组
        }
        for (int j = 0; j < cnt && primes[j] <= n / i; j++) {
            st[primes[j] * i] = 1; 	// 标记合数
            if (i % primes[j] == 0) // 保证每个合数只被它的最小质因子筛一次
                break;
        }
    }
}

排序数组（堆排、快排、归排）

Mon, 28 Apr 2025 00:00:00 GMT

1️⃣ 堆排序

class Solution {
public:
    // 向下调整
    void heapify(vector<int>& nums, int i, int n) {
        int largest = i;
        int left = i * 2 + 1;
        int right = i * 2 + 2;
        if (left < n && nums[left] > nums[largest])
            largest = left;
        if (right < n && nums[right] > nums[largest])
            largest = right;
        if (largest != i) {
            swap(nums[largest], nums[i]);
            heapify(nums, largest, n);
        }
    }

    void heapsort(vector<int>& nums) {
        int n = nums.size();
        // i = n / 2 也可, 多判断一次而已
        // 向上初始化构建, 获取数组最大值
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(nums, i, n);
        }
        // 最大值不断调整到末尾, 并对新元素 nums[0] 向下进行调整
        for (int i = n - 1; i >= 0; i--) {
            swap(nums[i], nums[0]);
            heapify(nums, 0, i);    // 每次都从 0 开始调整
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        heapsort(nums);
        return nums;
    }
};

2️⃣ 快速排序（朴素版）

class Solution {
public:
    int partition(vector<int>& nums, int l, int r) {
        int pivot = nums[l];
        int i = l, j = r + 1;
        while (i < j) {
            // while (i < r && nums[++i] < pivot) 也可
            while (++i < r && nums[i] < pivot)
                ;
            // while (j > l && nums[--j] > pivot) 也可
            while (--j > l && nums[j] > pivot)
                ;
            if (i < j) {
                swap(nums[i], nums[j]);
            }
        }
        swap(nums[l], nums[j]);
        return j;
    }

    void quicksort(vector<int>& nums, int l, int r) {
        if (l < r) {
            int pivot = partition(nums, l, r);
            quicksort(nums, l, pivot - 1);
            quicksort(nums, pivot + 1, r);
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        quicksort(nums, 0, nums.size() - 1);
        return nums;
    }
};

3️⃣ 快速排序（随机版 · 性能🔝）

class Solution {
public:
    int partition(vector<int>& nums, int l, int r) {
        int pivot = nums[l];
        int i = l, j = r + 1;
        while (i < j) {
            while (++i < r && nums[i] < pivot)
                ;
            while (--j > l && nums[j] > pivot)
                ;
            if (i < j) {
                swap(nums[i], nums[j]);
            }
        }
        swap(nums[l], nums[j]);
        return j;
    }

    int randomized_partition(vector<int>& nums, int l, int r) {
        int i = l + rand() % (r - l + 1);
        swap(nums[i], nums[l]);
        return partition(nums, l, r);
    }

    void quicksort(vector<int>& nums, int l, int r) {
        if (l < r) {
            int pivot = randomized_partition(nums, l, r);
            quicksort(nums, l, pivot - 1);
            quicksort(nums, pivot + 1, r);
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        quicksort(nums, 0, nums.size() - 1);
        return nums;
    }
};

4️⃣ 归并排序

class Solution {
public:
    void merge(vector<int>& nums, int l, int m, int r) {
        int i = l, j = m + 1, k = 0;
        vector<int> temp(r - l + 1);
        while (i <= m || j <= r) {
            if (i > m) {
                temp[k++] = nums[j++];
            } else if (j > r) {
                temp[k++] = nums[i++];
            } else if (nums[i] < nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        for (int idx = 0; idx < (r - l + 1); idx++) {
            nums[l + idx] = temp[idx];
        }
    }

    void mergesort(vector<int>& nums, int l, int r) {
        if (l >= r)
            return;
        int m = (l + r) / 2;
        mergesort(nums, l, m);
        mergesort(nums, m + 1, r);
        merge(nums, l, m, r);
    }

    vector<int> sortArray(vector<int>& nums) {
        mergesort(nums, 0, nums.size() - 1);
        return nums;
    }
};

腾讯 wxg 一面｜354. 俄罗斯套娃信封问题

Mon, 28 Apr 2025 00:00:00 GMT

腾讯 WXG 一面｜354. 俄罗斯套娃信封问题

给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。

当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。

注意：不允许旋转信封。

示例 1：

输入：envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出：3
解释：最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。

示例 2：

输入：envelopes = [[1,1],[1,1],[1,1]]
输出：1

提示：

1 <= envelopes.length <= 10^5
envelopes[i].length == 2
1 <= wi, hi <= 10^5

0️⃣ 前置题目

✅ 300. 最长递增子序列｜DP / 二分

1️⃣ LIS · 动态规划（超时 TLE）

时间复杂度 $O(n^2)$

class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        int n = envelopes.size();
        vector<pair<int, int>> arr(n);
        for (int i = 0; i < n; i++)
            arr[i] = {envelopes[i][0], envelopes[i][1]};
        ranges::sort(arr);

        vector<int> f(n, 1);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i].first > arr[j].first && arr[i].second > arr[j].second) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
        }
        return ranges::max(f);
    }
};

2️⃣ 贪心 + 二分查找

时间复杂度：$O(n·logn)$

先排序，再按照 LIS 二分贪心模板求最长递增子序列。因为二者都必须是递增的，所以第二维度需要逆序排序，使得第一维度相同的多个数，最后一个插入的一定是最小值，这样能嵌套的信封最多。

class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        sort(envelopes.begin(), envelopes.end(), [](auto& a, auto& b) {
            return a[0] < b[0] || (a[0] == b[0] && a[1] > b[1]);
        });
        vector<int> g;
        for (auto& e : envelopes) {
            auto it = lower_bound(g.begin(), g.end(), e[1]);
            if (it == g.end()) {
                g.push_back(e[1]);
            } else {
                *it = e[1];
            }
        }
        return g.size();
    }
};

并查集

Mon, 28 Apr 2025 00:00:00 GMT

✅ 并查集

相关例题：

并查集是一种用于管理元素所属集合的数据结构，实现为一个森林，其中每棵树表示一个集合，树中的节点表示对应集合中的元素。

顾名思义，并查集支持两种操作：

合并（Union）：合并两个元素所属集合（合并对应的树）
查询（Find）：查询某个元素所属集合（查询对应的树的根节点），这可以用于判断两个元素是否属于同一集合

并查集在经过修改后可以支持单个元素的删除、移动；使用动态开点线段树还可以实现可持久化并查集。

模板代码

vector<int> p(n);

iota(p.begin(), p.end(), 0);

vector<int> size(n, 1);

int find(int x) {
    if (p[x] != x) {
        // 路径压缩
        p[x] = find(p[x]);
    }
    return p[x];
}

void unite(int a, int b) {
    int pa = find(a), pb = find(b);
    if (pa == pb) return;
    p[pa] = pb;
    size[pb] += size[pa];
}

684. 冗余连接

树可以看成是一个连通且无环的无向图。

给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。

请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的那个。

示例 1：

输入: edges = [[1,2], [1,3], [2,3]]
输出: [2,3]

示例 2：

输入: edges = [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]

1️⃣ 并查集

class Solution {
public:
    vector<int> p;

    void init(int n) {
        p.resize(n + 1);
        iota(p.begin(), p.end(), 0);
    }

    int find(int x) {
        if (x != p[x])
            p[x] = find(p[x]); // 路经压缩
        return p[x];
    }

    bool isSame(int u, int v) {
        int pu = find(u);
        int pv = find(v);
        return pu == pv;
    }

    void join(int u, int v) {
        int pu = find(u);
        int pv = find(v);
        p[pu] = pv;
    }

    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        init(edges.size());
        for (auto e : edges) {
            int u = e[0], v = e[1];
            if (isSame(u, v)) {
                return e;
            } else {
                join(u, v);
            }
        }
        return {};
    }
};

C++ ACM 模式

Sun, 27 Apr 2025 00:00:00 GMT

✅ 华为校招机考备考题单：https://rttxvuqg3f.feishu.cn/docx/PcBHdy3GsoIhxnx1RqucVqRdnAf

C++ ACM 模式输入输出

1. 输入输出的相关库函数

1️⃣ 输出格式化（精度）

C++ 提供了多种方式来控制输入输出的格式，常用的包括 std::setw、std::setprecision、std::fixed 等。

#include <iostream>
#include <iomanip>  // 提供格式化工具

int main() {
    double pi = 3.14159265358979;
    
    std::cout << "原始值: " << pi << std::endl;

    // 设置输出精度为 2 位小数
    std::cout << "保留两位小数: " << std::fixed << std::setprecision(2) << pi << std::endl;
    return 0;
}

2️⃣ cin

cin 是标准输入流对象，通常用于从用户那里读取数据。当我们用 while (cin) 来读取输入时，它的工作原理是不断检查输入流是否有效。如果用户输入了数据并且没有遇到错误或者文件结束标志（例如 Ctrl+Z 或 Ctrl+D 表示 EOF），那么 cin 就会继续读取并进入循环。

注意，cin >> val 会一直从 标准输入流 中读取数据，以空白字符为分隔符，包括：

空格 ' '
回车 '\n'
制表符 '\t'

这些都是分隔符，但 不会终止输入流，只是划分输入的不同部分。

3️⃣ stringstream

std::stringstream 是 C++ 标准库中的一个类，位于 <sstream> 头文件中。它提供了一个用于在内存中进行输入输出操作的字符串流。std::stringstream 允许你像使用 std::cin 和 std::cout 一样操作字符串，它可以用来从字符串中读取数据，或将数据写入到字符串中。它的主要用途是进行字符串的格式化和数据的转换。

std::stringstream 继承自 std::iostream，因此可以使用 << 和 >> 运算符来进行数据流的输入输出。如果想清空 stringstream 中的数据，可以使用 str("") 方法，将流的内容设置为空字符串，或者使用 clear() 来重置流的状态。

#include <iostream>
#include <sstream>

int main() {
    std::stringstream ss1;
    int x = 10;
    double y = 3.14;
    ss1 << "Integer: " << x << ", Double: " << y;
    std::cout << ss.str() << std::endl;
    
    std::stringstream ss2("123 456 3.14");
    int a, b;
    double c;
    ss >> a >> b >> c;
    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
    
    // 清空: ss.str("")
    ss1.str("");
}

4️⃣ getline

getline 函数是 C++ 中用于从输入流中读取一行文本的函数，通常用于读取用户输入或文件中的一行数据。它的基本用法是：读取一整行数据，直到遇到换行符（\n）为止。它不会将换行符包含在返回的字符串中。函数原型为：

istream& getline (istream& is, string& str);

它接受两个参数：

is：输入流对象（如 cin 或 ifstream）。
str：存储读取内容的 string 对象。

#include <iostream>
#include <string>
using namespace std;

int main() {
    // 输入 1 2 3 4
    string line;
    while (getline(cin, line)) {
        cout << "输入的行是: " << line << endl;
    }
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

int main() {
    std::string input;
    std::cin >> input;  // 输入 1,2,3,4

    std::stringstream ss(input);
    std::vector<int> nums;
    std::string number;
	// stringstream, string
    while (getline(ss, number, ',')) {
        nums.push_back(std::stoi(number));
    }
    return 0;
}

2. A+B+C+...（单行输入版）

输入样例：

1 2 3 4 5

输出样例：

题解：

#include <bits/stdc++.h>
using namespace std;

int main() {
  // 数据范围: -10^9 <= x <= 10^9
  long long val, s = 0;
  while (cin >> val) {
    s += val;
  }
  cout << s << endl;
  return 0;
}

3. A+B+C+...（多行输入版）

输入样例：

1 2 3
4 5 6 7
8 9

输出样例：

6
22
17

题解：

#include <iostream>
#include <sstream>
using namespace std;

int main() {
  string line;
  while (getline(cin, line)) { // 持续读取完整一行，一直到 EOF
    // 使用 stringstream 解析每一行的输入
    // 假设读到的是"1 2 3"
    stringstream ss(line);
    long long num, sum = 0;
    while (ss >> num) { // 逐个读取这一行的整数
      sum += num;       // 将读取的整数累加到 sum 中
                        // 先是sum += 1
                        // 再是sum += 2
                        // 最后是sum += 3
    }
    cout << sum << endl; // 输出这一行所有整数的和 : 6
  }
  return 0;
}

🔥 4. A+B+C+...（带元素个数的多行输入版）

输入：

输出：

3
1
0

⚠️ 本题反而要注意：cin 不是读到 \n 停止，而是 EOF，所以 line 14 不能用 while(cin >> val) 来替代，否则后续元素都会被吸收到 nums 数组中。

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, Q;
  cin >> n >> Q;

  vector<int> nums(n);
  for (int i = 0; i < n; i++) {
    cin >> nums[i];
  }
  vector<int> query(Q);
  for (int i = 0; i < Q; i++) {
    cin >> query[i];
  }
  return 0;
}

或者可以使用 cin.peek() != '\n' 搭配 cin >> val 使用（这一刻我才明白 cin.peek() 与 cin.ignore() 的作用）：

记得先处理上一行的末尾（如果需要处理）：cin.ignore() 或 cin.get()
再使用 cin.peek() != '\n' & cin >> val 来循环读取当前行元素

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, Q;
  cin >> n >> Q;
  //vector<int> nums(n);
  //for (int i = 0; i < n; i++) {
  //  cin >> nums[i];
  //}
    
// 等价于
    
  // 🔥注意这里需要处理第一行的 '\n', 因为 cin >> n >> Q 后还没跳到下一行。
  cin.ignore();	// 或者 cin.get();
  vector<int> nums;
  int val;
  while (cin.peek() != '\n' && cin >> val) {
      nums.push_back(val);
  }
  vector<int> query(Q);
  for (int i = 0; i < Q; i++) {
    cin >> query[i];
  }
  return 0;
}

⚠️ 拓展延伸

1️⃣ 上述的输入是：

5 3⏎(换行)
1 2 2 3 2⏎(换行)
2⏎(换行)
3⏎(换行)
4⏎(换行)

2️⃣ 假设输入变成以下这种（即第二行换行符前还有一个␣(空格)）：

5 3⏎(换行)
1 2 2 3 2␣(空格)⏎(换行)
2⏎(换行)
3⏎(换行)
4⏎(换行)

那 nums 的个数会有 6 个，即第 3 行的 2 也会当成 nums 的元素，因为 ␣(空格) 不是 \n，所以会再触发一次 cin 操作，所以建议使用 for (int i = 0; i < n; i++) { cin >> nums[i]; } 的方式替代 peek() 判断！

OJ 时间复杂度限制与预估

在编写程序时，分析其时间复杂度（Time Complexity）是评估程序效率的重要手段。时间复杂度描述了程序运行时间与输入规模之间的关系，通常使用大O符号表示（如O(n)、O(n²)等）。下面将详细解释时间复杂度的概念，并分析这段代码的时间复杂度。

🔥 OJ 一般 C++ 1秒（即1000ms）大概能跑 1e8 量级（很多题目都会限制时间和内存，如下：

时间限制: C/C++ 1000ms , 其他语言： 2000ms

内存限制: C/C++ 256MB , 其他语言： 512MB

#include <iostream>
using namespace std;
int x;
int ans = 0;
int main() {
	cin>>x;
	for (int i = 1; i <= x; i++) {
		ans++;
	}
	cout<<ans;
	return 0;
}

🔥对于这个简单的代码，x < 1e8 , 运行不会超时， x > 1e8 , 运行超时

✅ 时间复杂度衡量的是算法执行所需的时间增长率，随着输入规模的增加，算法的运行时间如何变化。常见的时间复杂度包括：

O(1)：常数时间，无论输入规模多大，执行时间保持不变。
O(log n)：对数时间，随着输入规模增加，执行时间按对数增长。例如二分操作。
O(n)：线性时间，执行时间与输入规模成正比。
O(n log n)：线性对数时间，常见于高效排序算法如快速排序、归并排序。
O(n²)：平方时间，常见于简单的嵌套循环，如冒泡排序。

✅ 如何计算时间复杂度：

识别基本操作：确定算法中最频繁执行的操作，如循环中的语句、递归调用等。
计算基本操作的执行次数：根据输入规模，计算这些操作随着输入增长的次数。
忽略低阶项和常数系数：在大O表示法中，只保留增长最快的项，忽略常数和低阶项。

🔥 对于一般情况：

n=$10^5$ 或 n=$10^6$ 左右考虑 $O(n log n)$ 以下的做法
n=$5 * 10^3$ 左右考虑 $O(n^2)$ 以下的做法
n=$10^2$ 左右考虑 $O(n^3)$ 以下的做法
n=$20$ 左右考虑 $O(2^n)$ 以下的做法

各数据类型的读入与构造

数组

#include <bits/stdc++.h>
#include <numeric>
using namespace std;

int main() {
  int n;
  cin >> n;
  vector<int> nums(n);
  for (int i = 0; i < n; i++) {
    cin >> nums[i];
  }
  cout << accumulate(nums.begin(), nums.end(), 0) << endl;
  return 0;
}

链表

#include <bits/stdc++.h>
using namespace std;

struct ListNode {
  int val;
  ListNode *next;
  ListNode(int x) : val(x), next(nullptr) {}
};

ListNode *createLinkedList(vector<int> &nums) {
  ListNode dummy(0);
  ListNode *cur = &dummy;
  for (int x : nums) {
    cur->next = new ListNode(x);
    cur = cur->next;
  }
  return dummy.next;
}

void printLinkedList(ListNode *head) {
  for (ListNode *cur = head; cur; cur = cur->next) {
    cout << cur->val << endl;
  }
}

int main() {
  int n;
  cin >> n; // 读取数组长度

  vector<int> nums(n);
  for (int i = 0; i < n; i++) {
    cin >> nums[i]; // 读取数组元素
  }

  ListNode *head = createLinkedList(nums); // 创建链表
  printLinkedList(head);                   // 遍历链表并输出

  return 0;
}

二叉树的读入与构建（输入为数组形式）

本题相当于根据「层序遍历」结果来构造二叉树：本质就是根据数组索引来构造

✅ 推荐阅读（题解）：

输入

1 2 3 4 5 -1 6

树的结构

输出

题解

#include <bits/stdc++.h>
using namespace std;

struct TreeNode {
  int val;
  TreeNode *left;
  TreeNode *right;
  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode *buildTree(const vector<int> &nums) {
  if (nums.empty() || nums[0] == -1)
    return nullptr;
  vector<TreeNode *> nodes(nums.size(), nullptr);
  for (size_t i = 0; i < nums.size(); i++) {
    if (nums[i] != -1)
      nodes[i] = new TreeNode(nums[i]);
  }
  for (size_t i = 0; i < nums.size(); i++) {
    if (nodes[i]) {
      if (2 * i + 1 < nums.size())
        nodes[i]->left = nodes[2 * i + 1];
      if (2 * i + 2 < nums.size())
        nodes[i]->right = nodes[2 * i + 2];
    }
  }
  return nodes[0];
}

void levelOrder(TreeNode *root) {
  if (!root)
    return;
  queue<TreeNode *> q;
  q.push(root);
  while (!q.empty()) {
    TreeNode *curr = q.front();
    q.pop();
    cout << curr->val << endl;
    if (curr->left)
      q.push(curr->left);
    if (curr->right)
      q.push(curr->right);
  }
}

int main() {
  string line;
  getline(cin, line);
  stringstream ss(line);
  vector<int> nums;
  int val;
  while (ss >> val) {
    nums.push_back(val);
  }
  TreeNode *root = buildTree(nums);
  levelOrder(root);
  return 0;
}

普通树的读入与构建（输入为相邻边 & father 数组）

分成两种形式的读入，一起讲解

题目描述

给定一棵 n 个节点的树，节点编号为1−n1−n，树的根节点固定为 1。我们有两种方式表示树的结构：

方式一：通过 n-1 条边的形式，每条边 u v 表示节点 u 和节点 v 之间存在一条边。
方式二：通过一个 father 数组，father[i] 表示节点 i+1 的父节点。

请你编写程序，读入树的结构并使用深度优先搜索遍历打印这棵树的节点编号。

为了输出统一，从根节点开始遍历，优先访问序号小的子节点。

输入

输入包含三部分：

第一行包含一个整数 n，表示树的节点个数。
第二行包含一个整数 type，表示树的表示方式：
- 如果 type = 1，表示通过边的形式输入。
- 如果 type = 2，表示通过 father 数组输入。
如果 type = 1，接下来会有 n-1 行，每行两个整数 u v，表示树中节点 u 和节点 v 之间存在一条边。
如果 type = 2，接下来一行有 n 个整数，father[i] 表示节点 i+1 的父节点，其中 father[0] = 0，表示 1 号节点为根节点,没有父节点。

输出

打印遍历这棵树的节点编号。

输入样例 1

输出样例 1

1 2 4 5 3

样例1 图例

输入样例 2

5
2
0 1 1 2 2

输出样例 2

1 2 4 5 3

数据范围

$1\le n \le 10^5$

🔥题解

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

#define MAX 100005 // 假设最大节点数 10^5

vector<int> adjList[MAX];    // 邻接表
vector<int> traversalResult; // 存储先序遍历结果

void DFS(int node, int parent) {
  traversalResult.push_back(node);
  for (auto &child : adjList[node]) {
    if (child != parent) {
      DFS(child, node);
    }
  }
}

int main() {
  int n, type;
  cin >> n >> type;

  if (type == 1) {
    // type 1: 通过边的形式读入
    for (int i = 0; i < n - 1; i++) {
      int u, v;
      cin >> u >> v;
      adjList[u].push_back(v);
      adjList[v].push_back(u);
    }
  } else if (type == 2) {
    // type 2: 通过 father 数组输入
    vector<int> father(n + 1);
    for (int i = 1; i <= n; i++) {
      cin >> father[i];
      if (father[i] != 0) {
        adjList[father[i]].push_back(i);
        adjList[i].push_back(father[i]);
      }
    }
  }
  // 为了保证遍历顺序的一致性，先对每个节点的子节点进行排序
  for (int i = 1; i <= n; i++) {
    sort(adjList[i].begin(), adjList[i].end());
  }

  DFS(1, 0);

  for (int i = 0; i < (int)traversalResult.size(); i++) {
    if (i > 0)
      cout << ' ';
    cout << traversalResult[i];
  }
  return 0;
}

图的构造（邻接矩阵 & 邻接表）

题目描述

给定两张有向图 A 和 B，其中图 A 以邻接矩阵形式给出，图 B 以邻接表形式给出。请判断这两张图是否完全一样。我们将“完全一样”的定义为：每个节点的邻居集合完全一致。

输入

输入的第一行包含两个整数 n，表示图的节点数。

接下来的 n 行，给出图 A 的邻接矩阵。该矩阵的第 i 行第 j 列表示节点 i 和节点 j 之间是否有边。如果存在边，则该位置的值为 1，否则为 0。

接下来的 n 行，给出图 B 的邻接表。每行第一个数 node,后面跟的第一个数 k 表示接下来输入 k 个数 val 表示节点 node 向这些节点 val 连一条边。

输出

如果图 A 和图 B 完全一样，则输出 "YES"；否则输出 "NO"。

注意

图 A 和图 B 是有向图，即如果 A[i][j]=1，那么 i 到 j 有条有向边。
节点编号从 1 到 n。
图 A 和图 B 的节点数相同。
数据范围：
- $1≤n≤10^3$
- 图 A 的邻接矩阵大小为 n×n，其中每个元素为 0 或 1。
- 图 B 的邻接表中每个节点的邻居数量不超过 n−1。

样例输入 1

样例输出 1

YES

样例输入 2

样例输出 2

NO

样例 2 提示

图 A 的邻接矩阵为：

0 1 1
1 0 1
1 1 0

表示图 A 中，节点 1 与节点 2 和节点 3 相连，节点 2 与节点 1 和节点 3 相连，节点 3 与节点 1 和节点 2 相连。

图 B 的邻接表为：

1 2 2 3
2 2 1 3
3 1 1

表示图 B 中，节点 1 与节点 2 和节点 3 相连，节点 2 与节点 1 和节点 3 相连，节点 3 与节点 1 相连。

对比可以发现，在图 B 中，节点 3 不连向节点 2。因此，图 A 和图 B 不完全一样，输出 "NO"。

邻接矩阵

邻接表

题解

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
  int n; // 顶点数
  cin >> n;
  vector<vector<int>> adjA(n + 1), adjB(n + 1);

  // 读取并转换图 A
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
      int val;
      cin >> val;
      if (val == 1)
        adjA[i].push_back(j);
    }
  }

  // 读取图 B
  for (int i = 0; i < n; i++) {
    int node, k;
    cin >> node >> k;
    adjB[node].resize(k);
    for (int j = 0; j < k; j++) {
      cin >> adjB[node][j];
    }
  }

  // 对邻接表排序
  for (int i = 1; i <= n; i++) {
    sort(adjA[i].begin(), adjA[i].end());
    sort(adjB[i].begin(), adjB[i].end());
  }

  // 比较邻接表
  bool same = true;
  for (int i = 1; i <= n; i++) {
    if (adjA[i] != adjB[i]) {
      same = false;
      break;
    }
  }

  cout << (same ? "YES" : "NO") << endl;
  return 0;
}

2025.04.24 吉比特笔试题

Thu, 24 Apr 2025 00:00:00 GMT

1. 数组查询

给定一个数组 a[n]，以及 q 次查询 (l, r)，输出 a[l] - a[l+1] - a[l+2] - ... - a[r-1] - a[r] 的值。

输入描述

第一行包含两个整数 n 和 q，表示数组的长度和查询的次数。
第二行包含 n 个整数，表示数组 a。
接下来的 q 行，每行包含两个整数 l 和 r，表示查询的区间（假设数组下标从 1 开始）。

输出描述

对于每个查询，输出一个整数，表示对应的计算结果。

示例 1

输入：

输出：

-13
-5
3

解释：

第一个查询：$1 - 2 - 3 - 4 - 5 = -13$
第二个查询：$2 - 3 - 4 = -5$
第三个查询：$3$

代码：模拟 / 前缀和

直接按照题目要求计算即可。对于每个查询 (l, r)，从 a[l] 开始，依次减去 a[l+1] 到 a[r] 的值。时间复杂度为 $O(q * n)$，在 n 和 q 较小的情况下可以通过。

优化思路：可以预处理前缀和数组 prefix，其中 prefix[i] 表示 a[1] - a[2] - ... - a[i]。然后对于查询 (l, r)，结果为：

如果 l == 1，直接取 prefix[r]。
否则，结果为 a[l] - (prefix[r] - prefix[l])。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, q;
    cin >> n >> q;
    vector<int> a(n + 1);
    vector<int> prefix(n + 1, 0);
    
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        if (i == 1) {
            prefix[i] = a[i];
        } else {
            prefix[i] = prefix[i - 1] - a[i];
        }
    }

    while (q--) {
        int l, r;
        cin >> l >> r;
        if (l == 1) {
            cout << prefix[r] << endl;
        } else {
            cout << a[l] - (prefix[r] - prefix[l]) << endl;
        }
    }
    return 0;
}

2. 多米诺骨牌推倒

给定一排多米诺骨牌，每个骨牌有一个数值。每次操作可以选择一个位置和一个方向（左或右）进行推倒。推倒的规则是：

如果相邻骨牌（根据方向）的数值比当前骨牌的数值小，则会被推倒，并继续向该方向传播，直到遇到不小于当前骨牌数值的骨牌为止。
问最少需要多少次操作才能将所有骨牌都推倒。

输入描述

第一行包含一个整数 n，表示骨牌的数量。
第二行包含 n 个整数，表示每个骨牌的数值。

输出描述

输出一个整数，表示最少需要的操作次数。

示例 1

输入：

5
3 1 2 4 1

输出：

解释：

第一次操作：选择 4，向右推倒，可以推倒 1（因为 1 < 4）
第二次操作：选择 3，向右推倒，可以推倒位置 1
第二次操作：选择 2 推倒

代码：转化为区间覆盖问题

后半部分代码参考 LC 45. 跳跃游戏 II

这个问题是一个链式反应模拟 + 贪心优化问题。目标是最小化推动次数，使得所有积木都被推倒。

我们可以对问题进行如下处理：

模拟倒塌过程（从某个位置向左或向右传递）；
预处理每个积木从左或右可以推倒的“影响范围”；
贪心策略：用最少的“倒塌段”覆盖所有积木（区间覆盖）。

步骤详解：

Step 1：预处理每个积木向左/右能影响多远
- 对于每个位置 i：
  - 向右倒：不断检查 A[i+1] < A[i], A[i+2] < A[i+1]... 直到不满足，记录影响区间 R[i]；
  - 向左倒：不断检查 A[i-1] < A[i], A[i-2] < A[i-1]... 类似，记录影响区间 L[i]。
Step 2：把每个可能的倒塌行为看作一个“区间”覆盖
- 从 i 向右能推倒到 j，我们记录一个区间 [i, j]
- 从 i 向左能推倒到 k，我们记录一个区间 [k, i]
- 总共会有 2n 个这样的区间。
Step 3：用最少的这些区间覆盖整个 [1, n]

这个就是经典的 区间覆盖问题：

将所有区间按起点排序；
每次选择起点 ≤ 当前覆盖末尾，终点最大的区间；
如果无法延伸则失败；
否则计数操作次数，直到覆盖整个 [1, n]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> A(n + 2);  // 1-based indexing, pad for safety
    for (int i = 1; i <= n; ++i) {
        cin >> A[i];
    }

    vector<pair<int, int>> intervals;

    // 向右推
    for (int i = 1; i <= n; ++i) {
        int j = i;
        while (j + 1 <= n && A[j + 1] < A[j]) {
            ++j;
        }
        intervals.emplace_back(i, j);
    }

    // 向左推
    for (int i = 1; i <= n; ++i) {
        int j = i;
        while (j - 1 >= 1 && A[j - 1] < A[j]) {
            --j;
        }
        intervals.emplace_back(j, i);
    }

    // 贪心区间覆盖 [1, n]
    sort(intervals.begin(), intervals.end());

    int res = 0, end = 0, next_end = 0, idx = 0;
    while (end < n) {
        while (idx < intervals.size() && intervals[idx].first <= end + 1) {
            next_end = max(next_end, intervals[idx].second);
            ++idx;
        }
        if (next_end == end) {
            cout << -1 << endl;  // 理论上不会出现
            return 0;
        }
        end = next_end;
        ++res;
    }

    cout << res << endl;
    return 0;
}

3. 绳子分割与多边形面积

牛牛小朋友和他的朋友们，一共 $n$ 个人在操场上玩一个圈地盘的游戏。这个游戏的规则是这样的，将一根的绳子剪成 $n$ 段，让每个小朋友都能有一小段绳子。每个小朋友用拿到的一小段绳子分别圈地，要求绳子头尾相接（头尾相接时产生的损耗忽略不计），并且第 $i$ 个小朋友要求他用绳子在地上圈起来的地盘是 $a_i$ 边形的（有些小朋友对他圈起来的地盘是什么形状的并不关心，用 $-1$ 表示）。

小朋友们只能找到一根长度为 $l$ 的绳子，需要把绳子剪开之后，所有小朋友可以圈出地盘的面积的最小值为 $s$。为了让小朋友们尽可能高兴，需牛牛要一种剪绳子的方法，让 $s$ 尽可能大。你能帮助牛牛解决这个问题吗？你只需要精确到小数点后 6 位即可（和标准答案相对误差低于 $1e^{-5}$ 则被判定为正确）。

输入描述

第一行包含两个整数 l 和 n。
第二行包含 n 个整数，表示数组 a。

输出格式

输出一个浮点数，表示面积最小值的最大可能值，保留足够的小数位数。

示例 1

输入：

10 2
4 -1

输出：

2.5

代码

这个问题可以转化为 二分答案 + 几何判断 的问题：

核心思想：

目标：将长度为 l 的绳子分成 n 段，使得所有小朋友围成的图形的面积的最小值最大化。
限制条件：
- 每个小朋友的形状是一个正多边形，边数为 a_i（若为 -1，代表形状不限制，可以视为正圆）。
- 总绳长为 l。
我们用 二分搜索 来猜测最小的面积 s，然后验证是否可以在绳长为 l 的情况下满足每个人的要求。

面积计算公式：

对于边数为 k 的正多边形，边长为 x / k，周长为 x，面积为：

$$ A = \frac{k}{4} \cdot x^2 \cdot \cot\left(\frac{\pi}{k}\right) $$

如果是圆（a_i == -1），设周长为 x，则半径 r = x / (2π)，面积为：

$$ A = \pi \cdot \left(\frac{x}{2\pi}\right)^2 = \frac{x^2}{4\pi} $$

给定一个猜测的最小面积 s，我们尝试为每个小朋友分配一段最短绳长，使得他能围成面积至少为 s，然后计算所有这些最短绳长的和是否不超过 l。

#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>

using namespace std;

const double PI = acos(-1.0);
const double EPS = 1e-7;

int n;
double l;
vector<int> a;

double get_min_len(int k, double s) {
    if (k == -1) { // Circle
        return sqrt(4 * PI * s);
    } else {
        double tan_val = tan(PI / k);
        double coeff = k / (4 * tan_val); // cotangent = 1 / tan
        return sqrt(s / coeff);
    }
}

bool check(double s) {
    double total_len = 0;
    for (int i = 0; i < n; ++i) {
        double min_len = get_min_len(a[i], s);
        total_len += min_len;
        if (total_len > l)
            return false;
    }
    return true;
}

int main() {
    cin >> n >> l;
    a.resize(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    double left = 0, right = 1e18; // Upper bound high enough
//    while (right - left > EPS)
    for (int iter = 0; iter < 100; ++iter) { // binary search
        double mid = (left + right) / 2;
        if (check(mid)) {
            left = mid;
        } else {
            right = mid;
        }
    }

    cout << fixed << setprecision(6) << left << endl;
    return 0;
}

Effective C++

Sun, 13 Apr 2025 00:00:00 GMT

Effective C++

视 C++ 为一个语言联邦（C、Object-Oriented C++、Template C++、STL）
宁可以编译器替换预处理器（尽量以 const、enum、inline 替换 #define）
尽可能使用 const
确定对象被使用前已先被初始化（构造时赋值（copy 构造函数）比 default 构造后赋值（copy assignment）效率高）
了解 C++ 默默编写并调用哪些函数（编译器暗自为 class 创建 default 构造函数、copy 构造函数、copy assignment 操作符、析构函数）
若不想使用编译器自动生成的函数，就应该明确拒绝（将不想使用的成员函数声明为 private，并且不予实现）
为多态基类声明 virtual 析构函数（如果 class 带有任何 virtual 函数，它就应该拥有一个 virtual 析构函数）
别让异常逃离析构函数（析构函数应该吞下不传播异常，或者结束程序，而不是吐出异常；如果要处理异常应该在非析构的普通函数处理）
绝不在构造和析构过程中调用 virtual 函数（因为这类调用从不下降至 derived class）
令 operator= 返回一个 reference to *this （用于连锁赋值）
在 operator= 中处理 “自我赋值”
赋值对象时应确保复制 “对象内的所有成员变量” 及 “所有 base class 成分”（调用基类复制构造函数）
以对象管理资源（资源在构造函数获得，在析构函数释放，建议使用智能指针，资源取得时机便是初始化时机（Resource Acquisition Is Initialization，RAII））
在资源管理类中小心 copying 行为（普遍的 RAII class copying 行为是：抑制 copying、引用计数、深度拷贝、转移底部资源拥有权（类似 auto_ptr））
在资源管理类中提供对原始资源（raw resources）的访问（对原始资源的访问可能经过显式转换或隐式转换，一般而言显示转换比较安全，隐式转换对客户比较方便）
成对使用 new 和 delete 时要采取相同形式（new 中使用 [] 则 delete []，new 中不使用 [] 则 delete）
以独立语句将 newed 对象存储于（置入）智能指针（如果不这样做，可能会因为编译器优化，导致难以察觉的资源泄漏）
让接口容易被正确使用，不易被误用（促进正常使用的办法：接口的一致性、内置类型的行为兼容；阻止误用的办法：建立新类型，限制类型上的操作，约束对象值、消除客户的资源管理责任）
设计 class 犹如设计 type，需要考虑对象创建、销毁、初始化、赋值、值传递、合法值、继承关系、转换、一般化等等。
宁以 pass-by-reference-to-const 替换 pass-by-value （前者通常更高效、避免切割问题（slicing problem），但不适用于内置类型、STL迭代器、函数对象）
必须返回对象时，别妄想返回其 reference（绝不返回 pointer 或 reference 指向一个 local stack 对象，或返回 reference 指向一个 heap-allocated 对象，或返回 pointer 或 reference 指向一个 local static 对象而有可能同时需要多个这样的对象。）
将成员变量声明为 private（为了封装、一致性、对其读写精确控制等）
宁以 non-member、non-friend 替换 member 函数（可增加封装性、包裹弹性（packaging flexibility）、机能扩充性）
若所有参数（包括被this指针所指的那个隐喻参数）皆须要类型转换，请为此采用 non-member 函数
考虑写一个不抛异常的 swap 函数
尽可能延后变量定义式的出现时间（可增加程序清晰度并改善程序效率）
尽量少做转型动作（旧式：(T)expression、T(expression)；新式：const_cast<T>(expression)、dynamic_cast<T>(expression)、reinterpret_cast<T>(expression)、static_cast<T>(expression)、；尽量避免转型、注重效率避免 dynamic_casts、尽量设计成无需转型、可把转型封装成函数、宁可用新式转型）
避免使用 handles（包括引用、指针、迭代器）指向对象内部（以增加封装性、使 const 成员函数的行为更像 const、降低 “虚吊号码牌”（dangling handles，如悬空指针等）的可能性）
为 “异常安全” 而努力是值得的（异常安全函数（Exception-safe functions）即使发生异常也不会泄露资源或允许任何数据结构败坏，分为三种可能的保证：基本型、强列型、不抛异常型）
透彻了解 inlining 的里里外外（inlining 在大多数 C++ 程序中是编译期的行为；inline 函数是否真正 inline，取决于编译器；大部分编译器拒绝太过复杂（如带有循环或递归）的函数 inlining，而所有对 virtual 函数的调用（除非是最平淡无奇的）也都会使 inlining 落空；inline 造成的代码膨胀可能带来效率损失；inline 函数无法随着程序库的升级而升级）
将文件间的编译依存关系降至最低（如果使用 object references 或 object pointers 可以完成任务，就不要使用 objects；如果能够，尽量以 class 声明式替换 class 定义式；为声明式和定义式提供不同的头文件）
确定你的 public 继承塑模出 is-a（是一种）关系（适用于 base classes 身上的每一件事情一定适用于 derived classes 身上，因为每一个 derived class 对象也都是一个 base class 对象）
避免遮掩继承而来的名字（可使用 using 声明式或转交函数（forwarding functions）来让被遮掩的名字再见天日）
区分接口继承和实现继承（在 public 继承之下，derived classes 总是继承 base class 的接口；pure virtual 函数只具体指定接口继承；非纯 impure virtual 函数具体指定接口继承及缺省实现继承；non-virtual 函数具体指定接口继承以及强制性实现继承）
考虑 virtual 函数以外的其他选择（如 Template Method 设计模式的 non-virtual interface（NVI）手法，将 virtual 函数替换为 “函数指针成员变量”，以 tr1::function 成员变量替换 virtual 函数，将继承体系内的 virtual 函数替换为另一个继承体系内的 virtual 函数）
绝不重新定义继承而来的 non-virtual 函数
绝不重新定义继承而来的缺省参数值，因为缺省参数值是静态绑定（statically bound），而 virtual 函数却是动态绑定（dynamically bound）
通过复合塑模 has-a（有一个）或 “根据某物实现出”（在应用域（application domain），复合意味 has-a（有一个）；在实现域（implementation domain），复合意味着 is-implemented-in-terms-of（根据某物实现出））
明智而审慎地使用 private 继承（private 继承意味着 is-implemented-in-terms-of（根据某物实现出），尽可能使用复合，当 derived class 需要访问 protected base class 的成员，或需要重新定义继承而来的时候 virtual 函数，或需要 empty base 最优化时，才使用 private 继承）
明智而审慎地使用多重继承（多继承比单一继承复杂，可能导致新的歧义性，以及对 virtual 继承的需要，但确有正当用途，如 “public 继承某个 interface class” 和 “private 继承某个协助实现的 class”；virtual 继承可解决多继承下菱形继承的二义性问题，但会增加大小、速度、初始化及赋值的复杂度等等成本）
了解隐式接口和编译期多态（class 和 templates 都支持接口（interfaces）和多态（polymorphism）；class 的接口是以签名为中心的显式的（explicit），多态则是通过 virtual 函数发生于运行期；template 的接口是奠基于有效表达式的隐式的（implicit），多态则是通过 template 具现化和函数重载解析（function overloading resolution）发生于编译期）
了解 typename 的双重意义（声明 template 类型参数是，前缀关键字 class 和 typename 的意义完全相同；请使用关键字 typename 标识嵌套从属类型名称，但不得在基类列（base class lists）或成员初值列（member initialization list）内以它作为 base class 修饰符）
学习处理模板化基类内的名称（可在 derived class templates 内通过 this-> 指涉 base class templates 内的成员名称，或藉由一个明白写出的 “base class 资格修饰符” 完成）
将与参数无关的代码抽离 templates（因类型模板参数（non-type template parameters）而造成代码膨胀往往可以通过函数参数或 class 成员变量替换 template 参数来消除；因类型参数（type parameters）而造成的代码膨胀往往可以通过让带有完全相同二进制表述（binary representations）的实现类型（instantiation types）共享实现码）
运用成员函数模板接受所有兼容类型（请使用成员函数模板（member function templates）生成 “可接受所有兼容类型” 的函数；声明 member templates 用于 “泛化 copy 构造” 或 “泛化 assignment 操作” 时还需要声明正常的 copy 构造函数和 copy assignment 操作符）
需要类型转换时请为模板定义非成员函数（当我们编写一个 class template，而它所提供之 “与此 template 相关的” 函数支持 “所有参数之隐式类型转换” 时，请将那些函数定义为 “class template 内部的 friend 函数”）
请使用 traits classes 表现类型信息（traits classes 通过 templates 和 “templates 特化” 使得 “类型相关信息” 在编译期可用，通过重载技术（overloading）实现在编译期对类型执行 if...else 测试）
认识 template 元编程（模板元编程（TMP，template metaprogramming）可将工作由运行期移往编译期，因此得以实现早期错误侦测和更高的执行效率；TMP 可被用来生成 “给予政策选择组合”（based on combinations of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不适合的代码）
了解 new-handler 的行为（set_new_handler 允许客户指定一个在内存分配无法获得满足时被调用的函数；nothrow new 是一个颇具局限的工具，因为它只适用于内存分配（operator new），后继的构造函数调用还是可能抛出异常）
了解 new 和 delete 的合理替换时机（为了检测运用错误、收集动态分配内存之使用统计信息、增加分配和归还速度、降低缺省内存管理器带来的空间额外开销、弥补缺省分配器中的非最佳齐位、将相关对象成簇集中、获得非传统的行为）
编写 new 和 delete 时需固守常规（operator new 应该内涵一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就应该调用 new-handler，它也应该有能力处理 0 bytes 申请，class 专属版本则还应该处理 “比正确大小更大的（错误）申请”；operator delete 应该在收到 null 指针时不做任何事，class 专属版本则还应该处理 “比正确大小更大的（错误）申请”）
写了 placement new 也要写 placement delete（当你写一个 placement operator new，请确定也写出了对应的 placement operator delete，否则可能会发生隐微而时断时续的内存泄漏；当你声明 placement new 和 placement delete，请确定不要无意识（非故意）地遮掩了它们地正常版本）
不要轻忽编译器的警告
让自己熟悉包括 TR1 在内的标准程序库（TR1，C++ Technical Report 1，C++11 标准的草稿文件）
让自己熟悉 Boost（准标准库）

More Effective C++

仔细区别 pointers 和 references（当你知道你需要指向某个东西，而且绝不会改变指向其他东西，或是当你实现一个操作符而其语法需求无法由 pointers 达成，你就应该选择 references；任何其他时候，请采用 pointers）
最好使用 C++ 转型操作符（static_cast、const_cast、dynamic_cast、reinterpret_cast）
绝不要以多态（polymorphically）方式处理数组（多态（polymorphism）和指针算术不能混用；数组对象几乎总是会涉及指针的算术运算，所以数组和多态不要混用）
非必要不提供 default constructor（避免对象中的字段被无意义地初始化）
对定制的 “类型转换函数” 保持警觉（单自变量 constructors 可通过简易法（explicit 关键字）或代理类（proxy classes）来避免编译器误用；隐式类型转换操作符可改为显式的 member function 来避免非预期行为）
区别 increment/decrement 操作符的前置（prefix）和后置（postfix）形式（前置式累加后取出，返回一个 reference；后置式取出后累加，返回一个 const 对象；处理用户定制类型时，应该尽可能使用前置式 increment；后置式的实现应以其前置式兄弟为基础）
千万不要重载 &&，|| 和 , 操作符（&& 与 || 的重载会用 “函数调用语义” 取代 “骤死式语义”；, 的重载导致不能保证左侧表达式一定比右侧表达式更早被评估）
了解各种不同意义的 new 和 delete（new operator、operator new、placement new、operator new[]；delete operator、operator delete、destructor、operator delete[]）
利用 destructors 避免泄漏资源（在 destructors 释放资源可以避免异常时的资源泄漏）
在 constructors 内阻止资源泄漏（由于 C++ 只会析构已构造完成的对象，因此在构造函数可以使用 try...catch 或者 auto_ptr（以及与之相似的 classes）处理异常时资源泄露问题）
禁止异常流出 destructors 之外（原因：一、避免 terminate 函数在 exception 传播过程的栈展开（stack-unwinding）机制种被调用；二、协助确保 destructors 完成其应该完成的所有事情）
了解 “抛出一个 exception” 与 “传递一个参数” 或 “调用一个虚函数” 之间的差异（第一，exception objects 总是会被复制（by pointer 除外），如果以 by value 方式捕捉甚至被复制两次，而传递给函数参数的对象则不一定得复制；第二，“被抛出成为 exceptions” 的对象，其被允许的类型转换动作比 “被传递到函数去” 的对象少；第三，catch 子句以其 “出现于源代码的顺序” 被编译器检验对比，其中第一个匹配成功者便执行，而调用一个虚函数，被选中执行的是那个 “与对象类型最佳吻合” 的函数）
以 by reference 方式捕获 exceptions（可避免对象删除问题、exception objects 的切割问题，可保留捕捉标准 exceptions 的能力，可约束 exception object 需要复制的次数）
明智运用 exception specifications（exception specifications 对 “函数希望抛出什么样的 exceptions” 提供了卓越的说明；也有一些缺点，包括编译器只对它们做局部性检验而很容易不经意地违反，与可能会妨碍更上层的 exception 处理函数处理未预期的 exceptions）
了解异常处理的成本（粗略估计，如果使用 try 语句块，代码大约整体膨胀 5%-10%，执行速度亦大约下降这个数；因此请将你对 try 语句块和 exception specifications 的使用限制于非用不可的地点，并且在真正异常的情况下才抛出 exceptions）
谨记 80-20 法则（软件的整体性能几乎总是由其构成要素（代码）的一小部分决定的，可使用程序分析器（program profiler）识别出消耗资源的代码）
考虑使用 lazy evaluation（缓式评估）（可应用于：Reference Counting（引用计数）来避免非必要的对象复制、区分 operator[] 的读和写动作来做不同的事情、Lazy Fetching（缓式取出）来避免非必要的数据库读取动作、Lazy Expression Evaluation（表达式缓评估）来避免非必要的数值计算动作）
分期摊还预期的计算成本（当你必须支持某些运算而其结构几乎总是被需要，或其结果常常被多次需要的时候，over-eager evaluation（超急评估）可以改善程序效率）

网络编程与 I/O 多路复用

Sun, 13 Apr 2025 00:00:00 GMT

网络编程

Socket

如果我们要将数据从电脑 A 的某个进程发到电脑 B 的某个进程，如果需要确保数据能够发送给对方，那就选可靠的 TCP 协议，否则可以采用 UDP 协议。

那这时候就需要用 socket 进行编程，第一步就是创建一个关于 TCP 的 socket。

下文皆以 TCP 为例

// SOCK_STREAM：TCP 流套接字
// SOCK_DGRAM：UDP 数据报套接字
int sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

sock_fd 相当于文件句柄，客户端和服务端都需要各自创建 fd：

对于服务端：就可以根据 fd 依次执行 bind()、listen()、accept() 方法，然后坐等客户端的连接请求
对于客户端：根据 fd 来执行 connect() 向服务端发起建立连接的请求，此时就会发生 TCP 三次握手

以下是 TCP 三次握手的示意图：

连接建立完成后，客户端可以执行 send() 发送消息，服务端可以执行 recv() 接收消息；反过来，服务端也可以执行 send()，客户端执行 recv()。

服务端

可以使用 socket() 系统调用创建套接字，它在 <sys/socket.h> 中定义。

Definition

int socket(int __domain, int __type, int __protocol)

__domain
- AF_INET：IPv4
- AF_INET6：IPv6
__type
- SOCK_STREAM：TCP 流套接字
- SOCK_DGRAM：UDP 数据报套接字
__protocol：指定协议，当 __protocol 为 0 时，会自动选择 type 类型对应的默认协议。
- IPPROTO_TCP
- IPPTOTO_UDP
- IPPROTO_SCTP
- IPPROTO_TIPC

Usage

int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
// 定义服务器地址
sockaddr_in serverAddress;
serverAddress.sin_family = AF_INET;
serverAddress.sin_port = htons(8080);
serverAddress.sin_addr.s_addr = INADDR_ANY;

sockaddr_in：用于存储套接字地址的数据类型
htons：该函数用于将 unsigned int 从机器字节序转换为网络字节序
INADDR_ANY：当我们不想将套接字绑定到任何特定网卡 IP，而是让它监听所有网卡（所有可用 IP）时使用

bind(serverSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress));

调用 bind() 绑定套接字

listen(serverSocket, 5);

然后监听 serverSocket 引用的套接字

int clientSocket = accept(serverSocket, nullptr, nullptr);

accept() 调用用于接受应用程序正在监听的套接字上收到的连接请求

char buffer[1024] = {0};
recv(clientSocket, buffer, sizeof(buffer), 0);
cout << "Message from client: " << buffer << endl;

然后开始从客户端接收数据，我们可以指定所需的缓冲区大小，以便有足够的空间接收客户端发送的数据

close(serverSocket);

最后使用 close() 关闭套接字

server.cpp 完整代码

// C++ program to show the example of server application in
// socket programming
#include <cstring>
#include <iostream>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>

using namespace std;

int main()
{
    // creating socket
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);

    // specifying the address
    sockaddr_in serverAddress;
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(8080);
    serverAddress.sin_addr.s_addr = INADDR_ANY;

    // binding socket.
    bind(serverSocket, (struct sockaddr*)&serverAddress,
         sizeof(serverAddress));

    // listening to the assigned socket
    listen(serverSocket, 5);

    // accepting connection request
    int clientSocket = accept(serverSocket, nullptr, nullptr);

    // recieving data
    char buffer[1024] = { 0 };
    recv(clientSocket, buffer, sizeof(buffer), 0);
    cout << "Message from client: " << buffer << endl;

    // closing the socket
    close(serverSocket);

    return 0;
}

更完整的写法：server.c

#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>

int main() {
    // int socket(int __domain, int __type, int __protocol)
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 0.0.0.0
    server_addr.sin_port = htons(2000);               // system used: 0 ~ 1023

    if (bind(sock_fd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr)) == -1) {
        printf("bind failed: %s\n", strerror(errno));
    }

    // int listen(int __fd, int __n): 后者为等待队列的长度
    listen(sock_fd, 10);
    printf("listen finished: %d\n", sock_fd);  // 3
    system("netstat -ano | grep 2000");
    // getchar();  // 方便查看 netstat -ano | grep 2000: tcp  0    0 0.0.0.0:2000   0.0.0.0:*   LISTEN   off (0.00/0/0)

    struct sockaddr_in client_addr;
    // int accept(int __fd, struct sockaddr *__restrict__ __addr, socklen_t *__restrict__ __addr_len)
    socklen_t len = sizeof(client_addr);
    int client_fd = accept(sock_fd, (struct sockaddr*)&client_addr, &len);
    printf("accept finished\n");
    system("netstat -ano | grep 2000");

    char buffer[1024] = {0};
    // ssize_t recv(int __fd, void *__buf, size_t __n, int __flags)
    int count = recv(client_fd, buffer, sizeof(buffer), 0);
    printf("RECV: %s\n", buffer);

    // ssize_t send(int __fd, const void *__buf, size_t __n, int __flags)
    count = send(client_fd, buffer, count, 0);
    printf("SEND: %d\n", count);

    // getchar();
    while (1);

    return 0;
}

客户端

与服务器类似，我们也需要创建一个套接字并指定地址。不过，我们不会接受请求，而是在能够使用 connect() 调用发送数据时，发送连接请求。然后我们使用 send() 函数发送数据。所有操作完成后，我们使用 close() 函数关闭连接。

client.cpp 完整代码

// C++ program to illustrate the client application in the
// socket programming
#include <cstring>
#include <iostream>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>

int main()
{
    // creating socket
    int clientSocket = socket(AF_INET, SOCK_STREAM, 0);

    // specifying address
    sockaddr_in serverAddress;
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(8080);
    serverAddress.sin_addr.s_addr = INADDR_ANY;

    // sending connection request
    connect(clientSocket, (struct sockaddr*)&serverAddress,
            sizeof(serverAddress));

    // sending data
    const char* message = "Hello, server!";
    send(clientSocket, message, strlen(message), 0);

    // closing socket
    close(clientSocket);

    return 0;
}

更完整的写法：client.c

#include <netinet/in.h>
#include <stdio.h>
#include <sys/socket.h>

int main() {
    unsigned short port = 2000;
    // char *server_ip = "10.26.57.8";      // 应该发送到对应IP的网卡地址: 10.26.57.3
    // char *server_ip = "localhost";       // ✅ 两个程序在同一个服务器上跑就可
    char *server_ip = "10.26.57.3";         // ✅ 网卡地址能接收到

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket error");
        exit(-1);
    }

    struct sockaddr_in server_addr;
    // bzero <==> memset(&server_addr, 0, sizeof(server_addr));
    bzero(&server_addr, sizeof(server_addr));  // 初始化服务器地址
    // AF_INET:  IPv4
    // AF_INET6: IPv6
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    // inet_pton() 是一个通用的地址转换函数，不知道你打算转换成 IPv4 还是 IPv6，必须由你告诉它目标地址族
    // AF_INET:  IPv4
    // AF_INET6: IPv6
    // 客户端绑定具体服务端IP必须使用该方法
    inet_pton(AF_INET, server_ip, &server_addr.sin_addr.s_addr);
    system("netstat -ano | grep 2000");

    // int connect(int __fd, const struct sockaddr *__addr, socklen_t __len)
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect error");
        close(sockfd);
        exit(-1);
    }

    system("netstat -ano | grep 2000");

    char buffer[1024] = "Client INFO: test...";
    // ssize_t send(int __fd, const void *__buf, size_t __n, int __flags)
    int count = send(sockfd, buffer, sizeof(buffer), 0);
    printf("SEND: %d\n", count);

    while (1);

    return 0;
}

源码分析

sockaddr

sockaddr 在头文件 <sys/socket.h> 中定义，sockaddr 的缺陷是 sa_data 把「目标地址」和「端口信息」混在一起了：

struct sockaddr
{ 
　　unsigned short sa_family;	// 2 字节，地址族，AF_xxx
　　char sa_data[14]; 		// 14 字节，包含套接字中的目标地址和端口信息 
};

sockaddr_in

sockaddr_in 在头文件 <netinet/in.h> 或 <arpa/inet.h> 中定义，该结构体解决了 sockaddr 的缺陷，把 port 和 addr 分开存储在两个变量中：

struct sockaddr_in {
    sa_family_t    sin_family; // 地址族，一般是 AF_INET（IPv4），也可以是 AF_INET6（IPv6）
    in_port_t      sin_port;   // 端口号（使用 htons() 转换为网络字节序）
    struct in_addr sin_addr;   // IP 地址（结构体）
    char           sin_zero[8];// 填充字段，保持结构体大小与 sockaddr 一致
};

struct in_addr {
    unsigned long s_addr;      // 32 位 IPv4 地址打印的时候可以调用 inet_ntoa() 函数将其转换为 char* 类型
};

sockaddr 常用于 bind、connect、recvfrom、sendto 等函数的参数，指明地址信息，是一种通用的套接字地址。

sockaddr_in 是 internet 环境下套接字的地址形式。所以在网络编程中我们会对 sockaddr_in 结构体进行操作，使用 sockaddr_in 来建立所需的信息，最后使用类型转化 (struct sockaddr*) 即可。

一般先把 sockaddr_in 变量赋值后，强制类型转换后传入用 sockaddr 做参数的函数：

sockaddr_in 用于 socket 定义和赋值
sockaddr 用于函数参数

Usage：程序员不应该操作 sockaddr，而是使用 sockaddr_in 来表示地址，并强转为 (struct sockaddr *) 传入函数中：

// int accept(int __fd, struct sockaddr *__restrict__ __addr, socklen_t *__restrict__ __addr_len)
struct sockaddr_in client_addr;
socklen_t len = sizeof(client_addr);

int client_fd = accept(sock_fd, (struct sockaddr*)&client_addr, &len);

// int connect(int __fd, const struct sockaddr *__addr, socklen_t __len)
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));  // 初始化服务器地址
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(2000);
inet_pton(AF_INET, "10.26.57.3", &server_addr.sin_addr.s_addr);

connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)

讲一讲 I/O 多路复用｜select、poll、epoll 的区别是什么？

I/O 多路复用是一种 I/O 的处理方式，指的是复用一个线程处理多个 socket 中的事件。能够复用资源，防止创建过多线程导致的上下文切换的开销。

我们熟悉的 select/poll/epoll 内核提供给用户态的多路复用系统调用，进程可以通过一个系统调用函数从内核中获取多个事件。

select、poll

✅ select 图解

✅ poll 图解

select 实现多路复用的方式是，将已连接的 Socket 都放到一个文件描述符集合，然后调用 select 函数将文件描述符集合拷贝到内核里，让内核来检查是否有网络事件产生，检查的方式很粗暴，就是通过遍历文件描述符集合的方式，当检查到有事件产生后，将此 Socket 标记为可读或可写，接着再把整个文件描述符集合拷贝回用户态里，然后用户态还需要再通过遍历的方法找到可读或可写的 Socket，然后再对其处理。

select 使用固定长度的 BitsMap，表示文件描述符集合，而且所支持的文件描述符的个数是有限制的，在 Linux 系统中，由内核中的 FD_SETSIZE 限制，默认最大值为 1024，只能监听 0~1023 的文件描述符。

但是 poll 和 select 并没有太大的本质区别，都是使用「线性结构」存储进程关注的 Socket 集合，因此都需要遍历文件描述符集合来找到可读或可写的 Socket，时间复杂度为 $O(n)$，而且也需要在用户态与内核态之间拷贝文件描述符集合，这种方式随着并发数上来，性能的损耗会呈指数级增长。

epoll

Linux 2.6 版本诞生了 epoll 模型，彻底解决了 select/poll 性能不足的问题

✅ epoll 图解

int s = socket(AF_INET, SOCK_STREAM, 0);
bind(s, ...);
listen(s, ...);

// epoll_fd
int epfd = epoll_create(...);
epoll_ctl(epfd, ...); // 将所有需要监听的 socket 添加到 epfd 中

while(1) {
    int n = epoll_wait(...);
    for (接收到数据的 socket) {
        //处理
    }
}

epoll 通过两个方面，很好解决了 select/poll 的问题：

第一点，epoll 在内核里使用「红黑树」来跟踪进程所有待检测的文件描述字，把需要监控的 socket 通过 epoll_ctl() 函数加入内核中的红黑树里，红黑树是个高效的数据结构，增删改一般时间复杂度是 $O(logn)$。而 select/poll 内核里没有类似 epoll 红黑树这种保存所有待检测的 socket 的数据结构，所以 select/poll 每次操作时都传入整个 socket 集合给内核，而 epoll 因为在内核维护了红黑树，可以保存所有待检测的 socket ，所以只需要传入一个待检测的 socket，减少了内核和用户空间大量的数据拷贝和内存分配。
第二点，epoll 使用事件驱动的机制，内核里维护了一个链表来记录就绪事件，当某个 socket 有事件发生时，内核通过回调函数将其加入到这个就绪事件列表中，当用户调用 epoll_wait() 函数时，只会返回有事件发生的文件描述符的个数，不需要像 select/poll 那样轮询扫描整个 socket 集合，大大提高了检测的效率。

从下图你可以看到 epoll 相关的接口作用：

epoll 的方式即使监听的 Socket 数量越多的时候，效率不会大幅度降低，能够同时监听的 Socket 的数目也非常的多了，上限就为系统定义的进程打开的最大文件描述符个数。因而，epoll 被称为解决 C10K 问题（服务器同时处理 10,000个客户端连接的挑战）的利器。

技术人求职指南

Sun, 13 Apr 2025 00:00:00 GMT

小册链接：https://juejin.cn/book/7211868947363135545

序言：求职市场凛冬已至，技术人该如何杀出重围

整个小册内容可分为 求职前、求职中、求职后、入职后 四个阶段，具体如下：

本小册始于求职，却不止步于求职，虽然未曾包罗职场所有的软技能，但是对于技术人职场这个板块，许多方面都有所涉及。同时，尽管整个小册未牵扯任何技术内容，看着学起来难度不大，但其中无一不是实用的技巧分享，重要性远超你去学习某个单一的技术，能得到的回报也绝对会远超你所花费的成本。

整体收益清单如下：

工作多年的技术人，能给自己做好技术总结与定位；
能够掌握平时学习、面试前复盘的技巧与方法论；
能搞懂招聘方的用人需求、HR筛选简历的具体过程；
学会简历优化的技巧，打造一份最适合自己的简历；
理解投递简历的时机、技巧，增多自己的面试机会；
能摸透求职面试过程中的面试官，到底是什么角色；
学会消除面试前的焦虑，及调研要入职的目标公司；
掌握各类面试场景中的引导、控场技巧、忌讳点；
能从容应对HR面中的各类人事问题，以及谈薪技巧；
学会面试之后如何对面试进行总结、复盘与自我优化；
多个Offer在手时，学会自行判断哪个才最适合自己；
作为新人入职时，如何快速融入新环境和安稳转正；
具备做职业规划的能力，合理安排职业的生涯路线；
大龄程序员该怎样避免中年危机，保持核心竞争力；
如果被提拔成技术管理层，如何才能带好自己的团队；
学会如何优雅地向上级领导、公司提出涨薪与离职；
当工作出现意外状况，学会利用法律进行合理维权；
了解如何实现“睡后收入”，避开“副业兼职”的坑。

自我认知篇：作为技术人该如何定位自己在行业内的级别？

一、如何理解技术行业内的级别？

人分三六九等，技术行业内的潜规则同样如此。

不同行业对于技术工种的等级划分，具体职称上也许会有不同，但殊归同途，凡是涉及到技术性的岗位，都能被分为“初级、中级、高级、资深”这四个级别，简单总结如下：

初级：掌握岗位要求的基本技术，满足日常工作的基本需求（能干活）。
中级：不仅仅只局限于满足基本需求，在广度上也有着丰富认知（能干更多的活）。
高级：对技术不是停留在表面应用，而是在技术的深度上有一定研究（懂原理）。
资深：除开有着广度、深度认知外，能充分了解各个细节并解决问题（懂原理还有实际经验）。

可以看出，越往后级别越高，专业能力也会越强。这里对高级和资深稍作解释：高级更偏向于理论派，懂很多知识但没有太多实战经验；而资深则属于实战派，不仅懂，还具备丰富的经验沉淀，资深既代表了能力，还代表了资历，以及权威性。

作为技术人的我们，了解这些级别划分后，同时也要清楚自己的定位，否则就会出现如下这种尴尬场景：

目前处于初级水平，但偏偏学习时在看底层原理，求职路上发现面试官压根不问。

学习是件好事，但必须掌握科学的方式方法，千万别盲目跟风学习，只有明确了自身的能力定位后，才能带来最大的学习收益。比如，认识到自己目前处于“爬”阶段，那下一阶段则要学习“走”的能力，而跳过“走”直接去学“跑”的方案也并非不可取，只是并没有学“走”给自己带来的收益大罢了。

二、技术人该如何明确自我定位？

关于明确自我定位的好处在前面已重点说明，一方面有利于清晰地认识自我水平，另一方面则可以确定提升的方向。

不过自我定位是一个比较虚的概念，针对不同的人、不同的工作年限，实际情况会存在些许差异。为此，下面会先讲明不同年限应该要达到的级别，接着再阐述技术人该如何进行自我总结，最后则会针对一些特殊情况进行讲解。

不同年限的工作者应该达到的级别

在技术行业中都有一个潜规则，那就是一位从事N年的人，应该要达到XXX水平，比如今天公司招了一位具有九年经验的新员工，虽然你与他之间素未谋面，但潜意识下，就会觉得来了个大牛，这也是工作年限带来的“附加Buff加成”。

不过虽说年限不一定代表能力，但对于业内的技术人员而言，都可以依据不同年限做出一定判断，在这件事上所有技术人都有一个“共识”，通常来说，不同年限对应的标准如下。

工作0~2年：至少需要达到初级水准。
工作3~5年：至少需要达到中级水准。
工作5~8年：至少需要达到高级水准。
工作8年以上：至少需要达到资深水准。

至少要将能力与工作年限保持正比，否则一方面薪资不如意，另一方面求职机会也会少上许多。

技术人该如何做好自我总结？

自我总结依旧是一个比较泛的概念，有工作总结、年度总结、人生总结等各色各样的总结，相信大家也一定写过不少，尤其是入职一家要求写日报、周报、月报的企业时，XXX总结会令人写到麻木。不过我这里提到的并非常规性的自我总结，而是技术人的能力总结，更偏于撰写一份自己的“知识图谱”。

只有总结了自己的技术能力，才能帮助我们更加清晰地认识自我。但往往很多人都缺乏这种“技术总结”的能力，尤其是随着工作年限的增长，工作中会出现如下场景：

新入职的工作要用到这个，我得去学一学。下周接手的项目上会用到XXX技术，我得抽空去看看。新项目中要XXX来做，我得去瞅瞅。 .......

相信碰到这种情况的人不在少数，很多时候去学习一项新技术，都会有点身不由己，并不是自己想学，而是工作需要，不得不去掌握！最终就造成了“这也会，那也会，什么都会，但似乎又什么都不会”的尴尬局面出现。

当遇到这种情况，如果长期处于一家企业不动还好，但当你再次踏上求职路时，此前埋下的诸多弊端就会凸显出来，不知道如何写简历、如何准备面试、不清楚自己该找什么级别的工作……彻底迷失了自我，并失去了前进的方向。

这种现象往往在工作年限较长的群体中额外明显，想要走出这个困境，首先得学会对自我的技术进行总结！如何总结呢？最有效的方法是：知识树。

知识树是指通过思维导图之类的软件，例如通过支持在线编辑的 XMind 进行技术归纳，先将自己掌握的诸多技术按属性进行总结，再从知识树中得出反馈，从而确定自己的能力级别，如下所示：

但在做知识树总结时，有三点需要注意。

第一点，整棵知识树应当围绕着一个明确的方向展开（⭐比如 C++ 方向）。因为知识树要具备高强度的专业性，不能将日常生活中懂的方方面面全部写进去，这显然并不合适。开始撰写前必须先挑选自己最擅长的方向作为主体。以开发岗为例，如果你掌握了多门语言，那么一定要先选择一门语言作为主体，其他技能可以归纳到另一个主体分支中：

第二点，知识树不应该无限制延伸。这里主要针对树的深度和分支数量，对于某个具体的技术栈，千万别把每个细节都详细罗列，也不必无限往下深究原理，如下：

上述只是简单示例，重点是要记住不要无限拓展即可，毕竟这是总结，不是写书、写手册，如果不控制树的深度，浪费时间不说，同时还失去了总结的初衷。

就好比写小说，咱们只需要将情节脉络、目录规划写出即可，无需在其中详细写出每一个情节、章节的具体内容。

第三点，首次进行总结，不必追求完美。很多人首次画知识树时，往往都会追求完善性，写一个技术栈时，刻意去搜索还有哪些没写，还有哪些可以补充的。但记住：在首次画知识树时，你记得多少写多少就行，后面可以继续完善。

同时在画知识树时，千万要牢记：列出来的技术点一定是自己熟悉的，不要把只听过或者只简单了解过的技术点罗列在其中！画知识树不是设计技术大纲，实事求是才能得到最准确的答案。

如何根据知识树判断自己的能力？

当各位将知识树画好后，首先纵观知识树的二/三级分支数量，如果仅有几个，这意味着你很大可能处于“初级水平”，也就是能满足工作的基本需求。反之，如果分支数量较多，整棵树的主干已经涉及了很多主流技术栈，那也就意味着你很大可能达到了“中级水准”。

那如何判断自己是否达到了“高级”水平呢？这点依旧可以靠知识树来给出答案，如果知识树广度足够，挨个去看罗列出的技术栈，询问自己是否理解技术的大体原理。如果你认为对大部分技术，都有一定深度的见解，再加上自己具有不错的经验沉淀，那么恭喜你，你已经达到了“高级”水平。

最后，如果技术广度、深度都有了，如何判断自己是不是资深呢？对于这个问题，知识树和我都给不了你答案，此时的你应该扪心自问，自己是否达到了资深水平？

因为高级和资深之间，其实并没有明确的边界，更多的是技术见解、经验沉淀上的差异，如果一个已达资深水平的技术人，当你询问内心时，你就一定能够给出自信的答案。

技术能力与工作年限不匹配怎么办？

在经过技术总结后，如果你发现能力和年限严重不匹配，好比你有六年经验，结果到头来一看，哦豁！能力就中级怎么办？这时需要做的自然就是学习，但学习的过程无疑是痛苦且难坚持的，尤其是工作并不轻松的小伙伴，代表需要拿出休闲、下班后的时间去学习。

但凡事先苦而后甜，如果连学习的苦都吃不下，那你只能本本分分地当一个“菜鸟”，更高的薪资？更好的发展？不存在的，既然选择在技术行业继续打拼，那就不要停下学习的脚步！当你学不进去想要放弃时，记住一句话：这是未来的你，正在向你发出的求救信号！

不过学习也并非靠死办法，产生兴趣才是最好的良药，后面会有关于学习方法的分享，但这些是后话了。

如何根据能力定位，确定提升方向？

事先声明：如果急着找工作，可以先跳过这点，因为学习是长久的事，不能操之过急。

针对前面的多种情况，如果是初级，那下一步的提升计划，应该围绕着技术广度展开，至少要将当前专业内的大部分主流技术掌握后，才能达到“中级水准”。

🎯对于「初级」的小伙伴来说，提升广度的技术要学哪些呢？很简单，去看市场招聘，看招聘中频繁出现的技术栈，对于你不会的，统统记录下来，然后用不同的颜色，加入到知识树中，最后去进行相应学习即可。

🎯而目前已经达到「中级水准」时，下一步的提升应该针对技术深度，也就是对自己掌握的技能，别再停留在表面应用，而是深入内部探寻其原理，使用经验+深度，才能帮你抵达“高级水平”。

那中级水准的小伙伴，加强深度的方向是什么呢？比较快的做法就是找培训机构，也就是那些打着“XXX进阶课程”名号的机构，对于他们课程的含金量先不做评价，重点是参考他们的课程大纲！虽说课程质量不一定能保障，但大纲这块绝对花了心血，毕竟这是招牌，想要吸引“进阶培训”的学员，课程大纲必然要令人满意。

培训机构卖的进阶课程，绝对是技术的风向标，任何一家机构都不会掺杂无用内容在里面，大纲是市场需求提炼后的精华内容。当你拿到课程大纲后，直接和自己的知识树比对，把自己没有掌握的技术，同样用不同颜色标注上去即可。

知识树标出自己要提升的技术点后，接着可以慢慢学习，学习的同时要记得完善知识树，毕竟前面只是简单的罗列，后续学会某个技术栈后，可以将大体梗概补充在知识树中，这也能够帮助你后续快速复习。

⭐额外说明，不是你把某个技术学了，就代表你一定会了它，牢记：学是一回事，用是另外一回事！千万不要产生一个错觉，也就是看了一套教程就代表学会了它，只有当你能把这项技术灵活运用时，才代表着真正学会了它。

🚫所以大家在学习工作用不到的技术时，请一定要多加思考！很多时候，尤其是看视频学习，人会处于“接受式思维”，别人怎么教，自己就怎么理解，这样带来的弊端就是：

当相同的技术换一个场景，你就不会用了，这显然不能说你会了这项技术，只能说有所了解。

为此，想要真正学会一项新技术，要带有“质疑式思维”去看！学习时多思考，才能真正帮你掌握它。尤其是针对一些还在校的小伙伴来说，因为没有过实际的业务经验，所以学习时更需如此，否则会导致面试中，换个方式问，结果就一问三不知。

三、怎样得到自我画像？

前面讲清楚了技术级别、自我定位以及如何制定提升的计划，下面开始接入“求职话题”的正轨。

求职是一场没有硝烟的战争，想要把这场仗打得漂亮，就必须要牢记一点：成功需要缜密的计划和精心的准备！对于冲动之下就提桶跑路的做法，我个人不是很赞成，因为这会让求职变得异常被动，如下：

快速与目前公司交接工作，办理离职的相关手续；
草草地写好简历，开始通过各大招聘渠道投递简历；
简单地刷刷面试题八股文，准备迎接面试开始；
面试发挥不够理想，人事通知：先暂时回家等通知；
反复投简历、去面试、等通知、不断处于焦虑中……

上面这个找工作的过程，我将其称之为运气流面试法，尤其当能力一般时，会显得异常被动，能否成功上岸找到下家，主动权统统交给了市场。运气好，可能很快就找到了新工作。运气略微背一点，稍微拖上几周的时间，你内心就会慢慢变得焦虑、心态逐渐变差……

要记住！找工作是你选公司，而并不是公司选你，求职的目标应该是钱多事少离家近，而不是跌跌撞撞碰运气。

那怎么做到你选公司呢？这需要你对自身有全面的了解，在前面认识到自身的技术能力后，接着还要看看自己的综合条件。

古人讲究吾日三省吾身，而作为求职者的我们，也理当如此，但这三省究竟是什么呢？

自己的学历背景怎么样？
自己的工作履历怎么样？
自己的技术能力怎么样？

在正式踏上求职路之前，一定要想明白这三个问题，因为这三点贯穿咱们整个求职旅途。

学历背景怎么样？

学历背景，这将直接决定着你面试机会的多与少，虽说许多人都在高呼：“学历其实并没有那么重要！”

但不可置疑的一点就是：学历是你求职路上的敲门砖，如果学历不行，很多人事会直接用软件过滤掉。

除开少部分公司，如今大部分企业的HR压根不看本科以下的简历，本科以下的会直接过滤，连看都不看，是不是很残忍？但事实就是如此。

连能力都不看就直接pass，有人也许会觉得这未免太不公平了吧！但请记住：95%+的HR并不懂技术，同时也不缺应聘者，工作年限、能力无法三言两语确认，所以学历便成了筛选的第一关，从高学历的群体中挑选人才，会比从所有群体中挑选人才更简单。

工作履历怎么样？

工作履历是指自己的工作年限与经历，这其中包含了上家公司的性质、背景等。如果你有大厂背景，例如BATJ企业的工作经验，这无疑将成为你求职路上的闪光点，至少在你出去面试时，许多人都会下意识地为你打上大佬的标签。

不过除开大厂背景外，你目前的工作年限以及上家公司的性质，是外包、自研、外企还是独角兽？（下文有详细介绍）

这些多少会对你后面的求职有些许影响，Why？因为你的工作履历将决定着你下份工作的收入，不同履历的求职者，市场会给予不同的报价，很少有人能打破涨薪30%的限制。例如一位只具备两年外包经验的求职者，市场能否给到30K的薪酬呢？显然并不现实，就算你技术再优秀，也很难打破市场的潜规则。

✍不过，履历虽然决定求职报价，但 30% 的薪资涨幅（最多 30%，潜规则），也并不是所有人都能拿到，除非你能力十分出色，否则一般涨幅只会处于 10%～20% 这个区间，按如今的环境来看，「平跳」都是很常见的事。

技术能力怎么样？

学历决定了面试机会的多与少，履历决定了薪资的高或低，而技术能力则是最后一省，这也是最重要的！

任何一个技术行业，不存在只靠优秀的学历、出色的履历，就能成功入职的情况，技术行业的根本是以技术作为驱动，你技术能力的强弱，将直接决定着你能否通过面试。

学历虽然决定着面试机会，但在技术能力够强的前提下，也并非绝对，比如Vue的作者尤大（尤雨溪），假设他就算是初中学历，此时去找工作，学历高或低，这对他会有影响吗？答案很显然。

当然，有人或许会觉得举例很极端，技术能达到这个层次的人，才多少呢？

确实，但我要表达的意思是：只要你能力够强，学历其实没有那么重要！一般社招（三年以上）有本科学历，不管背景、性质如何，相对来说影响就不大了。同时，市场对“高能力的人才”的包容性很强，大家可以去看“六年以上”的社招市场，就算你的学历是专科，依旧存在一大批能达标的招聘。

因此，当你达到某些条件后，就算学历、履历不行，只要技术足够OK，可以忽略前面两条。

三省吾身后得到自我画像

在真正准备面试前，作为求职者的我们必然要思考前面三个问题，思考清楚后同样用思维导图的形式进行总结：

学历决定面试数量，履历决定薪资待遇，技术决定能否入职！其中最重要的是第三条，大家都身处在这个行业，对于这条的含义，诸位也许比我更明白。在我的工作生涯中，也见过许多名校毕业、高学历者面试被pass，毕竟能做事才是这个行业最重要的前提。

仔细想明白这三点后，相信大家对于下份工作，该找什么类型、什么薪资范围的下家，心里多多少少有谱了。

不过这并非是让大家“三省吾身”的初衷，做这一步只是为了让诸位更全面地认识自己，尤其对条件较差的小伙伴而言，如学历较低的伙伴，很多时候会下意识逃避这一点，但只有当认识到自身的缺陷后，才能便于后续做出调整。

求职意向篇：怎样定下合理的期望薪资及确定目标公司？

现在应该对自己的技术、现状有了新的认知，但也仅仅止步于此。

如何根据自我画像，制定合理的期望薪资呢？如何选择适合自己的公司呢？

一、如何制定合理的期望薪资？

求职者的面试期望，主要包含期望薪资、目标公司这两方面，想要制定合理的求职期望，需要结合自身情况、市场环境来综合考虑。下面一起聊聊吧～

影响期望薪资的因素

先讲明几个影响期望薪资的因素，接着再说如何制定期望薪资，影响薪资的因素有以下四个。

市场氛围：如果大环境整体氛围不行，跳槽时几乎很难找工作，涨薪的可能性也会很小。
技术级别：不同的技术能力，好比初级和高级，两者拿到的薪水待遇自然不同。
所在城市：一线、新一线、省会、非省会城市之间，薪资待遇必然有所差异。
- 一线城市：北京、上海、广州、深圳。
- 新一线城市：成都、重庆、杭州、武汉、苏州、西安、南京、长沙、天津、郑州、东莞、青岛、昆明、宁波、合肥。
- 二线城市：泉州、厦门、福州、...
- 三线城市：...
- 四线城市：...
- 五线城市：...
工作履历：很多人上一份工作履历，将会成为下一份工作的基础，薪资涨幅会受限。

大环境的市场氛围如何判断？

很多人在跳槽前，最想知道的就是目前外面的行情怎么样，接着会根据行情来决定是提桶跑路、还是继续窝着。

行情好不好其实可以直观地从招聘软件看出，根据招聘方的活跃度进行判断。如果你所在的城市，发布招聘需求的大部分招聘者活跃度很低，这意味着当前城市的行情并不是很好，很多HR、Boss都停止了招聘。

但这种手段需要一定的数据支持，单纯靠人工手动来进行判断，需要查看大量招聘才能得到具体的反馈，因此这种方式最好结合数据采集手段（爬虫）完成，效率更快的同时，精准性也会更高。

当然，大家也可以通过技术群/社区等渠道，直接询问相关城市的同行，以此得到大概行情。

如果目前行情并不佳，最好的选择是骑驴找马，也就是暂时先不辞去当前工作，先出去试试水感受氛围，找到满意的下家后可以选择无缝衔接。但如果目前已经离职，想要在行情较差的市场中找到工作，那这时就需要做好降低期望的心理准备（尤其是在如今这个四处喊着“XXX已死”的时段内，新工作很有可能是平跳，甚至降薪）。

不同城市、技术级别的薪资标准

自身技术级别、所在城市，都会影响你的期望薪资。IT行业公认的薪资梯队如下：

这里以一线城市的后端开发岗为例，来说明不同级别的薪资范畴。

初级开发工程师：7K～13K左右。
中级开发工程师：13K～20K左右。
高级开发/技术专家：20K～32K左右。
资深开发/架构师：32K以上。

上述薪资范畴，在不同的岗位上也许存在差异，例如前端、C/C++、Go……但级别对应的薪资中位数浮动区间不大，因此可以适当参考上述给出的薪资标准。

不过假设你是中级水平，到底拿14K，还是18K呢？这要根据上份履历决定，下面聊聊这点。

上份履历是重要基础

前面在强调行情、城市、技术决定期望薪资，但更重要的一点是：你上份工作履历，这将直接决定着下份工作的待遇。通常情况下30%是极限，比如上份工作是10K，但你自认为能力到了高级，直接开价25K，这属于漫天要价，基本不可能拿到。

但如果你目前的薪资较低，能力特别出色的情况下，跳槽薪资翻倍的可能性也有，例如原本是6K，经过跳槽后要到12K，这种现象比较常见。

不过随着工作年限的增长，到手薪资的不断提高，这意味着你越来越接近行业薪资的天花板，所以跳槽时，薪资的涨幅空间会越来越小，一般不会超过前面所说的30%。

有时你的能力明明达到了高级水平，但你在上家公司一待就是三四年，老板也不怎么给你涨薪，所以导致上份工作的薪资并不是很高，此时该如何摆脱上份工作带来的涨薪限制呢？其实这种情况也有解决方案。

实话实说：只要能力足够出色，招聘方也会给到满意的报价。
编织谎言：说自己之前在“非一线”的分公司上班，所以薪资谈的是非一线城市的待遇。

第一个方案比较容易理解，第二个方案的原理则是：享受“非一线转一线”带来的“红利”，这时原本所说的30%限制会被打破（但一个谎言需要更多的谎言来圆，这样做的话要想好说辞）。

制定合理的期望薪资

经过前面的内容熏陶后，大家对影响期望薪资的各个因素都已了解，那究竟如何制定合理的期望薪资呢？接下来重点聊聊这个。

很多人在面试前没有想过期望薪资，因此喜欢临时报价，但要牢记：期望薪资并不该是“顺来逆受”！你必须得先自己坚定立场，如果你自己报出的期望薪资都很随便，那很大程度上就与这个薪资无缘了。

当然，适当参考面试情况来选择性报价，这种方案是可取的。坚定立场并非死守立场，如面试前的期望是20K，但面试发挥得一塌糊涂，结果还楞生生喊20K的报价，这合理吗？显然并不合理。

不过选择性报价的前提是：你得有一个自己的最低要价。所以，这里要借助一些招聘平台，从招聘平台得到市场反馈的报价，大家要学会善用招聘网站的“条件筛选”，如下：

先选择好求职城市，然后把上节得到的自我画像信息依次填入，最终就能得到市场给予的报价。

通常情况下，市场对相同条件的求职者，给予的薪资区间大致相同，所以这个报价，也是你期望薪资的参考之一。同时还要结合上份履历、技术能力去进行微调，经过一番调整后，你将得到一个与你最符合的期望薪资。

接着可以优化成范围值，例如期望15K，则可以变为14K~16K，设立最低期望和最高期望，这样方便你根据面试的发挥情况，去进行合理报价。

同时，因为该薪资范围是结合自我画像得来的，所以你几乎是与该薪资最匹配的人选，毕竟该薪酬范围内的招聘要求你完全满足！

但制定好期望薪资后还不够，找工作、找工作，一定要理解里面的“找”字，这意味着你可以挑公司，而并不是公司挑你。因此，接着我们就来聊聊如何确定自己的目标公司。

二、如何确定最合适的目标公司？

大部分小伙伴刚踏入社会时，对第一家任职的公司基本没有要求，想的是有口饭吃就成。不过随着自己的年限、经验、技术不断增长，有了资本之后，开始对下家公司也有了一定要求，好比：“打死不去外包！”

不同类型、规模的企业，所具备的氛围有所不同，入职后的工作内容也存在差异。比如微小创业型公司，你进去之后可能需要干特别多的活；而中大型规模的企业，入职后的分工会很详细，多个岗位各司其职，相互之间配合起来完成工作任务。

接着大致介绍一下企业的分类，大家可以根据不同类型企业的特点，选择一类自己期望入职的企业。

技术人眼中的企业分类

这几年由于疫情影响，倒下了一大批公司，但留下来的依旧不少，对于所有招聘IT技术类岗位的企业而言，咱们可以用体量、性质、业务三个维度来进行划分。下面先做大致罗列，后面再列出具体区别。

站在 体量或规模 的维度来看，企业可以划分为四大类。

小型/创业型企业：公司规模通常在 100 人以下。
中型/成长型企业：规模通常在 200~1000 人左右。
大型/成熟型企业：上市企业、国企、独角兽、次级大厂等，规模通常在几千到几万人左右。
互联网顶级大厂：典型的BATJ、美团、拼多多、字节……以纯互联网业务为主的企业。

以 公司性质 的角度来说，企业大致可分为两大类、五小类。

自研型企业
- 软件产品即核心：软件作为公司主营业务，依靠互联网产品盈利，如阿里、字节、腾讯等。
- 软件产品非核心：公司主营业务为实体产品，软件系统用于辅助功能，如车企、餐饮等。
- 国外企业（外企）：国内的外企通常是为了打开亚洲市场，可能是官网、平台、产品等。
外包型企业
- 人力外包型：对外招聘技术人员，外派到项目方驻场开发。
- 项目外包型：类似于接单工作室，招聘技术人员开发外部接到的项目。

从业务的划分而言，企业大致可以分为两类。

互联网型企业：主要以卖服务为主，例如直播、金融、电商等类型的业务。
传统型企业：主要依托于实际产品，例如工业、银行、保险等类型的业务。

PS：互联网型和传统型企业的划分，其实有多种解读，有些以技术老旧来区分，这里就以性质来分。

上面分别从三个维度对企业进行了划分，之前也说过不同类型的企业，以IT技术人员的身份入职，工作量、工作内容、福利待遇、内在地位等方面有所差异，下面展开讲一讲。

以体量规模维度划分

小型企业：

优势：初级进入后成长速度快。
- ①地位不错：由于公司团队人数不多，因此每一个技术成员都是核心。
- ②成长最快：因为技术人员配比不全，所以工作承担的责任更大。
- ③具备潜力：如果公司后面业务做大，你将成为元老级骨干，待遇也许咔咔涨。
- ④氛围很好：由于公司人员较少，每个人之间都很熟悉，同事之间能打成一片。
劣势：工作内容繁杂且风险大。
- ①工作繁杂：很大几率成为全干人才，前端、后端、测试、运维一体化。
- ②风险较大：公司规模较小，资金链也较短，一点意外因素可能就欠薪倒闭。
- ③成长较少：对于初级开发而言收获的成长最多，但中高级以上工作带来的成长很小。
- ④隐私性低：人员少、资金小，代表场地不会太大，回头一看会发现老板正盯着你。
- ⑤加班较多：由于制度不完善，所以加班、下班后再上线等情况是常事。

中型企业：

优势：业务稳定且潜力很高。
- ①业务稳定：能做到这个规模说明至少稳住了一块业务，入职后倒闭风险较低。
- ②潜力很高：每一个大型企业都是从这步跨过去的，比小企业的晋升空间大。
- ③团队完善：通常至少会配备完善的技术团队，不会出现哪里需要哪里搬的现象。
劣势：
- ①加班严重：由于公司正在高速成长，所以平时加班会较多。
- ②裙带关系：这个规模的企业中，领导层裙带关系最多，公司高层普遍是老板亲朋。
- ③福利较差：该规模的企业中还未搭建出完善的福利体系，能享受到的福利随机。

大型企业：

优势：某个领域的独角兽，风险性极低。
- ①福利不错：具备完善的福利体系，生日会、下午茶、奖金、年终奖等都有。
- ②制度完善：加班有补贴，晋升体系明确，管理制度正规化……
- ③加班较少：因为已经打下了一块业务，所以平时工作量也不大，加班较少。
- ④风险极低：由于已经啃下了某块业务，抗风险性更高，不用担心跑路。
- ⑤影响力好：虽然没有顶级大厂的含金量高，但也具备一定知名度，可以“镀银”。
劣势：官僚主义严重，归属感不高。
- ①官僚主义：由于企业不算小，所以高层容易拉帮结派，需要一定情商才好晋升。
- ②归属感低：新人进入团队后容易成为螺丝仔，同事之间较为冷漠，归属感不高。
- ③结构复杂：内部管理结构比较复杂，各项工作流程也相对复杂，不利于快速发展。
- ④发展缓慢：由于已经啃下一大块业务，更多的是求稳，而并非追求激进发展。
- ⑤成长较低：内部已经具备完善的技术体系，熟悉后很难从工作中获得技术成长。

顶级大厂：

优势：薪资待遇高，镀金的完美跳板。
- ①薪资超高：相同技术对比其他规模的企业，薪资待遇要高出30%以上。
- ②福利超好：正常年终奖在3～6个月，有购房低息贷、期权分红等。
- ③镀金跳板：业内影响力大且名气高，“毕业后”具备大厂背景加持。
- ④流程规范：相较于外部企业，大厂的工作流程更正规，能收获不少知识。
- ⑤积累人脉：身边都是社会精英人士，对比外部更容易积累优质的人脉资源。
- ⑥晋升明确：新人进入后，能力决定薪资待遇，前期成长的速度较为可观。
劣势：内卷超级严重，个人地位不高。
- ①内卷严重：因为绩效末尾淘汰机制的存在，同事之间内卷十分严重。
- ②地位不高：如果不是影响力较大的巨佬入职，在团队中的影响力较低。
- ③暗斗颇重：大厂一般倡导狼性文化，部门、员工之间竞争相对严重。
- ④难晋高岗：普通员工干到一定级别线后，很难“立大功”晋升更高的职位。
- ⑤易成螺丝：大厂讲究专而精，入职后通常会分配到某个岗位上打螺丝。

以公司性质维度划分

以公司性质来划分，主要可分为自研型、外包型这两类企业。自研型企业中主要分为软件产品为核心、软件产品非核心这两种，但为了全面性，咱们也将外企列入了自研型企业中。反观外包型企业，主要涵盖人力外包与项目外包。

接着简单说明一下各类公司的优劣势。

软件即核心型自研：技术人员的地位很高，并且福利待遇相对不错，负责的产品也会更加追求完善性。但由于是自研型企业，所以能接触到的业务线不多，入职一段时间后，工作能给自己带来的成长不多，并且以普通员工的身份入职，很容易成为打螺丝的那位。

软件非核心型自研：整体与前者相差不大，但技术人员的地位相对没有那么高，毕竟公司主要以实体产品为主。但入职后十分安逸，忙完项目产品的初版研发后，后续的工作特别轻松，不过个人成长会随之受限，后续也很难以技术身份晋升内部高管，比较适合养老。

外企：有机会进的小伙伴都可以尝试，除开少数外企，大部分外企的福利待遇特别好，并且十分强调工作与休息时间的界限，钱多事少的类型。不过想进需要一定的英语能力，并且有些外企所用的技术会跟国内主流技术脱轨，不利于后续发展（研究所、军工类的也大致相同）。

人力型外包：地位特别特别特别低，著名的那句“外包仔别偷吃公司零食”就源自于这类外包公司，一般入职后会被外派到甲方驻场，负责大型项目的边角料业务开发，十分不利于后续发展。至于优势的话似乎没有太多，也许钱会多一点点？如果不是走投无路，不建议选这类Offer。

项目型外包：这类外包比前者要好，地位也没有那么低，主要是负责开发承接的外部项目，特别适合初中级积累业务经验，能够接触到各行各业的项目（我有位老同学堪称外包狂人，巅峰时期一人负责17个外包项目）。但项目更追求开发速度，并不追求质量，讲究“能跑就行、又不是不能用……”，不利于后期成长。

以业务性质维度划分

站在业务性质的维度上划分，主要可分为互联网企业和传统型企业。

前者一般技术较新，技术上也更为激进一些，对于技术人来说，工作带来的成长会更大。

后者则技术相对较老，发展较为缓慢，技术上较为保守，求稳为上策。

对于技术人员而言，互联网型企业必然会比传统型企业好上许多，不仅仅是薪资待遇上的差距，更多的是工作上带来的个人成长。

技术人该如何选目标公司？

经过一番啰嗦后，相信诸位对各类企业有了一定了解，不同类型的企业多少会有差异，前面给出优劣分析，虽说不一定绝对权威，但大体符合，因此可以作为客观参考项。

了解各类企业的优劣特点后，又该如何选择目标公司呢？

这得因人而异，每个人的追求不同，所以选择也会有所不同。比如有人要钱，就算加班也能接受；而有人追求轻松，钱少一点也不在乎……为此，大家可以根据自己内心所想，去确定目标公司。

站在我个人的角度给出的建议，初级可以选业务比较丰富或成长价值不错的企业，如项目型外包、小型创业公司等，因为现阶段对个人成长最有益的，是追求业务和工作经验上的积累。

中级则可以选技术成长类的企业，主要关注入职后能给自己带来能力增长的企业。

高级水准左右的小伙伴，则主要追求好的平台，如大厂、大型企业等，这有利于后续个人的发展空间（职位、薪资）。

当然，初级选业务积累，中级选技术成长，高级选后期发展，这也仅是我个人的建议，也不一定要这么选，大家适当参考即可，具体还是要遵从自己的内心想法，如果你内心没有要求，遵守“给钱就干”的原则也不是不行。

自己到底要不要尝试冲击大厂？

冲击大厂，这应该是很多技术人的梦想之一，毕竟大厂不仅代表更高的薪资福利，而且也是一种镀金手段。当履历上增添一笔大厂的工作经验后，也能成为以后简历的闪光点，有助于拿到更多的面试。同时从大厂“毕业”之后，薪资报酬也会高上许多。

入职大厂带来的好处毋庸置疑，以大厂作为跳板也的确是很不错的镀金方案，但大厂的招聘往往更严格，除非你的综合条件都不差，并对自身技术有绝对自信，否则我并不建议冲大厂，因为大厂的面试流程比较长，有些能达到好几周。所以目前如果处于待业状态，在没有一定把握的情况下，冲击大厂反而会带来一定的影响（时间开销）。

不过大厂也并非遥不可及，如果你具备以下条件，那我的建议是可以尝试尝试。

远超同龄人的技术，至少对比相同年限的工作经验者，技术能力上有不小优势。
具备不错的学历背景，不要求一定要是985/211名校、硕士等学历，但至少还过得去。
具备不错的项目经历，有参与过核心系统的架构与开发工作，只有简单的项目就不必尝试。
年龄最好是在25岁及以下，最多不能超过28岁，超过该年龄时再尝试，技术要求更高。

上述这四点，是通过「社招」进大厂需满足的四个前提，如果其中某条不曾具备，那你去尝试的结果很有可能会以失败告终。

但还有一类人除外，那就是「应届生」，满足两点即可：

不错的学校背景，如985/211院校的应届生，大厂会去校园招聘；
具备扎实的计算机功底、不错的项目经历，或者不错的实习经验。

学历不错的应届生是最容易进大厂的一批人，因为不仅招聘要求会放低，而且流程也会快很多，并且无需对某个技术有特别深入的研究，大厂招聘应届生更关注“培养价值”，毕竟还未真正出学校的应届生，专业方向还未彻底定性，所以可栽培的价值很高。

如果符合上述两个条件的小伙伴，可以参加校招会尝试看看。错过了校招进大厂的小伙伴，那就只能走社招进入，网申通道投递的简历，通过率比较低，因此社招想要进大厂，最好还是找人内推。

如何挖掘高潜力的企业

大家都做过“买彩票中五百万”的美梦，也一定有过“入职的公司突然成为独角兽，从此自身地位水涨船高”的念头。

当自身冲击大厂不够格时，找一家具有“成为独角兽”潜力的企业，这听起来似乎很不错，对吧？但从数不尽的创业公司中，想找到这样的企业，难度无疑堪比大海捞针！

难道我们只能凭运气来碰“高潜力”公司吗？答案是No，其实找高潜力的“千里马”，也存在一定的技巧与方法！哦？具体怎么做呢？下面来聊一聊。

以个人的视角和认知，想要挑选出“千里马”格外困难，就好比在股市中，普通人买到潜力股的概率也很小，不过股市中我们可以抄作业，抄一些大佬的持仓配置，这个技巧同样可以换到“挑公司”中！那挑选高潜力公司时，究竟要抄谁的作业呀？很简单，抄大厂和资本的。

我们可以借助企业工商信息查询系统，如企查查、天眼查等，直接搜索大厂的名字，接着查看其对外的投资情况，例如：

又或者可以去抄资本机构的作业，如红杉资本、纪源资本、高瓴资本、达晨创投、深创投等投资公司，根据其对外的投资情况，选择心仪的“高潜力”公司：

这背后的原理相信大家都懂，作为专业的投资手，以及行业的龙头，投资的目光自然比咱们看得更远，所以当大家想要真正找一家高潜力的公司时，就可以优先往大厂、资本投资的优质企业投递简历。

三、应届毕业生又该如何抉择？

事先声明：非应届生身份的小伙伴，可跳过这个阶段。

应届毕业生属于一个比较特殊的群体，目前的处境也有些尴尬，现在整个行业的人才较为饱和，企业招聘时也不缺人来应聘，因此如今留给应届生的空间越来越小，纵观整个行业趋势，涌入这个行业的人每年都在逐步增多，所以应届生将要面临的是“狼超多、肉很少”的情况。

应届毕业生中，如果学历背景较为不错的，那一定要尝试冲击大厂，这将是一个改写以后人生走向的路口，因为第一份工作的薪水、经历，将直接决定你的起点，大厂无疑是起点最高的一个选择。例如普通公司4K的实习生，和大厂15K的实习生，两者在找第二份工作时，薪资待遇将会有着天差地别。

但如果学历、院校背景没有那么好，在有其他更好选择的情况下，我不建议再往这行钻，为什么呢？下面一起来探讨一下。

相较于早些年人才稀缺的那个时代，如2010年左右，只要你说是计算机专业毕业的，一大堆公司会抢着要。而回头再看如今，除开规模不错的企业外，很多公司对应届生的招聘开始减少，这个现象大家应该能够明显感受到。随着时间往后推移，尤其是疫情影响之后，很多企业甚至都不再招聘实习生，这是为什么呢？

主要有如下四点原因。

人才饱和：略微多花一点钱，就能招聘一个具备实际动手能力的初级开发。
事情很多：因为刚出学校，很多东西不懂，往往许多工作需要老人协助完成。
效率很低：花费了多于老员工的N倍时间，做出来的结果还需要再次改善。
忠诚度低：企业花了几个月的时间培养成型，结果因为薪资不满意很容易跑路。

因此，除开大厂外，很多企业，尤其是中小型公司基本上不会选择招聘实习岗，因为除开少数优秀的实习生外，选择招聘其他实习生反而是一种吃力不讨好的行为。

当然，看到这里我相信有部分小伙伴，可能会感到略微有些难受，觉得这些话有些难听，但这就是现实。

对于应届毕业生而言，这个行业如今没有那么美好，那应届生该如何抉择呢？

最好的选择是大厂/中厂，大厂有足够的魅力留下实习生的心（薪资待遇/镀金履历）。
如果学历不够，第二选择是考研，市场对高学历的应届生很友好，考研后选择机会更多。
如果自认考研无法上岸，第三选择是靠亲戚朋友转行，转到一个发展、薪资不错的行业。
如果原生家庭没有人脉资源，最后的选择才是踏入这行死磕，开启一条“异常苦逼之路”。

🌗总之，对于应届生来说，只需认准一条原则即可，那就是尽可能地去提升你的起点！你的第一份工作，很大几率下，将会直接影响着你未来的发展，当有更好的起点可供选择时，那请千万不要犹豫，进大厂、考编、考公、考研都是这个道理，起点不同，未来的人生轨迹也会完全不同！

技术突击篇：如何根据求职意向进行快速提升与复盘？

一、突击与复盘并不是闭眼摸虾

如何准备面试才最高效呢？那就是：请围绕着期望薪资准备面试，千万不要闭眼摸虾！

既然有了一个具体的期望薪资，那你就能确定自己要准备哪些技术，因为同一薪资范围内的招聘要求大致都相同，此时你可以拿着自己的期望薪资，去到一些招聘平台上，多查看一些招聘要求，从中选取出现频率较高的技术栈与要求，然后进行定制化复盘。

为何要这么做呢？因为许多小伙伴在准备面试时，都会显得有些无厘头，这或许是因为环境造成的，如今四处都在喊着面试要造火箭，培训机构天天跟你说：你是个只懂CRUD的螺丝仔……久而久之，这些话也成了业内所有人的共识，大家在准备面试时，也潜意识地会去看原理性的内容，但这有必要吗？也许有一定意义，毕竟前面的那些话，也在一定程度上影响了面试官，但请牢记：千万不要把重心放错了地方！

比如典型的案例：

高并发，这玩意儿重要吗？重要，但如果你只想找初级的工作，天天研究高并发有意义吗？有人可能会回答：“没办法，面试要问！”

但请记住，初级面试中会不会问高并发呢？显然大部分不会，除开少数个例除外。

从上述案例中要明白一个道理，前面做的技术定位、求职意向并非白用功，你应该要搞清自己需要的、摒弃不需要的，不要去做无意义的技术准备。通过招聘需求得到自己的复习/学习重心，再结合目前的现状来制定计划，才能让面试前的技术准备最高效。

一般要准备面试的群体我将其分为如下两类，这两类群体都有各自的面试计划。

时间充裕的骑驴找马者：目前有工作，考虑换个新环境。
焦急万分的自由技术人：目前已辞职，迫切需要新工作。

二、技术突击：时间充裕的骑驴找马者

对于目前还未离职的小伙伴而言，时间方面会比较充足，这意味着可以慢慢准备面试，在这种情况之下，去刷面试题反而不是最好的选择，应该要考虑的是做技术突击，逐步将自己的能力提升到符合期望薪资的水准。毕竟刷面试题属于临时抱佛脚、治标不治本的做法，很难真正理解那些自己不懂的知识点。

既然要做技术突击，切入点在哪？到底是追求广度还是深度？对于这点，要因人而异。如若想要找“中级水平”的工作，首先应该追求广度；如果打算尝试“高级水平”的面试，此时应该注重技术深度。但牢记：广度不是涵盖全部，深度不是死钻到底，一定要把握好分寸，追求广度也好，深度也罢，想要做到极致很难，不仅要耗费很多时间，而且还需投入大量精力。

确定了学习方向后，接着再回到之前所画的“知识树”，通过调研招聘需求后，用其他颜色把自己所缺乏的技术标注出来，这是接下来要学习的内容，尤其对技术与年限严重不匹配者来说，这将是你技术追上工作年限的最佳时机。

确定了要完善的技术内容后，接着还需规划学习路线，凡事都有轻重缓急之分，学习也不例外，对于自己缺乏的技术，要先做好优先级排序，首先把那些热度高、通用性强的技术放前面，闲暇之余再考虑那些能用到、但热度不高的技术。这样做的好处在于可以应对突发情况，就算中途被“优化”了，因为重要的技术已经弄懂了，那些优先级不高的内容在面试中也不会影响大局。

最快的与最有质量的学习方法

学习的方向、欠缺的知识、学习的路线都确定了后，又该如何去学习不足的技术呢？

效率最高的学习方法：读经典书籍，看优质专栏。
质量最高的学习方法：看教学视频，跟培训课程。

对于具备不错基础及自学能力的人，个人建议选第一种方式！一方面是因为速度快，另一方面还能顺便加强自学能力。

不过有一点不可否认：通过第二种方式学习，无疑会比前者更加轻松且质量更高，因为任何课程/视频的设计者在规划时，绝对已经考虑周全，你想要掌握的技术点，基本都能学到，能录制课程的人绝对比“目前的你”更懂这项技术。但相较前者会更加浪费时间，同时还有一点要注意：通过看视频/课程的方式学习，容易让人产生依赖性，丧失一定程度上的自主学习能力！

这点相信有过长期靠视频学习的小伙伴，应该能感同身受，当你想要研究一个新问题/新技术，如果在网上没有找到相关视频时，将会显得有些无从下手，不知道如何开展研究，这就是长期依靠第二种方式学习带来的弊端。

有人会说：“你这意思是一定要靠第一种方式学习咯？”实则不然，要分具体情况来定，如果目前要研究一个从未接触过的新技术，或自己底子不是特别好，那选择第二种方式依旧是最好的方案。

第一种方式更适合一些目前至少达到了中级以上水平，且具备一定自主学习能力的小伙伴！如果不熟悉某项技术，再加上自主学习能力较弱，那么自己去尝试研究时，花费的时间会远超第二种方式。毕竟现在各种资料满天飞，但大多数仅停留在表面阐述，或仅有只言片语，想要找到一套较完整且有深度的资料，也会比较困难。

找到适合自己的优质学习资源

选择一种适合自己的学习方式后，如何找到优质的资源呢？

先来聊聊如何寻找质量不错的视频教程（对应前面第二种学习方式），这里也可以加上一个前缀：免费，但事先声明，我并非引导大家成为白嫖佬，只是希望大家别花冤枉钱。这里提供几种方式，如下：

学习前请先查查自己的网盘，如果平时你爱收集资源，或许能给你一个意料外的惊喜；
网盘没有对应资源时，请先去常用的资源平台看看，如大家比较熟悉的B站；
合理使用搜索引擎，天下没有不透风的墙，搜索引擎玩得溜，想要啥都能找出来；
善用技术交流圈，技术群、社区、论坛，略微花点代价，大部分学习资料都能换到；
学会通过网购渠道低价买入，起步大几千的课程舍不得买，此时你去闲鱼、淘宝能有惊喜。

不过并非所有视频资源都算优质，大家一定也遇到过很多优劣不一的资源，因此找到一份学习资源时，要记住：“客官，你不要那么猴急啊，讨厌~”优不优质全靠同行衬托，最好的办法是找几套出处不同的教程，简单听一下相同知识点的讲解，就能高低立判，选择最好或最适合的那份再学习也不迟。

接着再简单聊聊，如果选择通过第一种方式学习，又该如何寻找优质的资料呢？如下：

如果比较热门且出现时间较长的技术，先去看看有没有对应的经典书籍；
如果是比较新的热门技术，可以直接去参考对应技术栈的官方文档；
通过搜索引擎、技术网站输入具体的关键字，多点开几篇资料，对比后再阅读；
寻找优质的连载资料，例如某些大佬的付费专栏、电子书、掘金的小册子等。

自己研究某项技术时，通常就是依靠这四种方法。

第一种方法无疑最好，至少专业性最高，但大部分书籍的描述会有些拗口，这时需要你具备一定的理解、推导能力。

第二种方法比较适合研究新技术，官网的文档绝对是最准确的，但有时会看到的是英文版手册，所以需要不错的英语阅读能力。

第三种方法绝对是大家最常用的方案，也是较为特殊的一种方法。一项技术对应的文章资料有很多，但资料五花八门，同一个知识点可能会被解读出不同的释义，这时你需要具备一定的辨别能力，千万别听风就是雨，最好多对比不同的资料，再结合自己的理解去推导出你想要的答案。

说实话，这样做会比较耗精力，想要从一堆资料中去研究明白一个知识点，需要不少的时间，毕竟有时找到了满意的、但描述却不全面，有些描述全面、但内容又不满意，所以想要通过这种方法去学习，往往要靠自己去提炼精华，多看多理解，最终形成自己的技术认知。

不难发现，上述一些问题也是我强调第一种学习方式得具备一定底子的原因。如果底子较为薄弱，当你看书、看官方文档时就会很难理解，甚至犯困，当你去看文章时，也很难做到“取其精华，去其糟粕”。

理性看待线下培训与线上网课

相信大家对“培训”这个词汇都不陌生，随着国内互联网的发展，再加上近些年疫情影响，培训机构、在线教育的崛起速度异常惊人，但对于培训机构的评价却褒贬不一，尤其是身为程序员的我们，对它们是又爱又恨，爱是因为能从它们身上学到一些知识（大部分视频教程都源自于培训机构），恨是因为它们加速了行业内卷。

这里不对“培训机构”做过多评价，我们重点是要聊一聊它们的核心业务：付费课程。

但凡接触过这些机构的小伙伴，经过一番营销洗脑以及课程推广后，对于它们的付费课程多少有过幻想，对比传统的教学视频，付费课程的最大吸引力在于：课程内容全面，都以面授或直播的形式开展，不懂的可以当场提问，有疑惑的课后随时解答。

这是付费课程的最大优势，也是大家想买课的最大原因。但记住！并不是所有机构都那么负责，很多机构付费前对你无微不至，但加入后需要解答时，你会发现解答的时间很慢、甚至压根没人回（这里有相关经验的小伙伴应该深有体会）。

那我们到底需不需要这些付费课程呢？或者付费课程值不值得入手呢？这同样得因人而异，如果你的自主学习能力差、自律性比较差、底子比较薄弱，那应该会比较合适，毕竟花钱了你会更加珍惜一些。

反观前面对于能选择第一种学习方式的人来说，这个课程的价值就不大了，毕竟课程里面有的东西你都能靠自己研究明白，唯一珍贵的一点是有人能帮你解答疑惑，但对比其昂贵的学费，显然投入和产出不成正比。

但如果你坚决要报课学习，那也没有问题，只不过以我接触过的人来说，大部分人报课后，只是给自己买了个教训（里面坑很多）。因此，在付费前一定要货比三家，请擦亮眼睛仔细分辨，选择一家好的机构，不仅后续能拥有更好的服务，而且也会帮你省去很多麻烦。

综上，我们就可以提炼其主线内容啦，如下图：

三、快速复盘：焦急万分的自由技术人

前面针对还在职的小伙伴，提供了一系列的准备方案，那再来到大家比较关心的一种情况，如果我目前已经离职了，现在迫切需要一份新工作怎么办？

我：我知道这时的你会很急，但你先别急！
你：！？？！
你：哥，我是想要你教我一套能快速找工作的秘诀啊，不是听废话的。

怎样才能快速找到新工作呢？记住，等我有条件开公司了，第一时间就给你直接发Offer，哈哈~

心态调整与制定复盘计划的核心

话回正题，在很多人看来“你很急但先别急”这句话是废话，尤其是所投简历如石沉大海、面试回家等通知的小伙伴，听到这句话会更来气：“奶奶个熊的，火都快烧到我屁股上了，你还叫我不要急！”

但要明白一个道理：你的焦虑并不能改变你的处境，急躁只能加速你内心的焦虑，最终反而会影响你的心态，所以离职后首先要做的是调整好自己的心态，做好“长期奋战”的心理准备。

以我的某位朋友为例，他当时就是这种情况，求职碰壁后并未焦虑，而是调节好了心理并放松了心态，您猜这结果怎么着？

高情商：他硬生生享受了前所未有的一年长假。
低情商：一年没找着工作。

上面这个故事告诉我们，放松心态不是完全摆烂，调节心理不是放弃挣扎，否则最终你也将成为一位享受长假的自由人！调整心态目的是在于减少不必要的焦虑，但自己的面试计划也要如常进行。那待业的小伙伴又该如何快速做技术复盘呢？和前面类似，先定位自身技术能力，接着根据自身所缺，按优先级制定一份复盘计划即可。

但千万要记住一点：复盘计划不是学习计划，相较于前一种的未离职人员，你没有那么多时间去做提升，因此复盘计划是围绕着你自身的技术在做准备，复盘的核心是：我目前会哪些技术？期望薪资的面试中，会问到哪些技术？问到什么程度？针对自身不足去准备即可。

这里额外说明一点：火候欠缺者应该适当降低期望。如果你目前的能力最多只能拿到15K，但你的期望薪资偏偏定在18K，此时距离18K还有好些个未掌握的技术需要学习，但目前已经没了工作，想要去学习还未掌握的技术时，你的时间扛不住这么消耗，所以最好的做法是适当降低期望薪资，最好降低到一个自己有把握的范围内。人要量力而行，千万不要打肿脸充胖子，否则就算接到了面试也很难通过。

如何高效地刷面试八股文

接着再说说，当制定好复盘计划后，如何基于复盘计划进行快速复盘呢？

其实这就没有秘诀了，老老实实去看面试八股文，八股文既然能有这么高的热度，绝不是偶然造成的！它们都是经过精心地整理、认真地撰写，最终才形成的面试题合集，这将是你快速复盘的最大助力。

刷面试题最快的方法不是死记硬背，而是尝试理解。以我的职业生涯为例，从工作以来，我也负责过许多场大大小小的面试，考察的求职者中不乏有很多“八股文选手”，我提出的诸多问题，他们都能给出准确的回答，不过其中至少有70%以上的选手，其回答让我感到异常僵硬，给人一种背书的感觉，回答的说法也比较官方化，缺乏自己的理解，简单来说就是回答不接地气。

所以！看八股文时一定要学会自己去理解，只有当你理解了才能在面试中谈出自己的看法，而不是死板地僵硬回答。毕竟八股文涵盖了诸多面试问题，而热度高的那些问题，绕来绕去就那么些，面试前的很多求职者基本上都看八股文，相同的问题别人这么回答，你也这么回答，最终只会导致你显得平平无奇。

虽说要试图理解面试八股文，但有时会碰到这种情况（举个形象的例子）。

问：为什么 AlCl3 是共价化合物？
答：金属元素与非金属元素形成的化合物通常是离子化合物，如NaCl、K2S等，但AlCl3是共价化合物。AlCl3的熔点192.4℃（2.5个大气压），沸点为177.8℃（沸点比熔点低是因为测定AlCl3熔点需加压，因而使得熔点升高）。AlCl3在熔融态、气态和非极性溶剂中均以二聚体Al2Cl6的形式存在。

这你能看懂吗？90%的人看了直摇头，看不懂，根本看不懂，其实我也看不懂，因为我是随手复制的。

但这种情况在刷题过程中又会碰到，有些面试题你可能压根不懂，无法理解时怎么办呢？最好的办法是选择跳过，毕竟连看都看不懂了，意味着这个题远超你目前的技术认知，所以不要浪费时间去试图理解它。但你又担心面试会被问到这个题咋办？实在担心的话也可以简单背一下答案，给自己简单留个印象和心理安慰。

同时，不要去试图找到一份十全十美的面试题，因为就算找到了也不一定适用，刷面试题也要多看多比对才行，多用搜索引擎搜索XXX面试题，例如：Spring面试题、Vue面试题……从搜索结果中挑几篇自己认为合适的，然后进行复盘，切记：不要拿着一份相同的八股文反复看！

相同的技术栈要多找几份面试题来刷，看第一篇的时候带着理解思维，看完第一篇，后面的速度就会比较快，把自己找的几份面试题都看了之后，再选一份自己认为最好的，接着去遮住答案，在心里模拟回答一下，回答后再仔细看一遍原文的答案，以此加深脑海中的印象。

通过这种方式刷题，好处如下。

第一遍以理解思维去看：能让你对相应知识点形成自己的认知。
后续针对相同技术多刷不同面试题：能纠正你前面的错误认知，增强你对知识点的记忆。
最后模拟回答再看解析：能联想面试场景回答，再次加深脑海里的印象。

虽然这样刷题的进度会慢点，但绝对是效果最好的，而且会比反复看同一份面试题要有趣得多，最主要的是能形成自我理解，而并非死记原文的官方回答。

对这一阶段进行简单总结：先放松心态做好心理准备 → 针对自己的已有技术找出不足 → 制定好复盘计划与路线 → 按计划开始有技巧地刷面试题。

四、降维打击才是求职的灵丹妙药

如今四处都在喊着XXX寒冬、XXX已死、XXX已凉……当大家听到、看到这些话时，难免内心会产生焦虑。身处技术行业的我们，又该如何摆脱这些困境呢？最后就再来聊一个求职必胜的小妙招，也就是：如何增强自己在面试中的核心竞争力！

其实具体方法在标题中就给出了，那就是依靠 “降维打击” 来做到鹤立鸡群。

道理很简单，现在很多岗位在招聘时，都处于狼多肉少的情况，如果你不能在众多面试者中脱颖而出，那就很难收到入职邀约，先来看个例子：

假设一个企业发布了招聘需求，总共来了五位应聘者面试，恰巧你也是其中之一，但你们五个候选者的技术水平都差不多，面试中的发挥也差异不大，这时企业会怎么挑选合适的人选呢？

这个时候就得看眼缘了，比如你因为面试时左脚先进门，所以不合适。另一个人因为嘴角有颗痣，所以也不合适。最终入职的人，也许就是一个面试官、HR看着更顺眼的人！这公平吗？不公平，但现实中有些情况下，的确如此。

所以，面对于上述那种场景，想要做到真正的求职必胜，就必须让自己的面试表现更为突出才行！具体该如何做呢？以我来举例子，场景如下：

现在有一个8K的初级招聘，目前有三位应届毕业生争得焦头烂额，都想自己拿到入职邀约。

此时我去面试后，并且极力表现出想加入这家公司，这时面试官会怎么选？通常情况下会选我，Why？因为对比其他三位候选人，我的经验、能力、面试表现绝对会亮眼一些，招聘和购物都遵循着同样的道理，也就是追求性价比，此时我的性价比更高，所以肯定是招聘方的不二人选。

从上面这则小故事中，希望诸位能明白一个道理：降维打击到底是什么意思？就是以超出对应岗位的能力去面试！

比如，你目前具备找18K工作的能力，但你偏偏去面15K的招聘，这会显得你额外突出，自然也能在众多候选者中脱颖而出。但反过来，如果目前只具备18K的能力，求职时也往18K的招聘上冲，最终结果也就是显得平平无奇，毕竟和你竞争的人都处于同一个水平。

但能面18K为啥要去拿15K？其实我的意思并非让大家降低自己的期望薪资，而是提高自己的技术水平。比如你目前的期望薪资是18K，那你就把能力提升到20K的水准，然后再去面18K的招聘，这才是我口中所谓的“降维打击”。这也是为什么我推荐大家提前准备面试的原因，充分准备和临时抱佛脚，两者之间相差甚大！

PS：上面所述的15K、18K、20K只是为了将技术能力具体化，实际求职过程中，15K、18K的技术能力可能大致相同，相同技术能力的人，到底是拿15K还是18K，要取决于对应求职者的工作履历，也存在一定的运气成分。

洞悉人事篇：HR 是如何在成百上千份简历中挑选候选者的？

前面一节聊了面试前如何技术准备，这节来说说求职路上必遇的角色：HR/人事，一次求职面试过程中，通常都会先与这个角色打交道。

人事这个角色分歧很大，有令人厌烦的尖酸刻薄者，有善于交际的亲和派，也有狐假虎威的二五仔，甚至有啥也不懂的毕业生。

在很多公司举行的匿名投票中，票选最让人讨厌的职位时，HR往往都是首当其冲的那个。

相对来说，HR是一个吃力不讨好的职位，需要很高的情商才能做得很好，否则很容易遭人嫌，对外让应聘者讨厌（态度不好），对内让领导嫌弃（招不到人）、让员工厌恶（克扣考勤），所以做好HR其实很难。

不过这里就不对HR的难处做过多描述了，下面重点谈一谈HR对求职途中的影响。

一、重新认识一下 HR

任何企业中都会有HR（Human Resource），翻译过来叫人力资源，但也习惯被称为人事。小一些的公司也许只会有1~2个人事专员，具备一定规模的企业则会组建人力资源部/人事部。其工作职责分为六大模块。

人力资源规划：根据公司业务发展需求，规划内部各部门岗位需求和人员招聘数量。
执行招聘计划：在各渠道发布招聘信息、负责应聘者的初次筛选、面试接待与HR面等。
组织内部培训：负责内部岗位技能、企业文化、新人入职等培训，督导培训计划的实施。
参与绩效管理：参与制定绩效方案、组织绩效实施、评估、反馈等工作，完善绩效体系。
核对员工考勤：核实员工的打卡、迟到、缺勤、旷工、请假、工牌、卫生等各类考勤情况。
处理劳动关系：处理入职、试用、转正、升职、请假、异动、劝退、裁员等劳动管理工作。

当然，并非所有公司的人事都具备处理上述所有工作的权利，小一些的公司也许老板会直接参与其中，或者规模较大的企业还会有行政部辅助，但组织架构完善的企业，基本上都会规划出人力资源部，上述职责将会统统放权给该部门，但这些与我们没有太大关系，重点把注意力放在第二条，这是作为求职者需要关注的。

那些千年不变的只招不聘岗

HR是求职路上的第一关，通常会负责应聘者的简历筛选，但先记住：有些HR并非真心招聘。这具体是怎么回事呢？

想要弄明白这个问题，就不得不先说清HR的绩效机制。KPI绩效考核制度是大部分企业中都存在的，一个员工绩效系数的高低，也将直接影响其工资收入，而人事部门同样涵盖在绩效考核的范围内，一般HR的绩效指标有如下几点。

成本控制率：对员工的工资、奖金、福利补贴等成本不能超出预算。
员工离职率：通常是指自己负责招入的新员工，需要控制离职率。
内部满意度：主要指内部员工是否对人事有不满意、投诉，出现则会影响绩效。
培训完成率：督办一场培训时，是否顺利完成、员工到场比例、员工满意度等。
招聘完成率：主要跟面试邀约数量、到公司应聘人数、新员工的入职人数等挂钩。
……

这里抛开其他无关的绩效指标不谈，重点看最后一条关于招聘类的绩效指标，其中面试邀约数、实际应聘数、新员工入职人数等都会影响HR的绩效，这一条也是专门负责招聘的HR，在绩效考核制定中，对绩效系数影响最大的一个指标，意味着该指标会直接影响某些公司的HR收入，因此市场上也有不少“非真心”的HR出现。

当你投递简历后，被对方邀请过去面试时，可能你只是她刷KPI的工具，对方发布这个招聘需求属于“只招不聘”，你的作用在于帮她完成当月的绩效指标，为什么有些HR会这么干呢？

其实经过前面的绩效分析后，相信大家不用我说也就明白了，也就是为了把自己的招聘完成率提高，拉高自己的绩效系数罢了。

PS：对于这点大家简单了解即可，虽然市场上有这类情况，但毕竟与整体情况对比，那也只是少数，所以不必太过在意，心里有谱就行。更多的招聘需求还是真心为了招人，而并非HR刷绩效的手段。

为什么大部分 HR 会比较热情？

相信大家见到的很多HR，在接待你时都比较热情，这是为什么呢？

一方面是出于礼貌和职业素养，而另一方面则有关她的利益，除开能够帮她提高绩效系数外，同时还有一些额外的好处：

因为有人过去面试可以帮她刷绩效，同时假设入职了，她有一定的奖金（这笔奖金不多），如果后续入职员工比较稳定，在厂里转正之后，又会得到一笔不小的奖金。

听了上述回答后，相信大家应该能够想明白下面这三个问题。

你的面试能给 HR 带来什么？
你的入职能给 HR 带来什么？
你的转正能给 HR 带来什么？

但她当时是在工厂做HR，负责工厂的招工。对于IT公司的HR来说，可能细节上会有所不同，但你的面试、入职、转正，多多少少都会给她带来一些好处或奖励。

OK，对于HR招聘的那些事就此打住，大家只要稍微对这些有了解就好了，毕竟只是为了让你更熟悉HR，更重要的是接下来的内容：技术行业的HR是如何筛选简历的呢？

二、技术行业的 HR 是如何筛选简历的？

想要了解技术行业的HR是如何筛选简历的，那得先明白一个道理：九成八以上的人事并不懂技术，但你投递简历后第一步就是人事做筛选。不知是否有人存在这种经历：

明明我简历上技术写得很牛逼，项目写得也很优秀，但为啥一投简历就没反应啊？

如果你有这个困扰，那很有可能是因为你的简历太丑了，或者太过花哨了，这容易遭到HR的排斥。毕竟她也不懂技术啊，当她打开你的简历之后，映入眼帘的就是排版不公正、样式特别丑、模板花里胡哨……问题时，可能她就是啪地一下，很快啊，就把简历关了，然后拖进回收站，整套动作一气呵成。

所以，牢记一点，你想要简历的通过率高一点，第一步应该至少保证足够整洁，不说要让人家眼前一亮，但至少别给人家留下负面印象，因为一个岗位往往有很多人投简历，多你一个不多，少你一个也不少，简历如果很丑的话，的确会影响简历通过率。

HR 筛选简历的流程

明白HR并不懂技术这个前提后，接着来聊聊HR筛选简历的流程，以及HR在不懂技术的情况下，她是如何筛选简历的、关注点又会放在哪儿。

先来说说筛选流程：

美好的一天，元气满满的HR坐到电脑桌前，打开了招聘平台……
随机点开一份投递的简历，简单看两眼快速扫描简历的整体信息。
如果简历整体信息满足需求，再花费8~15秒搜索简历中的关键指标。
浏览简历搜索到关键信息后，接着会对简历进行评估，合适的单独拎出来。
对于评估合格的简历，HR会花费1~3分钟仔细阅读，重点关注是否与招聘需求匹配。
简历经过仔细审阅后，各项条件都符合招聘需求，接着联系应聘者，发出面试邀约。

上述这个过程是“人肉式简历筛选”的过程，也是中小型企业会采用的方式。但国内一些大厂除外，它们往往具备完善的人力资源系统，内部会有招聘流程模块。

大厂的大致简历筛选流程如下：

简历首先被录入系统（从招聘渠道对接），简历会进入初审状态。
然后交给系统AI进行筛选，AI会快速过滤掉一批不合适的简历。
接着会从简历中快速提取关键指标、词汇，生成应聘者的个人画像（报表/图像）。
通过求职者的个人画像比对投递的岗位JD，判断求职者是否适合这个岗位。
匹配岗位JD的求职者，才会真正由系统交给HR进行最终评估，合适则会锁住简历。
……

对比前面“纯手工”筛选简历的方式，大厂这种使用程序介入处理的方式更为智能，尤其是应对大厂每天接到的海量简历，这种系统能极大程度上减轻HR的工作量。

而且要注意一点，大厂为了防止每天出现海量的重复简历，通常这类系统对简历都有冷却期，也就是当你的简历被pass过一次之后，需要等待一段时间后才能继续投递。在冷却期间内，就算多次反复投递也无法生效，系统在最开始就会自动过滤掉冷却期内的简历。

HR 在筛选简历时的关注点

前面简单了解简历筛选的流程后，下面说说HR在筛选简历时的关注点，这将直接影响到简历的通过率。只有当大家真正明白了HR的关注点之后，才能写出一份比较不错的简历，但本章不会过多阐述简历优化的内容，这些东西都是后话，本章旨在洞悉人事。

HR在上述不同的环节中，对简历信息的关注是不同的，如果你简历在任一环节有问题，都有可能影响简历的通过率。

先来聊聊HR刚打开简历的第一眼会关注什么呢。简历整洁性、应聘者的基本信息，如果简历上的字七扭八歪或者比较“辣眼睛”，这是很有可能被淘汰的，毕竟HR大多数是女性，女性通常喜美厌丑，简历的美观整洁程度确实会成为筛选的第一原则。

不过正常套用简历模板的情况下，基本不会由于外观被pass，所以下面就来聊聊HR会关注哪些基本信息。学历、年龄、工作年限，看这些信息是因为能够通过这些信息做最快筛选，学历、工作年限不合格者会直接pass，同时看年龄是为了核实简历真实性，可以根据年龄来简单推断学历、工作年限是否真实。

通过前面的快速筛选阶段后，接着HR会对满足条件的简历进行快速过滤，这时的关注点会在期望薪资、上家公司信息与业务、以及历史工作履历上，第一点就不必我多说了，从这点能精准地得知是否能开起你想要的工资，如果给不到你想要的期望薪资，也会直接pass。

正是由于这点原因，所以很多人会在简历写上“薪资面议”，要不要写面议呢？简历优化篇再细聊。

除开期望薪资外，还会去瞅你的工作经历，主要是看你任职的上家公司，在此期间，会关注上家规模、你的岗位以及公司业务性质，这三点会决定你与公司的匹配度。

如果你上家公司是500强、国内/外大厂，这无疑是你很大的加分项。

看了你上家公司的规模后，接着会看一下你在上家公司的岗位，是否与目前招聘的岗位匹配，对于匹配度高的应聘者会优先选择，比如招项目经理，你有过项目经理的履历，无疑你会更合适一些。

最后，HR还会分析你的上家，与目前公司的业务匹配度，如果是同一业务类型的项目，这绝对将成为大大滴加分项。比如：

一个做金融性质的企业招聘，那最希望的是：招到一个之前具有金融经验的人。毕竟有经验代表上手速度快，如果招了一个之前专门写管理系统的新人进来，先不论技术如何，就光金融领域内的一堆业务概念，理解起来也需要不短的时间。

分析完你上家公司的情况后，接着会看看你的工作生涯，也就是你历史从业经历。如果你频繁地在不同公司内横跳，这无疑是会被pass的类型。例如你在每家公司待的平均工龄是一年，那HR心里会想：“我假设把你招进来了，一年之后你业务熟了，活干得也越来越快了，是不是很有几率也会跑路呢？”

企业用人的第一原则是追求稳定，谁都不希望自己的企业内招到一个不稳定的人，所以具备“不稳定因素”的应聘者会直接在简历筛选中pass。

经过上述两轮筛选后，HR手中留下的简历，既满足公司招聘的硬性条件，同时又贴合公司的业务线、岗位需求，所以接下来HR会做最终的评选阶段，也就是看应聘者的“个人技术栈与项目经历”。诸多小伙伴看到这里就疑惑了：你前面不是说HR不懂技术吗？！？？为啥HR会去看个人技术栈啊？

想要弄懂此问题，就得先知道：HR发布的招聘需求怎么来的？无非就两个方式。

来源一：用人部门写的。需要招聘一个什么能力的人，最清楚的莫过于用人部门本身。当部门缺人时，尤其存在技术岗位空缺时，HR并不清楚要招一个什么技术的人进来啊，所以大部分公司会由用人部门本身去写招聘需求，然后交给HR对外发布。

来源二：用人部门给的关键字去复制同行的。不是所有公司的技术部门，都会亲自给HR写招聘需求，毕竟大部分“技术人”的文笔水平欠佳，你叫我形容一下招什么人可以，但叫我写出标准的招聘需求就有些为难，通常这种情况下，用人部门只会给出一些技术栈关键字。但HR看不懂这些技术栈啊，为此就直接去参考同行的招聘，将对应的招聘关键字套入其中，从而形成了自己的招聘需求。

但无论HR是通过哪种方式弄到的招聘需求，但最终手里都会有一份技术关键字的清单，虽然HR不能直接筛选出技术达标的简历，但起码也能大概淘汰一些技术不达标的简历。

所以，在最后这个筛选阶段中，HR会通过用人部门给出的关键字，对简历进行精准匹配，尽量把简历的精准度提高（最后这个详细评审阶段中，有些专业的HR会详细阅读你的简历，从而判断你与当前岗位到底合不合适）。

HR 也许不是最终决断者

经过前面HR的一系列筛选后，你的简历经过千辛万苦，终于通过了重重难关，此时屏幕对面的你，也许会歪嘴一笑：“嘿，就你这小小HR，能难住我？”

但此刻别高兴得太早，因为HR只是你简历的第一关，我们都懂HR不会技术这个道理，相信招聘的公司也不会不懂，所以当HR筛选出一批相对满意的简历后，接着会递给懂技术的用人部门！

纳尼？技术面试官这时就出场了？Yes，越专业、规模越大的企业招聘，技术面试官参与简历筛选的几率也就越大。身为求职方的我们，不想去参加一场无意义的面试，而作为招聘方的企业同样如此，与其喊很多人过来面试，不如从中再挑选出一批优秀者发出邀约，这样也能极大程度上减少多场不必要的面试。

既然技术面试官会参与简历筛选，而同为技术人的他，在看简历时会关注什么呢？

现在幻想你是一位面试官，现在手里有份简历，你站在技术人的角度出发，首先会关注什么？

毫无疑问，必然是关注对方的技术，当HR给坐在工位上的你，递来一份简历时，场景如下：

（用漫不经心的目光一瞥，稍后嘴角上扬邪魅一笑）：嘿，让我看看这小子技术怎么样！

技术面试官在看简历时，并不会去关注你年龄多大、学历多高，更看重的是你的技术能力，也正因他与你同为技术人，所以对技术的考查会更加专业，看简历时大多数抱着这三个想法。

①先看看找工作的这小子，他会的我会不会，懂得有没有我多～
②这小子会得不少，再看看他懂得有多深！
③这小子技术不错，让我看看他做过什么项目，有没有我手上的项目牛～

综上，技术面试官在筛选简历时，通常会看技术广度、深度，以及项目经验这三点，所以想要通过技术面试官的简历筛选，这三点上面要下功夫，既不能太装，也不能显得太弱，毕竟太装了容易面试遭到惨打，太弱了入不了对方法眼。

这三点具体该如何写，也会在后面《简历优化篇》中详细阐述，这篇只了解大概的简历筛选流程。

最后记住一点：简历是第一关，也是最重要的一关！当技术面试官看完你的简历后，通知人事给你发起面试邀约，这意味着你的简历至少得到了他的认可，你要做的就是在面试中发挥出简历上的水平，薪资能在对方接受的范围之内时，你拿到Offer的几率八九就不离十了（除开有比你更合适的人选，或你的性格、价值观不合适外）。

三、公司招聘时的意中人是怎样的？

截至目前，大家认真阅读完前面的内容之后，相信对HR、技术面试官如何筛选简历的流程，已经熟透于心了。最后这个阶段，来聊聊企业招聘时，到底想招到什么样的人。

众所周知的一点，现如今找工作越来越难，当准备开启一场面试之旅时，从自信到自闭的人不在少数，似乎现在找工作变得很困难了，是不？你这么想，实则企业也是这样想的，HR也是这么想的。

此时你小小的脑袋应该有着大大的疑惑：“找工作的人这么多，为什么企业招人还难啊？”

其实更为具体一点来说，是企业想招到一个满意的人难，如今市场的技术人才鱼龙混杂，会吹技术差的、技术强不会吹的、没经验硬包装的、技术好又会吹但脾气差的……各色各样的求职者比比皆是，这就导致了企业想要招到“意中人”的难度大大提升，那企业眼中的“意中人”长啥样呢？

身披黄金甲，脚踏七彩云……

呸，走错片场了，通常企业招聘时真正的意中人要求如下。

① 能干活：掌握的技术能力可以满足公司业务的基本需求。

② 上手快：做过与公司业务接近的项目，熟悉公司所用的技术栈，要花费的培养成本低。

③ 够稳定：入职后能够持续给公司贡献价值，不会入职一段时间后就提桶跑路。

④ 高性价比：除开能完全与空缺岗位相匹配外，能干活的前提下还“不贵”。

⑤ 潜力高：具备不错的学习能力，能随着公司业务的不断发展持续成长。

活好价廉够稳定，这是企业眼中的意中人，是不是与大家求职时的“钱多事少离家近”很像？理想很丰满，现实却很骨感，求职往往很难找到一份“钱多事少离家近”的工作，最终结局大多以“凑合着干”结尾，而企业招聘时亦是如此，最终也只能满足于“又不是不能用”这个水准。

我们聊这个话题有何意义呢？很简单，我们要做的就是：把自己变成别人喜欢的样子。企业招聘想要上手快的，我们投简历时，就可以专门去找和上家公司业务接近的岗位。企业想要高性价比的，那就执行之前聊到的降维打击方案……总之，尽量去迎合企业的用人需求，呈现给企业一种 “我是最合适” 的感觉即可。

最后也对本章的简历筛选流程做个简单总结，不多废话了，上个图就一清二楚，如下：

简历优化篇（上）：怎样撰写一份与自身情况最匹配的简历？

简历优化，一个十分美妙的词汇，也是很多人在苦苦追求的“求职秘方”，这也是许多标题党、网课惯用的词汇。不知大家是否见过以下这些标题：

简历到底怎么写，才能让面试邀约的电话被打到爆？
如何优化才能打造一份让HR为之倾心的高光简历？
最近面试接到手软，原来全靠这样去做简历优化！
如何有效打造出一份杀手级的王牌简历！
……

大家首次看到这些标题时，当时一定是两眼放光，但当你点击详细了解之后，绝对是期待有多高、失望就有多大，因为这类标题的背后，往往都是一些软文引流、营销广告……相信经历过的小伙伴肯定深有体会！

那简历到底有没有优化技巧呢？其实有，优化简历能为你接到更多的面试，但打铁还需自身硬，它并不能成为你拿下Offer的王牌手段，属于锦上添花。

事先声明：简历优化属于求职途中比较重要的阶段，不会三言两语草草结尾，而是尽量做到事无巨细，所以篇幅较长，分为了上下两篇，大家阅读时请保持耐心。

一、个人简历的基本原则与要素

撰写、优化简历时，首先要记住：不存在最好的简历！没有哪份简历能让所有HR都满意，就好像一个人再怎么完美，也不可能受到所有人的喜欢。为此，在写简历时不要追求所谓的最好，写出一份适合自己实际情况的简历才最重要。

同时，往往诸多小伙伴在写简历前，喜欢去从网上找写好的简历模板、找朋友要简历，这种做法能理解，毕竟自己写简历时脑子难免有些短路，不知从何下手，所以想要参考一些相关的简历，尝试从中得到启发。

参考他人简历确实是一种不错的方法，但参考不是照搬，千万不能找到一份简历后，把里面的名字等各类信息一改，大部分内容直接照搬，最后就形成了自己的个人简历，显然这并不合适。

虽然照搬的效率最高，但每个人的技术掌握度、经历都有所差异，所以大家的简历也要根据自身情况进行调整，结合之前的知识树以及自我画像，多花点时间认真去写，才能得到一份最符合自己的简历。

但写简历时怎么根据个人情况去写呢？下面先一起聊聊写简历时的基本要素。

写简历时最基本的第一要素，是保证简历的排版工整性。在上章中曾聊到过，如果简历不够工整，HR打开后可能会直接关掉。比如这样的简历：

大家以正常人的目光来看，简历信息七扭八歪、中英文混乱、字体忽大忽小……如果你每天都会收到几十份简历，突然打开了一份这样的简历，会怎么做？相信你也会关掉它，毕竟一眼扫过去连信息都分辨不清，更别说美观度了，所以简历的第一要素就是排版工整。

排版工整不仅是上下两行要对齐，而且最好也不要留白，留白会很别扭，并拉长简历篇幅，如下反例：

尤其是上面留白，但下面铺满时，看起来的感觉会更加不协调。最好的方式是多行归并为单行，以平铺的方式撰写基本信息（上述案例中，单行3~4个信息左右）。

除开信息排版工整外，大家在选用简历模板时，别选太花哨的，颜色尽量单调，一份简历中不要超过三种，并且样式也要足够清晰，简历布局最好是从上到下，这样才方便HR阅读。

颜色单调、样式简洁、布局从上到下，这三点要素要遵守。不要试图用花哨的颜色、炫酷的样式、另类的布局来吸引HR注意，更多时候反而起到反作用！我看过许多份求职简历，投简历的人才们，可谓是八仙过海各显神通，举几个典型的反例。

有个应届生的简历中，字体用了渐变色，持续盯个十多秒连眼睛都花了。
还有个简历是用PPT来做的，刚点开就是咔的一下，整出一个开场动画……
还有许多简历布局花哨，左右布局、前面左右，后面上下布局，阅读起来特别麻烦。

这样做能引起筛选简历的人注意吗？答案是绝对行，比如我至今都记得一些“人才”的简历，但这样“另类吸引力”，结果适得其反，影响阅读效率的简历，大多数都会被直接pass。

除开前面几点外，还要注意一点：字体大小、间距、行距合适。如果简历上的字体大小跟蚂蚁一样，并且前字紧挨后字，上行紧贴下行时，这同样会十分影响阅读体验，当打开这样的简历后，想要看清还得先掏出老花镜。

同时，作为技术人的我们，也要学会省略不必要的信息，比如身高、体重、民族、户籍、是否婚配等，这些信息有必要写吗？

其实没有必要，因为这些不是技术行业的招聘要求，又不是去面服装模特，你人帅气质佳也好、貌美大长腿也罢，都跟你去面技术岗无关，所以尽量把这些无关信息省掉，没有人愿意去花时间，看一些与自己需求无关的内容。

同时，对简历的篇幅也要稍加控制，最好是2~3页左右，没人愿意浪费时间看长篇大论，为此，必须要用足够短的篇幅吸引眼球！

我见过的部分简历中，有些求职者恨不得把整个人生经历中的每个细节写上去，最夸张的简历高达十多页。说句公道话，先不说这么长的简历HR有没有耐心看，就算它通过了简历筛选，去面试打印简历时，光打印费就多出五六倍，不知情的人还以为是个作家要出本书呢。

OK，前面把写简历时一些要注意的基本要素就讲明了，最后给一个通用的简历顺序。

①基本信息：能第一时间让HR了解到你的基本情况。
②求职意向：说明到岗时间、期望薪资、工作性质等需求。
③教育经历：额外明显地把你自己的教育背景体现出来。
④工作经历：可以十分清晰地看到你的职业工作生涯。
⑤专业技能：对于你的专业能力、水平、技术的良好体现。
⑥项目经历：自己接手过、负责过的项目可以依次罗列出来。
⑦个人荣誉：这点有没有都行，如果有特别值得说明的可以单独列出来。
⑧自我评价：自我给自我的总结，但很多情况下大家都套模板（这点最后细聊）。

简历会出现的几个大项如上，当你写简历时，没有特殊情况，就可以按照上面的优先级撰写，因为这个顺序正好符合HR筛选简历的顺序。当你的简历能让HR看得更舒心时，也自然会给HR留下一个不错的印象（前提是你能够满足人家招聘的要求）。

最后对这些撰写简历的基本要素稍加提炼，给出一个小的总结。

简历信息的排版一定要工整。
选择的简历模板不要太花哨。
简历色调尽量保持单调或统一。
简历信息的布局选择从上到下。
简历中的字体大小、间距、行距要合适。
简历的篇幅最好控制在2~3页左右。
按照HR筛选的流程做好简历排序。

一份简历遵守上述各个要素，基本上能够得到一个初稿，为啥是初稿呢？

因为这样写出来的简历属于通用版，后续还需要根据自身的情况，对初稿进行适当调整，从而显得更加合理，也能让自己的简历做到扬长避短！但往往许多小伙伴写简历时，写到这里就止步了，原因在于不清楚如何继续优化，那接下来就一起聊聊这个话题吧。

二、如何优化出最适合自己的简历？

经过前面的一些叨叨絮絮，现在终于来到了大家最感兴趣的话题，也就是简历优化。但这里做个声明，下面确实会教大家一些简历优化的技巧，不过技巧永远只是技巧，可以提高简历的通过率，但还是那句话：打铁必须自身硬，如果本身自己的技术就不强，履历很一般，那再好的技巧也是无力回天。

简历优化这个话题比较大，本节先说通用的优化技巧，也就是任何人都可以用的优化手段；在下节中再聊大家比较关心的内容，即如何制造亮点、如何描述技术栈、怎样阐述项目经验等内容。

重视简历上的优先级

“优先级”这个概念，在《技术突击篇》中曾讲到过，对于自己需要提升/复盘的技术栈，首先应该按优先级进行排序，接着再制定相应的学习路线，这样才能确保自己准备的内容对目前最有利。

而任何事情都分轻重缓急，简历上的信息也不例外。简历各个信息，也应该分清先后顺序，例如：

①自我评价
②兴趣爱好
③所获荣誉
④基本信息
⑤项目经历
⑥工作经验
……

以上述这个顺序撰写简历行不行？No，如果你敢这样写简历，HR就敢第一个pass你，为什么？因为HR筛选简历时，大半天都找不到她要的信息在哪个位置，每次寻找一个信息都需要做“全表扫描”，所以遇到这样的简历时，第一时间会被pass。

这也是为何强调顺序的原因，方便HR就是方便自己，所以一份基本的简历应该分清主次，哪些内容写前面，哪些内容写后面，心里要有个底。前面第一阶段中已经给了一个通用排序，这里就不重复啰嗦了，此处强调优先级的目的，主要是为了在后面讲优化技巧时，能帮助大家理解为什么要这样优化。

基本信息的优化

简历简历，意味着简历该简，不应该过多叙述的一些内容，在简历上就要省去。这点在前面就已提及，但一个技术人的求职简历，基本信息这栏要留下哪些内容呢？

姓名：起码能够让人家知道你叫啥，这点必须在。
性别：这点写不写都无所谓，但一般邀约中都会有先生/女士这类称呼，所以写上最好。
年龄：有些招聘方会卡年龄，例如大厂，所以超过30岁的小伙伴可以省略。
工作年限：招聘方一般都有工作经验要求，这点必须在，突出匹配度。
电话：这点不做过多解释，毕竟人家面试邀约、电话面试、入职邀约等都可能直接打电话。
邮箱：这点大家也都懂，有些公司发面试邀约、入职Offer，都会直接以邮件形式通知。
学历：敲门砖，大多数HR第一时间关注的信息中，就包含了这项内容，必须写。

这里把工作年限、学历单独拎出来讲一下，我知许多人喜欢包装年限，尤其是培训出身的小伙伴。

毕竟在之前的IT市场中，工作年限越高就意味着薪资越高，包括现在的市场也依旧遵守这个潜规则，所以包装年限的人不在少数。但记住包装的经验要经得起推敲，比如：

年龄22岁，学历专科，工作经验四年。

这显然并不合理，正常的专科毕业就20岁了，你目前22岁，哪儿来的四年工作经验？所以这类经不起推敲的简历，必然是HR第一批淘汰的目标。为此，包装可以，但请一定要合理！

也许这时有一些特殊的小伙伴又要说了：“我情况不一样啊，专科是自考/成考/函授等方式拿到的，我18岁就做程序员了，按理来说的的确确有四年工作经验呀！”

对于这类特殊群体而言，如果学历并不是统招全日制，就只能说明自身情况，这样可以避免你在第一轮筛选中被淘汰（或者你简历上的年龄也包装一下，但入职时如何解释就看个人发挥了）。

那把年龄从简历上删了可以吗？不行，大部分HR在看不到年龄的情况下，因为她不清楚你的具体情况，只会感觉你的简历经不起推敲，所以你的简历依旧会被淘汰。

PS：我给出的基本信息这一栏，似乎没写毕业院校是不？很多人会习惯性地把这个写上，其实写的意义不大，毕竟后面还会有教育经历这一栏，里面会包含毕业院校的，所以你在基本信息中省掉也无大碍。

最后，简历要不要放照片呢？贴照片这点本身没有错，但最好不要贴照片，要贴的话也别贴生活照，而是从专业照相馆中拍出来的证件照。

除非你拥有例如彭于晏、胡歌……以及我这样的颜值，这时你贴什么类型的照片都没关系，而且还能给你的简历加分，毕竟人都是追求美的动物，更何况许多HR都是女孩子呢。

当然，还有一种人特别适合贴照片，即看起来就很强的大佬，看起来很强是啥意思呢？聪明绝顶的大佬！说人话就是拥有地中海发型的大佬，当你贴上一张这样的照片时，整个简历无需过多的描述，懂行的人一眼就能看出你是大牛，发型就是技术的最好证明！

小总结：对于基本信息的优化，主要是省去不必要的信息，能够经得起推敲，以及方便HR阅读即可。

求职意向的优化

求职意向这一栏，有些小伙伴会下意识忽略它，或者就简单写个目标岗位，但其实，这栏最好还是在简历上单独列出来，并且优先级排第二最佳！

在我看过的简历中，求职意向通常都写成这样：

先来聊聊上面的到岗时间，许多人喜欢写随时到岗，其实这种做法并不太好，虽然HR面的时候，招聘方会再次主动询问到岗时间，但这里最好也写成“一周内到岗”。

这样做的好处是：当你收到Offer之后，可以谈出一周左右的缓冲期，在这个时间内可以再去面其他公司，拿到多个Offer后再综合考虑选择谁！身为求职者的我们，也应该具备选择的权利，把主动权牢牢掌握在自己的手中。

同时求职意向这栏中，如果自己目前还在职，属于骑驴找马者的话，也应适当描述自己的现状，例如：

写出自己的现状，这方便HR筛选时，判断你是否合适，如果无法接受较长的到岗时间，就自然不会邀请你去面试。同时也方便了自己，因为如果不写明这点，当你面试通过拿Offer时，对方发现你无法在短时间内与上家交接，很可能就会放弃你重新招聘，最终导致你这场面试相当于白搞。

接下来，对期望薪资这点再展开聊聊，这点不用想，至少80%+的人都喜欢写“面议”，那到底该不该写“面议”呢？

这其实要分情况来看，写“面议”的好处在于能接到更多的面试，毕竟招聘方不清楚你的期望薪资，所以在你简历还不错的情况下，都会对你发出面试邀约。

这样听起来似乎写“面议”很好对不对？但并非如此，你把具体的期望薪资写上会更好，Why？说到这里很多人犯迷糊了，为什么面试多了还不好啊？道理很简单，虽然写上期望薪资后面试会变少，但这些面试邀约将会更精准！

更加精准的含义是指：既然招聘方看完了你的期望薪资，还依旧对你发出面试邀约，这代表对方可以接受你的报价！也就是只要你能力达标，对方就可以给你满意的薪资，所以，虽然表面看起来面试少了，但得到的效果反而会更佳。

那到底要不要写上期望薪资呢？前面说过要因人而异，如果你目前处于待业状态，迫切想找到一个新工作，此时简历写“面议”的效果比较好，毕竟这样面试机会更多。

但如果你目前还在职，属于骑驴找马这类人，写出具体薪资会更合适，既能够减少很多不必要的面试（毕竟面试需要请假或者抽时间），同时还能让自己的面试邀约更精准。

最后，还有一类人就算离职了，也适合写具体薪资，就是对自己的技术较为自信，或者技术能力比较出色，同时也不急着找到一份新工作的人，毕竟你都不急了，自然面试更精准更好一些。

如果你决定写期望薪资，尽量写成范围值，并且比真实的期望薪资，多出一点点，这样有利于后续的谈薪。

小总结：对于求职意向的优化，主要针对到岗时间、目前现状、期望薪资这三点，小伙伴可以根据实际情况来做优化调整。

教育经历的优化

教育经历这玩意儿呢，很多小伙伴都喜欢放在第二栏，重点突出自己的教育背景，HR打开简历之后，第一眼就能瞅着，把它放在这里真的合适吗？也要因人而异，比如这种情况：

合适吗？不合适，因为专科学历并非是一种优势，或者说并不是一个亮点，所以对于专科、双非本或者非统招学历者，我的建议是放到后面几栏去。

什么样的人适合把教育经历放在第二栏呢？三类人：

①具备国内985/211名校背景，例如清华大学、北京大学、复旦大学等；
②具备高学历，例如硕士研究生学位、博士研究生学位等；
③具备海外名校的留学经历，如英国剑桥大学、美国哈佛大学等。

符合这三类标准的小伙伴，就可以把教育经历放在第二栏这个显眼的位置，毕竟这属于你的优势，也是你本身的亮点之一，不仅要把位置靠前，还可以重点把这块区域的字体加粗（虽然有点刻意，但不免是一种引起HR注意力的手段）。

PS：走校招路线的应届生，不管院校背景如何，都可以把教育经历放在第二栏。

小总结：对于教育经历的优化，主要强调了在简历中的优先级，什么人才适合放在第二栏。

工作经历的优化

工作经历这一栏，相信参考过一些简历的小伙伴，应该熟悉其通用模板，如下：

先写任职时间、公司名称、所在部门、担任职务这四项，下面的子栏中，则详细写出自己的工作职责，将自己的从业经验按公司划分，分别套入其中之后，能够清晰反映出自己的工作经历，但这里面有三个小技巧要说一下。

第一个技巧，工作经历以倒序的形式描述。有些人写工作经验时，喜欢根据从业时间线从早写到如今，但这种方式有点不好就在于：无法将上家第一时间呈现给HR。所以最好以倒序的手法描述工作经历，也就是最近的一家公司放最前面，因为HR看工作经验这一栏时，重点会关注你的上家公司。

第二个技巧，如果存在多段比较短的工作经历，可以合并成一份工作经验。虽然这样做听起来不地道，但却是求职途中惯用的伎俩，毕竟上章聊过，HR除开关注上家公司外，还会关注你在每家公司的任职时间，如果每家公司的任职时间都不长，说明你是个十分不稳定的人，很有可能由于此原因造成简历被淘汰（但多段工作经验合成一段时，最好是将之前的工作经验合并，如果是最近的一两家公司，是可以通过社保缴纳情况查出来的，所以合并经历时也要视情况而定）。

第三个技巧，适当控制工作经历的篇幅。工作年限较长的小伙伴，可能待过很多家公司，如果每段经历都描述得很详细，一方面自己很难回忆起来，另一方面也会大幅度拉长篇幅。为此，如果年限比较长，那把最近两家公司的工作职责写细即可，其他公司的经历可以略写（如上图中的第三段工作经历）。

OK，掌握上述三个技巧后，接着再说说另外两个比较重要的优化手段，但聊之前得先认识项目中的不同角色，我不知大家的简历，是否属于这样的情况，以Java为例：

求职意向：Java开发工程师。
第一份工作担任的岗位：Java开发工程师。
第二份工作担任的岗位：Java开发工程师。
第三份工作担任的岗位：Java开发工程师。
……

虽然我没见过诸位的简历，但我相信简历类似这种情况的小伙伴有很多，求职意向也好，还是工作履历也罢，所有职位都写XXX工程师，首先声明：其实这样写并没有问题，但也可以做得更好，怎么做呢？

先聊聊项目中的不同角色，通常项目中都会分为三类人。

普通成员：负责项目中边角业务的相关工作，例如开发、文档撰写、测试……
核心骨干：承担项目中核心业务功能的处理工作。
项目主管：作为项目的负责人，主导项目进度的正常推进，参与产品设计、规划等工作。

任何技术团队都有这三类角色，初中级水平的技术人一般站在成员梯队，中高级水平的技术人通常站在骨干梯队，而高级/资深水平的人，往往站在主管梯队，这也是业内的一种潜规则，能力越强的人必然职位越高，因此你可以借助这些去优化工作经历，例如：

第一份工作：XXX开发工程师。
第二份工作：XXX主程、XXX核心开发。
第三份工作：项目负责人、项目经理、技术总监、XXX架构师。

当然，我上面只是举例说明，这么干的好处在哪儿呢？能让HR看到你的职位在随着工作不断上升，也就是你的履历呈现上升趋势，而不是干了N年的“基层杂役”，从而制造一定的优势。

看到这里许多人又来了疑惑：“可是我的项目就只有三个人啊，项目很小怎么办？”其实这是好事，Why？你想想，既然你这个项目只有三个人，那你属不属于项目的核心开发？是不是项目的主程？答案当然是的，所以请放心大胆地写在工作经历上，别再写XXX工程师了，直接写XXX主程或XXX核心开发工程师。

当然，如果你这个项目只有你一个人负责的话，那这更是天大的好事啊，信我的，直接写项目负责人、项目经理，在HR筛选你简历的时候，绝对能让她高看一眼。就事论事，这撒谎了吗？显然没有，只是把事实换了一种手法论述罢了，但最终呈现的结果却完全不同。

注意：当你在简历上写下XXX核心、主程、负责人时，也一定要做好相关的准备，如何准备呢？相信你在以往公司一定有上级吧？你就把他的工作职责写成你的就行，毕竟任何一家企业在招聘时，不可能详细了解到你在以往公司的内部情况，所以请把你那颗忐忑不安的心放在肚子里。

最后，对于工作职责如何写呢？如下：

参与了XXX系统的研发工作，主要负责AAA、BBB、CCC...工作；
与某某部门的XX成员进行对接，协助其完成MMM、NNN、ZZZ.....工作；
负责项目的aaa、bbb、ccc....等工作，基于XXX完成某某工作；
……

看着上面这些用语，有没有一种熟悉的感觉？相信大部分人都是这样写的，看着似乎没有大毛病，但没有问题就是最大的问题，这样去写能否突出你的优势？显然不能，你与其他人对比，同样平平无奇，没有任何亮点存在，那究竟该如何写呢？比如：

参与系统重构工作，解决了长期存在的代码臃肿问题，极大程度上提升了项目的拓展性；
负责主导项目中XX模块的优化工作，解决了XXX延迟问题，成功将响应速度提升200%；
与XX部门携手攻克性能问题，解决了XX时间段的并发问题，自此项目的吞吐量提升四倍；
……

对比前面常规的通用写法，后面这种手法描看着是不是更有冲击力？至少技术面试官在筛选你简历时，他肯定对你这些工作中，如何解决问题的具体手段额外感兴趣，因此对比前面那种普通写法的求职者来说，你的简历将会更有竞争力。

这种阐述手法，也被称之为**STAR法则**，也就是在形容一项工作时：

先说执行此项工作的情景（Situation）
接着再说本次工作的任务（Task）
然后再说本项工作的行动过程（Action）
最后再说此项工作落实后取得的结果（Result）

大家在描述工作职责时，尽量摆脱传统简历模板中的描述手法即可，多运用这种所谓的STAR法则来套入就行。

最后，对于个人的工作职责来说，有两类人可以适当做出其他调整。

①技术管理：可以写明自己的管理规模，再写出自己带团队的成果等。
②技术牛人：写出实际工作收益，如在职期间解决了大流量、高并发（亿级流量、百万并发）。

小总结：对于工作经历的优化技巧不算少，首先说了描述工作经历时的三个小技巧，接着讲明白了项目中的不同角色，最后又聊到工作职责该如何去写。写工作经历时要多运用前面提到的原则、技巧，尽可能地提升“简历的竞争力”。

简历优化篇（下）：如何美化专业技能与打造项目技术亮点？

在《简历优化上篇》中，我们已经打造了一份“基本”的简历，但对于求职的技术人而言并不够，毕竟技术行业的简历，最关键的还是专业技能的表达，以及项目经验的描述。为此，本章中会详细讲到这些内容：

怎样写专业技能才能显得不一样？
如何去打造项目经验中的亮点呢？
怎么写简历上的自我评价才诚恳？
针对不同的JD该如何微调简历？

现在就不再多说废话啦，让我们直接开始吧！

一、怎样写好简历上的专业技能

作为技术从业者的我们，在简历上表露自身的技术能力，这自然是必不可少的一项，毕竟这可是咱们吃饭的看家本领！那在简历上描述个人技术时，到底是该吹牛呢，还是谦虚啊？吹牛怕被面试官吊打，谦虚又怕别人看不上，这可怎么办？没关系，下面我们就逐步聊聊简历的专业技能该如何写。

遵循六条基本原则

在描述简历上的专业技能时，首先得遵循下述六条原则：

描述技术栈形容的词汇需保持一致；
各项标点符号要统一（包括符号的输入法）；
包含英文的技术关键字，遵循驼峰命名法；
对技术按属性分类分项，条条罗列更清晰；
对掌握的技术按热度、掌握度排序；
“精通”要慎用，要确定自己能驾驭再用。

接下来会先展开讲讲这六条原则，然后再讲解如何对其进行优化，从而突出自己的技术优势。

第一条，形容技术的词汇要统一。这是指对于所有技术的掌握程度，应该使用相同性质的形容词汇进行描述。例如，最常用、也是最经典的一组形容词汇：了解、熟悉、熟练掌握、精通，这分别代表技术的四个掌握层次。简历上描述技术能力时，通常要使用同一组词去描述，不能出现下述这种情况：

熟悉 XXX、专注 XXX、精通 XXX、善于 XXX……

虽然上述这种用不同表达词的描述手法也可以，但最好还是用同一性质的形容词汇（至少看起来不要脱离一个词系），这样能直接把你对技术的掌握程度反馈给面试官，能让面试官清楚你对各项技术的掌握度。

第二条，标点符号统一。主要指中英符号一致、结尾符号一致，这是为了保证简历的美观程度。毕竟中、英模式下的各个符号，相对都有所差异，如果不统一的情况下，显然会影响简历的整洁性，例如：

这样的简历看上去有些潦草感，HR筛选简历时，也会注重整洁性问题的。为此，在描述专业技能时，一定要统一标点符号，如：所有符号都为中文符号，每一项都以。句号结尾。

第三条，英文单词的开头字母大写，不同单词间遵循驼峰命名法。作为IT开发人员，掌握的专业技能中，难免会有许多技术关键字是英文，因此要注意这些关键字的大小写。以Java为例，SpringMVC不能写成springmvc、SPRINGMVC、sPrINgMvC等形式，毕竟这样写严重影响美感，并且还显得自身不够专业（同时单词也不能打错，字母顺序也不能打错，注意多加检查）。

第四条，对技术按属性分类分项。有些小伙伴为了图方便，描述专业技能时会将其写成一段话。但其实要想让简历更直观、更便于阅读，专业技能最好分成多项去描述。不过分项时要注意，最好按属性做分类，而不是随意罗列。

以全栈开发举例，假设通过如下方式描述：

精通 Nginx、Vue、CSS、Spring、MQ、JVM、React、gRPC……

你觉得合理吗？并不合理，毕竟这些技术都不属一个领域！最好的做法是按照属性的不同，将每个属性单开一项进行描述，如前端分一项、Java 分一项、中间件分一项……

第五条，技术栈按热度、掌握度排序。面试官看专业技能这一栏的目的是啥？想要看出你会什么，并判断你与空缺岗位所需的技术栈是否匹配。为此，在写专业技能时，一定要按技术热度进行排序，热度越高代表需求更高，匹配度自然也越高，因此将热度高的技术栈放在前面，更便于招聘方“检索”信息。除开热度外，也可以适当地将自己比较擅长的技术放前面，比如“精通”的优先级应该要高于“了解”。

第六条，“精通”要慎用！ 很多人在写专业技能时，都存在一个疑惑：“我这项技术到底是写了解，还是熟悉、熟练掌握、精通呢？”大家很难把握这个度，因此往往会遵循下面这个原则：

听过写了解，学过写熟悉，用过写熟练掌握，研究过底层写精通。

这样做有没有问题呢？其实前三项问题不大，但“精通”这个词要慎用！因为只要你敢写“精通”，那后果绝对是会引来面试官的狂轰滥炸。为此，如果你对某项技术有绝对自信，有过全面且深入性的研究，能 Hold 住吹出去的牛，那简历上就放心大胆地吹。反之，尽量谦虚为上，不要去写“精通”。

遵守上述六条原则撰写简历上的专业技能，最后能得到一份“初稿”，接着可以再建立在“初稿”的基础之上，对其不断进行优化与改进即可。

正常人如何美化自己的专业技能？

对技术栈的描述，许多人都停留在用“了解、熟悉、熟练掌握、精通”这套词，然后就没有然后了……

举个尤为常见的例子，如下：

熟练掌握AAA；

熟悉BBB；

了解CCC；

学习过DDD；

有过XXX经验。

这样可以吗？当然可以，但你没有真正表达出对技术的掌握度，比如你写熟悉BBB，但你到底熟悉到什么程度呢？看你简历的人无从得知，假设你是一位面试官，想要基于简历进行提问时，又该如何提问？你不清楚，只能按自己的推断去提问。

也正是由于上述原因，所以在描述技术栈可以稍加美化，如下：

原文：精通Spring框架。
美化：精通Spring框架，曾阅读过IOC、AOP、MVC、事务机制的源码。
原文：熟悉Nginx。
美化：熟悉Nginx代理技术，能熟练运用Nginx搭建服务的热备集群。

也就是给面试官一个方向，看到你的这项技术栈之后，能明确知道你具体对哪方面有过深入研究，至少能在面试中，给予对方一个提问的方向，而并不是让对方盲目提问。简单来说就是：对于自己掌握的技术栈，不要再用一个单调的词汇形容，而是加上一些修饰语去引导。

经验丰富者又该如何优化专业技能？

前面所说的方法都只适用于“初、中、高级”水平的人，随着工作年限的不断增长，个人的技术栈也在不断丰富，所以一些工作多年的技术人，所掌握的技术栈十分多，再按照前面的方式就容易写出长篇大论。我见过的简历中，甚至见过专业技能写了三十多项的牛人，但这样去写，不如换成下面这种方式（以后端为例）：

十年IT开发经验，六年系统架构经验，具备丰富的大型项目处理经验；
精通大流量、高并发、海量数据处理，擅于构建高吞吐低延迟架构；
精通常用开源框架，如Spring体系框架，阅读过大部分框架底层源码；
精通分布式/微服务架构，熟知分布式架构各难点排除及解决方案；
精通关系型数据库、非关系型数据库，擅于搭建大流量系统存储中心；
精通Shell脚本语言编写，具备搭建可持续化自动部署/监控中台经验；
精通中间件技术、线上问题排除、系统故障分析、应用性能优化手段；
……

看上述这段专业技能描述，虽说没有指明具体的技术栈，但常人看到这段描述就能感受出：是个大佬！

Why？因为这段描述是提炼过的内容，不再拘泥于某个技术细节，更多的是在突出自己的优势，所以这也是每位资深技术人应该要掌握的能力，即：学会提炼自己的专业技能，重点突出自身的优势，而并非长篇大论。

不过话说回来，干到资深水准的小伙伴，基本上也无需通过投简历的方式找工作。毕竟自身工作经验丰富，所以人脉关系并不差，换工作更多是被挖，或者走内推、猎头的途径。

二、项目经验不应该写成流水账

聊完了专业技能如何撰写后，接着再来说说项目经历，项目经历估计是大家头疼的一栏，很多时候不知道如何去描述项目，为此，这里先给出一个 通用模板。

基本信息：项目名称（项目开发周期）。
技术架构：项目开发中所使用的技术栈。
项目背景：如果是自研项目，说明项目的背景。
项目描述：大概形容一下这个项目是干嘛的。
个人职责：说清自己在项目中做的事情。
技术描述：罗列一些自己在项目中用到的技术亮点（可以与个人职责合二为一）。
个人收获：大概讲讲做完这个项目给自己带来的成长（可选项，中级以上建议不写）。

大家在描述项目经验时，都可以按照这个模板往里套，给个简单的示例，如下：

按模板去套自己的项目，你的项目经历就能较为全面地体现出来。但对于年限较长的小伙伴而言，因为工作的时间不算短，所以接手过的项目不在少数，请牢记：千万不要把项目经历写成流水账！

项目经历怎么写才更吸引人？

不要写成流水账是啥意思呢？就是简历无需写太多的项目，我的建议是来4个左右就够了，而这几个项目中，至少前两个一定要选比较有吸引力的，即技术面试官感兴趣的！但问题又来了：什么样的项目算比较有吸引力的呢？

具备吸引力的项目主要有如下几类：

知名度比较高，例如淘宝、京东（这里是举例，稍微有点名气也行）；
用户量比较大，用户基数大代表流量大，对性能、技术要求会更高，知名度也不会低；
技术难度比较大，用到了较复杂或较新的技术开发的项目，如直播、金融类型项目等。

描述项目经历时，从接手过的项目中，选几个符合上述条件的即可，千万别把所有项目都写上去！因为这样干，会造成简历篇幅过长，同时还容易写成流水账，看着虽然多，但没有核心，所以写项目经历讲究：浓缩的才是精华。

但如果你从业时间较短，接手过的项目并不多，则可以把做过的项目都写上去。同时，如果项目都算不上很出色，你也可以用一点小手段，也就是所谓的“包装大法”。找一两个你认为比较出色的项目，写在你的简历上也行，但这样的做的前提是：你对“包装”的项目，必须得像自己做过的一样熟悉，如果无法吃透包装的项目，自然在面试中很容易露出~~鸡~~马脚。

平凡的项目如何制造亮点？

相信诸位都有一个苦恼：“平时工作就是打螺丝，简历上的项目该如何写出不一样的感觉啊？”

这是导致大家项目经历看着很平凡的罪魁祸首，很多人往往就是因为不知如何优化项目经历，所以只能按事实陈述，导致项目经历一点也不突出。

下面就来教大家优化项目的方法。

优化项目主要依靠两条准则，第一条是通过语言美化，第二条则是塑造技术亮点。

1. 善用语言去美化

先来说一则小故事：

一个小和尚问方丈：“师父，我念经的时候可以抽烟吗？” 方丈怒道：“当然不行！” 另一个小和尚也问这个方丈：“师父，我吸烟的时候可以念经吗？” 方丈的回答是:“自然可以。”

从这个故事中大家能明显感受到语言的魅力，同样的一件事情，用不同方式去表达，事情的核心并没有改变，但得到的结果却完全不同。这个道理很容易懂，但却很少有人能真正用好它。怎样才叫用好这个道理呢？例如：

A：我要教人搞传销诈骗！
B：现在传销诈骗日益猖獗，为了防止大家上当，我将以犯罪人的视角宣传反诈骗！
A：小李兼职摆摊卖炒饭，昨天赚了15块，今天赚了60块。
B：小李兼职摆摊卖炒饭，今日相较昨日，收益环比增长300%！

上面两个例子，大家是不是有种熟悉感？日常生活中有着许多类似的案例，但具体有哪些就不指出了。这里重点是在强调：一件相同的事情在不同的语言修饰下，产生的结果自然不同！想要给自己简历上的项目做美化，首先就得利用这个原则去落实。

但搞技术的人里面，大部分都缺乏这项能力，因为大家更偏向于理工科，文学功底有所欠缺，想利用这个准则用来美化项目，会存在些许难度，因此这里给出两个示例参考。

原文：两三个人负责一个项目，自己负责写代码、在开发周期内交付项目。
美化：推动项目正常进度，参与需求分析与系统架构设计，负责项目核心模块的开发工作。
原文：把写好的项目丢到服务器上，以后出问题了再负责改一下 Bug。
美化：主导项目的上线部署工作，跟进线上实际运行状况，及时排查与解决线上故障。

这些示例中，事情的本质有改变吗？其实没有，归根结底说的还是同一件事，但当换了一种表达方式后，给人的感觉完全不同。比如第一个示例中，按照正常的写法去形容，给人的感觉就是个做业务开发的螺丝仔，但换了一个说法之后，你便化身成了团队主程、核心骨干，少了你肯定不行（2～3个人负责开发的项目，少了你的确不行）。

OK，上述内容便是优化项目的第一个技巧，也就是把同样的事情，用听起来更加牛逼的方式表达出来。但这里要牢记：适当塑造确实可以提升竞争力，但塑造时也千万不要过度。比如你在飞机上打了两颗螺丝，结果写成参与了整架飞机的制造，甚至对外宣称你造了架飞机，这可以吗？不行，因为实际考察时，稍微一问就露馅了，那什么叫适当地塑造呢？可以把“给飞机打了几颗螺丝”改为“参与了飞机零部件的制造”。

简历的项目经历中，这个技巧可以用在项目描述、技术描述、职责描述等各方面。好比项目职责描述中，我见过的许多简历，往往是下面这样：

负责开发XXX模块，实现了AAA、BBB功能。

这样写虽然可以，但会显得有点平平无奇，那如何优化呢？套下面的模板：

负责开发XXX模块，利用XXX等技术，解决了XXX问题，达到了XXX效果。

有小伙伴会说，我不会套啊，能不能给个例子啊？那就来一个吧（以后端举例）：

负责XX模块开发，利用MQ、Redis中间件，解决了系统并发吞吐低的问题，经实测由500QPS提升至4000QPS。

这样看起来是不是好多了？所以在写项目经历时，这个美化技巧一定要利用好。

2. 学会塑造技术亮点

接着再聊聊第二个优化技巧：制造技术亮点。

为啥要制造技术亮点？因为技术面试官在看项目时，重点只关注三方面。

项目的背景：规模大不大、名气大不大、技术难度高不高、业务复不复杂……
你是什么角色：你在项目中是负责边角料开发的螺丝仔，还是核心开发，或者负责人……
项目中的技术亮点：项目中有没有比较难的问题，会用到令人眼前一亮的技术或方案……

前两点在前面讲过了，现在把目光放在最后一点，这点对于大家来说，似乎是个不小的问题，我天天就是打螺丝，哪儿来的什么技术亮点啊？利用CV大法日码一万行算不算亮点？

由于工作的局限性，似乎项目中很难出现技术亮点是不？这点我能理解，不过大可不必担忧，既然你做项目时没有亮点，那你在平时瞎逛时，有没有遇到过令你眼前一亮的技术解决方案、疑难排查呢？如果有，就请把它写在你的简历上。

这样做合适吗？当然没问题，但前提也需要你能吃透写的亮点，因为你既然写了，那么面试中80%几率会被问到，如果Hold不住自己写的亮点，面试结果自然可想而知！

那有哪些属于技术亮点呢？以后端举例（其他岗位我不是很熟悉，大家根据自己情况来定）：

分布式系统中需要传递一个全局唯一的 ID，用于串联分布式系统中请求的链路日志记录。
- 亮点 1：如何确保全局唯一？可以延伸分布式ID生成策略，如拓展到雪花算法。
- 亮点 2：并发情况下，如何保证不同请求的ID不会冲突？可以延伸到ThreadLocal。
项目中某个接口调用后响应速度缓慢，每次用户访问时需要等待很久，如何做的优化？
- 亮点 1：线上排查手段，如何精准定位到响应缓慢的接口、造成缓慢的原因……
- 亮点 2：性能优化手段，如何优化了响应时间？拓展到MQ中间件、多线程、缓存……
……

总之，所谓的技术亮点，就是写一些比较难、吸引人的问题，这样面试官在看的时候，自然会对你解决问题的方案感兴趣，因此你的简历吸引力会更大。并且在面试过程中，也可以大概率引导面试官的提问。

综上，我们可以总结出项目经历描述与优化的要点，其实重点就是做好三方面：选好适合的项目、美化好项目经历、突出技术亮点。这三个是技术面试官会关注的点，所以针对简历的项目优化，围绕着这核心的三点展开即可。

最后，额外说明一点，如果你所负责的项目是面向C端的业务，可以适当贴出演示地址，这样有助于让招聘方充分了解到你的项目，尤其是针对同业务类型的招聘方，看到你的实际项目时，会对你更加满意。

三、简历上其他容易忽略的技巧

认真对待自我评价

至此，简历上会出现的每项信息，都给出了编写时的建议及优化技巧，但前面忽视了一项内容，也就是“自我评价”这一栏，大家在写这栏时，基本上全靠在网上抄。正因如此，很多简历的自我评价都会出现下述这些信息：

我的建议是最好别这么写，而是结合个人的实际情况，诚恳地写出一段自我评价！因为有些 HR 在看简历时，会优先查看你对自己的评价，所以写的时候，可以优先考虑写上自己的优势，如：

平时热衷于技术研究与分享，XX签约作者、XX博客专家、XX畅销书原作者、XX技术核心贡献者……

N年服务端、后端开发经验，N年大型项目架构经验，主导过十余个大型项目研发及落地，多个项目用户规模达到千万级、全站单日并发达到百万级……

上述这段自我评价中，就能够将你自己的优势完美体现出来，但如果没有优势的话，一段发自内心的诚恳评价，也能给人留下良好的印象。不过对于技术人来说，这段评价的影响也并不大，有句话叫做“无过便是功”，能写出一段有优势最好，如果文笔功夫实在欠缺，从网上复制一段也OK。但千万不要自作聪明，在自我评价中大肆吹嘘、夸奖自己，否则只能适得其反。

不要一份简历打天下

JD（全称Job Description）是指职位描述，即你在招聘网站上看到的招聘需求。

在求职的过程中，当你看到一个JD很满意，薪资待遇、福利、技术栈、业务等方面都特别合适，那针对这样的JD就要额外珍惜，别抱着“一份简历打天下”的想法。

面对自己满意的招聘，尤其是工作年限较长的伙伴，可以了解下招聘方的业务范围，适当把简历的项目调整成与招聘方业务更匹配的。同时再参考JD上的技术要求，调整一下自己的专业技能顺序。

为此，大家在写好一份通用简历的前提下，也要做好随时微调的准备，匹配度越高的简历，会更受招聘方的欢迎。对于招聘方而言，想要招到一个业务经验、技术能力十分匹配的人才并不容易，如果你能够通过微调达到对方满意的标准，简历上项目的业务属性、个人的技术栈，都与招聘方相匹配时，那自然成功几率会更高。

写好简历后要做的三两事

当你按照文中所说，撰写并优化好了简历之后，首先记得多复查两遍，看看整份简历是否可以再精简一些。如果可以，请再次对简历动刀，毕竟写简历是个修修补补的过程，多番打磨后才能得到更好的成品。同时，复查也能解决不细心带来的后患，例如错别字、英文单词的字母顺序反了、某些内容重复……这类问题。

确保简历内容完全正确，并且足够精简时，可以把你的简历发给同为技术人的几位朋友、同学看看，如果你的朋友看了之后，觉得你的简历比他写得要好，那相对来说你的简历就很不错啦！同时，朋友看你简历的过程，相当于他人帮你复查了一次，也相当于别人给你筛选了一次，说不定他们还能给出一些额外的调整建议。

最后，简历成品出来之后，一定不要忘了导成PDF格式噢！如果是.doc、.md或其他格式，当你投递简历的时候很容易出现打不开，或者打开出现乱码、排版混乱的问题，而转换成.pdf格式后自然就不存在这些问题。

自我练习篇：自我介绍、项目介绍该怎么说面试官才会听？

自我介绍、项目介绍，这属于技术面试必不可少的两个环节，但往往许多小伙伴，要么不会表达，刚开始介绍没多久就结束了，或者开始介绍后，就不知道该如何停下来，又或者不知怎样介绍得更好，做到扬长避短……

正因上述一些情况，所以大家会遇到下面两个困扰：

面试中的自我介绍，怎么说才合理？
面试中的项目介绍，怎么说才更合适？

想要做好这两点，需要经过充分准备与一定练习，整个过程需要一点时间，也需要克服一些困难，具体怎么做呢？下面我们一同来探讨探讨吧～

一、自我介绍该怎么说才合理？

自我介绍是许多面试的第一问。当你与面试官初次见面时，通常都会让你先做个简单的自我介绍。估计有些人会犯嘀咕：“你是没长眼吗？简历上都写着还叫我介绍？”

简历上有求职者的大致信息，这点我们懂，其实面试官也懂，但为何还要让人做自我介绍呢？原因如下：

面试官想对你有个初步的了解，毕竟你们也许是第一次见面，之前对你不熟悉；
面试官想从这里判断你的语言组织能力、沟通能力怎么样，以及性格是否内向等；
虽然简历上有你的大致信息，但面试官需要时间浏览，自我介绍则起到缓冲作用；
看你自我介绍时的语言表述，和简历信息是否一致，以此来推断简历信息的真实性；
面试官想要通过你做自我介绍，来打破四目对视的尴尬场景，起到缓解气氛的作用。

由于上述几点因素，所以自我介绍才成了面试中常有的环节。不过也并非所有面试都会叫你做自我介绍，尤其是技术面试官，很多时候没那么讲究，可能上来就直接聊技术。

但有可能不需要做自我介绍，不代表咱们不需要准备，那自我介绍怎么说才合适呢？我们一起来分析下这个话题。

自我介绍的模板和注意点

问候语 + 姓名 + 年龄 + 毕业院校 + 工作年限 + 目标岗位 + 专业技能 + 上家经历 + 工作职责 + 结束语

将自己的信息套入这个模板中，就能够得到一个自我介绍的初稿。但是，有以下三点要切记。

第一点，注意扬长避短。如果自己的学历是专科或非统招学历，可以适当省去毕业院校，毕竟这是你的短处。反之，如果你拥有名校背景，则可以在自我介绍中重点突出。其他方面，例如项目经历、工作履历、个人荣誉……亦是同理。

第二点，注意控制时长，不要太短也不要太长。

这里分享之前我做面试官的两个经历：

经历一：我让候选人做个自我介绍，结果一分钟没到就完了，当时我连简历都没看完。

经历二：我让候选人做自我介绍，我趁机快速浏览一下简历，结果候选人嘴不带停，从基本信息一直介绍到了项目经历，讲了十多分钟还在描述项目细节……

由上面案例可得知，自我介绍也需要一定的技巧，太短的话可能面试官连简历都没看完，太长的话则会变成面试官一直等着你，无论哪种情况都容易给人留下不好的印象。为此，一定要学会控制自我介绍的时长。

下面结合前面给出的模板，给出一个自我介绍的例子：

面试官你好，我叫竹子爱熊猫，今年29岁，17年于清华大学硕士毕业，至今从事Java开发已有六年时间，今天是因为在Boss上看到了贵公司的招聘，所以过来应聘Java架构师一职。

平时个人比较热爱技术，主要擅长XXX、XXX...等方面，对XXX、XXX...都有过深入研究（这里最好简短，不要把所有掌握的技能都讲一遍）。

毕业以来曾先后就职于公司1、公司2等多家企业，上份工作是在XXX担任技术总监一职，在职期间内曾主导项目1、项目2、项目3等多个项目的研发工作，平时主要负责职责1、职责2....

以上大致就是我个人的基本介绍，如果你有其他需要了解的，我这边可以再做补充。

又或者：

你好，我叫竹子爱熊猫，今年22岁，因为我是培训出身，所以参加工作的年份比较早，20xx年的时候就出来上班了，到现在已经工作了有三年时间，技术栈这块，个人比较擅长......

在我工作的三年以来，一直在XXX公司做Java开发，在职期间内，曾参与过项目1、项目2、项目3等项目的设计与研发工作，平时自己主要是负责职责1、职责2....（如果自己感觉较短，这里也可以补充一个最近做过的项目）。

今天主要是看到了贵公司在Boss上的招聘，仔细阅读招聘需求后，发现自身能力与贵公司的需求比较匹配，同时之前自己也做过XX方面的业务，所以过来面试Java开发一职。

在给出的两个自我介绍示例中，虽然不是很长，但却涵盖了个人基本信息、工作年限、从哪来的、来干嘛的、之前在哪些公司待过、在上家公司是做啥的、上家公司做过哪些项目等内容，整段介绍看起来简短，但已经将面试官想要知道的所有信息都做了介绍（案例仅供参考，如若有更好的方式可以结合一下，不必完全套入）。

同时，第一点提到的“扬长避短”要充分发挥好！比如第一个示例中，高学历+名校背景，显然是候选人的优势，因此可以在自我介绍中重点突出；而后者因为是培训出身，所以学历这块可以适当跳过。

另外，第三个切记点是：在自我介绍的最后，一定要记得加上结束语！ 这是许多小伙伴会遗漏的点，但加上它之后效果会很好：一方面可以给自我介绍收场，避免叨叨絮絮个没完，不知道如何停下介绍的尴尬场景；另一方面还能给面试官留下提问的“衔接口”，也就是最后那句“如果你有其他需要了解的，我这边可以再做补充”，面试官就可以接话提问。

自我练习的方式

将自身的情况套入给出的模板中，能够得到一个最基本的初稿，可以先调整优化一下，接着可以背两遍，熟悉稿子之后再多加练习。

练习的方式主要有三种。

对镜练习：自己正对着镜子，然后盯着自己的双眼，开始模拟做自我介绍。
录音练习：通过手机自带的录音软件，或者用通信软件语音功能，录制一段自我介绍。
录像练习：利用手机的相机录像功能，调整好角度之后录制一段自我介绍。

看到这三种练习方法，相信许多小伙伴会有些排斥，心里可能会想着：“我都已经把稿子写好了，面试直接按稿子说就好了呀，干嘛还要这么去练？”如果你的内心也有这个想法，其实很正常，但请一定要去尝试练习！

为什么一定要去练习呢？心里默念难道不可以吗？

如果你是个社牛，练不练习都无关紧要，毕竟性格本身就很外向，在面试中自然可以做到侃侃而谈。但如若性格偏内向或者性格普通，就一定要多加练习！这个练习不仅仅是为了做好自我介绍，而且还可以改善面试中整体的个人表现。

对镜练习

对镜练习时，先盯着自己的双眼，或者盯着自己的眉心，然后再开始练习自我介绍，并且不是练习一遍就完事，一定要多次练习，至少也要在10次以上，最好做到30次以上！Why？自我介绍练习个三五遍就滚瓜烂熟了，至于练这么多遍吗？

咱们不能只看表象，其实这里是在练习眼神！我见过许多人在回答问题时，都会出现眼神飘忽的现象，比如当我一直盯着他时，最多三秒，就会避开与我的眼神接触，这显然是不自信的表现。甚至有些候选人，在面试时整个眼神摇摆不定，喜欢东瞟西看，这更会给人留下不好的印象。

而对镜练习就能很好地改善眼神问题，当你习惯与自己对视时，你的眼神也会逐渐坚定，经过多次练习后，在以后真正的面试场景中，也会下意识地盯着面试官的眼睛回答问题。直视他人是一种尊重他人的表现，也是一种自信的表现，更能给人留下一个好印象。

不知大家身边是否有入伍多年的“兵哥哥”，当你跟他们待在一起时，你会发现他们的气场完全不一样。当然，我们就算对镜练习两年半，也不一定能够达到军人的气质，但至少能够改善原本眼神上的一些小毛病，起码能习惯与人对视，不至于面试时怯场，从而表现得很糟糕。

录音练习

对镜练习好眼神之后，接着是录音练习，因为当你在说话时，是无法感受到自己的谈吐好坏，就算说话语气词、口头禅很多，在事后也不会有所察觉。这件事相信大家都有所体会，比如身边有些朋友或领导，说话时带很多语气词或口头禅，听的人都能感受到，但他自身却觉察不到。录音练习主要解决的就是这类问题。

当准备好自我介绍的稿子后，可以把自我介绍录下来，但要记住：无论是对镜练习、录音练习还是后面的录像练习，就算发挥不好，也要坚持下去！许多小伙伴在做一件事情时，如果没做好的第一反应就是重做，比如跟朋友发语音，说着说着出现一点卡壳时，通常会取消重新说一遍，但在练习时千万不要这么做！

录制好一段自我介绍的音频后，接着你要放大声音去听。当你前几次听自己的录音时，可能会感觉有点尴尬，迫切地想关掉不听，这是十分常见的情况，请不要在意，认真去找录音中自己认为不足的地方，并且加以改善后再次录制，直到自己感觉没问题为止。

不过自我介绍在录音练习时，往往无法反映出自己说话的问题，因为自我介绍经过前面的练习后，在你内心已经滚瓜烂熟了，所以录制时会更加自然一点。为了充分反映出自身的问题，可以预设一个主题自由发挥，比如“以猫为主题讲个故事、谈谈你对XXX技术的看法……”，只要不是事先准备的都行，单个录音至少要保持在10分钟以上。

这样做的好处在于：一方面能充分找出自己说话时的问题，另一方面还能锻炼自己的临场发挥能力，就算是在胡言乱语也没关系，当你录制好之后再去听的时候，就能明显感觉到问题所在。比如找找自己说话的过程中，是否经常出现“嗯、啊、吗、额、可能”等语气或停顿，如果有，就换个主题录音练习，但在下次练习的时候，脑海里强迫自己注意减少这些语气词和停顿。

通常经过5~8个主题的切换后，你说话的小毛病能得到不小改善，最主要的是你能习惯临场发挥，从而能做到在面试中侃侃而谈。这也是为什么有些人一开口时，总能如滔滔江水般连绵不绝的原因，难道他们与生俱来就有这个能力吗？并不是，都是靠锻炼出来的，大部分人最开始都是支支吾吾，经历多了之后才逐渐变得能说会道。

录像练习

对镜练习能改善眼神气质问题，录音练习能改善谈吐与增强临场发挥能力，而录像练习的作用是干嘛呢？许多小伙伴似乎感觉录像和录音的差距不大呀？为什么还要多此一举呢？实则不然，录像练习的最大好处在于改善小动作。

小动作这个情况，许多人一紧张或尴尬时就会出现，比如摸鼻子、撩头发、扭脖子、舔嘴唇、两个手相互触碰、手掌从大腿搓到膝盖……总之人在紧张时，就容易出现各种肢体小动作。与口头禅、语气词的状况类似，这些小动作也是潜意识下做出的反应，当事人也很难觉察，录像练习的作用，就是解决这类问题。

同样随机找个主题，然后准备录制视频练习，但私下一人练习很难产生紧张、尴尬的情绪，所以在录制视频时，你还需要通过“想象”来辅助。比如，你目前录制一个自我介绍的视频，但在自己做自我介绍的时候，脑海里面去想一些紧张的场景：

目前在考试你正打算作弊，目前你站在几百人的大会台上发言……

或者想象一些尴尬的场景也行，例如：

在人来人往的广场上跳舞，在许多人吃饭的食堂里大声唱歌……

上面列出的一些场景是不是想象着就紧张？听起来就很尴尬？你在录像练习时，需要的就是这种情绪来辅助，只有当你处于这种情绪之下，才能把潜意识中的那些小动作“唤醒”，这种情况下录制的视频，才真正能反映出你不好的习惯。

录制好之后，当自己去看视频的时候，同样会感觉很尴尬，此时要抱着“鸡蛋里面挑骨头”的心态去找问题，将发现的不足记录下来，然后加以改善，最后就能控制好自己在紧张/尴尬情绪下的表现。

对镜练习、录音练习、录像练习，针对于求职前的自我练习就讲到这里啦，我并不确定有多少人会去落实这些，或许没人去这么做，又或很多人跟着方法做，这我都无从得知。但我真心希望大家可以去尝试练练，虽然听起来这么做会有点尴尬，但当你真正尝试后，真正改善掉自身不足时，你得到的将是一个全新的自己，这些练习带来的好处不仅仅是满足面试，更能让你在以后的日子中长久受益。

二、面试时如何介绍项目？

技术人的社招面试而言，更多会围绕着项目展开话题，因此项目介绍成为了面试必然存在的环节。一场技术面试也许可能没有自我介绍，但绝不会少了项目介绍，所以除开要准备自我介绍外，准备项目介绍也必不可缺。

但有些人在介绍项目时，会遇到两个问题。

不会说：不知道如何描述自己的项目，以及自己在项目中的职责。
不会停：一旦开始介绍之后，从整体描述讲到实现细节，不知道如何收场。

这是我个人经验中，在候选人身上看到的两个问题，归根结底就是不会去形容项目，所以才会导致这些现象出现。那项目介绍又该遵循什么样的原则呢？如下：

面试官没有指定项目的情况下，优先介绍自己最熟悉、最好的项目；
以简历上写的作为基础，但千万不要介绍得和简历写的一模一样；
以讲故事的方式去形容自己的项目，才能更加吸引面试官的注意力；
针对项目中的技术亮点和个人职责，多运用STAR法则去进行阐述。

上述四点是项目介绍时要遵守的原则，其中第一点很容易理解就不多说了。第二点则是许多人常犯的错误，简历上怎么写的就怎么介绍，但请大家一定要杜绝这种情况出现，毕竟面试官让你说，主要是想听点不一样的，而并不是让你把简历上的内容重复一遍。

前面提到的四点原则中，第一、二点比较容易理解，但第三、四点如何运用起来呢？待会儿会用社区买菜来举例说明，但在此之前，会先讲一下项目介绍的通用模板，然后基于给出的示例来讲述第三、四条原则。

项目介绍的模板与注意点

基本信息 + 项目背景 + 项目描述 + 技术架构 + 个人职责 + 技术亮点 + 结束语

这个模板咋套进去呢？结合社区买菜案例，套进去给个示例：

项目背景：我最近做过的一个项目叫XX买菜，因为随着互联网时代的进步，人们购物愈发依赖于网购平台，相较于传统的门店、商场购物，网上购物更加便捷。但当我们想要在这些平台上购买日常需要的家庭食材时，如蔬菜水果、肉禽水产之类的，由于快递的周期普遍在三天左右，所以到货时基本都不怎么新鲜。为此，既要如网购般方便、又要保证新鲜程度的需求就产生了，这也是我们做这个项目的初衷。

基本信息：为了尽快将这个项目落地，当时组建了一个XX人的研发团队，从需求分析到初版上线，整个过程大致耗费了六个月。

项目描述：XX买菜是一个依托于社区的买菜平台，用户通过网上下单，平台通过线下专员配送的方式，结合本地仓库、专属配送链、社区提货点等机制，从而实现了当天买、隔日达的需求，由于是依托社区作为提货点，所以十分便于用户提货。并且结合冷链配送、社区保鲜保证了食材的新鲜度，相较于传统的线下市场、超市买菜，线上买菜更加便捷、可挑选的种类也更多，同时价格上更实惠，也能保障足够新鲜……

结合业务需求和分布式架构思想，我们将其拆分成了XX1、XX2....等多个子系统，XX1子系统主要负责....、XX2主要负责....（简单概述）

技术架构：考虑到系统的可用性及拓展性，核心服务都采用了弹性集群部署，同时也为了保障程序性能，项目中也引入了XX、XX等中间件，而整个项目的技术架构为......

个人职责：我在项目中主要负责....等工作（最好不要只说编码，可以拓展到推进项目、跨部门对接....）。

技术亮点：在项目的开发过程中，其实我们也遇到并解决过过很多难点问题，例如并发情况下单机锁失效问题、服务故障的无感切换、基于全局ID实现分布式链路追踪、线上突发故障的定位排查等等。

结束语：以上就是我最近一个项目的大致情况，如果您有其他想了解的，可以随时问我，我这边可以再做补充。

上述这个项目介绍的方式，首先能说明项目的基本情况，也能说明为什么要做这个项目、项目大概是干嘛的、里面用了什么技术、自己在里面做了什么事、项目中有没有遇到什么难点问题……基本也将面试官想知道的说出来了。经过大致介绍后，面试官也能根据他感兴趣的方向进行提问。

PS：这仅是一个通用的模板，如果你有更好的方式去介绍自己的项目，也不一定要套用这个模板，这里只是给出案例当作参考，如果你不会做项目介绍时，则可以套入模板提前准备。

但不管你是否要套模板，项目介绍时也要注意以下两个点。

一是控制时长。千万不要超过五分钟，太长就显得太过啰嗦，面试官听完之后抓不住你要表达的主题。
二是加结束语。我见过许多候选人都没有这个习惯，自我介绍也好，项目介绍也罢，说着说着就戛然而止了，我都不知道候选人到底是已经说完了，还是想缓口气接着说，所以加上结束语后，更便于面试官接话。

运用讲故事手法和 STAR 法则

前面提到的第三点原则，是多用讲故事的手法介绍项目。相信大家在前面给出的示例中能感受出来，在示例的一开始，并未直接进行枯燥的项目介绍，而是以讲故事的形式，先讲述了项目的产生背景和平台描述，从而能让面试官更有兴趣听下去。为了能让大家产生对比感，下面也贴一个反例：

我最近做过的项目叫XXX，里面被分成了N大模块，XX1模块是用来……XX2模块是负责……

这样去介绍项目虽然精简，但不免有种乏味感在内，缺失了一定的铺垫，很难让面试官代入进去，尤其当你介绍的时间一长，面试官甚至到后面都不会听了，而是等着你说完就开始提问……所以，讲故事的手法主要是为了引起面试官兴趣，至少别让别人听起来就感觉很枯燥。

接着聊聊起初说到的第四点，个人职责和技术亮点多运用STAR法则。通常我建议个人职责和技术亮点结合在一起去说，这样有助于消除职责介绍时的枯燥感，因为很多小伙伴在讲个人职责时，更多的停留在业务的介绍，例如：

我主要负责XXX...模块的开发，XX1模块是用来...，里面主要又N个功能，功能1...、功能2...

这样去介绍，时间一长，同样会带来很重的枯燥感，所以适当地控制业务介绍，掺入一些技术亮点的穿插效果会更佳，例如：

我主要负责XX...模块的开发，X1模块是用来...，里面包含了x1、x2...等核心功能，XX2模块...。

在我做订单模块的开发过程中，由于晚上十一点会有新的菜品库存补货，此时订单量会剧增造成系统并发过高，因而导致系统访问较为缓慢，为了解决这个问题，我用到了XXX...等技术与XXX方案，经过实测后，业务高峰期的1.5s延迟降到了140ms左右。

这样去介绍个人职责是不是比前面好多啦？既避免了过多业务介绍带来的枯燥，又为后续面试官的发问留下了话题，所以一定要多结合技术去做职责介绍，并且运用上STAR法则，因为什么出现了这个问题、怎么处理的问题、处理之后得到的成效（但只建议展开1~2个亮点细说，其他的亮点可以轻略带过，太多反而是副作用）。

OK，到这里就是如何做好项目介绍的全部内容啦，在大家准备项目介绍时，最好也是把它写出来，写出之后可以再次微整，整体描述要显得精简，同时也可以结合提到的原则稍加美化。当项目介绍调整好之后，就不用再做自我介绍时的那些练习了，但也记得在心中默念几次，加深印象之后才能表达得更为自然。

未完待续...

GDB: The GNU Project Debugger

Sun, 13 Apr 2025 00:00:00 GMT

官方文档：GDB: The GNU Project Debugger

官方提供的 GDB Document 所展示的 gdb 调试全过程示例如下链接【已阅】：https://sourceware.org/gdb/current/onlinedocs/gdb/Sample-Session.html#Sample-Session
- gdb m4
- set width 70
- break m4_changequote / b m4_changequote
- run / r
- n / next
- s / step
- backtrace / bt
- p lquote / print lquote
- list / l
- p len_lquote=strlen(lquote)
- c / continue
- ctrl-d / quit

1. `gdb` 启动 gdb

# 直接启动 gdb
$ gdb
# 启动 gdb 的同时加载一个要调试的 [可执行文件]
# 该 test 文件在编译的过程中必须要加 -g 选项, 把调试信息加到可执行文件中: gcc -g test.c -o test
$ gdb test

2. `quit`/`q` 退出 gdb

$ quit
$ q

3. `file` 命令加载程序

$ file [可执行文件]

(gdb) file test
Reading symbols from test...

4. `list`/`l` 命令显示源代码

list` 命令可以列出可执行文件的源代码的一部分，简写为 `l

该命令既可不带参数：list 命令将显示 10 行代码，第一次从首行开始显示，第二次从上次显示的末行的下一行开始显示，以此类推
也可带 1 个参数：list n 命令显示的是第 n 行的前 5 行和后 4 行代码
或者带 2 个参数：list n1, n2 命令显示的是 n1—n2 行之间的源代码内容
还可以显示某函数附近的源代码内容：list funcname

(gdb) list
1       #include <iostream>
2       #include <fstream>
3       #include <vector>
4
5       using namespace std;
6
7       int main()
8       {
9         ofstream outfile;
10        outfile.open("./results/MD_trace_results.txt", ios::out | ios::app);
(gdb) l
11        if (!outfile.is_open())
12        {
13          cout << "failed" << endl;
14          exit(1);
15        }
16
17        cout << "succeeded" << endl;
18
19        return 1;
20      }
(gdb) l
Line number 21 out of range; open_file.cpp has 20 lines.

5. `run`/`r` 命令运行程序

使用 run / r 可以在 gdb 中运行调试中的程序，该命令可以跟一个或多个参数，作为运行程序的命令行参数。

(gdb) run 1 2 3
`/home/wyk/straid/code/open_file' has changed; re-reading symbols.
Starting program: /home/wyk/straid/code/open_file 1 2 3
argc = 4
argv[0]: /home/wyk/straid/code/open_file
argv[1]: 1
argv[2]: 2
argv[3]: 3
succeeded
[Inferior 1 (process 145429) exited with code 01]

使用 show args 命令显示传给该程序的参数列表：

(gdb) show args
Argument list to give program being debugged when it is started is "1 2 3".

如果重新运行 run 则会将上次的命令行重新参数传给该程序。

如果要改变传递给程序的参数，可使用 set args：

(gdb) set args 4 5 6
(gdb) run
Starting program: /home/wyk/straid/code/open_file 4 5 6
argc = 4
argv[0]: /home/wyk/straid/code/open_file
argv[1]: 4
argv[2]: 5
argv[3]: 6
succeeded
[Inferior 1 (process 145554) exited with code 01]

6. `break`/`b` 命令设置断点

程序执行到断点时将被挂起，有以下几种方式设置断点：

break` 命令也有简写形式 `b

(1) 根据行号设置断点 break <linenum>

(gdb) break 10
Breakpoint 1 at 0x5555555552d5: file open_file.cpp, line 10.

设置好断点后启动程序，会停在断点位置：

(gdb) run
Starting program: /home/wyk/straid/code/open_file 4 5 6

Breakpoint 1, main (argc=4, argv=0x7fffffffe178) at open_file.cpp:10
10        cout << "argc = " << argc << endl;

(2) 根据函数名设置断点 break <funcname>

(gdb) break main
Breakpoint 2 at 0x5555555552a9: file open_file.cpp, line 8.

(3) 执行非当前源文件的某行或某函数时停止执行（为非当前源文件设置断点）

(gdb) break filename:linenum
# or
(gdb) break filename:funcname

(4) 根据条件停止执行程序

(gdb) break linenum if expr
# or
(gdb) break funcname if expr

⭐清除断点：

clear <source-line>：清除源文件某一行的所有断点
delete <breakpoint-id>：删除 info b 中对应 ID 的断点

(gdb) info b
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x00005555555553ad in main(int, char**) at open_file.cpp:17
2       breakpoint     keep y   0x00005555555553e3 in main(int, char**) at open_file.cpp:19
3       breakpoint     keep y   0x00005555555552d5 in main(int, char**) at open_file.cpp:10
(gdb) clear 17  # 清除源文件 line 17 位置的断点
(gdb) info b
Num     Type           Disp Enb Address            What
2       breakpoint     keep y   0x00005555555553e3 in main(int, char**) at open_file.cpp:19
3       breakpoint     keep y   0x00005555555552d5 in main(int, char**) at open_file.cpp:10
(gdb) delete 2  # 清除 Num=2 的断点
(gdb) info b
Num     Type           Disp Enb Address            What
3       breakpoint     keep y   0x00005555555552d5 in main(int, char**) at open_file.cpp:10

7. 在不退出/中断 gdb 的情况下使用 shell 命令：`!<command>` 或 `shell <command>`

# don't work
(gdb) echo $PATH
# works
(gdb) shell echo $PATH
/home/wyk/.vscode-server/bin/8fa188b2b301d36553cbc9ce1b0a146ccb93351f/bin/remote-cli:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
(gdb) !ls -al $PWD
total 108
drwxrwx--- 8 wyk  wyk   4096 Dec 17 17:36 .
drwxrwxr-x 6 wyk  wyk   4096 Dec  7 08:57 ..
drwxr-xr-x 2 root root  4096 Dec  7 12:43 bin
drwxrwxr-x 7 wyk  wyk   4096 Dec  7 12:43 include
-rwxrwxrwx 1 wyk  wyk    278 Nov 22 03:04 install_depends.sh
-rwxrwxr-x 1 wyk  wyk   3589 Dec  7 09:12 Makefile
drwxr-xr-x 2 root root  4096 Dec  7 12:43 obj
-rwxrwxr-x 1 wyk  wyk  41016 Dec 17 17:36 open_file
-rw-rw-r-- 1 wyk  wyk    535 Dec 17 17:36 open_file.cpp
-rw-rw-r-- 1 wyk  wyk   5964 Nov 22 03:04 README.md
drwxrwxr-x 2 wyk  wyk   4096 Dec  7 10:38 results
-rwxrwxrwx 1 wyk  wyk    880 Dec 12 15:08 run_bench.sh
-rwxrwxrwx 1 wyk  wyk    486 Dec  7 10:37 run_tracemd.sh
-rwxrwxrwx 1 wyk  wyk    397 Dec  7 09:27 run_tracest.sh
drwxrwxr-x 2 wyk  wyk   4096 Nov 22 03:04 src
drwxrwxr-x 2 wyk  wyk   4096 Nov 22 03:04 Traces

因为在 GDB 中不常使用 shell 命令，所以需要 shell 和 ! 的限制，而经常在开发环境中使用 make 命令，所以无需使用以上符号即可调用 make 命令。

# make 命令可直接调用
(gdb) make -j4

# sudo 命令：还是得使用 ! 或者 shell
(gdb) !sudo make -j10
[sudo] password for wyk: 
g++ -I. -I./include -I./include/Bitmap -I./include/concurrentqueue -I./src -Wp,-MT,obj/define.o -Wp,-MMD,obj/define.o.d -g -std=c++2a -Wall -Wno-unused-variable -Wno-unused-but-set-variable -Wno-sign-compare -Wno-comment -O3  -c -o obj/define.o ./include/define.cc
g++ -I. -I./include -I./include/Bitmap -I./include/concurrentqueue -I./src -Wp,-MT,obj/ecEncoder.o -Wp,-MMD,obj/ecEncoder.o.d -g -std=c++2a -Wall -Wno-unused-variable -Wno-unused-but-set-variable -Wno-sign-compare -Wno-comment -O3  -c -o obj/ecEncoder.o ./include/ecEncoder.cc
g++ -I. -I./include -I./include/Bitmap -I./include/concurrentqueue -I./src -Wp,-MT,obj/metadata.o -Wp,-MMD,obj/metadata.o.d -g -std=c++2a -Wall -Wno-unused-variable -Wno-unused-but-set-variable -Wno-sign-compare -Wno-comment -O3  -c -o obj/metadata.o ./include/metadata.cc
...

@ 管道命令 |, 可用 pipe 将 gdb 中的命令与 shell 命令结合使用 [ | 原本是用于 shell 与 shell 之间的管道命令 ]

# 不生效
(gdb) show args | wc -l
Argument list to give program being debugged when it is started is "1 2 3".
# 使用 pipe 即可打通 gdb 与 shell 之间的传输
(gdb) pipe show args | wc -l
1
(gdb) pipe p argv | wc -l
1
# | 原本用于 shell 与 shell 之间的命令传输
(gdb) !ls -al | wc -l
17

8. `s` 命令 == step「单步进入」

(gdb) help s
Step program until it reaches a different source line.
Usage: step [N]
Argument N means step N times (or till program stops for another reason).

9. `finish` 命令「单步跳出」

(gdb) help finish
Execute until selected stack frame returns.
Usage: finish
Upon return, the value returned is printed and put in the value history.

10. `n` 命令 == next「单步跳过」

(gdb) help n
Step program, proceeding through subroutine calls.
Usage: next [N]
Unlike "step", if the current source line calls a subroutine,
this command does not enter the subroutine, but instead steps over
the call, in effect treating it as a single source line.

11. `c` 命令 == continue「跳到下一个断点」

(gdb) help c
Continue program being debugged, after signal or breakpoint.
Usage: continue [N]
If proceeding from breakpoint, a number N may be used as an argument,
which means to set the ignore count of that breakpoint to N - 1 (so that
the breakpoint won't break until the Nth time it is reached).

If non-stop mode is enabled, continue only the current thread,
otherwise all the threads in the program are continued.  To 
continue all stopped threads in non-stop mode, use the -a option.
Specifying -a and an ignore count simultaneously is an error.

12. `return n` 命令直接跳过当前函数后面的语句并直接返回 n，该 n 值是自定义的返回值

(gdb) return 6
Make main(int, char**) return now? (y or n) y
#0  __libc_start_main (main=0x5555555552a9 <main(int, char**)>, argc=4, argv=0x7fffffffe178, 
     init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe168)
     at ../csu/libc-start.c:342
342     ../csu/libc-start.c: No such file or directory.
(gdb) n
[Inferior 1 (process 148790) exited with code 06]
(gdb) n
The program is not being run.

13. `print var`/`p var` 命令查看 var 值

(gdb) print argv
$1 = (char **) 0x7fffffffe178
(gdb) print argc
$2 = 4
(gdb) print *argv[0]
$3 = 47 '/'
(gdb) print argv[0]
$4 = 0x7fffffffe42e "/home/wyk/straid/code/open_file"
(gdb) print argv[1]
$5 = 0x7fffffffe44e "1"
(gdb) print argv[2]
$6 = 0x7fffffffe450 "2"
(gdb) print argv[3]
$7 = 0x7fffffffe452 "3"
(gdb) print argv[4]
$8 = 0x0

14. `backtrace` / `bt` 与 `frame`、`up`、`down`、`info` 搭配食用：查看函数调用栈的最佳命令｜快速定位 bug 位置

立瀚教学 get 到 backtrace，转载链接：gdb调试之函数调用栈——backtrace

更基础的 gdb 内容：GDB调试利器

bt ：bt是 backtrace 指令的缩写，显示所有的函数调用栈的信息，栈中的每个函数都被分配了一个编号，最近被调用的函数在 0 号帧中（栈顶），并且每个帧占用一行。
bt n ：显示函数调用栈从栈顶算起的 n 帧信息（n 表示一个正整数）。
bt -n ：显示函数调用栈从栈底算起的 n 帧信息。
bt full ：显示栈中所有信息如：函数参数，本地变量等。
bt full n ：显示函数调用栈从栈顶算起的 n 帧的所有信息。
bt full -n ：显示函数调用栈从栈底算起的 n 帧的所有信息。

上面的 bt 指令主要是查看栈的信息，而每一帧都会有详细的信息，这些函数调用信息帧包括：调用函数的地方，函数的参数等。如果想查看栈中某一帧的信息，首先要做的是切换当前栈。这时候需用用到 frame 指令（缩写形式为 f）。

f n / frame n: 它的功能是切换到编号为 n 的栈帧（n 表示一个正整数），并显示相关信息。

除了使用 frame 指令切换栈帧外，还可以使用 up 和 down 指令。

down n ：表示往栈顶方向下移 n 层（n 表示一个正整数，默认值为 1）。
up n ：表示往栈底方向上移 n 层。

info 指令是一个很强大的指令，使用它可以查看各种变量的值，如果我们希望看到详细的函数调用信息帧的信息，如：函数地址、调用函数的地址、被调用函数的地址、当前函数由哪种编程语言编写、函数参数地址及形参值、局部变量的地址、当前桢中存储的寄存器等，可以使用以下指令：

info frame ：指令的缩写形式为 i f ，查看函数调用帧的所有信息。
info args ：查看函数变量的值。
info locals ：查看本地变量的信息。

15. 了解一下 GDB 的语法规则|注意事项

使用 gdb 调试的前提是在编译命令中添加 -g 参数，因为有些编译器是无法同时处理 -g 和 -O 选项，所以无法调试带有调试信息 (-g) 的优化 (-O) 可执行文件！
gdb 是单行输入，由 <命令> 跟着 <参数>，取决于命令，比如 step 5 表示连续执行 5 次 step
对于缩写无歧义的 gdb 命令，通常可以截断使用；如果有些以相同字母开头可能造成歧义的命令，可以使用 help 命令来判别该缩写命令是属于哪一条具体的命令，比如 help s
直接按下「回车」会重复上一步命令，但是对于某些可能带来麻烦的命令不会生效，比如 run；对于 list 和 x 命令，按下回车会构造新的参数来重复命令，这样方便扫描资源和内存（连续按下 list 会往下不断展示 10 行代码），ctrl+o 同 Enter
# 表示注释，同 shell 脚本
gdb 使用 Tab 按钮也可「补全命令」

# 盘点一些 gdb 系统命令 [Useful]
(gdb) help
(gdb) help <command>
(gdb) complete <alphabet>   # 列出以 alphabet 开头的所有命令, 比如 complete sh: sharedlibrary shell show
(gdb) show
(gdb) info
(gdb) set
# Here are several miscellaneous show subcommands, all of which are exceptional in lacking corresponding set commands:
(gdb) show version
(gdb) show copying
(gdb) info copying
(gdb) show warranty
(gdb) info warranty
(gdb) show configuration

⭐更多内容（未完待续）：

inferior 可以同时调试多个程序
- info inferiors
- inferior <infno>
- add-inferior
- clone-inferior
- remove-inferiors <infno>
- kill inferiors <infno>
- ...
threads 可以调试多线程
- info threads
- ...
checkpoint 可以保留快照，搭配 restart <checkpoint-id> 回到快照点，当你接近错误点时，可以保留快照，如果因为走得太远导致错过关键语句，无需重新启动程序，直接跳回上一个快照点 checkpoint 即可
- checkpoint: 在此处留下快照点
- info checkpoints: 查看所有快照点信息
- restart <checkpoint-id>: 回到指定快照点
- delete checkpoint <checkpoint-id>: 删除指定快照点
- ...
watchpoint: 当观察的表达式变化时，立刻停下
catchpoint: 当某个事件触发时，立刻停下
breakpoint: 断点——毋庸置疑
- b <linenum>
- b <funcname>
- info breakpoints
- save breakpoints <filename>
- disable breakpoints
- enable breakpoints
- clear <source-line>：清除源文件某一行的所有断点
- delete <breakpoint-id>：删除 info b 中对应 ID 的断点
step
- step 是单步程序源代码
- stepi 是单步机器指令
next
- next 是单步程序源代码
- nexti 是单步机器指令
finish
until
...

分布式系统｜共识算法 Paxos

Sun, 13 Apr 2025 00:00:00 GMT

分布式系统 · 协调与协定（XMU Curriculum）

本章为「2024 春季课程」分布式系统的部分重要内容，仅作归纳，便于理清框架。

✅ L6-时间同步与全局状态

时钟同步
- 物理时钟同步问题（机器本地时间）
  - NTP 网络时间协议：使用中心化的全局时间同步来保证各节点的时间统一
  - Berkeley 算法：服务器主动定期询问每台机器的时间，服务器基于客户的回答计算出平均值，告知它们拨快或者拨慢时间 —— 主动式服务（与 Cristian 算法中的被动式时间服务器相反）
  - Cristian 算法：一台机器设为时间服务器，其他的每台机器周期性地向时间服务器发送请求消息以获得当前标准时间
- 逻辑时钟（时钟的内部一致性）
  - Lamport 算法：为了同步逻辑时钟，Lamport 定义了一个二元关系，称作“先发生”的关系...
全局状态
- 全局一致性快照
- Chandy-Lamport 算法：引入「分布式快照」概念
  - Initiating a snapshot
  - Propagating a snapshot
  - Terminating a snapshot

✅ L7-协调与协定

分布式互斥 Ricart-Agrawala 算法
选举算法
- Bully
拜占庭与共识问题
- 拜占庭
- 共识算法
  - Paxos
  - Raft

✅ L8-并发控制与分布式事务

原子事务
- ACID 特性
- 事务实现
  - 私有工作空间与影子更新
  - 写前日志
- 分为单层事务、嵌套事务、分布式事务
并发控制：当多个事务在不同的进程（在不同的处理机上）中同时执行时，需要一些机制以保证它们互不干扰，这种机制称为并发控制算法
- 两阶段封锁协议（2PL）：恰好在需要或不再需要锁时去请求或释放锁；可能会死锁
- 乐观的并发控制：做自己想做的，有问题出现再说（避免了死锁，允许最大的并行度；有时可能会失效，这时所有的事务都必须退回重新运行一遍）
- 时间戳：每个文件带有对它操作的最后一个提交事务的读时间戳、写时间戳
分布式事务
- CAP 理论：一致性、可用性、分区容错性
- BASE 理论：基本可用、软状态、最终一致性
- 分布式事务解决方案
  - CP 方式：强一致性，弱可用
  - AP 方式：高可用，但弱一致
- 基于这两种思想，延伸出了很多分布式事务解决方案（2PC、3PC、TCC 等）
  - 两阶段提交协议（2PC）
    - 准备阶段 Prepare：取得一致决定
    - 执行阶段 Commit/Rollback：执行命令（提交或废弃）
  - 三阶段提交协议（3PC）：在协调者和参与者中都引入超时机制，并且把两阶段提交协议的第一个阶段分成了两步
    - CanCommit：与 2PC 的 Prepare 阶段类似
    - PreCommit：协调者将通知事务参与者准备提交或取消事务，写本地的 redo 和 undo 日志，但不提交
    - DoCommit：提交或回滚，如果无法及时收到来自协调者的信息之后，他会默认执行提交，不会一直锁定资源处于阻塞状态
  - TCC：解决 2PC 中的资源锁定和阻塞问题，减少资源锁定时间
    - Try：资源的检测和预留
    - Confirm：执行的业务操作提交，要求 Try 成功，Confirm 一定要成功
    - Cancel：预留资源释放

1. 分布式互斥

1.1 集中式算法（仿照单机）

选一个进程作为协调者，进程若要进入临界区，它向协调者发送请求消息，协调者负责处理

优点: 易实现、通信量少 (请求-许可-释放)
缺点: 单点故障、瓶颈、无法辨认服务器崩溃

1.2 分布式互斥算法（Ricart-Agrawala 算法）

Lamport 提出了一种分布式互斥算法，Ricart 等对它作了进一步的改进。

步骤 1：当一个进程想进入一个临界区时，它构造一个消息，其中包含它要进入的 <临界区的名字、它的进程号、当前时间>，然后它将该消息发送给所有其他的进程。
步骤 2：当一个进程接收到来自另一个进程的请求消息时，它根据自己与消息中的临界区相关的状态来决定它要采取的动作。
- 若接收者不在临界区也不想进入临界区，它就向发送者发送一个 ok 消息
- 若接收者已经在临界区中，它不进行应答，而是将该请求放入队列中
- 如果接收者想进入临界区但尚未进入时，它将对收到的消息的时间戳与包含在它发送给其余进程的消息中的时间戳（本身的时间戳）进行比较，时间戳最早的那个进程获胜。如果收到的消息的时间戳比较早，那么接收者向发送者发回一个 ok 消息。如果它本身的时间戳比较早，那么接收者将收到的请求放入队列中，并且不发送任何消息
步骤 3：在发送了请求进入临界区的请求消息后，进程进行等待，直到其他所有进程都发回了允许进入消息为止，一旦请求进程得到了所有进程的允许，它就可以进入临界区了。
步骤 4：当它退出临界区时，它向其队列中的所有进程发送 ok 消息，并将它们从队列中删除。

缺点：

n 点失败
n 点瓶颈
2(n-1) 个消息

改进方案：

超时重发
组通信
简单多数同意

1.3 令牌环算法

进程没有固定顺序，可以用软件的方法构造出一个逻辑环，环中为每个进程都分配了一个位置（如按网络地址），不管按什么方式分配，每个进程要知道谁在它的下一个位置上。进程从它邻近的进程得到令牌后，检查自己是否要进入临界区。如果自己要进入临界区，那么它就进入临界区，做它要做的工作，然后离开临界区。在该进程退出临界区后，它沿着环继续传递令牌。

2. 选举算法

许多分布式算法需要一个进程充当协调者，发起者，排序者或其他特定的角色。

2.1 欺负算法（Bully）

当一个进程 P 发现协调者不再响应请求时，它发起选举。进程 P 选举过程如下

P 向所有号码比它大的进程发送选举 (Election) 消息
若无人响应，P 获胜成为协调者
若有号码比它大的进程响应，响应者接管，P 的工作完成
由于总是号码最大的进程取胜，因而将该算法命名为欺负算法

...

3. 拜占庭问题与共识算法

3.1 拜占庭将军

Lamport 在 1982 年发表的论文《The Byzantine Generals Problem》描述了拜占庭将军投票问题，借以映射分布式系统中计算机通信容错问题。

Wikipedia

一组拜占庭将军分别各率领一支军队共同围困一座城市。为了简化问题，将各支军队的行动策略限定为进攻或撤离两种。因为部分军队进攻部分军队撤离可能会造成灾难性后果，因此各位将军必须通过投票来达成一致策略，即所有军队一起进攻或所有军队一起撤离。因为各位将军分处城市不同方向，他们只能通过信使互相联系。在投票过程中每位将军都将自己投票给进攻还是撤退的信息通过信使分别通知其他所有将军，这样一来每位将军根据自己的投票和其他所有将军送来的信息就可以知道共同的投票结果而决定行动策略。

投票系统的问题在于，军队中可能存在叛徒和敌军的间谍，左右将军们的决定又扰乱整体军队的秩序。这时候在已知有成员可能不可靠的情况下，其他忠诚的将军如何在不受叛徒和间谍影响的情况下意见达成一致，这就是拜占庭将军问题。

拜占庭将军问题提供了对「分布式共识」问题的一种情景化描述：

 拜占庭将军：即分布式系统的服务节点

 忠诚的将军：即分布式系统正常的服务节点

 叛变的将军：出现故障并发送误导信息的服务节点

 信使被杀：通信故障导致信息丢失

 信使被间谍替换：服务节点进行网络通信过程中信息被黑客攻击，通信存在劫持以及信息伪造

1998 年，Lamport 发表了名为《The Part-Time Parliament》的论文，这是 Paxos 算法第一次公开发发布，为网络异常情况下分布式系统如何保证数据一致性提供了一个解决思路。注意 Paxos 算法是有特定前提的，即先不考虑拜占庭将军问题（消息篡改）的情况。

《The Part-Time Parliament》中使用了大量的数学证明，考虑到大多数人理解起来比较困难，Lamport 于 2001 年发表了另一篇论文《Paxos Made Simple》，使用了逻辑推导来论述 Paxos 算法。

...

共识理论

1. 什么是共识

「共识」是指在分布式系统中，多个节点对某个数据值或决策达成一致意见。

用数学术语来描述一下分布式系统的共识问题：在一个包含 n 个实例的分布式系统中，集合 {0,1,2,…,n−1} 表示这些实例。每个实例 i 拥有一个初始值 vi。这些实例之间可以相互通信。系通过某种算法，使得即使部分实例出现故障，系统中的所有非故障实例仍能达成一致，选择出一个不可更改的最终决定值 vf。

共识算法三个性质：

终止性（Termination）：所有非故障的实例最终都会确定某一个值并终止算法执行。换句话说，算法不会无限期地执行下去，实例们都会在有限的时间内达成决议。
一致性（Consistency）：所有非故障的实例最终选择的值 vf 必须是相同的。
完整性（Integrity）：如果所有节点提议相同的值，那么该值一定会被最终选定为共识结果。

这些性质确保了在分布式系统中，即使面临部分节点故障或网络延迟等问题，系统仍然能够达成一个一致的决策，避免数据不一致的问题。

2. 一致性和共识

一致性：指的是在分布式系统中，多个节点在执行一系列操作后，通过遵循某些协议，确保它们对外部呈现的数据和状态保持一致。简单来说，就是确保所有节点上的数据是完全同步的，并且在某个提案（Proposal）上达成共识。

共识：指的是多个节点在分布式系统中就某个状态或决定达成一致的过程。

✅ 换句话说，一致性强调的是最终的状态是否一致，而共识则是实现这种一致性的手段。

3. 为什么要达成共识

在分布式系统中，多个节点（如服务器、进程等）共同协作来完成任务，对外感觉就像是一个单机的服务。由于是分布式的环境，一定会存在网络问题，时钟问题，以及节点故障问题，这些问题都将导致系统出现各种各样的问题，其可靠性得不到保证。比如：

选主（Leader Election）：在需要一个主节点进行写操作的分布式数据库中，系统必须确保在所有节点之间达成共识，选出一个主节点。如果网络出现故障，可能会导致出现多个主节点的情况，这样会引发数据冲突和一致性问题。共识算法能够保证在这种情况下，系统能够选出唯一的主节点。
原子提交（Atomic Commit）：在涉及多个节点或分区的分布式事务中，所有节点必须一致地决定是提交还是回滚事务，以保证事务的原子性。如果事务在某些节点上成功，而在其他节点上失败，系统就需要使用共识机制来确保所有节点做出统一的决定，要么全部提交，要么全部回滚。

可见，共识是分布式系统正常运转的最基本保障，只有在共识的帮助下，分布式系统才能保证一致性，像单一节点一样工作，对外提供可靠的服务。

4. 共识算法

「共识算法」也叫「一致性协议算法」，是用于在分布式系统中让多个独立的节点就某个决策或状态达成一致的一类算法。分布式系统中的每个节点都可能会因为网络分区、节点故障、延迟等问题，导致它们之间无法完全同步状态。因此，共识算法的目标是在这种不确定性和潜在的故障情况下，确保所有非故障节点最终能够就某个值或操作达成一致。

共识算法通常具备以下几个关键特性：

终止性（Termination）：所有非故障的实例最终都会确定某一个值并终止算法执行。换句话说，算法不会无限期地执行下去，实例们都会在有限的时间内达成决议。
一致性（Consistency）：所有非故障的实例最终选择的值 vf 必须是相同的。
完整性（Integrity）：如果所有节点提议相同的值，那么该值一定会被最终选定为共识结果。

4.1 常见的共识算法

Paxos：一种经典的共识算法，被认为是分布式一致性问题的基础解决方案
Raft：一种更易于理解和实现的共识算法，解决了 Paxos 的复杂性问题
ZAB (ZooKeeper Atomic Broadcast protocol)：ZooKeeper 使用的原子广播协议，确保分布式系统中的状态一致性

Paxos 算法

「共识算法」本质就是「一致性算法」

1. Basic Paxos

在正式介绍 Basic Paxos 算法之前，首先来看一个问题。

假设有一个分布式的 key-value 存储集群，有 A，B，C 三个节点，对外提供只读服务。也就是说，key-value 键值对一旦被创建，就不能再被修改。

假设此时，有两个客户端 client1 和 client2 同时发起创建键值对的请求，且创建的键值对 key 都为"Name"，client1 试图创建 “Name：张三”，client2 试图创建“Name：李四”，在这种情况下，这个分布式集群如何达成共识，实现在 A，B，C 各个节点上，Key 为"Name"的值是一致的呢。

这里其实就需要一种共识机制，保证集群中的 A，B，C 三个节点能达成一致，每个节点写入一样的值，Paxos 算法就能保证这样一种共识。

1.1 Paxos 涉及的概念

Basic Paxos 的工作机制主要分为三个角色和两个主要阶段。

1.1.1 提案（Proposal）

提案指的是需要在多个节点之间达成一致的某个值或操作，提案是由提案编号（n）和提案的值（v）组成的，可以表示为 [n, v]。每个提案的提案编号是唯一的。

1.1.1.1 提案编号

提案编号一般不是由 Paxos 算法生成的，而是由外部传入的。所以不同的业务场景可以按照自身业务需求，自定义提案编号的生成逻辑，只需要保证提案编号全局唯一并且单调递增即可。

比如在只有一个 Proposer 的环境中可以简单地使用自增 ID 或时间戳作为提案编号。例如，使用时间戳 1693702932000。在有两个 Proposer 的环境中，可以为不同提议者分配不同的编号序列。

例如，一个提议者使用奇数（1, 3, 5...），另一个提议者使用偶数（2, 4, 6...）。在有多个 Proposer 的环境中，可以为每个 Proposer 分配一个固定的 ServerId，并将自增序号或时间戳与 ServerId 组合，生成唯一的提案编号。例如，1.1 或者 1693702932000.1 表示 Proposer1 生成的第一个提案编号。每个 Proposer 在发起 Prepare 请求后如果没有得到超半数响应时，会更新自己的提案号，再重新发起新一轮的 Prepare 请求。

1.1.1.2 提案值

在 Paxos 算法中，提案值的具体内容也是根据实际业务需求来定义的。提案值可以是数值、字符串、命令（cmd），甚至是一些操作。比如在分布式数据库的场景中，可以将数据的插入、更新、删除操作等作为提案值。这种灵活性允许 Paxos 算法适应各种不同的应用场景。

1.1.2 三个角色

在 Paxos 算法中，角色分为提议者（Proposer）、接受者（Acceptor）和学习者（Learner），它们的关系如下：

提议者（Proposer）：处理客户端请求，主动发起提案（proposal）给所有的接受者（Acceptor），提议者的角色通常由集群中的某些节点担任
接受者（Acceptor）：被动接受提案，对提案进行投票，并存储已经接受的值，返回投票结果给 Proposer 以及发送通知给 Learner
学习者（Learner）：不参与提案和投票，只被动接收提案结果

一个节点，既可以是提议者，也可以是接受者！

在实际的分布式业务场景中，一个服务器节点或进程可以同时扮演其中的一种或几种角色，而且在分布式环境中往往同时存在多个 Proposer、多个 Acceptor 和多个 Learner。

1.1.3 两个阶段

1.1.3.1 准备阶段（prepare）

提议者（Proposer）：生成一个唯一的提案编号 n，并向所有的接受者（Acceptor）发送一个准备请求（Prepare Request），请求内容是编号 n，注意在准备阶段请求只会包含请求编号，而不会包含提案值。

接受者（Acceptor）：在收到准备请求后，接受者（Acceptor）会做出如下承诺：

如果接受者（Acceptor）收到过比此次提案编号n更大的准备请求，将丢弃这次准备请求，不作响应
否则：
1. 接受者（Acceptor）承诺不再通过编号小于等于 n 的提案的准备（Prepare）请求
2. 接受者（Acceptor）承诺不再通过编号小于 n 的提案的接收（Accept）请求，也就是不再通过编号小于 n 的提案
3. 如果接受者（Acceptor）已经通过某一提案，则承诺在准备请求的响应中返回已经通过的最大编号的提案内容，即提案值。如果没有通过任何提案，则在 prepare 请求的响应中返回空值，即尚无提案

从 prepare 流程可知：集群中的每个 Acceptor 会存储自己当前已接受（Accept）的最大提案编号和提案值。

1.1.3.2 接受阶段（accept）

提议者（Proposer）：在收到大多数接受者（Acceptor）的准备响应后，提议者将正式发起一个带有提案编号 n 和提案值 v 的接受请求 [n, v] 给所有接受者。

⚠️ 注意：这里提议者（Proposer）设置提案值 v 有一定的规则：如果在准备（prepare）请求的响应中，部分 acceptor 已经批准过的提案值，则 v 为 prepare 请求的响应中编号最大的提案值，否则可以由 proposer 任意指定。

接受者（Acceptor）：接受者（Acceptor）会根据准备阶段的响应情况作出如下承诺：

如果此时接受者没有通过编号大于 n 的准备请求，则会批准通过提案 [n, v]，并返回已通过的编号最大的提案（也就是 n）
如果此时接受者已经通过了编号大于 n 的准备请求，则会拒绝提案 [n, v]，并返回已通过的编号最大的提案（大于 n 的编号，比如 m）

提议者（Proposer）会统计收到的 accept 请求的响应，如果响应中的编号等于自己发出的编号，则认为该 acceptor 批准通过了该提案。如果存在大多数 acceptor 批准了该提案，则认为该提案已达成共识，即该提案被通过。如果没有大多数 acceptor 批准该提案，则重新回到 prepare 阶段进行协商。

需要注意的是：在准备请求中，proposer 只会发提案编号 n。而 accept 请求，proposer 会发送提案编号和提案值，也就是 [n, v]。

1.1.4 算法流程

先明确几个变量的意思：

minProposal：当前 acceptor 在 prepare 请求中通过的最大提案编号
acceptedProposal：当前 acceptor 在 accept 请求中通过的最大提案编号
acceptedValue：当前 acceptor 在 accept 请求中通过的最大提案编号的提案值

Acceptor 需要持久化存储 minProposal、acceptedProposal、acceptedValue 这 3 个值

算法流程如下：

第一阶段：Prepare 阶段

为提案生成一个全局唯一且递增的提案编号 n
Proposer 会向所有 Acceptor 节点发送一个包含提案编号 n 的准备请求（Prepare(n)）
当 Acceptor 接收到准备请求（Prepare(n)）时，会将 n 与其已知的最小提案编号 minProposal 进行比较，如果 n > minProposal，则更新 minProposal 为 n，并返回其当前已经接受的提案编号 acceptedProposal 和对应的值 acceptedValue 给 Proposer，如果 n 小于或等于 minProposal，则该请求将被拒绝，不作处理
Proposer 接收到大多数（过半）Acceptor 的响应后，如果发现有 Acceptor 返回了 acceptedValue，那么 Proposer 将选择所有响应中编号最大的 acceptedProposal 对应的 acceptedValue 作为本次提案的值。
如果所有 Acceptor 都没有返回 acceptedValue，Proposer 可以自由设置本次提案的值

第二阶段：accept 阶段

在确定提案的值后，Proposer 将向所有 Acceptor 节点广播接收请求（Accept(n, value)）
Acceptor 接收到 Accept(n, value) 请求后，再次比较 n 与其当前的 minProposal，如果 n >= minProposal，则 Acceptor 更新 minProposal 和 acceptedProposal 为 n，并将 value 设置为 acceptedValue，然后持久化该提案并返回确认。如果 n < minProposal，则该请求将被拒绝，并返回当前的 minProposal
Proposer 接收到大多数 Acceptor 的确认后，若发现有返回值 result（minProposal） > n，表示有更新的提议，跳转到步骤 1，否则认为当前提案已经达成一致

1.1.5 最终值选定

Acceptor 在每次同意新的提案值后，会将结果同步给 Learner。Learner 通过汇总各个 Acceptor 的反馈，判断是否已获得多数同意（超过半数）。如果达成共识，即获得了多数同意，Learner 会向所有 Acceptor 和 Proposer 发送广播消息，并结束提案。在实际应用中，Learner 通常由多个节点组成，每个 Learner 都需要接收到最新的投票结果。对于 Learner 的实现，Lamport 在其论文中提供了两种方案：

主从 Learner 架构：选定一个 Learner 作为主节点，专门接收投票结果（Accepted 消息），其他 Learner 节点作为备份节点。主节点接收数据后再将其同步到其他 Learner 节点。这种方案的缺点在于可能产生单点故障问题，如果主节点宕机，将无法获取投票结果。
分布式 Learner 同步：Acceptor 同意提案后，将结果同步到所有 Learner 节点，然后每个 Learner 节点再将结果广播给其他 Learner 节点。尽管这种方式避免了单点故障，但由于涉及多次消息传递，效率相对较低。

1.1.6 算法模拟

还是以开篇的例子来进行分析，在实际应用中，通常提议者（Proposer）是集群中的某些节点，接收客户端请求，将其封装成提案（proposal）。这里为了方便演示，将 Client1 和 Client2 看作提议者，并不会影响 Paxos 算法的本质。

准备阶段（prepare）：

假设 Client1 的提案编号是 1，Client2 的提案编号是 6，Client1 和 Client2 分别向所有的接受者发送准备请求

紧接着，节点 A 和节点 B 收先到提案者 Client1 的准备请求，编号为 1，节点 C 先收到提案者 Client2 的准备请求，提案编号为 6

分析各个节点在接收到第一个准备请求的处理过程

节点A、B：由于之前没有通过任何提案，所以节点 A 和节点 B 都将返回“尚无提案”的准备提案请求响应，并承诺，后续不再响应编号小于 1 的准备请求，也不会通过编号小于 1 的提案
节点 C：由于之前没有通过任何提案，所以节点 A 和节点 B 都将返回“尚无提案”的准备提案请求响应，并承诺，后续不再响应编号小于 6 的准备请求，也不会通过编号小于 6 的提案

接下来，节点 A 和节 B 收到提议者 Client2 发出的编号为 6 的提案，而节点 C 会收到提议者 Client1 发出的编号为 1 的提案

节点 A、B：此时收到的准备请求提案编号为 6，大于之前响应的准备请求的提案编号 1，并且节点 A 和节点 B 都还未通过（accept）任何提案，所以均返回“尚无提案”的准备提案请求响应，并承诺，后续不再响应编号小于 6 的准备请求，也不会通过编号小于 6 的提案
节点 C：由于节点 C 此时接收到的提案编号 1 小于之前响应的准备请求的提案编号 6，所以丢弃该准备请求，不作响应

接收阶段（accept）：

Client1 和 Client2 收到大多数节点的准备响应之后，开始发送接收请求（accept）

Client1：Client1 在接收到大多数的接受者（节点 A，B）的准备响应之后，会根据响应中的提案编号最大的提案值来设置接受请求的值。由于节点 A, B 均返回“尚无提案”，即提案值为空，所以 Client1 会自己设置一个提案值“张三”，把自己的提议值 “张三”作为该提案的值，发送接受请求 [1, “张三”] 给 A, B, C 三个 acceptor
Client2：同理 Client2 在接收到大多数接受者的准备响应后，也会根据响应中的提案编号最大的提案的来设置接受请求的值。由于节点 A, B, C 均返回“尚无提案”，即提案值为空，所以 Client2 会自己设置一个提案值 “李四”，把自己的提议值 “李四” 作为该提案的值，发送接受请求 [6, “李四”]

节点 A，B，C 收到 Client1 和 Client2 的接受请求之后

由前面的准备阶段响应可知，节点 A，B，C 承诺可以通过的最小提案编号为 6，而此时节点 A，B，C 接收到的 Client1 发出的接受请求为 [1, “张三”]，提案编号 1 小于承诺的提案编号 6，所以 [1, “张三”] 被拒绝，并向 Client1 返回当前 accepter 在准备请求中通过的最大提案编号 6

节点 A，B，C 收到 Client2 发出的接受请求为 [6, “李四”]，提案编号 6 不小于承诺的提案编号 6，所以提案 [6, “李四”] 被通过，节点 A，B，C 达成了共识，接收 Name 的值为 “李四”

假设集群中还有学习者，在接受者通过了某个提案后，会通知所有学习者。一旦学习者确认多数接受者都同意了这个提案，它们也会同意并采纳提案的值。

1.1.6.1 接受者存在已通过提案的情况

在上述例子中，在准备阶段和接受阶段均不存在已通过提案的情况，准备阶段接受者的请求响应都是“尚无提案”，假设有节点已经通过了提案点又是什么场景呢？想象出这样一个场景：

假设节点 A，B 已经通过了 [6, “李四”] 提案，而节点 C 尚未通过任何提案，此时，新增一个提议者 Client3，Client3 的提案为 [8，“王五”]

Client3 向节点 A，B，C 发送提案编号为 8 的准备请求。

节点 A 和 B 将接收 Client3 的准备请求，由于节点 A 和 B 已经通过了编号为 [6, “李四”] 的提案，所以它们在准备响应中会包含这个提案的详细信息。而节点 C 因为之前没有通过任何提案，因此它返回的是‘尚无提案’的准备响应。

在接收到来自节点 A、B、C 的准备响应后，Client3 随即向这些节点发送接受请求。特别要注意的是，Client3 会根据响应中提案编号最大的提案值来确定接受请求的值（1.1.3.2 小节的注意事项）。由于准备响应中包含了提案 [6, “李四”]，因此 Client3 将接受请求的提案编号设为 8，提案值设置为“李四”，即客户端 3 发送的接受请求为 [8, “李四”]。

节点 A, B, C 接收到提议者 Client3 的接受请求，由于提案编号 8 不小于三个节点承诺可以通过的最小提案编号 6，因此均通过提案 [8, “李四”]。

1.1.7 活锁问题

先看一个例子，这里 Server1 和 Server4 既作为 Proposer，又作为 Acceptor，Server1 即 Proposer1，Server4 即 Proposer4。所有的 server 都是 acceptor。P1.1 表示 Proposer1 发起的编号为 1 的 prepare 请求，P2.4 表示 Proposer4 发起的编号为 2 的 prepare 请求，以此类推。A1.1 X 表示 Proposer1 发起的 accept 请求，提案编号为 1，提案值为 X，A2.4 Y 表示 processe4 发起的 accept 请求，提案编号为 2，提案值为 Y，以此类推。

client1 向 server1 即 Proposer1 发起写入 X 的请求，client2 向 server4 即 Proposer4 发起写入 Y 的请求。

随着时间线从左往右看，server3 即 acceptor3 先收到 proposer1 发起的 prepare 请求 P1.1，由于没有通过任何提案，所以尚无提案，承诺不通过提案编号小于 1 的提案，随后 acceptor3 收到了 proposer4 发起的 prepare 请求 P2.4，由于此次天的编号 2 大于之前承诺的提案编号 1，所以向 proposer4 返回，承诺不再通过提案编号小于 2 的提案。

紧接着 acceptor3 收到 proposer1 发起的 accept 请求 A1.1 X，由于之前承诺了不再通过提案编号小于 2 的提案，而此次收到的 accept 提案编号为 1，所以拒绝。proposer1 发起的 accept 提案被拒绝了，所以它加大编号，又发起了 P3.1 的 prepare 请求，此次提案编号为 3，大于 acceptor3 承诺的最大提案编号 2，所以做出响应，回应承诺不再通过提案编号小于 3 的提案，随后 proposer4 发来 accept 请求 A2.4 Y，此时由于提案编号为 2，小于 acceptor3 刚刚承诺的最大提案编号 3，所以这个 accept 请求也会被决绝。proposer4 又加大 prepare 的提案编号，如此循环往复.....

一直通过多个 Proposer 的 prepare 请求，但是不能通过 accept 请求，导致一直没有提案通过，这样就形成了活锁。

1.1.7.1 活锁的定义

在多个提议者同时提出提案时，由于出现竞争，这几个提议者不断的更新提案编号，发起新的提案，导致一直没有 accept 请求被通过，导致提案一直不能通过，而陷入这样的死循环，就是活锁问题。

1.1.7.2 活锁的解决方案

随机延迟重试：当一个 Proposer（提议者）发现支持它的 Acceptor（接受者）数量小于半数时，Proposer 并不会立即更新编号并再次发起提案，而是会随机延迟一小段时间。这样做的目的是为了错开多个 Proposer 之间的冲突。
设置 Proposer 的 Leader：可以在系统中选举一个 Proposer 作为 Leader，让这个 Leader 负责发起所有的提案。其他 Proposer 不再主动提案，只在需要时响应 Leader 的请求。

2. Multi-Paxos

Basic Paxos 算法虽然能一定程度解决分布式系统的共识问题，但是存在很多的局限性：

它只能对一个值形成决议
提案的最终确定至少需要两次网络来回，在高并发情况下可能需要更多的网络来回，因此性能低下
当存在多个 Proposer 的时候，极端情况下甚至会形成活锁

因此 Basic Paxos 算法几乎只是用来做理论研究，并不直接应用在工程实践中。

有没有更好的算法策略能够有效解决 Basic Paxos 算法带来的这些问题呢？基于这种目的随即出现了 Multi-Paxos 算法

2.1 Multi-Paxos 算法概念

Multi-Paxos 算法其实是 Lamport 提出的一种思想，而并非具体的算法。可以认为，Multi-Paxos 算法是一类算法的总称，这类算法都基于 Multi-Paxos 思想，实现了一系列值共识。

2.2 Multi-Paxos 思想

总的来说，multi-paxos 思想基于 basic-paxos 算法做了两点改进：

2.2.1 领导者选举

在所有 Proposers 中选举出一个 Leader，让这个 Leader 唯一地提交提案（Proposal）给 Acceptors 进行表决。这样一来，就没有多个 Proposer 之间的竞争，从而解决了活锁问题。在只有一个 Leader 提交提案的情况下，Prepare 阶段可以被跳过，从而将原本的两阶段过程简化为一阶段，从而显著提高了系统的效率。

2.2.2 优化 Basic Paxos 执行过程

准备阶段的意义在于让 Proposer 通过发送 Prepare 请求来了解各个 Acceptor 节点上已通过的提案，但有了领导者（Leader）后，只有领导者才可发送提议，领导者独自负责提出提案，所以领导者能够保证提案的最新性和唯一性。因此，领导者的提案就已经是最新的了。所以不再需要通过准备阶段来发现之前被大多数节点通过的提案。领导者可以直接跳过准备阶段，进入接受阶段（Accept Phase），从而减少不必要的通信开销和 RPC 调用次数。

3. Paxos 面试题

3.1 Prepare 与 Accept 阶段工作过程差不多，为什么需要 Prepare 过程呢，Paxos 算法在设计之初为什么不直接进行 Accept 阶段呢

因为在 basic proxos 算法中，有多个 proposer 可以发起提案，一个 acceptor 可能通过不同的 proposer 发起的提案，prepare 请求的主要作用就是获取各个 acceptor 节点上已通过的最新提案，保证最新性和唯一性。

3.2 提案编号可以怎么生成

在只有一个 Processer 的环境中可以简单地使用自增 ID 或时间戳作为提案编号。例如，使用时间戳 1693702932000。在有两个 Processer 的环境中，可以为不同提议者分配不同的编号序列。例如，一个提议者使用奇数（1, 3, 5...），另一个提议者使用偶数（2, 4, 6...）。在有多个 Processer 的环境中，可以为每个 Processer 分配一个固定的 ServerId，并将自增序号或时间戳与 ServerId 组合，生成唯一的提案编号。例如，1.1 或者 1693702932000.1 表示 Processer1 生成的第一个提案编号

3.3 Paxos 协议的活锁问题怎么解决

随机延迟重试：当 Proposer 接收到响应，发现支持它的 Acceptor 小于半数时，不立即更新编号发起重试，而是随机延迟一小段时间，来错开彼此的冲突
设置 Proposer 的 Leader：可以在系统中选举一个 Proposer 作为 Leader，让这个 Leader 负责发起所有的提案，其他 Proposer 不再主动提案，只在需要时响应 Leader 的请求，等同于 Multi-Paxos 算法

分布式系统｜共识算法 Raft

Sun, 13 Apr 2025 00:00:00 GMT

Raft 算法

Raft 动图演示：http://www.kailing.pub/raft/index.html

更多链接：

分布式系统一致性模型与共识算法：Raft 详解

深度解析 Raft 分布式一致性协议

1. Raft 背景

Paxos 算法虽然理论上能够解决分布式的共识问题，但是其过于复杂，难以理解。实现 Paxos 算法的开源软件很少，比较有代表性的是 Google 的 Chubby。

正是由于 Paxos 算法的复杂性和实现难度，使得其在实际工程中的应用受到了限制。然而，分布式系统的发展迫切需要一种既高效又易于实现的分布式一致性算法。在这种背景下，Raft 算法应运而生，成为一种更具实用性和可读性的替代方案。

Raft 算法由斯坦福大学的 Diego Ongaro 和 John Ousterhout 在 2013 年发表的《In Search of an Understandable Consensus Algorithm》中提出。Raft 算法是一类基于日志复制的分布式共识算法，由于 Raft 算法易于理解和实现，在提出后，迅速获得了广泛关注，并成为了分布式系统中实际应用最广泛的一致性算法之一。目前，已经有十多种语言的 Raft 算法实现框架，比较有代表性的有 etcd、Consul，CockroachDB 等。

所以说掌握了 Raft 算法，就能比较轻松地处理绝大部分的一致性场景和需求，本文的大纲如下：

2. Raft 算法优化思路

Raft 算法为了达到易于理解的目的，主要做了两件事：

问题分解：将分布式共识问题拆分成主节点选举、日志复制、安全点，以及成员变更 4 个独立子问题逐一进行解决
状态简化：通过减少算法中需要考虑的状态数，使得算法更加清晰和易于理解

3. 领导者选举（Leader Election）

3.1 Raft 角色

在一个 Raft 集群中，每个节点有以下三种状态，一般也称这三种状态的节点为 Raft 集群的三种角色

领导者（Leader）
1. 处理客户端请求
2. 管理和同步日志
3. 定期向 Follower 发送心跳（Heartbeat）信号，以表明自己仍然存活，并防止 Follower 发起选举
跟随者（Follower）
1. 被动地响应 Leader 的日志同步请求
2. 响应 Candidate 发起的邀票请求
3. 把客户端打到 Follower 的请求转发给 Leader
候选者（Candidate）
1. 在集群刚启动或 Leader 宕机时，Follower 节点可以转换为 Candidate 并发起选举
2. 当 Follower 长时间未接收到 Leader 的心跳信号时，会认为 Leader 可能已经失效，从而将自己状态转换为 Candidate 并发起选举。Candidate 向其他节点请求选票，若获得超过半数节点的投票，它就会成为新的 Leader
3. 如果选举胜出，Candidate 转变为 Leader；否则，如果有其他节点当选为 Leader，Candidate 会返回到 Follower 状态

节点状态转换如下图所示

从上图可以看出，在集群启动时，所有的节点都处于 Follower 状态，如果在一段时间内，没有收到来自 Leader 的心跳信息，则 Follower 将切换成 Candidate，然后发起投票，如果该 Candidate 收到了多数（超过半数）的 Follower 的投票（包含该 Candidate 自己投给自己的一票），则该 Candidate 将切换成 Leader。在选举过程中，如果该 Candidate 发现有其他节点有比自己更新（即日志条目的任期号更高），它会自动放弃选举，并重新切回 Follower。

一句话概括：系统中最多只有一个 Leader，如果在某一段时间内没有 Leader，Follower 会通过选举投票的方式选出 Leader。Leader 会不停的给 Follower 发送心跳信息，保证自己的存活状态。如果 Leader 挂掉，Follower 会切换成 Candidate 发起投票，重新选出 Leader。

3.2 任期

任期是一个整数，用于标识 raft 集群的一个时间段。这个跟国家行政相似，比如上一个五年是领导人人 xx 任期的五年，这个五年是领导人 yy 的任期，可以简单的理解为“朝代”，用递增的整数表示。那对应到 raft 集群中，就可以简单的理解为，任期是某个节点处于 leader 的一个时间段。但这里需要明确一点，可能某些情况下，因为选票的分流，在选举期间内没有成功选出 Leader，则会进入下一个任期。任期示意图如下：

任期包含两个阶段：

选举阶段
已选举出 Leader 的阶段

同上面所说，任期也可能只包含选举阶段，没有 Leader，比如图中的任期 3，这种情况下，会立即进入到下一个任期，开始新的选举。

任期具有如下特点：

每个节点都会保存当前的任期（即一个标识时间段的整数），并随着集群状态的变化进行更新
Follower 等待 Leader 的心跳超时后，会推举自己为 Candidate 发起投票，此时会将当前任期编号加 1。比如当前该 Follower 保存的任期为 1，在推举自己为候选人邀票时，会将任期编号增加到 2
当一个节点发现自己保存的任期编号比另一个节点的任期编号小，它会主动更新自己的任期编号到最新的较大的任期编号，比如节点 A 当前的任期编号是 1，当收到来自节点 B 的请求投票的 RPC 消息时，因为消息中包含了节点 B 的任期编号，且编号为 2，那么节点 A 将把自己的任期编号更新为 2
如果一个节点接收到一个比自己任期编号小的 RPC 请求，该节点会立即拒绝这个 RPC 请求（无论是投票请求还是日志追加请求）。这是因为这个请求的任期编号已经过时，代表着发出请求的节点拥有的是旧任期，不再被视为合法的领导者或候选者
如果一个 Leader 或者是 Candidate 发现自己的任期编号比其他节点小，该节点会立即退回到 Follower，假设由于网络分区错误，集群中出现了两个 Leader，LeaderA 任期编号为 4，LeaderB 任期编号为 5，当网络分区错误恢复后，LeaderA 收到了来自 LeaderB 的心跳信息，LeaderA 将回退为 Follower，接收 LeaderB 成为 Leader

3.3 随机超时

Raft 算法中的随机超时有以下两种情况：

Follower 等待 Leader 心跳信息的超时间隔是随机的：这里的随机化的超时机制可以防止多个 Follower 同时转换为 Candidate，减少选举冲突
Candidate 等待选举结果的超时间隔是随机的：当一个节点转换为 Candidate 并发起选举后，会等待其他节点的投票结果，这个等待时间是随机的。如果在这个等待的时间段内，没有获得大多数选票，将再次随机设置一个等待时间，发起新一轮投票。这里的随机化的超时机制降低了多个 Candidate 同时发起选举的可能性

总的来说，在 Raft 算法中，随机超时机制是一个关键设计，保证在大多数情况下只有一个节点发起选举，避免多 Candidate 选举带来的性能问题

3.4 通信方式

在 Raft 算法中，节点之间通过远程调用（RPC）进行通信，主要涉及以下三种类型的 RPC：

投票 RPC：由 Candidate 节点在选举过程中向 Follower 发出
附加日志条目 RPC：Leader 节点在日志复制过程中将日志条目发送给其他 Follower 节点，同时也起到维持心跳的作用，确保 Leader 的存活状态
快照 RPC：当 Follower 的日志落后 Leader 太多时，Leader 会发送 Snapshot RPC 请求，通过快照的方式帮助 Follower 快速同步日志

3.5 选举流程

如上图所示：Follower 在收到 Leader 心跳信息超时后，会推选自己为 Candidate，将自身的任期+1，然后发起选举，如果在设置的时间内收到了多数选票，将晋升为新的 Leader，如果没有获得足够多的选票，收到 Leader 的心跳包，则 Candidate 恢复成 Follower 角色。

3.5.1 选举详细流程下面以三个节点的集群来演示下选举的详细流程

初始状态

初始时，每个节点的角色都是 Follower，任期 Term 为 0（假设任期编号从 0 开始），每个节点都设置了一个随机超时时间（节点 A：100ms，节点 B：120ms，节点 C：160ms），如下图：

发起投票

由于节点 A 的随机超时时间是设置的最小的，为 100ms，所以在 A 在 100ms 后倒计时结束被唤醒，成为 Candidate，并为自己发起投票，此时将自己的任期编号加 1，变为 1。先投自己一票，然后向其他的 Follower 发起投票 RPC 请求。

响应投票

Follower 节点 B 和 C 收到 Candidate 节点 A 的投票请求后，会做如下处理：

如果自身已经在任期编号为 1 的投票请求中投过票了，则会忽略该投票请求
否则，将自己的选票投给 Candidate，也就是节点 A，并将自身保存的任期编号设置为 1，然后重置随机超时时间

假设 B 和 C 都没有在任期编号为 1 的投票请求中投过票，此时都将选票投给 A，并设置自身的任期编号为 1，然后重置随机超时时间。

结束投票

3.5.2 多 Candidate 选举

从上面的选举过程可知，每个节点都会设置一个随机超时时间，这样可以降低了多个节点在同一时刻被唤醒成为 Candidate 的概率。但是也只是能降低概率，并且由于系统可能存在网络延迟，所以仍然无法完全避免多个 Follower 同时成为 Candidate 发起投票，假设这里有两个 Follower（A 和 B）同时被唤醒，转换为 Candidate 发起投票：

假设 A 和 B 设置的随机超时时间都是 120ms，在 A 和 B 节点被同时唤醒之后，会各自为自己投上一票，然后开始向其他节点发送投票请求，假设节点 C 先收到 A 的投票请求，之后再收到 B 的投票请求，那样 C 将会把选票投给 A，最终节点 A 获得两票（包含自己一票）成为 Leader，而节点 B 只会获得一张选票（自己的一票），则会回退成 Follower.

3.5.3 平票问题

一般在集群中，节点的个数都会选择奇数个，很重要的一点就是防止两个 Candidate 同时发起选票获得相同票数，导致系统内无法选出 Leader 的情况。但是由于系统可能出现故障，导致某个节点故障之后，依然可能会存在这个问题。假设集群中的节点是出现了偶数个，结果又会怎样呢？

假设集群中有 A，B，C，D 四个节点，其中 A，B 两个节点设置的随机超时时间都是 120ms。现在假设 A，B 被同时唤醒了，向其他节点发送投票请求。节点 A 和 B 在同一任期内竞选领导者时，由于每个节点在同一个任期内只能投票一次，A 和 B 都已经投了自己的票，因此不会再给对方投票。然后节点 C 把票投给 A，节点 D 把票投给 B，这样节点 A 和 B 都获得了两张选票，出现了平票的情况，这种情况下是不会有 Leader 被选出来的，所有节点会恢复成 Follower 状态，重新设置随机超时时间，准备下一轮的选举，虽然会有下一次轮的选举，直到选出新的 Leader，但是在这个过程中，集群都是处于不可用状态，所以选举的轮次越多，集群不可用状态越久，因此要尽量避免平票问题。

节点 A 和节点 B 回退为 Follower 之后，重新设置随机超时时间，节点 A 50ms，节点 B 100ms，等待超时时间开启新一轮的选举：

3.5.4 脑裂问题

前面所说的情况是在集群完全正常的情况下，一个集群中只会存在一个 Leader。假设在一个集群内发发生了网络分区，形成了两个分区，选举情况将会怎样进行呢？

这里以 5 个节点的集群为例，集群节点 A,B,C,D,E，节点 A 为集群 Leader。假设发生了网络分区，[A,B,C] 为一个分区，节点 [D,E] 为一个分区，由于 A 本身就是原集群的 Leader，所以 [A,B,C] 分区内还是按照以前的集群模式 A 为 Leader，向 B，C 节点发送心跳。而 [D,E] 由于发生了网络分区，收不到 A 节点的心跳信息了，假设 D 节点设置的随机超时时间较短，那么到时间后，会成为 Candidate，发起投票，成为 [D,E] 这个分区的 Leader，由于经过了一轮选举，那么 [D,E] 这个分区的任期将会比 [A,B,C] 分区的任期大 1。这个时候在整个集群 [A,B,C,D,E] 中就有了两个 Leader A 和 D，这就是“脑裂问题”。

脑裂问题如何解决？

其实在网络恢复后，虽然有了两个 Leader，Leader 都会向其他的节点发送心跳信息，这里 A 和 C 会互相收到对方发送的心跳信号，但是在 A 节点收到 C 节点发送的心跳之后，会发现携带的任期比自身保存的任期要大，所以 A 节点会退成 Follower，集群会再次恢复成只有一个 Leader 的状态。

4. 日志复制（Log Replication）

Raft 算法中第二个很重要的字问题就是日志复制，日志复制（Log Replication）是保证整个集群中的所有节点（follower）一致地存储相同状态的核心机制。它的主要目标是通过将客户端提交的指令（通常是状态变化操作）复制到每个节点的日志中，确保所有节点都达成一致的状态，即一致性。

4.1 日志

在 raft 日志其实是一种数据格式，主要用于存储客户端的一些列操作指令，日志由三部分组成，分别是：

索引值（Log index）
任期编号（Term）
指令（Command）

索引值：日志条目对应的索引值，用来标识第几条日志，是一个连续单调递增的整数
任期编号：创建这条日志条目的 Leader 的任期编号
指令：客户端发起请求需要执行的指令，例如指令 X <- 2 表示将 X 变量赋值为 2

一条日志也叫日志项，从上图可以看出，在一个 Leader 的任期内，可以有多个日志项，比如任期 1 内有 3 个日志项，任期 3 内有 4 个日志项。

日志还对应有两个状态：

committed（已提交）：针对的是日志，对应于某个日志项被成功复制到集群的大多数节点之后，这个日志项就处于 committed 状态，比如索引值 1-7 所对应的日志项均处于 committed 状态，因为他们都被复制到了大多数节点
applied （已应用）：针对的是状态机即节点，节点要将日志真正应用到状态机，即真正改变了节点上对应变量的值

4.2 日志复制过程

集群中只有 Leader 会跟客户端交互，接收客户端的指令，而这些指令除了要在客户端执行以外，还需要通过日志复制的方式讲这些指令复制到各个 Follower 节点，以保证集群的一致性。

日志复制的过程可以总结如下：

Leader 接收到客户端请求，请求中的指令创建一个新的日志项，然后追加（append）到当前本地日志中（此时 Leader 中该日志项的状态为 uncommitted）
Leader 通过日志复制 RPC 请求将该日志项复制到其他 Follower 节点（此时在各个 Follower 中该日志项的状态为 uncommitted）
当 Leader 确认将日志项成功复制到大多数节点后，Leader 会将该日志项标记为 committed，之后 Leader 会将该日志项应用到自己的状态机，即真正执行指令，修改对应的值
Leader 将执行结果返回给客户端
Leader 通过心跳或新的日志复制请求将提交了该日志项的状态同步给 Follower，如果 Follower 发现 Leader 已提交了该日志项，而自己还没将该日志项应用 apply 至状态机，则会将该日志项应用至自己的状态机中
如果 Follower 节点出现宕机或者由于网络丢包，Leader 会通过不断重试发送日志复制请求来确保日志条目最终复制到 Follower 上

可以看出，在日志复制过程中，只要有半数以上的处于正常工作的状态，整个系统就可用，假如在复制日志的过程中，出现了节点宕机、进程中断等问题，可能导致日志不一致，这种情况会怎么处理呢？

4.3 日志一致性

从前面的日志复制过程可以看出，在日志复制过程中，只要有半数以上的处于正常工作的状态，整个系统就可用，假如在复制日志的过程中，出现了节点宕机、进程中断等问题，可能导致日志不一致，这种情况会怎么处理，怎么来保证各个节点日志的一致性呢？

首先看一下 Raft 日志的特点，Raft 日志具体如下两个特性：

如果不同日志中的两个日志项有相同的「任期编号」和「索引值」，那么这两个日志项一定有相同的指令
如果不同日志中的两个日志项有相同的「任期编号」和「索引值」，那么这两个日志项之前的所有日志项也全部都相同

通过这两个特征其实可以看出，只要同步到位的日志都是一致的，在 Raft 算法中，其实是以领导者日志为准来实现日志的一致性的，主要包括两个步骤：

Leader 通过日志复制 RPC 请求的一致性检查，找到 Follower 节点上与自己具有相同日志项的最大索引值（在该索引值之前的日志项，Leader 和 Follower 是一致的，之后不一致）
Leader 强制 Follower 更新不一致日志条目，Leader 强制 Follower 将该索引值之后的所有日志项删除，并将 Leader 该索引值之后的所有日志项同步给 Follower

4.3.1 一致性检查

Leader 为了找到 Follower 节点上与自己具有相同日志项的最大索引值，每次日志复制请求除了发送该日志项之外，还要发送一些额外信息，这里引入两个新的概念：

prevLogIndex：Leader 当前需要复制的日志项的前一个日志项的索引值
prevLogTerm：Leader 当前需要复制的日志项的前一个日志项的任期编号

如下图，假设 Leader 当前需要将索引值为7的日志项发送复制到 Follower，则 prevLogIndex 为 6，prevLogTerm 为 3

下面以一个具体的例子来看：

当前 Leader 的最大日志项索引为 10，假设当前 Leader 需要将 10 号日志项复制给 Follower，步骤如下：

Leader 将索引值为 10 的日志项通过日志复制 RPC 请求发送给 Follower，同时还会发送该日志项的 prevLogIndex（9）和 prevLogTerm（3），Follower 收到消息后，判断自己没有索引值为 9 的日志，因此拒绝更新日志并向 Leader 失败信息
Leader 收到 Follower 的失败响应后，将日志项的索引值减 1，接着发送索引值为 9 的日志项并且携带 prevLogIndex（8）和 prevLogTerm（3）给 Follower，Followe 发现自己索引值为 8 的日志项中任期为 4，指令为 N <- 5，和 Leader 发过来的日志项不一样，再次拒绝更新，向 Leader 响应失败
直至需要复制索引值为 7 的日志项时，Follower 发现同步过来的 prevLogIndex 为 6，prevLogTerm 为 3，与自己在索引值为 6 的的日志条目相同（任期也是 3），则接收该日志复制 RPC 请求
Leader 收到跟 Follower 的成功响应后，Leader 通过日志复制 RPC 消息，强制 Follower 复制并更新覆盖索引值为 7 及之后的内容。保证 Follower 与 Leader 的日志状态一致

5. 安全性

前面分析了 Raft 算法是如何进行 Leader 选举以及日志复制的，但是这套机制还不能够完全保证每个节点都会严格按照相同的顺序 apply 日志，这就可能造成各个节点的状态机不一致。

假设有如下场景：

Leader 将某些日志项复制到了大多数节点上，在 commit 后发生了宕机
某个 Follower 尚未被复制这些日志项，但是在 Leader 挂了之后，进行的选举中，该 Follower 成为了 Leader
这个新的 Leader 又同步并提交了一些新的日志，这些日志覆盖掉了其它节点上的上一任提交的日志
各个节点在进行 apply 时可能应用了不同的日志序列，导致出现不一致

所以要想保证各个节点状态机一致性，光有 Leader 选举和日志复制策略还是不够的，还要有一些额外的措施，这就是本小节要讨论的安全性限制策略。

5.1 对选举的限制

回顾上述场景，为什么会出现日志被错误地覆盖，导致不一致。根本问题其实就是在第二部，一个落后的 Follower（还没被复制上一任 Leader 的最新日志）就当选了新的 Leader。那么他接下来的操作肯定会以自己的日志为准，导致集群中其他节点的日志被覆盖掉。所以这个 Candidate 来竞选 Leader 其实是不合格的，Candidate 必须有足够的资格才能当选 leader，所以在 Candidate 发起选举投票的时候，可以加一个条件限制：

⚠️每个 Candidate 发起投票 RPC 请求时必须在请求体中包含自己本地日志最新的任期编号（term）和索引值（index）当 Follower 收到 Candidate 的投票请求时，如果发现该 Candidate 的日志还没有自己的新，则拒绝投票给该 Candidate。

🌟在加了这个条件之后，再结合上本身 Candidate 就必须赢得集群大多数节点的投票才会成为 Leader，同时一条日志只有复制到了大多数节点才能被 commit，所以 Leader 就一定拥有所有 committed 日志。也就是说：Follower 不可能比 leader 多出一些 committed 日志。

比较日志新旧的策略也很简单：(term, index) 比较，先比较 term， term 更大的日志更新，term 相同的话，index 大的日志更新。

5.2 对提交的限制

单独的对选举加一定限制还不能保证日志的正确性，不正确的提交（commit）同样会带来问题。回顾一下 commit 的作用：

当 leader 得知某条日志项被成功复制到集群的大多数节点后，就可以进行 commit，表明该日志项可以被 apply 生效到状态机，committed（已提交）日志项一定最终会被状态机 apply。

但是不正确的 commit 也可能带来日志覆盖的问题，考虑如下场景：

图中的方框内的数字表示该日志项的任期 term，对应坐上面一栏的数字表示该日志项的索引值 index，一条日志项用（term，index）表示，从左到右随着时间集群状变更如下：

阶段 a：S1 是 leader，收到请求后将日志项(2, 2) 只复制给了 S2，尚未复制给 S3，S4，S5
阶段 b：S1 宕机，S5 选举获取了 S3、S4、S5 三票，当选任期（term）为 3 的 leader，收到客户端请求后保存了日志项（3，2），尚未复制给任何节点
阶段 c：S5 宕机，S1 恢复，S1 重新当选 term 为 4 的 leader，继续将日志项 (2, 2) 复制给了 S3，已经满足大多数节点（S1，S2，S3），于是 S1 将该日志项 commit
阶段 d：S1 又宕机，S5 恢复，S5 选举获得了 S2、S3、S4 三票，重新当选，将日志项(3, 2) 复制给了所有节点并 commit。注意，此时发生了日志覆盖错误，已经 committed 的日志项(2, 2) 被 (3, 2) 覆盖了

为了避免这个错误，需要在日志的提交阶段也加一个限制：

⚠️ Leader 只允许 commit 包含当前任期 (term) 的日志。

假设有了这个限制，再来模拟一下上述场景，在加了这个限制后，其实上述阶段的阶段 c 就出错了，阶段 c 虽然 S1 恢复当选了 term4 的 Leader，但是其并不能直接将日志项（2，2）commit，因为 S1 当前的日志为（4，3），必须等到（4，3）成功复制后才能 commit。

一旦有了这个限制，在阶段 c 就只存两种情况了：

日志项（2，2）始终没有被 commit，这样 S5 在阶段 d 将其覆盖就是安全的
日志项（2，2）连同（4，3）一起被成功 commit，这样的话，在阶段 d，S5 就无法成功当选 Leader（对选举的限制，当 Follower 收到 Candidate 的投票请求时，如果发现该 Candidate 的日志还没有自己的新，则拒绝投票给该 Candidate），就不存在上述问题了

6. 节点变更问题

集群中的节点数量并不是恒定不变的，比如随着业务的发展，集群需要扩容或者是缩容，那么就需要适当的增加或者是减少机器节点，又或者是某些几点出现了故障，需要变更机器等等，都需要变更集群的节点数量。Raft 算法如何处理集群成员节点变更的问题呢？

6.1 配置

在介绍节点变更过程之间，需要先明确一个概念：配置（configuration）

在 Raft 算法中，使用用配置来表示集群的节点集合，比如某个集群由 A、B、C 三个节点构成，那么集群的配置就是 [A, B, C]，在稳定的状态下，所有节点的配置都相同。从这里就可以知道，每个节点是通过这个配置信息来获取集群状态的，比如在选举，日志同步过程中，集群中有哪几个 Follower，Leader 需要向哪几个节点发送 RPC 通信都需要通过配置来获取。

6.2 节点变更可能带来的问题

集群中节点的变更很有可能给集群的一致性带来影响，主要是会影响集群的多数派。我们知道在 Raft 中很多场合都需要多数派的支持，比如在投票中，只有当一个节点收到多数派投票（超过半数）才会成为 Leader，在日志同步中，只有当 Leader 确认将日志项成功复制到多数派（超过半数）节点后，会将该日志项标记为 committed，类似的场景还有很多。

而集群节点的变更最主要的就是会影响到多数派，比如在一个三个节点的集群中原本只要 2 个节点就可以达到多数派，假设现在往集群新增两个节点，则需要三个节点才能达到多数派。

在 Raft 集群中，同样是由 Leader 节点负责同步集群的配置信息，当集群中出现节点变更，几乎不能保证所有节点同时进行配置的变更，由于网络先后等因素导致一部分节点配置已变更，另一部分没有变更在所难免，所以就会导致集群中部分节点使用的新的配置信息 C_new，而有的节点使用老的配置信息 C_old。

假设有如下场景中，原来集群有三个节点 [server1,server2,server3]，现在向集群新增了两个节点 server4 和 server5.

当处于画框的时间点时，假如此时出发了选举，server1 和 server2 用的是旧的配置文件 C_old，因此他们会从节点 [server1,server2] 中选出 Leader；而节点 server3，server4 和 server5 已经是新的配置文件 C_new 了，他们会从节点 [server3,server4,server5] 中选出新的 Leader。此时集群就可能会有两个 Leader，出现脑裂问题。

6.3 节点变更策略

前面分析了在集群变更的时候很可能导致集群的一致性出现问题，那又没有什么策略可以解决这个问题呢？主要有以下这几种解决方案。

6.3.1 串行更新

这种方法就是先将集群原来所有节点关闭，更新其配置后，再启动新的集群，显然这种方法很安全，可以保证集群始终只有一个 Leader，但是这种方法会导致每次成员变更时都需要关闭集群，导致集群无法对外提供服务，对于高可用的业务场景显然不适用。

6.3.2 单节点变更

每一次集群的变动只能新增或者删除一个节点，假设集群需要变更多个节点，那么需要分多个步骤来完成，每次只变更一个节点。比如原集群有 3 个节点，先需要扩容到 5 个节点，那么需要分两步，第一步扩充到 4 个节点，再由 4 个节点增加到 5 个节点，所以单节点变更法也叫单步成员变更法。

详细步骤如下：

客户端向 Leader 提交一个集群成员变更请求，请求的内容新增或者删除节点，以及服务节点的地址信息
Leader 在收到请求之后，向本地日志中追加一条配置信息志，其中包含了新的集群配置信息 C_new，之后，这个新的配置信息会随着 RPC 请求（AppendEntries）同步给所有的 Follower 节点。注意：配置信息日志被添加到日志中是立即生效（不需要 commit 之后再生效）
当配置信息日志被复制到新的配置信息 C_new 所标识的所有节点的多数派节点后，就 commit 该日志

提交配置日志的作用：

日志提交之后，才可以响应客户端，完成集群节点变更
标志着本轮节点变更已结束，可以开始下一轮的节点变更
如果集群中有删除节点，那么提交日志之后，被删除的节点可以关机了

6.3.2.1 单步成员变更法为什么可以解决集群节点变更带来的脑裂问题呢？

这里可以枚举出奇偶节点情况下，新增或者删除节点的情况

从上图可以看出，不管原集群节点数是奇数还是偶数，也不管是在原集群上新增一个节点还是删除一个节点，在集群的节点数变更之后，原集群的多数派和新集群的多数派一定存在交集，那么再同一个任期内，原集群 C_old 和新集群 C_new 中交集的那一个节点只会进行一次投票，要么投票给 C_old，要么投票给 C_new，这样就避免可同一任期出现在两个 Leader 的现象。

需要注意的是：单节点变更法虽然简单，很好理解，但是也有其缺陷，这种方式在串行化的方式下可以保证一个集群只能有一个 Leader，但是并发执行单节点变更，可能会出现一次单节点变更还没完成，新一次单节点变更已经执行，导致集群出现脑裂问题，这里不过多阐述，感兴趣的话可以去看 Raft 论文。

6.3.3 两阶段切换集群成员配置

虽然 Raft 论文中认为单步变更是更简单的办法，但节点变更有一定的问题，但是现在主流的实现都使用了 Joint Consensus（联合共识）算法来完成集群变更，也就是小标题所说的两阶段切换集群成员配置。

具体流程如下：

阶段一
1. 客户端将新配置 C_new 发送给 Leader，Leader 取旧配置 C_old 和新配置 C_new 的并集（称为联合配置（表示为 C_old,new））并立即 apply 即生效
2. Leader 将配置 C_old,new 包装成日志通过 AppendEntries 请求复制到 Follower 节点
3. Follower 收到 C_old,new 后立即生效，立刻应用该配置作为当前节点的配置，当 C_old,new 的大多数节点（即 C_old 的大多数节点和 C_new 的大多数节点）都切换后，leader 将 commit 该日志
阶段二
1. 紧接着 Leader 将新配置 C_new 包装成日志通过 AppendEntries 请求复制到 Follower 节点
2. Follower 收到 C_new 后立即生效，如果此时发现自己不在 C_new 列表，则主动退出集群
3. Leader 确认 C_new 的大多数节点都切换成功后，给客户端发送执行成功的响应

几个概念详细解释一下：

C_old,new：比如 C_old 为 [A, B, C]，C_new 为 [B, C, D]，那么 C_old,new 就为他们的并集 [A, B, C, D]
C_old,new 的大多数节点：是指 C_old 中的大多数和 C_new 中的大多数，如下表所示，第一行因为 C，D 节点还没有被复制到日志，导致 C_new 的多数派不能达成，所以该日志不能被 commit

上图展示了用两阶段提交方法集群节点变更过程中的几个过渡期：

虚线：表示已经创建但尚未 commit 的成员配置日志
实线：表示 committed 的成员配置日志

在每一个时期，每一个任期下都不可能出现两个 Leader.

原因如下

阶段一：C_old,new 日志尚未 commit

在这个阶段，集群中节点可能处于旧配置 C_old 下，也有可能处于联合配置 C_old,new 下，但无论这两种情况的哪一种，只要原 leader 发生宕机，新 leader 都必须得到旧配置 C_old 下大多数节点的投票，所以不会出现两个 Leader
再次强调一下：C_old 节点发起选举需要 C_old 的大多数，C_old,new 发起选举需要 C_old 和 C_new 两者的大多数

阶段二： C_old,new 已经 commit，C_new 下发之前

在这个阶段，C_old,new 已经被 commit，表示联合配置 C_old,new 已经被应用到了集群的大多数节点上（C_old 的大多数节点和 C-new 的大多数节点），因此当 leader 宕机时，新选出的 leader 一定是已经拥有 C_old,new 的节点，否则票数通不过，所以不可能出现两个 leader

阶段三： C_new 已经下发，但尚未 commit

在这个阶段，集群中可能有三种节点，集群中节点可能处于旧配置 C_old 下，也有可能处于联合配置 C_old,new 下，还有可能处于新配置 C_new 下，但由于已经经历了阶段 2，因此 C_old 节点不可能再成为 leader。而无论是 C_old,new 还是 C_new 节点发起选举，都需要经过大多数 C_new 节点的同意，因此也不可能出现两个 leader

阶段四：C_new 已经 commit

在这个阶段，C_new 已经被 commit，因此只有 C_new 节点可以得到大多数选票成为 leader，所以也不会出现两个 Leader，至此，集群已经安全地完成了这轮变更，可以继续开启下一轮变更了

7. 小结

Raft 算法将共识问题分解成了多个相对独立的子问题，从而简化了共识的实现。其主要流程包括领导者选举以及日志复制，集群先选举出 leader，然后 leader 负责复制、提交日志。当然为了在任何异常情况下系统不出错，还需要满足一定的安全性，以及需要对 Leader Election，Log Replication 两个子问题加一些限制条件。最后集群都是动态变化的，所以 Raft 算法也应用了单节点变更以及联合共识机制来保证集群节点安全的变更。

分布式系统｜理论基础

Sun, 13 Apr 2025 00:00:00 GMT

分布式系统概念

单机就不说了，分辨一下「集群」和「分布式」的区别：

集群是相同应用的多备份部署，同一份代码，功能相同，相当于多台单机，有效负载均衡，不过耦合度太高。
分布式则是将业务拆成了多个不同的子业务，每个子业务有单独的服务部署，这些子业务构成一个完整的系统。

熟悉了分布式的概念，这里需要强调一下「分布式」和「微服务」的关系：

微服务是一种软件设计理念，它是面向服务的，将大的系统或者是服务，拆分成一组小的且相互独立的服务。这些小的服务都是都是独立运行的，并且每个小服务有自己的数据库、业务逻辑，服务之间通过网络进行通信和协作。这组小服务一起协作对外提供服务，共同完成一个系统的任务。
微服务其实是一种特定的分布式系统架构风格，分布式是一种系统架构的范畴，而微服务是分布式系统的一种具体实现方式，微服务将应用程序拆分成小的、自治的服务单元，通过网络进行通信和协作来完成系统任务。分布式有很多种实现方式，微服务并不是它唯一的实现方式。

分布式理论基础

由于分布式系统中的程序是部署在多个节点上的，各个节点通过网络通信。一旦有网络通信，就会有网络的可靠性问题，延迟问题，以及各个节点的故障问题等等。可能出现有的节点能正常工作，而有的节点挂掉，导致有的请求达到正常节点就能正常处理，而打到故障节点又会失败。又或者因为网络故障，导致有的写操作在部分节点成功，而在另一些节点失败，总之可能存在种种状态不一致的情况，这些问题的存在影响着系统在高性能，高可用等方面的设计。而随着分布式的发展，人们总结出了一套分布式设计理论，这套理论对于后来分布式系统设计有着指导意义，这就是大名鼎鼎的 CAP 理论。

CAP 原理

更多：阮一峰｜CAP 定理

1. CAP 理论由来

Lynch 教授提出了一个影响深远的概念，如在一个不稳定（要么消息错乱，要么消息丢失）的网络环境里（异构模型），想始终保持数据一致是不可能的，这个概念为后来 CAP 理论的发展奠定了重要基础。

在 CAP 理论出来之前，并没有一个明确的方向性的指导。所以在设计实现分布式系统时会显得很混乱。可能在分布式系统中，不同的子模块有着不同的设计标准，对同一个系统而言，这显然不是很合理

比如在一个由两个模块构成的分布式系统中，这两个模块 A 和 B 之间能够互相通信

A 模块的设计原则是：A 发送请求给其他模块，如果节点间出现了故障，会选择不断的重试，一直等到节点通信恢复。可以理解为提供高质量服务。

B 模块的设计原则是：B 发送请求给其他模块，如果节点间出现了故障，会选择直接断开，并记下当前状态，等待后续处理，可以理解为提供高可用服务。

显然，系统中如果出现了通信故障，A 往 B 发请求，会出现不断重试，而 B 往 A 发请求，则会出现直接断开的情况，整个系统会很混乱。

所以，IT界的研究者们长期以来一直在探索指导原则来指导分布式系统的设计，在 2000 年 Eric Brewer 教授在 PODC 会议上首次提出了 CAP 理论。然而，当时这一理论还没有被正式证明，所以只能称为 CAP 猜想。

这个猜想一经提出，就在业界引起了极大的关注，因为它为分布式系统设计提供了一个简单而有力的框架。到了 2002 年，Seth Gilbert 和 Nancy Lynch 通过理论证明了 CAP 猜想的正确性，从而使 CAP 理论正式确立，并成为分布式系统设计中的重要理论基础之一。

2. CAP 理论

在一个分布式系统中，一致性（Consistency）、可用性（Availability）和分区容错性（Partition Tolerance）这三个目标无法同时满足，最多只能同时满足其中的两个。

2.1 数据一致性（C）

「数据一致性」是指在分布式系统中的所有节点，在同一时间点上拥有相同的数据副本。比如某个节点数据有更新，那么其他的节点数据要跟着更新，要求所有的读请求都必须读到这个新数据。

写操作（增、删、改）：数据变更
读操作

当数据服务有多个节点的时候，当数据服务接收到写请求时，怎样判定数据服务上所有的节点都一起发生了变更呢？

当然有的分布式系统由不同的策略配置，比如 MySQL 的主从集群，当配置为全同步时，即每次写数据只有当主库把数据都同步到从库后，才会返回成功，这样返回写成功后，称之为数据一致性改变。
如果不是这种配置策略，比如半同步，只有部分从库同步完了数据，也会返回成功，那么从从库读数据的话，可能就会读取不到新值，就不能称之为数据一致性改变。

假设「一主两从」的 MySQL 集群系统，在网络通信正常情况下，如果经过一次写请求后，两个从库节点都发生了数据变化。然后，读请求把这些变化后的数据都读取到了，我们就把这次数据修改称为数据发生了一致性改变。

假设系统内部发生了通信问题，主库和从库 2 之间的通信发生了故障，而主库和从库 1 之间的通信正常，那么写入操作成功之后，从库 1 可以读取到 V1 版本数据，而从库 2 无法读取到 V1 版本数据，地区到的还是旧数据。此时，系统中的节点就没有发生一致性改变。

2.2 可用性（A）

「可用性」是指系统要处于 100% 的可用状态，对于每一个请求，正常节点要在合理的时间给出正确的响应，即系统能够正常提供服务。

必须在合理时间内给出响应，时间根据业务要求来定。
只要正常的节点都能做出响应（无论数据是否最新）：
- 如果系统内的某个节点或者是某些节点宕机了，但是其他的正常节点可以在合理的时间内做出响应。
- 节点正常，但是节点上的数据有问题，比如不是最新数据，如果有请求达到这个节点上了，依然不能拒绝请求，要正常返回这个旧数据。

2.3 分区容错性（P）

「分区容错性」是指分布式系统能够在网络分区的情况下继续运行对外提供服务，即系统能够在节点之间进行通信的网络出现故障或延迟的情况下，保证系统的正常运行。

网络分区

网络分区只在分布式集群中，在分布式系统中，多个节点之间的网络本来是连通的，但是由于某些故障导致节点之间网络不通了，形成不同的子集，子集中节点之间网络互通，而子集与子集之间网络不通，整个网络就形成了几块区域，就是网络分区。

上图中，G1 和 G2 是两台跨区的服务器。G1 向 G2 发送一条消息，G2 可能无法收到。系统设计的时候，必须考虑到这种情况。

一般来说，分区容错无法避免，因此可以认为 CAP 的 P 总是成立。CAP 定理告诉我们，剩下的 C 和 A 无法同时做到。

3. CAP 为什么不能同时满足

这个问题看似是论证一致性、可用性、分区容忍性为什么只能选择其中的两个同时满足，其实并非如此。因为在分布式系统中分区容错性（Partition-tolerance ） 是不得不选择的。假设不考虑分区容错性，那就相当于把数据只存放在一个节点上，因为数据依旧集中在一个地方，一旦这个节点出现故障，整个系统毫无疑问会随之瘫痪，这在实际的生产环境中通常是不可接受的，而且数据集中在一个地方，这本身也与分布式相矛盾。

✅ 在分布式系统中，分区容错性（ P ）是一定要满足的，剩下的一致性（ C ）和可用性（ A ）只能满足其一。因此，分布式架构不可能选择 CA 架构，只能选择 CP 架构或者 AP 架构。

由于存在分区容错性，所以存在 server2 写入 X=2 失败，而 server1 写入 X=2 成功，那么此时 client2 和 client3 就会读取到不一样的值，client2 读取到 X=2，而 client3 读取到 X=1，此时系统可用，但是违背了一致性，保证了 A，但是违背了 C，属于 AP 架构。
假设此时要保持 X 值的一致性，server1 和 server2 的 Write 操作必须同时成功，系统必须等待 server2 也写入成功，在失败的这段时间里，系统是不可用状态，这样的话就保证了一致性 C，但是也降低了系统的可用性，违背了 A，此时属于 CP 架构。

由此可见，在分布式系统中，无法同时满足 CAP 定律中的 “一致性”、“可用性” 和 “分区容错性” 三者。

4. CAP 如何选择

任何方案选型都要根据业务场景出发，看业务场景适合哪种，就选哪种，一般而言：

CP 使用场景：比较典型的 CP 系统是分布式数据库，数据的一致性是最基本的要求。在极端情况时，优先保证数据的强一致性，代价就是放弃系统的可用性。例如，类似 Redis、HBase 这种分布式存储系统，以及 ZooKeeper 这种分布式协调系统。另一个常见场景就是金融领域，为了资金安全一般需要确保强一致性。
AP 使用场景：AP 则是适应于目前大多数对于用户体验要求高的互联网应用场景，比如社交媒体，内容分发业务，像微博、Instagram。用户量大，主机众多，分布式部署，而且集群的规模越来越大，节点故障、网络故障时有发生，要保证系统的可用性，保障 AP 放弃 CP 是常见的一种做法。

5. CAP 的不足

CAP 最大的不足其实也就是一致性（Consistency）、可用性（Availability）的强取舍问题。

在实际应用中，一致性和可用性并不只是简单的二选一问题，而是取决于各自的优先级。当我们强调一致性时，并不意味着系统的可用性会完全丧失。比如，在 Zookeeper 中，只有在主节点出现问题时，系统才可能会出现短暂的不可用状态，但在其他时间，系统通过各种方式来保证其可用性。同样，强调可用性时，通常也会采用技术手段来确保数据最终能够保持一致性。CAP 定理并没有详细说明这些细节。

✅ 其实简单来说，就是在设计分布式系统时，对于一致性和可用性希望有一些折中的手段，而不是选择了其中一个特性，就要完全舍弃另一个特性。

BASE 原理

正因为 CAP 理论存在一些局限性，eBay 的架构师 Dan Pritchett 基于他在大规模分布式系统中的实践经验，总结出了 BASE 理论。BASE 理论是对 CAP 理论的进一步扩展，其核心思想是，即便无法实现强一致性（Strong Consistency），应用程序也可以通过适当的方法达到最终一致性（Eventual Consistency）。

BASE 理论是一个更具工程实践意义的理论，它弥补了 CAP 理论过于抽象的问题，同时也为 AP 系统提供了整体的工程实践思想。目前 BASE 理论已经成为分布式系统中的核心理论之一。

1. 数据一致性

BASE 理论对数据一致性做了一些更细致的分类，从而对 CAP 理论作了进一步的扩展。数据一致性大致可以分为以下几类：

1.1 强一致性

数据更新操作完成之后，数据立即生效，后续的所有访问当中都能得到最新的结果。

1.2 弱一致性

数据更新操作完成之后，不要求立即可以读到最新写入的值，能容忍在更新发生之后，部分情况下无法访问到新数据的情况。

1.3 最终一致性

数据更新操作完成之后，能容忍更新后一段时间内无法访问到最新数据，不需要实时保证系统数据的强一致性，但是经过一段时间的同步之后，最终可以达到一个一致的状态。所以，最终一致性可以看作是弱一致性的一个特例。

而在 CAP 理论中的 C 指的是强一致性，所以要分析什么样的系统适合 AP，什么样的系统适合 CP，其实就是在强一致性和可用性之间做权衡，根据业务情况，看那些业务能够容忍最终一致性，而很在乎用户体验，这样的业务就适合 AP，而对于强一致性要求高的业务则适合用 CP。

2. BASE

BA 基本可用（Basically Available）：系统在遇到不可预知的故障时，允许损失部分可用性，就是说即使系统不能完全正常工作，但是仍然有部分功能可用。换句话说，但至少能够提供部分服务。例如，响应时间比平时长或者某些功能暂时不可用。
- 响应性能变弱：比如正常情况下请求响应为 0.3s，但是出现了某个故障之后，虽然还能正常响应，但是响应时长变为了 2s
- 系统功能有损：比如商城双十一活动时，评论模块出现故障，但不会影响交易、商品等核心模块的流程使用
S 软状态（Soft state）：指允许系统中的数据存在中间状态，这种状态可能是不一致的，但是这种中间状态的存在不会影响系统的整体可用性，因为数据在不同节点之间的同步可能存在延迟。
E 最终一致性（Eventual Consistency）：系统不要求数据实时地达到一致性，而是允许数据在一段时间后最终达到一致状态。这意味着在经过一定的时间之后，所有副本的数据会最终到达一致的状态。

既然在分布式系统中分区容错性我们无法回避，而根据 CAP 理论，我们要么选择 AP 模型，要么选择 CP 模型。但是在很多的场景中，尤其是对可用性要求高的场景往往既需要可用性，又想保证一致性，这里就出现了矛盾。所以这里可以在选择可用性的同时，弱化强一致性，但是并不是永远放弃一致性，在分区故障恢复后，根据各自的业务特点，经过一段时间系统应该达到最终一致性。而系统中一部分不一致时，系统仍需要保持系统整体“主要可用”，也就是基本可用。其实 Base 理论可以理解为：分区容错性 + 基本可用性 + 最终一致性；其实就是对 CAP 理论的一种延伸。

动图轻松理解 Self-Attention

Sat, 12 Apr 2025 00:00:00 GMT

Self-Attention 是 Transformer 中最核心的思想。我们在阅读 Transformer 论文的过程中，最难理解的可能就是自注意力机制实现的过程和繁杂的公式。本文在 Illustrated: Self-Attention 这篇文章的基础上，加上了自己对 Self-Attention 的理解，力求通俗易懂。希望大家批评指正。

1. Self-Attention 是什么？

我们再来讲解一个重要的概念，即 query、key 和 value。这三个词翻译成中文就是查询、键、值，看到这中文的意思，还是迷迷糊糊的。我们来举个例子：小明想在 b 站搜索深度学习，他把深度学习四个字输入到搜索栏，按下搜索键。搜索引擎就会将他的查询 query 映射到数据库中相关的标签 key，如吴恩达、神经网络等等，然后向小明展示最匹配的结果 value。

最后我们来说说 Self-Attention。和 Attention 类似，他们都是一种注意力机制。不同的是 Attention 是 source 对 target，输入的 source 和输出的 target 内容不同。例如英译中，输入英文，输出中文。而 Self-Attention 是 source 对 source，是 source 内部元素之间或者 target 内部元素之间发生的 Attention 机制，也可以理解为 Target=Source 这种特殊情况下的注意力机制。

下面我们通过一个简单的例子，来了解 Self-Attention 的计算步骤。

2. 计算步骤

2.1 定义 input

在进行 Self - Attention 之前，我们首先定义 3 个 1×4 的 input。 pytorch 代码如下：

import torch
x = [
    [1, 0, 1, 0],  # input 1
    [0, 2, 0, 2],  # input 2
    [1, 1, 1, 1]   # input 3
    ]
x = torch.tensor(x, dtype=torch.float32)

2.2 初始化权重

每个 input 和三个权重矩阵分别相乘会得到三个新的矩阵，分别是 key(橙色)，query(红色)，value(紫色)。我们已经令 input 的 shape 为 1×4，key、query、value 的 shape 为 1×3，因此可以推出与 input 相乘的权重矩阵的 shape 为 4×3。代码如下：

这三个不同的权重矩阵（$W_Q、W_K、W_V$）是通过神经网络模型的训练过程自动学习而来的。在自注意力机制中，这些矩阵是模型参数的一部分，它们的初值通常是随机初始化的。然后，通过训练数据和反向传播算法，模型会逐渐调整这些矩阵的值，以最小化预测误差（比如分类任务中的交叉熵损失）。

w_key = [
  [0, 0, 1],
  [1, 1, 0],
  [0, 1, 0],
  [1, 1, 0]
]  
w_query = [
  [1, 0, 1],
  [1, 0, 0],
  [0, 0, 1],
  [0, 1, 1]
]
w_value = [
  [0, 2, 0],
  [0, 3, 0],
  [1, 0, 3],
  [1, 1, 0]
]
w_key = torch.tensor(w_key, dtype=torch.float32)
w_query = torch.tensor(w_query, dtype=torch.float32)
w_value = torch.tensor(w_value, dtype=torch.float32)

print("Weights for key: \n", w_key)
print("Weights for query: \n", w_query)
print("Weights for value: \n", w_value)

2.3 计算 key, query 和 value

现在我们计算 key, query 和 value 矩阵的值，计算的过程也很简单，运用矩阵乘法即可：

key = input * w_key;
query = input * w_query;
value = input * w_value;

keys = x @ w_key
querys = x @ w_query
values = x @ w_value

print("Keys: \n", keys)
# tensor([[0., 1., 1.],
#         [4., 4., 0.],
#         [2., 3., 1.]])

print("Querys: \n", querys)
# tensor([[1., 0., 2.],
#         [2., 2., 2.],
#         [2., 1., 3.]])
print("Values: \n", values)
# tensor([[1., 2., 3.],
#         [2., 8., 0.],
#         [2., 6., 3.]])

2.4 计算 attention scores

例如：为了获得 input1 的注意力分数 (attention scores)，我们将 input1 的 query(红色)与 input1、2、3 的 key(橙色) 的转置分别作点积，得到 3 个 attention scores(蓝色)。同理，我们也可以得到 input2 和 input3 的 attention scores。

attn_scores = querys @ keys.T
print(attn_scores)

# tensor([[ 2.,  4.,  4.],  # attention scores from Query 1
#         [ 4., 16., 12.],  # attention scores from Query 2
#         [ 4., 12., 10.]]) # attention scores from Query 3

2.5 对 attention scores 作 softmax

上一步得到了 attention scores 矩阵后，我们对 attention scores 矩阵作 softmax 计算。softmax 的作用为归一化，使得其中各项相加后为 1。这样做的好处是凸显矩阵中最大的值并抑制远低于最大值的其他分量。

from torch.nn.functional import softmax

attn_scores_softmax = softmax(attn_scores, dim=-1)
print(attn_scores_softmax)
# tensor([[6.3379e-02, 4.6831e-01, 4.6831e-01],
#         [6.0337e-06, 9.8201e-01, 1.7986e-02],
#         [2.9539e-04, 8.8054e-01, 1.1917e-01]])

attn_scores_softmax = [
  [0.0, 0.5, 0.5],
  [0.0, 1.0, 0.0],
  [0.0, 0.9, 0.1]
]
attn_scores_softmax = torch.tensor(attn_scores_softmax)
print(attn_scores_softmax)

2.6 将 attention scores 与 values 相乘

每个 score(蓝色)乘以其对应的 value(紫色)得到 3 个 alignment vectors(黄色)。在本教程中，我们将它们称为 weighted values(加权值)。

weighted_values = values[:,None] * attn_scores_softmax.T[:,:,None]
print(weighted_values)

2.7 对 weighted values 求和得到 output

从图中可以看出，每个 input 生成 3 个 weighed values(黄色)，我们将这 3 个 weighted values 相加，得到 output(深绿)。图中一共有 3 个 input，所以最终生成 3 个 output。

outputs = weighted_values.sum(dim=0)
print(outputs)

# tensor([[2.0000, 7.0000, 1.5000],  # Output 1
#         [2.0000, 8.0000, 0.0000],  # Output 2
#         [2.0000, 7.8000, 0.3000]]) # Output 3

3. 回到论文

我们在 Attention is all you need 这篇论文中，可以看到这样一个公式：

$$ Attention(Q,K,V)=softmax(\frac{QK^T}{\sqrt{d_k}})V $$ 其实，这个公式就是描述了我们上面计算的过程。我们首先将 Query 与 Key 的转置作点积，然后将结果除以 $\sqrt{d_k}$ ，再作 softmax 计算，最后将计算的结果与 Value 作矩阵乘法得到 output。

这里有一个点，就是为什么要除以 $\sqrt{d_k}$，$d_k$ 表示的是词向量的维度。我们除以 $\sqrt{d_k}$ 是为了防止 $QK^T$ 值过大，导致 softmax 计算时上溢出 (overflow)。其次，使用 $d_k$ 可以使 $QK^T$ 的结果满足期望为 0，方差为 1 的分布。

4. 为什么这样计算？

最后的问题是，为什么要像公式那样计算呢？

我们先从 $QK^T$ 看起，从几何角度看，点积是两个向量的长度与它们夹角余弦的积。

如果两向量夹角为 90°，那么结果为 0，代表两个向量线性无关。
如果两个向量夹角越小，两向量在方向上相关性也越强，结果也越大。

点积反映了两个向量在方向上的相似度，结果越大越相似。

对 $QK^T$ 进行相似度的计算后，再使用 softmax 归一化。最后将归一化的结果与 $V$ 作乘法，计算的结果就是输入经过注意力机制加权求和之后的表示。

ChatGPT 是如何处理文字输入的？

Sat, 12 Apr 2025 00:00:00 GMT

我们清楚了 ChatGPT 模型的输入和输出，实际上就是将文字输入 ChatGPT 模型当中，然后再让模型预测出文字，本质上就是一个“文字接龙”式的语言模型。

而文字在进入 ChatGPT 模型之前，需要先经过一个转换，形成另外一种数据形式。在 ChatGPT 计算处理完之后，也需要将结果再做逆转换，形成文字形式，反馈给用户。这种转换包括两个步骤，Tokenizer 和 Embedding。本文主要介绍这两个模块。

Tokenizer

ChatGPT 官方目前已经开始对服务收费了，收费方式主要是计算用户使用的 token 数，数量越多，收费越高。

例如，用户提问了一条文本，文字（带标点和各种特殊符号）共有 50 个字符，但耗费了 30 个 token，ChatGPT 根据输入生成一条回答，总计 200 个 token，逆转换为文字总共 300 个字，那么用户一共消费的 token 数就是 30+200=230 个。那什么是 token 呢？

token 是任何 NLP 神经网络模型接收用户输入的最小粒度。 token 本身就是一些字符的组合，如英文单词#cat、中文词汇鞋子、英文词缀ly、中文汉字珂等，都可以看作是一个 token。

将用户输入的文本转换为 token 序列的过程就叫做 Tokenizer。它包含两部分，一部分是从文字转换为 token（设置在进入 ChatGPT 之前），另一部分是将 token 转换为文字，也就是逆转换（设置在 ChatGPT 模型输出之后）。

Tokenizer 算法 BPE 执行流程

Tokenizer 目前最流行的实现方法是 字符对编码 BPE（Byte Pair Encoding）算法，它也是 ChatGPT 采用的算法。BPE 算法是根据一份 token 词表（Vocabulary），将输入的文本拆解成若干个 token。其中，每一个 token 都存在于词表。

具体以如下一条输入模型的文本为例：

The newest car has a lower price and the lowest fuel.

这条文本中，包含了 53 个字符（包含字母、空格和标点，以及任何键盘可以打出的特殊符号，均输入 ChatGPT 中）。

一般地，模型训练所使用的词表中 token 数量大约从几万~几十万不等。假设 BPE 算法已经生成一个 Token 词表（Vocabulary） ，其部分词表 token 内容如下：

| #low | est | #new | er | #the | #car | | --------- | ------ | ---- | ---- | ----- | ---- | | #and | #fuel | #a | #has | #have | and | | #thailand | #price | #dog | #old | #most | ... |

BPE 算法就是根据上述 token 词表对文本进行匹配，从文本中拆分出存在于词表中的 token，将文本转换成如下的形式：

The newest car has a lower price and the lowest fuel.

==>

#The, #new, est, #car, #has, #a, #low, er, #price, #and, #the, #low, est, #fuel.

在这条例子中，文本被拆分成 15 个 token。由于英文单词是以空格形式进行分割的，因此，每一个单词的首字母都添加#为单词起始的标识，它可以理解为一个空格，不加#的token表示无法独立成词。一些单词被拆分成若干部分，如newest被拆分成两部分，#new 和 est。然后，模型就接收这样的 token 数据做进一步处理计算。

从上面的例子中，我们可以看出，token 中一般都是以非常高频的字符组合构成的，而且这些 token 往往具备一定的语义。例如，newest被拆解为#new 和 est，前半部分是单词词根，后半部分是英文形容词最高级。

同样地，ChatGPT 模型在回答用户问题，输出答案时，也是首先输出 token 序列，再将 token 序列反转为正常的自然语言文本，这个操作叫做 De-tokenization。它与 Tokenization 是完全互逆的操作。读者可以尝试把上面的 token 序列合并成完整的文本句子。

对于中文而言，常用汉字大约为 7000 个左右，而且文本之间不存在空格。因此，也可以采用上述的算法来完成，唯一的区别就是中文的 token 的开头不添加 # 符号。一些极为常见的中文单词可能合并为一个 token，如我们，而考虑到词频，绝大多数中文依然以单字独立成 token。

Byte-level BPE 算法

之前介绍的 BPE 算法是基于字符的，除此之外，还有一种基于字节的 BPE 算法（Byte-level BPE）。这种方法，主要是为了克服基于字符的 token 词表，由于各种特殊字符数量太庞大导致效果变差。

除了我们常用的中文外，ChatGPT 可以随意操作英文、日文、韩文、法文等至少二十多种文字。这些语言的文字和符号更是多种多样，有英文拉丁字母ABCDabcd，中文汉字千百花鸟风月，西里尔字母БГД，日语假名ピンイ，当然也包括很多 emoji 特殊符号💁👌🎍😍。

所有的字符在计算机中都是以 Unicode 编码格式实现的。

Unicode 编码是一种用于计算机表示全球范围内各种语言文字字符的标准编码方式，它为世界上所有的字符都分配了一个唯一的数字编号，解决不同国家和地区使用不同语言文字、字符集的问题。 Unicode 编码采用 16 进制表示，每个字符都有一个唯一的码点，例如汉字“中”在 Unicode 编码中的码点是U+4E2D，其中 U+ 表示 Unicode 编码，4E2D 是该字符的 16 进制码点。若以 UTF-8 编码为例，汉字“中”被转换为 3 个字节（byte） 的二进制数据：11100100 10111000 10101101。

Unicode 常用字符目前总量大约有十多万，如果直接基于字符形式，构造 token 词表的话，那么词表可能会变得非常庞大，达到几十万。过于庞大的词表会对 ChatGPT 模型产生很强的不确定性因素，让模型难以训练。

因此，Byte-level BPE 算法应运而生。这种算法的执行步骤和上述的 BPE 算法完全一致，唯一的区别在于，BPE 算法直接操作 Unicode 字符，而 Byte-level BPE 算法把文本的字节作为直接操作的对象。

由于操作的基本单位是字节而不是字符，因此即使是复杂的、多样化的文字系统（如中文、日文等），其基础元素也仅仅是256个可能的字节值。这相较于直接基于字符的BPE算法，其可能需要包含成千上万个不同的字符，词表大小显著减少。小型词表意味着模型训练和推理时的内存和存储需求大大降低。

例如，在 BPE 算法中，中 字被当作一个字符进行 token 匹配。而在 Byte-level 算法中，它被当作 3 个字符进行匹配（因其 Unicode 占用 3 个字节）。而英文字母如 p 则在两种算法中，都被当作一个字符处理，因为字母的 Unicode 编码只占用一个字节。所有的字节个数全部加起来不过 256 （即一个字节所表示的符号个数 $1\ Byte = 8\ bit = 2^8$）个，这对模型训练是一个巨大的利好。

Byte-level BPE 算法的代码链接：Byte-level BPE，感兴趣的可以阅读一下。

BPE 的词表是如何训练得到的？

BPE 的词表主要是根据训练文本语料统计得到的，训练的语料数量越大，得到的 BPE 词表越准确，越具有词根语义。

假设根据一份语料数据，我们可以统计得到如下词汇和其对应出现的次数。

| #lowest | 7 | #lower | 4 | #newest | 5 | #older | 5 | #newer | 4 | | --------- | ---- | ------ | ---- | ------- | ---- | ------ | ---- | ------- | ---- | | #and | 10 | #fuel | 4 | #a | 14 | #has | 4 | #oldest | 5 | | #thailand | 3 | #price | 6 | #new | 7 | #old | 6 | ... | ... |

以上均为文本中存在的完整的词汇。

接下来，我们可以按字母进行统计，得到频率最高的字符对为标红的 “es”，共计出现 17 次。我们单独把 “es” 提出来，并把语料中的所有 “es” 看作一个整体。
再重复上面的过程，可以发现“est”可以看作是“es” 和 “t” 的结合体，总计也出现 17 次。因此，可以把“est” 看作一个整体，放入词表，并把语料中所有的 “est” 看作一个整体。
再重复上面的过程，可以发现，“#a” 的频率仅次于 “est”，为 14 次。因此，把 “#a” 放入词表中。
再重复，可以把 “er” 这个字符对提取出来。
以此类推，我们可以逐渐将高频的字符对提取出来，不断放入词表中。
当放入词表中的 token 数达到了预定的最大数 N 时（一般从几万到几十万不等），得到最终的词表，即可用于 BPE 算法的执行流程，拆分每一条文本为若干 token。

Tokenizer 的好处

克服长尾效应 OOV

在英文单词中，最常出现的 5000 个单词占据了实际使用量的 90%。而那些极低频的单词数量极多，但总共加起来的实际使用量也不超过 2%。这就是自然语言的长尾效应 ，这种现象也出现在其它语言中。

直接把极低频的单词和字符当作 token，本身意味着数据量的缺乏，会导致它有可能不在词表中（Out Of Vocabulary，OOV），对 NLP 模型的性能产生很大的影响。因此，引入 Tokenizer，采用 BPE 算法可以避免低频词作为 token。

例如，根据上述训练例子得到的词表，#strangest 这个词在训练语料中词频较低，可能不出现在 token 词表中，但 “#strang” 和 “est” 一定以较高的频率出现在 token 词表中。

多语言支持

在早期，NLP 神经网络模型功能十分单一，且仅支持某一种语言。一个针对英文的文本分类模型，并不能支持中文的文本分类。而 BPE 算法，包括 Byte-level BPE 算法的设计，使得一份词表中包含了多种语言的字符，支持模型的多语言处理功能。

词嵌入｜Embedding

ChatGPT 的输入文字转换为 token 之后，还需要将 token 再转换为张量，这个过程叫做词嵌入（ Embedding），同时 embedding 也指被转换后得到的张量本身。

在神经网络中，张量（Tensor）是指多维数组，它可以存储和处理大量的数据，是神经网络中最基本的数据结构。张量一般都以浮点数（小数的一种计算机表示形式）作为元素进行填充。

例如，$a=[[1.034,0.932,−0.347],[0.023,−1.025,0.256]]$ 就是一个 $(2,3)$ 形状的张量，是一个多维数组。

而向量（vector），就是高中数学中的概念，一般就可以看作是一维张量。

ChatGPT 从功能上看，是一个语言模型，但从结构上看，它是一个多层的、复杂的神经网络模型，每一层的神经网络都在进行浮点数张量（Tensor）的数字计算，而 ChatGPT 的输入是文字符号，token 也是文字符号。因此，token 需要先转换为浮点数字，再进入模型中进行计算。将用户输入的 token 转换为浮点数张量的过程，就叫做词嵌入（Embedding） 。当模型将结果计算完，也要将最终的浮点数转换为具体的 token，作为输出。

#The, #new, est, #car, #has, #a, #low, er, #price, #and, #the, #low, est, #fuel.

仍以上述句子为例，假设 token 词表（Vocabulary）的数量总共为 N，每一个 token 都用一个 M 维的浮点数张量表示，其中每一个 token 都对应了一行张量，即该 token 的 embedding 表示。

例如，#price 这个 token 对应的 embedding 是一个 M 维向量：

$#price→ [0.103,0.034,0.129,−0.219,−0.156,...,0.0284,−0.172]$

这组数据就可以传入 ChatGPT 模型中，做模型的训练和使用。所有的词表组成了一个 $N × M$ 维度的张量，如下图左侧方阵。

根据例子中的前四个 token，我们可以将其对应的 embedding 抽取出来，按 token 的顺序排列成一组 $N_{输入token数}×M$ 的张量，这组张量即可输入 ChatGPT 进行操作，图中白色部分表示词表中的词汇未匹配到 token 序列。换句话说，它完成了由 token 到其对应张量的映射。

在实际模型当中，一次性输入给模型的 token 数量 $N_{输入token数}$ 并不是无限大的，例如，在 ChatGPT 的 gpt-3.5-turbo 版本中，最大的输入 token 数量为 4097 个，超出这个范围则会被模型自动截断。

在自然语言中，文字的顺序是非常重要的，“我喜欢你”，和 “你喜欢我” 表达的含义是完全不同的。所以，ChatGPT 考虑到模型的每个 token 相互之间的顺序不能改变，需要明确地在输入端标识出每个 token 的位置张量（Position Embedding），其大小和 token 的 embedding 是一致的。两者以如下形式融合起来：$embedding_{input}=UW_e+W_p$。

其中，$W_e$ 是 token embedding 矩阵，$W_p$ 是 position embedding 矩阵。而其中的 $U$ 是一个上下文矩阵。根据第 3 节的语言模型原理，模型在建模时有上下文限制，针对当前的一个 token，模型只能关注该 token 之前的 $k$ 个 token。因此，$U=(u_{-k},...,u_{-2},u_{-1})$，它是一个单位矩阵。

假设 token 数量小于模型可接收的最大数量，那么，上述公式可以退化为：$embedding_{input}=W_e+W_p$。

由此，即可输入 ChatGPT 模型进行计算。

第 1 节中提到，ChatGPT 是有多轮对话能力的。

在模型中，需要从输入端将输入1（Q1）、输出1（A1）、输入2（Q2）等部分信息区分出来。这几个部分信息分别叫做一个 segment，其中每一个 segment 都包含了多个 token，它们共享了同一个 segment embedding。具体方式如下：

上图中做了假设：Q1、A1、Q2 分别包含了 4 个 token。当然，在实际输入中，每个 segment 包含的 token 数都是可以灵活变化的；上面对话的轮数仅有两轮，而实际输入中，对话轮数可以非常多，形如 Q1、A1、Q2、A2、...、Qn，只要所有 segment 对应的 token 总数加起来不超过模型允许的最大 token 数即可。

因此，输入给 ChatGPT 的 embedding可以表示为如下公式： $$ embedding=embedding_{segment}+embedding_{position}+embedding_{token} $$

Embedding 的好处

最早的时候，NLP 是直接处理文本字符串，没有 Embedding 这个操作的。Embedding 这个操作最早是由 word2vec 模型提出并实施的，GPT 系列模型，包括 ChatGPT 已将此操作作为了固定默认步骤。

Embedding 方便接入大规模神经网络

我们在第 2 节中论述了，AI 想要有较高水平的智能，其模型规模必然比较大，参数量众多。在机器学习领域，神经网络模型是最容易扩展其模型规模的。我们会在第 8 节讲解神经网络相关的概念。

如果没有 Embedding 操作，那么 NLP 领域依然停留在直接处理字符的层面上，模型的规模扩展难度较大。embedding 将文字对应的 token 转换为抽象的固定维度的张量，标志着 NLP 迈入了深度神经网络的大门。

Embedding 抽象了 token 的语义

当我们训练好 ChatGPT 这个模型之后，假设我们抽取出如下 token 对应的 embedding 向量：

#price（价格），#cost（开销），#trunk（卡车），#texi（出租车）

其对应的均为 M 维 embedding 向量。计算两个向量相似度的方式主要采用余弦距离，则一定有： $$ cos(price,cost)>cos(price,truck) \ cos(truck,texi)>cos(cost,texi) $$ 其含义为，price 和 cost 在 embedding 上的相似度，要大于 price 和 truck 的相似度，这符合人们的语言直觉。可以得出结论，在自然语言中，语义相近的两个词汇，其 embedding 向量之间的数学意义上的距离更相近。

换句话说，Embedding 建立了自然语言的语义与数学之间的关联关系。

总结

Tokenizer 将模型输入的文字转换为 token 序列。
ChatGPT 使用了 BPE 算法实现 Tokenizer。
Embedding 将 token 序列映射为张量矩阵，方便模型进行张量矩阵运算。

ChatGPT 的灵魂：Attention 注意力机制

Sat, 12 Apr 2025 00:00:00 GMT

Original Paper：Attention is All You Need !

Recommended Post：Self-Attention Principle

OpenAI 的 GPT 系列模型，包括其它科技公司研发的各种最先进的 NLP 模型，甚至图像处理模型，广泛采用了 Attention 注意力机制进行建模，它可谓是当前 NLP 神经网络的灵魂机制。

注意力机制的思想

相信大家在学生时期，都被家长或老师提点过：“听课的时候注意力集中点！不要东张西望！” 这里就用到了注意力机制。这句话的含义是，学生应当把注意力集中在接收课堂知识上，而不是放在无关的信息上。

注意力机制的思想实际上广泛应用在各个方面，它可以抽象为如下形式：

一个智能体（人或 AI 模型）从接收到的大量信息（文本、图像、音频）中，剔除不重要、不相关的信息，重点关注与自身密切相关的信息。其核心在于收缩关注的信息范围，实现信息的压缩。

根据第 3 节的介绍，在 NLP 中，ChatGPT 语言模型建模实际上是寻找输入文本的上下文关联关系。例如：

例2：请补全这条语句：掘金社区是一个便捷的技术交流______

在这条文本中，想要补全最终的语句，应当参考前文的信息，而前文总共 14 个字，对空格处影响最大的是掘金两个字，而像形容词便捷的，系词是一个都不是最关键的影响因素。换句话说，我们应当设计一种注意力机制，让模型能够在输出空格字符的时候，最大限度地注意到掘金两个字。

注意力机制的建模

建立权重模式

根据第 4 节的介绍，在 NLP 模型中，自然语言是以 token 形式排列输入模型中的。如下图所示，绿色的每一列都是对应的一个 token 的 embedding 向量表示，假设每一个 token 的 embedding 具有 7 维，总共 14 个 token 共同组成一个 embedding 矩阵。我们的模型设计思路，是模型应当能够在输出平台的平 字时，更加关注到掘金二字。

让模型更加关注到掘金两个字，实际上可以认为，给掘金两个字对应的 token embedding 赋予更大的权重。

在神经网络模型中，所有的操作均为矩阵操作，所有的特征均为向量形式。设 $e_i$ 表示第 $i$ 个 token 的 embedding 表示，在例子中，它是一个 7 维的向量，$w_i$ 是第 $i$ 个 token 对应的权重值，它是一个标量值。那么，可以对所有的 token embedding 做一个加权： $$ h=\sum_ie_iw_i $$ 这里，$h$ 是一个加权后的结果，它也是一个 7 维的向量。它的本质含义，是从各个 token 不同的 embedding 中，按重要程度（权重值 $w_i$）做加和，权重值高的 $e_i$ ，对后续操作影响大，权重值低的 $e_i$ ，对后续操作影响小。这就产生了一种更加注意权重高的 $e_i$ 的效果。

softmax 函数

定义：softmax 函数是在机器学习和深度学习中广泛使用的一个非常重要的函数，尤其是在处理分类问题时。它可以将一个含任意实数的K维向量压缩（映射）成另一个 K 维实向量，其中每个元素的范围都在 $(0, 1)$ 之间，并且所有元素的和为 1。因此，softmax 函数的输出可以被视为一个概率分布。

公式：$Softmax(z_i)=\frac{e^{z_i}}{\sum^K_{j=1}e^z j}$

作用和特点：softmax 函数的输出可以解释为一个概率分布，每个元素的值代表了对应类别的概率。使用指数函数确保所有的输出都是正的，并且可以放大输入向量中的差异。softmax 函数配合交叉熵损失函数，常用于训练阶段的梯度下降优化。这种组合可以给出明确的梯度信息，有利于模型通过学习数据来调整参数，以提高分类的准确性。

应用场景：

多类分类问题：在神经网络的最后一层，用于将神经元的输出转换为预测每个类别的概率。

语言模型：在处理自然语言处理任务，如文本分类或机器翻译时，softmax 被用来预测下一个词的概率分布。

增强学习：在某些策略梯度方法中，softmax 用于从一组可能的动作中选择动作。

上面的加权计算中，$w_i$ 是一个标量值，假设模型经过训练后，针对上述例子的 token 计算得到：$w=(w_1,w_2,\ldots,w_i,w_{14})=(2.1,1.3,\ldots,-1.2,-0.4)$

其中的数值有正有负，前两个 token 对应的权重标量值较大，说明对后续操作的影响大。若直接进行加权，这不符合人们的一般认知。一般来说，权重占比以概率形式表示，概率值应当大于 0，小于 1，且所有分量的加和等于 1。

例如：今年国内的 GDP 占比中，第一产业占比 14.6%，第二产业占比 35.2%，第三产业占比 50.2%。

这是一个典型的概率分布示例，其总和为1，三产占比最高，权重最大，影响经济的程度最大。

因此，我们应当将 $w$ 转换为概率占比形式，主要采用 softmax 方法： $$ α_i=\frac{exp(w_i)}{\sum_i exp(w_i)} $$ 其中，$exp$ 是指数计算，$α_i$ 表示第 $i$ 个 token 的 embedding 对应的权重，其值介于 0~1 之间。计算上例，假设： $$ w=(2.1,1.3,0.1,0,−0.2,−1.3,0.5,0.2,−0.8,0,0.1,−0.7,−1.2,−0.4) $$ 那么，第 1 个 token 的权重： $$ α_1=\frac{exp(2.1)}{\sum exp(w_i)} = \frac{8.166}{8.166+3.669+1.105+1+\cdots+0.301+0.67}=\frac{8.166}{21.858}=0.374 $$

此外，其它若干 token 的权重为： $$ α_2=\frac{exp(1.3)}{\sum exp(w_i)} = \frac{3.669}{8.166+3.669+1.105+1+\cdots+0.301+0.67}=\frac{3.669}{21.858}=0.167 $$

$$ α_6=\frac{exp(-1.3)}{\sum exp(w_i)} = \frac{0.272}{8.166+3.669+1.105+1+\cdots+0.301+0.67}=\frac{0.272}{21.858}=0.012 $$

第 1、2 个 token 对应掘金 两个字，分别占权重 37.4% 和 16.7%，占比较高，第 6 个字是一，它的 token 对应的权重仅 1.2%，占比较低。这说明，在这个模型中更加注重了掘金 的权重，方便后续模型输出正确的字符 token。

这个例子说明了 softmax 算法的一些特性：

1、softmax 可以将一维向量，输出形成概率分布的形式；

2、softmax 利用指数函数，会更加着重值更高的元素，使要关注的元素更加突出；

3、相应地，由于指数函数特性，它也可以尽力压低不需关注的元素的权重。

以公式形式表示，计算模型的所有 embedding 加权后的权重： $$ h=\sum_i e_i α_i $$ Softmax 函数在神经网络模型中十分常用，除了应用在注意力机制计算外，softmax 还可以完美契合交叉熵损失函数（将在第 8 节中介绍）。

自注意力机制 Self-Attention

前文讲述了，利用权重向量 $w$ 就可以找到模型要关注的重点内容。那么，$w$ 从哪来呢？值如何计算出来？

计算权重，不同的模型、不同的 NLP 任务都有不同的形式。这项技术经过多年的发展，最终趋向于自注意力机制（Self-Attention） ，这也是 ChatGPT 所采用的形式。

$w$ 是一个权重向量，其长度（维度）与 token 的个数相同，其中的每一项是标量值。我们知道，神经网络模型中都是以向量、矩阵等构成的张量作为计算基础的。因此，想要计算得到一个标量值，最简单的形式就是向量点积，我们需要想办法找到两个向量。

假设针对第 $i$ 个 token，有两个向量 $q_i$ 和 $k_i$，两者具有相同的维度，其点积可以得到一个标量值：$w_i=q_i k_i$

依然以前述句子为例。在补全句子时，掘金对要空格处填写的字符，影响最大。而“掘金对要填写什么字符，影响最大”这一认知，依然是我们阅读这个句子本身得到的。换句话说，$w_i$ 权重的信息来源，依然是原句子本身（Self），这就是自注意力命名的原因。

因此，我们可以直接把每个 token 的 embedding 分别当作向量 $q_i$ 和 $k_i$ 进行计算。计算过程如下图所示。

更详细的解析请见：动图轻松理解 Selft-Attention（自注意力机制）

当我们计算第 $i$ 个 token的 $w_i$ 值时，以第 1 个 token 掘字为例，应当先观察整条文本的 token，将所有的 token 都和 掘 token 做计算，这实际上就是在比较 掘 token 和其它 token 的关联关系。

在上图中，$q_i$ 含义为 query（中文含义为查询向量），和 $k_i$ 的含义为 key（中文含义为钥匙向量）。

为何起名 query 和 key？

query 和 key 这两个词，最初是计算机搜索引擎中提出的概念，在 AI 领域中，被引申到注意力机制上。

例如，当我们在 Google 搜索引擎中查询搜索“成都有什么好吃的？”时，搜索引擎会按匹配程度给出若干回答。

其中，用户的搜索问句，就被称为 query，而每一条匹配到的结果，都包含和 query 的关联性，也就是各自的 key。通过 query 和每一条 key 的匹配，就可以得到问答搜索结果的匹配程度。

回到上图中，当计算 掘 token 的输出向量时，即利用其 query 向量，分别和每一个 token 的 key 向量做点积，并对这个点积 score 做归一化（图中的 2.645 实际上是 $\sqrt7$，即 query 向量的维度 $\sqrt{d_q}$）。由此，就得到了熟悉的 $w$ 权重向量，进而执行 softmax，就得到了一个概率分布 $\alpha$ ，由此可以计算出 掘 token 的输出向量。

为什么要除以 $sqrt{d_q}$ ？神经网络模型的训练过程是采用梯度下降法来完成的。这里具体细节不展开，你可以参考第 8 节的内容。

梯度下降非常像一个人从山顶上走到山脚下。放在神经网络的训练中，一个良好的训练过程，是人能够顺利找到下山的路，平稳下来。而若遇到一段很长的平路，没有向下的坡路，则说明模型训练遇到了阻碍。

既然模型需要做梯度下降，则必须保证模型在做参数运算过程中，梯度值是存在且较大的。而 softmax 函数很容易造成梯度消失，消失原因在于，输入 softmax 函数的值过大。

在上述例子中，$q_i k_i$ 乘积过大，会导致模型训练过程中的梯度消失，进而模型训练失败。因此，为了限制这个乘积值，需要除以这两个向量的维度根号值，确保数值在稳定的范围内。

计算后续每个 token 位置的输出向量均同理。若想计算最后一个输出位（即空格处，第 15 个 token 要填的字）的向量，计算方法也和上面同理。

上述计算方式是一步一步地以向量表示形式展开的。若以矩阵形式做公式计算，则可以表示为： $$ Attention(Q,K,V)=softmax(\frac{QK^T}{\sqrt{d_q}})V $$ 其中：

$Q=(q_1,q_2,\ldots,q_i,\ldots,q_{d_q})$
$K=(k_1,k_2,\ldots,k_i,\ldots,k_{d_k})$
$V=(v_1,v_2,\ldots,v_i,\ldots,v_{d_v})$

其中，$QK^T$ 就是点积的矩阵形式，最右侧的 $V$ 可以理解为 token embedding 组成的矩阵。$softmax(*)V$ 实际上就是前述各个 embedding 的注意力权重 $\sum_i e_i \alpha_i$ 的矩阵表示形式，$e_i$ 表示第 $i$ 个 token 的 embedding 表示，$\alpha_i$ 是注意力权重概率值。

还需要补充说明的是，我们在讲解注意力机制的计算过程中，默认了 $q_i, k_i, v_i$ 都是 token embedding 本身，在实际的模型中却并不是这样。

第 2 节中，我们提到了 ChatGPT 模型为了体现强大的模型拟合能力，具备较为高级的智能，其模型参数量是随着规模逐渐增大的。到了 ChatGPT 的基础模型 GPT3.5，模型训练的参数规模已经达到了 1750 亿。

神经网络模型之所以很容易契合模型膨胀扩张这一需求。其关键特点在于可以加参数。

在 $q_i、k_i、v_i$ 这里，也可以扩充参数，提升模型的拟合能力。

具体来讲，$Q、K、V$ 三个模型矩阵都是由 token embedding 矩阵做一个矩阵变换得到的。其维度也可以和 embedding 的维度不同。具体形式如下图所示。

具体过程参见「动图轻松理解 Self-Attention.md」

在图中，$W_Q、W_K、W_V$ 均为模型参数，它们都是神经网络模型扩展的可训练参数。其具体计算方法为：

$q_i=W_Q e_i$
$k_i=W_K e_i$
$v_i=W_V e_i$

需要明确的是，$Q$ 和 $K$ 的维度必须是相同的，这样才能保证可执行点积运算。而 $V$ 的维度则可以灵活多变，图中特意以 4 维和 7 维强调这一点。但一般来讲，三者和 token embedding 的维度保持一致即可。

如果我们把注意力机制的输入输出当作一个黑盒，我们可以观察其输入、输出为如下形式：

经过了一层自注意力机制之后，模型的输入和输出结构是相仿的，每一个 token 和其上下文经过对比之后，又生成了一个对应的融合了上下文信息的向量表示。

因此，我们完全可以多多堆叠自注意力层，不断地让模型学习上下文联系。ChatGPT 也确实是这么干的，这将在第 6、7 节中展开讲。

注意力机制的好处

通过本节的介绍，我们已经非常清楚，自然语言中自注意力机制是如何将每个 token 的上下文融合起来的，这是目前深度学习模型最流行的操作。

正如例句中，空格处要填写的内容，位于句子的末尾，而信息相关的 掘金 二字则位于句首，中间跨越了很多个 token，寻找两者之间的关联关系，注意力机制非常擅长。技术上讲，这叫注意力机制擅长计算长文本依赖。

而在过去，神经网络里主要使用循环神经网络（RNN）模型结构来处理。RNN 的网络结构可以使用如下公式来解释：$e_i=h(e_{i-1},W_{RNN})$。

其中，$h(*)$ 是 RNN 的计算函数，$e_i$ 是第 $i$ 个 token 的网络内的 embedding 表示，$W_{RNN}$ 是模型参数。它表示了第 $i$ 个 token 必然和其相邻的第 $i-1$ 个 token 相关联，而无法跨 token。在处理例句的注意力时，局限性很强。

另外，深度学习中模型的计算量超级大，为了让 ChatGPT 模型能够快速输出结果，就需要采用并行计算的方式。

所谓并行计算，就是一种朴素的加速思想，一个工作，一个人干需要10天，那么找10个人来，一天时间干完。在程序里，主要就是采用多核 GPU 来计算。

注意力机制相比 RNN，更加方便模型在工程上实施并行加速计算。

总结

注意力机制的本质是从大量信息中剔除杂质、无关信息，保留感兴趣的信息。
注意力机制在 NLP 领域的应用主要是 自注意力 Self-Attention 形式，它是神经网络具备充分拟合能力的灵魂。
在第 1 节中，我们提到了，Transformer 是构成 ChatGPT 这座房子的砖块和钢筋，而自注意力机制则是构成 Transformer 的核心要素。下一节，我们就来介绍 Transformer 结构和原理。

C++ STL 与常见语法糖

Sat, 12 Apr 2025 00:00:00 GMT

刷题常见语法

function｜`auto&& dfs`

1️⃣ 关于 [572. 另一棵树的子树] 代码中的 auto dfs = [&](auto&& dfs, TreeNode* node) -> pair<int, bool> {} 传递 auto&& dfs 的解释。

// 572. 另一棵树的子树
class Solution {
public:
    int getHeight(TreeNode* root) {
        if(root == nullptr)
            return 0;
        int left_h = getHeight(root->left);
        int right_h = getHeight(root->right);
        return max(left_h, right_h) + 1;
    }

    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr || q == nullptr) {
            return p == q;
        }
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }

    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        int hs = getHeight(subRoot);
        
        auto dfs = [&](auto&& dfs, TreeNode* node) -> pair<int, bool> {
            if(node == nullptr)
                return {0, false};
            auto [left_h, left_found] = dfs(dfs, node->left);
            auto [right_h, right_found] = dfs(dfs, node->right);
            if(left_found || right_found)
                return {0, true};
            int node_h = max(left_h, right_h) + 1;
            return {node_h, node_h == hs && isSameTree(node, subRoot)};
        };

        return dfs(dfs, root).second;
    }
};

🔥 为什么需要在调用 dfs 传递 dfs 自身：为了能够递归调用 dfs，我们需要在 lambda 的内部将其传递给自己。C++ 的 lambda 本身是不能直接递归的，因为它只是一个匿名函数对象，不知道如何调用自身。因此，我们显式地将 dfs 作为参数传递给它自身，以便在递归时能正确调用。

2️⃣ 如果要简化调用方式（即不重复传入 dfs），那可以这样定义：

auto dfs = [&](this auto&& dfs, TreeNode* node) -> pair<int, bool> {
    ...
}
// call
dfs(root);

3️⃣ 当然也可以使用 function<pair<int, bool>(TreeNode*)>dfs = [&](TreeNode* node) -> pair<int, bool> {}; 这样就只需要传一个参数，但是也显得代码有些臃肿，看个人习惯，我比较习惯直接用 function 而不是 auto，也可以是：auto&& dfs = [&](auto&& dfs, TreeNode* node) -> pair<int, bool> {};

`->`，`.` 常见用处

. 是结构体的成员运算符。用于通过对象或引用直接访问对象的成员。

struct MyStruct {
    int x;
    void func() { /* ... */ }
};

MyStruct obj;
obj.x = 10;   // 使用 . 来访问成员变量
obj.func();   // 使用 . 来调用成员函数

-> 是指针指向其成员的运算符。组合操作符，相当于先解引用指针，再通过 . 访问成员。

MyStruct* ptr = &obj;
ptr->x = 20;   // 使用 -> 来访问成员变量
ptr->func();   // 使用 -> 来调用成员函数

其它用法：

pair<int, int> p 使用 p.first

// 对象
std::pair<int, int> p = {1, 2};
p.first = 10;
// 指针
std::pair<int, int>* pPtr = &p;
pPtr->first = 10;

迭代器通常是一个对象（例如容器的迭代器），但它通常表现为类似指针的行为，所以迭代器 iterator 使用 -> 来解引用访问元素

// 迭代器是对象
it.operator++();  // 假设 it 是一个迭代器对象，可以直接调用成员函数

// 但是访问元素需要使用 -> 解引用
auto it = mp.begin();
it->first; 	// 访问 std::map 或 std::unordered_map 中的 pair 成员
// *it 解引用迭代器后通常指向容器中的元素，-> 是 (*it).member 的简写

关于 for 在 map 与 pair 中的遍历

unordered_map<int, int> mp{{1, 2},
                           {3, 4}};
// iterator
auto it = mp.begin();
cout << it->first << ": " << it->second << std::endl;

// unordered_map
for (auto &p: mp) {
    std::cout << p.first << ": " << p.second << std::endl;
}

vector<pair<int, int>> vec{{1,  2},
                           {11, 22}};
// pair
for (auto &p: vec) {
    std::cout << p.first << ": " << p.second << std::endl;
}

常见数据结构数值大小

size_t：是一种在 C 和 C++ 中常见的无符号整数类型，它用于表示某个对象或类型在内存中的大小，通常由 sizeof 操作符返回。size_t 的定义在标准头文件 <stddef.h>（C 中）或 <cstddef>（C++ 中）中。

无符号类型：size_t 是无符号整数，这意味着它不能表示负值（始终 >= 0）。
平台相关：size_t 的具体大小依赖于平台的架构。在32位系统上，size_t 通常为 4 字节（32 位）；在64位系统上，它通常为 8 字节（64 位）。
典型用途：size_t 主要用于数组索引、内存大小计算、malloc 和 calloc 等内存分配函数的返回值。

// 像 STL 的容器 size() 函数返回值是 size_t，而 size_t 是一个与机器相关（32bit，64bit）的无符号整数类型，
size_t size() const;

// 死循环
for (size_t i = N; i >= 0; --i) {
	// todo
}

其他常见数据结构类型

| 数据类型 | 字节大小 | 数值范围 | | ------------- | ---------------------- | ----------------------------------------- | | char | 1 | -128 到 127 或 0 到 255（无符号） | | signed char | 1 | -128 到 127 | | unsigned char | 1 | 0 到 255 | | short | 2 | $-2^{15}$ 到 $2^{15}-1$ | | int | 4 | $-2^{31}$ 到 $2^{31}-1$ | | long | 4 或 8 | ... | | long long | 8 | $-2^{63}$ 到 $2^{63}-1$ | | wchar_t | 2 或 4 | ... | | char16_t | 2 | 0 到 $2^{16}-1$ | | char32_t | 4 | 0 到 $2^{32}-1$ | | size_t | 4 或 8（根据机器而定） | 0 到 $2^{32}-1$ 或者 0 到 $2^{64}-1$ |

`atoi()`, `stoi()`, `iota()`, `itoa()` 与 `c_str()`

c_str()：将 string 转为 char*，即把 C++ 字符串对象转换为 C 风格的字符串（以 \0 结尾的字符数组）

// const char* c_str() const noexcept;
std::string str = "hello";
const char* cstr = str.c_str();  // cstr 现在为 "hello"

itoa()：Integer to ASCII；将整数转换为 C 风格的字符串（即以 \0 结尾的字符数组），返回指向转换后字符串的指针，即参数 str 的地址
iota()：Incremental Fill；将指定范围内的每个元素赋值为一个递增的值，通常用于生成序列

itoa() 为 C 库函数

// char* itoa(int value, char* str, int base);
char buffer[20];
itoa(12345, buffer, 10);  // 将整数 12345 转换为字符串 "12345"

// void iota(ForwardIt first, ForwardIt last, T value);
std::vector<int> vec(5);
std::iota(vec.begin(), vec.end(), 10);  // vec 现在包含 {10, 11, 12, 13, 14}

atoi()：ASCII to Integer；将 char* 转为 int，因此对于一个字符串 str 我们必须调用 c_str() 的方法把这个 string 转换成 const char* 类型；不会做范围检查，如果超出范围的话，超出上界，则输出上界，超出下界，则输出下界。

atoi() 为 C 库函数

// int atoi(const char* str);
const char* str = "123";
int num = atoi(str);  // num 现在为 123

stoi()：String to Int；将 string 转为 int，且会做范围检查，默认范围是在 int 的范围内的，如果超出范围的话则会 runtime error.
stof()：String to Float；将 string 转为 float，同上
to_string()

// int stoi(const std::string& str, size_t* pos = 0, int base = 10);
std::string str1 = "456";
int num1 = stoi(str1);  // num 现在为 456

// float stof(const std::string& str, size_t* pos = 0);
std::string str2 = "3.14";
float num2 = stof(str2);  // num 现在为 3.14f

max_element() 与 min_element()

std::max_element() 和 std::min_element() 分别是取「最大值」和「最小值」的函数

C++ 20 也可以使用 ranges::max_element() 与 ranges::min_element()

std::vector<int> v{3, 1, -4, 1, 5, 9};

// ForwardIt max_element( ForwardIt first, ForwardIt last );
int mx_elem = *max_element(v.begin(), v.end());

// ForwardIt min_element( ForwardIt first, ForwardIt last );
int mn_elem = *min_element(v.begin(), v.end());

// 自定义 compare 函数
auto it = std::max_element(v.begin(), v.end(), [](int a, int b)
    {
        return std::abs(a) < std::abs(b);
    });
std::cout << *it << std::endl;

`__builtin_popcount(nums[i])`

__builtin_popcount(nums[i]) 是 GCC 和 Clang 编译器中的内置函数，用于计算一个整数中二进制位为 1 的数量。

// 3011. 判断一个数组是否可以变为有序
class Solution {
public:
    bool canSortArray(vector<int>& nums) {
        // __builtin_popcount(num): GCC 和 Clang 编译器中的内置函数，用于计算一个整数中二进制位为 1 的数量
        int n = nums.size();
        int pre_max = 0;
        for (int i = 0; i < n;) {
            int mx = 0;
            int ones = __builtin_popcount(nums[i]);
            while (i < n && __builtin_popcount(nums[i]) == ones) {
                if (nums[i] < pre_max) {
                    return false;
                }
                mx = max(mx, nums[i++]);
            }
            pre_max = mx;
        }
        return true;
    }
};

resize() 知多少

ans.resize(n, avg) 多出的空间用 avg 补全，数组变短则直接截断。

ranges::nth_element()

相关例题：1738. 找出第 K 大的异或坐标值

ranges::nth_element(vec, vec.end() - k) 求取第 k 大的数并放在对应位置，左边比其小，右边比其大，但顺序不保证。

// 1738. 找出第 K 大的异或坐标值
class Solution {
public:
    int kthLargestValue(vector<vector<int>>& matrix, int k) {
        int m = matrix.size(), n = matrix[0].size();
        vector<int> ans;
        vector<vector<int>> s(m + 1, vector<int>(n + 1));
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                s[i + 1][j + 1] = s[i][j] ^ s[i + 1][j] ^ s[i][j + 1] ^ matrix[i][j];
                ans.push_back(s[i + 1][j + 1]);
            }
        }
        ranges::nth_element(ans, ans.end() - k);
        return ans[ans.size() - k];
    }
};

lower_bound() 与 upper_bound()

lower_bound() 和 upper_bound() 都是利用「二分查找」方法在排序数组中进行查找。

lower_bound(nums.begin(), nums.end(), num)：找第一个大于或等于 num 的数字
upperer_bound(nums.begin(), nums.end(), num)：找第一个大于 num 的数字

// 2529. 正整数和负整数的最大计数
class Solution {
public:
    int maximumCount(vector<int>& nums) {
        int neg = ranges::lower_bound(nums, 0) - nums.begin();
        int pos = nums.end() - ranges::upper_bound(nums, 0);
        return max(neg, pos);
    }
};

等价于 ranges::equal_range()

class Solution {
public:
    int maximumCount(vector<int>& nums) {
        auto [left, right] = ranges::equal_range(nums, 0);
        int neg = left - nums.begin();
        int pos = nums.end() - right;
        return max(neg, pos);
    }
};

`std::move()` 与右值表达式

推荐阅读：一文读懂 C++ 右值引用和 std::move

1. 什么是右值和左值？

在 C++ 中，表达式的值可以分为两种类型：左值（lvalue） 和 右值（rvalue）。

左值（lvalue）：
- 左值表示一个具有持久存储（可以取地址）的对象，通常是变量或可以出现在赋值操作符左边的表达式。
- 例如：变量、数组元素、对象的成员等。
- 示例：
```
int x = 10;
x = 20; // x 是一个左值，可以赋值。
```
右值（rvalue）：
- 右值表示一个临时值或不持久存储的值，通常是表达式的结果，如常量、临时对象、运算结果等。右值通常无法取地址，也不能在赋值操作符的左边使用。
- 示例：
```
int y = 10 + 20; // 10 + 20 是一个右值，只是一个计算结果。
int z = 30;      // 30 是一个右值。
```

2. 右值引用（rvalue reference）

右值引用是 C++11 引入的一种新特性，它允许你通过引用操作右值。它的语法是在类型后面加上 &&，例如：int&& 表示一个右值引用。

右值引用的用途：
- 移动语义：允许通过移动（而不是复制）资源来优化性能，特别是对于涉及大量数据的对象（如大数组、字符串等）。
- 完美转发：在模板编程中使用，允许将函数参数完美转发给另一个函数。

右值引用的示例：

int x = 10;
int&& rvalueRef = 10; // 10 是右值，rvalueRef 是一个右值引用。

3. `std::move()` 的作用

std::move() 是 C++ 标准库中的一个函数模板，用于将一个左值显式地转换为右值引用。这种转换允许开发者以右值引用的方式来处理本应是左值的对象，从而触发移动语义。

为什么需要 std::move()：
- 移动语义：在实现对象移动时（例如在 std::vector 中），你可以通过 std::move() 将资源从一个对象“移动”到另一个对象，而不是复制它们。这样可以避免不必要的资源分配和释放，极大提高性能。
- 避免复制：通过 std::move()，你可以明确告诉编译器，你不再需要某个对象的值，所以可以将其资源移动到另一个对象中。

std::move() 的示例：

#include <iostream>
#include <string>
#include <utility> // std::move

int main() {
    std::string str = "Hello, World!";
    std::string newStr = std::move(str); // str 的内容被移动到 newStr 中。

    std::cout << "str: " << str << std::endl;    // str 现在可能为空。
    std::cout << "newStr: " << newStr << std::endl; // newStr 拥有 "Hello, World!"。
    return 0;
}

输出：

str: 
newStr: Hello, World!

在这个例子中，std::move(str) 将 str 转换为一个右值引用，这样 newStr 可以接管 str 的资源，而不需要复制字符串的内容。str 在移动后，其内部资源（如字符串数据）被转移到 newStr，因此 str 变为空或处于未定义状态。

4. 移动语义与对象的生命周期

当对象的资源被移动后，原对象通常会被清空或置于一种安全的“空”状态。你不应再依赖或使用已移动的对象，除非明确知道它处于什么状态。

移动构造函数：

当一个对象被移动时，通常会调用它的移动构造函数。移动构造函数接受一个右值引用，并将资源从旧对象移动到新对象。

示例：

class MyClass {
public:
    MyClass() : data(new int[100]) {}
    ~MyClass() { delete[] data; }

    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(other.data) {
        other.data = nullptr; // 旧对象的指针设为 nullptr，表示资源已被转移。
    }

private:
    int* data;
};

5. `std::move()` 与右值引用的通俗理解

右值引用：你可以把右值引用看作是一个能够接管“临时对象”所有权的“特殊指针”，它可以直接操作这些临时对象而不会额外复制数据。
std::move()：它并不是真正“移动”了什么东西，而是“转换”了一个左值，使其变得可以被视为右值（临时对象），这样你就可以使用右值引用来操作它。其背后是为了优化性能，减少不必要的资源复制。

move 总结

右值引用（int&&）允许你捕获和操作临时对象，从而实现更高效的资源管理。
std::move() 是一种显式的类型转换工具，将左值转换为右值引用，告诉编译器可以“安全地”移动这个对象的资源。
使用 std::move() 和右值引用，可以避免不必要的复制操作，优化代码的执行效率，尤其是在处理大量数据的对象时。

C++ ranges 包

该包位于 #include <algorithm>

#include <algorithm>

std::vector<int> vec = {1, 2, 3};

ranges::sort(vec);

ranges::for_each(vec, [](int& n) { n *= 2; });

ranges::find(vec, 1);

int cnt = ranges::count_if(vec, [&](int x) { return x % 2 == 0; });

// 原地去重: 移除范围内的重复连续元素， unique() 返回去重后最大值的指针位置
auto it = std::ranges::unique(vec);

//constexpr const T& max( const T& a, const T& b, Comp comp = {}, Proj proj = {} );
int mx = ranges::max(1, 9999);
vector<vector<int>> nums;
//constexpr T max( std::initializer_list<T> r, Comp comp = {}, Proj proj = {} );
int max_end = ranges::max(nums, {}, [](const auto& a) { return a[1]; })[1];

// fill 快速填充
int min_d[26];
ranges::fill(min_d, INT_MAX);

ranges::lower_bound(nums, 0);

ranges::upper_bound(nums, 0);

ranges::reverse(vec);

auto [left, right] = ranges::equal_range(nums, 0);

ranges::nth_element(ans, ans.end() - k);

bool isEmpty = ranges::empty(vec);

auto size = ranges::size(vec);

auto begin = std::ranges::begin(vec);
auto end = std::ranges::end(vec);

auto dist = std::ranges::distance(vec.begin() + 1, vec.end() - 1);
auto distance = std::ranges::distance(vec);

关于 `static auto x = []()` 的用法解析

推荐阅读：关于 static auto x = []() 的用法解析

static const auto _ = []() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    return nullptr;
}();

class Solution {
public:
    // 官方题解
    bool canThreePartsEqualSum(vector<int>& arr) {
        int s = accumulate(arr.begin(), arr.end(), 0);
        if(s % 3 != 0)
            return false;
        int target = s / 3;
        int n = arr.size(), i = 0, cur = 0;
        while(i < n) {
            cur += arr[i];
            if(cur == target)
                break;
            ++i;
        }
        if(cur != target)
            return false;
        int j = i + 1;
        // 满足最后两个数组非空
        while(j + 1 < n) {
            cur += arr[j];
            if(cur == target * 2)
                return true;
            ++j;
        }
        return false;
    }
};

`ios::sync_with_stdio(false)`

作用: 这行代码用于解除 C++ 标准流（cin, cout, 等）与 C 标准流（scanf, printf, 等）的同步。
原因: 在 C++ 中，cin 和 cout 默认与 scanf 和 printf 这类 C 的输入输出流同步，以确保它们可以混合使用而不会出现顺序问题。然而，这种同步会带来性能开销。
效果: 将 ios::sync_with_stdio(false) 设为 false 后，cin 和 cout 不再与 C 标准流同步，因此可以提高输入输出的效率，但这也意味着你不应再混用 C 和 C++ 的输入输出函数，否则可能会导致未定义行为。

`cin.tie(nullptr)`

作用: cin.tie(nullptr) 用于解除 cin 和 cout 之间的绑定关系。
原因: 默认情况下，cin 和 cout 是绑定在一起的，这意味着在每次使用 cin 进行输入操作前，cout 会自动刷新缓冲区，以确保输入输出顺序的正确性。然而，这种绑定关系在处理大量数据时会带来性能损失。
效果: 将 cin 的绑定关系设为 nullptr 后，cout 不会自动刷新缓冲区，从而提高了程序的运行效率。但这意味着你需要手动刷新输出缓冲区（通过 cout.flush() 或 endl 等方式），以确保输出顺序正确。

总结

这两行代码通常用于竞赛编程或需要快速处理大量输入输出的程序中，能够显著提高输入输出的性能。然而，需要注意的是，它们可能会改变输入输出行为的某些细节，因此在启用这些优化时应确保不混用 C 和 C++ 的输入输出函数，并在需要时手动刷新输出缓冲区。

使用 #include<bits/stdc++.h> 指令，您可以轻松将大多数标准 C++ 头文件包含在代码中（面试中的 ACM 模式经常使用该标准库函数）
bits/stdc++.h 是 GCC 专用的头文件，在使用 Clang 的 MacOS 上默认不可用。要修复“文件未找到”错误，您可以创建自己的 stdc++.h 文件并将其放在 Clang 可以找到的目录中。

类型转换 `static_cast<int>(val)`

C++ 提供了几种不同的类型转换操作符，每种都有特定的用途和使用场景：

static_cast：基本数据类型之间的转换（如 int 转 float）
dynamic_cast：用于处理包含多态的类层次结构的类型转换
const_cast：修改变量的 const 或 volatile 修饰符，允许去除或增加这些修饰符
reinterpret_cast：最危险的类型转换操作符，主要用于在指针或引用之间进行非常规的、非安全的类型转换

push() 与 emplace()

对于 map 也好，pair 也好，或者是对象，emplace 都能直接构造。

std::map<int, std::string> myMap;

// 使用 insert 和 std::make_pair
myMap.insert(std::make_pair(1, "one"));

// 使用 emplace，直接传入构造 pair 的参数
myMap.emplace(2, "two");

C/C++ `__builtin` 超实用位运算库函数

`__builtin_ctz()` / `__builtin_ctzll()`

返回括号内数字的二进制表示数末尾 0 的个数

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 输出 3: 8 = 1000, 末尾 3 个 0
    cout << __builtin_ctz(8) << endl ;
    return 0;
}

`__builtin_clz()` / `__builtin_clzll()`

返回括号内数字的二进制表示数前导 0 的个数

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 输出 28:
    // 8 = 0000 0000 0000 0000 0000 0000 0000 1000
    // 整型(int)为 32 位, 有 28 个前导 0
    // 如果换成 __builtin_clzll 则输出 60
    cout << __builtin_clz(8) << endl ;
    return 0 ;
}

`__builtin_popcount()`

返回括号内数字的二进制表示数 1 的个数

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 输出 4: 15 = 1111, 1 的个数有 4 个
    cout << __builtin_popcount(15) << endl ;
    return 0 ;
}

`__builtin_parity()`

判断括号中数字的二进制表示数 1 的个数的奇偶数（偶数返回 0，奇数返回 1）

#include <bits/stdc++/h>
using namespace std;

int main() {
    // 输出 0: 15 = 1111, 1 的个数为 4 (偶数个)
    cout << __builtin_parity(15) << endl ;
    return 0 ;
}

`__builtin_ffs()`

返回括号中数字的二进制表示数的最后一个 1 在第几位（从后往前算）

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 输出 4: 8 = 1000, 最后一个 1 在第四位
    cout << __builtin_ffs(8) << Lendl ;
    return 0 ;
}

STL

推荐阅读：https://www.apiref.com/cpp-zh/cpp/container.html

容器库是类模板与算法的汇集，允许程序员简单地访问常见数据结构，例如队列、链表和栈。

有三类容器：

顺序容器
关联容器
无序关联容器

容器管理为其元素分配的存储空间，并提供直接或间接地通过迭代器（拥有类似指针属性的对象）访问它们的函数。

C++ 标准模板库（STL）提供了一系列强大的容器，这些容器封装了常见的数据结构，支持各种操作和算法。

一旦 STL 容器中有 find() 方法，那么判断方法一般是 stl.find(val) != stl.end().

⚠️ find 函数只有在「关联容器」和「string」中存在：

前者返回迭代器 iterator
后者 If no matches were found, the function returns string::npos.

顺序容器

顺序容器实现能按顺序访问的数据结构

array：静态的连续数组
vector：动态的连续数组
deque：双端队列
forward_list：单链表
list：双链表

关联容器

关联容器实现能快速查找「 $O(log n)$ 复杂度」的数据结构

set：唯一键的集合，按照键排序
map：键值对的集合，按照键排序，键是唯一的
multiset：键的集合，按照键排序
multimap：键值对的集合，按照键排序

无序关联容器

无序关联容器提供能快速查找「均摊 $O(1)$，最坏情况 $O(n)$ 复杂度」的无序（哈希）数据结构

unordered_set：唯一键的集合，按照键生成散列
unordered_map：键值对的集合，按照键生成散列，键是唯一的
unordered_multiset：键的集合，按照键生成散列
unordered_multimap：键值对的集合，按照键生成散列

容器适配器

容器适配器提供顺序容器的不同接口

stack：适配一个容器以提供栈（LIFO 数据结构）
queue：适配一个容器以提供队列（FIFO 数据结构）

迭代器非法化

只读方法决不非法化迭代器或引用
修改容器内容的方法可能非法化迭代器和/或引用

举个例子：

#include <iostream>
#include <vector>

using namespace std;

template<typename T>
std::ostream &operator<<(std::ostream &s, const vector<T> &v) {
    s.put('[');
    char comma[3] = {'\0', ' ', '\0'};
    for (const auto &e: v) {
        s << comma << e;
        comma[0] = ',';
    }
    return s << ']';
}

int main() {
    vector<int> vec{1, 2, 3, 4, 5, 6};
    auto it = vec.begin();
    vec.insert(it, 1);      // success
    vec.insert(it, 666);    // fail: 迭代器非法化(因为在上一步后容器扩容)
    cout << vec.capacity() << endl;    // 扩容: 重新分配内存空间

    it = vec.begin();   // 重新指向新内存地址
    vec.insert(it, 666);    // success
    vec.insert(it, 666);    // success
    vec.insert(it, 666);    // success
    cout << vec << endl;


    auto i = vec.begin();
    vec.erase(i);   // success
    vec.erase(i);   // success

    i = vec.end() - 1;
    vec.erase(i);   // success
    vec.erase(i);   // fail: 迭代器非法化
    cout << vec << endl;

    return 0;
}

迭代器非法化总结表格：

这里的插入指代任何添加一或多个元素到容器的方法：

因为插入过程可能会导致容器扩容（capacity 变化），扩容后会释放原有的空间，而迭代器依然指向原有空间中的位置，此时该迭代器变成野指针，导致无法访问！

insert
push_back
push_front
operator[] 也算，因为也存在插入的可能性

而擦除指代任何从容器移除一或多个元素的方法：

擦除后迭代器失效是因为删除的是最后一个有效元素，然后删除后该迭代器指向容器的非有效位置！

erase
pop_back
pop_front
clear

尾后迭代器需要特别留意。通常像指向未被擦除元素的正常迭代器一般非法化此迭代器。

故 std::set::end 决不被非法化，std::unordered_set::end 仅在重哈希时被非法化，std::vector::end 始终被非法化（因为它始终出现在被修改元素后），以此类推。

STL 成员函数

成员函数一览表

bitset｜位图

std::bitset 也称「位图」，非常常用

template <size_t N> 
class bitset

bitset 的初始化方式：

std::bitset<N> bitset1; // 创建一个长度为 N 的 bitset，所有位都被初始化为 0
std::bitset<N> bitset2(value); // 使用二进制整数 value 初始化一个长度为 N 的 bitset
std::bitset<32> bitset21(0xffff);          // bits 0 ... 15 are set to 1; 16 ... 31 are 0
std::bitset<128> bitset22(0xffff);         // bits 32 through 127 initialized to zero
 
std::bitset<N> bitset3(string); // 使用二进制字符串 string 初始化一个长度为 N 的 bitset
string str("1111111000000011001101");
std::bitset<N> bitset31(str);    //用整个字符串来初始化bitset
std::bitset<32> bitset32(str, 5, 4); // 4 bits starting at str[5], 1100
std::bitset<32> bitset33(str, str.size() - 4);     // use last 4 characters
 
std::bitset<N> bitset4(bitset); // 使用另一个 bitset 初始化一个长度为 N 的 bitset
std::bitset<n> bitset5(bitset4, pos, n);	  //bitset5是bitset4中从位置pos开始的n个位的副本

方法：

| 方法 | 功能 | | ------------ | ---------------------------------------------- | | b.any() | b 中是否存在置为 1 的二进制位？ | | b.none() | b 中不存在置为 1 的二进制位？ | | b.count() | b 中置为 1 的二进制位的个数 | | b.size() | b 中二进制位的个数 | | b[pos] | 访问 b 中在 pos 处的二进制位 | | b.test(pos) | b 中在 pos 处的二进制是否为 1？ | | b.set() | 把 b 中所有二进制位都置为 1 | | b.set(pos) | 把 b 中在 pos 处的二进制位置为 1 | | b.reset() | 把 b 中所有二进制位都置为 0 | | b.reset(pos) | 把 b 中在 pos 处的二进制位置为 0 | | b.flip() | 把 b 中所有二进制位取反 | | b.flip(pos) | 把 b 中在 pos 处的二进制位取反 | | b.to_ulong() | 用 b 中同样的二进制位返回一个 unsigned long 值 | | os << b | 把 b 中的位集输出到 os 流 |

std::bitset<4> b1("1100");
size_t count = b1.count(); // count set bits
size_t size = b1.size();   // get number of bits
bool bit = b1.test(2);     // test bit at position 2
bool any = b1.any();       // check if any bit is set
bool none = b1.none();     // check if no bit is set
b1.flip();                 // flip all bits

这些函数使得 std::bitset 成为处理位级别数据的强大工具。

std::bitset 还支持「位操作符」、「位移操作符」和「比较操作符」：

std::bitset<4> b1("1100");
std::bitset<4> b2("1010");
std::bitset<4> b3 = b1 & b2; // bitwise AND
std::bitset<4> b4 = b1 | b2; // bitwise OR
std::bitset<4> b5 = b1 ^ b2; // bitwise XOR
std::bitset<4> b6 = ~b1;     // bitwise NOT

std::bitset<4> b1("1100");
std::bitset<4> b2 = b1 << 1; // left shift
std::bitset<4> b3 = b1 >> 1; // right shift

std::bitset<4> b1("1100");
std::bitset<4> b2("1010");
bool equal = (b1 == b2); // compare bitsets

string

str[i] 取到的是 char 字符

c_str()：const CharT* c_str() const;

string 可以利用以下几个方法模拟 stack

push_back()
pop_back()

erase()

append()

length()

find()：finds the first occurrence of the given substring

#include <iomanip>
#include <iostream>
#include <string>

int main()
{
    std::string::size_type n;
    std::string const s = "This is a string"; /*
                             ^  ^  ^
                             1  2  3          */
 
    // search from beginning of string
    n = s.find("is");
 
    // search from position 5
    n = s.find("is", 5);
 
    // find a single character
    n = s.find('a');
 
    // find a single character
    n = s.find('q');
}

rfind()：find the last occurrence of a substring

string::npos：一般和 find() 搭配使用

// string search functions return npos if nothing is found
std::string s = "test";
if (s.find('a') == s.npos)
    std::cout << "no 'a' in 'test'\n";

查找，包括前面 find 与 rfind

find_first_of()：size_type find_first_of( const basic_string& str, size_type pos = 0 ) const;

find_first_not_of()

find_last_of()

find_last_not_of()

operations

starts_with() [C++ 20]

ends_with() [C++ 20]

contains() [C++ 23]

substr(size_type position = 0, size_type count = npos)：获取子串

int/float 转为 string

to_string
to_wstring

string 转为数值

stoi()
stof()
stod()
stol()
stoll()

array

array 是一个固定大小的数组封装容器。

std::array<int, 5> arr = {1, 2, 3, 4, 5};

// at(size_t index)
int value1 = arr.at(2);  	// value = 3
int value2 = arr[2];  		// value = 3

int first = arr.front();  	// first = 1
int last = arr.back();  	// last = 5

int* p = arr.data();  // p 是指向 arr 首元素的指针

// size_t 一般用作 size() 的接收参数
size_t size = arr.size();  // size = 5

std::array<int, 0> ar;  // 定义一个空的 std::array
bool isEmpty = ar.empty();  // isEmpty = true

std::array<int, 3> arr1 = {1, 2, 3};
std::array<int, 3> arr2 = {4, 5, 6};
arr1.swap(arr2);  // arr1 现在是 {4, 5, 6}, arr2 现在是 {1, 2, 3}

vector

动态数组，支持随机访问，内存是连续的。

常用方法：

push_back(value)：在末尾添加元素。
pop_back()：删除末尾元素。
insert(vec.begin(), value)：在指定位置插入元素。
erase(vec.begin())：删除指定位置的元素。
clear()：清空容器。
resize(n)：调整容器大小。
at(index)：访问指定位置的元素。
front()：访问第一个元素。
back()：访问最后一个元素。
empty()：检查容器是否为空。
size()：返回容器中元素的数量。
capacity()：返回容器的容量。
reserve(n)：预留至少 n 个元素的空间。

deque

双端队列，支持在两端快速插入和删除。内存可能不连续，支持常数时间的随机访问。

push_back(value)
push_front(value)
pop_back()
pop_front()
front()
back()
erase(position)
insert(position, value)
at(index)
empty()
size()

set [有序]

集合，存储唯一元素，元素按顺序排列，底层通常是红黑树。

插入、删除、查找的时间复杂度为 $O(log n)$。

insert(value)
emplace(value)
erase(position)
erase(value)
find(value)
count(value)
empty()
size()
contains(value) [C++ 20]

multiset [有序]

允许存储重复元素的集合，元素按顺序排列，底层通常是红黑树。

插入、删除、查找的时间复杂度为 $O(log n)$。

滑动窗口 + multiset

// 1438. 绝对差不超过限制的最长连续子数组
class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        multiset<int> ordered_set;
        int left = 0, ans = 0;
        for (int right = 0; right < nums.size(); right++) {
            ordered_set.insert(nums[right]);
            while (*ordered_set.rbegin() - *ordered_set.begin() > limit) {
                ordered_set.erase(ordered_set.find(nums[left]));
                left++;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

insert(value)：插入元素。
erase(position)：删除指定位置的元素。
erase(value)：删除与指定值相等的元素。
find(value)：查找指定值的元素。
count(value)：统计与指定值相等的元素数量。
clear()：清空容器。
empty()：检查容器是否为空。
size()：返回容器中元素的数量。

map [有序]

键值对集合，按键排序，键唯一，底层通常是红黑树。

插入、删除、查找的时间复杂度为 $O(log n)$。

insert({key, value})：插入键值对。
erase(position)：删除指定位置的键值对。
erase(key)：删除指定键的键值对。
find(key)：查找指定键的键值对。
count(key)：统计指定键的键值对数量（返回 0 或 1）。
clear()：清空容器。
empty()：检查容器是否为空。
size()：返回容器中元素的数量。
at(key)：访问指定键的值（若键不存在则抛出异常）。
operator[](key)：访问或插入指定键的值。

multimap [有序]

允许重复键的键值对集合，按键排序，底层通常是红黑树。

插入、删除、查找的时间复杂度为 $O(log n)$。

insert({key, value})：插入键值对。
erase(position)：删除指定位置的键值对。
erase(key)：删除指定键的键值对。
find(key)：查找指定键的键值对。
count(key)：统计指定键的键值对数量。
clear()：清空容器。
empty()：检查容器是否为空。
size()：返回容器中元素的数量。

unordered_map

无序容器使用哈希表实现，元素无序排列，插入和查找操作平均时间复杂度为 O(1)。

键值对集合，键唯一，元素无序排列，底层为哈希表。

插入、删除、查找的平均时间复杂度为 $O(1)$。

unordered_set

集合，存储唯一元素，元素无序排列，底层为哈希表。

插入、删除、查找的平均时间复杂度为 $O(1)$。

unordered_multimap

键值对集合，键唯一，元素无序排列，底层为哈希表。

插入、删除、查找的平均时间复杂度为 $O(1)$。

unordered_multiset

允许存储重复元素的集合，元素无序排列，底层为哈希表。

插入、删除、查找的平均时间复杂度为 $O(1)$。

`std::pair<int, int>`

将两个值组合在一起，常用于关联容器（如 std::map）

p.first：第一个元素
p.second：第二个元素
make_pair(val_1, val_2)：创建一个 pair 对象

stack

后进先出（LIFO）的栈，默认使用 std::deque 作为底层容器。

push(value)
pop()
top()
empty()
size()

queue

先进先出（FIFO）的队列，默认使用 std::deque 作为底层容器。

queue 为单端队列，deque 为双端队列

push(value)
pop()
front()
back()
empty()
size()

priority_queue

top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push / emplace 插入元素到队尾（后者为 in-place insert）
pop 弹出队头元素
swap 交换内容

const auto data = {1, 8, 5, 6, 3, 4, 0, 9, 7, 2};

// 大顶堆(默认)
priority_queue<int> max_priority_queue;
// priority_queue<int, vector<int>, less<>> max_priority_queue;

// 小顶堆
priority_queue<int, vector<int>, greater<int>>
        min_priority_queue(data.begin(), data.end());

关于 swap 函数：

int main()
{
    std::vector<std::string> v1{"1","2","3","4"},
                             v2{"Ɐ","B","Ɔ","D","Ǝ"};
 
    std::priority_queue s1(std::less<>(), std::move(v1));
    std::priority_queue s2(std::less<>(), std::move(v2));
 
    print("s1", s1);
    print("s2", s2);
 
    s1.swap(s2);
 
    print("s1", s1);
    print("s2", s2);
}

Output:

s1 [4]: 4 3 2 1
s2 [5]: Ǝ D Ɔ B Ɐ
s1 [5]: Ǝ D Ɔ B Ɐ
s2 [4]: 4 3 2 1

iterator

begin() 与 end()：返回指向数组开头和末尾之后一个位置的迭代器

cbegin() 与 cend()：返回指向数组开头和末尾之后一个位置的常量迭代器

rbegin() 与 rend()：返回指向数组末尾和开头之前一个位置的反向迭代器

crbegin() 与 crend()：返回指向数组末尾和开头之前一个位置的常量反向迭代器

常量迭代器只读，不可以修改对应的元素值。

Modern C++

Sat, 12 Apr 2025 00:00:00 GMT

Link: Modern C++ (Lecture & Tutorials, 2020, Vizzo & Stachniss) - University of Bonn

CMake｜Build System｜library

✅ Modern C++: The Basics (Lecture 0, I. Vizzo, 2020)：简单的 Linux 和 Cpp 历史和教程

✅ Modern C++: Build and Tools (Lecture 1, I. Vizzo, 2020)：学习了 cpp build system 整个流程（包括使用 cmake 生成 makefile 以及 CMAKE 的语法）、静态库/动态库（lib*.a 与 lib*.so）

# 可以自己写 library 然后自己追加
# compile modules
c++ -std=c++17 -c tools.cpp -o tools.o
# organize modules into libraries
# "ar rcs libname.a module.o module.o ..."
ar rcs libtools.a tools.o <other_modules>
# link libraries when building code
c++ -std=c++17 main.cpp -L . -ltools -o main

# Use CMake to simplify the build
# CMakeLists.txt
cmake_minimum_required(VERSION 3.1)
project(first_project)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_FLAGS "-Wall")

# 这个命令可以将构建系统的整个脚本过程输出到当前目录下
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)	# important!
# tell cmake where to look for *.hpp *.h files
include_directories(include/)

# create library "libtools"
add_library(tools src/tools.cpp)	# create libtools.a

# add executable main
add_executable(main src/main.cpp)	# main.o

# tell the linker to bind these objects together
target_link_libraries(main tools)	# ./main

# Build a CMake project (Build process)
cd <project_folder>
mkdir build && cd build
cmake ..
make

strtok｜stringstream

✅ Modern C++: Core C++ (Lecture 2, I. Vizzo, 2020)

#include <iomanip>
#include <iostream>
#include <sstream>

using namespace std;

int main() {
  stringstream filename("00205.txt");

  int num = 0;
  string ext;

  // Split the string stream using simple syntax
  // 而不是使用 strtok 来分割字符串
  filename >> num >> ext;

  cout << num << endl;
  cout << ext << endl;

  return 0;
}

int main(int argc, char const *argv[]);

argc defines number of input parameters

argv is an array of string parameters

By default:

argc == 1
argv == "<binary_path>"

C++ Functions

✅ Modern C++: C++ Functions (Lecture 3, I. Vizzo, 2020)

C++ 17 可以像 Python 返回多个类型一样，返回多种值了 —— tuple

#include <iostream>
#include <tuple>
using namespace std;

auto Foo() {
  return make_tuple("Super Variable", 19);
}

int main() {
  auto [name, age] = Foo();
  cout << name << " is " << age << " years old." << endl;
}

WARNING: Never return reference to locally variables!!!

#include <iostream>
using namespace std;

int& MultiplyBy10(int num) {   // retval is created
  int retval = 0;
  retval = 10 * num;
  cout << "retval is " << retval << endl;   // 加上这行代码后，g++ -O3 test.cpp -o test 就可以正常工作；反之则输出乱数
  return retval;
} // retval is destroyed, it's not accesisble anymore

int main() {
  int out = MultiplyBy10(5);
  cout << out << endl;
  return 0;
}

返回了一个指向已经被销毁的内存位置的引用，访问这个引用会导致未定义的行为。g++ -O3 test.cpp -o test 则会输出错误的值，不加 -O3 则正常，或者说在方法中加个 cout 输出则也正常。

Static：发生在「编译」时

Non-Static：发生在「运行」时

inline function

function calls are expensive...
If the function is rather small, you could help the compiler.
inline is a hint to the compiler
- should attempt to generate code for a call.
- rather than a function call.
总结：当函数足够小的时候，可以用 inline 来内联函数，帮助编译器为你优化它 —— 即当函数调用时，直接将代码放（替换）到对应位置，而不是调用。

Check it out: https://godbolt.org/z/EGd6aG

Good C++ Practices

[ ] Break up complicated computations into meaningful chunks and name them.
[ ] Keep the length of functions small enough.
[ ] Avoid unecessary comments.
[ ] One function shouldl achieve ONE task.
[ ] If you can't pick a short name, then split functionallity.
[ ] Avoid macros: If you must use ig, use ugly names with lots of capital letters.

C++ Namespace

Helps avoiding name conflicts
Group the project into logical modules

Avoid using namespace <name>：好比写算法时总是使用 using namespace std;，这是需要避免的！

#include <cmath>
#include <iostream>

// Avoiding!!!
using namespace std;  // std namespace is used

// Self-defined function power shadows the std::pow
double pow(double x, int exp) {
  double res = 1.0;
  for(int i = 0; i < exp; i++) {
    res *= x;
  }
  return res;
}

int main() {
  cout << "2.0 ^ 2 = " << pow(2.0, 2) << endl;
  return 0;
}

C++ STL Library

✅ Modern C++: The C++ STL Library (Lecture 4, I. Vizzo, 2020)

Size of container (C vs. CPP)

int data[6];
size_t data_size = sizeof(data) / sizeof(data[0]);

std::array<int, 6> data_{};
cout << data_.size() << endl;

Clear elements (C vs. CPP)

char letters[5] = {'a', 'e', 'i', 'o', 'u'};
memset(letters, 0, sizeof(letters));

std::string letters_{"aeiou"};
letters_.clear();

Iterating over maps

New in C++17

std::map<char, int> _dict{{'a', 17}, {'b', 3}};
for(const auto& [key, val] : _dict) {
    cout << key << val;
}

C++ Iterators

C++ Algorithm

sort(v.begin(), v.end())
find(v.begin(), v.end(), val)
fill(v.begin(), v.end(), -1)
count(v.begin(), v.end(), val)
count_if(v.begin(), v.end(), [](int x) {return x % 3 == 0;})
for_each(v.begin(), v.end(), [](const int& n) {cout << " " << n;})
rotate(v.begin(), v.begin() + 2, v.end())
transform(v.begin(), v.end(), [](char ch) { return std::toupper(ch); })
accumulate(v.begin(), v.end(), 0)
max()
min_element(v.begin(), v.end()): *min_element(v.begin(), v.end())
auto [min, max] = minmax_element(v.begin(), v.end())
...

C++ Utilities

✅ Modern C++: I/O Files, Intro to Classes (Lecture 5, I. Vizzo, 2020)

C++ includes a variety of utility libraries that provide functionality ranging from bit-counting to partial function application.

These libraries can be broadly divided into two groups:

language support libraries
general-purpose libraries

Language support

Type support（std::size_t）

Dynamic memory management（std::shared_ptr）

Error handling（std::exception，assert）

Initializer list（std::vector{1, 2}）

Much more ...

General-purpose libraries

Program utilities（std::abort）

Date and Time（std::chronologically::duration）

Optional, variant and any（std::variant）

Pairs and tuples（std::tuple）

Swap, forward and move（std::move）

Hash support（std::hash）

Formatting library (coming in C++20)

Much more ...

Much more utilities

Just spend some time looking around: https://en.cppreference.com/w/cpp/utility

Error handling

跳过，不建议使用

We can throw an exception if there is an error.

std::exception

To use exceptions: #include <stdexcept>

An exception can be "caught" at any point of the program (try - catch) and even "thrown" further (throw)

The constructor of an exception receives a string error message as a parameter.

This string can be called through a member function what()

Intuition

Only used for "exceptional behavior"

Often misused: e.g. wrong parameter should not lead to an exception.

🔥 GOOGLE—STYLE: Don't use exceptions.

Link: https://en.cppreference.com/w/cpp/error

I/O Library

read/write file

Use streams from STL

Syntax similar to cerr, cout

#include <fstream>

using std::string;
using Mode = std::ios_base::openmode;

// input
std::ifstream f_in(string& filename, Mode mode);

// output
std::ofstream f_out(string& filename, Mode mode);

// in_output
std::fstream f_in_out(string& filename, Mode mode);

There are many modes under which a file can be opened.

| Mode | Meaning | | ---------------- | --------------------------- | | ios_base::app | append output | | ios_base::ate | seek to EOF when opened | | ios_base::binary | open file in binary mode | | ios_base::in | open file for reading | | ios_base::out | open file for writing | | ios_base::trunc | overwrite the existing file |

#include <fstream>
#include <iostream>
#include <string>

using namespace std;

int main() {
  int i;
  double a, b;
  string s;
  ifstream in("test_cols.txt", ios_base::in);
  while (in >> i >> a >> s >> b) {
    // ...
  }
  return 0;
}

#include <iomanip>
#include <fstream>
using namespace std;
int main() {
    string filename = "out.txt";
    ofstream outfile(filename);
    if(!outfile.is_open()) {
        return EXIT_FAILURE;
    }
    double a = 1.23456789;
    outfile << fixed << setprecision(20) << a << endl;
    return 0;
}

directory_iterator

#include <filesystem>
#include <fstream>
#include <iostream>

namespace fs = std::filesystem;

int main() {
  fs::create_directories("sandbox/a/b");
  std::ofstream("sandbox/file1.txt");
  std::ofstream("sandbox/file2.txt");
  for (auto& p : fs::directory_iterator("sandbox")) {
    std::cout << p.path() << "\n";
  }
  fs::remove_all("sandbox");
  return 0;
}

# 必须指定 c++ 17 才可以编译
g++ -std=c++17 test.cpp -o test

"sandbox/a"
"sandbox/file1.txt"
"sandbox/file2.txt"

#include <filesystem>
#include <fstream>
#include <iostream>

namespace fs = std::filesystem;

int main() {
  std::cout << fs::path("/foo/bar/txt").filename() << '\n'
            << fs::path("/foo/.bar").filename() << '\n'
            << fs::path("/foo/bar/").filename() << '\n'
            << fs::path("/foo/.").filename() << '\n'
            << fs::path("/foo/..").filename() << '\n';
  return 0;
}

# 必须指定 c++ 17 才可以编译
g++ -std=c++17 test.cpp -o test

"txt"
".bar"
""
"."
".."

#include <filesystem>
#include <fstream>
#include <iostream>

namespace fs = std::filesystem;

int main() {
  std::cout << fs::path("/foo/bar.txt").extension() << '\n'
            << fs::path("/foo/bar.").extension() << '\n'
            << fs::path("/foo/bar.png").extension() << '\n'
            << fs::path("/foo/.").extension() << '\n'
            << fs::path("/foo/..").extension() << '\n';
  return 0;
}

g++ -std=c++17 test.cpp -o test

".txt"
"."
".png"
""
""

const fs::path& p = "...";
fs::(exists(p));

C++ Classes

class glossary

Class Definition
Class Implementation
Class data members
Class Member functions
Class Constructors
Class Destructor
Class setters
Class getters
Class operators
Class static members

By default everything is private

Access members with a "."

GOOGLE—STYLE: All data must be private

What about structs?

Definition starts with the keyword struct:

struct ExampleStruct {
    Type value;
    Type value;
    Type value;
    // No functions!
}

struct is a class where everything is public

🔥 GOOGLE—STYLE: Use struct as a simple data container, if it needs a function it should be a class instead.

🔥 Always initialize structs using braced initialization, such as:

struct namedInt {
	int num;
    std::string name;
};

namedInt var{1, std::string{"hello"}};

Const correctness

const after function states that this function does not change the object

Mark all functions that should not change the state of the object as const

Ensures that we can pass objects by a const reference and still call their functions.

Substantially reduces number of errors.

Typical const error

#include <iostream>
#include <string>

using namespace std;

class Student {
 public:
  Student(string name) : name_(name) {}

  // This function *might* change the object
  const string& getName() { return name_; }
  // correct: const string& getName() const { return name_; }

 private:
  string name_;
};

void Print(const Student& student) { cout << student.getName() << endl; }

如果不在 getName() 后面加上 const，那么编译器不能保证你不会改变它，除了 setter，一般都需要加上 const吗，这能很大程度上避免错误。

`std::Move()` semantics

c++11 引入 move()

所有权转移，用于将左值显示转换为右值，允许通过移动（而不是复制）资源来优化性能。

Smart pointers

Smart pointers wrap a raw pointer into a class and manage its lifetime (RAII)
Smart opinters are all about ownership
Only use them with heap memory!
#include <memory>

C++ 11 Smart pointers types

std::auto_ptr
🔥 std::unique_ptr
🔥 std::shared_ptr
std::weak_ptr

因为使用的是 unique，不能直接用 = 复制，但是可以转移所有权，那就使用 move()

Markdown 数学公式指导手册

Sat, 12 Apr 2025 00:00:00 GMT

用 Katex 改写数学公式，发现右括号接下标，不能正常解析，)改成 \rparen, ]改成 \rbrack

一、公式使用参考

1．如何插入公式

LaTex 的数学公式有两种：行中公式和独立公式。行中公式放在文中与其它文字混编，独立公式单独成行。

行中公式示例: $\sum_{i=0}^n i^2 = \frac{(n^2+n)(2n+1)}{6}$

独立公式示例：$$\sum_{i=0}^n i^2 = \frac{(n^2+n)(2n+1)}{6}$$

$$ \sum_{i=0}^n i^2 = \frac{(n^2+n)(2n+1)}{6} $$

自动编号的公式可以用如下方法表示：

若需要手动编号，参见大括号和行标的使用。

$$
\begin{equation}
数学公式
\label{eq:当前公式名}
\end{equation}
$$

自动编号后的公式可在全文任意处使用 \eqref{eq:公式名} 语句引用。

2．如何输入上下标

^ 表示上标,_ 表示下标。如果上下标的内容多于一个字符，需要用 {} 将这些内容括成一个整体。上下标可以嵌套，也可以同时使用。

$$x^{y^z}=(1+{\rm e}^x)^{-2xy^w} $$

$$ x^{y^z}=(1+{\rm e}^x)^{-2xy^w} $$

3．如何输入括号和分隔符

()、[] 和 | 表示符号本身，使用 \{\} 来表示 {} 。当要显示大号的括号或分隔符时，要用 \left 和 \right 命令。

一些特殊的括号：

| 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | | \langle | $\langle$ | \rangle | $\rangle$ | | \lceil | $\lceil$ | \rceil | $\rceil$ | | \lfloor | $\lfloor$ | \rfloor | $\rfloor$ | | \lbrace | $\lbrace$ | \rbrace | $\rbrace$ | | \lvert | $\lvert$ | \rvert | $\rvert$ | | \lVert | $\lVert$ | \rVert | $\rVert$ |

$$ f(x,y,z) = 3y^2z \left( 3+\frac{7x+5}{1+y^2} \right) $$

$$ f(x,y,z) = 3y^2z \left( 3+\frac{7x+5}{1+y^2} \right) $$

有时候要用 \left. 或 \right. 进行匹配而不显示本身。

$$\left. \frac{{\rm d}u}{{\rm d}x} \right| _{x=0}$$

$$ \left. \frac{{\rm d}u}{{\rm d}x} \right|_{x=0} $$

4．如何输入分数

通常使用 \frac {分子} {分母} 命令产生一个分数，分数可嵌套。便捷情况可直接输入 \frac{a}{b} 来快速生成一个。如果分式很复杂，亦可使用 分子 \over 分母 命令，此时分数仅有一层。

$$\frac{a-1}{b-1} \quad and \quad {a+1\over b+1}$$

$$ \frac{a-1}{b-1} \quad and \quad {a+1\over b+1} $$

5．如何输入开方

使用 \sqrt [根指数，省略时为2] {被开方数} 命令输入开方。

$$\sqrt{2} \quad and \quad \sqrt[n]{3}$$

$$ \sqrt{2} \quad and \quad \sqrt[n]{3} $$

6．如何输入省略号

数学公式中常见的省略号有两种，\ldots 表示与文本底线对齐的省略号，\cdots 表示与文本中线对齐的省略号。

$$f(x_1,x_2,\ldots ,x_n) = x_1^2 + x_2^2 + \cdots + x_n^2$$

$$ f(x_1,x_2,\ldots ,x_n) = x_1^2 + x_2^2 + \cdots + x_n^2 $$

7．如何输入矢量

使用 \vec{矢量} 来自动产生一个矢量。也可以使用 \overrightarrow 等命令自定义字母上方的符号。

$$ \vec{a} \cdot \vec{b}=0 $$

$$ \vec{a} \cdot \vec{b}=0 $$

$$ \overleftarrow{xy} \quad and \quad \overleftrightarrow{xy} \quad and \quad \overrightarrow{xy} $$
$$ xy \text{ with arrows:} \quad \overleftarrow{xy} \\; \mid \\; \overleftrightarrow{xy} \\; \mid \\; \overrightarrow{xy} $$

$$ \overleftarrow{xy} \quad and \quad \overleftrightarrow{xy} \quad and \quad \overrightarrow{xy} \ xy \text{ with arrows:} \quad \overleftarrow{xy} ; \mid ; \overleftrightarrow{xy} ; \mid ; \overrightarrow{xy} $$

8．如何输入积分

使用 \int_积分下限^积分上限 {被积表达式} 来输入一个积分。

$$\int_0^1 {x^2} \,{\rm d}x$$

$$ \int_0^1 {x^2} ,{\rm d}x $$

本例中 \, 和 {\rm d} 部分可省略，但建议加入，能使式子更美观。

9．如何输入极限运算

使用 \lim_{变量 \to 表达式} 表达式来输入一个极限。如有需求，可以更改 \to 符号至任意符号。

$$ \lim_{n \to +\infty} \frac{1}{n(n+1)} \quad and \quad \lim_{x\leftarrow{示例}} \frac{1}{n(n+1)} $$

$$ \lim_{n \to +\infty} \frac{1}{n(n+1)} \quad and \quad \lim_{x\leftarrow{示例}} \frac{1}{n(n+1)} $$

10．如何输入累加、累乘运算

使用 \sum_{下标表达式}^{上标表达式} {累加表达式} 来输入一个累加。与之类似，使用 \prod \bigcup \bigcap 来分别输入累乘、并集和交集。此类符号在行内显示时上下标表达式将会移至右上角和右下角。

$$ sum_{i=1}^n \frac{1}{i^2} \quad and \quad \prod_{i=1}^n \frac{1}{i^2} \quad and \quad \bigcup_{i=1}^{2} R $$

$$ \sum_{i=1}^n \frac{1}{i^2} \quad and \quad \prod_{i=1}^n \frac{1}{i^2} \quad and \quad \bigcup_{i=1}^{2} R $$

11．如何输入希腊字母

输入 \小写希腊字母英文全称 和 \首字母大写希腊字母英文全称 来分别输入小写和大写希腊字母。对于大写希腊字母与现有字母相同的，直接输入大写字母即可。

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | --- | --- | | \alpha | $\alpha$ | A | $A$ | \beta | $\beta$ | B | $B$ | | \gamma | $\gamma$ | \Gamma | $\Gamma$ | \delta | $\delta$ | \Delta | $\Delta$ | | \epsilon | $\epsilon$ | E | $E$ | \zeta | $\zeta$ | Z | $Z$ | | \eta | $\eta$ | H | $H$ | \theta | $\theta$ | \Theta | $\Theta$ | | \iota | $\iota$ | I | $I$ | \kappa | $\kappa$ | K | $K$ | | \lambda | $\lambda$ | \Lambda | $\Lambda$ | \mu | $\mu$ | M | $M$ | | \nu | $\nu$ | N | $N$ | \xi | $\xi$ | \Xi | $\Xi$ | | o | $o$ | O | $O$ | \pi | $\pi$ | \Pi | $\Pi$ | | \rho | $\rho$ | P | $P$ | \sigma | $\sigma$ | \Sigma | $\Sigma$ | | \tau | $\tau$ | T | $T$ | \upsilon | $\upsilon$ | \Upsilon | $\Upsilon$ | | \phi | $\phi$ | \Phi | $\Phi$ | \chi | $\chi$ | X | $X$ | | \psi | $\psi$ | \Psi | $\Psi$ | \omega | $\omega$ | \Omega | $\Omega$ |

部分字母有变量专用形式，以 \var 开头。

| 小写 | 大写 | 变量形式 | 显示 | | --- | --- | --- | --- | | \epsilon | E | \varepsilon | $\epsilon$|$E$|$\varepsilon$ | | \theta | \Theta | \vartheta | $\theta$|$\Theta$|$\vartheta$ | | \rho | P | \varrho | $\rho$|$P$|$\varrho$ | | \sigma | \Sigma | \varsigma | $\sigma$|$\Sigma$|$\varsigma$ | | \phi | \Phi | \varphi | $\phi$|$\Phi$|$\varphi$ |

12．如何输入其它特殊字符

若需要显示更大或更小的字符，在符号前插入 \large 或 \small 命令。

若找不到需要的符号，使用 Detexify 来画出想要的符号。

(1) 关系运算符

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | --- | --- | | \pm | $\pm$ | \times | $\times$ | \div | $\div$ | \mid | $\mid$ | | \nmid | $\nmid$ | \cdot | $\cdot$ | \circ | $\circ$ | \ast | $\ast$ | | \bigodot | $\bigodot$ | \bigotimes | $\bigotimes$ | \bigoplus | $\bigoplus$ | \leq | $\leq$ | | \geq | $\geq$ | \neq | $\neq$ | \approx | $\approx$ | \equiv | $\equiv$ | | \sum | $\sum$ | \prod | $\prod$ | \coprod | $\coprod$ | \backslash | $\backslash$ |

(2) 集合运算符

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | | \emptyset | $\emptyset$ | \in | $\in$ | \notin | $\notin$ | | \subset | $\subset$ | \supset | $\supset$ | \subseteq | $\subseteq$ | | \supseteq | $\supseteq$ | \bigcap | $\bigcap$ | \bigcup | $\bigcup$ | | \bigvee | $\bigvee$ | \bigwedge | $\bigwedge$ | \biguplus | $\biguplus$ |

(3) 对数运算符

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | | \log | $\log$ | \lg | $\lg$ | \ln | $\ln$ |

(4) 三角运算符

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | | 30^\circ | $30^\circ$ | \bot | $\bot$ | \angle A | $\angle A$ | | \sin | $\sin$ | \cos | $\cos$ | \tan | $\tan$ | | \csc | $\csc$ | \sec | $\sec$ | \cot | $\cot$ |

(5) 微积分运算符

| 输入 | 显示 | 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | --- | --- | | \int | $\int$ | \iint | $\iint$ | \iiint | $\iiint$ | | \partial | $\partial$ | \oint | $\oint$ | \prime | $\prime$ | | \lim | $\lim$ | \infty | $\infty$ | \nabla | $\nabla$ |

(6) 逻辑运算符

| 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | | \because | $\because$ | \therefore | $\therefore$ | | \forall | $\forall$ | \exists | $\exists$ | | \not\subset | $\not\subset$ | \not< | $\not<$ | | \not> | $\not>$ | \not= | $\not=$ |

(7) 戴帽符号

| 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | | \hat{xy} | $\hat{xy}$ | \widehat{xyz} | $\widehat{xyz}$ | | \tilde{xy} | $\tilde{xy}$ | \widetilde{xyz} | $\widetilde{xyz}$ | | \check{x} | $\check{x}$ | \breve{y} | $\breve{y}$ | | \grave{x} | $\grave{x}$ | \acute{y} | $\acute{y}$ |

(8) 连线符号

| 输入 | 显示 | | --- | --- | | \fbox{a+b+c+d} | $\fbox{a+b+c+d}$ | | \overleftarrow{a+b+c+d} | $\overleftarrow{a+b+c+d}$ | | \overrightarrow{a+b+c+d} | $\overrightarrow{a+b+c+d}$ | | \overleftrightarrow{a+b+c+d} | $\overleftrightarrow{a+b+c+d}$ | | \underleftarrow{a+b+c+d} | $\underleftarrow{a+b+c+d}$ | | \underrightarrow{a+b+c+d} | $\underrightarrow{a+b+c+d}$ | | \underleftrightarrow{a+b+c+d} | $\underleftrightarrow{a+b+c+d}$ | | \overline{a+b+c+d} | $\overline{a+b+c+d}$ | | \underline{a+b+c+d} | $\underline{a+b+c+d}$ | | \overbrace{a+b+c+d}^{Sample} | $\overbrace{a+b+c+d}^{Sample}$ | | \underbrace{a+b+c+d}_{Sample} | $\underbrace{a+b+c+d}{Sample}$ | | \overbrace{a+\underbrace{b+c}_{1.0}+d}^{2.0} | $\overbrace{a+\underbrace{b+c}{1.0}+d}^{2.0}$ | | \underbrace{a\cdot a\cdots a}_{b\text{ times}} | $\underbrace{a\cdot a\cdots a}_{b\text{ times}}$ |

(9) 箭头符号

| 输入 | 显示 | 输入 | 显示 | | --- | --- | --- | --- | | \uparrow | $\uparrow$ | \Uparrow | $\Uparrow$ | | \downarrow | $\downarrow$ | \Downarrow | $\Downarrow$ | | \leftarrow | $\leftarrow$ | \Leftarrow | $\Leftarrow$ | | \rightarrow or \to | $\to$ | \Rightarrow | $\Rightarrow$ | | \leftrightarrow | $\leftrightarrow$ | \Leftrightarrow | $\Leftrightarrow$ | | \longleftarrow | $\longleftarrow$ | \Longleftarrow or \impliedby | $\Longleftarrow$ | | \longrightarrow | $\longrightarrow$ | \Longrightarrow or \implies | $\Longrightarrow$ | | \longleftrightarrow | $\longleftrightarrow$ | \Longleftrightarrow or \iff | $\iff$ | | \mapsto | $\mapsto$ | \underrightarrow{1℃/min} | $\underrightarrow{1℃/min}$ |

13．如何进行字体转换

若要对公式的某一部分字符进行字体转换，可以用 {\字体 {需转换的部分字符}} 命令，其中 \字体 部分可以参照下表选择合适的字体。一般情况下，公式默认为意大利体。

示例中 全部大写 的字体仅大写可用。

| 输入 | 说明 | 显示 | 输入 | 说明 | 显示 | | --- | --- | --- | --- | --- | --- | | \rm | 罗马体 | $\rm{Sample}$ | \cal | 花体 | $\cal{SAMPLE}$ | | \it | 意大利体 | $\it{Sample}$ | \Bbb | 黑板粗体 | $\Bbb{SAMPLE}$ | | \bf | 粗体 | $\rm{Sample}$ | \mathit | 数字斜体 | $\mathit{SAMPLE}$ | | \sf | 等线体 | $\sf{Sample}$ | \mathscr | 手写体 | $\mathscr{SAMPLE}$ | | \tt | 打字机体 | $\tt{Sample}$ | | | | | \frak | 旧德式体 | $\frak{Sample}$ | | | |

转换字体十分常用，例如在积分中：

$$
\begin{array}{c | c}
\mathrm{Bad} & \mathrm{Better} \\\\
\hline \\\\
\int_0^1 x^2 dx & \int_0^1 x^2 \\,{\rm d}x
\end{array}
$$

$$ \begin{array}{c | c} \mathrm{Bad} & \mathrm{Better} \ \hline \ \int_0^1 x^2 dx & \int_0^1 x^2 ,{\rm d}x \end{array} $$

注意比较两个式子间 dx 的不同。使用 \operatorname 命令也可以达到相同的效果，详见定义新的符号 \operatorname 。

14．大括号和行标的使用

使用 \left 和 \right 来创建自动匹配高度的 (圆括号)，[方括号] 和 {花括号} 。在每个公式末尾前使用 \tag{行标} 来实现行标。

$$
f\left(
	\left[
		\frac{
			1+\left\\{x,y\right\\}
        }{
            \left(
            \frac xy + \frac yx
            \right)
            (u+1)
        }+a
    \right]^{3/2}
\right)
\tag {行标}
$$

$$ f\left( \left[ \frac{ 1+\left{x,y\right} }{ \left( \frac xy + \frac yx \right) (u+1) }+a \right]^{3/2} \right) \tag {行标} $$

如果你需要在不同的行显示对应括号，可以在每一行对应处使用 \left. 或 \right. 来放一个“影子“括号：

$$
\begin{aligned}
a=&\left(1+2+3+ \cdots \right. \\\\
& \cdots+ \left. \infty-2+\infty-1+\infty\right)
\end{aligned}
$$

$$ \begin{aligned} a=&\left(1+2+3+ \cdots \right. \ & \cdots+ \left. \infty-2+\infty-1+\infty\right) \end{aligned} $$

15．其它命令

(1) 定义新的符号 \operatorname

查询关于此命令的定义和关于此命令的讨论来进一步了解此命令。

$$ \operatorname{Symbol} A $$

$$ \operatorname{Symbol} A $$

(2) 添加注释文字 \text

在 \text {文字} 中仍可以使用 $公式$ 插入其它公式。

$$ f(n)= \begin{cases} n/2, & \text {if $n$ is even} \\\\ 3n+1, & \text{if $n$ is odd} \end{cases} $$

$$ f(n)= \begin{cases} n/2, & \text {if $n$ is even} \ 3n+1, & \text{if $n$ is odd} \end{cases} $$

(3) 在字符间加入空格

有四种宽度的空格可以使用： \,、\;、\quad 和 \qquad 。

$$ a \, b \mid a \; b \mid a \quad b \mid a \qquad b $$

$$ a , b \mid a ; b \mid a \quad b \mid a \qquad b $$

当然，使用 \text {n个空格} 也可以达到同样效果

(4) 更改文字颜色

使用 \color{颜色}{文字} 来更改特定的文字颜色。更改文字颜色需要浏览器支持，如果浏览器不知道你所需的颜色，那么文字将被渲染为黑色。

对于较旧的浏览器（HTML4与CSS2），支持的颜色较少; 对于较新的浏览器（HTML5与CSS3），额外的124种颜色将被支持输入 \color {#rgb} {text} 来自定义更多的颜色，其中 #rgb 的 r g b 可输入 0-9 和 a-f 来表示红色、绿色和蓝色的纯度（饱和度）。

\begin{array}{|rrrrrrrr|}
\hline
\verb+#000+ &amp; \color{#000}{text} &amp; \verb+#005+ &amp; \color{#005}{text} &amp; \verb+#00A+ &amp; \color{#00A}{text} &amp; \verb+#00F+ &amp; \color{#00F}{text}  \\\\
\verb+#500+ &amp; \color{#500}{text} &amp; \verb+#505+ &amp; \color{#505}{text} &amp; \verb+#50A+ &amp; \color{#50A}{text} &amp; \verb+#50F+ &amp; \color{#50F}{text}  \\\\
\verb+#A00+ &amp; \color{#A00}{text} &amp; \verb+#A05+ &amp; \color{#A05}{text} &amp; \verb+#A0A+ &amp; \color{#A0A}{text} &amp; \verb+#A0F+ &amp; \color{#A0F}{text}  \\\\
\verb+#F00+ &amp; \color{#F00}{text} &amp; \verb+#F05+ &amp; \color{#F05}{text} &amp; \verb+#F0A+ &amp; \color{#F0A}{text} &amp; \verb+#F0F+ &amp; \color{#F0F}{text}  \\\\
\hline
\verb+#080+ &amp; \color{#080}{text} &amp; \verb+#085+ &amp; \color{#085}{text} &amp; \verb+#08A+ &amp; \color{#08A}{text} &amp; \verb+#08F+ &amp; \color{#08F}{text}  \\\\
\verb+#580+ &amp; \color{#580}{text} &amp; \verb+#585+ &amp; \color{#585}{text} &amp; \verb+#58A+ &amp; \color{#58A}{text} &amp; \verb+#58F+ &amp; \color{#58F}{text}  \\\\
\verb+#A80+ &amp; \color{#A80}{text} &amp; \verb+#A85+ &amp; \color{#A85}{text} &amp; \verb+#A8A+ &amp; \color{#A8A}{text} &amp; \verb+#A8F+ &amp; \color{#A8F}{text}  \\\\
\verb+#F80+ &amp; \color{#F80}{text} &amp; \verb+#F85+ &amp; \color{#F85}{text} &amp; \verb+#F8A+ &amp; \color{#F8A}{text} &amp; \verb+#F8F+ &amp; \color{#F8F}{text}  \\\\
\hline
\verb+#0F0+ &amp; \color{#0F0}{text} &amp; \verb+#0F5+ &amp; \color{#0F5}{text} &amp; \verb+#0FA+ &amp; \color{#0FA}{text} &amp; \verb+#0FF+ &amp; \color{#0FF}{text}  \\\\
\verb+#5F0+ &amp; \color{#5F0}{text} &amp; \verb+#5F5+ &amp; \color{#5F5}{text} &amp; \verb+#5FA+ &amp; \color{#5FA}{text} &amp; \verb+#5FF+ &amp; \color{#5FF}{text}  \\\\
\verb+#AF0+ &amp; \color{#AF0}{text} &amp; \verb+#AF5+ &amp; \color{#AF5}{text} &amp; \verb+#AFA+ &amp; \color{#AFA}{text} &amp; \verb+#AFF+ &amp; \color{#AFF}{text}  \\\\
\verb+#FF0+ &amp; \color{#FF0}{text} &amp; \verb+#FF5+ &amp; \color{#FF5}{text} &amp; \verb+#FFA+ &amp; \color{#FFA}{text} &amp; \verb+#FFF+ &amp; \color{#FFF}{text}  \\\\
\hline
\end{array}

$$ \begin{array}{|rrrrrrrr|} \hline \verb+#000+ & \color{#000}{text} & \verb+#005+ & \color{#005}{text} & \verb+#00A+ & \color{#00A}{text} & \verb+#00F+ & \color{#00F}{text} \ \verb+#500+ & \color{#500}{text} & \verb+#505+ & \color{#505}{text} & \verb+#50A+ & \color{#50A}{text} & \verb+#50F+ & \color{#50F}{text} \ \verb+#A00+ & \color{#A00}{text} & \verb+#A05+ & \color{#A05}{text} & \verb+#A0A+ & \color{#A0A}{text} & \verb+#A0F+ & \color{#A0F}{text} \ \verb+#F00+ & \color{#F00}{text} & \verb+#F05+ & \color{#F05}{text} & \verb+#F0A+ & \color{#F0A}{text} & \verb+#F0F+ & \color{#F0F}{text} \ \hline \verb+#080+ & \color{#080}{text} & \verb+#085+ & \color{#085}{text} & \verb+#08A+ & \color{#08A}{text} & \verb+#08F+ & \color{#08F}{text} \ \verb+#580+ & \color{#580}{text} & \verb+#585+ & \color{#585}{text} & \verb+#58A+ & \color{#58A}{text} & \verb+#58F+ & \color{#58F}{text} \ \verb+#A80+ & \color{#A80}{text} & \verb+#A85+ & \color{#A85}{text} & \verb+#A8A+ & \color{#A8A}{text} & \verb+#A8F+ & \color{#A8F}{text} \ \verb+#F80+ & \color{#F80}{text} & \verb+#F85+ & \color{#F85}{text} & \verb+#F8A+ & \color{#F8A}{text} & \verb+#F8F+ & \color{#F8F}{text} \ \hline \verb+#0F0+ & \color{#0F0}{text} & \verb+#0F5+ & \color{#0F5}{text} & \verb+#0FA+ & \color{#0FA}{text} & \verb+#0FF+ & \color{#0FF}{text} \ \verb+#5F0+ & \color{#5F0}{text} & \verb+#5F5+ & \color{#5F5}{text} & \verb+#5FA+ & \color{#5FA}{text} & \verb+#5FF+ & \color{#5FF}{text} \ \verb+#AF0+ & \color{#AF0}{text} & \verb+#AF5+ & \color{#AF5}{text} & \verb+#AFA+ & \color{#AFA}{text} & \verb+#AFF+ & \color{#AFF}{text} \ \verb+#FF0+ & \color{#FF0}{text} & \verb+#FF5+ & \color{#FF5}{text} & \verb+#FFA+ & \color{#FFA}{text} & \verb+#FFF+ & \color{#FFF}{text} \ \hline \end{array} $$

(5) 添加删除线

使用删除线功能必须声明 $$ 符号。

(注意: katex 不需要\\require{cancel})

在公式内使用 \require{cancel} 来允许 片段删除线 的显示。声明片段删除线后，使用 \cancel{字符}、\bcancel{字符}、\xcancel{字符} 和 \cancelto{字符} 来实现各种片段删除线效果。

\begin{array}{rl}
\verb|y+\cancel{x}| &amp; y+\cancel{x}\\\\
\verb|\cancel{y+x}| &amp; \cancel{y+x}\\\\
\verb|y+\bcancel{x}| &amp; y+\bcancel{x}\\\\
\verb|y+\xcancel{x}| &amp; y+\xcancel{x}\\\\
\verb|y+\cancelto{0}{x}| &amp; y+\cancelto{0}{x}\\\\ (katex 不支持)
\verb+\frac{1\cancel9}{\cancel95} = \frac15+&amp; \frac{1\cancel9}{\cancel95} = \frac15 \\
\end{array}

$$ \begin{array}{rl} \verb|y+\cancel{x}| & y+\cancel{x}\ \verb|\cancel{y+x}| & \cancel{y+x}\ \verb|y+\bcancel{x}| & y+\bcancel{x}\ \verb|y+\xcancel{x}| & y+\xcancel{x}\ \verb+\frac{1\cancel9}{\cancel95} = \frac15+ & \frac{1\cancel9}{\cancel95} = \frac15 \ \end{array} $$

二、矩阵使用参考

1．如何输入无框矩阵

在开头使用 begin{matrix}，在结尾使用 end{matrix}，在中间插入矩阵元素，每个元素之间插入 & ，并在每行结尾处使用 \ 。使用矩阵时必须声明 $ 或 $$ 符号。

$$
    \begin{matrix}
    1 & x & x^2 \\\\
    1 & y & y^2 \\\\
    1 & z & z^2 \\\\
    \end{matrix}
$$

$$ \begin{matrix} 1 & x & x^2 \ 1 & y & y^2 \ 1 & z & z^2 \ \end{matrix} $$

2．如何输入带边框的矩阵

在开头将 matrix 替换为 pmatrix bmatrix Bmatrix vmatrix Vmatrix 。

$ \begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{matrix} $
$ \begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{pmatrix} $
$ \begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{bmatrix} $
$ \begin{Bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{Bmatrix} $
$ \begin{vmatrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{vmatrix} $
$ \begin{Vmatrix} 1 & 2 \\\\ 3 & 4 \\\\ \end{Vmatrix} $

$$ \begin{matrix} 1 & 2 \\ 3 & 4 \\ \end{matrix} \ \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix} \ \begin{bmatrix} 1 & 2 \\ 3 & 4 \\ \end{bmatrix} \ \begin{Bmatrix} 1 & 2 \\ 3 & 4 \\ \end{Bmatrix} \ \begin{vmatrix} 1 & 2 \\ 3 & 4 \\ \end{vmatrix} \ \begin{Vmatrix} 1 & 2 \\ 3 & 4 \\ \end{Vmatrix} \ $$

3．如何输入带省略符号的矩阵

使用 \cdots , \ddots , \vdots 来输入省略符号。

$$
        \begin{pmatrix}
        1 & a_1 & a_1^2 & \cdots & a_1^n \\\\
        1 & a_2 & a_2^2 & \cdots & a_2^n \\\\
        \vdots & \vdots & \vdots & \ddots & \vdots \\\\
        1 & a_m & a_m^2 & \cdots & a_m^n \\\\
        \end{pmatrix}
$$

$$ \begin{pmatrix} 1 & a_1 & a_1^2 & \cdots & a_1^n \ 1 & a_2 & a_2^2 & \cdots & a_2^n \ \vdots & \vdots & \vdots & \ddots & \vdots \ 1 & a_m & a_m^2 & \cdots & a_m^n \ \end{pmatrix} $$

4．如何输入带分割符号的矩阵

$$
        \left[
            \begin{array}{cc|c}
              1&2&3\\\\
              4&5&6
            \end{array}
        \right]
$$

其中 cc|c 代表在一个三列矩阵中的第二和第三列之间插入分割线。

$$ \left[ \begin{array}{cc|c} 1&2&3\ 4&5&6 \end{array} \right] $$

5．如何输入行中矩阵

若想在一行内显示矩阵，使用\bigl(\begin{smallmatrix} ... \end{smallmatrix}\bigr)。

这是一个行中矩阵的示例 $\bigl( \begin{smallmatrix} a & b \\\\ c & d \end{smallmatrix} \bigr)$ 。

这是一个行中矩阵的示例 $\bigl(\begin{smallmatrix} a & b \ c & d \end{smallmatrix}\bigr)$

三、方程式序列使用参考

1．如何输入一个方程式序列

人们经常想要一列整齐且居中的方程式序列。使用 \begin{align}…\end{align} 来创造一列方程式，其中在每行结尾处使用 \\ 。使用方程式序列无需声明公式符号 $ 或 $$ 。

请注意 {align} 语句是 自动编号 的。

$$
\left\\{ 
    \begin{array}{c}
        a_1x+b_1y+c_1z &=d_1 \\\\ 
        a_2x+b_2y+c_2z &=d_2 \\\\ 
        a_3x+b_3y+c_3z &=d_3 \\\\
    \end{array}
\right. 
$$

$$ \left{ \begin{array}{c} a_1x+b_1y+c_1z &=d_1 \ a_2x+b_2y+c_2z &=d_2 \ a_3x+b_3y+c_3z &=d_3 \ \end{array} \right. $$

2．在一个方程式序列的每一行中注明原因

在 {align} 中灵活组合 \text 和 \tag 语句。\tag 语句编号优先级高于自动编号。

$$
\begin{align}
   v + w & = 0  &\text{Given} \tag 1\\\\
   -w & = -w + 0 & \text{additive identity} \tag 2\\\\
   -w + 0 & = -w + (v + w) & \text{equations $(1)$ and $(2)$} \tag 3
\end{align}
$$

$$ \begin{align} v + w & = 0 &\text{Given} \tag 1\\ -w & = -w + 0 & \text{additive identity} \tag 2\\ -w + 0 & = -w + (v + w) & \text{equations $(1)$ and $(2)$} \tag 3 \end{align} $$

本例中第一、第二行的自动编号被 \tag 语句覆盖，第三行的编号为自动编号。

四、条件表达式使用参考

1．如何输入一个条件表达式

使用 begin{cases} 来创造一组条件表达式，在每一行条件中插入 & 来指定需要对齐的内容，并在每一行结尾处使用 \\，以 end{cases} 结束。条件表达式无需声明 $ 或 $$ 符号。

$$
        f(n) =
        \begin{cases}
        n/2,  & \text{if $n$ is even} \\\\
        3n+1, & \text{if $n$ is odd}
        \end{cases}
$$

$$ f(n) = \begin{cases} n/2, & \text{if $n$ is even} \\ 3n+1, & \text{if $n$ is odd} \end{cases} $$

2．如何输入一个左侧对齐的条件表达式

若想让文字在左侧对齐显示，则有如下方式：

$$
        \left.
        \begin{array}{l}
        \text{if $n$ is even:}&n/2\\\\
        \text{if $n$ is odd:}&3n+1
        \end{array}
        \right\\}
        =f(n)
$$

$$ \left. \begin{array}{l} \text{if $n$ is even:}&n/2\ \text{if $n$ is odd:}&3n+1 \end{array} \right} =f(n) $$

3．如何使条件表达式适配行高

在一些情况下，条件表达式中某些行的行高为非标准高度，此时使用 \\[2ex] 语句代替该行末尾的 \\ 来让编辑器适配。

不适配[2ex]

$$
f(n) = 
\begin{cases}
\frac{n}{2},  & \text{if $n$ is even} \\\\
3n+1, & \text{if $n$ is odd}
\end{cases}
$$

$$ f(n) = \begin{cases} \frac{n}{2}, & \text{if $n$ is even} \ 3n+1, & \text{if $n$ is odd} \end{cases} $$

适配[2ex]

$$
f(n) = 
\begin{cases}
\frac{n}{2},  & \text{if $n$ is even} \\\\[2ex]
3n+1, & \text{if $n$ is odd}
\end{cases}
$$

$$ f(n) = \begin{cases} \frac{n}{2}, & \text{if $n$ is even} \[2ex] 3n+1, & \text{if $n$ is odd} \end{cases} $$

一个 [ex] 指一个 “X-Height”，即x字母高度。可以根据情况指定多个 [ex]，如 [3ex]、[4ex] 等。其实可以在任何地方使用 \\[2ex] 语句，只要你觉得合适。

五、数组与表格使用参考

1．如何输入一个数组或表格

通常，一个格式化后的表格比单纯的文字或排版后的文字更具有可读性。数组和表格均以 begin{array} 开头，并在其后定义列数及每一列的文本对齐属性，c l r 分别代表居中、左对齐及右对齐。若需要插入垂直分割线，在定义式中插入 | ，若要插入水平分割线，在下一行输入前插入 \hline 。与矩阵相似，每行元素间均须要插入 & ，每行元素以 \\ 结尾，最后以 end{array} 结束数组。使用单个数组或表格时无需声明 $ 或 $$ 符号。

$$
\begin{array}{c|lcr}
n & \text{左对齐} & \text{居中对齐} & \text{右对齐} \\\\
\hline
1 & 0.24 & 1 & 125 \\\\
2 & -1 & 189 & -8 \\\\
3 & -20 & 2000 & 1+10i
\end{array}
$$

$$ \begin{array}{c|lcr} n & \text{左对齐} & \text{居中对齐} & \text{右对齐} \ \hline 1 & 0.24 & 1 & 125 \ 2 & -1 & 189 & -8 \ 3 & -20 & 2000 & 1+10i \end{array} $$

2．如何输入一个嵌套的数组或表格

多个数组/表格可互相嵌套 并组成一组数组/一组表格。使用嵌套前必须声明 $$ 符号。

$$
% outer vertical array of arrays 外层垂直表格
\begin{array}{c}
    % inner horizontal array of arrays 内层水平表格
    \begin{array}{cc}
        % inner array of minimum values 内层"最小值"数组
        \begin{array}{c|cccc}
        \text{min} & 0 & 1 & 2 & 3\\\\
        \hline
        0 & 0 & 0 & 0 & 0\\\\
        1 & 0 & 1 & 1 & 1\\\\
        2 & 0 & 1 & 2 & 2\\\\
        3 & 0 & 1 & 2 & 3
        \end{array}
    &
        % inner array of maximum values 内层"最大值"数组
        \begin{array}{c|cccc}
        \text{max}&0&1&2&3\\\\
        \hline
        0 & 0 & 1 & 2 & 3\\\\
        1 & 1 & 1 & 2 & 3\\\\
        2 & 2 & 2 & 2 & 3\\\\
        3 & 3 & 3 & 3 & 3
        \end{array}
    \end{array}
    % 内层第一行表格组结束
    \\\\
    % inner array of delta values 内层第二行Delta值数组
        \begin{array}{c|cccc}
        \Delta&0&1&2&3\\\\
        \hline
        0 & 0 & 1 & 2 & 3\\\\
        1 & 1 & 0 & 1 & 2\\\\
        2 & 2 & 1 & 0 & 1\\\\
        3 & 3 & 2 & 1 & 0
        \end{array}
        % 内层第二行表格组结束
\end{array}
$$

$$ % outer vertical array of arrays 外层垂直表格 \begin{array}{c} % inner horizontal array of arrays 内层水平表格 \begin{array}{cc} % inner array of minimum values 内层"最小值"数组 \begin{array}{c|cccc} \text{min} & 0 & 1 & 2 & 3\\ \hline 0 & 0 & 0 & 0 & 0\\ 1 & 0 & 1 & 1 & 1\\ 2 & 0 & 1 & 2 & 2\\ 3 & 0 & 1 & 2 & 3 \end{array} & % inner array of maximum values 内层"最大值"数组 \begin{array}{c|cccc} \text{max}&0&1&2&3\\ \hline 0 & 0 & 1 & 2 & 3\\ 1 & 1 & 1 & 2 & 3\\ 2 & 2 & 2 & 2 & 3\\ 3 & 3 & 3 & 3 & 3 \end{array} \end{array} % 内层第一行表格组结束 \\ % inner array of delta values 内层第二行Delta值数组 \begin{array}{c|cccc} \Delta&0&1&2&3\\ \hline 0 & 0 & 1 & 2 & 3\\ 1 & 1 & 0 & 1 & 2\\ 2 & 2 & 1 & 0 & 1\\ 3 & 3 & 2 & 1 & 0 \end{array} % 内层第二行表格组结束 \end{array} $$

3．如何输入一个方程组

使用 \begin{array}…\end{array} 和 \left\{…\right. 来创建一个方程组。

$$
\left\\{ 
    \begin{array}{c}
    a_1x+b_1y+c_1z=d_1 \\\\
    a_2x+b_2y+c_2z=d_2 \\\\ 
    a_3x+b_3y+c_3z=d_3
    \end{array}
\right. 
$$

$$ \left{ \begin{array}{c} a_1x+b_1y+c_1z=d_1 \ a_2x+b_2y+c_2z=d_2 \ a_3x+b_3y+c_3z=d_3 \ \end{array} \right. $$

或者使用条件表达式组 \begin{cases}…\end{cases} 来实现相同效果：

$$
\begin{cases}
a_1x+b_1y+c_1z=d_1 \\\\
a_2x+b_2y+c_2z=d_2 \\\\ 
a_3x+b_3y+c_3z=d_3
\end{cases}
$$

$$ \begin{cases} a_1x+b_1y+c_1z=d_1 \ a_2x+b_2y+c_2z=d_2 \ a_3x+b_3y+c_3z=d_3 \end{cases} $$

六、连分数使用参考

1．如何输入一个连分式

就像输入分式时使用 \frac 一样，使用 \cfrac 来创建一个连分数。

$$
x = a_0 + \cfrac{1^2}{a_1
          + \cfrac{2^2}{a_2
          + \cfrac{3^2}{a_3 + \cfrac{4^4}{a_4 + \cdots}}}}
$$

$$ x = a_0 + \cfrac{1^2}{a_1 + \cfrac{2^2}{a_2 + \cfrac{3^2}{a_3 + \cfrac{4^4}{a_4 + \cdots}}}} $$

不要使用普通的 \frac 或 \over 来创建，否则会看起来 很恶心 。

$$
x = a_0 + \frac{1^2}{a_1
          + \frac{2^2}{a_2
          + \frac{3^2}{a_3 + \frac{4^4}{a_4 + \cdots}}}}
$$

$$ x = a_0 + \frac{1^2}{a_1 + \frac{2^2}{a_2 + \frac{3^2}{a_3 + \frac{4^4}{a_4 + \cdots}}}} $$

当然，你可以使用 \frac 来表达连分数的 紧缩记法 。

$$
x = a_0 + \frac{1^2}{a_1+}
          \frac{2^2}{a_2+}
          \frac{3^2}{a_3 +} \frac{4^4}{a_4 +} \cdots
$$

$$ x = a_0 + \frac{1^2}{a_1+} \frac{2^2}{a_2+} \frac{3^2}{a_3 +} \frac{4^4}{a_4 +} \cdots $$

连分数通常都太大以至于不易排版，所以建议在连分数前后声明 $$ 符号，或使用像 [a0;a1,a2,a3,…] 一样的紧缩记法。

七、交换图表使用参考

1．如何输入一个交换图表

使用一行 \require{AMScd} 语句来允许交换图表的显示。声明交换图表后，语法与矩阵相似，在开头使用 begin{CD}，在结尾使用 end{CD}，在中间插入图表元素，每个元素之间插入 & ，并在每行结尾处使用\\ 。

$$
\begin{CD}
    A  @>a>>  B \\\\
    @VbVV   @VVcV \\\\
    C  @>>d>  D
\end{CD}
$$

$$ \begin{CD} A @>a>> B \ @VbVV @VVcV \ C @>>d> D \end{CD} $$

其中，@>>> 代表右箭头、@<<< 代表左箭头、@VVV 代表下箭头、@AAA 代表上箭头、@= 代表水平双实线、@| 代表竖直双实线、@.代表没有箭头。在 @>>> 的 >>> 之间任意插入文字即代表该箭头的注释文字。

$$
\begin{CD}
    A @>>> B @>{\text{very long label}}>> C \\\\
    @. @AAA @| \\\\
    D @= E @<<< F
\end{CD}
$$

$$ \begin{CD} A @>>> B @>{\text{very long label}}>> C \ @. @AAA @| \ D @= E @<<< F \end{CD} $$

在本例中， “very long label“自动延长了它所在箭头以及对应箭头的长度。

八、一些特殊的注意事项

有些小窍门会让数学公式显得更好看，强迫症和完美主义者会喜欢下面的内容。

1. 某些分数的显示问题

在以e为底的指数函数、极限和积分中尽量不要使用 \frac 符号：它会使整段函数看起来很怪，而且可能产生歧义。也正是因此它在专业数学排版中几乎从不出现。横着写这些分式，中间使用斜线间隔 / （用斜线代替分数线）。

$$
\begin{array}{c|c}
\mathrm{Bad} & \mathrm{Better} \\\\
\hline \\\\
e^{i\frac{\pi}2} \quad e^{\frac{i\pi}2}& e^{i\pi/2} \\\\
\int_{-\frac\pi2}^\frac\pi2 \sin x\,dx & \int_{-\pi/2}^{\pi/2}\sin x\,dx \\\\
\end{array}
$$

$$ \begin{array}{c|c} \mathrm{Bad} & \mathrm{Better} \ \hline \ e^{i\frac{\pi}2} \quad e^{\frac{i\pi}2}& e^{i\pi/2} \ \int_{-\frac\pi2}^\frac\pi2 \sin x,dx & \int_{-\pi/2}^{\pi/2}\sin x,dx \ \end{array} $$

2. 留出合理的间隔

| 符号在被当作分隔符时会产生过于狭窄的间隔，因此在需要分隔时最好使用 \mid 来代替它。

$$
\begin{array}{c|c}
\mathrm{Bad} & \mathrm{Better} \\\\
\hline \\\\
\{x|x^2\in\Bbb Z\} & \{x\mid x^2\in\Bbb Z\} \\\\
\end{array}
$$

$$\begin{array}{c|c} \mathrm{Bad} & \mathrm{Better} \ \hline \ {x|x^2\in\Bbb Z} & {x\mid x^2\in\Bbb Z} \ \end{array}$$

3. 多重积分符号的显示

使用多重积分符号时，不要多次使用 \int 来声明，直接使用 \iint 来表示二重积分，使用 \iiint 来表示三重积分等。对于无限次积分，可以用 \int \cdots \int 表示。

$$
\begin{array}{c|c}
\mathrm{Bad} & \mathrm{Better} \\\\
\hline \\\\
\int\int_S f(x)\,dy\,dx & \iint_S f(x)\,dy\,dx \\\\
\int\int\int_V f(x)\,dz\,dy\,dx & \iiint_V f(x)\,dz\,dy\,dx
\end{array}
$$

$$\begin{array}{c|c} \mathrm{Bad} & \mathrm{Better} \ \hline \ \int\int_S f(x),dy,dx & \iint_S f(x),dy,dx \ \int\int\int_V f(x),dz,dy,dx & \iiint_V f(x),dz,dy,dx \end{array}$$

4. 多个微分符号的显示

在微分符号前加入 \, 来插入一个小的间隔空隙；没有 \, 符号的话，将会把不同的微分符号堆在一起。

$$
\begin{array}{c|c}
\mathrm{Bad} & \mathrm{Better} \\\\
\hline \\\\
\iiint_V f(x){\rm d}z {\rm d}y {\rm d}x & \iiint_V f(x)\,{\rm d}z\,{\rm d}y\,{\rm d}x
\end{array}
$$

$$ \begin{array}{c|c} \mathrm{Bad} & \mathrm{Better} \ \hline \ \iiint_V f(x){\rm d}z {\rm d}y {\rm d}x & \iiint_V f(x),{\rm d}z,{\rm d}y,{\rm d}x \end{array} $$

感谢您花费时间阅读这份指导手册，本手册内容可能有疏漏之处，欢迎更改指正。

深入浅出 Docker 技术

Sat, 12 Apr 2025 00:00:00 GMT

Docker 是什么

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux 或 Windows 操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

容器技术

容器使软件应用程序与操作系统脱钩，从而为用户提供了一个干净而最小的Linux环境，同时在一个或多个隔离的“容器”中运行其他所有内容。容器的目的是启动一组有限的应用程序或服务（通常称为微服务），并使它们在独立的沙盒环境中运行。

这种隔离可防止在给定容器中运行的进程监视或影响在另一个容器中运行的进程。同样，这些容器化服务不会影响或干扰主机。能够将分散在多个物理服务器上的许多服务整合为一个的想法，是数据中心选择采用该技术的众多原因之一。

容器VS虚拟机

首先我们来看下面一张图，下面是虚拟机的实现方式

虚拟机实现资源隔离的方法是利用在主操作系统上运行独立的从操作系统，上图所示，在最底层运行的是我们所熟知的服务器，通常服务器上会运行一个主操作系统.

虚拟机的Guest OS即为虚拟机安装的操作系统，它是一个完整操作系统内核；虚拟机的Hypervisor层可以简单理解为一个硬件虚拟化平台，他负责协调宿主机上的硬件资源分配与管理.一个比较经典的虚拟机软件就是Parallels Desktop.

下面再来看看Docker的实现方式

Docker容器技术的实现要比虚拟机技术的实现减少一层，由于Docker不需要Hypervisor实现硬件资源虚拟化，运行在Docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上Docker将会在效率上有优势.

最后做一个简单的比较.

| 特性 | 容器 | 虚拟机 | | --- | --- | --- | | 启动 | 秒级 | 分钟级 | | 硬盘使用 | 一般为MB | 一般为GB | | 性能 | 接近原生 | 弱于 | | 系统支持量 | 单机支持上千个容器 | 一般是几十个 |

Docker 的使用

可能有部分读者朋友们没有直接的使用过docker.我们先来举一个例子.在以前没有docker的情况下，假使我们想在linux环境下运行一个mysql，可能我们先要下载压缩包，解压，编译，设置等等流程，十分复杂.

但是当我们使用docker运行mysql时，只需要先运行docker pull mysql就会自动下载最新的mysql镜像.

再运行docker run mysql以后，就可以直接运行，如果你想再运行一份mysql实例，只需要再运行一次docker run的命令，并设置新的端口就能运行，这么一看是不是感觉docker是不是非常好用.

docker的功能还远远不止这些，接下来让我们一起走进docker，看看docker是怎么实现的容器技术.

Docker 基础概念

运行流程

在Docker运行的流程图中，我们可以简单的把image理解为可执行程序，Container就是运行起来的进程。Registry就是代码管理平台.

那么写程序需要源代码，那么“写”image的"源代码"就是dockerfile，docker就是"编译器"。

因此我们只需要在dockerfile中指定需要哪些程序、依赖什么样的配置，之后把dockerfile交给“编译器”docker进行“编译”，生成"可执行程序"image，之后就可以运行这个image了，image运行起来后就是Docker container。

`Image`(镜像)

Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

首先来看一个比较简单的例子:

上图是一个由debian系统作为基础镜像的简历样例，可以看到中间层就是基础的镜像，我们并没有对镜像进行任何定制化的操作，运行起来后就生成了一个容器，容器才是可写的对象.

对于Linux而言，内核启动后，会挂载root文件系统为其提供用户空间支持。而Docker镜像（Image），就相当于是一个root文件系统。

当然，Docker能实现的功能远不止如此，下面我们再来看看如何使用DockerFile构建一个定制化镜像:

FROM debian
RUN apt-get install emacs
RUN apt-get install apache2
CMD ["/bin/bash"]

Docker设计时，充分利用Union FS的技术，将其设计为分层存储的架构。镜像实际是由多层文件系统联合组成。

镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。

分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。

但是在构建镜像时也要格外的注意，比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。所以在构建镜像时，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。

`Container`(容器)

容器 (container) 的定义和镜像 (image) 几乎一模一样，唯一区别在于容器的最上面那一层是可读可写的。

广义上我们可以将容器理解为，容器 = 镜像 + 读写层。

`Repository`(仓库)

镜像构建完成后，可以很容易的在当前宿主上运行，但是如何在其他服务器上运行这个镜像，那么我们就需要一个集中存放镜像文件的场所.这时就引出了Docker Repository的概念.

Docker Registry (仓库注册服务器)是一个集中的存储、分发镜像的服务。Docker 仓库的概念跟 Git 类似，注册服务器可以理解为 GitHub 这样的托管服务。实际上，一个 Docker Registry 中可以包含多个仓库 (Repository) ，每个仓库可以包含多个标签 (Tag)，每个标签对应着一个镜像。所以说，镜像仓库是 Docker 用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。

通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本 。我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签.。

仓库又可以分为两种形式：

public(公有仓库)
private(私有仓库)

Docker Registry 公有仓库是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。

除了使用公开服务外，用户还可以在本地搭建私有 Docker Registry 。Docker 官方提供了 Docker Registry镜像，可以直接使用做为私有 Registry 服务。当用户创建了自己的镜像之后就可以使用 push 命令将它上传到公有或者私有仓库，这样下次在另外一台机器上使用这个镜像时候，只需要从仓库上 pull 下来就可以了。

Docker 架构

Docker是一个C/S模式的架构，后端是一个松耦合架构，模块各司其职。

用户的所有命令通过Docker Client与Docker Daemon建立通信，并发送请求给后者。
Docker Daemon作为Docker架构中的主体部分，首先提供Server的功能使其可以接受Docker Client的请求；
Engine执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。

在之前的基础概念中，我们已经了解了Registry，Container等概念.接下来就是一些Docker运行过程中的组件介绍.

`Docker Client`

Docker Client是和Docker Daemon建立通信的客户端。用户使用docker命令后，Docker Client负责解析对应的命令以及参数，并向Docker Daemon服务端发起请求.
Docker Client可以通过以下三种方式和Docker Daemon建立通信：
1. tcp://host:port
2. unix://path_to_socket
3. fd://socketfd
Docker Client发送容器管理请求后，由Docker Daemon接受并处理请求，当Docker Client接收到返回的请求相应并简单处理后，Docker Client一次完整的生命周期就结束了。一次完整的请求：发送请求→处理请求→返回结果，与传统的C/S架构请求流程一致.

`Docker Daemon`

Docker Daemon是docker的守护进程，也是docker运行时的核心.分别有两个部分组成.

Docker Server
1. Docker Server相当于C/S架构的服务端。功能为接受并调度分发Docker Client发送的请求。接受请求后，Server通过路由与分发调度，找到相应的Handler来执行请求。
2. 在Server的服务过程中，Server在listener上接受Docker Client的访问请求，并创建一个全新的goroutine来服务该请求。在goroutine中，首先读取请求内容，然后做解析工作，接着找到相应的路由项，随后调用相应的Handler来处理该请求，最后Handler处理完请求之后回复该请求。
Engine
1. Engine是Docker架构中的运行引擎，通过执行Job的方式来管理所有的容器与镜像。
2. 在Engine数据结构的设计与实现过程中，有一个handler对象。该handler对象存储的都是关于众多特定job的handler处理访问。举例说明，Engine的handler对象中有一项为：{“create”: daemon.ContainerCreate，}，则说明当名为"create"的job在运行时，执行的是daemon.ContainerCreate的handler。
Job
1. 一个Job可以认为是Docker架构中Engine内部最基本的工作执行单元。Docker可以做的每一项工作，都可以抽象为一个Job。无论是镜像的下载，容器的运行停止等等。Docker Server的运行过程实际也是一个Job，名为serveapi。
2. Job的概念与Unix中进程相仿。在Unix进程中，对每个进程都有名称，参数，环境变量，标准的输入输出，错误处理，返回状态等，在Docker的Job也都存在.

`Graph`

Graph中管理着所有本地已经下载的镜像.其中Graph DB中记录了所有镜像之间的依赖关系.

`Driver`

通过Driver驱动，Docker可以实现对Docker容器运行环境的定制，定制的维度主要有网络环境、存储方式以及容器执行方式。

Docker Driver的实现可以分为以下三类驱动：graphdriver、networkdriver和execdriver。

`graphdriver`

graphdriver主要用于完成容器镜像的管理，包括存储与获取。

graphdriver主要用于容器镜像的管理:

负责从Docker Registry下载镜像并进行存储，当用户下载指定的容器镜像时，graphdriver将容器镜像分层存储在本地的指定目录下.
负责从本地镜像存储目录中获取指定的容器镜像，并按特定规则为容器准备rootfs；
负责管理通过指定Dockerfile构建的全新镜像。

`networkdriver`

networkdriver的作用是完成Docker容器网络环境的配置，其中包括:

Docker Daemon启动时为Docker环境创建网桥；
Docker容器创建前为其分配相应的网络接口资源；
Docker容器分配IP、端口并与宿主机做NAT端口映射，设置容器防火墙策略等

`execdriver`

execdriver作为Docker容器的执行驱动，负责创建容器运行时的命名空间，负责管理容器资源使用的统计与限制，负责容器内部进程的真正运行等

在Docker 0.9.0版本之前，只支持使用Linux的LXC驱动进行容器管理，在0.9.0版本之后默认使用native驱动实现，native驱动是docker项目下一个全新的子项目，去除了外部依赖.

`libcontainer`

ibcontainer是Docker架构中一个使用Go语言设计实现的库，设计初衷是希望该库可以不依靠任何依赖，直接访问内核中与容器相关的系统调用。

正是由于libcontainer的存在，才使得docker可以不需要依赖LXC或者其他包就可以完成对防火墙，namespaces等的操作。

`Docker Container`

Docker Container（Docker容器）是Docker架构中服务交付的最终体现形式。Docker通过DockerDaemon的管理，libcontainer的执行，最终创建Docker容器。Docker容器作为一个交付单位，功能类似于传统意义上的虚拟机（Virtual Machine），具备资源受限、环境与外界隔离的特点。

流程梳理

看到这里，我相信各位读者朋友们应该已经对Docker基础架构有了一个大概得认知了，让我们以docker run为例子回顾一下 Docker 各个组件是如何协作的。

假设我们要运行一条: docker run -p 3306:3306 --name mysql -d mysql

容器启动过程如下：

Docker 客户端执行 docker run 命令
Docker daemon 通过graghdriver去Gragh中拉取最新的 mysql 镜像
Docker daemon 通过networkdriver建立端口映射
Docker daemon 通过execdriver启动容器

Docker 核心技术实现

在了解了这么多Docker实现以后，我们可能还会有最后一些疑问，Docker是如何实现资源隔离的.

在日常使用 Linux 或者 macOS 时，我们并没有运行多个完全分离的服务器的需要，但是如果我们在服务器上启动了多个服务，这些服务其实会相互影响的，每一个服务都能看到其他服务的进程，也可以访问宿主机器上的任意文件，这是很多时候我们都不愿意看到的，我们更希望运行在同一台机器上的不同服务能做到完全隔离，就像运行在多台不同的机器上一样。

Docker实现容器之间的完全隔离一共使用到了三大技术:

`Namespaces`(命名空间)

命名空间 (namespaces) 是 Linux 为我们提供的用于分离进程树、网络接口、挂载点以及进程间通信等资源的方法.

进程隔离

在Docker Deamon启动的初期，会通过setNamespaces函数去创建一个新的命名空间.在创建命名空间使用的clone函数中传入CLONE_NEWPID参数就完成容器对宿主机之间的进程隔离.

文件资源隔离

在创建命名空间使用的clone函数中传入CLONE_NEWNS参数，子进程即可得到父进程挂载的拷贝.

当容器创建时，容器需要一个自己的rootfs来实现与别的容器文件资源隔离，所以当Docker创建容器时，会将容器需要的目录进行挂载，并改变容器能访问的根目录，将容器之间的文件系统隔离.

改变容器能够访问个文件目录的根节点，libcontaine 提供的了pivot_root 或者 chroot 函数。

网络隔离

当 Docker 启动时，会自动在主机上创建一个 docker0 虚拟网桥，实际上是 Linux 的一个 bridge，可以理解为一个软件交换机。它会在挂载到它的网口之间进行转发。

当创建一个 Docker 容器的时候，同时会创建了一对veth pair接口。这对接口一端在容器内，即是容器内部的eth0；

veth pair是成对出现的一种虚拟网络设备接口，一端连着网络协议栈，一端彼此相连，彼此联通的这端数据互通。

另一端在本地并被挂载到 docker0 网桥，名称以 veth 开头。通过这种方式，主机可以跟容器通信，容器之间也可以相互通信。Docker就创建了在主机和所有容器之间一个虚拟共享网络。

`Control Groups`(控制组)

Control Groups（简称 CGroups）能够隔离宿主机器上的物理资源，CGroup提供以下这些功能.

限制进程组可以使用的资源数量（Resource limiting ）。比如：memory子系统可以为进程组设定一个memory使用上限，一旦进程组使用的内存达到限额再申请内存，就会触发OOM（out of memory）。
进程组的优先级控制（Prioritization ）。比如：可以使用cpu子系统为某个进程组分配特定cpu share。
记录进程组使用的资源数量（Accounting ）。比如：可以使用cpuacct子系统记录某个进程组使用的cpu时间
进程组隔离（Isolation）。比如：使用ns子系统可以使不同的进程组使用不同的namespace，以达到隔离的目的，不同的进程组有各自的进程、网络、文件系统挂载空间。
进程组控制（Control）。比如：使用freezer子系统可以将进程组挂起和恢复

物理资源隔离

CGroup通过多个子系统来控制系统资源的分配.

我们可以使用lssubsys -m查看当前系统下CGroup对应的子系统目录.

cpuset /sys/fs/cgroup/cpuset
cpu，cpuacct /sys/fs/cgroup/cpu，cpuacct
blkio /sys/fs/cgroup/blkio
memory /sys/fs/cgroup/memory
devices /sys/fs/cgroup/devices
freezer /sys/fs/cgroup/freezer
net_cls，net_prio /sys/fs/cgroup/net_cls，net_prio
perf_event /sys/fs/cgroup/perf_event
pids /sys/fs/cgroup/pids

在宿主机内，首先当Docker启动时，会在上述的所有子系统下创建docker文件夹.

当Docker创建容器时，会在docker文件夹下的task子目录下创建pid对应的新文件对容器资源进行分配以及管控.

`UnionFS`(联合文件系统)

Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下

在Docker中，每一个镜像层都是建立在另一个镜像层之上的，同时所有的镜像层都是只读的，只有每个容器最顶层的容器层才可以被用户直接读写，所以需要一个文件系统对所有的文件进行管理.

镜像管理

在Docker中目前使用了多种文件系统对镜像进行管理，包括当前主流的overlay2，aufs等等.

不同的存储驱动在存储镜像和容器文件时也有着完全不同的实现，有兴趣的读者可以在 Docker 的官方文档Docker storage drivers 中找到相应的内容。

Docker 常用命令

🐳 Docker 概念，工作流和实践 - 入门必懂

Dockerfile｜.dockerignore
docker build .
docker images
docker tag <IMAGE_ID> <USER_NAEM/IMAGE_NAME>:<TAG>，比如 docker tag e6f dansoncutnodejs:v1.0
docker login
docker push <USER_NAEM/IMAGE_NAME>:<TAG>
docker build -t eggpain-image .：构建的时候就指定镜像名
docker rmi -f dansoncut/nodejs:v1.0：后面那串其实就是镜像名
docker run -d <IMAGE_NAME>：-d 是 detached-mode 让容器不占用当前的命令行窗口
docker run -d -p <HOST_PORT:CONTAINER_PORT> --name <CONTAINER_NAME> <IMAGE_NAME>
docker ps、docker ps -a
docker stop <CONTAINER_NAME>
docker rm -f <CONTAINER_ID>/<CONTAINER_NAME>
docker exec -it <CONTAINER_NAME> /bin/bash：以终端交互的方式进入容器

Docker 网络模式

🐳 Docker 网络模式 Linux【Bridge | Host | None】

sudo docker network ls
- Bridge：如果没有指定容器的网络，默认加入的都是「默认 Bridge」网络，自定义 Bridge 网络可以提供自动 DNS 解析（默认 Bridge 不会自动为容器间进行 DNS 解析），不同 Bridge 网络还可以实现更好的隔离，所以非常适合单个宿主里运行多个容器。真因为起到隔离作用，容器里的数据要出来需要地址转化，即 NAT，性能会被拉低。
- Host：Host 网络就不需要地址转换了，即不需要端口映射（直接指定 --network host），因为容器直接和宿主合体了，适合高网络性能的场景，但存在安全问题；Host 网络没有自己的 IP 地址，在单个容器需要处理大量端口的时候，就不需要像 Bridge 网络那样逐个端口进行关联，但是如果要多个容器用同一个端口会出现端口冲突（该模式仅能在 Linux 主机上实现）
- None：不能联网，适合进行备份，有些需要网络隔离的一次性操作也非常好用。
sudo docker network create -d bridge <BRIDGE_NAME>：自定义 Bridge 网络，创建的网络可以通过 sudo docker network ls 查看；默认 Bridge 网络范围是 172.17.0.0/16，网关是 172.17.0.1；而新创建的网络则是 172.18.0.0/16，网关为 172.18.0.1。此后会出现一个类似 docker0 的接口。
Docker 安装后会出现一个 docker 0 的端口
sudo docker run -d --name naihe1 --hostname naihe1 --network naihe-bridge <IMAGE>：创建一个容器加入到自定义的 Bridge 网络
sudo docker run -d --name egg --network host <IMAGE>：创建一个 Host 网络下的容器，此时就不需要端口关联了，因为该容器和宿主共用所有网络和端口
sudo docker run -it --network none <IMAGE>：none 网络，无法联网
sudo docker network rm <NETWORK_NAME>：删除网络（Bridge 网络可以有多个，Host 网络只能有一个），注意，默认 bridge、host、none 网络都不能删除；该命令仅针对自定义 Bridge 网络。

dockerfile 与 docker-compose 通俗解释

先简单理解 docker 的使用过程，它分为镜像构建与容器启动。

镜像构建：即创建一个镜像，它包含安装运行所需的环境、程序代码等。这个创建过程就是使用 dockerfile 来完成的。
容器启动：容器最终运行起来是通过拉取构建好的镜像，通过一系列运行指令（如端口映射、外部数据挂载、环境变量等）来启动服务的。针对单个容器，这可以通过 docker run 来运行。

而如果涉及多个容器的运行（如服务编排）就可以通过 docker-compose 来实现，它可以轻松的将多个容器作为 service 来运行（当然也可仅运行其中的某个），并且提供了 scale (服务扩容) 的功能。

🙄简单总结：

dockerfile: 构建镜像；
docker run: 启动容器；
docker-compose: 启动服务；

从头开始：dockerfile、docker run、docker-compose 存在的必要性

假如你不用 docker ，搭建 wordpress 怎么弄？先找台 server ，假设其 OS 为 Ubuntu ，然后按照文档一步步敲命令，写配置，对吧？

用 docker 呢？随便找台 server ，不管什么操作系统，只要支持 docker 就行， docker run ubuntu, docker 会从官方源里拉取最新的 Ubuntu 镜像，可以认为你开了个 Ubuntu 虚拟机，然后一步步安装，跟上面一样。

但是这样安装有个显著的缺点，一旦 container 被删，你做的工作就都没了。当然可以用 docker commit 来保存成镜像，这样就可以复用了。

但是镜像一般比较大，而且只分享镜像的话，别人也不知道你这镜像到底包含什么，这些问题都不利于分享和复用。

一个直观的解决方案就是，写个脚本把安装过程全部记录下来，这样再次安装的时候，执行脚本就行了。 Dockerfile 就是这样的脚本，它记录了一个镜像的制作过程。

有了 Dockerfile, 只要执行 docker build . 就能制作镜像，而且 Dockerfile 就是文本文件，修改也很方便。

现在有了 wordpress 的镜像，只需要 docker run 就把 wordpress 启动起来了。

如果仅仅是 wordpress 这也就够了。但是很多时候，需要多个镜像合作才能启动一个服务，比如前端要有 nginx ，数据库 mysql, 邮件服务等等，当然你可以把所有这些都弄到一个镜像里去，但这样做就无法复用了。

更常见的是，nginx, mysql, smtp 都分别是个镜像，然后这些镜像合作，共同服务一个项目。

docker-compose 就是解决这个问题的。你的项目需要哪些镜像，每个镜像怎么配置，要挂载哪些 volume, 等等信息都包含在 docker-compose.yml 里。

要启动服务，只需要 docker-compose up 就行，停止也只需要 docker-compse stop/down

简而言之， Dockerfile 记录单个镜像的构建过程， docker-compse.yml 记录一个项目（project, 一般是多个镜像）的构建过程。

你说有些教程用了 dockerfile + docker-compose, 是因为 docker-compose.yml 本身没有镜像构建的信息，如果镜像是从 docker registry 拉取下来的，那么 Dockerfile 就不需要；如果镜像是需要 build 的，那就需要提供 Dockerfile.

docker-compose是编排容器的。例如，你有一个 php 镜像，一个 mysql 镜像，一个 nginx 镜像。如果没有 docker-compose，那么每次启动的时候，你需要敲各个容器的启动参数，环境变量，容器命名，指定不同容器的链接参数等等一系列的操作，相当繁琐。而用了 docker-composer 之后，你就可以把这些命令一次性写在 docker-composer.yml 文件中，以后每次启动这一整个环境（含 3 个容器）的时候，你只要敲一个 docker-composer up 命令就ok了。

dockerfile 的作用是从无到有的构建镜像。它包含安装运行所需的环境、程序代码等。这个创建过程就是使用 dockerfile 来完成的。

Dockerfile：为 docker build 命令准备的，用于建立一个独立的 image ，在 docker-compose 里也可以用来实时 build。

docker-compose.yml：为 docker-compose 准备的脚本，可以同时管理多个 container ，包括他们之间的关系、用官方 image 还是自己 build 、各种网络端口定义、储存空间定义等。

总结

看到这里相信各位读者朋友们对 Docker 已经有了更为深刻的理解.

由于 Docker 更新至今，代码库太过庞大，也只能从低版本的 Docker 源码以及大佬们的 Docker 技术文章中窥其一二，如果有感兴趣的朋友也可以相互交流.

参考文献

Git 个人工作流分享

Sat, 12 Apr 2025 00:00:00 GMT

查看本地分支与远程分支的对应关系

# 查看远程分支与本地分支的对应关系
$ git branch -vv
# 查看所有分支（远程 + 本地）
$ git branch -a

新建远程分支 | `push`

$ git checkout <local-branch>
# 本地分支和远程分支的名字可不一样，但一般是同名分支 | 关联后 (--set-upstream) 可直接 push
# git push origin master 这个master指的是远程分支，因为本地分支默认为当前分支
$ git push origin <local-branch>:<remote-branch>

Tip: push 的时候只会上传当前的 branch 的指向，并不会把本地的 HEAD 的指向也一起上传到远程仓库。事实上，远程仓库的 HEAD 是永远指向它的默认分支（即 master，如果不修改它的名称的话），并会随着默认分支的移动而移动的。

`--set-upstream` 设置远程分支与本地分支关联

# 关联远程仓库的 master 分支与本地的 master 分支，该方法在 push 中可设置，如果要直接绑定分支但不 push 呢，见下面命令行
$ git push --set-upstream origin master:master
# 通过 branch 命令直接设置
$ git branch --set-upstream-to=origin/feature2 feature2

拉取远程分支 | `pull`

# 说明：关联后 (--set-upstream) 可直接 push
# git pull origin master 这个 master 指的是远程分支，因为本地分支默认为当前分支
$ git pull origin <remote-branch>:<local-branch>

根据远程分支上创建本地分支

# 只有远程分支的时候，根据远程分支创建本地分支即可
$ git checkout -b <local-branch> origin/<remote-branch>

删除远程分支

# 说明：git push origin <local-branch>/<remote-branch>
# Method1: 推送空分支到远程分支 remote-branch，相当于删除远程分支
$ git push origin :<remote-branch>
# Method2: 直接删除远程分支
$ git push origin --delete <remote-branch>
# Tip: 删除本地分支
$ git branch -d <local-branch>

区分 `git reset` & `git checkout`

⭐Reference: https://blog.csdn.net/longintchar/article/details/82314102

git reset 会带着当前指向的 branch 一起向前推进
git checkout 只会修改当前 HEAD 的指向，可先用 checkout 跳转到某次提交处，然后创建某个分支 feature（此时的 HEAD 并未指向 feature1，而是仅仅处于同一处 commit），最后再使用 checkout 切换到该 feature 分支上（即 HEAD 指向 feature 分支）

checkout 签出动作会将 HEAD 与 branch 分离开来，它有一个专门的参数用于让 HEAD 与 branch 脱离且不移动 HEAD 的用法：

$ git checkout --detach

git 各式后悔药

git 管理仓库时，往往需要撤销某些操作/提交/暂存内容。

1. 撤销工作区的文件修改

如果工作区的某个文件被改乱了，但还没有执行 git add，可以用 git checkout 命令找回本次修改之前的文件。

$ git checkout -- [filename]

⭐它的原理是先找暂存区，如果该文件有暂存的版本，则恢复该版本，否则恢复上一次提交的版本。

注意：工作区的文件变化一旦被撤销，就无法找回了。

2. 从暂存区撤销文件

如果不小心把一个文件添加到暂存区，可以用下面的命令撤销。

$ git rm --cached [filename]

上面的命令不影响已经提交的内容。

3. 替换上一次提交信息

💔情况一：提交以后，发现提交信息写错了，这时可以使用 git commit 命令的 --amend 参数，可以修改上一次的提交信息。

$ git commit --amend -m "Fixes bug #42"
# git commit --amend 也可

它的原理是产生一个新的提交对象，替换掉上一次提交产生的提交对象。

💔情况二：提交之后，发现提交的文件需要修改！这时先修改好工作区，然后再执行 add 后执行 git commit --amend，因为这时暂存区有发生变化的文件，会一起提交到仓库。

$ git commit --amend -m "append info"
# git commit --amend 也可

所以，--amend 不仅可以修改提交信息，还可以整个把上一次提交替换掉。

4. 撤销某次提交 | 但需新增来覆盖提交

一种常见的场景是，提交代码以后，你突然意识到这个提交有问题，应该撤销掉，这时执行下面的命令就可以了。

$ git revert HEAD

上面命令的原理是，在当前提交后面，⭐新增一次提交(commit+1)，抵消掉上一次提交导致的所有变化(workspace&stage change)。它不会改变过去的历史，所以是首选方式，没有任何丢失代码的风险。

git revert 命令只能抵消上一个提交，如果想抵消多个提交，必须在命令行依次指定这些提交。比如，抵消前两个提交，要像下面这样写。

$ git revert [倒数第一个提交] [倒数第二个提交]

git revert 命令还有两个参数。

--no-edit：执行时不打开默认编辑器，直接使用 Git 自动生成的提交信息。
--no-commit：只抵消暂存区(stage)和工作区的文件变化，不产生新的提交。

5. 丢弃提交 | 回溯

如果希望以前的提交在历史中彻底消失，而不是被抵消掉，可以使用git reset命令，丢弃掉某个提交之后的所有提交。

$ git reset [last good SHA]

git reset的原理是，让最新提交的指针回到以前某个时点，该时点之后的提交都从历史中消失。

默认情况下，git reset不改变工作区的文件（但会改变暂存区），--hard 参数可以让工作区里面的文件也回到以前的状态。

$ git reset --hard [last good SHA]
# 或者
$ git reset --hard HEAD^1

执行 git reset 命令之后，如果想找回那些丢弃掉的提交，可以使用 git reflog 命令，具体做法参考这里。不过，这种做法有时效性，时间长了可能找不回来。

6. 撤销当前分支的变化

你在当前 error 分支上做了几次提交，突然发现放错了分支，这几个提交本应该放到 master 分支。

# 将 error 分支上的<最新一次>提交转移到 master 分支
$ git checkout master
$ git cherry-pick error

# 将 error 分支上的多次提交转移到 master 分支，注意：SHA1 比 SHA2 来得早！
$ git checkout master
$ git cherry-pick [SHA1] [SHA2]

目标：将 error 分支上的最新两次 commit 转移到 master 分支

先执行 git checkout master

再执行 git cherry-pick [SHA1] [SHA2]

有冲突解决冲突，没冲突即可完成

OK！error 分支想要 reset 就 reset~

合并分支 | `merge`

由于现在 Git 仓库处于冲突待解决的中间状态（已执行 merge 操作），所以如果你最终决定放弃这次 merge，也需要执行一次 merge --abort 来手动取消它。

# 回到 merge 前的状态
$ git merge --abort
# 在 master 分支上合并 feature 分支
$ git checkout master
$ git merge feature

主流工作流 Feature Branching

这种工作流的核心内容可以总结为两点：

任何新的功能（feature）或 bug 修复全都新建一个 branch 来写；
branch 写完后，合并到 master，然后删掉这个 branch。

这就是这种工作流最基本的模型。

从上面的动图来看，这种工作流似乎没什么特别之处。但实质上，Feature Branching 这种工作流，为团队开发时两个关键的问题提供了解决方案：

代码分享
一人多任务

1. 代码分享

# 本地电脑
$ git checkout -b books
$ git push origin books
# 同事电脑
$ git pull
$ git checkout books
$ git checkout master
$ git pull	# merge 之前 pull 一下，让 master 更新到和远程仓库同步
$ git merge books
$ git push
# 删除本地 books 分支，删除远程 books 分支
$ git branch -d books
$ git push origin -d books

借助 GitHub 的 Pull Request 简化 Feature Branching 工作流

事实上，上面所说的这个流程，还可以利用 Pull Request 来进一步简化。

Pull Request 并不是 Git 的内容，而是一些 Git 仓库服务提供方（例如 GitHub）所提供的一种便捷功能，它可以让团队的成员方便地讨论一个 branch ，并在讨论结束后一键合并这个 branch 到 master。

同样是把写好的 branch 给同事看，使用 Pull Request 的话你可以这样做：

把 branch push 到中央仓库；
在中央仓库处创建一个 Pull Request。以 GitHub 为例：

然后你的同事就可以在 GitHub 上看到你创建的 Pull Request 了。他们可以在 GitHub 的这个页面查看你的 commits，也可以给你评论表示赞同或提意见，你接下来也可以根据他们的意见把新的 commits push 上来，这也页面会随着你新的 push 而展示出最新的 commits。

在讨论结束以后，你们一致认为这个 branch 可以合并了，你只需要点一下页面中那个绿色的 "Merge pull request" 按钮，GitHub 就会自动地在中央仓库帮你把 branch 合并到 master 了：

然后你只要在本地 pull 一下，把最新的内容拉到你的电脑上，这件事情就算完成了。

另外，GitHub 还设计了一个贴心的 "Delete branch" 按钮，方便你在合并之后一键删除 branch。

完整的例子：

# 拉取 feature2 分支
$ git pull origin feature2:feature2
$ git branch --set-upstream-to=origin/feature2 feature2
$ git branch -vv
  feature1 c16362b [origin/feature1] Merge branch 'master' into feature1
* feature2 db3024c [origin/feature2] create branch feature2
  master   55c2952 [origin/master: behind 2] Merge pull request
$ git checkout master
# master 分支也要 pull
$ git pull origin master:master

2. 一人多任务

你正在认真写着代码，忽然同事过来跟你说：「内个……你这个功能先放一放吧，我们最新讨论出要做另一个更重要的功能，你来做一下吧。」

如果你是在独立的 branch 上做事，切换任务是很简单的。你只要稍微把目前未提交的代码简单收尾一下，然后做一个带有「未完成」标记的提交（例如，在提交信息里标上「TODO」），然后回到 master 去创建一个新的 branch 就好了。

# 切换回 master 主分支！！！因为需要从主分支上创建分支
$ git checkout master
$ git checkout -b new_feature

查改历史改动记录

git log

# 在 .bashrc 中设置 git-log 别名，可图形化输出 git log 的信息
$ alias git-log='git log --pretty=oneline --all --graph --abbrev-commit'
$ git-log
# 查看历史改动信息
$ git log
# 查看详细的历史记录，可以看到每个 commit 的具体改动细节（-p 是 --patch 的缩写）
$ git log -p
# 查看简要统计，只想大致看一下改动内容
$ git log --stat

git show

# 查看某个具体的 commit: $ git show 查看当前 commit
$ git show <SHA-1>
$ git show <SHA-1> <filename>	# 具体到某个指定文件

git diff

比对本地工作目录与暂存区的内容（即显示未使用 git add 加入暂存区的内容与暂存区的内容的不同之处）

$ git diff
diff --git a/README.md b/README.md
index 4b572c1..0f8ceb4 100644
--- a/README.md
+++ b/README.md
@@ -5,3 +5,4 @@
 4. `git branch feature1` && `git checkout feature1` && `git checkout master` && `git merge feature1` (feature1)
 5. master branch (feature branching, solve conflict by `pull request`)
 6. feature2
+7. 哈哈哈哈

比对暂存区与上一条提交的内容（即显示 git add 后的内容与上次 commit 之间内容的不同之处）

# 二者命令完全等价
$ git diff --staged
$ git diff --cached

比对工作目录和上一条提交的内容：

使用 git diff HEAD 可以显示工作目录和上一条提交之间的不同，它是上面这二者的内容相加。换句话说，这条指令可以让你看到「如果你现在把所有文件都 add 然后 git commit，你将会提交什么」（不过需要注意，没有被 Git 记录在案的文件（即从来没有被 add 过的文件，untracked files 并不会显示出来。为什么？因为对 Git 来说它并不存在啊）。

$ git diff HEAD
# 也可 git diff <SHA-1>

实质上，如果你把 HEAD 换成别的 commit，也可以显示当前工作目录和这条 commit 的区别。

不喜欢 merge 的分叉，那就用 rebase 吧

rebase —— 变基？！

其实这个翻译还是比较准确的。rebase 的意思是，给你的 commit 序列重新设置基础点（也就是父 commit）。展开来说就是，把你指定的 commit 以及它所在的 commit 串，以指定的目标 commit 为基础，依次重新提交一次。例如下面这个 merge：

# merge 过来；rebase 过去
$ git merge branch1

master: 1-2-3-4-7

branch1: 1-2-5-6-7

如果把 merge 换成 rebase，可以这样操作：

$ git checkout branch1
# merge 过来；rebase 过去
$ git rebase master

master: 1-2-3-4-7-8

branch1: 1-2-5-6

master 上的 7、8 是 branch1 上的 5、6 rebase 过去的~

可以看出，通过 rebase，5 和 6 两条 commits 把基础点从 2 换成了 4 。通过这样的方式，就让本来分叉了的提交历史重新回到了一条线。这种「重新设置基础点」的操作，就是 rebase 的含义。

另外，在 rebase 之后，记得切回 master 再 merge 一下，把 master 移到最新的 commit：

$ git checkout master
$ git merge branch1

master/branch1: 1-2-3-4-7-8

为什么要从 branch1 来 rebase，然后再切回 master 再 merge 一下这么麻烦，而不是直接在 master 上执行 rebase？

从图中可以看出，rebase 后的 commit 虽然内容和 rebase 之前相同，但它们已经是不同的 commits 了。如果直接从 master 执行 rebase 的话，就会是下面这样：

这就导致 master 上之前的两个最新 commit 被剔除了。如果这两个 commit 之前已经在中央仓库存在，这就会导致没法 push 了：

所以，为了避免和远端仓库发生冲突，一般不要从 master 向其他 branch 执行 rebase 操作。而如果是 master 以外的 branch 之间的 rebase（比如 branch1 和 branch2 之间)，就不必这么多费一步，直接 rebase 就好。

⭐以上情况是不发生冲突的 rebase，如果发生冲突了，那么就需要先解决冲突再执行如下命令：

以下展示另外一个例子！

# 1.修改冲突文件
# 2.git add. & git commit -m "fix conflict"
# 3.rebase continue
$ git rebase --continue

初始状态

git checkout rebase-branch

git rebase master：发生 conflict 在 "step 3"！

解决冲突后，再执行 add 与 commit（⭐甚至这一步都不需要 commit，在 add 之后即可）

git rebase --continue

git checkout master

git merge rebase-branch：相当于 fast-forward！

⭐总结：需要说明的是，rebase 是站在需要被 rebase 的 commit 上进行操作，这点和 merge 是不同的（相反）。

如何修复倒数第 2 个 commit | 交互式 rebase

commit --amend 可以修复最新 commit 的错误，但如果是倒数第二个 commit 写错了，怎么办？

如果不是最新的 commit 写错，就不能用 commit --amend 来修复了，而是要用 rebase。不过需要给 rebase 也加一个参数：-i。

rebase -i 是 rebase --interactive 的缩写形式，意为「交互式 rebase」。

所谓「交互式 rebase」，就是在 rebase 的操作执行之前，你可以指定要 rebase 的 commit 链中的每一个 commit 是否需要进一步修改。

那么你就可以利用这个特点，进行一次「原地 rebase」。

例如你是在写错了 commit 之后，又提交了一次才发现之前写错了：

$ git log

现在再用 commit --amend 已经晚了，但可以用 rebase -i：

$ git rebase -i HEAD^^

说明：在 Git 中，有两个「偏移符号」： ^ 和 ~。

^ 的用法：在 commit 的后面加一个或多个 ^ 号，可以把 commit 往回偏移，偏移的数量是 ^ 的数量。例如：master^ 表示 master 指向的 commit 之前的那个 commit； HEAD^^ 表示 HEAD 所指向的 commit 往前数两个 commit。

~ 的用法：在 commit 的后面加上 ~ 号和一个数，可以把 commit 往回偏移，偏移的数量是 ~ 号后面的数。例如：HEAD~5 表示 HEAD 指向的 commit往前数 5 个 commit。

上面这行代码表示，把当前 commit （ HEAD 所指向的 commit） rebase 到 HEAD 之前 2 个的 commit 上：

如果没有 -i 参数的话，这种「原地 rebase」相当于空操作，会直接结束。而在加了 -i 后，就会跳到一个新的界面：

把 pick 修改成 edit 后，就可以退出编辑界面了：

上图的提示信息说明，rebase 过程已经停在了第二个 commit 的位置，那么现在你就可以去修改你想修改的内容了。

修改完成之后，和上节里的方法一样，用 commit --amend 来把修正应用到当前最新的 commit：

$ git add 笑声
$ git commit --amend

在修复完成之后，就可以用 rebase --continue 来继续 rebase 过程，把后面的 commit 直接应用上去。

$ git rebase --continue

然后，这次交互式 rebase 的过程就完美结束了，你的那个倒数第二个写错的 commit 就也被修正了：

实质上，交互式 rebase 并不是必须应用在「原地 rebase」上来修改写错的 commit ，这只不过是它最常见的用法。你同样也可以把它用在分叉的 commit 上，不过这个你就可以自己去研究一下了。

丢弃倒数第二个提交 | 强大的 rebase

如果要丢弃刚提交的 commit，那只需要执行 git reset --hard HEAD^ 即可，那如果是倒二个呢？

`git rebase -i`

$ git rebase -i HEAD^^
# 上文是修改 pick 为 edit；而该操作只需要将 pick 当行删除即可

`git rebase --onto`

除了用交互式 rebase ，你还可以用 rebase --onto 来更简便地撤销提交。

rebase 加上 --onto 选项之后，可以指定 rebase 的「起点」。一般的 rebase，告诉 Git 的是「我要把当前 commit 以及它之前的 commits 重新提交到目标 commit 上去，这其中，rebase 的「起点」是自动判定的：选取当前 commit 和目标 commit 在历史上的交叉点作为起点。

例如下面这种情况：

如果在这里执行：

$ git rebase <第3个commit>

那么 Git 会自动选取 3 和 5 的历史交叉点 2 作为 rebase 的起点，依次将 4 和 5 重新提交到 3 的路径上去。

而 --onto 参数，就可以额外给 rebase 指定它的起点。例如同样以上图为例，如果我只想把 5 提交到 3 上，不想附带上 4，那么我可以执行：

$ git rebase --onto <第3个commit> <第4个commit> branch1

--onto 参数后面有三个附加参数：目标 commit、起点 commit（注意：rebase 的时候会把起点排除在外）、终点 commit。所以上面这行指令就会从 4 往下数，拿到 branch1 所指向的 5，然后把 5 重新提交到 3 上去。

$ git rebase --onto HEAD^^ HEAD^ branch1

上面这行代码的意思是：以倒数第二个 commit 为起点（起点不包含在 rebase 序列里哟），branch1 为终点，rebase 到倒数第三个 commit 上。

也就是这样：

reset 的本质 | 参数解析

reset 的三种参数：

--hard：重置位置的同时，清空工作目录的所有改动；
--soft：重置位置的同时，保留工作目录和暂存区的内容，并把重置 HEAD 的位置所导致的新的文件差异放进暂存区。
--mixed（默认 git reset）：重置位置的同时，保留工作目录的内容，并清空暂存区。

checkout 的本质 | 除了切换分支还可签出某个提交

不过实质上，checkout 并不止可以切换 branch。checkout 本质上的功能其实是：签出（ checkout ）指定的 commit。

直接上案例：

$ git checkout HEAD^^
$ git checkout master~5
$ git checkout <SHA>
$ git checkout <SHA>^^^

另外，如果你留心的话可能会发现，在 git status 的提示语中，Git 会告诉你可以用 checkout -- 文件名 的格式，通过「签出」的方式来撤销指定文件的修改：

即撤销工作目录下的修改（此时未添加到暂存区）

Emergency！放下你手上的工作 | stash 临时存放工作目录变动

"stash" 这个词，和它意思比较接近的中文翻译是「藏匿」，是「把东西放在一个秘密的地方以备未来使用」的意思。在 Git 中，stash 指令可以帮你把工作目录的内容全部放在你本地的一个独立的地方，它不会被提交，也不会被删除，你把东西放起来之后就可以去做你的临时工作了，做完以后再来取走，就可以继续之前手头的事了。

具体说来，stash 的用法很简单。当你手头有一件临时工作要做，需要把工作目录暂时清理干净，那么你可以：

$ git stash

就这么简单，你的工作目录的改动就被清空了，所有改动都被存了起来。

然后你就可以从你当前的工作分支切到 master 去给你的同事打包了……

打完包，切回你的分支，然后：

$ git stash pop

你之前存储的东西就都回来了。很方便吧！

注意：没有被 track 的文件（即从来没有被 add 过的文件不会被 stash 起来，因为 Git 会忽略它们。如果想把这些文件也一起 stash，可以加上 -u 参数，它是 --include-untracked 的简写。就像这样：
$ git stash -u

从暂存区撤回工作目录 | restore

use git restore --staged <file> to unstage

如果已经将文件添加到暂存区，然后想要撤销暂存区中该文件的内容（打回工作目录），则使用以下命令：

$ git restore --staged <file>

tip：如果文件在工作目录下修改过但未添加到暂存区，则通过前文提到的 git checkout -- <file> 来撤销该修改。

找回丢失的 branch | reflog

reflog 是 "reference log" 的缩写，使用它可以查看 Git 仓库中的引用的移动记录。如果不指定引用，它会显示 HEAD 的移动记录。假如你误删了 branch1 这个 branch，那么你可以查看一下 HEAD 的移动历史：

$ git reflog

从图中可以看出，HEAD 的最后一次移动行为是「从 branch1 移动到 master」。而在这之后，branch1 就被删除了。所以它之前的那个 commit 就是 branch1 被删除之前的位置了，也就是第二行的 c08de9a。

所以现在就可以切换回 c08de9a，然后重新创建 branch1 ：

$ git checkout -b branch1

这样，你刚删除的 branch1 就找回来了。

注意：不再被引用直接或间接指向的 commits 会在一定时间后被 Git 回收，所以使用 reflog 来找回删除的 branch 的操作一定要及时，不然有可能会由于 commit 被回收而再也找不回来。

reflog 默认查看 HEAD 的移动历史，除此之外，也可以手动加上分支名称查看其他分支的引用移动历史，例如 master 分支：

$ git reflog master

不可移动的 branch | tag

tag 是一个和 branch 非常相似的概念，它和 branch 最大的区别是：tag 不能移动。所以在很多团队中，tag 被用来在关键版本处打标记用。

更多关于 tag：git-scm.com/docs/git-ta…

Git Flow：复杂又高效的工作流

除了前面讲到的 "Feature Branching"，还有一个也很流行的工作流：Git Flow。Git Flow 的机制非常完善，很适合大型团队的代码管理。不过由于它的概念比较复杂（虽然难度并不高），所以并不适合新手直接学习，而更适合在不断的自我研究中逐渐熟悉，或者在团队合作中慢慢掌握。基于这个原因，我最终也没有在这本小册里讲 Git Flow，但我推荐你自己在有空的时候了解一下它。

2025.04.12 饿了么笔试题

Sat, 12 Apr 2025 00:00:00 GMT

题解链接：https://mp.weixin.qq.com/s/uWZalLLGSpPh8HxLeUtQOA

测评链接：https://niumacode.com/training/68

1. 小红的小苯题

小红拿到了一个正整数 x，小苯希望小红找到一个正整数 y，满足 x ⊕ y 既是 x 的因子，也是 y 的因子，你能帮帮小红吗?

在这里，⊕ 表示位运算中的按位异或操作。

输入描述

如果存在解，请输出一个正整数 y (1 ≤ y ≤ $10^{18}$)，代表询问的答案。如果无解，请输出 -1。

如果存在多个解决方案，您可以输出任意一个，系统会自动判定是否正确。注意，自测运行功能可能因此返回错误结果，请自行检查答案正确性。

示例 1

输入：

输出：

解释：对样例 1，由于 6⊕4 = 2，而 2 同时是 4 和 6 两个数字的因数。

⚠️ 注意，本题答案不唯一。

代码：脑筋急转弯

因为 1 是所有数字的因子，所以直接让 y=x^1，凑出 1 即可。

#include <iostream>
using namespace std;

int main() {
    long x;
    cin >> x;

    if (x == 1) {
        cout << -1 << endl;
    } else {
        long y = x ^ 1;
        cout << y << endl;
    }

    return 0;
}

2. 音乐队列

小红的播放器里一共有 n 首歌待放，歌单里第 $i$ 首歌的长度为 $a_i$ 秒。

小红会按顺序播放歌单里的歌，如果当前歌放完了，会自动插放下一首，两首歌曲之间没有缓冲的时间。

第 $i$ 首歌曲的等待时长为 $a_1 + … + a_{i-1}$ 秒，第一首歌曲等待时间为 0 秒。

小红想知道，如果她选择 $k$ 首歌移除播放队列，那么播放队列中剩下的歌曲的等待时长之和最小能达到多少?

输入描述

第一行输入两个整数 $n(1≤n ≤5000;0≤k≤n)$ 表示歌单里歌曲的数量、需要移除的歌曲数量
第二行输入 $n$ 个整数，表示每首歌的长度，其中 $ 1 ≤ a_i ≤ 10^9$

输出描述

输出一个整数，表示插放队列中剩下的歌曲的等待时长之和的最小值。

示例 1

输入：

3 1
1 2 3

输出：

示例 2

输入：

3 0
1 2 3

输出：

代码：贪心算法

目标转换：最小化移除 $k$ 首歌后的总等待时间，等价于最大化移除这 k 首歌所能减少的总等待时间。
计算单次移除收益：对于原始列表中的每一首歌 $a_j$，计算如果只移除它，会使原始总等待时间减少多少。这个减少量 $R_j$ 等于 $a_j$ 原本的等待时间加上 $a_j$ 对其后面所有歌曲等待时间的贡献（即 $a_j$ 的长度乘以它后面歌曲的数量）。
贪心选择：既然要最大化总减少量，并且移除每首歌的“收益” $R_j$ 是基于原始列表计算的，可以独立看待。因此，采用贪心策略：计算所有歌曲的 $R_j$，然后选择 $R_j$ 值最大的 $k$ 首歌进行移除。
计算结果：确定要移除的 $k$ 首歌的原始索引。构建一个只包含剩下 $n-k$ 首歌的新列表（保持它们的原始相对顺序）。直接计算这个新列表的总等待时间。核心思想是贪心，优先移除那些能最大程度降低总等待时间的歌曲。

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>
using namespace std;

// Class to store reduction value and original index
struct ReductionInfo {
    long long reduction;
    int originalIndex; // 1-based index

    ReductionInfo(long long r, int idx) : reduction(r), originalIndex(idx) {}
};

int main() {
    int n, k;
    cin >> n >> k;

    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    if (k == n) {
        cout << 0 << endl; // If all songs are removed, waiting time is 0
        return 0;
    }
    if (k == 0) {
        // Calculate original waiting time directly if k=0
        long long totalWait = 0;
        long long currentPrefixSum = 0;
        for (int i = 0; i < n; i++) {
            totalWait += currentPrefixSum;
            currentPrefixSum += a[i];
        }
        cout << totalWait << endl;
        return 0;
    }

    // Calculate prefix sums
    vector<long long> prefixSum(n + 1, 0);
    for (int i = 0; i < n; i++) {
        prefixSum[i + 1] = prefixSum[i] + a[i];
    }

    // Calculate reduction for each song
    vector<ReductionInfo> reductions;
    for (int j = 1; j <= n; j++) {
        // R_j = P[j-1] + (n-j) * a[j-1]
        long long rj = prefixSum[j - 1] + (long long)(n - j) * a[j - 1];
        reductions.emplace_back(rj, j);
    }

    // Sort reductions in descending order
    sort(reductions.begin(), reductions.end(), [](const ReductionInfo& r1, const ReductionInfo& r2) {
        // Sort by reduction descending. If reductions are equal, order doesn't matter much,
        // but consistent sorting is good (e.g., by index ascending).
        if (r2.reduction != r1.reduction) {
            return r2.reduction < r1.reduction; // Descending reduction
        }
        return r1.originalIndex < r2.originalIndex; // Ascending index as tie-breaker
    });

    // Identify indices to remove
    unordered_set<int> removedIndices;
    for (int i = 0; i < k; i++) {
        removedIndices.insert(reductions[i].originalIndex);
    }

    // Build the new list of songs (kept songs)
    vector<int> keptSongs;
    for (int i = 0; i < n; i++) {
        if (removedIndices.find(i + 1) == removedIndices.end()) { // Check using 1-based index
            keptSongs.push_back(a[i]);
        }
    }

    // Calculate the total waiting time for the kept songs
    long long finalTotalWait = 0;
    long long currentPrefixSumNew = 0;
    for (int songLength : keptSongs) {
        finalTotalWait += currentPrefixSumNew;
        currentPrefixSumNew += songLength;
    }

    cout << finalTotalWait << endl;

    return 0;
}

3. 小红的加权三色数

小红得到一棵树，该树有 $n$ 个节点。每个节点具有三种颜色之一，分别为 R、G 与 B。每个节点还拥有一个正整数权值，用 $w_i$ 表示第 $i$ 个节点的权值。

小红需要选择一个节点作为根节点。选定后，该根节点的颜色保持不变，不能被修改。对于其他非根节点，小红可以进行修改操作。每次修改操作的规则为：

选择一个非根节点，将以该节点为根的子树内所有节点的颜色统一修改为目标颜色，目标颜色为根节点的初始颜色在一次修改中，该操作的代价为被修改子树内所有节点权值之和。

小红希望通过合理选择根节点并规划修改方案，使得最终全树所有节点均为根节点的颜色，同时使总代价最小。

名词解释

子树：对于树中的一个节点，其与所有后代节点构成的树称为该节点的子树。

输入描述

第一行输入一个整数 $(1 ≤ n ≤ 5*10^5)$，代表树的节点数量。
第二行输入一个长度为 $n$ 的字符串，该字符串仅由字符 R、G、B 组成，其中第 $i$ 个字符表示第 $i$ 个节点的初始颜色。
第三行输入 $n$ 个正整数 $w_1,w_2,...,w_n(1≤w_i≤10^9)$，表示各节点的权值。
随后输入 $n-1$ 行，每行包会两个整数 $u$ 和 $v(1≤u,v≦n,u≠y)$，表示节点 $u$ 与节点 $v$ 之间存在一条边。保证给定的 $n$ 个节点构成一棵树，即任意两个节点之问存在且仅存在一条简单路径。

输出描述

输出一个整数，代表使全树所有节点顿色统一为根节点初始颜色所需的最小总代价。

示例 1

输入：

输出：

解释：

若选择节点 2 或节点 3 作为根节点，则目标颜色为 B。
以节点 2 为根时，仅需修改与其相连的非根节点（如节点 1），修改操作使节点 1 变为 B，代价为 1。
同理，以节点 3 为根时，方案类似，总代价亦为 1。
故最小总代价为 1。

代码：换根 DP（reroot）

题目要求尝试以每个节点 $r$ 为根，计算将整棵树染成 $r$ 初始颜色的最小代价，并求所有根选择中的最小代价。
暴力不可行：对每个节点作为根都独立计算一次代价（需要 DFS 确定子树和计算代价）复杂度为 $O(N^2)$，太慢。
核心技术：换根 DP (Rerooting DP)。 这种技术适用于需要计算以每个节点为根时的某个树上属性的问题，能将复杂度优化到 $O(N)$。
- 第一遍 DFS（向下）：任选一个节点（如 0）作为临时根。计算每个节点的子树权重和 subtreeSum[u]。
- 计算 DP 状态 dpDown[u][C]：表示在以 0 为根时，假设 u 的父节点颜色已经是目标色 C，将 u 的子树完全染成颜色 C 所需的最小代价。这个计算依赖于其子节点的 dpDown 值和 subtreeSum 值。
- 第二遍 DFS（向上/换根）：计算最终 DP 状态 finalCost[u][C]：表示如果以 u 为真正的根，将整棵树染成目标色 C 的最小总代价。
- 这个计算利用 dpDown[u][C]（处理 u 子树部分的代价）和其父节点 p 的 finalCost[p][C] 以及 dpDown 值（推导出处理树上其他部分的代价）。
- 统计答案：遍历所有节点 r (0 到 N-1)。获取节点 r 的初始颜色 initial_color[r]。该节点作为根时的最小代价为 finalCost[r][initial_color[r]]。在所有 r 的这个代价中取最小值，即为最终答案。

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

vector<vector<int>> adj;
vector<char> colors; // 0-based node index
vector<int> weights; // 0-based node index
vector<long long> subtreeSum; // S[u]: sum of weights in subtree rooted at u
vector<vector<long long>> dpDown; // dpDown[u][color_idx]: cost for subtree u if parent imposes target color
vector<vector<long long>> finalCost; // finalCost[u][color_idx]: total cost if u is root and target color is color_idx
long long totalWeightSum;
const int R_IDX = 0;
const int G_IDX = 1;
const int B_IDX = 2;
int n;

// Helper to map color char to index 0, 1, 2
int colorToIndex(char c) {
    if (c == 'R') return R_IDX;
    if (c == 'G') return G_IDX;
    return B_IDX; // 'B'
}

// DFS1: Calculate subtree sums, starting from node 0
void dfs_sum(int u, int p) {
    subtreeSum[u] = weights[u];
    for (int v : adj[u]) {
        if (v != p) {
            dfs_sum(v, u);
            subtreeSum[u] += subtreeSum[v];
        }
    }
}

void dfs_dp_down(int u, int p) {
    for (int v : adj[u]) {
        if (v != p) {
            dfs_dp_down(v, u); // Calculate for child first
            int vColorIdx = colorToIndex(colors[v]);
            long long sv = subtreeSum[v]; // Subtree sum of child v

            for (int targetColorIdx = 0; targetColorIdx < 3; targetColorIdx++) {
                if (vColorIdx == targetColorIdx) {
                    // If child color matches target, add child's dpDown cost for that target
                    dpDown[u][targetColorIdx] += dpDown[v][targetColorIdx];
                } else {
                    // If child color differs, must modify child's subtree, cost is S[v]
                    dpDown[u][targetColorIdx] += sv;
                }
            }
        }
    }
}

// Helper to get contribution of child x's subtree when target is C, from parent's view
long long getContribution(int x, int targetColorIdx) {
    int xColorIdx = colorToIndex(colors[x]);
    if (xColorIdx == targetColorIdx) {
        // If x matches target, contribution is the cost calculated below x for that target
        return dpDown[x][targetColorIdx];
    } else {
        // If x doesn't match target, the whole subtree x must be modified, cost is S[x]
        return subtreeSum[x];
    }
}

// DFS3: Rerooting to calculate finalCost[u][C] = cost if u is root and target is C
void dfs_reroot(int u, int p) {
    for (int v : adj[u]) {
        if (v != p) {
            // Calculate cost contribution from the 'parent' branch (everything except v's subtree)
            for (int targetColorIdx = 0; targetColorIdx < 3; targetColorIdx++) {
                long long costParentBranch; // Cost of the tree excluding v's subtree, assuming targetColorIdx

                long long contributionFromV = getContribution(v, targetColorIdx);
                // Weight sum of the parent branch (everything except v's subtree)
                long long sumExcludingVSubtree = totalWeightSum - subtreeSum[v];

                int uColorIdx = colorToIndex(colors[u]);
                if (uColorIdx == targetColorIdx) {
                    // If u matches target, the cost from parent branch is its calculated cost,
                    // which is the total cost from u's perspective minus v's contribution.
                    costParentBranch = finalCost[u][targetColorIdx] - contributionFromV;
                } else {
                    // If u doesn't match target, from v's perspective, u must be modified.
                    // The cost incurred by this modification is the sum of weights in that branch.
                    costParentBranch = sumExcludingVSubtree;
                }
                // Total cost for v = (cost below v) + (cost from parent branch)
                finalCost[v][targetColorIdx] = dpDown[v][targetColorIdx] + costParentBranch;
            }
            // Recurse into child v
            dfs_reroot(v, u);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;

    colors.resize(n);
    for (int i = 0; i < n; ++i) {
        cin >> colors[i];
    }

    weights.resize(n);
    totalWeightSum = 0;
    for (int i = 0; i < n; ++i) {
        cin >> weights[i];
        totalWeightSum += weights[i];
    }

    adj.resize(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        --u; --v; // Convert to 0-based
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    subtreeSum.resize(n);
    dpDown.assign(n, vector<long long>(3, 0));
    finalCost.assign(n, vector<long long>(3, 0));

    // Step 1: Calculate subtree sums (rooted arbitrarily at 0)
    dfs_sum(0, -1);

    // Step 2: Calculate dpDown (cost from below, relative to root 0)
    dfs_dp_down(0, -1);

    // Step 3: Rerooting DP
    // Initialize root's finalCost (cost if 0 is root = cost below 0)
    for (int c = 0; c < 3; ++c) {
        finalCost[0][c] = dpDown[0][c];
    }
    // Start rerooting DFS from root 0 to calculate finalCost for all nodes
    dfs_reroot(0, -1);

    // Step 4: Find minimum cost
    long long minTotalCost = LLONG_MAX;
    for (int r = 0; r < n; ++r) {
        int targetColorIdx = colorToIndex(colors[r]); // Target color is initial color of root r
        minTotalCost = min(minTotalCost, finalCost[r][targetColorIdx]);
    }

    cout << minTotalCost << endl;

    return 0;
}

2025.04.09

Wed, 09 Apr 2025 00:00:00 GMT

陆续一个月了，腾讯、阿里云、淘天、高德、拼多多、字节、美团... 能投的都投了。

项目：要么是让介绍项目难点时讨论下，要么就是基于项目去引申（相当于场景题和设计题），时间多的话，可以自己借助 GPT 和有些技术团队的博客/沙龙去提升下项目。比如缓存一致性问题，遍地都是 Cache Aside 或者延时双删，可以调研下有没有其他成熟些的方案。

八股：少部分是八股盛宴，大多数情况问的都是些常规八股，偶尔是很细的八股 + 深挖。有的面试甚至没问八股。有些面试官会在你不了解某个八股的时候，会引导着思考。比如解决某个问题，我提到了可能要用本地缓存，面试官问我了解本地缓存不，不了解，然后就会问你觉得本地缓存该如何设计，有哪些功能。

手撕：简单题 + Hot 100 原题。遇到过多线程题：顺序打印 ABC、多线程计算数组和（future_task 最好会用），一次 sql 题（简单的 sql 还是最好掌握，如果面试官出了个简单的，写不出来就很尴尬了）

其他类型的题：大文件，小内存，排序/去重/统计次数等，这部分就看个人知识储备和思考能力了。

建议：多刷面经，可以快速积累场景题、设计题、多线程题，而且能快速 get 到高频八股，比如 oom、cpu 使用率高、慢查询治理...

找暑期哪有不疯的，运气也是非常重要（特指面试官）。

最后祝各位早日 oc（也祝我能 oc），无需过度焦虑，才四月初，正是发力期，过段时间一堆鸽穿的。

2025.04.05 美团笔试题

Sat, 05 Apr 2025 00:00:00 GMT

题解链接：https://mp.weixin.qq.com/s/v5MeHD9ui8lPxRIoe0wD3Q

测评链接：https://oj.niumacode.com/training/59

1. 整数转变

开始有一个整数 b，你需要经过若干次操作，使 n 的值不小于 m 。

操作一：将 $n$ 更改为 $2 * n$ ，花费为 $w_2$
操作二：将 $n$ 更改为 $3 * n$ ，花费为 $w_3$

请输出需要的最小花费。

输入描述

输入第一行一个整数 $T$，代表接下来有 $T$ 组测试数据。接下来 $T$ 行，每行有 4 个整数 $n,m,w_2,w_3$
$1< T < 10000$
$1< n,m < 2^{31}-1$
$1< w_2,w_3 < 1000$

输出描述

对于每组测试数据，输出一行，一个整数代表最小花费

示例 1

输入：

4
1 6 2 3
4 32 3 4
2 1 1 2
1 2147483647 1 4

输出：

代码：动态规划（记忆化搜索 + 哈希表 memo）

记忆化搜索，这个题不可以使用迭代的动态规划来完成，会超时，记忆化搜索可以跳过非常多不必要考虑的状态（因为使用了 unordered_map 而非 vector，省去了逐个遍历的时间）。

#include <bits/stdc++.h>

using namespace std;

unordered_map<long long, long long> memo;

long long dfs(long long i, long long m, long long w2, long long w3) {
    if(i >= m)
		return 0;
    if(memo.find(i) != memo.end())
       	return memo[i];
    return memo[i] = min(dfs(i * 2, m, w2, w3) + w2, dfs(i * 3, m, w2, w3) + w3);
}

int main() {
    int T;
    cin >> T;
    while(T--) {
        int n, m, w2, w3;
        cin >> n >> m >> w2 >> w3;
        memo.clear();
        cout << dfs(n, m, w2, w3) << endl;
    }
    return 0;
}

2. 漂亮数

我们定义一个漂亮数是这样的数：

该数为正整数
设该数为 x，存在一个质数 p 使得 x mod p = 0 且 p * p >= x

给你一个正整数 n，你能否求出有多少漂亮数小于等于 n？

输入描述

输入一行一个正整数 $n(1 < n < 5 * 10^6)$

输出描述

输出一行一个正整数，代表小于等于 n 的漂亮数的个数。

示例 1

输入：

输出：

解释：10 以内除了 1 和 8 都是漂亮数

代码：数论

筛质数
基于最小质因数，递推计算每个数的最大质因数。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<int> min_prime(n + 1, 0);  // 最小质因数数组
    vector<int> primes;

    // 欧拉筛法预处理最小质因数
    for (int i = 2; i <= n; ++i) {
        if (min_prime[i] == 0) {
            min_prime[i] = i;
            primes.push_back(i);
        }
        for (size_t j = 0; j < primes.size(); ++j) {
            int p = primes[j];
            if (p > min_prime[i] || i * p > n) {
                break;
            }
            min_prime[i * p] = p;
        }
    }

    int count = 0;
    vector<int> max_prime(n + 1, 0);  // 最大质因数数组

    for (int x = 2; x <= n; ++x) {
        if (min_prime[x] == x) {  // x是质数
            max_prime[x] = x;
            count++;
        } else {  // x是合数
            int p = min_prime[x];
            int m = x / p;
            max_prime[x] = max(p, max_prime[m]);
            if (1LL * max_prime[x] * max_prime[x] >= x) {
                count++;
            }
        }
    }

    cout << count << endl;

    return 0;
}

3. 最长路径

游游很喜欢树，这一天他在研究树上的路径，他遇到了一个难题，现在邀请你帮助他解决该问题。

在一棵树上，两个点并不一定能确定一条链，但是可以找到一条经过这两个点最长的一条链。

你有一棵 n 个点的树，树上每条边都有一个权值，定义一条简单路径的长度为这条简单路径上的边权和，对于给定的两个点 x, y，你需要回答在树上经过这两个点的最长简单路径是多少。

树上的路径：从节点 u 到节点 v 的简单路径定义为从节点 u 出发，以节点 v 为终点，随意在树上走，不经过重复的点和边走出来的序列。可以证明，在树上，任意两个节点间有且仅有一条简单路径。

输入描述

第一行两个数 $n, m (1< n, m < 10^5)$
接下来 $n - 1$ 行，每行 3 个数 $u_i, v_i, d_i (1 < u_i, v_i < n, 1 < d_i < 10^9)$，表示树的第 $i$ 条边
接下来 $m$ 行，每行 2 个数 $x, y$，表示一次询问。

输出描述

共 m 行，每行一个整数 ans，表示你的答案

示例 1

输入：

输出：

代码：LCA（最近公共祖先）

路径由三部分组成：

起点 a 到 x：选一个能离 x 最远的点 a（不能往 y 方向走）
x 到 y：这是唯一的固定路径
y 到终点 b：选一个能离 y 最远的点 b（不能往 x 方向走）

总长度就是这三段距离的和。核心是找到 a 和 b 这两个“最远端点”。

为了快速计算，需要提前准备三个重要信息：

向下最长路径（子树方向）
- 用深度优先搜索（DFS）从根节点出发，记录每个节点 u 的两个值：
  - down1[u]：u 向下走到子树的最长路径（比如 u→ 子节点 v → ... → 叶子）
  - down2[u]：次长路径（必须走不同子节点）
- 同时记录 down1_child[u] 表示哪个子节点贡献了最长路径
向上最长路径（父节点方向）
- 第二次 DFS 计算 up[u]，表示从u向上走（经过父节点）的最长路径。这里要考虑两种情况：
  - 如果父节点的最长路径经过 u → 只能用父节点的次长路径
  - 否则 → 可以用父节点的最长路径
- 比如父节点 p 的最长路径是 p→q，而 u 是 p 的子节点但不是 q，则 up[u] = up[p] + 边权
LCA（最近公共祖先）
- 用倍增法预处理每个节点的 $2^k$ 级祖先，快速计算 x 和 y 的距离：
  - dist(x,y) = 到根的距离x + 到根的距离y - 2 * 到根的距离(lca(x,y))：这能快速得到 x 到 y 的路径长度
- 对于每个查询 $(x,y)$，分情况处理：
  1. x 和 y 是同一个点：最长路径要么是向下走两条分支（down1 + down2），要么是向上走再向下（up + down1）
  2. x 和 y 不同
    - 分三步计算：
      1. 确定路径方向：
        
        找到 x 到 y 路径上的邻居节点 nx（如果 y 在 x 的子树里，nx 是 x 的子节点；否则是 x 的父节点）
        
        同理找到 y 的邻居 ny
      2. 计算 max_dist_x（不经过 nx 的最远距离）：
        
        如果 nx 是父节点 → 只能向下走，取 down1[x]
        
        如果 nx 是子节点 → 比较向上（up[x]）和向其他子节点的路径（down1 或 down2）
      3. 同样计算 max_dist_y，最终总长度是这三部分的和

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cmath>
using namespace std;

const int MAX_N = 200005;
const int MAX_LOG_N = 20;

unordered_map<int, vector<pair<int, int>>> adj;
int parent[MAX_LOG_N][MAX_N];
int dist_to_parent_pow2[MAX_LOG_N][MAX_N];
int depth[MAX_N];
int dist_from_root[MAX_N];
int actual_parent[MAX_N];
int edge_weight_to_parent[MAX_N];
int down1[MAX_N], down2[MAX_N], down1_child[MAX_N], up[MAX_N];
vector<int> results;

void add_edge(int u, int v, int d) {
    adj[u].emplace_back(v, d);
    adj[v].emplace_back(u, d);
}

void dfs1(int u, int p, int d, int current_dist) {
    depth[u] = d;
    dist_from_root[u] = current_dist;
    parent[0][u] = p;
    actual_parent[u] = p;

    int max1 = 0, max2 = 0, child1 = 0;

    for (auto& [v, weight] : adj[u]) {
        if (v != p) {
            edge_weight_to_parent[v] = weight;
            dist_to_parent_pow2[0][v] = weight;
            
            dfs1(v, u, d + 1, current_dist + weight);
            
            int current_down_path = down1[v] + weight;
            if (current_down_path >= max1) {
                max2 = max1;
                max1 = current_down_path;
                child1 = v;
            } else if (current_down_path > max2) {
                max2 = current_down_path;
            }
        }
    }

    down1[u] = max1;
    down2[u] = max2;
    down1_child[u] = child1;
}

void dfs2(int u, int p) {
    int p_node = actual_parent[u];
    
    if (p_node != 0) {
        int weight_up = edge_weight_to_parent[u];
        int down_from_parent_not_via_u;
        
        if (down1_child[p_node] == u) {
            down_from_parent_not_via_u = down2[p_node];
        } else {
            down_from_parent_not_via_u = down1[p_node];
        }
        
        up[u] = weight_up + max(up[p_node], down_from_parent_not_via_u);
    }

    for (auto& [v, weight] : adj[u]) {
        if (v != p) {
            dfs2(v, u);
        }
    }
}

int get_lca(int u, int v) {
    if (depth[u] < depth[v]) swap(u, v);
    
    for (int k = MAX_LOG_N - 1; k >= 0; --k) {
        if (depth[u] - (1 << k) >= depth[v]) {
            u = parent[k][u];
        }
    }
    
    if (u == v) return u;
    
    for (int k = MAX_LOG_N - 1; k >= 0; --k) {
        if (parent[k][u] != parent[k][v]) {
            u = parent[k][u];
            v = parent[k][v];
        }
    }
    
    return parent[0][u];
}

int get_dist(int u, int v) {
    int l = get_lca(u, v);
    return dist_from_root[u] + dist_from_root[v] - 2 * dist_from_root[l];
}

int get_ancestor(int u, int k) {
    int node = u;
    for (int i = 0; i < MAX_LOG_N; ++i) {
        if ((k >> i) & 1) {
            node = parent[i][node];
            if (node == 0) break;
        }
    }
    return node;
}

void solve() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, m;
    cin >> n >> m;

    for (int i = 0; i < n - 1; ++i) {
        int u, v, d;
        cin >> u >> v >> d;
        add_edge(u, v, d);
    }

    int MAX_LOG_N = (n - 1) == 0 ? 1 : 32 - __builtin_clz(n - 1);
    
    dfs1(1, 0, 0, 0);

    for (int k = 1; k < MAX_LOG_N; ++k) {
        for (int i = 1; i <= n; ++i) {
            parent[k][i] = parent[k-1][parent[k-1][i]];
            if (parent[k-1][i] != 0) {
                dist_to_parent_pow2[k][i] = dist_to_parent_pow2[k-1][i] + dist_to_parent_pow2[k-1][parent[k-1][i]];
            }
        }
    }

    dfs2(1, 0);

    for (int i = 0; i < m; ++i) {
        int x, y;
        cin >> x >> y;

        if (x == y) {
            int ans = max(down1[x] + down2[x], up[x] + down1[x]);
            results.push_back(ans);
            continue;
        }

        int l = get_lca(x, y);
        int dist_xy = get_dist(x, y);

        int nx = 0;
        if (l == x) {
            int target_depth = depth[x] + 1;
            int steps_up = depth[y] - target_depth;
            nx = get_ancestor(y, steps_up);
        } else {
            nx = actual_parent[x];
        }

        int ny = 0;
        if (l == y) {
            int target_depth = depth[y] + 1;
            int steps_up = depth[x] - target_depth;
            ny = get_ancestor(x, steps_up);
        } else {
            ny = actual_parent[y];
        }

        int max_dist_x;
        if (nx == actual_parent[x]) {
            max_dist_x = down1[x];
        } else {
            if (nx == down1_child[x]) {
                max_dist_x = max(up[x], down2[x]);
            } else {
                max_dist_x = max(up[x], down1[x]);
            }
        }

        int max_dist_y;
        if (ny == actual_parent[y]) {
            max_dist_y = down1[y];
        } else {
            if (ny == down1_child[y]) {
                max_dist_y = max(up[y], down2[y]);
            } else {
                max_dist_y = max(up[y], down1[y]);
            }
        }

        int ans = max_dist_x + dist_xy + max_dist_y;
        results.push_back(ans);
    }

    for (int res : results) {
        cout << res << "\n";
    }
}

int main() {
    solve();
    return 0;
}

分布式系统中如何保证崩溃一致性？

Wed, 02 Apr 2025 00:00:00 GMT

面试官：你如何在系统中保证崩溃一致性？

崩溃一致性的定义和重要性

崩溃一致性是指系统在发生崩溃（例如服务器宕机、进程异常退出或断电）后，能够确保持久化的数据仍然处于一致的有效状态。也就是说，无论何时发生崩溃，系统存储上的数据要么保持崩溃前的完整更新，要么回退到崩溃前的稳定状态，不会出现部分更新导致的数据不完整或损坏。例如，在文件系统或数据库中，如果一次操作需要更新多个位置，崩溃一致性要求不能出现只更新了一部分就崩溃的情况，否则会造成数据结构的不一致。通过保证崩溃一致性，系统在重启恢复后可以正确地继续运行，数据不会因中途崩溃而处于混乱状态。这在分布式存储、数据库和后端服务中至关重要，直接关系到数据可靠性和系统健壮性。

常见的崩溃一致性保障方案

在分布式系统和后端架构设计中，有多种机制用来保证崩溃一致性。实际设计中通常根据场景组合运用这些方案：

写前日志（Write-Ahead Logging，WAL）

先将将要进行的更新记录到日志（预写日志）并持久化，再执行实际的数据更新。这样如果系统在更新过程中崩溃，重启时可以通过日志重放或回滚确保数据一致 (存储系统的崩溃一致性问题 (Crash Consistency))。WAL 广泛应用于数据库和文件系统（如 MySQL InnoDB 的 redo log，PostgreSQL 的 WAL，Ext4 文件系统的 journal 模式）。举例来说，在数据库事务中，先写事务日志并将其 fsync 到磁盘，再更新数据页；若中途崩溃，重启时根据日志完成未完事务或撤销部分更新，保证数据一致不丢失。

两阶段提交（2PC）/ 三阶段提交（3PC）

这是分布式事务的经典协议，用于确保跨多个节点或资源的原子性提交。一致性通过一个协调者让所有参与者都准备就绪再统一提交。两阶段提交 (prepare/commit) 确保所有节点要么都提交事务，要么都回滚，中间任一节点崩溃都不会导致部分节点提交。例如，在订单系统中，订单服务和支付服务需要同时更新，各服务在准备阶段预留资源，只有当所有服务都准备成功后才正式提交扣款和订单确认，否则全部撤销。2PC 的缺点是协调者崩溃或网络分区时会阻塞（出现脑裂风险）。三阶段提交在 2PC 基础上增加预提交阶段（CanCommit、PreCommit、DoCommit），减少单点故障导致的阻塞，但通信开销更大，且仍要求可靠网络条件。实际中原生 3PC 较少直接使用，更常用改进的一致性协议或结合其他机制来避免单点问题。

分布式一致性协议（如 Paxos / Raft 等）

这些是一致性算法，用于在多副本场景下保证数据副本之间的状态一致，进而保障崩溃后的系统一致性。Paxos 和 Raft 通过多数派投票达成共识，确保一旦某个操作被多数节点提交，整个集群最终都应用该操作，即使部分节点崩溃也不影响全局一致结果。它们通常用于实现复制日志和领导者选举。例如，Raft 协议通过由 Leader 将日志条目复制到 Follower，并要求超过半数节点写入确认后再认为提交成功，这样即使一个节点崩溃，已提交日志仍然存在于其他节点中，系统可以选举新 Leader 继续提供服务。很多分布式 KV 存储（如 Etcd、Consul）和分布式数据库利用 Raft/Paxos 保证在崩溃或网络异常情况下数据不会不一致。此外，基于这些共识协议可以构建分布式事务：例如 Google Spanner 将 2PC 与 Paxos 结合，在每个分片组内用 Paxos 保证副本一致性，并用 2PC 跨分片提交全局事务，从而同时实现强一致和高可用的事务处理。

本地持久化与 fsync

无论采用哪种高级协议，底层的持久化正确性都是基础。为了保证崩溃时数据已真正写入稳定存储，需要使用fsync或类似手段将数据刷盘。操作系统和硬件常有缓存，如果只写入内存缓冲区而不刷新到磁盘，崩溃会导致已写入的数据丢失。通过在关键步骤后调用 fsync 确保数据写入磁盘，可以提供持久化的崩溃一致性。例如，消息队列在写入消息日志后会调用 fsync（或根据配置定期刷盘）才确认消息“已持久化”，这样 Broker 宕机重启后，日志里的消息仍然可用，不会丢失或损坏。需要注意频繁 fsync 会影响性能，因此实际系统常结合批量写入或后台刷盘策略，在保证一定一致性的前提下平衡性能（例如 MySQL 的innodb_flush_log_at_trx_commit参数决定每次事务提交是否立即 fsync 日志）。

幂等性设计与重试机制

在分布式系统中，失败重试是常见现象（例如网络超时后客户端重发请求，或者服务重启后重新处理消息）。为了保证在崩溃和重试场景下状态不乱，要求关键操作具有幂等性——同一操作执行一次和多次的效果相同，不会因重复执行产生副作用差异。例如，支付接口需要设计为幂等，以避免由于请求超时重复扣款；又如订单创建接口应防止创建重复订单。这通常通过在业务层引入唯一请求 ID 或事务 ID 来实现，每次操作前先检查是否已处理过该 ID，已处理则跳过，未处理才执行并记录结果。幂等设计配合重试机制，使系统在部分操作失败或崩溃恢复后可以安全地重放操作，达到“至少一次”投递但效果如“只执行一次”的一致性结果。例如，消息队列消费者在处理消息时，如果进程突然崩溃，下次重启后消息会被重新投递，此时消费者处理逻辑如果具备幂等（例如根据消息唯一键检查数据库中是否已应用），就能保证不会因重复消费导致数据错误。

实际项目经验与应用案例

面试中展示崩溃一致性的理解，最好结合自身经历或熟悉的系统案例，说明如何运用了上述机制：

分布式 KV 存储系统：举例来说，在设计分布式 Key-Value 存储时，会使用 WAL 日志 + 多副本复制来保证崩溃一致性。每次写操作先写入本地 WAL 并持久化，然后通过一致性协议（如 Raft）将该操作复制到其他节点。在我参与的一个存储引擎项目中，我们采用 Raft 保证各副本日志一致，同时每台节点本地使用 WAL 和定期快照。一次写入只有当多数节点写入日志成功并且主节点的日志 fsync 完成后才确认成功返回。这样，即便某个节点宕机，其恢复时可以通过重放本地 WAL 和从其他副本同步缺失日志将数据恢复到崩溃前的一致状态。这种方案在实践中确保了无单点故障的数据可靠性——如 etcd、ZooKeeper 也使用类似思路，保证配置数据在节点崩溃后依然一致。

订单和支付事务系统：在电商订单系统中，经常需要保证诸如“扣库存”和“扣款”这两个不同服务的操作要么都成功要么都不执行。我的经验是可以采用分布式事务或事务补偿机制来解决。例如，我们尝试过使用两阶段提交：订单服务作为协调者，通知库存服务和支付服务预留资源（准备阶段），如果都成功则发出提交指令，各自将最终状态持久化；如果中途任一失败则发出回滚指令撤销之前的操作。这保证了服务崩溃或网络异常时不会出现“扣了款但订单未创建”这类不一致结果。另外一种实践是使用 Saga（补偿事务）模式配合幂等设计，各服务先本地完成操作，如果后续步骤失败则通过调用补偿动作（如退款、加回库存）来最终达成一致。无论哪种方案，都需要在实际落地时注意持久化（写数据库事务日志或业务状态日志）以及操作的幂等性。例如，我们会为每个订单生成唯一事务 ID，在整个事务链路中传递，崩溃恢复后根据事务日志判断需要补偿还是继续未完成的步骤。通过这样的设计，订单系统在面临部分服务宕机重启时，仍然可以保证数据的最终一致性和正确性。

消息队列系统：以分布式消息队列为例（如 Kafka 或 RabbitMQ），崩溃一致性体现在不丢消息且不重复乱序。实际项目中，我部署过的 Kafka 集群采用持久化日志+副本同步：生产者发送的消息先写入领导者节点的磁盘日志（Kafka 提供多种 acks 级别确保消息写入持久化），Leader 将消息复制给 Follower 节点，等至少一个 Follower 也写入成功后再确认给生产者。每条消息有偏移量，消费者处理时按偏移顺序提交位移。若 Broker 崩溃，Zookeeper/Raft 协调下会选出新的 Leader 继续未完成的日志追加，消费者可以从上次提交的偏移继续消费，保证顺序和一致性。而对于消费者重复消费的情况，我们在消费端通过幂等处理解决：例如消息携带唯一 ID，消费逻辑更新数据库前先检查记录是否已处理该 ID，以避免因消费者崩溃重启后重复消费导致的数据重复。通过这些措施，消息队列系统实现了崩溃后恢复不丢消息，并使得任何重复消息的影响可控，从而在分布式部署下依然保持数据一致可靠。

面试回答思路和结构化表达建议

在技术面试中回答“如何保证崩溃一致性”这类问题时，可以按照有条理的结构来表达，确保面试官能清晰理解你的思路：

问题背景简介：首先简要说明什么是崩溃一致性，以及在什么背景下需要考虑它。可以点出崩溃场景（宕机、断电等）会导致部分写入丢失或数据结构不完整，从而引出需要机制保证一致性的重要性。
可选方案对比：接下来概述解决崩溃一致性的常见方案。可以按照从单机到分布式逐步展开，例如先介绍本地级别的方案（WAL 日志、Copy-on-Write、fsync 刷盘等），再说明分布式场景的方案（2PC/3PC 分布式提交、Paxos/Raft 一致性算法、幂等重试等）
- WAL 适合单节点多步骤原子更新
- 2PC 适合跨服务事务但有阻塞问题
- Raft 适合多副本一致
实际方案选择及理由：然后重点描述你在实际项目中用到了哪些机制来保证崩溃一致性，以及为什么选择这些方案。结合具体案例谈更有说服力，比如说明“在某项目中我们遇到 XX 一致性要求，选择了 YY 方案，因为…”。阐述方案如何落地实施（比如如何实现日志持久化、如何协调多服务提交）。这一部分体现你将理论用于实践的能力，例如提到性能考量（为什么选 WAL 而不是每次直接写入，以及 WAL 带来的性能提升与一致性保障）、可靠性需求（为何采用 Raft 保证副本一致）等决策因素。
遇到的问题与优化：最后补充说明在实现崩溃一致性过程中遇到的挑战以及采取的优化措施。这显示你对细节和系统影响有深入理解。比如，你可以提到性能瓶颈和解决：“由于频繁 fsync 影响吞吐，我们采用了批量提交来优化磁盘 IO”。或者复杂性问题：“实现 2PC 时遇到了超时和协调难题，通过引入超时重试和事务日志监控来保证一致性”。再比如边缘情况处理：“考虑到网络分区导致的脑裂，我们引入了仲裁机制/心跳检测来处理”。通过讲述如何发现问题、解决问题，表现出你对崩溃一致性机制有实战经验和思考。结束时可以强调经过这些努力，系统成功保证了在各种异常情况下数据的一致可靠。

Linux Kernel I/O

Sun, 30 Mar 2025 00:00:00 GMT

前置知识｜页缓存 & 零拷贝

零拷贝技术（Zero-Copy）

概念：在传统的数据传输过程中（比如读取文件发送给网络），数据通常会在内核空间和用户空间之间多次拷贝。零拷贝的目标是尽量减少或避免数据在内核空间与用户空间之间的拷贝操作，从而提升性能。

如果服务端要提供文件传输的功能，我们能想到的最简单的方式是：将磁盘上的文件读取出来，然后通过网络协议发送给客户端。

传统 I/O 的工作方式是，数据读取和写入是从用户空间到内核空间来回复制，而内核空间的数据是通过操作系统层面的 I/O 接口从磁盘读取或写入。

代码通常如下，一般会需要两个系统调用：

read(file, tmp_buf, len);
write(socket, tmp_buf, len);

首先，期间共发生了 4 次用户态与内核态的上下文切换，因为发生了两次系统调用，一次是 read() ，一次是 write()，每次系统调用都得先从用户态切换到内核态，等内核完成任务后，再从内核态切换回用户态。

上下文切换到成本并不小，一次切换需要耗时几十纳秒到几微秒，虽然时间看上去很短，但是在高并发的场景下，这类时间容易被累积和放大，从而影响系统的性能。

其次，还发生了 4 次数据拷贝，其中两次是 DMA 的拷贝，另外两次则是通过 CPU 拷贝的，下面说一下这个过程：

第一次拷贝，把磁盘上的数据拷贝到操作系统内核的缓冲区里，这个拷贝的过程是通过 DMA 搬运的。
第二次拷贝，把内核缓冲区的数据拷贝到用户的缓冲区里，于是我们应用程序就可以使用这部分数据了，这个拷贝到过程是由 CPU 完成的。
第三次拷贝，把刚才拷贝到用户的缓冲区里的数据，再拷贝到内核的 socket 的缓冲区里，这个过程依然还是由 CPU 搬运的。
第四次拷贝，把内核的 socket 缓冲区里的数据，拷贝到网卡的缓冲区里，这个过程又是由 DMA 搬运的。

这种简单又传统的文件传输方式，存在冗余的上文切换和数据拷贝，在高并发系统里是非常糟糕的，多了很多不必要的开销，会严重影响系统性能。

所以，要想提高文件传输的性能，就需要减少「用户态与内核态的上下文切换」和「内存拷贝」的次数。

从 Linux 2.1 版本开始，Linux 引入了 sendfile 来简化操作。文件通过 sendfile() 直接发送到 socket，不经过用户空间。

#include <sys/socket.h>
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

它的前两个参数分别是目的端和源端的文件描述符，后面两个参数是源端的偏移量和复制数据的长度，返回值是实际复制数据的长度。

首先，它可以替代前面的 read() 和 write() 这两个系统调用，这样就可以减少一次系统调用，也就减少了 2 次上下文切换的开销。其次，该系统调用，可以直接把内核缓冲区里的数据拷贝到 socket 缓冲区里，不再拷贝到用户态，这样就只有 2 次上下文切换，和 3 次数据拷贝。如下图：

多路复用技术（I/O Multiplexing）

概念：允许单个线程同时监听多个 I/O 事件（如 socket 连接），只在有事件发生时才进行处理，避免阻塞等待每个 I/O。

常见接口：

select
poll
epoll（Linux 高效实现）

用途：

高并发服务器（如 Nginx、Redis）
网络编程中高效的 I/O 模型

优势：

少量线程处理大量连接
减少线程切换开销

页缓存（Page Cache）技术

位于「程序内存分布」中的内核空间

概念：操作系统将磁盘中的数据缓存在内存中，以加快文件读写速度。缓存的单位是“页”（通常是 4KB）。

作用：

加快文件读取（命中缓存时无需访问磁盘）
写文件时先写到缓存，再异步刷到磁盘（提高写入性能）

相关命令：

sync：强制把缓存写入磁盘
drop_caches：清除缓存，用于测试或释放内存

Linux 内核 I/O 链路一览图

Linux I/O 存储栈下的读写流程

应用程序通过系统调用访问文件（无论是块设备文件，还是各种文件系统中的文件）。可以通过 open 系统调用，也可以通过 memory map 的方式调用来打开文件。

mmap 与 read/write 的区别可以参考文章：mmap 与 read/write 对比

Linux 内核收到系统调用的软中断，通过参数检查后，会调用虚拟文件系统（Virtual File System，VFS），虚拟文件系统会根据信息把相应的处理交给具体的文件系统，如 ext2/3/4 等文件系统，接着相应的文件 I/O 命令会转化成 bio 命令进入通用块设备层，把针对文件的基于 offset 的读/写转化成基于逻辑区块地址（Logical Block Address，LBA）的读/写，并最终翻译成每个设备对应的可识别的地址，通过 Linux 的设备驱动对物理设备，如硬盘驱动器（Harddisk Drive，HDD）或固态硬盘进行相关的读/写。

用户态文件系统的管理。Linux 文件系统的实现都是在内核进行的，但是用户态也有一些管理机制可以对块设备文件进行相应的管理。例如，使用 parted 命令进行分区管理，使用 mkfs 工具进行文件系统的管理，使用逻辑卷管理器（Logical Volume Manager，LVM）命令把一个或多个磁盘的分区进行逻辑上的集合，然后对磁盘上的空间进行动态管理。

当然在用户态也有一些用户态文件系统的实现，但是一般这样的系统性能不是太高，因为文件系统最终是建立在实际的物理存储设备上的，且这些物理设备的驱动是在内核态实现的。那么即使文件系统放在用户态，I/O 的读和写也还是需要放到内核态去完成的。除非相应的设备驱动也被放到用户态，形成一套完整的用户态 I/O 栈的解决方案，就可以降低 I/O 栈的深度。另外采用一些无锁化的并行机制，就可以提高 I/O 的性能。例如，由英特尔开源的 SPDK（Storage Performance Development Kit）软件库，就可以利用用户态的 NVMe SSD（Non-Volatile Memory express）驱动，从而加速那些使用 NVMe SSD 的应用，如 iSCSI Target 或 NVMe-oF Target 等。

linux IO 存储栈分为 7 层:

VFS 虚拟文件层: 在各个具体的文件系统上建立一个抽象层，屏蔽不同文件系统的差异。
PageCache 层: 为了缓解内核与磁盘速度的巨大差异。
映射层 Mapping Layer: 内核必须从块设备上读取数据，Mapping layer 要确定在物理设备上的位置。
通用块设备层: 通用块层处理来自系统其他组件发出的块设备请求，包含了块设备操作的一些通用函数和数据结构。
I/O 调度层： IO 调度层主要是为了减少磁盘 IO 的次数，增大磁盘整体的吞吐量，队列中多个 bio 进行排序和合并。
块设备驱动层: 每一类设备都有其驱动程序，负责设备的读写。
物理设备层: 物理设备层有 HDD、SATA SSD、NVMe SSD 等物理设备。

PageCache 层 —— 两种策略

write back: 写入 PageCache 便返回，不等数据落盘。
write through: 同步等待数据落盘。

程序的内存分布，其中包括内核空间（Page Cache 在内存中）

读流程

下面以一次文件读取操作为例，完整详细描述一次 I/O 请求处理链路：

虚拟文件系统层（VFS，也是 Linux 一切皆文件的底层原因）
文件系统（Ext2/3/4、NFS、Btrfs、xfs）
通用块设备层（bio、request）
I/O 调度器（CFQ、Deadline、noop、BFQ）
设备驱动（块设备/字符设备）
设备控制器（如 NVMe/SCSI 控制器）
中断处理（IRQ 处理流程）

1️⃣ 用户进程调用标准库函数

用户进程发起系统调用 read(fd, buf, count)，系统陷入内核态。

// glibc 中封装的 read() 最终触发 syscall
ssize_t read(int fd, void *buf, size_t count);

内核获取调用参数，内核深入调用 sys_read，检查文件描述符的有效性并获取内核文件结构体，通过软中断（x86 上是 syscall 指令）进入内核态：

// 内核入口点（x86_64 架构）
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
    return ksys_read(fd, buf, count);
}

2️⃣ 虚拟文件系统 VFS

内核通过文件描述符定位 struct file *：

ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
{
    struct fd f = fdget_pos(fd);          // 从 fd 表中找到 struct file
    ...
    return vfs_read(f.file, buf, count, &f.file->f_pos);
}

VFS 提供统一的文件接口，不管是 ext4、xfs 还是设备文件，统一调用：

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    if (file->f_op->read)
        return file->f_op->read(file, buf, count, pos);  // legacy
    else if (file->f_op->read_iter)
        return call_read_iter(file, buf, count, pos);
}

3️⃣ 文件系统层

假设文件位于 ext4 文件系统，对应操作函数为：

// ext4_file_operations
.read_iter = ext4_file_read_iter

这最终会调用 generic_file_read_iter()，进入页缓存机制（page cache）。

页缓存流程：

在页缓存中查找页是否命中
命中则拷贝回用户态（零拷贝优化）
未命中则触发 page cache miss → 发起读取请求到块设备

// mm/filemap.c
filemap_get_pages() → 调用 readpage(s) → 提交 bio 到块层

4️⃣ 通用块设备层

页缓存 page miss 会创建对应的 bio 结构体表示一次 I/O 请求并提交 submit_bio()，然后对 bio 进行进一步封装，形成更底层的 request 结构传入 I/O 调度器队列。

✅ request 是 I/O 调度的最小单位，多个 bio 访问存储器件上相邻的区域数据并且是同种类型的（读/写），则会被合并到一个 request 中，所以一个 request 可能包含多个 bio。

bio structure

submit_io

submit_bio(bio); // fs 层构造 bio，提交到底层设备

块层主要组件：

bio：描述一次 I/O 操作（起始扇区、长度、数据缓冲区等）
request_queue：设备对应的请求队列
I/O scheduler：调度多个 bio 的先后顺序

5️⃣ I/O 调度器

I/O 调度器决定请求的先后顺序，进行排序和合并优化，以此优化磁盘/硬盘访问。

blk_mq_sched_insert_request()
blk_mq_run_hw_queue()

常见调度器如：

CFQ（完全公平队列）
Deadline
noop
BFQ（新版本）

6️⃣ 块设备驱动

调度器处理完后，接着将 request 分发给具体驱动，调用对应的驱动操作函数（例如 NVMe 驱动）：

SATA 磁盘驱动 (ahci.ko)
NVMe 驱动 (nvme.ko)

// nvme driver: drivers/nvme/host/nvme-core.c
nvme_queue_rq() → 调用控制器提交命令

驱动程序将 request 翻译成硬件控制器能理解的指令集

对于磁盘：ATA/SCSI 命令
对于 NVMe：NVMe 命令

驱动程序将命令写入设备控制器寄存器，具体一些是控制器的 Submission Queue，并触发 DMA（直接内存访问）数据传输。

7️⃣ 设备控制器/硬件接口层

硬件控制器接收到 SQ 中的命令，解析命令 read 并读取数据到 DMA 缓存，通过 DMA 把数据传输到内存中的内核缓冲区（Page Cache），DMA 数据传输完成后，写入 Completion Queue，硬件设备发起硬件中断通知 CPU 操作完成。

8️⃣ 中断处理流程

CPU 响应硬件中断，内核执行相应中断处理程序：

确认硬件完成状态；
根据 CQ 的完成项来找到并标记 request/bio 已经完成；
唤醒被该 read 阻塞的上层等待进程（在 wait_on_page_locked() 阻塞）。

9️⃣ bio 回传用户空间

唤醒进程后，内核从内核缓冲区（Page Cache）将数据拷贝到用户空间缓冲区。

系统调用返回，用户进程继续执行。

写流程

write()—>sys_write()—>vfs_write()—>通用块层—>IO 调度层—>块设备驱动层—>块设备

mmap 与 read/write

顺便复习下 mmap 与 read/write 的区别：mmap 与 read/write 对比

传统的 file I/O 中 read 系统调用首先从磁盘拷贝数据到 kernel，然后再把数据从 kernel 拷贝到用户定义的 buffer 中。

而 mmap 直接由内核操刀，mmap 返回的指针指向映射内存的起始位置，然后可以像操作内存一样操作文件，而且如果是用 read/write 将 buffer 写回 page cache 意味着整个文件都要与磁盘同步（即使这个文件只有个别 page 被修改了），而 mmap 的同步粒度是 page，可以根据 page 数据结构的 dirty 位来决定是否需要与 disk 同步。这是 mmap 比 read 高效的主要原因。对于那种频繁读写同一个文件的程序更是如此。

面试题：如何不使用库函数完成对底层设备的读写？

用户态 I/O

参考《操作系统原理与实现》13.4.2 小节 —— 陈海波

无论是基于系统调用还是 I/O 库接口，应用程序默认操作的设备对象都是操作系统提供的逻辑设备。用户态和内核态之间需要大量的拷贝，造成性能下降，有没有办法不使用库函数来达到直接对底层物理设备的读写呢？

以网络 I/O 为例，一种直观的思路是允许防火墙软件直接操作网卡的 DMA 缓冲区（应用程序直接操作设备控制器的 DMA 缓冲区），为了实现这一目标，Intel 联合其他网卡制造商共同开发了一套高性能的用户态网络 I/O 框架 —— 数据平面开发套件（DPDK）。

DPDK 在设计上采用旁路内核的设计，即网络包的收发处理基本不需要 Linux 内核的参与，DPDK 的设计思路如下：

其底层原理同样适用于其他物理设备

用户空间驱动

为了能在用户态同网卡设备进行交互，DPDK 需要在用户态直接执行网卡驱动代码。做法就是将设备寄存器直接映射到应用自身的进程地址空间中，进而让 DPDK 的用户态驱动通过 MMIO 操作设备。

正如操作系统为应用程序的开发提供统一设备文件系统的和 I/O 使用接口一样，Linux 提供了用户态驱动开发框架，即 UIO (Userspace I/O)。

Linux 将 UIO 设备抽象为路径为 /dev/uio [x] 的设备文件。应用程序通过打开 UIO 设备文件获取设备的 I/O 空间和中断信息，同时自行决定如何操作和响应设备。

注意：UIO 用户驱动通常不使用 write 接口，而是从 uio_driver.h 中已经经过 mmap 处理的内存区间直接与设备交换数据。

更多详细内容可以查看 Linux Kernel 中的 include/linux/uio_driver.h.

系统调用的优化

系统调用作为应用程序调用操作系统的入口，其性能也非常重要。然而不同于传统的函数调用，系统调用的过程复用了异常机制，因此不可避免地需要执行特权级切换、上下文保存等操作，导致其时延比普通函数调用高1～2 个数量级。对于需要频繁进行系统调用的应用来说，这是很大的性能开销。

Q：那么要怎样绕过费时的异常处理机制来实现系统调用呢？

A：可以通过在用户态和内核态之间共享一小块内存的方式，在应用与内核之间创建一条新的通道。

1️⃣ 方法 1：共享内核只读数据给应用

内核将一部分数据通过只读的形式共享给应用，允许应用直接读取。

这种方法的缺点在于：如果系统调用需要修改内核中的变量，或者在运行过程中需要读取更多内核数据，该方法就不适用了。

2️⃣ 方法 2：允许应用以 “向内存页写入请求” 发起系统调用

第二种方法就是允许应用（用户态）以 “向内存页写入请求” 的方式发起系统调用，并通过轮询来等待系统调用完成；内核（内核态）同样通过轮询来等待用户的请求，然后执行系统调用，并将系统调用的返回值写入同一块内存页以表示完成。

但应用和内核怎么同时轮询呢？

这个设计的关键点在于：让内核独占一个 CPU 核心。

这个核心一直在内核态运行，而其他 CPU 核心则一直在用户态运行。这样从系统整体来看，对于任何一个 CPU 核心都不会发生从用户态到内核态的切换，大大降低系统调用的时延。在应用将请求写入内存页后的下一个时钟周期，处于轮询状态的内核立即可以读到这个请求，并开始运行处理函数；同样，当内核将返回结果写入内存页后，在另一个 CPU 核心处于轮询状态的应用立即可以读到结果并继续运行。

不过这种方式存在两个缺点：

第一个缺点在于，如果有多个应用同时发起请求，内核需要一个个顺序处理，则时延可能会比原来更长，因为没能充分使用多核。解决方法也很直接：让多个 CPU 核心同时运行在内核态并轮询用户的请求，当内核忙不过来时，占用的核心多一些，反之少一些（根据系统负载动态调整内核占用的 CPU 核心数）。

第二个缺点在于，如果整个系统只有一个 CPU 核心怎么办？可以将轮询改为批处理。当 CPU 运行在用户态时，应用程序一次发起多个系统调用请求，同样将请求和参数写入共享内存页。然后 CPU 切换到内核态，内核一次性将所有系统调用处理完，把结果写入共享内存页，再切换回用户态运行。由于特权级的切换次数变少了，所以整体吞吐率提升了。

DuckDB 的 Adaptive Radix Tree 源码分析

Fri, 14 Mar 2025 00:00:00 GMT

DuckDB 不同于其他数据库，并没有使用 B+ 树作为主要索引结构，而是使用 ART (Adaptive Radix Tree) 作为它内部的主要索引结构，本文介绍这一索引。

ART (Adaptive Radix Tree)

ART 索引是由 Viktor Leis, Alfons Kemper, Thomas Neumann 等人提出，它相比于 B+ 树的主要区别在于 B+ 树是面向磁盘的，而 ART 则是面向内存的，即 ART 索引是需要全部加载到内存中的。DuckDB 之所以选择这个索引有以下几方面的考虑：

随着内存越来越大，并且价格也越来越便宜，我们可以使用纯内存的索引，从而避免磁盘 I/O，提升性能
ART 索引可以很大程度上节省空间
ART 索引支持范围查询
ART 索引有着较高的性能

后续本文会先介绍 ART 这一数据结构，然后配合着 DuckDB 的代码描述 ART 是如何实现的。

Trie 数据结构

在讲 ART 索引之前，我们先看一下 Trie 树🌲

如果你不知道 Trie 树，可以参考 Wikipedia：https://en.wikipedia.org/wiki/Trie

✅ LeetCode 上也有「206. 实现 Trie（前缀树）」算法题可供参考：

请你实现 Trie 类：
- Trie() 初始化前缀树对象。
- void insert(String word) 向前缀树中插入字符串 word 。
- boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
- boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

假设字符串里面只有 a 和 b 两种字符。

insert：例如插入字符串 aab，相当于生成了一条移动方向为「左-左-右」的路径。标记最后一个节点为终止节点。再插入字符串 aabb，相当于生成了一条移动方向为「左-左-右-右」的路径。标记最后一个节点为终止节点。

search：例如查找字符串 aab，相当于查找二叉树中是否存在一条移动方向为「左-左-右」的路径，且最后一个节点是终止节点。

startsWith：例如查找前缀 aa，相当于查找二叉树中是否存在一条移动方向为「左-左」的路径，无其他要求。

推广到 26 种字母，其实就是一棵 26 叉树，对于 26 叉树的每个节点，可以用哈希表，或者长为 26 的数组来存储子节点。

struct Node {
    Node* son[26]{};
    bool end = false;
};

class Trie {
private:
    Node* root = new Node();

    int find(string word) {
        Node* cur = root;
        for (char c : word) {
            c -= 'a';
            if (cur->son[c] == nullptr) {
                return 0; // not found
            }
            cur = cur->son[c];
        }
        return cur->end ? 2 : 1;
    }

public:
    Trie() {}

    void insert(string word) {
        Node* cur = root;
        for (char c : word) {
            c -= 'a';
            if (cur->son[c] == nullptr) {
                cur->son[c] = new Node();
            }
            cur = cur->son[c];
        }
        cur->end = true;
    }

    bool search(string word) {
        return find(word) == 2;
    }

    bool startsWith(string prefix) {
        return find(prefix) != 0;
    }
};

我们可以看到 Trie 树在检索时的优点是，它的检索时间仅与最长的字符串长度有关，而与存储的字符数量无关，这一特性在数据量极大的情况下十分优秀，但是它的缺点是浪费空间，即每个内部节点都需要保存固定数量的指针，即使它仅有极少的子节点。

比如图中的 root 节点，尽管它只有三个子节点，但是它仍然需要保存指向 a,b,c,d,e... 的空指针，这十分浪费空间，其次 Trie 树仅支持保存字符串。

ART 则是在 Trie 树的基础上，解决了它缺点的同时，保留了它的优点，下面来介绍 ART 索引。

对于一个索引而言，我们希望它有以下两个特点：

查询速度快
空间占用小

但是如果我们使用 Trie 树做索引（ART 是 Trie 的一个变种），我们就要面临取舍：

如果内部节点拥有的最大子节点越多（空间占据越多），那么它的高度也越低（速度越快）
如果内部节点拥有的最大子节点越少（空间占据越少），那么它的高度也越高（速度越慢）

ART 树选择每个内部节点的大小为 8bit（子节点的数量为 256），刚好是一个 Byte。这样的好处是免去了内存对齐的问题，同时在空间与速度上取得了一个较好的平衡，我们称内部节点所占据的位宽为 span。

尽管如此，面对稀疏的数据时，每个节点有 256 个子节点仍然会浪费空间，为了解决这个问题，ART 将内部节点进一步细分为以下四类，我们分别来对其进行介绍：

Node 4
Node 16
Node 48
Node 256

Node 4

从图中可以看出，Node 4 分为两个部分，一个是 key 数组，一个是 child 数组。

key 数组存放 key 的部分内容（也就是 key 的一个 Byte）
child 数组则是保存对应的子节点的指针

注意，我们为了可以范围查询，key 数组要求顺序存储。

Node 16

Node 16 和 Node 4 几乎一样，区别只是从 4 个 slot 变成 16 个 slot。

Node 48

Node 48 和之前介绍的 Node 一样也是分为 key 数组和 child 数组，区别在于 Node 48 的 key 数组长度为 256，且内部 key slot 存放的是指针，指向对应子节点在 child 数组中的位置，这样我们就无需通过遍历找到对应的数组，而是可以直接通过 key 的二进制值作为下标直接定位到对应的 key slot。

实际查询仅需要 child_array[key_array[key]] 即可。

Node 256

Node 256 就是「Trie 树」原始的内部节点表示形式，仅需要一个数组，数组的下标即为 key，数组中存放的就是子节点的指针。

各种不同类型的 Node 可以相互转换，如果子节点数量超过限制容量就向上转换，如果节点数量相较于限制容量太小就向下转换。

Leaf

ART 中的叶节点存放的就是 Key 对应的 Value 值，ART 的叶节点可以采用三种形式：

单独有一个叶节点类型专门保存 Value
和中间节点保持一致的类型，唯一区别则是 child 数组不保存指针而是保存值
如果值足够小可以通过位操作和指针一起保存，那么我们可以将值直接存放在内部节点中

🔥 DuckDB 采用的是第一种方式。

Optimization

在解决了 ART 的空间问题，我们希望可以进一步优化查询速度，即减少树的高度。

论文链接：https://db.in.tum.de/~leis/papers/ART.pdf

论文中有两种方式，但实际上我们可以通过一种简单的做法同时获得这两种优化，每个节点加上 Prefix 标识。

1. Lazy Expansion

其实这个优化相当简单，我们只需 Leaf 可以保存多个 byte 即可，这样子对于多个只有一个子节点的路径来说，我们可以将其都保存在 Leaf 中，从而减少树的高度。

2. Path Compression

这个优化和 Lazy Expansion 类似，我们只需让 内部节点 可以保存多个 byte 即可。即如果内部节点有相同的前缀，我们可以将其保存在 Prefix 中，key 数组仅仅只对 key 不同的部分作区分。这样也可以有效地减少树的高度。

如果这里没看懂也没关系，后续我会分析 DuckDB 的代码，那样会更加清晰。

数据转换

对于 ART 来说，前面介绍的都是对于字符串类型 string，如果作为一个广泛使用的索引，也需要支持不同类型的数据。而 ART 索引实际上是把 Key 作为数据流进行处理的，也就是说如果想要通过 ART 进行范围搜索，我们需要让 Key 保持一个性质，即二进制的大小与该类型的语义大小相同： $$ memcmp(binary(x),binary(y)) < 0 \Leftrightarrow x < y \ memcmp(binary(x),binary(y)) = 0 \Leftrightarrow x = y \ memcmp(binary(x),binary(y)) > 0 \Leftrightarrow x > y $$ 因此我们需要对某些数字进行转换。

unsigned int

无需转化，已经满足需求。

signed int

将符号为 flip 即可。

float

static inline uint32_t EncodeFloat(float x) {
	uint64_t buff;

	//! zero
	if (x == 0) {
		buff = 0;
		buff |= (1u << 31);
		return buff;
	}
	// nan
	if (Value::IsNan(x)) {
		return UINT_MAX;
	}
	//! infinity
	if (x > FLT_MAX) {
		return UINT_MAX - 1;
	}
	//! -infinity
	if (x < -FLT_MAX) {
		return 0;
	}
	buff = Load<uint32_t>(const_data_ptr_cast(&x));
	if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
		buff |= (1u << 31);
	} else {          //! negative numbers
		buff = ~buff; //! complement 1
	}

	return buff;
}

char

UCA 算法已经做出了定义。

Unicode Collation Algorithm (UCA) 是 Unicode 规定的如何比较两个字符串大小的算法。

null

可以将该值设置为比最大位数仍多 1 位。

compound keys

按照其包含的基本类型进行拼接即可。

DuckDB 源码分析

DuckDB 代码链接：https://github.com/duckdb/duckdb/tree/main/src/execution/index/art

其他参考：

论文

《The Adaptive Radix Tree: ARTful Indexing for Main-Memory Databases》

《SMART: A High-Performance Adaptive Radix Tree for Disaggregated Memory》

相关代码

[cpp] ART：https://github.com/rafaelkallis/adaptive-radix-tree

[golang] ART：https://github.com/plar/go-adaptive-radix-tree

这一章通过阅读 DuckDB 的源码，来看一下 ART 索引的实现。

ART 索引的相关实现都在 art.cpp 和 art.hpp，我们主要关注 Insert 和 Find，其他函数留给读者自行了解。

Insert

bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {

	if (!node.IsSet()) {
		// node is currently empty, create a leaf here with the key
		Leaf::New(*this, node, key, depth, row_id);
		return true;
	}

	if (node.DecodeARTNodeType() == NType::LEAF) {

		// add a row ID to a leaf, if they have the same key
		auto &leaf = Leaf::Get(*this, node);
		auto mismatch_position = leaf.prefix.KeyMismatchPosition(*this, key, depth);

		// identical equal
		if (mismatch_position == leaf.prefix.count && depth + leaf.prefix.count == key.len) {
			return InsertToLeaf(node, row_id);
		}

		// example:
		// prefix : hello
		// key[depth] : heel;
		// mismatch_position = 2
		// replace leaf with Node4 and store both leaves in it
		auto old_node = node;
		auto &new_n4 = Node4::New(*this, node);

		// new prefix
		// new_n4's prefix is he
		new_n4.prefix.Initialize(*this, key, depth, mismatch_position);

		// old_node's prefix change to llo
		auto key_byte = old_node.GetPrefix(*this).Reduce(*this, mismatch_position);

		// add child
		Node4::InsertChild(*this, node, key_byte, old_node);

		Node leaf_node;
		Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
		// add child
		Node4::InsertChild(*this, node, key[depth + mismatch_position], leaf_node);

		return true;
	}

	// handle prefix of inner node
	auto &old_node_prefix = node.GetPrefix(*this);
	if (old_node_prefix.count) {

		auto mismatch_position = old_node_prefix.KeyMismatchPosition(*this, key, depth);
		if (mismatch_position != old_node_prefix.count) {

			// prefix differs, create new node
			auto old_node = node;
			auto &new_n4 = Node4::New(*this, node);
			new_n4.prefix.Initialize(*this, key, depth, mismatch_position);

			auto key_byte = old_node_prefix.Reduce(*this, mismatch_position);
			Node4::InsertChild(*this, node, key_byte, old_node);

			Node leaf_node;
			Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
			Node4::InsertChild(*this, node, key[depth + mismatch_position], leaf_node);

			return true;
		}
		depth += node.GetPrefix(*this).count;
	}

	// recurse
	D_ASSERT(depth < key.len);
	auto child = node.GetChild(*this, key[depth]);
	if (child) {
		bool success = Insert(*child, key, depth + 1, row_id);
		node.ReplaceChild(*this, key[depth], *child);
		return success;
	}

	// insert at position
	Node leaf_node;
	Leaf::New(*this, leaf_node, key, depth + 1, row_id);
	Node::InsertChild(*this, node, key[depth], leaf_node);
	return true;
}

参数含义：

node 即为当前要进行插入的节点
key 即为要插入的 key
depth：即当前已经处理到 key 的第几个 byte，举个例子，key 为 hello，depth 为 3，那么说明 he 已经保存在了 node 的祖先节点中，我们当前要处理的是 l
row_id 即为 key 对应的 value 值

bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
	if (!node.IsSet()) {
		// node is currently empty, create a leaf here with the key
		Leaf::New(*this, node, key, depth, row_id);
		return true;
	}
}

如果当前节点为空，那么直接设置该节点为叶节点，并且将 row_id 进行保存，注意这里我们会使用 lazy-expansion，即将 key 剩余未处理的字符全部保存在叶节点中。

bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {

	// .... skip
	if (node.DecodeARTNodeType() == NType::LEAF) {

		// add a row ID to a leaf, if they have the same key
		auto &leaf = Leaf::Get(*this, node);
		auto mismatch_position = leaf.prefix.KeyMismatchPosition(*this, key, depth);

		// identical equal
		if (mismatch_position == leaf.prefix.count && depth + leaf.prefix.count == key.len) {
			return InsertToLeaf(node, row_id);
		}

		// example:
		// prefix : hello
		// key[depth] : heel;
		// mismatch_position = 2
		// replace leaf with Node4 and store both leaves in it
		auto old_node = node;
		auto &new_n4 = Node4::New(*this, node);

		// new prefix
		// new_n4's prefix is he
		new_n4.prefix.Initialize(*this, key, depth, mismatch_position);

		// old_node's prefix change to llo
		auto key_byte = old_node.GetPrefix(*this).Reduce(*this, mismatch_position);

		// add child
		Node4::InsertChild(*this, node, key_byte, old_node);

		Node leaf_node;
		Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
		// add child
		Node4::InsertChild(*this, node, key[depth + mismatch_position], leaf_node);

		return true;
	}
	
	//skip....
}

如果当前遇到的是叶节点，同时 key 完全相同，那么我们可以直接将 row_id 插入叶节点中。不然的话，我们需要将叶节点变成内部节点，同时将不同的部分作为该内部节点的叶节点，如下图所示。

bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {

	// skip ....
	// handle prefix of inner node
	auto &old_node_prefix = node.GetPrefix(*this);
	if (old_node_prefix.count) {

		auto mismatch_position = old_node_prefix.KeyMismatchPosition(*this, key, depth);
		if (mismatch_position != old_node_prefix.count) {

			// prefix differs, create new node
			auto old_node = node;
			auto &new_n4 = Node4::New(*this, node);
			new_n4.prefix.Initialize(*this, key, depth, mismatch_position);

			auto key_byte = old_node_prefix.Reduce(*this, mismatch_position);
			Node4::InsertChild(*this, node, key_byte, old_node);

			Node leaf_node;
			Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
			Node4::InsertChild(*this, node, key[depth + mismatch_position], leaf_node);

			return true;
		}
		depth += node.GetPrefix(*this).count;
	}

	// recurse
	D_ASSERT(depth < key.len);
	auto child = node.GetChild(*this, key[depth]);
	if (child) {
		bool success = Insert(*child, key, depth + 1, row_id);
		node.ReplaceChild(*this, key[depth], *child);
		return success;
	}

	// insert at position
	Node leaf_node;
	Leaf::New(*this, leaf_node, key, depth + 1, row_id);
	Node::InsertChild(*this, node, key[depth], leaf_node);
	return true;
}

如果是内部节点，那我们需要讨论：

如果前缀完全相同，即 "hello" 和 "hellopxxx"。那么我们仅需要找出子节点进行插入即可

如果前缀有不同之处，即 "hello" 和 "helopxxx"。那么我们需要创建一个新的节点，并将两个节点作为子节点进行插入

可以看到我们只需要在内部节点和叶节点中支持存储多个字符后，便天然支持上述的优化方案。

Find

Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {

	while (node.IsSet()) {
		if (node.DecodeARTNodeType() == NType::LEAF) {
			auto &leaf = Leaf::Get(*this, node);

			// check if leaf contains key
			for (idx_t i = 0; i < leaf.prefix.count; i++) {
				if (leaf.prefix.GetByte(*this, i) != key[i + depth]) {
					return Node();
				}
			}
			return node;
		}
		auto &node_prefix = node.GetPrefix(*this);
		if (node_prefix.count) {
			for (idx_t pos = 0; pos < node_prefix.count; pos++) {
				if (key[depth + pos] != node_prefix.GetByte(*this, pos)) {
					// prefix mismatch, subtree of node does not contain key
					return Node();
				}
			}
			depth += node_prefix.count;
		}

		// prefix matches key, but no child at byte, does not contain key
		auto child = node.GetChild(*this, key[depth]);
		if (!child) {
			return Node();
		}

		// recurse into child
		node = *child;
		D_ASSERT(node.IsSet());
		depth++;
	}

	return Node();
}

查找的代码相对来说比较简单：

查找到了 Leaf 节点，检查 Prefix 是否匹配，如果不匹配说明 Key 不存在，若匹配直接返回该叶节点即可
查找到了 内部节点，检查 Prefix 是否匹配，如果不匹配说明 Key 不存在，若匹配则继续搜索对应的子节点

最后

本文介绍了 DuckDB 的 ART 索引，可以看到尽管 ART 索引的树会比 B+ 树更高，因此如果是面向磁盘的情况下，B+ 树会比 ART 索引优势更大，但是如果是内存索引的情况下，ART 索引更加紧凑，同时它的渐进时间复杂度仅与 key 的长度有关，可能也更加 Cache friendly？它的节点相较于 B+ 树更加的小，可以更多的保存在 Cache 中。从论文中的实验来看，它的性能会比 B+ 树更好。相较于 Hash table，它支持范围查询。基于此，DuckDB 将 ART 索引作为其的主要索引。

未来世界的幸存者

Mon, 03 Feb 2025 00:00:00 GMT

彻底了解你自己

所有关于成长的书籍都告诉我们要扬长避短，做自己最擅长的事，但是了解自己长短这件事情并不容易。

你可能试过很多方法，比如心理学的各种人格与性格分类，甚至玄学中的星座、属相等等。你会从这些工具中得到各种各样结果，但不管你被归类为冷静理性的 intj，还是敏感细腻的 infp；是潇洒随意的射手座，还是完美主义的处女座。这些结论除了为你的自恋找到依据，或者为自我厌恶的部分做心理按摩以外，就只能增加些谈资，并没有什么实用价值，你的生活和事业并没有因为你知道这些而变好。

所以你需要一个科学的工具，这个工具叫回馈分析法。人类这种生物是没有多少自由意志的，所有的决策都被潜意识所影响。

卡尔·荣格曾说过，除非你意识到自己的潜意识，否则它会一直影响着你的生活，然后你说那是命运。

所以你必须扒开你的潜意识看看你的底色，而窥探潜意识最好的方式，就是用回馈分析法观察自己的决策。

你的潜意识如何影响你的人生，真实的你自己是什么样子，答案藏在你做的每一个决策里。

具体操作是：在你准备做一件事情之前，记录下你对结果/效果的期望，在事情完成之后，将实际的结果/效果与你的预期进行比较。

比如下面这样。

决策：我决定远离有毒的同事关系，跳槽到新公司重新开始。
预期结果：新公司的同事关系一定会很和睦，至少会和平相处。
实际结果：新公司的同事一样很坏，他们都针对我。

你记录的越多，你就对自己越了解，你会发现成功和失败的原因都极其类似，有些事情你很擅长，有些事情你就是死活也做不到。

你是怎么想的和怎么说的都不重要，重要的是怎么做的，你的决策和行为方式才是你最真实人格的体现，你所有的长项和缺陷都在其中一览无遗。

当然，你也不必花费数年的时间来记录自己的决策和结果，回忆过去所做的对人生有重大影响的决策，也可以达到同样的效果。

从这些记录中，你可以分析出你应该做什么，避免做什么，你最强的欲望和最深的恐惧都一目了然。

然后改变其中能改变的，接受并避免那些不能改变的，在以后的人生中充分发挥你的长项，而不是在缺陷里死循环，白白浪费时间。

等价交换

你目前所拥有的一切都是来自你自身价值的交换，你的工作来自于你的技能；你的生意来自你掌握的资源；你的友情来自你所能提供的情绪价值；你的爱情来自物质和情绪价值的双重交换。

人在年轻的时候总是过于自我，觉得自己 “配得上这世间所有美好”，所以一旦不被领导赏识，难免会觉得 “怀才不遇”。你爱的人不爱你，你会觉得对方 “瞎了眼”，永远不会反思自己配不配，因为你觉得爱情不应该用物质来衡量，可是你试图用 “有趣的灵魂” 去交换别人的财富、地位、美貌这些硬通货，又高尚到哪里去了呢？

短期内你的价值可能会被高估或者被低估，但生活就像投资品一样，是存在均值回归的，溢价终究会被时间抹平，最终每个人都只能过上自身实力能够匹配的生活。

所以你想要什么，必需要先掌握能够与之交换的筹码。

那么你有什么呢？

如果你是一个普通人，那么你对世界的认知无非来自知乎、微博以及你平凡父母的言传身教；你的知识来自智商正常就能读的学校（毕业后大部分都还了回去）；你掌握的工作技能，任何一个应届生培训半个月就能胜任。

你想要怒放的生命，你想要不平凡的人生，又或者你没有别的愿望，只想和多个异性.....（季羡林先生语，此处省略）

就凭这些能交换到你想要的生活吗？

所以你必须要增加你的筹码，如果你不名一文，那就应该用你的勤奋，去交换技能和知识，然后和这个世界做交易，在每一步交易中都获得自己想要的筹码，或者是钱，或者是人情，或者是信息。当你积攒的筹码足够多，最后你就可以给你的目标一个 “无法拒绝的条件”，过上你想要的人生。

这是一条极为艰苦的道路，爽片里的主角一旦下定决心奋斗，几个转场镜头，主角就脱胎换骨，走向人生巅峰。可是真实的奋斗不是这样，真实世界的奋斗是血与火的拼杀，是未知带来的恐惧，是无数个不眠之夜，你需要忍受焦虑和未知的煎熬。在这个过程中你会不断杀死 “自我”，从一个文艺小清新，变成一个 “油腻的生意人”，但这是一条正确的路。

你要有一门安身立命的手艺

你必须要精通一门手艺，通过这门手艺你可以连接更高阶层的人，用帮助他们的方式种下友谊的种子，积累跨越阶层的人脉，从他们那里获取有价值的信息。

这门手艺将是你人生的下限，保证你过上至少中等水平的生活。这非常重要，假如你生活在社会底层，为了生活不得不精打细算，那么你将会因为生存资源匮乏养成 “稀缺头脑模式”，没有任何多余 “带宽” 来考虑如何学习提升，这叫贫穷的陷阱。陷入其中的人会因为缺乏改变现状的心力而长期贫困，甚至出现贫困的代际传递，他们的子女大概率也会继续贫困。

在学习手艺的过程中你还可以掌握把事情做成的方法论，不要小看这件事的价值，成功乃成功之母，这个社会大多数人都浑浑噩噩，没有体验过真正成功的滋味，多少都有点习得性无助，当你体验过为一件事专注到废寝忘食，最终把它做成，你将脱胎换骨。

得益于互联网的发展，我们学习一门手艺不需要像古时候一样磕头拜师（如果你看过白鹿原就知道那时候学手艺这事儿有多难），现今社会需要的大部分技术都可以从网络上学习，网上有丰富详细的各种教程，你可以学习任何你想学的东西，互联网时代不会埋没人才，也不会亏待勤奋的人，假如你是的话。

生理决定了你的精神状态

你有没有想过，为什么有的人精力充沛，遇到紧急工作能连续熬夜，在巨大压力下，还能保持充足睡眠，该吃就吃，该喝就喝。而你整天精神萎靡，早上起不来，晚上睡不着，浑身散发负能量，遇难则退，“太难了”、“做不到” 是你的口头禅，饿、困、穷是你的日常抱怨内容。

有人觉得这是性格问题，但其实本质是个生理问题，人体分泌的各种神经递质会影响我们的情绪，而情绪又会外化为我们的各种日常行为。

大体上我们的情绪主要被三种神经递质影响：

多巴胺

多巴胺应该是最为大众熟知的神经递质，多巴胺不生产快乐，它是一种 “承诺你这么做就能够获得快乐” 的物质，是人的心理动力源泉。没有了它就没有做任何事情的内在驱动力。

人们之所以会在周五工作效率特别高，是因为知道完成工作，就可以在周末愉快的玩耍。如果多巴胺分泌水平较低，就会缺乏这种奖赏机制下产生的动力，明明知道很多事情「很重要」「必须做」，但就是提不起精神，一再拖延。

血清素

血清素最核心的作用是保持情绪和心情的稳定性。比如，别人对你发脾气，你心态很好，不容易生气。或者遇到挫折时抗压能力强，有点类似成功学说的 “逆商”。

另外，血清素还能抑制「厌烦」情绪的产生。有实验表明，当分泌血清素的神经元被激活，实验参与者会表现出更高的耐心和积极性。哪怕接连给他们制造困难，也不会失控和不耐烦。

同样的，当大脑缺乏血清素的时候，很容易导致情绪不稳定，感到抑郁、厌烦、悲观，觉得世界一片灰暗，动不动就发脾气烦躁，看什么都不顺眼。

皮质醇

皮质醇又叫 “压力荷尔蒙”，听起来是一种不好的激素，实际上大有益处。人在运动锻炼和比赛之前身体会自然分泌皮质醇，可以短暂的改善记忆力和提高疼痛阈值。人体能进化并保留出皮质醇这种激素，是自然选择的结果。一个面对猛兽的原始人，不管他是选择战斗还是逃跑，适当的压力都会提升他的警惕性与战斗能力，生存概率也就会因此提高。也就是说，今天的人类都是那些能产生压力情绪的原始人的后代。

但是皮质醇过高则又变成了一件坏事，它会让我们过度悲观，导致什么也不想干，食欲大增，吃饱了还想吃。

最关键的，皮质醇高还会导致「延迟满足」能力变弱，所有让人进步的事情，都需要先苦后甜，你想英语流利，就必须忍受背单词的枯燥。但是皮质醇过高，会让人没办法集中精力做需要静下心才能做的事情，只想要当下的满足。

如果你多巴胺和血清素分泌水平低，皮质醇分泌水平高，你就会变成一个负能量黑洞或者高敏感人格，日日陷在心理内耗中不能自拔，学习、工作、事业就不要想了。

饮食｜冥想｜运动

那么怎么改善这些神经递质的分泌水平呢？有三种经过科学检验的方法：饮食、冥想、运动。

1️⃣ 先说饮食，有些食物对改善神经递质的分泌有一定作用，但是我不建议用饮食调理，因为如果不能想吃什么就吃什么，人的情绪会受很大影响，饮食的调理功效会被对冲掉，所以饮食的作用可能不会太明显。

2️⃣ 其次是冥想，有研究表明，有规律的进行冥想可以直接影响大脑中关键神经递质的水平，能有效提高自控力、钝感力，促进睡眠。而且冥想的效果立竿见影，没有冥想经历的人，尝试一次冥想就能体验到久违的内心平静，对驱散焦躁情绪帮助极大。

3️⃣ 最后是运动，这是我比较推荐的一种方法，运动对提高多巴胺和血清素，降低皮质醇的作用非常显著，这和我们的印象大体上是一致的，运动能力好，身体素质好的人，通常元气满满，更乐观开朗。而身体素质差或者干脆就是亚健康的人抗压能力弱，遇到问题会更多抱怨，没有耐心，甚至脾气也更差。

当然冥想和运动都需要长期坚持，这对本身就充满负能量的人来说非常难。但是人生若不做成几件抓心挠肝的难事，基本不可能有阶级跃迁的机会。何况还是这种只要坚持就有效果，因果关系极为清晰的事。

完美主义害死人

让一个完美主义者不出手的理由有很多，天气和心情都可以是原因，他们害怕失败，希望一出手就是完美状态。但这几乎是做不到的，很多事情都是在与现实的碰撞中一步一步完善的，不可能事先在脑海中想清楚每一个细节。

软件设计领域有一个著名的 “MVP” 原则，既最小可行产品，可以把它理解为一个软件的最简单版本，细节虽然不完善，甚至粗糙，但它是可以运行的，可以满足用户最核心的需求。把它快速推向市场，接受用户的检验，验证这个软件是否有市场，确定以后再快速迭代，加大投入。这样做可以用最小的成本，快速验证自己的创意，如果一开始就追求大而全，要么失了先机，让别人抢占市场，要么就是闭门造车，做的东西完全没人用，浪费时间和金钱。

很多人在学习上也是完美主义者，喜欢死抠细节，不搞明白绝不进入下一章节的学习。在学习上死磕精神是对的，但是对于初学者来说，过于抠细节往往会钻牛角尖，导致学习过程举步维艰。不是说细节不重要，而是初学阶段的细节问题，要么在以后的章节会讲到，要么就是初学者不了解基本概念，思考了一个不是问题的问题。

对于一个想要做点事儿的人来说，接纳一定程度的未知、混乱、瑕疵是常态，路是一步步走出来的。你需要在 “战争中学习战争”，让自己的想法和技能接受别人的检验和反馈。很多功成名就的人在成功以后都自夸当初如何运筹帷幄、高瞻远瞩，但实际上哪个不是一路如履薄冰，小心翼翼才走到今天。

你需要做一个副业

这几年很多人都在尝试副业，但是我让你做的副业不是利用一项技能接私活，而是独立运营一门小生意。它可以是在朋友圈卖水果；在二手平台卖旧货；做外贸 soho；利用独立站做 drop shipping；做自媒体博主（文字、音频、视频，你对哪个感兴趣就做哪一种类型）。

做这些小生意你有百分之一的可能赚到超过你工资的钱，百分之十的可能赚点零花钱，更可能是亏几顿 KFC，但这些都不重要，重要的是培养商业能力和保持市场敏感度。你会学习如何引流获客，什么是投入产出比，什么是供应链。当你以一个商人的视角看待这个世界时，你会更加客观，你没有得到你想要的东西，只会是你错了，因为市场永远不可能出错，它只会给正确对待的它的人以回报。

读一百本商业书籍，在脑中设计一万个商业模式，不如自己亲自运营一个小生意，你只有身在其中才能保持对市场的敏感，在下一波浪潮到来时及时抓住机会，站上浪潮之巅。

做站长失败的伊光旭抓住了微博崛起的机会，运营出冷笑话精选等一批微博大号；在论坛博客时代就活跃的人，抓住了公众号的红利期，赚得盆满钵溢；在阿里巴巴把流量日益向大卖家倾斜时，一些活不下去的小卖家抓住了拼夕夕的机会；近几年火爆的跨境电商，从业者大多以前就在做传统外贸。

🌀没有人是横空出现的，你必须先进场

得到贵人帮助

如果你研究过一些大佬的生平，你就会发现在大佬崛起的关键节点，往往都有贵人相扶。大佬得到的也许并不是直接的帮助，可能就是一个建议或者信息，但大佬从此就一飞冲天。

那么什么样的人才能得到贵人相助呢？

首先你要有平均线以上的能力，这是别人给你机会的基础。一个团队中什么样的人会得到提拔呢？不一定是能力最好的人，但肯定不是能力最差的人。

其次，你要靠谱，这个品质非常重要，甚至比能力还重要。对一个领导来说，“可预期” 这件事非常重要，能力最好的人未必是可预期的，他可能心高气傲，受不了委屈随时撂挑子不干。如果你能做到 “凡事有交代，件件有着落，事事有回音”，成为领导心目中靠谱的人，那么领导就更有可能成为帮助你的贵人。

第三，你要真诚，懂得感恩（起码要表现的如此），因为没有人愿意帮助一个白眼狼。

除此以外，还有一种人必然会得到贵人相助，那就是真正的 “人中龙凤”，如果你惊才绝艳，才华突破天际，里里外外都表现出 “非池中物” 的品质，别人知道你迟早要出头，打压你也无济于事，就会给你提供帮助，提前在你这里攒下人情。

比如拼夕夕的创始人黄峥。在浙大期间黄峥就表现出了极客的品质，他热衷在网上发布技术文章，是学校的风云人物。网易的创始人丁磊有次遇到一个技术难题，在网上看到了黄峥的文章，于是联系到黄峥，在他的帮助下顺利解决了问题。丁磊非常希望黄峥能够加入网易，但是当时黄峥正要去美国留学，丁磊便介绍黄峥给退休在美国做投资的步步高创始人段永平认识，两人很快成为忘年之交。

段永平是黄峥重要的人生导师和贵人。黄峥在美国硕士毕业以后获得两个 offer，一个来自科技巨头微软，一个来自创立不久但发展迅速的谷歌。段永平建议他去当时规模还不大的谷歌。后来谷歌上市，黄峥持有的期权立刻让他实现财务自由。在谷歌工作两年后，黄峥回国创业，段永平又成为了他的投资人。

像黄峥这样的人万中无一，对于普通人来说，把自己修炼到具备水平以上的能力，并展现自己的靠谱和真诚，是获得贵人帮助的最好方式。

「2024 年终总结」世界指向任何我想去的地方

Fri, 10 Jan 2025 00:00:00 GMT

我总是习惯在跨年的时节，去回望过去的人生旅途，在无数次相遇和离别中，找回内心的平静。

今年真的要过去了，我始终觉得元旦不算新年，但真等到了除夕，又似乎和平时没有什么区别。2024 年仿佛一直都在路上，一直都在疲于奔命，社会节奏本就匆忙，互联网更是。为生活奔波的时候，没精力和大爷聊天，也没心情抬头看朝霞日落，连电梯上升的加速度都压得人腿软。

我总是期待着也祈祷着自己在路上，哪怕是周末了，我也希望自己可以从头忙到尾，兼顾学业、家庭、朋友，找时间读一本好书，听一场音乐会，看一场电影。似乎什么好事我都不愿意错过，好像身在一家自助餐厅，每样菜都很好吃，我都想尝试。我也确实很喜欢吃自助，但其实很快就吃饱了，已经不再是当年了。

对我个人来说，没有任何一件事情，像生病和生病造成的影响让我成熟得更快，它明确指出生命中到底什么最重要，我或许现在还没有找到，但一定不是屏幕上冗长的代码和无用的八股。

我最初写年终总结的初衷，仅仅是为了如果有一天 remake 了，能在互联网多留一些痕迹，所以当阅读人数从几十人到几万人，我就会很开心，这意味着世界上又多了一些看到了我痕迹的人。我写的这种不算小说，所以我写的很慢，一个作者哪能写尽世上的所有人呢，写来写去，写的还是自己和自己身边的人，无论孤独还是野心，都是自己人生某个侧面的写照，这是我的局限与浅薄，但也是我的真诚。

#01 我的学生时代

春节那几天恰逢初高中学校的校友日，顺便约上朋友和老师一起回去看看，那六年的时间还历历在目。

我在高中的时候有人嫉妒我，我想大概是因为和哪个女生传过绯闻，被当成了情敌，我在本科的时候有人嫉妒我，我想是因为我当年是个卷王，对于卷王，大多数人都是恨得咬牙切齿然后一边痛骂一边怨恨为什么这个人不是自己，特别是人前显圣的时候，因为我也在心里骂过那个台上的卷王，这俩我都能理解。我不理解的是，怎么读了研究生，仍然会有人嫉妒我，嫉妒这样的一个卷了好些年后的衰仔。

有次看到个热搜是，一百万回到高三，问你愿不愿意，我其实挺想去的，可惜没钱，后来看了评论区才发现，原来是给我一百万。

图 1～图 3 分别是：小学、初中、高中

替我的化学老师带孩子哈哈哈，非常可爱

说实话我并不知道我为什么会疯狂的怀念学生时代，有时候一个画面，一段音乐，都可以勾起思绪，惆怅得不行，听说人喜欢怀旧是因为现实里过得并不好，我也不知道这是不是对的。那天我坐在曾经我们下课后聚众闲聊的走道边，脑海一路开始回想过去读书的日子，那时候阳光不是很大，暖暖的，温和的照在眼前，隔着树叶斑驳的影子在墙上晃动。也许我生来就是比较喜欢念旧的，不管过去有多好多差，总会去怀念那一段青涩的日子。怀念那个 12 人间的老旧寝室，晚上此起彼伏的鼾声；怀念偷偷看着喜欢的女孩子，然后她也会偶尔回头看自己一眼；怀念留下来默默的打扫卫生，然后听着广播里的不知名歌曲；怀念在图书馆用 MP3 听周杰伦的歌；怀念那条通往教学楼和寝室的小路；怀念那家经常去的奶茶店；怀念那辆通往学校的公交车...

在十七八岁或者更早的某天，我们像无数个往常一样和朋友说再见，很多年之后才意识到那是最后一见，却连那天的天气都记不起来了。相比之下，能认真告别就已经足够幸运了。

那天我拍了很多照片存手机里，好像这样就能留住我的学生时代一样。

可是人是会变的，大家都走了，没有人留在原地，我只是往过去多看了几眼。

很多年后，我还是会想起高考后的那个盛夏，大学，军训，正午，不知道哪里来的马蜂嗡嗡的穿过迷彩服的人群，人群快速的散开又聚合，在阴凉地看着未来的舍友和同学军训，呆呆的幻想着美好的大学生活。这时候还没有计算机，没有 Java，没有绩点，没有保研，也没有什么实习，什么秋招，什么天南海北的漂泊，聚散离合。

看到那些曾与我度过美好时光的人都已渐渐淡出我的人生时，我的心情 be like：🥺

#02 白日梦想家

分享一些我在 2024 年看过的文学作品，不限文体。

我们活在这样复杂的世界里，被其中如同圆周率一样从不重复也亳无规则的事情拉扯着，朝世界尽头盲目地跋涉而去。我们就是这样生活在如同圆周率般复杂而变化莫测的世界里，慢慢地度过了自己的人生，而文学把生命剥出新的层次，让人看见新的可能。它让我获得日常琐碎中感受不到的快乐，甚至是痛苦，但每感受一次，我就多活了一次。时间多珍贵啊，能多活一次，就要多活一次。活着，认真笃定地生活，要清醒，要思考，而不是长久地单薄地发笑。

0x01. 世界只有一个真相

黑塞的《悉达多》尽了最大的努力来缓解我们人生的空虚感，尤其是当你一无所有的时候，你依然可以拥有欲望和目标。

世界只有一个真相：原来我期待的圆满的人生，不会到来，换句话说，每一个当下就是圆满。所谓的我，就是过去一切体验的总和。我是我接触过的人、碰到过的物、感受过的情爱、迷失过的痛苦。所有的一切，才有此刻的我，少一点都不是。

我听便灵魂与肉体的安排，去经历罪孽，追逐肉欲和财富，去贪慕虚荣，以陷入最羞耻的绝望，以学会放弃挣扎，学会热爱世界。我不再将这个世界与我所期待的，塑造的圆满世界比照，而是接受这个世界，爱它，属于它。

0x02. 你想活出怎样的人生

四月份，和朋友一同去看了宫崎骏这部收官之作《你想活出怎样的人生》，是日本作家吉野源三郎的著作《你想活出怎样的人生》的同名电影。

在虚无主义无孔不入的时代，清醒观察思考，努力认真生活，无论时代如何困难、残酷，请始终作为一个“人”而活着 —— 也许这就是 83 岁的宫崎骏与内心的矛盾与伤痛纠葛一生后，想要告诉大家的活法。

0x03. 死亡不是终点，遗忘才是

强烈建议大家都去看看《寻梦环游记》，一部具有带有亡灵色彩与死亡教育的动画片。

人的一生，要死去三次：

第一次，当你的心跳停止，呼吸消逝，你在生物学上被宣告了死亡。
第二次，当你下葬，人们穿着黑衣出席你的葬礼，他们宣告，你在这个社会上不复存在，你悄然离去。
第三次，是这个世界上最后一个记得你的人，把你忘记。

这部电影不只是教会了我们应该如何在亲情与梦想之间做选择、如何去面对死亡，它更是一堂教育课，教会了我们如何成长，让我们明白活着的意义。我们是人类的一分子，而人类是充满激情的。医学、法律、商业、科技，这些都是崇高的追求，足以支撑人的一生。但音乐、诗歌、梦想、情感，这些才是我们活着的意义。

0x04. 自由，就是拥有被讨厌的勇气

《被讨厌的勇气》一书中的阿德勒心理学其实就是个体心理学，把人当作一个独立的个体，也就是所谓的课题分离。我们要清楚的知道哪些是自己的课题，哪些是别人的课题，没必要为别人的期待而活，珍惜更多当下的时刻，去体验更多的事物，相见什么人就去见，去认识，去告别，做好自己的课题，被别人讨厌也没关系。人生是不断与理想的自己进行比较，不要把人生理解为一条线，而要理解成点的连续。人生就像是在每一个瞬间不停旋转起舞的连续的刹那。暮然四顾时常常会惊觉：已经来到这里了吗？

在人际关系中面对困难时，应该先考虑 “倾听更大共同体的声音”，阿德勒用了一个更容易理解的比喻，当下的痛楚，如果比作杯中的风暴，那你应该跳出杯子，在太平洋这阵风暴完全不值一提，如果此刻难过，就用更宏大的视角去看待现在的困境。在读万卷书行万里路的过程中，找到更大的世界，去稀释当下的痛苦，当世界的分母变得足够大，痛苦的分子就无关紧要了。

0x05. 巴音布鲁克没有海

属实没想到《飞驰人生》还有续集，不管是第一部还是第二部，都给了我极佳的视觉震撼和观感体验。

影片中最击中我内心的一段对话：

"我们努力了就一定有机会"

"不是的，我努力过无数次了，但我明白，机会只存在于其中的一两次"

巴音布鲁克没有海，只有无尽的热爱，把你的全部奉献给你所热爱的一切。

0x06. 花束般的恋爱

不得不说，这部电影拍得很细腻，我在看的时候已经把我自己完全带入这个男主，我的心情随着麦跌宕起伏，体会到了学生时代恋爱的青涩，也感受到了成年后的爱情和生活多么不容易。

我也懂得了人生重要的一课：不要挽留所有要离开的人。你应该优先考虑你的神经系统，当远离某人可以让你的精神放松下来，给你带来平静时，你就知道是时候放弃这段关系了。

0x07. 等待戈多

《等待戈多》是爱尔兰现代主义剧作家塞缪尔·贝克特的两幕悲喜剧，1953 年首演。这是一个关于等待的故事，人生中那些名为等待的消磨，那些名为绝望的希望。戈多是你打不通的电话，是公交站未到的公车，是明天，是时间，是你现实生活中所有不可期的一切。

人生就是一场漫无目的的等待，生活是一个希望渺茫的困局，人是自己的救世主，等待戈多就是等待自己。

虚无的人生，荒诞的世界，每个人都在等待戈多。

#03 寻找人生的 25 号底片

中学的时候喜欢看意林之类的杂志，里面的作者用乱七八糟的理由跑去旅游，然后说 “阻碍你脚步的永远只有逃离的勇气和对生活的热爱”。

我觉得太对了，可惜 12306 付款方式里没有勇气和热爱，不知道是不是下了盗版。

Jan. 泉州

年初和小伙伴们从厦门打车去泉州玩了一遭，刚好碰到大师在免费写春联，排了一晚上终于拿到了哈哈哈

晚上租了一个四人麻将房，锋哥（大师兄）的胜率高达 90%+，被虐惨了

有我这个地道的泉州人带路，狠狠地逛了西街、关岳庙、五店市，后面还深度体验了下蟳埔村的簪花（指偷拍🫤

清源山

May. 漳州

五一：南靖土楼 + 长汀古城

Jun. 杭州

六月，实验室一起去杭州开会，也算故地重游了。

参加学术会议最深的感受就是：全场四五个小时表现最具专业性的是摄影师。

除了开会，还抽空去灵隐寺、京杭大运河、西湖等各地游玩，体验了人生第一次剧本杀。此外还参观了浙大玉泉校区，和浙大的某实验室深入交流了一番，收获挺多的。

Jun. 西安

六月底前往西安 · OPPO 公司结项，开启了长达两个月的实习。

记录人生第一次坐飞机 ✈️

西安不愧是「碳水之都」

夕阳无限好

公司的健身房有点小，但是挺赞的，因为基本只有我在用

实习期间看到个帖子，说 xx 公司自己一入职就给自己花了 5w：笔记本 + 显示屏 + 一堆软件。下面有老哥锐评，你怎么不说公司还替你建了好几个亿的写字楼，非常真实。在 OPPO 实习的这段时间，只能用公司的电脑，而公司内电脑权限很小，你甚至不能下 QQ 和微信，也不能访问公网云盘，有时候觉得，不是给人配了个电脑，而是给电脑配了个人，人走了是耗材，电脑回到公司循环使用。

我之前一直用的 Windows，后来转向了 Mac，有朋友问我，Windows 和 Mac 怎么选，这个问题很难回答，就像大一暑期的时候问我 C++ 和 Java 这两门课应该怎么选择一样。之前觉得，用 Windows 让我还记得我是个学生，记得大一开学刚买第一个笔记本时的激动，而 Mac 给我的回忆只有极强的续航和轻便，以便我在不同的会议室奔波。

这两个月除了开不完的会议以及赶不完的进度，还投了一篇论文，好在是中了，会议需要作者 12 月到武汉开会，可惜我导不给报销，推掉了。

会议邀请函

奇險天下第一山 · 華山

落花时节又逢君 · 西安交大

Jul. 成都

七月去成都找师兄玩！虽说刚毕业 1 个月，但还是迫不及待来见一面～

这三天自驾游去「川西 · 毕棚沟」游玩，在成都街头走走，到熊猫谷看看国宝 🐼

成都美食真的顶哇！

在成都的最后一天，恰逢附近有梵高展！

Jul. 银川

抓住七月的尾巴，自己一人前往银川三天，其中一天跟了一个小团一日游：中卫 + 沙坡头 + 腾格里沙漠 + 66 号公路。

银川即是 “归雁入胡天” 的古来边关，更是 “大漠孤烟直” 的具像化，览山公园的风景让我着迷，我走过沙漠，骑骆驼 🐫，吹过旷野的风，这种无拘无束，自由掌握人生的感觉真美好。

生活的底片从来不是遥远的白日梦，而是热爱生活的自己。

Oct. 福州

国庆节回了一趟福州，见了许久未见的朋友，每一刻都弥足珍贵。

约了本科两位亦师亦友的教授闲聊

感谢好朋友们的热情款待，顺带蹭了俩老师一顿饭哈哈哈

同时郑重的感谢我的好朋友思萍，来福州这段时间麻烦她不少

这次从福州回来，买了一等票，我之前觉得坐一等座是很不划算的行为，直到这时候我才明白，人为什么会去坐一等座，很简单：高铁上坐商务座的是有钱的，坐二等座是有票的，所以坐一等座的是没票而且没钱的。

每每返回福州，总会感伤和怀念那段时光和同学们。有一些东西要靠消失才能证明它的珍贵，如果这是无法返航的日子，那我祝你们一路向前，桥都坚固，隧道都光明，如果不能，那就祝你们曾经的理想能足够支撑当下的生活，等到未来偶然的一天回到这里，再聚的时候，我们能轻轻释怀所有的冷雨，微笑着轻描淡写地说：不过些许风霜罢了。

Oct. 东山岛

计划了几月之久的东山岛旅游，工作日的短暂逃离💨

说好的一起看日出呢，就我醒了

Nov. 广州

又是参会的一周，做不了学术大佬，就做学术蝗虫！

CCF China Storage'2024｜又见程老师！

📷

广式早茶

#04 被审判的二十余岁人生

我总觉得，学生时代在大四那年就已经结束了，读研只是一场用来对前四年脱敏的短暂回光返照。每一根网线都在传递着焦虑的信息，只能靠逃避来抵制对未来的恐惧和怀疑。

有一次学长和我闲聊，问我最近学习怎样，我说我没学。他斟酌着措辞跟我隐晦的暗示：“额，有空闲时间不学习我会有内疚感的，你没有吗？”

我沉默了一会，然后不得不痛苦的承认了一个事实，是的，这可能就是我现阶段痛苦的根源。原来我傲慢的讨厌这讨厌那，讨厌世界，讨厌你们，我最讨厌的是我自己，那个傲慢又懒惰的自己。最痛苦莫过于清醒的摆烂。呵，不过话说回来，都是二十来岁，谁还没点儿理想啊。海边绚烂的烟花，路上美丽的夕阳，湖面晴朗的天空，益海楼前火烧的晚霞，落日，晚风，鲜花。这些浪漫与美好毋庸置疑装点了我的青春，但绝不能够成为我青春的全部意义，我要的是热血万丈，我要去的是英雄梦想，我要看的是天地奇观，我要拼尽全力拿到众望所归的成就，大大松一口气地听着别人的称赞，然后再谦虚的说，运气好而已。

有时候，我也会为一些无用的事情落泪，理想主义者的无畏坚持，改革者的魄力，权衡利弊者的仗义直言，已知悲剧结局的少年志气，或者仅仅是次元有壁。无病呻吟久了，有朝一日真得病了，我才突然发现，那些所谓挫折好像也就那么回事，太阳底下没有新鲜事。不过好像真到了需要验证某个成果的年纪了，生活热衷于打断理想主义者的脊梁，但永远有人撞破阻碍着理想主义者的屏障，也永远有人是理想主义者。看到被迫 gap 的同龄人困境，听到别人对他们或怜悯或嗤笑的高高在上的评价，我根本没办法庆幸自己逃过一劫。气愤和痛苦，夹杂着铺天盖地的焦虑将我包围，不是作壁上观，实属无奈，谁都一样。走在向上的钢丝上，越往上走，一旦踩空只会坠落得更加难看，泻水置平地，各自东西南北流。人们以为自己在追求幸福，但向下的自由不是自由，人类区别于一支芦苇，正是在于思维流动的光辉。

这一年，过得自信心全无，读研就像是某种无形的寄生虫，对人的侵蚀是无声无息、不温不火的，每天都透支一点点，一年后就消耗掉你所有的热情和活力。这一年我也终于理解了为什么工作的人越来越少发朋友圈，真的上纲上线倒也没有，但以前发是坦坦荡荡的分享快乐，现在发是如履薄冰，感觉像是在吸引炮火，真的丧失了很大一部分的自由。我也开始理解为什么有人会沉溺酒精、尼古丁、短视频，因为日子过到一定程度，有时候真的需要一点麻醉剂来饮鸩止渴。也许这时候有人又会说：年轻人就是吃不了苦、无病呻吟。辛苦就是辛苦，各有各的辛苦，并不是不如某某辛苦，就没有资格说出来。自嘲是为了不麻木，重视自己的感受。这一代的年轻人并非软弱，即使说了这么多丧气话，大家也一直在努力生活。只不过满腹牢骚者也可以把工作干得很好，胆怯者也可以颤颤巍巍的成为英雄。我开始意识到，解构才是对个体的真正尊重，人生无数次阅历的积攒，就只为在某个重要的时刻给予我们面对的勇气。

无所谓，每个人都有自己的南墙要撞！

这一年，看着身边二十啷当岁的朋友。有的啤酒肚了，头发开始掉了，被女孩甩了。如果问我，生活会不会将当初的少年打趴，我不知道，但生活一定会将当初的少年打散。再聚首，再问起当年的少年意气，多数人都会不好意思地笑笑，然后说，那时候不懂事。而喝多的时候，就全成了让自己觉得矫情的眼泪。往往这个时候，我想不出来什么安慰的话。我确实没有什么话想讲，只觉得胸口像是春夏的雷雨天前那样发闷。人的心态会经历很多个奇妙的转变，这种转变甚至都不需要什么道理和铺垫，就好像你本来好好地在路上走着，然后一下子和路边的陌生人一起举着手，大声欢呼或者低着头默哀一样。

我们终于活到了小时候最羡慕的年纪，却没有成为小时候最想成为的人。毕业之后的我们都在害怕自己没出息，害怕自己买不起房子车子，遇不到喜欢自己的人，每次过年回家面对什么时候结婚，什么时候要孩子这种话题，其实更害怕的是面对许久不见的父母。我们都是普通的孩子，我们都想让自己的爸爸妈妈更自豪一些，更幸福一些。可我们自己的幸福都还像个石子，在生活的湖面上打着水漂。这么多年上学上过来，努力地学习，考试，可到最后才发现，普通的孩子只是聚光灯下的基石。想想这些年，我有很多以为近在咫尺的时候，我努力地抓啊抓，可就是什么都抓不到。再多的书也比不上导师满意的 PPT 和恰到好处的谄媚。我一边和自己的妈妈保证说，以后我一定会有出息的，一边成晚成晚的睡不着觉。这样的场景太多了，多到我觉得每一场跌宕起伏的人生经历总是会有个这样毫不意外的结局。

爬到山顶的时候，跑向海边的时候，以为我不再是我的时候。

我总以为山顶的石头不一样，升起的太阳不一样。

我总以为海边吹的风不一样，尽头的那边不一样。

我以为我不再是我，我爱她，她也爱我。

可惜，山还是山，海还是海。

我拥有很多人情绪崩溃的瞬间，他们有的在我身边，有的靠互联网奇缘。我没有和其中的任何一个人有过合照，有一起吃过一顿饭，没有听到过他们的声音，也没有听太多他们的故事。我只是短暂地让他们靠了一下岸。

而当生活的节奏反复无常，日历上的时间不断反转，我总是会在人生的重要时刻丧失无穷无尽的仪式感。我常觉得所有人都是被上了锁的自由花，偶尔被阳光照耀的时候会觉得自己配的上很多东西。像是野马找到了河边的水，牵牛爬上了缺角的屋檐。我很难分辨压在自己身上的到底是挡住眼睛的石头，还是粘住了后背的五指山。任何一种喘不过来气的定义都被他人掌控，我带着面罩，别人掐着氧气管。等到自己坚持不住的那一刻，很难说是呼吸的缺失，还是自己早就病入膏肓。

好多事情想不明白，只能先活着，看以后能不能想明白了。

人人都得活着，所以人人都得藏着。我偶尔就在这样沉默的冰河之下，悄悄探出头来，感受下有温度的太阳。然后再沉下去，告诉别人海面之上的故事。

#05 人生南北多歧路

网上冲浪看到一个很有意思的话题：人一辈子，最重要的到底是什么？

原回答如下，感触颇深

三岁那年，我紧握着手中的棒棒糖，坚定的认为那最重要。

五岁那年，我花了整整一个下午，逮住那只蜻蜓，那一刻，它好像是最重要的。

七岁那年，我看着同桌手中的奖状，带着羡慕和一点点嫉妒，觉得那也许是最重要的。

九岁那年，仰躺在树荫下，阳光斑驳的洒在脸上，一个悠闲的暑假于我而言是如此重要。

十三岁那年，我意识到，重点高中的录取通知书对我的人生很重要。

十六岁那年，坐在教室里，微风穿堂，盯着前排姑娘的马尾出了神，忽然觉得就这样一直下去也不错。

十八岁那年，我日夜苦读，求神拜佛，只为一张大学录取通知书。

二十二岁那年，告别校园，懵懂的踏进所谓社会，一份工作又成了最重要的。

二十四岁那年，迎来了我的婚礼，我看着满堂宾客和我的新娘，她当然不是我十六岁时的那个姑娘，心中只觉得有些遗憾，不过那一刻，我的新娘就成为了我最重要的人。

二十五岁那年，我和狐朋狗友推杯换盏，吹牛打屁，不谙世事的年纪，只觉得面子最重要。

二十六岁那年，我焦急的等在产房外，啼哭声打破了宁静，我知道，更重要的来了。

三十三岁那年，被房贷和车贷搞的焦头烂额的我觉得，钱可太重要了。

三十八岁那年，一生强硬的爸爸开始征求我的意见，那一刻我猛然意识到，他终于是老了。

还是三十八岁那年，妈妈再没有训斥过我，而是不厌其烦的念叨，还带着些小心翼翼，我知道，她也会老的。

又是三十八岁那年，儿子不再黏我，他有了自己的伙伴的生活，我知道，此后的一辈子，他只会不停的远离我。

那年，我恍然，可能时光才是这世上最重要的吧。

四十岁那年，看着乱七八糟的体检报告，我才想起，我从来没觉得自己重要。

四十五岁那年，浑浑噩噩度过了半生，挺着啤酒肚在工位摸鱼的时候，回想起年少的梦想，从未觉得梦想如此重要。

五十岁那年，看着儿子和一个还不错的姑娘步入婚姻殿堂，我眯着眼看着台上的儿子，不知道新娘是不是他十六岁时爱上的那个姑娘。但还是觉得儿子的幸福比我的幸福更重要。

五十五岁那年，我气喘吁吁的跟在孙子屁股后面，生怕他摔跤，那一刻，我从未给予孙子远大的希冀，他平安快乐便是最重要的。

六十岁那年，我将父母葬在了一起，年纪大了，很多事也便看开了许多，我没有流泪，只觉得，爸爸的责骂和母亲的絮叨在那一刻无比重要。

七十岁那年，妻子终是先走一步，儿子儿媳事业有成，孙子在外地读大学，我只能无所事事的在大街上闲逛，莫名觉得，妻子可比那广场舞的老太太重要的多。

七十五岁那年，在医院里，医生让我出去，单独留下我儿子的时候，我明白时间不多了，趁着这功夫我给孙子打了个电话，我想告诉他，如果你在十六岁的时候爱上过一个姑娘，可千万要握紧，就像握紧三岁那年手中的棒棒糖。思来想去，又觉得多少有些为老不尊，电话接通后，只说了一句爷爷想你了，有空来看看我。医生宽慰我问题不大，我笑着告诉医生，人生没有大问题，其实把日子过下去是最重要的。

七十六岁那年，孙子回来看我了，让他看到我奄奄一息的样子心里多少还有点别扭，儿子儿媳守在床边，泣不成声，我没有多余的精力思考什么最重要了，我只想着后事从简，儿子儿媳年纪也不小了，身体遭不住，孙子刚刚参加工作不久，请假不好请，别给领导留下坏印象。

正想着，不知哪里吹来一阵风，迷了我的眼，睁开眼，爸爸妈妈牵着手，脸上挂着我最熟悉的笑容，他们都是年轻的样子，张开双臂示意我抱抱，我好想他们啊，所以我毫不犹豫跳下床，向他们飞奔而去，奔跑中，我变成了六十岁的样子，五十岁的样子，四十岁的样子，三十岁的样子，直到变成三岁的样子，他们终于又能抱起我了，我向他们点点头，他们也笑着点头，带着我转身离开。我回望一眼儿子儿媳和孙子，他们抱着七十六岁的我，嚎啕大哭，虽然不舍，不过没关系，我知道他们依然可以过的很好。

所以，什么最重要？什么都重要，但又不是非有不可。初中的亲戚小孩问我寒假作业不写有什么后果吗。我说有的，比如你会拥有一个没有作业的寒假。当然，你也会失去一些什么，比如寒假作业。

你曾经认为最重要的，总有失去的那天。

时间改变了太多东西了。

遗憾才是人生的常态。

年少的标志之一，就是对人生的旷野感到恐惧。

这不稀奇，当然也不值得去忧虑，因为它来源于一种与现实之间轻飘飘的，遥远的疏离。

我完全无法想象当我的生命趋于麻木，当我困守在一间窄窄的房子里，开始为钱发起了愁，为生计开始了奔波，那是怎样一副光景。

而这样的一生到底有什么意义呢。

不要恐惧，不要害怕你的自由和浪漫会失去。

我说了人生就如同一片旷野，当那漫长且潮湿的雨季来临以后，你就会发现浅小的水洼成为了汪洋，萤火虫成了海上的月亮，蝉也化作挥动着翅膀的鲸。

去赋予生活意义，也赋予生活爱和有趣。

一个人思虑太多，就会失去做人的乐趣，一直往前走吧，会有你想要的答案的。

年轻嘛，未妨惆怅是清狂，但我知道，人不能永远过着打球、唱歌、夜宵这样放纵的日子，一方面，岁月无情，另一方面，美丽的东西往往也太过单薄，成为一个好的人就是要有一种对于世界的开放性、一种信任自己难以控制的无常事物的能力... 这种生活的根基就在于愿意被暴露在世界中，就在于更像一株植物，而不是一颗宝石。

现代人格外接受不了不确定性，于是热衷于相信存在一套稳定的秩序，费尽千辛万苦地找一个尽可能高的位置把自己放进去，高塔当然辉煌，高的位置当然可以很好的安放一个人，可是转头看，凡有日月星辰照耀之地，又何处不可寄此一生？天地广阔，四季春秋，等年华老去，明天的我们也许会去找一些更厚重的东西来承担更长久的人生，比如去祖国的宏大叙事里做一枚齿轮，不管你信不信，朋友，对于齿轮来说，运转不是致命的，生锈才是。

所以，困住你脚步的到底是什么？

我的意思是，当你意识到生命只有一次的时候，你的第二次生命就开始了。

#06 这江湖没什么好的，也就酒还行

似乎本科时候也没那么难熬，可能是因为当时在乎的人都在身边吧，我是个贼念旧的人，这点其实不好，也不适合互联网。

2019 年以前腾讯放弃了电商，默认了自己没有电商基因、京东在 3C 电子做着防守、字节跳动正准备发布一款叫 “抖音” 的音乐社交软件、那家叫拼多多的初创公司还在农村里乱转，卖点可怜的水果拼团生意，那会的耀子还和华子绑在一起，大家还觉得是个低端品牌，至于比亚迪，绝大多数人连简历都不曾投递过，当然，从 2020 年开始一切都变了。

正如公司所信仰的拥抱变化一样，其实我们也拥抱了不少变化，比如还没出生的时候就遇到了计划生育，刚出生赶上了非典，到了喝奶粉的年纪遇到了三鹿毒奶粉，没安分几年又来了多种版本的禽流感，小学爱吃校门口大锅炸的辣条，后来发现用的全是地沟油，玩游戏的时候赶上了防沉迷，好不容易混进大学被疫情封了三年，毕业了发现大学生比狗都多，想吃外卖了到了发现是国潮包装。

我们这一代人绝大多数都看过考试周破防，对我来说是大二的暑期，我喜欢去买一瓶热带风味冰红茶，这是我本科过得最开心的一个暑假之一了，下学期的课很少很少，然后要保研啦，保研去哪里不知道呢，反正有很多很多的可能性，我到时候一定要选一个喜欢的学校，喜欢的城市，冰红茶的瓶盖上有时会写着再来一瓶，我总是不着急兑换，因为觉得来日方长，未来有一天我收拾东西提桶跑路的时候发现了当年的瓶盖，才意识到好像我的青春只剩下了谢谢惠顾。

忘了在哪里看到的鸡汤：“不要谩骂以前的自己，TA 当时一个人站在雾里也很迷茫”。

但我从不骂，因为我他丫的现在还在雾里。

政治老师曾说过：“这个选项没有错，只是它不符合题意”，我想，在这个时代，我们也是。

我一直是个很悲观的人，也没什么安全感，我走在一直变强的路上，我现在有能力屏蔽掉许多坎坷，但终有一天，我会遇到迈不过去的门槛，压抑不了的负面情绪。我始终会想，这时候，谁还会在我身边，我希望大家都在，但这个显然太过天真了，我现在给不出答案，但其实与人的每一次相遇我都在想，TA 会怎么做。我厌恶欺骗，相对于欺骗别人，我更厌恶被别人欺骗。所以我是个很慢热的人，我的很多值得交心的朋友，在我决定敞开心扉的时候，早就不在我身边了。

在此声明一下哥们不是回避型人格，哥们是逃难型人格，每次感觉到别人一丁点冷落，哥们都会屁滚尿流地收拾包袱跑路。

我这人从很小的时候就争强好胜，我一直以为是我自己赢了，直到有一天看着镜子，才知道自己输了。在我最美好的时候，我最在意的人都不在我身边。从认识我到对我失望，到底需要多长时间，我每认识一个朋友，就会在心里想一遍这个问题。如果几年前你问我会不会害怕失去而逃避未来的相遇，我会回答是的，但现在不会是。因为我已经失去过很多了，不再差这点了。

以我的能力和意志力，永远不会迎来把过往的错误和懊悔全部弥补的那一天，但以我的记忆力和心态，一定有毫无内疚把他们全部抛之脑后的那一天。人的烦恼就是记性太好，如果可以把所有事都忘掉，以后每一天都是个新开始，你说多好。因为我总是很擅长把一个可以花精力解决的问题，变成一个需要时间接受的事实。

学计算机的总有种错觉，仿佛自己穷举出所有的可能性，然后选取一个不会太差的决定，也有时会觉得，很多事靠卷或是努力可以解决，这几年发现并不是。朋友问我的人生是贪心还是动态规划，我说我只会暴力，但我很喜欢 KMP 算法：一个人能走多远不取决于在顺境中能走多快，而在于他在逆境中能否找到曾经的自己。

有时候会觉得，命运不公平。人和人是不一样的，有的人生下来就和开了挂一样，有钱开朗，家庭温馨，一路上会遇到很多有趣的人，很多朋友，老了跟人吹牛都有很多故事可讲，成为别人眼中酷酷的老头或者老婆婆，对这样的人来说，每件往事都很珍贵，但也都没那么珍贵，就像她可能会在意这周的演唱会，会激动的好几天睡不着抢票，做规划，要是抢不到也没有什么大不了，她可以飞到另一个城市去看下周的演唱会，但有些人不一样，他们一辈子就呆在一片很小很小的地方，一共认识不了几个人，没有几个人会真正在乎他，也没有几件他真正在乎的事。

有时候又会觉得，命运挺公平，至少过程，是独一无二的，是有开心的时刻的。

我始终觉得，人非草木，人活一世，更多的只是活几个瞬间。

反正这个世界挺没意思的，要是没了我那几个朋友，就更没意思了。

我很重感情，这是优点也是弱点。

我由衷感谢那些还陪在我身边的朋友们。

于道各努力，千里自同风！

还有许多朋友遗失了合照和相片，找了一晚上实在没找到 😭

#07 UNICEF｜联合国儿童基金会

这一年，也可以尽自己所能做一些慈善活动，为什么会有这个想法呢。我想借用中科院黄国平博士的一段话：人情冷暖，生离死别，固然让人痛苦与无奈，而贫穷则可能让人失去希望。我的理想不伟大，只愿年过半百，归来仍是少年，希望还有机会重新认识这个世界，不辜负这一生吃过的苦。最后如果还能做出点让别人生活更美好的事，那这辈子就赚了。

大爱壁纸

#08 超级全满贯｜Fan Z.D.

从小学一年级我就开始打乒乓球了，打了 12 年的球，至今已经二十余年的间隔了。

今年奖励自己新买了一副乒乓球拍，作为球迷也见证了樊振东的夺冠之路，心满意足。

奥运会男单那两场比赛我已经看了无数次，但是我还是会选择点进来：

我非常喜欢的几位乒乓球运动员：

张继科：抢班夺朝，这么多年只有张继科一人做到了，真正意义上的天赋型选手
马龙：GOAT 无需多言
樊振东：16 岁横空出世，天降紫薇星，17 岁成为男乒史上最年轻世界冠军，三剑客时代后我唯一爱看的选手

简单介绍下东哥的职业生涯

2013 年樊振东横空出世，在队内选拔赛中原本并没有获得参赛资格，而是赛后教练组动用机动名额给了樊振东，这才让他第一次参加巴黎世乒赛，但是在第三轮比赛中就输给了张继科，此时樊振东年仅 16 岁。

2015 年樊振东再次参赛，成功打进苏州世乒赛半决赛，尽管此刻的他技术进步明显，但遇到了巅峰发胶龙，还是被 4 : 1 带走，止步半决赛。

之后樊振东又打进世界杯决赛与马龙会师，没想到被马龙横扫夺冠。

2016 年里约奥运会樊振东当时世界排名第二，却最终以 P 卡参赛，那一年是龙队横扫张继科夺冠，划时代的决赛。

2016 年樊振东成功打进世界杯决赛，并且以 4 : 1 的大比分战胜许昕，夺得首个三大赛男子单打冠军。

2017 年杜塞尔多夫世乒赛，樊振东首次打入决赛，但是以两分之差遗憾输给龙队，赛后也成为了他的意难平。

2018 年世界杯在马龙出局的情况下，樊振东顶住压力战胜波尔再夺世界杯冠军。

2019 年布达佩斯世乒赛，此时樊振东世界排名第一，却爆冷输给梁靖崑。

2019 年成都世界杯，马龙意外被张本智和打败无缘决赛，而后樊振东在主场战胜了张本智和蝉联冠军。

2020 年世界杯决赛，樊振东时隔五年决赛再遇马龙，决胜局以两分之差险胜马龙成为世界杯四冠王！

2021 年东京奥运会男单决赛，樊振东首次奥运单打便以 4 : 2 的比分遗憾输给马龙摘银。

2021 年休斯顿世乒赛樊振东再一次打进决赛，这也是罕见的决赛外战，樊振东不出意外 4 : 0 横扫小莫拿下首个世乒赛冠军。

2023 年德班世乒赛决赛，樊振东战胜王楚钦蝉联世乒赛单打冠军，再一次捧起圣伯莱杯。

2024 年巴黎奥运会，樊振东的 last dance 表明了自己的决心，并成功击败小莫拿下自己生涯的首个奥运单打冠军。

从 13 年看小胖崭露头角，到乒坛 11 年的角逐，他乒乓球生涯的大部分时间，都和巅峰张继科以及巅峰马龙重叠，一拍一拍从三剑客的时代打出自己的时代。三大赛单打拥有四个世界杯冠军，两个世乒赛冠军，一个奥运会冠军，三大赛团体冠军更是数不胜数。

解说口中的樊振东是普通人一生的缩影，其实不是的，他是天才，但是大满贯这条路他走了十一年，但未来不止于此，一个时代的到来，它不会轻易落下帷幕！

Fan Z.D.

#09 2024 东成西就

一年前的我，略带期待地向未来发出诘问，一字一句：“一年后的你，生活有答案了吗？”

人类常常如此，有时候连自己的问题是什么都没弄清楚，就敢执着地去索要答案。

于是我开始复盘，在飞驰的时光里，努力筛选一些拿得出手的成绩。不得不说，每当复盘的时候，数据还是挺能安慰到人的，如非为了申请或吹嘘，我大概很少会主动想起所谓加身的荣誉，这些其实只占珍贵时光中的很少一部分。

GitHub

LeetCode

Apple Music

集满 Jay Chou 所有专辑

Netease Cloud Music

高德地图

知乎

专利

花各有期

手机相册里的 2024

#10 你看，每个人都在闪闪发光

点开了很久没看的朋友圈，当初想的是打着防止被骚扰的理由换账号，实际上是接受不了和身边朋友的落差，很多人去名校读研，或者留学，每个学校都赫赫有名，许多人也都有自己的归宿。

“你看，每个人都在闪闪发光。“

我对自己说。就像烟花一样，我好喜欢烟花，恨不得在每个句子里都上一颗火星，这样整篇文章就看起来熠熠生辉。

我知道，应该接受过去、享受当下、期待未来，

可我永远只会后悔过去、浪费当下、焦虑未来。

我们总是把自己未经历或者已经经历过的时光称作最美好的时光，我突然开始怀疑，其实从来没有哪段时光是美好的，所有时光都是痛苦的，所谓美好，只是大脑编出来的一个美妙幻梦，让我们在尘世间有所寄托。我开始怀疑，会不会所有对过去的怀念，全部来自于不用真的再去经历那些事情，本质上只是旁观者的幸灾乐祸。我想不是的，起码过年放烟花的日子，是实实在在的开心的。不论春晚有多无聊，当主持人的倒数淹没在鞭炮声里，火树银花凌空绽放，整座城市隆隆作响，震颤从天空传到大地，极尽所能地宣告我们又活过一年，捂住耳朵又不舍得错过满天绚烂，仰起头，眼底惊喜和火光交相辉映。

这一年我的心态也转变了不少，以前我总是想着追寻那个所谓的成功，所谓的万事求全，但回过头来你会发现和伙伴一起被现实打得满地找牙的过程，似乎才是最美妙的。我很喜欢我朋友和我说过的一句话，他说巅峰的快乐总是短暂的，你知道人生最美好的感受是什么吗？虚惊一场，对吧！最美好的感觉就在这一张一弛之间。

当你看尽人类所有的历史，悲欢离合，英雄小人，爱恨情仇，都只在这么一颗小小的蓝色星球之上，你会不会有这种感觉，最终我们都会化为尘土，那为什么要做所谓的好事，还有难的事呢？如果这个宇宙的结局是注定、是消亡、是归于死寂，那或许更说明，过程才是最重要的，这是我们能够改变的唯一的事。

2024 年在漫长的折磨中，带着无尽苦涩，终究也是结束了，有人欣喜雀跃，有人遗憾痛悔，更多人在平淡艰巨的日子里，朝着更大的光荣彼岸无声努力着。

如果未来变得更糟，也没关系，我们有的是时间去变成更好的人。

关于离别，是制造羁绊需要承担的掉眼泪的风险。

关于未来，是做该做的事并承担它的事与愿违。

新的一年里，我只希望趁着自己还有劲儿，多笑一笑，百年需笑三万六千场，一日一笑，此生快哉！

今天这个日落真的很完美，我就在此刻为这篇文章画上句号，尽情享受这一刻。

我们明年再见👋