Spark分布式计算期末复习

单选题30分，程序判断10分，问答30分，编程题30分

1. Scala

1.1 特点

Scala是一门现代的多范式编程语言（多范式特性：集成了面向对象编程和函数式编程）；由Java开发，运行在JVM上（继承了Java的运行速度，兼顾了与Java的兼容性并屏蔽了Java语言的复杂性，是大数据计算框架的首选语言）。
Scala大数据计算框架：
  ① Scala支持众多大数据计算框架；
  ② Spark（分布式通用计算引擎）；
  ③ Kafka（分布式消息系统）；
  ④ Flink（分布式实时流处理框架）

1.2 Scala源代码文件，编译后的文件

源代码文件：*.scala文件
编译成Java字节码文件：*.class文件

1.3 变量和常量

1.4 推断类型

1.5 for循环

1.6 数组

	// 创建数组
    var a : Array[String] = new Array[String](3)
    var b = new Array[String](3)
    var c = Array[String]   // 错误的！
    var d : Array[String] = Array("IBM","Google","Intel")
    var e = Array("IBM","Google","Intel")

    // 生成范围数组   var z = Range(start,end,step) step可省略，缺省为1
    var f = Range(1,10)     // 生成从1到10的整型数组

    // 访问数组  arrayName(下标值)
    var num : Int = f(1)

    // 合并数组
    var newArray = Array.concat(a,b)    // 将a、b数组合并成一个数组

1.7 方法与函数的区别

1.8 函数的声明（有名和匿名）

1.9 高阶函数

1.10 闭包

1.11 Lambda演算

1.12 集合类型List、Array、Map、Tuple创建和访问元素

1.13 容器方法Foreach、Map、FlatMap、Filter、Reduce、sum、max、min、count

2. Spark基础

2.1 Spark开发语言

Scala

2.2 Spark编程支持的语言

Scala、Java、Python

2.3 Spark生态系统

Spark Core：提供Spark核心功能，实现了Spark的底层机制并提供基本数据抽象格式。
Spark SQL：提供Spark SQL语言的解析与执行。
Spark Streaming：流式计算框架，提供了数据流的接入、抽象、计算等规范。
MLlib：机器学习框架，常用机器学习算法的分布式实现。
GraphX：分布式图计算框架，常用图算法的分布式实现。
Tachyon：分布式文件存储系统。

2.4 Spark特点/优点

1. 运行速度快：使用先进的有向无环图执行引擎，以支持循环数据流与内存计算。
2. 容易使用：支持Scala、Java、Python和R语言编程，API设计简洁，可通过Spark Shell进行交互式编程。
3. 通用性：提供完整而强大的技术栈，Spark Streaming、Spark SQL、MLlib和GraphX等组件。
4. 运行模式多样：本地模式、独立分布式和利用第三方平台的分布式。

2.5 主从架构

2.6 提交模式

1. Local
     - 主从架构在本地进程中实现，常用于开发测试。
     - 在Client上安装配置Spark，不用启动Spark守护进程。
2. Spark on Standalone
     - 使用Spark的Standalone提供资源调度；任务由Client提交至Spark集群，主从架构在Spark的Master和Worker守护进程中实现。
     - 安装配置Spark集群并事先启动Spark守护进程。
3. Spark on YARN
     - 使用Hadoop YARN提供资源调度；任务由Client直接提交至YARN，主从架构由YARN中ResourceManager和NodeManager实现。
     - 须先安装配置Hadoop集群并启动YARN；在Client上安装配置Spark即可，不用启动Spark守护进程。

2.7 deploy-mode：client与cluster的区别

2.8 运行架构、Application、SparkSession、Executor、Job、Stage、Task

Driver：
  Spark任务管理进程，执行用于提交的应用程序的main()方法，启动Application。
SparkContext：
  Application上下文，包含RDD、SparkConf和任务划分组件。
RDD：
  Spark的基本数据结构，基于内存的分布式存储序列，分区存储在Worker中。
Application：
  用户编写的Spark应用程序或启动SparkShell会创建Application，其中包含了一个SparkSession。
SparkSession：
  Spark与用户的交互结构，集成了SparkContext。
Executor：
  运行在Worker上，用于执行Stage中的Task。
Job：
  包含了RDD的每次Action操作。
Stage：
  Job的基本调度单位，一个Job会分为多个Stage，每个Stage包含多个Task，故也称为任务集。
Task：
  Task是Job中每个Stage具体执行的任务，最终以Stage为单位被分配到各Worker节点中的Executor中执行。
  RDD中的每个Task操作一个Partition，最终RDD的并行度取决于RDD的Partition情况。

