老船长有一张祖传藏宝图，怕沉船弄丢。他先雇了三个抄写员，把图各抄一份锁进三只保险柜，纸墨和柜子都贵得吓人，而且三只柜子同船遇难时照样一起泡汤。后来一位数学画师献计：不必整张抄写，只要把图裁成 4 片，再按隐藏的数学规律画出 2 片「影子碎片」，把 6 片分装进不同的漂流瓶；海上丢几瓶都不怕，只要手里还剩任意 4 片，他就能用一副罗盘把整张宝藏图复原。这个故事里，藏宝图是数据，抄本是副本，影子碎片是校验块，而那副「罗盘」就是今天的主角——纠删码（Erasure Coding）。分布式存储系统正是靠它，把三副本 300% 的开销压缩到 130%~150%，同时保证数据不丢。

岗位关联

对 AI 从业者：大模型训练、数据湖、云盘背后都有分布式存储；懂纠删码，你才能讲清「存储成本怎么省、故障怎么扛」，这是架构设计与面试的高频硬通货。

目录
  1. 可视化演示
  2. 三副本之痛：为什么需要纠删码
  3. 核心原理：撕开、画影、复原
  4. 数学基础：特殊颜料与罗盘
  5. 关键算法：三个画师流派
  6. 性能特性：省下的纸、费掉的墨
  7. 工程实践：老船长的航海手册
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

三副本之痛：为什么需要纠删码

老船长最初防丢的办法非常朴素：雇三个抄写员，把藏宝图各抄一份，锁进三只保险箱。纸张、墨水和保险箱都是真金白银，存储成本直接翻到三倍；更要命的是，三只保险箱若同船沉没，三份抄本一起泡汤。分布式系统最早的「三副本」策略正是如此——简单、可靠，但贵。

在 HDFS 这类系统里，一份数据默认存三份，任何一台机器坏了，另外两台还能读。可是存储硬件是数据中心里最大的成本项之一，三副本意味着 300% 的物理开销。工程师们开始寻找「花 1.5 份的钱，买到接近 3 份的安心」的办法，答案就是纠删码（Erasure Coding, EC）。

纠删码思想最早出现在 RAID（磁盘冗余阵列）中，字面意思是「擦除之后还能编解码」。它不再整份复制数据，而是把原始数据切成 k 块，再生成 m 块校验数据，总共存 n = k + m 块。任意丢失不超过 m 块，都能通过解方程组还原原始数据。这也是「冗余」从量变到质变的一步：冗余不一定非得是完整副本，也可以是数学上的「影子」。

老船长算了笔账：抄三份花 3 倍纸墨，请画师做「影子碎片」只要 1.5 倍纸墨。省下来的钱，足够给船队再买三张新帆——至于画师作画要花多少时间，那是另一笔账，下节慢慢算。

存储开销率=nk×100%=k+mk×100%\displaystyle \text{存储开销率} = \frac{n}{k} \times 100\% = \frac{k + m}{k} \times 100\%
通俗解释：开销率 = 实际占用的物理空间 ÷ 用户真正要的数据大小。三副本是 3/1 = 300%，而 RS(6,3) 是 9/6 = 150%。
  1. 物理存储量系统为保护这份数据而实际写进磁盘的总块数，记作 n = k + m。分子越大，花的钱越多。
    物理存储量=k+m=n\text{物理存储量} = k + m = n
  2. 有效数据量用户真正需要的那一份数据，被切成 k 块，记作 k。分母是固定的。
    有效数据量=k\text{有效数据量} = k
  3. 开销率做除法并化为百分比。三副本 k=1, n=3，开销率 300%；纠删码 k=6, m=3 时开销率 9/6 = 150%，省下整整一半磁盘。
    nk=96=1.5=150%\frac{n}{k} = \frac{9}{6} = 1.5 = 150\%
  4. 代价转移省下的存储并没有消失，而是转移成编码计算和修复带宽的开销，这正是后面要展开的「省钱却费墨」。
    省下的成本→解码计算+修复带宽\text{省下的成本} \rightarrow \text{解码计算} + \text{修复带宽}

核心原理：撕开、画影、复原

