Spark考试题总结

一.选择判断

1.单选

下面哪个不是 RDD 的特点 ( )

A.可分区 B.可序列化 C.可修改 D.可持久化

关于累加器，下面哪个是错误的 ( )
A.支持加法 
B.支持数值类型
C.可并行 
D.不支持自定义类型

Scala语言中，以下说法正确的是（）
A.常量和变量都可以不用赋初始值
B.常量需要赋初始值，变量可以不用赋初始值
C.常量和变量都需要赋初始值
D.常量不需要赋初始值，变量必须赋初始值

下面对MapReduce描述错误的是(  )
A. 适合离线批处理   
B. 具有很好的容错性和扩展性
C. 启动开销小、可以使用很少的磁盘到时效率提高  
D. Shuffle连接Map和Reduce

下面描述正确的是(  )
A. NameNode是一个中心服务器，单一节点，负责管理文件系统的名字空间以及客户端对文件的访问.
B. DataNode负责元数据操作，很文件内容相关的数据流经过DataNode.
C. 副本存放在那些DataNode上有NameNode和DataNode协商控制.
D. DataNode全权管理数块的赋值，接受心跳信号和块状态报告

下列那个配置描述是错误的(  )
A.<name>fs.defaultFS</name> 是定义hdfs集群的命名空间
B.<name>dfs.replication</name> 是定义hdfs文件系统副本数
C.<name>dfs.datanode.data.dir</name> 是定义hdfs文件系统元数据存放目录
D.<name>dfs.namenode.name.dir</name> 是定义hdfs文件系统元数据存放目录

下列哪一项是yarn的一级调度管理(  )
A.计算资源管理
B.Schdule的周期管理
C.app内部计算模型管理
D.多样化计算模型管理

下列哪一项不是applicationMaster的功能(  )
A.数据切分
B.为应用程序申请资源，并进一步分配给内部任务
C.任务监控与容错
D.所有应用的管理者

关于ResourceManager描述错误的是(  )
A. 全局的资源管理器，整个集群只有一个，负责集群资源的同意管理和调度分配
B. 处理客户单请求
C. 启动和监控ApplicationMaster
D. 资源分配和调度、不监控NodeManager

以下说明错误的是(  )
A. setup() : 对 Map Task 进行一些预处理
B. map() : 每次接受一个 Key-Value 对并对其进行处理，再分发处理
C. cleanup() : 对 Reduce Task 进行一些处理后的工作
D. run() : 相当于 Map Task 的驱动

scala 中，以下说法错误是 (  )
A. scala 中可以在类中定义类。
B. scala 中可以在函数中定义函数。
C. scala 中不可以在类中定义object。
D. scala 中可以在函数中定义类。

下面关于override修饰符的描述错误的是 (  )
A. Scala里所有重载了父类具体成员的成员都需要这样的修饰符
B. Scala里如果子类成员实现的是同名的抽象成员则这个修饰符是可选的
C. Scala里如果子类中并未重载或实现什么基类里的成员则禁用这个修饰符
D. Scala里如果子类是抽象类则子类的同名成员不可以使用这个修饰符

Scala里，final修饰符的描述正确的是 (  )

A. 类的声明上添加final修饰符确保成员不被子类重载
B. 类的声明上添加final修饰符把整个类声明为final，这个类不能被继承
C. 类的声明上添加final修饰符确保成员只能被子类重载一次
D. 以上说法都是错误的

调用函数时指定（），参数顺序可以跟函数定义时的顺序不同
A.参数名
B.参数值
C.默认值
D.变量值

scala 中，类和它的伴生对象说法错误的是(  )
A. 类和它的伴生对象定义在同一个文件中。
B. 类和它的伴生对象可以有不同的名称。
C. 类和它的伴生对象可以互相访问私有特性。
D. 类和它的伴生对象可以实现既有实例方法又有静态方法。

 

2.多选

