spark基础

中文字符用utf-8编码占用3个字节(bit)，GBK、GB2312收编的汉字占2个字节(bit)，严格地用iso8859-1无法表示汉字，只能转为问号
ASCII 英文一个字节
gb2312，gbk 中文两个字节，英文一个字节
在中文系统中ansi一般指gb2312或gbk
GB2312、GBK都属于双字节字符集 (DBCS)
Utf-8 中文三个字节，英文一个字节
Unicode 中文两个字节，英文两个字

-------------------hadoop start ---------------------------------------
用命令显示hadoop所有的datanode的健康状况
hadoop dfsadmin -report

如何快速杀死一个job
1、执行 hadoop job -list 拿到 job-id
2、hadoop job -kill job-id
-------------------hadoop end ---------------------------------------

-----------------------Spark32个常用算子总结-----------------------------------
https://blog.csdn.net/fortuna_i/article/details/81170565
官方文档上列举共有32种常见算子，包括Transformation的20种操作和Action的12种操作。

##################batch_manage.sh#### eg : ./batch_manage.sh 2019-01-01 2019-10-31 ########
#!/bin/bash
WORKSPACE=$(cd $(dirname $0)/; pwd)

###经营业务v3：统计

提交脚本
set -e
cd $WORKSPACE
source /etc/profile
if [ $# -gt 1 ]
then
start_time=$1
end_time=$2elsestar{t}_{t}ime=‘date-d"-1day"+en{d}_{t}ime=‘date+fiecho"star{t}_{t}ime=$start_time,end_time=$end_time"
libPath=./libs
##第一版数据汇总表
start_job()
{
spark-submit
–master yarn
–deploy-mode client
–name “offline_third_manage”
–driver-memory 1G
–num-executors 1
–executor-cores 1
–executor-memory 3G
–conf “spark.driver.extraJavaOptions=-XX:+UseG1GC -XX:MaxGCPauseMillis=300 -XX:InitiatingHeapOccupancyPercent=50 -XX:G1ReservePercent=20 -XX:+DisableExplicitGC -Dlog4j.configuration=file:/opt/cloudera/parcels/CDH-6.0.1-1.cdh6.0.1.p0.590678/lib/spark2/conf/log4j.properties”
–conf “spark.executor.extraJavaOptions=-XX:+UseG1GC -XX:MaxGCPauseMillis=300 -XX:InitiatingHeapOccupancyPercent=50 -XX:G1ReservePercent=20 -XX:+DisableExplicitGC -Dlog4j.configuration=file:/opt/cloudera/parcels/CDH-6.0.1-1.cdh6.0.1.p0.590678/lib/spark2/conf/log4j.properties”
–conf spark.eventLog.enabled=true
–conf spark.memory.fraction=0.6
–conf spark.memory.storageFraction=0.5
–conf spark.default.parallelism=9
–conf spark.dynamicAllocation.enabled=false
–conf spark.ui.port=4080
–conf spark.ui.killEnabled=true
–files /etc/hive/conf.cloudera.hive/hive-site.xml
–files /etc/hbase/conf.cloudera.hbase/hbase-site.xml
–class com.hqtech.server.ManageTaskServer
$job_jar $start_time $end_time $tasks $dimension_tables $increment_tables
}

##第一次提交任务
start_job

#echo “start delete checkpointdata!!!”
##################batch_manage.sh############

spark-submit 详细参数说明
参数名 参数说明
–master master 的地址，提交任务到哪里执行，例如 spark://host:port, yarn, local
–deploy-mode 在本地 (client) 启动 driver 或在 cluster 上启动，默认是 client
–class 应用程序的主类，仅针对 java 或 scala 应用
–name 应用程序的名称
–jars 用逗号分隔的本地 jar 包，设置后，这些 jar 将包含在 driver 和 executor 的 classpath 下
–packages 包含在driver 和executor 的 classpath 中的 jar 的 maven 坐标
–exclude-packages 为了避免冲突 而指定不包含的 package
–repositories 远程 repository
–conf PROP=VALUE 指定 spark 配置属性的值，例如 -conf spark.executor.extraJavaOptions="-XX:MaxPermSize=256m"
–properties-file 加载的配置文件，默认为 conf/spark-defaults.conf
–driver-memory Driver内存，默认 1G
–driver-java-options 传给 driver 的额外的 Java 选项
–driver-library-path 传给 driver 的额外的库路径
–driver-class-path 传给 driver 的额外的类路径
–driver-cores Driver 的核数，默认是1。在 yarn 或者 standalone 下使用
–executor-memory 每个 executor 的内存，默认是1G
–total-executor-cores 所有 executor 总共的核数。仅仅在 mesos 或者 standalone 下使用
–num-executors 启动的 executor 数量。默认为2。在 yarn 下使用
–executor-core 每个 executor 的核数。在yarn或者standalone下使用

--------------spark ----------------------------------

1. DAG （新组件）: 数据库可用性组

2. RDD(Resilient Distributed Datasets): 弹性分布式数据集， 是分布式内存的一个抽象概念, 它代表一个不可变、可分区、里面的元素可并行计算的集合。
   Spark之RDD的概念
   RDD，弹性分布式数据集，是spark的底层数据结构。RDD是一个容错的，可以被并行操作的数据集合。RDD的特点之一是分布式存储，它的好处就是数据存储在不同的节点上，当需要数据进行计算的时候可以在这些节点上并行操作。弹性表现在节点在存储RDD数据的时候，既可以存储在内存中，也可以存储在磁盘上，也可以两者结合使用。RDD还有个特点就是延迟计算，当是transformation算子的时候，并不执行操作，直到遇到action算子的时候才开始执行计算。

   RDD的五大特性
   1 、A list of partitions
   ??–RDD是由多个partition构成的。
   2、A function for computing each split
   ??–RDD的每个分区上都有一个函数去作用
   3、 A list of dependencies on other RDDs
   ??–RDD有依赖性，通常情况下一个RDD是来源于另一个RDD，这个叫做lineage。RDD会记录下这些依赖，方便容错。
   4、Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
   –可选项，如果RDD里面存的数据是key-value形式，则可以传递一个自定义的Partitioner进行重新分区，例如这里自定义的Partitioner是基于key进行分区，那则会将不同RDD里面的相同key的数据放到同一个partition里面。
   5、Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)
   最优的位置去计算，也就是数据的本地性。