画师把图裁成 4 片（k=4），又按一套「影子规律」画出 2 片原图上根本不存在的碎片（m=2）。这 6 片被分装进 6 只漂流瓶。画师立下规矩：只要船队能找回任意 4 片——哪怕是 2 片原图加 2 片影子——他都能用罗盘复原整张藏宝图。这里，k 是数据分块数，m 是校验块数，k + m 构成一个 EC 条带（stripe）。

编码时，k 个数据块与 m 个校验块一起分布在不同的存储节点上。与传统副本最大的区别是：副本要求找「特定的一份」，而纠删码只要求凑够任意 k 块。因为编码过程本质是给 k 个未知数配上 k 个独立方程，只要方程够数，解就唯一。校验块不是数据的备份，而是与原数据线性相关的「影子」，这也是它能参与解方程的原因。

「任意 k 块可恢复」为什么成立？把 k 个数据块看作 k 个未知数，m 个校验块提供 m 个额外线性方程，加上 k 块自身的信息，累计 k 个独立方程就能解出全部未知数。因此只要丢失不超过 m 块，系统中剩余块数不少于 k，数学上就一定有唯一解。

老船长把 6 只漂流瓶分航线投海，即使风暴吞掉 2 瓶，画师只要拿到 4 瓶就能重画宝图；若吞掉 3 瓶，就再也拼不出完整的图——这就是「容错上限 = m」的最直观画面。

n=k+m,容错上限=m 块,冗余率=mk×100%\displaystyle n = k + m,\qquad \text{容错上限} = m\ \text{块},\qquad \text{冗余率} = \frac{m}{k} \times 100\%
通俗解释：k 是原图片数，m 是影子碎片数；只要丢失数 ≤ m，数学上一定能复原；再多丢一片就再也拼不全。
  1. n = k + mk 个数据块加 m 个校验块构成一个条带，n 是实际存储总块数。
    n=k+mn = k + m
  2. 容错上限 = m最多同时坏 m 块仍可恢复；坏 m+1 块，剩余块数不足 k，一定不可恢复。
    可恢复条件：丢失数≤m\text{可恢复条件：丢失数} \le m
  3. 冗余率 m/k每 k 份数据要搭 m 份校验，冗余率越低越省空间，但容错也越低。
    冗余率=mk\text{冗余率} = \frac{m}{k}
  4. 任意 k 块可恢复等价于「k 个未知数、k 个独立方程」有唯一解，与缺的是数据块还是校验块无关。
    解的存在唯一性⇔rank=k\text{解的存在唯一性} \Leftrightarrow \text{rank} = k

数学基础：特殊颜料与罗盘

为什么影子碎片能「算」出来？因为画师用的是一盒特殊颜料：里面只有 256 种颜色，编号 0~255，恰好对应计算机里的一个字节。这个封闭的颜料盒在数学上叫「有限域 GF(2^8)（伽罗瓦域）」。在这里，加减法是异或（XOR），乘法靠查表完成，一切运算都不会产生小数和舍入误差——处理字节数据时天衣无缝。

编码时画师取出一张「图纸」：范德蒙德（Vandermonde）矩阵 V，第 i 行第 j 列是 x_i 的 j 次幂，x_i 取 1 到 m 的编号。把 V 乘上 k 个数据块组成的列向量 D，就得到 m 个校验块。写成线性代数语言就是 C = V · D。解码是反过来的过程：从完整编码矩阵中挑出现存 k 块对应的 k 行，组成子矩阵 V_sub，求逆后再乘以现存数据 C_received，即可还原全部数据块。

在 GF(2^8) 的颜料盒里，颜色只有 256 种，但混合规则处处闭环，永远不会调出「色差」。画师只要保证影子碎片的坐标不重复，罗盘就永远指得到回家的路——这就是纠删码能在真实系统里逐字节恢复数据的根基。