以下（）可以实现类似java中的break跳出方式
A.使用一个Boolean类型的控制变量，合适的时候return
B.使用嵌套函数—从函数当中return
C.使用Breaks对象中的break方法
D.使用continu   

ABC

下列函数中参数必须为空的有（）  

A.readLine()   
B.readInt()   
C.readDouble()  
D.readChar()

BCD

Spark跟如下哪些不是一类（）
A.MapReduce
B.HDFS
C.YARN
D.Storm

BC

Spark可以实现哪些形式的分布式计算（）

A.内存式运算
B.机器学习
C.交互式查询
D.流式计算

ABCD

Spark的算子类型（）
A.转换算子
B.迭代算子
C.动作算子
D.核心算子

AC

下列哪些是spark的特点（ ）

A.运行快
B.基于内存
C.底层是mr运算
D.速度快

ABD

以下那些事宽依赖算子（ ）

A.join
B.mapPartitons
C.groupByKey
D.flatMap

AC

哪个是本地模式运行的条件 （ ）
A.spark.localExecution.enabled=true  
B.显式指定本地运行
C.finalStage 无父 Stage
D.partition默认值

ABC

Stage 的 Task 的数量跟什么无关（ ）

A.Partition             
B.Job             
C.Stage            
D.TaskScheduler

BCD

spark的存储级别包含（ ）

A.MEMORY_ONLY                      
B.MEMORY_ONLY_SER
C.MEMORY                                    
D.MEMORY_AND_DISK_SER

ABD

Spark 的四大组件中包含（ ）
A.Spark Streaming          
B.Mlib 
C.Graphx                           
D.Spark R

ABC

Spark driver的功能是什么（ ）

A.是作业的主进程
B.负责了作业的调度
C.负责向HDFS申请资源
D.负责作业的解析

ABD

spark的有几种部署模式（ ）
A.本地模式
B.standalone 模式
C.spark on yarn 模式
D.mesos模式

ABCD

下列那些是spark中的常用算子（ ）
A.map 
B.mapPartitions  
C.mapPartition 
D.foreachPartitions

AB

下列那些选项导致内存溢出（ ）
A.map端
B.数据不平衡
C.shuffle后
D.standalone模式下资源分配不均匀

ABCD

Spark 的数据结构有 （ ）

A.rdd    B.DataFrame  C.Dataset D.RowMatrix

AB

SparkRdd 转换算子有（ ）
A.map  B.filter  c.mapPartitions D.collect

ABC

以下是Spark中executor的作用是（ ）

A.保存计算的RDD分区数据   
B.向Driver反向注册   
C.接受Driver端发送来的任务Task，作用在RDD上进行执行      
D.做资源调度任务  

ABC

关于累加器，下面哪个是正确的（ ）

A.支持加法 
B.支持数值类型   
C.可并行    
D.不支持自定义类型

ABC

关于广播变量，下面哪个是正确的 （ ）
A.任何函数调用    
B.是只读的  
C.存储在各个节点    
D.存储在磁盘或 HDFS

ABC

spark的特点有哪些（ ）
A.快速性
B.通用性
C.兼容性
D.持续性

ABC

下列选项有哪些是spark优化（ ）

A.复用同一个rdd
B.创建重复的rdd
C.尽量使用shuffle算子
D.使用map-side预聚合的shuffle操作

AD

Spark为什么比mapreduce快（ ）
A.基于内存计算，减少低效的磁盘交互；
B.高效的调度算法，基于DAG
C.容错机制Linage，精华部分就是DAG和lineage
D.executor封装cpu与内存，执行效率高

ABC

spark sql为什么比Hadoop快（ ）
A.消除了冗余的HDFS读写
B.基于内存，减少低效的磁盘交互
C.消除了冗余的MapReduce阶段
D.JVM的优化

ACD

Master 的 ElectedLeader 事件后不做哪些操作（ ）

