📝 字节数开面试 八股复盘

📝 核心定位：聚焦大数据开发高频八股问题，覆盖数据倾斜、Spark 故障排查、排序算法、数据库连接、工具库使用、Pyspark 实操、存储引擎对比等核心考点，结合实操场景给出细节化解答，适配实习生面试需求。

一、🔍 数据倾斜相关问题

1. 数据倾斜是什么？

数据倾斜是大数据处理中常见的问题，指在分布式计算（如 Spark、MapReduce）过程中，数据在各个计算节点上的分布极度不均匀：部分节点需要处理远超其他节点的数据量（如某节点处理 1000 万条数据，其他节点仅处理 10 万条），导致该节点成为计算瓶颈（运行缓慢、OOM 等），最终拖慢整个任务的执行效率，甚至导致任务失败。

核心表现：任务长时间卡在 reduce 阶段（99%）、个别 executor 内存溢出、各节点 CPU/ 内存使用率差异极大。

2. 如何发现数据倾斜？

1. 📊 监控工具观察：通过 Spark UI（4040 端口）查看各 stage 的 Task 执行情况，重点关注「Input Size/Records」列，若某任务的输入数据量是其他任务的几十倍以上，可判定为数据倾斜；同时查看 Executor 的 CPU、内存使用率，倾斜节点通常会出现高负载。

2. 🔍 日志分析：查看任务执行日志，若出现「Task is running too slow」「OOM」等异常，且异常集中在少数几个 Task ID，结合数据分布统计（如 group by 的 key 计数），可定位倾斜 key。

3. 📈 数据预分析：在任务执行前，对核心数据（如 group by 的 key、join 的关联字段）进行分布统计（如 countByKey()），若存在少数 key 的出现频次远超其他 key（如某 key 出现 100 万次，其他 key 均小于 1 万次），则提前预判数据倾斜。

3. 数据倾斜的解决方案

核心思路：数据倾斜本质是数据分布不均导致的计算瓶颈，需针对 map 阶段（数据预处理 / 分发）、reduce 阶段（数据聚合 / 关联）及其他辅助维度分别优化，实现数据均匀分布与高效计算。

1. Map阶段解决方案（聚焦数据预处理与均匀分发，从源头减少倾斜）

• 🔧 方案 1：开启 Map 端预聚合（减少 Shuffle 数据量）：在 Spark 中设置参数 spark.sql.mapAggregateBytesLimit（默认 10485760 字节），开启 Map 阶段局部聚合，将相同 key 的部分数据提前聚合后再发送到 reduce 端；优先使用 reduceByKey（自带 Map 端聚合）替代 groupByKey，从源头减少 Shuffle 数据传输量。

• 🔧 方案 2：Map 端过滤 / 拆分倾斜 key：在数据进入 Shuffle 前，对 map 端输出数据进行预处理。若倾斜 key 是无效数据（如 null 值、测试数据），直接过滤；若倾斜 key 是有效数据但数量极少，可单独提取该部分数据进行局部计算（Map 端单独处理后暂存），避免其进入 reduce 阶段拖累整体任务。

• 🔧 方案 3：小表广播实现 Map Join（避免 Shuffle）：针对 Join 场景，若小表数据量较小（如 <100MB），将小表广播到所有 Executor 节点的 map 端，使大表数据在 map 端直接与小表数据关联，无需将数据发送到 reduce 端进行关联，彻底避免 Join 场景的 Shuffle 倾斜。可通过 spark.sql.autoBroadcastJoinThreshold 调整广播阈值（单位字节），或手动指定 Map Join（如 Hive 中 /*+ MAPJOIN(小表名) */）。

2. Reduce阶段解决方案（聚焦数据均匀聚合/关联，破解已出现的倾斜瓶颈）

• 🔧 方案 1：随机前缀打散倾斜 key（核心方案）：针对 Group By/Join 场景中存在的倾斜 key，在 reduce 端处理前，对倾斜 key 添加随机前缀（如 0-9 的随机数），将一个倾斜 key 拆分为多个子 key（如「user10086」拆分为「0_user10086」「1_user10086」…），使数据均匀分发到不同 reduce 节点；待 reduce 阶段局部聚合完成后，再去掉随机前缀，对结果进行二次聚合，得到最终结果。

