PPD's blog

2025年终总结

Sun, 04 Jan 2026 17:03:13 +0800

跑步

今年跑了一千公里，居然比去年多了一倍，开始我以为因为加入跑团导致跑量大增，看了一下反而之前三月份是跑的最多的。想起来今年从新年第一天以跑20.25公庆祝新年开始，上半年我就比较稳定地保持一周跑三次的节奏。

六月份碰巧遇到了开心纯跑前海队，被热情地邀请加入跑团，然后十月开始的新一届为期四个月的跑团服务组成员，每周三次6点开始的例跑，如果不是当服务组成员，我是不可能坚持这么久的。不过侧面也说明我还是一个很靠谱的人，从来没有临时缺席的情况。

今年也是我跑马最多的年份，参加了四个半马，分别是揭阳、成都温江、长沙、清迈。

爬山

年初我发起了一次带领诺友爬南山的活动，包括我总共6个人，过程挺愉快的。我原本以为没有后续了，没想到 LX 想每个月都爬一次山，于是我们就相互督促，后面又爬了凤凰山、梧桐山、五园联通、马峦山、梅沙尖等等，年底还去挑战了一下三水线（金龟村下撤）。作为一个来深圳八年都没爬过梧桐山的人，这一年居然能爬这么多山，现在还是觉得不可思议，这就是所谓的"一群人走的远"吧！其实组织每月爬山还是有不少挑战的，首先是时间，好几次我都是前一天返回深圳第二天爬山；其次是路线选择，不能选太难的线路，也不能重复。不过后面我发觉到爬山具体爬什么山其实不是最重要的，最重要的是走出家门，走进大自然，感受其中的能量。

阅读

从年初参加了诺言线下读书会开始，我就积极参加了线上打卡挑战活动。看完了15本书，还有2本看不下去不看了。今年卸载了微信读书，改成了看实体书，主是手机对我来说还是干扰太多了，不过这样也养成了出门带书的好习惯。

收获最大的是《深度关系》这本书，武志红老师讲的东西相比国外的心理学书籍更接近国人体质，所以会更有感触。愿我们都有好的自恋和好的关系！

英语

从去年年底开始在 Preply 线上学英语，今年算是学了完整的一年，大概每周一到两节课的样子。可能用"学"这个字不够准确，因为我其实主要是和老师闲聊，并没有课本或者固定的主题，更不是为了考试。在平台上找老师也看运气，上半年的那个老师开始还正常，慢慢不时临时改期，最后直接从平台消失了；后面遇到的我现在的英语老师就很好，很准时也很耐心，而且会用心记下每个学生的情况，这样的聊天感觉像和一个老朋友在聊，不会因为语言不熟练而紧张。

要说一年下来我英语水平提高了吗？我想可能并没有。因为我慢慢意识到靠每周一两节线上课是远远不够的，还是自己平时需要多输入和输出英语内容，而我目前这块并没有做好。但我想收获还是有的，从今年两次出国旅行的经历看来，我对说英语没有那么犯怵了。

旅行

今年去了很多地方，一半是去跑马，有独自出行，有和家人，也有去见朋友。

三月底为了去跑揭阳半马，去了普宁和揭阳，第一次去潮汕地区，感觉还挺有意思的，那边寺庙香火好旺啊

四月中旬先是特种兵似的游了重庆和成都，在重庆特意住了一晚背包十年，继续感受不同地方背包十年的氛围。第二天早上体验了板凳面，晚上和第一份工作认识的如同学般的前同事吃了九宫格微微辣火锅（本来我想选微辣，后面我就老实了~），逛了洪崖洞，

接着又坐高铁去了成都，体验了一下坐在公园喝茶摆龙门阵。最后一天早晨还跑了温江半马，跑道几乎没有爬升，所以让我破了150。跑完就去吃了美食作家王刚开的水煮鱼店，味道还不错，吃完我就立刻会深圳转机去大阪了。

到大阪的第一天见了一个诺友，一个三十加的三娃妈妈，独自在日本求学，实在是太有勇气了，她说她当初日文不会，英语不好，完全靠提前准备好可能会问的问题的英语答案，然后死背下来才通过的申请面试的。晚饭就是在超市买了和牛在她宿舍煎了吃，味道还挺好的，一次特别的吃和牛的体验。第二天去大阪城公园看了樱花，今年相比往年天气冷，所以看到了正在盛开的樱花，真的好美，而且去的早感觉包场的感觉。

晚上去了音乐厅看了鲁叔的演奏，这是我第一次听付费的钢琴演出，现场听的感觉还是挺不一样的，两个小时过的实在太快了，有点不过瘾~

后面又去了京都，京都感觉像个安逸小城，沿着鸭川散步好惬意啊。最后我又临时决定还是去富士山看看，于是立马坐新干线来到山脚下的一个小镇，参照攻略，第二天一大早去了附近的一个公园，不到六点的时候就看到了小镇全貌和远处富士山融为一体的美景，后面去租了自行车环山中湖骑了一圈，看到了在湖中自由徜徉的白天鹅。

结束后我又坐新干线赶回大阪，意外地发现酒店里有免费温泉，于是体验了一下，确实很舒服。

六月底和姐姐去了贵阳和安顺，贵州美食真的好吃又便宜，一个肚子真的吃不下，我还会再来吃的~

国庆上海的大学室友来找我们，先是带带他们在前海逛了逛，后面我们去了在广州的大学室友那里，他们两夫妻加我这个单身狗在广州和佛山自驾游了一番，吃了好多好吃的，看了佛山舞狮，最后还去了长隆动物园。

十月底去跑了一下长沙半马，这次更多是见家乡的同学，当天去了同学家里吃饭，第二天跑完又见了另一个同学。

十一月底去福州见了一个前同事和一个当地的朋友，在福州吃了很多当地美食，最后还提了一箱鱼丸回来。

最后年底去了清迈跑了凌晨四点开始的半马，在青旅认识了很多来gap的朋友，爬了素贴山，还去英语角和两个外国人聊到12点关门。

后面又去曼谷溜达了一下，果然曼谷更热也更城市化，曼谷的公交车窗子直接没有玻璃，开的速度也超快。

工作

今年依旧是远程工作的一年，下半年发现了一个步行15分钟可到的新图书馆，人少环境好，我大多数时间在此办公，周一图书馆不开的时候就去星巴克。

三季度突然要和隔壁组合并，领导开始说有两个人要我带，但实际又不归我管，这种情况弄的我有点焦虑和难受，后面说开了主要还是各做各的，我们的代码和技术可以搬用（后面发现这才是主要目的，他们还是要做他们的，是我想太多导致自己压力山大）。目前这个合并（或者说被兼并）并没有显现出产出的提升，效率就更不用说了。只能说静观其变吧，做好自己要做的和想做的。

四季度终于有时间用 rust 开始重写项目了，发现 rust 确实有一些相比 go 好的点，比如支持 int 128，这样就可以很好的用来代替decimal；比如高性能 json库。但 rust 因为独有的所有权特性，导致需要共享的时候相当难受，某种程度上也是 Arc 满天飞了；另外虽然 rust 也支持同步代码，但基本上实际场景只能写异步代码，这个还是go 简单好用啊。目前 rust 项目还在测试中，不知道能否有效果，明年在进一步推进。明年还想学的是 solidity，希望也能反馈到工作中来。

关系

今年感觉自己更加接纳自己了，更少的匮乏感，更少的自我攻击。即使受到秃头阳痿的中年暴击，也能较为坦然的接受。每当自己感到自己不够好的时候我就会心里默念"I love you 我爱你"，算是自己把经历匮乏不安的童年的我好好养育一遍吧。

今年见到了大多数我生命中重要的人，感恩遇见。

以前除了家人同学朋友，我没有其他的人际关系，今年通过爬山和跑步认识了一些人，感觉和深圳这座城市连接更紧密了，感恩遇见。

今年和爸爸的关系算是一个低谷吧，有一阵我看到他的来电显示，整个人会产生躯体僵硬反应，那种贬低打压和孝道绑架让我实在难以承受。从刀姐和金惟纯的对谈播客获得很多启发，让我从这种负面情绪走出来，对自己全然负责，也让别人对他自己负责。过好自己的生活先吧，电话不一定要接。

投资

中文MEME试水亏钱了，1011早上起来了但不知道怎么抓机会，总结就是没怎么尝试。

今年最后看了一本畅销书《金钱心理学》，里面提到了尾部的胜利，但只有多尝试才有可能遇到尾部，所以还是要多试。另外里面也提到了财富是你没有花掉的钱，这些能给你带来选择自由的没花掉的钱才是财富，这提醒我还是要多储蓄少消费。

2024海南环岛摩旅

Fri, 03 Jan 2025 16:58:12 +0800

前言

之所以想去海南摩旅，主要原因是24年发现了一个非常喜欢的 Youtuber — Little Chinese Everywhere，看到她在广西和海南骑摩托车旅行，感觉摩托车还蛮不错的，相比汽车更轻便自由，又没有自行车那么累（很久之前也想过骑车环岛来着）。刚好圣诞又有假期，于是便起心动念了。

动念的第2天便搜索了一下摩托车驾照考证相关的信息，立马报名了去佛山考三轮摩托车D照的项目，中间在深圳练了2次车，第8天就考试拿到驾照了。

我是个不怎么喜欢做攻略和准备的人，直到临出发10天前才做具体准备：

看攻略确定西进东出，从海口出发和结束，选了一些觉得有兴趣的点，大概7天
确定租车店铺（后面感觉他家确实还可以）
装备买了40L防水袋、手套、防水鞋套（没用上），一贯风格就是轻(不)装(想)出(花)行(钱)，没有买专门的骑行服和雨衣，用冲锋衣代替

海口-临高（第1天）

凌晨到海口，睡了一觉，走出酒店大门，就看到了椰子树作为行道树的街道，随即又有骑行队伍路过，瞬间感觉自己来对地方了！

出酒店门就感觉来对地方了

没有预约，直接走入网上提前看好的租车店，花了1分钟选了一台125的踏板车，作为小白，有个入门车对我来说够用了。本来还想着要不要先在海口逛逛，但老板建议我直接出发，不然第二天行程会很赶，于是我就毫无准备地回酒店拿好行李出发了。

一开始我不太敢上机动车道，在非机动车和电瓶车一起，后面慢慢才上机动车道。

出了市区很快就上环岛旅行公路啦，路况很好。

上环岛旅游公路啦

第一个很让我震撼的场景是发现田里很多人在一起收割甘蔗，很壮观，而且有涉及机械抓和大卡车。我没忍住和割甘蔗的阿姨搭讪，阿姨还热情问我吃不吃甘蔗！

第一次见收甘蔗，好像和收水稻类似？

两台机械抓在装车

满满一大卡车甘蔗

第二个让我感觉很深刻的是路过一个静谧的小渔村，港湾停满了渔船，马路边摆满了渔网，渔民们正在补网

静谧的港湾

补网ing

不知不觉过了五点，下起了小雨，温度降了很多，我感觉有点失温，油也不多了，于是就近去了新盈镇住宿了，晚上吃到了特色的虾饼和老盐茶

围炉吃虾饼的方式感觉很新奇

我吃了9个，只要3块钱

临高-儋州（第2天）

今天是个阴雨天，还好雨不大。

河里的人不知道是在干什么

本来想去峨蔓火山公园，但发现油不够了，只好拐去加油了，加完油后面就直接去东坡书院了，在东坡书院复习了一些早已还给语文老师的诗词。

书院正门

水光潋滟晴方好，山色空蒙雨亦奇

之后就去儋州市区等同学了，晚上吃了好吃的糟粕醋火锅

店面看起来不起眼，但很快就满座了

金桔当蘸料，第一次见

鱼肉好鲜美

儋州-莺歌海（第3天）

今天是赶路的一天，路况也很好。路上遇到一个在棋子湾长期旅居的小姐姐，平时在网上教英语，出来散步会带上她的小狗狗

三只可爱小狗狗

好酷的房车，背景是个大风车

到目的地莺歌海镇啦，这里是个小渔村，很有生活气息！

村子很好逛，总体看下来，他们的建筑风格大体分为三个时代。

第一代是一层，可能是盖瓦或者平层，粉刷的白墙

这个好像没住人了

两只可爱的猫猫

村口肉铺

第二代是两层，会贴漂亮的瓷砖

鱼肉好鲜美

第三是就是很现代化的别墅形式了

鱼肉好鲜美

不时看到有人家门口有晒各种这样的鱼

这个问了好像说叫魔鬼鱼

海边，天气好的时候可以看日落

天气有点阴

美丽的民宿门口

莺歌海-三亚（第4天）

往三亚走，天气开始好起来，中途歇脚的时候，刚好有个骑车的大叔也在我边上停下来了，于是我们聊了好一会。叔叔来自山东，62岁，职业是农民，目前是农闲时期，不想老在家打麻将吸二手烟，所以一个人带着自行车就坐火车来环岛啦，普通的装备，不赶时间，主打一个休闲玩耍！

我三十年后还能有这种状态吗？

后面去了一下大小洞天景区里面的自然博物馆

大小洞天景区里面的椰林

场馆挺小的，很多恐龙相关的介绍，可能我期待太高了，感觉不及预期~

里面不让拍照

当天住在美丽之冠，外面看起来建筑设计很别致，但里面其实入住率很低，自带的商场都关停了，也许和开发商是恒大有关？

视野还不错

三亚-神州半岛（第5天）

来海南，其实还有一个目的，就是来三亚跑半马啦

七点起跑，六点多一点就出门啦，天还没亮

整装待发

太阳出来了，美丽的椰林跑道

靓丽的300兔子

路过一片沙滩，好美，忍不住停下来拍个照

我去前面探探路

这次跑步主要目标就是看看跑友们的 cosplay，好好玩

媒婆也跑步？

美人鱼

真理！

这应该是新疆风格？

直播跑步的新娘

真的陪跑？

跑完休整了一下，又上路了，看到人们在插秧，果然海南是种三季稻的

这算早稻吗？

本身走错路了，也听说日月湾在修路，后面直接往神州半岛去了。

入住的度假公寓太舒服了，空间大，设施齐全，洗衣机晾衣架都有，非常适合长期待

还能看到内海

休整一下就往海边跑了，忘记换拖鞋了！不过看到了美丽的晚霞!

好宁静

原来海边可以玩烟花

远处也放起了烟花

神州半岛-文昌（第6天）

一早又来海边了，看到了一个三人叔叔阿姨骑行团，得知他们从宇宙的尽头—铁岭出发，沿着海岸线一路南下，这是他们这次骑行的第83天！

很有故事感的车

到了一片没有游客的海滩，发现有很多贝壳

海滩独享

捡了一个多小时贝壳，只挑带孔洞的捡，很上头

我好富有

想着摆个心形来着，结果海浪一来，就被冲远了

不要跑！

第一次见漫山的菠萝树

远处都是菠萝

美丽的海边

这里沙子好白

道路两旁满满的椰子树

靠边走不会被椰子砸到吧

文昌-海口（第7天）

今天本来没有抱什么期待，加速往回赶，想早点还车，但后面还是去了一下木兰湾。说实话木兰灯塔没什么看的，近海也没什么看的。但是好奇如我，多走了两步，看到了这一周来觉得最美的海滩。我在这里也停留了一个多小时，海浪声听得超级舒服

在我的旧有认知里面以为绿色的是苔藓，其实它是海草，很喜欢这一抹绿意

海草近景

后记

作为一个新手，7 天 1080 公里顺利完成环岛，我感觉很幸运。回过头想，摩托确实感觉有点有点脆弱，尤其是走在车流中的时候，不过如果想太多的话，也就不会出发啦！

环岛旅游公路大部分路况都很好，专门建了停车充电上厕所的休息区，所以驾车或骑车都很合适。但路上加油站比较少，有时需要绕路加油，所以对于小油箱的摩托车来说，额外准备一个油箱更好。海南摩托车加油需要身份证，但注册中石化的易捷加油的话就可以直接用小程序加油了，我还体验了2次自助加油！

从这次住的酒店来看，不少酒店都改造成智能家居模式了，灯光窗帘等都可以语音控制；另外海南的酒店喜欢用4个6加4个8这个密码；最后不得不说海南这边的度假酒店的设计实在适合长待的人！

这次让我印象最深的人还是那个山东叔叔，作为一个62岁的农民，农闲时能有这种心力独自出来骑车环岛，我很佩服。当然我们聊到后面有机会可以走中线，他也说对他这个年纪的人来说以后说不准了。30年后我有这种心力吗？

这次我最喜欢的地方是莺歌海和神州半岛，以后如果有机会长待的话，我希望每个地方能住上一段时间。

这次旅行我好像没有一次感到孤独，即使海边看情侣放烟花，我也只是尽情欣赏。大概率和驾驶摩托有关，我第一天还带了一会耳机听歌，后面就再也没用耳机了，路况好的时候我常常油门拧到底，不过125的极限时速也不会超过100。专注驾驶某种程度也算是进入了心流，整个人沉浸在过程中，杂念很少。另外我适应了在酒店点外卖，之前我出去玩很少点外卖，但这次我点了好几次外卖，这样就不用纠结去外面找吃的时候适不适合一个人吃的问题了!

2024年终总结

Tue, 31 Dec 2024 07:23:11 +0800

工作

今年的关键词还是重构，基础系统和信号模型都做了重构，还算是小有收获。

明年要做什么我其实还没太想清楚，重构目前做的差不多了，更多的需要创新。今年我学了一些Rust/Solana/Jupiter相关的东西，或许这些积淀明年能做点什么东西出来

今年是完全远程工作的第二年，大部分时间在家工作，部分时间在图书馆。去图书馆去的少的主要原因年中有一段时间身体突然不太舒服中断了，年末又偶尔去图书馆了。

今年团队合并加入了两个小伙伴，虽然交流也并没那么密切，但感觉还是有不少收获。

生活

今年的关键词是重新连接。

今年旅行还不少，主要是江苏、肯尼亚、海南。清明去了江苏，在苏州见到了新同事前同事，逛了逛春意盎然的园子，喜欢苏州这座城市。后面和分别在江浙沪的三个大学室友在常州相聚，还去月子中心看了初生的小宝宝。

五一跟团去了非洲，终于亲眼见到了真实的动物大世界！另外和同行的小伙伴不时的互动交流也是看到了很多不一样的人生。

最后就是年底的海南摩旅环岛，此刻我在文昌，今天也是旅程最后的一天。整个行程，没做什么准备，我也永远是那个没什么装备的那个人。大概看了一下小红书，选了几个感兴趣的地点就出发了。回头看来，感触最多的点都是路上意外遇到的。最喜欢莺歌海和神州半岛，以后有机会我都想住上个一星期；另外我在一片无名的海边捡了一个多小时贝壳，太好玩了，满载了一堆天然带孔洞的贝壳而归；最后我从遇到的人身上感触最深的就是最重要的就是出发，限制没那么多。

另外我也见了2次在广州的同学，之前5年没去广州了。

回家见了小时候的朋友，和他一家人吃了饭，去了他的新家坐了坐。

在深圳趁机见了一下来出差的朋友，上次见面2年前还是我去她家吃饭。

特意绕了点路，去见了大学唯一海南的同学，我是第一个来海南找她蹭饭的人，吃了好吃的糟粕醋火锅！

有一个第一份工作认识的很有缘分的朋友没有机会见着，但年底我主动联系然后我们语音畅聊了一个多小时，明年争取去川渝跑个步去找他见一面！

去佛山跑步的时候顺便去见了不是很熟悉但这两年重新走动的表哥，看看他们日常的生活状态也挺有感触的。

最后我重新联系了我的高中计算机老师，十多年没有联系了，我在QQ上表达了我的感谢，老师过了几天后回复我了，也给了我满满的祝福！后面有机会去学校看望她！

时隔三年半之后，今年重新回到半马跑道，十二月第一个和最后一个周日分别跑了一场，而且都破2了，二十多岁都没破过2！现在我的身体肯定没有二十多岁好，说明训练是有用的！

今年也在找对象做了一些尝试和努力，虽然没有结果，但过程也是好的。尤其是年底的一场短暂的上头，让我看到了很不一样的自己！

今年第四季度生活节奏超级好，一边是规律跑步，一边是每日阅读打卡，整个人变得很充实。今年看到让我最震撼的一句话是重读《力量从哪里来》这本书发现的！

我们最大的不敢是不敢发光！另外只有允许自己发光时，我们才会允许他人发光。

展望

Go ahead, have fun. — Faker

2024端午小记

Sun, 16 Jun 2024 11:17:34 +0800

端午节回家待了几天，做点记录

生机

我们这里现在只种一季水稻，刚好端午节前后就是插秧的时节，这个项目目前还没有被很好地机械化，工作量还蛮大，在家人们的相互帮忙下合力完成

燕子也回来了

一些水果

一些蔬菜

当下小学生社交通证 — 烟卡

教他们玩我的时代的游戏 — 跳棋

自创规则地玩扑克

小朋友的想象

给你花花

也给你

她好快乐啊

老去

高铁上和我一同从深圳回家的三伯母

路上偶遇小姑父姑妈

终于拿到退休证的爸爸，虽然每月只有一千多，但作为一个没有退休的农民而言，也算难得。

大姨父一个人独居，最近独自醉酒后离世，挂历还在。

结尾

自然而然

五一肯尼亚之旅

Sun, 19 May 2024 15:52:44 +0800

前言

其实很早就看到了李奕写的报名介绍，想着要不趁机去看看《动物世界》记录片里面的非洲大草原，我甚至年初写到了今年计划里面。但一犹豫金钱和时间，就拖延起来，后面三月份才把自己从候补名单里面捞出来。

行前准备

机票我在飞猪上购买的，选的埃塞俄比亚航空，抵达时间比较合适，价格也比较便宜。（后面才知到机票可以直接从官网买可能价格更优；另外埃塞俄比亚首都机场是中国人前往非洲的最大中转站，来回都遇到不同非洲国家工作的中国人）

去肯尼亚需要打黄热疫苗，但深圳和广州很难预约，据电话了解好像一天就 20 个名额，感觉不比春节火车票容易。后面去苏州出差的第一天，我随手看了一下，苏州和常州的很好预约，于是我在苏州打了疫苗。

肯尼亚温度在二十多度，和国内南方差不多，在最后一天花了两个小时打包行李，我背着一个 30L 的双肩包就出发了。

内罗毕(第0-1天)

早上达到了埃塞尔比亚机场等待转机，阴雨天气，和其他航班来的 4 个小伙伴汇合。

机场还有祈祷室！

写博客的时候才发现里面有后面才认识的小伙伴

他们围着坐着在充电

中午抵达内罗毕机场，发现是个大晴天，感觉云从地里冒出来的，好惊喜。

下机后发现天气真好

云是从地里冒出来的吗

好多接机的人

晚上已经到了的 11 个小伙伴以及李奕一起碰面了，吃了粤菜。暖场自我介绍活动大概是这样的：叫什么，哪里人，学什么，做什么，一个个人趣事或者小时候经历。人太多，只记得个大概，哈哈。

第二天上午，我们在当地向导的带领和警察的保护下，我们参观了基贝拉──非洲第一大贫民窟。

入口内外主要是一些服装店铺，很多货源都来自中国

市场外围，很多中国来的二手衣服

市场外围，鞋子600先令起

市场内部，衣服店

市场入口，比较狭窄，牵手的母女

市场内部，比较泥泞

市场内部，比较狭窄

菜市场

菜市场，4-20 表示4个20先令

这个摊位的东西好像都比较常见

各种水果

洋葱洋葱洋葱

番茄番茄番茄

番茄大亨给我们介绍番茄

居住区

各种个性十足的巴士，感觉售票员是个危险职业

好酷

房子上也有各种涂鸦作品

泥地足球

球出界了

感觉比较难进球

坐在铁轨上看球

一路路过好多个小的基督教堂，里面大都放着欢快的歌谣，我们后面参观了一个，里面实在太嗨了，简直就是一个大型蹦迪现场。

小小的房子里面站满了人

是牧师也是MC

这个与我对教堂的固有印象大相径庭，后面看到《穿越非洲两百年》书里的描述才理解。

教堂里，人们敲锣打鼓，载歌载舞，极具非洲特色。这或许与传教士们的努力有关，为了传播信仰，他们改造了基督教严肃的一面，将非洲的歌舞成功地引入其中，形成了快速的传播。

最后我们参观了向导的家，十平米左右大小，一家六口住在一起，她说 “We don’t have much but we have each other”，这让我想起了 up 主蕾儿乔什看世界的视频我在印度最大的贫民窟生活了三天。

瓦塔木(第1-3天)

午饭过后我们乘坐小飞机到了印度洋旁边的小镇瓦塔木

这种飞机好像能坐20人左右

也有大一点的飞机

飞机上俯瞰

我们入住的酒店叫 TreeHouse，整个酒店就置身于海边的树林里。

屋顶俯瞰周边

我住在屋顶的房间，名字叫 starbed

露天浴室？

想的话可以来个日出浴？

果然名不虚传，仰望天空 360 度全是星星，晚上大家轮流在大沙发上躺着看星空聊天

房间外是个大阳台

好多星星

好多星星+n

能看星星，当然也能看日出

另一栋房子的屋顶是一个视野超好的瑜伽室，我个人本身对瑜伽和冥想都不太感冒，但想着来都来了体验一下，结果这个体验成了我的一个 high point。过程中不扣动作细节，更注重呼吸和和身心的连接，练完感觉整个人既放松又充满能量。

另外我们还去划了皮划艇，去年在万荣在向导的带领下还落水的我这次没有落水，哈哈，感谢 Nico~

好原生态的水域

中途上岸参观了一下红树林，超级原生态！水沟里面有好多小海螺，沙地里有数不清的小螃蟹

好多种子和小树苗

水渠里面有好多海螺

好多小螃蟹，跑的超快

继续前行，很幸运地看到了火烈鸟，听说它们一般不来这里

大家绑在一起看落日，向导还给准备了爆米花和茶，巴适！

返程啦，在太阳落山之后的余烬光辉中，大家在三三两两地聊天，感觉世界很安静。

内罗毕(第3-4天)

回内罗毕中转，在小飞家吃天水麻辣烫，吃的好撑（二手瓜的原因？），最后的红烧肉反而吃不下了。

内罗毕也是个鲜花城市

马赛马拉(第4-7天)

又坐小飞机啦，发现机场居然可以是泥地！

天气好好

飞机降落，转弯了

我们相当于包机了

飞机飞的好低，来一波俯瞰图

树木沿着河流生长

看起来被洪水淹了

左边好多牛羊

有朋友好奇我们怎么看动物的？是否安全？那首先给大家看看我们坐的车，车是完全敞开式的，相比天窗式，其实更方便观察动物

和另一辆车相互对拍

在狮子眼中我们都是NPC

下雨天也可以应对

下面开始动物大赏！

斑马斑马，憨憨的斑马

狮子狮子，嬉戏的狮子

其他可爱的动物

近距离看到的第一个大型动物

雨中的大象家族

角马

最后的早上看到了吗喽家族

来点小伙伴们用相机拍的的近景图

Dik-dik 兔子般大小的羚羊

疣猪彭彭

河马上岸了

嬉戏的狮子

你瞅啥

看到小象了吗

好肥的鬣狗

秃鹫在和鬣狗抢腐食

看到豹子的食物约等于看到豹子了吧？

去酒店的路上，我们先救了一辆已经陷进泥潭的面包车，后面我们自己的另外一辆车也陷进去啦，我们在唱 Hakuna Matata 给大家加油~

先拉出了面包车

尝试往前拉车

后面后退来拉来的

马赛马拉最后的午餐，我们坐在树荫下，边吃午餐，边随意分享一部自己喜欢的文学影视等作品

大概记得有如下：

动漫《排球小子》
书《命运》、《被讨厌的勇气》
综艺《种地吧》、《无限挑战》
电影《三傻》、《爱在三部曲》
电视剧《0.5的男人》

我分享的是鲁叔的音乐《白云》，当场播放起来，成了很应景的背景音，甚至被有的小伙伴当做是当天的 high point。

（ps 回来后我已经看起了《命运》）

多才多艺的同行小伙伴里面有一个故事大王 Echo，她正好是做遗愿清单工作坊的，于是我们饭后趁机免费体验了一次。

作为暖场，Echo 先分享了她自己的一个爱情故事，好多小伙伴给听哭了（-_-。）

工作坊的简要流程是先冥想放松，想象自己的一生，回答如下问题

理想寿命
死前状态的三个关键词
写出十条清单
选出其中最重要的三条
确定每条完成的时间点（相互提问完之后回答）

大家当场分享了理想寿命和死前关键词，80岁好像是最低的数字，哈哈! 我们的唯一CP中的男生说要活 124 岁，为了走在对方后面。好感人！（听说他们晚上回去因为这个先后问题还争吵了）

死前关键词其实大家大差不太多。

另外还有一个环节就是两两分组，通过给对方的清单提问，来帮助对方对对清单更明确和深刻。

我和李奕一组，我们的清单风格差别挺大的，我一开始看了挺诧异的，她竟然划掉了我认为很重要的点。后面我想了想，她这样做是因为本身在这个划去的点上已经做的很好了，另外她留下的点让我想到了"能量越大，影响力越大"的观点，对比起来，我写的都是很个人的事情，哈哈。因为没有提前想过，我就写出了五条，有的还有点重合。李奕帮我问了我很多问题，让我对我写下的答案清晰了不少。

当晚晚餐的时候，大家每个人都分享了感觉稍稍私密的清单，不同的人确实还是有不一样的，有的很具体，有的很宏观。

最后一天上午，我们参观了一个马赛人的村庄

手持木棍的马赛人

人畜自然地生活在一起

咩咩咩

他们的房子围成一个圈，可能牛羊就关在中间

房子近景

房子内部，女主人正在烙饼,房子左右两边都是床

时间飞快，得说再见了！马赛马拉！

后记

这算是我第一次参团中长途旅行，整体体验还蛮好的，真的是把自己带来就行了，其他的都安排好了。我们超级幸运，航班没有延误，行程没有遇到洪水（同期很多人被洪水影响，甚至产生生命危险）。

每晚的 high/low point 分享，即是每个人对一天的回顾，也是相互了解和熟悉的契机，是很好的仪式流程。

把自己抛到一个完全陌生的环境是一个很好的自我了解的机会，我感觉我又更加了解自己一点了。

作为唯一一个英语不行的人，感谢同行小伙伴的帮助，让我旅行体验提升很多。

到马赛马拉的那天，天气骤变，我中暑发烧了，还有点慌，多谢 Chloe 万里带来的藿香正气水。搞笑的是最后回内罗毕后，才发现不少人也中暑了，盈盈给其他人都进行了中国传统艺能——刮痧，房间里不时传出奇怪的惨叫声。（ps 去马赛马拉注意防风保暖）

吃了很多好吃的，但光顾着吃了，没怎么拍美食~

Shuming 有条清单是"reconnect with old friends"，我去了好久不去的广州见了大学室友。

回来时差倒了好几天，终于正常了~

2024出差小记

Thu, 04 Apr 2024 16:22:03 +0800

前言

关于这次苏州出差行，我在春节前就有了念头，但迟迟没有最后确定日期，因为这个纯属我个人主观想法。新近合并的团队成员在苏州，只见了一面，他们随口提到办公室有多余的工位，感觉对方还是蛮好相处以及有很多可以学习的地方，我想也许大家线下办公一段时间可以交流了解地更充分。所以这其实是一次自费自愿出差，然后拖延症如我，周四才决定下周一去。

出差

为了最大化周末时间，我选择了周日晚上坐动卧早上到上海再转高铁到苏州。虽然办公室在北边的万达广场，但我还是特意选择了从南广场出来，看看亲切的平门城楼，然后慢慢步行看看两边的街景，溜达着前往办公室。

到了才知道，为了避开早高峰，他们提前到八点开始上班，另外他们自费租的办公室视野很好，工位也挺多。十分钟步行通勤时间，宽敞放松的办公环境，久违的线下办公感觉还是很好的。除了交流双方的工作模式外，因为线下，确实多了好多闲聊的机会，很多聊天内容是不太可能在线上通讯软件上产生的。另外世界好小，发现居然还有共同认识的人。

总的来说，对于目前感觉处在能力瓶颈有点闭门造车的我，新成员的加入给了我一些新的探索方向的启发。

赏景

阴差阳错，办公室旁边就是春分街，来的这周又正好是耶稣受难节和复活节（因为放假第一次知道这两个节日），所以我错峰出行地去逛了网师园和留园。不得不说，苏州花红叶绿的春天的实在太美了，眼睛和心灵都得到洗涤。

访友

作为一个内向独立的人，友谊维系是一个我很需要修炼的人生课题。

感谢对我的一声吆喝就做出积极回应的大学室友们，也感谢我自己，让分别位于江浙沪的他们再次聚集起来。异地聚会确实挺不容易的，但我们没有具体的计划，定好了大概的时间地点，后面就都是随机行事了。虽然有一些时日没见，但线下面对面交流起来大家就慢慢熟络起来，大部分时间我们都在吃吃喝喝聊天中度过，聊聊各自的生活和工作，同一大学专业的我们如今所做的职业和行业都不相同。通过这次近距离的相处，我发现可能变化最大的是 Kenny 同学，对，他居然给自己微信取了一个英文昵称！才知道他离开了当初我们俩共同校招进去的待了七年的公司，我以为他大概率不会主动离开的。另外人也变得主动热情多了，在说到老婆孩子在附近的月子中心邀请我们去看的时候，另外两个同学觉得会有打扰或者不方便婉言拒绝的时候（我内心是想去的），仍再三邀请，于是我们一起去看望了黄老师和 22 天大的端端小朋友，在月子中心的一小时感觉时间变慢了，世界变安静了，大家的注意力都放在了这个如此小的人类幼崽身上；

当大家关切我的婚恋问题时，他多次说如果需要他可以帮忙介绍，虽然异地本来可能性不大，但我知道他不是在说客套话，这个话是对我的肯定和关心，这个话我不太可能会说，我感觉以前的他也不太会说，我想是良好的夫妻关系改变了他吧。晚上九点主场散去，剩下的三个人又喝起了茶，聊了一些私人话题，大家都有各自的课题需要去应对。十一点左右，Kenny 同学突然提起：要不去网吧吧？于是在时隔八年之后，我们再次一齐走向网吧，在那有点寒冷的春夜街头，我们有种逃课出来偷偷上网的感觉，搞笑的是我们找了一个小时才找到一个有三连坐的网吧。最后当那熟悉的三个 ID 再次出现在游戏界面时，还是很让人感慨的（我的大刀早已饥渴难耐了）。

另外也分别见了两个第一份工作的同事，只是约一顿饭，但都畅聊了三四个小时，一个四年没见，一个七年没见，好像也没有很生分，线下见面的感觉还是蛮好的。大家也都各自通过自己的方式换了行业换了职业，聊聊前司，聊聊职业危机，聊聊婚恋问题等等，时间好像一眨眼就过去了。

最后我也去上海见了两个只有网络上有交集的朋友，我发现两边离火车站近的话，工作日晚上苏州到上海跨城约个饭也是可以的。我也发现人少的场合我也没那么社恐，我完全敞开的时候，即使陌生人也可以敞开的聊天。

后记

虽然这次去的时候动卧错买成二等座，回来飞机晚点三小时，主动与人链接的时候既笨拙又敏感，但遇到的同事、同学和朋友都很有爱，我吸收到了满满能量。感谢~

2023年终总结

Sun, 31 Dec 2023 16:56:53 +0800

工作

今年工作的关键词依然是重构。后端从 flask+sqlalchemy+celery 换到了 gin+gorm+cron，而前端从 jQuery+Bootstrap 换到了 Vue+AntDesign。这是我第一次写前后端分离的项目，之前也没有用过 Vue，刚开始完成 MVP 版本的时候还是蛮开心的，到后面就是漫长的实现业务需求的阶段。不过做为一个需求分析、设计、前端、后端、测试的全沾工程师好处就是踩过所有坑体会每一个细节、随时重构、只保留必要的功能。

今年是完全远程工作的一年，远程工作的好处之一就是可以四处打工，我在老挝和云南工作过一段时间，不过体验并没有我想象的那么美好。首先我的工作需要很多时候需要自己去探索和调研，很费精力，工作日基本一眨眼就天黑了；其次因为一直在换地方，我得不停考虑住哪里，洗衣服方便不，去哪里吃饭；最后我发现我也没那么喜欢旅行，我可能主旋律还是习惯待在一个熟悉的环境里面，所以我今年主要都在图书馆工作，喜欢这个充满着学习和思考氛围、男女老少皆宜的场域。