C=Vm×k⋅Dk×1,D=Vsub−1⋅Creceived\displaystyle \mathbf{C} = \mathbf{V}_{m\times k}\cdot\mathbf{D}_{k\times 1},\qquad\mathbf{D} = \mathbf{V}_{\text{sub}}^{-1}\cdot\mathbf{C}_{\text{received}}
通俗解释：V 是「画影子碎片的模版」，求逆是「用影子反推原图」的逆向罗盘；所有运算都在 256 色的封闭颜料盒里进行。
  1. V 矩阵（范德蒙德）第 i 行为 [1, x_i, x_i², …, x_i^{k-1}]，保证 m 个生成方程彼此独立。
    Vi=[1, xi, xi2, …, xik−1]\mathbf{V}_{i} = [1,\ x_i,\ x_i^2,\ \dots,\ x_i^{k-1}]
  2. 编码 C = V · D矩阵乘法把 k 个数据块线性组合成 m 个校验块，乘法在 GF(2^8) 中逐字节完成。
    ci=∑j=0k−1vi,j dj(mod GF(28))c_i = \sum_{j=0}^{k-1} v_{i,j}\, d_j \quad (\text{mod } GF(2^8))
  3. 取子矩阵 V_sub从完整编码矩阵选出现存 k 块对应的行，得到 k×k 方阵；只要丢失 ≤ m 块，它一定可逆。
    Vsub=V[现存块的行索引]\mathbf{V}_{\text{sub}} = \mathbf{V}[\text{现存块的行索引}]
  4. 求逆还原 D用高斯消元在有限域中求 V_sub 的逆，再乘现存数据，逐字节恢复原始数据。
    D=Vsub−1 Creceived\mathbf{D} = \mathbf{V}_{\text{sub}}^{-1}\,\mathbf{C}_{\text{received}}

关键算法：三个画师流派

有了数学罗盘，画师也分化出流派。最经典的是 Reed-Solomon（RS）码：一位孤胆画师，每片影子碎片都关联全图，能抗击任意 m 块丢失，但修复一块碎片时，要跑遍全球取回 k 块再重算，网络开销大。它的优点是容错能力最强、数学最优雅，缺点是修复时「兴师动众」。

LRC（局部冗余码）则是「小组长」模式：把碎片分成多个小组，每组内部生成一个局部校验块，组外再配全局校验块。丢了一块碎片，只需找组内的小组长借 l 块即可恢复，修复带宽从 k 块降到 l 块；代价是多花一些局部校验块的存储。再生码（Regenerating Code）则是「接力画师团」：修复时每个存活节点只传一小份「素描」，新节点把素描组合起来重新画出丢失碎片，使修复带宽达到理论最优。

老船长在航图上批注：孤胆画师（RS）适合「不常坏但必须极稳」的传世宝图；小组长模式（LRC）适合「船队常颠簸」的日常运输；接力画师团（再生码）成本最低，但画师们要配合默契。选哪个流派，取决于海况和预算。

ηLRC=k+l+gk,γRS=k⋅B,γrepair=d⋅β\displaystyle \eta_{\text{LRC}} = \frac{k + l + g}{k},\qquad\gamma_{\text{RS}} = k \cdot B,\qquad\gamma_{\text{repair}} = d \cdot \beta
通俗解释：LRC 用多一点存储换少很多修复流量；RS 修复要读全量 k 块；再生码让 d 个邻居各传一点 β 就够。
  1. LRC 存储开销 ηk 数据块 + l 局部校验 + g 全局校验，总块数除以 k。
    ηLRC=k+l+gk\eta_{\text{LRC}} = \frac{k + l + g}{k}
  2. RS 修复带宽 γ_RS丢一块要读 k 块参与重算，每块 B 字节，总传输 kB。
    γRS=k×B\gamma_{\text{RS}} = k \times B
  3. 再生码修复带宽 γ招呼 d 个邻居，每个邻居只传 β 字节，总传输 dβ 通常小于 kB。
    γrepair=d×β\gamma_{\text{repair}} = d \times \beta
  4. 局部性（locality）LRC 的「小组长」把修复读取范围从全条带缩小到组内，这是它在云存储中流行的核心原因。
    局部性=l(l≪k)\text{局部性} = l \quad (l \ll k)

性能特性：省下的纸、费掉的墨

碎片库最大的好处是省纸，但每次读图都有代价。要读原图，必须先把碎片按数学规律「拼」回来，这个过程叫解码，需要额外的 CPU 计算；一旦某块碎片丢失，修复时还要从其他节点传数据回来重建，占用网络带宽。这就是「省下的纸、费掉的墨」。

存储效率定义为 k/(k+m)：3 副本只有 33%，RS(6,3) 有 67%。但 k 越大，单块丢失时重建需要读取的数据越多、修复时间越长；修复时间越长，期间再坏一块的概率越大，可靠性反而下降。因此 k 不能盲目调大。性能指标主要有三个：存储效率、修复带宽（重建一块丢失数据需要跨网传输的字节数）、解码计算开销。