• 🔧 方案 2：大表倾斜 key 打散 + 小表扩容（Join 场景专属）：若 Join 的两张表均为大表，且只有大表存在倾斜 key，可采用“大表打散 + 小表扩容”策略。对大表中倾斜的 key 添加随机前缀，同时将小表按相同的随机前缀扩容（即小表的每条数据复制 N 份，分别添加 0-N 的前缀），然后进行 Join；Join 完成后去掉前缀，确保关联结果正确。

• 🔧 方案 3：增大 Shuffle 并行度（均衡 reduce 负载）：通过调整参数 spark.sql.shuffle.partitions（默认 200），增加 reduce 阶段的任务数量，让数据更均匀地分布到各个 reduce 任务中。通常根据数据量调整为 1000-2000，避免因分区数过少导致单个 reduce 任务处理数据量过大。

3. 其他维度解决方案（辅助优化，提升整体稳定性与效率）

• 🔧 方案 1：开启自适应执行（动态调整执行计划）：设置 spark.sql.adaptive.enabled=true，Spark 会根据实际数据分布自动调整 Shuffle 分区数和执行计划（如将小任务合并、大任务拆分），可有效缓解轻微数据倾斜，减少手动调参成本。

• 🔧 方案 2：数据预处理优化（上游规避倾斜）：在数据接入阶段，对易产生倾斜的数据进行预处理，如对高频 key 进行分片存储、将 null 值等特殊 key 替换为合法的随机 key，从上游减少数据倾斜的可能性。

• 🔧 方案 3：资源配置优化（提升单节点处理能力）：适当增加 Executor 的内存和 CPU 核心数（如 --executor-memory 8g --executor-cores 4），提升单个 reduce 节点的处理能力；同时设置 spark.executor.memoryOverhead=2g，增加堆外内存，避免因内存不足导致的任务失败，间接提升倾斜数据的处理效率。

二、🔥 Spark任务故障排查（OOM等）

1. Spark任务执行报错（如OOM），怎么排查？

1. 🔍 第一步：定位报错类型与位置

   1. 查看 Driver/Executor 日志：Driver 日志通常在提交任务的节点，Executor 日志可通过 Spark UI（「Executors」→「Logs」）查看，确认报错是 Driver OOM 还是 Executor OOM，以及报错对应的 Task ID、Stage ID。

   2. 通过 Spark UI 分析：查看「Stages」页面，定位报错 Stage 的 Task 执行情况，重点关注输入数据量（是否存在数据倾斜）、Task 运行时间、内存使用情况；查看「Storage」页面，确认 RDD 缓存是否过多。

2. 📊 第二步：分析核心原因

   1. Executor OOM 常见原因：数据倾斜（单 Task 处理数据过多）、RDD 缓存过多 / 未释放、算子使用不当（如 collect() 将大量数据拉到内存）、内存配置不足。

   2. Driver OOM 常见原因：使用 collect()/take() 将大量数据拉到 Driver 节点、广播变量过大、Driver 内存配置不足。

3. ✅ 第三步：验证与定位

   1. 若怀疑数据倾斜：执行数据分布统计（如 countByKey()），查看 key 的分布情况。

   2. 若怀疑缓存问题：查看 Storage 页面的缓存占用，确认是否有不必要的 RDD 缓存。

   3. 若怀疑算子问题：检查代码中是否有 collect()、reduceByKey() 等可能导致内存压力的算子。

2. Spark任务报OOM，具体能优化什么？有哪些加参数的方式？

（1）核心优化方向

• 🔧 解决数据倾斜：参考「数据倾斜解决方案」，打散倾斜 key、增大 Shuffle 并行度等。

• 🔧 优化内存使用

  • 合理缓存 RDD：只缓存必要的 RDD，使用 persist(StorageLevel.MEMORY_AND_DISK_SER)（内存不足时溢写到磁盘，且序列化存储，减少内存占用），避免使用默认的 MEMORY_ONLY。

  • 避免大量数据拉取到 Driver：禁用 collect()（除非数据量极小），改用 takeSample() 抽样查看数据；若必须收集，确保数据量在 Driver 内存可承受范围。

  • 优化算子：使用高效算子（如 reduceByKey 替代 groupByKey，避免 Shuffle 数据量过大）；对大表进行过滤、分区后再进行 Join/Group 操作。

• 🔧 调整资源配置：根据任务复杂度和数据量，合理分配 Executor 内存、CPU 核心数。

（2）关键参数调整（解决OOM）

