sparkRDD

RDD

RDD弹性分布式数据集，spark最基本的数据抽象，代表一个不可变，可分区，里面元素可并行计算的集合。
具有数据流模型的特点：自动容错，位置感知性调度和可伸缩性。
RDD允许用户在执行多个查询时，显示地将工作集缓存在内存中，后续的查询能重用工作集，这极大提高查询速度
特点：一系列的分区，每一个函数作用于每个分区，RDD之间是一系列依赖，如果是k-v类型的RDD，会有一个分区器，分区器就是决定把数据放到哪个分区

一般Worker需要和DataNode节点部署在一起，这样可以有效的避免大量网络IO
一个分区一定在一个节点上，一个节点可以有多个分区
RDD由多个分区组成的分布式数据集
一个block块对应一个分区

启动spark-shell

./spark-shell 
--master spark://hadoop01:7077  master地址
--executor-memory 512m    内存
--total-executor-cores 2    cpu核数

提交任务

./spark-submit
.
--class org.apache... 类名
--master spark://hadoop01:7077  master地址
--executor-memory 512m    内存
--total-executor-cores 2    cpu核数
jar包路径
args 其它参数（需要传才写）

spark集群的启动流程

1、首先启动master进程
2、master开始解析slaves配置文件，找到worker的host，然后启动相应的worker
3、worker开始与master进行注册，把注册信息发送给master
4、master收到注册信息后，把注册信息保存到内存与硬盘中，然后master给worker发送注册成功的信息（masterurl）
5、worker收到master的url信息，开始与master建立心跳

spark集群提交流程

1、driver 端 的sparksubmit 进程与master进行通信，创建一个重要的对象（sparkcontext）
2、master收到任务信息后，开始资源调度，和所有的worker进行通信，找到比较空闲的worker，并通知worker启动excutor进程
3、executor进程启动后，开始与driver（client） 进行通信（反向注册），driver开始将任务提交到相应的executor，executor开始计算任务

RDD和它依赖的父RDD的依赖关系，窄依赖narrow dependency，宽依赖wide dependency

主要说的是partition  分区
窄依赖：一父分区只能对应一子分区        分组后join
宽依赖：一父分区可以对应多子分区，宽依赖与shuffle密不可分  没分组join

Lineage

RDD转换为RDD（只支持粗粒度转换），将创建RDD的一系列Lineage(即血统)记录下来，以便恢复分区
Lineage会记录元数据信息和转换行为，当RDD部分分区数据丢失时，通过Lineage保存的信息来重新运算和恢复丢失的数据分区

一系列一对一关系（窄依赖），会形成一个Pipeline。可以通过父分区来再运行计算丢失分区的数据，其它的Pipeline不受影响 

Lineage在开发中不如cache 然后checkpoint（缓存放到hdfs）

丢失分区数据后找回数据顺序：cache（内存中找），checkpoint（hdfs中恢复），Lineage（从父分区再运行计算）

它与集群容错机制有点像。
集群容错机制：当一个节点（Worker）突然宕机，Master（重新调度任务）会将宕机的节点Worker未完成的数据交给其它节点。其它节点再在自己上面启动一个Worker，然后Worker启动Executor运行

RDD 缓存 checkpoint

cache：重要RDD的缓存起来，里面调用的是persist，默认是内存缓存（可以选择缓存级别）
checkpoint：持久化到本地或者hdfs
Spark速度快的原因：在不同操作中可以在内存中持久化或者缓存多个数据集（RDD），当持久化后，每个分区都把计算的数据分片保存在内存中，在此RDD或者之后的计算中可以重用，使后续动作更加迅速。缓存是spark构建迭代式算法和快速交互式查询的关键。

为什么要checkpoint？
运行处的中间结果，往往很重要，所以为了保证数据的安全性，要把数据做检查点
最好把checkpoint 到RDFS,便于该集群所有节点访问到
在checkpoint之前，最好先cache一下，就是先把数据缓存到内存，这样便于运行程序时调用，也便于checkpoint时直接重缓存中获取数据

什么时候做checkpoint？
在发生shuffle之后做checkpoint，（shuffle速度慢，项目中shuffle越少越好）
checkpoint的步骤？
1、创建checkpoint储存目录  sc.checkpointDir("hdfs://...")
2、把数据cache起来  rdd.cache()
3、checkpoint   rdd.checkpoint()
### 注意：当数据很大时，慎用cache，也不要不用，（关键地方，数据集不是非常大就用）

rdd.unpersist() 清除cache（cache的rdd调用unpersist()）

DAG 有向无环图 stage