3. collect
   https://blog.csdn.net/chaoshengmingyue/article/details/82021746
   是Action操作里边的一个算子，这个方法可以将RDD类型的数据转化为数组，同时会从远程集群是拉取数据到driver端

4. Stage概念
   Spark任务会根据RDD之间的依赖关系，形成一个DAG有向无环图，DAG会提交给DAGScheduler，DAGScheduler会把DAG划分相互依赖的多个stage，划分stage的依据就是RDD之间的宽窄依赖。遇到宽依赖就划分stage,每个stage包含一个或多个task任务。然后将这些task以taskSet的形式提交给TaskScheduler运行。 stage是由一组并行的task组成

5. DataFrame和DataSet可以相互转化，DataFrame是特殊的Dataset
   df.as[ElementType] 这样可以把DataFrame转化为DataSet，
   ds.toDF() 这样可以把DataSet转化为DataFrame。

6. SparkSQL提供了一个DSL风格(领域特定语言)与SQL风格，如果想使用SQL风格的语法，需要将DataFrame注册成表,采用如下的方式

7. 对一个集合进行并行化的方式有两种：parallelize()和makeRDD()

8. df.filter($"key2"===$“key3”-1).show
   其中, ===是在Column类中定义的函数，对应的不等于是=!=。

9.窄依赖、宽依赖（父rdd —> 子rdd）
窄依赖
从 RDD 的 parition 角度来看
父 RRD 的 parition 和 子 RDD 的 parition 之间的关系是一对一的 (或 者是多对一的)。
不会有 shuffle 产生
宽依赖
父 RRD 的 parition 和 子 RDD 的 parition 之间的关系是一对多的
会产生shuffle

窄依赖的函数有：map, filter, union, join(父RDD是hash-partitioned ), mapPartitions, mapValues
宽依赖的函数有：groupByKey, join(父RDD不是hash-partitioned ), partitionBy
各算子介绍（join算子需分情况对待）https://www.cnblogs.com/carsonwuu/p/11596815.html  https://blog.csdn.net/know9163/article/details/80532608  https://www.cnblogs.com/chushiyaoyue/p/6812232.html

10.Spark中cache和persist的区别
1）cache和persist都是用于将一个RDD进行缓存的，这样在之后使用的过程中就不需要重新计算了，可以大大节省程序运行时间；
2）cache只有一个默认的缓存级别MEMORY_ONLY ，cache调用了persist，而persist可以根据情况设置其它的缓存级别；
3）executor执行的时候，默认60%做cache，40%做task操作，persist是最根本的函数，最底层的函数

★★★★★persist几种持久化级别(缓存级别)★★★★★
a.MEMORY_ONLY
使用未序列化的Java对象格式，将数据保存在内存中。如果内存不够存放所有的数据，则数据可能就不会进行持久化。那么下次对这个RDD执行算子操作时，那些没有被持久化的数据，需要从源头处重新计算一遍。这是默认的持久化策略，使用cache()方法时，实际就是使用的这种持久化策略。
b.MEMORY_AND_DISK
使用未序列化的Java对象格式，优先尝试将数据保存在内存中。如果内存不够存放所有的数据，会将数据写入磁盘文件中，下次对这个RDD执行算子时，持久化在磁盘文件中的数据会被读取出来使用。
c.MEMORY_ONLY_SER
基本含义同MEMORY_ONLY。唯一的区别是，会将RDD中的数据进行序列化，RDD的每个partition会被序列化成一个字节数组。这种方式更加节省内存，从而可以避免持久化的数据占用过多内存导致频繁GC。
d.MEMORY_AND_DISK_SER
基本含义同MEMORY_AND_DISK。唯一的区别是，会将RDD中的数据进行序列化，RDD的每个partition会被序列化成一个字节数组。这种方式更加节省内存，从而可以避免持久化的数据占用过多内存导致频繁GC。
e.DISK_ONLY
使用未序列化的Java对象格式，将数据全部写入磁盘文件中。
f.MEMORY_ONLY_2, MEMORY_AND_DISK_2, 等等
对于上述任意一种持久化策略，如果加上后缀_2，代表的是将每个持久化的数据，都复制一份副本，并将副本保存到其他节点上。这种基于副本的持久化机制主要用于进行容错。假如某个节点挂掉，节点的内存或磁盘中的持久化数据丢失了，那么后续对RDD计算时还可以使用该数据在其他节点上的副本。如果没有副本的话，就只能将这些数据从源头处重新计算一遍了。

