Spark RDD的基本概念

已于 2023-04-18 21:11:09 修改
阅读量680 收藏 1
点赞数 2
分类专栏： Apache Spark基础 文章标签： spark 大数据 scala
于 2023-04-18 16:25:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41940415/article/details/130224962
版权

1. 什么是RDD

RDD的全称为Resilient Distributed Dataset，是⼀个弹性、可复原的分布式数据集，是Spark中最基本的抽象，是⼀个不可变的、有多个分区的、可以并⾏计算的集合。
RDD中并不装真正要计算的数据，⽽装的是描述信息，描述以后从哪⾥读取数据，调⽤了⽤什么⽅法，传⼊了什么函数，以及依赖关系等。

resilient的含义：

  1. 有弹性(或弹力)的;
  2. 可迅速恢复的; 有适应力的; 能复原的;

所以，RDD本质更像是Scala中的迭代器

2. RDD的五大属性

  1. 有⼀些列连续的分区(分区列表)：

分区编号从0开始，分区的数量决定了对应阶段Task的并⾏度。对于RDD 来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD 时指定RDD 的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。
protected def getPartitions: Array[Partition]

  1. 有⼀个函数作⽤在每个输⼊切⽚上(compute计算函数):

每⼀个分区都会⽣成⼀个Task，对该分区的数据进⾏计算，这个函数就是具体的计算逻辑。
Spark 中RDD 的计算是以分片为单位的，每个RDD都会实现compute 函数以达到这个目的。ompute 函数会对迭代器进行复合，不需要保存每次计算的结果。
def compute(split: Partition, context: TaskContext): Iterator[T]

  1. RDD之间的⼀系列依赖关系：

RDD调⽤Transformation后会⽣成⼀个新的RDD，⼦RDD会记录⽗RDD的依赖关系，包括宽依赖（有shuffle）和窄依赖（没有shuffle）。
在部分分区数据丢失时，Spark 可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD 的所有分区进行重新计算。
protected def getDependencies: Seq[Dependency[_]] = deps

  1. （可选的）K-V的RDD在Shuffle会有分区器：

当前Spark 中实现了两种类型的分片函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。只有对于于key-value 的RDD ， 才会有Partitioner， 非key-value 的RDD 的Parititioner 的值是None。Partitioner 函数不但决定了RDD 本身的分片数量， 也决定了parent RDD Shuffle 输出时的分片数量。
默认使⽤HashPartitioner

  1. 处理 HDFS 上的文件时，会按文件及偏移量范围划分 partition，通常一个 hdfs 的 block 块对应一个 partition，比如：

PARTITION_0:/inputdata/aaa.txt ,0~128M

PARTITION_1:/inputdata/aaa.txt,128M~200M
2. 处理 MySQL 等数据库中的数据时，会按照用户指定的某个字段的取值范围和指定的分区数进行 partition 划分，比如：

PARTITION_0: from xdb.table_a where id < 100000

PARTITION_1: from xdb.table_a where id >=100000 and id<200000
PARTITION_2: from xdb.table_a where id >=200000
val partitioner: Option[Partitioner] = None

  1. （可选的）每个分区的首选计算执行位置：

对于一个HDFS 文件来说，这个列表保存的就是每个Partition 所在的块的位置。按照“移动数据不如移动计算”的理念，Spark 在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。
protected def getPreferredLocations(split: Partition): Seq[String] = Nil
RDD 是一个应用层面的逻辑概念。一个RDD 多个分片。RDD 就是一个元数据记录集，记录了RDD 内存所有的关系数据

image.png

3. RDD的算⼦分类

  1. **Transformation：**即转换算⼦，调⽤转换算⼦会⽣成⼀个新的RDD，Transformation是Lazy的，不会触发job执⾏。
  2. **Action：**⾏动算⼦，调⽤⾏动算⼦会触发job执⾏，本质上是调⽤了sc.runJob⽅法，该⽅法从最后⼀个RDD，根据其依赖关系，从后往前，划分Stage，⽣成TaskSet。

