spark中常用算子介绍

原创 已于 2026-07-19 15:41:23 修改 · 524 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
spark

当前文章被收录于：

spark
1 篇文章 0 人学习
订阅专栏 查看详情
于 2026-07-19 14:56:32 首次发布

目录

1 简要介绍

算子：分布式集合对象上的API。

RDD算子分为，

  • 转换算子Transformation：返回值仍旧是RDD。它是懒加载的，如果没有action算子，它是不工作的。
  • action算子：返回值不是RDD。

对于这两类算子来说，转换算子，相当于在构建执行计划；action算子是执行计划的开关。

2 转换算子

2.1 map

map算子：将RDD中的数据一条条处理。

rdd.map(func)

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3 ,4, 5], 3)
    print(rdd.map(lambda data: data * 10).collect())

输出，

[10, 20, 30, 40, 50]

2.2 flatMap

功能：对rdd先执行map操作，然后进行解除嵌套操作。

解除嵌套，

#嵌套的list
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

#如果解除了嵌套
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3)
    print(rdd.flatMap(lambda x: x).collect())

输出为，

[1, 2, 3, 4, 5, 6, 7, 8, 9]

2.3 reduceByKey

功能：针对KV型RDD，自动按照key分组，然后根据你提供的聚合逻辑，完成组内数据的聚合。

rdd.reduceByKey(func)
#func: (v, v) -> v

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2)], 3)
    print(rdd.reduceByKey(lambda x, y: x + y).collect())

输出为，

[('b', 3), ('a', 6)]

2.4 mapValues

功能：针对二元元组RDD，对其内部的二元元组的Value执行map操作。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2)], 3)
    print(rdd.mapValues(lambda x: x * 10).collect())

输出为，

[('a', 10), ('a', 20), ('a', 30), ('b', 10), ('b', 20)]

2.5 groupBy

功能：将RDD的数据进行分组。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2)], 3)
    print(rdd.groupBy(lambda x: x[0]).collect())
    print(rdd.groupBy(lambda x: x[0]).map(lambda x: (x[0], list(x[1]))).collect())

结果为，

[('b', <pyspark.resultiterable.ResultIterable object at 0x7a945583b5f0>), ('a', <pyspark.resultiterable.ResultIterable object at 0x7a945c11faa0>)]
[('b', [('b', 1), ('b', 2)]), ('a', [('a', 1), ('a', 2), ('a', 3)])]

2.6 filter

功能：过滤想要的数据进行保留。

保留func返回值为true的数据。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2)], 3)
    print(rdd.filter(lambda x: x[1] >= 2).collect())

结果为，

[('a', 2), ('a', 3), ('b', 2)]

2.7 distinct

功能：对RDD数据进行去重，返回新的RDD。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 1), ('a', 2), ('b', 1), ('b', 1)], 3)
    print(rdd.distinct().collect())

结果为，

[('a', 1), ('a', 2), ('b', 1)]

2.8 union

功能：2个rdd合并成1个rdd返回。

rdd1.union(rdd2)

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd1 = sc.parallelize([1, 2, 3, 4], 3)
    rdd2 = sc.parallelize(['1', '2', '3'], 3)
    print(rdd1.union(rdd2).collect())

结果为，

[1, 2, 3, 4, '1', '2', '3']

2.9 join

功能：对两个RDD执行JOIN操作，可实现SQL的内连接或外连接，只能用于KV型RDD。关联条件按照二元元组的KEY来进行。

语法：

rdd.join(other_rdd)           #内连接
rdd.leftOuterJoin(other_rdd)  #左外连接
rdd.rightOuterJoin(other_rdd) #右外连接

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd1 = sc.parallelize([('001', 'zhangsan'), ('002', 'lisi'), ('003', 'wangwu')], 3)
    rdd2 = sc.parallelize([('001', '销售部'), ('002', '硬件部'), ('000', '软件部')], 1)
    print(rdd1.join(rdd2).collect())
    print(rdd1.leftOuterJoin(rdd2).collect())
    print(rdd1.rightOuterJoin(rdd2).collect())

结果为，

[('001', ('zhangsan', '销售部')), ('002', ('lisi', '硬件部'))]                  
[('003', ('wangwu', None)), ('001', ('zhangsan', '销售部')), ('002', ('lisi', '硬件部'))]
[('000', (None, '软件部')), ('001', ('zhangsan', '销售部')), ('002', ('lisi', '硬件部'))]

2.10 intersection

