一名2024届毕业生的求职日记（暑期实习）

总结

通过

公司	岗位	时间	进度	评价
SmartX	SRE	2022-12	三面通过，一周后直接入职	寒假接了，实习到开学之前，总体体验很好，氛围很棒，但因为学校有事提前离职了，虽然组长说后面处理完学校的事情，还可以回来，但由于想试试大厂就没回去。
字节	飞书后端	2022-12	一面侥幸通过，主动拒了二面	当时想去 SmartX 所以就拒掉了，没想到开学后字节根本不招人了。
快手	容器云开发	2023-2	两面通过，很快发了 offer	流程走的很快，今年招了很多人，不清楚进去做什么
百度	风控研发后端	2023-3	三面通过，养鱼两周发了 offer	还是想做基础架构，感觉这个岗位更多是调用算法的能力，实现内容审核，更像是传统后端，所以拒了
拼多多	后端	2023-3	一面过，主动拒了二面	听了室友的面试，自知顶不住 PDD 的工作强度，怕了怕了
美团	基础架构	2023-3	二面通过，养鱼两周发了 offer	做轻容器和富容器相关的工作，据说就招一个人
Amazon	全栈	2023-4	二面通过，养鱼一个月，发了offer	Amazon 还是香的，就是要进去转全栈 Java+React
PayPal	PaaS 后端	2023-4	二面通过，拒了 HR 面	团队规模有点小，主要是因为国内安全审查无法使用 AWS，只能找人自己做基础架构
腾讯	腾讯计费后端	2023-4	一面通过，主动拒了二面	要我去深圳实习，溜了溜了

其他

公司	岗位	日期	评价
米哈游	云游戏后端	2023-3	笔试挂，是我不配了
蚂蚁	基础架构	2023-3	垃圾系统，有 BUG 说我走了别人的内推码，直接挂简历，后面转 BU 就一直跑池子
字节	后端	2023-3	投了好多意向，全部没消息，卡在简历评估
携程	基础架构	2023-3	简历挂，是我不配了
蔚来	基础架构	2023-3	简历挂，是我不配了
阿里	本地生活基础架构	2023-4	二面通过，HR 面挂了	做 Service Mesh 相关的工作，二面挺有意思的
腾讯	天美 QQ 飞车	2023-4	被问到不会 C++，果然挂了

腾讯天美（2023-4-25）

1. 只记得自己最后反问技术栈，结果面试官问我会不会 C++，会不会高性能编程，当然是不会啦😧

腾讯计费一面（2023-4-13）

1. 自我介绍
2. 介绍一个 kubevela 的项目
3. 介绍遇到的困难，以及如何解决的
4. 介绍 kubevela 的作用
5. 介绍 k8s 的组件
6. 介绍调度器的原理
7. 介绍 k8s 集群中，Pod 的数量和 Node 的数量受什么影响（这个不太清楚）
8. 介绍 service 的原理，外界访问一个 Pod 的流程
9. 介绍 TinyKV 项目为什么要基于 etcd 的架构来做
10. 联合主键 (A,B,C)，查询 SELECT * FROM TABLE1 WHERE B=1 AND C=2，走不走主键
11. 查询 SELECT * FROM TABLE1 WHERE B=1 AND A=2，走不走主键（这个应该和优化器有关，答错了）

阿里本地生活 Golang 二面（2023-4-13）

1. 自我介绍
2. 介绍 vela top 的工作
3. 遇到的困难，如何解决的
4. 一直追问有了 WEB 的方式，并且 WEB 端已经支持了这种能力，为什么还要在 CLI 端做 vela top。
5. 上面的问题实际上一直在追问我如何理解 vela top 的需求。
6. 介绍 Raft 协议
7. Raft 协议中选举是如何做的

PayPal 二面（2023-4-12）

1. 自我介绍
2. slice 原理
3. map 原理
4. channel 原理
5. 做题：手写一个排序算法
6. 做题：两个排序数组找中位数

PayPal 一面（2023-4-10）