4. 创建RDD的⽅法

4.1 从文件系统

4.1.1 本地文件系统

val rdd = sc.textFile("/tmp/student.txt", 2)
rdd.foreach(println)

4.1.2 HDFS文件系统

val rdd = sc.textFile("hdfs:///tmp/student.txt", 2)
rdd.foreach(println)

4.2 通过并行化方式

val rdd: RDD[Int] = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))

5. RDD的转换

RDD中的所有转换都是情性的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集(例如一个文件)上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这个设计让Spark更加有效率地运行。例如我们可以实现：通过map创建的一个新数据集，并在reduce 中使用，最终只返回reduce的结果给Driver，而不是整个大的新数据集。

5.1 RDD的本质

5.1.1 scala迭代器案例

5.1.1.1 案例01
object IteratorDemo {
  def main(args: Array[String]): Unit = {

    val source = Source.fromFile("data/wordcount/input/wc.txt")

    val lines: Iterator[String] = source.getLines()

    val filtered: Iterator[String] = lines.filter(line => {
      !line.startsWith("aaa")
    })

    val upper: Iterator[String] = filtered.map(line => {
      line.toUpperCase()
    })

    while (upper.hasNext) {
      val upperWord = upper.next()
      println(upperWord)
    }

    source.close()
  }
}

断点执行

第一次断点

image.png

第二次断点

image.png

第三次断点

image.png

5.1.1.2 案例02
object IteratorDemo2 {
  def main(args: Array[String]): Unit = {
    val iterator = List(1, 2).iterator

    val iter1 = iterator.map(it => {
      println("第一次map执行：")
      it * 10
    })

    val iter2 = iter1.map(it => {
      println("第二次map执行：")
      it * 1000
    })

    iter2.foreach(println)
  }
}

第一次：
注释掉iter2.foreach(println)，点击运行无运行结果。

image.png

第二次：
放开注释，点击运行

image.png

5.1.1.3 解释

有此可见，调用scala中的迭代器的方法(map、filter、flatmap)时，并不会立刻执行。
直到调用Iterator的foreach()、next()方法，才会真正的触发迭代器执行，这就是所谓的lazy特性。
这就类似RDD中的转换算子和行动算子。

5.1.1.4 scala中迭代器的lazy原理

map源码

  def map[B](f: A => B): Iterator[B] = new AbstractIterator[B] {
    def hasNext = self.hasNext
    def next() = f(self.next())
  }
  1. 迭代器要真正执行运算，需要调用hasNext判断是否还是数据，然后调用next返回下条数据
  2. 而scala的map中并没有调用hasNext也没有调用next
  3. map算子只是返回一个新的迭代器：
    1. **hasNext()调用父迭代器的hasNext()**方法
    2. **next()在父迭代器的next()**的返回结果上，应用了map算子传入的函数f

5.1.2 RDD的lazy原理

Rdd 转换算子的 lazy 原理，与scala 的迭代器算子的 lazy 原理很类似。
**Scala 迭代器算子：**map/fatMap 等，方法的内部实现只是创建了一个新的迭代器返回（并没有去调用迭代器的 hasNext 和next 进行迭代计算）
**Rdd 的转换算子：**map/fatMap 等，方法的内部实现只是创建了一个新的 RDD返回（并没有去调用RDD 内部的迭代器的hasNext 和 next进行迭代计算）

5.2 RDD的依赖关系

RDD之间的依赖关系一般分为两种，宽依赖和窄依赖。
image.png

5.2.1 窄依赖

/**
 * Base class for dependencies where each partition of the parent RDD is used by at most one
 * partition of the child RDD.  Narrow dependencies allow for pipelined execution.
 */