功能：求2个rdd的交集，返回一个新rdd。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd1 = sc.parallelize([1, 2, 3], 3)
    rdd2 = sc.parallelize([2, 3, 4, 5], 1)
    print(rdd1.intersection(rdd2).collect())

结果为，

[2, 3]

2.11 glom

功能：将RDD的数据加上嵌套，这个嵌套按照分区来进行。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.glom().collect())

结果为，

[[1, 2], [3, 4], [5, 6, 7]]

2.12 groupByKey

功能：针对KV型RDD，自动按照key分组。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 3), ('b', 4)], 3)
    print(rdd.groupByKey().collect())
    print(rdd.groupByKey().map(lambda x: (x[0], list(x[1]))).collect())

结果为，

[('b', <pyspark.resultiterable.ResultIterable object at 0x6ffdb97bb5f0>), ('a', <pyspark.resultiterable.ResultIterable object at 0x6ffdb8c8b7a0>)]
[('b', [3, 4]), ('a', [1, 2])]

2.13 sortBy

功能：对RDD数据进行排序，基于你指定的排序依据。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.sortBy(lambda x: x, ascending=False, numPartitions=2).collect())

结果为，

[7, 6, 5, 4, 3, 2, 1]

2.14 sortByKey

功能：针对KV型RDD，按照key进行排序。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('b', 2), ('A', 3), ('B', 4)], 3)
    print(rdd.sortByKey(ascending=True, numPartitions=2, keyfunc=lambda key: str(key).lower()).collect())

输出为，

[('a', 1), ('A', 3), ('b', 2), ('B', 4)]

2.15 mapPartitions

一次传递的是一整个分区的数据。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 2)
    print(rdd.mapPartitions(lambda lst: [x * 10 for x in lst]).collect())

结果为，

[10, 20, 30, 40, 50, 60, 70]

2.16 partitionBy

功能：对KV型RDD进行自定义分区操作。

用法：

rdd.partitionBy(参数1,参数2)
- 参数1:重新分区后有几个分区
- 参数2:定义分区规则，函数传入

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([(1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0)], 2)
    print(rdd.glom().collect())
    print(rdd.partitionBy(2, lambda x: (x % 2)).glom().collect())

结果为，

[[(1, 0), (2, 0), (3, 0)], [(4, 0), (5, 0), (6, 0), (7, 0)]]                    
[[(2, 0), (4, 0), (6, 0)], [(1, 0), (3, 0), (5, 0), (7, 0)]]

2.17 repartition

功能：对RDD的分区执行重新分区，仅数量。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([(1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0)], 3)
    print(rdd.glom().collect())
    print(rdd.repartition(2).glom().collect())

结果为，

[[(1, 0), (2, 0)], [(3, 0), (4, 0)], [(5, 0), (6, 0), (7, 0)]]                  
[[(5, 0), (6, 0), (7, 0)], [(1, 0), (2, 0), (3, 0), (4, 0)]]

3 action算子

3.1 countByKey

功能：统计key出现的次数，一般适用于KV型RDD。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 3), ('c', 4)], 3)
    print(rdd.countByKey())

结果为，

defaultdict(<class 'int'>, {'a': 2, 'b': 1, 'c': 1})

3.2 collect

功能：将RDD各个分区内的数据，统一收集到Driver中，形成一个List对象。

要注意，如果结果数据集很大，会把Driver内存撑爆。

3.3 reduce

功能：将RDD数据集按照你传入的逻辑进行聚合。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5], 3)
    print(rdd.reduce(lambda a, b: a + b))

结果为，

15

3.4 fold

功能：和reduce一样，接受传入逻辑进行聚合，聚合是带有初始值的。

这个初始值，会作用在：

  • 分区内聚合
  • 分区间聚合

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 1, 1], 1)
    print(rdd.glom().collect())
    print(rdd.fold(10, lambda a, b: a + b))

结果为，

[[1, 1, 1]]                                                                     
23

3.5 first

功能：取出RDD的第一个元素。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3], 3)
    print(rdd.first())

结果为，

1

3.6 take

功能：取RDD的前N个元素，组合成List返回。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.take(4))

结果为，

[1, 2, 3, 4]

3.7 top

功能：对RDD数据集进行降序排列，取前N个。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.top(4))

结果为，

[7, 6, 5, 4]

3.8 count

功能：计算RDD有多少条数据，返回值是一个数字。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.count())

结果为，

7

3.9 takeSample

功能：随机抽样RDD的数据。

用法：

