Spark面试题持续更新【2023-07-04】

2024-07-25 15:49:50 浏览数 (2)
Spark面试题
  • 1. 谈一谈你对spark的理解
    • 1）我对Spark的理解可以从以下几个方面进行进一步说明：
    • 2） Spark比MarReduce快的原因
  • 2. 介绍Spark的算子，介绍foreach和foreachPartition的区别
  • 3. Spark中广播变量的作用
  • 4. Spark的宽窄依赖，设计宽窄依赖的目的，相关算子
  • 5. Spark的groupByKey和reduceByKey的区别、groupByKey相比较reduceByKey为什么更容易产生数据倾斜
        • reduceBykey通过什么分区
        • groupByKey通过什么分区
        • reduceByKey和groupByKey都使用哈希分区，为什么reduceByKey能缓解数据倾斜问题。
  • 6. Spark的转换算子和行动算子有什么区别
  • 7. 对Spark中Application、job、Stage、Task的理解
  • 8. Spark的运行流程
  • 9. Spark有几种部署方式
  • 10. Spark提交作业参数
  • 11. SparkSQL中join操作与left join操作的区别
  • 12. SparkStreaming有哪几种方式消费Kafka中的数据，它们之间的区别是什么
  • 13. 简述SparkStreaming窗口函数的原理
  • 14. 如何使用Spark实现topN的获取（描述思路或使用伪代码）
  • 15. 京东：调优之前与调优之后性能的详细对比（例如调整map个数，map个数之前多少、之后多少，有什么提升）

1. 谈一谈你对spark的理解

  • 定义（最基础的理解）： Spark是一种基于内存的快速、通用、可扩展的大数据分析（计算）引擎。
  • 定义解读： Spark是一个开源的分布式计算框架，旨在处理大规模数据处理和分析任务。它提供了一个高级别的编程接口，使得开发者可以使用高级的抽象概念（如RDD、DataFrame和Dataset）来进行并行计算和数据处理。
1）我对Spark的理解可以从以下几个方面进行进一步说明：
  • 弹性分布式数据集（RDD）：RDD是Spark的核心数据结构，它代表一个分布式的、可容错的、不可变的数据集合。RDD具有高度的容错性和可伸缩性，可以在内存中缓存数据，以便在多次操作之间共享和重用。RDD支持并行操作，可以通过转换算子和行动算子对数据进行处理和计算。
  • 计算模型：Spark采用了基于内存的计算模型，可以将数据加载到内存中进行高速的数据处理和分析。这种内存计算模型大大提高了计算速度，并且在迭代计算和交互式查询等场景下具有很好的性能。
  • 抽象概念：Spark提供了一系列高级的抽象概念，如DataFrame和Dataset，使得开发者可以使用类似于关系型数据库的查询语言（如SQL）或强类型的编程语言（如Scala、Python和Java）来进行数据处理和分析。这些抽象概念简化了开发过程，提高了开发效率。
  • 广泛的生态系统：Spark拥有丰富的生态系统，包括Spark SQL用于结构化数据处理、Spark Streaming用于实时流处理、MLlib用于机器学习、GraphX用于图计算等。这些模块可以无缝集成，形成一个全面而强大的数据处理和分析平台。
  • 分布式计算能力：Spark利用集群中的多个计算节点并行执行任务，实现了分布式计算。它具有良好的容错机制，可以自动恢复计算中的故障，并支持任务的动态调度和资源管理。

综上所述，Spark是一个高性能、可扩展且易用的分布式计算框架，具有丰富的功能和灵活的编程接口，适用于大规模数据处理、实时流处理、机器学习和图计算等各种场景。它在大数据领域发挥着重要的作用，并受到广泛的应用和支持。

2） Spark比MarReduce快的原因

Spark 计算比 MapReduce 快的根本原因在于 DAG（有向无环图） 计算模型。一般而言，DAG 相比MapReduce 在大多数情况下可以减少shuffle次数。 Spark 的DAGScheduler 相当于一个改进版的 MapReduce，如果计算不涉及与其他节点进行数据交换，Spark可以在内存中一次性完成这些操作，也就是中间结果无须落盘，减少了磁盘IO的操作。但是，如果计算过程中涉及数据交换，Spark 也是会把 shuffle 的数据写磁盘的！

2. 介绍Spark的算子，介绍foreach和foreachPartition的区别

（1） 下面是五个常用的Spark转换算子：