A.通知 driver 
B.通知 worker 
C.注册 application 
D.直接 ALIVE

ABC

关于累加器，下面哪个是正确的的（ ）

A.支持加法 
B.支持数值类型 
C.不可并行 
D.不支持自定义类型

AB

Spark 支持的分布式部署方式中哪个是正确的（ ）
A.standalone
B.spark on mesos
C.spark on YARN
D.Spark on local

ABC

Task 不运行在下来哪里个选项中 Executor 上的工作单元（ ）

A.Driver program
B.spark master
C.worker node
D.Cluster manager

ABD

属于spark的执行流程对的是（ ）
A.程序打包到hdfs
B.master在对应的worker上开启executor进程
C.executor向driver进程反向注册
D.executor接受到任务之后，分批次执行

BCD

spark的特点包括（ ）
A.快速
B.通用
C.可延伸
D.兼容性

ABD

哪些是本地模式运行的个条件（ ）

A.spark.localExecution.enabled=true  
B.显式指定本地运行
C.finalStage 无父 Stage
D.partition默认值

ABC

关于spark中数据倾斜引发原因正确的选项有（ ）
A.key本身分布不均衡
B.计算方式有误
C.过多的数据在一个task里面
D.shuffle并行度不够

ABCD

关于spark容错说法错误的有（ ）

A.在容错机制中，如果一个节点死机了，而且运算窄依赖，则只要把丢失的父RDD分区重算即可，依赖于其他节点
B.宽依赖开销更大
C.Checkpoint可以节约大量的系统资源
D.RDD的容错机制是基于Spark Streaming的容错机制

AD

容错的级别有（ ）

A.最多一次 
B.至少一次 
C.一次仅一次 
D.只能一次

ABC

关于广播变量，下面哪个是错误的（ ）
A.任何函数调用      B.是只读的  
C.存储在各个节点    D.存储在磁盘或 HDFS

ABC

spark中常用的算子（ ）
A.map
B.mapPartitions
C.foreach
D.以上全不是

ABC

Spark的数据本地性有哪几种（ ）

A.PROCESS_LOCAL是指读取缓存在本地节点的数据
B.NODE_LOCAL是指读取本地节点硬盘数据
C.ANY是指读取非本地节点数据
D.B和C对

ABC

关于master的作用，下面正确的是（ ）
A.接受driver端注册请求
B.启动任务的容器Executor
C.任务资源的调度
D.监控集群

ACD

如何解决数据倾斜（ ）
A.增大分区
B.增加前缀或后缀
C.减少分区
D.根据需要找key

ABD

Spark的资源分配方式包括( ) 

A.尽量集中
B.尽量打散
C.全部集中
D.全部打散

AB

下面哪个操作是宽依赖 ( )

A.join 
B.filter
C.group 
D.sort

ACD

下列哪个是 RDD 的缓存方法 ( ) 

A.persist() 
B.Cache() 
C.Memory()
D.MemoryCache()

AB

 

spark.deploy.recoveryMode 支持那种（ ）

A.ZooKeeper 
B.FileSystem
C. NONE 
D Hadoop

ABC

下面哪些端口是 spark 自带服务的端口 ( )

A.8080 B.4040 C.8090 D.18080

ABD 

下面属于HDFS设计目标的是
A.自动快速检测应对硬件错误
B.流式访问数据
C.移动计算比移动数据本身更划算
D.简单一致性模型

ABCD

下面描述正确的是(  )
A. HDFS将数量众多的廉价机器使得硬件错误成为常态
B. HDFS支持多种软硬件平台中的可移植性 
C.HDFS上的一个文件大小是G或T数量级的，支持一个云中文件数量达到千万数量级。
D. HDFS上的文件可以任意修改

ABC

hive有什么好处(  )
A. 可以使用sql，操作存储在hdfs中的数据
B. 可以通过语句自动编译mapreduce
C. 可以直接在表中插入数据
D. 可以存储数据

AB

