Rob Pike 解释并发与并行：Go 语言中构建高效可扩展系统的核心思想与实践

gnbitcom

并发与并行的区分 [00:01:06]

Rob Pike 指出，虽然当今的编程语言似乎以面向对象为主，但现实世界本质上是并行的。从多核机器到网络再到用户交互，一切都在同时发生。然而，我们现有的计算工具在表达这种并行世界观方面并不理想。要解决这个问题，我们需要理解并发及其应用。

对并行性的普遍误解 [00:01:26]

• 许多程序员误以为并发工具意味着可以并行运行程序以加快速度。
• 这种误解常导致程序在更多处理器上运行时反而变慢。
• Rob Pike 的目标是纠正这种世界观，解释为什么并发性实际上更好。

并发的定义 [00:01:42]

• 并发是构建事物的一种方式，是独立执行事物的组合，通常是函数，但不限于此。
• 这些独立执行的事物通常表现为相互作用的进程，这里指的进程是线程、协程等概念的抽象集合。
• 它是关于同时处理许多事情的结构。

并行的定义 [00:02:13]

• 并行是多个事物同时执行，这些事物可能相关，也可能不相关。
• 它是关于同时做许多事情的执行。

并发与并行的关系 [00:02:30]

• 并发和并行是相关但相互独立的思想。
• 并发是一种组织事物的方式，以便可能利用并行性做得更好。
• 并行不是并发的目标；并发的目标是良好的结构。
• 操作系统驱动程序类比 [00:02:58]
  • 鼠标、键盘、显示器和网络驱动程序在操作系统中被管理为独立的并发事物。
  • 如果只有一个处理器，它们不是并行运行的，因为一次只有一个驱动程序在运行。
  • 这是一个并发模型，但并非固有的并行。
• 向量点积类比 [00:03:24]
  • 向量点积是一种并行任务，可以分解为微观操作，在高级计算机上并行执行。
  • 这是与并发截然不同的概念。

CSP理论与Go语言 [00:03:49]

• 为了使并发工作，需要引入通信的概念。
• Tony Hoare 在 1978 年发表的论文《Communicating Sequential Processes (CSP)》是计算机科学的经典之作。
• CSP 理论影响了 Go 语言和 Erlang 等并发语言的设计。
• Go 语言通过 goroutines、channels 和 select 语句支持并发。

搬书地鼠比喻 [00:04:29]

Rob Pike 通过一个生动的地鼠（Gopher）搬运旧 C++ 手册到焚化炉的例子，来阐述并发与并行的概念及其在系统设计中的应用。

单个地鼠效率低下 [00:04:44]

• 场景: 一个地鼠负责将一大堆旧手册从书堆搬到焚化炉。
• 问题: 只有一个地鼠，效率低下，耗时很长。

  

两个地鼠：并行但不一定并发 [00:04:58]

• 场景: 增加到两个地鼠。
• 问题: 如果只有一个独轮车和焚化炉，两个地鼠可能会相互阻碍，效率不一定会提升。
• 改进: 为每个地鼠提供一辆独轮车，并确保它们在焚化炉和书堆处协调。
  • 这将加快书籍搬运速度，但需要同步，可能发生“堵车”。

    

• 思考: 这仍然是一个并发设计，但如果一次只能有一个地鼠移动（像单核处理器），它并不是并行执行的。
• 并发设计与并行执行: 拥有两个并发事物并不意味着它们会自动并行执行，除非调度器能让它们同时工作。

并发分解与并行化 [00:06:56]

• 新的设计模式: 将搬书任务分解为更小的、独立的并发步骤。
• 流水线式并发设计:
  • 4个地鼠分工:
    1. 加载地鼠: 从书堆装载书籍到独轮车。
    2. 搬运地鼠: 搬运装满书的独轮车到焚化炉附近。
    3. 卸载地鼠: 将书从独轮车卸到焚化炉。
    4. 空车返回地鼠: 将空独轮车运回书堆。
  • 效率提升: 即使额外增加了“空车返回”的工作，通过更好的并发分工和管理，整个流程可以运行得更快。

    

• 并行化: 通过实例化更多这样的地鼠流程，可以实现任务的并行化。

多流水线并行设计 [00:09:27]