map：对RDD中的每个元素应用一个函数，并返回一个新的RDD。该函数可以是任意的用户自定义函数或Lambda表达式。例如，可以将RDD中的每个元素乘以2。

filter：基于一个条件对RDD中的元素进行过滤，并返回一个新的RDD，只包含满足条件的元素。该条件可以是一个用户自定义函数或Lambda表达式。例如，可以过滤掉RDD中的负数元素。

flatMap：对RDD中的每个元素应用一个函数，返回一个包含零个或多个元素的新RDD。该函数可以生成多个输出元素，这些元素将被扁平化成一个单一的RDD。例如，可以将RDD中的每个元素拆分成单词。

reduceByKey：按键对RDD中的元素进行分组并聚合。对于具有相同键的元素，将应用一个聚合函数来将它们合并为单个值，并生成一个新的RDD。该操作通常与键值对RDD结合使用。例如，可以通过reduceByKey对键值对RDD中的值进行求和。

groupBy：按键对RDD中的元素进行分组，并返回一个包含键值对的RDD，其中键是原始RDD中的唯一键，而值是具有相同键的元素的集合。该操作通常与键值对RDD结合使用。例如，可以根据年份对日期RDD进行分组。

（2）关于foreach和foreachPartition的区别：

  • 区别：
  • foreach是一个行动算子，用于对RDD中的每个元素应用一个函数。它会迭代遍历RDD的所有元素，并将每个元素应用于给定的函数。foreach是一种在分布式环境下执行的迭代操作，但它没有返回结果。
  • foreachPartition也是一个行动算子，但它将RDD的每个分区应用于一个函数。与foreach不同，foreachPartition将分区作为单位进行迭代，并将每个分区的元素集合传递给给定的函数。这可以用于执行批处理操作，以提高执行效率。
  • 区别在于foreach是逐个处理元素，而foreachPartition是逐个处理分区。因此，当需要对RDD中的元素执行操作时，可以使用foreach；当需要对整个分区执行操作时，可以使用foreachPartition。使用foreachPartition可以减少与外部系统的交互次数，从而提高效率。
  • 应用场景 除了遍历打印结果之外，Apache Spark中的foreach操作还有其他实际应用场景，例如：
  1. 写入外部系统：可以使用foreach遍历RDD/DataFrame中的每个元素，并将数据写入外部系统，如数据库、文件系统或消息队列。例如，可以使用它将记录插入数据库或将数据写入分布式文件系统（如Hadoop HDFS）。
  2. 发送数据到API或服务：如果需要将数据发送到外部API或服务，可以使用foreach遍历元素并进行API调用或将数据发送到服务。这对于实时数据处理和与外部系统的集成非常有用。
  3. 执行自定义计算：foreach允许您对RDD/DataFrame的每个元素应用自定义计算或操作。例如，可以计算额外的指标或执行不通过内置Spark函数实现的复杂转换。
  4. 更新外部状态：如果需要基于RDD/DataFrame中的元素更新外部状态，可以使用foreach遍历数据并相应地更新外部状态。这对于维护有状态信息或更新共享资源非常有用。

需要注意的是，Spark中的foreach操作是终端操作，意味着它会触发前面的转换操作的执行。此外，在使用foreach将数据写入外部系统等操作时，确保容错性并适当处理任何可能的失败或重试非常重要。

3. Spark中广播变量的作用

ChatGPT Spark中的广播变量（Broadcast Variables）是一种用于在集群中高效共享大型只读数据集的机制。广播变量可以在每个工作节点上缓存一份数据，以便在执行任务时可以快速访问。

广播变量的作用主要体现在以下几个方面：

  • 提高性能：广播变量可以减少任务之间的数据传输量。在默认情况下，Spark将闭包变量（例如在map或filter函数中引用的外部变量）通过网络发送给每个工作节点。但是，对于较大的只读数据集，这种方式会导致网络传输延迟和额外的开销。通过广播变量，只需要在集群中传输一次数据，然后在每个节点上进行本地访问，减少了网络传输的开销，提高了任务的执行性能。
  • 减少内存占用：广播变量将数据集缓存在内存中，而不是在每个任务中重复加载和存储数据。这样可以减少内存的占用，提高资源利用率。
  • 提供共享数据：广播变量允许在集群中共享只读数据，这对于多个任务需要访问相同数据集的情况非常有用。例如，当多个任务需要使用同一个配置文件、字典、映射表或机器学习模型时，可以使用广播变量将这些数据集共享给所有任务，避免每个任务都进行独立加载和存储。
  • 简化编程模型：通过广播变量，开发者可以更方便地在分布式计算中使用和共享只读数据。它提供了一种简化编程模型的方式，使得开发者可以专注于业务逻辑的实现，而不需要手动处理数据的传输和存储。

