问题是怎么暴露的

最近 dws_biz_order_calendar_para 这个 Databricks 任务开始频繁挂掉。日志里 exit code 137,Driver OOM。而且表现很奇怪——第一次跑基本必挂,重跑却大多能过,跟抽签一样。

同一时段还有几个大数据量的同步任务一起失败,都是往 MySQL 推数据的。集群资源被多个任务同时抢占,driver 内存扛不住。

先看这个任务的数据流:

1
2
3
4
5
6
7
8
9
Step 1: 301,780 行(总订货日历)
↓
Step 2-3: 301,780 行(恒温路线判断 + 窗口函数)
↓
Step 4: 104,547,880 行 ← 爆炸点
↓
Step 5: 104,547,880 行(禁止发注判定)
↓
Step 6: 91,478,958 行(聚合 + 窗口函数) ← 挂在这里

30 万行到 1 亿行,膨胀了 346 倍。

Step 4 是个 INNER JOIN,日历数据和商品展开清单关联。每个 (store_code, logistics_type, rfid_flag, temperature_type) 组合会匹配到多个商品。商品展开清单有 238 万行有效商品,30 万 × 238 万的 join,笛卡尔积直接炸了。这个 JOIN 是业务刚需,避不开,只能从后续处理下手。


三个具体的性能瓶颈

1. 重复的 .count() 调用

代码里有个低级失误:

1
2
print(f"   Step 4 记录数: {tmp4.count():,}")
print(f" Step 4 记录数: {tmp4.count():,}") # 写了两遍

104M 行数据,每次 .count() 都要把整个 DAG 从头跑一遍。多调一次等于白送一次全量计算。

2. cache() + count() 物化 1 亿行

Step 5 做禁止发注判定,要在 104M 行上做 8-way union。代码的做法是:

1
2
tmp4_cached = tmp4.cache()
tmp4_cached.count() # 物化缓存

.cache() 把 104M 行全塞进 executor 内存。driver 本身占用不大,只存元数据,但如果这时候有其他任务并发跑,集群资源被抢,OOM 就来了。

3. Step 6 中间多余的 count()

1
2
3
4
valid_df = tmp5.filter(F.col("valid_flag") == 1)
print(f" 有效记录数: {valid_df.count():,}") # 104M 行又算一遍

grouped = valid_df.groupBy(...) # 紧接着再扫一遍

filter 完立刻 count(),触发一次全量计算。紧接着 groupBy 又来一次。tmp5 的 lineage 包含 Step 5 的 8-way union,算一次代价就不小。

重跑能过的原因也清楚了:多个任务共享同一个集群,第一次跑的时候并发执行把内存吃满。重跑时不少任务在上次失败时已经完成了,内存压力小了自然能过。


大表加工的几个注意点

这次优化踩出来的坑,总结成几条在 Spark 大表加工时需要注意的事项。

.count() 在大 DataFrame 上代价很高

每次调用 .count() 都会触发整个 DAG 的全量计算。数据量小的时候感知不到,过了千万级就会明显变慢。能合并的统计就合并,不要在中间过程频繁 count。

慎用 .cache() 处理大数据量

.cache() 把数据物化到 executor 内存。数据量大的时候,如果集群还在跑其他任务,内存很容易被抢爆。替代方案是写入临时表落盘——多了 IO 开销,但换来了确定性。

用临时表切断 lineage DAG

复杂的多步 ETL 里,每个 Step 跑完就把结果写到磁盘上的 Delta 临时表,下一步从磁盘读。这样后续操作不会拖着前面越来越长的 lineage,Spark 优化器也不用去理解一长串嵌套的转换逻辑。

1
2
3
4
5
6
# Step 4 跑完后落盘
TEMP_TABLE_STEP4 = f"`{CATALOG}`.muji.`temp_step4_{P_DATE}`"
tmp4.write.mode("overwrite").saveAsTable(TEMP_TABLE_STEP4)

# Step 5 从磁盘读取,不依赖前面的 DAG
tmp4_from_disk = spark.read.table(TEMP_TABLE_STEP4)

在 Step 4→5 和 Step 5→6 两个边界都加了临时表后,全程没 OOM。

注意 serverless 集群的配置限制

有些配置在 serverless 环境下不允许手动设置,比如 spark.databricks.delta.optimizeWrite.enabled 默认已开启,手动 set 会报错。部署到不同环境前最好先确认集群类型。

表名里的特殊字符要转义

表名中包含 - 或日期(如 2026-10-11),SQL 解析器会当成减号。整个表名要用反引号包起来:

1
2
3
4
# 报错
`aop-dev`.muji.temp_step4_2026-10-11
# 修好后
`aop-dev`.muji.`temp_step4_2026-10-11`

Spark JDBC 写入 MySQL 的优化

同步任务往 MySQL 推数据走的是 Spark JDBC。数据量一大,写入本身就慢,还可能锁表、死锁。几个关键参数的设置直接影响写入性能。

batchsize:控制每批写入行数

1
2
3
df.write.format("jdbc")
.option("batchsize", 50000) # 每批 5 万行
.save()

