Saša Jurić指BEAM运行时打破高可用微服务神话

The Soul of Erlang and Elixir • Sasa Juric • GOTO 2019 — GOTO Conferences

GOTO Conferences

通过将调度、故障隔离与状态分布直接内建于虚拟机底层,BEAM消除了将系统拆分为复杂外部中间件与碎片化工具链的人为工程妥协。

AI-assisted summary of The Soul of Erlang and Elixir • Sasa Juric • GOTO 2019 — original source. Check the original for full context.

Source published:

Key ideas

  • BEAM 虚拟机将 Erlang/Elixir 系统精简为单一操作系统进程,内部支持派生数百万级轻量进程,且天然具备微秒级抢占式调度以实现延迟隔离。 (6:00)
  • 通过解耦长连接进程与一次性计算进程,系统在遭遇代码未捕获异常或 CPU 密集型长任务时,背景每秒万次请求的吞吐量保持完全稳定。 (12:40)
  • BEAM 原生提供基于 Reductions 指标的运行时内省与一等公民取消机制(Process.exit(pid, :kill)),支持在无外部工具干预下精准排查并热修复线上故障。 (20:11)
  • 借助 Swarm 等编排库与位置透明的 PID 特性,系统仅需三行代码即可实现具备故障转移与服务注册的分布式集群,免去笨重的外部中间件胶水层。 (35:13)

Detailed notes

## Background 该视频由 GOTO Conferences 于 2019 年 5 月 22 日在 YouTube 平台发布,记录了《Elixir in Action》作者 Saša Jurić 在 GOTO Chicago 2019 大会上的演讲。视频简介指出,演讲超越了表层语法和生态,聚焦于 Erlang 与 Elixir 的底层并发模型与高可用特性,旨在帮助有经验的后端开发者理解如何利用它们快速构建从小型网站到超大规模分布式系统的服务端应用。

## TL;DR Saša Jurić 深入剖析了 Erlang 与 Elixir 的底层基石——BEAM 虚拟机的并发架构与运行机制。他通过生动的现场 Demo 演示了单调度器环境下 10,000 个轻量级进程的并发运行,展示了 BEAM 进程如何实现近乎完美的故障隔离、微秒级抢占式调度以及运行期内省与热代码修复。随后,他展示了原生分布式能力与位置透明性,并对比了现代拼凑式微服务与“技术单一性”架构的差异。最后他指出,BEAM 彻底消除了“敏捷起步原型”与“支撑长远海量扩展”之间的对立,是构建高可用系统的真正灵魂。

## Atmosphere & style 整场演讲节奏紧凑且干货密集,讲者充满激情与感染力,开篇对 Joe Armstrong 的致敬更是奠定了一层由衷敬佩的情感底色。在技术演示环节,气氛在面对失控死循环与线上告警的紧张排错中推向高潮,讲者戴上“运维帽子”现场远程取证、强制杀进程并热部署修复代码的过程令人拍案叫绝。观众不仅能感受到资深工程师对工业级架构的深刻洞察,更能体会到那种从复杂运维泥潭中解脱出来的纯粹快乐。

## Bulletin - [06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) BEAM 虚拟机将 Erlang/Elixir 系统精简为单一操作系统进程,内部支持派生数百万级轻量进程,且天然具备微秒级抢占式调度以实现延迟隔离。 - [12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) 通过解耦长连接进程与一次性计算进程,系统在遭遇代码未捕获异常或 CPU 密集型长任务时,背景每秒万次请求的吞吐量保持完全稳定。 - [20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) BEAM 原生提供基于 Reductions 指标的运行时内省与一等公民取消机制(Process.exit(pid, :kill)),支持在无外部工具干预下精准排查并热修复线上故障。 - [35:13](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2113s) 借助 Swarm 等编排库与位置透明的 PID 特性,系统仅需三行代码即可实现具备故障转移与服务注册的分布式集群,免去笨重的外部中间件胶水层。

## Key takeaways - [00:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=0s) Erlang 与 Elixir 的核心竞争力不在于表层语法,而在于底层统一的 BEAM 虚拟机的并发模型与运行时机制。 - [02:46](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=166s) BEAM 进程是拥有独立内存堆栈与独立垃圾回收的顺序执行上下文,各进程间纯粹依靠异步消息传递进行交互。 - [06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) BEAM 将系统整体封装在单一 OS 进程中,通过与 CPU 核心绑定的调度器管理海量轻量进程,技术上限可承载数以亿计的并发单元。 - [10:24](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=624s) 将 WebSocket 连接与运算任务拆解为双层进程拓扑,可有效阻断未捕获异常对网络连接及全局系统的连锁破坏。 - [15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) BEAM 调度器基于指令规约数(Reductions)在极短时间片内强制抢占,牺牲单任务极致性能以换取全系统的公平响应与延迟隔离。 - [17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) 高可用性的本质不在于盲目追求“几个9”的抽象数字,而在于即使系统发生局部故障也能持续陪伴并服务用户。 - [20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) BEAM 具备出色的生产内省能力,运维人员无需重启或预设探针,即可通过 IEx Shell 对生产节点进行动态诊断与 top 分析。 - [23:42](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1422s) Process.exit(pid, :kill) 构成了运行时底层的一等公民取消机制,能瞬间终止脱缰死循环而不干扰其他正常业务事务。 - [26:29](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1589s) BEAM 支持零停机热代码替换,允许修复模块在不停机、不掉线的情况下动态加载并即时生效。 - [29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) BEAM 原生打通了单机并发与分布式边界,通过位置透明的 PID 实现跨节点透明调用与自动故障转移。 - [36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) “技术单一性”主张通过统一的图灵完备语言与运行时覆盖全栈需求,大幅替代拼凑式架构中的碎片化中间件与细分专家壁垒。 - [40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) BEAM 消除了“轻量快速启动工具”与“超大规模长远演进系统”之间的伪权衡,使敏捷开发与高可用架构在同一选型下得以兼得。

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=0s) 致敬 Joe Armstrong 与寻找 BEAM 语言的“灵魂”

演讲在掌声中开始。讲者 Saša Jurić 首先向刚逝世不久的 Erlang 主要发明者 Joe Armstrong 致以深切的哀悼与崇高的敬意。他感慨道,虽然 Joe 离开了人世,但他留下的思想和技术遗产依旧熠熠生辉,今天整个演讲所探讨的内容,归根结底都建立在 Joe Armstrong 对计算机科学领域的巨大贡献之上。谈到个人经历时,Saša Jurić 充满感情地表示,自己在相当长一段时间内都在使用 Erlang 和 Elixir,这毫无疑问是他整个职业生涯中最享受、最开心的阶段,因此他希望通过这场演讲,将这份快乐传递给大家,解释自己为什么对这些语言如此着迷。

```mermaid flowchart TD accTitle: BEAM Runtime Architecture accDescr: High-level architectural mapping showing how multiple languages compile to run on the unified BEAM runtime layer inside a single OS process.

subgraph Languages["上层开发语言与代码实现"] direction LR L1["Erlang"] L2["Elixir"] L3["其他 BEAM 语言"] end

subgraph BEAM["统一运行层:BEAM / Erlang 虚拟机"] VM["BEAM 虚拟化执行环境"] end

subgraph OperatingSystem["底层操作系统环境"] OSProcess["单一操作系统进程 (Single OS Process)"] end

Languages -->|"统一接口与语义"| VM VM -->|"运行于宿主系统"| OSProcess ```

他将本次演讲的主题定为寻找 Erlang 与 Elixir 的“灵魂”。虽然市面上看起来是两种甚至更多的语言,但讲者指出,他完全可以“买一送一”,因为本次探讨的核心不是表层的语法差异,而是底层的统一运行时——也就是 Erlang 虚拟机(通常称为 BEAM)。从使用者的角度和编写 BEAM 系统的开发者视角来看,所有语言都只是与 BEAM 交互、借用其威力的接口。因此他在演讲中可能会混用这些名字,有时说 Elixir(因为现场所有的演示 Demo 和代码示例都是用 Elixir 编写的),有时说 Erlang,但他真正指代的其实是任何运行在 BEAM 之上的语言。

- 整个演讲结构划分为清晰的三大部分: 1. 基础理论部分:介绍 BEAM 并发的核心原理与底层机制。 2. 核心演示部分:基于生动的实战 Demo,演示如何将一个系统拆分成不同的并发单元,并深入探讨这种架构设计带来的收益。 3. 观点探讨部分:抛出一个简短且略带颠覆性的思想实验,探讨一种与当今主流软件构建方式背道而驰的新型架构风格——这是一种依托 BEAM 运行时才得以成立的架构方式,讲者坚信它比当今行业盛行的构建方案更加简单,同时也更强大灵活。

Saša Jurić 坦言自己的议程安排非常宏大,而演讲时间十分紧迫,因此他提前向全场打好招呼,表示自己会讲得非常快,希望能为所有人带来大量值得思考的技术干货。

---

[02:46](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=166s) BEAM 并发模型的基石:轻量级进程与消息传递

讲者切入正题,正式剖析 Joe Armstrong 心中构想的“BEAM 风格并发”(BEAM-style concurrency)。该模型的核心基石是被称为“进程”(Process)的概念。在 BEAM 的术语中,进程是代码在运行时的执行上下文,任何 Elixir 代码在运行状态下都必然从属于某一个进程。

Saša Jurić 特别强调,必须纠正初学者的概念混淆:这里的进程既不是操作系统的 OS 进程,也不是操作系统的 OS 线程。从本质上讲,一个 BEAM 进程就是一个完全顺序执行的单线程程序(Sequential Program),进程内部没有任何并发机制。在其中,开发者按最传统的方式写代码——调用函数、传递参数、获取返回值、执行条件分支逻辑、写循环等。只要局限在单个顺序执行的范畴内,Elixir 展现出的是某种定义下的函数式编程特性;而一旦涉及跨进程的交互,就进入了该语言的另一个核心范式——并发。

要实现并发,就必须启动多个进程。Elixir 标准库提供了最底层的原语函数 `spawn`。当一个正在运行的顺序程序调用 `spawn` 并传入一个匿名函数(Lambda)时,系统就会立即派生出一个全新的进程。一旦新进程启动完成,调用方的进程立刻继续向下执行。在概念模型上,此时就有了两个完全独立、互不相干的程序在并行运行。

讲者用极其强调的语气总结这两个进程之间的完全隔离性:

> “They have their own separate execution flow, they have their own separate memory space (stack, heap), they are separately garbage collected at different points in time, and they are really completely two separate programs.” > —— *Saša Jurić*

由于两者没有任何共享内存,彼此协作的唯一途径就是通过发送消息,即基于消息传递的并发(Message Passing Concurrency)。在语言底层,开发者可以通过 `send` 函数向指定的目标进程发送消息。这里的消息可以是 Elixir 中能够构建的任意数据项(Term)。在接收端,目标进程则从自己的邮箱(Mailbox,一个类似先进先出 FIFO 的队列)中拉取消息并进行处理。

```mermaid flowchart LR accTitle: BEAM Process Message Passing accDescr: Sequence showing Process A sending an arbitrary data message into Process B's FIFO mailbox.

subgraph ProcessA["进程 A (顺序程序)"] ExecA["调用 send(PID, 消息)"] end

subgraph ProcessB["进程 B (顺序程序)"] Mailbox["进程邮箱 (FIFO Queue)"] ExecB["拉取消息并执行处理"] end

ExecA -->|"异步发送消息数据"| Mailbox Mailbox --> ExecB ```

为了帮助现场听众建立直观类比,Saša Jurić 将这种模式比作“微服务架构”(Microservices):正如微服务之间是两个相互独立的 OS 进程,没有共享状态,只能通过 HTTP 等网络请求进行通信;BEAM 进程也是两个完全独立的程序,通过消息交流。但最大的颠覆在于:BEAM 内部没有网络开销,没有复杂的 HTTP 协议封装,不需要反反复复的对象序列化与反序列化,这种隔离机制直接由语言底层和运行时本身提供原生支持。当现场有听众提问如何定位目标时,讲者简要回应,每个进程都有唯一的进程标识符(Process ID / PID),可以据此进行寻址与引用。

---

[06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) 运行时底层调度机制与万级并发 Demo 启动

解释完概念之后,讲者进一步揭开 BEAM 在底层的运行真相。当开发者在 Elixir 中写完系统源码并输入一条启动命令时,操作系统层面实际上只启动了一个单一的操作系统进程(Single OS Process),即运行了一个 Erlang 虚拟机(BEAM)实例。整个庞大的分布式或服务端系统,在底层就驻留在这个单一 OS 进程内。

在这个 OS 进程中,开发者可以随心所欲地利用代码 `spawn` 产生海量的轻量级进程。这些进程启动速度极快,内存开销微乎其微。开发者完全不需要节制,可以在系统内部轻松运行数千、数十万甚至数百万个进程;BEAM 虚拟机自身施加的技术上限甚至高达约 1.3 亿个进程。