需要注意的是，广播变量适用于只读数据集，因为它在任务执行期间是不可变的。如果需要在任务执行期间更新数据集，那么广播变量可能不适合，需要考虑其他机制来共享和更新数据。

4. Spark的宽窄依赖，设计宽窄依赖的目的，相关算子

ChatGPT 在Spark中，宽依赖（Wide Dependency）和窄依赖（Narrow Dependency）是用于描述RDD（弹性分布式数据集）之间依赖关系的概念。

宽依赖（Wide Dependency）：

  • 宽依赖表示子RDD的分区依赖于父RDD的多个分区。
  • 当一个算子需要将父RDD的多个分区数据合并到一个子RDD的分区时，就会产生宽依赖。
  • 宽依赖会导致数据的洗牌（Shuffle），即数据在网络中进行大量的数据传输和重新分区，对性能产生负面影响。
  • 例如，groupByKey、reduceByKey等需要进行全局聚合的操作会产生宽依赖。

窄依赖（Narrow Dependency）：

  • 窄依赖表示子RDD的每个分区只依赖于父RDD的一个分区或者少数几个分区。
  • 当一个算子只需要通过父RDD的一个分区数据就可以计算出子RDD的一个分区时，就会产生窄依赖。
  • 窄依赖不需要进行数据洗牌，只需要简单的数据传输和转换，对性能影响较小。
  • 例如，map、filter、union等不需要全局聚合的操作会产生窄依赖。

设计宽窄依赖的目的：

  • Spark的宽窄依赖机制是为了提高计算效率和容错能力而设计的。
  • 窄依赖允许Spark在不进行数据洗牌的情况下进行并行计算，提高了计算效率。
  • 宽依赖需要进行数据洗牌，但Spark可以通过重新执行丢失的分区来实现容错，提高了容错能力。

总结： Spark的宽依赖和窄依赖是描述RDD之间依赖关系的概念。宽依赖需要进行数据洗牌，而窄依赖可以进行并行计算。Spark通过设计宽窄依赖来提高计算效率和容错能力。

5. Spark的groupByKey和reduceByKey的区别、groupByKey相比较reduceByKey为什么更容易产生数据倾斜

ChatGPT groupByKey和reduceByKey是Spark中用于对键值对RDD进行聚合操作的算子，它们在功能和性能上存在一些区别。

区别：

聚合逻辑：

  • groupByKey：对RDD中具有相同键的元素进行分组，将它们的值组合成一个迭代器。返回一个新的键值对RDD，其中每个键都有一个对应的迭代器。
  • reduceByKey：对RDD中具有相同键的元素进行分组，并对每个键的值进行聚合操作（如求和、求平均值等）。返回一个新的键值对RDD，其中每个键都有一个聚合后的值。

性能：

  • reduceByKey相比groupByKey更具有优势。reduceByKey在分组之后，在每个分组内进行本地聚合操作，减少了数据在网络中的传输量。而groupByKey会将所有数据都进行洗牌（Shuffle），并将数据发送到reduce节点上进行聚合操作，造成了更多的网络传输和数据交换。
  • reduceByKey在聚合之前可以进行本地合并，减少了数据量和网络传输，因此具有更好的性能。

为什么groupByKey相比reduceByKey更容易产生数据倾斜：

  • 数据倾斜是指在进行分组操作时，某些键的数据量远远超过其他键，导致部分任务的处理时间明显长于其他任务，从而降低整体计算性能。
  • groupByKey将具有相同键的元素放在同一个分组中，如果某些键的数据量特别大，则这些数据需要发送到同一个reduce节点上进行聚合操作，导致该节点的负载过重，产生数据倾斜问题。
  • reduceByKey在每个分区内进行本地聚合操作，因此数据倾斜的影响相对较小。它会将数据在每个分区进行合并，减少了特定键的数据量，分摊了负载，降低了数据倾斜的可能性。

综上所述，reduceByKey相比groupByKey更容易处理数据倾斜问题，因为它在分组之前可以进行本地合并，减少了数据量和网络传输，降低了特定键的数据倾斜风险。