那面那个是Hive的数据单元(  )
A. Textfile
B. Sequencefile
C. Rcfile
D. 都不正确

ABC

关于定义类正确的说法是（）
A.定义类时可以不用publiC.private来修饰
B.定义类时类名前需用class关键字
C.一个类文件中可以有多个类
D.定义的所有的类都具有共有可见性

ABC

关于构造器说法正确的是（）
A.每个类都有主构造器
B.除了主构造器，还可以定义辅助构造器
C.用this关键字定义辅助构造器
D.构造器参数可以不带val或var

ABCD

 

关于单例对象的说法正确的是（）

A.在Scala中没有静态方法和静态字段
B.可以使用object这个语法结构来达到静态类的效果
C.单例对象无法存放工具方法和常量
D.调用单例对象的方法是类名.方法名

ABD

 

关于伴生对象下列说法正确的是（）

A.与类名相同的对象叫做伴生对象
B.类和伴生对象之间可以相互访问私有的方法和属性
C.声明伴生对象的方法是object 类名
D.一个类中必须要声明伴生对象

ABC

3.判断

scala中没有静态方法（）错

在scala编译器中，右键点击xxx.scala Refactor重命名时，xxx.scala内部名字改变（）错

在scala中给变量赋值时一般不需要指定类型（）对

在scala中当一行代码存在多条语句时用逗号隔开（）对

scala中定义的变量不可以被重新赋值（）错

scala中定义的常量不允许重新进行赋值（）对

在scala中常量需要赋初始值，变量可以不用赋初始值（）错

scala不刻意区分基本数据类型和引用数据类型（）对

实现单个特质中的抽象方法时不需要override关键字（）对

带有特质的对象就是在对象构造时指定其所需要的特质（）对

使用with关键字串联起来的特质实现的同一个方法被调用的前后顺序相同（）错

scala中的while循环和do循环与java中不相同（）错

vector在scala中表示集合的一种（）对

for推导式生成的集合与他的第一个生成器类型不兼容（）错

scala的语法支持不写分号（）错

scala 中的if/else表达式没有返回值（）错

scala 的设计中每个表达式都应该有某种类型的输出值（）对

Unit类似于java中的void，表示空的概念，不占用底层存储（）对

scala支持switch（）错

scala中的赋值语句可以连在一起写（）错

scala的异常工作机制和java一样，当程序抛出异常时当前的程序被终止（）对

scala中异常抛出的对象必须是java.lang.Throwable的子类（）对

scala可以在方法或函数定义时就声明可能会抛出的异常（）错

Scala可以使用模式匹配的方法捕获异常（）对

scala中函数对对象进行操作（）错

scala的函数定义中，必须给出所有的参数类型（）对

scala的函数定义中函数如果不是递归的，不需要指定返回类型（）对

scala中如果函数体需要多个表达式完成，可以使用代码块，块中的第一个表达式的值代表函数的返回值（）错

我们在调用某些函数时并不显式的给出所有参数值，对于这些函数我们可以使用默认参数（）对

scala不允许函数的参数有不确定的个数（）错

sparkStreaming的核心抽象是Dstream（）对

spark on hive是hive把spark作为底层计算框架（）错

Spark Job 默认的调度模式FIFO（）对

Saprk中的广播的广播变量存储在磁盘或者HDFS中（）错

join算子是属于宽依赖（）对

Spark中的窄依赖有shuffle宽依赖没有shuffle（）错

RDD不支持细粒度的写和更新操作（）对

可以增大driver的内存参数spark.driver.memory(default 1g)防止spark内存溢出 （）对

spark中cache是缓存数据，默认是缓存在内存中，其本质还是调用persist（）对

SparkRdd action 算子的结果最后提交给driver（）对

SparkRdd 使用Transformation算子会销毁上一个rdd（）对

Spark的资源分配方式是尽量集中、尽量打散（）错