在虚拟机的多核利用与调度方面,BEAM 的内部设计非常精巧: - 虚拟机在底层会启用若干个名为调度器(Schedulers)的操作系统线程。 - 默认情况下,BEAM 会严格按照硬件环境,为每个可用的 CPU 核心绑定分配一个专属的调度器线程。 - 调度器负责具体执行这些轻量级进程的代码。一个通俗但不失本质的理解模型是:假设后台存在一个等待执行的进程队列,每个调度器从队列头部取出一个进程,让其运行一段极微小的时间片,随后将其放回队列尾部,接着处理下一个进程,如此循环往复。

为了向听众展示这种并发并非空中楼阁,讲者切入准备好的实战 Demo。他提前在本地机器上将一个用 Elixir 开发的小型演示系统作为后台服务(Headless Daemon)启动。他强调,这个服务的启动配置方式与真实生产环境完全一致,它是一个完全独立的单一 BEAM OS 进程,没有任何外部辅助支撑组件。

随后,讲者打开系统内置的 Web 仪表盘(Dashboard),准备通过手动触发后台任务来模拟合成负载(Synthetic Load)。在底层设计中,系统中的每一个任务(Job)都是一个完全独立的轻量级进程。讲者在控制界面上点击启动按钮,仅仅在一秒钟之内,仪表盘上的活跃进程数直接飙升,10,000 个独立的轻量级并发进程瞬间在后台全速运转起来。

每个进程都在执行一个无限循环(Infinite Loop);在每一次循环中,它们都会执行一小段 CPU 密集型计算来制造真实算力负载,随后向一个预先设定好的知名进程发送通信消息。即使面对瞬间创建的万级并发程序,单一 BEAM 节点依然举重若轻地并行处理着所有任务。

[08:45](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=525s) 监控面板与单调度器压力环境

演示系统的指标仪表板上正在实时展示系统的运行状态。系统内部设计了一个单例且全局寻址的进程,该进程在每次迭代中标记一次操作成功,随后休眠整整一秒并循环往复;同时有若干辅助进程负责收集指标数据,并通过 WebSocket 推送给任何打开此页面的用户。

左侧图表显示了每秒成功操作数(successes per second),当前维持在预期的 10,000 次/秒(10K/s)左右。图表线条并非完全平直,而是伴随着轻微振荡。产生波动的原因有两个:一是内部逻辑并未严格同步;二是演示所用的单台机器配置相对普通,除了承载服务端系统外,浏览器还在高频利用 SVG 渲染动态图表,从而占用了一部分计算资源。

该系统被刻意配置为仅运行一个调度器线程(Scheduler Thread)。在当前的四核宿主机上,BEAM 默认会启动四个调度器,但为了使演示效果更加直观极端,演讲者将其硬编码限制为单个调度器线程。这意味着所有进程都在模拟单核 CPU 环境下的并发竞争。右侧负载图表显示,单调度器在 10K/s 负载下的 CPU 占用率仅在 20% 左右,系统尚有充足的余量。

- **基准吞吐量**:维持在约 10,000 次成功操作/秒(10K successes per second)。 - **调度器配置**:默认可利用宿主机 4 个核心,被强制限定为 1 个调度器线程,以模拟单核环境。 - **基准负载占用**:在维持 10K/s 吞吐的情况下,单调度器的 CPU 占用率仅约 20%。

---

[10:24](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=624s) 页面交互模型与双层进程架构

在合成用户(Synthetic Users)以 10K/s 频率产生背景流量的同时,演讲者打开了一个供真实用户访问的 Web 界面。这个界面极为朴素,却概括了所有 Web 系统的核心本质:用户输入数据,系统消化计算,再将结果输出。该页面的具体功能是输入一个正整数 $n$,系统计算前 $n$ 个自然数的累加和(例如输入 3 计算 $1+2+3=6$,输入 4 计算 $1+2+3+4=10$)。

支撑该功能的底层进程拓扑具有精细的分工结构。浏览器与后台建立长连接 WebSocket,所有用户交互均通过该通道进行。每条活跃的 WebSocket 连接均对应一个由系统动态派生的连接进程(Connection Process)。如果同时有 3 位用户在线,系统内就存在 3 个连接进程;若有 100 万用户在线,系统便生成 100 万个连接进程;若无人在席,数量归零。

计算任务并没有直接放在连接进程内执行。每当用户提交请求,连接进程都会单独派生一个专职的、一次性的“计算进程”(Calculation Process / Task)。计算进程完成运算后,将结果异步发送回连接进程,连接进程再推送到浏览器渲染,而计算进程随即正常退出并销毁。

```mermaid flowchart TD accTitle: 用户交互与进程生命周期架构 accDescr: 展示浏览器通过 WebSocket 连接到独立的连接进程,连接进程动态派生一次性计算进程并回收结果的流程。

subgraph BrowserClient["客户端浏览器"] UI["用户界面 (输入 / 结果渲染)"] end

subgraph BeamRuntime["BEAM 运行时"] ConnProc["连接进程 (Connection Process)<br/>随 WebSocket 长期存活"] CalcProc["计算进程 (Calculation Process / Task)<br/>一次性、算完即销毁"] end

UI -->|"1. WebSocket 提交自然数 N"| ConnProc ConnProc -->|"2. 动态派生 (Spawn)"| CalcProc CalcProc -->|"3. 累加计算并回传消息"| ConnProc ConnProc -->|"4. 推送计算结果"| UI CalcProc -.->|"5. 正常退出终止"| Terminate(["销毁回收"]) ```

---

[12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) 故障隔离:单进程崩溃不波及系统

之所以采取连接进程与计算进程分离的设计,最根本的目标是提高系统的容错能力(Fault Tolerance)与高可用性(High Availability)。真实生产环境中总会隐藏各样错误,演讲者演示了最常见的一类缺陷:业务逻辑未能覆盖边缘分支,导致服务端抛出未捕获的运行时异常(如被零除、负数求平方根或“undefined is not a function”)。

在此演示中,数字 13 被预设为会触发崩溃的异常输入。当用户提交 13 时,前端界面提示了错误信息。通过查看后台以独立服务运行的系统日志,可以观察到明确的崩溃记录:一个名为 `Task` 的组件异常终止。这意味着专职负责该次求和的“计算进程”已经崩溃挂掉,但整个系统的运行并没有中断。

Saša Jurić 强调了 BEAM 错误隔离机制的核心特质:

> “Now an important thing about BEAM is that when a process crashes, everything else progresses, right? So most of the system still works.”

即使连续不断地提交 13 触发异常,控制台频繁抛出错误日志,左侧监控大盘上的背景吞吐量仍然稳稳保持在 10K/s。同时,进程的崩溃绝非悄无声息。BEAM 允许其他进程监听或监控其生命周期;计算进程崩溃时,连接进程收到了一条结构化退出消息(指出“进程 Foo 因原因 Bar 死亡”),因而连接进程得以在保持 WebSocket 不断开的前提下,将友好的错误提示推送回客户端。

- **崩溃现象**:计算进程在遭遇未处理异常时直接挂掉(Task termination),由日志捕获错误堆栈。 - **稳定性保障**:后台 10,000 次/秒的操作未受波及,系统其他用户的并发事务正常推进。 - **消息感知机制**:连接进程通过进程间消息感知下游崩溃,从而向 UI 正确反馈错误信息,而不会导致网络连接掉线。

---

[15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) 延迟隔离与抢占式调度的公平机制

进程不仅能够隔离错误,更能“隔离延迟”(Separate Latencies)。为了验证这一点,演讲者展示了系统内的另一个缺陷:求和计算采用了一种极其低效、纯 CPU 绑定的暴力循环实现(从 1 循环累加至 $n$),没有任何公式化优化。

当输入一个巨大的数值(9 个 9:`999,999,999`)时,计算进程陷入了长达约 10 秒的纯 CPU 密集型循环。监控面板显示,单核调度器的 CPU 使用率瞬间被打满到 100%。在常规的单线程协作式系统或事件循环系统中,这类耗时任务必然会阻塞整个主线程,导致背景任务与网络 I/O 陷入停滞。然而,在该单调度器系统中,背景的 10K/s 吞吐量曲线依旧保持平稳,没有发生断崖式下跌。

这得益于 BEAM 调度器具备微秒级的真正抢占式调度能力(Preemption)。无论进程在执行 I/O 操作还是密集的 CPU 计算,调度器都会在极小的时间片(通常小于 1 毫秒)内强制执行上下文切换。关于这种设计取舍,Saša Jurić 总结道:

> “BEAM essentially favors a fair distribution of CPU time for every single activity in the system, or in other words, it promotes the progress of the system as a whole at the expense of the maximum efficiency of any single activity in the system.”

BEAM 不追求让单个计算任务以极限速度跑完,而是将全系统的整体向前推进置于首位。这种牺牲单任务极致性能来换取全系统响应度与公平性的调度模型,精确切中了并发多用户 Web 系统的运行本质。

- **暴力计算规模**:输入数值为 9 个 9($999,999,999$),造成约 10 秒的纯 CPU 循环消耗。 - **调度开销与时间片**:调度器在上百万个 Reductions(指令消耗计数)基准下切分时间片,上下文切换间隔小于 1 毫秒(< 1 ms)。 - **抢占特质**:实现真正的抢占式多任务,CPU 密集型进程无法独占执行资源,避免了由单点繁重计算引发的系统级高延迟。

[17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) 高可用性的本质:在故障与重算中保证系统前行

Saša Jurić 强调,把系统拆分成独立进程并将故障隔离与延迟隔离绑定在一起,是构建高可用架构的核心所在。他在演示中作为单一用户输入了高 CPU 消耗的计算任务(输入 `456789`),随后展示出连接依然可用,甚至可以继续输入其他数据并制造一批错误。令人惊叹的是,整个大盘依然保持着对其他用户的稳定推进,当前受测用户自身也保持着稳定响应,而后台那个漫长的密集计算任务最终也顺利完成。这种即使生产环境发生各种局部问题、依然能够牢牢掌控局面的表现,正是健壮系统的典范。Saša 形象地比喻道:尽管船体被凿穿了几个洞,但整艘船依然平稳航行,没有沉没,并且继续为绝大多数用户提供服务。

Saša Jurić 深刻地指出:“This in my mind is what high availability is about it's not about chasing some mythical amount of nines of uptime it's about having a system which is there for its users which is ultimately its primary if not the only purpose.”(在我看来,这就是高可用性的真正意义所在:它不是去盲目追逐某种虚无缥缈的‘几个9’的正常运行时间指标,而是要让系统始终能够陪伴并服务它的用户——这终究是系统最核心甚至是唯一的目的。)

```mermaid flowchart TD accTitle: BeamProcessIsolationArchitecture accDescr: 架构图展示了一个重度计算任务或故障请求如何被限制在独立子进程中,而不影响全局调度器和其他用户的处理。

subgraph UserSpace["用户交互层"] U1["当前测试用户"] U2["其他系统用户 (10k 请求/秒)"] end

subgraph BeamRuntime["BEAM 运行时环境"] ConnProc["当前用户连接进程 (PID)"] CalcProc["重度计算 / 故障计算进程"] OtherProc["成千上万个轻量进程"] end

U1 -->|"发送复杂计算 / 触发错误"| ConnProc ConnProc -->|"隔离派发计算"| CalcProc U2 -->|"常规业务交互"| OtherProc OtherProc -->|"正常稳定处理"| BeamRuntime ```

---

[18:44](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1124s) 恶性隐患:负数输入引发的失控死循环

即便系统具备高可用弹性,线上遗留的隐蔽缺陷若不排除,依然可能威胁到整个系统的存亡。Saša 现场输入了一个负数 `-1`,展示了这类极具杀伤力的隐患。系统在业务逻辑上本就不应接受这种非法的值域输入,但一旦接收并进入计算,由于代码缺陷,它迟迟无法返回结果。观察监控调度器可以看到,CPU 使用率瞬间被持续拉满到 100%。这个操作直接演变成了一个失控的(rogue)CPU 密集型死循环,相当于执行了无休止的 `while(true);`。

得益于 BEAM 进程调度的优越性,系统依然展现出强大的韧性:在单线程调度器跑满的情况下,系统面向其他用户的吞吐依然保持在每秒 10,000 次成功的基准线。然而这只是一时的侥幸。如果用户因没有收到结果而反复重试,或者其他用户也踩中同样的负数边界条件,系统最终会被这些空转的死循环拖垮,彻底陷入瘫痪。因此,运维人员必须具备在系统完全崩溃前快速定位并排查此类隐形炸弹的能力。

---

[20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) 穿透黑盒:利用 BEAM 运行时内省与可观测性快速诊断

为了还原真实的排错场景,Saša 戴上“运维人员的帽子”,假定自己并不知道刚才发生的操作,只是收到了 CPU 飙升至 100% 的线上告警。他通过 SSH 登录到服务器查看日志,但日志一片死寂,只有之前测试数字 13 时的旧错误记录,对于眼前这个无任何输出的无限循环完全没有帮助。

此时 BEAM 的核心优势显露无遗:它是一个高度具备可调试性(debuggable)、内省性(inspectable)和可观测性(observable)的运行时系统。开发者无需在启动时预设特殊调试标志,也无需重启系统,就能直接接入正在生产运行的节点进行动态探查。Saša 执行了远程控制台命令,打开了一个连接到线上生产环境的 IEx(Interactive Elixir)Shell 会话。在这个仅有一个调度线程(单核运行)、负载跑满且并发处理着每秒 10,000 次请求的系统里,运维人员执行的代码依然被平稳调度。

