RDD（Resilient Distribute Dataset，弹性分布式数据集），Spark 中最基本的数据处理模型，最小的计算单元。让Spark实现一个技术栈同意数据处理（one stack to rule them all）的目标。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。

如下图所示，RDD 会分解成 Task 分发到 Executor。

RDD 实现原理

RDD 的实现原理与 Java 的 IO 流套接很相似。Java IO 样例。

1）文件流的方式。下述代码，通过 FileInputStream 的 read() 方法，逐个字符读取效率比较低。

package com.wuji1626.io;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamSample {

    public static void main(String[] args) throws IOException {
        InputStream in = null;
        try {
            in = new FileInputStream("input\\word.txt");
            int data;
            while ((data = in.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close(); // 确保流被关闭以释放资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2）采用 BufferedInputStream 缓冲后再打印。

public class BufferedInputStreamSample {
    public static void main(String[] args) {
        {
            InputStream in = null;
            try {
                in = new BufferedInputStream(new FileInputStream("D:\\workspace\\Java\\bigdata-sample\\input\\word.txt"));
                int data;
                while ((data = in.read()) != -1) {
                    System.out.print((char) data);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close(); // 确保流被关闭以释放资源
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

采用 BufferedInputStream、FileInputStream、InputStream 等字节流存在一个问题：字节形式无法识别字符，如果进行截取很可能造成中文、日文等多字节文字出现乱码的情况。

3）使用 Reader 按照字符流读取文件。

public class BufferedReaderSample {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(
                new FileInputStream("D:\\workspace\\Java\\bigdata-sample\\input\\word.txt"),"UTF-8"));
        String line;
        while ((line = in.readLine()) != null){
            System.out.println(line);
        }
        in.close();
    }
}

BufferedReader/InputStreamReader：是装饰者模式，即在核心的基础上增加一些功能。

RDD概念

RDD（Resilient Distribute Data）是弹性分布式数据集的简称。

RDD 数据处理方式类似 IO 流，也有装饰设计模式的存在。RDD 的数据只有在调用 collect 方法时，才会真正执行业务逻辑操作。之前封装全是功能的扩展。

区别是：Buffer 会存在于 IO 处理中，可以临时存储一些数据，Spark 中数据不会暂存，RDD 不会保持数据。

RDD 将最小计算单元通过组合让它的功能越来越强大。

RDD 的特性

• 弹性：
• 存储的弹性：内存与磁盘的自动切换，Spark 叫 MR（MapReduce）使用内存，由于内存有限，占满时可以自动切换到硬盘。
• 容错的弹性：数据丢失可以自动回复，读取数据时知道读取了什么文件的什么分区，一旦出错可以重复读取即可。分布式计算的容错行要重点考虑。
• 计算的弹性：计算出错可以重试。
• 分片的弹性：可以根据需要重新分片之前有 2 Executor是，两个分区，Executor 增加到 4 个后分区也可以动态调整。
• 分布式：数据存储在大数据集群的不同节点上。
• 不可变：与弹性相反，RDD 封装计算逻辑，不可改变，想要变，只能产生新的 RDD，在新 RDD 里封装计算逻辑，只能用装饰者模式进行套接。
• 可分区并行计算：读取完数据事先进行分区化处理。
• 数据集：RDD 没有保存数据的能力，随着流程一直往下执行下去。封装了计算逻辑的模型，并不保存数据。
• 数据抽象：RDD 是一个抽象类，需要子类具体实现子类功能更丰富完整。

RDD 的 5 个主要属性

RDD 本身是一个抽象类，其内部有5个部分需要实现，其中前3个是必备的：

1. getPartitions()：分区列表（数据块列表）。RDD 数据结构中存在分区列表，用于执行任务时并行计算。是实现分布式计算的重要属性。分区使数据相互独立。

protected def getPartitions(): Array[Partiton]

2. compute()：分区计算函数，计算每个分片的函数。每个分区都有自己的计算逻辑。数据与逻辑相结合的函数，每个 RDD 相同，并非每个分区相同。

def ompute(spkit:Partion, context: TaskContext):Iterator[T]

3. getDependencies()：RDD 之间的依赖关系，RDD 之间都有包装。对父RDD的依赖列表。

protected def getDeendencies():seq[Dependency[_]]=deps

4. partitioner()：key-value RDD的分区器，将数据进行分区的逻辑。

@transient val partitioner: Option[Partitioner]=None

Scala 为解决空针的语法，partioner 属性可能有也可能没有，默认值是一个 None。

5. getPreferredLocations()：每个数据分片的预定义地址列表（如HDFS上的数据块地址），判断计算发到哪个节点效率最优。移动数据，不如移动计算。

前3个方法描述RDD间的Lineage（血缘关系）信息，后2个方法用于优化执行。

RDD的一些通俗描述：

1. 可以将RDD理解为T实例的一个集合，RDD中的每条记录都是一个T实例。
2. 分区（Partition）：将T实例的集合拆分成多个子集合，子集合就是数据分区。
3. 用于构建该RDD的父RDD即是该RDD的父依赖，由于可以有多个父依赖的RDD，对应父RDD是一个依赖列表。RDD之间的依赖关系通过RDD分区之间依赖体现，通过依赖列表以及RDD的getPartitions()方法可以知道RDD的各分区是如何依赖父RDD的分区。如：简单的映射（map）转圜，转换后的RDD（MapPartitionsRDD）各个分区，依赖父RDD的各个分区（分区一一对应的依赖关系），即：转换后RDD各个分区的数据块（Block），是来自父RDD对应分区的数据块。
4. 计算每个片的compute()，体现惰性（Lazy）计算的特性。compute()记录RDD对父依赖的各个分区数据的操作，即记录了对各个分区输入源数据进行计算的结果。

补充：

• compute()针对分区数据，计算的并行数就是分区个数；
• compute()针对分区数据，可以认为计算的粒度是分区粒度，因此可以认为RDD的计算，某种程度上 是粗粒度的，即如果使用RDD的compute()大部分API计算都针对分区而非T元素。如果需要针对T元素进行细粒度处理，需要使用RDD的mapPartitions()操作，直接处理分区的数据Iterator。

5. Key-Value RDD，其实是T类型为Key-Value对的类型。

Spark 执行原理

从计算角度讲，数据处理中需要计算资源（内存 & CPU）和计算模型（计算逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。

Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个个计算任务，然后将任务分发到已经分配资源的计算节点上，按照指定的计算模型进行数据计算，最后得到计算结果。

RDD 是 Spark 框架中用于数据处理的核心模型。以 YARN 为例：

1. YARN 集群启动

2. Spark 通过申请资源创建调度节点和计算节点。

3. Spark 框架根据需求将计算逻辑根据分区划分成不同任务。

4. 调度节点将任务根据计算节点状态发送到对应的计算节点进行计算。

从 1~4 流程可以看出，RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给 Executor 节点执行计算。