spark基础学习

=学习spark前的原理组成

yarn中有两种节点：资源的总管家、资源的分布式管理
HDFS：默认的HDFS三个备份，默认的备份策略(机架策略，两个机架之间是相互独立的)
(默认第一个在本地做一个备份，第二个同机架做一个备份，第三个在另一个机架上做一个备份)
HDFS基于block，底层基于是磁盘的
Tachyon:是基于内存的
Hive有两种数据分类，一种是元数据(默认存在Derby里面，是单用户的，所以用MySQL替换)，另一种是业务数据(存储的情况下分为内表存储和外表存储(例：做删除操作，内部表会将数据和结构都删掉，外部表只能删除结构))
用一句话描述Hive：在海量数据的情况下用交互式查询分析的一个工具
storm：实时在线流计算（做财务相关）
GraphX：图计算
MLbase：机器学习库
Shark SQL：是sparkSQL的前身
spark一站式交互解决所有问题
spark core：有个核心的概念叫RDD，在spark中万物皆RDD

MapReduce-shuffer
分为两个task，map task和reduce task
先执行map task，先做数据的切分，根据block大小切分（block默认大小为128M），切分后是和block先以后决定的，在128M左右
（为什么要有block协商后一致？分布式存储，可能划分成两个block，然后分布到两台机器上，那样计算是数据就要移动了，数据移动计算就慢了）
默认为二八比例，满百分之八十的时候就会达到触发条件，然后发生易写，也就是发生shuffer机制
发生易写的同时，将用剩下的百分之二十用于继续接收数据，这个时候可能汇报OOM(内存溢出)，解决问题的根本方法：调整二八比例
如果没有达到百分之八十的时候，有一个监控的机制，如果没有数据流的时候，也会触发shuffer机制，然后数据进行落地到磁盘，map task的工作就结束了

reduce task：读数据的时候叫shuffer read ，拿到数据后先做小的聚合，然后在进行打的聚合，reduce task处理之后进行落地磁盘。可以不执行reduce task

Standalone是spark提供的一个资源平台

=配置虚拟机中的spark

将spark相关的包传到虚拟机进行解压即可

单节点的时候不需要修改配置文件

集群搭建spark时需要修改配置文件
参考spark命令文档

==spark的核心概念RDD=

spark core的核心概念RDD：
rdd是一个弹性分布式数据集
hdfs是一个分布式存储系统，hdfs是通过划分block来实现的（默认的block大小128M）
rdd的五大特性：
1、rdd是由一系列的partition组成的(看源码)
2、rdd之间就有一系列的依赖关系
3、算子作用在parttition上
4、分区器作用在(key，value)格式的rdd上(简单理解，某些算子的使用必须使用在(key，value)格式上的rdd上，例如reducebykey)
5、每一个rdd都会提供一批最优的计算位置，以便于本地化计算
spark默认没有提供读取hdfs的方法，它是通过读取mr来进行hdfs数据读取的
spark在进行数据切分的时候，默认的情况下切分完的partition的个数和block的个数是一致的，但是partition的大小是和block的大小商议后一致的
注：rdd是不存储数据的，rdd存储的是业务逻辑

spark资源调度+任务调度==

spark任务调度流程：(有相应的PPT图解)
1.rdd.join(rdd2);rdd.groupBy(…);rdd.filter(…)，这个操作是有序的，一直向下执行，形成的是DAG有向无环图
2.会将有向无环图交给DAGScheduler，将有向无环图切成一个有一个的task，将task以taskset形式发送到TaskScheduler
3.TaskScheduler将taskset中所有的task解除来，将task发送到具体的Worker里执行
4.Worker会将每一个task转换成Threads(线程)，worker实在Executor进程中将task转换成线程，然后一个一个线程的去执行

spark基于standalone资源调度器下-----client模式下的资源调度的流程(有相关的图解)
1、所有的worker向master汇报自己的资源状况，从而master就算掌握了所有spark中worker的资源情况
2、执行./spark-submit命令的时候，当程序加载完成前两行后，spark相关通道建立，driver启动
3、driver向master申请本app执行所需要的资源列表
4、master在收到driver请求的资源列表后，会随机选择一个worker，告诉他，让其查找一批用于该app计算使用的资源地址列表
5、worker收到master分配的任务指令后，开始寻找相应的地址列表信息，收集完成后，将信息收集完成的消息发送给master
6、master在收到worker的确认消息后，告诉其将资源地址信息反向注册给driver端
7、worker收到master的指令后，将地址信息反向注册给driver
8、driver收到地址信息后，开始执行任务流程，调度资源完成