abstract class NarrowDependency[T](rdd: RDD[T]) extends Dependency(rdd) {
  /**
   * Get the parent partitions for a child partition.
   * @param partitionId a partition of the child RDD
   * @return the partitions of the parent RDD that the child partition depends upon
   */
  def getParents(partitionId: Int): Seq[Int]
}

如果新生成的child RDD中每个分区都依赖parent RDD中的一部分分区，那么这个分区依赖关系被称为NarrowDependency。

5.2.2 宽依赖

/**
 * Represents a dependency on the output of a shuffle stage.
 * @param rdd the parent RDD
 * @param partitioner partitioner used to partition the shuffle output
 * @param serializerClass class name of the serializer to use
 */
class ShuffleDependency[K, V](
    @transient rdd: RDD[_ <: Product2[K, V]],
    val partitioner: Partitioner,
    val serializerClass: String = null)
  extends Dependency(rdd.asInstanceOf[RDD[Product2[K, V]]]) {

  val shuffleId: Int = rdd.context.newShuffleId()
}

宽依赖表示新生成的child RDD中的分区依赖parent RDD中的每个分区的一部分。

5.2.3 实际情况

image.png
NarrowDependency：
窄依赖有如上图几种形式：OneToOne，Range，ManyToMany。
按照通常的定义，其中左下角的ManyToMany这种形式被定义为宽依赖。但参考Spark算子：cartesian。
cartesian算子逻辑就是ManyToMany的数据流转方式，但是参考cartesian算子的源码(待后面再具体分析)，该算子是一个窄依赖。
ShuffleDependency：
宽依赖通常都是ManyToMany这种形式。但与窄依赖中ManyToMany不同的是，窄依赖中子RDD会依赖父RDD的整个分区的所有数据，而宽依赖中子RDD只会依赖父RDD分区中的一部分数据。

6. RDD的算子

常见算子参考:
https://spark.apache.org/docs/latest/rdd-programming-guide.html

6.1 keys & values

6.1.1 使用

val sc = new SparkContext(conf)

val lst: Seq[(String, Int)] = List(
      ("spark", 1), ("hadoop", 1), ("hive", 1), ("spark", 1),
      ("spark", 1), ("flink", 1), ("hbase", 1), ("spark", 1),
      ("kafka", 1), ("kafka", 1), ("kafka", 1), ("kafka", 1),
      ("hadoop", 1), ("flink", 1), ("hive", 1), ("flink", 1)
    )

val wordAndOne: RDD[(String, Int)] = sc.parallelize(lst, 4)

// 获取keys
val keyRDD1: RDD[String] = wordAndOne.keys

// 使用map实现同样的效果
val keyRDD2: RDD[String] = wordAndOne.map(_._1)

val values1: Array[String] = keyRDD1.collect()
val values2: Array[String] = keyRDD2.collect()

println(values1.toBuffer)
println(values2.toBuffer)

image.png

6.1.2 深入理解

进入wordAndOne.keys

PairRDDFunctions.scala

class PairRDDFunctions[K, V](self: RDD[(K, V)])
(implicit kt: ClassTag[K], vt: ClassTag[V], ord: Ordering[K] = null)
extends Logging with Serializable {

    // 省略若干方法
  
    def keys: RDD[K] = self.map(_._1)
  
}

进入RDD类

RDD.scala
image.png

因此，当使用PairRDDFunctions的构造方法来调用keys方法：

val wordAndOne: RDD[(String, Int)] = sc.parallelize(lst, 4)

//不使用隐式转换
val pairRDDFunc = new PairRDDFunctions[String, Int](wordAndOne)
val keyRDD = pairRDDFunc.keys

由此可见，keys和values本是PairRDDFunctions的方法，此处涉及隐式转换，将rdd.keys转化为调用rdd.map(_._1)。
此类算子出了keys，还有：values、mapValues、flatMapValues等

6.2 ReduceByKey

6.2.1 使用

val conf = new SparkConf()
.setAppName("WordCount")
.setMaster("local[*]") //本地模式，开多个线程
//1.创建SparkContext
val sc = new SparkContext(conf)