• 进一步扩展: 如果将整个流水线系统（4个地鼠、1个书堆、1个焚化炉）复制一份，形成两个独立的流水线。
• 效率提升: 这样可以同时处理两堆书籍，理论上效率提高一倍。
• 并行维度: 这展示了可以在不同维度上并行化并发设计，从而提高吞吐量。

  

• 灵活性: 即使在有 8 个地鼠工作的复杂系统中，如果只有一个处理器，设计仍然是正确且功能正常的，只是无法实现并行加速。

并发设计的优势 [00:12:17]

• 多种设计方案: 解决问题有多种并发设计方案。
• 重构与扩展: 并发设计易于重构、重新安排和在不同维度上进行扩展。
• 正确性保证: 良好的并发算法在设计上是安全且正确的，不容易出错。
• 与现实世界问题的映射: 将“书堆”替换为“Web内容”、“地鼠”替换为“CPU”、“独轮车”替换为“网络或编组代码”，“焚化炉”替换为“Web代理或浏览器”，这个地鼠模型就变成了一个 Web 服务架构。
• 易于理解: 如果地鼠能理解并发，我们也能。并发概念并不复杂，只是需要正确的工具和思维方式。

Go语言并发特性 [00:13:51]

Go语言提供了一系列内置的并发原语，使得并发编程变得简单且高效。

Goroutines [00:14:06]

• 定义: Go 协程（goroutine）类似于线程，但它们更轻量级。
• 启动方式: 在函数调用前加上 go 关键字即可启动一个 goroutine，使其在后台独立运行。
• 特点:
  • 与调用程序并发运行，无需等待其返回。
  • 非常廉价：创建和销毁成本远低于操作系统线程。
  • 动态多路复用到操作系统线程，开发者无需关心调度和阻塞。
  • 一个 goroutine 阻塞（如进行系统调用）不会阻塞其他 goroutine。
• 数量: 在 Go 程序中创建成千上万个 goroutine 是常规操作，甚至可以达到百万级别。

Channels [00:15:39]

• 定义: 通道（channels）是 goroutine 之间通信的管道，类似于 Shell 中的管道，但具有类型安全性。
• 通信方式:
  • 发送数据到通道：channel <- value
  • 从通道接收数据：value <- channel
• 阻塞特性: 默认情况下，发送和接收操作都是阻塞的，直到另一端准备好进行通信。
• 示例: 一个简单的定时器，一个 goroutine 在睡眠一段时间后向通道发送当前时间，另一个 goroutine 从通道接收这个时间。

Select 语句 [00:16:37]

• 定义: select 语句允许 goroutine 同时监听多个通道，根据哪个通道准备好通信来执行不同的代码块。
• 功能:
  • 多路复用通信：等待多个通道中的任意一个就绪。
  • 条件执行：根据哪个 case 就绪来执行相应的操作。
  • default 子句：如果所有通道都未就绪，则执行 default 块，实现非阻塞行为。
  • 随机选择：如果有多个通道同时就绪，系统会随机选择一个执行。
• 类比: 类似于编程语言中的 switch 语句，但用于通信。

Go并发的实践能力 [00:17:18]

• 成本效益: Go 协程非常便宜，栈大小可动态伸缩，从而可以轻松创建大量并发任务。
• 闭包支持: Go 语言支持闭包，这在创建匿名函数作为并发任务时非常有用。

Go语言实际案例 [00:18:22]

Rob Pike 接着通过几个 Go 语言的实际代码示例，展示了如何利用 Go 语言的并发特性来解决现实世界的编程问题。

守护进程/后台操作 [00:18:22]

• 目标: 将数据从一个输入通道复制到另一个输出通道，且不阻塞主程序。
• 实现: 使用 go func() 结合闭包创建一个 goroutine，在后台循环读取输入通道并写入输出通道。
• 通道遍历: Go 的 for range 循环可以自动遍历通道，当通道关闭且耗尽时自动退出。
• 优势: 简单、简洁，后台任务自动完成，无需显式等待。

简单负载均衡器 [00:19:04]

