Spark入门介绍(以wordcount为例）

什么是Spark？

Spark是一个开源框架，是基于内存计算的大数据并行计算框架。

Spark架构

并行化是将工作负载分在不同线程或不同节点上执行的子任务，Spark的工作负载划分有RDD分区决定。
RDD：是弹性分布式数据集。

Spark工作原理

Master是由四大部分组成(RDD Graph,Scheduler,Block Tracker以及Shuffle Tracker）

编写程序提交到Master上，

启动RDD Graph就是DAG，它会提交给Task Scheduler任务调度器等待调度执行

具体执行时，Task Scheduler会把任务提交到Worker节点上
Block Tracker用于记录计算数据在Worker节点上的块信息

Shuffle Blocker用于记录RDD在计算过程中遇到Shuffle过程时会进行物化，Shuffle Tracker用于记录这些物化的RDD的存放信息

RDD Graph

RDD Graph即DAG：
每个RDD由四个分区组成，每个分区分配一个任务执行，
绿色框表示实施RDD操作后的数据集。

Stage

由于shuffle依赖必须等RDD的parent RDD partition数据全部ready之后才能开始计算，因此spark的设计是让parent RDD将结果写在本地，完全写完之后，通知后面的RDD。后面的RDD则首先去读之前的本地数据作为input，然后进行运算。

由于上述特性，将shuffle依赖就必须分为两个阶段(stage)去做：

第一个阶段(stage)需要把结果shuffle到本地，例如reduceByKey，首先要聚合某个key的所有记录，才能进行下一步的reduce计算，这个汇聚的过程就是shuffle

第二个阶段(stage)则读入数据进行处理。

同一个stage里面的task是可以并发执行的，下一个stage要等前一个stage ready

（和mapreduce的reduce需要等map过程ready 一脉相承）

(为什么要写在本地：后面的RDD多个partition都要去读这个信息，如果放到内存，如果出现数据丢失，后面的所有步骤全部不能进行，违背了之前所说的需要parent RDD partition数据全部ready的原则。为什么要保证parent RDD要ready，如下例，如果有一个partition未生成或者在内存中丢失，那么直接导致计算结果是完全错误的：

写到文件中更加可靠。Shuffle会生成大量临时文件，以免错误时重新计算，其使用的本地磁盘目录由spark.local.dir指定，缓存到磁盘的RDD数据。最好将这个属性设定为访问速度快的本地磁盘。可以配置多个路径到多个磁盘，增加IO带宽

在Spark 1.0 以后，SPARK_LOCAL_DIRS(Standalone, Mesos) or LOCAL_DIRS (YARN)参数会覆盖这个配置。比如Spark On YARN的时候，Spark Executor的本地路径依赖于Yarn的配置，而不取决于这个参数。)

对于transformation操作，以shuffle依赖为分隔，分为不同的Stages。

窄依赖------>tasks会归并在同一个stage中，（相同节点上的task运算可以像pipeline一样顺序执行，不同节点并行计算，互不影响）

shuffle依赖------>前后拆分为两个stage，前一个stage写完文件后下一个stage才能开始

action操作------>和其他tasks会归并在同一个stage（在没有shuffle依赖的情况下，生成默认的stage，保证至少一个stage）

宽窄依赖

RDD依赖关系，也就是有依赖的RDD之间的关系，比如RDD1------->RDD2（RDD1生成RDD2），RDD2依赖于RDD1。这里的生成也就是RDDtransformation操作

窄依赖（也叫narrow依赖）

从父RDD角度看：一个父RDD只被一个子RDD分区使用。父RDD的每个分区最多只能被一个Child RDD的一个分区使用

从子RDD角度看:依赖上级RDD的部分分区 精确知道依赖的上级RDD分区，会选择和自己在同一节点的上级RDD分区，没有网络IO开销，高效。如map，flatmap，filter

宽依赖（也叫shuffle依赖/wide依赖）

从父RDD角度看：一个父RDD被多个子RDD分区使用。父RDD的每个分区可以被多个Child RDD分区依赖

从子RDD角度看:依赖上级RDD的所有分区 无法精确定位依赖的上级RDD分区，相当于依赖所有分区（例如reduceByKey） 计算就涉及到节点间网络传输

Spark之所以将依赖分为narrow和 shuffle：

(1) narrow dependencies可以支持在同一个集群Executor上，以pipeline管道形式顺序执行多条命令，例如在执行了map后，紧接着执行filter。分区内的计算收敛，不需要依赖所有分区的数据，可以并行地在不同节点进行计算。所以它的失败恢复也更有效，因为它只需要重新计算丢失的parent partition即可，

(2)shuffle dependencies 则需要所有的父分区都是可用的，必须等RDD的parent partition数据全部ready之后才能开始计算，可能还需要调用类似MapReduce之类的操作进行跨节点传递。从失败恢复的角度看，shuffle dependencies 牵涉RDD各级的多个parent partition。

以wordcount为例

1、新建一个scala project

2、导入包（主要用以下5个包）
sparksql
sql-mapping-mr
sparkStreaming-及时处理
sparkMLlib-机器学习
sparkGraphx-图计算
3、更改scala版本，右击项目——>configure Build Path——>Edit

4、新建一个object scala

import org.apache.spark.SparkContext
import org.apache.spark.SparkConf
import org.apache.spark.SparkConf

object wordCount {

def main(args: Array[String]):Unit = {
 // System.setProperty("hadoop.home.dir", "C://Users//Administrator.DESKTOP-T63BNEF//Desktop//all folder//hadoop-2.6.5");
    //spark处理---并发迭代大数据  
    //RDD.map word->(w,1)
    //rdd.reduce->w->sum 1
     //1.sc
    var conf = new SparkConf()
    conf.setMaster("local[*]").setAppName("hello")
    var sc = new SparkContext(conf)
    sc.setLogLevel("WARN");
    //2.sc.textFile ->RDD
    var path = "src/data/123"       // "src/data/123"为需要计算的文本文件
    var filedata_rdd = sc.textFile(path,2)
    var words_rdd=filedata_rdd
    .flatMap(_.split("\\W+"))
    .map(x=>(x,1))
    .reduceByKey(_+_)
    .map(_.swap)
    .sortByKey(false)
//    words_rdd.foreach(println)
    print(filedata_rdd.count())
    words_rdd.foreach{line=>
      println("word="+line._1+" ,num="+line._2)
    }
    println("end....")
  }    
}

测试文本数据：

运行结果：