val lst: Seq[(String, Int)] = List(
      ("spark", 1), ("hadoop", 1), ("hive", 1), ("spark", 1),
      ("spark", 1), ("flink", 1), ("hbase", 1), ("spark", 1),
      ("kafka", 1), ("kafka", 1), ("kafka", 1), ("kafka", 1),
      ("hadoop", 1), ("flink", 1), ("hive", 1), ("flink", 1)
    )
//通过并行化的方式创建RDD，分区数量为4
val wordAndOne: RDD[(String, Int)] = sc.parallelize(lst, 4)


val reduced: RDD[(String, Int)] = wordAndOne.reduceByKey(_ + _)

6.2.2 分区理解

ReduceByKey对应的逻辑图
image.png

进入
wordAndOne.reduceByKey(_ + _)

def reduceByKey(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  reduceByKey(defaultPartitioner(self), func)
}

进入
defaultPartitioner

def defaultPartitioner(rdd: RDD[_], others: RDD[_]*): Partitioner = {
  val rdds = (Seq(rdd) ++ others)
  val hasPartitioner = rdds.filter(_.partitioner.exists(_.numPartitions > 0))

  val hasMaxPartitioner: Option[RDD[_]] = if (hasPartitioner.nonEmpty) {
    Some(hasPartitioner.maxBy(_.partitions.length))
  } else {
    None
  }

  val defaultNumPartitions = if (rdd.context.conf.contains("spark.default.parallelism")) {
    rdd.context.defaultParallelism
  } else {
    rdds.map(_.partitions.length).max
  }

  // If the existing max partitioner is an eligible one, or its partitions number is larger
  // than or equal to the default number of partitions, use the existing partitioner.
  if (hasMaxPartitioner.nonEmpty && (isEligiblePartitioner(hasMaxPartitioner.get, rdds) ||
      defaultNumPartitions <= hasMaxPartitioner.get.getNumPartitions)) {
    hasMaxPartitioner.get.partitioner.get
  } else {
    new HashPartitioner(defaultNumPartitions)
  }
}

class HashPartitioner(partitions: Int) extends Partitioner {
  require(partitions >= 0, s"Number of partitions ($partitions) cannot be negative.")

  def numPartitions: Int = partitions

  def getPartition(key: Any): Int = key match {
    case null => 0
    case _ => Utils.nonNegativeMod(key.hashCode, numPartitions)
  }

  override def equals(other: Any): Boolean = other match {
    case h: HashPartitioner =>
      h.numPartitions == numPartitions
    case _ =>
      false
  }

  override def hashCode: Int = numPartitions
}

该种情况会使用HashPartitioner。并且，在key位null的时候，会发生数据倾斜。
具体什么什么情况使用什么Partitioner在后续分区和分区器的文章中再具体介绍。

进入
Utils.nonNegativeMod(key.hashCode, numPartitions)

def nonNegativeMod(x: Int, mod: Int): Int = {
  val rawMod = x % mod
  rawMod + (if (rawMod < 0) mod else 0)
}
  1. 分区号有两个因素决定：key(的hashcode值)和分区数
  2. key相同，分区号一定相同；
  3. 一个分区号可能会有不同的key；
  4. key.hashcode可能是负数，但分区号一定是非负的；

6.2.3 深入理解

在reduceByKey的底层调用的是combineByKeyWithClassTag

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = self.withScope {
  combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)
}

调用combineBykey

val lst: Seq[(String, Int)] = List(
  ("spark", 1), ("hadoop", 1), ("hive", 1), ("spark", 1),
  ("spark", 1), ("flink", 1), ("hbase", 1), ("spark", 1),
  ("kafka", 1), ("kafka", 1), ("kafka", 1), ("kafka", 1),
  ("hadoop", 1), ("flink", 1), ("hive", 1), ("flink", 1)
)
val wordAndOne = sc.parallelize(lst, 4)