1. 自我介绍
2. 介绍 KubeVela 的项目
3. 介绍如何使用 KubeVela 交付一个应用
4. 介绍 vela top 项目的意义
5. 借助 KubeVela 如何实现滚动发布
6. 滚动发布需要借助 K8S 中哪种资源
7. Deployment 滚动升级的策略有哪些
8. Deployment 交付时的哪个组件起的作用
9. Scheduler 调度 Pod 的过程
10. Pod 被调度到节点之上后的过程
11. Ingress 原理
12. Endpoint 原理
13. 使用 Go 实现一个功能：获取一个 Linux 主机上全部的进程，并获取该进程的 cmd line。并暴露该指标成为一个服务，该服务需要提供一个接口，可以获取一个小时内的情况。

Amazon 二面（2023-4-07）

1. 自我介绍
2. 介绍一个项目
3. 介绍项目的难点以及如何解决的
4. 介绍实习中项目遇到的困难并且是如何解决的
5. 介绍 cgroup 这种技术
6. 如何获取一个 Linux 主机上的所有进程
7. 实现一个计算器
8. 反问

Amazon 一面（2023-4-07）

1. 自我介绍
2. 介绍一个项目
3. 介绍项目中的难点如何解决的
4. 删除链表的倒数第 N 个节点
5. HashMap 的实现原理
6. 反问

阿里本地生活 Golang 一面（2023-3-29）

1. 自我介绍
2. 叙述一下 Go 中的协程，协程是如何实现抢占式调度的
3. 叙述一下 Go 中 channel 的原理，有缓冲和无缓冲的区别
4. 叙述一下 Go 接口的原理
5. 叙述一下 Go 垃圾回收的原理
6. 介绍一下 Go 逃逸分析的过程
7. 介绍一下 defer 的原理，defer 的调用顺序，嵌套 defer 如何调用
8. 介绍一下 Go 中字符串拼接的几种方式，几种方式的性能开销如何排序（这个确实听说过，不记得了）
9. 介绍一下 K8S 的基本组件（基本都介绍了，但是他问我还有没有其他的，说不出来了）
10. etcd 为什么可以实现分布式一致性
11. etcd 可以单机部署吗
12. go-client 原理
13. WebHook 的原理（这个确实没了解过）
14. 介绍 KubeVela 的项目
15. 参与过程中遇到的最大的挑战，如何解决的
16. 如何把开源项目结合到实际的项目中

美团基础架构二面（2023-3-27）

1. 自我介绍
2. 介绍 KubeVela 这个项目
3. 项目过程中遇到了什么问题，如何解决的
4. 项目设计的过程中，社区成员有没有给一些指导
5. KubeVela 这个项目它为开发和运维人员提供哪些能力
6. 如何看待项目的成熟度，有哪些企业采用这个项目
7. 这个项目对这些企业带来了多少效率的提升，或者带来了多大的成本节省
8. 进程间通信方式，实际应用中是如何使用的
9. 消息队列的方式和共享内存的方式有什么区别
10. TCP 为什么会粘包
11. 你在 SmartX 和阿里云都体验过，你如何看待大公司和小公司
12. 你如何看待美团和阿里云
13. 你能说一下你人生的至暗时刻吗

腾讯笔试（2023-3-26）

5 道题：100%、100%、100%、32%、5%

小红书笔试（2023-3-26）

3 道题：100%、100%、100%

拼多多后端一面（2023-3-23）

出了一道 leetcode 上没有的链表相减😢

1. 自我介绍
2. 根据自我介绍中提到的内容，详细介绍一段经历，有无遇到什么问题，如何解决的
3. 介绍最近一段实习经历，业务场景是什么，最后离职的时候，做到什么程度
4. 手撕：链表相减

A-B 的场景下有可能出现两种情况：A > B 或 A < B，但后者处理明显难度更大，做的时候不知道该怎么解决这个问题，所以说要事先判断一下，保证大数减小数。

package main
import (
    "fmt"
)

type ListNode struct {
    val  int
    next *ListNode
}

func main() {
    array1 := []int{3, 4, 2, 7}
    array2 := []int{4, 6, 5}

    lst1 := initListNode(array1)
    lst2 := initListNode(array2)
    
    lst1 = reverseList(lst1)
    lst2 = reverseList(lst2)
    
    ans := subList(lst1, lst2)

    for ans != nil {
        fmt.Print(ans.val, " ")
        ans = ans.next
    }
}