• 目标: 将一系列工作任务分发给多个并发工作的“工人”，并收集结果。
• 工作任务结构: 定义一个 Work 结构，包含要处理的整数值。
• 工人（Worker）定义:
  • 接收输入通道（chan Work），发送输出通道（chan Result）。
  • 在循环中从输入通道接收任务，执行计算（模拟睡眠阻塞），然后将结果发送到输出通道。
• 负载均衡器实现:
  • 创建单个输入通道和单个输出通道。
  • 启动任意数量的工人 goroutine，它们都从同一个输入通道读取，并向同一个输出通道写入。
  • 启动一个任务生成器 goroutine，向输入通道发送任务。
  • 主程序从输出通道接收所有结果。
• 优势:
  • 简洁：代码量少，易于理解。
  • 正确性：无论在单处理器还是多处理器上都能正确运行。
  • 可伸缩：通过增加工人数量即可扩展，无需显式同步（如锁）。

    

高级负载均衡器 [00:21:47]

• 目标: 构建一个更真实的负载均衡器，将请求分配给负载最小的工人，且请求可以携带用于返回结果的通道。
• 请求（Request）定义:
  • 包含一个 func() 类型，表示要执行的计算。
  • 包含一个 chan interface{} 类型，用于向请求者返回结果。
• 请求者（Requester）定义:
  • 创建一个结果通道。
  • 生成计算任务（模拟睡眠）。
  • 将请求（包含计算函数和结果通道）发送到工作通道。
  • 等待结果通道返回结果。
• 工人（Worker）定义:
  • 包含一个请求通道和待处理任务计数（表示负载），以及在堆中的索引。
  • 在循环中从请求通道接收请求，执行请求中的计算函数。
  • 将结果发送回请求中附带的结果通道。
  • 关键点: 工人直接将结果返回给请求者，不经过负载均衡器，提高了效率。

    

• 负载均衡器（Balancer）定义:
  • 包含一个工人池（使用堆实现，以便快速找到负载最小的工人）。
  • 一个 done 通道，用于工人完成任务后通知负载均衡器。
  • Balancer 的核心是一个 select 循环：
  1. 接收新请求时：从堆中取出负载最小的工人，将请求发送给它，增加该工人负载，再将其放回堆。
  2. 工人完成任务时：通过 done 通道接收通知，减少该工人负载，更新其在堆中的位置。
• 优势:
  • 可伸缩：支持任意数量的请求者和工人。
  • 正确性：设计正确，负载始终保持均匀。
  • 简洁：核心逻辑非常精简，特别是调度和完成任务的代码。
  • 无锁：整个架构没有使用显式锁或互斥量，通过通道通信和 Go 协程的调度机制自然实现同步。

    

分布式数据库查询 [00:27:54]

• 目标: 向一个复制型数据库（多个分片存储相同数据）发送查询，并返回第一个响应的结果，以提高速度和容错性。
• 实现:
  • 接收数据库连接数组和查询内容。
  • 创建一个带缓冲的结果通道，缓冲区大小等于数据库副本的数量。
  • 遍历所有数据库连接，为每个连接启动一个 goroutine。
  • 每个 goroutine 执行查询，并将结果发送到同一个结果通道。
  • 主函数阻塞并等待从结果通道接收第一个结果，然后返回。

    

• 优势:
  • 高效：只等待最快的响应，无需等待所有副本。
  • 容错：如果某个副本宕机或响应慢，不影响整体结果。
  • 简洁：短短几行代码实现了复杂的分布式查询逻辑。
  • 自然表达：利用 Go 协程并行发起请求，利用通道收集结果的天然特性实现。

总结 [00:29:59]

Rob Pike 再次强调：并发性不是并行性，但它能实现并行性，并且让并行性变得简单。

• 并发是构建事物的结构，使得程序能处理复杂和独立的部分。
• 并行是执行事物的方式，利用多个资源同时运行。
• Go语言的并发工具 (goroutines, channels, select) 让开发者能够以简洁、正确且可伸缩的方式构建系统，无需显式使用复杂的锁机制。
• 核心洞察: 专注于良好的并发设计，并行性可以作为一种“自由变量”来利用，而无需在设计阶段过度担忧。
• 推荐阅读: 视频最后提供了 Rob Pike 和其他计算机科学家的相关文章和讲座链接，以供进一步学习。