• Executor 内存配置：

  • --executor-memory 8g：设置每个 Executor 的内存（默认 1g），根据数据量调整（如大数据量设为 8g-16g）。

  • --executor-cores 4：设置每个 Executor 的 CPU 核心数（默认 1），提高并行处理能力。

  • spark.executor.memoryOverhead=2g：设置 Executor 的堆外内存（默认是 executor-memory 的 10%），避免堆外内存不足导致 OOM。

• Driver 内存配置：

  • --driver-memory 4g：设置 Driver 内存（默认 1g），若使用 collect() 或广播大变量，需适当增大。

  • spark.driver.memoryOverhead=1g：Driver 堆外内存配置。

• Shuffle 与缓存优化：

  • spark.sql.shuffle.partitions=1000：增大 Shuffle 并行度，缓解数据倾斜导致的 OOM。

  • spark.storage.memoryFraction=0.6：调整用于缓存的内存比例（默认 0.6），若任务不需要大量缓存，可适当降低，增加执行内存。

• 其他辅助参数：

  • spark.task.maxFailures=4：设置 Task 最大失败重试次数（默认 4），轻微 OOM 可通过重试解决。

  • spark.sql.adaptive.enabled=true：开启自适应执行，自动调整分区和执行计划。

三、📚 常见排序算法

核心排序算法分类及关键信息汇总：

✨ 面试重点：快速排序（分治思想、基准选择影响效率）、归并排序（稳定、外部排序适用）、堆排序（空间效率高），需掌握核心原理和复杂度分析。

四、🗄️ 服务器连接MySQL的方式

常见的 3 种连接方式，适用于不同场景（命令行、代码开发、工具连接）：

1. 命令行连接（最基础，适用于快速验证）

前提：服务器已安装 MySQL 客户端（如 mysql-client），命令格式：

mysql -h <主机IP> -P <端口号> -u <用户名> -p <数据库名>

参数说明：

• -h：MySQL 服务器的 IP 地址（本地连接可省略，或写 localhost/127.0.0.1）。

• -P：MySQL 端口号（默认 3306，若修改过需指定）。

• -u：登录用户名（如 root）。

• -p：提示输入密码（注意 -p 后无空格，若直接写密码可改为 -p< 密码 >，但安全性低）。

• < 数据库名 >：可选，连接后直接进入该数据库。

示例：连接本地 MySQL，用户 root，数据库 test：

mysql -u root -p test

2. 代码连接（开发场景，如Java/Python）

（1）Python连接（使用pymysql库）

步骤：① 安装 pymysql（pip install pymysql）；② 编写连接代码：

import pymysql

# 建立连接
conn = pymysql.connect(
    host='localhost',  # 服务器IP
    port=3306,         # 端口号
    user='root',       # 用户名
    password='123456', # 密码
    database='test'    # 数据库名
)

# 创建游标（执行SQL的工具）
cursor = conn.cursor()

# 执行SQL
cursor.execute("SELECT * FROM user LIMIT 10")
result = cursor.fetchall()  # 获取查询结果
print(result)

# 关闭游标和连接（避免资源泄露）
cursor.close()
conn.close()

（2）Java连接（使用JDBC驱动）

