> 作者：幻好
> 來源：https://developer.hs.net/thread/2173

# 概述

Apache Spark 是一個快速且通用的叢集計算系統。提供 Java、Scala、Python 和 R 中的高階 API，以及支援通用執行圖的最佳化引擎。它還支援一組豐富的高階工具，包括用於 SQL 和結構化資料處理的 Spark SQL、用於機器學習的 MLlib、用於圖形處理的 GraphX 和 Spark Streaming。

本文主要介紹Spark入門知識，以及核心 RDD 相關概念。

![R-C.png](https://developer.hs.net/storage/attachments/2022/03/17/lB5FBWsuMDdzO8SBc0MhwOQndwJl7LBSeW9aJSg6_thumb.png "5427")

# Spark RDD

## RDD 基礎概念

### RDD 是什麼

**RDD**(Resilient Distributed Dataset)名為**彈性分散式資料集**，是 Spark 中最基本的資料抽象，代表一個不可變、可分割槽、裡面的元素可平行計算的集合。 具體釋義：

- Resilient：彈性伸縮，RDD 裡面的中的資料可以儲存在記憶體中或者磁碟裡面。
- Distributed：元素是分散式儲存的，可直接用於分散式計算。
- Dataset：資料集合，可以存放很多元素。

> RDD 是一個**只讀**的資料集，其不實際儲存真正要計算的資料，而是記錄了資料的位置在哪裡，資料的轉換關係（呼叫的方法，傳入的函式）。

### RDD 設計目的

在許多迭代式演算法(比如機器學習、圖演算法等)和互動式資料探勘中，不同計算階段之間會重用中間結果，即一個階段的輸出結果會作為下一個階段的輸入。但是，之前的 MapReduce 框架採用非迴圈式的資料流模型，把中間結果寫入到 HDFS 中，帶來了大量的資料複製、磁碟 IO 和序列化開銷。且這些框架只能支援一些特定的計算模式(map/reduce)，並沒有提供一種通用的資料抽象。
AMP 實驗室發表的一篇關於 RDD 的論文:[《Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing》](http://people.csail.mit.edu/matei/papers/2012/nsdi_spark.pdf)就是為了解決這些問題的。
RDD 提供了一個抽象的資料模型，使使用者不必擔心底層資料的分散式特性，只需將具體的應用邏輯表達為一系列轉換操作(函式)，不同 RDD 之間的轉換操作之間還可以形成依賴關係，進而實現管道化，從而避免了中間結果的儲存，大大降低了資料複製、磁碟 IO 和序列化開銷，並且還提供了更多的API(map/reduec/filter/groupBy 等)。

### RDD 主要屬性

在RDD內部，每個 RDD 都具有**五個主要屬性**：

- A list of partitions（分割槽列表）
- A function for computing each split（計算每個拆分的函式）
- A list of dependencies on other RDDs（對其他 RDD 的依賴列表）
- Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)（可選地，一個用於鍵值 RDD 的分割槽器（例如，說 RDD 是雜湊分割槽的））
- Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)（（可選）計算每個拆分的首選位置列表（例如 HDFS 檔案的塊位置））

![1647242613598-bd7cae1a-b899-4eb6-ab53-cceeb23aebe8.png](https://developer.hs.net/storage/attachments/2022/03/17/P8Nd5B2vXbx2YNpLPIZoQRvAn21dRstF8j2VCqXC_thumb.png "5428")
屬性說明：

| 屬性                                                                                                       | 說明                                                                                                                                                                                                                                                                   |
| ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| A list of partitions                                                                                       | 一組分片(Partition)/一個分割槽(Partition)列表，即資料集的基本組成單位。對於 RDD 來說，每個分片都會被一個計算任務處理，分片數決定並行度。使用者可以在建立 RDD 時指定 RDD 的分片個數，如果沒有指定，那麼就會採用預設值。                                                     |
| A function for computing each split                                                                        | 一個函式會被作用在每一個分割槽。Spark 中 RDD 的計算是以分片為單位的，compute 函式會被作用到每個分割槽上。                                                                                                                                                                  |
| A list of dependencies on other RDDs                                                                       | 一個 RDD 會依賴於其他多個 RDD。RDD 的每次轉換都會生成一個新的 RDD，所以 RDD 之間就會形成類似於流水線一樣的前後依賴關係。在部分分割槽資料丟失時，Spark 可以透過這個依賴關係重新計算丟失的分割槽資料，而不是對 RDD 的所有分割槽進行重新計算。(Spark 的容錯機制)                |
| Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)                | -可選項，對於 KV 型別的 RDD 會有一個 Partitioner，即 RDD 的分割槽函式，預設為 HashPartitioner。                                                                                                                                                                          |
| Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file) | 可選項,一個列表，儲存存取每個 Partition 的優先位置(preferred location)。 對於一個 HDFS 檔案來說，這個列表儲存的就是每個 Partition 所在的塊的位置。按照"移動資料不如移動計算"的理念，Spark 在進行任務排程的時候，會盡可能選擇那些存有資料的 worker 節點來進行任務計算。 |

### RDD 資料結構

RDD 是一個資料集的表示，不僅表示了資料集，還表示了這個資料集從哪來，如何計算，主要屬性包括：