职业发展可能是每个打工人都会感到迷茫和困惑的话题，我今年年中有去尝试去争取一下，对我个人来说算一次勇敢尝试，也发现了我不知道的的游戏规则，另外还是相信真诚和以身作则是最好的领导力。

生活

今年旅行主要去了老挝、云南、景德镇。我个人旅行风格是只做大概的规划，但大晚上到了老挝，乌漆嘛黑，语言不通，手机快没电，多多少少还是有点慌的，感谢后面一同结伴的叔叔阿姨们。老挝行总体来说作为一个外国人去感受一个语言、饮食、信仰完全不一样的国度去感受一下还是蛮开拓视野的。云南行也算一次新奇的体验。当你刚到昆明这个城市坐上地铁，在某一个站你发现上车的每个人都抱着两束花，你会想这个城市这么浪漫吗？当你去逛菜市场，你会发现很多当地特有的食物，你会发现这里不单单按公斤计价，有的还按堆计价。当你出了丽江火车站，一抬头，发现远方不只有白云，居然还有雪山，后面你会发现这里到处都能看到雪山。当你去了大理，你会发现这里到处赶集，人潮涌动；你会发现这里酒吧也可以是路边摊的形式，一把吉他，几条折叠板凳；你会发现这里不少素食馆，味道还蛮好的。当你到了景德镇，你会发现琳琅满目的陶瓷作品，以及作品背后的工作室和作坊；你会发现真的有人来这学习手艺，成为景漂的一员。

今年也做了一些破旧立新的尝试。换了从大学时就带起的眼镜，世界好像是用眼睛看的清晰一点了。另外可能是成长经历的原因，其实一直有点害怕去医院，在姐姐的陪伴下去了医院，看了一下医生，治好了一个拖延很久的小毛病，终于首次使用上了医保。有一天看小红书突然兴起，决定自己动手把住了六年的房间重新刷一下墙漆，于是花了一个周末边学边做完成了这个开始时不觉得艰巨的任务。最后效果只能说勉强还行，但做之前玩笑说可以将刷墙发展成第二职业看来很难有竞争力。今年重新拾起了好多年没有打过的羽毛球，感觉是个不错的运动，可惜后面脚受伤之后就没打了。今年甚至下载了青藤之恋尝试去交友，算是不错的尝试，更了解自已一点了吧，另外也在上面围观其他人的人生经历，看到更大的世界。

今年跑步跑了 323 公里，和去年持平，也没有参加任何比赛。

今年英语换到了多邻国上学习，但用了几个月之后感觉没有什么提高，就中断了。今年刻意减少 B 站的使用时间，希望多在油管上看看英文视频，但其实在油管上也主要还是看中文视频，哈哈。

今年技术上的学习主要在学习如何写前端，工作上需要用到学习确实更有效率；学习 NATS 的设计原理，七年前的 1.0 版本还可以跑，基础软件还是蛮稳定的；C++ 通过《 C++ 之旅》第三版入了一下门，有操作符重载和模版这两大魔法，感觉 C++ 好灵活，另外编译器和设计标准不同步感觉有点坑，有的 C++ 20 的功能都没有实现。

今年看过的书差不多忘光了，但记得《论世衡史》和《置身事内》里面有一个类似的观点：无论是闭关锁国，还是自由贸易，背后其实都是利益多方的复杂博弈的结果。很让人震撼，但也很真实。

展望

日常跑步
探索新事情

链接

[笔记]C++之旅

Wed, 29 Nov 2023 18:51:08 +0800

第一章基础

hello world 示例

import std;

int main() {
    std::cout << "Hello, World!\n";
}

函数

函数声明包含名称、参数和返回值，返回值在名称之前。

函数的类型由他的返回值类型和参数类型序列组成普通函数 double get(const vector<double>& vec, int index) 的类型是 double(const vector<double>&, int)；而类成员函数包含类名，如char& ClassA::operator[](int index) 的类型是char& ClassA::(int)

如果两个函数有相同的名称但不同的参数类型，则编译器会选择最适合每个调用的函数

类型、变量与运算

常见的基础类型有 char、bool、int、unsigned 和double 等等

常用算是类型转换会以最高操作对象精度元素，如 double 和 int 类型的加法会以 double 的精度进行

可以使用 C语言方式 = 来初始化对象，但建议使用 {} 来初始化，避免隐式类型转换

doube d1 = 2.3;
double d2 {2.3};
double d3 = {2.3};  // =符合可以省略

int i1 = 7.3; // 发生隐式转换，i1=7
int i2 {7.8} // 报错！

当定义变量时，可以从初始化符号推导出来，可以无需指定类型，用 auto 代替

1
2
3

auto b = true; // bool 类型
auto i = 123; // int 类型
auto d = 1.2; // double 类型

常量

有 2 种常量

const: 主要用来说明接口，编译器负责执行 const 承诺，可以在运行时计算
constexpr: 主要用于声明常量，把数据置于只读内存区域，必须由编译器计算

int var = 17;
const double sqv = sqrt(var);
constexpr int dmv = 27;
constexprt double sqv2 = sqrt(var); // 错误：不能是个非常量表达式

被声明为 constexpr 或者 consteval 的函数是 c++ 版本的纯函数，必须在编译时计算，且不能有任何副作用，只能使用输入参数作为信息。

指针、数组和引用

在声明中，[] 表示对应类型的数组，* 表示指向对应类型的指针，& 表示指向对应对象的引用。引用和指针类似，但可以不使用前缀*就能直接访问引用对象的值，而且引用初始化滞后就不能再指向其他的对象。

在表达式中，前置一元操作符* 表示取内容，前置一元操作符& 表示取地址

建议使用 nullptr 而非 0 来表示空指针，避免和整数类型混淆

初始化

初始化是将一段没有被初始化的内存区域变成一个有效的对象，对几乎所有的数据类型而言，对未初始化的对象的读写操作都是未定义的。

要让赋值操作成功进行，被赋值的对象必须拥有一个有效的值

赋值

对于内置类型来说，赋值语句就是简单的机器赋值指令。两个对象是独立的，修改 y 值的时候不会影响 x 的值。

1
2
3

int x = 2;
int y = 3;
x = y;

如果希望不同的对象指向（共享）相同的值，必须明确指定

int x = 2;
int y = 3;
int* p = &x;
int* q = &y;
p = q;  // p 和 q 两个指针都指向了 y

给引用赋值改变的是引用对象的值

int x = 2;
int y = 3;
int& r = x;
int& r2 = y;
r = r2;   // 从 r2 读取，通过 r 写入，x 变成 3

第二章用户自定义类型

结构

struct 将所需的元素组织在一起

如下有一个简单的 Vector struct 示例

struct Vector {
    double* elem;
    int sz;
}

void vector_init(Vector& v, int s) {
    v.elem = new double[s];
    v.sz = s;
}

doubel read_and_sum(int s) {
    Vector v;
    vector_init(v, s);
    
    for (int i=0; i !=s; ++i) {
        std::cin >> v.elem;
    }
    
    double sum = 0;
    for (int i=0; i != s; i++) {
        sum += v.elem[i];
    }
    return sum;
}

自定义类型的名称通常使用首字母大写，以便和标准库类型区分

访问 struct 成员有两种方式，通过名字或引用时用. 符号，通过指针时用-> 符号

void f(Vector v, Vector& rv, Vector* pv) {
    int i1 = v.sz;
    int i2 = rv.sz;
    int i3 = pv->sz;
}

类

类将数据和操作组织在一起，类的 public 成员定义了该类的接口，private 成交则只能通过接口访问

class 和 struct 没有本质区别，唯一区别在于 struct 成员默认是 public 的。

class Vector {
public:
    Vector(int s) : elem{new double[s]}, sz{s} {}

    double &operator[](int i) { return elem[i]; }

    int size() { return sz; }

private:
    double *elem;
    int sz;
};

Vector 对象是一个句柄，包含指向元素的指针（elem）和元素的数量（sz）, Vector 包含 Vector()、 operator[] 和 size() 三个接口。

和类名同名的成员函数为构造函数，用来构造类的实例

枚举

枚举类型用来表示少量整数数值的集合，提升代码的可读性，降低潜在错误。

enum class Color {
    red, blue, green
};
enum class TrafficLight {
    green, yellow, red
};

enum 后面的 class 表示这个枚举类型是强类型，具备独立的作用域，不同的 enum class 是不同的类型

enum class 不可以隐式地和整数混用

联合

union 是一种特殊的 struct，他的所有成员被分配在同一块内存区域中，实际占用的空间就是它最大的成员所占用的空间。

enum class Type {ptr, num};

union Value {
    char* p;
    int i;
};


struct Entry {
    Type t;
    Value v;
};

void f(Entry* pe) {
    if (pe->t == Type::num) {
        std::cout << "num: " << pe->v.i << "\n";
    } else {
        std::cout << "ptr: " << *(pe->v.p) << "\n";
    }
}

第三章模块化

c++ 中有两种方式可以实现分离编译

头文件
模块

头文件有明显的缺点

编译耗时，对于同一个文件，每 #include 一次编译器就需要处理一次
顺序依赖
代码膨胀

c++ 20 引入了 module, 使用 import 来引入 module

函数参数和返回值

参数传递

参数默认使用传值的方式，为了性能，可以使用传引用的方式

返回值

返回值的默认行为也是复制传值。可以通过给对象提供移动构造方法，将对象移动到函数之外

返回类型后置

相比传统的记法，后置返回记法更符合逻辑

1
2

auto next_elem() -> Elem*;
auto sqrt(doyble) -> double;

第四章错误处理

使用 throw error 抛出错误，使用 try ... catch (error) 来捕捉错误

错误处理通常有三种方式：

抛出异常
返回错误码
终止程序（如调用 exit之类的函数）

第五章类

具体类

具体类的典型特征是它的成员变量是其定义的一部分

RAII (Resource Acquisition Is Initialization) 资源获取即初始化是 c++ 一种惯用管理内存的方式，它能保证已构造的对象，最后会被销毁，即其析构函数会被调用。

抽象类

抽象类将使用者和类的实现细节完全隔离，即将接口和实现完全解耦，并放弃了纯局部变量

class Container {
public:
    virtual double& operator[](int) = 0;
    virtual int size() const = 0;
    virtual ~Container() {}
};

如上所示， Container 即为一个抽象类。使用关键字virtual 声明的函数为虚函数，虚函数可能会在派生类中被重新定义。 = 0 后缀表示该函数为纯虚函数，必须在派生类中定义该函数。

class List_container:public Container {
private:
    std::list<double> ld;
public:
    List_container() {}
    List_container(std::initializer_list<double> il): ld{il} {}
    ~List_container() {}

    double& operator[](int i) override;
    int size() const override { return ld.size();}
};

double& List_container::operator[](int i) {
    for (auto& x: ld) {
        if (i == 0) {
            return x;
        }
        --i;
    }
    throw std::out_of_range{"List container"};
}

: public 表示"派生自"或者"是…的子类型"。基类和派生类的关系称之为继承。

override 是可选的，但可以显示声明覆盖基类对应函数的意图

虚函数

每个含有虚函数的类都有一个虚函数表，所以对应的实例都有一个指针，来指向这个共享的表

第六章基本操作

拷贝和移动

我们可以通过定义拷贝构造函数和拷贝赋值操作符来控制拷贝过程，通过使用引用类型可以减少拷贝对象的开销

Vector::Vector(Vector&& a) :elem{a.elem}, sz{a.sz} {
    a.elem = nullptr;
    a.sz = 0;
}

Vector 的移动构造函数如上，符号&& 代表右值引用，可以给该引用绑定一个右值。

左值的大致含义是能出现在赋值操作符左侧的内容，而右值正好与其相反，是无法为其赋值的值。

右值引用就是引用了一个别人无法赋值的内容，所以可以安全地"窃取"它的值。

第七章模版

参数化类型

template<typename T>
class Vector {
private:
    T *elem;
    int sz;
public:
    explicit Vector(int s);

    ~Vector() { delete[] elem; }

    T &operator[](int i);

    const T &operator[](int i) const;

    int size() const { return sz; };
};

template<typename T>
Vector<T>::Vector(int s) {
    if (s < 0) {
        throw std::length_error{"Vector constructor: negative size"};
    }

    elem = new T[s];
    sz = s;
}

template<typename T>
const T &Vector<T>::operator[](int i) const {
    if (i < 0 || i >= size()) {
        throw std::out_of_range{"Vector::operator[]"};
    }
    return elem[i];
}

使用 template 可以将 Vector 改成成支持任意类型的动态数组

模版是一种编译时机制，在编译过程进行实例化时，每个实例都会生成一份代码

可以对模版添加 concept 概念，用来对模版参数添加限制

参数化操作

模版函数

template<typename Sequence, typename Value>
Value sum(const Sequence& s, Value v) {
    for (auto x: s) {
        v += x;
    }
    return v;
}

模版函数可以是类的成员函数，但不能是虚函数，因为编译器不知道模版的所有实例，不能为模版函数生成 vtb1 虚函数表

函数对象

template<typename T>
class Less_than {
       const T val;
public:
        Less_than(const T& v): val{v} {}
        bool operator()(const T& x) const {return x < val;}
};

void fct(int n, const std::string& s) {
    Less_than lti {42};
    Less_than<std::string> lts {"Backus"};

    bool b1 = lti(n);
    bool b2 = lts(s);
}

函数对象用来定义对象，该对象可以像函数一样被调用。

operator() 称之为应用操作符

匿名函数

[&](int a) {return a < x} 是一个匿名函数，

[&]是匿名函数的捕获列表，它指定了函数体内的局部变量可以使用引用形式访问，如果使用值的方式则为[=]，什么都不捕获则为[]

模版机制

别名模版

template<typename Key, typename Value>
class Map {};

template<typename Value>
using String_map = Map<std::string, Value>;

using String_int_map = String_map<int>;

第八章概念和泛型编程

概念

模版中，类型名称指示符 typename 是限定程度最低的，我们可以使用概念使之定义更加清晰明确

template<std::forward_iterator Iter>
void advance(Iter p, int n) {
    while (--n) {
        ++p;
    }
}

template<std::random_access_iterator Iter>
void advance(Iter p, int n) {
    p += n;
}

void use_advance(std::vector<int>::iterator vip, std::list<std::string>::iterator  lsp) {
    advance(vip, 10);
    advance(lsp, 10);
}

如果有多个可选的模版，编译器会选择满足最严格参数需求的版本

template<typename B>
concept Boolean = requires(B x, B y) {
    { x = true };
    { x = false };
    { x = ( x == y) };
    { x = ( x != y) };
    { x = !x };
    { x = (x = y) };
};

template<typename T, typename T2 = T>
concept Equality_comparable = requires (T a, T2 b) {
            { a == b } -> Boolean;
            { a != b } -> Boolean;
            { b == a } -> Boolean;
            { b != a } -> Boolean;
};

如上示例，我们可以使用 concept 自己定义概念

泛型编程

可变参数模版

定义模版时，可以令其接受任意数量任意类型的实参，这样的模版称之为可变参数模版

template<typename T>
concept Printable = requires(T t) {std::cout << t;};

template<Printable ...T>
void print(T&&... args) {
    (std::cout << ... << args) << '\n';
}

[笔记]数据结构和算法之美（更新中）

Thu, 29 Jun 2023 07:21:46 +0800

第二讲

十个重点数据结构

数组
链表
栈
队列
散列表
二叉树
堆
跳表
图
Trie 树

十个重点算法

递归
排序
二分查找
搜索
哈希
贪心
分治
回溯
动态规划
字符串匹配

第三讲复杂度分析（上）

大 O 复杂度表示法

n 表示数据规模的大小
f(n) 表示每行代码执行的次数总和
T(n) 表示代码执行的时间
O 表示 T(n) 和 f(n) 成正比

大 O 时间复杂度表示的是代码执行时间随着数据规模增长的变化趋势

时间复杂度分析

三个实用分析方法

只关注循环执行次数最多的一段代码
加法法则：总复杂度等于量级最大的那段代码的复杂度
乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

常见的时间复杂度

空间复杂度分析

空间复杂度指算法的存储空间随着数据规模增长的变化趋势

第四讲复杂度分析（下）

时间复杂度按情况可以分为四个

最好情况时间复杂度 best case time complexity
最坏情况时间复杂度 worst case time complexity
平均情况时间复杂度 average case time complexity
均摊时间复杂度 amortized time complexity

// n表示数组array的长度
int find(int[] array, int n, int x) {
  int i = 0;
  int pos = -1;
  for (; i < n; ++i) {
    if (array[i] == x) {
       pos = i;
       break;
    }
  }
  return pos;
}

上述代码，最好情况是 x == array[0]，时间复杂度为 O(1) ; 最坏情况 x 不在 array 里，时间复杂度为 O(n)。

x 在数组中的位置，有 n+1中情况： 0~n-1 位置中和不在数组中。把每种情况需要遍历的元素个数相加再除以 n+1，就可以得到需要遍历的元素个数的平均值：

省略掉系数，常量，简化后得到复杂度为 O(n)

上面的计算方式有个问题就是没有考虑 n+1种情况出现的概率情况，不出现在数组中的概率要大于处在某个位置的概率。为了简化问题，假设出现和不出现在数组中的概率都为 1/2, 那么出现在数组中某个位置的概率为 1/2n.

这个值是概率论中的加权平均值，也叫期望值，所以这里的平均时间复杂度叫加权平均复杂度

省略掉系数，常量，简化后得到复杂度也为 O(n),

 // array表示一个长度为n的数组
 // 代码中的array.length就等于n
 int[] array = new int[n];
 int count = 0;
 
 void insert(int val) {
    if (count == array.length) {
       int sum = 0;
       for (int i = 0; i < array.length; ++i) {
          sum = sum + array[i];
       }
       array[0] = sum;
       count = 1;
    }

    array[count] = val;
    ++count;
 }

上述代码实现了数组插入功能，如果数组没满，直接插入，如果满了，将数组求和放入第一个位置，然后将新的数据插入。

最好情况时间复杂度为 O(1), 即数组没满的时候

最坏情况时间复杂度为 O(n), 即数组满了的时候

平均情况时间复杂度为 O(1), 计算过程如下

针对示例，每次 O(n) 的插入操作，都会跟着 n-1 次 O(1) 的插入操作，那么把耗时多的一次操作均摊到接下来的耗时少的 n-1 次操作，均摊下来，这一组连续插入操作的均摊时间复杂度为 O(1).

第五讲数组

数组（Array）是一种线性表数据结构，它用一组连续的内存空间，来存储一组具有相同类型的数据。

假设上图数组 a 的地址为 base_address = 1000，那么元素 a[i] 的地址为 base_address + i * data_type_size

时间复杂度

下标访问：O(1)
插入：最好 O(1), 最坏 O(n), 平均 (1+2+…+n)/n = O(n)
删除：最好 O(1), 最坏 O(n), 平均 O(n)

第六讲链表

链表通过指针将一组零散的内存块串联在一起，常见的有单向链表、双向链表和循环链表

链表相比数组的优点在于插入和删除的复杂度是 O(1)

第八讲栈

栈只允许在一端插入和删除数据，并且满足先进后出的特性，入栈和出栈的复杂度为 O(1)

第九讲队列

队列和栈比较相似，只允许在一端插入，在另一端删除数据，并且满足先进先出的特性，入队和出队的复杂度为 O(1)

第十讲递归

递归问题三个前置条件

一个问题的解可以分为若干个子问题的解
该问题和子问题的求解思路完全一样
存在递归终止条件

第十一讲排序(上)

评价算法的主要维度

时间复杂度
空间复杂度，是否为原地排序
稳定性，相等元素排序前后的先后顺序是否不变

常见三种 O(n2) 复杂度排序算法详情如下

冒泡排序

def bubble_sort(nums: list[int]):
    swapped = False
    for i in range(len(nums)-1):
        for j in range(len(nums) - 1 - i):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
                swapped = True
        if not swapped:
            break

冒泡排序最好的情况，数据完全有序，复杂度为 O(n)；

冒泡排序最坏的情况，数据完全逆序，复杂度为 O(n2)；

有序元素对：指对于 i, j 两个位置的元素满足 a[i] <= a[j] 且 i < j 的情况。零有序度：数据完全逆序，有序度为 0；满有序度：数据完全有序，有序度为 n*(n-1)/2。

数据的平均有序度为 (n*(n-1)/2)/2, 所以冒泡排序的平均复杂度为 O(n2)

插入排序

将数组分为两个区间

已排序区间：初始值只有一个元素，即第一个元素
未排序区间

核心思想是依次取未排序区间的元素，在已排序区间找到合适的位置插入，保证已排序区间一直有序

def insertion_sort(nums: list[int]):
    for i in range(1, len(nums)):
        j = i-1
        v = nums[i]
        while j >= 0 and nums[j] > v:
            nums[j+1], nums[j] = nums[j], nums[j+1]
            j -= 1
        nums[j+1] = v

插入排序最好的情况，数据完全有序，每次只要比较一个数据就能确定数据插入的位置，复杂度为 O(n)；

插入排序最坏的情况，数据完全逆序，复杂度为 O(n2)；

数组平均插入复杂度未 O(n), 所以插入排序的平均复杂度为 O(n2)

选择排序

选择排序也分为已排序区间和未排序区间，每次选择未排序区间最小元素放到已排序区间的末尾

def selection_sort(nums: list[int]):
    for i in range(len(nums)-1):
        idx = i
        for j in range(i+1, len(nums)):
            if nums[j] < nums[idx]:
                idx = j
        nums[idx], nums[i] = nums[i], nums[idx]

选择排序是不稳定的算法，如 [5, 8, 5, 2, 9]

选择排序的最好/最坏/平均复杂度都为 O(n2)

第十二讲排序(下)

归并排序

归并排序利用分治的思想，并用递归的技巧来实现

def merge(left, right) -> list[int]:
    i, j = 0, 0
    res = []

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    while i < len(left):
        res.append(left[i])
        i += 1
    while j < len(right):
        res.append(right[j])
        j += 1
    return res


def merge_sort(nums: list[int]) -> list[int]:
    if len(nums) < 2:
        return nums
    mid = len(nums) // 2
    return merge(merge_sort(nums[:mid]), merge_sort(nums[mid:]))

归并排序的空间复杂度未 O(n) (临时空间使用后就释放了)

归并排序的最好/最坏/平均复杂度都为 O(nlogn)

快速排序

快速排序是不稳定的排序算法

归并排序平均复杂度都为 O(nlogn), 但极极端情况可能退化未 O(n2), 比如数组本身有序，又选择最后一个元素作为 pivot 的情况

def partition(nums: list[int], l: int, r: int) -> int:
    pivot = nums[r]
    i = l
    for j in range(i, r):
        if nums[j] < pivot:
            nums[j], nums[i] = nums[i], nums[j]
            i += 1
    nums[i], nums[r] = nums[r], nums[i]
    return i

def _quick_sort(nums: list[int], l: int, r: int):
    if l >= r:
        return
    idx = partition(nums, l, r)
    _quick_sort(nums, l, idx-1)
    _quick_sort(nums, idx+1, r)


def quick_sort(nums: list[int]):
    _quick_sort(nums, 0, len(nums)-1)

第十三讲线性排序

桶排序（Bucket Sort）

假设有 n 个数据，均匀地分布到 m 个桶内，每个桶内有 k = n/m 个元素，每个桶使用快排排序，复杂度为 O(klogk)，总复杂度为 O(nlog(n/m))，当 m 接近 n 时，log(n/m) 是个非常小的常量，所以复杂度接近 O(n)

桶排序的前提条件是数据能均匀分布在每个桶中，并且桶与桶之间有大小顺序。极端情况如果数据分布在一个桶中，复杂度退化为 O(nlogn)

桶排序适合外部排序

计数排序（Counting Sort）

计数排序是一种特殊的桶排序，相当于每个桶中的数据都是相同的值。

def counting_sort(nums: list[int]):
    m = max(nums)

    c = [0 for _ in range(m + 1)]

    for num in nums:
        c[num] += 1

    for i in range(1, m + 1):
        c[i] += c[i - 1]

    r = [0 for _ in range(len(nums))]
    for i in range(len(nums) - 1, -1, -1):
        idx = c[nums[i]] - 1
        r[idx] = nums[i]
        c[nums[i]] -= 1

    for i in range(len(nums)):
        nums[i] = r[i]

计数排序适用于数据范围不大的非负整数的场合

基数排序（Radix Sort）

基数排序要求数据可以分割出独立的位来比较，且位的范围不大

第十四讲快速排序优化

优化分区点

如果数组原本就是有序的，且分区点都取最后一个，这样复杂度就会退化到 O(n2)。

有两种简单的优化方式

三数取中法：从区间前中后取三个数，比较大小选中间的那个
随机法

glibc qsort 的优化方式

数据量不大的时候使用归并排序
使用三数取中法
快排区间小于4时使用插入排序，并使用哨兵机制来优化
在堆上实现栈，避免过深的递归导致栈溢出

第十五讲二分查找

二分查找的依赖条件是：数据有序且可以随机访问

对于不存在重复元素的解法：

def binary_search(nums: list[int], v: int) -> int:
    l, r = 0, len(nums)-1

    while l <= r:
        m = (l+r)//2
        if nums[m] == v:
            return m
        elif nums[m] < v:
            l = m+1
        else:
            r = m-1
    return -1

存在重复元素的第一个值：

def binary_search(nums: list[int], v: int) -> int:
    l, r = 0, len(nums)-1

    while l <= r:
        m = (l+r)//2
        if nums[m] == v:
            if m == 0 or nums[m-1] != v:
                return m
            else:
                r = m - 1
        elif nums[m] < v:
            l = m+1
        else:
            r = m-1
    return -1

存在重复元素的最后一个值：

def binary_search(nums: list[int], v: int) -> int:
    l, r = 0, len(nums)-1

    while l <= r:
        m = (l+r)//2
        if nums[m] == v:
            if m == len(nums)-1 or nums[m+1] != v:
                return m
            else:
                l = m + 1
        elif nums[m] < v:
            l = m+1
        else:
            r = m-1
    return -1

存在重复元素的大于等于的第一个值：

def binary_search(nums: list[int], v: int) -> int:
    l, r = 0, len(nums)-1

    while l <= r:
        m = (l+r)//2
        if nums[m] >= v:
            if m == 0 or nums[m-1] < v:
                return m
            else:
                r = m - 1
        else:
            l = m+1
    return -1

存在重复元素的小于等于的最后一个值：

def binary_search(nums: list[int], v: int) -> int:
    l, r = 0, len(nums)-1

    while l <= r:
        m = (l+r)//2
        if nums[m] <= v:
            if m == len(nums)-1 or nums[m+1] > v:
                return m
            else:
                l = m + 1
        else:
            r = m-1
    return -1

第十七章跳表

通过给链表添加索引，这样就可以实现快速增删查

通过随机函数确定插入在哪一层

// https://github.com/MauriceGit/skiplist
func (t *SkipList) generateLevel(maxLevel int) int {
	level := maxLevel - 1
	// First we apply some mask which makes sure that we don't get a level
	// above our desired level. Then we find the first set bit.
	var x uint64 = rand.Uint64() & ((1 << uint(maxLevel-1)) - 1)
	zeroes := bits.TrailingZeros64(x)
	if zeroes <= maxLevel {
		level = zeroes
	}

	return level
}

redis 作者回答 zset 选用跳表的理由：

// https://news.ycombinator.com/item?id=1171423

antirez on March 6, 2010 | root | parent | next [–]
 
There are a few reasons:
1) They are not very memory intensive. It's up to you basically. Changing parameters about the probability of a node to have a given number of levels will make then less memory intensive than btrees.

2) A sorted set is often target of many ZRANGE or ZREVRANGE operations, that is, traversing the skip list as a linked list. With this operation the cache locality of skip lists is at least as good as with other kind of balanced trees.

3) They are simpler to implement, debug, and so forth. For instance thanks to the skip list simplicity I received a patch (already in Redis master) with augmented skip lists implementing ZRANK in O(log(N)). It required little changes to the code.

第十八章散列表（上）

散列表是基于数组的随机访问特性，利用散列函数，将数据映射到数组的某个位置

散列冲突

常用的解放方案有开放寻址法（open addressing）和链表法（chaining）

开放寻址法

最简单的一种开放寻址法为线性探测：如果位置被占用，会继续寻找。

二次探测 quadratic probing: 步长变为步数的平方，如 hash(x) + 0、 hash(x) + 1^2、hash(x) + 2^2 双重散列 double hashing: 使用多个散列函数，第一个发现占用后，使用第二个

链表法

链表法将散列值相同的数据放在同一个链表中

查找和删除的复杂度和链表长度 k 成正比，即 O(k)

第十九章散列表（中）

哈希函数设计

不过太耗时
尽可能随机且随机分布

扩容

扩容时，只申请空间，不搬迁数据。

当插入数据时，将数据插入新的表，并搬迁一个旧表的值到新表
查询数据时，先查新表，没查到再查旧表

Java HashMap 实现优化

采用链表法解决冲突，链表长度超过8时改用红黑树

第二十一讲哈希算法（上）

定义

将任意长度的二进制值串映射为固定长度的二进制值串的规则称为哈希算法。

优秀哈希算法要求

单向，不可从哈希值推导出原始值
对数据敏感，差了一个 bit 的两个数据的哈希值大不相同
冲突概率非常小
执行效率高效

应用场景

安全加密，md5 哈希值有 2^128 种可能
唯一标识
数据校验
散列函数

第二十二讲哈希算法在分布式服务中的应用

负载均衡

对客户端会话ID 或者 IP 地址计算哈希值，然后对服务器列表大小进行取余，得到列表索引位置。

数据分片

分布式存储

一致性哈希算法示例： GeeCache一致性哈希

第二十三章二叉树

树的相关概念

根节点：没有父节点的节点叶子节点：没有子节点的节点

高度、深度和层的示意如下图

二叉树

完全二叉树：叶子节点都在最后两层，最后一层的叶子节点都靠左排列，除了最后一层，其他层节点的个数要达到最大

满二叉树：叶子节点都在最后一层，除了叶子节点之外，每个节点都有两个子节点

链式存储方式

使用链表来存储，每个节点有三个字段，一个字段存储数据，另外两个字段分别指向左右子节点

顺序存储方式

根节点存储下标为 1 的位置，左节点存在下标为 2i 的位置，右节点存储在 2i+1 的位置

遍历

二叉树有三种经典的遍历方式：前序遍历、中序遍历、后续遍历

第二十四章二叉查找树

二叉查找树：对于任意一个节点，其左子树的每个节点均小于它，右子树的每个节点都大于它

查找操作

从根节点出发，如果等于要找的数据则返回，如果小于则从左子树找，否则从右子树找。

插入操作

从根节点出发，如果大于根节点，当右节点为空，则直接插到右节点的位置，否则遍历右子树；如果小于根节点，当左节点为空，则直接插到左节点的位置，否则遍历左子树。

删除操作

当目标节点没有子节点，将其父节点指向的指针置为空
当目标节点有一个子节点，将其父节点指向的指针指向目标节点的子节点
当目标节点有两个子节点，用目标节点右子树的最小节点来替换目标节点

第二十五章平衡二叉查找树

极端情况下二叉查找树会退化成链表，所以需要设计平衡二叉树来避免性能退化的问题。

平衡二叉树的严格定义：任何一个节点的左右子树的高度差值不能大于一。

AVL 树完全满足平衡二叉树的严格定义，查找效率高，但为了维持这种高度的平衡，每次插入和删除都要调整，比较复杂和耗时。

红黑树只做到了近似平衡，在维护平衡的成本上，比 AVL 树的成本低。所以查找、插入和删除操作的性能都比较稳定

红黑树中有两种颜色的节点：黑色、红色，节点具有有如如下要求：

根节点是黑色的
每个叶子节点都是黑色的空节点
相邻节点不能同时为红色，即红色节点被黑色隔开
每个节点，其到达叶子节点的所有路径中黑色节点的数量是一样的

链接

NATS 学习笔记

Thu, 01 Jun 2023 08:31:17 +0800

Quality of Service (QoS)

At most once

Core NATS is a fire-and-forget messaging system. It will only hold messages in memory.

If a subscriber is not listening on the subject, or is not active when the message is sent, the message is not received.

At least/ exactly once

JetStream support higher qualities of service (at least once and exactly once)

Subject-based Messaging

消息基于 Subject 匹配和传递

特殊符号

.作为 token 分隔符
*正则匹配一个 token
> 正则匹配一个或者多个 token，且只能位于末尾

Core NATS

基于at most once 的服务质量，Core NATS 有三种消息传递模式

publish-subscribe
request-reply
queuing

Publish-Subscribe 是一对多的通讯模式，一个发送者在一个 Subject 上发送的消息，任何活跃的订阅这个 Subject 的接收者都会收到消息

Request-Reply

Request-Reply 建立在 Publish-Subscribe 基础之上，接受者在收到消息后，会像 Reply subject 发送响应消息

Queue Groups

Queue Groups 建立在 Request-Reply 基础之上，当有多个接收者时，这些接收者就形成了一个 Queue Group，每次消息会随机有一个接受者来消费消息

JetStream

JetStream 是建立在 Core NATS 上的分布式持久系统，需要 1、3 或 5 个 server (分别容忍 0、1 和 2 个 server 挂掉)

Stream

存储类型

File
Memory

保留策略

LimitsPolicy: MaxMsgs, MaxBytes, MaxAge, and MaxMsgsPerSubject
InterestPolicy: 当没有消费者消费或者所有消费者消费了，消息会删除
WorkQueuePolicy: 每个消息只能被消费一次，一个 WorkQueue 只能有一个消费者

丢弃策略

DiscardOld
DiscardNew

Consumer

Ack 策略

AckExplicit: 每个消息都 Ack
AckNone: 无 Ack
AckAll: Ack 最后收到的一个消息

Deliver 策略

DeliverAll: 接收所有消息
DeliverLast: 接收最新的消息
DeliverNew：接收 Consumer 创建之后的消息
DeliverByStartSequence：接收指定 OptStartSeq 之后的消息
DeliverByStartTime：接收指定 OptStartTime 之后的消息

MaxAckPending

最大 Pending 数量，超过则不再传递消息

KV 存储

JetStream 可以提供 KV 功能，具体包括增删改查，甚至可以监听 key的改动、获取 value 的历史版本

协议

NATS 使用文本格式的协议，基于 TCP 进行通信。以换行符做消息分隔符，以空格或制表符作为字段分隔符。

可以直接使用 telnet 或者 netcat 作为客户端直接和服务段交互

`1`	`nc -c localhost 4222`

具体操作符类型如下：

类型	发送方	语法	备注
INFO	Server	`INFO {"option_name":option_value,...}␍␊`	连接建立之后发送
CONNECT	Client	`CONNECT {"option_name":option_value,...}␍␊`	指定连接信息
PUB	Client	`PUB <subject> [reply-to] <#bytes>␍␊[payload]␍␊`	发布消息到服务段
SUB	Client	`SUB <subject> [queue group] <sid>␍␊`	订阅消息
UNSUB	Client	`UNSUB <sid> [max_msgs]␍␊`	取消订阅消息
MSG	Server	`MSG <subject> <sid> [reply-to] <#bytes>␍␊[payload]␍␊`	转发消息给客户端
PING	Both	`PING␍␊`	心跳请求
PONG	Both	`PONG␍␊`	心跳相应
+OK	Server	`+OK␍␊`	确认消息，verbose 模式才有
-ERR	Server	`-ERR <error message>␍␊`	错误

源码阅读

数据解析

基于一个有限状态机，接受到的数据会一个字符一个字节去录入和转移状态

for i = 0; i < len(buf); i++ {
    b = buf[i]

    switch c.state {
    case OP_START:
       ...
    case OP_P:
        switch b {
        case 'U', 'u':
            c.state = OP_PU
        case 'I', 'i':
            c.state = OP_PI
        case 'O', 'o':
            c.state = OP_PO
        default:
            goto parseErr
        }
    case OP_PU:
        switch b {
        case 'B', 'b':
            c.state = OP_PUB
        default:
            goto parseErr
        }
    case OP_PUB:
        switch b {
        case ' ', '\t':
            c.state = OP_PUB_SPC
        default:
            goto parseErr
        }
    ...
    default:
        goto parseErr
    }
}