func initListNode(array []int) *ListNode {
    newHead := new(ListNode)
    point := newHead

    for i := 0; i < len(array); i++ {
        newNode := &ListNode{
            val: array[i],
        }
        point.next = newNode
        point = point.next
    }
    return newHead.next

}

func reverseList(head *ListNode) *ListNode {
    if head == nil || head.next == nil {
        return head
    }
    ans := reverseList(head.next)
    head.next.next = head
    head.next = nil
    return ans
}

func subList(lst1, lst2 *ListNode) *ListNode {
    newHead := new(ListNode)
    point := newHead
    x, y, z := -1, -1, 0
    for x != 0 && y != 0 {
        if lst1 != nil {
            x = lst1.val
            lst1 = lst1.next
        } else {
            x = 0
        }
        if lst2 != nil {
            y = lst2.val
            lst2 = lst2.next
        } else {
            y = 0
        }
        tmp := x - y - z
        if tmp < 0 {
            tmp = 10 + tmp
            z = 1
        } else {
            z = 0
        }
        newNode := new(ListNode)
        newNode.val = tmp
        point.next = newNode
        point = point.next
    }
    return newHead.next

}

后面通知一面过了，但是考虑到这个是 PDD，加上已经有别的公司的 OC 了，放弃二面。

阿里巴巴笔试（2023-3-22）

3 道题：100%、50%、0%

美团基础架构一面（2023-3-21）

正好是做容器调度和限制的，所以方向比较契合，最后还问我感不感兴趣这个方向

1. 自我介绍
2. SmartX 实习经历，介绍背景、解决的问题、遇到的问题、如何解决的
3. cgroup 原理
4. 你提到了你们这个采集服务，最后也用 cgroup 进行资源限制，那么进行限制后不会出现采集数据不准确的问题吗
5. 使用的是 cgroup v1 还是 cgroup v2，知道他们的原理或者区别吗
6. 你们有没有遇到过服务启动较慢，然后没有来得及加入到 cgroup 管理中的情况，如何解决的
7. 那如果出现这个情况，没有加入到 cgroup 之前，不会出现短时间资源短时间不受控的情况吗
8. 介绍 kubevela
9. 遇到过什么问题吗，如何解决的
10. 了解 MySQL 中的 B 树与 B+ 树吗，这个两个的区别吗
11. 知道数据库的隔离级别吗
12. 了解 Redis 吗？除了使用还知道底层原理吗，知道跳表的原理吗（正好不知道，尴尬🐶）
13. 知道 go 的 map 吗？为什么是并发不安全的
14. 知道 go 的内存分配机制吗
15. go 多线程之间是如何通信或者共享内存的
16. 手撕： N 字形变换（没看懂题目的意思）
17. 场景题：1T 大小的文件，1G 的内存，如何排序

百度后端三面（2023-3-18）

一天连续三面，顶不住了，前面聊的挺好，反手出了道 Hard 😧

1. 自我介绍
2. 介绍 KubeVela 的工作
3. 项目中的难点是什么，如何解决的
4. 还在维护这个项目吗
5. 除了你之外还有人在维护这个项目吗
6. 平时的兴趣爱好
7. 以后的职业发展计划是怎么样的
8. 是想做业务还是做基础架构
9. 为什么不选择使用 C++ 作为主力语言
10. 研究生读的什么方向
11. 为什么不介绍实验室的项目
12. 保研的时候，为什么选择这个方向
13. 算法题：编辑距离

func minDistance(word1 string, word2 string) int {
    size1,size2:=len(word1),len(word2)
    dp:=make([][]int,size1+1)
    for i:=0;i<=size1;i++{
        dp[i]=make([]int,size2+1)
        dp[i][0]=i
    }
    for j:=0;j<=size2;j++{
        dp[0][j]=j
    }
    
    for i:=1;i<=size1;i++{
        for j:=1;j<=size2;j++{
            if word1[i-1]==word2[j-1]{
                dp[i][j]=min(dp[i-1][j]+1,min(dp[i][j-1]+1,dp[i-1][j-1]))
            }else{
                dp[i][j]=min(dp[i-1][j],min(dp[i][j-1],dp[i-1][j-1]))+1
            }
        }
    }
    // fmt.Println(dp)
    return dp[size1][size2]
}

  

