10-21 16:52 西安电子科技大学 Java 发布于江苏

关注

字节|自我介绍时间太长了……也会被挂？

先来唠唠

今天来和大家唠唠组织的一位朋友前几天在字节跳动一面的魔幻经历。

面试一开始，面试官很客气地说：

“先做个自我介绍吧。”

她心想：

“常规环节，稳了！”

于是开始滔滔不绝地介绍自己的项目、技术栈、实习经历…… 结果说到一半，面试官突然打断她：“同学，你用了快5分钟了，后面还有不少问题，我们加快一下进度。”

她以为字节的自我介绍是卡秒表的。

后来复盘才意识到，她自己确实把“简洁版”自我介绍讲成了“故事会”，结果直接导致后面技术问题的难度被拉满……

面试官的问题一个比一个硬核：从GC三色标记问到树结构的子集判断算法，从JWT中间件实现聊到长连接的负载均衡…… 全程高能，头皮发麻。

今天我就把这场面的经验教训和真题答案整理出来，帮大家避坑！

如何正确做自我介绍？

复用boss平台打招呼的话术
介绍清楚简历中最近的那个项目
整体时间控制在5分钟以内
自我介绍完毕后，反问面试官:这就是我的自我介绍，您有什么想了解的，我给您详细再解答一下。

看机会

顺便吆喝一句，技术大厂→机遇机会，前端-后端-测试，待遇和稳定性都还不错，感兴趣可以试试~

面试原题 & 参考答案

1. 项目中内存溢出问题如何解决？gopool的作用？

答案：

问题原因：高并发场景下，频繁创建协程导致内存占用激增，触发OOM（Out of Memory）。
解决方案：引入gopool：通过协程池复用协程，限制最大并发数，避免无限制创建。任务队列：将请求任务放入队列，由池中空闲协程消费。动态扩缩容：根据负载动态调整池大小（如突发流量时扩容）。
优化效果：内存占用减少40%，协程创建耗时下降90%。

2. 读写锁（RWMutex）的实现原理？

答案：

核心机制：读锁（共享锁）：允许多个goroutine同时获取，通过计数器记录读锁数量。写锁（互斥锁）：独占模式，获取写锁时会阻塞后续所有读/写请求。
优先级策略：Go的RWMutex采用写优先设计，避免写锁长时间等待（写锁请求到来后，新读锁会被阻塞）。
底层实现：依赖Mutex和条件变量（sync.Cond）管理阻塞队列。

3. 长连接如何实现？

答案：

关键技术点：心跳机制：客户端定期发送心跳包（如TCP Keepalive或WebSocket Ping/Pong），服务端检测超时后断开连接。连接复用：HTTP/1.1的Keep-Alive或HTTP/2多路复用，减少TCP握手次数。服务端配置：Nginx设置keepalive_timeout（空闲连接保持时间）、keepalive_requests（单连接最大请求数）。断线重连：客户端实现自动重连逻辑，处理网络波动。

4. 负载均衡Nginx的均衡算法有哪些？

答案：

常用算法：轮询（Round Robin）：按顺序分发请求，均匀但忽略服务器性能差异。加权轮询（Weighted Round Robin）：根据服务器配置分配权重，性能高的服务器承担更多流量。IP Hash：基于客户端IP计算哈希值，固定分配到同一服务器（适合会话保持场景）。最小连接数（Least Connections）：优先分配给当前连接数最少的服务器。响应时间加权（需插件）：根据服务器响应时间动态调整权重。

5. 数据一致性：延迟双删策略是什么？

答案：

背景：缓存与数据库不一致问题（如先更新数据库再删缓存，期间可能有旧数据被回写）。
延迟双删步骤：第一次删除：更新数据库前先删除缓存。更新数据库：执行DB写操作。第二次删除：延迟一段时间（如500ms）后再次删除缓存。
目的：确保数据库主从同步完成，避免旧数据在同步期间被写入缓存。
注意事项：延迟时间需根据业务主从同步耗时调整。

6. JWT在Gin框架中如何通过中间件实现？

答案：

实现步骤：生成Token：用户登录后，用HS256算法签名生成JWT（包含用户ID、过期时间）。中间件验证：

func JwtAuth() gin.HandlerFunc {  
    return func(c *gin.Context) {  
        tokenString := c.GetHeader("Authorization")  
        // 解析Token  
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {  
            return []byte("your_secret_key"), nil  
        })  
        if err != nil || !token.Valid {  
            c.AbortWithStatusJSON(401, gin.H{"error": "无效Token"})  
            return  
        }  
        // 提取Claims  
        if claims, ok := token.Claims.(jwt.MapClaims); ok {  
            c.Set("userID", claims["userID"])  
        }  
        c.Next()  
    }  
}

路由使用：