spark 1.4 版本的最大变化是支持动态资源分配（）错

spark只能用web ui 来查看运行日志（）对

hive 的元数据存储在 derby 和 MySQL 中没有区别（）错

sparkStreaming的核心抽象是Rdd（）错

Stage 的 Task 的数量Partition决定的（）对

默认的存储级别 是MEMORY_ONLY（）对

spark 的 master 和 worker 通过netty方式进行通信的（）对

做checkpoint有两种方式,数据检查点和记录数据的更新（）对

spark中sparkStreaming的核心是DataFrame（）错

具体的task运行在那他机器上，dag划分stage的时候确定的这是数据本地性（）对

reducebykey和groupbykey都只做全局聚合（）错

 

二.简答

简述spark的容错机制

答案：Spark的容错机制分为两种；
第一种方式，lineAge内部如果有分片数据丢失，可以通过上下的依赖关系，启动重算机制，进行容错。
第二种方式，spark可以通过checkPoint机制，设置一个第三方存储路径（一般是hdfs），当有数据丢失的时候，从对应的路径恢复数据，但是一旦启动了checkPoint意味着之前的lineAge被终止。

spark作业调优

序列化对于提高分布式程序的性能起到非常重要的作用。一个不好的序列化方式（如序列化模式的速度非常慢或者序列化结果非常大）会极大降低计算速度。很多情况下，这是你优化Spark应用的第一选择。Spark试图在方便和性能之间获取一个平衡。Spark提供了两个序列化类库：
Java 序列化：在默认情况下，Spark采用Java的ObjectOutputStream序列化一个对象。该方式适用于所有实现了java.io.Serializable的类。通过继承 java.io.Externalizable，你能进一步控制序列化的性能。Java序列化非常灵活，但是速度较慢，在某些情况下序列化的结果也比较大。
Kryo序列化：Spark也能使用Kryo（版本2）序列化对象。Kryo不但速度极快，而且产生的结果更为紧凑（通常能提高10倍）。Kryo的缺点是不支持所有类型，为了更好的性能，你需要提前注册程序中所使用的类（class）。

driver的功能是什么？

1）一个Spark作业运行时包括一个Driver进程，也是作业的主进程，具有main函数，并且有SparkContext的实例，是程序的人口点；

2）功能：负责向集群申请资源，向master注册信息，负责了作业的调度，，负责作业的解析、生成Stage并调度Task到Executor上。包括DAGScheduler，TaskScheduler。

RDD宽依赖和窄依赖？

RDD和它依赖的parent RDD(s)的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。

1）窄依赖指的是每一个parent RDD的Partition最多被子RDD的一个Partition使用

2）宽依赖指的是多个子RDD的Partition会依赖同一个parent RDD的Partition

cache和pesist的区别 

1）cache和persist都是用于将一个RDD进行缓存的，这样在之后使用的过程中就不需要重新计算了，可以大大节省程序运行时间；

2） cache只有一个默认的缓存级别MEMORY_ONLY ，cache调用了persist，而persist可以根据情况设置其它的缓存级别；

3）executor执行的时候，默认60%做cache，40%做task操作，persist最根本的函数，最底层的函数

RDD有哪些缺陷？

1）不支持细粒度的写和更新操作（如网络爬虫），spark写数据是粗粒度的所谓粗粒度，就是批量写入数据，为了提高效率。但是读数据是细粒度的也就是说可以一条条的读

2）不支持增量迭代计算，Flink支持

Spark中数据的位置是被谁管理的？

每个数据分片都对应具体物理位置，数据的位置是被blockManager，无论数据是在磁盘，内存还是tacyan，都是由blockManager管理

Spark程序执行，有时候默认为什么会产生很多task，怎么修改默认task执行个数？
 

1）因为输入数据有很多task，尤其是有很多小文件的时候，有多少个输入block就会有多少个task启动；