2.9 Spark的执行spark-shell、spark-submit以及必要的参数master和deploy-mode

2.10 Spark编程框架

2.11 什么是惰性计算

一次性执行大量计算步骤，有助于调度器优化资源调度、提升计算效率和存储效率。

2.12 转换(Transformation)操作是什么？有哪些算子？

定义计算操作返回一个新的RDD只定义计算操作不执行计算，若连续执行转换操作，所有的操作会累积到返回的RDD中。
算子有：makeRDD、textFile、wholeTextFiles、map、flatMap、filter、groupBy、groupByKey、reduce、reduceByKey。

2.13 行动(Action)操作是什么，有哪些算子

执行RDD中所有操作并返回结果一次性执行RDD中累积的所有数据读取、转换操作和自身操作，并返回最终结果。
算子有：count、max、min、collect、saveAsTextFile。

2.14 算法

2.14.1 平均数

val rdd = Array(1,2,2,3,3,3)
println(rdd.sum() / rdd.count())

2.14.2 WordCount(+分区优化)

// 分区优化前
val conf = new SparkConf()
conf.setAppName("Test")
val sc = new SparkContext(conf)

val r=List("hello"," hello","world","spark","math","math","world")
val rdd=sc.makeRDD(r, 2)
rdd.map(x=>(x,1)).groupByKey()
     .map(x=>(x._1,x._2.count(x=>true))).foreach(println)

// 分区优化后
val r=List("hello"," hello","world","spark","math","math","world")
val rdd=sc.makeRDD(r, 2)
rdd.map(x=>(x,1))
     .mapPartitions(x=>x.toList.groupBy(y=>_._1)
                                   .map(y=>(y._1,y._2.count(z=>true)))
                                   .toIterator)
     .groupByKey().map(x=>(x._1,x._2.sum)).foreach(println)

2.14.3 最大值所在项

例：List中包含每个学生各科分数，返回每个学生的姓名、最高分的科目和分数。

val conf = new SparkConf()
conf.setAppName("Test")
val sc = new SparkContext(conf)
val students = List(("stu1", List(("math", 60), ("eng", 70), ("C", 72))), ("stu2", List(("math", 80), ("eng", 68), ("C", 79))), ("stu3", List(("math", 78), ("eng", 90), ("C", 88))))
val rdd=sc.makeRDD(students)
rdd.flatMap(x=>x._2.map(y=>(x._1,(y._1,y._2))))
   .reduceByKey((x,y)=>if(x._2>y._2) x else y)
   .map(x=>(x._1,x._2._1,x._2._2))
   .collect

// 输出结果：Array((stu1,C,72), (stu2,math,80), (stu3,eng,90))

2.14.4 求和

val rdd = Array(1,2,2,3,3,3)
println(rdd.sum())

2.14.5 求总数

val rdd = Array(1,2,2,3,3,3)
println(rdd.count())

2.15 RDD依赖关系（窄依赖，宽/shuffle依赖），各有什么算子？

• RDD的依赖关系
    一个RDD(父算子)由算子计算后生成另一个RDD(子RDD)，子RDD数据依赖于父RDD数据计算后得到。
• 窄依赖
    父RDD分区与子RDD分区一一对应，RDD分区在计算过程中不被分割，执行调度时父RDD和子RDD的Task可被分配到同一个Executor执行，不需要通过Shuffle重组数据。
    各Executor完全独立异步执行，不需要等待同步过程。
• 宽依赖
    子RDD分区的数据从多个父RDD分区抽取过来，父RDD分区数据会被抽取到多个子RDD分区中去。

2.16 分区映射算子

mapPartitions、repartition

2.17 分区器

HashPartitioner、RangePartitioner

2.18 RDD计算优化

3、Spark SQL

3.1 DataFrame，Schema

DataFrame：基于RDD构建，以面向列的方式存储表格数据，包含了表格的元数据Schema。
Schema：DataFrame中的数据结构信息，包含：列名、列数据类型、列注释、是否可为空等。

3.2 DataFrame与RDD的区别是什么？

• RDD可看作是分布式的对象的集合，Spark并不知道对象的详细模式信息
• DataFrame可看作是分布式的Row对象的集合，提供了由列组成的详细模式(Schema)信息

3.3 DataFrame的创建

3.4 DataFrame(Spark SQL)算子：

转换类：select、selectExpr（+统计方法sum、avg、count）、where、.sqlContext.sql（能将算子与SQL语句相互翻译）




行动类：show、printSchema

3.5 利用简单的算子实现指定的搜索功能

4. Spark Streaming

概念：微批处理、DStream、Receiver

5. Spark MLlib

概念：MLlib