0316momenta一面

好的，这是一份针对资深后端开发工程师 岗位的面试问题清单。问题覆盖了 Git 工作流、Python 调试与并发、系统设计（LRU）和多线程同步 等核心领域，深度和广度都符合"资深"定位。

下面我将逐一分析每个问题，并提供专业、准确、详细的参考答案。

1. `git rebase` 跟 `git merge` 的区别

考察点：对 Git 分支模型和历史管理策略的理解。

参考答案：

两者都是用于整合来自不同分支的修改，但它们的工作方式和产生的历史记录截然不同。

特性	`git merge`	`git rebase`
核心思想	合并（Merge）	变基/重放（Replay）
工作方式	在当前分支上创建一个新的合并提交（Merge Commit），该提交有两个父提交，分别指向两个被合并分支的最新提交。	将当前分支上的一系列提交"摘下来" ，然后在目标分支的最新提交之后重新应用（replay）这些提交。
历史记录	非线性历史。保留了分支的完整历史，清晰地展示了并行开发的过程。	线性历史。让项目历史看起来像是一条直线，非常整洁。
适用场景	- 公共/共享分支（如 `main`, `develop`）的集成。 - 需要保留完整的、真实的开发历史时。	- 本地私有分支的整理，在推送到远程仓库前使用。 - 希望保持一个干净、线性的项目历史。
风险	安全。不会改写已存在的提交历史。	危险！会改写提交历史。如果在已经推送到远程的公共分支上执行 `rebase`，会导致协作混乱。

总结：

"简单来说，merge 是'合'，它尊重历史，会产生一个合并点；rebase 是'搬'，它重写历史，让历史看起来更线性。对于本地未推送的分支，我习惯用 rebase 来保持整洁；但对于任何已经共享的分支，必须使用 merge 来保证协作安全。"

2. `git fetch` 跟 `git pull` 的区别

考察点：对 Git 数据同步基本命令的理解。

参考答案：

git fetch:
- 作用：仅从远程仓库下载最新的提交、分支和标签等元数据到你的本地 （.git 目录下），但不会自动合并或修改你当前的工作区文件。
- 结果：你的本地代码不变，但你可以通过 git log origin/main 查看远程分支的最新状态，并决定如何与本地分支进行整合（例如，手动 merge 或 rebase）。
- 安全性：非常安全，因为它不会改变你的工作区。
git pull:
- 作用：git pull 是一个组合命令 ，它等价于 git fetch + git merge（默认行为）。
- 过程：首先执行 fetch 获取远程更新，然后立即将远程跟踪分支（如 origin/main）合并（merge）到你当前的本地分支。
- 风险：因为它会自动合并，如果本地有未提交的更改或者合并有冲突，可能会导致工作区混乱。你失去了在 fetch 之后检查变更再决定如何整合的机会。

总结：

"fetch 是'只看不碰'，让你安全地了解远程仓库的最新动态；而 pull 是'看完了就直接合并'，虽然方便，但不够透明。作为资深开发者，我更倾向于先 fetch，审查变更后再手动 merge 或 rebase，这样对代码的控制力更强。"

3. `git reset` 跟 `git revert` 的区别

考察点：对 Git 撤销操作和历史管理策略的理解。

参考答案：

两者都用于"撤销"更改，但哲学完全不同。

git reset:
- 核心思想 ：移动 HEAD 指针，并可选择性地重置暂存区（Index）和工作区（Working Directory）。
- 影响：会改写历史。它通过将分支指针移回到某个旧的提交来"丢弃"后续的提交。
- 模式：
  - --soft：只移动 HEAD，暂存区和工作区不变。常用于合并多个提交。
  - --mixed (默认)：移动 HEAD 并重置暂存区，工作区不变。常用于取消暂存。
  - --hard：移动 HEAD，并重置暂存区和工作区。会丢失所有未提交的更改！
- 适用场景 ：仅限于本地未推送的提交 。绝对不要对已经推送到共享仓库的提交使用 reset --hard。
git revert:
- 核心思想 ：创建一个新的提交来"抵消" （undo）。
- 影响：不会改写历史，而是通过增加新提交来修正错误。历史是安全的、可追溯的。
- 适用场景 ：撤销已经推送到远程仓库的公共提交。这是在团队协作中撤销错误的安全方式。

总结：

"reset 是'时光倒流'，直接抹掉历史，只适用于本地；revert 是'亡羊补牢'，通过新增一个修复提交来修正错误，是处理公共历史的安全做法。在团队项目中，revert 是首选。"

4. Python死锁是什么？如何定位Python死锁的问题？

考察点：对多线程编程陷阱和调试能力的掌握。

参考答案：

什么是死锁 ？

死锁是指两个或多个线程 （或进程）。
经典场景：线程A持有锁L1并等待锁L2，同时线程B持有锁L2并等待锁L1。
如何定位Python死锁？
1. 信号处理（最常用）
  - 在程序启动时注册一个信号处理器（如 SIGUSR1）。
  - 当程序疑似卡死时，向其发送信号：kill -USR1 <pid>。
  - 信号处理器会打印出所有线程的当前堆栈 ，从而清晰地看到每个线程卡在哪个 acquire() 调用上。
  lua 复制代码