- **获取全局进程**:通过调用 `Process.list()`,列出当前系统中所有轻量进程的 PID(Process ID)。 - **进程指标内省**:通过 `Process.info(pid)` 查询特定进程属性,其中最为核心的指标是 `reductions`(规约数)。 - **Reductions 原理**:这是一个非负整数,大致等同于进程自诞生以来执行的虚拟机指令数量。要找出最消耗 CPU 的“罪魁祸首”,只需计算两个时间点之间各进程 reduction 计数的增量差值,再倒序排列即可获得类似操作系统 `top` 的视图。 - **定位元凶**:Saša 运行了预先封装的工具函数 `runtime.top()`,立刻获取到过去一秒内 CPU 占用最高的前十个进程。排名第一的进程(PID 如 `0.12605.0`)占用了绝大部分 CPU;再次运行验证,该 PID 依然稳居榜首,确凿无疑为消耗资源的失控进程。

---

[23:42](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1422s) 运行时取证与一级取消机制:`Process.exit(pid, :kill)` 的威力

锁定恶意进程后,即使它是一个陷入死循环、不让出时间片、不响应任何消息的脱缰程序,BEAM 运行时仍能从外部强行读取其状态。Saša 将该异常进程的 PID 存入变量,调用 `Process.info(pid,:current_stacktrace)` 直接拉取其当前的调用堆栈轨迹,随后又运行了辅助函数 `runtime.trace()`,在最多 1 秒或 50 次调用的限制下,动态捕获该进程正在执行的函数调用轨迹。

取证完成后,Saša 直接调用标准库中的终止函数对该死循环进程进行清理:

```elixir Process.exit(pid,:kill) ```

指令刚一敲下,仪表盘上的 CPU 调度使用率瞬间断崖式下跌,恢复至正常水准,而整个系统每秒 10,000 次的业务处理丝毫不受干扰。与此同时,在前台用户界面上,用户立刻收到了计算失败的报错通知。这是因为虽然执行计算的子进程被底层的 `:kill` 强行处决(类似 BEAM 级别的 `kill -9`,无法被代码内的 `try-catch` 拦截),但负责网络连接的进程依然活着,它接收到了子进程夭折的退出信号,从而能够体面地向客户端派发异常提示。

Saša 评价道:“This process exiting it's like a seemingly simple thing but one which is as far as I know exclusive to BEAM in terms of guarantees this is essentially a first-class cancellation implemented at the runtime layer.”(这种进程退出看似是一件微不足道的小事,但就其所能提供的保障而言,据我所知是 BEAM 所独有的——这本质上是运行时底层所实现的一等公民级别的取消机制。)无论是通过交互式终端介入,还是在代码中使用高阶抽象实现超时取消或用户主动取消,这种由底层保障的强力取消机制都只需要极少的代码就能发挥极其惊人的威力。随后,他将注意力转回刚才抓取的栈帧与模块轨迹数据,展开具体的代码级根因分析。

[26:29](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1589s) 深入崩溃现场与热代码修复

```mermaid flowchart TD accTitle: 热代码修复流程图 accDescr: 展示从系统边界拦截错误、修复算法问题到热升级生产环境的完整流程。

subgraph Edge ["系统边界 (边界拦截)"] A["客户端请求"] --> B["输入校验 (系统边缘)"] B -->|"非法输入 (-1, 0, 123)"| C["直接丢弃并返回 invalid input"] end

subgraph Core ["业务核心层 (问题修复)"] B -->|"正整数输入"| D["高斯求和算法 n*(n+1)/2"] D --> E["解决数字 13 的边界问题"] E --> F["单元测试全部通过"] end

subgraph Deploy ["热部署到生产环境"] F --> G["执行自动化任务编译模块"] G --> H["无缝热替换 BEAM 代码"] H --> I["生产环境吞吐保持 10k req/s (零停机)"] end ```

通过堆栈追踪(Stack Trace)定位到具体的文件和行号后,Saša Jurić 开始结合运行时的动态视图剖析故障原因。该进程陷入了无尽的递归调用(在函数式编程中,恒等递归即等同于死循环)。通过逐帧观察循环参数的变化,他发现第一个参数每次递增 1,第二个参数每次递减 1,而第三个参数则按一定规律持续攀升。代码深处的这个函数默认输入必须是正整数,一旦传入负数或不满足约定的数据,就会引发无限递归。

在业务领域模型中,这部分代码处于系统较深的位置,假设处理的都是自然数并没有逻辑错误。真正的问题在于系统的边缘——即接收用户输入的地方——缺乏足够严格的校验,导致无效数据层层穿透进入核心。为了解决这些累积的问题,Saša 现场修复了代码:在边缘取消了防御性校验的注释以拦截负数;修复了导致数字 13 报错的边界缺陷;并运用高中数学的高斯求和公式(`n * (n + 1) / 2`)彻底取代原先效率低下的求和实现。

在所有本地自动化测试验证通过后,Saša 运行了一个专用的热部署脚本。该脚本重新编译了两个模块,并在不重启生产进程的前提下,将新代码动态加载到运行中的系统。监控仪表盘上的指标表明,系统在代码加载期间未受丝毫干扰,依然以每秒 10,000 次成功的稳定速率处理流量。在前端页面无需刷新的情况下,负数和零被即时判定为非法输入,数字 13 顺利得出结果,而一长串极大数字的求和也在瞬间完成。

> “Essentially what happened here: we had a system with problems, and it was staying on top of the game, and it allowed me to approach it, the system, and look from inside it to figure out what the problems are, but I was able to quickly fix those problems and deployed into production without disturbing anything in the system itself, right, the other activities.” — Saša Jurić

- **诊断信息提取**:从单条崩溃进程的状态不仅能查明所在函数与行号,还能还原每一次递归迭代所接收的具体参数值。 - **架构原则**:边缘负责严格的数据过滤,内部业务领域则专注合法实体的核心逻辑。 - **零停机动态加载**:BEAM 允许在单机运行时中并行存在旧版本与新版本的代码模块,实现平滑过渡且不中断正在处理的网络连接与计算任务。

---

[29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) BEAM 集群与分布式原生并发

BEAM 不仅在单机多核上表现优异,其底层对分布式系统也具备开箱即用的支持。开发者可以在单台机器或跨独立物理机/虚拟机启动多个 BEAM 节点(Node)。仅需调用一个简单的原生函数,即可在两个节点之间建立底层的 TCP 连接,从而组成一个原生的 BEAM 集群。

在形成集群后,Erlang 和 Elixir 为开发者提供了极具吸引力的编程能力:开发者可以枚举集群内的全部节点、动态监听节点的加入(Join)与脱离(Leave)事件,并且可以在任意指定节点上生成进程,甚至完全跨节点透明地发送与接收消息。在 BEAM 的哲学体系中,单机并发与分布式在语义和抽象上是等同的,开发者编写分布式通信的代码与在单机内向某个进程收发消息几乎毫无区别。

Saša 通过一个服务注册仪表盘演示了分布式特性的工作方式。在界面上启动一个名为 `node2` 的前台节点后,集群立即感应到了新成员。当在 UI 中创建全局命名的服务(在 BEAM 中本质上就是一个被赋予集群级名称的独立进程)`foo` 时,系统自动在某一个节点上实例化了该进程。点击查询时,客户端向集群发起消息调用,该进程捕获自身的状态、获取所宿留的节点名称并将数据打包响应。接着创建的服务 `bar` 则被调度到另一个节点上运行,展示了简单的集群负载均衡。

为了展示机器宕机时的容错能力,Saša 直接在终端终止了 `node2` 的运行。仪表盘上的视图随之改变:原本存活在 `node2` 上的 `bar` 进程被系统感知丢失,并立刻在依然存活的 `node1` 上复活,再次向该服务发送请求时,响应的提供方已自动切换为 `node1`。

> “Because in fact in BEAM, concurrency and distribution are one and the same thing.” — Saša Jurić

- **节点互联机制**:多个虚拟机实例之间通过单条长连接构成全互联网络拓扑(Full Mesh)。 - **进程位置透明性**:向进程发送消息或注册名称不需要硬编码目标 IP 或端口,底层分发由虚拟机和集群协议自动路由。 - **高可用故障转移**:当某个 BEAM 节点宕机断网时,其余节点会迅速触发事件钩子,支持关键状态自动重构与恢复。

---

[32:34](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1954s) 现实权衡与基于 Swarm 的服务编排

尽管分布式特性在演示中看似无缝且强大,Saša 对 BEAM 的原生分布式机制给出了极其坦诚的客观评价。他指出,分布式 BEAM 在工程实践中伴随着一系列非常严重的现实缺陷,从最底层的运行时协议(如全互联网络带来的节点数量扩展上限,以及对网络分区的脆弱性)一直延伸到上层的抽象库。因此在工业界,很多人对其在生产环境的采用持保留态度。

然而,Saša 特别强调,这些问题在本质上是“机械实现层面”的缺陷(Mechanical issues),而不是概念模型或顶层 API 设计的失败。这意味着底层的通信协议、连接策略和状态同步机制完全可以在未来被持续重写与改良,而无需颠覆现有的接口契约。这种高层概念的优雅性正是其蕴含巨大潜力的关键。

在代码架构层面,让一个本地并发模块升级为支持全局高可用的分布式服务极其简洁。核心业务模块 `local` 仅仅是标准的 Elixir 并发代码,对分布式机制完全解耦且一无所知。赋予其分布式能力的关键在于项目配置文件 `mix.exs` 中引入的高阶分布式编排库——**Swarm**。在 BEAM 生态中,引入第三方依赖不仅仅是导入一组静态函数库,更意味着直接将一整套自主运转的后台进程组引入到应用系统内部。这一行依赖声明,就在系统启动时拉起了一组负责监听节点拓扑变动、维护全局名称注册表以及管理生命周期的常驻进程。

> “While many people do use BEAM distribution, distributed BEAM in production, there are also many people who would tell you like maybe not use that thing... but I would also say that these issues are purely mechanical, which means that they can be fixed in the implementation without significantly changing or without changing at all the interface, the contract, the way we use this thing.” — Saša Jurić

- **依赖项的双重属性**:在常见语言中,依赖库仅提供供调用的代码逻辑;在 BEAM 体系下,依赖项自身可以携带常驻的并发进程(Activities / Processes)嵌入到系统的运行拓扑中。 - **Swarm 编排器职责**:负责管理分布式注册表,监听节点的在线与离线事件,并自动实现进程在存活节点之间的漂移与状态重构。 - **内聚性优势**:不再依赖外部笨重的外部协调服务(如独立部署的 ZooKeeper 或 Consul 代理),协调机制直接以内置参与者的形式运行在宿主语言的运行时内部。

[35:13](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2113s) 三行代码的分布式:基于 Swarm 的服务注册与位置透明性

Saša Jurić 展示了如何通过极其简洁的方式构建分布式系统。在启动了名为 Swarm 的库之后,在集群中的任意位置启动一个具名服务(named service)仅仅退化为调用一个特定的 Swarm 函数。该函数会自动在集群中挑选一个节点启动对应进程,并在内部维护给定名称与该进程之间的映射关系。当需要查找并调用该服务时,只需调用另一个 Swarm 函数并传入名称,它就会返回一个 PID(进程标识符)。

在 BEAM 虚拟机中,PID 是一个具备位置透明性(location transparency)的数据类型。无论目标进程位于本地节点还是远程集群节点,绝大多数操作 PID 的函数表现完全一致,开发者根本无需关心物理拓扑。由于底层基础设施透明地抹平了网络差异,开发者直接将拿到的 PID 传给普通的 BEAM 函数即可直接通信。Saša 强调,整套分布式能力的引入仅仅花费了三行代码,侧边没有任何额外运行的操作系统进程、容器、虚拟机或第三方服务;即便在完全断开外网的环境下,这套演示依然顺畅运行。更进一步,系统的用户界面也是完全由 Elixir 代码驱动的,甚至没有手写 JavaScript,整套系统在技术上表现出高度的一致与内聚。

```mermaid flowchart TD accTitle: Swarm 分布式服务注册与位置透明调用流程 accDescr: 展示客户端通过 Swarm 注册并解析服务 PID,进而透明调用本地或远程进程的过程。

subgraph Cluster["分布式 BEAM 集群"] Client["客户端 Elixir 代码"] Swarm["Swarm 分布式注册表"]

subgraph NodeA["节点 A (本地)"] P1["服务进程 A"] end

subgraph NodeB["节点 B (远程)"] P2["服务进程 B"] end end

Client -->|"1. swarm_register(name)"| Swarm Swarm -->|"2. 调度并启动"| P2 Client -->|"3. swarm_whereis(name)"| Swarm Swarm -->|"4. 返回统一 PID"| Client Client -->|"5. 透明消息发送 / 调用"| P2 ```

- 在 BEAM 集群中,PID 是全局通用的“位置透明”标识符,本地进程与跨节点远程进程的调用语法完全相同。 - 实现具备容错与服务发现的分布式架构仅需大约三行 Elixir 代码,无需依赖外部编排系统或代理。

[36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) 技术单一性(Technical Uniformity):系统 A 与系统 B 的真实对比