func min(a,b int)int{
    if a<b{
        return a
    }
    return b
}

百度后端二面（2023-3-18）

1. 自我介绍
2. 介绍一下对云原生的理解
3. 云原生除了微服务、容器化这些点，还带来了哪些提升
4. 以往的企业中不上云的情况下，是怎么部署项目的，运维是怎么进行的
5. 云原生的缺点是什么
6. 介绍一下 KubeVela 的工作
7. 这个工作完全是你自己做的吗
8. 采集的数据的粒度是什么样的，主要采集的指标有哪些
9. 介绍一下 SmartX 的工作，这个公司是做什么的
10. 采集的指标的有哪些，粒度是怎么样的
11. 你做的工作涵盖面很广，但都没有特别深入，你是怎么考虑这件事的
12. 算法题：重排链表

func reorderList( head *ListNode )  {
    // write code here
    if head==nil || head.Next==nil{
        return 
    }
    m:=middleNode(head)
    
    l1,l2:=head,m.Next
    m.Next=nil
    l2=reverseList(l2)
    mergeList(l1,l2)
}

func middleNode(head *ListNode)*ListNode{
    fast,slow:=head,head
    for fast.Next!=nil && fast.Next.Next!=nil{
        fast=fast.Next.Next
        slow=slow.Next
    }
    return slow
}

func reverseList(head *ListNode) *ListNode{
    var pre,cur *ListNode=nil,head
    for cur!=nil{
        tmp:=cur.Next
        cur.Next=pre
        pre=cur
        cur=tmp
    }
    return pre
}

func mergeList(l1,l2 *ListNode) {
    var tmp1,tmp2 *ListNode
    for l1!=nil && l2!=nil{
        tmp1=l1.Next
        tmp2=l2.Next
        l1.Next=l2
        l1=tmp1
        l2.Next=l1
        l2=tmp2
    }
}

百度后端一面（2023-3-18）

1. 自我介绍
2. PingCAP 的这个项目是在实习的时候做的吗
3. 这个项目的结构是怎样的
4. 既然项目结构完全参照了 etcd，那他的意义是什么
5. 你知道 PingCAP 基于 TiKV 又做了一个什么产品吗
6. 介绍 KubeVela 中做的工作
7. vela top 如何获取资源状态
8. 介绍 SmartX 实习的工作
9. 介绍 cgroup 原理
10. 介绍网易有道实习的工作
11. MySQL 索引的数据结构
12. 为什么使用 B+ 树，和 B 树的区别是什么
13. MySQL 中索引结构对 B+ 树做了什么优化
14. HTTP2 做了什么优化
15. 介绍一下 HTTP3
16. WebSocket 的原理
17. 为什么选择使用 WebSocket
18. WebSocket 和 HTTP2 的主动推送的区别是什么
19. go 中在数据冲突的情况下保证数据一致，平时是怎么做的
20. go 的 gmp 模型
21. 场景题：一个没有使用 k8s 的 PaaS 平台，有 8 个服务，怎么保证正常的服务数量，服务宕机之后可以恢复，该怎么设计
22. 算法题：二叉树的层序遍历

func levelOrder( root *TreeNode ) [][]int {
    // write code here
    if root==nil{
        return [][]int{}
    }
    
    ans:=make([][]int,0)
    nodes:=make([]*TreeNode,0)
    nodes=append(nodes,root)
    
    for size:=len(nodes);size!=0;size=len(nodes){
        tmp:=make([]int,0)
        for i:=0;i<size;i++{
            tmp=append(tmp,nodes[i].Val)
            if nodes[i].Left!=nil{
                nodes=append(nodes,nodes[i].Left)
            }
            if nodes[i].Right!=nil{
                nodes=append(nodes,nodes[i].Right)
            }
        }
        nodes=nodes[size:]
        ans=append(ans,tmp)
    }
    return ans
}

百度笔试（2023-3-12）

3 道题：100%、100%、0%
最后一道题有思路，也是正确的，可惜没做出来，恨！

拼多多笔试（2023-3-11）