- 分割槽列表
- 計算函式
- 依賴關係
- 分割槽函式(預設是 hash)
- 最佳位置

分割槽列表、分割槽函式、最佳位置，這三個屬性其實說的就是資料集在哪，在哪計算更合適，如何分割槽； 計算函式、依賴關係，這兩個屬性其實說的是資料集怎麼來的。

## RDD 基本操作

### RDD 物件建立

> API文件參考：[https://spark.apache.org/docs/2.4.5/api/scala/index.html#org.apache.spark.SparkContext](https://spark.apache.org/docs/2.4.5/api/scala/index.html#org.apache.spark.SparkContext)

透過 `SparkContext.scala` API 原始碼，能夠了解到 RDD 可以透過以下方法建立：

- 由外部儲存系統的資料集建立，包括本地的檔案系統，還有所有 Hadoop 支援的資料集，比如 HDFS、Cassandra、HBase 等。

![1647244703608-b8acabb7-d077-4771-a8ac-48772ba28a53.png](https://developer.hs.net/storage/attachments/2022/03/17/uy3yD25JEkHU8i3A4nCEE6RQDuQEoRhW3nBmhRMK_thumb.png "5429")

```scala
// 建立一個 SparkContext 物件
val spConf = new SparkConf().setAppName("WordCount").setMaster("local")
val spContext = new SparkContext(spConf)
// 本地系統檔案建立 RDD
val textFile = spContext.textFile("src/wordCount/temp/test.txt")
// HDFS 檔案建立 RDD
val textFile1 = spContext.textFile("hdfs://node1:8088/wordCount/temp/test.txt")
```

2. 透過已存在的 RDD 經過運算元轉換生成新的 RDD：

```scala
val rdd = textFile.flatMap(_.split(" "))
```

3. 透過已存在的集合建立新的 RDD：

```scala
val rdd1 = spContext.parallelize(Array(1,2,3,4,5,6,7,8))
val rdd2 = spContext.makeRDD(List(1,2,3,4,5,6,7,8))
```

![1647330208280-73edc821-8a85-4ba4-9929-ca76807d538b.png](https://developer.hs.net/storage/attachments/2022/03/17/elpMy83V9rt2HjHXBPZP7tYemZhcl874yTMOjfie_thumb.png "5430")

> `parallelize` 方法以惰性並行化執行。如果 `seq` 是一個可變集合，並且在呼叫並行化之後和對 RDD 的第一個操作之前被更改，則生成的 RDD 將反映修改後的集合，傳遞引數的副本以避免這種情況。
> 避免使用 `parallelize(Seq())` 建立一個空的RDD 。考慮 emptyRDD 用於沒有分割槽的 RDD，或 `parallelize(Seq[T]())` 用於T的 RDD 有空分割槽。

![1647330252866-c289c72f-ea8a-4c4c-b4fd-dffeb7299d25.png](https://developer.hs.net/storage/attachments/2022/03/17/7Maf0qlKugrnefFXJok1JzsNNBGpolo7LpP7mGkT_thumb.png "5431")

> 透過原始碼發現 `makeRDD` 方法底層還是呼叫的 `parallelize` 方法

### RDD 運算元概述

RDD 中的運算元即官方中稱為 Operator （操作），對應 RDD 物件中的方法。
為什麼不直接叫方法呢？

- 之所以叫運算元是為了與原 Scala 中物件的方法進行區分，因為 Scala 中物件的方法是在同一節點的記憶體中完成的，而 RDD 的運算元是將計算邏輯傳送到分散式節點（Executor 端）中執行的
- RDD 的方法外部操作都是在 Driver 端執行，而方法內部的邏輯程式碼是在 Executor 端執行

> 參考博文理解：[https://blog.csdn.net/weixin_43101402/article/details/116065748](https://blog.csdn.net/weixin_43101402/article/details/116065748)

RDD 的運算元分為兩類：

- Transformations 轉換操作，返回一個新的 RDD
- Actions 動作操作，返回值不是 RDD(無返回值或返回其他計算結果值)

> RDD 中的所有轉換都是惰性求值/延遲執行的，也就是說並不會直接計算。只有當發生一個要求返回結果給 Driver 的 Action 動作時，這些轉換才會真正執行。
> 之所以使用惰性求值/延遲執行，是因為這樣可以在 Action 時對 RDD 操作形成 DAG （有向無環圖）進行 Stage 的劃分和並行最佳化，這種設計讓 Spark 更加有效率地執行。

Spark 還為 RDD 提供了統計相關運算元：

| Operator       | 說明                      |
| -------------- | ------------------------- |
| count          | 個數                      |
| mean           | 均值                      |
| sum            | 求和                      |
| max            | 最大值                    |
| min            | 最小值                    |
| variance       | 方差                      |
| sampleVariance | 從取樣中計算方差          |
| stdev          | 標準差:衡量資料的離散程度 |
| sampleStdev    | 取樣的標準差              |
| stats          | 檢視統計結果              |

### Transformations

Spark RDD 支援通用的 transformations 轉換運算元如下列表所示：

| **轉換運算元**                                                                  | **功能說明**                                                                                                                                                                                                                                                                                                                              |
| ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **map**(_func_)                                                             | 返回一個新的 RDD，該 RDD 由每一個輸入元素經過 func 函式轉換後組成                                                                                                                                                                                                                                                                               |
| **filter**(_func_)                                                          | 返回一個新的 RDD，該 RDD 由經過 func 函式計算後返回值為 true 的輸入元素組成                                                                                                                                                                                                                                                                     |
| **flatMap**(_func_)                                                         | 類似於 map，但是每一個輸入元素可以被對映為 0 或多個輸出元素(所以 func 應該返回一個序列，而不是單一元素)                                                                                                                                                                                                                                         |
| **mapPartitions**(_func_)                                                   | 類似於 map，但獨立地在 RDD 的每一個分片上執行，因此在型別為 T 的 RDD 上執行時，func 的函式型別必須是 Iterator[T] => Iterator[U]                                                                                                                                                                                                                 |
| **mapPartitionsWithIndex**(_func_)                                          | 類似於 mapPartitions，只是func 多了一個整型的分割槽索引值，因此如果RDD包含元素型別為T，則 func 必須是 Iterator `<t>` => Iterator `<u>` 的對映函式。                                                                                                                                                                                           |
| **sample**(_withReplacement_, _fraction_, _seed_)                       | 取樣部分（比例取決於 fraction ）資料，同時可以指定是否使用回置取樣（withReplacement），以及隨機數種子(seed)                                                                                                                                                                                                                                     |
| **union**(_otherDataset_)                                                   | 返回源資料集和引數資料集（otherDataset）的並集                                                                                                                                                                                                                                                                                                  |
| **intersection**(_otherDataset_)                                            | 返回源資料集和引數資料集（otherDataset）的交集                                                                                                                                                                                                                                                                                                  |
| **distinct**([_numPartitions_]))                                            | 返回對源資料集做元素去重後的新資料集                                                                                                                                                                                                                                                                                                            |
| **groupByKey**([_numPartitions_])                                           | 只對包含鍵值對的RDD有效，如源RDD包含 (K, V) 對，則該運算元返回一個新的資料集包含 (K, Iterable `<v>`) 對。注意：如果你需要按key分組聚合的話（如sum或average），推薦使用 reduceByKey或者 aggregateByKey 以獲得更好的效能。注意：預設情況下，輸出計算的並行度取決於源RDD的分割槽個數。當然，你也可以透過設定可選引數 numTasks 來指定並行任務的個數。 |
| **reduceByKey**(_func_, [_numPartitions_])                                | 如果源RDD包含元素型別 (K, V) 對，則該運算元也返回包含(K, V) 對的RDD，只不過每個key對應的value是經過func聚合後的結果，而func本身是一個 (V, V) => V 的對映函式。另外，和 groupByKey 類似，可以透過可選引數 numTasks 指定reduce任務的個數。                                                                                                          |
| **aggregateByKey**(_zeroValue_)(_seqOp_, _combOp_, [_numPartitions_]) | 如果源RDD包含 (K, V) 對，則返回新RDD包含 (K, U) 對，其中每個key對應的value都是由 combOp 函式 和 一個“0”值zeroValue 聚合得到。允許聚合後value型別和輸入value型別不同，避免了不必要的開銷。和 groupByKey 類似，可以透過可選引數 numTasks 指定reduce任務的個數。                                                                                 |
| **sortByKey**([_ascending_], [_numPartitions_])                           | 如果源RDD包含元素型別 (K, V) 對，其中K可排序，則返回新的RDD包含 (K, V) 對，並按照 K 排序（升序還是降序取決於 ascending 引數）                                                                                                                                                                                                                   |
| **join**(_otherDataset_, [_numPartitions_])                               | 如果源RDD包含元素型別 (K, V) 且引數RDD（otherDataset）包含元素型別(K, W)，則返回的新RDD中將包含內關聯後key對應的 (K, (V, W)) 對。外關聯(Outer joins)操作請參考 leftOuterJoin、rightOuterJoin 以及 fullOuterJoin 運算元。                                                                                                                          |
| **cogroup**(_otherDataset_, [_numPartitions_])                            | 如果源RDD包含元素型別 (K, V) 且引數RDD（otherDataset）包含元素型別(K, W)，則返回的新RDD中包含 (K, (Iterable `<v>`, Iterable `<w>`))。該運算元還有個別名：groupWith                                                                                                                                                                            |
| **cartesian**(_otherDataset_)                                               | 如果源RDD包含元素型別 T 且引數RDD（otherDataset）包含元素型別 U，則返回的新RDD包含前二者的笛卡爾積，其元素型別為 (T, U) 對。                                                                                                                                                                                                                    |
| **pipe**(_command_, _[envVars]_)                                          | 以shell命令列管道處理RDD的每個分割槽，如：Perl 或者 bash 指令碼。RDD中每個元素都將依次寫入程式的標準輸入（stdin），然後按行輸出到標準輸出（stdout），每一行輸出字串即成為一個新的RDD元素。                                                                                                                                                        |
| **coalesce**(_numPartitions_)                                               | 將RDD的分割槽數減少到numPartitions。當以後大資料集被過濾成小資料集後，減少分割槽數，可以提升效率。                                                                                                                                                                                                                                                  |
| **repartition**(_numPartitions_)                                            | 將RDD資料重新混洗（reshuffle）並隨機分佈到新的分割槽中，使資料分佈更均衡，新的分割槽個數取決於numPartitions。該運算元總是需要透過網路混洗所有資料。                                                                                                                                                                                                   |
| **repartitionAndSortWithinPartitions**(_partitioner_)                       | 根據partitioner（spark自帶有HashPartitioner和RangePartitioner等）重新分割槽RDD，並且在每個結果分割槽中按key做排序。這是一個組合運算元，功能上等價於先 repartition 再在每個分割槽內排序，但這個運算元內部做了最佳化（將排序過程下推到混洗同時進行），因此效能更好。                                                                                          |

> 參考文件：[https://spark.apache.org/docs/2.4.5/rdd-programming-guide.html#transformations](https://spark.apache.org/docs/2.4.5/rdd-programming-guide.html#transformations)

### Actions

Spark RDD 支援通用的 Actions 動作運算元如下列表所示：

| **動作運算元**                                             | **功能說明**                                                                                                                                                                                                                                                                                                                                                                              |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **reduce**(_func_)                                     | 將RDD中元素按func進行聚合（func是一個 (T,T) => T 的對映函式，其中T為源RDD元素型別，並且func需要滿足 交換律 和 結合律 以便支援平行計算）                                                                                                                                                                                                                                                         |
| **collect**()                                            | 將資料集中所有元素以陣列形式返回驅動器（driver）程式。通常用於，在RDD進行了filter或其他過濾操作後，將一個足夠小的資料子集返回到驅動器記憶體中。                                                                                                                                                                                                                                                   |
| **count**()                                              | 返回資料集中元素個數                                                                                                                                                                                                                                                                                                                                                                            |
| **first**()                                              | 返回資料集中首個元素（類似於 take(1) ）                                                                                                                                                                                                                                                                                                                                                         |
| **take**(_n_)                                          | 返回資料集中前 n 個元素                                                                                                                                                                                                                                                                                                                                                                         |
| **takeSample**(_withReplacement_, _num_, [_seed_]) | 返回資料集的隨機取樣子集，最多包含 num 個元素，withReplacement 表示是否使用回置取樣，最後一個引數為可選引數seed，隨機數生成器的種子。                                                                                                                                                                                                                                                           |
| **takeOrdered**(_n_, _[ordering]_)                   | 按元素排序（可以透過 ordering 自定義排序規則）後，返回前 n 個元素                                                                                                                                                                                                                                                                                                                               |
| **saveAsTextFile**(_path_)                             | 將資料集中元素儲存到指定目錄下的文字檔案中（或者多個文字檔案），支援本地檔案系統、HDFS 或者其他任何Hadoop支援的檔案系統。儲存過程中，Spark會呼叫每個元素的toString方法，並將結果儲存成檔案中的一行。                                                                                                                                                                                            |
| **saveAsSequenceFile**(_path_)(Java and Scala)         | 將資料集中元素儲存到指定目錄下的Hadoop Sequence檔案中，支援本地檔案系統、HDFS 或者其他任何Hadoop支援的檔案系統。適用於實現了Writable介面的鍵值對RDD。在Scala中，同樣也適用於能夠被隱式轉換為Writable的型別（Spark實現了所有基本型別的隱式轉換，如：Int，Double，String 等）                                                                                                                     |
| **saveAsObjectFile**(_path_)(Java and Scala)           | 將RDD元素以Java序列化的格式儲存成檔案，儲存結果檔案可以使用 SparkContext.objectFile 來讀取。                                                                                                                                                                                                                                                                                                    |
| **countByKey**()                                         | 只適用於包含鍵值對(K, V)的RDD，並返回一個雜湊表，包含 (K, Int) 對，表示每個key的個數。                                                                                                                                                                                                                                                                                                          |
| **foreach**(_func_)                                    | 在RDD的每個元素上執行 func 函式。通常被用於累加操作，如：更新一個累加器（[Accumulator](http://spark.apache.org/docs/latest/programming-guide.html#AccumLink) ） 或者 和外部儲存系統互操作。注意：用 foreach 操作出累加器之外的變數可能導致未定義的行為。更詳細請參考前面的“理解閉包”（[Understanding closures](http://spark.apache.org/docs/latest/programming-guide.html#ClosuresLink)）這一小節。 |

> 參考文件：[https://spark.apache.org/docs/2.4.5/rdd-programming-guide.html#actions](https://spark.apache.org/docs/2.4.5/rdd-programming-guide.html#actions)

### RDD 運算元實踐

```scala
  /**
   * 給定一個鍵值對 RDD： val rdd = sc.parallelize(Array(("spark",2),("hadoop",6),("hadoop",4),("spark",6)))
   * key 表示圖書名稱，value 表示某天圖書銷量 請計算每個鍵對應的平均值，也就是計算每種圖書的每天平均銷量。
   * 最終結果:("spark",4),("hadoop",5)。
   */
  def calRddDemo(sc: SparkContext): Unit = {
    val rdd = sc.parallelize(Array(("spark", 2), ("hadoop", 6), ("hadoop", 4), ("spark", 6)))
    val mapRdd = rdd.groupByKey()
  
    //    方法1
    val args1 = mapRdd.mapValues(o => o.sum / o.size).collect()
    args1.foreach(println)
  
    //    方法2
    val args2 = mapRdd.map(t => (t._1, t._2.sum / t._2.size)).collect()
    args2.foreach(println)
  }
```

## RDD 持久化

Spark 中最重要的功能之一就是將資料集持久化（或快取）在記憶體中，當持久化一個 RDD 時，每個節點都會將它計算的任何分割槽儲存在記憶體中，並在對該資料集（或從它派生的資料集）的其他操作中重用它們。這使得未來的行動更快（通常超過 10 倍）。快取是迭代演算法和快速互動使用的關鍵工具。
透過使用 `persist()` 或 `cache()` 方法將 RDD 標記為持久化，在第一次在 Action 計算時觸發，它將計算的結果儲存在節點的記憶體中。在觸發後面的 Action 時，該 RDD 將會被快取在計算節點的記憶體中，並供後面重用。
![1647342966653-46c4f512-d25c-40f7-b71f-c561d477b911.png](https://developer.hs.net/storage/attachments/2022/03/17/m8Z6IsxJkY8S42eQzHAoZ4za2Xt2OAzr4ynOy5bG_thumb.png "5432")

> 透過檢視 RDD 的原始碼發現 cache 最終也是呼叫了 persist 無參方法(預設儲存只存在記憶體中)。

Spark 的快取是容錯的——如果 RDD 的任何分割槽丟失，它將使用最初建立它的轉換自動重新計算。

### RDD 儲存級別

每個持久化的 RDD 都可以使用不同的儲存級別進行儲存，例如：允許將資料集持久化到磁碟上、將其持久化在記憶體中或者作為序列化的 Java 物件（以節省空間），跨節點複製它。這些透過將 `StorageLevel` 物件傳遞給 `persist()` 來設定級別。 `cache()` 方法是使用預設儲存級別的簡寫，即 `StorageLevel.MEMORY_ONLY`（將反序列化的物件儲存在記憶體中）。

| **儲存級別**                                                                                                          | **說明**                                                                                 |
| --------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| MEMORY_ONLY                                                                                                                 | -預設級別                                                                                      |
| -將 RDD 以非序列化的 Java 物件儲存在 JVM 中。                                                                               |                                                                                                |
| -如果沒有足夠的記憶體儲存 RDD，則某些分割槽將不會被快取，每次需要時都會重新計算。                                               |                                                                                                |
| MEMORY_AND_DISK                                                                                                             | -將 RDD 以非序列化的 Java 物件儲存在 JVM 中。                                                  |
| -如果資料在記憶體中放不下，則溢寫到磁碟上．需要時則會從磁碟上讀                                                               |                                                                                                |
| MEMORY_ONLY_SER                                                                                                             |                                                                                                |
| (Java and Scala)                                                                                                            | -將 RDD 以序列化的 Java 物件(每個分割槽一個位元組陣列)的方式儲存。                                 |
| -通常比非序列化物件(deserialized objects)更具空間效率，特別是在使用快速序列化的情況下，但是這種方式讀取資料會消耗更多的 CPU |                                                                                                |
| MEMORY_AND_DISK_SER                                                                                                         |                                                                                                |
| (Java and Scala)                                                                                                            | -與 MEMORY_ONLY_SER 類似，但如果資料在記憶體中放不下，則溢寫到磁碟上，而不是每次需要重新計算它們 |
| DISK_ONLY                                                                                                                   | -將 RDD 分割槽儲存在磁碟上                                                                       |
| MEMORY_ONLY_2, MEMORY_AND_DISK_2, etc.                                                                                      | -與上面的儲存級別相同，只不過將持久化資料存為兩份，備份每個分割槽儲存在兩個叢集節點上            |
| OFF_HEAP (experimental)                                                                                                     | -與 MEMORY_ONLY_SER 類似，但將資料儲存在堆外記憶體中。(即不是直接儲存在 JVM 記憶體中)              |

使用注意：

- RDD 持久化/快取的目的是為了提高後續操作的速度
- 快取的級別有很多，預設只存在記憶體中，開發中使用 memory_and_disk
- 只有執行 Action 操作的時候才會真正將 RDD 資料進行持久化/快取
- 實際開發中如果某一個 RDD 後續會被頻繁的使用，可以將該 RDD 進行持久化/快取

### RDD 容錯機制

持久化可以把資料放在記憶體中，雖然是快速的，但並不能完全保證資料可靠；也可以把資料放在磁碟上，也不能保證資料的完全可靠性，如磁碟使用中途損壞等。所以持久化存在一定的侷限性，為了解決這一問題，就需要利用 RDD 中的 **checkpoint 檢查點**。
![image.png](F:\01mynotes\0317-大資料分散式計算系統 Spark\大資料分散式計算系統Spark核心之RDD.assets\1647344646657-aaa54f40-969f-4241-b963-ce61b078f512.png)
checkpoint 的產生就是為了更加可靠的資料持久化，在 checkpoint 的時候一般把資料放在在 HDFS 上，這就天然的藉助了 HDFS 天生的高容錯、高可靠來實現資料最大程度上的安全，實現了 RDD 的容錯和高可用。
將此 RDD 標記為 checkpoint 檢查點，它將被儲存到使用 `SparkContext#setCheckpointDir` 設定的檢查點目錄內的檔案中，並且將刪除對其父 RDD 的所有引用。必須在此 RDD 上執行任何作業之前呼叫此函式。

使用注意：

- 開發中為了保證資料的安全性性及讀取效率，可以對頻繁使用且重要的資料，先做快取/持久化，再做 checkpint 操作。
- 強烈建議將此 RDD 持久化在記憶體中，否則將其儲存在檔案中將需要重新計算。
- 持久化和 checkpoint 的區別：
  - 儲存位置: Persist 或 Cache 方法只能儲存在本地的磁碟和記憶體中(或者堆外記憶體--實驗中) ，而 checkpoint 可以儲存資料到 HDFS 相關的分散式儲存系統上。
  - 生命週期: Cache 和 Persist 的 RDD 會在程式結束後會被清除或者手動呼叫 unpersist 方法，而 checkpoint 的 RDD 在程式結束後依然存在，不會被刪除。

## RDD 依賴與DAG

### RDD 依賴分類

RDD 和 其子 RDD 之間的依賴關係分為兩類：**寬依賴**(wide dependency/shuffle dependency) 、**窄依賴**(narrow dependency) 。

![1647391499607-c6caa584-fb25-4bf3-bb10-af8f22ecae0e.png](https://developer.hs.net/storage/attachments/2022/03/17/6RcrgGbDoESdbosHMq66qR4QBV4Lu9rH3iz1431Y_thumb.png "5433")
窄依賴：父 RDD 的一個分割槽只會被子 RDD 的一個分割槽依賴；
寬依賴：父 RDD 的一個分割槽會被子 RDD 的多個分割槽依賴（涉及到 shuffle)。

### RDD 依賴意義

1. 對於窄依賴：

- 窄依賴的多個分割槽可以平行計算。
- 窄依賴的一個分割槽的資料如果丟失只需要重新計算對應的分割槽的資料就可以了。

2. 對於寬依賴：

- 劃分 Stage(階段)的依據:對於寬依賴,必須等到上一階段計算完成才能計算下 一階段。

### RDD DAG

**DAG** (Directed Acyclic Graph 有向無環圖)指的是資料轉換執行的過程，有方向，無閉環(其實就是 RDD 執行的流程)。
RDD 從一開始的建立透過一系列的轉換操作就形成了 DAG 有向無環圖，任務執行時，可以按照 DAG 的描述，執行真正的計算(資料被操作的一個過程)。
DAG的邊界：

- 開始：透過 SparkContext 建立的 RDD；
- 結束：觸發 Action，一旦觸發 Action 就形成了一個完整的 DAG。

### DAG 劃分 Stage

一個 Spark 程式可以有多個 DAG(有幾個 Action，就有幾個 DAG，圖中最後只有一個 Action，那麼就是一個 DAG)。
一個 DAG 可以有多個 Stage(根據寬依賴/shuffle 進行劃分)。
![1647395414584-24d13540-8ed1-4b8c-9d27-0dbe79d358cb.png](https://developer.hs.net/storage/attachments/2022/03/17/NMezBha53GM2wjwG83ED6x5OnfYOAck4Cb1iB5pj_thumb.png "5434")
**同一個 Stage 可以有多個 Task 並行執行**(task 數=分割槽數，如上圖，Stage1 中有三個分割槽 P1、P2、P3，對應的也有三個 Task)。
可以看到這個 DAG 中只 reduceByKey 操作是一個寬依賴，Spark 核心會以此為邊界將其前後劃分成不同的 Stage。
同時可以注意到，在圖中 Stage1 中，從 textFile 到 flatMap 到 map 都是窄依賴，這幾步操作可以形成一個流水線操作，透過 flatMap 操作生成的 partition 可以不用等待整個 RDD 計算結束，而是繼續進行 map 操作，這樣大大 提高了計算的效率。

**劃分的意義：**
一個複雜的業務邏輯如果有 shuffle，那麼就意味著前面階段產生結果後，才能執行下一個階段，即下一個階段的計算要依賴上一個階段的資料。那麼按照 shuffle 進行劃分(也就是按照寬依賴就行劃分)，就可以將一個 DAG 劃分成多個 Stage/階段，在同一個 Stage 中，會有多個運算元操作，可以形成一個 pipeline 流水線，流水線內的多個平行的分割槽可以並行執行。

**如何劃分：**
對於窄依賴，partition 的轉換處理在 stage 中完成計算，不劃分(將窄依賴儘量放在在同一個 stage 中，可以實現流水線計算)。
對於寬依賴，由於有 shuffle 的存在，只能在父 RDD 處理完成後，才能開始接下來的計算，也就是說需要要劃分 stage。

> Spark 會根據 shuffle（寬依賴）使用回溯演算法來對 DAG 進行 Stage 劃分，從後往前，遇到寬依賴就斷開，遇到窄依賴就把當前的 RDD 加入到當前的 stage 階段中。

## 資料混洗

部分 Spark 運算元會觸發眾所周知的**混洗（Shuffle）**事件。Spark中的混洗機制是用於將資料重新分佈，其結果是所有資料將在各個分割槽間重新分組。一般情況下，混洗需要跨執行器（executor）或跨機器複製資料，這也是混洗操作一般都比較複雜而且開銷大的原因。

### 基本說明

為了理解混洗階段都發生了哪些事，首先以 [reduceByKey](http://spark.apache.org/docs/latest/programming-guide.html#ReduceByLink) 運算元為例來看一下。reduceByKey運算元會生成一個新的RDD，將源RDD中一個key對應的多個value組合進一個tuple - 然後將這些values輸入給reduce函式，得到的result再和key關聯放入新的RDD中。這個運算元的難點在於對於某一個key來說，並非其對應的所有values都在同一個分割槽（partition）中，甚至有可能都不在同一臺機器上，但是這些values又必須放到一起計算reduce結果。
在Spark中，通常是由於為了進行某種計算操作，而將資料分佈到所需要的各個分割槽當中。而在計算階段，單個任務（task）只會操作單個分割槽中的資料 – 因此，為了組織好每個reduceByKey中reduce任務執行時所需的資料，Spark需要執行一個多對多操作。即，Spark需要讀取RDD的所有分割槽，並找到所有key對應的所有values，然後跨分割槽傳輸這些values，並將每個key對應的所有values放到同一分割槽，以便後續計算各個key對應values的reduce結果 – 這個過程就叫做**混洗（Shuffle）。**
雖然混洗好後，各個分割槽中的元素和分割槽自身的順序都是確定的，但是分割槽中元素的順序並非確定的。如果需要混洗後分割槽內的元素有序，可以參考使用以下混洗操作：

- mapPartitions 使用 .sorted 對每個分割槽排序
- repartitionAndSortWithinPartitions 重分割槽的同時，對分割槽進行排序，比自行組合repartition和sort更高效
- sortBy 建立一個全域性有序的RDD

會導致混洗的運算元有：**重分割槽（repartition）**類運算元，如： [repartition](http://spark.apache.org/docs/latest/programming-guide.html#RepartitionLink) 和 [coalesce](http://spark.apache.org/docs/latest/programming-guide.html#CoalesceLink)；**ByKey** 類運算元(除了計數類的，如 countByKey) 如：[groupByKey](http://spark.apache.org/docs/latest/programming-guide.html#GroupByLink) 和 [reduceByKey](http://spark.apache.org/docs/latest/programming-guide.html#ReduceByLink)；以及Join類運算元，如：[cogroup](http://spark.apache.org/docs/latest/programming-guide.html#CogroupLink) 和 [join](http://spark.apache.org/docs/latest/programming-guide.html#JoinLink).

### 效能影響

混洗（Shuffle）之所以開銷大，是因為混洗操作需要引入磁碟I/O，資料序列化以及網路I/O等操作。為了組織好混洗資料，Spark需要生成對應的任務集 – 一系列map任務用於組織資料，再用一系列reduce任務來聚合資料。注意這裡的map、reduce是來自MapReduce的術語，和Spark的map、reduce運算元並沒有直接關係。
在Spark內部，單個map任務的輸出會盡量儲存在記憶體中，直至放不下為止。然後，這些輸出會基於目標分割槽重新排序，並寫到一個檔案裡。在reduce端，reduce任務只讀取與之相關的並已經排序好的blocks。
某些混洗運算元會導致非常明顯的記憶體開銷增長，因為這些運算元需要在資料傳輸前後，在記憶體中維護組織資料記錄的各種資料結構。特別地，reduceByKey和aggregateByKey都會在map端建立這些資料結構，而ByKey系列運算元都會在reduce端建立這些資料結構。如果資料在記憶體中存不下，Spark會把資料吐到磁碟上，當然這回導致額外的磁碟I/O以及垃圾回收的開銷。
混洗還會再磁碟上生成很多臨時檔案。以Spark-1.3來說，這些臨時檔案會一直保留到其對應的RDD被垃圾回收才刪除。之所以這樣做，是因為如果血統資訊需要重新計算的時候，這些混洗檔案可以不必重新生成。如果程式持續引用這些RDD或者垃圾回收啟動頻率較低，那麼這些垃圾回收可能需要等較長的一段時間。這就意味著，長時間執行的Spark作業可能會消耗大量的磁碟。Spark的臨時儲存目錄，是由spark.local.dir 配置引數指定的。
混洗行為可以由一系列配置引數來調優。參考Spark配置指南（[Spark Configuration Guide](http://spark.apache.org/docs/latest/configuration.html)）中“混洗行為”這一小節。

## 共享變數

預設情況下，當 Spark 在叢集的多個不同節點的多個任務上並行執行一個函式時，它會把函式中涉及到的每個變數，在每個任務上都生成一個副本。但有時需要在多個任務之間共享變數，或者在任務（Task）和任務控制節點（Driver Program）之間共享變數。
為了滿足這種需求，Spark 提供了兩種型別的變數：

1. **累加器**（Accumulators）：累加器支援在所有不同節點之間進行累加計算（比如：計數、求和）。
2. **廣播變數**（Broadcast Variables）：廣播變數用來把變數在所有節點的記憶體之間進行共享，在每個機器上快取一個只讀的變數，而不是為機器上的每個任務都生成一個副本。

### Accumulators

累加器（Accumulators）是僅透過關聯和交換操作“新增”到的變數，因此可以有效地並行支援。它們可用於實現計數器（如在 MapReduce 中）或求和。 Spark 原生支援數值型別的累加器，程式設計師可以新增對新型別的支援。 作為使用者，您可以建立命名或未命名的累加器。如下圖所示，一個命名的累加器（在此例項中為計數器）將顯示在修改該累加器的階段的 Web UI 中。 Spark 在“Tasks”表中顯示由任務修改的每個累加器的值。

```scala
scala> val accum = sc.longAccumulator("My Accumulator")
accum: org.apache.spark.util.LongAccumulator = LongAccumulator(id: 0, name: Some(My Accumulator), value: 0)

scala> sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum.add(x))
...
10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s

scala> accum.value
res2: Long = 10
```

累加器使用例項：

```scala
  /**
   * 累加器 操作例項
   *
   * 假設需要統計資料的運算元量
   *
   */
  def AccumulatorDemo(sc: SparkContext): Unit = {
    val dealRdd = sc.parallelize(Array(1, 2, 3, 4, 5, 6))
    // 1.不使用累加器
    // 直接使用普通變數進行計數，最後計算結果為0
    // 因為 foreach 中的函式是傳遞給 Worker 中的 Executor 執行
    // 而 counter 變數在 Driver 端定義的，會以副本形式傳遞給 Executor
    // 最後各個 Executor 中的 counter 累加，但 Driver 端的 counter 並不會被操作
    var counter = 0;
    dealRdd.foreach(f => counter += 1)
    println("counter = " + counter) // counter = 0

// 2.使用累加器
    // 透過累計器能夠解決普通變數無法正常計數的問題
    // 從 Spark2.0 開始 Accumulator 類已經過時，計數可以使用 LongAccumulator 工具類
    var accu: LongAccumulator = sc.longAccumulator("count name")
    dealRdd.foreach(f => accu.add(1))
    println("accumulator = " + accu.value) // accumulator = 6
  }
```

### Broadcast Variables

廣播變數（Broadcast Variables）是指在每臺機器上快取一個**只讀變數**，而不隨任務一起傳送它的副本。例如，它們可用於以有效的方式為每個節點提供大型輸入資料集的副本。 Spark 還嘗試使用高效的廣播演算法來分發廣播變數，以降低通訊成本。
Spark 動作透過一組階段執行，由分散式“shuffle”操作分隔。 Spark 自動廣播每個階段內任務所需的公共資料。以這種方式廣播的資料以序列化形式快取，並在執行每個任務之前進行反序列化。這意味著顯式建立廣播變數僅在跨多個階段的任務需要相同資料或以反序列化形式快取資料很重要時才有用。
透過呼叫 SparkContext.broadcast(v) 從變數 v 建立廣播變數。廣播變數是 v 的一個包裝器，它的值可以被訪問 透過呼叫 value 方法。

```scala
scala> val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar: org.apache.spark.broadcast.Broadcast[Array[Int]] = Broadcast(0)

scala> broadcastVar.value
res0: Array[Int] = Array(1, 2, 3)
```

廣播變數使用例項：

```scala
 /**
   * 廣播變數 操作例項
   *
   * 假設需要將部門id的集合：List(2, 1, 3, 2, 0)
   * 需要透過字典索引的方式翻譯成對應部門的名字,字典項如下：
   * List((0, "研發部門"), (1, "財務部門"), (2, "營銷部門"), (3, "人力部門"))
   *
   */
  def BroadCastDemo(sc: SparkContext): Unit = {
    val depListRdd = sc.parallelize(List(2, 1, 3, 2, 0))
    val depDictMap: collection.Map[Int, String] = Map((0, "研發部門"), (1, "財務部門"), (2, "營銷部門"), (3, "人力部門"))
    // 1.不使用廣播變數
    // 不使用廣播變數雖然也能實現對於部門集合id的對映
    // 但是使用的 depDictMap 變數會在 task 之間以副本形式傳遞，如果計算量較大對效能影響也會增加
    var depNameRdd = depListRdd.map(v => (v, depDictMap(v)))
    depNameRdd.foreach(println) // (1,財務部門) (3,人力部門) (2,營銷部門) (0,研發部門) (2,營銷部門)

// 2.使用廣播變數
    // 透過使用廣播變數，各個 task 中都是複用同一個 broadcast 變數，減少了 task 之間的傳輸
    val broadcast : Broadcast[collection.Map[Int, String]]  = sc.broadcast(depDictMap)
    depNameRdd = depListRdd.map(v => (v, broadcast.value(v)))
    depNameRdd.foreach(println) // (1,財務部門) (3,人力部門) (2,營銷部門) (0,研發部門) (2,營銷部門)
  }
```

# 總結

本文對於大資料計算系統 Spark 的入門知識和核心技術 RDD 進行了深入的剖析，希望能對學習本文的同學有所收穫。</w></v></v></u></t>

大資料分散式計算系統 Spark 入門核心之 RDD

相關文章