Spark-Core Spark核心部分

spark核心部分总结

spark-core

spark简介

• 分布式计算引擎（大数据计算框架），用来替代MapReduce
• 速度是MapReduce的一百倍（官方），实际检测大概十倍左右

• spark会尽量将数据放在内存中进行计算（cache）
• 使用DAG有向无环图 spark可以将多个MapReduce串联在一起
• 粗粒度资源调度，spark在任务执行之前会将所需要的所有资源全部申请下来

• spark生态体系

• spark-sql 将sql转换成RDD进行计算
• MLlib 机器学习
• Graphx 图计算
• spark-streaming 实时计算

---

搭建 Spark搭建地址

运行模式

• local[] 本地运行
• 独立集群 基本已经淘汰
• yarn

• yarn-client
  1.Driver在本地启动
  2.一般用于上线前的测试
  3.spark程序运行的日志会全部发送到Driver端，会导致本地网卡流量剧增

• yarn-cluster
  1.Driver在集群中启动
  2.上线使用

• Mesos

---

RDD五大特性

RDD Resilient Distributed Dataset 弹性分布式数据集

• A list of partitions
• A function for computing each split
• A list of dependencies on other RDDs
• Optionally, a Partitioner for key-value RDDs
• Optionally, a list of preferred locations to compute each split on

1. RDD由一组分区组成，每一个block块对应一个分区
2. 函数实际上是作用在每一个分区上，每一个分区都会有一个task来处理
3. RDD之间存在依赖关系

宽依赖

• 有shuffle的算子会产生宽依赖，分区对应关系是一对多

窄依赖

• 没有shuffle的算子， 分区对应的关系是一对一

stage

• 根据宽窄依赖划分stage （一组可以并行计算的task）

4. 分区的算子必须作用在key-value格式的RDD上
5. spark为task的计算提供了最佳计算位置，会尽量将task发送到数据所在的节点执行，移动计算而不是移动数据

1. taskScheduler知道所有数据的位置
2. task由taskScheduler发送

---

常用算子

转换算子

• map
• flatmap
• filter
• groupByKey
• reduceByKey
• join
• union
• sortBy
• sample
• mapValues
• mapPartition
  …

操作算子

• reduce
• foreach
• collect
• count
• saveAsTextFile
  …

转换算子是懒执行模式，即存在于逻辑层面，实际上并没有做任何操作，只有在出现操作算子时，才会将代码运行。

---

缓存

• RDD中默认不保存数据
• 如果多次使用同一个RDD，可以将RDD进行缓存（懒执行）
• 使用方式

persist 方法

• MEMORY_ONLY
• MEMORY_ONLY_SER
• MEMORY_AND_DISK_SER

• 缓存的数据实际上是保存在Executor的内存或者磁盘上的，由blockmanager管理

    val rdd1: RDD[String] = sc.textFile("spark/data/students.txt")

    val stuRDD: RDD[String] = rdd1.map(line => {
      println("map")//测试检查用，看RDD算子运行几次
      line
    })

	//尝试不加后上面的map出现几次，相当于 stuRDD.persist(StorageLevel.MEMORY_ONLY)
    stuRDD.cache()

    //缓存到内存，内存足够为第一选择
//    stuRDD.persist(StorageLevel.MEMORY_ONLY)
//
//    第二选择,内存加压缩数据
//    stuRDD.persist(StorageLevel.MEMORY_ONLY_SER)
//
//    第三选择，内存加压缩数据加磁盘
//    stuRDD.persist(StorageLevel.MEMORY_AND_DISK_SER)

    //统计班级人数
    stuRDD
      .map(line => (line.split(",")(4),1))
      .reduceByKey(_+_)
      .foreach(println)

    //统计性别人数
    stuRDD
      .map(line => (line.split(",")(3),1))
      .reduceByKey(_+_)
      .foreach(println)

---

CheckPoint

• 将RDD的数据保存到hdfs中，会切断RDD的依赖关系
• 流程

1.当第一个job执行完成之后，会向前回溯，如果有RDD做了CheckPoint，会打上一个标记
2. 重新启动一个job任务计算RDD 的数据，将RDD的数据保存到hdfs

• 优化