JDBC 默认 batchsize 是 1000。数据量大的时候这个值太小,网络往返次数太多。调到 50000 甚至 100000 可以显著减少 round-trip。但也不要设太大——单批太大,MySQL 端解析 SQL 的内存开销也跟着涨,容易触发 max_allowed_packet 报错。

numPartitions:控制并发写入线程数

1
2
3
df.repartition(8)  # 8 个分区 = 8 个并发 JDBC 连接
.write.format("jdbc")
.save()

Spark 每个 partition 会起一个独立的 JDBC 连接写入。分区数决定了并发度。设太小(比如 1)等于串行写,大表能写半小时。设太大(比如 64)MySQL 端连接数被打满,反而互相等锁。经验值:百万级数据 8-16 个分区够用,千万级以上可以放到 32。

rewriteBatchedStatements:多行 INSERT 合并

这是 JDBC URL 里的参数,也是最关键的一个优化:

1
jdbc_url = base_url + "&rewriteBatchedStatements=true"

不开这个参数时,Spark JDBC 的行为是:即使设了 batchsize=50000,实际上还是逐条发 INSERT 语句,只是在攒够 batchsize 条后做一次 commit。MySQL 收到的是 50000 条独立的 INSERT。

开了之后,MySQL JDBC 驱动会把 batch 内的多条 INSERT 合并成一条:

1
2
3
4
5
6
7
-- 不开 rewriteBatchedStatements
INSERT INTO t VALUES (1, 'a');
INSERT INTO t VALUES (2, 'b');
INSERT INTO t VALUES (3, 'c');

-- 开了 rewriteBatchedStatements
INSERT INTO t VALUES (1, 'a'), (2, 'b'), (3, 'c');

网络往返从 N 次变成 1 次,MySQL 解析开销也大幅降低。实测百万行数据写入,开了这个参数能快 3-5 倍。

其他几个配合的 JDBC 参数:

1
2
3
4
5
6
7
jdbc_opts = (
"&rewriteBatchedStatements=true"
"&useServerPrepStmts=false" # 不用服务端预编译,批量写入时反而更慢
"&cachePrepStmts=false" # 不缓存预编译语句,批量场景用不上
"&elideSetAutoCommits=true" # 避免重复设置 autocommit 状态
"&maintainTimeStats=false" # 关闭时间统计,减少开销
)

索引策略:先删后建 vs 边写边维护

这是大表写入时最容易忽略的问题。MySQL 每次 INSERT 都要维护二级索引——数据写入时如果有多个二级索引,每个索引都要同步更新。并发写入时索引页的锁竞争尤其严重。

项目里有两种写入方式,对应不同的索引策略:

方式一:write_table(普通覆写)

1
writer.write_table("biz_db", "biz_weekly_fcst", df, mode="overwrite")

流程:TRUNCATE TABLE → append 写入。表上的索引全程保留,每次 INSERT 都触发索引更新。适合数据量不大的表(几十万行以内)。

方式二:write_table_bulk(大表批量写入)

1
writer.write_table_bulk("biz_db", "biz_store_stock", df)

流程完全不同:

1
2
3
4
5
6
1. CREATE TABLE temp LIKE target       ← 复制表结构(含索引)
2. DROP INDEX idx_xxx ON temp ← 删除所有二级索引
3. INSERT INTO temp ... ← 无索引写入(快)
4. CREATE INDEX idx_xxx ON temp ← 数据写完后重建索引
5. DROP TABLE target ← 删旧表
6. RENAME TABLE temp TO target ← 原子替换

核心区别在第 2-4 步。先把二级索引全部删掉,写入过程中 MySQL 不用维护任何索引,纯顺序写。等数据全写完了,再一次性重建索引。

为什么这样更快?

  • 带索引写入:每条 INSERT 都要在 B+Tree 上找位置、做页分裂,并发时多个线程抢同一页的锁
  • 先写后建索引:写入时是纯顺序 INSERT,没有锁竞争。重建索引时 MySQL 用的是排序建索引(sort buffer + 顺序扫描),比逐行维护 B+Tree 快很多

实测一张 200 万行的表,带 3 个二级索引:

  • 直接写入(带索引):约 8 分钟
  • 先删后建(write_table_bulk):写入 2 分钟 + 重建索引 1 分钟 = 3 分钟

索引越多、数据量越大,差距越明显。


效果对比

指标 优化前 优化后
DAG 重复计算 3-4 次 104M 全量计算 0 次
Driver 内存压力 cache + count 物化 临时表落盘
任务稳定性 看运气,经常需要重跑 稳定通过
JDBC 写入 默认 batchsize=1000,逐条 INSERT batchsize=50000 + rewriteBatchedStatements
索引维护 写入时带索引,锁竞争严重 大表先删索引后重建

小结

Spark 大表加工和 JDBC 写入 MySQL,两个场景,核心思路类似:减少不必要的计算和锁竞争。

大表加工这边,用临时表切断 DAG,避免 Spark 拖着一长串 lineage 反复重算。cache 在小数据量下没问题,过了千万级就该考虑落盘。

JDBC 写入那边,三个参数决定性能下限:batchsize 控制每批大小,rewriteBatchedStatements 把多条 INSERT 合并成一条,numPartitions 控制并发度。大表还要注意索引——写入前删掉二级索引,写完后重建,比边写边维护索引快很多。