takeSample(参数1: True or False, 参数2: 采样数, 参数3: 随机数种子)
- 参数1: True表示运行取同一个数据；False表示不允许取同一个数据。
- 参数2: 抽样要几个。
- 参数3: 随机数种子。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.takeSample(False, 5))

结果为，

[4, 6, 3, 5, 2]

3.10 takeOrdered

功能：对RDD进行排序取前N个。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.takeOrdered(3, lambda x: x))
    print(rdd.takeOrdered(3, lambda x: -x))

结果为，

[1, 2, 3]                                                                       
[7, 6, 5]

3.11 foreach

功能：对RDD的每一个元素，执行你提供的逻辑操作。这个方法没有返回值。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 3)
    print(rdd.foreach(lambda x: print(x * 10)))

结果为，

50tage 0:>                                                          (0 + 3) / 3]
60
70
30
40
10
20
None

3.12 saveAsTextFile

功能：将RDD的数据写入文本文件中。支持本地写出、hdfs等文件系统。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 1)
    rdd.saveAsTextFile("out")

结果为，
在这里插入图片描述

3.13 foreachPartition

功能：和普通foreach一致，一次处理的是一整个分区的数据。

使用示例，

from pyspark import SparkConf, SparkContext


if __name__ == "__main__":
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    rdd = sc.parallelize([1, 2, 3, 4, 5, 6, 7], 2)
    def f(iter):
        res = []
        for x in iter:
            res.append(x * 10)
        print(res)
    print(rdd.foreachPartition(f))

结果为，