在CheckPoint之前可以先cache一下

	//设置CheckPoint位置
  	sc.setCheckpointDir("spark/data/checkpoint")
    //读取分数表
    val studentRDD: RDD[String] = sc.textFile("spark/data/students.txt")

    val stuRDD: RDD[String] = studentRDD.map(line => {
      println("map...")//测试用，显示次数即为RDD的运行次数
      line
    })


    /**
      * checkpoint : 快照,  将rdd的数据持久化到hdfs, 数据不会丢失
      */
	//优化
    stuRDD.cache()
    stuRDD.checkpoint()

    // 统计i班级人数
    stuRDD
      .map(line => (line.split(",")(4), 1))
      .reduceByKey(_ + _)
      .foreach(println)

    // 统计性别人数
    stuRDD
      .map(line => (line.split(",")(3), 1))
      .reduceByKey(_ + _)
      .foreach(println)

    stuRDD
      .map(line => (line.split(",")(3), 1))
      .reduceByKey(_ + _)
      .foreach(println)

---

广播变量

• 当在算子内使用到Driver端的一个变量的时候，这个变量会被封装到task中，变成一个变量副本发送到Executor中
• 由于task的数量一般大于Executor的数量所有，会产生很多的变量副本，会降低任务执行的速度

使用广播变量

1. 在Driver端定义一个广播变量
2. 在算子中如果使用到广播变量，先去Executor中获取
3. 如果Executor中没有这个广播变量，Executor会去Driver端获取广播变量
4. 后续的task就可以直接使用

• 使用广播变量之后变量副本 <= Executor数量

	val student: RDD[String] = sc.textFile("students.txt")

    val list: List[String] = List("文科一班","文科二班","理科一班")

    //将集合广播
    val broadList: Broadcast[List[String]] = sc.broadcast(list)

    val result: RDD[String] = student.filter(line => {
      	val clazz: String = line.split(",")(4)
		//获取广播变量
      	val value: List[String] = broadList.value
      	value.contains(clazz)
    })
    result.foreach(println)

---

累加器

• 在算子内部修改Driver端的一个变量是不会生效的，因为在算子里面的代码在Executor端运行，算子外面的代码在Driver端运行，属于不同的JVM

• 累加器的使用

1. 在Driver定义一个累加器
2. 在Executor端进行累加
3. 在Driver端读取累加结果

	//定义累加器，默认值是0
    val acc: LongAccumulator = sc.longAccumulator

    rdd.foreach(i => {
      acc.add(1)
    })
    println(acc.value)

//不使用累加器
	var a: Int = 0
	rdd.foreach(i => {
		a+=1
	})
	println(a)

---

BlockManager

• 在每一个Executor中都有一个块管理器，用来管理Executor中的数据
• 管理范围

1. RDD缓存的数据
2. 广播变量和累加器
3. shuffle文件

---

shuffle

1. hashshuffle 小文件数 = map数 * reduce数
2. hashshuffleManager 小文件数 = core数 * reduce数
3. sortshuffle（默认） 小文件数 = 2 * map数
4. sortshuffle bypass机制，在溢写的过程中不排序，当reduce的数量小于200的时候会触发

---

资源调度和任务调度

• 当在代码中出现new SparkContext的时候开始资源调度

• client模式

1. Driver在本地启动
2. 向RM申请启动AM
3. AM启动后向RM申请资源
4. RM分配资源启动Executor
5. Executor启动之后反向注册给Driver

（AM ApplicationMaster RM ResourceManage）

• cluster模式

1. Driver和AM合二为一，功能合并
2. AM启动后向RM申请资源
3. RM分配资源启动Executor
4. Executor启动之后反向注册给Driver

• 任务调度

1. 当代码中遇到Action算子的时候开始任务调度
2. 构建DAG有向无环图
3. DAGScheduler根据宽窄依赖切分stage
4. DAGScheduler将stage以taskSet的形式发送给TaskScheduler
5. TaskScheduler将task发送到Executor中执行（会尽量将task发送到数据所在的节点执行）
6. Executor向TaskScheduler汇报任务执行情况

• task失败之后TaskScheduler重试三次，如果因为shuffle file not found导致的异常，TaskSchedule不负责重试task，而是由DAGScheduler重试上一个stage
• TaskSchedule重试三次还失败，由DAGScheduler重试stage