内存翻倍,任务照样挂?
Driver 报了 OOM,你把 executor 内存从 8G 加到 16G,任务照样挂。因为爆的根本不是 Executor:加错了地方,加多少都没用。Spark OOM 怎么排查,是面试和生产排障里特别高频的问题。很多人的回答是:OOM 了就加内存、加 executor、调大并行度。这些手段能用,但不知道 OOM 发生在哪,加内存就像头疼只吃止疼药:今天压住了,数据一涨还是炸。真正想听的,是你能不能先判断是哪种 OOM,再按 Driver、Executor、Shuffle、数据倾斜和代码写法分别处理。
一句话回答:Spark OOM 排查的核心,不是先加内存,而是先定位。定位三件事:OOM 发生在 Driver 还是 Executor,发生在 Shuffle 还是 Cache,是单个 Task 数据太大,还是数据倾斜。解决时,优先减少单任务的数据量、改掉错误写法,最后才调内存参数。
先看痛点一:Driver OOM 和 Executor OOM,根本不是一回事。Driver 负责调度和收集结果,它爆掉,通常是 collect、toPandas 把大量结果拉了回来,或者广播变量太大、任务元数据太多。Executor 负责执行 Task,它爆掉,通常是单个 Task 数据太大、Shuffle 拉得太多,或者缓存太多、数据倾斜。所以 Driver OOM 你去加 executor memory,基本没用;Executor OOM 只加 driver memory,也没用。打个比方:Driver 像餐厅前台,Executor 像后厨。前台被单据淹没,和后厨锅太小是两回事。
痛点二:只加内存,会掩盖真正的数据问题。一张订单表 10 亿行,其中大客户 user_id 10086 一个人就占了 3 亿行。按 user_id 做 groupBy,这个 key 的 3 亿行会被打到同一个 reduce task。这时候 OOM 的根因不是内存小,而是数据倾斜。把 executor 从 8G 调到 16G,今天可能能跑;明天这个客户涨到 5 亿行,还是会炸。记住:OOM 经常只是现象,数据倾斜、分区不合理、代码写法不当,才是病根。
痛点三:同样是 OOM,日志关键词完全不同。排查第一件事不是改配置,是看日志。Java heap space:JVM 堆内存不够,查 Executor 或 Driver 的堆,和单个 Task 的数据量。GC overhead limit exceeded:时间几乎全花在 GC 上、却回收很少,多半是对象太多或缓存太多。按 JVM 文档,是超过 98% 的时间在做 GC,却回收不到 2% 的堆。Container killed by YARN:容器内存超限,要查 memoryOverhead、堆外内存和 Python 进程。maxResultSize 报错:返回 Driver 的结果太大,查 collect、show 大量数据和 toPandas。ExecutorLostFailure:Executor 被杀了,要接着看是 OOM、节点异常还是容器超限。MetadataFetchFailedException:Shuffle 元数据丢了,它通常是 Executor 挂掉之后的结果,要往前找根因。把这些关键词连成一张路由图:看到任务失败,先问日志关键词是什么。maxResultSize、collect、toPandas,优先查 Driver。Java heap space、ExecutorLost,优先查 Executor 堆内存。YARN memory limits、overhead,优先查堆外和容器内存。某个 Task 特别慢、数据特别大,优先查数据倾斜。报错日志就像体检单:同样是不舒服,贫血、发烧、高血压,处理方式完全不同。
进入核心排查。第一步:先定位 OOM 发生在哪个角色。Driver OOM 常见五种:collect 把几千万行拉回 Driver;toPandas 把大 DataFrame 拉到单机;maxResultSize 超限;任务数太多,Driver 要存大量 task 和 stage 元数据;还有广播变量太大,Driver 构建广播对象时被撑爆。Executor OOM 也有五种:单个 partition 太大、Shuffle read 太大;数据倾斜,几个 task 特别大;cache、persist 了太多表;UDF 创建大量对象,GC 压力过高。定位之后方向就清楚了:Driver 少拉结果回本地,Executor 减少单 Task 数据量;容器被杀关注 memoryOverhead,少数 Task 特别大,就拆大 key 或加盐。看一个最典型的 Driver OOM 写法:filter 完直接 collect,再在本地循环打印。假设结果有 5000 万行,全部拉回 Driver 这一台机器,很容易 OOM。正确写法:分布式写出。每个 Executor 各写各的 parquet 文件,数据不经过 Driver。如果只是调试看几眼,就 limit 100 再 show,只取少量数据。顺带纠正一点:maxResultSize 默认 1g,超了 Spark 会直接中止作业,它其实是在保护 Driver。所以别一看到这个报错就把它调成 0;Driver 适合调度,不适合搬全量数据。Executor 适合计算,但单个 Task 也吃不下过大的分区,这就是第二步。
第二步:看是不是单个 Task 数据太大。Spark 按 partition 切任务,一个 task 通常处理一个 partition。Executor OOM 很多时候不是集群总内存不够,而是某个 task 分到的数据太大。比如 800GB 数据只有 80 个分区,平均每个 task 要处理 10GB。executor 内存只有 8G,Shuffle 过程中数据再膨胀一下,很容易爆。合理增加到 2000 个分区,每个 task 平均 400MB,单 task 压力就下来了。补充一下分区从哪来:读文件时按每片最多 128MB 切,Shuffle 之后默认是 200 个分区。所以 800GB 读进来不会只有 80 个分区;分区太少,多半是 Shuffle 分区数设少了,或者被 coalesce 过。处理方式:读入后按数据量重分区,比如聚合前按 user_id repartition 到 2000。同时把 Shuffle 分区数 spark.sql.shuffle.partitions 也调到 2000。但注意边界:按 user_id 重分区,同一个 key 永远落在同一个分区。它能解决所有 Task 都偏大,解决不了一个超级大 key;那是倾斜,后面单独讲。分区也不是越多越好:太少,单 task 太大;太多,调度开销变大、小文件变多。生产里常用经验:让单个 task 处理几百 MB,而不是好几个 GB。好比 800 斤货:80 个人搬每人 10 斤,2000 个人搬每人 0.4 斤;人太少累趴,人太多排队,要找平衡。
第三步,重点排查 Shuffle 和数据倾斜,Spark OOM 最容易发生在 Shuffle 阶段。groupByKey、reduceByKey、join、distinct、orderBy、窗口函数,都会触发 Shuffle。Shuffle 要跨节点重新拉取、排序、聚合数据,内存里会形成 buffer。前面专题讲过 Shuffle 的流程。这里的关键是:所有分区里 user_id 10086 的数据,都会汇到同一个 reduce task,其他 task 早就跑完了,只有它被压垮。再精确一点:排序和聚合内存不够时,Spark 会先溢写磁盘,表现是 spill 变多、变慢。真正撑爆的,多是没法溢写的部分:比如 groupByKey 要把一个 key 的全部 value 一次装进内存。看代码。错误写法:map 成 user_id 和 pay_amount,再 groupByKey,最后求和。groupByKey 会把同一个 key 的所有明细拉到一起,大 key 让单个 Reducer 内存暴涨。正确写法:reduceByKey,先在 map 端局部聚合,再 Shuffle。每个 map 分区里,大 key 只剩一条局部和,Shuffle 数据量显著减少。前面专题专门讲过这两个算子;顺便说一句,DataFrame 的 groupBy 加 sum 本身就带 map 端预聚合,groupByKey 的坑主要出在 RDD 写法里。如果是 Join 倾斜,有四招。第一,小表广播,避免大 Shuffle Join;自动广播的阈值默认是 10MB。第二,大 key 加盐,把一个大 key 拆成多个小 key,前面专题讲过加盐的做法。第三,先单独处理热点 key,再 union 回普通 key 的结果。第四,Spark SQL 开启 AQE 的 skew join 优化,参数是 adaptive enabled 和 skewJoin enabled。纠正一下:Spark 3.2 起 AQE 默认就开着,3.5 里这两个参数默认都是 true,写出来只是显式声明。AQE 判断倾斜要同时满足:分区大于中位数的 5 倍,并且大于 256MB,然后把它拆开处理。但它只管 Join,不管 groupBy 聚合倾斜;聚合倾斜还得自己加盐,做两阶段聚合。一句话:Shuffle 阶段 OOM,优先看数据倾斜和 Shuffle 数据量,不要只盯 executor memory。
补充几个面试官可能追问的概念。先看 Driver OOM:多数是把分布式数据拉回单机。数据本来分散在各个 Executor 上,比如 3 个 Executor 各有 1 千万行;一 collect,3 千万行全挤进 Driver 这一台机器,就变成了单机内存问题。四种场景对照:查看数据,别 collect 后打印,用 show 100 或 limit 100;导出结果,别 collect 到本地写文件,用分布式 write parquet 或 csv;Pandas 分析,别把大表直接 toPandas,先聚合、采样或者 limit;广播变量,别广播几 GB 的对象,先过滤裁剪再广播。Spark SQL 的广播表也是先 collect 到 Driver 再构建,所以表太大,先撑爆的是 Driver。
补充二:memoryOverhead,堆外内存也会把容器撑爆。在 YARN 或 Kubernetes 上,Executor 容器里不只有 JVM 堆。还有 JVM 自身开销、线程栈、Netty 和 Shuffle 用的直接内存、Arrow,以及 Python worker 进程。所以明明设了 executor memory 8g,日志却提示容器超过 9G 被 kill,这就要看 memoryOverhead。YARN 上报 Container killed,换到 Kubernetes,就是 Pod 状态 OOMKilled。它的默认值是 executor 内存的 10%,最少 384MB;8g 对应约 819MB,容器申请约 8.8G。YARN 再按最小分配粒度向上取整,常见就是 9G,堆外一用多就超。另外两块单独计算:开了 offHeap,offHeap size 单独加到容器上;PySpark 没设 pyspark memory 时,Python 进程不受限,挤占的也是 overhead。这时可以像这样提交:executor memory 8g,memoryOverhead 3g,cores 4。四个参数放一起记。spark.executor.memory 是 JVM 堆内存,不够就报 Java heap space。spark.executor.memoryOverhead 是堆外和容器额外内存,不够就是 YARN 或 K8s 容器超限。spark.executor.cores 是每个 Executor 同时跑的 Task 数,cores 太多会让多个 Task 抢内存。spark.sql.shuffle.partitions 是 Shuffle 分区数,太少单 Task 大,太多调度开销大。一句话记:executor memory 不是容器总内存,memoryOverhead 也很关键。
补充三:Cache OOM,缓存不是越多越好。cache 和 persist 用得好能提速,用不好会把 Executor 内存占满。典型反例:orders、users、events 三张大表全都 cache,而且从不释放。更稳的写法:只缓存复用次数高的数据,比如从 users 里只挑三列再 persist。多个 Action 复用完之后,马上 unpersist 释放。前面专题讲过统一内存:Storage 存缓存,Execution 做 Shuffle、排序和聚合。缓存太多,挤压执行内存,后面的 Shuffle 就可能 OOM。再精确一点:执行内存可以把缓存驱逐出去,但默认有一半统一区的缓存受保护,执行内存会被压到剩下那一半;被驱逐的缓存要重算,大量缓存对象还会加重 GC。另外 DataFrame 的 cache 默认是内存加磁盘,放不下会落盘;RDD 的 cache 默认只放内存。
把整套排查串成一棵决策树。任务 OOM,先看 Driver 和 Executor 日志,确认报错关键词。Driver 报错:减少拉回 Driver 的数据,用 write 分布式输出,用 limit 采样调试。容器超限被杀:调 memoryOverhead,关注 Python、Arrow 和堆外内存。Executor 堆内存报错:打开 Spark UI,定位失败的 Stage 和大 Task。少数 Task 远大于其他?是,就是数据倾斜:拆大 key、加盐、广播小表、AQE skew join。否,再看单 Task 数据是否过大:是,就增加合理分区,调 shuffle partitions,别让单 Task 处理好几个 GB。还不是,就查代码:cache 太多,就少缓存、选对存储级别、及时 unpersist;groupByKey 或大 join,就改 reduceByKey、预聚合、列裁剪、过滤下推。这些都排除了,仍然内存不足,最后才调资源:executor memory、cores 和 overhead。
面试怎么答?可以这样说:我不会一上来就加内存,先判断 OOM 发生在哪。第一,看日志和 Spark UI,区分 Driver OOM、Executor OOM 和容器 memoryOverhead 超限。collect、toPandas、maxResultSize,多半是 Driver 问题;Java heap space、某个 task 失败,多半是 Executor 问题。第二,看失败 Stage 和 Task 指标:少数 Task 远大于其他,优先判断数据倾斜;所有 Task 都大,可能是分区太少或 Shuffle 数据太大,就增加合理分区、做过滤和列裁剪。第三,看代码和资源:避免 groupByKey、大结果 collect、过度 cache,能预聚合就先减少 Shuffle。最后才调 executor memory、memoryOverhead、shuffle partitions 和 cores。判断标准就一句:先减少数据和错误写法,再增加资源。
追问一:Executor 内存越大越好吗?不是。内存太小容易 OOM,但太大也可能带来更长的 GC 停顿。比如一个 Executor 给 64G 堆,一次 Full GC 可能卡很久,任务看起来像假死。还有个 JVM 细节:堆超过约 32G,压缩指针失效,对象引用从 4 字节变成 8 字节,同样多的内存,能装的对象反而变少。更稳的做法是控制每个 Executor 的 cores 和内存,让同时跑的 Task 别太多,再通过合理分区,减少单 Task 的数据量。
追问二:为什么 executor cores 也会影响 OOM?因为每个 core 通常同时跑一个 Task,cores 是 8,就有 8 个 Task 同时抢同一块内存。很多资料说 8 个 Task 抢 8G,其实没那么多:8G 堆先扣掉 300MB 预留,再乘 0.6,执行和存储共用的统一内存,只有约 4.6G。而每个 Task 拿到的执行内存,最多是 N 分之一,至少保证 2N 分之一,N 是同时在跑的 Task 数。8 个 Task 同时跑,每个最多约 590MB;哪个 Task 要 2G,就扛不住了。把 cores 降到 3 或 4,每个 Task 的上限至少翻倍,单 Task 可用内存反而更稳。所以调 Spark 资源不能只看总内存,还要看并发 Task 数。
追问三:数据倾斜导致 OOM,怎么处理?先在 Spark UI 的 Stage 页看 Task 汇总指标:Duration、Shuffle Read Size、Input Size。如果最大值远远超过中位数,少数 Task 明显比其他大,就是倾斜信号。聚合倾斜:给大 key 加盐,做两阶段聚合。Join 倾斜:广播小表、拆热点 key 单独处理,或者让 AQE skew join 自动拆分。核心目标就一个:把超级大 key 拆散,别让一个 Task 独自扛下全部数据。
追问四:怎么判断是 cache 导致的 OOM?信号是:前面 cache 了大表,后面的 Stage 开始频繁 GC、spill 变多,甚至 Executor lost。去 Spark UI 的 Storage 页,看缓存了哪些表、存储级别和占了多少内存。再查代码里,是不是有多个大 DataFrame 同时 cache,却忘了 unpersist。解决方式:只缓存复用多次、计算成本高的数据,选合适的 persist 级别,用完及时释放。
回到开头:Driver 爆了却去加 executor 内存,就是没先定位。先看日志定位角色,再看 Task 找倾斜和大分区,再改写法,最后才加资源,这道题就稳了。