彈性分布式數據集（RDDs）

Spark圍繞著彈性分布式數據集（RDD）這個概念，RDD是具有容錯機制的元素集合，可以并行操作。有兩種方式創建RDDs：并行化驅動程序中已存在的集合，或者引用外部存儲系統中的數據集，例如一個共享文件系統，HDFS，HBase，或者任何支持Hadoop輸入格式的數據源。

并行集合

在驅動程序中已存在的集合上調用SparkContext的parallelize方法可創建并行集合。通過拷貝已存在集合中的元素來生成可并行操作的分布式數據集。下面是創建并行集合的例子：

val data = Array(1, 2, 3, 4, 5)
val distData = sc.parallelize(data)

一旦創建完成，分布式數據集(distData)就可以被并行操作。例如，調用distData.reduce((a, b) => a + b)可以累加數組的元素。稍后介紹分布式數據集上的操作。

并行集合的一個重要參數是分區（partitions）的數量，用于切分數據集。Spark會為集群上的每個分區運行一個任務。通常你會想要為集群上的每個CPU分配2-4個分區。一般情況下，Spark會嘗試根據集群自動設置分區的數量。當然，你可能想手動設置，通過傳遞parallelize方法的第二個參數（如sc.parallelize(data, 10)）可以實現。注意：有些代碼為了向下兼容使用了術語slices（和partitions一個意思）。

外部數據集

Spark可以通過任何Hadoop支持的存儲源創建分布式數據集，包括你本地的文件系統，HDFS， Cassandra，HBase，Amazon S3等等。Spark支持文本文件，SequenceFiles和任意其它Hadoop輸入格式。

文本文件RDDs可使用SparkContext的textFile方法創建。這個方法需要文件的URI（一個本地機器上的路徑，或者一個hdfs://, s3n://等），文件內容讀取后是所有行的集合。下面是一個示例：

scala> val distFile = sc.textFile("data.txt")
distFile: org.apache.spark.rdd.RDD[String] = data.txt MapPartitionsRDD[10] at textFile at <console>:26

一旦創建完成，distFile就可以進行數據集操作。例如，可使用map和reduce操作累積所有行的大小，代碼是distFile.map(s => s.length).reduce((a, b) => a + b)。

用Spark讀取文件時需要注意的是：

• 如果使用本地文件系統的路徑，文件必須在worker節點上可以訪問。可以拷貝本地文件到所有woker節點，也可以使用網絡共享文件系統。
• Spark中所有基于文件的輸入方法，包括textFile，都支持在目錄，壓縮文件和通配符。例如，可以使用textFile("/my/directory")，textFile("/my/directory/*.txt")和textFile("/my/directory/*.gz")。
• textFile方法還包含一個可選參數，用于控制文件的分區數量。默認情況下，Spark會為文件的每個block創建一個分區（HDFS默認的block大小是128MB），不過你可以通過可選參數設置更大的分區值。需要注意的是不能比blocks的數量還少。

除了文本文件，Spark的Scala API還支持多種數據格式：

• SparkContext.wholeTextFiles可以讀取包含多個小文本文件的目錄，并且把每個文件作為(filename, content)返回。相比之下，textFile會把每個文件的每一行作為一條記錄返回。
• 對于SequenceFiles，使用SparkContext的sequenceFile[K, V]方法，K和V是文件中的鍵值類型。K和V應該是Hadoop的Writable接口的子類，如IntWritable和Text。此外，Spark允許為一些常見的Writables指定原生類型；例如，sequenceFile[Int, String]會自動讀取IntWritables和Texts。
• 對于其它Hadoop輸入格式，可以使用SparkContext.hadoopRDD方法，以任意JobConf和輸入格式類，key類和value類作為參數。和使用輸入源設置Hadoop作業一樣設置上述參數。對于基于新MapReduce API(org.apache.hadoop.mapreduce)的輸入格式，可以使用SparkContext.newAPIHadoopRDD。
• RDD.saveAsObjectFile和SparkContext.objectFile支持將RDD保存到由序列化的Java對象組成的簡單格式。雖然這不如專業格式Avro效率高，卻提供了一種保存RDD的簡單方式。

RDD操作