Saša 引用了其著作《Elixir in Action》中的一张真实项目对比表,回顾了他在 2010 年代初并行参与维护的两套系统。系统 A 最初选型的核心技术对现代软件系统天然伴随的高并发、高可用挑战缺乏底层支持。面对这些挑战,团队不得不将控制权退让给操作系统层面:他们不得不运行大量的 OS 进程,在需要更好并发支持的地方引入其他编程语言,并采购大量的第三方中间件产品。虽然业务需求最终得以勉强满足,但解决方案的技术复杂度与技术门槛高得惊人,新入职的初级工程师需要消化海量的概念才能有信心动手改动代码。

与之形成鲜明对比的是系统 B。该系统基于运行在 BEAM 之上的 Erlang 实现。BEAM 常被称为“专为代码打造的操作系统”,因为运行时的语言接口本身就直接提供了类似操作系统的能力(如进程隔离、并发调度、故障恢复)。因此,团队完全不需要下沉到宿主 OS 层面去缝合零件,而是用纯粹的 Erlang 在同一个代码库内搞定了一切,在运行时每个机器节点只需运行单个 OS 进程。尽管自研的 Erlang 方案无法在所有花哨功能或极端峰值性能上百分之百匹敌成熟的商业第三方软件,但它完全足以满足业务需求,并换来了无价的“技术单一性”(Technical Uniformity)。

> “It is in fact sometimes said that BEAM is an operating system for our code, and if I have the operating system directly in my runtime and I have the language as the main interface, then I don't need to fall back to the OS level.” —— Saša Jurić

| 架构维度 | 系统 A(传统拼凑架构) | 系统 B(Erlang / BEAM 统一架构) | |:--- |:--- |:--- | | **基础运行环境** | 语言本身缺乏高可用支持,下沉依赖操作系统及外部服务 | BEAM 自带进程调度与故障隔离(“针对代码的操作系统”) | | **技术栈构成** | 多语言混杂、大量第三方中间件产品与 OS 进程 | 单一语言(Erlang)、单项目工程、每机单 OS 进程 | | **技术复杂度与门槛** | 极高;新手需理解多种中间件协议与不同抽象模型 | 极低;只需掌握一套语言概念即可参与全栈开发 | | **运维与交付负担** | 需编排 5-10 个不同组件,监控与日志高度碎片化 | 统一接入点,调试、度量指标与日志采集高度集约 |

[38:10](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2290s) 降本增效:告别“胶水代码”与细分专家壁垒

Saša 阐明,追求技术单一性并不是为了单一而单一,而是因为它能在整个软件工程生命周期中释放出巨大的工程红利。如果整套系统由单一技术(例如 Elixir)实现,开发团队在日常工作中的摩擦阻力将显著降低:从本地搭建开发环境、编写单元测试,到配置持续集成(CI)流水线以及生产部署,管理一个纯粹的单一系统远比同时协调编排 5 到 10 个独立运转的组件要轻松得多。在生产环境中,团队只需监控一个进程,日志收集、指标埋点和交互式调试都有唯一且强大的切入点。

更为关键的是团队协作维度的质变。当技术门槛被大幅拉低,团队不再需要人为划分狭隘的专业技术壁垒。团队不再被迫聘用专门的 Redis 专家、Nginx 专家、ZooKeeper 专家、Kafka 专家或 Kubernetes 专家;新员工入职后只需学习 Elixir,便能立刻对系统整体做出实质性贡献。此外,工程师们也能从充斥着 YAML、INI、JSON、TOML、XML 等非图灵完备且工具链粗糙的 Ad-hoc DSL 地狱中解脱出来。整个软件系统完全可以使用一门图灵完备、兼具编译期与运行期灵活性、能无缝对接 OS 底层能力的通用语言进行端到端描述。

> “And so we don't need to have all these narrow specialists — we don't need to have like a Redis specialist, Nginx specialist, HAProxy specialist, ZooKeeper specialist, Kafka specialist, Kubernetes specialist, and so on and so forth. And we don't need to wrestle with all these YAMLs and INIs and JSONs and TOMLs and XMLs and other kind of ad hoc DSLs and their quite substandard tooling.” —— Saša Jurić

[40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) BEAM 的终极潜力:兼顾“快速启动”与“长远扩展”的双赢

Saša 展望了 BEAM 语言尚未被业界完全挖掘的真正潜力(他坦言目前社区的发展或许只走到了一半)。他描绘了一个理想的工程场景:当开发者需要构建一个面向 Web 的中小型 CRUD 系统时,只需新建一个 Elixir 工程,引入少量依赖项,5 分钟之内便能一应俱全——直接在同一个项目中获得开箱即用的分布式能力、带复制的高可用 SQL 数据持久化能力,没有任何多余的外部依赖,这构成了名副其实的“极简起步”(Simple Start)。

这种极简起步之所以不同于常规的“玩具框架”,是因为它的基石是一门成熟的图灵完备语言,其底层承载的是拥有三十余年工业级洗礼与海量各色项目验证的 BEAM 虚拟机。这意味着团队在业务规模急剧扩大、面临极端高并发与分布式复杂挑战时,完全有底气在现有架构上持续演进,而根本不需要经历“推倒重写”的阵痛。以往软件工程界认为“快速原型开发选型”与“支撑超大规模长远系统选型”不可兼得的人工假象被彻底打破。Saša 总结道,BEAM 正是这种融合能力的根基,它当之无愧是 Erlang 与 Elixir 的“灵魂”。

在演讲结尾,Saša 为现场听众提供了其著作《Elixir in Action》的专享购书优惠代码(当天享有 5 折,后续提供 4 折优惠),并宣布向现场观众赠送两本实体书以及若干电子书名额。他风趣地提醒大家演讲结束后可直接上台索取,打趣道“你们甚至不用假装对其他话题感兴趣”,并在引导大家对本次分享打分反馈后圆满结束了整场演讲。

> “The artificial trade-off of having to choose between a quick start technology and the long run one disappears, flies out the window, and I get both in the same piece of technology. And this is all in my opinion possible... owing to BEAM, this wonderful runtime which is in my view indeed the soul of Erlang and Elixir.” —— Saša Jurić

- **BEAM 的双重杀手锏**:消除了“易于敏捷起步的轻量技术”与“支撑海量规模的高可靠技术”之间的割裂对立。 - **书籍福利**:Saša 在现场提供了《Elixir in Action》的限时 50% / 40% 折扣代码,并免费派送了两本纸质版及多份电子版书籍。

## Notable quotes > [17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) This in my mind is what high availability is about it's not about chasing some mythical amount of nines of uptime it's about having a system which is there for its users which is ultimately its primary if not the only purpose. — Saša Jurić

> [29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) Because in fact in BEAM, concurrency and distribution are one and the same thing. — Saša Jurić

> [15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) BEAM essentially favors a fair distribution of CPU time for every single activity in the system, or in other words, it promotes the progress of the system as a whole at the expense of the maximum efficiency of any single activity in the system. — Saša Jurić

> [40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) The artificial trade-off of having to choose between a quick start technology and the long run one disappears, flies out the window, and I get both in the same piece of technology. — Saša Jurić

> [36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) It is in fact sometimes said that BEAM is an operating system for our code, and if I have the operating system directly in my runtime and I have the language as the main interface, then I don't need to fall back to the OS level. — Saša Jurić

> [12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) Now an important thing about BEAM is that when a process crashes, everything else progresses, right? So most of the system still works. — Saša Jurić

> [38:10](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2290s) And so we don't need to have all these narrow specialists — we don't need to have like a Redis specialist, Nginx specialist, HAProxy specialist, ZooKeeper specialist, Kafka specialist, Kubernetes specialist, and so on and so forth. — Saša Jurić

## Mentioned Saša Jurić, Joe Armstrong, BEAM, Erlang, Elixir, Swarm, Elixir in Action, GOTO Conferences, Redis, Nginx, HAProxy, ZooKeeper, Kafka, Kubernetes

## Video description This presentation was recorded at GOTO Chicago 2019. #gotocon #gotochgo http://gotochgo.com

Saša Jurić - Author of "Elixir in Action” @sasajuric5850

ABSTRACT Whether you're developing a small web site or a large-scale distributed system, Erlang and Elixir are great tools for building server-side systems. Both languages can help you start quickly and deal with highly complex problems at a large scale. This talk aims to explain what makes Erlang and Elixir suitable for such tasks. We'll look past the syntax and the ecosystem, focusing instead on the concurrency model of these languages. Combining a bit of high-level theory and a couple of demos, we'll examine some important properties of Erlang/Elixir concurrency, with a special emphasis on why these properties are very relevant when building highly available systems. The talk targets experienced backend developers, but no knowledge of Erlang or Elixir is required. You will walk away from [...]

Download slides and read the full abstract here: https://gotochgo.com/2019/sessions/712

RECOMMENDED BOOKS Saša Jurić • Elixir in Action • https://amzn.to/2RZh5eN McCord, Tate & Valim • Programming Phoenix 1.4 • https://amzn.to/3zcUqj4

https://twitter.com/GOTOcon https://www.linkedin.com/company/goto- https://www.instagram.com/goto_con https://www.facebook.com/GOTOConferences #erlang #elixir #programming #DistributedSystems #FunctionalProgramming #SasaJuric

CHANNEL MEMBERSHIP BONUS Join this channel to get early access to videos & other perks: https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/join

Looking for a unique learning experience? Attend the next GOTO conference near you! Get your ticket at https://gotopia.tech Sign up for updates and specials at https://gotopia.tech/newsletter

SUBSCRIBE TO OUR CHANNEL - new videos posted almost daily. https://www.youtube.com/user/GotoConferences/?sub_confirmation=1