```
import threading, sys, traceback, signal

def dump_threads(sig, frame):
    print("\n*** Thread Dump ***", file=sys.stderr)
    for th in threading.enumerate():
        print(f"\nThread {th.name}:", file=sys.stderr)
        traceback.print_stack(sys._current_frames()[th.ident], file=sys.stderr)
    print("\n*** End Thread Dump ***", file=sys.stderr)

signal.signal(signal.SIGUSR1, dump_threads)
```
2. 使用 faulthandler 模块（Python 3.3+）
  - faulthandler.dump_tracebacks_later(timeout, repeat=True) 可以在超时后自动打印所有线程的堆栈。
3. 事后分析：
  - 如果程序崩溃并生成了 core dump，可以使用 gdb 结合 Python 调试符号来分析。
  - 使用性能分析工具如 py-spy 进行实时采样：py-spy top -p <pid> 或 py-spy record -o profile.svg -p <pid>。

总结：

"死锁的根本原因是锁的获取顺序不一致。预防胜于治疗，最佳实践是为所有锁定义一个全局的获取顺序。一旦发生死锁，通过信号处理器打印所有线程堆栈是最快速有效的定位手段。"

5. Python中的pdb了解吗？怎么使用？底层的原理是什么？

考察点：对Python调试工具链和运行时机制的理解。

参考答案：

是什么 ？
pdb (Python Debugger) 是Python标准库自带的交互式源码调试器。
怎么使用？
1. 命令行启动 ：python -m pdb my_script.py
2. 代码中插入断点（推荐）
  - Python < 3.7: import pdb; pdb.set_trace()
  - Python >= 3.7: breakpoint() (更简洁，且可通过环境变量 PYTHONBREAKPOINT 控制)
3. 常用命令：
  - l (list): 显示当前代码
  - n (next): 执行下一行（不进入函数）
  - s (step): 执行下一行（进入函数）
  - c (continue): 继续执行直到下一个断点
  - p <var> (print): 打印变量值
  - pp <var> (pretty-print): 美化打印变量值
  - q (quit): 退出调试器
底层原理 ？
pdb 的核心是利用了Python解释器的 sys.settrace 机制。
- 当你调用 set_trace() 时，pdb 会设置一个全局的跟踪函数（trace function）。
- Python解释器在执行每一行代码、进入/退出函数、抛出异常等关键事件时，都会调用这个跟踪函数。
- pdb 的跟踪函数会检查当前事件是否是用户感兴趣的（比如是否到了断点行），如果是，就暂停程序执行 ，并将控制权交给一个交互式的命令循环（REPL）。
- 用户在这个REPL中输入命令（如 n, s），pdb 会解析命令并决定下一步如何继续跟踪程序的执行。

总结：

"pdb 是一个基于 sys.settrace 事件钩子的强大调试器。它通过拦截解释器的执行流程，在关键时刻暂停程序并提供一个交互界面，让我们能够窥探程序的内部状态。breakpoint() 是现代Python中设置断点的最佳实践。"

6. 深度学习了解吗？

考察点：对AI/ML领域的知识广度和技术敏感度。

参考答案（根据您提到的回答方向）：

"我对深度学习有基础的了解，并持续关注其发展。

卷积神经网络 (CNN) 我理解其核心在于局部感受野 和权值共享。通过卷积核在输入数据（如图像）上滑动，提取局部特征（如边缘、纹理），并通过池化层降低维度、增强平移不变性。这种结构使其在计算机视觉任务（如图像分类、目标检测）上取得了巨大成功。

大语言模型 (LLM) 方面，我知道其基础架构是Transformer ，它摒弃了RNN的循环结构，完全依赖自注意力机制 （Self-Attention）来建模序列中任意两个位置之间的关系。这使得模型可以并行训练，并能捕捉长距离依赖。像GPT系列这样的模型通过在海量文本上进行自回归预训练 （预测下一个词），学习到了强大的语言理解和生成能力。目前，LLM正通过提示工程 （Prompt Engineering）、上下文学习 （In-Context Learning）和微调（Fine-tuning）等方式被广泛应用。"

（如果岗位与AI相关，可以补充）"虽然我的主要精力在后端工程，但我认为理解这些模型的基本原理对于构建高效的AI应用后端（如推理服务、向量数据库集成）非常重要。"

7. 讲一下目前的项目在做什么？

考察点：沟通能力、业务理解、技术架构抽象能力。

回答建议（通用模板）：

"我目前在负责一个 [项目类型，如：混合云管理平台 / 高并发API网关] 的后端开发。

业务目标 是解决 [核心痛点，如：企业IT资源利用率低 / 第三方服务调用链路过长] 的问题。

技术架构 上，我们采用了 [核心技术栈，如：Python/FastAPI, K8s, MySQL, Redis, RabbitMQ] 。我主要负责 [你的职责，如：核心API的设计与实现、分布式任务调度模块、性能优化] 。

近期挑战 是 [具体挑战，如：如何在保证数据一致性的前提下提升跨云同步的吞吐量] ，我们通过 [解决方案，如：引入最终一致性模型和异步消息队列] 成功将性能提升了X倍。