2）spark中有partition的概念，每个partition都会对应一个task，task越多，在处理大规模数据的时候，就会越有效率。不过task并不是越多越好，如果平时测试，或者数据量没有那么大，则没有必要task数量太多。

3）参数可以通过spark_home/conf/spark-default.conf配置文件设置:spark.sql.shuffle.partitions 50 spark.default.parallelism 10第一个是针对spark sql的task数量第二个是非spark sql程序设置生效

 简单描述一下spark shufflle的过程？

答案：spark的shuffle意味着数据要重新洗牌，主要分为两个流程，第一个是shuffle write，另外一个是shuffle read。
shuffle write有两种方式，第一种类似于mapreduce的shuffle，第二种采用的是先排序后建立索引的方式，能大大减少第一种方式里面中间文件产生导致的性能降低。
shuffle的read过程，要先判断需要读取数据来自于本节点还是其他节点，如果是其他节点需要先建立一个socket连接，然后通过文件块的方式来读取。

Shuffle分为两类，基于hash的
讲解了三种情况，建立索引排序

哪些rdd会导致shuffle？

答案： 1.byKey的算子
       2.reparation和coalesece(true)
    3.join(非 cogroup)

kafka+spark-streaming结合丢数据怎么解决？

spark streaming从1.2开始提供了数据的零丢失，想享受这个特性，需要满足如下条件：
1.数据输入需要可靠的sources和可靠的receivers
2.应用metadata必须通过应用driver checkpoint
3.WAL（write ahead log）

你觉得spark 可以完全替代hadoop 么?

不可以
Spark只是分布式计算平台，而hadoop已经是分布式计算、存储、管理的生态系统。
与Spark相对应的是Hadoop MapReduce。我认为Spark是可以取代MapReduce的，从而成为Hadoop系统中不可或缺的一部分。
Spark更适合于迭代运算比较多的ML和DM运算。因为在Spark里面，有RDD的概念。RDD可以cache到内存中，那么每次对RDD数据集的操作之后的结果，都可以存放到内存中，下一个操作可以直接从内存中输入，省去了MapReduce大量的磁盘IO操作。但是，我们也要看到spark的限制：内存。我认为Hadoop虽然费时，但是在OLAP等大规模数据的应用场景，还是受欢迎的。目前Hadoop涵盖了从数据收集、到分布式存储，再到分布式计算的各个领域，在各领域都有自己独特优势。
至于Spark相对于Hadoop的优势，我已经说了，分布式计算仅仅是hadoop的一部分。所以以下比较内容实际上是Spark和MapReduce的对比：
更快
更容易使用
编程的时候没有蛋疼的map+reduce函数，而且配置起来超级方便。除支持JAVA外，支持scala、python、R。特别是scala，简直是太适合写数据分析的程序了，mapreduce用JAVA实在是太蛋疼了。而且RDD自带的函数超级好用，真心比mapreduce方便太多
巨好用的库
能解决90%问题的四大组件，无论是SQL、还是流数据处理、机器学习库、图计算，相当好用。当然，hadoop相关的库也不少，不过spark是原生包含，用起来方便点。
运行方便
Spark是可以脱离hadoop运行的，比如数据可以从数据库或者本地文件里面抽取。不过毕竟大数据时代，大家都习惯于将Spark和hadoop通过mesos或者yarn结合起来用；主要用Hadoop的HDFS，当然HBASE或者HIVE这种HDFS之上的组件，Spark也支持。

对于Spark中的数据倾斜问题你有什么好的方案？

1）前提是定位数据倾斜，是OOM了，还是任务执行缓慢，看日志，看WebUI
2)解决方法，有多个方面
· 避免不必要的shuffle，如使用广播小表的方式，将reduce-side-join提升为map-side-join
·分拆发生数据倾斜的记录，分成几个部分进行，然后合并join后的结果
·改变并行度，可能并行度太少了，导致个别task数据压力大
·两阶段聚合，先局部聚合，再全局聚合
·自定义paritioner，分散key的分布，使其更加均匀