4 道题：100%、100%、100%、75%

美团笔试第一次（2023-3-10）

5 道题：100%、100%、73%、55%、0%

快手容器云二面（2023-02-28）

• 自我介绍
• 介绍一个参与过的项目
• 参与项目中遇到的困难，是如何解决的？
• 了解数据库吗？了解索引吗？
• 了解联合索引吗？
• 联合索引的字段顺序会如何影响索引使用。
• 了解网络吗？介绍一个 HTTP 与 HTTPS 的区别。
• TLS 在网络中的那一层？
• TCP 是如何通信的？序列号的作用。
• 做题，根据一个父子节点的关系表，重建一棵多叉树。

OC 审批走流程

快手容器云一面（2023-02-23）

项目

• 自我介绍
• 介绍一个参与过的项目
• 过程中的遇到的困难
• 项目能够支撑的应用数量级别
• 实习经历
• cgroup 的理解

语言

• channel 原理
• 向一个空的 channel 写入数据，会发生什么？（分有缓存和无缓存两种）
• 向一个未初始化的 channel 写入数据，会发生什么？（这个没答好，提示写出来了）
• 向一个关闭的 channel 写入数据，会发生什么？
• context 原理
• context 作用
• go 的垃圾回收
• 什么时候会触发写屏障？
• go 垃圾回收的问题，平时需要注意什么避免 GC 带来的性能问题
• goroutine 的原理，线程模型理解
• 线程通信方式
• go 协程通信方式

操作系统

• 什么时候会从用户态陷入内核态
• 线程通信方式

计算机网络

• 拥塞控制的原理
• 慢启动阶段的作用

k8s

• kube-proxy 的原理
• kube-proxy 三种模式
• ivs 相比于 iptable 通过 hash 的方式带来了性能提升，那么还有什么方式可以提升性能？（不懂）
• schuduler 的原理

做题

• 二叉树任意两个节点间的最大距离（没思路 g）
• 最长递增子序列

字节跳动飞书后端一面（2022-12-13）

1. 自我介绍
2. KubeVela 介绍
3. Raft 选举原理
4. Raft 3 个节点的集群，挂掉一个两外两个节点可以选举出新的 Leader 吗
5. Golang Chan 的原理
6. HTTPS 原理
7. Hash 冲突的解决办法
8. 做题：链表求和（反转链表写的有 Bug…）
9. 做题：简单 SQL（太久没写不记得 HAVING 和 Group BY 了）

体验很好，自己傻逼，这种简单题都没顺利完成，给我机会我不中用啊。
不过后续通知我通过了，不过没兴趣，直接去 SmartX 了不面了。

SMARTX 分布式管理平台三面 （2022-12-9）

1. 自我介绍
2. 介绍一下在 KubeVela 社区所做的工作。
3. 工作中的难点？
4. 提到的对网络 IO 造成界面阻塞，那界面阻塞是什么原因造成的？
5. 既然界面阻塞是因为单线程阻塞，那么不能采用多线程的方式吗？
6. TinyKV 的主要内容？
7. 给定一个场景：5 个节点全部掉线，又全部同时恢复，在 Raft 协议下，会发生什么？
8. 掉线节点如何知道自己的身份？
9. 持久化 leader 的状态的作用是什么？
10. 重新选举是如何进行的？
11. 为什么在判断消息是否过时要同时使用 index 和 term？
12. 给定一个场景：3 台机器，两个存储副本该如何实现？
13. Go 中 channel 的原理？

一周 OC，还算顺利

SMARTX 分布式管理平台二面 （2022-12-8）

1. 自我介绍和从事开发的介绍。
2. KubeVela 社区做的主要工作。
3. KubeVela 如何做资源采集。
4. K8S 中的组件。
5. 控制器是如何通知调度器，进行相应操作的。
6. 在网易搭建性能测试平台时所做的主要工作。
7. Jenkins 是多实例的吗？
8. MySQL 和 MongoDB 的区别和业务选型上的考量。
9. Docker 是如何做资源隔离的。
10. 平时使用 Linux 从事哪些开发。
11. 使用 Linux 内核的版本。
12. Linux 主要使用哪些命令。
13. 如何配置一个网卡的静态 IP。
14. 统计出现频率最高的 K 个单词。