stage划分：找到最后的RDD，向前找，以宽依赖划分（宽依赖前的）为一个stage，整体划为一个stage，直到所有RDD划分完。（每个宽依赖划）
Stage:根据RDD之间的依赖关系的不同将DAG划分为不同的Stage，对于窄依赖，partition的转换处理在stage中完成计算，对于宽依赖，由于有shuffle的存在，只能在parentRDD中处理完成后才开始接下来的计算，因此宽依赖是划分stage的依据。
划分stage是为了把RDD来生成一个个task提交到Executor中执行，所以需要把RDD 先划分stage再生成task。

一个Stage 生成n个分区个task

task的生成是依据stage，在stage中先划分pipeline（与分区个数相同），然后根据pipeline生成task
shuffle read ：发生在shuffle后，把父RDD 的数据读取到子RDD中
shuffle write： 把中间结果数据写到磁盘，为了保证数据安全性。
shuffle write 为什么不写内存里？
1、避免结果集太大而占用太多的内存资源，造成内存溢出
2、保存到磁盘可以保证数据的安全性

任务执行流程 4个阶段

RDD的生成  ：  RDD 依赖关系，
stage的划分  ： DAG 划分stage（在sparkcontext中 调用了 DAGScheduler（划分stage的））
任务的生成  ：在sparkcontext中 调用了 TaskSetScheduler
任务的提交  ：多节点提交
在sparkcontext中  调用 actorSystem，DAGScheduler，TaskSetScheduler详情看sparkcontext源码

yarn提交任务和spark提交任务的对比

resoucemanager 相当于master，负责任务调度，nodemanage相当于worker，负责创建容器和启动自己的子进程。
client端相当于driver，提交任务
yarnchild 相当于executor，直接参与计算进程

JdbcRDD RDD与mysql的交互

//这是向mysql中数据库 bigdata下的location_info表中查询数据
object JdbcRDD {
  def main(args: Array[String]): Unit = {
    val conf =new SparkConf().setAppName("jdbcRDD").setMaster("local[*]")
    val sc =new SparkContext(conf)
    val conn=()=>{
      Class.forName("com.mysql.jdbc.Driver").newInstance()
      DriverManager.getConnection("jdbc:mysql://192.168.216.53:3306/bigdata?useUnicode=true&characterEncoding=utf8","root","root")
    }
    val sql="select id,location,counts,access_date from location_info where id >= ? and id <= ? order by counts"
    val jdbcRDD =new JdbcRDD(
      sc,conn,sql,0,100,2,
      res=>{
        val id=res.getInt("id")
        val location =res.getString("location")
        val counts=res.getInt("counts")
        val access_date=res.getDate("access_date")
        (id,location,counts,access_date)
      }
    )
    println(jdbcRDD.collect().toBuffer)
    sc.stop()
  }
}

自定义排序 比较两个或多个字段时

第一种有隐式转换，第二种就直接继承

object Mysort {
  implicit val girlOrdering = new Ordering[Girl] {
    override def compare(x: Girl, y: Girl) = {
      if (x.faceValue != y.faceValue) {
        x.faceValue - y.faceValue
      } else {
        y.age - x.age
      }
    }
  }
}
//case class Girl(val faceValue: Int, val age: Int) {}//第一种
case class Girl(val faceValue: Int, val age: Int) extends Ordered[Girl] {
  override def compare(that: Girl) = {
    if (this.faceValue != that.faceValue) {
      this.faceValue - that.faceValue
    } else {
      this.age - that.age
    }
  }
}
object CustimSort {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("jdbcRDD").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val girlInfo = sc.parallelize(Array(("a", 80, 25), ("b", 84, 24), ("c", 85, 26)))
    //第一种排序方式
    //    import Mysort.girlOrdering
    //    val res: RDD[(String, Int, Int)] = girlInfo.sortBy(x=>Girl(x._2,x._3),false)
    //第二种
    val res: RDD[(String, Int, Int)] = girlInfo.sortBy(x => Girl(x._2, x._3), false)
    println(res.collect().toBuffer)
    sc.stop()
  }
}

累加器 Accumulator

task 只能对accumulator进行累加

spark提供的accumulator，主要用于多个节点对一个变量进行共享操作。
它提供了多个task对一个变量并行的操作功能，task只能对Accumutor进行累加的操作，不能读取其值
只有driver才能读取。
/**
  * 累加器，就是累加操作
  */
object Accumulator {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("jdbcRDD").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val sum: Accumulator[Int] = sc.accumulator(0)
    val numbers = sc.parallelize(Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 0), 2)
    numbers.foreach(num => {
      sum += num
    })
    println(sum)
    sc.stop()
  }
}