为什么要进行序列化？

序列化可以减少数据的体积，减少存储空间，高效存储和传输数据，不好的是使用的时候要反序列化，非常消耗CPU

Spark累加器有哪些特点？

1）累加器在全局唯一的，只增不减，记录全局集群的唯一状态
2）在exe中修改它，在driver读取
3）executor级别共享的，广播变量是task级别的共享
两个application不可以共享累加器，但是同一个app不同的job可以共享

三.论述

请用java 手写一个spark单词计数程序？

public class WordCountLocal {
 public static void main(String[] args) {
  SparkConf conf = new SparkConf().setAppName("WordCountLocal").setMaster("local[2]");
  
  JavaSparkContext sc = new JavaSparkContext(conf);
  JavaRDD<String> words = sc.textFile("c:.//words.txt").flatMap(new FlatMapFunction<String, String>() {
   @Override
   public Iterable<String> call(String line) throws Exception {
    return Arrays.asList(line.split(" "));
   }
  });  
  JavaPairRDD<String, Integer> mapToPair = words.mapToPair(new PairFunction<String, String, Integer>() {
   @Override
   public Tuple2<String, Integer> call(String word) throws Exception {    
    return new Tuple2<String, Integer>(word,1);   
   }
  });  
  JavaPairRDD<String, Integer> result = mapToPair.reduceByKey(new Function2<Integer, Integer, Integer>() {
   
   @Override
   public Integer call(Integer v1, Integer v2) throws Exception {   
    return v1 + v2;
   }
  });
 
  result.foreach(new VoidFunction<Tuple2<String,Integer>>() {
   @Override
   public void call(Tuple2<String, Integer> wordCount) throws Exception {
   
    System.out.println(wordCount._1 + " appear " + wordCount._2 + " times!");
   }
  });
  sc.close();
 }
}

请用scala 手写一个spark的wordCount程序？（数据源为：c：//words.txt）

object WordCount {
  def main(args: Array[String]) {
    val conf = new SparkConf().setAppName("WordCount").setMaster("local")
    val sc = new SparkContext(conf)
    sc.setCheckpointDir("")
    val rdd1 =sc.textFile("hdfs://huawei:8020/words.txt").flatMap(_.split(" ")).
      map((_,1)).reduceByKey(_+_).persist(StorageLevel.MEMORY_AND_DISK)
     rdd1.checkpoint()
       rdd1.saveAsTextFile("")
    println(rdd1.collect().toBuffer)
  }
}

Spark Streaming与Storm的优劣分析

事实上，Spark Streaming绝对谈不上比Storm优秀。这两个框架在实时计算领域中，都很优秀，只是擅长的细分场景并不相同。

Spark Streaming仅仅在吞吐量上比Storm要优秀，而吞吐量这一点，也是历来挺Spark Streaming，贬Storm的人着重强调的。但是问题是，是不是在所有的实时计算场景下，都那么注重吞吐量？不尽然。因此，通过吞吐量说Spark Streaming强于Storm，不靠谱。

事实上，Storm在实时延迟度上，比Spark Streaming就好多了，前者是纯实时，后者是准实时。而且，Storm的事务机制、健壮性 / 容错性、动态调整并行度等特性，都要比Spark Streaming更加优秀。

Spark Streaming，有一点是Storm绝对比不上的，就是：它位于Spark生态技术栈中，因此Spark Streaming可以和Spark Core、Spark SQL无缝整合，也就意味着，我们可以对实时处理出来的中间数据，立即在程序中无缝进行延迟批处理、交互式查询等操作。这个特点大大增强了Spark Streaming的优势和功能。

storm和spark-streaming：为什么用storm不同spark-streaming

对于Storm来说：