这个项目让我深入理解了 [你学到的关键点，如：大规模分布式系统的复杂性 / 高可用性设计模式] 。"

关键：STAR原则 （Situation, Task, Action, Result），突出你的个人贡献 和技术深度。

8. 算法题：LeetCode 146 LRU Cache

考察点：数据结构设计、哈希表与双向链表的结合应用。

参考答案（Python）：

LRU (Least Recently Used) 缓存需要在 O(1) 时间内完成 get 和 put 操作。

核心思想：
- **哈希表 **(dict) 提供 O(1) 的 key-to-node 查找。
- **双向链表 **(Doubly Linked List) 维护节点的访问顺序。链表头部是最近使用的，尾部是最久未使用的。

python 复制代码

class ListNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {} # key -> ListNode
        # 创建虚拟头尾节点，简化边界操作
        self.head = ListNode()
        self.tail = ListNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def _add_node(self, node):
        """Add node right after head."""
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def _remove_node(self, node):
        """Remove an existing node from the linked list."""
        prev_node = node.prev
        next_node = node.next
        prev_node.next = next_node
        next_node.prev = prev_node

    def _move_to_head(self, node):
        """Move a node to the head (most recently used)."""
        self._remove_node(node)
        self._add_node(node)

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._move_to_head(node) # Mark as most recently used
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self._move_to_head(node)
        else:
            new_node = ListNode(key, value)
            self.cache[key] = new_node
            self._add_node(new_node)

            if len(self.cache) > self.capacity:
                # Remove the least recently used (tail.prev)
                lru_node = self.tail.prev
                self._remove_node(lru_node)
                del self.cache[lru_node.key]

关键点 ：必须能清晰解释为什么需要双向链表 （为了O(1)删除尾部节点）和哈希表（为了O(1)查找）。

9. 算法题：LeetCode 1114. 按序打印

考察点：多线程同步原语（锁、信号量、条件变量）的应用。

题目：三个线程分别调用 first(), second(), third()，要求无论线程如何调度，都必须按 first -> second -> third 的顺序执行。

参考答案（多种解法）：

解法1：使用 threading.Lock

python 复制代码

from threading import Lock

class Foo:
    def __init__(self):
        self.lock1 = Lock()
        self.lock2 = Lock()
        self.lock1.acquire() # 先锁住second
        self.lock2.acquire() # 先锁住third

    def first(self, printFirst: 'Callable[[], None]') -> None:
        printFirst()
        self.lock1.release() # first执行完，释放second的锁

    def second(self, printSecond: 'Callable[[], None]') -> None:
        with self.lock1: # 等待lock1被释放
            printSecond()
            self.lock2.release() # second执行完，释放third的锁

    def third(self, printThird: 'Callable[[], None]') -> None:
        with self.lock2: # 等待lock2被释放
            printThird()

解法2：使用 threading.Semaphore

python 复制代码

from threading import Semaphore

class Foo:
    def __init__(self):
        self.s1 = Semaphore(0)
        self.s2 = Semaphore(0)

    def first(self, printFirst: 'Callable[[], None]') -> None:
        printFirst()
        self.s1.release()

    def second(self, printSecond: 'Callable[[], None]') -> None:
        self.s1.acquire()
        printSecond()
        self.s2.release()

    def third(self, printThird: 'Callable[[], None]') -> None:
        self.s2.acquire()
        printThird()

解法3：使用 threading.Condition (更通用)

python 复制代码

from threading import Condition

class Foo:
    def __init__(self):
        self.condition = Condition()
        self.state = 0 # 0: wait for first, 1: wait for second, 2: wait for third

    def first(self, printFirst: 'Callable[[], None]') -> None:
        with self.condition:
            printFirst()
            self.state = 1
            self.condition.notify_all() # 唤醒所有等待的线程

    def second(self, printSecond: 'Callable[[], None]') -> None:
        with self.condition:
            while self.state != 1:
                self.condition.wait() # 等待state变为1
            printSecond()
            self.state = 2
            self.condition.notify_all()

    def third(self, printThird: 'Callable[[], None]') -> None:
        with self.condition:
            while self.state != 2:
                self.condition.wait()
            printThird()

总结：这个问题考察的是对线程同步原语 的理解。Lock 和 Semaphore 是更直接的解决方案，而 Condition 则提供了更灵活的"等待-通知"机制。作为资深开发者，应能根据场景选择最合适的工具。

1. git rebase 跟 git merge 的区别

2. git fetch 跟 git pull 的区别

3. git reset 跟 git revert 的区别

4. Python死锁是什么？如何定位Python死锁的问题？

5. Python中的pdb了解吗？怎么使用？底层的原理是什么？

6. 深度学习了解吗？

7. 讲一下目前的项目在做什么？

8. 算法题：LeetCode 146 LRU Cache

9. 算法题：LeetCode 1114. 按序打印

1. `git rebase` 跟 `git merge` 的区别

2. `git fetch` 跟 `git pull` 的区别

3. `git reset` 跟 `git revert` 的区别