RDD支持兩種操作：transformations（從一個已存在的數據集創建新的數據集）和actions（在數據集上進行計算并將結果返回給驅動程序）。例如，map是一個transformation，用于將數據集中的每個元素傳遞給一個函數并且返回一個新的RDD作為結果。reduce是一個action，它會用某個函數將RDD的所有元素聚合然后將最終結果返回給驅動程序（有一個reduceByKey返回分布式數據集）。

Spark的所有transformation都是lazy的，不會立刻計算結果。相反，只是記錄應用到基礎數據集（如文件）的transformation。只有action要返回結果到驅動程序時才會計算transformation。這樣設計是為了Spark更高效。例如，map創建的數據集會在reduce中使用，之后會返回reduce的結果給驅動程序，而map創建的那個更大的數據集。

默認情況下，轉換得到的RDD，每次要對其執行action的時候重新計算。可以使用persist（或cache）方法將RDD保存到內存中，Spark會將RDD的元素存儲到集群中，下次查詢的時候會更快。Spark也支持將RDD存儲到磁盤上，或者跨多個節點復制。

基礎

RDD的基本操作，如下：

val lines = sc.textFile("data.txt")
val lineLengths = lines.map(s => s.length)
val totalLength = lineLengths.reduce((a, b) => a + b)

第一行從外部文件定義了一個基本RDD。這個數據集沒有加載到內存，也沒有做其它操作，lines僅僅是指向文件的指針。第二行定義了lineLengths作為map transformation的結果。lineLengths不是立即計算的，因為是懶加載的。最后，執行reduce action。這時候Spark會將計算分解成多個任務運行在獨立的機器上，每個機器會執行一部分map和局部的reduce，然后返回結果到驅動程序。

如果之后還想用lineLengths，在reduce之前執行以下語句：

lineLengths.persist()

這樣可以在第一次計算時將lineLengths保存到內存中。

函數傳遞到Spark

Spark的API很依賴給驅動程序傳遞函數來在集群上運行。有兩種推薦方式：

• 匿名函數，用于短代碼。
• 在全局單例對象中的靜態方法。例如，定義了object MyFunctions，然后傳遞MyFunctions.func1，如下：

object MyFunctions {
  def func1(s: String): String = { ... }
}

myRdd.map(MyFunctions.func1)

也可以在類的實例中（相對于單例對象）傳遞方法的引用，這需要傳遞包含方法的對象。例如：

class MyClass {
  def func1(s: String): String = { ... }
  def doStuff(rdd: RDD[String]): RDD[String] = { rdd.map(func1) }
}

如果創建了MyClass的實例并且調用doStuff，其中的map會引用實例的func1方法，所以整個對象都需要發送到集群。類似于rdd.map(x => this.func1(x))這種寫法。

類似地，訪問外部對象的字段也會引用整個對象：

class MyClass {
  val field = "Hello"
  def doStuff(rdd: RDD[String]): RDD[String] = { rdd.map(x => field + x) }
}

和rdd.map(x => this.field + x)寫法等價。為了避免這個問題，最簡單的方法是拷貝field到本地變量，不進行外部訪問：

def doStuff(rdd: RDD[String]): RDD[String] = {
  val field_ = this.field
  rdd.map(x => field_ + x)
}

理解閉包

在集群上執行代碼時，理解變量和方法的作用范圍和生命周期是Spark的一個難點。RDD操作在作用范圍之外修改變量是經常出現的問題。下面是一個foreach()增加計數的例子，相同的問題也會出現在其它操作當中。

示例

看下面RDD元素求和的示例，代碼的行為會根據是否在同一個JVM上執行而有所不同。常見的例子是在local模式（--master = local[n]）下運行與部署在集群（spark-submit提交給YARN）上運行進行對比。

var counter = 0
var rdd = sc.parallelize(data)

// Wrong: Don't do this!!
rdd.foreach(x => counter += x)

println("Counter value: " + counter)

本地模式 vs. 集群模式

上面代碼的行為是未定義的，可能無法按照預期工作。為執行作業，Spark會把RDD操作分拆成任務，每個任務由一個executor執行。執行之前，Spark會計算任務的閉包。閉包就是變量和方法（上面例子里是foreach()），它們對于在RDD上執行計算的executor是可以見的。這個閉包會被序列化并發送到每個executor。

發送到每個executor的閉包變量是一個拷貝，在foreach函數中引用counter時，已經不是驅動節點上的counter了。驅動節點的內存中仍然有counter，但是對于所有executor已經不可見了！所有executor只能看到序列化閉包中的拷貝。counter最后的值還是0，因為所有的操作都在序列化閉包內的counter上執行。