[40, 50, 60, 70]                                                    (0 + 2) / 2]
[10, 20, 30]
None
标签
#spark #大数据 #分布式
Spark常用算子介绍
olifchou的博客
11-13 6134
一、简介 Spark主要包含Transformation和Action两种算子。 Transformation算子 Transformation类算子一般都是懒操作的，即该过程并不提交Job作业，而是等到Action算子才会提交作业。主要包括：map、filter、flatMap、mapPartitions、mapPartitionsWithIndex、sample、union、intersection、distinct、groupByKey、reduceByKey、aggregateByKey、sort
Spark中rdd的介绍，创建及常用算子
zxk112233的博客
10-08 671
目录 1.RDD简述 2.Rdd的创建 2.1集合并行化 2.2读取外部文件系统 2.3调用转换类的算子 3.Rdd的算子 3.1.Transformation 3.1.1.map 3.1.3.mapPartitions 3.1.4.mapPartitionsWithIndex 3.1.5.flatMap 3.1.6.filter 3.1.7.groupBy,gro...
Spark--常用算子介绍
Natsu_natsu的博客
10-10 272
spark算计介绍
SPARK RDD常用算子介绍
汝知否
11-19 446
常用的RDD转换操作API： 常用的RDD转换操作API 操作 含义 filter(func) 筛选出满足函数func的元素，并返回一个新的数据集 map(func) 将每个元素传递到函数func中，并将结果返回为一个新的数据集，一对一进行转换 flatmap(func) 与map()相似，但每个输入元素都可以映射到0或多个输出结果
spark RDD常用算子介绍
qa38113202的博客
06-15 782
package com.cn.RDD import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.SparkContext._ import org.apache.spark.streaming.StreamingContext import org.
spark GraphX 常用算子介绍
zzf135的博客
04-26 282
构建图，查看图信息边过滤，点过滤三元组属性值出度入度subgraph连通图参考官网文档：https://spark.apache.org/docs/latest/graphx-programming-guide.html。
大数据技术之Spark（二）——RDD常用算子介绍
five小点心的博客
03-31 4367
RDD 的操作分为和。就是从一个 RDD 产生一个新的 RDD；就是进行实际的计算。我们把RDD方法也称为算子。所以转换操作和行动操作一般也被叫做和。
EMR Serverless Spark 基于 MinHash-LSH 实现 PB 级文本语义去重 4 倍加速
科技很有意思
07-31 315
某企业迁移至阿里云 EMR Serverless Spark 后，借助 MinHash-LSH 内置函数与 Fusion Engine 向量化加速，去重性能提升 4 倍，数据准备周期从天级降至小时级。
SparkCore 之 Spark Transformation 类算子详解
https://starzy1990.github.io/
07-30 289
本文系统拆解了Spark核心Transformation算子，按照功能分为五大类：映射过滤类（map/filter等）、聚合排序类（reduceByKey等）、连接类（join等）、分区调整类（repartition等）和集合操作类（union等）。重点分析了各算子的语法、依赖类型（窄/宽）、执行原理和性能特点，特别指出： 映射类算子（如mapPartitions）通过分区级操作可显著提升性能 聚合类算子中reduceByKey相比groupByKey因Map端预聚合优势明显 宽依赖算子（如join）会触发
腾讯云发布智能数据湖计算AI DLC 支持Spark和Ray同一平台运行
cloudbigdata的博客
07-27 452
腾讯云正式发布智能数据湖计算平台AI DLC，面向自动驾驶、具身智能、Agent等AI场景，提供覆盖数据处理、训练、推理到 Agent 应用的一体化能力。以腾讯自研的 WorkBuddy 为例，接入 AI DLC 后，其处理同一批数据的端到端时间缩短80%，完成相同任务所需算力约为此前的五分之一。
大数据Hadoop运维应用实践——Spark与hadoop集群的整合_独立模式下Spark集群的安装部署
提供C#相关开发 、云计算、运维测试、网络安全相关技术分享与服务，有意向可联系。
07-30 340
本文是关于Apache Spark独立模式集群配置安装实践教程。主要内容包括：1. Spark核心组件与架构解析；2. 版本选型指南；3. Standalone模式集群部署方案，涵盖环境变量配置、内存分配、核心参数调优等关键技术点；4. 生产级systemd服务配置与Ansible自动化部署脚本；5. 实战演示spark-shell本地/集群模式使用及常见问题解决方案；6. spark-submit任务提交示例。适合作为企业级Spark集群部署的参考手册。
Java版Spark全套知识点总结+100道练习题（含答案）
Remix_xy的博客
07-30 215
常用Java算子：map、flatMap、filter、distinct、sortBy、union、intersection、subtract、groupByKey、reduceByKey、join、cogroup等。Spark SQL是Spark处理结构化数据的组件，兼容Hive SQL、标准SQL，支持SQL语句和DSL编程两种开发方式，底层基于Catalyst优化器实现查询优化，性能远超Hive。答案：机制：所有转换算子仅记录计算逻辑，不执行任务，只有行动算子调用时，才根据DAG执行计算。
大数据Hadoop运维应用实践——Spark与hadoop集群的整合_在yarn中配置spark
最新发布
提供C#相关开发 、云计算、运维测试、网络安全相关技术分享与服务，有意向可联系。
07-31 56
本文详细介绍了在Hadoop YARN环境下集成Spark集群的配置过程。主要内容包括：1）规划Spark与Hadoop集群整合方案，仅需在一个节点安装Spark客户端；2）修改YARN配置文件并部署Spark Shuffle服务；3）配置Spark历史日志服务，包括HDFS目录创建和配置文件修改；4）重启相关服务并启动HistoryServer；5）测试YARN下Spark任务提交的两种模式（Client和Cluster）。适用于大数据平台运维人员参考实施Spark与Hadoop集群的整合部署。
SparkCore 之 Spark RDD 五大特性及弹性分布式容错原理剖析
https://starzy1990.github.io/
07-30 453
RDD 论文获奖不是因为它"比 MR 快"，而是它提出了一种新的分布式计算抽象——通过五个特性的精心设计，在容错、并行、数据本地性、内存计算四个维度上找到了最优平衡点。Partitions→ 并行粒度Dependency→ Stage 划分基础→ Shuffle 分布策略→ 数据本地性保证→ 惰性求值 + 计算容错**RDD 五大特性不是孤立的知识点，而是一个有机整体。**理解它们如何联动，才算真正理解了 Spark Core。
Spark 调优-数据倾斜从发现到定位在到解决
weixin_39750695的博客
07-30 257
大数据开发高频问题：数据倾斜，每次面试都有他；但是你真的经历过自己去发现优化过吗？本次手把手带你从发现到排查解决全过程。
SparkCore 之 Spark Action 类算子详解
https://starzy1990.github.io/
07-30 530
Action 算子虽然数量不多（约 20 个），但理解它们的数据流向和内存压力：数据向 Driver 汇聚 → 控制数据量foreach/saveAsTextFile → Executor/存储：数据向外发散 → 无内存压力reduce/aggregate → 聚合后返回：Executor 间聚合 → 关注 Shuffle选对 Action，不仅决定性能，更决定你的 Driver 会不会 OOM。👨‍💻starzy| AI Data Engineer / 大数据技术实践者。
DGX Spark使用流程记录
guoqingru0311的博客
07-27 91
NVIDIA DGX Spark相关的使用记录
Spark数据源
qq_43494013的博客
07-27 338
Spark数据源
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YMWM_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值