reduceBykey通过什么分区

ChatGPT 在Spark中，reduceByKey操作是对具有相同键的元素进行分组和聚合的操作。reduceByKey操作通过哈希分区（Hash Partitioning）来确定每个键值对应的分区。

在哈希分区中，Spark使用键的哈希值来决定将键值对分配到哪个分区。具体而言，Spark首先对键调用hashCode()方法生成哈希码，然后将哈希码与当前RDD的分区数取模，以确定将键值对分配到哪个分区。

在分布式环境中，通常会有多个reduce任务并行运行，每个任务负责处理一个或多个分区。通过哈希分区，Spark将具有相同键的元素分配到相同的分区，以确保具有相同键的元素在同一个reduce任务中进行聚合操作。

使用哈希分区可以确保数据在多个reduce任务之间均匀分布，提高并行性和性能。然而，如果数据倾斜（某些键的数据量远远超过其他键），则可能会导致部分任务的处理负载过重，从而影响性能。在处理数据倾斜的情况下，可以考虑使用其他解决方案，如使用自定义分区器或调整数据分布等方法来缓解数据倾斜问题。

groupByKey通过什么分区

ChatGPT 在Spark中，groupByKey操作是将具有相同键的元素进行分组的操作。groupByKey操作使用哈希分区（Hash Partitioning）来确定每个键值对应的分区。

与reduceByKey类似，groupByKey也是通过键的哈希值来决定将键值对分配到哪个分区。Spark首先对键调用hashCode()方法生成哈希码，然后将哈希码与当前RDD的分区数取模，以确定将键值对分配到哪个分区。

在分布式环境中，通常会有多个任务并行运行，每个任务负责处理一个或多个分区。通过哈希分区，Spark将具有相同键的元素分配到相同的分区，以确保具有相同键的元素在同一个任务中进行分组操作。

然而，需要注意的是，groupByKey操作在数据倾斜的情况下可能会导致一些分区中的数据量远远超过其他分区，从而造成负载不均衡的问题。这是因为groupByKey会将具有相同键的元素放在同一个分区中，如果某些键的数据量特别大，则这些数据需要发送到同一个任务上进行处理，造成该任务的负载过重。

如果数据倾斜成为性能瓶颈，可以考虑使用其他聚合算子，如reduceByKey或aggregateByKey，它们能够在分组之前进行局部聚合，减少数据量和网络传输，从而缓解数据倾斜问题。

reduceByKey和groupByKey都使用哈希分区，为什么reduceByKey能缓解数据倾斜问题。

ChatGPT 对于reduceByKey操作和groupByKey操作，它们在分区方式上都使用了哈希分区，但reduceByKey相比groupByKey更容易缓解数据倾斜问题的原因如下：

  • 本地聚合：reduceByKey在每个分区内进行本地聚合操作，即在每个分区中对具有相同键的元素进行合并。这样可以减少在网络中传输的数据量，将数据量较大的键在本地进行合并，减轻了网络传输压力。
  • 分区级聚合：reduceByKey会在分区级别上进行聚合操作，而不是整体的全局聚合。这意味着具有相同键的数据会在分区内进行合并，而不是在整个RDD上进行合并。这样可以将负载均衡在各个分区上，避免了某个分区成为热点分区的问题。
  • 数据压缩：reduceByKey在进行本地聚合时，可以使用一些数据压缩技术（如Combiner）来减少存储和传输的数据量。这可以进一步降低数据倾斜问题的影响，提高整体性能。

总结：reduceByKey相比groupByKey能够缓解数据倾斜问题的关键在于本地聚合和分区级聚合的策略。这些策略使得具有相同键的数据在分区内进行局部合并，减少了数据传输量，并将负载分散在不同分区上，从而减轻了数据倾斜的影响。

6. Spark的转换算子和行动算子有什么区别

在Spark中，有两种类型的操作：转换算子（Transformation）和行动算子（Action）。它们在执行时的行为和返回结果上有所区别。

转换算子（Transformation）：

  • 转换算子用于从一个RDD（弹性分布式数据集）创建一个新的RDD，或者对一个RDD进行变换操作，并返回一个新的RDD。
  • 转换算子是惰性求值的，即当应用转换算子时，并不会立即执行计算，而是记录下操作的转换规则。
  • 转换算子通常用于构建RDD的计算逻辑，它们不会触发实际的计算，而是创建一个RDD的执行计划。

常见的转换算子包括：