//调用combineByKey实现与reduceByKey同样的功能
//前两个函数是在上游执行的
//在每个分区中，key第一次出现，将value进行相应的操作
val f1 = (x: Int) => {
  val stage = TaskContext.get().stageId()
  val partition = TaskContext.getPartitionId()
  println(s"f1 function invoked in state: $stage, partition: $partition")
  x
}
//在每个分区内，将key相同的value进行局部聚合操作
val f2 = (a: Int, b: Int) => {
  val stage = TaskContext.get().stageId()
  val partition = TaskContext.getPartitionId()
  println(s"f2 function invoked in state: $stage, partition: $partition")
  a + b
}
//第三个函数是在下游完成的
val f3 = (m: Int, n: Int) => {
  val stage = TaskContext.get().stageId()
  val partition = TaskContext.getPartitionId()
  println(s"f3 function invoked in state: $stage, partition: $partition")
  m + n
}

val reduced: RDD[(String, Int)] = wordAndOne.combineByKey(f1, f2, f3)

image.png
DAG图
image.png
由此可见，reduceByKey在map(stage 0)端进行了预聚合。

未完待续…

我不需要这个昵称
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
rdd分片 spark_Spark RDD基本概念与基本用法
weixin_39924584的博客
12-23 217
1. 什么是RDDRDD(Resilient Distributed Dataset)叫做分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错，位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。2. RDD的属性1) A list...
Spark RDD基本概念、宽窄依赖、转换行为操作
upupfeng的博客
02-22 567
本文介绍一下rdd的基本属性概念、rdd的转换/行动操作、rdd的宽/窄依赖。 文章目录RDD概述RDD的内部代码先看看基本概念的代码：常用的函数/算子案例小总结转换、行动算子一些常见的行动操作宽、窄依赖一些常见的宽窄依赖Reference RDD：Resilient Distributed Dataset 弹性分布式数据集，是Spark中的基本抽象。 RDD表示可以并行操作的元素的不变分区集...
Spark RDD基本概念与基本用法
Swordfall的博客
05-08 2168
1. 什么是RDD RDD(Resilient Distributed Dataset)叫做分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错，位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。 2. RDD的属性 1)...
Spark RDD编程基本操作
晓晓的天空
03-11 2728
Spark RDD编程基本操作
Spark_RDD基本概念
weixin_44449054的博客
02-28 150
标题1.什么是RDD2. 为什么会产生RDD3.RDD的属性4.RDD运行图5.RDD弹性6. RDD特点 1.什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。 RDD允许用户在执行多个查询时显式地将数据缓存在内存中，后续的查询能够重用这些数据，这极大地提升了查询速度 Dataset： 一个数据集合，用于存放数据的。 Distributed： RDD中的数据是分布式
spark RDD概念及组成详解
鸭梨的博客
11-17 795
是什么 RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。 实体就是一个class abstract class RDD[T: ClassTag]( @transient private var _sc: SparkContext, @transient private var deps: Seq[Dependency[_]] ) extends Serializ
SparkRDD讲解
m0_52835696的博客
10-31 753
SparkRDD
Spark RDD
zhaoguowei的博客
10-25 581
Spark RDD概述 弹性分布式数据集 Resilient Distributed Datasets (RDDs)，是Spark中最基本的数据（计算）抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。创建RDD的方法有两种：并行化 驱动程序中的现有集合，或引用外部存储系统（例如共享文件系统，HDFS，HBase或提供Hadoop InputFormat的任何数据源）...
Spark RDD简介
哈
08-25 9983
RDD基本概念 RDD(Resilient Distributed Datasets)，弹性分布式数据集，是分布式内存的一个抽象概念。RDD提供了一种高度受限的共享内存模型，即RDD是只读的记录分区的集合，只能通过在其他RDD执行确定的转换操作（如map、join和group by）而创建，然而这些限制使得实现容错的开销很低。 对开发者而言，RDD可以看作是Spark的一个对象，它本身运行于内存中，如读文件是一个RDD，对文件计算是一个RDD，结果集也是一个RDD ，不同的分片、 数据之间的依赖 、key-
spark rdd 实战 ，基本语法
01-24
本文将对 Spark RDD 进行深入浅出的讲解，涵盖 Spark 的基本特性、生态体系、优势、支持的 API、运行模式、RDD 的概念和类型、容错 Lineage、缓存策略等知识点。 Spark 的基本特性 Spark 是一个高可伸缩性、高...
Spark RDD是什么？
01-07
本节将对 RDD 的基本概念及与 RDD 相关的概念做基本介绍。 RDD 的基本概念 RDD 是 Spark 提供的最重要的抽象概念，它是一种有容错机制的特殊数据集合，可以分布在集群的结点上，以函数式操作集合的方式进行各种并行...
Spark RDD 资料
01-31
总之，Apache Spark 中的 RDD 是一个非常重要的概念，理解其特性及如何使用可以大大提升数据处理的效率。通过掌握 RDD 的创建方式、属性以及编程 API，开发者可以更好地利用 Spark 来解决复杂的数据处理问题。
Spark rdd讲解
06-09
**Resilient Distributed Dataset (RDD)** 是 Spark 核心框架中的一个基本抽象，代表了一个不可变的、分区的数据元素集合，可以在集群上并行操作。RDD 的设计初衷是为了支持大规模数据集上的容错、高效和并行计算。 ...
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 785
我们使用Structured Streaming来监控socket数据统计WordCount。
【系统架构设计】数据库系统（四）
weixin_48618536的博客
07-25 667
数据仓库建立之后，首先要从数据源中抽取相关的数据到数据准备区，在数据准备区中经过净化处理后再加载到数据仓库数据库，最后根据用户的需求将数据导入数据集市和知识挖掘库中。数据源：是数据仓库系统的基础，是整个系统的数据源泉，通常包括企业内部信息和外部信息，内部信息包括存放于RDBMS（关系型DBMS）中的各种业务处理数据和各类文档数据；本层的功能是从数据源抽取数据，对所抽取的数据进行筛选、清理，将处理过的数据导入或者说加载到数据仓库中，根据用户的需求设立数据集市，完成数据仓库的复杂查询、决策分析和知识的挖掘等。
分布式系统常见软件架构模式
Ben的专栏
07-25 958
简而言之，有效管理数据和通信流对于构建健壮且可扩展的分布式系统至关重要。对等、API 网关、发布-订阅、请求-响应、事件溯源、ETL、批处理、流处理和编排等架构模式提供了有价值的解决方案，以应对系统设计和实现中的各种挑战。通过理解这些软件架构和分布式系统模式及其各自的优势和权衡，架构师和开发人员可以做出明智的决策，设计出满足其应用程序和用户不断变化的需求的系统。
消息队列-rabbitmq（生产者.消费者. 消息.可靠性）
最新发布
2202_75352238的博客
07-28 287
在我们 生产者发送消息到交换机的时候，假如 我们发送到交换机 ，但是 队列没有收到消息，会返回ack，发送到交换机，然后发送到队列，消费者没有接收到消息返回ack，但是发送到交换机失败，会返回nack。死信交换机 ，都是假如一个定时消息过期了，或者发送延迟消息我们直接把该消息传递到我们绑定的死信交换机中，跟上文 消息发送失败了返回rejct之后，消息发送到err交换机是两种不同的策略。当一条消息发送失败的时候，消费者重新尝试消费消息，达到我们重试的次数之后，消费者返回reject，mq直接删除消息。
Spark RDD API入门与实用操作
对于初学者来说，这份PDF文档是一个重要的学习资源，它涵盖了RDD的基本概念、创建、管理和持久化。 **1. RDD简介** RDD（Resilient Distributed Dataset）是Spark中不可或缺的一部分，它代表了一个不可变且分区的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值