[Source](https://www.youtube.com/watch?v=JvBT4XBdoUE)

中文简报

Erlang 与 Elixir 的灵魂 • Sasa Juric • GOTO 2019 本演讲旨在纪念 Erlang 联合发明人 Joe Armstrong,深入探讨了 BEAM 虚拟机如何通过轻量级进程隔离、抢占式调度和消息传递来实现容错性与高可用性。通过在单 CPU 核心上运行的现场演示,Jurić 展示了 BEAM 如何在保持每秒 10,000 次后台操作的同时,隔离未处理的异常、抢占紧密的 CPU 密集型循环,并实现实时远程自省以及零停机热代码重载。他还演示了通过 Swarm 等库构建的分布式集群,将 BEAM 统一的运行时与主流多层架构分散的运维开销进行了对比。 将 Erlang 和 Elixir 联系在一起的真正基石是 BEAM 虚拟机,它本质上就像一个代码操作系统,能够在单个操作系统进程中生成多达 1.3 亿个轻量级进程。 (0:00) BEAM 通过归约计数(reduction counting)在每毫秒强制执行抢占式上下文切换,这使得单核实例即使在并发任务触发无限 CPU 密集型循环时,也能保持不间断的每秒 10,000 次操作吞吐量。 (15:36) 运维人员可以将实时远程 IEx shell 连接到饱和的生产节点,以检查堆栈跟踪、流式传输运行时函数调用,并在不中断用户连接的情况下执行无条件进程终止(Process.exit(pid, :kill))。 (20:11) 通过在单一运行时内提供原生并发、分布式位置透明性和热代码重载,BEAM 消除了快速 MVP 开发与长期企业可扩展性之间的传统权衡。 (39:58)

精炼阅读摘要

Saša Jurić 指出,Erlang 与 Elixir 的核心力量在于底层的 BEAM 虚拟机,它将轻量进程、抢占式调度与高内省机制深度内建,使开发者能在一个技术栈内同时实现高并发、故障隔离与极简的单体架构。 BEAM 进程机制与资源调度 (2:46) BEAM 平台的核心构建单元是轻量进程,这并非操作系统原生的线程或进程,而是一种内存空间完全独立的顺序执行体。每个 BEAM 进程拥有专属的堆、栈及独立的垃圾回收周期,彼此间不共享内存,仅依赖异步消息传递与先进先出的邮箱机制进行通信。在物理层面,整套应用通常只占用单个操作系统进程,虚拟机内部则默认针对每个 CPU 核心分配一个调度器线程来分发任务。BEAM 在架构上最高可支持约 1.3 亿个轻量进程,由于启动成本微乎其微,在极短时间内拉起数以万计的并发任务成为标准操作。 在演示中,Jurić 在单台笔记本的单一操作系统进程内一秒内创建了 10,000 个后台进程,各进程以死循环运行 CPU 密集计算并持续上报心跳。为了测试极端边界条件,他刻意将虚拟机约束至仅运行单个调度器线程。即使在这样等同于单核 CPU 的严苛环境下,系统基线吞吐量仍稳定维持在每秒约 10,000 次操作,而调度器负载仅占 20% 左右,展示了其脱离重型操作系统上下文切换的高效调度能力。 故障与延迟的双重隔离保证 (10:30) 在面向用户的 Web 架构设计中,BEAM 会为每一个建立的 WebSocket 连接分配一个独立的专属进程,而在具体处理特定运算时,该连接进程会进一步衍生出一个一次性计算子进程(Task)。这种架构设计确立了两道安全屏障:故障隔离与延迟隔离。当计算子进程遭遇未捕获异常崩溃时(如传入测试异常值 13),故障仅停留在该单次任务内。由于父级连接进程监控着子任务并接收到崩溃原因通知,WebSocket 连接不会中断,前台界面只会显示友好的错误提示,而全系统每秒 10,000 次的后台基线吞吐量完全未受影响。 延迟隔离则归功于 BEAM 调度器具备的高频强占式机制,其上下文切换频率通常在 1 毫秒以内,依托 reduction 计数器强制分配执行时间片。当演示中故意输入九位数的大数触发耗时约 10 秒的暴力穷举求和、使单核 CPU 利用率飙升至 100% 时,后台吞吐指标依然保持平稳无卡顿。该机制优先保障整体系统的公平吞吐,防止长耗时或陷入死循环的失控任务霸占 CPU,从而重塑了服务可用性的实际意义。 动态探查与生产不停机热修复 (20:11) 面对最棘手的隐性 Bug——例如程序未进行边界校验,在收到负数输入 `-1` 后陷入无异常抛出的无限尾递归并导致 CPU 持续占满——传统的被动日志系统往往毫无痕迹。BEAM 提供了直接连入运行中节点的交互式远程控制台(IEx shell),且得益于公平调度,即便 CPU 处于满载状态,诊断 shell 依然响应迅速。运维人员无需预先配置侵入性调试开关,即可通过系统内建的原生函数遍历进程表,以 reductions 指标的变化增量精准定位消耗 CPU 的进程 PID。 在演示中,Jurić 定位到失控进程后,不仅当场抽取了其当前调用栈帧与即时函数调用追踪链路,还利用 `Process.exit(pid, :kill)` 信号予以精准销毁。这种由父进程监听并处理消亡事件的一等公民取消机制,瞬时化解了危机而不产生脏状态。随后,他在本地补齐了正整数边界断言防线,换用高斯求和公式优化算法复杂度,跑通单元测试后,直接将编译后的字节码热注入到正在运行的生产节点。修复全程无停机,全套系统的持续数据处理从未间断,前端无需刷新即刻恢复正常。 分布式编排与技术同构的架构红利 (29:51) BEAM 原生将并发与分布式视为同一套模型,两个 BEAM 节点只需一条 TCP 连接即可组网形成集群。其核心优势在于进程标识符(PID)具备完全的位置透明性,消息发送操作与具体进程位于本地核还是远程主机完全解耦。在演示中,借助 Swarm 这类纯 Elixir 库,仅需引入少量配置并在代码中调用三行指令,系统便自动拉起监控树,实现了跨节点的命名服务注册、动态服务摆放与节点宕机自动漂移,全程无需借助外部侧车代理、容器编排工具或额外网络组网。 Jurić 将这种模式与堆砌第三方工具的传统架构(系统 A)进行了对比。传统方案由于语言层面缺乏原生的并发与分布原语,不得不引入大量独立操作系统进程,并在外围集成 Redis、NGINX、ZooKeeper、Kafka 或 Kubernetes 以及充斥各类 ad-hoc DSL 的配置文件。而依托 BEAM 的架构(系统 B)将虚拟机视为承载代码的操作系统,在一套图灵完备的语言内搞定后台任务、分布式状态、缓存与编排,大幅降低了团队成员的认知负荷,打破了“初期敏捷但后期必须重写”与“初期就承担沉重分布式架构”的两难困境。 Jurić 坦承原生分布式 Erlang 在网络底层机制和上层库支持上仍面临一些严肃的工程问题,许多从业者在严苛生产环境中对此持谨慎态度,但他认为这些属于可迭代优化的机械实现细节。整场演讲论证了 BEAM 凭借进程隔离、调度公平性及运行时同构能力,构成了极具弹性的系统工程底座。

Detailed notes — zh

## Background 该视频由 GOTO Conferences 于 2019 年 5 月 22 日在 YouTube 平台发布,记录了《Elixir in Action》作者 Saša Jurić 在 GOTO Chicago 2019 大会上的演讲。视频简介指出,演讲超越了表层语法和生态,聚焦于 Erlang 与 Elixir 的底层并发模型与高可用特性,旨在帮助有经验的后端开发者理解如何利用它们快速构建从小型网站到超大规模分布式系统的服务端应用。 ## TL;DR Saša Jurić 深入剖析了 Erlang 与 Elixir 的底层基石——BEAM 虚拟机的并发架构与运行机制。他通过生动的现场 Demo 演示了单调度器环境下 10,000 个轻量级进程的并发运行,展示了 BEAM 进程如何实现近乎完美的故障隔离、微秒级抢占式调度以及运行期内省与热代码修复。随后,他展示了原生分布式能力与位置透明性,并对比了现代拼凑式微服务与“技术单一性”架构的差异。最后他指出,BEAM 彻底消除了“敏捷起步原型”与“支撑长远海量扩展”之间的对立,是构建高可用系统的真正灵魂。 ## Atmosphere & style 整场演讲节奏紧凑且干货密集,讲者充满激情与感染力,开篇对 Joe Armstrong 的致敬更是奠定了一层由衷敬佩的情感底色。在技术演示环节,气氛在面对失控死循环与线上告警的紧张排错中推向高潮,讲者戴上“运维帽子”现场远程取证、强制杀进程并热部署修复代码的过程令人拍案叫绝。观众不仅能感受到资深工程师对工业级架构的深刻洞察,更能体会到那种从复杂运维泥潭中解脱出来的纯粹快乐。 ## Bulletin - [06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) BEAM 虚拟机将 Erlang/Elixir 系统精简为单一操作系统进程,内部支持派生数百万级轻量进程,且天然具备微秒级抢占式调度以实现延迟隔离。 - [12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) 通过解耦长连接进程与一次性计算进程,系统在遭遇代码未捕获异常或 CPU 密集型长任务时,背景每秒万次请求的吞吐量保持完全稳定。 - [20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) BEAM 原生提供基于 Reductions 指标的运行时内省与一等公民取消机制(Process.exit(pid, :kill)),支持在无外部工具干预下精准排查并热修复线上故障。 - [35:13](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2113s) 借助 Swarm 等编排库与位置透明的 PID 特性,系统仅需三行代码即可实现具备故障转移与服务注册的分布式集群,免去笨重的外部中间件胶水层。 ## Key takeaways - [00:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=0s) Erlang 与 Elixir 的核心竞争力不在于表层语法,而在于底层统一的 BEAM 虚拟机的并发模型与运行时机制。 - [02:46](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=166s) BEAM 进程是拥有独立内存堆栈与独立垃圾回收的顺序执行上下文,各进程间纯粹依靠异步消息传递进行交互。 - [06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) BEAM 将系统整体封装在单一 OS 进程中,通过与 CPU 核心绑定的调度器管理海量轻量进程,技术上限可承载数以亿计的并发单元。 - [10:24](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=624s) 将 WebSocket 连接与运算任务拆解为双层进程拓扑,可有效阻断未捕获异常对网络连接及全局系统的连锁破坏。 - [15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) BEAM 调度器基于指令规约数(Reductions)在极短时间片内强制抢占,牺牲单任务极致性能以换取全系统的公平响应与延迟隔离。 - [17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) 高可用性的本质不在于盲目追求“几个9”的抽象数字,而在于即使系统发生局部故障也能持续陪伴并服务用户。 - [20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) BEAM 具备出色的生产内省能力,运维人员无需重启或预设探针,即可通过 IEx Shell 对生产节点进行动态诊断与 top 分析。 - [23:42](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1422s) Process.exit(pid, :kill) 构成了运行时底层的一等公民取消机制,能瞬间终止脱缰死循环而不干扰其他正常业务事务。 - [26:29](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1589s) BEAM 支持零停机热代码替换,允许修复模块在不停机、不掉线的情况下动态加载并即时生效。 - [29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) BEAM 原生打通了单机并发与分布式边界,通过位置透明的 PID 实现跨节点透明调用与自动故障转移。 - [36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) “技术单一性”主张通过统一的图灵完备语言与运行时覆盖全栈需求,大幅替代拼凑式架构中的碎片化中间件与细分专家壁垒。 - [40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) BEAM 消除了“轻量快速启动工具”与“超大规模长远演进系统”之间的伪权衡,使敏捷开发与高可用架构在同一选型下得以兼得。 ## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=0s) 致敬 Joe Armstrong 与寻找 BEAM 语言的“灵魂” 演讲在掌声中开始。讲者 Saša Jurić 首先向刚逝世不久的 Erlang 主要发明者 Joe Armstrong 致以深切的哀悼与崇高的敬意。他感慨道,虽然 Joe 离开了人世,但他留下的思想和技术遗产依旧熠熠生辉,今天整个演讲所探讨的内容,归根结底都建立在 Joe Armstrong 对计算机科学领域的巨大贡献之上。谈到个人经历时,Saša Jurić 充满感情地表示,自己在相当长一段时间内都在使用 Erlang 和 Elixir,这毫无疑问是他整个职业生涯中最享受、最开心的阶段,因此他希望通过这场演讲,将这份快乐传递给大家,解释自己为什么对这些语言如此着迷。 ```mermaid flowchart TD accTitle: BEAM Runtime Architecture accDescr: High-level architectural mapping showing how multiple languages compile to run on the unified BEAM runtime layer inside a single OS process. subgraph Languages["上层开发语言与代码实现"] direction LR L1["Erlang"] L2["Elixir"] L3["其他 BEAM 语言"] end subgraph BEAM["统一运行层:BEAM / Erlang 虚拟机"] VM["BEAM 虚拟化执行环境"] end subgraph OperatingSystem["底层操作系统环境"] OSProcess["单一操作系统进程 (Single OS Process)"] end Languages -->|"统一接口与语义"| VM VM -->|"运行于宿主系统"| OSProcess ``` 他将本次演讲的主题定为寻找 Erlang 与 Elixir 的“灵魂”。虽然市面上看起来是两种甚至更多的语言,但讲者指出,他完全可以“买一送一”,因为本次探讨的核心不是表层的语法差异,而是底层的统一运行时——也就是 Erlang 虚拟机(通常称为 BEAM)。从使用者的角度和编写 BEAM 系统的开发者视角来看,所有语言都只是与 BEAM 交互、借用其威力的接口。因此他在演讲中可能会混用这些名字,有时说 Elixir(因为现场所有的演示 Demo 和代码示例都是用 Elixir 编写的),有时说 Erlang,但他真正指代的其实是任何运行在 BEAM 之上的语言。 - 整个演讲结构划分为清晰的三大部分: 1. 基础理论部分:介绍 BEAM 并发的核心原理与底层机制。 2. 核心演示部分:基于生动的实战 Demo,演示如何将一个系统拆分成不同的并发单元,并深入探讨这种架构设计带来的收益。 3. 观点探讨部分:抛出一个简短且略带颠覆性的思想实验,探讨一种与当今主流软件构建方式背道而驰的新型架构风格——这是一种依托 BEAM 运行时才得以成立的架构方式,讲者坚信它比当今行业盛行的构建方案更加简单,同时也更强大灵活。 Saša Jurić 坦言自己的议程安排非常宏大,而演讲时间十分紧迫,因此他提前向全场打好招呼,表示自己会讲得非常快,希望能为所有人带来大量值得思考的技术干货。 --- ### [02:46](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=166s) BEAM 并发模型的基石:轻量级进程与消息传递 讲者切入正题,正式剖析 Joe Armstrong 心中构想的“BEAM 风格并发”(BEAM-style concurrency)。该模型的核心基石是被称为“进程”(Process)的概念。在 BEAM 的术语中,进程是代码在运行时的执行上下文,任何 Elixir 代码在运行状态下都必然从属于某一个进程。 Saša Jurić 特别强调,必须纠正初学者的概念混淆:这里的进程既不是操作系统的 OS 进程,也不是操作系统的 OS 线程。从本质上讲,一个 BEAM 进程就是一个完全顺序执行的单线程程序(Sequential Program),进程内部没有任何并发机制。在其中,开发者按最传统的方式写代码——调用函数、传递参数、获取返回值、执行条件分支逻辑、写循环等。只要局限在单个顺序执行的范畴内,Elixir 展现出的是某种定义下的函数式编程特性;而一旦涉及跨进程的交互,就进入了该语言的另一个核心范式——并发。 要实现并发,就必须启动多个进程。Elixir 标准库提供了最底层的原语函数 `spawn`。当一个正在运行的顺序程序调用 `spawn` 并传入一个匿名函数(Lambda)时,系统就会立即派生出一个全新的进程。一旦新进程启动完成,调用方的进程立刻继续向下执行。在概念模型上,此时就有了两个完全独立、互不相干的程序在并行运行。 讲者用极其强调的语气总结这两个进程之间的完全隔离性: > “They have their own separate execution flow, they have their own separate memory space (stack, heap), they are separately garbage collected at different points in time, and they are really completely two separate programs.” > —— *Saša Jurić* 由于两者没有任何共享内存,彼此协作的唯一途径就是通过发送消息,即基于消息传递的并发(Message Passing Concurrency)。在语言底层,开发者可以通过 `send` 函数向指定的目标进程发送消息。这里的消息可以是 Elixir 中能够构建的任意数据项(Term)。在接收端,目标进程则从自己的邮箱(Mailbox,一个类似先进先出 FIFO 的队列)中拉取消息并进行处理。 ```mermaid flowchart LR accTitle: BEAM Process Message Passing accDescr: Sequence showing Process A sending an arbitrary data message into Process B's FIFO mailbox. subgraph ProcessA["进程 A (顺序程序)"] ExecA["调用 send(PID, 消息)"] end subgraph ProcessB["进程 B (顺序程序)"] Mailbox["进程邮箱 (FIFO Queue)"] ExecB["拉取消息并执行处理"] end ExecA -->|"异步发送消息数据"| Mailbox Mailbox --> ExecB ``` 为了帮助现场听众建立直观类比,Saša Jurić 将这种模式比作“微服务架构”(Microservices):正如微服务之间是两个相互独立的 OS 进程,没有共享状态,只能通过 HTTP 等网络请求进行通信;BEAM 进程也是两个完全独立的程序,通过消息交流。但最大的颠覆在于:BEAM 内部没有网络开销,没有复杂的 HTTP 协议封装,不需要反反复复的对象序列化与反序列化,这种隔离机制直接由语言底层和运行时本身提供原生支持。当现场有听众提问如何定位目标时,讲者简要回应,每个进程都有唯一的进程标识符(Process ID / PID),可以据此进行寻址与引用。 --- ### [06:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=360s) 运行时底层调度机制与万级并发 Demo 启动 解释完概念之后,讲者进一步揭开 BEAM 在底层的运行真相。当开发者在 Elixir 中写完系统源码并输入一条启动命令时,操作系统层面实际上只启动了一个单一的操作系统进程(Single OS Process),即运行了一个 Erlang 虚拟机(BEAM)实例。整个庞大的分布式或服务端系统,在底层就驻留在这个单一 OS 进程内。 在这个 OS 进程中,开发者可以随心所欲地利用代码 `spawn` 产生海量的轻量级进程。这些进程启动速度极快,内存开销微乎其微。开发者完全不需要节制,可以在系统内部轻松运行数千、数十万甚至数百万个进程;BEAM 虚拟机自身施加的技术上限甚至高达约 1.3 亿个进程。 在虚拟机的多核利用与调度方面,BEAM 的内部设计非常精巧: - 虚拟机在底层会启用若干个名为调度器(Schedulers)的操作系统线程。 - 默认情况下,BEAM 会严格按照硬件环境,为每个可用的 CPU 核心绑定分配一个专属的调度器线程。 - 调度器负责具体执行这些轻量级进程的代码。一个通俗但不失本质的理解模型是:假设后台存在一个等待执行的进程队列,每个调度器从队列头部取出一个进程,让其运行一段极微小的时间片,随后将其放回队列尾部,接着处理下一个进程,如此循环往复。 为了向听众展示这种并发并非空中楼阁,讲者切入准备好的实战 Demo。他提前在本地机器上将一个用 Elixir 开发的小型演示系统作为后台服务(Headless Daemon)启动。他强调,这个服务的启动配置方式与真实生产环境完全一致,它是一个完全独立的单一 BEAM OS 进程,没有任何外部辅助支撑组件。 随后,讲者打开系统内置的 Web 仪表盘(Dashboard),准备通过手动触发后台任务来模拟合成负载(Synthetic Load)。在底层设计中,系统中的每一个任务(Job)都是一个完全独立的轻量级进程。讲者在控制界面上点击启动按钮,仅仅在一秒钟之内,仪表盘上的活跃进程数直接飙升,10,000 个独立的轻量级并发进程瞬间在后台全速运转起来。 每个进程都在执行一个无限循环(Infinite Loop);在每一次循环中,它们都会执行一小段 CPU 密集型计算来制造真实算力负载,随后向一个预先设定好的知名进程发送通信消息。即使面对瞬间创建的万级并发程序,单一 BEAM 节点依然举重若轻地并行处理着所有任务。 ### [08:45](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=525s) 监控面板与单调度器压力环境 演示系统的指标仪表板上正在实时展示系统的运行状态。系统内部设计了一个单例且全局寻址的进程,该进程在每次迭代中标记一次操作成功,随后休眠整整一秒并循环往复;同时有若干辅助进程负责收集指标数据,并通过 WebSocket 推送给任何打开此页面的用户。 左侧图表显示了每秒成功操作数(successes per second),当前维持在预期的 10,000 次/秒(10K/s)左右。图表线条并非完全平直,而是伴随着轻微振荡。产生波动的原因有两个:一是内部逻辑并未严格同步;二是演示所用的单台机器配置相对普通,除了承载服务端系统外,浏览器还在高频利用 SVG 渲染动态图表,从而占用了一部分计算资源。 该系统被刻意配置为仅运行一个调度器线程(Scheduler Thread)。在当前的四核宿主机上,BEAM 默认会启动四个调度器,但为了使演示效果更加直观极端,演讲者将其硬编码限制为单个调度器线程。这意味着所有进程都在模拟单核 CPU 环境下的并发竞争。右侧负载图表显示,单调度器在 10K/s 负载下的 CPU 占用率仅在 20% 左右,系统尚有充足的余量。 - **基准吞吐量**:维持在约 10,000 次成功操作/秒(10K successes per second)。 - **调度器配置**:默认可利用宿主机 4 个核心,被强制限定为 1 个调度器线程,以模拟单核环境。 - **基准负载占用**:在维持 10K/s 吞吐的情况下,单调度器的 CPU 占用率仅约 20%。 --- ### [10:24](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=624s) 页面交互模型与双层进程架构 在合成用户(Synthetic Users)以 10K/s 频率产生背景流量的同时,演讲者打开了一个供真实用户访问的 Web 界面。这个界面极为朴素,却概括了所有 Web 系统的核心本质:用户输入数据,系统消化计算,再将结果输出。该页面的具体功能是输入一个正整数 $n$,系统计算前 $n$ 个自然数的累加和(例如输入 3 计算 $1+2+3=6$,输入 4 计算 $1+2+3+4=10$)。 支撑该功能的底层进程拓扑具有精细的分工结构。浏览器与后台建立长连接 WebSocket,所有用户交互均通过该通道进行。每条活跃的 WebSocket 连接均对应一个由系统动态派生的连接进程(Connection Process)。如果同时有 3 位用户在线,系统内就存在 3 个连接进程;若有 100 万用户在线,系统便生成 100 万个连接进程;若无人在席,数量归零。 计算任务并没有直接放在连接进程内执行。每当用户提交请求,连接进程都会单独派生一个专职的、一次性的“计算进程”(Calculation Process / Task)。计算进程完成运算后,将结果异步发送回连接进程,连接进程再推送到浏览器渲染,而计算进程随即正常退出并销毁。 ```mermaid flowchart TD accTitle: 用户交互与进程生命周期架构 accDescr: 展示浏览器通过 WebSocket 连接到独立的连接进程,连接进程动态派生一次性计算进程并回收结果的流程。 subgraph BrowserClient["客户端浏览器"] UI["用户界面 (输入 / 结果渲染)"] end subgraph BeamRuntime["BEAM 运行时"] ConnProc["连接进程 (Connection Process)<br/>随 WebSocket 长期存活"] CalcProc["计算进程 (Calculation Process / Task)<br/>一次性、算完即销毁"] end UI -->|"1. WebSocket 提交自然数 N"| ConnProc ConnProc -->|"2. 动态派生 (Spawn)"| CalcProc CalcProc -->|"3. 累加计算并回传消息"| ConnProc ConnProc -->|"4. 推送计算结果"| UI CalcProc -.->|"5. 正常退出终止"| Terminate(["销毁回收"]) ``` --- ### [12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) 故障隔离:单进程崩溃不波及系统 之所以采取连接进程与计算进程分离的设计,最根本的目标是提高系统的容错能力(Fault Tolerance)与高可用性(High Availability)。真实生产环境中总会隐藏各样错误,演讲者演示了最常见的一类缺陷:业务逻辑未能覆盖边缘分支,导致服务端抛出未捕获的运行时异常(如被零除、负数求平方根或“undefined is not a function”)。 在此演示中,数字 13 被预设为会触发崩溃的异常输入。当用户提交 13 时,前端界面提示了错误信息。通过查看后台以独立服务运行的系统日志,可以观察到明确的崩溃记录:一个名为 `Task` 的组件异常终止。这意味着专职负责该次求和的“计算进程”已经崩溃挂掉,但整个系统的运行并没有中断。 Saša Jurić 强调了 BEAM 错误隔离机制的核心特质: > “Now an important thing about BEAM is that when a process crashes, everything else progresses, right? So most of the system still works.” 即使连续不断地提交 13 触发异常,控制台频繁抛出错误日志,左侧监控大盘上的背景吞吐量仍然稳稳保持在 10K/s。同时,进程的崩溃绝非悄无声息。BEAM 允许其他进程监听或监控其生命周期;计算进程崩溃时,连接进程收到了一条结构化退出消息(指出“进程 Foo 因原因 Bar 死亡”),因而连接进程得以在保持 WebSocket 不断开的前提下,将友好的错误提示推送回客户端。 - **崩溃现象**:计算进程在遭遇未处理异常时直接挂掉(Task termination),由日志捕获错误堆栈。 - **稳定性保障**:后台 10,000 次/秒的操作未受波及,系统其他用户的并发事务正常推进。 - **消息感知机制**:连接进程通过进程间消息感知下游崩溃,从而向 UI 正确反馈错误信息,而不会导致网络连接掉线。 --- ### [15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) 延迟隔离与抢占式调度的公平机制 进程不仅能够隔离错误,更能“隔离延迟”(Separate Latencies)。为了验证这一点,演讲者展示了系统内的另一个缺陷:求和计算采用了一种极其低效、纯 CPU 绑定的暴力循环实现(从 1 循环累加至 $n$),没有任何公式化优化。 当输入一个巨大的数值(9 个 9:`999,999,999`)时,计算进程陷入了长达约 10 秒的纯 CPU 密集型循环。监控面板显示,单核调度器的 CPU 使用率瞬间被打满到 100%。在常规的单线程协作式系统或事件循环系统中,这类耗时任务必然会阻塞整个主线程,导致背景任务与网络 I/O 陷入停滞。然而,在该单调度器系统中,背景的 10K/s 吞吐量曲线依旧保持平稳,没有发生断崖式下跌。 这得益于 BEAM 调度器具备微秒级的真正抢占式调度能力(Preemption)。无论进程在执行 I/O 操作还是密集的 CPU 计算,调度器都会在极小的时间片(通常小于 1 毫秒)内强制执行上下文切换。关于这种设计取舍,Saša Jurić 总结道: > “BEAM essentially favors a fair distribution of CPU time for every single activity in the system, or in other words, it promotes the progress of the system as a whole at the expense of the maximum efficiency of any single activity in the system.” BEAM 不追求让单个计算任务以极限速度跑完,而是将全系统的整体向前推进置于首位。这种牺牲单任务极致性能来换取全系统响应度与公平性的调度模型,精确切中了并发多用户 Web 系统的运行本质。 - **暴力计算规模**:输入数值为 9 个 9($999,999,999$),造成约 10 秒的纯 CPU 循环消耗。 - **调度开销与时间片**:调度器在上百万个 Reductions(指令消耗计数)基准下切分时间片,上下文切换间隔小于 1 毫秒(< 1 ms)。 - **抢占特质**:实现真正的抢占式多任务,CPU 密集型进程无法独占执行资源,避免了由单点繁重计算引发的系统级高延迟。 ### [17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) 高可用性的本质:在故障与重算中保证系统前行 Saša Jurić 强调,把系统拆分成独立进程并将故障隔离与延迟隔离绑定在一起,是构建高可用架构的核心所在。他在演示中作为单一用户输入了高 CPU 消耗的计算任务(输入 `456789`),随后展示出连接依然可用,甚至可以继续输入其他数据并制造一批错误。令人惊叹的是,整个大盘依然保持着对其他用户的稳定推进,当前受测用户自身也保持着稳定响应,而后台那个漫长的密集计算任务最终也顺利完成。这种即使生产环境发生各种局部问题、依然能够牢牢掌控局面的表现,正是健壮系统的典范。Saša 形象地比喻道:尽管船体被凿穿了几个洞,但整艘船依然平稳航行,没有沉没,并且继续为绝大多数用户提供服务。 Saša Jurić 深刻地指出:“This in my mind is what high availability is about it's not about chasing some mythical amount of nines of uptime it's about having a system which is there for its users which is ultimately its primary if not the only purpose.”(在我看来,这就是高可用性的真正意义所在:它不是去盲目追逐某种虚无缥缈的‘几个9’的正常运行时间指标,而是要让系统始终能够陪伴并服务它的用户——这终究是系统最核心甚至是唯一的目的。) ```mermaid flowchart TD accTitle: BeamProcessIsolationArchitecture accDescr: 架构图展示了一个重度计算任务或故障请求如何被限制在独立子进程中,而不影响全局调度器和其他用户的处理。 subgraph UserSpace["用户交互层"] U1["当前测试用户"] U2["其他系统用户 (10k 请求/秒)"] end subgraph BeamRuntime["BEAM 运行时环境"] ConnProc["当前用户连接进程 (PID)"] CalcProc["重度计算 / 故障计算进程"] OtherProc["成千上万个轻量进程"] end U1 -->|"发送复杂计算 / 触发错误"| ConnProc ConnProc -->|"隔离派发计算"| CalcProc U2 -->|"常规业务交互"| OtherProc OtherProc -->|"正常稳定处理"| BeamRuntime ``` --- ### [18:44](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1124s) 恶性隐患:负数输入引发的失控死循环 即便系统具备高可用弹性,线上遗留的隐蔽缺陷若不排除,依然可能威胁到整个系统的存亡。Saša 现场输入了一个负数 `-1`,展示了这类极具杀伤力的隐患。系统在业务逻辑上本就不应接受这种非法的值域输入,但一旦接收并进入计算,由于代码缺陷,它迟迟无法返回结果。观察监控调度器可以看到,CPU 使用率瞬间被持续拉满到 100%。这个操作直接演变成了一个失控的(rogue)CPU 密集型死循环,相当于执行了无休止的 `while(true);`。 得益于 BEAM 进程调度的优越性,系统依然展现出强大的韧性:在单线程调度器跑满的情况下,系统面向其他用户的吞吐依然保持在每秒 10,000 次成功的基准线。然而这只是一时的侥幸。如果用户因没有收到结果而反复重试,或者其他用户也踩中同样的负数边界条件,系统最终会被这些空转的死循环拖垮,彻底陷入瘫痪。因此,运维人员必须具备在系统完全崩溃前快速定位并排查此类隐形炸弹的能力。 --- ### [20:11](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1211s) 穿透黑盒:利用 BEAM 运行时内省与可观测性快速诊断 为了还原真实的排错场景,Saša 戴上“运维人员的帽子”,假定自己并不知道刚才发生的操作,只是收到了 CPU 飙升至 100% 的线上告警。他通过 SSH 登录到服务器查看日志,但日志一片死寂,只有之前测试数字 13 时的旧错误记录,对于眼前这个无任何输出的无限循环完全没有帮助。 此时 BEAM 的核心优势显露无遗:它是一个高度具备可调试性(debuggable)、内省性(inspectable)和可观测性(observable)的运行时系统。开发者无需在启动时预设特殊调试标志,也无需重启系统,就能直接接入正在生产运行的节点进行动态探查。Saša 执行了远程控制台命令,打开了一个连接到线上生产环境的 IEx(Interactive Elixir)Shell 会话。在这个仅有一个调度线程(单核运行)、负载跑满且并发处理着每秒 10,000 次请求的系统里,运维人员执行的代码依然被平稳调度。 - **获取全局进程**:通过调用 `Process.list()`,列出当前系统中所有轻量进程的 PID(Process ID)。 - **进程指标内省**:通过 `Process.info(pid)` 查询特定进程属性,其中最为核心的指标是 `reductions`(规约数)。 - **Reductions 原理**:这是一个非负整数,大致等同于进程自诞生以来执行的虚拟机指令数量。要找出最消耗 CPU 的“罪魁祸首”,只需计算两个时间点之间各进程 reduction 计数的增量差值,再倒序排列即可获得类似操作系统 `top` 的视图。 - **定位元凶**:Saša 运行了预先封装的工具函数 `runtime.top()`,立刻获取到过去一秒内 CPU 占用最高的前十个进程。排名第一的进程(PID 如 `0.12605.0`)占用了绝大部分 CPU;再次运行验证,该 PID 依然稳居榜首,确凿无疑为消耗资源的失控进程。 --- ### [23:42](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1422s) 运行时取证与一级取消机制:`Process.exit(pid, :kill)` 的威力 锁定恶意进程后,即使它是一个陷入死循环、不让出时间片、不响应任何消息的脱缰程序,BEAM 运行时仍能从外部强行读取其状态。Saša 将该异常进程的 PID 存入变量,调用 `Process.info(pid,:current_stacktrace)` 直接拉取其当前的调用堆栈轨迹,随后又运行了辅助函数 `runtime.trace()`,在最多 1 秒或 50 次调用的限制下,动态捕获该进程正在执行的函数调用轨迹。 取证完成后,Saša 直接调用标准库中的终止函数对该死循环进程进行清理: ```elixir Process.exit(pid,:kill) ``` 指令刚一敲下,仪表盘上的 CPU 调度使用率瞬间断崖式下跌,恢复至正常水准,而整个系统每秒 10,000 次的业务处理丝毫不受干扰。与此同时,在前台用户界面上,用户立刻收到了计算失败的报错通知。这是因为虽然执行计算的子进程被底层的 `:kill` 强行处决(类似 BEAM 级别的 `kill -9`,无法被代码内的 `try-catch` 拦截),但负责网络连接的进程依然活着,它接收到了子进程夭折的退出信号,从而能够体面地向客户端派发异常提示。 Saša 评价道:“This process exiting it's like a seemingly simple thing but one which is as far as I know exclusive to BEAM in terms of guarantees this is essentially a first-class cancellation implemented at the runtime layer.”(这种进程退出看似是一件微不足道的小事,但就其所能提供的保障而言,据我所知是 BEAM 所独有的——这本质上是运行时底层所实现的一等公民级别的取消机制。)无论是通过交互式终端介入,还是在代码中使用高阶抽象实现超时取消或用户主动取消,这种由底层保障的强力取消机制都只需要极少的代码就能发挥极其惊人的威力。随后,他将注意力转回刚才抓取的栈帧与模块轨迹数据,展开具体的代码级根因分析。 ### [26:29](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1589s) 深入崩溃现场与热代码修复 ```mermaid flowchart TD accTitle: 热代码修复流程图 accDescr: 展示从系统边界拦截错误、修复算法问题到热升级生产环境的完整流程。 subgraph Edge ["系统边界 (边界拦截)"] A["客户端请求"] --> B["输入校验 (系统边缘)"] B -->|"非法输入 (-1, 0, 123)"| C["直接丢弃并返回 invalid input"] end subgraph Core ["业务核心层 (问题修复)"] B -->|"正整数输入"| D["高斯求和算法 n*(n+1)/2"] D --> E["解决数字 13 的边界问题"] E --> F["单元测试全部通过"] end subgraph Deploy ["热部署到生产环境"] F --> G["执行自动化任务编译模块"] G --> H["无缝热替换 BEAM 代码"] H --> I["生产环境吞吐保持 10k req/s (零停机)"] end ``` 通过堆栈追踪(Stack Trace)定位到具体的文件和行号后,Saša Jurić 开始结合运行时的动态视图剖析故障原因。该进程陷入了无尽的递归调用(在函数式编程中,恒等递归即等同于死循环)。通过逐帧观察循环参数的变化,他发现第一个参数每次递增 1,第二个参数每次递减 1,而第三个参数则按一定规律持续攀升。代码深处的这个函数默认输入必须是正整数,一旦传入负数或不满足约定的数据,就会引发无限递归。 在业务领域模型中,这部分代码处于系统较深的位置,假设处理的都是自然数并没有逻辑错误。真正的问题在于系统的边缘——即接收用户输入的地方——缺乏足够严格的校验,导致无效数据层层穿透进入核心。为了解决这些累积的问题,Saša 现场修复了代码:在边缘取消了防御性校验的注释以拦截负数;修复了导致数字 13 报错的边界缺陷;并运用高中数学的高斯求和公式(`n * (n + 1) / 2`)彻底取代原先效率低下的求和实现。 在所有本地自动化测试验证通过后,Saša 运行了一个专用的热部署脚本。该脚本重新编译了两个模块,并在不重启生产进程的前提下,将新代码动态加载到运行中的系统。监控仪表盘上的指标表明,系统在代码加载期间未受丝毫干扰,依然以每秒 10,000 次成功的稳定速率处理流量。在前端页面无需刷新的情况下,负数和零被即时判定为非法输入,数字 13 顺利得出结果,而一长串极大数字的求和也在瞬间完成。 > “Essentially what happened here: we had a system with problems, and it was staying on top of the game, and it allowed me to approach it, the system, and look from inside it to figure out what the problems are, but I was able to quickly fix those problems and deployed into production without disturbing anything in the system itself, right, the other activities.” — Saša Jurić - **诊断信息提取**:从单条崩溃进程的状态不仅能查明所在函数与行号,还能还原每一次递归迭代所接收的具体参数值。 - **架构原则**:边缘负责严格的数据过滤,内部业务领域则专注合法实体的核心逻辑。 - **零停机动态加载**:BEAM 允许在单机运行时中并行存在旧版本与新版本的代码模块,实现平滑过渡且不中断正在处理的网络连接与计算任务。 --- ### [29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) BEAM 集群与分布式原生并发 BEAM 不仅在单机多核上表现优异,其底层对分布式系统也具备开箱即用的支持。开发者可以在单台机器或跨独立物理机/虚拟机启动多个 BEAM 节点(Node)。仅需调用一个简单的原生函数,即可在两个节点之间建立底层的 TCP 连接,从而组成一个原生的 BEAM 集群。 在形成集群后,Erlang 和 Elixir 为开发者提供了极具吸引力的编程能力:开发者可以枚举集群内的全部节点、动态监听节点的加入(Join)与脱离(Leave)事件,并且可以在任意指定节点上生成进程,甚至完全跨节点透明地发送与接收消息。在 BEAM 的哲学体系中,单机并发与分布式在语义和抽象上是等同的,开发者编写分布式通信的代码与在单机内向某个进程收发消息几乎毫无区别。 Saša 通过一个服务注册仪表盘演示了分布式特性的工作方式。在界面上启动一个名为 `node2` 的前台节点后,集群立即感应到了新成员。当在 UI 中创建全局命名的服务(在 BEAM 中本质上就是一个被赋予集群级名称的独立进程)`foo` 时,系统自动在某一个节点上实例化了该进程。点击查询时,客户端向集群发起消息调用,该进程捕获自身的状态、获取所宿留的节点名称并将数据打包响应。接着创建的服务 `bar` 则被调度到另一个节点上运行,展示了简单的集群负载均衡。 为了展示机器宕机时的容错能力,Saša 直接在终端终止了 `node2` 的运行。仪表盘上的视图随之改变:原本存活在 `node2` 上的 `bar` 进程被系统感知丢失,并立刻在依然存活的 `node1` 上复活,再次向该服务发送请求时,响应的提供方已自动切换为 `node1`。 > “Because in fact in BEAM, concurrency and distribution are one and the same thing.” — Saša Jurić - **节点互联机制**:多个虚拟机实例之间通过单条长连接构成全互联网络拓扑(Full Mesh)。 - **进程位置透明性**:向进程发送消息或注册名称不需要硬编码目标 IP 或端口,底层分发由虚拟机和集群协议自动路由。 - **高可用故障转移**:当某个 BEAM 节点宕机断网时,其余节点会迅速触发事件钩子,支持关键状态自动重构与恢复。 --- ### [32:34](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1954s) 现实权衡与基于 Swarm 的服务编排 尽管分布式特性在演示中看似无缝且强大,Saša 对 BEAM 的原生分布式机制给出了极其坦诚的客观评价。他指出,分布式 BEAM 在工程实践中伴随着一系列非常严重的现实缺陷,从最底层的运行时协议(如全互联网络带来的节点数量扩展上限,以及对网络分区的脆弱性)一直延伸到上层的抽象库。因此在工业界,很多人对其在生产环境的采用持保留态度。 然而,Saša 特别强调,这些问题在本质上是“机械实现层面”的缺陷(Mechanical issues),而不是概念模型或顶层 API 设计的失败。这意味着底层的通信协议、连接策略和状态同步机制完全可以在未来被持续重写与改良,而无需颠覆现有的接口契约。这种高层概念的优雅性正是其蕴含巨大潜力的关键。 在代码架构层面,让一个本地并发模块升级为支持全局高可用的分布式服务极其简洁。核心业务模块 `local` 仅仅是标准的 Elixir 并发代码,对分布式机制完全解耦且一无所知。赋予其分布式能力的关键在于项目配置文件 `mix.exs` 中引入的高阶分布式编排库——**Swarm**。在 BEAM 生态中,引入第三方依赖不仅仅是导入一组静态函数库,更意味着直接将一整套自主运转的后台进程组引入到应用系统内部。这一行依赖声明,就在系统启动时拉起了一组负责监听节点拓扑变动、维护全局名称注册表以及管理生命周期的常驻进程。 > “While many people do use BEAM distribution, distributed BEAM in production, there are also many people who would tell you like maybe not use that thing... but I would also say that these issues are purely mechanical, which means that they can be fixed in the implementation without significantly changing or without changing at all the interface, the contract, the way we use this thing.” — Saša Jurić - **依赖项的双重属性**:在常见语言中,依赖库仅提供供调用的代码逻辑;在 BEAM 体系下,依赖项自身可以携带常驻的并发进程(Activities / Processes)嵌入到系统的运行拓扑中。 - **Swarm 编排器职责**:负责管理分布式注册表,监听节点的在线与离线事件,并自动实现进程在存活节点之间的漂移与状态重构。 - **内聚性优势**:不再依赖外部笨重的外部协调服务(如独立部署的 ZooKeeper 或 Consul 代理),协调机制直接以内置参与者的形式运行在宿主语言的运行时内部。 ### [35:13](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2113s) 三行代码的分布式:基于 Swarm 的服务注册与位置透明性 Saša Jurić 展示了如何通过极其简洁的方式构建分布式系统。在启动了名为 Swarm 的库之后,在集群中的任意位置启动一个具名服务(named service)仅仅退化为调用一个特定的 Swarm 函数。该函数会自动在集群中挑选一个节点启动对应进程,并在内部维护给定名称与该进程之间的映射关系。当需要查找并调用该服务时,只需调用另一个 Swarm 函数并传入名称,它就会返回一个 PID(进程标识符)。 在 BEAM 虚拟机中,PID 是一个具备位置透明性(location transparency)的数据类型。无论目标进程位于本地节点还是远程集群节点,绝大多数操作 PID 的函数表现完全一致,开发者根本无需关心物理拓扑。由于底层基础设施透明地抹平了网络差异,开发者直接将拿到的 PID 传给普通的 BEAM 函数即可直接通信。Saša 强调,整套分布式能力的引入仅仅花费了三行代码,侧边没有任何额外运行的操作系统进程、容器、虚拟机或第三方服务;即便在完全断开外网的环境下,这套演示依然顺畅运行。更进一步,系统的用户界面也是完全由 Elixir 代码驱动的,甚至没有手写 JavaScript,整套系统在技术上表现出高度的一致与内聚。 ```mermaid flowchart TD accTitle: Swarm 分布式服务注册与位置透明调用流程 accDescr: 展示客户端通过 Swarm 注册并解析服务 PID,进而透明调用本地或远程进程的过程。 subgraph Cluster["分布式 BEAM 集群"] Client["客户端 Elixir 代码"] Swarm["Swarm 分布式注册表"] subgraph NodeA["节点 A (本地)"] P1["服务进程 A"] end subgraph NodeB["节点 B (远程)"] P2["服务进程 B"] end end Client -->|"1. swarm_register(name)"| Swarm Swarm -->|"2. 调度并启动"| P2 Client -->|"3. swarm_whereis(name)"| Swarm Swarm -->|"4. 返回统一 PID"| Client Client -->|"5. 透明消息发送 / 调用"| P2 ``` - 在 BEAM 集群中,PID 是全局通用的“位置透明”标识符,本地进程与跨节点远程进程的调用语法完全相同。 - 实现具备容错与服务发现的分布式架构仅需大约三行 Elixir 代码,无需依赖外部编排系统或代理。 ### [36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) 技术单一性(Technical Uniformity):系统 A 与系统 B 的真实对比 Saša 引用了其著作《Elixir in Action》中的一张真实项目对比表,回顾了他在 2010 年代初并行参与维护的两套系统。系统 A 最初选型的核心技术对现代软件系统天然伴随的高并发、高可用挑战缺乏底层支持。面对这些挑战,团队不得不将控制权退让给操作系统层面:他们不得不运行大量的 OS 进程,在需要更好并发支持的地方引入其他编程语言,并采购大量的第三方中间件产品。虽然业务需求最终得以勉强满足,但解决方案的技术复杂度与技术门槛高得惊人,新入职的初级工程师需要消化海量的概念才能有信心动手改动代码。 与之形成鲜明对比的是系统 B。该系统基于运行在 BEAM 之上的 Erlang 实现。BEAM 常被称为“专为代码打造的操作系统”,因为运行时的语言接口本身就直接提供了类似操作系统的能力(如进程隔离、并发调度、故障恢复)。因此,团队完全不需要下沉到宿主 OS 层面去缝合零件,而是用纯粹的 Erlang 在同一个代码库内搞定了一切,在运行时每个机器节点只需运行单个 OS 进程。尽管自研的 Erlang 方案无法在所有花哨功能或极端峰值性能上百分之百匹敌成熟的商业第三方软件,但它完全足以满足业务需求,并换来了无价的“技术单一性”(Technical Uniformity)。 > “It is in fact sometimes said that BEAM is an operating system for our code, and if I have the operating system directly in my runtime and I have the language as the main interface, then I don't need to fall back to the OS level.” —— Saša Jurić | 架构维度 | 系统 A(传统拼凑架构) | 系统 B(Erlang / BEAM 统一架构) | |:--- |:--- |:--- | | **基础运行环境** | 语言本身缺乏高可用支持,下沉依赖操作系统及外部服务 | BEAM 自带进程调度与故障隔离(“针对代码的操作系统”) | | **技术栈构成** | 多语言混杂、大量第三方中间件产品与 OS 进程 | 单一语言(Erlang)、单项目工程、每机单 OS 进程 | | **技术复杂度与门槛** | 极高;新手需理解多种中间件协议与不同抽象模型 | 极低;只需掌握一套语言概念即可参与全栈开发 | | **运维与交付负担** | 需编排 5-10 个不同组件,监控与日志高度碎片化 | 统一接入点,调试、度量指标与日志采集高度集约 | ### [38:10](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2290s) 降本增效:告别“胶水代码”与细分专家壁垒 Saša 阐明,追求技术单一性并不是为了单一而单一,而是因为它能在整个软件工程生命周期中释放出巨大的工程红利。如果整套系统由单一技术(例如 Elixir)实现,开发团队在日常工作中的摩擦阻力将显著降低:从本地搭建开发环境、编写单元测试,到配置持续集成(CI)流水线以及生产部署,管理一个纯粹的单一系统远比同时协调编排 5 到 10 个独立运转的组件要轻松得多。在生产环境中,团队只需监控一个进程,日志收集、指标埋点和交互式调试都有唯一且强大的切入点。 更为关键的是团队协作维度的质变。当技术门槛被大幅拉低,团队不再需要人为划分狭隘的专业技术壁垒。团队不再被迫聘用专门的 Redis 专家、Nginx 专家、ZooKeeper 专家、Kafka 专家或 Kubernetes 专家;新员工入职后只需学习 Elixir,便能立刻对系统整体做出实质性贡献。此外,工程师们也能从充斥着 YAML、INI、JSON、TOML、XML 等非图灵完备且工具链粗糙的 Ad-hoc DSL 地狱中解脱出来。整个软件系统完全可以使用一门图灵完备、兼具编译期与运行期灵活性、能无缝对接 OS 底层能力的通用语言进行端到端描述。 > “And so we don't need to have all these narrow specialists — we don't need to have like a Redis specialist, Nginx specialist, HAProxy specialist, ZooKeeper specialist, Kafka specialist, Kubernetes specialist, and so on and so forth. And we don't need to wrestle with all these YAMLs and INIs and JSONs and TOMLs and XMLs and other kind of ad hoc DSLs and their quite substandard tooling.” —— Saša Jurić ### [40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) BEAM 的终极潜力:兼顾“快速启动”与“长远扩展”的双赢 Saša 展望了 BEAM 语言尚未被业界完全挖掘的真正潜力(他坦言目前社区的发展或许只走到了一半)。他描绘了一个理想的工程场景:当开发者需要构建一个面向 Web 的中小型 CRUD 系统时,只需新建一个 Elixir 工程,引入少量依赖项,5 分钟之内便能一应俱全——直接在同一个项目中获得开箱即用的分布式能力、带复制的高可用 SQL 数据持久化能力,没有任何多余的外部依赖,这构成了名副其实的“极简起步”(Simple Start)。 这种极简起步之所以不同于常规的“玩具框架”,是因为它的基石是一门成熟的图灵完备语言,其底层承载的是拥有三十余年工业级洗礼与海量各色项目验证的 BEAM 虚拟机。这意味着团队在业务规模急剧扩大、面临极端高并发与分布式复杂挑战时,完全有底气在现有架构上持续演进,而根本不需要经历“推倒重写”的阵痛。以往软件工程界认为“快速原型开发选型”与“支撑超大规模长远系统选型”不可兼得的人工假象被彻底打破。Saša 总结道,BEAM 正是这种融合能力的根基,它当之无愧是 Erlang 与 Elixir 的“灵魂”。 在演讲结尾,Saša 为现场听众提供了其著作《Elixir in Action》的专享购书优惠代码(当天享有 5 折,后续提供 4 折优惠),并宣布向现场观众赠送两本实体书以及若干电子书名额。他风趣地提醒大家演讲结束后可直接上台索取,打趣道“你们甚至不用假装对其他话题感兴趣”,并在引导大家对本次分享打分反馈后圆满结束了整场演讲。 > “The artificial trade-off of having to choose between a quick start technology and the long run one disappears, flies out the window, and I get both in the same piece of technology. And this is all in my opinion possible... owing to BEAM, this wonderful runtime which is in my view indeed the soul of Erlang and Elixir.” —— Saša Jurić - **BEAM 的双重杀手锏**:消除了“易于敏捷起步的轻量技术”与“支撑海量规模的高可靠技术”之间的割裂对立。 - **书籍福利**:Saša 在现场提供了《Elixir in Action》的限时 50% / 40% 折扣代码,并免费派送了两本纸质版及多份电子版书籍。 ## Notable quotes > [17:39](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1059s) This in my mind is what high availability is about it's not about chasing some mythical amount of nines of uptime it's about having a system which is there for its users which is ultimately its primary if not the only purpose. — Saša Jurić > [29:51](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=1791s) Because in fact in BEAM, concurrency and distribution are one and the same thing. — Saša Jurić > [15:36](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=936s) BEAM essentially favors a fair distribution of CPU time for every single activity in the system, or in other words, it promotes the progress of the system as a whole at the expense of the maximum efficiency of any single activity in the system. — Saša Jurić > [40:00](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2400s) The artificial trade-off of having to choose between a quick start technology and the long run one disappears, flies out the window, and I get both in the same piece of technology. — Saša Jurić > [36:30](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2190s) It is in fact sometimes said that BEAM is an operating system for our code, and if I have the operating system directly in my runtime and I have the language as the main interface, then I don't need to fall back to the OS level. — Saša Jurić > [12:40](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=760s) Now an important thing about BEAM is that when a process crashes, everything else progresses, right? So most of the system still works. — Saša Jurić > [38:10](https://www.youtube.com/watch?v=JvBT4XBdoUE&t=2290s) And so we don't need to have all these narrow specialists — we don't need to have like a Redis specialist, Nginx specialist, HAProxy specialist, ZooKeeper specialist, Kafka specialist, Kubernetes specialist, and so on and so forth. — Saša Jurić ## Mentioned Saša Jurić, Joe Armstrong, BEAM, Erlang, Elixir, Swarm, Elixir in Action, GOTO Conferences, Redis, Nginx, HAProxy, ZooKeeper, Kafka, Kubernetes ## Video description This presentation was recorded at GOTO Chicago 2019. #gotocon #gotochgo http://gotochgo.com Saša Jurić - Author of "Elixir in Action” @sasajuric5850 ABSTRACT Whether you're developing a small web site or a large-scale distributed system, Erlang and Elixir are great tools for building server-side systems. Both languages can help you start quickly and deal with highly complex problems at a large scale. This talk aims to explain what makes Erlang and Elixir suitable for such tasks. We'll look past the syntax and the ecosystem, focusing instead on the concurrency model of these languages. Combining a bit of high-level theory and a couple of demos, we'll examine some important properties of Erlang/Elixir concurrency, with a special emphasis on why these properties are very relevant when building highly available systems. The talk targets experienced backend developers, but no knowledge of Erlang or Elixir is required. You will walk away from [...] Download slides and read the full abstract here: https://gotochgo.com/2019/sessions/712 RECOMMENDED BOOKS Saša Jurić • Elixir in Action • https://amzn.to/2RZh5eN McCord, Tate & Valim • Programming Phoenix 1.4 • https://amzn.to/3zcUqj4 https://twitter.com/GOTOcon https://www.linkedin.com/company/goto- https://www.instagram.com/goto_con https://www.facebook.com/GOTOConferences #erlang #elixir #programming #DistributedSystems #FunctionalProgramming #SasaJuric CHANNEL MEMBERSHIP BONUS Join this channel to get early access to videos & other perks: https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/join Looking for a unique learning experience? Attend the next GOTO conference near you! Get your ticket at https://gotopia.tech Sign up for updates and specials at https://gotopia.tech/newsletter SUBSCRIBE TO OUR CHANNEL - new videos posted almost daily. https://www.youtube.com/user/GotoConferences/?sub_confirmation=1 [Source](https://www.youtube.com/watch?v=JvBT4XBdoUE)

Source quotes

[17:39] Saša Jurić: This in my mind is what high availability is about it's not about chasing some mythical amount of nines of uptime it's about having a system which is there for its users which is ultimately its primary if not the only purpose. [29:51] Saša Jurić: Because in fact in BEAM, concurrency and distribution are one and the same thing. [15:36] Saša Jurić: BEAM essentially favors a fair distribution of CPU time for every single activity in the system, or in other words, it promotes the progress of the system as a whole at the expense of the maximum efficiency of any single activity in the system. [40:00] Saša Jurić: The artificial trade-off of having to choose between a quick start technology and the long run one disappears, flies out the window, and I get both in the same piece of technology. [36:30] Saša Jurić: It is in fact sometimes said that BEAM is an operating system for our code, and if I have the operating system directly in my runtime and I have the language as the main interface, then I don't need to fall back to the OS level. [12:40] Saša Jurić: Now an important thing about BEAM is that when a process crashes, everything else progresses, right? So most of the system still works. [38:10] Saša Jurić: And so we don't need to have all these narrow specialists — we don't need to have like a Redis specialist, Nginx specialist, HAProxy specialist, ZooKeeper specialist, Kafka specialist, Kubernetes specialist, and so on and so forth.