router.GET("/profile", JwtAuth(), func(c *gin.Context) {  
    userID := c.MustGet("userID").(string)  
    // 查询用户信息并返回  
})

7. 缓存击穿、穿透、雪崩的区别与解决方案？

答案：

缓存击穿：问题：热点Key过期后，大量请求直接击穿到数据库。解决：互斥锁：仅允许一个线程重建缓存，其他线程等待。逻辑过期：缓存永不过期，后台异步更新。
缓存穿透：问题：查询不存在的数据（如恶意请求不存在的ID）。解决：布隆过滤器：拦截无效请求。缓存空值：对不存在的数据也缓存空结果（设置短过期时间）。
缓存雪崩：问题：大量Key同时过期，数据库压力激增。解决：随机过期时间：在基础过期时间上增加随机值。集群限流：Hystrix或Sentinel实现服务降级。

8. 死锁是什么？如何解决？（可能想问多线程同步）

答案：

死锁条件：互斥：资源只能被一个线程持有。持有并等待：线程持有资源同时等待其他资源。不可抢占：资源只能由持有者释放。循环等待：多个线程形成环形等待链。
解决方案：破坏循环等待：按固定顺序申请资源。超时释放：申请资源超时后自动放弃（如Go的context.WithTimeout）。检测与恢复：通过算法检测死锁后强制释放资源（数据库常用）。

9. 网络I/O模型：阻塞、非阻塞、多路复用、异步的区别？

答案：

阻塞I/O：线程一直等待数据就绪（如默认的Socket read）。
非阻塞I/O：线程轮询检查数据状态，未就绪时立即返回错误。
多路复用（select/poll/epoll）：单线程监听多个Socket事件，就绪时通知处理（高并发场景常用）。
异步I/O（AIO）：内核完成数据拷贝后主动回调通知线程（如Windows IOCP，Linux的io_uring）。

10. 进程间通信（IPC）方式有哪些？

答案：

管道（Pipe）：单向通信，父子进程间使用（如Shell命令|）。
命名管道（FIFO）：可在无关进程间使用。
消息队列：通过消息缓冲区通信，支持多进程读写。
共享内存：进程直接访问同一内存区域，效率最高。
信号（Signal）：单向异步通知（如kill -9）。
Socket：支持跨网络通信（本地Socket性能更优）。

11. TCP三次握手过程？

答案：

SYN：客户端发送SYN包（seq=x）进入SYN_SENT状态。
SYN-ACK：服务端返回SYN+ACK包（seq=y, ack=x+1）进入SYN_RCVD状态。
ACK：客户端发送ACK包（ack=y+1）进入ESTABLISHED状态，服务端收到后也进入ESTABLISHED。

目的：双方确认彼此的发送和接收能力正常，并协商初始序列号。

12. Golang反射（reflect）的核心用途？

答案：

核心功能：类型检查：通过reflect.TypeOf()获取变量类型信息。值操作：通过reflect.ValueOf()修改变量值（需可寻址）。动态调用：通过Value.Call()执行函数或方法。
典型场景： JSON序列化/反序列化（如json.Marshal内部使用反射）。ORM框架中结构体与数据库表的映射。
注意事项：反射代码可读性差且性能较低，非必要不推荐使用。

13. Golang的GC（垃圾回收）机制：三色标记法与屏障技术

答案：

三色标记法：白色：未被标记的对象（待回收）。灰色：已标记但子对象未检查。黑色：已标记且子对象已检查。
流程：从根对象（栈、全局变量等）出发，逐步标记可达对象为黑色，最终回收白色对象。
写屏障（Write Barrier）：目的：解决并发标记期间对象引用变化导致的误回收。实现：当黑色对象引用白色对象时，触发屏障将白色对象标记为灰色。
混合写屏障：Go 1.8+引入，结合插入屏障和删除屏障，减少STW（Stop The World）时间。

14. 算法题：判断一个树是否是另一个树的子树

答案：

问题描述：给定树A和树B，判断B是否是A的子树（结构和值完全一致）。
解法：递归遍历A的每个节点，与B的根节点对比，若值相同则递归检查子树结构。
Go代码：

type TreeNode struct {  
    Val   int  
    Left  *TreeNode  
    Right *TreeNode  
}  

func isSubtree(root *TreeNode, subRoot *TreeNode) bool {  
    if root == nil {  
        return subRoot == nil  
    }  
    // 当前节点是否匹配，或左/右子树是否包含子树  
    return isSame(root, subRoot) ||   
           isSubtree(root.Left, subRoot) ||   
           isSubtree(root.Right, subRoot)  
}  

func isSame(a, b *TreeNode) bool {  
    if a == nil && b == nil {  
        return true  
    }  
    if a == nil || b == nil || a.Val != b.Val {  
        return false  
    }  
    return isSame(a.Left, b.Left) && isSame(a.Right, b.Right)  
}