★★ rdd cache默认存储级别是MEMORY_ONLY，dataFrame、dataSet默认存储级别是MEMORY_AND_DISK

11.spark - Locality Level (UI界面参数理解)
PROCESS_LOCAL: 数据在同一个 JVM 中，即同一个 executor 上。这是最佳数据 locality。
NODE_LOCAL: 数据在同一个节点上。比如数据在同一个节点的另一个 executor上；或在 HDFS 上，恰好有 block 在同一个节点上。速度比 PROCESS_LOCAL 稍慢，因为数据需要在不同进程之间传递或从文件中读取
NO_PREF: 数据从哪里访问都一样快，不需要位置优先
RACK_LOCAL: 数据在同一机架的不同节点上。需要通过网络传输数据及文件 IO，比 NODE_LOCAL 慢
ANY: 数据在非同一机架的网络上，速度最慢

12.spark四大组件
Spark SQL、Spark Streaming、MLlib、GraphX

13.Spark中的调度模式主要有两种：FIFO和FAIR。
默认情况下Spark的调度模式是FIFO（先进先出），谁先提交谁先执行，后面的任务需要等待前面的任务执行。
而FAIR（公平调度）模式支持在调度池中为任务进行分组，不同的调度池权重不同，任务可以按照权重来决定执行顺序。
spark的调度模式可以通过spark.scheduler.mode进行设置。

14.spark累加器
累加器（accumulator）是Spark中提供的一种分布式的变量机制，其原理类似于mapreduce，即分布式的改变，然后聚合这些改变。累加器的一个常见用途是在调试时对作业执行过程中的事件进行计数。

15.spark 中的Stage 的 Task 的数量由Partition分区数决定
stage0 task1,task2,task3,task4,task5
job stage1 task1,task2,task3,task4,task5
stage2 task1,task2,task3,task4,task5
job-stage-task的对应关系。首先job的划分是遇到action操作时，被发现后经过sparkcontext的runjob方法来到DAGscheduler，这个类中它会通过依赖关系划分出stage，一个stage是一个taskset，里面的每个task对应着rdd的一个分区。task可以理解为并行的分片。

Stage概念是spark中独有的。一般而言一个Job会切换成一定数量的stage。各个stage之间按照顺序执行。至于stage是怎么切分的，首选得知道spark论文中提到的narrow dependency(窄依赖)和wide dependency（ 宽依赖）的概念。其实很好区分，看一下父RDD中的数据是否进入不同的子RDD，如果只进入到一个子RDD则是窄依赖，否则就是宽依赖。宽依赖和窄依赖的边界就是stage的划分点

16.Executor与Task
每个worker节点可以起一个或多个Executor。
每个Executor由若干core组成，每个Executor的每个core一次只能执行一个Task。
每个Task执行的结果就是生成了目标RDD的一个partiton。

注意: 这里的core是虚拟的core而不是机器的物理CPU核，可以理解为就是Executor的一个工作线程。
而 Task被执行的并发度 = Executor数目 * 每个Executor核数。

17.Unit代表无返回值

18.repartition和coalesce的区别与使用场景解析
源码
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
coalesce(numPartitions, shuffle = true)
}
可以看到 repartition 内部实现调用的 coalesce 且为coalesce中 shuffle = true的实现

a.如果父RDD为1000分区，filter转换操作后过滤了50%的数据，想把数据重新分布在500分区中，这个时候是去减少分区这个时候使用coalesce(500)，能够避免引起shuffle
b.分区由少变多，或者在一些不是键值对的ＲＤＤ中想要重新分区的话，就需要使用repartition了

19.yarn-cluster和yarn-client模式剖析(https://blog.csdn.net/zxr717110454/article/details/80636569)
a、yarn-client，driver运行在本地客户端，负责调度Application，会与yarn集群产生大量的网络通信，从而导致网卡流量激增。好处是，执行时可以在本地看到所有的log，便于调试。所以一般用于测试环境。
b、yarn-cluster，driver运行在NodeManager，每次运行都是随机分配到NM机器上去，不会有网卡流量激增的问题。缺点就是本地提交后看不到log，只能通过yarn application-logs application id命令来查看。比较麻烦

20. Spark内存分配(https://www.jianshu.com/p/b68a3a2df7a3)
    在Spark 1.5版本及以前，Spark采用静态内存管理模型。Spark 1.6版本推出以后，Spark采用了统一内存管理模型。