黑客灵魂

这个屌丝很懒，什么也没留下！

热门标签

Spark分布式计算期末复习_( )是spark的基本数据结构,基于内存的分布式存储序列,分区存储在worker中。

作者：黑客灵魂 | 2024-07-09 02:48:32

踩

( )是spark的基本数据结构,基于内存的分布式存储序列,分区存储在worker中。

Spark分布式计算期末复习

1. Scala
2. Spark基础
3、Spark SQL
4. Spark Streaming
- 概念：微批处理、DStream、Receiver
5. Spark MLlib
- 概念：MLlib

单选题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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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特点/优点

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

2.5 主从架构

在这里插入图片描述

2.6 提交模式

Local
- 主从架构在本地进程中实现，常用于开发测试。
- 在Client上安装配置Spark，不用启动Spark守护进程。
Spark on Standalone
- 使用Spark的Standalone提供资源调度；任务由Client提交至Spark集群，主从架构在Spark的Master和Worker守护进程中实现。
- 安装配置Spark集群并事先启动Spark守护进程。
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())
1
2

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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))
1
2
3
4
5
6
7
8
9
10
11

2.14.4 求和

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

2.14.5 求总数

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

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

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