工程上还关注「降级读」：节点损坏时读请求可以绕过坏块、用其他块临时计算出数据，让业务无感。修复分成两个阶段：先定位并重建缺失块，再后台写回新节点。整个过程越短，系统处于「少一块」的危险状态就越短，数据越安全。

老船长在航海日志里写下：每省一张纸，就要多费一份墨。真正的高手不是省到极致，而是在纸、墨、风浪之间找到平衡——这正是参数调优的本质。

存储效率=kk+m,修复带宽RS=k×B,修复时间∝k⋅B带宽\displaystyle \text{存储效率} = \frac{k}{k+m},\qquad\text{修复带宽}_{\text{RS}} = k \times B,\qquad\text{修复时间} \propto \frac{k \cdot B}{\text{带宽}}
通俗解释：k 越大越省纸，但丢一片时要把 k 片都找回来重画，耗时也更久。
  1. 存储效率有效数据占总存储的比例；3 副本 1/3，RS(6,3) 为 6/9 = 2/3。
    kk+m=69≈67%\frac{k}{k+m} = \frac{6}{9} \approx 67\%
  2. RS 修复带宽 kB重建一块丢失碎片需读 k 个存活块，每块 B 字节。
    k×Bk \times B
  3. 修复时间传输 kB 数据所需时间，k 越大修复越慢，系统长时间少一块。
    k⋅B网络带宽\frac{k \cdot B}{\text{网络带宽}}
  4. 降级读不等待完整重建，直接用现存块临时算出被读数据，保证业务连续。
    降级读=在线重构缺失块\text{降级读} = \text{在线重构缺失块}

工程实践：老船长的航海手册

老船长把教训写成了手册。第一条：热门的宝图整张挂墙上，读得快；陈年的宝图收进碎片库，省地方。对应存储系统就是：热数据用副本，冷数据用纠删码，或者在同一集群中按目录或策略混用。第二条：选参数要看海况——磁盘故障率高、修复带宽紧张时，m 要取大些；追求读性能时 k 取小，甚至直接用副本。

HDFS 3.0 起内置纠删码，支持 RS-6-3、RS-3-2 和 XOR 等编码策略，运行时可动态切换。对象存储更是把 EC 当作默认能力：AWS S3 的存储类、阿里云 OSS 的深度归档、MinIO 默认的纠删码模式，都用它把冗余成本压到 130%~150%。工程上参数有规律：k 通常取 6~12，冷数据集群 k 取大、m 取 3~4。

可靠性如何粗估？假设单盘故障率 p（如年化 1%），修复一块盘平均需要 t，那么一年内数据丢失概率近似为：

手册最后一行，老船长写道：副本是笨办法但最稳，纠删码是巧办法但不免费；真正的高手，是知道哪张图该挂墙上、哪张图该进碎片库的人。

Pdata loss≈(k+m)×(p×trepair)m+1\displaystyle P_{\text{data loss}} \approx (k+m) \times \left( p \times t_{\text{repair}} \right)^{m+1}
通俗解释：p 是单盘在单位时间内的故障率，t_repair 是修复时间；要「坏 m+1 块」才会真丢数据，所以指数是 m+1。
  1. p（故障率）单块盘在单位时间内的年化故障率（AFR），如 1%/年。
    p=AFR≈0.01p = \text{AFR} \approx 0.01
  2. t_repair（修复时间）从发现坏块到重建完成的平均时间，需折算到与 p 相同的时间单位。
    trepair=平均修复时长t_{\text{repair}} = \text{平均修复时长}
  3. p × t修复窗口内某一特定块再坏的概率；窗口越短，这个值越小。
    p×trepairp \times t_{\text{repair}}
  4. (p·t)^(m+1)需要 m+1 块同时在窗口内坏才丢数据；指数越大概率越低。
    (p×trepair)m+1\left(p \times t_{\text{repair}}\right)^{m+1}
  5. (k+m) 倍条带里共有 n 块「候选者」，块数越多起点越多，风险线性放大。
    (k+m)×⋯(k+m) \times \cdots

AI 应用场景

AI 训练数据湖归档

阶段：数据存储与生命周期管理

解决的问题：训练数据（图片、视频、日志）体量大且访问频率低，三副本让存储成本膨胀到 300%；纠删码把冗余压到 130%~150%，同时容忍多节点故障，是冷热分层中「冷层」的标配。

