[面试题] 从京东背调失败谈Python多线程面试：交替打印字符串详解

最近在论坛上看到一个分享，有位技术同学经历了京东的五轮技术面试，成功拿到了月薪40K的Offer，却在最后的背景调查环节功亏一篑。帖子里的一句“京东背调，从来不是走个过场”引发了广泛讨论。

背景调查，本质上是用过去的经历为现在的你背书。无论是学历、项目经验还是离职原因，任何在简历上动过的“小聪明”，到了大厂严谨的背调流程前，都可能成为无法挽回的硬伤。尤其是在Java面试求职等关键环节，诚信是基本底线。此外，在公开平台对前公司的负面评价也需谨慎，因为背调的一个电话就足以重塑你在新雇主心中的形象。

Offer失而复得固然遗憾，但这也是一次重要的提醒：职场信誉需要长期积累，简历务必如实填写，在流程完全走完前切忌孤注一掷。扎实的技术功底与同样重要的职业操守，共同构成了你的职场竞争力。

算法题：交替打印字符串

昨晚加班等压测结果时，和同事聊起他刚经历的一场面试。面试官出了一道经典的并发编程题：“用Python多线程交替打印两个字符串”。题目看似简单，却足以考察对线程同步机制的深入理解。

题目要求很简单：给定两个字符串，例如 “ABC” 和 “123”，需要输出 “A1B2C3”，即字母和数字严格交替打印。

如果面试不要求多线程，单线程实现易如反掌，使用 zip 函数即可轻松合并：

def alternate_merge(s1: str, s2: str) -> str:
    res = []
    for a, b in zip(s1, s2):
        res.append(a)
        res.append(b)
    # 如果两个长度不一样，把剩下的拼上
    if len(s1) > len(s2):
        res.append(s1[len(s2):])
    elif len(s2) > len(s1):
        res.append(s2[len(s1):])
    return "".join(res)

print(alternate_merge("ABC", "123"))      # A1B2C3
print(alternate_merge("ABCD", "12"))      # A1B2CD
print(alternate_merge("AB", "12345"))     # A1B2345

这个版本是纯粹的算法/数据结构操作，时间复杂度为O(n)。但面试的难点通常在于“多线程交替打印”。

为什么多线程环境下实现交替打印会变得复杂？设想这样一个场景：

• 线程1负责打印 “ABC” 中的字母。
• 线程2负责打印 “123” 中的数字。

理想情况是线程1打印A，线程2打印1，如此交替。但在没有同步控制的情况下，线程调度由操作系统决定，输出可能变成 “ABC123” 或 “123ABC”，完全失去了“交替”的意义。

因此，这道题的核心在于：如何让两个线程有序地、轮流地执行打印操作，而非依赖不可靠的调度运气。

在Python中，实现线程同步的常见工具有 Lock、Condition、Event、Semaphore等。针对本题，两种主流思路是：

1. 使用一个共享的状态变量配合 Condition（条件变量）。
2. 使用两个 Event 对象作为信号灯，互相等待。

下面展示一个使用 Condition 的清晰实现版本。其核心思路是：

• 定义一个 turn 变量，标识当前轮到哪个线程打印（例如 “letter” 或 “digit”）。
• 两个线程共享同一个 Condition 对象，在不该自己打印时调用 wait() 进入等待。
• 当轮到自己时，打印一个字符，更改 turn 状态，并调用 notify_all() 唤醒等待的线程。

具体代码如下：

import threading

class AlternatingPrinter:
    def __init__(self):
        # 条件变量，内部自带一把锁
        self.cond = threading.Condition()
        # 一开始先让字母线程先打印
        self.turn = "letter"

    def print_letters(self, s: str):
        for ch in s:
            with self.cond:
                # 不是我这回合，我就老老实实等
                while self.turn != "letter":
                    self.cond.wait()
                # 轮到我了，打印一个
                print(ch, end="", flush=True)
                # 轮到数字线程
                self.turn = "digit"
                # 唤醒对方
                self.cond.notify_all()

    def print_digits(self, s: str):
        for ch in s:
            with self.cond:
                while self.turn != "digit":
                    self.cond.wait()
                print(ch, end="", flush=True)
                self.turn = "letter"
                self.cond.notify_all()

if __name__ == "__main__":
    printer = AlternatingPrinter()
    t1 = threading.Thread(target=printer.print_letters, args=("ABC",))
    t2 = threading.Thread(target=printer.print_digits, args=("123",))

    t1.start()
    t2.start()

    t1.join()
    t2.join()
    print()  # 换行

运行上述代码，输出结果应为 A1B2C3。面试官可能会针对代码细节进行追问，以下几点可以作为你的回答储备：

• 为什么用 while 检查条件而不是 if？ 这是为了防止“虚假唤醒”（spurious wakeup）。线程被唤醒后，条件不一定真正满足，因此需要用 while 循环再次检查，这是使用 Condition 的标准模式。
• 为什么使用 with self.cond:？ Condition 对象内部基于锁（Lock）实现。with self.cond: 语句会自动获取和释放这把锁，确保检查 turn、打印、修改 turn 这一系列操作是原子的，防止数据竞争。
• 为什么打印时设置 flush=True？ 这是为了确保输出立即显示，避免因标准输出缓冲导致打印顺序在视觉上错乱，尤其是在某些交互式环境或日志中。

如果面试官问及字符串长度不等的情况，可以这样回应：“当前实现默认两字符串等长。若长度不同，可在交替打印完较短字符串后，让剩余字符的线程直接打印完尾部。这需要对同步协议进行小幅调整，避免死锁。” 展示你考虑到了边界情况即可。

一个常见的错误实现是仅靠两个独立的线程函数，幻想操作系统会“自然”地交替调度：

def print_letters():
    for ch in "ABC":
        print(ch, end="")

def print_digits():
    for ch in "123":
        print(ch, end="")
# 启动两个线程...

这种写法完全依赖不可控的线程调度，在生产环境中是极不可靠的。真正健壮的交替打印，必须依靠明确的同步原语进行控制。

总结一下，这道“交替打印字符串”的题目考察点非常全面：

• 基础版：考察字符串操作和基本算法思维。
• 进阶版（多线程）：深入考察对线程同步机制（如 Condition、Event）的理解与应用能力，以及解决并发竞争问题的实战经验。

掌握这个问题的多种解法，不仅能让你在面试中从容应对，也能加深对Python并发编程模型的理解。在云栈社区的技术论坛中，你可以找到更多关于并发编程的深度讨论和实战案例，与更多开发者一起交流成长。