spark-资源调度+任务调度(有相关的图解)
1、当spark启动后，所有的worker节点向master汇报自己的资源情况，从而master就知道了整个spark的资源情况(./start-all.sh)
2、当执行./spark-submit的时候，加载完成前两行代码后，spark通道建立，driver启动(DAG调度器，task调度器)
3、task调度器开始向master申请本次app执行所需要的所有资源列表
4、master收到资源请求后，会随机选择一台worker，让其寻找相应的地址资源列表
5、worker收到master命令后，会寻找相应的资源，并将其收集到的资源列表地址反向注册给driver
6、driver收到资源地址后，资源调度申请完成，任务调度开始执行
7、DAG调度器收到程序形成的有向无环图后，根据宽窄依赖对其进行stage的划分，并将其以taskset的形式发给task调度器
8、task调度器收到taskset后，会将其拆分为一个个task，并将其以task的形式发送到指定的worker中
9、worker收到task后，将其放在excutors中，并将其转换为线程来进行执行
10、worker执行完成程序后，将执行结果交给driver，返回客户端，程序执行完成(任务调度执行完成)

*driver的五大特性=====*

driver的五大特性：(集群模式下，必须指定driver)(有相关的图解)
1、建立连接
2、检测心跳机制
3、task任务的分发
4、task任务执行的监测，调度资源
5、结果的回收(回收task结果)

代码执行流程：
1、加载数据
2、通过调用算子进行处理，进行数据落地化

spark中有三种算子：
transformations类算子(转换类算子)：特性，延迟执行的,需要算子触发(action算子触发)
map：输入和输出是一对一的，输入一个对应输出一个(一步处理，例：直接给一个集合)
flatMap：(两步处理，经过处理后的数据，例：将集合拆分，给每个元素)
filter：就是一个简单的过滤器
simple：一般在样本取样的时候用
groupByKey：是一个小的聚合，在本地的一个聚合，groupByKey经过加工就是reduceByKey
reduceByKey：是一个大的聚合
join：用法和SQL中的形同
action类的算子(执行类算子)，一个action算子触发一个job
count、reduce、lookup、save
持久化算子(控制类算子)

为什么spark运行快？1、spark中有多种算子，用到最多的是transformations类算子。2、spark在执行程序之前将所有的资源都申请完毕(mr是执行一次程序申请一次资源，所以慢，优点是节省资源)

**=spark持久化==========**

spark持久化：
1、cache 具有以下特性
1.1cache是懒执行的
1.2cache执行完的结果必须有一个变量接收；代码示例：var ts=lines.cache()
1.3cache后不能跟随任意算子
2、checkpoint 检查点
checkpoint的执行流程
2.1在job执行完成之后，程序开始从最后一个rdd进行回溯检查
2.2在回溯的过程中，如果检查到某个rdd设置了checkpoint检查点，那么对其进行标记
2.3整个回溯过程完成后，程序启动另外一个线程对有编辑的rdd运行一下操作
2.3.1切断该rdd的所有依赖关系
2.3.2将该rdd进行保存----保存到checkpoint指定的目录下

**Spark Shuffer=======**

spark shuffer中包含两种shuffer：HashShuffer和SoreShuffer(有相关的PPT解析)
如何聚合的：通过Shuffer Write和Shuffer Read进行聚合的

HashShuffer：一个partition对应一个task，maptask和reducetask数量相等
分为Base Shuffer和优化后的HashShuffer
Base Shuffer：(磁盘小文件个数=mr)
优化后的HashShuffer(默认磁盘小文件buffer(内存缓冲)大小32k，不够大的时候会成倍增加，然后进行微调)：
第一个task落地磁盘文件，第二个task执行时，先判断是否有相同的task落地磁盘文件，没有就先开辟一块空间(磁盘小文件个数=2reducetask个数)
SortShuffer：
分为普通运行机制和bypass运行机制
普通运行机制：内存默认大小为5M，5.01*2-5=5.02,然后在申请5.02M内存，然后在进行向内存里添加，申请资源，知道资源不能再申请的时候才发生shuffer机制（sortshuffer独特的机制）
然后数据进行排序，内存缓冲大小32k也可以修改；形成磁盘文件，SortShuffer进行磁盘文件合并，做了一个索引文件，然后maptask结束
好处：多出来好几级缓冲，所以执行快
bypass运行机制：
比普通运行机制少了一个排序，需要一个触发条件
触发条件：shuffer reduce task数量小于spark shuffer sort bypassMergeThreshold参数的值才能触发

广播变量：
driver会将代码程序以task的形式发送到worker中，转换为线程进行执行，是定义在driver端的
如果有100个task，在worker的内存区，弄一块来接收i这个变量，用于本worker执行线程使用
注意：广播变量必须在driver端进行定义，在worker使用

累加器：
专门用于分布式累加求和用的，累加器的关键字Accumulator
是定义在driver端的，Driver可以读取值，操作在Executor端，在Executor端是不能读取数据的

窄依赖：task与task之间，一对一或者多对一就是窄依赖
宽依赖：task与task之间，一对多就是宽依赖
stage内部是窄依赖，stage与stage之间是宽依赖
用stage解释为什么spark运行快：因为程序运行的时候，是根据宽窄依赖对stage进行划分，stage内不是没有落地磁盘的，没有shuffer的，所以运行程序比较快

生产者是java项目（main service model dao）
消费者是web项目（controller model service）