20K Java+AI 岗位高频考点 — Spark是大数据处理的事实标准,面试常考核心原理、RDD/DataFrame、性能调优、与Flink对比。覆盖Spark架构、SQL优化、Structured Streaming、Java集成。
| 维度 | MapReduce | Spark |
|---|---|---|
| 中间结果 | 写磁盘 | 内存(可选磁盘) |
| 编程模型 | Map+Reduce两阶段 | DAG多阶段 |
| 迭代计算 | 每次读磁盘 | 内存迭代 |
| 延迟 | 分钟级 | 秒级 |
| 容错 | 重新计算 | 血缘重算 |
| 性能 | 慢(10-100x) | 快 |
Driver(驱动程序)
├── SparkContext:Spark入口
├── DAGScheduler:将Job拆分为Stage
├── TaskScheduler:将Stage分配为Task
└── SchedulerBackend:与Cluster Manager通信
Cluster Manager(资源管理)
├── Standalone:Spark自带
├── YARN:Hadoop资源管理器
└── Kubernetes:容器编排
Executor(执行器)
├── 每个Node一个Executor
├── 多个Task线程
├── BlockManager:数据块管理
└── Shuffle服务
执行流程:
Client → Driver → DAG → Stage → Task → Executor
代码 → RDD/DataFrame操作 → 逻辑计划 → 物理计划 → Job
Job → Stage(按Shuffle边界切分)→ Task(Stage内的并行任务)
触发Job的操作(Action):
- collect(), count(), save(), show(), foreach()
不触发Job的操作(Transformation,惰性):
- map(), filter(), groupBy(), join(), reduceByKey()
Shuffle边界:
- 宽依赖(Shuffle) → 切分Stage
groupBy, reduceByKey, join, distinct
- 窄依赖(Pipeline) → 同一Stage
map, filter, flatMap, union
Executor内存划分:
- Reserved Memory(300MB):系统保留
- User Memory(1 - 0.6 × 0.5 = 40%):用户数据结构
- Execution Memory(30%):Shuffle/Join/Sort/Aggregation
- Storage Memory(50%):缓存RDD/DataFrame
参数:
spark.memory.fraction = 0.6 # Execution+Storage占堆比例
spark.memory.storageFraction = 0.5 # Storage占联合内存比例
spark.executor.memory = 4g # Executor堆内存
spark.driver.memory = 2g # Driver堆内存
Unified Memory Manager:Execution和Storage可互相借用
Map阶段:
1. Map Task输出数据
2. 按分区规则(Partitioner)写入不同分区文件
3. 数据先写入内存缓冲区,溢写到磁盘
4. 最终合并为分区文件(merged file)
Reduce阶段:
1. Reduce Task拉取对应分区的数据
2. 边拉取边排序/聚合
3. 合并后交给下游处理
Shuffle类型:
- HashShuffle(弃用)
- SortShuffle(默认):数据排序后写磁盘
- BypassMergeSortShuffle:分区数<200且不需要map端聚合
- UnsafeShuffle:支持序列化数据的快速处理
优化参数:
spark.shuffle.compress = true
spark.shuffle.file.buffer = 32k
spark.reducer.maxSizeInFlight = 48m
1. 分区列表(partitions):数据分布在多个分区
2. 计算函数(compute):每个分区的计算逻辑
3. 依赖列表(dependencies):与其他RDD的依赖关系
4. 分区器(partitioner):可选,数据如何分区
5. 首选位置(preferredLocations):可选,计算最优位置
创建方式:
1. 并行化集合:sc.parallelize(List(1,2,3))
2. 外部数据:sc.textFile("hdfs://data/*.log")
3. RDD转换:rdd.map(...).filter(...)
窄依赖(1:1或N:1):
- map, filter, flatMap, union
- 父分区最多被子RDD一个分区使用
- 可管道化执行,无需Shuffle
宽依赖(1:N或M:N):
- groupByKey, reduceByKey, join, distinct
- 父分区被子RDD多个分区使用
- 必须Shuffle,切分Stage边界
面试回答:
窄依赖允许在同一个Stage内管道执行,数据不需要网络传输。
宽依赖导致Shuffle,数据需要跨节点重新分配,是性能瓶颈的主要来源。
优化思路是减少Shuffle次数。
// Java RDD持久化
JavaRDD<String> rdd = sc.textFile("hdfs://data/large.txt");
// 缓存到内存
rdd.cache(); // 等同于 persist(MEMORY_ONLY)
// 持久化级别
rdd.persist(StorageLevel.MEMORY_ONLY()); // 仅内存
rdd.persist(StorageLevel.MEMORY_AND_DISK()); // 内存+磁盘溢写
rdd.persist(StorageLevel.DISK_ONLY()); // 仅磁盘
rdd.persist(StorageLevel.MEMORY_ONLY_SER()); // 序列化存储(省内存)
rdd.persist(StorageLevel.MEMORY_AND_DISK_SER()); // 序列化+磁盘
// 手动释放
rdd.unpersist();
血缘:RDD记录从创建到当前的转换链
容错机制:
1. 分区数据丢失
2. 从血缘链重新计算丢失分区
3. 如果有checkpoint,从checkpoint恢复
Checkpoint:
rdd.checkpoint(); // 保存到HDFS,截断血缘
sc.setCheckpointDir("hdfs://checkpoint/");
适用:血缘链很长(>10次转换)的RDD
| 维度 | RDD | DataFrame | Dataset |
|---|---|---|---|
| 类型安全 | 编译期 | 运行期 | 编译期 |
| 优化 | 无 | Catalyst优化 | Catalyst优化 |
| 序列化 | Java/Kryo | Tungsten二进制 | Tungsten二进制 |
| API | 函数式 | SQL-like | 函数式+SQL |
| 性能 | 低 | 高 | 高 |
| 适用 | 非结构化 | 结构化 | 类型安全 |
// 创建SparkSession
SparkSession spark = SparkSession.builder()
.appName("OrderAnalysis")
.master("yarn")
.getOrCreate();
// 读取数据
Dataset<Row> orders = spark.read()
.option("header", "true")
.option("inferSchema", "true")
.csv("hdfs://data/orders.csv");
// DataFrame操作
Dataset<Row> result = orders
.filter(col("status").equalTo("completed"))
.groupBy("user_id")
.agg(
sum("amount").as("total_amount"),
count("*").as("order_count")
)
.orderBy(col("total_amount").desc())
.limit(100);
result.show();
result.write().parquet("hdfs://output/user_stats/");
// 注册UDF
spark.udf().register("formatAmount",
(UDF1<Double, String>) amount -> String.format("%.2f", amount),
DataTypes.StringType);
// 使用UDF
orders.withColumn("formatted_amount",
callUDF("formatAmount", col("amount")));
// UDAF(自定义聚合函数)
public class MedianUDAF extends Aggregator<Double, MedianBuffer, Double> {
// 实现 reduce, merge, finish 方法
}
// 定义Bean类
public class Order implements Serializable {
private Long orderId;
private Long userId;
private Double amount;
private String status;
// getter/setter...
}
// Encoders
Encoder<Order> orderEncoder = Encoders.bean(Order.class);
Dataset<Order> orderDS = spark.read()
.json("hdfs://data/orders.json")
.as(orderEncoder);
// 类型安全的操作
Dataset<Order> completed = orderDS
.filter((FilterFunction<Order>) o -> "completed".equals(o.getStatus()))
.map((MapFunction<Order, Order>) o -> {
o.setAmount(o.getAmount() * 0.9); // 打9折
return o;
}, orderEncoder);
优化流程:
1. 解析(Parse):SQL → Unresolved Logical Plan
2. 分析(Analyze):结合Catalog解析表名列名 → Resolved Logical Plan
3. 逻辑优化(Optimize):规则优化 → Optimized Logical Plan
- 谓词下推(Predicate Pushdown)
- 列裁剪(Column Pruning)
- 常量折叠(Constant Folding)
- 过滤合并(Filter Merge)
4. 物理计划(Physical Planning):生成多个物理计划 → 选代价最低的
5. 代码生成(Code Generation):Whole-Stage CodeGen
示例 - 谓词下推:
SELECT name FROM users WHERE age > 18
优化前:全表扫描 → 过滤 → 选择name列
优化后:先过滤age > 18 → 只选name列(减少数据量)
| 策略 | 条件 | 说明 |
|---|---|---|
| Broadcast Hash Join | 小表<广播阈值 | 小表广播到所有Executor |
| Sort Merge Join | 大表+大表 | 两边排序后合并(默认) |
| Shuffle Hash Join | 中等大小 | 哈希分区后Join |
// 强制广播Join
orders.join(broadcast(smallTable),
orders.col("product_id").equalTo(smallTable.col("id")));
// 参数配置
spark.conf().set("spark.sql.autoBroadcastJoinThreshold", 10485760); // 10MB
// 分区裁剪
spark.read().parquet("hdfs://data/orders/")
.filter(col("date").between("2025-01-01", "2025-01-31"));
// 只读取1月分区数据
// Bucketing(分桶)
df.write().bucketBy(100, "user_id")
.sortBy("created_at")
.saveAsTable("orders_bucketed");
// 后续按user_id join无需Shuffle
// 缓存热表
spark.sql("CACHE TABLE hot_products");
// Adaptive Query Execution (AQE)
spark.conf().set("spark.sql.adaptive.enabled", "true");
spark.conf().set("spark.sql.adaptive.coalescePartitions.enabled", "true");
spark.conf().set("spark.sql.adaptive.skewJoin.enabled", "true");
核心思想:将流视为无边界的DataFrame
处理模型:Micro-Batch(微批处理)
- 定期将流数据作为一个小批次处理
- 延迟约100ms(可配置)
连续处理(Continuous Processing):
- 延迟约1ms(实验性)
spark.conf().set("spark.sql.streaming.continuous.enabled", "true")
Source:
- Kafka, File, Socket, Rate(测试)
Sink:
- Console, File, Kafka, Foreach, Memory
// Event Time处理
Dataset<Row> stream = spark.readStream()
.format("kafka")
.option("kafka.bootstrap.servers", "localhost:9092")
.option("subscribe", "events")
.load();
// 解析Event Time
Dataset<Row> parsed = stream
.select(from_json(col("value").cast("string"), schema).as("data"))
.select("data.*")
.withWatermark("event_time", "5 minutes") // 延迟5分钟的水位线
.groupBy(window(col("event_time"), "1 hour"))
.agg(count("*").as("event_count"));
// 输出模式
// Append:只输出新增结果(默认)
// Complete:输出全量结果
// Update:只输出变更的结果
stream.withWatermark("event_time", "10 minutes")
.groupBy("user_id")
.agg(count("*").as("actions"))
.writeStream()
.outputMode("update")
.format("kafka")
.option("checkpointLocation", "hdfs://checkpoint/")
.option("topic", "user_stats")
.start();
// 读取Kafka
Dataset<Row> kafkaStream = spark.readStream()
.format("kafka")
.option("kafka.bootstrap.servers", "k1:9092,k2:9092")
.option("subscribe", "orders")
.option("startingOffsets", "latest")
.load();
// 写入Kafka
result.writeStream()
.format("kafka")
.option("kafka.bootstrap.servers", "k1:9092")
.option("topic", "order_stats")
.option("checkpointLocation", "/checkpoint/order_stats")
.start();
现象:少数Task运行时间远超其他Task
原因:分区键分布不均(如null值、热点用户)
方案一:加盐打散
// 给热点Key加随机前缀
df.withColumn("salted_key",
concat(col("user_id"), lit("_"), floor(rand() * 10)))
方案二:广播Join
// 小表直接广播,避免Shuffle
df.join(broadcast(smallDF), "key")
方案三:增加分区数
df.repartition(200, col("user_id"))
方案四:两阶段聚合
// 局部聚合 → 全局聚合
df.map(x -> (key_prefix + x.key, x.value))
.reduceByKey(_ + _) // 局部聚合
.map(x -> (real_key, x.value))
.reduceByKey(_ + _) // 全局聚合
// 广播变量:只读共享数据
Broadcast<Map<String, String>> broadcastMap =
sc.broadcast(loadConfigMap());
rdd.map(data -> {
String value = broadcastMap.value().get(data.getKey());
return transform(data, value);
});
// 累加器:分布式计数
LongAccumulator errorCount = sc.longAccumulator("errors");
rdd.foreach(data -> {
if (isInvalid(data)) {
errorCount.add(1);
}
});
System.out.println("Errors: " + errorCount.value());
# Executor配置
spark.executor.instances = 10
spark.executor.cores = 4
spark.executor.memory = 8g
spark.executor.memoryOverhead = 2g
# 并行度
spark.default.parallelism = 200
spark.sql.shuffle.partitions = 200
# 序列化
spark.serializer = org.apache.spark.serializer.KryoSerializer
spark.kryo.registrationRequired = false
# 内存
spark.memory.fraction = 0.6
spark.memory.storageFraction = 0.5
# 网络
spark.network.timeout = 300s
spark.executor.heartbeatInterval = 60s
# 动态分配
spark.dynamicAllocation.enabled = true
spark.dynamicAllocation.minExecutors = 2
spark.dynamicAllocation.maxExecutors = 50
关键Tab:
- Jobs:查看Job列表和状态
- Stages:查看Stage详情、Shuffle读写量、GC时间
- Tasks:查看Task执行时间分布
- Storage:查看缓存使用情况
- SQL:查看SQL执行计划
关键指标:
- Task Duration:最长Task时间(识别倾斜)
- GC Time:GC占比>10%需优化内存
- Shuffle Read/Write:Shuffle数据量(识别瓶颈)
- Spill:磁盘溢写次数(内存不足)
- Input/Output Size:数据读写量
// Delta Lake是Spark上的ACID存储层
Dataset<Row> df = spark.read().format("delta").load("/delta/orders");
// 写入(ACID事务)
df.write().format("delta").mode("append").save("/delta/orders");
// Time Travel(时间旅行)
Dataset<Row> oldData = spark.read().format("delta")
.option("versionAsOf", 5) // 读取第5版本
.load("/delta/orders");
// Schema Evolution
spark.conf().set("spark.databricks.delta.schema.autoMerge.enabled", "true");
// OPTIMIZE优化文件大小
spark.sql("OPTIMIZE delta.`/delta/orders/` ZORDER BY (user_id)");
// Spring Boot + Spark
@Service
public class SparkJobService {
private final SparkSession spark;
public SparkJobService() {
this.spark = SparkSession.builder()
.appName("AnalyticsService")
.master("yarn")
.config("spark.submit.deployMode", "cluster")
.getOrCreate();
}
public UserStats analyzeUserBehavior(String date) {
Dataset<Row> events = spark.read()
.parquet("hdfs://events/" + date + "/");
Row result = events
.filter(col("event_type").isin("click", "purchase"))
.groupBy("user_id")
.agg(
count("*").as("total_events"),
sum(when(col("event_type").equalTo("purchase"), 1).otherwise(0)).as("purchases")
)
.agg(
avg("total_events").as("avg_events"),
avg("purchases").as("avg_purchases")
)
.first();
return new UserStats(result.getDouble(0), result.getDouble(1));
}
}
| 维度 | Spark | Flink |
|---|---|---|
| 模型 | 微批处理 | 流处理(原生) |
| 延迟 | 100ms+ | 毫秒级 |
| Exactly-Once | 支持 | 原生支持 |
| 批处理 | 强(原生) | 支持(DataStream API) |
| 生态 | Spark SQL/ML/Graph | 较少 |
| 状态管理 | 基础 | 强大(RocksDB) |
| 适用 | 批处理+准实时 | 实时流处理 |
"Spark比MapReduce快10-100倍,核心原因有三:第一,内存计算,中间结果不落盘;第二,DAG执行引擎,多阶段在一个Job中完成,而MapReduce每个阶段都是一个独立Job;第三,Catalyst优化器做谓词下推、列裁剪等自动优化。我们用Spark替代MapReduce后,ETL任务从4小时缩短到30分钟。"
场景:订单表(10亿) JOIN 用户表(1000万)
方案1:Broadcast Join(用户表<10GB)
orders.join(broadcast(users), "user_id")
方案2:Bucket Join
两表按user_id分桶,Join无需Shuffle
方案3:Sort Merge Join(默认)
两表按Join Key排序后合并
方案4:倾斜优化
热点Key单独处理 + 非热点正常Join
# Spark提交到K8s
spark-submit \
--master k8s://https://k8s-api:6443 \
--deploy-mode cluster \
--name spark-etl \
--class com.example.ETLJob \
--conf spark.kubernetes.container.image=spark:3.5 \
--conf spark.kubernetes.namespace=spark \
--conf spark.executor.instances=10 \
--conf spark.executor.memory=8g \
local:///opt/spark/jobs/etl.jar
Lambda架构:
- 批处理层(Batch Layer):Spark全量计算(T+1)
- 速度层(Speed Layer):Flink实时计算
- 服务层(Serving Layer):合并批+流结果
Kappa架构:
- 全部用Flink,Spark只做历史数据回填
Spark定位:
- 离线ETL、T+1报表
- 数据湖批处理(Iceberg/Hudi/Delta)
- 机器学习训练(MLlib)
Spark三快:内存计算不落盘、DAG多阶段一次跑、Catalyst自动优化
>
Shuffle三优化:减少Shuffle次数、广播小表避免Shuffle、增大并行度分散热点
>
数据倾斜四招:盐值打散、广播Join、增加分区、两阶段聚合
>
选型口诀:离线批处理选Spark、实时流处理选Flink、批流一体看场景