具体案例：某自动驾驶公司每年采集 10 PB 路测数据，冷数据归档到对象存储并启用 EC(12+4)，存储成本下降约 60%；重新拉取训练时，多条带并行解码，读取吞吐仍能达到 GB/s 级。

大模型 Checkpoint 保护

阶段：模型训练容错

解决的问题：千卡训练集群中单节点故障可能导致最新权重 checkpoint 损坏；用副本保护太贵，用 EC 保护则只需少量校验块，坏盘不超过 m 块时可在线恢复，训练不中断。

具体案例：某大模型训练任务每 30 分钟写一次 20 GB 的 checkpoint 到共享存储，存储端采用 RS(8,4)。一次机房断电损坏 3 块磁盘，训练任务通过「降级读」继续拉取权重，零中断完成本轮保存。

个人云盘与对象存储容灾

阶段：数据持久性保障

解决的问题：网盘底层对象存储需要 11 个 9 的持久性，纯副本成本不可接受；EC 以少量校验块换来机架级容错，同时配合后台定期巡检。

具体案例：主流对象存储服务商在内部将 EC 条带跨机架分布，EC(8+3) 下同时坏 3 台存储服务器也不丢文件；性能分层后，热数据走副本、冷数据走 EC，兼顾延迟与成本。

Python 演示

python97 行
"""Mini Erasure Coding demo in GF(2^8): k=4 data + m=2 parity."""EXP = [0] * 512LOG = [0] * 256 def gf_init():    x = 1    for i in range(255):        EXP[i] = x        LOG[x] = i        x <<= 1        if x & 0x100:            x ^= 0x11D    for i in range(255, 512):        EXP[i] = EXP[i - 255] def gf_mul(a, b):    if a == 0 or b == 0:        return 0    return EXP[LOG[a] + LOG[b]] def gf_div(a, b):    return EXP[(LOG[a] - LOG[b]) % 255 + 255] def build_matrix(k, m):    mat = []    for i in range(k):        mat.append([1 if j == i else 0 for j in range(k)])    for i in range(1, m + 1):        row = []        v = 1        for j in range(k):            row.append(v)            v = gf_mul(v, i)        mat.append(row)    return mat def mat_mul(a, b):    rows, mid, cols = len(a), len(a[0]), len(b[0])    res = [[0] * cols for _ in range(rows)]    for i in range(rows):        for j in range(cols):            s = 0            for t in range(mid):                s ^= gf_mul(a[i][t], b[t][j])            res[i][j] = s    return res def mat_inv(mat, k):    aug = [row[:] + [1 if i == j else 0 for j in range(k)]           for i, row in enumerate(mat)]    for col in range(k):        pivot = None        for r in range(col, k):            if aug[r][col] != 0:                pivot = r                break        assert pivot is not None, "matrix not invertible"        aug[col], aug[pivot] = aug[pivot], aug[col]        inv_p = gf_div(1, aug[col][col])        for j in range(2 * k):            aug[col][j] = gf_mul(aug[col][j], inv_p)        for r in range(k):            if r != col and aug[r][col] != 0:                factor = aug[r][col]                for j in range(2 * k):                    aug[r][j] ^= gf_mul(factor, aug[col][j])    return [row[k:] for row in aug] def encode(data, k, m):    mat = build_matrix(k, m)    vec = [[d] for d in data]    prod = mat_mul(mat, vec)    return [prod[i][0] for i in range(k + m)] def decode(blocks, index, k, m):    mat = build_matrix(k, m)    sub = [mat[i] for i in index]    inv = mat_inv(sub, k)    vec = [[b] for b in blocks]    res = mat_mul(inv, vec)    return [res[i][0] for i in range(k)] def main():    gf_init()    k, m = 4, 2    data = [10, 20, 30, 40]    blocks = encode(data, k, m)    print("encoded blocks:", blocks)    index = [0, 1, 4, 5]    got = [blocks[i] for i in index]    recovered = decode(got, index, k, m)    print("recovered:", recovered)    assert recovered == data, "recovery failed"    print("OK: 4 of 6 blocks enough to recover original data") if __name__ == "__main__":    main()
目的：在 GF(2^8) 有限域上实现一个迷你 RS 纠删码：4 个数据块编码成 6 块，丢弃 2 块后仍能完整恢复原始数据。
  1. x ^= 0x11D有限域里的「进位规则」，让乘法结果永远封闭在 0~255 之间。
  2. build_matrix(k, m)生成单位阵 + 范德蒙德行组成的完整编码矩阵，是画师的「图纸」。
  3. mat_mul` 中 `s ^= gf_mul(a[i][t], b[t][j])GF(2^8) 中加法就是异或，上一行的异或结果作为累加和。
  4. index = [0, 1, 4, 5]模拟丢失第 2、3 块（原索引 2 和 3），剩下 2 数据块 + 2 校验块。
  5. assert recovered == data用断言验证「任意 4 块都能恢复原数据」这一核心性质。

