小红书秋招开发岗面经

Redis的高性能源于四大核心设计：
1. **内存操作**（性能基石）
   - 数据全量存储于内存，读写速度达微秒级（磁盘I/O为毫秒级）
   - 采用高效数据结构：SDS动态字符串（预分配+惰性释放）、跳跃表（ZSET底层）、压缩列表（Hash/List优化）

2. **单线程模型**（避免并发陷阱）
   - 主线程串行处理命令，消除锁竞争/上下文切换开销
   - 异步机制处理持久化：BGSAVE fork子进程写RDB，AOF缓冲追加

3. **I/O多路复用**（高并发支撑）
   ```c
   // 伪代码：epoll事件循环
   while(1) {
     int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
     for(i=0; i<n; i++){
        if(events[i] & EPOLLIN) 
           readQueryFromClient(conn);
     }
   }

**避坑提示**：若仅回答"Redis快是因为用内存"，未提单线程设计及多路复用，会被认为理解肤浅。

---

### 二、HTTP与RPC的本质区别
**面试官意图**：考察对通信协议场景化应用的理解，能否区分技术选型边界。

**核心对比**：
| **维度**       | **HTTP**                  | **RPC**                     |
|----------------|---------------------------|-----------------------------|
| 设计目标       | 通用资源传输              | 远程方法调用                |
| 协议开销       | Header+Body冗余结构       | Protobuf/Thrift二进制压缩   |
| 调用方式       | 手动拼装URL/Header        | 像本地函数一样调用          |
| 性能瓶颈       | 序列化/解析成本高         | 平均延迟降低40%+            |
| 典型场景       | 浏览器-服务端通信         | 微服务间内部调用            |

**技术选型建议**：
- 选HTTP：跨语言、跨平台、需暴露API给第三方
- 选RPC：服务网格内部通信、高频调用场景（如订单支付链路）

---

### 三、虚拟内存用户态地址空间布局
**面试题延伸**：当面试官问`malloc(1024)`时内存如何变化？

**地址空间解剖图**：

**关键考点**：
- 堆内存不足时会调用`brk()`扩展堆顶指针
- 超过128KB的大内存分配直接走mmap映射区

---

### 四、Go的GMP模型详解
**面试官意图**：考察对Go并发调度本质的理解，是否清楚协程高效的原因。

**GMP工作流程图**：
```mermaid
graph LR
    G1(Goroutine) --> P1[Processor]
    G2(Goroutine) --> P1
    P1 --> M1(Machine)
    M1 --> CPU1
    
    P2[Processor] --> M2(Machine)
    M2 --> CPU2
    G3(Goroutine) --> P2
    
    P1 -. 工作窃取 .-> P2

class Animal { int weight; };
class Tiger : virtual public Animal {};
class Lion : virtual public Animal {};
class Liger : public Tiger, public Lion {}; // 虚继承解决二义性

class Logger {
public:
    static std::mutex log_mutex; // 跨对象共享锁
};
std::mutex Logger::log_mutex; // 必须类外初始化

gdb -c core.dump ./a.out
bt full # 查看完整调用栈
frame 2 # 切到第2帧
info locals # 查看局部变量

double findMedianSortedArrays(vector<int>& A, vector<int>& B) {
    if (A.size() > B.size()) swap(A, B);
    int m = A.size(), n = B.size();
    int left = 0, right = m;
    while (left <= right) {
        int i = (left + right) / 2;
        int j = (m + n + 1) / 2 - i;
        
        int A_left = (i>0) ? A[i-1] : INT_MIN;
        int A_right = (i<m) ? A[i] : INT_MAX;
        int B_left = (j>0) ? B[j-1] : INT_MIN;
        int B_right = (j<n) ? B[j] : INT_MAX;
        
        if (A_left <= B_right && B_left <= A_right) {
            int max_left = max(A_left, B_left);
            int min_right = min(A_right, B_right);
            return (m+n)%2 ? max_left : (max_left+min_right)/2.0;
        }
        else if (A_left > B_right) right = i-1;
        else left = i+1;
    }
    return 0.0;
}