订阅列表

订阅列表使用前缀树来维护

type node struct {
	next  *level
	psubs []*subscription
	qsubs [][]*subscription
}

type level struct {
	nodes    map[string]*node
	pwc, fwc *node  // pwd、fwc 分别表示 '*' 和 '>' 订阅
}

插入操作

l := s.root
var n *node

for _, t := range tokens {
    if len(t) == 0 || sfwc {
        s.Unlock()
        return ErrInvalidSubject
    }

    switch t[0] {
    case pwc:
        n = l.pwc
    case fwc:
        n = l.fwc
        sfwc = true
    default:
        n = l.nodes[t]
    }
    if n == nil {
        n = newNode()
        switch t[0] {
        case pwc:
            l.pwc = n
        case fwc:
            l.fwc = n
        default:
            l.nodes[t] = n
        }
    }
    if n.next == nil {
        n.next = newLevel()
    }
    l = n.next
}
if sub.queue == nil {
    n.psubs = append(n.psubs, sub)
} else {
    // This is a queue subscription
    if i := findQSliceForSub(sub, n.qsubs); i >= 0 {
        n.qsubs[i] = append(n.qsubs[i], sub)
    } else {
        n.qsubs = append(n.qsubs, []*subscription{sub})
    }
}

删除操作

sfwc := false
l := s.root
var n *node

// Track levels for pruning
var lnts [32]lnt
levels := lnts[:0]


for _, t := range tokens {
    if len(t) == 0 || sfwc {
        return ErrInvalidSubject
    }
    if l == nil {
        return ErrNotFound
    }
    switch t[0] {
    case pwc:
        n = l.pwc
    case fwc:
        n = l.fwc
        sfwc = true
    default:
        n = l.nodes[t]
    }
    if n != nil {
        levels = append(levels, lnt{l, n, t})
        l = n.next
    } else {
        l = nil
    }
}


// 反向删除记录
for i := len(levels) - 1; i >= 0; i-- {
    l, n, t := levels[i].l, levels[i].n, levels[i].t
    if n.isEmpty() {
        l.pruneNode(n, t)
    }
}

查找操作

// matchLevel is used to recursively descend into the trie.
func matchLevel(l *level, toks []string, results *SublistResult) {
	var pwc, n *node
	for i, t := range toks {
		if l == nil {
			return
		}
		if l.fwc != nil {
			addNodeToResults(l.fwc, results)
		}
		if pwc = l.pwc; pwc != nil {
			matchLevel(pwc.next, toks[i+1:], results)
		}
		n = l.nodes[t]
		if n != nil {
			l = n.next
		} else {
			l = nil
		}
	}
	if n != nil {
		addNodeToResults(n, results)
	}
	if pwc != nil {
		addNodeToResults(pwc, results)
	}
}

集群

集群节点两两之间会建立一个类型为 ROUTER 的 Client。

建立连接后，会通过 SUB 类型消息告知当前节点订阅列表

func (s *Server) sendLocalSubsToRoute(route *client) {
	b := bytes.Buffer{}
	s.mu.Lock()
	for _, client := range s.clients {
		client.mu.Lock()
		subs := make([]*subscription, 0, len(client.subs))
		for _, sub := range client.subs {
			subs = append(subs, sub)
		}
		client.mu.Unlock()
		for _, sub := range subs {
			rsid := routeSid(sub)
			proto := fmt.Sprintf(subProto, sub.subject, sub.queue, rsid)
			b.WriteString(proto)
		}
	}
	s.mu.Unlock()

	route.mu.Lock()
	defer route.mu.Unlock()
	route.sendProto(b.Bytes(), true)
}

当有新的节点加入后，会转发新节点的信息

func (s *Server) forwardNewRouteInfoToKnownServers(info *Info) {
	s.mu.Lock()
	defer s.mu.Unlock()

	b, _ := json.Marshal(info)
	infoJSON := []byte(fmt.Sprintf(InfoProto, b))

	for _, r := range s.routes {
		r.mu.Lock()
		if r.route.remoteID != info.ID {
			r.sendInfo(infoJSON)
		}
		r.mu.Unlock()
	}
}

当普通 Client 有新的订阅时，Route Client 会转发消息到所有其他节点

// sid 会被重新， 添加 RSID 前缀和客户端信息等
func routeSid(sub *subscription) string {
	var qi string
	if len(sub.queue) > 0 {
		qi = "Q"
	}
	return fmt.Sprintf("%s%s:%d:%s", qi, RSID, sub.client.cid, sub.sid)
}


func (s *Server) broadcastInterestToRoutes(proto string) {
	var arg []byte
	if atomic.LoadInt32(&s.logging.trace) == 1 {
		arg = []byte(proto[:len(proto)-LEN_CR_LF])
	}
	protoAsBytes := []byte(proto)
	s.mu.Lock()
	for _, route := range s.routes {
		// FIXME(dlc) - Make same logic as deliverMsg
		route.mu.Lock()
		route.sendProto(protoAsBytes, true)
		route.mu.Unlock()
		route.traceOutOp("", arg)
	}
	s.mu.Unlock()
}

发布消息时，如果是 Route 类型的客户端，会对remoteID 做去重，以免给同一个 Route 客户端发送多次。并且消息只会从普通客户端发送到 Route 客户端，不会出现 Route 客户端再发到 Route 客户端的情况

// processMsg is called to process an inbound msg from a client.
func (c *client) processMsg(msg []byte) {
    var r *SublistResult
    isRoute := c.typ == ROUTER
    
    for _, sub := range r.psubs {
        // Check if this is a send to a ROUTER, make sure we only send it
		// once. The other side will handle the appropriate re-processing
		// and fan-out. Also enforce 1-Hop semantics, so no routing to another.
		if sub.client.typ == ROUTER {
		    // 只会转发一次
			if isRoute {
				continue
			}
			
			// route 去重
			if _, ok := rmap[sub.client.route.remoteID]; ok {
				c.Debugf("Ignoring route, already processed")
				sub.client.mu.Unlock()
				continue
			}
			rmap[sub.client.route.remoteID] = routeSeen
			sub.client.mu.Unlock()
		}
		// Normal delivery
		mh := c.msgHeader(msgh[:si], sub)
		c.deliverMsg(sub, mh, msg)
	}
}

Reference

迁移Python项目到Golang

Fri, 12 May 2023 07:40:27 +0800

前言

最近在用 Golang 重构一个 Python web 项目，之前后端主要的技术栈是 flask+sqlalchemy+celery，综合现有情况，我选择了使用 gin+gorm+cron 来做相应替换。但重构过程中发现某些功能在 Golang 生态中并不是那么完善，需要自己进行二次开发，主要是在 ORM 和定时任务这两块。

ORM

Model 生成

Model 生成有比较完善的工具 gen，通过读数据库schema信息直接生成 Struct。一些常用的配置：

WithDataTypeMap 用来做类型映射，如bigint 映射成 int
WithJSONTagNameStrategy 用来设置 json tag 生成规则，如 password 字段的 tag 设置成-
WithImportPkgPath 用来添加第三包引入，如使用了 decimal 类型的话需要引入decimal
gen.WithMethod option 来添加自定义方法

Migration

Golang 中比较广泛使用的三个方案有 golang-migrate、goose 和 atlas，但大多需要自己手写 SQL，远没有 Python 中的 alembic 简单好用。后面查阅了一番文档，atlas 还是可以通过 gorm Model 来生成 migration SQL，只是步骤复杂了点。

生成 migration SQL

使用 gorm db.AutoMigrate 方法将所有 Model生成到一个临时的数据库中
使用 atlas migrate diff 对比 migrations 文件夹和临时数据库表结构的差别从而生成 migration SQL

升级

使用 atlas migrate apply 1 命令升级一个版本

降级

找到上一个版本号prevVersion
使用atlas schema apply 命令，其中 --to 参数中指定 version=${prevVersion}
使用atlas migrate set ${prevVersion}来设置当前版本

定时任务

cron 代码简洁明了， cron.Recover和cron.SkipIfStillRunning 插件功能也很实用。

REST 接口

基于使用场景我做了一下封装，添加了一些 REST 接口：

调用 cron.Remove和 cron.Add 来实现动态停止和启动 Job,
获取已注册 Job 列表
单次运行 Job

Job 扩展

默认的 Job只有 EntryID 信息，所以做了如下扩展。

type Job interface {
	Run()
	ID() int
	Name() string
	Schedule() string
	Remark() string
}

2022年终总结

Sat, 31 Dec 2022 09:39:13 +0800

工作

今年工作的关键词是重构。编程语言由 python 转 go，引入了消息队列 ~~kafka~~ nats，一个人吭哧吭哧写了半年，将核心组件和业务重新设计了一遍，并顺利落地。我一方面很享受决策自由，以及看到重构完成后的简洁优雅带来的满满成就感；另一方面感到孤独，不过好在有 github、优质博客等供我学习和激发灵感。

今年六月底公司开始执远程工作制度，经过半年的体验，我确定我目前的岗位和我个人都挺适合远程办公的。之于岗位，首先我们组非常小巧而独立，几乎不依赖公司其他组同事，组内大概就是每天开5分钟晨会；其次某种层面来说我们组的主要工作成果可以通过数字直接考量，简单来说就是贡献了多少成交量和盈亏了多少钱。之于个人，我有足够的能力和意愿去解决当前工作中的大部分问题；我是一个内向型人格，我享受独处；我追求工作上的成就感，如果工作让我感受不到自己的价值和成长，我会主动离开。

今年组内入职了两个新同事。一个同事试用期后离开了，作为面试参与者反思了一下，面试时技术能力和行事风格的考量不应该被一些简历标签所影响。另外一个同事则相处融洽，且让我们提升了不少战斗力。

今年行业环境极其寒冷，各种重大事故不胜其数，谁会相信市值第五大代币崩盘？谁会相信第二大交易所会破产？或许明年的寒意还会更胜？

生活

今年上半年基本是做核酸扫场所码度过的。某一天出门时还好好的，下班时却发现住的地方被封控只进不出，我想了大概3秒，对我来说最好的选择还是得选择"进"。连续封控的那十八天虽然不能出门，但物资不缺，少了通勤时间，感觉一天时间变长了，有时间自己做饭，心情也很平静。

六月底开始远程办公后我想着何不回家住会呢？当时以为自己待不了多久，没带多少行李，踩着双拖鞋就回家了，没想到至今我都没有再返回深圳。回家住这么久最大的收获就是重新和我爸认识了解了一遍；其次就是吃了各种很多年没有吃过的应季食物吧。

在农村就久住就会发现出门没有车实在不方便，于是在九月初买了车。开始我想我这技术最远去个县城就顶天了，没想到一个月之后就怀着忐忑的心情独自一个人北上去了长沙，但在长沙两个月我就开了2次车，哈哈。在长沙见了几次同学，感受了一下他们的生活状态；住在湘江边上的安置小区，很多本地人，坐在宣传栏边上聊天的大妈都是人手一栋楼，你停下来看租房广告便会问你要什么样的户型的；一个偶尔的机缘我报了一门口语课，这是我第一次上口语课，算是很新鲜的体验吧，上课确实算一种和一个新地方建立连接的方式，尤其是口语课，顺着课程话题就认识了解老师和同学的经历了。

今年跑步跑了 320 公里，里程数相比去年少，主要还是因为在农村不太方便跑步。

今年看的书也比较少，最推荐的书是《也许你该找个人聊聊》，一些笔记：

我们是在人与人的关系中成长的
我们大多数人的心中都会有个"他们"，即使并没有谁在观察我们的生活
我意识到，即使到了七十岁，你的心还是会像十七岁时一样脆弱，容易受伤，充满渴望和激情
当人们不知道改变会带来什么的时候，往往不愿意放弃现有的东西，这个阶段的痛点是改变意味着失去，而新情况有又叫人不安
我们以为罗列遗愿清单是为了避免遗憾，但事实上我们是在靠它回避死亡
痛苦没有高低等级之分

今年年假还一天没用，利用周末和法定节假日就近旅行也玩耍了不少，上半年跟着前同事自驾游了 2 次；下半年和家人去了一下衡山、曾国藩故居，自己又独自爬了曾国藩古道。

今年世界杯我一场没看，但我看了很多 LOL 的比赛，夏季赛和世界赛都很精彩，谁能想到 4 号种子能逆袭夺冠呢？

今年的最后一个周一，至今没有打疫苗的我终于感染了新冠，头两天发烧头痛，第三天好了之后开始咳嗽和嗓子疼，整体上影响不大了。

展望

多找人聊聊天
日常跑步，参加一次半马
日常英语练习，精读《How I Met Your Mother》Season 1
带家人旅行一次
深度学习一下 nats，至少产出一篇文章
入门一下 C++，了解其优劣

nats丢消息排查小记

Tue, 13 Dec 2022 09:24:20 +0800

背景

最近我们把消息队列从 kafka 迁移到 nats, 主要原因是kafka的延迟不能忍受，5ms 其实也不小了，但在几千上万个 topic 的情况下，延迟有时会上升至数百 ms（我猜 topic 多的情况下顺序写的优势不再存在）。迁移到 nats 之后，使用 Publish-Subscribe 的延迟大概就 1ms, 真香！

但小部分场景需要用到 JetStream 来做持久化，使用了 JetStream 一段时间后发现，每天会随机的丢几条消息，发生的时间完全没有规律。

排查过程

通过命令行查 Stream 消息，发现丢失的消息是有被持久化的，所以问题要么出在服务端：没有把消息发送给客户端；要么客户端把消息弄丢了。大概看了一些服务端的代码，感觉没有头绪，想想还是从客户端入手比较简单。

首先在客户端接收原始消息那里加了一行日志，经过核对发现客户端确实收到了消息，但没有返回到上层，中间某个地方把消息弄丢了。

再看丢消息的时间点刚好在超时时间的临界点，猜想应该是超时处理的时候把消息丢了。于是写了一个消费者测试代码，把超时时间从 1 秒调到 0.1 秒，发现丢消息的概率显著提升。

最后确实发现了丢消息的地方（代码）。

但中间由于我加 debug 日志不够，产生了一个让我费解的疑问。具体如下：

我在 164、167、174 行加了 debug 代码。

从日志截图来看，代码运行到 164 后直接到了 174 行，167 行没有被运行。这里让我很不接，明明没有协程切换，为什么 167 行没有执行到。

知道在前同事群里请教，才发现是 166 行 set_result 报错了，所以没有执行到 167 行。

消除这个疑问之后，发现了问题的本源：

获取消息超时后，会取消future，但问题是取消的过程中可能发生协程切换，如果切换到 pending_queue.get()这个协程方法，就会导致丢掉一条消息。

你好！三十岁

Tue, 02 Aug 2022 06:30:31 +0800

不曾想到今年可以有机会在家远程工作，好似迎来了一个久违的"暑假"，而在这期间三十岁也向我招来了手。虽然我不怎么过生日，也不怎么吃蛋糕，但还是想在这个节点用文字来回顾来时路，记录当下时，展望未来希。

我应该从小算一个偏内向、简单、不捣蛋的小孩。不知道是不是晚一年上学的缘故，一开始学习上就比较顺利，考试拿第一名，当班长帮老师打杂。我家的教育方针应该是那种能读就读的放任自然式，拿了奖状回家也没有奖励那种。然后有三五个从幼儿园到初中同路上学的玩伴，其实整体上我的学校生活还是蛮轻松愉快的。

十岁那年算我家发生变故的一年，妈妈突然去世，几个月之后奶奶突发眼疾彻底失明。我当然没有一夜长大的觉悟，继续和同伴上学放学，只不过不再回自己家，而是去伯伯们家，奶奶轮到哪个伯伯照顾，我就跟着去哪家，所以我可以算吃四家饭长大的。伯伯们其实都还算好，不过由此变得敏感一些是难免的。

夸张一点说我和奶奶从此算是相依为命了，我成了奶奶的眼睛，奶奶成了我的港湾。俨然奶奶是那个无条件爱我的人，那些放学回家特意留给我的零食、那把夏天驱蚊的蒲扇、那些冬天为我烤干的湿袜子，以及奶奶那份至死保留的独立精神，都沉淀在的我人生底色中。

稍微长大的我还是想去外面看看，高考没有填一个省内志愿，大学毕业也想着既然在华东读书，也在华东工作看看。

工作后的第二个春节回家，我已经感受到奶奶已经快走到尽头了，我也感受到工作的城市即使有大学室友、胜似同学的同事仍感受不到归属感。于是辞了工作，家里蹲了半年，陪奶奶过了九十岁生日，自己重新归零学习另外一个领域的东西转行。

奶奶离开后，我有两年春节没有回家，因为我觉得春节就是在急急忙忙地走过场没有意思，但今年我回了，主要原因是我接纳了爸爸，也看到了他需要我。

重塑父子关系应该算很要的人生功课。我和爸爸缺失了太多相处时光，由此产生了很多隔阂。我觉得他有很多做的不好的地方，比如喝酒逞强把自己喝醉然后再睡一天觉、屁股粘在牌桌上而没有时间陪伴家人。我也缺乏很多对他的了解，比如我不知道他中年丧妻当时是什么感受怎么走过来的、如何面对衰老和其带来劳动价值的完全丧失。

我想人是会变的。以前我可能会趁着远程办公的机会去某个远方旅居一段时间，而这次我选择了回家。自己开玩笑说可能过不了几天会被爸爸赶出来，但是并没有，我和爸爸两个人相处得很好，可能我们都变了。我之前会想要是奶奶还在就好了，现在也释怀了，奶奶离开对她也算一种解脱，而我要怀着期许好好活着。母胎单身的我今年居然告了个白，虽然略显尴尬，但把心里话说出来，心结就解开了。

最近的状态就是六点起床，二十二点睡觉的节奏，我其实很享受这样的节奏。我几乎不依赖博物馆、图书馆、电影院、酒吧、咖啡馆、外卖等城市资源；相比有些吵闹的大开间办公空间，我更喜欢安静的环境。最近工作也进入了一个甜蜜期，有机会用一个新语言按自己的想法重新写一套新系统，从五一开动，到现在大体雏形完成。

聊一嘴未来，大环境下金融危机、战争可能随时会来；抵不过社会运转规律，方言会消失，农村会凋零，想想有点悲凉。还是希望世界和平、社会更加开放和包容。对于个人，希望家人平安健康，希望能找到人生队友，希望工作顺利。

[笔记]k8s入门

Sun, 24 Jul 2022 10:50:35 +0800

第零讲环境准备

使用 virtualbox 安装 ubuntu 虚拟环境

个人采坑记录

共享粘贴板设置

配置了双向粘贴版和安装 apt install virtualbox-guest-utils 还是不行，每次得手动启动 VBoxClient --clipborad. 通过 df -h 查看目录找到挂载的脚步在 /media/ubuntu/VBox_GAs_6.1.34/ 目录后面卸载 virtualbox-guest-utils，运行 sh /media/ubuntu/VBox_GAs_6.1.34/VBoxLinuxAdditions.run 安装才可以

第一讲初始容器

sudo usermod -aG docker ${USER} 将当前用户加入 docker 组，然后重启，否则需要 root 权限。

docker version 查看客户端和服务端版本信息

docker info 查看服务端系统信息

第二讲被隔离的进程

容器就是一个特殊的隔离环境，它能够让进程只看到这个环境里的有限信息。

隔离实现基于 Linux 提供的三种技术：

namcespace：资源隔离
cgroup：配额限制
chroot：文件系统根目录限制

第三讲 docker 实用命令

常用镜像操作命令

常用容器操作命令

第四讲 Dockerfile 编写

镜像是由许多只读层堆叠起来的

可以通过 docker inspect命令查看镜像的分层信息

示例


# Dockerfile
# docker build -t ngx-app .
# docker build -t ngx-app:1.0 .

ARG IMAGE_BASE="nginx"
ARG IMAGE_TAG="1.21-alpine"

FROM ${IMAGE_BASE}:${IMAGE_TAG}

COPY ./default.conf /etc/nginx/conf.d/

RUN cd /usr/share/nginx/html \
    && echo "hello nginx" > a.txt

EXPOSE 8081 8082 8083

第五讲镜像仓库

镜像仓库 registry 是提供镜像服务的网站，如上传、下载镜像等

Docker Hub 是当前最大的镜像仓库，上面有官方镜像、认证镜像、非官方镜像等

名字规则： user/image:tag

离线环境可以使用归档命令来共享

1
2
3

docker save ngx-app:latest -o ngx.tar

docker load -i ngx.tar

第六讲容器如何如外接互通

如何拷贝容器内数据

宿主机到容器

`1`	`docker cp a.txt 062:/tmp`

容器到宿主机

`1`	`docker cp 062:/tmp/a.txt ./b.txt`

如何共享文件目录

volume 挂载

`1`	`docker run -v host_path:container_path image:tag`

如何网络互通

host 模式

`1`	`docker run -d --rm --net=host nginx:alpine`

对比 ip addr命令在宿主机和容器的结果，可以发现是相同的

bridge 模式

桥接模式类似现实世界的交换机，不过是由软件虚拟出来的，容器和宿主机通过虚拟网卡接入网桥 docker0，收发网络包

`1`	`docker run -d --rm --net=bridge nginx:alpine`

使用 -p host_port:container_port 映射宿主机和容器端口

第九讲本机搭建 k8s 环境

使用 minikube

启动 minikube

`1`	`minikube start --kubernetes-version=v1.23.3 --image-mirror-country=cn`

启动容器服务

1
2
3

alias kubectl="minikube kubectl --"

kubectl run ngx --image=nginx:alpine

第十讲 k8s 工作机制

k8s 有许多模块组成，这些模块可分为组件（component）和插件（addon）两类

master 组件

apiserver

apiserver 是 k8s 系统唯一入口，对外提供了一些列 RESTful API，其他组件只能和它直接通信，相当于联络员

etcd

etcd 用来持久化存储系统里各种资源对象和状态，相当于配置管理员。其他组件想读写 etcd 的数据必须通过 apiserver

scheduler

scheduler 负责容器的编排工作，检查阶段的资源状态，把 pod 调度到最合适的节点运行，相当于部署人员。

controller-manager

controller-manager 负责维护容器和节点等资源状态，实现故障检测、服务迁移、应用伸缩等功能，相当于监控运维人员。

Node 组件

kubelet

kubelet 负责管理 Node 相关绝大部分操作， Node 上只有它与 apiserver 通信，实现状态报告、命令下发、启停容器等功能，相当于小管家。

kubelet 因为要管理整个节点，容器化会限制它的能力，所有运行在物理机上。

kube-proxy

kube-proxy 是 Node 的网络代理，转发 TCP/UDP 数据包，相当于专职小邮差

container-runtime

插件

比较重要的两个插件：DNS、Dashboard

第十一讲 API

YAML

k8s 使用 yaml 声明式（declarative）地描述资源

API 对象

k8s 在理论层面抽象出了许多个概念，用来描述系统的管理运维工作，这些概念叫做 “API 对象”。

可以使用kubectl api-resources 查看对象列表

如何描述 API 对象

命令式启动pod kubectl run ngx --image=nginx:alpine 可以改写成如下声明式配置

apiVersion: v1
kind: Pod
metadata:
  name: ngx-pod
  labels:
    env: demo
    owner: chrono

spec:
  containers:
    - image: nginx:alpine
      name: ngx
      ports:
        - containerPort: 80

可以将配置类比成 HTTP 报文，分为两部分

header: apiVersion, kind, metadata
body: spec

可以使用如下命令创建和删除资源

1
2
3

kubectl apply -f ngx-pod.yaml

kubectl delete -f ngx-pod.yaml

编写 yaml 技巧

使用kubectl api-resources查看对应的 API 版本和类型
使用kubectl explain 查看对应资源的详细说明
使用--dry-run=client -o yaml 生成 yaml 文件

第十二讲 Pod

Pod 是对容器的"打包"，是 k8s 最小的调度部署单位, 类似于 Linux 里面的进程组

如何使用 yaml 描述 Pod

Pod 有四个基本组成部分

apiVersion: 固定为 v1
kind：固定为 Pod
metadata:
- name: 指定名称，可以带 pod 后缀方便和其他资源区分
- labels: 标签，可添加任意的 key/value, 如 env=dev、region=north
containers: 容器列表
- image: 镜像
- name: 名字
- ports:对外暴露的端口
- imagePullPolicy: 镜像拉取策略，默认为 IfNotPresent, 本地不存在才会来取远程镜像
- env: 定义环境变量，运行时指定
- command: 容器启动时执行的命令，相当于Dockerfile 的 ENTRYPOINT
- args: command 参数，相当于 Dockerfile 的 CMD 指令

如何使用 kubectl 操作 Pod

使用 kubectl apply -f、kubectl delete -f 创建或删除 Pod

使用 kubectl logs 产看日志

使用 kubectl exec -it $pod -- sh 进入 Pod 内部

第十三讲 Job/CronJob

Job/CronJob 都属于离线业务，区别在于 Job 只运行一次

Job

Job yaml 相比 Pod, 区别在于 spec 使用 template 字段来定义 Pod

使用 kubectl apply -f job.yaml 启动 job

使用 kubectl get job 查看 job 状态使用 kubectl get pod 查看 job 中的 pod 的状态

部分离线作业重要字段

activeDeadlineSeconds: pod 超时时间
backoffLimit: pod 失败重试次数
completions: Job 需要完成运行多少个 Pod, 默认为1
parallelism: completions 对应的并发度

示例如下

apiVersion: batch/v1
kind: Job
metadata:
  name: sleep-job

spec:
  activeDeadlineSeconds: 15
  backoffLimit: 2
  completions: 4
  parallelism: 2

  template:
    spec:
      restartPolicy: OnFailure
      containers:
        - image: busybox
          name: echo-job
          imagePullPolicy: IfNotPresent
          command:
            - sh
            - -c
            - sleep $(($RANDOM % 10 + 1)) && echo done

CronJob

CronJob 其实组合了Job

第十四讲 ConfigMap/Secret

ConfigMap 保存明文配置， Secret 保存私密配置

ConfigMap

ConfigMap 可以使用 kubectl create cm info --from-literal=aa=bb --dry-run=client -o yaml > info-cm.ayml 创建模版

示例

apiVersion: v1
kind: ConfigMap
metadata:
  name: info

data:
  count: '10'
  debug: 'on'
  path: '/etc/systemd'
  greeting: |
        say hello to kubernetes.

创建和查看

kubectl apply -f info-cm.yaml

kubectl get cm

kubectl describe cm info

Secret

Secret 使用 kubectl create secret generic 创建模板

示例

apiVersion: v1
kind: Secret
metadata:
  name: user

data:
  name: cm9vdA==  # root
  pwd: MTIzNDU2   # 123456
  db: bXlzcWw=    # mysql

kubectl create secret generic user  --from-literal=aa=bb --dry-run=client -o yaml > user-secret.yaml

kubectl apply -f user-secret.yaml

kubectl get secret

kubectl describe secret user

使用

环境变量

使用 configMapKeyRef和secretKeyRef 来引用

apiVersion: v1
kind: Pod
metadata:
  name: env-pod

spec:
  containers:
  - env:
      - name: COUNT
        valueFrom:
          configMapKeyRef:
            name: info
            key: count
      - name: GREETING
        valueFrom:
          configMapKeyRef:
            name: info
            key: greeting
      - name: USERNAME
        valueFrom:
          secretKeyRef:
            name: user
            key: name
      - name: PASSWORD
        valueFrom:
          secretKeyRef:
            name: user
            key: pwd

    image: busybox
    name: busy
    imagePullPolicy: IfNotPresent
    command: ["/bin/sleep", "300"]

引用示意图如下

加载文件

Pod 可以挂载 Volume, 可以在 spec 中指定，在 containers引用

引用示意图如下

示意配置如下

apiVersion: v1
kind: Pod
metadata:
  name: vol-pod

spec:
  volumes:
  - name: cm-vol
    configMap:
      name: info
  - name: sec-vol
    secret:
      secretName: user

  containers:
  - volumeMounts:
    - mountPath: /tmp/cm-items
      name: cm-vol
    - mountPath: /tmp/sec-items
      name: sec-vol

    image: busybox
    name: busy
    imagePullPolicy: IfNotPresent
    command: ["/bin/sleep", "300"]

挂载后，ConfigMap 和 Secret 的键成了文件名，值成了文件内容

第十七讲搭建多节点 k8s 集群

实验环境准备

安装前

修改hostname, k8s 使用 hostname 来区分集群节点，所以 hostname 不能重名。

`1`	`sudo vim /etc/hostname`

安装 docker 运行时，将其 cgroup 的驱动程序改为 systemd

cat <<EOF | sudo tee /etc/docker/daemon.json
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

sudo systemctl enable docker
sudo systemctl daemon-reload
sudo systemctl restart docker

启用 br_netfilter 模块，使 k8s 能够检查和转发网络流量

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward=1 # better than modify /etc/sysctl.conf
EOF

sudo sysctl --system

关闭 swap，提升 k8s 性能

1
2

sudo swapoff -a
sudo sed -ri '/\sswap\s/s/^#?/#/' /etc/fstab

安装 kubeadm

更换 k8s 下载源

sudo apt install -y apt-transport-https ca-certificates curl

curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | sudo apt-key add -

cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
EOF

sudo apt update

下载 kubeadm

sudo apt install -y kubeadm=1.23.3-00 kubelet=1.23.3-00 kubectl=1.23.3-00

# 锁定版本，避免错误升级
sudo apt-mark hold kubeadm kubelet kubectl

下载镜像

由于 k8s 镜像在 google 镜像仓库 gcr.io，国内访问困难，改用国内镜像，然后使用 docker tag 改名

repo=registry.aliyuncs.com/google_containers