map：对RDD中的每个元素应用一个函数，并返回一个新的RDD。 filter：基于一个条件对RDD中的元素进行过滤，并返回一个新的RDD。 flatMap：对RDD中的每个元素应用一个函数，返回一个包含零个或多个元素的新RDD。 reduceByKey：按键对RDD中的元素进行分组并聚合。

行动算子（Action）：

  • 行动算子用于触发实际的计算并返回结果。当应用行动算子时，Spark将执行由之前的转换算子构建的RDD执行计划，并将计算结果返回给驱动程序或将结果写入外部存储系统。
  • 行动算子是具体执行计算的触发点，会导致Spark执行计算图中的转换算子，并返回一个结果或将结果写入外部存储。

常见的行动算子包括：

collect：将RDD中的所有元素返回到驱动程序中，以数组的形式返回。 count：返回RDD中元素的数量。 first：返回RDD中的第一个元素。 saveAsTextFile：将RDD中的元素保存到文本文件中。

总结： 转换算子用于构建RDD的计算逻辑，是惰性求值的，不会立即执行计算，而是创建一个RDD的执行计划。行动算子触发实际的计算，并返回结果或将结果写入外部存储。行动算子是具体执行计算的触发点。

7. 对Spark中Application、job、Stage、Task的理解

在Apache Spark中，Application、Job、Stage和Task是用于描述作业执行流程和任务划分的重要概念。

  1. Application（应用程序）：Spark应用程序是用户编写的用于执行数据处理和分析任务的程序。一个应用程序由一个或多个作业（Jobs）组成，并且通常由一个驱动程序（Driver）和分布在集群中的多个执行器（Executors）组成。应用程序定义了数据处理的整体逻辑和计算流程。
  2. Job（作业）：Spark作业是应用程序中的一个逻辑单元，代表一组可以并行执行的任务。一个作业由一系列的RDD转换操作组成。每个Action算子都会触发一个作业的执行，这个作业包括了从数据源到Action算子的整个转换过程。这些操作形成一个有向无环图（DAG）。每个作业在数据处理流程中定义了一个阶段（Stage）。
  3. Stage（阶段）：Spark阶段是作业执行的一个划分单元，将作业划分为多个阶段以实现任务的并行执行。一个阶段是由一组相互依赖的RDD转换操作组成，Stage的划分和调度是有DAGScheduler来负责的，并且数据流在这些操作之间没有shuffle操作。阶段可以根据数据的依赖关系进行划分，Stage的边界就是发生Shuffle的地方，可以提高并行度和任务执行效率。
  4. Task（任务）：Spark任务是被送到某个Executor上的作业中的最小执行单元，代表在一个执行器上对数据的操作。每个阶段都被划分为多个任务，每个任务处理RDD的一个分区。任务是在执行器上并行执行的，它们接收输入数据并产生输出数据。

总体而言，应用程序是用户编写的整个Spark程序，由多个作业组成。每个作业由一系列的RDD转换操作组成，形成一个DAG。作业被划分为多个阶段，每个阶段表示一组相互依赖的RDD转换操作，没有shuffle操作。每个阶段被划分为多个任务，在执行器上并行执行，每个任务处理一个RDD分区的数据。通过这样的层次结构和任务划分，Spark能够实现高效的分布式数据处理和计算。

8. Spark的运行流程

1): 在客户端提交Spark application，客户端向 ResourceManager 申请启动ApplicationMaster; 2): ResourceManager收到请求随机找到一台NodeManager节点启动ApplicationMaster(Driver); 3): ApplicationMaster启动之后向ResourceManager申请资源用于启动Executor; 4): ResourceManager返回满足资源的NodeManager节点，ApplicationMaster连接NodeManager节点启动Executor; 5): Executor反向注册给ApplicationMaster(Driver) 6): ApplicationMaster(Driver)发送task,监控task执行，回收结果;

9. Spark有几种部署方式

1）Local:运行在一台机器上，通常是练手或者测试环境。

2）Standalone:构建一个基于Master Slaves的资源调度集群，Spark任务提交给Master运行。是Spark自身的一个调度系统。

3）Yarn: Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

10. Spark提交作业参数

1）在提交任务时的几个重要参数

executor-cores —— 每个executor使用的内核数，默认为1，官方建议2-5个，我们企业是4个

num-executors —— 启动executors的数量，默认为2

executor-memory —— executor内存大小，默认1G

driver-cores —— driver使用内核数，默认为1