常见误区

误区三副本存了三份，肯定比纠删码更安全、更不会丢数据。

正解在相同总存储空间的约束下（比如都花 9 份空间），三副本只能保护 1 份数据，而 EC(6,3) 能保护 6 份数据且容忍任意 3 块丢失，可靠性反而更高。藏宝图故事里，抄三份意味着三份内容完全相同，一份烧了只能祈祷另一份别同时出事；碎片方案中每片内容不同，坏 3 片内都能重拼。

为何常见：直觉上「份数多 = 更安全」，却忽略了总成本约束与「每份内容相同」这个前提。

误区k 越大，存储效率越高、越省钱，所以 k 应该尽量设大。

正解k 大确实省空间，但修复一块丢失的数据要读 k 块，修复带宽和耗时随之变大；修复窗口越长，期间再坏一块的概率越大，可靠性反而下降。碎片库每片越小、片数越多，重画时需要的「邻居」就越多，凑齐碎片的时间也越长。

为何常见：只盯着存储效率这一项指标，忽略了修复带宽、可靠性与 k 的三角约束。

误区既然 EC 又便宜又抗丢，那把系统里所有副本都换成纠删码就好了。

正解副本读延迟低、写入简单、无需解码；热数据、小文件、延迟敏感场景副本仍是首选。实践中普遍「按策略混用」：热目录走副本，冷目录走 EC。老船长也不会把每天要看的航海图锁进碎片库。

为何常见：看到 EC 省钱就一刀切，忽略了读取性能与实现复杂度的差异。

误区GF(2^8) 也就是对字节做普通的加减乘除，跟数学课学的没区别。

正解有限域里加法是 XOR，乘除靠查表，所有运算封闭在 256 个数内、无任何舍入误差；若按实数域做矩阵求逆，恢复出的字节会带小数，根本无法落盘。就像画师的颜料盒是封闭的：无论如何混色，永远调出盒内 256 种颜色之一。

为何常见：初学线性代数时习惯了实数矩阵，想当然把普通矩阵乘法套到纠删码上。

误区恢复需要任意 k 块，那说明丢 k 块也能恢复，容错上限是 k。

正解「任意 k 块可恢复」的前提是系统里还剩至少 k 块，即丢失 ≤ m 块。丢 k 块意味着只剩 m 块，方程数（m）少于未知数（k），一定无解。容错上限是 m 而不是 k。漂流瓶丢到第 m+1 只时，画师手里的碎片就不够拼图了。

为何常见：把「恢复需要 k 块」与「可以丢 k 块」两个命题混为一谈。

面试题

Q1. 纠删码 EC(k=4, m=2) 最多能容忍丢失多少块仍可恢复？

单选题 · easy

  • A.任意 2 块← 正确答案
  • B.任意 4 块
  • C.只能丢校验块
  • D.只能丢 1 块

答案：A。m=2 即最多容忍 2 块丢失，剩下 4 块（k 块）足够解出全部数据；若丢 3 块只剩 3 块，未知数大于方程数必然无解。就像漂流瓶丢超过 2 只，碎片就拼不全宝图。B 是「恢复需要 4 块」的误读，C、D 都错误地限制了丢失对象。

Q2. RS 纠删码的数学基础通常建立在什么代数结构上？

单选题 · easy

  • A.实数域 R
  • B.有限域 GF← 正确答案
  • C.复数域 C
  • D.整数域 Z

答案：B。RS 码在有限域（如 GF(2^8)）上运算，保证字节级精确、无舍入误差。实数域矩阵求逆会产生小数误差；复数域与整数域不满足编码所需的封闭可逆性。这就像画师的颜料盒只有 256 种颜色，混色永远不出错。