for name in `kubeadm config images list --kubernetes-version v1.23.3`; do

    src_name=${name#k8s.gcr.io/}
    src_name=${src_name#coredns/}

    docker pull $repo/$src_name

    docker tag $repo/$src_name $name
    docker rmi $repo/$src_name
done

安装 master 节点

# --pod-network-cidr 设置集群使用网段
# --apiserver-advertise-address 设置apiserver 地址
sudo kubeadm init \
    --pod-network-cidr=10.10.0.0/16 \
    --apiserver-advertise-address=192.168.10.210 \
    --kubernetes-version=v1.23.3

安装后复制 kubectl 配置文件

1
2
3

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

加入集群

1
2

kubeadm join 192.168.10.210:6443 --token tv9mkx.tw7it9vphe158e74 \
  --discovery-token-ca-cert-hash sha256:e8721b8630d5b562e23c010c70559a6d3084f629abad6a2920e87855f8fb96f3

安装网络插件，这里使用 flannel

使用配置模版 kube-flannel.yml, 修改网段

net-conf.json: |
  {
    "Network": "10.10.0.0/16",
    "Backend": {
      "Type": "vxlan"
    }
  }

应用

`1`	`kubectl apply -f kube-flannel.yml`

使用 kubectl get node 验证

安装 worker 节点

克隆 master 虚拟机，使用 kubeamd join 指令加入即可

第十八讲 Deployment

Deployment 主要用来管理在线业务 Pod

生成默认模版

`1`	`kubectl create deploy ngx-dep --image=nginx:alpine --dry-run=client -o yaml > ngx-dep.yaml`


apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: ngx-dep
  name: ngx-dep
  
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ngx-dep
      
  template:
    metadata:
      labels:
        app: ngx-dep
    spec:
      containers:
      - image: nginx:alpine
        name: nginx

replicas 表示副本数量

selector 作用是筛选出要被 Deployment 管理的 Pod 对象，下属 matchLabels 必须和 template 的 labels 完全相同

# 查看deploy状态
kubectl get deploy

# 使用标签筛选 pod
kubectl get pod -l app=ngx-dep

# 调整 replicas
kubectl scale --replicas=5  deploy ngx-dep

第十九讲 DaemonSet

介绍

DaemonSet 会在满足条件的所有节点上运行一个 Pod, 就像 Linux 系统里的守护进程（Daemon）

一些应用与节点存在绑定关系，如

网络应用 kube-proxy
监控应用 prometheus
日志应用 fluentd

DaemonSet 不可以用 kubectl create 创建模板，可以在 Deployment 模版上修改，主要区别就是 DaemonSet 没有 replicas 字段

taint 和 toleration

节点的标签有一个专门字段taint 污点来表述，Pod 可以配置 toleratoin 来筛选 taint

taint 可以在 kubectl describe node 查看

# 添加 taint
kubectl taint node master node-role.kubernetes.io/master:NoSchedule-

# 结尾加"-" 来移除 taint
kubectl taint node master node-role.kubernetes.io/master:NoSchedule-

可以 Pod 的 spec 下选择 taint

tolerations:
- key: node-role.kubernetes.io/master
  effect: NoSchedule
  operator: Exists

静态 Pod

静态 Pod 不受 k8s 系统管控，不与 apiserver 发生关系

对应配置文件默认存放在 /etc/kubernetes/manifests 目录下

如 master 节点的四个核心组件都是以静态 Pod 形式存在的

第二十讲 Service

Service 工作原理和 Nginx 差不多， k8s 会分给它一个静态 IP, 然后它再去自动管理维护后面动态变化的 Pod 集合，当客户端访问 Service，它根据某种策略把流量转发给后面某个 Pod.

可以使用如下命令创建 yaml 模版

`1`	`kubectl expose deploy ngx-dep --port=80 --target-port=80 --dry-run=client -o yaml`

配置中主要有两个关键字 selector 和 ports

查看 ngx-svc 详情

exec 到 pod 进行测试

k8s 会自动给对象分配域名,可以使用 ngx-svc等域名访问

service 默认为 ClusterIP 类型，即静态 IP 只能集群内部访问。可以使用 NodePort 类型，这样节点会提供一个对外暴露的端口指向该 service


apiVersion: v1
...
spec:
  ...
  type: NodePort

NodePort 类型有如下缺点：

端口有限，默认只在 30000~32767 范围分配
每个节点都开端口，提高了网络通信成本
需要对外暴露节点的 IP 地址，为了安全需要搭建一个反向代码，增加了复杂度。

第二十二讲实战演练

要点回顾

Service 是 Pod IP 地址的抽象，它拥有一个固定的 IP 地址，再使用 iptables 规则把流量负责均衡到后面的 Pod, 节点上的 kube-proxy 组件后实时维护被代理的 Pod 状态，保证 Service 只会转发给健康的 Pod

Service 还基于 DNS 插件支持域名，所以客户端不在需要关心 Pod 具体情况

Service 是四层的负载均衡，而 Ingress 是七层负责均衡

Ingress 需要 IngressController 和 IngressClass 配合工作

Controller 是真正的集群入口，应用 Ingress 规则调度、分发流量；此外还提供反向代理的角色
Class 是用来分组管理 Ingress

IngressController 本身也是一个 Pod, 需要通过 NodePort、LoadBalancer等方式暴露到集群外。

WordPress 网站搭建

1. 部署 MariaDB

---

apiVersion: v1
kind: ConfigMap
metadata:
  name: maria-cm

data:
  DATABASE: 'db'
  USER: 'wp'
  PASSWORD: '123'
  ROOT_PASSWORD: '123'
  
---

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: maria-dep
  name: maria-dep

spec:
  replicas: 1
  selector:
    matchLabels:
      app: maria-dep

  template:
    metadata:
      labels:
        app: maria-dep
    spec:
      containers:
        - image: mariadb:10
          name: mariadb
          ports:
            - containerPort: 3306

          envFrom:
            - prefix: 'MARIADB_'
              configMapRef:
                name: maria-cm
---

apiVersion: v1
kind: Service
metadata:
  labels:
    app: maria-dep
  name: maria-svc

spec:
  ports:
    - port: 3306
      protocol: TCP
      targetPort: 3306
  selector:
    app: maria-dep

使用 ConfigMap + Development + Service 的方式

`1`	`kubectl appy -f wp-maria.yaml`

2. 部署 WordPress

apiVersion: v1
kind: ConfigMap
metadata:
  name: wp-cm

data:
  HOST: 'maria-svc'
  USER: 'wp'
  PASSWORD: '123'
  NAME: 'db'

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: wp-dep
  name: wp-dep

spec:
  replicas: 2
  selector:
    matchLabels:
      app: wp-dep

  template:
    metadata:
      labels:
        app: wp-dep
    spec:
      containers:
        - image: wordpress:5
          name: wordpress
          ports:
            - containerPort: 80

          envFrom:
            - prefix: 'WORDPRESS_DB_'
              configMapRef:
                name: wp-cm

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: wp-dep
  name: wp-svc

spec:
  ports:
    - name: http80
      port: 80
      protocol: TCP
      targetPort: 80
      nodePort: 30088

  selector:
    app: wp-dep
  type: NodePort

同样使用 ConfigMap + Development + Service  的方式

```shell
kubectl appy -f wp-dep.yaml

wp-svc 使用 NodePort 暴露到集群外

3. 部署 Nginx Ingress Controller

定义 IngressClass

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: wp-ink

spec:
  controller: nginx.org/ingress-controller

定义 Ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: wp-ing

spec:
  ingressClassName: wp-ink

  rules:
  - host: wp.test
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: wp-svc
            port:
              number: 80

定义 IngressController

# https://docs.nginx.com/nginx-ingress-controller/installation/installation-with-manifests/
kind: Deployment
metadata:
  name: wp-kic-dep
  namespace: nginx-ingress

spec:
  replicas: 1
  selector:
    matchLabels:
      app: wp-kic-dep

  template:
    metadata:
      labels:
        app: wp-kic-dep

    spec:
      serviceAccountName: nginx-ingress
      hostNetwork: true

      dnsPolicy: ClusterFirstWithHostNet

      containers:
      #- image: nginx/nginx-ingress:2.2.0
      - image: nginx/nginx-ingress:2.2-alpine
        imagePullPolicy: IfNotPresent
        name: nginx-ingress
        ports:
        - name: http
          containerPort: 80
        - name: https
          containerPort: 443
        - name: readiness-port
          containerPort: 8081
        - name: prometheus
          containerPort: 9113
        readinessProbe:
          httpGet:
            path: /nginx-ready
            port: readiness-port
          periodSeconds: 1
        securityContext:
          allowPrivilegeEscalation: true
          runAsUser: 101 #nginx
          capabilities:
            drop:
            - ALL
            add:
            - NET_BIND_SERVICE
        env:
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        args:
          - -ingress-class=wp-ink
          - -health-status
          - -ready-status
          - -nginx-status
          - -enable-snippets

          - -nginx-configmaps=$(POD_NAMESPACE)/nginx-config
          - -default-server-tls-secret=$(POD_NAMESPACE)/default-server-secret
         #- -v=3 # Enables extensive logging. Useful for troubleshooting.
         #- -report-ingress-status
         #- -external-service=nginx-ingress
         #- -enable-prometheus-metrics
         #- -global-configuration=$(POD_NAMESPACE)/nginx-configuration

---

apiVersion: v1
kind: Service
metadata:
  name: wp-kic-svc
  namespace: nginx-ingress

spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
    nodePort: 30080

  selector:
    app: wp-kic-dep
  type: NodePort

需要执行 ingress 目录 setup.sh 脚本

1
2

# https://github.com/chronolaw/k8s_study/blob/master/ingress/setup.sh
./setup.sh

在 /etc/hosts 加上 worker node 对 wp.test 映射后即可使用 http://wp.test 访问服务

第二十四讲 PersistentVolume

PersistentVolume, 简称 PV 是存储的抽象，实际就是一些文件系统，如 GlusterFS、NFS、本地磁盘

PersistentVolumeClaim, 简称 PVC，用来代表 Pod 向系统申请 PV，申请成功后会将 PV 和 PVC 绑定在一起

StorageClass 抽象了特定的存储类型，在 PVC 和 PV 之间充当协调人的角色。

PV 配置文件


apiVersion: v1
kind: PersistentVolume
metadata:
  name: host-10m-pv

spec:
  storageClassName: host-test
  accessModes:
    - ReadWriteOnce
  capacity:
    storage: 10Mi
  hostPath:
    path: /tmp/host-10m-pv/

accessModes 定义了设备访问模式：

ReadWriteOnce: 可读写，但只能被一个 Node 上的 Pod 挂载
ReadOnlyMany: 仅可读，可以被多个 Node 上的 Pod 挂载
ReadWriteMany: 可读写，可以被多个 Node 上的 Pod 挂载

PVC 配置文件

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: host-5m-pvc

spec:
  storageClassName: host-test
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Mi

Pod 示例

apiVersion: v1
kind: Pod
metadata:
  name: host-pvc-pod

spec:
  volumes:
  - name: host-pvc-vol
    persistentVolumeClaim:
      claimName: host-5m-pvc

  containers:
    - name: ngx-pvc-pod
      image: nginx:alpine
      ports:
      - containerPort: 80
      volumeMounts:
      - name: host-pvc-vol
        mountPath: /tmp

第二十五讲 PV+NFS

安装 NFS

服务端

sudo apt -y install nfs-kernel-server


mkdir -p /tmp/nfs

# 添加配置
sudo echo '/tmp/nfs 192.168.10.0/24(rw,sync,no_subtree_check,no_root_squash,insecure)'  >> /etc/exports
# 通知 nfs 
sudo exportfs -ra
# 查看详情
sudo exportfs -v

# 检查网络挂载
showmount -e localhost

客户端

sudo apt -y install nfs-common

# 测试服务端挂载情况
showmount -e 192.168.10.208


mkdir -p /tmp/test
sudo mount -t nfs 192.168.10.208:/tmp/nfs /tmp/test

静态 PV

pv 配置

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-1g-pv

spec:
  storageClassName: nfs
  accessModes:
    - ReadWriteMany
  capacity:
    storage: 1Gi

  nfs:
    path: /tmp/nfs/1g-pv
    server: 192.168.10.208

pvc 配置

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-static-pvc

spec:
  storageClassName: nfs
  accessModes:
    - ReadWriteMany

  resources:
    requests:
      storage: 1Gi

测试 pod 配置

apiVersion: v1
kind: Pod
metadata:
  name: nfs-static-pod

spec:
  volumes:
  - name: nfs-pvc-vol
    persistentVolumeClaim:
      claimName: nfs-static-pvc

  containers:
    - name: nfs-pvc-test
      image: nginx:alpine
      ports:
      - containerPort: 80

      volumeMounts:
        - name: nfs-pvc-vol
          mountPath: /tmp

示意图

动态 PV

使用 Provisioner 来自动管理存储、创建 PV ，

NFS Provisioner 是以 Pod 形式运行在 k8s，需要三个部署文件 rabc.yaml、class.yaml 和 deployment.yaml

storageClass 配置

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-client

provisioner: k8s-sigs.io/nfs-subdir-external-provisioner 
parameters:
  archiveOnDelete: "false"

pvc 配置

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-dyn-10m-pvc

spec:
  storageClassName: nfs-client
  accessModes:
    - ReadWriteMany

  resources:
    requests:
      storage: 10Mi

测试 pod 配置

apiVersion: v1
kind: Pod
metadata:
  name: nfs-dyn-pod

spec:
  volumes:
    - name: nfs-dyn-10m-vol
      persistentVolumeClaim:
        claimName: nfs-dyn-10m-pvc

  containers:
    - name: nfs-dyn-test
      image: nginx:alpine
      ports:
        - containerPort: 80

      volumeMounts:
        - name: nfs-dyn-10m-vol
          mountPath: /tmp

由于有 NFS Provisioner, 不再需要直接定义 PV 对象，会自动按 PVC 配置创建。

整体示意图

第二十六讲 StatefulSet

StatefulSets 和 Deployment 类似，不过 pod 名称是固定的，pod 启动是有序的。

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis-sts

spec:
  serviceName: redis-svc
  replicas: 2
  selector:
    matchLabels:
      app: redis-sts

  template:
    metadata:
      labels:
        app: redis-sts
    spec:
      containers:
      - image: redis:5-alpine
        name: redis
        ports:
        - containerPort: 6379

声明 svc

apiVersion: v1
kind: Service
metadata:
  name: redis-svc

spec:
  selector:
    app: redis-sts

  ports:
  - port: 6379
    protocol: TCP
    targetPort: 6379

验证网络

svc 和 sts 之间的关联

sts 可以通过定义 volumeClaimTemplates 来声明 pvc

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis-pv-sts

spec:
  serviceName: redis-pv-svc

  volumeClaimTemplates:
  - metadata:
      name: redis-100m-pvc
    spec:
      storageClassName: nfs-client
      accessModes:
        - ReadWriteMany
      resources:
        requests:
          storage: 100Mi

  replicas: 2
  selector:
    matchLabels:
      app: redis-pv-sts

  template:
    metadata:
      labels:
        app: redis-pv-sts
    spec:
      containers:
      - image: redis:5-alpine
        name: redis
        ports:
        - containerPort: 6379

        volumeMounts:
        - name: redis-100m-pvc
          mountPath: /data

三者关联图

pvc 状态

第二十七讲滚动更新

更新

k8s 里面的应用的版本变化就是指 template 里的 Pod 变化，最终使用 template 的 Hash 值作为版本号

apply 更新的 yaml 后，可以使用kubectl rollout status查看更新状态

可以使用 kubectl describe deployment ngx-dep 查看具体的 pod 变化

pod 变化过程示意图

历史及回滚

可使用 kubectl rollout history deployment ngx-dep 查看更新历史，默认保存最近十次记录

可使用 kubectl rollout history deployment ngx-dep --revision=2 查看具体历史的详情

可使用 kubectl rollout undo deployment ngx-dep 来回滚

可使用 kubectl rollout undo deployment ngx-dep --to-revision=3 来回滚到任意版本

回滚时 pod 变化过程示意图

添加版本备注信息

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ngx-dep
  annotations:
    kubernetes.io/change-cause: v1, ngx=1.21
... ...

第二十八讲如何监控 Pod 健康状态

资源配额

通过在容器描述部分添加 resources 字段来声明资源

apiVersion: v1
kind: Pod
metadata:
  name: ngx-pod-resources

spec:
  containers:
  - image: nginx:alpine
    name: ngx

    resources:
      requests:
        cpu: 10m
        memory: 100Mi
      limits:
        cpu: 20m
        memory: 200Mi

requests 表示容器需要申请的资源，limits 表示资源使用上限，超过则可能被强制停止。

cpu 的单位m代表千分之一。

如果不加资源声明，k8s 可以将 pod 调度到任意节点上，否则 k8s 会根据每个 Pod 声明的需求，像搭积木或者玩俄罗斯方块一样，把节点尽量塞满。

检查探针

k8s 定义了三种探针

Startup: 启动探针，用来检查应用是否启动成功
Liveness: 存活探针，用来检查应用是否正常运行
Readiness: 就绪探针，用来检查应用是否可以接受流量

三种探针是递进关系，Startup 成功后，才会执行后面两个探针

如果 Liveness 探针失败， k8s 会重启容器，Readiness 探针失败，会将容器从 Service 负载均衡集合中移除，不分配流量。

k8s 支持使用 shell、tcp、http 三种方式检测

apiVersion: v1
kind: Pod
metadata:
  name: ngx-pod-probe

spec:
  volumes:
  - name: ngx-conf-vol
    configMap:
      name: ngx-conf

  containers:
  - image: nginx:alpine
    name: ngx
    ports:
    - containerPort: 80
    volumeMounts:
    - mountPath: /etc/nginx/conf.d
      name: ngx-conf-vol

    startupProbe:
      periodSeconds: 1
      exec:
        command: ["cat", "/var/run/nginx.pid"]

    livenessProbe:
      periodSeconds: 10
      tcpSocket:
        port: 80

    readinessProbe:
      periodSeconds: 5
      httpGet:
        path: /ready
        port: 80

第二十九讲命名空间

命名空间是一个逻辑上的概念，它可以将集群切分成一个个彼此独立的区域

创建命名空间

`1`	`kubectl create ns dev-ns`

有了命名空间，就可以给命名空间设定资源配额，示例如下


apiVersion: v1
kind: ResourceQuota
metadata:
  name: dev-qt
  namespace: dev-ns

spec:
  hard:
    requests.cpu: 10
    requests.memory: 10Gi
    limits.cpu: 10
    limits.memory: 20Gi

    requests.storage: 100Gi
    persistentvolumeclaims: 100

    pods: 100
    configmaps: 100
    secrets: 100
    services: 10

    count/jobs.batch: 1
    count/cronjobs.batch: 1
    count/deployments.apps: 1

设定了资源配额之后，所有 Pod 都需要显式声明资源需求，但这样的严格要求有时不太方便，我们可以声明一个默认资源配额

apiVersion: v1
kind: LimitRange
metadata:
  name: dev-limits
  namespace: dev-ns

spec:
  limits:
  - type: Container
    defaultRequest:
      cpu: 200m
      memory: 50Mi
    default:
      cpu: 500m
      memory: 100Mi
  - type: Pod
    max:
      cpu: 800m
      memory: 200Mi

第三十讲如何使用 Metrics Server 和 Prometheus

Metrics Server

metrics server 是一个专门来收集核心资源指标的工具，定时从所有节点的 kubelet 里采集信息。

安装

#  下载配置yaml
wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml


# 修改配置 
# deployment.spec.template.spec.containers 对象 添加 '- --kubelet-insecure-tls'
# deployment.spec.template.spec 对象 添加 'nodeName: k8s-master #你自己的节点名称'

# 重命名镜像

repo=registry.aliyuncs.com/google_containers

name=k8s.gcr.io/metrics-server/metrics-server:v0.6.1
src_name=metrics-server:v0.6.1

docker pull $repo/$src_name

docker tag $repo/$src_name $name
docker rmi $repo/$src_name


# 应用

kubectl apply -f components.yaml

查看

HorizontalPodAutoscaler

HorizontalPodAutoscaler 是用来自动伸缩 Pod 数量的对象，简称 hpa.

hpa 从 Metrics Server 获取当前应用的指标，按照策略增减 Pod 数量

使用 nginx deploy 示例

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ngx-hpa-dep

spec:
  replicas: 1
  selector:
    matchLabels:
      app: ngx-hpa-dep

  template:
    metadata:
      labels:
        app: ngx-hpa-dep
    spec:
      containers:
        - image: nginx:alpine
          name: nginx
          ports:
            - containerPort: 80

          resources:
            requests:
              cpu: 50m
              memory: 10Mi
            limits:
              cpu: 100m
              memory: 20Mi
---

apiVersion: v1
kind: Service
metadata:
  name: ngx-hpa-svc
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 80
  selector:
    app: ngx-hpa-dep

创建 hpa 模版

1
2

export out="--dry-run=client -o yaml"              # 定义Shell变量
kubectl autoscale deploy ngx-hpa-dep --min=2 --max=10 --cpu-percent=5 $out

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: ngx-hpa

spec:
  maxReplicas: 10
  minReplicas: 2
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ngx-hpa-dep
  targetCPUUtilizationPercentage: 5

Prometheus

使用 kube-prometheus 部署比较方便

#  下载部署文件
wget https://github.com/prometheus-operator/kube-prometheus/archive/refs/tags/v0.11.0.tar.gz


# 修改配置
##  替换gcr 镜像 kubeStateMetrics-deployment.yaml、prometheusAdapter-deployment.yaml
image: k8s.gcr.io/kube-state-metrics/kube-state-metrics:v2.5.0
image: k8s.gcr.io/prometheus-adapter/prometheus-adapter:v0.9.1

image: chronolaw/kube-state-metrics:v2.5.0
image: willdockerhub/prometheus-adapter:v0.9.1
## 添加NodePort IP ,方便本机测试 prometheus-service.yaml、grafana-service.yaml
spec.type: NodePort

# 创建服务
kubectl create -f manifests/setup
kubectl create -f manifests

使用 kubectl get svc -n monitoring 获取 prometheus-k8s 服务 9090对应的端口、grafana 3000 对应的端口, 浏览器访问验证

第三十一讲网络通信

CNI

为了适应跨主机通信的需求，k8s 提出了自己的网络模型 IP-per-pod:

每个 pod 有唯一的 IP 地址
pod 里所有容器共享这个 IP 地址
集群内所有 pod 共享一个网段
pod 可以直接基于 IP 访问另外一个 pod

k8s 定义了一个实现上述网络模型的标准 CNI(container networking interface)，根据实现原理， CNI 插件大致分为三类：

Overlay: 构建了一个工作在真实底层网络之上的"逻辑网络"，把原始的 Pod 网络数据封包，再通过下层网络发送出去，到了目的地再拆包。特点是适应性强，但性能较低。
Route：使用系统内置的路由功能来实现 Pod 跨主机通信。特点是性能较高，但对底层网络依赖性强。
Underlay：直接使用底层网络来实现CNI，Pod 和主机在一个网络里。特点是性能最高，但对底层硬件和网络依赖性最强。

插件介绍

Flannel：早期使用 UDP 和 VXLAN 实现了 Overlay 模式，后来使用 Host-Gateway 支持了 Route 模式
Calico：Route 模式，使用 BGP 协议来维护路由信息，支持多种网络策略，具备数据加密、安全隔离、流量整形等功能
Cilium：同时支持 Overlay 和 Route 模式，深度使用了 eBPF 技术，在内核层次操作网络数据，性能很高。

Flannel 工作方式分析

创建 3 个 nginx pod

`1`	`kubectl create deploy ngx-dep --image=nginx:alpine --replicas=3`

默认使用基于 VXLAN 的 Overlay 模式，从单机的角度来看，Flannel 的网络结构几乎和 Docker 一模一样，只不过网桥从 docker0 换成了 cni0

本机网络连接示意图如下

route 查看路由表

10.10.0.0/24 网段的数据，都要走 cni0 设备，也就是“cni0”网桥。
10.10.1.0/24 网段的数据，都要走 flannel.1 设备，也就是 Flannel。
192.168.10.0/24 网段的数据，都要走 ens160 设备，也就是我们宿主机的网卡

假设我们要从 master 节点的“10.10.0.3”访问 worker 节点的“10.10.1.77”，因为 master 节点的“cni0”网桥管理的只是“10.10.0.0/24”这个网段，所以按照路由表，凡是“10.10.1.0/24”都要让 flannel.1 来处理，这样就进入了 Flannel 插件的工作流程。

跨主机网络示意图如下

链接

[笔记]Kafka 核心技术与实战

Wed, 29 Jun 2022 08:20:51 +0800

第一讲消息系统 ABC

定义

维基百科版: 消息系统是一组规范，利用这组规范在不同系统之间传递语义准确的消息，实现松耦合的异步数据传递。

传输模型

点对点
发布订阅

核心作用

削峰填谷

第二讲 kafka 术语

Record: 消息
Topic: 主题
Partition: 分区，有序不变，每个主题至少有一个分区，从 0 开始
Offset: 分区位移，表示分区中消息的位置信息，单调递增且不变
Replica: 副本，每个分区可有多个副本，仅 Leader 副本对外提供服务，Follower 副本仅做数据备份
Producer: 生产者，发布信息
Consumer: 消息者，消费消息
Consumer Offset: 消费者位移，表示消费者消费进度
Consumer Group: 多个消费者组成一个组，共同消费一个主题，实现高吞吐
Rebalance: 重平衡，消费组某个成员挂掉后，其他消费者自动重新分配订阅主题的过程

示意图如下：

问：kafka 为什么不像 mysql 那样允许 follower 对外提供服务？

kafka 使用不是典型的读多写少的场景
分区 Leader 分布在不同的 Broker 节点，已提供了负载均衡的功能

第四讲 kafka 发现版本

Apache Kafka

社区版，迭代速度快，社区响应度高

Confluent Kafka

kafka创始人创建的商业公司Confluent，为 kafka 提供了很多高级特性，如跨数据中心备份、集群监控

CDH/HDP Kafka

大数据云公司提供版本，集成在数据平台中

第六讲线上集群部署

操作系统

kafka 客户端在 Linux 上使用 epoll I/O 模型，在 Windows 上使用 select

磁盘

kafka 大多数场景是顺序读写，使用机械磁盘可以胜任线上坏境

磁盘容量

容量需要考虑如下因素

新增消息数
平均消息大小
消息留存时间
备份数
是否启用压缩

带宽

根据使用经验，超过 70% 带宽阈值就有网络丢包的可能性，

第七讲最最最重要集群参数（上）

Broker 参数

存储相关

log.dirs: 指定目录如 /home/kafka1,/home/kafka2, 多个目录可以实现故障转移Failover

zookeeper 相关

zookeeper.connect: zk1:2181,zk2:2181,zk3:2181/kafka1

topic 管理相关

auto.create.topics.enable: 是否允许自动创建Topic
unclean.leader.election.enable: 是否运行 Unclean Leader 选举
auto.leader.rebalance.enable: 是否允许定期举行 Leader 选举

数据留存相关

log.retention.{hours|minutes|ms}: 控制数据保留时长，默认hours=168
log.retention.bytes: 消息保存总容量大小，默认不限制
log.segment.bytes: 日志文件区块大小，默认 1GB （一个 partition 有多个 segment 文件组成，不会删除最新的一个segment）
segment.ms: 日志文件毫秒周期，默认 7 天
message.max.bytes: 最大接受消息大小，默认1000012，976KB

第八讲最最最重要集群参数（下）

Topic 级别参数

retention.ms: 消息保存时长，优先于Broker级别设置
retention.bytes: 消息保存大小，优先于与Broker级别设置

JVM 参数

KAFKA_HEAP_OPTS: 堆大小，建议设成 6G
KAFKA_JVM_PERFORMANCE_OPTS: GC参数

操作系统参数

文件描述符限制：使用 ulimit -n 1000000 改成一个较大值
文件系统类型：XFS 性能强于 ext4
Flush 落盘时间：默认是 5s，可适当增大来降低物理磁盘的写操作

第九讲消息分区机制原理

分区作用

数据的读写操作是针对分区这个粒度进行的

分区的作用就是提供负载均衡的能力，实现系统的高伸缩性

分区写入策略

轮询策略

默认策略，将消息平均分配到所有分区

随机策略

如果追求数据均匀分布，优先使用轮询策略

按消息键分配策略

键相同的消息会写入到同一个分区

显式指定分区

kafka-python 可以支持

`1`	`producer.send(topic, b'some_message_bytes', partiion=1)`

kafka-go 需要实现对应接口达到类似效果

type CustomBalancer struct {
	kfk.RoundRobin
}

//nolint
func (h *CustomBalancer) Balance(msg kfk.Message, partitions ...int) int {
	if msg.Partition == -1 {
		return h.RoundRobin.Balance(msg, partitions...)
	}
	return msg.Partition
}

消费者可以显式指定消费分区，消费者组通过自平衡分配分区

第十讲压缩算法

流程

Producer 端压缩、Broker 端保持、Consumer 端解压缩

压缩算法对比

依据情况选择压缩比和吞吐率合适的算法

第十一讲无消息丢失配置

kafka 只对已提交的消息做有限度的持久化保证

producer端

使用带回调的方法： send(msg, callback),
acks=-1 所有副本收到消息才算已提交
retries 设置一个较大值，在网络抖动失败时会重试消息发送（重试可能导致消息乱序，max.in.flight.requests.per.connection=1可以避免）

broker 端

unclean.leader.election.enable = false 不让落后的broker 参与Leader选举
replication.factor >= 3 消息多保持几份
min.insync.replicas > 1 控制消息至少写入到多少分布才算已提交（只在 acks=-1 是生效）

consumer 端

enable.auto.commit = false 手动提交维护

第十二讲拦截器

生产者可以在发送消息前和提交成功后植入拦截器

消费者可以在消费消息前以及提交位移后植入拦截器

第十四讲幂等和事务

kafka 默认提供的可交付保障是至少一次 at lease once; 通过禁止重试可以实现至多一次 at most once

幂等性 Producer

通过设置 enable.idempotence = true 可以开启

开启以后，单分区单会话能够保证不会出现重复消息

背后的实现逻辑是 Broker 多保存数据，当 Producer 发送了相同字段的消息后，Broker 能够知晓消息重复了，并将其丢弃掉

事务型 Producer

设置 enable.idempotence = true，以及 transaction.id

producer.initTransactions();
try {
            producer.beginTransaction();
            producer.send(record1);
            producer.send(record2);
            producer.commitTransaction();
} catch (KafkaException e) {
            producer.abortTransaction();
}

上面的代码能保证 Record1 和 Record2 要么全部成功，要么全部失败

事务可以保证跨分区、跨会话的幂等性

消费者端设置隔离级别 isolation.level = read_committed 后会只读取成功完成的事务消息

第十五讲消费者组

特性

consumer group 可以有一个或多个 consumer
group id 是 consumer group 的唯一标识
单个分区只会分配到一个 consumer

实例数量设置

假设一个 group 订阅了 3 个 topic, 每个 topic 有 2 个 partition, 那么设置 6 个实例能最大限度的利用kafka的高伸缩性，每个实例消费一个分区

rebalance 触发条件

成员数量发生变化，增加或减少
订阅主题数量发生变更
主题分区数量变更

第十六讲位移主题

__consumer_offsets 主要用来记录消费者的位移数据

当第一个 consumer 启动时，kafka 会自动创建位移主题，默认分区数 offsets.topic.num.partitions = 50 ，副本数 offsets.topic.replication.factor = 3

消费端位移提交分为手动和自动提交，手动提交提供了灵活性和可控性，而自动提交会定期地提交位移，即使没有新消息，这样会导致位移主题消息会越来越多，所以位移主题采用 log compaction 删除策略来删除重复消息

第十七讲消费者组重平衡

重平衡就是消费者组中所有消费者就如何订阅主题分区达成共识的过程。重平衡过程中，所有消费者不消费任何消息，在协调者 coordinator 的帮助下，完成订阅主题分区的分配。

broker 在启动时，会启动相应的 coordinator 组件，消费者组通过位移主题 __consumer_offsets 查找对应 coordinator 所在的 broker

消费者组所在 consumer_offsets 分区通过 abs(hash(group_id) % topic_partition_count) 计算可以得到

如何避免消费者被协调者错误移除？

session.timeout.ms: 心跳超时时间，建议设置成 6s
heartbeat.interval.ms: 心跳间隔，建议设置成 2s （即判定超时前能发送3轮心跳）
max.pool.interval.ms: 最大 poll 间隔，根据业务消费时长设定，应大于消费时长
GC 参数：频繁 GC 可能导致消费者停顿

第 18 讲位移提交

自动提交

consumer 后台线程定时提交位移，相关参数

enable.auto.commit = true (默认开启)
auto.commit.interval.ms = 5000 (最小提交间隔，默认5s)

假设消费者每 5s 提交一次位移，在第 3s 时发生重平衡，那么前3s的数据会再重复消费一次

手动提交

显式通过调用 cosummer.commitSync() 提交位移

while (true) {
            ConsumerRecords<String, String> records =
                        consumer.poll(Duration.ofSeconds(1));
            process(records); // 处理消息
            try {
                        consumer.commitSync();
            } catch (CommitFailedException e) {
                        handle(e); // 处理提交失败异常
            }
}

commitSync 是同步调用，会阻塞线程，可以使用 commitAsync

while (true) {
            ConsumerRecords<String, String> records = 
  consumer.poll(Duration.ofSeconds(1));
            process(records); // 处理消息
            consumer.commitAsync((offsets, exception) -> {
  if (exception != null)
            handle(exception);
  });
}

可以将两者结合，利用 commitSync 的重试规避瞬时错误，利用 commitAsync 来减少阻塞

try {
           while(true) {
                        ConsumerRecords<String, String> records = 
                                    consumer.poll(Duration.ofSeconds(1));
                        process(records); // 处理消息
                        commitAysnc(); // 使用异步提交规避阻塞
            }
} catch(Exception e) {
            handle(e); // 处理异常
} finally {
           try {
                        consumer.commitSync(); // 最后一次提交使用同步阻塞式提交
            } finally {
                        consumer.close();
            }
}

第二十一讲 Java 版消费者 TCP 连接管理

TCP 连接是在调用 KafkaConsumer.poll 方法被创建的。 poll 内部有三个时机可以创建 TCP 连接

创建连接时机

发起 FindCoordinator 请求时

消费者启动时会向负载最小的 Broker 建立连接，请求告知主题对应的 coordinator Leader 在哪个 broker

连接协调者

步骤 1 之后会和 coordinator 建立连接

消费数据时

消费者会向每个分区 Leader 所在的 Broker 建立连接。

假设消费的 5 个分区在 4 个 Broker 上，那会建立 4 个连接。

案例分析

# 建立第一个连接，连接的Broker的 ID 是 -1， 表明还不知道其任何信息
[2019-05-27 10:00:54,142] DEBUG [Consumer clientId=consumer-1, groupId=test] Initiating connection to node localhost:9092 (id: -1 rack: null) using address localhost/127.0.0.1 (org.apache.kafka.clients.NetworkClient:944)

# 向第一个连接请求集群元数据信息
[2019-05-27 10:00:54,188] DEBUG [Consumer clientId=consumer-1, groupId=test] Sending metadata request MetadataRequestData(topics=[MetadataRequestTopic(name='t4')], allowAutoTopicCreation=true, includeClusterAuthorizedOperations=false, includeTopicAuthorizedOperations=false) to node localhost:9092 (id: -1 rack: null) (org.apache.kafka.clients.NetworkClient:1097)

# 向第一个连接发送 FindCoordinator 请求
[2019-05-27 10:00:54,188] TRACE [Consumer clientId=consumer-1, groupId=test] Sending FIND_COORDINATOR {key=test,key_type=0} with correlation id 0 to node -1 (org.apache.kafka.clients.NetworkClient:496)

# 收到 Coordinator 所在 Broker 信息
[2019-05-27 10:00:54,203] TRACE [Consumer clientId=consumer-1, groupId=test] Completed receive from node -1 for FIND_COORDINATOR with correlation id 0, received {throttle_time_ms=0,error_code=0,error_message=null, node_id=2,host=localhost,port=9094} (org.apache.kafka.clients.NetworkClient:837)

# 和 Coordinator 建立第二个连接
[2019-05-27 10:00:54,204] DEBUG [Consumer clientId=consumer-1, groupId=test] Initiating connection to node localhost:9094 (id: 2147483645 rack: null) using address localhost/127.0.0.1 (org.apache.kafka.clients.NetworkClient:944)

# 建立第三到五个连接，用于实际消息的获取，说明这三个 Broker 都有要消费的分区
[2019-05-27 10:00:54,237] DEBUG [Consumer clientId=consumer-1, groupId=test] Initiating connection to node localhost:9094 (id: 2 rack: null) using address localhost/127.0.0.1 (org.apache.kafka.clients.NetworkClient:944)
[2019-05-27 10:00:54,237] DEBUG [Consumer clientId=consumer-1, groupId=test] Initiating connection to node localhost:9092 (id: 0 rack: null) using address localhost/127.0.0.1 (org.apache.kafka.clients.NetworkClient:944)
[2019-05-27 10:00:54,238] DEBUG [Consumer clientId=consumer-1, groupId=test] Initiating connection to node localhost:9093 (id: 1 rack: null) using address localhost/127.0.0.1 (org.apache.kafka.clients.NetworkClient:944)

总结上面的日志信息，可以看出消费者通常会创建三类连接：

确认协调者和获取集群元数据
连接协调者，令其执行组成员管理操作
执行实际消息的获取

当第三类连接建立后，第一类连接会被关闭，定期请求元数据的需求切换到第三类连接上。

问：第三类连接是主题级别还是 Broker 级别？

第二十二讲消费者组消费进度监控

消息滞后使用 Consumer Lag 衡量，假设当前生成了 20 万条消息，消费了 15 万条，那么 Consumer Lag 就等于 5 万。

使用命令行工具

`1`	`$ bin/kafka-consumer-groups.sh --bootstrap-server <Kafka broker连接信息> --describe --group <group名称>`

使用 Java Consumer API

使用 AdminClient 查询

public static Map<TopicPartition, Long> lagOf(String groupID, String bootstrapServers) throws TimeoutException {
        Properties props = new Properties();
        props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        try (AdminClient client = AdminClient.create(props)) {
            ListConsumerGroupOffsetsResult result = client.listConsumerGroupOffsets(groupID);
            try {
                Map<TopicPartition, OffsetAndMetadata> consumedOffsets = result.partitionsToOffsetAndMetadata().get(10, TimeUnit.SECONDS);
                props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false); // 禁止自动提交位移
                props.put(ConsumerConfig.GROUP_ID_CONFIG, groupID);
                props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
                props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
                try (final KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props)) {
                    Map<TopicPartition, Long> endOffsets = consumer.endOffsets(consumedOffsets.keySet());
                    return endOffsets.entrySet().stream().collect(Collectors.toMap(entry -> entry.getKey(),
                            entry -> entry.getValue() - consumedOffsets.get(entry.getKey()).offset()));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                // 处理中断异常
                // ...
                return Collections.emptyMap();
            } catch (ExecutionException e) {
                // 处理ExecutionException
                // ...
                return Collections.emptyMap();
            } catch (TimeoutException e) {
                throw new TimeoutException("Timed out when getting lag for consumer group " + groupID);
            }
        }
    }

使用JMX 监控指标

使用 JMX 指标集成到 Grafana 等监控框架中

kafka 消费者提供了名为 kafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}” 指标

其中有两个指标和消费进度有关：

records-lag-max
records-lead-min: 消费者位移和分区最旧消息的最小差值

第二十三讲副本机制

副本定义

副本本质上是一个只能追加写消息的提交日志。

这些副本分散保存在不同的 Broker 上，从而能够对抗 Broker 宕机带来的数据不可用。

副本角色

副本分为两类，Leader 和 Follower，分区在创建时会选出一个 Leader 副本，其余副本成为 Follower。

所有的读写请求都由 Leader 处理，Follower 只是从 Leader 异步拉取消息从而实现同步

当 Leader 挂掉后，ZooKeeper 能够监控到并开启新一轮的选举

Follower 不对外提供服务的好处：

方便实现 Read-your-writes 。如果从 Follower 读取消息，由于是异步的，可能看不到最新的消息
方便实现单调读 Monotonic Reads 。如果从多个副本读消息，可能出现某条消息一会存在一会不存在

In-sync Replicas (ISR)

ISR 指与 Leader 同步的副本集合， Leader 本身也包括在 ISR 中

通过 replica.lag.time.max.ms 参数指定 Follower 能够落后 Leader 的最长时间，在此范围内的 Follower 都在 ISR 中。

Unclean 领导者选举

当 ISR 为空时，只存在非同步副本。 unclean.leader.election.enable 参数控制是否允许 Unclean 领导者选举

开启的好处是使得 Leader 副本一直存在，提高可用性，但是可能会造成数据丢失，不建议开启。

第二十四讲请求处理过程

kafka 定义了一组请求协议，用于实现各种交互操作，PRODUCE 请求用于生产消息，FETCH请求用于消费消息，METADATA请求用于获取集群元数据

数据类请求

kafka 使用 Reactor 模式处理请求

Acceptor 线程用于分发请求，分发使用轮询模式

网络线程池来处理具体的请求，num.network.threads 参数控制线程数量，默认为3。

网络线程拿到请求后，将请求放入一个共享队列中，IO 线程池负责从队列中取出请求，执行真正的处理。如果是 PRODUCE 请求，则将消息写入磁盘日志；如果是 FETCH 请求，则从磁盘或页缓存中读取消息。

IO 线程处理完请求后，会将响应发送到网络线程池的响应队列中，然后由对应的网络线程将响应返回给客户端。

num.io.threads 参数控制 IO 线程数量，默认为8。

Purgatory 组件用来缓存延时请求。比如设置了 ack=all 的 PRODUCE 请求，需要等待所有 ISR 副本接收后才能返回。

控制类请求

控制类请求用来执行特定的 kafka 内部动作，比如负责更新 Leader/Follower/ISR 的 LeaderAndIsr 请求、负责勒令副本下线的 StopReplica 请求。

kafka 将控制类请求和数据类请求分类，分别创建了两套网络线程池和 IO 线程池

第二十五讲重平衡过程

通知触发

重平衡通知是通过心跳来通知的，协调者会将REBALANCE_IN_PROCESS包含在心跳响应中。

消费者组状态机

kafka 为消费者组定义了五种状态

状态机状态流转如下

消费者端流程

在消费者端，重平衡分为两个步骤：加入组和等待领导者消费者分配方案。这两个步骤分别对应两类特定的请求：JoinGroup 和 SyncGroup。

在收到所有消费者的订阅消息后，消费者通常将第一个发送 JoinGroup 消息的成员当做领导者，并将所有订阅信息发给领导者。领导者做出方案后，会发送 SyncGroup 请求，将方案发给协调者。其他成员也会发送空的 SyncGroup 请求。协调者会将分配方案在 SyncAGroup 响应中发送。

协调者端流程

新成员入组

成员主动离组

主动离组会发起 LeaveGroup

成员崩溃

重平衡开始后，协调者会给予成员一段缓冲时间 rebalance.timeout，要求成员必须在这段时间快速上报自己的位移消息。

第二十七讲高水位和 Leader Epoch

什么是高水位

《Streaming System》表述：水位是一个单调增加且表征最早未完成工作（ oldest work not yet completed）的时间戳

高水位的作用

定义消息可见性，即标识哪些消息可以被消费者消费
帮助kafka 完成副本同步。

位移值等于高水位的消息也属于未提交的消息。

同一个副本对象，其高水位值小于等于 LEO 值

高水位更新机制

leader 副本会保存所有 follower 副本的 LEO 值，其作用是帮助 leader 副本确认其高水位，即整个分区高水位。

leader副本

处理生产者请求：

写入消息到本地磁盘
更新分区高水位值：获取保存的所有远程副本 LEO 值， currentHW = max(crrentHW, min(LEO-1, …, LEO-n))

处理 follower 副本拉取消息逻辑

读取磁盘中的消息数据
使用 follower 副本发送请求中的位移值更新远程副本的 LEO 值
更新分区高水位值

follower副本

写入消息到本地磁盘
更新 LEO 值 currentLEO
更新高水位值：获取leader 发送的高水位值 currentHW, 更新高水位为 min(currentHW, currentLEO)

第二十八讲主题管理

创建主题

`1`	`bin/kafka-topics.sh --bootstrap-server broker_host:port --create --topic my_topic_name --partitions 1 --replication-factor 1`

查询主题列表

`1`	`bin/kafka-topics.sh --bootstrap-server broker_host:port --list`

查询单个主题详情

`1`	`bin/kafka-topics.sh --bootstrap-server broker_host:port --describe --topic <topic_name>`

修改（增加）主题分区

`1`	`bin/kafka-topics.sh --bootstrap-server broker_host:port --alter --topic <topic_name> --partitions <新分区数>`

修改主题单条消息最大字节数

`1`	`bin/kafka-configs.sh --zookeeper zookeeper_host:port --entity-type topics --entity-name <topic_name> --alter --add-config max.message.bytes=10485760`

修改主题带宽限速

1
2
3

bin/kafka-configs.sh --zookeeper zookeeper_host:port --alter --add-config 'leader.replication.throttled.rate=104857600,follower.replication.throttled.rate=104857600' --entity-type brokers --entity-name 0

bin/kafka-configs.sh --zookeeper zookeeper_host:port --alter --add-config 'leader.replication.throttled.replicas=*,follower.replication.throttled.replicas=*' --entity-type topics --entity-name test

删除主题

`1`	`bin/kafka-topics.sh --bootstrap-server broker_host:port --delete --topic <topic_name>`

第二十九讲动态配置

broker config 有三类参数

read-only: 重启 broker 才会生效
per-broker: 对应 broker 生效
cluster-wide: 整个集群生效

常用动态参数

log.retention.ms

修改日志留存时间

num.io.threads 和 num.network.threads

修改 IO 和网络线程数量

num.replica.fetchers 修改 follower 拉取数据的线程数量

第三十讲重设消费者组位移

策略类型

kafka 支持 7 种策略

命令行设置

Earliest

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --all-topics --to-earliest –execute`

Latest

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --all-topics --to-latest --execute`

Current

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --all-topics --to-current --execute`

Specified-Offset

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --all-topics --to-offset <offset> --execute`

Shift-By-N

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --shift-by <offset_N> --execute`

Datetime

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --to-datetime 2019-06-20T20:00:00.000 --execute`

Duration

`1`	`bin/kafka-consumer-groups.sh --bootstrap-server kafka-host:port --group test-group --reset-offsets --by-duration PT0H30M0S --execute`

第三十一讲常见脚本汇总

kafka-dump-log 查看 kafka 消息文件的内容，包括消息的各种元数据信息和消息本身

kafka-log-dirs 查看各个 Broker 磁盘占用情况

重点操作

生成消息

1
2

$ bin/kafka-console-producer.sh --broker-list kafka-host:port --topic test-topic --request-required-acks -1 --producer-property compression.type=lz4
>

消费消息

`1`	`$ bin/kafka-console-consumer.sh --bootstrap-server kafka-host:port --topic test-topic --group test-group --from-beginning --consumer-property enable.auto.commit=false`

查看文件


$ bin/kafka-dump-log.sh --files ../data_dir/kafka_1/test-topic-1/00000000000000000000.log 
Dumping ../data_dir/kafka_1/test-topic-1/00000000000000000000.log
Starting offset: 0
baseOffset: 0 lastOffset: 14 count: 15 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 0 CreateTime: 1561597044933 size: 1237 magic: 2 compresscodec: LZ4 crc: 646766737 isvalid: true
baseOffset: 15 lastOffset: 29 count: 15 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 1237 CreateTime: 1561597044934 size: 1237 magic: 2 compresscodec: LZ4 crc: 3751986433 isvalid: true
......

supervisor 源码解读

Sun, 27 Mar 2022 21:21:20 +0800

简介

Supervisor is a client/server system that allows its users to control a number of processes on UNIX-like operating systems.

当前最新版本为 4.2.4，发布于 2021-12-30

第一个发布版本为 1.0.3，发布于 2004-05-26

主要模块

supervisorctl

supervisorctl 是个命令行客户端，用户可以通过命令行输入指令来获取和变更进程状态等

命令列表

supervisor> help
default commands (type help <topic>):
=====================================
add    exit      open  reload  restart   start   tail
avail  fg        pid   remove  shutdown  status  update
clear  maintail  quit  reread  signal    stop    version

主流程

# file: supervisor/supervisorctl.py
class Controller(cmd.Cmd):
    def cmdloop(self, intro=None):
        while True:
            line = self.stdin.readline()
            stop = self.onecmd(line)
    def onecmd(self, line):
        cmd, arg, line = self.parseline(line)
        do_func = self._get_do_func(cmd)
        return do_func(arg)
        
    def _get_do_func(self, cmd):
        func_name = 'do_' + cmd
        func = getattr(self, func_name, self.default)
        return func
        
    def do_start(self, arg):
        supervisor = self.ctl.get_supervisor()
        names = arg.split()
        for name in names:
            result = supervisor.startProcess(name)
            self.ctl.output('%s: started' % name)

supervisord

主流程

# file: supervisor/supervisord.py

class Supervisor:
    def __init__(self, options):
        self.options = options
        self.process_groups = {}
        # process_groups struct like:
        # {
        #    "groupA": {
        #        "groupA": <Subprocess instance>,
        #    },
        #    "groupB": {
        #        "programB1": <Subprocess instance>,
        #        "programB2": <Subprocess instance>,
        #    },
        # }
        
    def runforever(self):
        # 创建管理子进程的Subprocess类实例（实际子进程还没启动）
        for config in self.options.process_group_configs:
            self.add_process_group(config) 
            
        # 启动 httpservers
        self.options.openhttpservers(self)
        
        # 注册信号
        self.options.setsignals()
        
        # 全局变量：包含所有socket对象
        socket_map = self.options.get_socket_map()
        
        while 1:
            combined_map = {}
            combined_map.update(socket_map)
            
            # 添加子进程标准输入输出相关的pipe
            combined_map.update(self.get_process_map())
            
            # 注册文件描述符
            for fd, dispatcher in combined_map.items():
                if dispatcher.readable():
                    self.options.poller.register_readable(fd)
                if dispatcher.writable():
                    self.options.poller.register_writable(fd)
                    
            # 读取可读写的文件描述符
            r, w = self.options.poller.poll(timeout)
            
            # 处理对应事件
            for fd in r:
                if fd in combined_map:
                    dispatcher = combined_map[fd]
                    dispatcher.handle_read_event()
            for fd in w:
                if fd in combined_map:
                    dispatcher = combined_map[fd]
                    dispatcher.handle_write_event()
                    
            for group in pgroups:
                # 检查进程状态，确定是否要启动或者停止操作
                group.transition()
                
            # waitpid(0, 1) 检查是否有进程停止
            self.reap()
            
            # 信号处理： 是否要停止、重启、重新打开日志文件等
            self.handle_signal()
            
            # 发送心跳事件
            self.tick()

子进程实例


def make_pipes(self, stderr=True):
    pipes = {}

    stdin, child_stdin = os.pipe()
    pipes['child_stdin'], pipes['stdin'] = stdin, child_stdin
    stdout, child_stdout = os.pipe()
    pipes['stdout'], pipes['child_stdout'] = stdout, child_stdout
    stderr, child_stderr = os.pipe()
    pipes['stderr'], pipes['child_stderr'] = stderr, child_stderr
    for fd in (pipes['stdout'], pipes['stderr'], pipes['stdin']):
        if fd is not None:
            flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NDELAY   # O_NDELAY is an alias for O_NONBLOCK
            fcntl.fcntl(fd, fcntl.F_SETFL, flags)
    return pipes
    
class Subprocess(object):
    pid = 0
    def __init__(self, config):
        self.config = config
        self.dispatchers = {}
        self.pipes = {}
        self.state = ProcessStates.STOPPED
        
    def spawn(self):
        filename, argv = self.get_execv_args()
        self.dispatchers, self.pipes = self.config.make_dispatchers(self)
        
        pid = options.os.fork()
         
        if pid != 0:
            self._spawn_as_parent(pid)
        else:
            self._spawn_as_child(filename, argv)
            
    def _spawn_as_parent(self, pid):
        self.pid = pid
        options = self.config.options
        options.close_child_pipes(self.pipes)
        
    def _spawn_as_child(self, filename, argv):
        options = self.config.options
        options.setpgrp()
        
        # 文件描述符重定向
        options.dup2(self.pipes['child_stdin'], 0)
        options.dup2(self.pipes['child_stdout'], 1)
        if self.config.redirect_stderr:
            options.dup2(self.pipes['child_stdout'], 2)
        else:
            options.dup2(self.pipes['child_stderr'], 2)
        for i in range(3, options.minfds):
            options.close_fd(i)
            
        env = os.environ.copy()
        os.execve(filename, argv, env)
        
    def stop(self):
        return self.kill(self.config.stopsignal)
        
    def kill(self, sig)
        self.change_state(ProcessStates.STOPPING)
        os.kill(self.pid, sig)

http_server

支持基于 tcp socket 或者 unix domain socket 的 http server

class supervisor_af_inet_http_server(supervisor_http_server):
     def __init__(self, ip, port, logger_object):
        self.ip = ip
        self.port = port
        
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
        self.handlers = []
        
        self.socket = sock
        sock.setblocking(0)
        sock.bind((ip, port))
        self.listen (1024)
        
        # 注册到全局 socket 字典里
        socket_map[sock.fileno] = self
        
    def handle_read_event(self):
        self.handle_accept()
        
    def handle_accept (self):
        conn, addr = self.socket.accept()
        http_channel(self, conn, addr)
        
class http_channel (asynchat.async_chat):
    def __init__ (self, server, conn, addr):
        self.socket = conn
        self.socket.setblocking(0)
        
        socket_map[self.socket.fileno] = self
        
        self.ac_in_buffer = b''
        self.ac_out_buffer = b''
        self.ac_out_buffer_size = 512
        terminator = '\r\n\r\n'
        
    def handle_read_event(self):
        self.handle_read()
        
    def handle_read (self):
        data = self.socket.recv(buffer_size)
        
        # 简化版 接收数据拼接 request, 实际逻辑更复杂
        self.ac_in_buffer += data
        if self.terminator in self.ac_in_buffer:
            request = self.new_reqeust()
            for h in self.server.handlers:
                if h.match (request):
                    h.handle_request (request)
        
    def handle_write_event(self):
        self.handle_write()
        
    def handle_write(self):
        obs = self.ac_out_buffer_size
        if len (self.ac_out_buffer) < obs:
            self.refill_buffer()
        if self.ac_out_buffer 
             num_sent = self.send (self.ac_out_buffer[:obs])
             if num_sent:
                self.ac_out_buffer = self.ac_out_buffer[num_sent:]

xmlrpc_interface

xmlrpc协议简介

xmlrpc 是一种基于 http 通信、使用 XML 格式序列化的远程过程调用方式

请求示例

POST /RPC2 HTTP/1.1  # 请求使用 POST 方法， path 为 /RPC2
Host: localhost:9011
Accept-Encoding: gzip
Content-Type: text/xml
User-Agent: Python-xmlrpc/3.8
Content-Length: 176

<?xml version='1.0'>
<methodCall> 
    <methodName>supervisor.stopProcess</methodName>
    <params>
        <param>
        <value><string>exits_123s</string</value>
        </param>
    </params>
</methodCall>

正常响应示例

HTTP/1.1 200 OK
Server: Medusa/1.12
Date: Thu, 24 Mar 2022 09:02:51 GMT
Content-Type: text/xml
Content-Length: 129

<?xml version='1.0'?>
<methodResponse>
    <params>
        <param>
            <value><boolean>1</boolean></value>
        </param>
    </params>
</methodResponse>

错误响应示例 (同样返回 http code 200 )

HTTP/1.1 200 OK
Server: Medusa/1.12
Date: Thu, 24 Mar 2022 08:53:09 GMT
Content-Type: text/xml
Content-Length: 279

<?xml version='1.0'?>
<methodResponse>
    <fault>
        <value>
            <struct>
                <member>
                    <name>faultCode</name>
                    <value><int>70</int></value>
                </member>
                <member>
                <name>faultString</name>
                <value><string>NOT_RUNNING: exits_123s</string></value>
                </member>
            </struct>
        </value>
    </fault>
</methodResponse>

supervisor中的实现

服务端 handler 实现

# file: supervisor/xmlrpcrpc.py
class supervisor_xmlrpc_handler(xmlrpc_handler):
    path = '/RPC2'
    def __init__(self, supervisord, subinterfaces):
        self.rpcinterface = RootRPCInterface(subinterfaces)
        self.supervisord = supervisord
        
    def match(self, request):
        return request.uri.startswith(self.path)
        
    def continue_request (self, data, request):
        params, method = xmlrpclib.loads (data)
        response = self.call (method, params)
        request.push (response)
        
    def call(self, method, params):
        return traverse(self.rpcinterface, method, params)

接口实现

# file: supervisor/rpcinterface.py

class SupervisorNamespaceRPCInterface:
    def __init__(self, supervisord):
        self.supervisord = supervisord
        
    def stopProcess(self, name, wait=True):
        process = self.supervisord.process_groups.get(name)
        if process is None:
            raise RPCError(Faults.BAD_NAME, name)
        if process.get_state() not in RUNNING_STATES:
            raise RPCError(Faults.NOT_RUNNING, name)

        msg = process.stop()
        if msg is not None:
            raise RPCError(Faults.FAILED, msg)
        return True

event

event 类型

SUPERVISOR_STATE_CHANGE: supervisord 状态相关
PROCESS_STATE: 子进程进程状态相关
PROCESS_GROUP: 进程组相关
TICK: 心跳相关

订阅实现逻辑

callbacks = []

def subscribe(type, callback):
    callbacks.append((type, callback))

def unsubscribe(type, callback):
    callbacks.remove((type, callback))

def notify(event):
    for type, callback in callbacks:
        if isinstance(event, type):
            callback(event)

eventlistener

eventlistener 是一种特殊的子进程，通过标准输入输出和 supervisord 来获取 event

向 stdout 写入 READY\n 向 supervisord 请求 event
读取 supervisord 在 stdin 写入的 event
向 stdout 写入 RESULT 2\nOK 向 supervisord 确认 event 已接收

import sys

def write_stdout(s):
    # only eventlistener protocol messages may be sent to stdout
    sys.stdout.write(s)
    sys.stdout.flush()

def write_stderr(s):
    sys.stderr.write(s)
    sys.stderr.flush()

def main():
    while 1:
        # transition from ACKNOWLEDGED to READY
        write_stdout('READY\n')

        # read event
        line = sys.stdin.readline()
        headers = dict([ x.split(':') for x in line.split() ])
        
        payload = sys.stdin.read(int(headers['len']))
        

        # transition from READY to ACKNOWLEDGED
        write_stdout('RESULT 2\nOK')

if __name__ == '__main__':
    main()

总结

客户端和服务端通过 xmlrpc 通信
主进程通过将 socket 和 pipe 设为非阻塞模式，然后通过轮询处理读写事件
主进程和子进程之间通过信号和 pipe 通信

参考链接

supervisor: supervisor 源码
xmlrpc_specification：xmlprc 协议文档
xmlrpc_python_stdlib：xmlprc python标准库文档
supervisor_gateway：基于 eventlistener 和 xmlrpc 实现的提供 RESTful API 的 supervisor 中间件

[笔记]业务开发算法 50 讲

Mon, 14 Mar 2022 08:36:33 +0800

第零讲 git diff 文本差分算法

定义

git diff 内置了多种算法，这里介绍的是其默认算法 Myers 差分算法。

An edit script for A and B is a set of insertion and deletion commands that transform A into B.

文本差分算法可以定义为用于求输入源文本到目标文本之间的编辑脚本算法。

编辑脚本是其中一系列插入和删除操作的序列

评价指标

有两个指标可以评价编辑脚本的优劣，分别是编辑脚本的长度、可读性

编辑脚本长度

编辑脚本较短时，尽可能的保留了更多原序列中的元素。

最短编辑脚本（SES Shortest Edit Script）和最长公共子序列问题其实是对偶问题

源序列 
S = ABCABBA length m = 7
目标序列
T = CBABAC  length n = 6

最长公共子序列(不唯一)
C = CBBA    length LC = 4

从上面的例子可以看出 SES 的长度等于 m + n - 2 * LC

可读性

可读性可以总结为两点：

尽可能保留整段文本，尽可能连续删除和插入，而不是彼此交叉
大部分人习惯先看到原文本删除，再看到目标文本的插入

所以总结算法逻辑就是：在最短的编辑脚本里，尽量找到删除在增加前面，且尽可能多的连续删除更多行的方式。

模型抽象

从源序列 S 到目标序列 T，有删除和插入两种操作，我们需要找到一种对这两个操作和相应变换状态的抽象方式。

源序列 
S = ABCABBA length m = 7
目标序列
T = CBABAC  length n = 6

转化成图搜索问题

Myers 将问题转化为图搜索问题，其中横轴代表源序列，纵轴代表目标序列，坐标 (0, 0) 代表初始状态，(m, n) 则对应了最终完整的从 S 到 T 的编辑脚本。横向移动代表删除操作，纵向移动代表插入操作。

如上图所示，从 (0, 0) 到 (3，4) 的路径表示字符串 ABC –> CBAB 的一种编辑方式，我们先插入 CB，然后删除 AB，再插入 AB，最后删除 C。

这样文本差分问题就转化成了如何在这样的网格中找到仅允许向下和向右移动的一个从 (0, 0) 到 (m, n) 的路径，路径的长度就代表了总共需要的操作数。

对于源序列和目标序列字符相等的坐标，如 (2, 0) 和 (3, 1)、(0, 2) 和 (2，4) 等，这种斜线路径不耗费任何操作数。如下图为一条最短路径的例子：

如何解决图搜索

Myers 论文中有几个重要的概念

D-path: 需要 D 步操作的路径称之为 D-Path
snake: 一个横线或竖线之后紧跟着 n 条斜线所形成的的路径为 snake，snake 操作数为 1，且 snake 结尾坐标后继不能为斜线。
line: 从左上到右下的 45 度的斜线，可以用 k = x - y 表示，在 m * n 的网格中，k 的取值范围为 [-n, m]。

Myers 论文中原图对上面的几个概念示意：

这样我们求解最短编辑脚本的目标就可以定义为找最短到达 (m, n) 的 D-path。

所有的 D-path 都是 (D-1)-path 加一条 snake 构成，这样我们可以从 1-path 出发，去搜索所有 2-path 最远能走到哪，然后一直递推到 D-path，第一次遇到终点时，就找到最短路径了。

当有多条 D-path 时，我们如何选可读性最好的路径呢？基于先看到删除再看到插入的原则，在考虑 D-path时，会从多条 (D-1)-path 中选出横坐标更大的路径。

代码实现

我们使用一个二维数组 dp 来记录图上的搜索状态

dp 第一个维度代表操作数，最大操作范围是我们最短编辑脚本的长度 m + n - 2 * LC
dp 第二个维度代表 k-line 的行号，在操作数为 d 时，其取值范围是 [-d, d]
dp 的值代表对应的 x 坐标（相应可以推算出 y 坐标）

     |      0     1     2     3     4     5
----+--------------------------------------
    |
 4  |                             7,3
    |                           /
 3  |                       5,2
    |                     /
 2  |                 [3,1]       [7,5]
    |               /     \     /     \
 1  |           [1,0]       [5,4]      [7,6]
    |         /     \           \
 0  |     [0,0]       2,2         5,5
    |         \                       \
-1  |           0,1         4,5         5,6
    |               \     /     \
-2  |                 2,4         4,6
    |                     \
-3  |                       3,6

操作数为 d，行号为 k 的状态只能从相邻的两行 k-1 横线过来（x+1）或者 k+1 竖线过来（x不变）。

因为整个数的结构是二叉的，奇数步数时必然处于奇数行号，偶数步数时必然处于偶数行号，这是因为每进行一步 snake 时，只会有一次删除或插入操作，所以 k 的遍历步长是 2 。

状态转移方程就是 dp[d][k] = max(dp[d-1][k-1]+1, dp[d-1][k+1])，即多个路径状选横坐标 x 最大的。

由于操作数 d 的状态计算只依赖 d-1 的状态数组，所以可以压缩一下空间使用一维数组记录即可。

伪代码

V[1]←0 
For D ← 0 to MAX Do
  For k ← −D to D in steps of 2 
    Do If k=−D or k≠D and V[k−1] < V[k+1] Then
      x ← V[k+1] 
    Else
      x ← V[k−1]+1 y ← x−k
    While x < N and y < M and a[x+1] = b[y+1] Do 
      (x,y) ← (x+1,y+1) 
      V[k] ← x
  If x ≥ N and y ≥ M Then
    Length of an SES is D
    Stop

python 版代码

def git_diff(a: str, b: str) -> int:
    a = " " + a
    b = " " + b
    v = {0: 0}
    d = 0
    break_out = False
    while True:
        d += 1
        for k in range(-d, d+1, 2):
            if k == -d:
                x = v[k + 1]
            elif k == d:
                x = v[k - 1] + 1
            else:
                if k+1 not in v:
                    x = v[k - 1] + 1
                else:
                    x = max(v[k + 1], v[k - 1] + 1)
            y = x - k
            while x < len(a) - 1 and y < len(b) - 1 and a[x + 1] == b[y + 1]:
                x += 1
                y += 1
            v[k] = x
            if x >= len(a) - 1 and y >= len(b) - 1:
                break_out = True
                break
        v = {k: x for k, x in v.items() if (k+d) % 2 == 0}
        if break_out:
            break
    return d

第一讲动态数组 vector

数组与内存

静态数组是由相同类型的元素线性排列的数据结构，在计算机上会分配一段连续的内存，对元素进行顺序存储。

静态数组的插入和删除的平均复杂度是 O(N)

静态数组的元素个数是事先确定的

动态数组

动态数组将扩容的逻辑分装起来，方便用户使用

Vector 源码分析

vector 中有三个关键指针

_start: 指向 vector 第一个元素
_finish: 指向 vector 最后一个元素
_end: 指向 vector 预留容量的边界

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
       ...
protected:
  _Tp* _M_start; //表示目前使用空间的头
  _Tp* _M_finish; //表示目前使用空间的尾
  _Tp* _M_end_of_storage; //表示目前可用空间的尾  
    ...
};

扩容实现源码

  void push_back(const _Tp& __x) {//在最尾端插入元素
    if (_M_finish != _M_end_of_storage) {//若有可用的内存空间
      construct(_M_finish, __x);//构造对象
      ++_M_finish;
    }
    else//若没有可用的内存空间,调用以下函数，把x插入到指定位置
      _M_insert_aux(end(), __x);
  }
  
template <class _Tp, class _Alloc>
  void 
  vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
  {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, *(_M_finish - 1));
      ++_M_finish;
      _Tp __x_copy = __x;
      copy_backward(__position, _M_finish - 2, _M_finish - 1);
      *__position = __x_copy;
    }
    else {
      const size_type __old_size = size();
      const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
      iterator __new_start = _M_allocate(__len);
      iterator __new_finish = __new_start;
      __STL_TRY {
        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
        construct(__new_finish, __x);
        ++__new_finish;
        __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);
      }
      __STL_UNWIND((destroy(__new_start,__new_finish), 
                    _M_deallocate(__new_start,__len)));
      destroy(begin(), end());
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start;
      _M_finish = __new_finish;
      _M_end_of_storage = __new_start + __len;
    }
  }

22-25 行，主要做的事情就是读取原有的 vector 大小 old_size，再从内存里申请一段新的空间，大小为 2*old_size，创建新的首尾指针并指向新的空间。
26-31 行，将老空间里的数据逐一搬到新的空间里，并在最后添加新的元素。这样就完成了扩容的主要目的，这是一个 O(n) 复杂度的操作，因为你需要对原数组进行逐一的深拷贝。
最后，在 32-38 行，我们需要做一些清理和收尾工作，释放掉老的数组空间和指针，将容器的首尾及容量指针都更新到对应的位置。

假设插入 N 次，那么总拷贝次数就是 1 加到 2 x 次方， x 是 logn x向上取整

`1`	`1 + 2 + 4 + 8 + … + 2 x = 2 (x+1) − 1`

这样插入 N 次的复杂度为 O(N), 平均每次插入操作复杂度为 O(1).

第二讲双向链表 list

链表简介

链表同样是一种序列式结构，但无需连续内存，使用通过指针相连的节点来存储。每个节点分为两个部分，一个是数据域 data field，另外一个是引用域 reference field。

因为通过指针串联，所以在任何位置插入或者删除节点，只需要 O(1) 的复杂度。

链表种类

链表通常有三种形式：单向链表、双向链表、循环链表

STL list 实现

list 是 STL 中的链表容器，实现了双向循环链表

节点实现

template <class T>
struct __list_node {
  __list_node<T>* next;  // 前驱节点指针
  __list_node<T>* prev; // 后继节点指针
  T data; //存储数据
};

迭代器实现

迭代器提供用于遍历的最重要的接口，支持的操作就是自增和增减

template<typename T>
struct __list_iterator{
    typedef __list_iterator<T>   self;
    typedef __list_node<T>*      link_type;
    link_type ptr; //成员
    __list_iterator(link_type p = nullptr):ptr(p){}
}

T& operator *(){return ptr->data;}
T* operator ->(){return &(operator*());}
// 类似 ++x 返回next节点
self& operator++(){
    ptr = ptr->next;
    return *this;
}
// 类似 x++ 返回当前节点
self operator++(int){
    self tmp = *this;
    ++*this;
    return tmp;
}
// 类似 --x 返回prev节点
self& operator--(){
    ptr = ptr->prev;
    return *this;
}
// 类似 x-- 返回当前节点
self operator--(int){
    self tmp = *this;
    --*this;
    return tmp;
}
bool operator==(const __list_iterator& rhs){
    return ptr == rhs.ptr;
}
bool operator!=(const __list_iterator& rhs){
    return !(*this==rhs);
}

数据结构实现

template<typename T>
class list{
    protected:
        typedef __list_node<T> list_node; // 显示定义list_node类型
        typedef allocator<list_node> nodeAllocator; // 定义allocator类型
    public:
        typedef T                  value_type;
        typedef T&                 reference;
        typedef value_type*        pointer;
        typedef list_node*         link_type;
        typedef const value_type*  const_pointer;
        typedef size_t             size_type;
    public:
        typedef __list_iterator<value_type> iterator; // 迭代器类型重写
    private:
        link_type node; // 只要一个指针，便可表示整个环状双向链表
        // ......
}

每个链表，都会有一个虚拟节点，用于标记整个循环链表的首尾连接处，它是链表的开始，也是链表的结尾，

迭代示例代码：

1
2

for (std::list<int>::iterator it=mylist.begin(); it!= mylist.end();++it)
    std::cout << ' ' << *it;

基本操作实现

初始化

void empty_initialize() {
  node = get_node(0);
  node->next = node; // next 指针指向自身
  node->prev = node; // prev 指针指向自身
}

link_type get_node() { return list_node_allocator:allocate(); }

插入

iterator insert(iterator position, const T& x) {
  lik_type tmp = create_node(x); // 创建一个临时节点
  tmp->next = position.node; // 将该节点的后继指针指向当前位置的节点
  tmp->prev = position.node->prev; // 将该节点的前驱指针指向当前位置的前驱节点
  (link_type(position.node->prev))->next = tmp; // 将前驱节点本来指向当前节点的后继指针改为指向该临时节点
  position.node->prev = tmp; // 同样，当前位置的前驱指针也要修改为指向该临时节点
  return tmp;
}

删除

iterator erase(iterator position) {
  link_type next_node = link_type(position.node->next);
  link_type prev_node = link_type(position.node->prev);
  prev_node->next = next_node;
  next_node->prev = prev_node;
  destroy_node(position.node);
  return iterator(next_node);
}

push / pop

void pop_front() { erase(begin()) };
void pop_back() {
  iterator tmp = end(); 
  erase(--tmp);
}

push_back(const T& x) { insert(end(), x); }

第三讲双端队列

队列

队列是一种先进先出的序列式数据结构

双端队列

双端队列可以在队列的两端都可以进行出队和入队操作

Deque 实现

内存布局

deque 的内存布局是由一段段连续的空间，用另一个类似数组的东西将这些空间的地址信息拼接在一起组成的。在首尾插入和删除数据的复杂度都是 O(1)

deque 既不像 vector 那样每次扩容都需要付出复制和拷贝的高昂代价，也不会像 list 那样每次插入一个新节点都需要申请一次内存。

deque 使用 map 变量来管理真正用于存储队列元素的一段段连续线性空间

可以认为 map 是一个数组，每个元素指向了一段缓冲区地址，而缓冲区对应了一段指定大小的连续内存空间，默认大小为 512 bytes

template <class _Tp, class _Alloc>
class _Deque_base {
  ...
protected:
  _Tp** _M_map;
  size_t _M_map_size;  
  iterator _M_start;
  iterator _M_finish;
  ...
}

迭代器

因为 deque 底层实质是分段连续空间，迭代器需要找到相邻的缓冲区以及当前所处位置

template <class _Tp, class _Ref, class _Ptr>
struct _Deque_iterator {
  typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
  typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
  static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
  ...
  typedef _Tp** _Map_pointer; // 缓冲区指针
  ... 
  _Tp* _M_cur; // 当前缓冲区的位置
  _Tp* _M_first; // 缓冲区的左边界线
  _Tp* _M_last; // 缓冲区的右边界
  _Map_pointer _M_node;
  _Deque_iterator(_Tp* __x, _Map_pointer __y) 
    : _M_cur(__x), _M_first(*__y),
      _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
}

_Self& operator++() {
    ++_M_cur;
    if (_M_cur == _M_last) {
      _M_set_node(_M_node + 1);
      _M_cur = _M_first;
    }
    return *this; 
 }  
  
 void _M_set_node(_Map_pointer __new_node) {
   _M_node = __new_node;
   _M_first = *__new_node;
   _M_last = _M_first + difference_type(_S_buffer_size());
 }
  
  
_Self& operator--() {
    if (_M_cur == _M_first) {
      _M_set_node(_M_node - 1);
      _M_cur = _M_last;
    }
    --_M_cur;
    return *this;
  }

基础操作

push 操作

如果当前缓冲区有空间，直接插入
如果 map 有空间，则新建一个缓冲区存入map
如果 map 空间不足，则分为两种情况
- map 使用率过半，就申请更大的空间，将老的 map 数据拷贝到新区域，map 指向的缓冲区不变
- map 使用率小于一半，将数据重新调整到 map 中间的位置

void push_back(const value_type& __t) {
    if (_M_finish._M_cur != _M_finish._M_last - 1) {
      construct(_M_finish._M_cur, __t);
      ++_M_finish._M_cur;
    }
    else
      _M_push_back_aux(__t);
  }
template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_push_back_aux()
{
  _M_reserve_map_at_back();
  *(_M_finish._M_node + 1) = _M_allocate_node();
  __STL_TRY {
    construct(_M_finish._M_cur);
    _M_finish._M_set_node(_M_finish._M_node + 1);
    _M_finish._M_cur = _M_finish._M_first;
  }
  __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));
}

pop 操作

如果迭代器和缓冲区的首位置相同，则除了释放当前的内存，还需要释放掉整段缓冲区的内存。

第四讲栈

栈区是有结构和固定大小的，区块按照次序存放，每个线程独占一个栈区，总大小也是事先确定的。

特性： LIFO

栈只能从栈顶删除或者插入元素，所以保证了后进先出的特性

STL 实现

STL 中使用了 deque 来实现 stack ，这种封装模式称为适配器模式，stack 也被看做是一种 container adapter

数据结构定义

template<typename _Tp, typename _Sequence = deque<_Tp> >
class stack
{
public:
    typedef typename _Sequence::value_type                value_type;
    typedef typename _Sequence::reference                 reference;
    typedef typename _Sequence::const_reference           const_reference;
    typedef typename _Sequence::size_type                 size_type;
    typedef          _Sequence                            container_type;
protected:
    _Sequence c; // stack 底层容器； 默认为 deque
public:
     reference
      top()
      {
        __glibcxx_requires_nonempty();
        return c.back();
      }
    void push(const value_type& __x) { c.push_back(__x); }
    void pop() {c.pop_back();}
    ...
}

第五讲 HashMap

散列

散列函数的本质是将一个更大且可能不连续空间，映射到一个空间有限的数组里，从而借用数组基于下标 O(1) 快速随机访问数组元素的能力。

但设置一个合理的散列函数是个非常有挑战的事情，比如 26 进制的散列函数就有一个巨大的缺陷，就是它所需的数组空间太大了，三位长度的元素就需要开一个接近 20000 （26^3）大小的计数数组。

这时我们需要对哈希值进行取模运算，但取模之后会遇到一个新问题：哈希碰撞。

JDK 实现

hash 方法

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

String 类型的 hashCode 方法

public int hashCode() {
    int h = hash;
    if (h == 0 && !hashIsZero) {
        h = isLatin1() ? StringLatin1.hashCode(value)
                       : StringUTF16.hashCode(value);
        if (h == 0) {
            hashIsZero = true;
        } else {
            hash = h;
        }
    }
    return h;
}

StringUTF16 hashCode 实现

public static int hashCode(byte[] value) {
    int h = 0;
    int length = value.length >> 1;
    for (int i = 0; i < length; i++) {
        h = 31 * h + getChar(value, i);
    }
    return h;
}

// like s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

在哈希计算时倾向于用奇素数进行乘法运算，因为使用偶数时相当于进行移位运算，部分位的信息丢失可能增加哈希冲突概率。

使用 31 是因为 31 * i 编译器可以自动转换成 (i « 5) - i

^ h »> 16

^ h >>> 16 把高 16位的信息叠加到低16位，这样在取模的时候就可以用到高位信息，减少冲突概率。

table 实现

transient Node<K,V>[] table;
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //在tab尚未初始化、或者对应槽位链表未初始化时，进行相应的初始化操作
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 查找 key 对应的节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 遍历所有节点 依次查找
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);  // 链表转化成红黑树
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

table 是经过散列之后映射到的内部连续数组，通过 hash 函数的计算，我们可以基于数组的下标快速访问到 key 对应的元素，元素存储的是 Node 类型。 Node 的具体实现可以是链表或者红黑树，当链表足够长时，会将链表转化成红黑树。

当table 中元素数量达到阈值时，会触发扩容逻辑

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // 翻倍扩容
    }
    else if (oldThr > 0) // 初始化的时候 capacity 设置为初始化阈值
        newCap = oldThr;
    else {               // 没有初始化 采用默认值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor; // 用容量乘负载因子表示扩容阈值
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                    // 新扩容部分，标识为hi，原来的部分标识为lo
                    // JDK 1.8 之后引入用于解决多线程死循环问题 可参考：https://stackoverflow.com/questions/35534906/java-hashmap-getobject-infinite-loop
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 整体操作就是将j所对应的链表拆成两个部分
                    // 分别放到 j 和 j + oldCap 的槽位
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

第六讲红黑树

二分查找树

每个节点的左节点，要么为空，要么比当前节点小；右节点要么为空，要么比当前节点大。

当树的高度为 h 时，查找的时间复杂度为 O(h)

平衡二分查找树

在一些情况下，二分查找树可能会退化成链表

平衡二分查找树的叶子节点高度差不超过 1

2-3 树

2-3 树是一种平衡查找树的实现，除了普通的 2 节点外，引入了 3 节点，这为自平衡增加了很大的灵活性。

3 节点在 2 节点的基础上增加了一个键，构成了一个有两个键和三条链的结构

在插入过程中，如果遇到 2 节点，直接加个键将该节点升级为 3 节点就好。

遇到 3 节点时，首先将元素放入该节点，使之成为 4 节点，然后将四节点的中间键提升到上层，

红黑树

红黑树是采用标准的二叉查找树节点并附着颜色信息来表示 2-3 树的实现，每个红色节点都和它的父节点一起构成了一个 3 节点。

红黑树有如下几个约束：

根节点为黑色
相邻节点不能同时为红色
每个节点到各个子节点的黑色节点数量相等
红节点只能作为左节点存在（这是左偏红黑树的要求）

一个 3 节点有两个键、三条链，那我们完全可以把一个以红节点为左子节点的黑节点和子节点一起看做一个 3 节点

因为红节点只是 3 节点的一部分，那么对应到红黑树上，显然不会出现两个连续的红色节点。

2-3 树上，每个节点到叶子节点的数量一定是一样的，且每个节点只包含一个黑色节点，那么红黑树到叶子节点路径中的黑色节点数量也必然是一样的。

旋转操作

旋转的作用在于处理插入和删除时产生的右偏红节点或者两个连续的红节点。

以左旋为例，本质就是将某个 3 节点从较小的键为根转移为较大的键为根

2 节点插入

当插入左边时，直接将 2 节点升为 3 节点即可

当插入右边时，将 2 节点提升为不符合规则的 3 节点，然后进行一次左旋即可。

3 节点插入

当插入右键的右侧时，将中间节点提升一层，并将左右节点变成黑色

当插入中间或者左侧时，需要进行一到两次的旋转

将三节点的左右节点变成黑色后，需要将中间键变成红色，这样当前子树到各个子节点路径的黑色节点数量就不会变化了

第七讲堆

优先队列

优先队列中的每一个元素，我们会赋予它一个优先级，优先级相同的元素遵循先进选出的原则，另有优先级高可以优先出队。

优先队列可以有多种实现方式，如链表、红黑树，但对于出队时找到优先级最高的元素需求，二叉堆是更好的选择。

二叉堆

二叉堆 binary heap 是建立在二叉树之上的，它有两个约束：

二叉堆是一颗满二叉树
二叉堆的每个节点和其子节点有偏序关系，大顶堆要求所有节点的值一定大于其左右子树的任何一个节点的值，小顶堆同理。

PriorityQueue 实现

以 JDK 14 的 PriorityQueue （简称 PQ）为例，分析基于堆的具体实现

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable {
      /**
       * Priority queue represented as a balanced binary heap: the two
       * children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The
       * priority queue is ordered by comparator, or by the elements'
       * natural ordering, if comparator is null: For each node n in the
       * heap and each descendant d of n, n <= d.  The element with the
       * lowest value is in queue[0], assuming the queue is nonempty.
       */
      transient Object[] queue; // non-private to simplify nested class access
      
      /**
       * The number of elements in the priority queue.
       */
      int size;
      
      /**
       * Inserts the specified element into this priority queue.
       *
       * @return {@code true} (as specified by {@link Queue#offer})
       * @throws ClassCastException if the specified element cannot be
       *         compared with elements currently in this priority queue
       *         according to the priority queue's ordering
       * @throws NullPointerException if the specified element is null
       */
      public boolean offer(E e) { ... }
      
      /**
       * Increases the capacity of the array.
       *
       * @param minCapacity the desired minimum capacity
       */
      private void grow(int minCapacity) { ... }
      
      public E peek() {
          return (E) queue[0];
      }

      /**
       * Inserts item x at position k, maintaining heap invariant by
       * promoting x up the tree until it is greater than or equal to
       * its parent, or is the root.
       *
       * To simplify and speed up coercions and comparisons, the
       * Comparable and Comparator versions are separated into different
       * methods that are otherwise identical. (Similarly for siftDown.)
       *
       * @param k the position to fill
       * @param x the item to insert
       */
      private void siftUp(int k, E x) { ... }
      
      public E poll() { ... }
    }
}

可以看到使用 queue 数组来存放元素，节点 queue[k] 对应的左右节点分别为 queue[2k+1]、queue[2k+2]。

堆的操作

插入

/**
 * Inserts the specified element into this priority queue.
 *
 * @return {@code true} (as specified by {@link Queue#offer})
 * @throws ClassCastException if the specified element cannot be
 *         compared with elements currently in this priority queue
 *         according to the priority queue's ordering
 * @throws NullPointerException if the specified element is null
 */
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    siftUp(i, e);
    size = i + 1;
    return true;
}

真正的插入操作是在 siftUp 函数中实现的。首先把元素放在数组尾部，然后依次向上与父节点比较，如果满足条件则位置互换。

private void siftUp(int k, E x) {
    if (comparator != null)
        siftUpUsingComparator(k, x, queue, comparator);
    else
        siftUpComparable(k, x, queue);
}



private static <T> void siftUpComparable(int k, T x, Object[] es) {
    Comparable<? super T> key = (Comparable<? super T>) x;
    while (k > 0) {
        // 计算父节点的下标
        int parent = (k - 1) >>> 1;
        Object e = es[parent];
        // 比较当前节点和父节点的关系 如果当前节点优先级更高，我们可以直接结束比较
        if (key.compareTo((T) e) >= 0)
            break;
        // 交换节点
        es[k] = e;
        k = parent;
    }
    es[k] = key;
}

删除

删除操作是将返回并删除堆顶元素

public E poll() {
    final Object[] es;
    final E result;
    // 取出堆顶元素
    if ((result = (E) ((es = queue)[0])) != null) {
        modCount++;
        final int n;
        // 其实就是要将最后一个元素放到顶部
        final E x = (E) es[(n = --size)];
        // 将最后一个元素置空
        es[n] = null;
        // 进行siftdown操作
        if (n > 0) {
            final Comparator<? super E> cmp;
            if ((cmp = comparator) == null)
                siftDownComparable(0, x, es, n);
            else
                siftDownUsingComparator(0, x, es, n, cmp);
        }
    }
    return result;
}

将根节点删除后，我们将尾部的节点提到根节点，然后依次下沉比较交互

private static <T> void siftDownComparable(int k, T x, Object[] es, int n) {
    // assert n > 0;
    Comparable<? super T> key = (Comparable<? super T>)x;
    int half = n >>> 1;           // loop while a non-leaf
    while (k < half) {
        int child = (k << 1) + 1; // assume left child is least
        Object c = es[child];
        int right = child + 1;
        if (right < n &&
            ((Comparable<? super T>) c).compareTo((T) es[right]) > 0)
            c = es[child = right];
        if (key.compareTo((T) c) <= 0)
            break;
        es[k] = c;
        k = child;
    }
    es[k] = key;
}

扩容

/**
 * Increases the capacity of the array.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 50%
    int newCapacity = ArraysSupport.newLength(oldCapacity,
            minCapacity - oldCapacity, /* minimum growth */
            oldCapacity < 64 ? oldCapacity + 2 : oldCapacity >> 1
                                       /* preferred growth */);
    queue = Arrays.copyOf(queue, newCapacity);
}

和 vector 扩容思想类似，当原容量小于 64 时，扩容到 2 倍 +2 ，否则 1.5 倍。

第八讲外部排序

常见排序算法

外部排序

外部排序是指借助外部存储来排序，相比内存，外部排序有更大的IO消耗。常用的外部排序为归并排序。

运行时间

每一层我们读取外层的数据总量是一样的，我们要做的是让归并的层次越低越好

假设数据段为 n, 归并路数为 k，那么层数为 logk(n)。但增加 k 的大小也会导致从 k 个元素中选择最小的元素的代价变高。

败者树

败者树的思想是使用叶子节点存储待比较的元素，两两比较，在父节点存储失败者，然后对获胜的元素两两比较，得到更上层的失败者。

根节点之上有一个最终获胜者

对于取出胜者并添加新元素的操作，只需要将新元素置于胜者的位置，再依次向上比较即可。

败者树相比堆，Pop时只需要和上层的败者比较即可，不像堆一定要和左右子树比较两次。

相关算法题 - 合并K个有序链表

第九讲二分法

二分查找

二分查找的核心是查找元素和比较有序排列

Kafka

Kafka 中所有的消息都是以"日志"的形式存储，消息按写入时间顺序，依次追加在许多日志文件中。文件中每条消息会相对第一条消息有一个偏移量(类似自增ID)。

Kafka 每个 topic 会有多个 partition，每个 partition下的日志按照顺序分成一个个有序日志段。

消息查找

00000000000000000000.log
00000000000000000000.index
00000000000000000000.timeindex
00000000000000000035.log
00000000000000000035.index
00000000000000000035.timeindex

上面为一个典型的日志文件存储情况：

.log 文件存储的就是消息本身的日志文件
.index 文件是索引文件
.timeindex 文件是基于时间戳的索引文件

.index 文件内容示例如下图

kafka为了使用更小的内存空间，采用了稀疏索引。

源码实现

      /**
     * Lookup lower and upper bounds for the given target.
     */
    private def indexSlotRangeFor(idx: ByteBuffer, target: Long, searchEntity: IndexSearchEntity): (Int, Int) = {
      // 检查index是否为空
      if(_entries == 0)
        return (-1, -1)
  
        // 二分搜索
      def binarySearch(begin: Int, end: Int) : (Int, Int) = {
        var lo = begin
        var hi = end
        while(lo < hi) {
          val mid = ceil(hi/2.0 + lo/2.0).toInt
          val found = parseEntry(idx, mid)
          val compareResult = compareIndexEntry(found, target, searchEntity)
          if(compareResult > 0)
            hi = mid - 1
          else if(compareResult < 0)
            lo = mid
          else
            return (mid, mid)
        }
        (lo, if (lo == _entries - 1) -1 else lo + 1)
      }
  
      val firstHotEntry = Math.max(0, _entries - 1 - _warmEntries)
      // 查询的目标offset是否在热区
      if(compareIndexEntry(parseEntry(idx, firstHotEntry), target, searchEntity) < 0) {
        return binarySearch(firstHotEntry, _entries - 1)
      }
  
      // 查询的目标offset是否小于最小的offset
      if(compareIndexEntry(parseEntry(idx, 0), target, searchEntity) > 0)
        return (-1, 0)
  
      return binarySearch(0, firstHotEntry)
    }

Kafka 使用了 mmap 将磁盘文件和内存进行映射，消息队列的特性决定了大部分索引查询其实都是在日志比较靠近尾部的区域，将索引中最后 8KB 认为热区，查询是优先查热区，没有命中再查冷区，这样就可以减少缺页中断的次数。

kafka 采用冷热二分查询的改进见这个issue

第十讲暴力搜索算法

BFS 和 DFS 是两种常见的搜索算法

第十一讲字符串匹配

Brute-Force 算法

/*
 * s: 主串
 * p：模式串
 */
std::vector<int> match(string s, string p) {
  std::vector<int> ans;
  int n = s.size();
  int m = p.size();
  int i, j;
  for (i = 0; i < n - m + 1; i++) {
    for (j = 0; j < m; j++) {
      if (s[i + j] != p[j]) break;
    }
    if (j == m) ans.push_back(i);
  }
  return ans;
}

Boyer-Moore 算法

坏字符规则

BM 算法采用从后向前匹配的方式

如上图，位置 6 匹配，那这里的 “S” 就是是个坏字符，遇到坏字符时，如果在模式串中没有出现，则说明没有重叠，可以直接跳过这段。

下一步匹配时，发现坏字符"P"，但 “P” 在模式串有出现，可以将模式串最后一次出现 “P"的位置对齐

每次发现坏字符时，我们需要向右移动移动（失配位置 - 失配字符最右出现的下标）位，其中如果失配字符没有在模式串出现，则下标为 -1，

好后缀规则

在 SIMPLE 和 EXAMPLE 的匹配中，我们发"MPLE"都匹配得上，那"MPLE"就称之为好后缀，同样"PLE”、“LE”、“E” 都是好后缀。

如果用坏字符规则，则应该将模式串移动(2 - (-1)) = 3 位，因为"I" 在模式串不存在。

我们使用好后缀的规则：找到好后缀在模式串中最右的匹配位置，总计向后移动（模式串字符串长度 - 1 - 好后缀在模式串上次出现的位置）位。上图好后缀"E" 的计算值为 6 （7-1-0）位

BM 算法具体实现

坏字符最右位置计算

def get_bc(pattern):
    bc = dict() # 记录每个badchar最右出现的位置
    for i in range(len(pattern) - 1):
        char = pattern[i]
        bc[char] = i + 1
    return bc

我们用 dict 来记录每个字符最右侧位置。工业级的实现会用 [0, 256] 的数组替代来提高性能。

好后缀计算

def get_gs(pattern):
    gs = dict()
    gs[''] = len(pattern)

    # suf_len 用于标记后缀长度
    for suf_len in range(len(pattern)):
        suffix = pattern[len(pattern) - suf_len - 1:]
        # j 用于标记可用于匹配的位置
        for j in range(len(pattern) - suf_len - 1):
            substr = pattern[j:j + suf_len + 1]
            if suffix == substr:
                gs[suffix] = len(pattern) - j - suf_len - 1

    for suf_len in range(len(pattern)):
        suffix = pattern[len(pattern) - suf_len - 1:]
        if suffix in gs: continue
        gs[suffix] = gs[suffix[1:]]

    gs[''] = 0
    return gs

匹配

def bm(string, pattern, bc, gs):
    # i 用于标记当前模式串和主串哪个位置左对齐。
    i = 0 
    # j 用于标记当前模式串匹配到哪个位置；从右往左遍历匹配。
    j = len(pattern)

    while i < len(string) - len(pattern) and (j > 0):
            # 从右往左匹配每个位置
            a = string[i + j - 1]
            b = pattern[j - 1]
            if a == b: # 匹配的上，继续匹配前一位
                j = j - 1
            else: # 匹配不上，根据两个规则的预处理结果进行快速移动
                i = i + max(gs.setdefault(pattern[j:], len(pattern)), j - bc.setdefault(a, 0))
                j = len(pattern)
            # 匹配成功返回匹配位置
            if j == 0:
                return i
    # 匹配失败返回 None
    return -1
    
if __name__ == '__main__':
    string = 'here is a simple example ' 
    pattern = 'example'

    bc = get_bc(pattern)  # 坏字符表
    gs = get_gs(pattern)  # 好后缀表

    print(gs)

    x = bm(string, pattern, bc, gs)

    print(x)

第十二讲拓扑排序

如上图的课表，部分课程学习有一些前置课程，用图的方式表示如下：

如果我们给出一个序列使得每个节点只出现一次，且保证如果存在路径 P 从 A 到 B，那么 A 在序列中一定出现在 B 之前，满足这个条件的序列就被可认为满拓扑排序。

拓扑排序是建立在有向无环图（DAG）的基础之上的.

khan 算法

khan 算法是一种基于贪心和广度优先思想的拓扑排序实现

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        // 邻接表数组
        vector<vector<int>> next(numCourses, vector<int>());
        // 入度表
        vector<int> pre(numCourses, 0);
        // 标记是否遍历过
        vector<int> visited(numCourses, 0);
        // 记录最终修读顺序
        vector<int> ans;

        // 构图
        for (auto edge: prerequisites) {
            int n = edge[0];
            int p = edge[1];

            next[p].push_back(n);
            pre[n]++;
        }

        queue<int> q;

        // 所有没有先修课程的课程入队
        for (int i = 0; i < numCourses; i++) {
            if (pre[i] == 0) {
                q.push(i);
            }
        }

        // BFS搜索
        while(!q.empty()) {
            int p = q.front();
            q.pop();
            ans.push_back(p);

            visited[p] = 1;
            // 遍历所有以队首课程为先修课程的课程
            for (auto n: next[p]) {
                // 由于队首课程已经被修读，所以当前课程入度-1
                pre[n]--;
                // 如果该课程所有先修课程已经修完；将该课程入队
                if (pre[n] == 0) {q.push(n);}
            }
        }

        // 环路检测： 如果仍有课程没有修读；说明环路存在
        for (int i = 0; i < numCourses; i++) {
            if (!visited[i]) return vector<int>();
        }

        return ans;
    }
};

DFS

// https://github.com/marcelklehr/toposort
    /**
   * Topological sorting function
   *
   * @param {Array} edges
   * @returns {Array}
   */
  
  module.exports = function(edges) {
    return toposort(uniqueNodes(edges), edges)
  }
  
  module.exports.array = toposort
  
  function toposort(nodes, edges) {
    var cursor = nodes.length
      , sorted = new Array(cursor)
      , visited = {}
      , i = cursor
      // Better data structures make algorithm much faster.
      , outgoingEdges = makeOutgoingEdges(edges)
      , nodesHash = makeNodesHash(nodes)
  
    // check for unknown nodes
    edges.forEach(function(edge) {
      if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
        throw new Error('Unknown node. There is an unknown node in the supplied edges.')
      }
    })
  
    while (i--) {
      if (!visited[i]) visit(nodes[i], i, new Set())
    }
  
    return sorted
  
    function visit(node, i, predecessors) {
      if(predecessors.has(node)) {
        var nodeRep
        try {
          nodeRep = ", node was:" + JSON.stringify(node)
        } catch(e) {
          nodeRep = ""
        }
        throw new Error('Cyclic dependency' + nodeRep)
      }
  
      if (!nodesHash.has(node)) {
        throw new Error('Found unknown node. Make sure to provided all involved nodes. Unknown node: '+JSON.stringify(node))
      }
  
      if (visited[i]) return;
      visited[i] = true
  
      var outgoing = outgoingEdges.get(node) || new Set()
      outgoing = Array.from(outgoing)
  
      if (i = outgoing.length) {
        predecessors.add(node)
        do {
          var child = outgoing[--i]
          visit(child, nodesHash.get(child), predecessors)
        } while (i)
        predecessors.delete(node)
      }
  
      sorted[--cursor] = node
    }
  }
  
  function uniqueNodes(arr){
    var res = new Set()
    for (var i = 0, len = arr.length; i < len; i++) {
      var edge = arr[i]
      res.add(edge[0])
      res.add(edge[1])
    }
    return Array.from(res)
  }
  
  function makeOutgoingEdges(arr){
    var edges = new Map()
    for (var i = 0, len = arr.length; i < len; i++) {
      var edge = arr[i]
      if (!edges.has(edge[0])) edges.set(edge[0], new Set())
      if (!edges.has(edge[1])) edges.set(edge[1], new Set())
      edges.get(edge[0]).add(edge[1])
    }
    return edges
  }
  
  function makeNodesHash(arr){
    var res = new Map()
    for (var i = 0, len = arr.length; i < len; i++) {
      res.set(arr[i], i)
    }
    return res
  }

第十三讲哈夫曼树

HTTP2 使用 HPACK 压缩协议来了压缩 Header，其主要包括三个部分

静态表
动态表
哈夫曼编码

静态表

有 61 个常用字段（部分包含值）编码到了 1~61 的索引表里

动态表

静态表字段有限，允许通过通信的方式，在客户端和服务端之间维护一张动态的字典，用索引来代表值

哈夫曼编码

限于静态表和动态表的大小，我们并不能压缩任意数据，于是引入哈夫曼编码来进一步提高压缩能力。

哈夫曼编码的主要思想就是让出现概率高的字符用短编码，概率低的用长编码；同时为了避免变长编码产生歧义，所以不同的字符键不能成为对方的前缀。

算法实现采用了贪心思想，用一颗二叉树来标记每个字符的编码方式，左分支代表 0，右分支代表 1；所有需要编码的字符对应一个叶子节点，根节点到该叶子节点的路径代表该字符的编码方式。

编码示例，假设有 a、b、c、d、e、f 六个字符，分别出现的频率是 5、9、12、13、16、45。依次选取两个频率最小的节点合成一颗子树，用两个频率只和代表父节点的频率。

最终对应编码为：

f          0
c          100
d          101
a          1100
b          1101
e          111

代码实现可借助小顶堆

    void buildHuffmanTree(string text)
  {
    // 利用hashmap对字符串进行频率计数
    unordered_map<char, int> freq;
    for (char ch: text) {
      freq[ch]++;
    }
  
    // 用堆去动态维护所有树中最小的两颗
    priority_queue<Node*, vector<Node*>, comp> pq;
  
    // 将所有的字符都初始化成为哈夫曼树的一个叶子节点
        // 并推入优先队列
    for (auto pair: freq) {
      pq.push(getNode(pair.first, pair.second, nullptr, nullptr));
    }
  
    // 每次取出最小的两个合并 直至优先队列只剩一个节点
    while (pq.size() != 1)
    {
      // 最小的两个节点出队
      Node *left = pq.top(); pq.pop();
      Node *right = pq.top();  pq.pop();
  
      // 建立一个内部节点，以这两个最小的树为左右节点
        int sum = left->freq + right->freq;
      pq.push(getNode('\0', sum, left, right));
    }
  
    // 优先队列中最后一个元素为整棵树的根节点
    Node* root = pq.top();
  }

2021年终总结

Sun, 13 Feb 2022 11:43:41 +0800

其实从12月开始就在想要写总结了，一直拖延，然后就想农历新年再写，结果就拖到现在。支撑我写总结的原因是看到太多真诚开放的年度总结了，向大家看齐，做一个真诚开放的自己。

工作

我一直以来并没有清晰明了的职业规划，年初选择数字货币行业 offer 的一个很大外部原因是我转行当程序员之前就非常喜欢的的程序员大佬在 2018 年就加入了这个行业，她公众号【嘀嗒嘀嗒】写的她自己经历的文章，看似简短，但让人常看常新，尤其是到了某些纠结迷茫的时候。

转眼新工作就一年了，一开始对数字货币几乎一无所知。从注册各种交易所账户体验炒币开始，接着跟风推特转发抢空投，然后在去中心化交易所交换各种币。区块链技术上也学了极客时间上的一门相关课程，然后找了一个高 star 开源的简易区块链实现照着实现了一遍，对区块链原理和运行有了进一步的了解，做入职分享时了解了一点 Conflux 公链。

我所在的小组负责交易所内部做市业务，交易所算我们的上游，而区块链又算交易所的上游。量化做市是为交易所提供流动性，简而言之就是使用程序根据一定的策略逻辑调下单接口自动挂买卖单由此产生深度，这样其他用户就可以有对手盘可以交易。在市场行情不可控的前提下如何既提供流动性又能保证不亏钱？这是一个难题！目前最主流的方式的通过对冲来控制风险和获取盈利，但是对冲太依赖对冲方了，很多时候找不到对冲方，有时也需要对冲更直接高效的方法。

小组从年初的 2 人到年末的 4 人，总算有点组的样子了。不过作为独立的内部小组，也不对外提供服务，我们组在公司有点隐身的感觉。我们没有产品、前端、测试等上下游配合，完全是自我在迭代，需求、实现和交付都自己来。我们的技术栈看起来朴实无华，网站用经典的 flask + jquery + bootstrap 组合，策略开发用 Python。其实我好久没有写过网页了，仍记得学 css 时对自己写的页面深深地不忍直视，好在有框架，也好在是自己用；另外顺道了解了 Vue 和 Nuxt.js，引入了很香的 pyechart 做可视化。策略方面，之前一份工作和量化数据和策略相关，但业务偏向于做一个通用的平台给别人来做策略研究。直到自己真的来写实盘策略，发现实盘策略和模拟策略差别太大了，真实交易情况下要考虑手续费，下单可能不成交，下单可能超时但实际成交了，交易所可能临时维护等等。另外策略属于比较机密的东西，而且不同的策略有不同的使用场景，真正优质的开源作品不多，让我收获最大的是 aioquant 和 hummingbot，感兴趣的同学可以看看。

生活

处在数字货币 7 * 24 小时交易这样的金钱永不眠的环境下，人难免变得浮躁，尤其是持有了一些资产之后，面对价格的浮动，内心的贪婪和恐惧都赤裸裸地展现出来，有一段时间，我会不停地刷手机上的行情软件，整个人变的无比焦虑，后面想清楚了自己是一个长期投资者，于是把行情软件都卸载了。直到元旦节计算盈亏，算下来总体应该没有亏，检查个人账户，才发现账户资产几个月前被人盗走了，不知道助记词何时被泄露了！而作为去中心化服务，被盗欲诉无门，只能认栽！

跑步仍是我的首选的长期爱好，总里程 400 公里，数字不大，但重要的是能让我养成早起健身的习惯，其中 5月份又去参加了汶川半马，之前两次都是我一个人参加，这次是带着爸爸和姐姐去参加，有家人在终点等我的感觉还是蛮好的，跑完步又带着爸爸和姐姐去了都江堰、青城山逛了逛，这算是我们三个人第一次一同旅行，还是蛮难得的。

12 月份和同学延续了一年一见的惯例。不过我周中先去了永宁和泉州，体验闽南习俗；周末和同学（及和同学般的前同事）在苏州碰头，一年未见，大家都感叹时间飞逝，每个人都在为各自的生活而前行。作为一个成年人，应该都体会到很多时候再见最多就是在朋友圈点赞见了，所以有时我感到自己能作为一个这样的中间的联结者而开心。

今年看了20+ 本书，微信读书是在太方便了，纸质书越读越少，最推荐的书是《项塔兰》，看完在心里立了一个小目标：有机会去一次印度。

英语学习现在迁移到了开言英语 APP 上，我还蛮喜欢真人英语视频对话这种模式的，每天大概 20 分钟的样子，不会感觉太大压力。

尝试了一下画画，但开始体验并不是很好，就放弃了，或许以后有机会吧。

展望

探索个人在区块链领域更多可能性：比如公链、智能合约
学习算法、docker和K8S
完结在学的C和操作系统课程
跑步每周三次，参加一次半马
每周英语练习
带家人旅行一次（计划去四姑娘山）

[笔记]深入C语言和程序运行原理

Mon, 31 Jan 2022 17:04:50 +0800

第零讲课前热身

数据量单位

位（bit）：是最小存储单位，每个位可以存一个二进制码值得 0 或 1 字节（byte）：通常是由八个位组成的一个存储单元，是计算机最小的可寻址单位位（word）：是处理器使用的自然数据单位，处理器单个指令可以操作的最大的内存块一般为一个字节大小

汇编语言

汇编语言（Assembly Language）是一种低级编程语言，和 CPU 架构相关。

汇编语言使用助记符（Mnemonic）来表示每个低级的机器指令，不同的汇编指令可以使用不同的参数形式，以 mov 指令举例，有如下三种形式：

mov r/m, r
mov r, r/m
mov r/m, imm

指令参数中，r 表示寄存器（register），m 表示内存（memory），imm 表示立即数（immediate）。指令mov ebx 1的含义是将立即数 1 存到寄存器 ebx 中。在x86指令集中，受限于 CPU 实现的复杂的，不存在将两个内存地址同时作为 src 和 dest 参数的指令。

指令mov ebx 1对应的机器码为 bb 01 00 00 00 机器码由 OpCode 和 Immediata Data 两部分组成，OpCode 占用一个字节，mov 对应的指令是 0xb8，寄存器对应阈值为 0x3，组合在一起即为 0xbb；由于 mov 传送 32 位数，所以立即数单独占用 4 个字节（使用小端序）

寄存器

寄存器可以简单理解为 CPU 提供的一组由位于芯片上的高速存储器硬件，拥有最快的数据访问速度和最低的延迟

寄存器通常分为如下几类：

统一寄存器：一般存放程序运行过程中产生的临时数据
状态寄存器：一般存放之间执行结果相关的状态信息，如指令是否引起进位等
系统寄存器：一般由操作系统使用，存放中断、CPU模式等信息

x86-64 架构中定义了 16 个通用寄存器，每个寄存器可以存放4个指令字（每个指令字16字节）

在汇编代码中，可以使用每个寄存器的不同别名来访问对应的低 8 位，低 16 位，低 32 位，以及完整的 64 位数据

需要注意的是当重写寄存器的低32位数据时，高32位数据会被置零，可以使用如下代码进行对比。

#include <stdio.h>
int main(void) {
  register long num asm("rax") = 0x100000000;
  asm("movl $0x1, %eax");
  // asm("movw $0x1, %ax");
  printf("%ld\n", num);
  return 0;
}

第一讲一个C程序的完整生命周期

C核心语法

实例程序如下


#include <stdlib.h> 
#include <stdio.h>
#include <stdint.h>
#include <assert.h>
#include <stdbool.h>

#define BOOL_TRUE 1  // 定义用到的宏常量与宏函数；
#define BOOL_FALSE 0
#define typename(x) _Generic((x), \
  unsigned short: "unsigned short int", \
  unsigned long: "unsigned long int", \
  default: "unknown")

typedef enum { Host, IP } IP_ADDR_TYPE;  // 定义枚举类型 IP_ADDR_TYPE，用于表示联合中生效的字段；
typedef struct {  // 定义结构 CONN；
  size_t id;
  uint16_t port;
  bool closed;
  IP_ADDR_TYPE addr_type;
  union {
    char host_name[256];
    char ip[24];
  };
} CONN;

inline static const char* findAddr(const CONN* pip) {  // 定义函数 findAddr，用于打印 CONN 对象的信息；
  assert(pip != NULL);  // 运行时断言，判断传入的 CONN 指针是否有效；
  return pip->addr_type == Host ? pip->host_name : pip->ip;
}

int main(int argc, char* argv[]) {  // 入口函数；
  static_assert(sizeof(CONN) <= 0x400, "the size of CONN object exceeds limit.");  // 静态断言，判断 CONN 对象的大小是否符合要求；
  const CONN conns[] = {  // 构造一个数组，包含三个 CONN 对象；
    [2] = { 1, 80, BOOL_TRUE, IP, { .ip = "127.0.0.1" } },
    [0] = { 2, 8080, BOOL_FALSE, IP, { .ip = "192.168.1.1" } },
    { 3, 8088, BOOL_FALSE, Host, { .host_name = "http://localhost/" } }
  };

  for (size_t i = 0; i < (sizeof(conns) / sizeof(CONN)); ++i) {  // 遍历上述 CONN 数组，并打印其中的内容；
    printf(
      "Port: %d\n"
      "Host/Addr: %s\n"
      "Internal type of `id` is: %s\n\n",
      conns[i].port,
      findAddr(&conns[i]),
      typename(conns[i].id)
    );
  }
  return EXIT_SUCCESS; 
}

入口函数

使用 main 函数作为入口函数，返回值为 0 表示成功。

数组

conns 即为数组

结果体和联合体

结果体中所有定义的字段对应内存连续排列联合体中同时只有一个字段生效，分配的内存为最大字段占用内存

控制语句

指针

宏

宏函数 typename 使用了 C11标准引入的 _Generic 关键字

断言

断言分为静态断言和动态断言，静态断言在代码编译时进行检查

函数内联

使用 inline 内联关键字，可以建议编译器将该函数的内部逻辑直接替换到函数的调用位置处，以减少函数调用开销提升性能

C 语言编程范式

C 语言属于命令式编程（Imperative Programing），这种范式更关注计算机完成任务所执行的具体步骤；与之对的另外一种编程范式为声明式编程（Declararive Programing），这种范式更倾向于表达计算逻辑。区别实例如下：

# 命令式
#define ARR_LEN 5
int main(void) { 
  int arr[ARR_LEN] = { 1, 5, 10, 9, 0 };
  for (int i = 0; i < ARR_LEN; ++i) {
    if (arr[i] > 7) {
      // save this element somewhere else.
    }
  }
  return 0;
}


# 声明式
let arr = [1, 5, 10, 9, 0]
let result = arr.filter(n => n > 7)

编译和运行

代码预处理：编译器会移除所有注释信息、处理宏指令。
编译优化：编译器优化源码，将代码编程成汇编格式。
汇编：编译器将汇编代码编译成操作系统使用的某种对象格式。
链接：编译器将依赖的对象文件进行整合，设置好程序中所有调用函数的正确地址，生成二进制执行文件。

第二讲数据和量值

量值

量值可以粗略地分为变量（Variable）和常量（constant）

变量

C 语言变量类型占用的具体字节大小与程序运行所在的硬件体系结构紧密相关

常量

在 C 语言中，通过内联方式直接写到源码中的字面量值一般被称为常量。

使用 const 关键字修饰的变量更接近于只读变量，不具有”常量表达式“属性，因此无法用来表示定长数组大小或使用在 case 语句中。常量表达式在编译时被求值，而只读变量在运行时才被确定

数据的存储形式

计算机内部使用补码（Two’s-complement）存放有符号整数，使用对应的二进制来存放无符号整数，使用 IEEE-754 标准来存放浮点数。

补码

一个补码所表示的实际数值，由负权重位的值（最高位）和正权重为的值求和。如 1101，是及对应的值为 -3（-8 + 5）。由此也得出四位补码的最小值为 -8（1000），最大值为 7（0111）。

IEEE-754

数据的存储位置

应用程序被正常加载前，需要将应用程序代码机器相关依赖数据映射到内存的某个位置，这段内存称之为进程的VAS（Virtual Address Space 虚拟地址空间）.

初始化的全局变量和静态变量和应用程序具有同样的生命周期，其值通常会被存放到进程VAS内的 .data 中。

局部变量存放于寄存器或者 VAS 的栈中

通过 malloc 创建的内存存放于 VAS 的堆中

未初始化的全局变量和静态变量存放于 VAS 的 .bss 中

常量会按照数据的大小和类型存放于 VAS的 .text （通常存放代码）或 .rodata （通常存放只读数据）中

第三讲运算符

运算符（operator）、表达式（expression）和语句（statement）是组成 C 语言程序的三个基本的语法结构，且一般依次呈包含关系。

运算符分类

算数、关系、为、赋值运算

这四类运算符经过编译后，可以直接对应到由目标平台上相应的机器指令组成的简单计算逻辑。

拿下图的 foo 函数举例

DWORD PRT [rbp-8] 指将寄存器 rbp 的值减去 8 得到的结果作为起始地址，然后操作一个大小为 DWORD 的空间。intel体系中 WORD 表示 16 位，DWROD 表示 32 位，QWORD 表示 64 位。

int arithmetic = x + y;对应的汇编代码中，前两行代码为分别从栈内存中将变量 x 和 y 存入寄存器 edx 和 eax，接着通过 add 指令计算两者之和，最后通过 mov 指令将寄存器 eax 的值移到局部变量 arithmetic 对应的栈内存中。

FLAGS 寄存器是一组用于反映程序当前运行状态的标志寄存器，详情如下

cmp 指令会在 CPU 内部对两个操作数进行隐式减法运算，然后设置 FLAGS寄存器状态。

逻辑运算符

以与运算符 && 举例，示例代码如下

je 指令会判断 ZF 标志位是否为 0，如果是则跳转到指定地址

与运算的高级编辑优化，编译器会采用 test、setne、movzx来实现，这种方式减少了对栈内存即条件跳转指令的使用，是的程序减少了访问内存时产生的延迟，以及由于分支预测失败导致的CPU周期延迟。

test    edi, edi  ; edi <- x.
setne   al
test    esi, esi  ; esi <- y.
setne   sil
movzx   esi, sil
and     esi, eax

成员访问运算符

int* n_ptr = &n;对应的汇编指令中首先 lea 指令将寄存器 rbp 中的值减去 16 后，存放到 rax 寄存器，即将n在站上的地址存放到 rax 寄存器；然后将 rax 寄存器的值存到变量 n_ptr对应的栈内存的存储位置。

int m = *n_ptr;对应的汇编指令中首先将 n_ptr的值传送到寄存器 ra；随后将 rax 的值作为地址，将该地址上的值以 DWORD（即 int）形式传送到 eax 寄存器；最后将 eax 寄存器中的结果只传送到变量 m 在栈内存的存储位置。

其他运算符

这里介绍 sizeof 和 (type)，示例如下：

size_t n = sizeof(int) 的汇编指令可以看出直接将结果4存到了 n 对应的栈内存。

short f = (short) n;的汇编指令首先将变量 n 的值移到 rax 寄存器，然后将其中低 16位的数据（ax）地道 f 所在的内存趋于

第四讲控制逻辑

表达式

表达式（expression）是由一系列运算符和操作数（operand）组成的一种语法结构。

对表达式的求值过程，实际上就是根据运算符的优先级和结合性，来对表达式和它所包含的子表达式进行递归求值的过程。

可以使用clang -Xclang -ast-dump -fsyntax-only main.c 命令得到 C 程序对应的 AST 结构

语句

语句（statement）是用来描述程序的基本构建块。

语句可以包含或者不含表达式；语句在执行时不返回任何结果；语句以分号结尾。

语句分为复合语句、表达式语句、选择语句、迭代语句、跳转语句。

int foo(int x, int y) {  // 复合语句；
 int sum = x + y; // 表达式语句；
 if (sum < 0) {  // 复合语句；
   sum = -sum;  // 表达式语句；
 }
 return sum;
}

选择语句

if...else 语句示例如下：

switch...case语句示例如下：

迭代语句

迭代语句主要包含 do...while、for、while 三种形式，u示例如下：

跳转语句

跳转语句主要包含 break、continue、return、goto 四种形式

第五讲函数调用（上）

快速回顾

借用函数，可以将一个程序的实现过程拆分为多个子步骤，并以结构化的方式来构建程序。

#include <stdio.h>
#include <tgmath.h>
typedef struct {
int x;
int y;
} Point;
int foo(int x, int y, Point* p, int(handler)(int)) {
return handler(x + y + p->x + p->y);
}
int handler(int n) {
return sqrt(n);
}
int main(void) {
int x = 2;
int y = 3;
Point p = { .x = 10, .y = 10 };
printf("%d", foo(x, y, &p, handler));  // 5.
return 0;
}

函数类型的参数默认以指针传递，可以省略表明指针类型的*符号


int foo(int x, int y, Point* p, int(*handler)(int)) {
  return (*handler)(x + y + p->x + p->y);
}

C 函数的调用约定

我们将编译器实现函数调用所遵循的一系列规则称之为函数的调用约定（Calling Convention）

调用约定并非 C 语言标准的一部分，不同平台有不同的标准， Unix系统使用 System V AMD64 ABI （简称 SysV）的调用约定

SysV 函数调用示例如下：

函数调用是通过 call 指令来完成，每个函数执行完毕后通过 ret 指令来退出函数的执行，并转移代码执行流程到之前函数调用指令的下一条指令上

参数约定

对于整形和指针类型的实参，需要分别使用寄存器 rdi、rsi、rdx、rcx、r8、r9，按函数定义是参数从左到右的顺序进行传值。如果参数超过 6 个，则余下参数通过栈内存进行传送，多出来的参数从右到左入栈

对于浮点数，使用 xmm0 到 xmm7 共 8 个寄存器进行存储。对于更宽的值，也可能使用 ymm 与 zmm 寄存器来代替 xmm 寄存器。

返回值传递

整数类型返回值，小于 64 位，使用 rax 寄存器（32 位的别名为 eax ），小于 128 位，使用 rax和 rdx 分别返回低 64 位和高 64 位

浮点数会使用 xmm、ymm、zmm 寄存器。

寄存器使用

对于 rbx、rbp、rsp 和 r12 ~ r15 寄存器，若函数需要使用它们，需要使用前暂存，退出前恢复。

堆栈清理

每个函数在结束前，需要清理自身的堆栈，可以通过 leave 指令完成

其他约定

函数在 call 调用前，需要保证栈顶地址值 16 字节对齐
从栈顶向上保留128 字节作为 “Red Zone”
系统调用使用寄存器 rdi、rsi、rdx、r10、r8 和 r9 传递参数

Red Zone 是位于栈顶向上的一段固定长度的内存段，这块区域可以被调用函数栈中的 “叶子” 函数（即不再调取其他函数的函数）使用，这样在需要额外栈内存时，就能省去调整栈内存大小的过程。

保存函数调用信息的栈帧

我们将栈内存数据块称之为帧栈，帧栈存放有返回地址、实参局部地址、返回值和暂存的寄存器值。

在进程内存中，栈内存是从高向低增长的，即栈底位于高地址处，栈顶位于低地址处。

rsp 寄存器又称之为 Stack Pointer，其存放着栈顶地址，即其决定了栈内存大小，通过减小其存储的值，就能扩大栈内存。

bar 函数第一行指令 push rbp 会将当前 rbp 寄存器的值存到栈中， rbp 寄存器又称为 Frame Pointer，通常来存储调用前的栈高度，即 rsp的旧值，以便进行帧栈寻址，并在退出前将栈中数据恢复到调用前的状态；第二行指令mov rbp, rsp便是将 rsp 的值保存到 rbp 中；第三行指令mov eax, 10 将结果存入 eax 寄存器; 第四行指令pop rbp 恢复 rbp 寄存器的值；第五行指令ret 将程序的执行转移到函数调用前。

main 函数第 29 行指令sub rsp, 16减小 rsp 的值，将栈空间扩大 16 字节；第 30、31 行指令分别将 1 和 2 存入 rbp-4 和 rbp-8 的位置；第 34、35 行指令，借助 push，将 8 和 7 存入 rbp-12 、 rbp-16的位置。

leave 指令会恢复 rsp的值来“清理”栈数据，并恢复 rbp的值。等效于: mov rsp, rbp; pop rbp; 与之对应的 enter 指令等效于 push rbp; mov rpb, rsp

第六讲函数调用（下）

函数参数求值顺序

#include <stdio.h>
int main(void) {
int n = 1;
printf("%d %d %d", n++, n++, n++);
return 0;
}

如上示例程序，C 函数参数的求值顺序并没有被明确规定，有的编译器按从左到右计算，有的从左到右计算。

为了程序健壮性，不要编写需要依赖特定函数参数求值顺序的代码。

尾递归调用优化（tail-call optimization）

函数调用过程所需数据是以帧栈的形式存到到进程的栈内存中，而栈内存的清理工作是在函数准备ret 返回前，通过 leave指令进行。对于正常的递归函数，由于函数不断调用自己，产生的帧栈越来越多，可能导致内存溢出；另外函数调用会创建和销毁帧栈，这也是消耗性能的。

尾递归调用优化是指在一定条件下，编译器直接利用跳转指令代替函数调用指令，来模拟函数调用过程，这样便可省去函数调用帧栈的不断创建和销毁，而且也只使用了有限的栈内存。

尾递归调用优化一个前提条件是：递归语句必须是在函数返回前的最后一条语句。在这种情况下，编译器才能确定函数的返回值没有被上一个帧栈所使用。

上面的函数开启最高编译优化等级”-O3“后，会使用尾递归优化，在执行 ret 前，会判断寄存器 edi 的值是否为0 （ZF=1），来决定调转

K&R 函数声明

K&R 函数声明可能不知道函数的参数列表，如下所示：

#include <stdio.h>
int add();
int main(void) {
printf("%d", add(1));  // ?
return 0;
}
int add(int x, int y) {
return x + y;
}

这样导致参数是一个随机值，不建议使用。

第七讲枚举、结构和联合是如何实现的？

枚举 Enumeration

从汇编代码可以看出自定义枚举类型都是以 int 类型存储的，枚举值 Mon 在底层是由 0 表示。

C 标准直接将枚举值当做整数进行处理，这样导致foo 函数在调用时，实际上允许传入任何可以被隐式转换为 int 类型的值。

结构 Struct

结构和数组类型，都是使用连续的内存存放数据，不过结构可以存放不同的类型的数据。

本质上，结构只是对内部所包含的各类数据的一个封装，因此只需要它分装的这些数据放在连续的内存装即可。

如上图的栈内存所示，字符转指针 p 位于 [rbp-32] 处，占用 8 个字节，字符 c 位于 [rbp-24] 处，占用 1 个字节，长整形 x 位于 [rbp-16]处，占用 8 个字节。

内存数据对齐

自然对齐是指被操作数据所在的地址为该数据大小的整数倍，当内存中的数据满足自然对齐时，CPU通常能够以最高的效率进行数据操作。

填充字节

某些情况即使结果对象各个数据成员都满足自然对齐的要求，额外的填充字节也会被添加，如下示例：

struct Foo {
char *p;  // 8 bytes.
char c;  // 1 bytes.
// (padding): 7 bytes.
};

之所以会这样，因为编译器想保证：当结构体被连续存放时，前一个对象结束的位置正好可以满足后一个对象的起始位置时自然对齐的要求。这样也就要求结构对象本身的大小必须是内部最大成员大小的整数倍。

联合 Union

联合和结构语法类型，只要把关键字从 struct 改为 union。顾名思义，联合就是所有字段共同使用一个内存区域。

联合对象的大小与内部定义最大成员的大小相同。

对一个单独的联合对象来说，哪个字段在生效我们无从得知，所以需要一个标签字段来配合指明正在生效的字段，这样模式叫做“Tagged Union”.

第八讲指针是如何灵活使用内存的

指针的基本使用

通过类型说明符加 * 符号可以定义一个指向该数据类型的指针。通过 const 关键字可以限制指针变量的行为

指针和数组

从上图看出，数据中的元素被分配在连续的栈内存中。

当 arr 作为实参传入函数 sum 后，实际传入的是一个指向 int 类型的指针，有关 arr 的大小和类型都全部丢失，这种情况称之为”数组的退化“。

指针的其他运算

算术运算

当我们对指针进行加减运算时，编译器是以当前指针所指向值对应的某个固定长度为单位，对指针中存放的地址值进行相应调整的。

关系运算

大多数情况，编译器会使用 cmp 和 setg 等指令来判断关系运算两侧操作数的大小

堆内存指针

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 5
int main(void) {
  int arr[] = { 1, 2, 3, 4, 5 };  
  // 分配用于存放 N 个整数的堆内存；
  int* p = (int*) malloc(sizeof(int) * N);
  // 将数组 arr 中的元素复制到分配的堆内存中；
  memcpy(p, arr, sizeof(int) * N);  
  for (int i = 0; i < N; ++i) {
    // 通过指针遍历堆空间中的数据；
    printf("%d\n", *(p + i));
  }
  // 释放先前分配的堆空间，让操作系统可以回收内存；
  free(p);  
  return 0;
}

在 VAS 中，堆内存位于栈内存的下方，堆内存是从低地址向高地址逐渐增长

堆内存可以动态创建，可以保持和程序相同的生命周期。另外和全局变量、静态变量这种将值完全暴露给所有程序代码相比，使用堆内存可以将数据的使用限制在所需的最小范围内，加强了程序对内存的精细化管理程度。

第九讲预处理器

预处理流程

预处理流程如下：

删除代码注释
处理宏定义 #define，进行展开和替换
处理条件预编译 #if、#elif，仅保留符合条件的代码
处理文件包含预编译指令 #include，将被包含的文件内容插入到指令所在位置
处理其他可识别的预处理指令如 #program
添加其他具有辅助性功能的注释信息

#pragma GCC warning "Just FYI!"
#include <stdbool.h>
#define PI 3.14
#define SQUARE(x) (x * x)
int main(void) {
#if defined PI
  // Some specific calculations.
  const double area = SQUARE(5) * PI;
  const bool isAreaGT100 = area > 100.0;
#endif
  return 0;
}

使用gcc -O0 -Wall -E exmaple.c -o example.I 得到预处理后的代码如下：

# 1 "macro.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "macro.c"

# 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdbool.h" 1 3 4
# 3 "macro.c" 2



int main(void) {

  const double area = (5 * 5) * 3.14;
  const
# 8 "macro.c" 3 4
       _Bool
# 8 "macro.c"
            isAreaGT100 = area > 100.0;
  return 0;
}

宏函数常用技巧

为返回值添加括号

#include <stdio.h>
// #define FOO(x) 1 + x * x
define FOO(x) (1 + x * x)
int main(void) {
  printf("%d", 3 * FOO(2));
  return 0;
}

为参数添加括号

#include <stdio.h>
// #define FOO(x) (1 + x * x)
define FOO(x) (1 + (x) * (x))
int main(void) {
  printf("%d", 3 * FOO(2));
  return 0;
}

警惕多次副作用

#include <stdio.h>
#define FOO(x) (1 + (x) * (x))
int main(void) {
  int i = 1;
  printf("%d", FOO(++i));
  return 0;
}

定义完备的多语句宏函数


#include <stdio.h>
// #define SAY() printf("Hello, "); printf("world!")

#define SAY() do { printf("Hello, "); printf("world!")} while (0)
int main(void) {
  int input;
  scanf("%d", &input);  
  if (input > 0)
    SAY();
  return 0;
}

第十讲字符、字符串与数学计算

字符和字符串

在 C 语言中，字符用单引号表示，字符串用双引号表示

字符

C 语言保证 char 类型只占用一个字节大小。

大多数情况编译器会选择 char 类型视为有符号整数类型。

字符串

字符串可以使用指针或者数组形式表示。

连续出现的字符串之间如果仅有空格分隔，则会将它们视为一个整体。

1
2
3

// read-only string.
const char strA[] = "Hello, geek!";  
const char* strB = "Hello" ", geek!";

上述字符串在内存的布局如下：

字符串被存放在连续的内存段上，且每个字符串最后都以一个空字符作为终止符。

使用数组和指针形式定义的字符串，其底层的数据引用方式会有所区别。其中数组方式会将字符串从 .rodata 中拷贝到其他位置（比如栈内存），因此修改这些这些数据不会改变原始的 .rodata 中的副本；而使用指针形式时指针会直接引用位于 .rodata 中的字符串数据，因此通过指针修改字符串的值会影响相同指向的指针字符串。

字符库函数

统计字符串长度

#include <string.h>
#include <stdio.h>
int main(void) {
  const char str[10] = "Hi";
  printf("%zu\n", strlen(str));  // 2.
}

strlen 函数不会计入字符串多余的终止符。

拼接字符串

#include <string.h>
#include <stdio.h>
#define STRLEN 14
int main(void) {
  char strA[STRLEN] = "Hello,";
  char strB[] = " world!";
  strncat(strA, strB, STRLEN - strlen(strA) - 1);
  printf("%s\n", strA); 
}

strncat 可控制被拼接字符串的长度

拷贝字符串

#include <string.h>
#include <stdio.h>
int main(void) {
  char strA[] = "aaaaaa";
  char strB[] = "bbbbbbb";
  printf("%s\n", strncpy(strA, strB, strlen(strA)));  // "bbbbbb".
}

格式化字符串

#include <stdio.h>
#define LEN 128
int main(void) {
  char dest[LEN];
  const char strA[] = "Hello, ";
  sprintf(dest, "%sworld!", strA);
  printf("%s\n", dest);
}

sprintf 会将格式化后的字符串保存到第一个参数传入的数组中

字符的判断和转换

ctype.h 中包含众多用于字符的函数

#include <ctype.h>
#include <stdio.h>
int main(void) {
  char c = 'a';
  printf("%d\n", isalnum(c));  // 1.
  printf("%d\n", isalpha(c));  // 1.
  printf("%d\n", isblank(c));  // 0.
  printf("%d\n", isdigit(c));  // 0.
  printf("%c\n", toupper(c));  // 'A'.
}

数学运算库函数

math.h 和 stdlib.h 包含了众多数学运算函数

thmath.h 里面提供了泛型办的数学运算函数，大体思路是通过宏来判断参数类型进而转换到正确类型的底层函数去，详情参考实现

第十一讲 IO 标准库

C 语言采用标准库 stdio 的方式，提供对 I/O 相关接口的支持

基本使用

#include <stdio.h>
int main(void) {
  printf("Enter some characters:\n");
  FILE* fp = fopen("./temp.txt", "w+");
  if (fp) {
    char ch;
    while (scanf("%c", &ch)) {
      if (ch == 'z') break;
      putc(ch, fp);
    }
  } else {
    perror("File open failed.");
  }
  fclose(fp);
  return 0;
}

通过 printf 将指定文本传送到标准输出流 stdout
通过 fopen 打开指定的文件，并将其与一个特定的文件 IO 流关联
通过 perror 将指定错误信息传送到标准错误流 stderr
通过 scanf 从标准输入流 stdin 读取输入的信息
通过 putc 将字符写入指定文件

接口级别

IO 接口一般分为两个级别：

标准 IO：ISO C 标准定义的一些列接口，实现与具体操作系统无关
低级 IO：使用具体操作系统相关的一系列底层接口来提供相应的 IO 能力

上面的代码使用低级 IO 接口实现如下:

#include <unistd.h>
#include <fcntl.h>
int main(void) {
  const char str[] = "Enter some characters:\n";
  write(STDOUT_FILENO, str, sizeof(str));
  const int fd = open("./temp.txt", O_RDWR | O_CREAT);
  if (fd > 0) {
    char ch;
    while (read(STDIN_FILENO, &ch, 1)) {
      if (ch == 'z') break;
      write(fd, &ch, sizeof(ch));    
    }
  } else {
    const char errMsg[] = "File open failed.";
    write(STDERR_FILENO, errMsg, sizeof(errMsg));
  }
  close(fd);
  return 0;
}

和低级 IO 相比，标准 IO 会为我们提供带缓冲的输入和输出操作。

低级 IO 背后的系统调用

低级 IO 接口通过系统调用来完成相应的 IO 操作，与调用用户函数不同使用 call 指令不同，在 x86-64 平台，通过 syscall 指令来执行一个系统调用函数。

每个系统调用函数有一个唯一整形 ID, open 函数的 ID 为 2。 SyxV 调用约定使用寄存器 rdi、rsi、rdx、r10、r8、r9 来进行实参的传递，寄存器 rax 用于存放系统调用对应的 ID，并接收系统调用的结果。

上面的代码使用汇编改造如下：

#include <unistd.h>
#include <fcntl.h>
int main(void) {
  const char str[] = "Enter some characters:\n";
  write(STDOUT_FILENO, str, sizeof(str));
  const char* fileName = "./temp.txt";
  // Call to `open` starts:
  // const int fd = open("./temp.txt", O_RDWR | O_CREAT);
  volatile int fd;
  asm("mov $2, %%rax\n\t"
      "mov %0, %%rdi\n\t"
      "mov $66, %%rsi\n\t"  // 2 | 64 -> 66;
      "syscall\n\t"
      "mov %%rax, %1\n\t"
       : "=m" (fileName)
       : "m" (fd));
  // Call ended.
  if (fd > 0) {
    char ch;
    while (read(STDIN_FILENO, &ch, 1)) {
      if (ch == 'z') break;
      write(fd, &ch, sizeof(ch));
    }
  } else {
    const char errMsg[] = "File open failed.";
    write(STDERR_FILENO, errMsg, sizeof(errMsg));
  }
  close(fd);
  return 0;
}

上面的代码中，将 ID 2 存入寄存器 rax, 将 fileName 首地址存入寄存器 rdi，将文件操作模式 66 存入寄存器 rsi，调用结果从寄存器 rax 存入局部变量 fd。

第十二讲非本地跳转和可变参数实现原理

本地跳转

本地跳转一般指由 goto 语句完成的程序执行流的转移过程

setjmp 和 longjmp 函数

如上图所示，在调用 longjmp 之后，程序会调到 call setjmp 下一条指令，这种跳转为我们提供了一种可以暂存函数调用状态并在未来某个时刻再恢复的能力。

运作原理

setjmp 函数在执行时，会将程序此刻的调用环境信息存储在由其第一个参数指定的 jmp_buf 类型的对象中，并同时将 0 作为结果返回，后续当程序执行到 longjmp 时，该函数便回从同一个 jmp_buf 对象中再次恢复之前保存的函数调用上下文，通过这种方式，程序的执行流程得到了重置。

SysV 调用约定，属于 Callee-saved 类型的寄存器信息需要在 call 指令调用时，由被调用函数 caller 负责保存和恢复。

自定义实现

setjmp 汇编如下：

.global setjmp  # 将 setjmp 暴露给链接器
.intel_syntax noprefix  # 使用汇编语法
setjmp:
  mov  QWORD PTR [rdi], rbx
  mov  QWORD PTR [rdi+0x8], rbp
  mov  QWORD PTR [rdi+0x10], r12
  mov  QWORD PTR [rdi+0x18], r13
  mov  QWORD PTR [rdi+0x20], r14
  mov  QWORD PTR [rdi+0x28], r15
  lea  rdx, [rsp+0x8]
  mov  QWORD PTR [rdi+0x30], rdx
  mov  rdx, QWORD PTR [rsp]
  mov  QWORD PTR [rdi+0x38], rdx
  xor  eax, eax
  ret

由 SysV 规定，寄存器 rdi 接收第一个实参，所以 rdi 保存着 jmp_buf 的首地址， jmp_buf 可以看做是一个具有足够大小的字节数组。

在 4~9 行我们将寄存器 rdx、rbp、r12、r13、r14、r15 的值进行保存，在 10~11 行我们将 setjmp 调用之前的 rsp 寄存器进行了暂存，在 12~13 行我们将 setjmp 调用后的地址进行暂存，这个地址将由 longjmp 使用

longjmp 汇编如下：

.global longjmp
.intel_syntax noprefix
longjmp:
  xor  eax, eax
  cmp  esi, 0x1
  adc  eax, esi
  mov  rbx, QWORD PTR [rdi]
  mov  rbp, QWORD PTR [rdi+0x8]
  mov  r12, QWORD PTR [rdi+0x10]
  mov  r13, QWORD PTR [rdi+0x18]
  mov  r14, QWORD PTR [rdi+0x20]
  mov  r15, QWORD PTR [rdi+0x28]
  mov  rsp, QWORD PTR [rdi+0x30]
  jmp  QWORD PTR [rdi+0x38]

在 4~5 行我们将对 long_jmp 的第二个参数做处理，如果实参为 0，将其改为 1，这样做是为了能够通过寄存器 rax 中的值区分当前代码是在 setjmp 函数调用后首次执行的，还是 long_jmp 恢复后执行的

将汇编代码编译成对象文件

1
2

gcc -c setjmp.s -o setjmp.o
gcc -c longjmp.s -o longjmp.o

完整代码

#include <stdio.h>
#include <stdnoreturn.h>
// 定义 jmp_buf 类型；
typedef long jmp_buf[8];
// 提供函数原型；
int setjmp(jmp_buf);
noreturn void longjmp(jmp_buf, int);
// 原始 C 示例程序代码；
jmp_buf jb;
noreturn void inspect(char val) {
  putchar(val);
  longjmp(jb, val);
}
int main(void) {
  volatile char count = 'A';
  if (setjmp(jb) < 'J')
    inspect(count++);
  return 0;
}

编译、测试

`1`	`gcc main.c setjmp.o longjmp.o -o main && ./main`

通常非本地跳转主要用来实现异常处理、协程等功能

使用非本地调整实现的 try … catch 可以参考longjump_try_trow_catch

可变参数

基本使用

#include <stdio.h>
#include <stdarg.h>
void print_sum(int count, ...) {
  int sum = 0;
  va_list ap;
  va_start(ap, count); 
  for (int i = 0; i < count; ++i)
    sum += va_arg(ap, int);
  va_end(ap);
  printf("%d\n", sum);
}
int main(void) {
  print_sum(4, 1, 2, 3, 4);
  return 0;
}

运作原理

SysV ABI 规定了可变参数列表的实现要求

首先实参将会按类型按顺序依次存入寄存器，接着一块名为 Register Save Area 的栈内存被构建，每个通过寄存器传入的实参值都会按照 rdi、rsi、rdx、rcx、r8、r9、xmm0~15 的寄存器先后顺序拷贝到 RSA 中，接下来创建结构体 va_list

typedef struct {
  unsigned int gp_offset;  // 下一个整型数据相较于 RSA 的偏移；
  unsigned int fp_offset;  // 下一个浮点数据相较于 RSA 的偏移；
  void *overflow_arg_area;  // 指向使用栈进行传递的数据；
  void *reg_save_area;  //  指向 RSA 的指针；
} va_list[1];

va_start(ap, count) 语句对 ap 进行了初始化，reg_save_area 指向了 RSA 起始位置，gp_offset 设置为从 RSA 中读整数实参相对 reg_save_area 的偏移

va_arg(ap, int) 语句根据 va_list 及提取参数的类型从 RSA 中取出相应的数据值

va_end(ap) 释放了 ap

第十三讲 C 并发编程

C11 标准加入了 thread.h 和 stdatomic.h 标准库，提供了一套通用的并发编程接口

进程 vs 线程

默认情况，操作系统会为每一个运行的程序创建一个相应的进程，作为程序的运行实例。进程中包含一系列运行时信息，比如 VAS、PID、处理器上下文（如通用寄存器和指令寄存器的值），进程状态分配调度相关资源。这些信息被放在 进程控制块 PCB 数据结构中。

相比进程，线程提供了更细粒度的运行单元，线程在共享程序运行资源的情况下，负责程序某个子任务的具体执行过程。线程的状态信息被放在 线程控制块 TCB 数据结构中

线程的基本控制

#include <threads.h>
#include <stdio.h>
int run(void *arg) {
  thrd_t id = thrd_current();  // 返回该函数运行所在线程的标识符；
  printf((const char*) arg, id);
  return thrd_success;
}
int main(void) {
#ifndef __STDC_NO_THREADS__
  thrd_t thread;
  int result;
  // 创建一个线程；
  thrd_create(&thread, run, "Hello C11 thread with id: %lu.\n");
  if (thrd_join(thread, &result) == thrd_success) {
    // 等待其他线程退出；
    printf("Thread returns %d at the end.\n", result);  
  }  
#endif
  return 0;
}

其他线程控制函数如下表：

数据竞争

数据竞争 Data Race 是指在一个多线程的环境中，有两个及以上的线程同一时间对同一块内存的数据进行了非原子操作，示例如下

#include <threads.h>
#include <stdio.h>
#define THREAD_COUNT 20
#define THREAD_LOOP 100000000
long counter = 0;  // 全局变量，用来记录线程的累加值；
int run(void* data) {
  for (int i = 0; i < THREAD_LOOP; i++)
    counter++;  // 在线程中递增全局变量的值；
  printf("Thread %d terminates.\n", *((int*) data));
  return thrd_success;
}
int main(void) {
#ifndef __STDC_NO_THREADS__
  int ids[THREAD_COUNT];  // 用于存放线程序号的数组；
  thrd_t threads[THREAD_COUNT];  
  for (int i = 0; i < THREAD_COUNT; i++) {
    ids[i] = i + 1;
    thrd_create(&threads[i], run, ids + i);  // 创建 THREAD_COUNT 个线程；
  }
  for (int i = 0; i < THREAD_COUNT; i++)
    thrd_join(threads[i], NULL);  // 让当前线程等待其他线程执行完毕；
  printf("Counter value is: %ld.\n", counter);  // 输出 counter 变量最终结果；
#endif
  return 0; 
}

counter++ 语句可能会编译为如下几条机器指令

1
2
3

mov eax, DWORD PTR counter[rip]
add eax, 1
mov DWORD PTR counter[rip], eax

竞态条件

竞态条件 Race Condition 是指由于程序中某些事件的发生时机和顺序不一致，从而影响正确性的一种缺陷

#include <threads.h>
#include <stdio.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <time.h>
#define THREAD_COUNT 10
atomic_int accountA = 100000000;  // 转出账户初始金额；
atomic_int accountB = 0;  // 转入账户初始金额；
int run(void* v) {
  int _amount = *((int*) v);  // 获得当前线程的转移金额；
  for(;;) {
    // 首先判断转出账户金额是否足够，不够则直接退出；
    if (accountA < _amount) return thrd_error;  
    atomic_fetch_add(&accountB, _amount);  // 将金额累加到转入账户；
    atomic_fetch_sub(&accountA, _amount);  // 将金额从转出账户中扣除；
  }
}
int main(void) {
#if !defined(__STDC_NO_THREADS__) && !defined(__STDC_NO_ATOMICS__)
  thrd_t threads[THREAD_COUNT];  
  srand(time(NULL));
  for (int i = 0; i < THREAD_COUNT; i++) {
    int amount = rand() % 50;  // 为每一个线程生成一个随机转移金额；
    thrd_create(&threads[i], run, &amount);
  }
  for (int i = 0; i < THREAD_COUNT; i++)
    thrd_join(threads[i], NULL);
  printf("A: %d\nB: %d", accountA, accountB);
#endif
  return 0; 
}

由于加钱和减钱的操作是分开的，可能导致错误的结果

指令重排

现代编译器和处理器会采用指令重排来进一步提升程序的运行效率。这种技术会在不影响程序可观测执行结果的情况下，对生成的机器指令或实际执行顺序进行适当的重排。

对于编译器来说，其表象是源码中的语句出现顺序和汇编代码实现的顺序不一致。

对于处理器来说，则是程序在真正执行时产生副作用的顺序（如变量赋值），与汇编代码指令出现顺序不一致

#include <threads.h>
#include <stdio.h>
#include <stdatomic.h>
#if !defined(__STDC_NO_ATOMICS__)
atomic_int x = 0, y = 0;
#endif
int run(void* v) {
  x = 10;
  y = 20;  // ！变量 y 的值可能被优先更新！
}
int observe(void* v) {
  while(y != 20) ;  // 忙等待；
  printf("%d", x);  // 只在 x 被更新后打印；
}
int main(void) {
#if !defined(__STDC_NO_THREADS__)
  thrd_t threadA, threadB;  
  thrd_create(&threadA, run, NULL);
  thrd_create(&threadB, observe, NULL);
  thrd_join(threadA, NULL);
  thrd_join(threadB, NULL);
#endif
  return 0; 
}

第十四讲如何协调线程

互斥量

互斥量 mtx_t_init 初始化有三种模式

mtx_plain: 普通模式
mtx_recursive：可重入模式
mtx_timed：有超时限制，超过后互斥失效

另外两个互斥相关函数

mtx_trylock: 加锁或者直接返回
call_once：仅调用一次

原子操作

stdaotmic.h 文件中提供了一些原子操作

#include <threads.h>
#include <stdio.h>
#include <stdatomic.h>
#define THREAD_COUNT 10
#define THREAD_LOOP 100000000
#if !defined(__STDC_NO_ATOMICS__)
_Atomic long counter = 0;  // 定义一个原子类型全局变量，用来记录线程的累加值；
#endif
int run(void* data) {
  for (int i = 0; i < THREAD_LOOP; i++)
    atomic_fetch_add_explicit(&counter, 1, memory_order_relaxed);  // 使用原子加法操作；
  printf("Thread %d terminates.\n", *((int*) data));
  return thrd_success;
}
int main(void) {
#if !defined(__STDC_NO_THREADS__) || !defined(__STDC_NO_ATOMICS__)
  int ids[THREAD_COUNT];
  thrd_t threads[THREAD_COUNT];  
  for (int i = 0; i < THREAD_COUNT; i++) {
    ids[i] = i + 1;
    thrd_create(&threads[i], run, ids + i);
  }
  for (int i = 0; i < THREAD_COUNT; i++)
    thrd_join(threads[i], NULL);
  printf("Counter value is: %ld.\n", counter);
#endif
  return 0; 
}

通过 _Atomic 声明一个院子类型变量，使用 atomic_fetch_add_explicit 来进行原子变量的加法操作，内存顺序有三种：

更多原子操作相关函数如下：

条件变量

#include <threads.h>
#include <stdio.h>
mtx_t mutex;
cnd_t cond;  // 定义一个条件变量；
int done = 0;
int run(void* data) {
  mtx_lock(&mutex); 
  done = 1;
  cnd_signal(&cond);  // 通知等待中的线程；
  mtx_unlock(&mutex); 
  return thrd_success;
}
int main(void) {
#ifndef __STDC_NO_THREADS__
  mtx_init(&mutex, mtx_plain); 
  cnd_init(&cond);  // 初始化条件变量；
  thrd_t thread;  
  thrd_create(&thread, run, NULL);
  mtx_lock(&mutex); 
  while (done == 0) {
    cnd_wait(&cond, &mutex);  // 让当前线程进入等待队列；
  }
  mtx_unlock(&mutex); 
  printf("The value of done is: %d", done);
  mtx_destroy(&mutex);
  cnd_destroy(&cond);  // 销毁条件变量；
#endif
  return 0; 
}

条件变量提供了线程间通知能力，某个线程可以在完成了某件事后，通知并唤醒等待线程。

本地变量

#include <stdio.h>
#include <threads.h>
#include <stdatomic.h>
#define THREAD_COUNT 10
#define THREAD_LOOP 10000
_Thread_local int counter = 0;  // 定义线程本地变量；
int run(void *data) {
  for (int i = 0; i < THREAD_LOOP; ++i)
    counter += 1;  // 更新当前线程所属的 counter 变量值；
  return counter;
}
int main(int argc, char const *argv[]) {
  thrd_t threads[THREAD_COUNT];
  int sum = 0, result = 0;
  for (int i = 0; i < THREAD_COUNT; ++i)
    thrd_create(&threads[i], run, NULL);
  for (int i = 0; i < THREAD_COUNT; ++i) {
    thrd_join(threads[i], &result);
    sum += result;  // 累加每个线程的计算值；
  }
  printf("The value of count is %d.\n", sum);
  return 0;
}

线程本地变量的值仅能够在某个线程的生存期内可用，变量的实际存储空间会在线程开始时分配，线程结束时回收。

第十五讲信号

什么是信号

信号实际上是一种可以用来传递特定消息的机制，操作系统将程序运行过程中发生的各类特殊情况转发给程序，并按照其指定的逻辑进行处理。

信号的产生是一个随机的过程，所以程序需要提前”告诉“操作系统，信号到来时，应该如何处理。这就是一种典型的异步事件处理方式。

信号与软中断

信号是一种软中断，当特定事件发生时，操作系统会将对应的信号值发送给相关程序，通常情况下，如果对应程序并未设置自定义的信号处理程序，则操作系统会执行默认信号处理程序。整个程序处理过程中，存在着 CPU 从用户态到信号处理程序的执行流程转移。

C 代码样例

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
void sigHandler(int sig) {
  printf("Signal %d catched!\n", sig);
  exit(sig);
}
int main(void) {
  signal(SIGFPE, sigHandler);
  int x = 10;
  int y = 0;
  printf("%d", x / y);
}

C 标准库提供了 6 种不同类型的信号

信号处理函数的原型为 void (*handler) (int)，即接受一个整形的信号值，不返回任何内容。

除零异常的信号交互逻辑如下：

CPU 执行触发指令 idiv
发现除零异常，CPU 暂停当前程序运行，并将控制权转交给操作系统
操作系统将信号 SIGFPE 发送给出错的程序
操作系统根据情况执行相应的信号处理程序
信号处理程序执行完毕后，如果程序未退出，则将程序执行恢复到之前的中断点，即 CPU 会重新执行 idiv 指令

可重入函数

当程序在执行函数 A 时收到了某个信号，信号处理函数中也对函数 A 发起了调用，这样可能会影响之前还未完成调用的函数 A 执行状态。

#include <stdio.h>
#include <signal.h>
#include <string.h>
#define BUF_SIZE 16  // 全局静态数组大小；
#define FORMAT_NUM_(N) " $"#N
#define FORMAT_NUM(N) FORMAT_NUM_(N)
#define RAISE_EXP_false_ASM()
// 调用 raise 函数向当前程序发送信号；
#define RAISE_EXP_true_ASM() \
  "movl    $4, %%edi\n\t" \
  "call    raise\n\t"
// 内联汇编实现；
#define INLINE_ASM(ID, HAS_EXP) \
  "mov     %0, %%r8\n\t" /* 复制传入的字符串数据到全局静态数组 */ \
  "testq   %%rsi, %%rsi\n\t" \
  "je      .L1" #ID "\n\t" \
  "xorl    %%eax, %%eax\n\t" \
  ".L3" #ID ":\n\t" \
  "movzbl  (%%rdi,%%rax), %%ecx\n\t" \
  "movb    %%cl, (%%r8,%%rax)\n\t" \
  "addq    $1, %%rax\n\t" \
  "cmpq    %%rsi, %%rax\n\t" \
  "jne     .L3" #ID "\n\t" \
  ".L1" #ID ":\n\t" \
  RAISE_EXP_##HAS_EXP##_ASM() /* 选择性调用 raise 函数 */ \
  "mov     $1, %%rax\n\t" \
  "mov     $1, %%rdi\n\t" \
  "mov     %0, %%rsi\n\t" \
  "mov" FORMAT_NUM(BUF_SIZE) ", %%rdx\n\t" \
  "syscall\n\t"  /* 触发系统调用，打印内容 */
  
static char buf[BUF_SIZE];  // 用于保存字符的全局静态数组；
void print_with_exp(const char* str, size_t len) {  // 会引起信号中断的版本；
  asm(INLINE_ASM(a, true) :: "g" (buf));
}
void print_normal(const char* str, size_t len) {  // 正常的版本；
  asm(INLINE_ASM(b, false) :: "g" (buf));
}
void sigHandler(int sig) {
  const char* str = "Hello";
  print_normal(str, strlen(str));
}
int main(void) {
  signal(SIGILL, sigHandler);
  const char* str = ", world!";
  print_with_exp(str, strlen(str));
  return 0;
}

不受中断和重新调用影响的函数称之为可重入函数

多线程信号处理

C 语言没有对并发编程的信号处理做规范，所以多线程应用中使用 signal 和 raise 函数会产生未定义的行为

第十六讲日期、时间与实用函数

日期与时间

日历时间

使用 time_t 类型表示，其代表从 1970-01-01: 00:00:00 到当前时间秒数

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t currTime = time(NULL);
    if (currTime != (time_t) (-1)) {
        printf("the current timestamp is: %ld(s)\n", currTime);
        printf("local time is: %s\n", asctime(localtime(&currTime)));
        printf("UTC time is: %s\n", asctime(gmtime(&currTime)));
    }
    return 0;
}

处理器时间

处理器时间即 CPU 资源被调度以支持程序在某段时间内正常运作所花费的时间。

#include <time.h>
#include <stdio.h>
int main(void) {
  clock_t startTime = clock();    
  for(int i = 0; i < 10000000; i++) {}
  clock_t endTime = clock();
  printf("Consumed CPU time is：%fs\n", 
   (double)(endTime - startTime) / CLOCKS_PER_SEC); 
  return 0;
}

字符串到数值的转换

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main(void) {
  // 一次性字符串到数值转换；
  const char* strA = "1.0";
  printf("%f\n", atof(strA));
  // 带溢出检查的转换函数，执行后会保存不能被转换部分的地址；
  const char* strB = "200000000000000000000000000000.0";
  char* end;
  double num = strtol(strB, &end, 10);
  if (errno == ERANGE) {  // 判断转换结果是否发生溢出；
    printf("Range error, got: ");
    errno = 0;
  }
  printf("%f\n", num);
  return 0;
}

生成随机数

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
int main (void) {
  srand(time(NULL));  // 初始化随机数种子；
  while (getchar() == '\n') 
    printf("%d", rand() % 10);  // 生成并打印 0-9 的随机数；
  return 0; 
}

动态内存管理

除了 malloc 和 free 函数之外，C 标准库也提供了另外的一些函数

进程控制

#include <stdio.h>
#include <stdlib.h>
void exitHandler() {
  printf("%s\n", getenv("PATH"));
}
int main(void) {
  if (!atexit(exitHandler)) {
    exit(EXIT_SUCCESS);
  }
  return 0;
}

第十七讲断言、错误处理和对齐

断言

断言分为静态断言和动态断言

一般我们在程序运行前使用静态断言，来检查它所需要满足的一系列要求

#include <assert.h>
double sqrt(double x) {
  // 检查函数使用时传入的参数；
  assert(x > 0.0);
  // ...
}
int main(void) {
  // 检查程序的编译要求；
  static_assert(sizeof(int) >= 4, 
    "Integer should have at least 4 bytes length.");
  // ...
  return 0;
}

定义 NDEBUG 宏可关闭断言功能

错误处理

在 C 语言中，名为 errno 的预处理宏会被展开为一个 init 类型的可修改全局左值

#include <tgmath.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
int main(void) {
  sqrt(-1);
  fprintf(stderr, "%s\n", strerror(errno));  // "Numerical argument out of domain".
  return 0;
}

可以通过 strerror 函数获取当前 errno 对应的可读文本

对齐

可以使用 _Alignas 来根据自身需要为数据指定特殊的对齐要求，stdalign.h 有对应的宏 alignas

#include <stdio.h>
#include <stdalign.h>
int main(void) {
#if __alignas_is_defined == 1 && __alignof_is_defined == 1
  alignas(1024) int n = 1;
  printf("The alignment of n is %zu\n", alignof(n));  // "The alignment of n is 1024".
  printf("The address of n is: %p\n", &n);  // "The address of n is: 0x7ffe80658c00".
#endif
  return 0; 
}

第十八讲极致优化（上）

高速缓存

CPU 芯片上有 L1、L2、L3 三个不同级别的高速缓存

高速缓存之所以能提升性能，一个重要的前提在于局部性原理

时间局部性：被引用过一次的内存位置接下来可能会被再次引用
空间局部性：如果一个内存位置被引用了，那附近的内存也可能会被引用

内联

通过内联关键字 inline ，可以建议编译器，将某个方法的实现内联到它的实际调用处。

#include <stdio.h>
static inline int foo() {
  return 10;
}
int main(void) {
  int v = foo();
  printf("Output is: %d\n", v);
  return 0;
}

上述代码对应的汇编代码如下

.LC0:
        .string "Output is: %d\n"
main:
        sub     rsp, 8
        mov     esi, 10
        mov     edi, OFFSET FLAT:.LC0
        xor     eax, eax
        call    printf
        xor     eax, eax
        add     rsp, 8
        ret

通过内联，程序不再需要使用 call 指令来调用 foo 函数，好处在于节省 call 指令执行时需要进行的函数帧栈创建和销毁过程。坏处是导致可执行二进制文件增大

restrict关键字

restrict 关键字用于指针，表明该指针是访问对应数据的唯一方式

#include <stdio.h>
void foo(int* x, int* y, int* restrict z) {
  *x += *z;
  *y += *z;
}
int main(void) {
  int x = 10, y = 20, z = 30;
  foo(&x, &y, &z);
  printf("%d %d %d", x, y, z);
  return 0;
}

对应的汇编代码如下：

foo:
        mov     eax, DWORD PTR [rdx]
        add     DWORD PTR [rdi], eax
        add     DWORD PTR [rsi], eax
        ret

使用restrict 关键字后，在为指针 y 进行值累加前，编译器不会再重复性地从内存中读取指针 z 对应的值

消除不需要的内存引用

原代码

#define LEN 1024
int data[LEN] = { ... };
int foo(int* dest) {
  *dest = 1;
  for (int i = 0; i < LEN; i++) {
    *dest = *dest * data[i];
  }
}

优化代码

#define LEN 3
int data[LEN] = { 1,2,4 };
int foo(int* dest) {
  register int acc = 1;
  for (int i = 0; i < LEN; i++) {
    acc = acc * data[i];
  }
  *dest = acc;
}

优化代码主要做了两件事情：

将用于存放临时积累值的 *dest 替换为局部变量
为局部变量添加 register 关键字，建议编译器将该值存放在寄存器中

第十九讲极致优化（下）

循环展开（Loop Unrolling）

现在 CPU 为了进一步提升指令的执行效率，通常会将单一的机器指令再进行拆分，以达到并行的目的。对于一个基本的五级 RISC 流水线来说， CPU 会将指令的执行细分为指令提取（IF）、指令译码（ID）、指令执行（EX）、内存访问（MEM）和寄存器写回（WB）。

在第一条机器指令经过了指令提取后，即使该指令没有完全执行完毕，CPU 也可以立即开始处理下一条机器指令。因此从宏观上来看，机器指令的执行由串行变成了并行。当五个节点全部执行完毕后，CPU 会更新指令指针（PC）

示例代码如下:

# 原代码
#define LEN 4096
int data[LEN] = { ... };
int foo(void) {
  int acc = 1;
  for (int i = 0; i < LEN; ++i) {
    acc = acc * data[i];
  }
  return acc;
}


# 展开后的代码
#define LEN 4096
int data[LEN] = { ... };
int foo(void) {
  int limit = LEN - 1;
  int i;
  int acc0 = 1;
  int acc1 = 1;
  for (i = 0; i < limit; i += 2) {  // 2x2 loop unrolling.
    acc0 = acc0 * data[i];
    acc1 = acc1 * data[i + 1];
  }
  for (; i < LEN; ++i) {  // Finish any remaining elements.
    acc0 = acc0 * data[i];
  }
  return acc0 * acc1;
}

我们将循环结果应用了 2 * 2 （步长为2，2个独立累积值变量）循环展开。

不过这样导致代码量增加和可读性下降，大部分情况下我们不需要手动改变代码来做循环展开。

优先使用条件传送指令

CPU 中存在着条件传送指令、条件分支指令等，CPU 执行条件分支指令会对分支进行预测，并提现执行分支指令，如果预测的跳转位置发生错误，就会将状态重置为发生跳转前分支所处的状态，并取出正确方向上的指令，开始重新处理。条件传送指令没有分支预测，所以没有这部分损失。

示例代码如下

#define LEN 1024
void foo(int* x, int* y) {
  int i;
  for (i = 0; i < LEN; i++) {
    if (x[i] > y[i]) {
      int t = x[i];
      x[i] = y[i];
      y[i] = t;
    }
  }
}


#include <stdio.h>
#define LEN 16
void foo(int* x, int* y) {
  int i;
  for (i = 0; i < LEN; i++) {
    int min = x[i] < y[i] ? x[i] : y[i];
    int max = x[i] < y[i] ? y[i] : x[i];
    x[i] = min;
    y[i] = max;
  }
}

上面示例通过增加几次比较和复制操作，来避免分支预测失败代码的惩罚。

使用更高的编译优化等级

gcc 可以指定更高的优化等级来优化

尾递归优化

尾递归优化通过将函数的递归调用优化为循环结构，减少了 call 指令的调用次数，进而减少了帧栈的创建和销毁过程，提升了程序的执行性能。

第二十讲编码规范

我们以 GNU 编码规范为基准

格式

每行字符数量保持在79个以内
函数定义是开始花括号“{”位于行首
函数命中位于行首
参数过多时，将超过限制的参数放到函数名下一行，并与第一个参数开头对齐

int
lots_of_args (int an_integer, long a_long, short a_short,
              double a_double, float a_float)
{
  // ...
}
struct foo 
{
  int a, b;
}
struct bar { int x, y; }

更多规范参考 GNU 旗下的格式化工具 indent

注释

文件层面，main 函数所在文件应以描述程序的基本用途的注释作为开头，而其他源文件应以文件名和描述该源文件基本功能的注释作为开头

函数层面，需要添加用于描述函数基本功能、参数类型、参数用途、参数可能取值和返回值含义等内容注释信息

语法约定

显示地为所有使用到的值标注类型，尤其是直接使用在表达式中的数字字面量值
外部函数和后续才会使函数的声明，应该被放置在当前源文件处开头统一的地方，或放到单独的文件中
将同类型的多个变量放在同一行声明
使用嵌套的流程控制语句（如 if 语句）时，总是将内部嵌套的逻辑包裹在大括号中。
尽量避免在 if 语句条件判断处做赋值操作（while 可以这样做）

命名

变量名一般采用下划线命名法

尽量使用小写字母、下划线和数字来组成变量名，把大写字母留给宏常量和枚举常量。

国际化

可以使用 GNU gettext 库，将消息翻译成各种语言

第二十一讲自动化测试

单元测试

单元测试就是对组成程序的基本单元（也可称为模块）进行功能正确性验证，它的目标是隔离程序的每个部分，并单独验证这些部分能够按照预期正常工作。

对于 C 程序来说，这里的单元通常为函数

通常使用 Cunit 进行单元测试

// ...
int maxi(int x, int y) {  // 被测试函数；
  return (x > y) ? x : y;
}
void test_maxi(void) {  // 测试用例；
  CU_ASSERT(maxi(0, 2) == 2);
  CU_ASSERT(maxi(0, -2) == 0);
  CU_ASSERT(maxi(2, 2) == 2);
}
// ...

集成测试

检测不同单元或模块整合在一起时，他们是否也可以很好地协同工作，这类测试称之为集成测试 Integration Testing，这类测试通常需要使用数据库，网络连接等真实的外部资源。

功能测试

功能测试 Functional Testing 的目的和集成测试十分类似，但功能测试对测试结果的正确性要求可能会更加严格，需要满足业务需求中的相应规定。

性能测试

通常可以使用运行时间和内存使用率这两个指标来作为程序运行性能的度量单位

可以使用 perf 命令行工具来进行性能测试

第二十二讲结构化编译

如何组织代码结构

对于小型项目，可以简单地将 .h 文件和 .c文件分别放在 include 目录和 src 目录，当项目变大时，可以将源文件按功能进行更细分的划分。

两种参考目录结构如下图

如何组织编译流程

一个简单的 C 项目如下图

可以用如下命令进行编译, 使用-I选项指定查找头文件需要搜索的目录，使用-l指定链接运行时依赖的库

`1`	`gcc src/main.c src/mod.c -I./include -lm -o bin/main`

使用 Makefile 进行结构化编译

# 用于控制编译细节的自定义宏；
CC = gcc
CFLAGS = -I./include
LDFLAGS = -lm
TARGET_FILE = bin/main

# 描述各个目标的详细编译步骤；
$(TARGET_FILE): $(patsubst src/%.c,src/%.o,$(wildcard src/*.c))
  $(CC) $^ $(LDFLAGS) -o $@

src/%.o: src/%.c include/%.h
  $(CC) $< $(CFLAGS) -c -o $@

使用 CMake 进行跨平台自动化构建

CMake（Cross-platform Make）会根据所在的平台，生成相应的“平台本地构建项目”，比如在 Unix 系统上，会生成相应的 Makefie 文件，在 Windows 会生成对应的 Visula Studio 工程文件。

CMake 的配置信息存在 CMakeLists.txt 文件中。

cmake_minimum_required(VERSION 3.10)
# 设置项目名称；
project(Test)
# 设置二进制目标文件名称；
set(TARGET_FILE "main")
# 添加源文件目录；
aux_source_directory(./src DIR_SRCS)
# 设置二进制目标文件的依赖；
add_executable(${TARGET_FILE} ${DIR_SRCS})
# 设置头文件查找目录；
target_include_directories(${TARGET_FILE} PUBLIC "${PROJECT_SOURCE_DIR}/include")
# 设置需要链接的库；
target_link_libraries(${TARGET_FILE} PUBLIC m)

第二十三讲高性能 HTTP Server 实战（上）

我们将会创建一个叫 FivSev 的服务，接收路径 “/?num={pos}”的 GET 请求，返回斐波那契数列对应位置的数值。

大体流程如下图

部分优化措施

使用线程池利用多核CPU
使用尾递归调用优化
使用条件变量避免忙等待

第二十四讲高性能 HTTP Server 实战（下）

项目基本结构

项目仓库地址: https://github.com/Becavalier/tiny-http-echo-server/tree/geektime

处理用户参数

// libs/structs.h#L9-L11
typedef struct {
  int threadCount;
} serverSettings;

// libs/helpers.h#L67-L86
void setupServerSettings(int argc, const char** argv, serverSettings* ss) {
  while (argc-- > 1) {
    // process key.
    const char* keyHead = argv[argc];
    const char* keyPos = strchr(keyHead, '=');
    const size_t keyLen = keyPos - keyHead + 1;
    char key[keyLen];
    wrapStrFromPTR(key, keyLen, keyHead, keyPos);
    // process value.
    const char* valHead = keyHead + keyLen;
    const char* valPos = strchr(valHead, '\0');
    const size_t valLen = valPos - valHead + 1;
    char val[valLen];
    for (size_t i = 0; valHead <= valPos; valHead++)
      val[i++] = *valHead;
    if (strcmp(key, "thread_count") == 0) {
      ss->threadCount = atoi(val);
    }
  }
}

TCP Server

监听请求

// src/main.c#L70-95
int serverFd; 
sockaddr_in address;
int addrLen = sizeof(address);

// establish a socket.
if ((serverFd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { ... }

bzero(&address, addrLen); 
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;  // -> 0.0.0.0.
address.sin_port = htons(PORT);
  
// assigns specified address to the socket.
if (bind(serverFd, (sockaddr*) &address, sizeof(address)) < 0) { ... }

// mark the socket as a passive socket.
if (listen(serverFd, MAX_LISTEN_CONN) < 0) { ... }

解析请求

// libs/helpers.c#L37-L65
int retrieveGETQueryIntValByKey(char* req, const char* key) {
  int result = 0;

  // extract uri;
  const char* uriHead = strchr(req, ' ') + 1;
  const char* uriTail = strchr(uriHead, ' ');
  size_t uriLen = uriTail - uriHead + 1;
  char strUri[uriLen];
  wrapStrFromPTR(strUri, uriLen, uriHead, uriTail);

  // parse uri;
  UriUriA uri;
  UriQueryListA* queryList;
  int itemCount;
  const char* errorPos;
  if (uriParseSingleUriA(&uri, strUri, &errorPos) == URI_SUCCESS) {
    if (uriDissectQueryMallocA(&queryList, &itemCount, uri.query.first, uri.query.afterLast) == URI_SUCCESS) {
      while (itemCount--) {
        if (strcmp(queryList->key, key) == 0) {
          result = atoi(queryList->value);
          break;
        }
        queryList = queryList->next;
      }
      uriFreeQueryListA(queryList);
    }
  }
  return result;
}

计算斐波那契数列

有递归和尾递归优化版本

// libs/helpers.c#L8-L20
int __calcFibTCO(int n, int x, int y) {
  if (n == 0)
    return x;
  if (n == 1)
    return y;
  return __calcFibTCO(n - 1, y, x + y);
}

int __calcFibRecursion(int n) {
  if (n <= 1)
    return n;
  return __calcFibRecursion(n - 1) + __calcFibRecursion(n - 2);
}

int calcFibonacci(int n) {
  // return __calcFibTCO(n, 0, 1);  // TCO version. 
  return __calcFibRecursion(n);  // recursion version.
}

第二十五讲可执行二进制文件

ELF 文件格式

Unix 最常使用的是ELF（executabke and linkable format）文件格式

通常可执行文件的组织方式分为3部分：header、section、segment

// elf.c
#include <stdio.h>
int main (void) {
  const char* str = "Hello, world!";
  printf("%s", str);
  return 0;
}

通过 file 命令查看文件格式信息

ELF 头

通过readelf -h可以查看文件头部内容

Section 头

Section 用于存放可执行文件中按照功能分类好的数据，各个 Section 相关信息存放在对应的 Section 头部中，众多连续的 Section 头便组成了 Section 头表

通过 ELF 头信息可以得到总共有 30 个 Section 头，第一个头位于文件开始偏移的 15512 字节

通过readelf -S 查看 Section 头部信息

.text 主要存放程序对应的机器代码，.rodata 存放只读常量，.data 存放已经初始化的全局变量或者静态变量，.bss 中coffee初始值为 0 的全局或者静态变量。

使用 objdump -s 查看某个 Section 的完整内容

Program 头

除了由 Section 组成的静态视图外，众多的 Segment 组成了可执行文件的动态图。

Segment 指定了应用程序在实际运行时，应该如何在进程的 VAS 内部组织数据。

使用readelf -l 查看 Segment 情况

Segment 对应的头部称之为 Program 头

其中 “LOAD” 类型的 Segment 会在运行时载入到进程的 VAS 中，而其余的 Segment 主要用于辅助程序的正常运行（如动态链接）。

通常 Segment 和 Section 之间有一定的对应关系，上图中第一个 LOAD 类型的 Segment 便包含 .text 和 .rodata 等 Section，第二个 LOAD Segment 包含 .data Section。这样印证了两个 LOAD 对应的 FLags 分别为 RE 和 RW。

另外第一个 LOAD 的 Offset 为 0 ，这意味着执行时会除了将对应的 Sections 加载到内存外，文件 ELF 头也会加载到内存中。

ELF 编程

可以使用 elf.h 库对 ELF 格式的应用编程

#include <stdio.h>
#include <elf.h>

void print_elf_type(uint16_t type_enum) {
  switch (type_enum) {
    case ET_REL: printf("A relocatable file."); break;
    case ET_DYN: printf("A shared object file."); break;
    case ET_NONE: printf("An unknown type."); break;
    case ET_EXEC: printf("An executable file."); break;
    case ET_CORE: printf("A core file."); break;
  }
}

int main (void) {
  Elf64_Ehdr elf_header;
  FILE* fp = fopen("./elf", "r");
  fread(&elf_header, sizeof(Elf64_Ehdr), 1, fp);
  print_elf_type(elf_header.e_type);  // "An executable file."
  fclose(fp);
  return 0;
}

ELF 文件类型

第二十六讲进程如何使用操作系统内存

计算机内部缓存系统

缓存由 L1、L2 等高速缓存和内存组成

虚拟内存机制

虚拟内存 Virtual Memory 是操作系统在物理内存的基础上进行了一层抽象，以帮助运行于其上的应用程序合理分配内存

CPU 会借助内存管理单元 MMU 将虚拟地址翻译成物理地址，然后再进行实际数据的获取。

每一个应用进程都有独立的虚拟地址空间 VAS，从进程的角度看，它可以独享整个计算机上的内存。在64 位 Linux 系统中，与应用代码相关的 Segment 会从 VAS 的固定地址 0x400000 处开始加载，而Section 内容将在满足一定对齐要求的条件下按顺序加载到高地址方向的虚拟内存中。

0x0 到 0x400000 (4K) 的虚拟地址不会使用，这样空指针可以触发异常

可以通过cat /proc/<pid>/maps 查看某个运行中的进程的 VAS 布局情况。

VAS 数据布局

VAS 数据按地址有低到高，可以分为如下几个部分：

LOAD Segments: 包括与代码相关的 Text Segment（.text, .rodata）位于最低地址处，紧接着为包含已初始化和未初始化数据的Data Segment（.data, .bss）
堆: 堆内存，向高地址方向增长
共享库数据：包含各类 .so 共享库相关的数据，程序会在运行时通过动态连接器来完成对它们的加载和处理
栈：栈内存，向低地址方向增长
用于系统调用加速的内核数据：该部分数据主要提供了用户进程可以直接和内核交互的接口，其中 [vvar] 包含只读的内核数据，另外 [vdso] 和 [vsyscall] 则包含用于辅助操作系统加速用户进程执行某些系统调用过程的信息。
其他内核数据

页表

每个进程有一个独立的页表结构来维护 VAS 中的虚拟页在对应物理内存中的映射状态。

页表本身维护在物理内存中，其内部由多个 PTE （Page Table Entry）组成，每个虚拟页对应一个 PTE 。

CPU、MMU、页表、物理内存和磁盘五者之间的协作关系如下图：

多级页表

多级页表节省空间的最重要的两个因素是：

当一级页表某个PTE 没有实际映射时，其对应的二级页表便不会被创建
只有一级页表才需要常驻内存，二级页表仅在需要时创建或者从磁盘调入

TLB

TLB (Translation Lookaside Buffer) 是 MMU 的一部分，用来加快虚拟地址查 PTE 的过程。可以简单将 TLB 理解为一个具有 N 行 M 列的矩阵，MMU 会从虚拟地址中提取用于查询表项的索引和标记，这两个值可以定位到具体单元格，如果单元格有值，则可以与虚拟地址中的其他信息一起组成最终的物理地址；否则仍需要通过主机查询页表的方式获取物理地址。

第二十七讲静态链接

示例代码如下

// main.c
#define LEN 2
extern int sharedArr[LEN];
extern int sum(int *arr, int n);
int* array = sharedArr;
int main(void) {
  int val = sum(array, LEN);
  return val;
}

// sum.c
#define LEN 2
int sharedArr[LEN] = { 1, 2 };
int sum(int *arr, int n) {
  int i, s = 0;
  for (i = 0; i < n; i++) {
    s += arr[i];
  }
  return s;
}

使用 gcc 将代码分别编译成二进制可执行文件 main 和目标文件 main.o、sum.o

1
2
3

gcc main.c sum.c -o main  # 生成可执行文件 main；
gcc -c main.c -o main.o  # 生成目标文件 main.o；
gcc -c sum.c -o sum.o  # 生成目标文件 sum.o；

目标文件

目标文件是一种被称为”可重定位文件“的 ELF 文件类型。但它不包含与动视图相关的的多种 Segment 和 Program 头部，因此不同类型的 Section 便成了用于描述它所有特征的基本结构。

可以使用nm 命令查看目标文件中的符号表，符号表包含了所有全局变量和函数信息

nm 会返回三列数据

第一列代表符号在对应 Section 中的偏移量
第二列代表符号的类型，D 代表已初始化的全局数据，位于 .data Section; T 代表函数，位于 .text Section; U 代表符号未定义
第三列代表名称

符号解析

编译器编译源码时，会为无法在当前编译单元内找到定义的符号生成一个特定符号表条目。链接器在随后进行符号解析时会在全局符号表中进行搜索。

如果链接器找到了多个同名定义，会按照一定规则进行解析。符号有强弱之分，通常函数和已初始化的全局变量为强符号，而未初始化的全局变量为弱符号。

如果有一个强符号和多个弱符号，选强符号
如果有多个弱符号，任意选一个（通常选择占用空间最大的）
如果有多个强符号，则报错

通过为函数显示添加 attribute((weak)) 标记可以设置其为弱符号。

重定位

符号解析之后，链接器开始将多个目标文件相同类型的Section 进行合并，同时为这些 Section 及符号指定运行时 VAS 地址。

链接器通过重定位步骤来修改 .data 和 .text 两个 Section 中对每个符号的引用信息，使得它们可以指向正确的运行时地址。

重定位依赖特殊的 Section: .rela.data 和 rela.text, 通常这两个 Section 也称之为重定位表。

上图中每列数据含义：

Offest: 指目标在 Section 中的偏移
Info:
Type: 指重定位类型
Sym. Value: 当前值
Sym. Name + Addend: 符号名称和修正量

重定位类型如上图，计算方式中 S 表示实际地址，A 表示 Addend，P 表示被修改的具体位置，L 表示在 PLT 中该符号的入口地址。

通过 objdump 可以找到重定向目标的位置

以 R_x86_64_pc32 类型 arrary 举例计算，验证 “S+A-P” 的计算方式

S 实际地址可以通过nm 查看, 结果为 0x601020

A 修正量为 -4

P 修改位置可以通过objdump -M inter -d main查看，40053e未改行机器指令起始位置，在此基础上加 3个字节（操作指令+寄存器占用？）即可得到重定向的修改位置： 4000541

0x601020 - 0x4 - 0x400541 结果为 0x200adb,对应大端地址即为 db 01 20 00

第二十八讲动态链接

共享库

能够被动态链接加载的库称之为共享库 Shared Library，在 Linux 中这类库文件以 ”.so“ 后缀结尾

使用示例

已上一讲中 sum.c 和 main.c 两个文件为例，将 sum.c 编译成动态库，并让 main.c 对应的应用程序使用。

使用命令gcc sum.c -shared -fPIC -o libsum.o 编译动态库文件
使用命令gcc -o main main.c -lsum -L.编译应用程序
使用命令export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH 来设置动态链接器查找动态库文件的目录
执行./main

位置无关代码

位置无关代码（Position Independent Code, PIC）是一类特殊的机器代码，这些代码在使用时，可以被放置在每个进程 VAS 中任意位置，而无需链接器对它内部引用的地址进行重定位。

通常可以将模块之间的数据引用分为四种方式:

模块内部函数调用
模块内部数据访问
模块之间函数调用
模块之间数据访问

模块内部函数调用一般以 PC 寄存器寻址方式进行，不依赖 VAS 内的绝对地址。

模块内部数据访问时由于.data 和 .text 是相对固定的，数据访问也可以使用相对稳定的地址进行。

全局偏移表

全局偏移表（Global Offset Table， GOT）是位于每个模块 Data Segment起始位置处的一个特殊结构，其内部的每个表项都存放一个地址信息，这些地址对应这被当前模块引用的外部函数或者变量在 VAS 中的实际地址。

当程序被加载进内存时，动态连接器根据实际情况，通过修正 GOT 中的值，来修正代码对应符号的实际引用地址

过程链接表

过程链接表（Procedure Linkage Table, PLT）是位于 Text Segment 中的一个表结构。其中第一表项 PT[0] 内部存放的代码专门用于调用动态连链接器，而其他表项则依次存放着用于完成用户函数调用过程相关的代码，这些表项的地址将被 call 指令直接使用。

加载时链接

动态连接器进行的符号重定位发生在程序代码被真正执行之前

运行时链接

程序可以自动选择想要加载的共享库模块，并在不使用时卸载。动态链接主要使用 dlopen、dlsym、、dlerror、dlclose 四个接口实现

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
typedef double (*cos_t)(double);
int main(void) {
  cos_t cosine;
  char *error;
  void* handle = dlopen("libm.so.6", RTLD_LAZY);
  if (!handle) {
    fprintf(stderr, "%s\n", dlerror());
    exit(EXIT_FAILURE);
  }
  dlerror();
  cosine = (cos_t) dlsym(handle, "cos");
  error = dlerror();
  if (error != NULL) {
    fprintf(stderr, "%s\n", error);
    exit(EXIT_FAILURE);
  }
  printf("%f\n", (*cosine)(2.0));
  dlclose(handle);
  return 0;
}

第二十九讲 C 程序入口

真正的入口函数

// main.c
int main(void) {
  return 0;
}

可以从图中看到，程序首先从 _start 开始执行

_start

_start 是链接器在生成目标可执行文件时，默认使用的一个符号名称。链接器在链接时会在全局符号表中找到该符号，并将虚拟地址拷贝到 ELF 头的 e_entry 字段中。

可以通过命令ld --verbose查看

_start 符号具体定义来自 crt1.o 文件

编译时带”-v“ 参数可是看到相关信息

_start 作用

crt1.o 是 C 运行时库（C Runtime Library CRT）提供的一个用于辅助应用程序正常运行的特殊文件，汇编代码见文件

#include <sysdep.h>

ENTRY (_start)
  cfi_undefined (rip)
  xorl %ebp, %ebp  /* 复位 ebp */
  mov %RDX_LP, %R9_LP   /* 保存 FINI 函数的地址到 r9 */
#ifdef __ILP32__
  /* 模拟 ILP32 模型下的栈操作，将位于栈顶的 argc 放入 rsi */
  mov (%rsp), %esi  
  add $4, %esp  /* 同时让栈顶向高地址移动 4 字节 */
#else
  popq %rsi  /* 将位于栈顶的 argc 放入 rsi */
#endif
  mov %RSP_LP, %RDX_LP  /* 将 argv 放入 rdx */
  and $~15, %RSP_LP  /* 对齐栈到 16 字节 */
  pushq %rax  /* 将 rax 的值存入栈中，以用于在函数调用前保持对齐状态 */
  pushq %rsp  /* 将当前栈顶地址存入栈中 */

  xorl %r8d, %r8d  /* 复位 r8 */
  xorl %ecx, %ecx  /* 复位 ecx */
#ifdef PIC
  /* 将 GOT 表项中的 main 函数地址存放到 rdi */
  mov main@GOTPCREL(%rip), %RDI_LP  
#else
  mov $main, %RDI_LP  /* 将 main 函数的绝对地址存放到 rdi */
#endif
  /* 调用 __libc_start_main 函数 */
  call *__libc_start_main@GOTPCREL(%rip)
  hlt  
END (_start)
  .data
  .globl __data_start
__data_start:
  .long 0
  .weak data_start
  data_start = __data_start

_libc_start_main 函数原型

int __libc_start_main(int (*main) (int, char**, char**), 
                      int argc, 
                      char **argv, 
                      void (*init) (void), 
                      void (*fini) (void), 
                      void (*rtld_fini) (void), 
                      void *stack_end);

_libc_start_main 会为用户代码的执行做一些前期准备工作

执行对用户ID的必要安全性检查
初始化线程子系统
注册 rtld_fini 函数，以便在动态共享对象退出是释放资源
注册 fini 处理程序，以便在程序退出时执行
调用初始化函数 init
调用 main 函数
用 main 的返回值调用 exit 函数

CRT

CRT（C Runtime Library CRT）为应用程序提供了对启动与退出、C 标准库函数、IO、堆、C 语言特殊实现、调试等多方面功能的实现和支持。

crt1.o 提供了 _start 符号的具体实现，仅参与可执行文件的编译过程
crti.o 和 crtn.o 两者通过协作，为共享对象提供了可以使用”构造函数“和”析构函数“的能力
crtbegin.o 和 crtend.o 分别提供了 ”构造函数“和”析构函数“的实现

第三十讲 ABI 和 API

API

API（Application Programming Interface）侧重点在于编程，通过遵循 API 规范，可以在相应的编程语言代码中使用这些接口。对于 C 语言来说，标准库头文件中的函数原型便是一种 API 的具体表现， glibc 和 musl 是其的具体实现。

API 的重要特征是提供相应功能的同时隐藏实现细节，让使用者可以按照较为统一和稳定的方式来使用系统的能力。

ABI

ABI（Application Bianry Interface）侧重点在于机器指令层面的具体格式， ABI 将程序、操作系统、硬件平台之间协作需要遵守的特定规则暴露出来。这些规则指定这个体系运行的二进制应用程序应该如何在机器代码层面进行数据访问或函数调用。

API 规范通常涵盖如下内容：

函数调用规范
处理器可以访问的数据类型的大小和对齐方式
进程初始化细节（如栈和寄存器的状态变化）
对象文件（如 .o）的基本结构
程序载入和动态链接的细节

第三十一讲程序和操作系统交互

什么是系统调用

系统调用是由操作系统内核封装过的一些可供上层应用程序使用的接口

以 getpid 函数具体

#include <unistd.h>
#include "syscall.h"
pid_t getpid(void) {
  return __syscall(SYS_getpid);
}

__syscall 对应的汇编实现

.global __syscall
.type __syscall,@function
__syscall:
  movq %rdi, %rax  // 将函数对应的ID 存放到 rax 
  movq %rsi, %rdi  // 将函数参数存放对寄存器
  movq %rdx, %rsi
  movq %rcx, %rdx
  movq %r8, %r10
  movq %r9, %r8
  movq 8(%rsp), %r9
  syscall  // 执行指令
  ret

系统调用和用户函数

两者最大区在在于系统调用执行的代码位于操作系统底层的内核环境中，而用户代码则位于内核之上的应用环境中。

在 x86 架构中，特权级别分为四个层次

不同特权级别，CPU 能被允许执行的机器指令和使用的起存器不同

系统调用实现

可以使用 int 实现系统调用

extern sub
global _start
section .text
_start:
  and   rsp,0xfffffffffffffff0  // 16位对齐
  mov   esi, 2
  mov   edi, 1
  call  sub
  # use "int" to invoke a system call.
  mov   ebx, eax  
  mov   eax, 1
  int   0x80

上述代码执行过程如图

PPD's blog

2025年终总结

跑步

爬山

阅读

英语

旅行

工作

关系

投资

2024海南环岛摩旅

前言

海口-临高（第1天）

临高-儋州（第2天）

儋州-莺歌海（第3天）

莺歌海-三亚（第4天）

三亚-神州半岛（第5天）

神州半岛-文昌（第6天）

文昌-海口（第7天）

后记

2024年终总结

工作

生活

展望

2024端午小记

生机

老去

结尾

五一肯尼亚之旅

前言

行前准备

内罗毕(第0-1天)

瓦塔木(第1-3天)

内罗毕(第3-4天)

马赛马拉(第4-7天)

后记

2024出差小记

前言

出差

赏景

访友

后记

2023年终总结

工作

生活

展望

链接

[笔记]C++之旅

第一章 基础

函数

类型、变量与运算

常量

指针、数组和引用

初始化

赋值

第二章 用户自定义类型

结构

类

枚举

联合

第三章 模块化

函数参数和返回值

参数传递

返回值

返回类型后置

第四章 错误处理

第五章 类

具体类

抽象类

虚函数

第六章 基本操作

拷贝和移动

第七章 模版

参数化类型

参数化操作

模版函数

函数对象

匿名函数

模版机制

别名模版

第一章基础

第二章用户自定义类型

第三章模块化

第四章错误处理

第五章类

第六章基本操作

第七章模版

第八章概念和泛型编程

第三讲复杂度分析（上）

第四讲复杂度分析（下）

第五讲数组

第六讲链表

第八讲栈

第九讲队列

第十讲递归

第十一讲排序(上)

第十二讲排序(下)

第十三讲线性排序

计数排序（Counting Sort）

基数排序（Radix Sort）

第十四讲快速排序优化

第十五讲二分查找

第十七章跳表

第十八章散列表（上）

第十九章散列表（中）

第二十一讲哈希算法（上）

第二十二讲哈希算法在分布式服务中的应用

第二十三章二叉树

第二十四章二叉查找树

第二十五章平衡二叉查找树