package main

import (
    "fmt"
    "strings"
)

type HeapNode struct {
    word string
    fre  int
}

func main() {
    content := "a b c a b b s"
    ans := make([]string, 2)
    freCountMap := countFre(content)
    freArray := convertMapToArray(freCountMap)
    size := len(freArray)
    buildHeap(freArray)
    for i := 0; i < 2; i++ {
        ans[i] = freArray[0].word
        freArray[size-1-i], freArray[0] = freArray[0], freArray[size-1-i]
        justify(freArray, 0, size-1-i)

    }
    fmt.Println(ans)
}

  

func countFre(content string) map[string]int {
    countMap := make(map[string]int)
    words := strings.Split(content, " ")
    for i := 0; i < len(words); i++ {
        countMap[words[i]]++
    }
    return countMap

}

  

func convertMapToArray(m map[string]int) []HeapNode {
    array := make([]HeapNode, len(m)+1)
    index := 1
    for key, value := range m {
        array[index] = HeapNode{
            word: key,
            fre:  value,
        }
        index++
    }
    return array
}

func buildHeap(wordArray []HeapNode) {
    size := len(wordArray)
    for i := len(wordArray) / 2; i >= 0; i-- {
        justify(wordArray, i, size)
    }
}

func justify(wordArray []HeapNode, top, size int) {
    left, right, k := top*2, top*2+1, top

    if left < size && wordArray[left].fre > wordArray[k].fre {
        k = left
    }

    if right < size && wordArray[right].fre > wordArray[k].fre {
        k = right
    }
    if k != top {
        wordArray[k], wordArray[top] = wordArray[top], wordArray[k]
        justify(wordArray, k, size)
    }

}

SMARTX 分布式管理平台一面 （2022-12-5）

• Raft 主要的内容，并分别阐述。
• 为 KubeVela 贡献的内容？
• KubeVela 资源信息采集是怎么做的？
• K8s 组件都有哪些？
• K8s 上 POD 的部署过程。
• K8s 如何减少 etcd 和 apiserver 的通信？
• K8s Service 是怎么将一个请求从 Service 重定向到容器的。
• Linux 上容器是怎么实现的？
• Linux 内存分配。
• 如果内存不足了这时候再使用 malloc 分配会怎么样。
• Linux 上减少 I/O 的方式有哪些？
• cache 是怎么减少 I/O 的？
• HTTP 长连接如何是实现的？
• HTTPS 是如何实现加密通信的？
• 非对称加密出了加密还有什么用途？
• WebSocket 原理。
• TCP 三次握手。
• TCP 半连接攻击。
• 实现一个多线程的一个生产者多个消费者场景。生产者有 n 的任务，最多同时有 m 个消费者。
• 如果不使用锁如何实现。

package main

import (
    "fmt"
    "sync"
)

type Task struct {
    sum           int
    finishJobNum  int
    RunningWorker int
    jobs          chan int
    workerSignal  chan int
    syncSignal    chan int
    wg            sync.WaitGroup
}

func main() {
    var n, m int
    t := Task{
        jobs:         make(chan int, n),
        workerSignal: make(chan int, m),
        syncSignal:   make(chan int, 1),
    }

    t.Productor(n)
    t.syncSignal <- 1
    
    for i := 0; i < m; i++ {
        t.workerSignal <- 1
    }

    t.wg.Add(n)

    for {
        <-t.syncSignal
        if t.finishJobNum >= n {
            break
        }

        t.syncSignal <- 1
        <-t.workerSignal

        select {
        case num := <-t.jobs:
            go t.Consumer(num)
        }
    }

    t.wg.Wait()

}

func (t Task) Consumer(num int) {
    t.sum += t.DoTask(num)
    <-t.syncSignal
    fmt.Println(t.finishJobNum, t.sum)
    t.finishJobNum++
    t.RunningWorker++
    t.finishJobNum--
    t.syncSignal <- 1
    t.workerSignal <- 1
    t.wg.Done()
}

func (t Task) Productor(n int) {
    for i := 0; i < n; i++ {
        t.jobs <- i
    }
}

func (t Task) DoTask(k int) int {
    return k + 1
}