Q3. 某系统采用 EC(k=6, m=3)，其存储开销率（物理空间 ÷ 有效数据）约为多少？

单选题 · mid

  • A.150%← 正确答案
  • B.200%
  • C.50%
  • D.300%

答案：A。存储开销率 = (k+m)/k = 9/6 = 150%。三副本是 300%，EC(6,3) 用 9 份空间保护 6 份数据，比三副本用 9 份空间保护 3 份数据效率高出一倍。B、C、D 分别是误算或三副本/误除的数值。

Q4. RS 纠删码修复一块丢失的数据块时，通常需要读取多少块参与重建？

单选题 · mid

  • A.1 块
  • B.k 块← 正确答案
  • C.m 块
  • D.k+m 块

答案：B。重建时用任意 k 块现存数据重新编码，最典型做法是读取 k 块。读 1 块信息不足；m 块只是校验块数量；读 k+m 块是全部读取、白白浪费带宽。这就像画师重画一片影子碎片，至少要把 k 片碎片都拿回来当参照。

Q5. 相比三副本，纠删码的特点包括哪些？

多选题 · mid

  • A.存储开销更低← 正确答案
  • B.修复带宽更大← 正确答案
  • C.引入编码计算开销← 正确答案
  • D.写入延迟更低

答案：ABC。EC 用更少空间换同等容错；但修一块要跨网读 k 块并做矩阵运算，修复带宽和 CPU 开销都更大。副本写入只需复制，写延迟更低，所以 D 错误。省下的纸终究要费在墨上。

Q6. LRC（局部冗余码）相比 RS 的核心改进是什么？

单选题 · hard

  • A.提高存储效率
  • B.降低修复带宽← 正确答案
  • C.提高写入速度
  • D.简化编码流程

答案：B。LRC 引入「小组长」局部校验块，丢块时只需组内读取 l 块即可恢复，修复带宽从 k 块降到 l 块。它用少量额外存储换修复效率；存储效率、写速度、编码复杂度均非其主要优化目标。

Q7. 分布式存储中选择纠删码参数 k、m 时，需要考虑哪些因素？

多选题 · mid

  • A.数据冷热程度← 正确答案
  • B.节点故障率← 正确答案
  • C.修复带宽上限← 正确答案
  • D.运维人员数量

答案：ABC。热数据延迟敏感选小 k 或副本，冷数据选大 k 省空间；故障率越高 m 要越大；网络带宽决定修复是否能及时完成，直接影响可靠性估算。运维人数属于管理因素，不参与编码参数决策。

Q8. 关于再生码与 RS 的比较，下列说法正确的有？

多选题 · hard

  • A.再生码显著降低修复带宽← 正确答案
  • B.RS 修复时需读取任意 k 个块← 正确答案
  • C.再生码编码复杂度必然更低
  • D.再生码适合大文件存储场景← 正确答案

答案：ABD。再生码让 d 个节点各传 β 字节协作重建，总修复带宽 dβ 通常远小于 RS 的 kB，故 A 正确；RS 修复需读 k 块是基本操作，B 正确；再生码引入更复杂的符号计算，编码复杂度通常更高而非更低，C 错误；再生码修复优势在大文件、跨多节点场景更明显，D 正确。

Q9. 以下哪个场景最适合使用纠删码？

单选题 · easy

  • A.内存缓存加速
  • B.对象存储冷数据← 正确答案
  • C.CPU 寄存器
  • D.网络路由转发

答案：B。冷数据访问少、容量大，是 EC 的主战场：省存储、抗故障。缓存追求低延迟，适合副本或分布式缓存；寄存器与路由转发关注性能而非持久化冗余。老船长的陈年宝图就该进碎片库。

Q10. 在 GF(2^8) 有限域中，任意非零元素 a 的 255 次幂 a^255 等于多少？

单选题 · extreme

  • A.等于 0
  • B.等于 1← 正确答案
  • C.等于 255
  • D.等于 a

答案：B。GF(2^8) 的乘法群共有 255 个非零元素，由有限域性质（费马小定理的推广），任意非零元素满足 a^255 = 1。这是编码矩阵在有限域中可逆、纠删码能可靠解码的数学根基。A、C、D 均不符合群论结论。