步骤：① 导入 MySQL JDBC 驱动包（如 mysql-connector-java-8.0.30.jar）；② 编写连接代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class MySQLConnection {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        
        try {
            // 加载驱动（MySQL 8.0+可省略）
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 建立连接
            Connection conn = DriverManager.getConnection(url, user, password);
            // 创建Statement
            Statement stmt = conn.createStatement();
            // 执行SQL
            ResultSet rs = stmt.executeQuery("SELECT * FROM user LIMIT 10");
            // 处理结果
            while (rs.next()) {
                System.out.println(rs.getString("username"));
            }
            // 关闭资源
            rs.close();
            stmt.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 可视化工具连接（运维/分析场景，如Navicat、DBeaver）

步骤：① 打开工具，新建连接→选择 MySQL；② 填写连接信息（主机 IP、端口、用户名、密码、数据库名）；③ 测试连接，成功后即可可视化操作（查询、增删改查）。

注意：若服务器开启防火墙，需开放 MySQL 端口（3306），允许外部 IP 访问。

五、🐍 Python数据分析/处理常用核心库

按功能分类，覆盖数据读取、清洗、分析、可视化全流程：

1. 数据读取与基础处理

• 📊 Pandas：Python 数据分析的核心库，提供 DataFrame（表格型数据结构），支持 CSV/Excel/JSON/ 数据库等多种数据格式的读取（read_csv、read_excel）、清洗（缺失值处理、去重、数据类型转换）、筛选、聚合（groupby、merge）等操作，是数据分析的基础工具。

• 🔧 NumPy：用于数值计算的基础库，提供数组（ndarray）数据结构，支持高效的数组运算（加减乘除、矩阵运算、统计函数），是 Pandas 等库的底层依赖。

2. 数据可视化

• 📈 Matplotlib：Python 可视化的基础库，支持绘制折线图、柱状图、直方图、散点图、饼图等多种图表，可自定义图表样式（颜色、字体、标签），适用于基础可视化需求。

• 🌟 Seaborn：基于 Matplotlib 封装的高级可视化库，语法更简洁，支持绘制更美观的统计图表（如热力图、箱线图、小提琴图），适合用于数据分析结果的快速展示。

• 🌐 Plotly：交互式可视化库，支持绘制可交互的图表（如交互式折线图、地图、3D 图），图表可缩放、悬停查看详情，适合用于制作 Dashboard 或网页展示。

3. 大数据处理

• 🔥 PySpark：Spark 的 Python API，支持分布式数据处理，提供与 Pandas 类似的 DataFrame API，可用于大规模数据的读取、清洗、分析、机器学习等操作，适用于大数据场景。

4. 数据库交互

• 🗄️ PyMySQL：Python 连接 MySQL 数据库的库，支持执行 SQL 语句、获取查询结果，适用于从 MySQL 读取数据或写入数据。

• 🔌 SQLAlchemy：ORM（对象关系映射）库，支持多种数据库（MySQL、PostgreSQL、SQLite 等），可通过 Python 类操作数据库，避免直接编写 SQL，适用于复杂的数据库交互场景。

5. 其他辅助库

• 📅 Datetime：Python 内置的日期时间处理库，用于日期解析、格式转换、时间差计算（如将字符串转换为日期格式、计算两个日期的间隔）。

• 🔍 Re：Python 内置的正则表达式库，用于字符串匹配、提取、替换（如从文本中提取手机号、邮箱，清洗不规则字符串）。

六、⚡ Pyspark简单数据处理分析Demo（口述+代码）

1. 核心需求

对用户行为数据（如用户点击、浏览、下单数据）进行分析，统计：① 每日用户点击量；② 各商品类别的点击 top3；③ 下单用户的点击偏好（点击最多的商品类别）。

2. 实现步骤（口述）

1. 📋 环境准备：确保 Spark 环境已配置（本地模式 / 集群模式），导入 PySpark 相关依赖（SparkSession、DataFrame 函数）。

2. 📥 数据读取：读取用户行为数据（假设为 CSV 格式，字段：user_id、action_time、action_type、product_id、product_category）。

3. 🧹 数据清洗：① 过滤无效数据（如 user_id 为空、action_time 格式错误）；② 转换数据类型（如将 action_time 转换为日期格式，提取日期字段）；③ 过滤所需的行为类型（如点击、下单）。

4. 📊 数据分析：

   1. 统计每日用户点击量：按日期分组，计数用户点击次数。

   2. 各商品类别的点击 top3：按商品类别分组计数，排序后取前 3。

   3. 下单用户的点击偏好：先筛选下单用户，关联其点击数据，按用户和商品类别分组计数，取每个用户点击最多的类别。

5. 📤 结果输出：将分析结果写入 CSV 文件或 MySQL 数据库，供后续使用。

6. 🔚 关闭 SparkSession：释放资源。

3. 代码实现（核心片段）

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, to_date, count, row_number
from pyspark.sql.window import Window

# 1. 初始化SparkSession（入口）
spark = SparkSession.builder \
    .appName("UserBehaviorAnalysis") \
    .master("local[*]")  # 本地模式，集群模式可省略
    .getOrCreate()

# 2. 读取数据（CSV格式）
df = spark.read.csv(
    path="user_behavior.csv",
    header=True,  # 第一行为列名
    inferSchema=True  # 自动推断数据类型
)

# 3. 数据清洗
# 3.1 过滤无效数据
df_clean = df.filter(
    col("user_id").isNotNull() & 
    col("action_time").isNotNull() & 
    col("action_type").isin(["click", "order"])  # 只保留点击和下单行为
)

# 3.2 转换日期格式，提取日期字段
df_clean = df_clean.withColumn("action_date", to_date(col("action_time"), "yyyy-MM-dd"))

# 4. 数据分析
# 4.1 统计每日用户点击量
daily_click = df_clean.filter(col("action_type") == "click") \
    .groupBy("action_date") \
    .agg(count("user_id").alias("daily_click_count")) \
    .orderBy("action_date")

# 4.2 各商品类别的点击top3
category_click = df_clean.filter(col("action_type") == "click") \
    .groupBy("product_category") \
    .agg(count("user_id").alias("click_count")) \
    .orderBy(col("click_count").desc())

# 使用窗口函数取top3
window = Window.orderBy(col("click_count").desc())
category_click_top3 = category_click.withColumn("rank", row_number().over(window)) \
    .filter(col("rank") <= 3) \
    .drop("rank")

# 4.3 下单用户的点击偏好
# 先获取下单用户ID
order_users = df_clean.filter(col("action_type") == "order") \
    .select("user_id").distinct()

# 关联下单用户的点击数据，统计每个用户点击最多的商品类别
user_click_preference = df_clean.filter(col("action_type") == "click") \
    .join(order_users, on="user_id", how="inner") \
    .groupBy("user_id", "product_category") \
    .agg(count("*").alias("click_count"))

# 窗口函数取每个用户点击最多的类别（若有并列取第一个）
window_user = Window.partitionBy("user_id").orderBy(col("click_count").desc())
user_click_preference = user_click_preference.withColumn("rank", row_number().over(window_user)) \
    .filter(col("rank") == 1) \
    .drop("rank", "click_count")

# 5. 结果输出（写入CSV，本地模式）
daily_click.write.csv("daily_click_result", header=True, mode="overwrite")
category_click_top3.write.csv("category_click_top3", header=True, mode="overwrite")
user_click_preference.write.csv("user_click_preference", header=True, mode="overwrite")

# 6. 关闭SparkSession
spark.stop()

七、🔍 ClickHouse/ES 相关问题

1. 你对ClickHouse或ES等其他数据存储有了解吗？

✅ ClickHouse：由 Yandex 开源的列式存储数据库，专为 OLAP（在线分析处理）场景设计，核心特点是查询速度快、支持大规模数据存储、支持复杂的聚合分析。适用于日志分析、用户行为分析、报表统计等场景，常作为大数据分析平台的查询引擎。

✅ Elasticsearch（ES）：基于 Lucene 的分布式搜索引擎，采用倒排索引结构，核心特点是全文检索能力强、支持实时数据写入和查询、可扩展性好。适用于日志检索、全文搜索（如电商商品搜索）、监控告警等场景，常与 Logstash、Kibana 组成 ELK 栈用于日志分析。

2. ClickHouse 和 Hive 表的区别是什么？

3. ClickHouse 查询为什么会快？

核心原因源于其设计上的多重优化，从存储、计算、索引等多个层面提升查询效率：

1. 📊 列式存储优化：按列存储数据，查询时只读取所需列（而非整行），大幅减少磁盘 IO；同时，同列数据类型相同，可进行高效的压缩（如 LZ4、ZSTD 压缩算法），进一步降低存储体积和 IO 开销。

2. 🔍 高效索引结构：支持多种索引类型，如主键索引（按主键排序存储，加速范围查询）、跳数索引（Skip Index，适用于低基数列，如性别、地区，快速跳过大量相同值）、布隆过滤器（Bloom Filter，快速判断值是否存在，减少不必要的查询）。

3. ⚡ 向量执行引擎：查询执行时，将数据按批次（向量）处理，而非单条记录处理，减少 CPU 上下文切换和函数调用开销，提升 CPU 利用率。

4. 📈 预聚合与分区：支持按时间等维度进行分区存储（如按天分区），查询时可只扫描目标分区，减少数据扫描范围；同时支持物化视图，提前计算并存储常用聚合查询结果，查询时直接读取物化视图，无需重复计算。

5. 🔧 分布式架构优化：支持分布式集群部署，数据可分片存储在多个节点，查询时可并行处理，充分利用集群资源；同时支持数据副本，提升查询可用性和并发能力。

6. 🚀 其他优化：支持向量化 SQL 函数、避免不必要的数据拷贝、查询优化器智能选择最优执行计划等。