本地模式中，在某些情況下，foreach函數會和驅動程序在同一個JVM上執行，這樣可以引用到原始的counter`并更新這個變量。

要保證有明確定義的行為，需要使用Accumulator
。當對變量的操作跨集群中的多個工作節點時，Accumulator提供一種安全更新變量的機制。后面介紹Accumulator時會詳細說明。

通常來說，閉包—構建像循環或局部定義的方法，不應該用于改變全局狀態。對于改變閉包外對象的行為，Spark沒有定義也不提供保證。有些代碼用本地模式執行，但那不是最常用的，這樣的代碼在分布式模式中不會按照預期執行。如果需要全局聚合，使用Accumulator。

打印RDD的元素

另外一個問題是用rdd.foreach(println)或rdd.map(println)打印RDD的元素。在一臺機器上，可以保證正常打印所有RDD的元素。但是在集群模式中，executor使用的是自己的stdout，不是驅動節點上的，所以在驅動節點的stdout是看不到打印結果的！要在驅動節點上打印所有元素，可以使用collect()方法將所有元素放到驅動節點：rdd.collect().foreach(println)。這樣做可能會導致驅動節點內存耗盡，因為collect()方法將整個RDD都放到一臺機器上了；如果只想打印部分元素，使用take()是一種安全的方式：rdd.take(100).foreach(println)。

操作鍵值對

RDD的大部分操作都可以處理任意對象類型，不過有幾個特殊操作只能操作鍵值對類型的RDD。最常用的就是分布式"shuffle"操作，如針對key進行分組或聚合元素。

在Scala中，這些操作對于包含Tuple2對象（語言內置的元組，可用(a, b)創建）的RDD自動可用。鍵值對操作在PairRDDFunctions類中可用，能夠自動處理包含元組的RDD。

例如，下面代碼在鍵值對上使用reduceByKey操作，計算每一行在文件中出現的次數：

val lines = sc.textFile("data.txt")
val pairs = lines.map(s => (s, 1))
val counts = pairs.reduceByKey((a, b) => a + b)

也可使用counts.sortByKey()，按字母序排序，使用counts.collect()將結果當做對象數據放到驅動程序中。

注意：當在鍵值對操作中使用自定義對象作為key時，必須保證有自定義的equals()方法以及與之匹配的hashCode()方法。更多細節，請參見Object.hashCode() documentation。

Transformations

下面列出了常用的transformations。更多細節，請參見RDD API doc（Scala）和pair RDD functions doc（Scala）。

Actions

下面的表列出了常用的actions。更多細節，請參見RDD API doc（Scala）和pair RDD functions doc（Scala）。

Spark RDD API也暴露了一些action的異步版本，如foreachAsync，立刻返回FutureAction給調用者，不會阻塞在action的計算上。這類方法用于管理或等待action的異步執行。通常需要在executor和機器之間拷貝數據，shuffle是一個復雜耗時的操作。

Shuffle操作

Spark中的一些操作會觸發被稱為shuffle的事件。shuffle是Spark重新分配數據的機制，讓數據在分區間有不同的分組。

背景

想要理解shuffle的細節，可參見reduceByKey操作。reduceByKey操作生成了一個新RDD，單個key的所有值都放到了元組（包含了key和這個key相關的所有值執行reduce函數后的結果）中。面臨的問題是，單個key的所有值不是一定放在同一個分區或者同一臺機器中，但是這些值需要一起計算結果。

在Spark中，數據通常不會為特定操作跨分區分布在需要的位置上。在計算時。單個任務在單個分區上執行—這樣，為了組織單個reduceByKey的reduce任務需要的所有數據，Spark需要執行一個all-to-all操作。需要從所有分區上找出所有key的所有值，然后將每個key的值跨分區集合起來結算處最后的結果—這就是shuffle。

雖然shuffle之后每個分區的元素集合是確定的，分區的順序也是確定，但是元素是無序的。如果想要在shuffle之后得到有序數據，可使用：

• mapPartitions，使用.sorted給每個分區排序
• repartitionAndSortWithinPartitions，在重新分區的同時高效地排序
• sortBy，生成全局排序的RDD
  會進行shuffle的操作包括repartition操作，如repartition和coalesce，'ByKey操作（除了計數），如groupByKey和reduceByKey，join操作，如cogroup和join。

性能影響

Shuffle是非常耗時的操作，因為需要磁盤I/O，數據序列化，以及網絡I/O。為了shuffle組織數據，Spark生成了任務集合，map任務集合負責祖師數據，reduce任務集合負責聚合數據。這個命名方式來自MapReduce，和Spark的map和reduce操作沒有直接關系。

單個map任務的結果一直放在內存中直到放不下為止。然后，這些結果會根據目標分區進行排序并寫到單個文件中。reduce任務會讀取相關的已排序的塊。

一些shuffle操作會消耗大量堆內存，因為它們在轉換前后使用內存數據結構來組織記錄。特別地，reduceByKey和aggregateByKey在map時創建這些數據結構，'ByKey操作在reduce時生成這些結構。當數據不適合放在內存中時，Spark會將這些表拆分到磁盤中，這樣會導致額外的磁盤I/O開銷以及增加GC。

shuffle也會在磁盤上生成大量中間文件。Spark 1.3，這些文件會保留到對應的RDD不再使用并且已經被回收。這樣做的話，在重新計算時shuffle文件不需要重新創建。如果應用程序一直保留這些RDD的引用或者GC不頻繁，那么shuffle文件可能會很長時間之后才會回收。這就意味著長時間運行的Spark作業可能會消耗大量磁盤空間。在配置Spark Context時，spark.local.dir配置參數用于指定臨時存儲目錄。

shuffle的行為可通過很多配置參數進行調整。具體參見Spark Configuration Guide中的‘Shuffle Behavior’。

RDD持久化

Spark最重要的功能之一就是在內存中跨操作持久化（或緩存）數據集。當持久化RDD時，每個節點會將其要計算的分區存儲到內存中，并且在數據集上進行其它action操作時重用內存中的數據。這樣之后的action操作可以執行得更快（通常超過10x）。緩存是迭代算法和快速交互的重要工具。

可使用persist()或cache()方法將RDD標記為持久化。第一在action中進行計算時，持久化的RDD會保存到節點內存中。Spark的緩存是具有容錯機制的—如果RDD的任意分區丟失了，會使用最初創建它的transformations自動重新計算。

另外，每個持久化的RDD可使用不同的存儲級別進行存儲，例如，持久化數據集到磁盤，作為序列化的Java對象持久化到內存，跨節點復制。這些等級通過給persist()傳遞StorageLevel對象（Scala）進行設置。cache()方法使用默認存儲等級，即torageLevel.MEMORY_ONLY（在內存中存儲反序列化對象）。存儲等級如下：

注意：在Python中，使用Pickle庫保存的對象永遠都是序列化的，所以是否選擇序列化等級都沒關系。Python可用的存儲等級包括MEMORY_ONLY，MEMORY_ONLY_2，MEMORY_AND_DISK，MEMORY_AND_DISK_2，DISK_ONLY和DISK_ONLY_2。

Spark會自動持久化shuffle操作的中間數據（如reduceByKey），甚至不需要用戶調用persist。這樣做是為了防止shuffle期間如果有節點出錯了需要重新計算整個輸入。如果想要重用RDD，建議用戶手動調用persist。

如何選擇存儲等級

Spark的存儲等級提供了在內存使用和CPU效率之間的不同權衡方案。推薦按照下面方法選擇存儲等級：

• 如果RDD內存適合使用默認存儲等級（MEMORY_ONLY），那就選擇默認存儲等級。這種方式是CPU效率最高的，能夠讓RDD上的操作盡可能快遞執行。
• 如果不適合，使用MEMORY_ONLY_SER并且選擇一個快的序列化庫讓對象存儲更節省空間，但是仍然可以合理地快速訪問。
• 除非計算數據集非常耗時，或者它們過濾掉了大量數據，否則不要將數據集放到磁盤。不然的話，重新計算分區可能和從磁盤讀取是一樣快的。
• 如果想要快速進行錯誤恢復，使用復制存儲等級（例如，如果使用Spark服務web應用請求）。所有存儲等級通過重新計算丟失數據提供全容錯機制，但是復制存儲等級可以讓任務繼續在RDD上執行，不需要等著丟失分區重新計算完成。

刪除數據

Spark會自動監控每個節點上的緩存使用情況，使用LRU將老數據分區清理掉。如果想要手動刪除RDD，使用RDD.unpersist()方法。