← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共9章,点击直达)
一、Spark核心原理二、RDD核心三、DataFrame与Dataset四、Spark SQL与优化五、Structured Streaming六、Spark性能调优七、Spark与生态集成八、面试高频综合题面试速记口诀

Q120 Spark批处理与大数据计算深度实战

20K Java+AI 岗位高频考点 — Spark是大数据处理的事实标准,面试常考核心原理、RDD/DataFrame、性能调优、与Flink对比。覆盖Spark架构、SQL优化、Structured Streaming、Java集成。

一、Spark核心原理

1. Spark vs MapReduce?

维度MapReduceSpark
中间结果写磁盘内存(可选磁盘)
编程模型Map+Reduce两阶段DAG多阶段
迭代计算每次读磁盘内存迭代
延迟分钟级秒级
容错重新计算血缘重算
性能慢(10-100x)快

2. Spark架构?


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

3. Spark作业执行流程?


代码 → 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

4. Spark内存管理?


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可互相借用

5. Shuffle原理?


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

二、RDD核心

6. RDD五大特性?


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(...)

7. 宽依赖 vs 窄依赖?


窄依赖(1:1或N:1):
- map, filter, flatMap, union
- 父分区最多被子RDD一个分区使用
- 可管道化执行,无需Shuffle

宽依赖(1:N或M:N):
- groupByKey, reduceByKey, join, distinct
- 父分区被子RDD多个分区使用
- 必须Shuffle,切分Stage边界

面试回答:
窄依赖允许在同一个Stage内管道执行,数据不需要网络传输。
宽依赖导致Shuffle,数据需要跨节点重新分配,是性能瓶颈的主要来源。
优化思路是减少Shuffle次数。

8. RDD持久化?


// 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();

9. RDD血缘(Lineage)与容错?


血缘:RDD记录从创建到当前的转换链

容错机制:
1. 分区数据丢失
2. 从血缘链重新计算丢失分区
3. 如果有checkpoint,从checkpoint恢复

Checkpoint:
rdd.checkpoint();  // 保存到HDFS,截断血缘
sc.setCheckpointDir("hdfs://checkpoint/");

适用:血缘链很长(>10次转换)的RDD

三、DataFrame与Dataset

10. RDD vs DataFrame vs Dataset?

维度RDDDataFrameDataset
类型安全编译期运行期编译期
优化无Catalyst优化Catalyst优化
序列化Java/KryoTungsten二进制Tungsten二进制
API函数式SQL-like函数式+SQL
性能低高高
适用非结构化结构化类型安全

11. Java DataFrame API?


// 创建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/");

12. UDF自定义函数?


// 注册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 方法
}

13. Dataset类型安全操作?


// 定义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);

四、Spark SQL与优化

14. Catalyst优化器?


优化流程:
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列(减少数据量)

15. Join策略?

策略条件说明
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

16. Spark SQL性能优化?


// 分区裁剪
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");

五、Structured Streaming

17. 流处理模型?


核心思想:将流视为无边界的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

18. Event Time与Watermark?


// 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"));

19. 状态管理与输出模式?


// 输出模式
// 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();

20. Kafka集成?


// 读取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();

六、Spark性能调优

21. 数据倾斜处理?


现象:少数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(_ + _)        // 全局聚合

22. 广播变量与累加器?


// 广播变量:只读共享数据
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());

23. 参数调优?


# 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

24. Spark UI分析?


关键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:数据读写量

七、Spark与生态集成

25. Delta Lake?


// 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)");

26. Java集成实战?


// 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));
    }
}

八、面试高频综合题

27. Spark vs Flink?

维度SparkFlink
模型微批处理流处理(原生)
延迟100ms+毫秒级
Exactly-Once支持原生支持
批处理强(原生)支持(DataStream API)
生态Spark SQL/ML/Graph较少
状态管理基础强大(RocksDB)
适用批处理+准实时实时流处理

28. Spark vs MapReduce面试怎么答?

"Spark比MapReduce快10-100倍,核心原因有三:第一,内存计算,中间结果不落盘;第二,DAG执行引擎,多阶段在一个Job中完成,而MapReduce每个阶段都是一个独立Job;第三,Catalyst优化器做谓词下推、列裁剪等自动优化。我们用Spark替代MapReduce后,ETL任务从4小时缩短到30分钟。"

29. 大表Join优化?


场景:订单表(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

30. Spark on Kubernetes?


# 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

31. 实时数仓中的Spark角色?


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、批流一体看场景