1、建议在那种需要纯实时，不能忍受1秒以上延迟的场景下使用，比如实时金融系统，要求纯实时进行金融交易和分析
2、此外，如果对于实时计算的功能中，要求可靠的事务机制和可靠性机制，即数据的处理完全精准，一条也不能多，一条也不能少，也可以考虑使用Storm
3、如果还需要针对高峰低峰时间段，动态调整实时计算程序的并行度，以最大限度利用集群资源（通常是在小型公司，集群资源紧张的情况），也可以考虑用Storm
4、如果一个大数据应用系统，它就是纯粹的实时计算，不需要在中间执行SQL交互式查询、复杂的transformation算子等，那么用Storm是比较好的选择

对于Spark Streaming来说：
1、如果对上述适用于Storm的三点，一条都不满足的实时场景，即，不要求纯实时，不要求强大可靠的事务机制，不要求动态调整并行度，那么可以考虑使用Spark StrStreaming
2、考虑使用Spark Streaming最主要的一个因素，应该是针对整个项目进行宏观的考虑，即，如果一个项目除了实时计算之外，还包括了离线批处理、交互式查询等业务功能，而且实时计算中，可能还会牵扯到高延迟批处理、交互式查询等功能，那么就应该首选Spark生态，用Spark Core开发离线批处理，用Spark SQL开发交互式查询，用Spark Streaming开发实时计算，三者可以无缝整合，给系统提供非常高的可扩展性

hadoop和spark的都是并行计算，那么他们有什么相同和区别

两者都是用mr模型来进行并行计算，hadoop的一个作业称为job，job里面分为map task和reduce task，每个task都是在自己的进程中运行的，当task结束时，进程也会结束
spark用户提交的任务成为application，一个application对应一个sparkcontext，app中存在多个job，每触发一次action操作就会产生一个job
这些job可以并行或串行执行，每个job中有多个stage，stage是shuffle过程中DAGSchaduler通过RDD之间的依赖关系划分job而来的，每个stage里面有多个task，组成taskset有TaskSchaduler分发到各个executor中执行，executor的生命周期是和app一样的，即使没有job运行也是存在的，所以task可以快速启动读取内存进行计算
hadoop的job只有map和reduce操作，表达能力比较欠缺而且在mr过程中会重复的读写hdfs，造成大量的io操作，多个job需要自己管理关系
spark的迭代计算都是在内存中进行的，API中提供了大量的RDD操作如join，groupby等，而且通过DAG图可以实现良好的容错

spark的有几种部署模式，每种模式特点？
 

1）本地模式
Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类
· local：只启动一个executor
· local[k]:启动k个executor
· local
：启动跟cpu数目相同的 executor
2)standalone模式
分布式部署集群， 自带完整的服务，资源管理和任务监控是Spark自己监控，这个模式也是其他模式的基础，
3)Spark on yarn模式
分布式部署集群，资源和任务监控交给yarn管理，但是目前仅支持粗粒度资源分配方式，包含cluster和client运行模式，cluster适合生产，driver运行在集群子节点，具有容错功能，client适合调试，dirver运行在客户端
4）Spark On Mesos模式。官方推荐这种模式（当然，原因之一是血缘关系）。正是由于Spark开发之初就考虑到支持Mesos，因此，目前而言，Spark运行在Mesos上会比运行在YARN上更加灵活，更加自然。

如何使用Spark解决分组排序问题？（互联网公司常面）
组织数据形式：
aa 11
bb 11
cc 34
aa 22
bb 67
cc 29
aa 36
bb 33
cc 30
aa 42
bb 44
cc 49
需求：
1、对上述数据按key值进行分组
2、对分组后的值进行排序
3、截取分组后值得top 3位以key-value形式返回结果
 

答案：
val groupTopNRdd = sc.textFile("hdfs://db02:8020/user/hadoop/groupsorttop/groupsorttop.data")
groupTopNRdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey().map(
x => {
val xx = x._1
val yy = x._2
(xx,yy.toList.sorted.reverse.take(3))
}
).collect