driver-memory —— driver内存大小，默认512M

2）给一个提交任务的样式

spark-submit

–master local[5]

–driver-cores 2

–driver-memory 8g

–executor-cores 4

–num-executors 10

–executor-memory 8g

–class PackageName.ClassName XXXX.jar

–name “Spark Job Name”

InputPath

OutputPath

11. SparkSQL中join操作与left join操作的区别

join和SQL中的inner join操作很相似，返回结果是前面一个集合和后面一个集合中匹配成功的，过滤掉关联不上的。

left Join类似于SQL中的左外关联left outer join，返回结果以第一个RDD为主，关联不上的记录为空。

12. SparkStreaming有哪几种方式消费Kafka中的数据，它们之间的区别是什么

一、基于Receiver的方式

这种方式使用Receiver来获取数据。Receiver是使用Kafka的高层次Consumer API来实现的。receiver从Kafka中获取的数据都是存储在Spark Executor的内存中的（如果突然数据暴增，大量batch堆积，很容易出现内存溢出的问题），然后Spark Streaming启动的job会去处理那些数据。

然而，在默认的配置下，这种方式可能会因为底层的失败而丢失数据。如果要启用高可靠机制，让数据零丢失，就必须启用Spark Streaming的预写日志机制（Write Ahead Log，WAL）。该机制会同步地将接收到的Kafka数据写入分布式文件系统（比如HDFS）上的预写日志中。所以，即使底层节点出现了失败，也可以使用预写日志中的数据进行恢复。

二、基于Direct的方式

这种新的不基于Receiver的直接方式，是在Spark 1.3中引入的，从而能够确保更加健壮的机制。替代掉使用Receiver来接收数据后，这种方式会周期性地查询Kafka，来获得每个topic partition的最新的offset，从而定义每个batch的offset的范围。当处理数据的job启动时，就会使用Kafka的简单consumer api来获取Kafka指定offset范围的数据。

优点如下：

**简化并行读取：**如果要读取多个partition，不需要创建多个输入DStream然后对它们进行union操作。Spark会创建跟Kafka partition一样多的RDD partition，并且会并行从Kafka中读取数据。所以在Kafka partition和RDD partition之间，有一个一对一的映射关系。

**高性能：**如果要保证零数据丢失，在基于receiver的方式中，需要开启WAL机制。这种方式其实效率低下，因为数据实际上被复制了两份，Kafka自己本身就有高可靠的机制，会对数据复制一份，而这里又会复制一份到WAL中。而基于direct的方式，不依赖Receiver，不需要开启WAL机制，只要Kafka中作了数据的复制，那么就可以通过Kafka的副本进行恢复。

一次且仅一次的事务机制。

三、对比：

基于receiver的方式，是使用Kafka的高阶API来在ZooKeeper中保存消费过的offset的。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。

基于direct的方式，使用kafka的简单api，Spark Streaming自己就负责追踪消费的offset，并保存在checkpoint中。Spark自己一定是同步的，因此可以保证数据是消费一次且仅消费一次。

在实际生产环境中大都用Direct方式

13. 简述SparkStreaming窗口函数的原理

窗口函数就是在原来定义的SparkStreaming计算批次大小的基础上再次进行封装，每次计算多个批次的数据，同时还需要传递一个滑动步长的参数，用来设置当次计算任务完成之后下一次从什么地方开始计算。

图中time1就是SparkStreaming计算批次大小，虚线框以及实线大框就是窗口的大小，必须为批次的整数倍。虚线框到大实线框的距离（相隔多少批次），就是滑动步长。

14. 如何使用Spark实现topN的获取（描述思路或使用伪代码）

方法1：

（1）按照key对数据进行聚合（groupByKey）

（2）将value转换为数组，利用scala的sortBy或者sortWith进行排序（mapValues）数据量太大，会OOM。

方法2：

（1）取出所有的key

（2）对key进行迭代，每次取出一个key利用spark的排序算子进行排序

15. 京东：调优之前与调优之后性能的详细对比（例如调整map个数，map个数之前多少、之后多少，有什么提升）

这里举个例子。比如我们有几百个文件，会有几百个map出现，读取之后进行join操作，会非常的慢。这个时候我们可以进行coalesce操作，比如240个map，我们合成60个map，也就是窄依赖。这样再shuffle，过程产生的文件数会大大减少。提高join的时间性能。

变量 函数 数据 性能 spark

0 人点赞