大数据面试题总结

大数据为什么这么快
1、扩展性
传统的是纵向扩展（服务器数量不变，每个的配置越来越高）
大数据是横向扩展（每个的配置不变，但服务器数量越来越多）
2、分布式
传统的是集中式存储，集中式计算
大数据是分布式存储，分布式计算
3、可用性
传统的是单份数据（存储数据的磁盘少）
大数据是多份数据（存储数据的磁盘多）
4、模型
传统的是移动数据到程序端
大数据是移动程序到数据端（减少了大量的IO开销和网络开销，利用并行计算，并行存储）
大数据为什快
横向扩展
移动程序到数据端
多个数据副本
分布式存储（减小磁盘IO的瓶颈）
分布式计算（众人拾柴火焰高-人多力量大）
Hadoop
hadoop的组成
HDFS : 用于海量数据的存储
MapReduce ：用于海量数据的计算
Yarn ：集群（CPU 内存 硬盘 ）资源调度
安装hadoop分准备阶段（每个节点上）
1、 JDK 1.8
2 、远程ssh无密码登录（主到从）
3、防火墙关闭
4、selinux关闭
5、修改主机名
6、主机名和IP对应
hadoop安装部署
1、上传解压
2、配置hadoop的环境变量
3、检查支持哪些库或包
进入hadoop安装目录的bin里面执行以下命令
./hadoop checknative
验证集群可用
jps 查看java进程的进行情况
1、到集群上创建一个文件夹或文件
只要能够创建文件夹或文件表示集群可用
2、查看HDFS的web界面
获取namenode所在节点的IP +50070
hadoop内的权限和LIMUX里面的权限是完全相同的
hadoop的HDFS 没有目录切换，所有的路径或文件的路径必须使用绝对路径
HDFS文件系统提供了方便使用的web浏览器。
jobHistory记录任务运行的详细日志
访问jobHistory记录的任务日志
获取JobHistoryServer服务所在节点的IP+19888查看任务的详细日志。
Hadoop的组成部分
HDFS
管理者：NameNode
作用：负责管理，管理集群内各个节点。负责管理整个文件系统的元数据（描述数据的索引），名字空间，目录树的维护
工作者：DataNode
作用：负责工作，进行读写数据。 周期向NameNode汇报。
负责管理用户的文件数据块.
辅助者：SecondaryNameNode
作用：责辅助NameNode管理工作。
辅助namenode管理元数据信息
MapReduce
Yarn
管理者：ResourceManager
工作者：NodeManager
HDFS使用场景：海量数据的存储
HDFS可用的总容量是集群中所有节点的综合，HDFS目录下的数据在任何一个节点都可以使用或访问
hdfs中默认的数据块切分大小是128M，128直至 一个数据切分的分界线，若上传数据超过128M，那么对数据进行切分。若小于128，有多大上传多大，数据块就是多大。
HDFS数据副本机制
1、第一份数据来源于用户的客户端
2、第二份数据存放在与第一份副本在同一个机架，不同的节点，按照一定的机制（cpu 内存 io 使用率和节点磁盘剩余容量）选取一个节点进行存放
3、第三份副本存放在，与第一第二副本不在同一机架，且逻辑距离最近的机架上，按照一定的机制（cpu 内存 io 使用率和节点磁盘剩余容量），选择一个节点进行存放
hadoop 视硬件设备经常损坏为常态，为了防止硬件损坏导致系统不可用，所以构建多副本机制。
NameNode的三大作用
1、维护、管理HDFS的目录数-元数据-名字空间。
2、确定指定的文件块到具体的Datanode结点的映射关系。
3、维护、管理工作者的心跳信息。
DataNode作用（重点）
1、负责数据的读写（响应的是客户端）
2、周期向NameNode做心跳报告 （节点是否可用、数据是否丢失、校验和）
10分钟没有心跳NameNode认为该节点宕机。
每三秒发送一次心跳报告
3、负责数据的流水线复制（一点一点复制）
机架感知（重点）
人为编写一个脚本，脚本中记录集群中节点与交换机的映射关系。机架感知依赖此脚本，数据副本机制也依赖于此脚本。
HDFS数据写入流程（重点）

1、 client发起文件上传请求，通过RPC与NameNode建立通讯，NameNode检查目标文件是否已存在，父目录是否存在，返回是否可以上传；
2、 client请求第一个block该传输到哪些DataNode服务器上；
3、 NameNode根据配置文件中指定的备份数量及机架感知原理进行文件分配，返回可用的DataNode的地址如：A，B，C；
4、 client请求3台DataNode中的一台A上传数据（本质上是一个RPC调用，建立pipeline），A收到请求会继续调用 B，然后B调用C，将整个pipeline建立完成，后逐级返回client；
5、 client开始往A上传第一个block（先从磁盘读取数据放到一个本地内存缓存），以packet为单位（默认64K），A 收到一个packet就会传给B，B传给C；A每传一个packet会放入一个应答队列等待应答。
6、 数据被分割成一个个packet数据包在pipeline上依次传输，在pipeline反方向上，逐个发送ack（命令正确应答），最终由pipeline中第一个DataNode节点A将pipelineack发送给client;
7、关闭写入流。
8、 当一个block传输完成之后，client再次请求NameNode上传第二个block到服务器。

HDFS文件读取流程

1、客户端通过调用FileSystem对象的open()来读取希望打开的文件。
2、 Client向NameNode发起RPC请求，来确定请求文件block所在的位置；
3、 NameNode会视情况返回文件的部分或者全部block列表，对于每个block，NameNode 都会返回含有该 block副本的 DataNode 地址； 这些返回的 DN 地址，会按照集群拓扑结构得出 DataNode 与客户端的距离，然后进行排序，排序两个规则：网络拓扑结构中距离 Client 近的排靠前；心跳机制中超时汇报的 DN 状态为 STALE，这样的排靠后；
4、 Client 选取排序靠前的 DataNode 来读取 block，如果客户端本身就是DataNode,那么将从本地直接获取数据(短路读取特性)；
5、 底层上本质是建立 Socket Stream（FSDataInputStream），重复的调用父类 DataInputStream 的 read 方法，直到这个块上的数据读取完毕；
6、并行读取，若失败重新读取
7、 当读完列表的 block 后，若文件读取还没有结束，客户端会继续向NameNode 获取下一批的 block 列表；
8、返回后续block列表
9、 最终关闭读流，并将读取来所有的 block 会合并成一个完整的最终文件。
HDFS数据完整性计算

数据写入之后进行数据首次校验，文件系统周期性进行校验，防止数据丢失。
读取数据之前进行数据校验，若两个校验相同，那么表示数据没有丢失，开始读取数据。
若两个校验不相同，那么表示数据有部分丢失，换到其他节点（相同副本的节点）读取数据。
HDFS 适用场景
一次写入，多次读出的场景，支持文件追加，但不支持在文
件中间修改。
HDFS 特性
1、 存储海量数据：HDFS可横向扩展，其存储的文件可以支持PB级数据
2、容错性高：数据保存多个副本，副本丢失后自动恢复。
可构建在廉价（与小型机大型机对比）的机器上，实现线性扩展。（随着节点数量的增加，集群的性能-计算性能和存储性能都会有所增加）当集群增加新节点之后，namenode也可以感知，进行负载均衡，将数据分发和备份数据均衡到新的节点上。（负载均衡：集群可将原本使用容量较高的节点上的数据自动写入新的节点上，达到所有节点容量均匀）每个节点磁盘使用容量百分比的差异可以人工设置。
3、大文件存储： 数据分块存储，将一个大块的数据切分成多个小块的数据。
HDFS缺点
1、不能做到低延迟数据访问：HDFS针对一次性获取大量的数据做了优化，牺牲了小数据量快速查询的性能。
2、多次写入，一次读取（擅长：HDFS适合一次写入，多次读取的场景。）
3、不支持多用户的并行写
4、不适合大量的小文件存储
A: 由于namenode将文件系统的元数据存储在内存中，因此该文件系统所能存储的文件总数受限于namenode的内存容量。
B: 元数据信息中每个文件、目录和数据块的存储信息大约占150字节。（1G 数据存储的元数据信息占用150字节 ，1M的数据元数据信息占用150字节）受限于内存，元数据信息的存储机制导致无论数据多大，元数据信息中描述这个数据的信息都是150字节。
HDFS高级命令
特定文件夹下的副本数可以设置、存储容量可以设置，存储的文件个数可以设置。
设置文件夹内数据的个数： hdfs dfsadmin -setQuota 50 lisi （lisi 本身算一个 最多可上传49个）
清除文件数量限制 hdfs dfsadmin -clrQuota /user/root/lisi
限制空间大小 hdfs dfsadmin -setSpaceQuota 100M /user/root/lisi (最多可以存储100M)
清除空间限额 hdfs dfsadmin -clrSpaceQuota /user/root/lisi
查看hdfs文件限额数量 hdfs dfs -count -q -h /user/root/lisi
HDFS 安全模式（safemode）
是HDFS一种特殊状态，该状态下 只允许数据读取，不允许数据的修改与添加等变更操作。
什么时候进入安全模式：集群重新启动的时候进入安全模式。
安全模式下多了什么：DataNode在启动的时候会向namenode汇报可用的block等状态。
如何查看集群当前的状态： hdfs dfsadmin -safemode get
如何进入安全模式：hdfs dfsadmin -safemode enter
如何退出安全模式：hdfs dfsadmin -safemode leave
Fsimage,Edits
NameNode在工作时生成Fsimage,Edits两个文件
Fsimage 文件系统的快照，这个文件相对较小
Edits 记录客户端对集群的所有添加、删除、修改等操作，这个文件相对较大。
作用：用于恢复集群到关闭前的状态。开机时系统会将这两个文件加载到内存，进行合并恢复。
合并:将Fsimage Edits两个文件合并成一个Fsimage.（恢复完后Edits失效）
HDFS配置选项
dfs.namenode.name.dir 设置fsimage 数据的存放路径
dfs.namenode.edits.dir 设置edits数据的存放路径
将edits文件转换成XML
hdfs oev -i edits_0000000000000000416-0000000000000000418 -p XML -o test002.xml
将Fsimage文件转换成XML
hdfs oiv -i fsimage_0000000000000000418 -p XML -o test001.xml

secondarynameNode工作原理（意义）
前提：未使用secondarynameNode时，NameNode工作中会产生fsimage 和edtes,edits日志过大，直接导致集群二次开机恢复原本状态过慢，引起开机时间过长。
secondarynameNode存在的意义就是加快集群二次启动的速度（减小集群二次启动的时间）secondarynameNode原理（如何帮助NameNode 周期性在NameNode节点拷贝fsimage 和edtes 到自己的节点上，进行合并，合并后生成全新的FSimage,最后将FSimage发送回NameNode.）
secondarynameNode最好是一个独立的节点, 此节点的配置最好与NameNode 相同。
触发secondarynameNode合并文件的条件
1、时间维度， 默认一小时合并一次 ， 人为设置使用如下参数
dfs.namenode.checkpoint.period ：3600
2、次数维度，默认100W次合并一次。人为设置使用如下参数
dfs.namenode.checkpoint.txns ： 1000000
NameNode存储到元数据信息（fsimage 和edtes）可以多目录存储，防止元数据丢失。
集群再次启动时，两个文件以最新的为准。若删除了最新的两个日志，会导致部分数据丢失。
SNN不能做NN的热备份
1、SNN不能接替NN工作
2、SNN有可能会造成数据丢失。
SNN存储Fsimage 和Edits日志文件的路径
SNN存储Fsimage 的路径是以dfs.namenode.checkpoint.dir为key value 是 路径
SNN存储Edits的路径是以dfs.namenode.checkpoint.edits.dir为key value 是 路径。
HDSF集群扩容
A: 准备一个全新的节点
1、关闭防火墙
2、关闭selinux
3、修改主机名
4、主机名与IP的对应关系
5、SSH免密码登录
6、安装JDK
B: 添加到集群
1、创建HDFS的Datanode的白名单
touch dfs.hosts
2 、修改hdfs-site.xml,将白名单添加到配置文件中
dfs.hosts
/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/dfs.hosts
3、刷新节点
HDFS 刷新 hdfs dfsadmin -refreshNodes
YARN 刷新 yarn rmadmin -refreshNodes4、将新节点的主机名添加到slaves文件中
5、启动新结点上的DataNode NodeManager
sbin/hadoop-daemon.sh start datanode
sbin/yarn-daemon.sh start nodemanager
6、web 查看
7、数据负载均衡
./start-balancer.sh
分布式并行计算框架MapReduce
是指实现某项任务或某项工作从开始到结束的计算过程或流的结构。
游戏中，目标是计算每组纸条中每个图形的总个数。一共八个步骤，每个步骤都是计算的一部分，是框架的一部分。
MapReduce计算框架：

分布式并行计算框架
一个大的任务被拆分成多个小任务，每个小任务同时执行。按照执行流程进行计算。
偏移量
指的是每行行首字母移动到文办的最前面需要一定的字符。
MapReduce的数据类型

java: long int double flfloat string Boolean
hadoop : LongWritable IntWritable DoubleWritable FloatWritable Text BooleanWritable
编写Map代码
1、实例一个实体类，继承Mapper<输入放入key的类型，输入的value的类型，输出放入key的类型，输出的value的
类型>
2 、重写map(LongWritable key, Text value, Context context)
key 每行行首的偏移量
value 每一行的数据
context 上下文对象
3、实现自己业务逻辑的代码
将数据进行拆分，并进行逐一输出。
编写Reduce代码
1、实例一个实体类，继承Reducer<输入放入key的类型，输入的value的类型，输出放入key的类型，输出的value的
类型>
2、重写reduce(Text key, Iterable values, Context context)
key: 每一个唯一的数据（游戏中的图形）
values： 每一个图形 ，1 的标记（1的list）
context:上下文对象3、遍历values(1的list)
进行求和
4、将key 和这个key对应的value(总和)输出。
Driver代码流程
//1 、实例一个job
//2、使用job 设置读物数据(包括数据的路径)
//3、使用job 设置MAP类（map 输入和输出的类型）
//4、使用job 设置Reduce类（Reduce 输入和输出的类型）
//5、使用job 设置数据的输出路径
//6、返回执行状态编号

Map的输出 是key,value的 list
Reduce的输入 是key value的list
MapReduce核心思想
分而治之，先分后和（只有一个模型）
Map负责数据拆分 map: [k1,v1] → [(k2,v2)]
Reduce负责数据合并 reduce: [k2, {v2,…}] → [k3, v3]
MapReduce执行流程
第一步：InputFormat
InputFormat 在HDFS文件系统中读取要进行计算的数据
输出给Split
第二步：Split
Split 将数据进行逻辑切分，切分成多个任务。
输出给RR
第三步：RR
RR 将切分后的数据转换成key value进行输出
key : 每一行行首字母的偏移量
value: 每一行数据
输出给Map
第四步：Map
接收一条一条的数据（有多少行数据Map运行多少次，输出的次数根据实际业务需求而定） 根域业务需求编写代码
Map的输出是 key value的 list
输出给Shufflfflffle（partition）
---------------------------------------Map-------------------------------------------------------
第五步： partition
partition: 按照一定的规则对 **key value的 list进行分区
输出给Shufflfflffle（sort）
第六步：Sort
Sort :对每个分区内的数据进行排序。
输出给Shufflfflffle（Combiner）
第七步：Combiner
Combiner: 在Map端进行局部聚合（汇总）
目的是为了减少网络带宽的开销
输出给Shufflfflffle（Group）
第八步：Group
Group: 将相同key的key提取出来作为唯一的key
将相同key对应的value提取出来组装成一个value 的List
输出给Shufflfflffle（reduce）
------------------------------------Shufflfflffle--------------------------------------------
第九步：reduce
reduce： 根据业务需求对传入的数据进行汇总计算。
输出给Shufflfflffle（outputFormat）
第十步：outputFormat
outputFormat:将最终的额结果写入HDFS

Map的输出到Partition（***）
计算逻辑：对map输出的key 取哈希值，用这个哈希值与reducetask的值取余。余几，就将这个key，value放在对应的分区编号里（分区有多个编号）。
reducetask的设置： job.setNumReduceTasks(2);Combiner作用
Map结束后，在Map端进行局部聚和。作用：较少网络传入次数，降低了网络开销。
job.setCombinerClass(WordCountReduce.class);
Split对数据进行逻辑切分
hdfs数据块大小是128 ，split 逻辑切分数据块大小是128M
HDFS 128 是存储层面的概念，是切分数据的分界点。
split 128 是一个逻辑切分。
这两个128没有关系。
Map 输出数据到内存
map输出的数据写入环形缓冲区（内存），缓冲区的默认大小是100M（可修改）。当数据达到阈值（默认0.8-可修改）时，环形缓冲区进行flflash,
环形缓冲区：数据在输出的同时，数据也可以写入空余的空间内。
当flflash的数据个数达到一定的数量时（默认4个）。对数据进行合并（merge）。
Reduce在Map拷贝数据
Map 输出的结果写入本地，reduce主动发出拷贝进程到Map端拷贝数据。
reduce获取大数据后，将数据写入内存，当数据达到阈值时进行flflash.
当flflash的个数达到一定的量时，进行合并，最终发送给reduce。
Map的最终由效果是什么样（如何能让Map达到最优）
Map端的最高效率是：尽量减少环形缓冲区flflush的次数（减少磁盘IO 的使用次数）
如何能够减少环形缓冲区flflush的次数：
1、加大环形缓冲区的内存
2、增大缓冲区阈值的大小 （考虑剩余的空间是不是够系统使用）
3、对输出的进行压缩（压缩-解压的过程会消耗CPU）

5.如何设置ReduceTask的数量
reducetask的设置：在驱动类中添加 job.setNumReduceTasks(2);
6.combiner的作用
Map结束后，在Map端进行局部聚和。
作用：较少网络传入次数，降低了网络开销。
7.combiner运行在MapReduce的哪一端？
Map端。在Map端中shuffle中。
8.Maptask的数量是可以人为设置的吗？
不可以，MapTask数量决定数据
9.Shuffle阶段的Partition分区算法是什么
计算逻辑：对map输出的key 取哈希值，用这个哈希值与reducetask的值取余。
余几，就将这个key，value放在对应的分区编号里（分区有多个编号）
9.Split逻辑切分数据，节分大小是多大？
128M，默认一个block块对应一个split切片
11内存角度介绍Map的输出到Reduce的输入的过程。
1.Map 输出数据到内存:
map输出的数据写入环形缓冲区（内存），缓冲区的默认大小是100M（可修改）。当数据达到阈值（默认0.8-可修改）时，环形缓冲区进行flash,
环形缓冲区：数据在输出的同时，数据也可以写入空余的空间内。
当flash的数据个数达到一定的数量时（默认4个）。对数据进行合并（merge）。
2:Reduce在Map拷贝数据
Map 输出的结果写入本地，reduce主动发出拷贝进程到Map端拷贝数据。
reduce获取大数据后，将数据写入内存，当数据达到阈值时进行flash.
当flash的个数达到一定的量时，进行合并，最终发送给reduce
12.最优的Map效率是什么？
Map端的最高效率:尽量减少环形缓冲区flush的次数（减少磁盘IO的使用次数）
1、加大环形缓冲区的内存
2、增大缓冲区阈值的大小 。
3、对输出的进行压缩。
13.最优的reduce是什么？
1.尽量减少环形缓冲区flush的次数
2.尽量将所有的数据在内存计算。
14.在MapReduce阶段，有哪些优化的点？（至少两个点）
1、加大环形缓冲区的内存
2、增大缓冲区阈值的大小 （考虑剩余的空间是不是够系统使用）
3、对输出的进行压缩（压缩-解压的过程会消耗CPU）
15.集群优化的核心思路是什么？
在网络带宽，磁盘IO是瓶颈的前期下
能不使用IO网络就不使用，在必须使用的前提下，能少用就少用。
所有的只要能够减少网络带宽的开销，只要能够减少磁盘IO的使用的次数的配置项，都是集群调优的可选项。
（可选项包括：软件层面【系统软件和集群软件】，硬件层面，网络层面）
hive
1、什么是Hive
Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供类SQL查询功能（HQL）
2、Hive的意义（最初研发的原因）
避免了去写MapReduce，提供快速开发的能力，减少开发人员的学习成本。
3、Hive的内部组成模块，作用分别是什么
1．元数据：Metastore
元数据包括：表名、表所属的数据库（默认是default）、表的拥有者、列/分区字段、表的类型（是否是外部表）、表的数据所在目录等；
默认存储在自带的derby数据库中，推荐使用MySQL存储Metastore 元数据存储
（1）解析器（SQL Parser）：解析HQL语义
（2）编译器（Physical Plan）：将HQL根据语义转换成MR程序
（3）优化器（Query Optimizer）：对逻辑执行计划进行优化。（对MR程序进行优化）
（4）执行器（Execution）：把任务提交到hadoop集群
4、Hive支持的数据格式
可支持Text，SequenceFile，ParquetFile，ORC格式RCFILE等
5、进入Hiveshell窗口的方式
1.hive
2. 启动服务 hiveserver2
beeline
! connect jdbc:hive2://主机名:10000
6、Hive数据库、表在HDFS上存储的路径是什么
/user/hive/warehouse
7、like与rlike的区别
like的内容不是正则，而是通配符。
rlike的内容可以是正则，正则写法与Java一样。
8、内部表与外部表的区别
删除内部表会直接删除元数据（metadata）及存储数据；
删除外部表仅仅会删除元数据，HDFS上的文件并不会被删除；
9、分区表的优点是，分区字段的要求是
1.提高特定（指定分区）查询分析的效率
2.分区字段的要求：分区字段不能出现在表中已有的字段内
10、分桶表的优点是，分桶字段的要求是
1.使取样（sampling）和join 更高效
2.分桶字段的要求：分桶字段必须是表中已有的字段
11、数据导入表的方式 有5种方式
1、直接向分区表中插入数据
2、通过查询插入数据
3、多插入模式
4、查询语句中创建表并加载数据
5、创建表时通过location指定加载数据路径
12、数据导出表的方式
有7种方式
1 将查询的结果导出到本地
2 将查询的结果格式化导出到本地
4、Hadoop命令导出到本地
5、hive shell 命令导出
3、将查询的结果导出到HDFS上(没有local)
6、export导出到HDFS上
7、sqoop 导出数据（后面单独学）
13、order by与sort by的区别
order by 是全局排序，一个MapReduce，而 sort by 是局部分区内部进行排序
14、where 与 having的区别
1.where是作用在表的所有字段，having是作用在查询的字段上。
2.在where子句中不能使用聚组函数，在having语句中可以使用聚组函数
15、distribute by何时使用，通常与哪个联合使用
按照指定的字段进行分区时，对数据进行分区时使用
通常和sort by联合使用，Hive要求distribute by语句要写在sort by语句之前
16、Cluster by何时使用
要根据某个字段进行分区，并且以这个字段进行排序时使用Cluster by
17、distribute by+sort by(相同字段) 与Cluster by的区别
cluster by 的结果有限制，只能正序排列，而 distribute by+sort by 可根据需求进行排序
18、hive -e/-f/-hiveconf分别是什么意思
hive -e 后面的参数是‘命令行’
hive -f 后面的参数是文件
hive -hiveconf 设置hive运行时候的参数配置
19、hive声明参数有哪些方式，优先级是什么
配置文件(配置文件参数)
hive -hiveconf (命令行参数)
在hive的shell窗口set(参数声明)
优先级：参数声明>命令行参数>配置文件参数
20、编写hiveUDF代码，方法名称叫什么
evaluate
21、企业中hive常用的数据存储格式是什么？常用的数据压缩格式是什么？
在实际的项目开发当中，hive表的数据存储格式一般选择：orc或parquet。压缩方式一般选择snappy。
22、hive自定义函数的类型
1.UDF(User-Defined-Function) 一进一出
2.UDAF(User- Defined Aggregation Funcation) 聚集函数，多进一出。Count/max/min
3.UDTF(User-Defined Table-Generating Functions) 一进多出，如lateral view explore)
23、Fetch抓取中
设置more有什么效果
执行某些查询语句，不会执行mapreduce程序
设置none有什么效果
执行查询语句，所有的查询都会执行mapreduce程序
24、本地模式有什么好处
在数据量较小时，提高查询效率
原因：查询数据的程序运行在提交查询语句的节点上运行（不提交到集群上运行），
25、当一个key数据过大导致数据倾斜时，如何处理
当发生数据倾斜时，使用局部聚和可以起到性能调优的效果（在Map端进行聚合）
当发生倾斜时，查询语句会转化成至少两个MR程序，第一个程序进行局部聚和，第二个MR程序进行最终聚和。
26、Count(distinct) 的替换语句如何编写
使用嵌套查询
例：select count(distinct id) from score;
转|换
select count(id) from (select id from score group by id) a;
27、如何使用分区剪裁、列剪裁
什么是分区剪裁：需要哪个分区，就获取哪个分区的数据
什么是列剪裁：需要哪个列，就获取哪个列的数据
28、如何理解动态分区调整
以第一个表的分区规则，来对应第二个表的分区规则，将第一个表的所有分区，全部拷贝到第二个表中来，第二个表在加载数据的时候，不需要指定分区了，直接用第一个表的分区即可
29、数据倾斜时，如何将众多数据写入10个文件
1.设置reduce数量10,使用id,对id进行分区distribute by
2.设置reduce数量10，然后使用 distribute by rand()
rand字段为随机数 ，从而随机的将数据写入到文件中
30、reduce数量的计算是什么
决定reduce数量的因素，
参数1：每个Reduce处理的最大数据量
参数2：每个任务最大的reduce数
计算reducer数的公式 N=min(参数2，总输入数据量/参数1)
31、并行执行有什么好处
在没有依赖的前提下，开启并行执行（多任务多阶段同时执行），从而起到优化执行效率的作用
32、严格模式不能执行哪些命令
1、用户不允许扫描所有分区
2、使用了order by语句的查询，要求必须使用limit语句
3、限制笛卡尔积的查询
33、JVM重用有什么好处
重复利用JVM，以减少JVM开启和关闭的次数，减少任务开销，提高效率
34、什么是MR本地计算
数据存储后，计算这批数据的程序已经写完，程序在进行分发时，优先将程序分发到程序所用到数据所在的节点。
35、先join后过滤的优化方案
先过滤后关联（join）
例如：SELECT a.id FROM bigtable a LEFT JOIN ori b ON a.id = b.id WHERE b.id <= 10;
优化方案：
1、SELECT a.id FROM ori LEFT JOIN bigtable b ON (b.id <= 10 AND a.id = b.id);
2、SELECT a.id FROM bigtable a RIGHT JOIN (SELECT id FROM ori WHERE id <= 10 ) b ON a.id = b.id;
36、影响Map数量的因素
当文件大小很小时，影响map的数量的因素是文件的个数
当文件大小很大时，影响map的数量的因素是数据块的数量
37、什么是MR本地模式
任务提交时，运行在提交HQl 所在的节点，不提交到集群。（本地计算提交到集群。本地模式不提交到集群）
hbase
1.HBase的基本介绍
a.Hbase是建立在hdfs之上的一个数据库，
b.不支持join等SQL复杂操作
c.支持的数据类型：byte[]，
d.依靠横向扩展，一个表可以有上十亿行，上百万列。
e.面向列(族)的存储和权限控制
f.对于为空(null)的列，并不占用存储空间，是一个稀疏表。
2.HBASE的适用场景
海量数据、精确查询、快速返回
海量数据：指的是数据量的背景
精确查询：业务场景
快速返回：是业务对时效性的要求
3.Hbase和Hadoop之间的关系
HDFS：
海量数据存储，适合一次性扫描大量数据。
适合一次写入多次读取
不适合频繁更新的数据
HBASE：
适用一次扫描少量数据。
适合多次写入多次读取
支持数据更新
支持删除数据
4.Hbase与RDBMS的关系
RDBMS ：
支持SQL查询
支持事务
支持Join
HBASE ：
不支持SQL查询
不支持事务
不支持Join
5. Hbase详细架构
Client：
访问数据的入口，包含访问hbase的API接口,维护着一些cache来加快对hbase的访问
Zookeeper：
1.zookeeper的选举机制保证任何时候，集群中只有一个master
2.实时监控Region Server的状态，将Region server的上线和下线信息实时通知给Master
3.存储Hbase的schema
4.存贮所有Region的寻址入口
Master：（说明：Hmaster短时间下线，hbase集群依然可用，长时间不行。）
1.为Region server分配region
2.负责region server的负载均衡
3.发现失效的region server并重新分配其上的region
4.处理schema（元数据）更新请求
Region server：
1.Region server维护Master分配给它的region，处理对这些region的IO请求
2.Region server负责切分在运行过程中变得过大的region
6.列族Column Family
列族是表的schema的一部分，而列不是。（schema包含表名和列族）
每个列都所属于某一个列族。一个列族可以包含多个列。一个列族与列的关系是一对多。
7.时间戳
标记一个数据的不同版本，时间戳可以由hbase(在数据写入时自动 )赋值，hbase支持工程师自己定义时间戳。每个 cell中，不同版本的数据按照时间倒序排序
8.hbase本身提供数据回收机制
1．保存数据的最后n个版本
2．保存最近一段时间内的版本
9. Cell
存储数据的最小单位，由{row key, column( = + ), version} 唯一确定的单元确定一个精确的数据
10.VersionNum
数据的版本号，默认值为系统时间戳。
11. hbase物理存储
1.一个regionserver内部可以有多个region,这多个region可能来自多个表或一个表。一个region只能属于一个 regionserver.
2.一个regionserver只有一个HLog
3.一个region里面可以有多个store
4.一个store里面有一个memstore与0个或多个storeFile
5. storeFile的数据类型为HFile
12.region的切分
region按大小分割的(默认10G)。每个表一开始只有一个region，随着数据的增加，一个region逐渐变大，达到 10G，进行分裂，等分成两个region.
13. Memstore与storefile
一个region由多个store组成，每个store包含一个列族的所有数据 Store包括位于内存的memstore和位于硬盘的 storefile
客户端检索数据时，先在memstore找，找不到再找storefile
14.HLog(WAL log)
保证数据完整性
每个Region Server维护一个Hlog,而不是每个Region一个.
Hlog的切分机制
1.当数据写入hlog以后，hbase发生异常。关闭当前的hlog文件
2.当日志的大小达到HDFS数据块的0.95倍的时候，关闭当前日志，生成新的日志
3.每隔一小时生成一个新的日志文件
15.读请求过程
meta表是hbase系统自带的一个表。里面存储了hbase用户表的元信息。
元信息为meta表内记录一行数据是用户表一个region的start key 到endkey的范围。
meta表存储在regionserver里。 具体存储在哪个regionserver里？zookeeper知道。
过程:
1.客户端到zookeeper询问meta表在哪
2.客户端到meta所在的节点（regionserver）读取meta表的数据
3.客户端找到region 获取region和regionserver的对应关系，直接到regionserver读取region数据
16.HBase的特征
1.海量存储:Hbase适合存储PB级别的海量数据，在几十到百毫秒内返回数据。
2.列式存储:这里的列式存储其实说的是列族存储列族理论上可以很多，但实际上建议不要超过6个
3.极易扩展:处理能力（RegionServer）的扩展，是基于存储的扩展（HDFS）
hbase在最初设计的时候就考虑了扩展性。
4.稀疏:在列数据为空的情况下，是不会占用存储空间的。
17. 写请求过程
1.Client先访问zookeeper，找到Meta表，并获取Meta表元数据。确定当前将要写入的数据所对应的HRegion和 HRegionServer服务器。
2.Client向该HRegionServer服务器发起写入数据请求。
3.Client先把数据写入到HLog，以防止数据丢失，然后将数据写入到Memstore。
4.Memstore达到阈值，会把Memstore中的数据flush到Storefile中
5.当Storefile越来越多，达到一定数量时，会触发Compact合并操作，将多个小文件合并成一个大文件。
6.Storefile越来越大，Region也会越来越大，达到阈值后，会触发Split操作，变成两个文件。

说明：hbasez 支持数据修改（伪修改），实际上是相同rowkey数据的添加。hbase只显示最后一次的添加
18. region的分配过程
前提：一个region只能分配给一个region server
1.master记录了当前有哪些可用的region server。以及当前哪些region分配给了哪些region server，哪些region还没有分配。
2.当需要分配的新的region，并且有一个region server上有可用空间时，master就给这个region server发送一个装载请求，把region分配给这个region server。
3.region server得到请求后，就开始对此region提供服务。
19. region server上线
前提：master使用zookeeper来跟踪region server状态。
1.当某个region server启动时，首先在zookeeper上的/hbase/rs目录下建立代表自己的znode。
2.master订阅了/hbase/rs目录上的变更消息，当/hbase/rs目录下的文件出现新增或删除操作时，master可以得到来自zookeeper的实时通知。因此一旦region server上线，master能马上得到消息
20.region server下线
前提：master使用zookeeper来跟踪region server状态。
1.当region server下线时，它和zookeeper的会话断开。
2.zookeeper而自动释放代表这台server的文件上的独占锁（znode）
3.zookeeper将变化发送给master
4.master 将挂掉的region server的region分配给其它还活着的regionserver
21.Hmaster的上线
前提：hbase集群中可以设置多个Hmaster，真正对外提供服务的只有一个
1.从zookeeper上获取唯一 一个代表active master的锁，用来阻止其它master成为真正的master。
2.扫描zookeeper上的/hbase/rs节点，获得当前可用的region server列表。
3.master和每个region server通信，获得当前已分配的region和region server的对应关系。 4.master扫描.META.表，计算得到当前还未分配的region，将他们放入待分配region列表。
22.Hmaster下线后的影响
master只维护表和region的元数据，不参与表数据IO的过程，所以master下线短时间内对整个hbase集群没有影响。表的数据读写还可以正常进行。
无法创建删除表，无法修改表的schema，无法进行region的负载均衡，无法处理region 上下线，无法进行region的 合并（region的split可以正常进行） 当hmaster下线后，启动Zookeeper的选举机制，选出新的Hmaster,新的Hmaster上线，执行上线流程。
23.flush机制
全局的memstore的flush机制默认为堆总大小（多个memstore 多个region）的40%，超过该大小会触发flush到磁盘的操作，会阻塞客户端读写，flush将所有的memstore全部flush.
单个的memstore默认为数据达到128M或1h将会flush.

hbase不建议配置过多列族：过多的列族会消耗大量的内存，同时数据在flush时消耗磁盘IO. 一个regionserver续写操作可用堆内存的80%，读取占用40% ，写入占用40%。这两个参数直接影响hbase读写性能。
24.compact机制
默认3个小的storeFile文件达到三个，合并成大的Storefile文件。
25.split机制
默认一个HFile达到10G的时候就会进行切分
26.hbase预分区的优点
1.增加数据读写效率:数据分布在多台regionserver节点
2.负载均衡，防止数据倾斜:当数据时离散的发送时，预分区可以解决数据倾斜
3.方便集群调度region: 分布在多个节点便于调度
27.rowKey的获取方式
1.通过rowkey直接查找
2.通过startkey endkey 范围查找
3.全表扫描
28.rowkey
最大长度是 64KB，完全可以自行设计。Hbase会对表中的数据按照rowkey排序（字典序）,建议越短越好(在保证业务需求的前提下)，不要超过16个字节.
29.rowkey散列原则
建议将rowkey的高位(左边)作为散列字段， 低位（右边）放时间字段，这样将提高数据均衡分布在每个 RegionServer，以实现负载均衡的几率。
若不按照此原则：
让时间戳作为高位，数据将按照时间的顺序进行存储可能会引发热点问题
30.什么是热点问题
让时间戳作为高位得前提下，有一点时间业务数据爆炸增长时，这个阶段的数据将存储在少数的节点上。
举例：如果以手机号为高位数据什么样的情况下会出现热点问题？
31.如何解决热点问题
原则：将分散的数据，放在rowkey的高位
1.哈希（随机数）:将哈希值放在高位
2.反转:反转固定长度或者数字格式的数据（时间戳反转、手机号反转，订单号反转）
3.加盐:本质时是加随机数，并且放在高位。
Zookeeper：
1、zk的选举机制 保证任何时候，集群中只有一个master
2、 实时监控Region Server的状态，将Region server的上线和下线信息实时通知给Master
3、 存贮所有Region的寻址入口
4 、存储Hbase的schema,包括有哪些table，每个table有哪些column family列族
yarn
1、什么是Yarn
通用资源管理系统和调度平台
2、Yarn特点：
1、支持多计算框架
2、资源利用率高，运行成本低，数据共享。
3、Yarn的意义：
降低了企业硬件的成本（多个集群变成一个集群），减少了资源的了浪费，运营成本低。

4、Yarn基本组成
ResourceManager ：一个集群资源调度的管理者
NodeManager ：一个节点资源调度的管理者（集群各个节点资源的工作者）
ApplicationMaster ： 一个计算任务的管理者
Container ： 容器（cpu 和 内存）
5、Yarn提交任务的流程

1、client向RM提交应用程序，其中包括启动该应用的ApplicationMaster的必须信息，例如ApplicationMaster程序、启动ApplicationMaster的命令、用户程序等。
2、ResourceManager启动一个container用于运行ApplicationMaster。
3、启动中的ApplicationMaster向ResourceManager注册自己，启动成功后与RM保持心跳。
4、ApplicationMaster向ResourceManager发送请求，申请相应数目的container。
5、申请成功的container，由ApplicationMaster进行初始化。container的启动信息初始化后，AM与对应的NodeManager通信，要求NM启动container。
6、NM启动启动container。
7、container运行期间，ApplicationMaster对container进行监控。container通过RPC协议向对应的AM汇报自己的进度和状态等信息。
8、应用运行结束后，ApplicationMaster向ResourceManager注销自己，并允许属于它的container被收回。
6、Yarn的调度方式
FIFO Scheduler ： 先进先出（先来后到的顺序）
Capacity Scheduler：容量调度
Fair Scheduler：公平调度
1、先进先出：优先提交的，优先执行，后面提交的等待。（火车过隧道）。
2、容量调度：允许创建多个任务对列，每个队列使用所有资源的一部分。多个任务对列可以同时执行。但是一个队列内部还是先进先出。CDH默认的调度器。
3、公平调度：第一个程序在启动时可以占用其他对列的资源（100%占用），当其他对列有任务提交时，占用资源的对列需要将资源还给该任务。还资源的时候，效率比较慢。
7、参数yarn.scheduler.fair.allow-undeclared-pools的作用是？（true/false）
如果提交一个任务没有到任何的队列，是否允许创建一个新的队列，默认为true
8、参数yarn.scheduler.fair.user-as-default-queue的作用是？（true/false）
是否提交到默认队列 ，以用户名为默认对列
9、介绍一下hadoopHA
1、HadoopHA 包括两个部分，NameNodeHA和ResourceManagerHA
2、hadoop HA解决了早期版本中的NN单点问题。YarnHA解决了ResourceManager的单点问题
3、NNHA方案中包含两个NN,一个是active状态，一个是StandBy状态。每个NN分配在两个完全独立的服务器中。每个NN所在的节点需配置一个ZKFC。
4、两个NN之间的元数据同步使用JN传递。
10、ZKFC作用:
监控NN所在节点的硬件设备、软件（NN）、操作系统，同时维护与ZK的通信。主要用于两个NN之间状态切换时的信息传递。

11、NN Active 状态和StandBy状态的确认：
两个NN到ZK集群注册一个临时的ZNode,哪个先注册成功，哪个就是Active,另外一个就是StandBy.
12、ActiveNN宕机后故障如何转移
当ActiveNN节点故障 ActiveZKFC通知ZK删除临时ZNode StandBy状态的ZKFC订阅这个临时ZNode的变换，若ZNode消失，StandBy状态的ZKCF立刻通知StandBy NN StandBy NN 远程登录ActiveNN，执行Kill -9 ActiveNN StandBy NN通知StandBy ZKFC去ZK上注册临时ZNode，注册成功切换为active状态。
13、两个NN之间的元数据信息如何实现快速同步？
ActiveNN实时将FSimage和日志接入JN（高效的存储系统）。StandByNN实时获取JN内部的数据，实现两个节点的实时元数据同步。
redis
1、什么是redis
Redis是一个基于内存的使用C语言编写的key-value开源的NOSQL存储系统。不支持SQL语句。
2、Redis持久化数据的方式有哪些
1、RDB 触发式的持久化
在配置文件中添加：save 5 2 (5秒中 有2次操作便会出发持久化)
2、AOF 日志形式的持久化
每秒钟存储一次
3、解决IT行业数据读取瓶颈的终极方案
读写分离
4、Redis如何实现读写分离？
Redis本身支持读写分离，主节点可以读数据、可以写数据、从节点只能读数据。配置redis的主从复制机制可实现读写分离。
5、介绍哨兵机制
解决得问题：主节点宕机导致数据无法写入redis
在redis的主从复制结构中，若没有哨兵机制，主节点宕机，将无法写数据到redis集群。
配置哨兵机制，当主节点当即后，哨兵会在原本为从节点的服务器中选取一个作为主节点，接受外部数据的写入。以此实现当主节点宕机后redis依然可以写入数据。
Redis默认有16个数据库
使用 select N (0-15)实现数据库的切换
flushdb 清空一个数据库内的所有数据
flushall 清空所有数据库内的所有数据
kafka
Kafka知识点总结
Kafka的流程：
1、Kafka生态系统四大角色，生产者(Producer)、kafka集群(Broker)、消费者(Consumer)、zookeeper
2、每个消费者都必须属于一个消费组，一个组内的消费者可以多个。
3、一个Topic可以有1到多个多个分区（Partition）
4、一个分区可以有1到多个segment。
5、每个segment可以有由一个log和一个index组成。
6、被复制的分区叫做主副本（Leader）,复制出来的叫做从副本（Follower）
7、生产者只往主副本写数据，消费者只在主副本拉取数据。
8、从副本只做数据备份，不做数据读写。
【红色字体表示隐藏知识点】
9、一个分区内的一条数据，只能被一个消费组内的一个消费者消费。
10、消费者的最大并发度由topic的分区数量决定
11、分区副本的数量必须小于等于broker的数量
12、一个topic内的多个分区，每个分区只是所有数据的一部分。所有分区的数据累加到一起是这个topic的全部数据。
13、zookeeper中记录了broker的id 、消费者消费数据的offset,消费者与partition的对应关系（ConsumerA—> Partition-0, ConsumerB—> Partition-1）
1、什么是kafka
是一个分布式，分区的，多副本的，多订阅者的消息发布订阅系统。

2、kafka的使用场景
应用耦合、异步处理、限流削峰、消息驱动的系统
3、kafka优缺点
优点：可靠性强（分布式-分区-副本）、扩展性强（可伸缩）、性能高（数据读写）、耐用性强（数据持久化）、时效性强。
缺点：由于是批量发送，数据并非真正的实时。
仅支持同一分区内消息有序，无法实现全局消息有序；
有可能消息重复消费；
依赖zookeeper进行元数据管理。
4、Kafka架构（流程）
生产者、kafka集群、消费者、zookeeper
5、Kafka架构（API）
生产者、消费者、StreamAPI、ConnectAPI
6、Topic内部有哪些组成？
每个Topic包含一个或者多个Partition，一个partition当中存在多个segment文件段，每个segment分为两部分，.log文件和.index文件。
7、分区和消费组内的消费者之间的关系有哪些情况？
Partition = 消费任务的并发度=刚刚好，每个任务读取一个partition数据
Partition > 消费任务的并发度=有部分消费任务读取多个分区的数据
Partition < 消费任务的并发度=有部分消费任务空闲(可以创建多于分区的消费者数量)
8、分区数、消费者与读取效率之间的关系
分区数越多，同一时间可以有越多的消费者来进行消费，消费数据的速度就会越快，提高消费的性能
9、副本数与broker之间的关系
数据副本（包含本身）数一般情况下小于等于broker的个数
10、什么是主/从副本
被复制的分区叫做主副本（Leader）,复制出来的叫做从副本（Follower）
11、主/从复本的作用是什么
主副本负责数据的读写。
从副本只做数据备份，不做数据读写。

12、Lsr是什么？
ISR是一组与leaders完全同步的消息副本（包括leaders本身）。

13、生产者生产数据到kafka集群，数据到分区的方式
a)没有指定分区编号，没有指定key,时采用轮询方式存户数据
b)没有指定分区编号，指定key时，数据分发策略为对key求取hash值，这个值与分区数量取余，于数就是分区编号。
c)指定分区编号，所有数据输入到指定的分区内
d)自定义分区
14、Consumer消费数据的流程
1、首先Consumer连接指定的Topic partition所在leader broker，使用折半/二分查找，先确定数据所在的segment。
2、确定在哪个segment后，使用确定的segment内的index文件找到数据具体的位置采用pull方式从kafkalogs中获取消息。
15、Kafka中的数据删除机制是什么？
1、时间：默认存储168小时（一周）
2、数据的大小：默认 -1 （不删除），可以自行设置。
16、Kafka如何保证数据不丢失
1、生产者如何保证数据不丢失？？ 通过ack 机制确保数据不丢失。
2、kafka集群如何保证数据不丢失？？ 通过数据副本保证数据不丢失。
3、消费者如何保证数据不丢失？？ 通过维护数据的offset 保证数据不丢失。
17、Kafka高性能的原因有哪里？
顺序读写、分区、批量发送、数据压缩
18、Kafka高效查询数据的有哪些原因
1、Kafka把topic中一个parition大文件分成多个小文件段，通过多个小文件段，就容易定期清除或删除已经消费完文件，减少磁盘占用。
2、通过索引信息可以快速定位message和确定response的最大大小。
3、通过index元数据全部映射到memory，可以避免segment file的IO磁盘操作。
4、通过索引文件稀疏存储，可以大幅降低index文件元数据占用空间大小。
19、如何从Kafka得到准确的信息(不是重读数据)?
在数据生产过程中避免重复。
在数据消耗期间避免重复。
20、Kafka的设计是什么样的呢？
Kafka将消息以topic为单位进行归纳 将向Kafka topic发布消息的程序成为producers. 将预订topics并消费消息的程序成为consumer. Kafka以集群的方式运行，可以由一个或多个服务组成，每个服务叫做一个broker. producers通过网络将消息发送到Kafka集群，集群向消费者提供消息
21、数据传输的事物定义有哪三种？
1、最多一次:消息不会被重复发送，最多被传输一次，但也有可能一次不传输
可能会造成数据丢失。
3、最少一次: 消息不会被漏发送，最少被传输一次，但也有可能被重复传输.
可能会造成数据的重复消费。
3、精确的一次（Exactly once）: 不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次，这是大家所期望的
22、Kafka判断一个节点是否还活着有哪些条件？
1、节点必须可以维护和ZooKeeper的连接，Zookeeper通过心跳机制检查每个节点的连接
2、如果节点是个follower,他必须能及时的同步leader的写操作，延时不能太久
23、Kafka 与传统消息系统之间有哪些区别？
1、Kafka 持久化日志：这些日志可以被重复读取和无限期保留
2、Kafka 是一个分布式系统：它以集群的方式运行，可以灵活伸缩，在内部通过复制数据提升容错能力和高可用性
3、Kafka 支持实时的流式处理
24、Kafka创建Topic时将分区放置到不同的Broker的策略是什么？
前提：副本因子不能大于 Broker 的个数；
第一个分区（编号为0）的第一个副本放置位置是随机从 brokerList 选择的；
其他分区的第一个副本放置位置相对于第0个分区依次往后移。
例如：有5个 Broker，5个分区，假设第一个分区放在第四个 Broker 上，那么第二个分区将会放在第五个 Broker 上；第三个分区将会放在第一个 Broker 上；第四个分区将会放在第二个 Broker 上，第五个分区将会放在第三个 Broker 上；
25、Kafka新建的分区会在哪个目录下创建
若 log.dirs 参数只配置了一个目录，那么分配到各个 Broker 上的分区将在这个目录下创建文件夹用于存放数据。
若 log.dirs 参数配置了多个目录，那么 Kafka 会在含有分区目录总数最少的文件夹中创建新的分区目录，分区目录名为 Topic名+分区ID。注意（不是磁盘使用量最少的目录）
26、partition的数据如何保存到硬盘
topic中的多个partition以文件夹的形式保存到broker，每个分区序号从0递增， 且消息有序 Partition文件下有多个segment（xxx.index，xxx.log） segment 文件里的 大小和配置文件大小一致可以根据要求修改 默认为1g 如果大小大于1g时，会滚动一个新的segment并且以上一个segment最后一条消息的偏移量命名
27、kafka的ack机制
request.required.acks有三个值 0 1 -1
0:生产者不会等待broker的ack，这个延迟最低但是存储的保证最弱当server挂掉的时候就会丢数据
1：服务端会等待ack值 leader副本确认接收到消息后发送ack但是如果leader挂掉后他不确保是否复制完成新leader也会导致数据丢失
-1：同样在1的基础上 服务端会等所有的follower的副本受到数据后才会受到leader发出的ack，这样数据不会丢失
28、Kafka的消费者如何消费数据
消费者每次消费数据的时候，消费者都会记录消费的物理偏移量（offset）的位置 等到下次消费时，他会接着上次位置继续消费。同时也可以按照指定的offset进行重新消费。
29、如何使kafka集群内的数据是有序的？
只创建一个分区。（但是实际这样会存在性能问题，具体业务具体分析后确认。）
30、Zookeeper汇总保留了哪些数据？
1、消费者提交的偏移量。
2、分区和消费者的所有者关
3、broker id
说明：leader检测、分布式同步、配置管理、识别新节点何时离开或连接、集群、节点实时状态
31、kafka consumer 什么情况会触发再平衡reblance?
1、一旦消费者加入或退出消费组，导致消费组成员列表发生变化，消费组中的所有消费者都要执行再平衡。
2、订阅主题分区发生变化，所有消费者也都要再平衡。
32、描述下kafka consumer 再平衡步骤?
1、关闭数据拉取线程，清空队列和消息流，提交偏移量；
2、释放分区所有权，删除zk中分区和消费者的所有者关系；
3、将所有分区重新分配给每个消费者，每个消费者都会分到不同分区；
4、将分区对应的消费者所有关系写入ZK，记录分区的所有权信息；
5、重启消费者拉取线程管理器，管理每个分区的拉取线程。
33手动提交offset有什么好处？？
使更新offset更及时，避免因offset更新不及时导致重复消费数据的问题。
34、为什么kafka中的数据需要定期删除或合并？
Kafka只用于做数据的临时存储、临时缓冲，不是永久存储（永久性存储使用HDFS）。
spark
什么是Spark
基于内存的，用于大规模数据处理（离线计算、实时计算、快速查询（交互式查询））的统一分析引擎。
Spark特点
快：
Spark计算速度是MapReduce计算速度的10-100倍
易用：（算法多）
MR支持1种计算模型，Spsark支持更多的计算模型。
通用：
Spark 能够进行离线计算、交互式查询（快速查询）、实时计算、机器学习、图计算等
兼容性：
Spark支持大数据中的Yarn调度，支持mesos。可以处理hadoop计算的数据。
Spark运行模式
1.local本地模式(单机)–开发测试使用
2.standalone独立集群模式–开发测试使用
3.standalone-HA高可用模式–生产环境使用
4.on yarn集群模式–生产环境使用
5.on cloud集群模式–中小公司未来会更多的使用云服务

Spark编写代码

1、创建一个 Sparkconf对象，设置app名称
2、创建一个SparkContext,
3、读取数据，对数据进行计算
4、保存数据
SparkCore
什么是RDD
弹性分布式数据集（数据存储在内存），一个不可变、可分区、里面的元素可并行计算的集合
RDD的主要属性
1、数据集的基本组成单位是一组分片(Partition)或一个分区(Partition)列表
每个分片都会被一个计算任务处理，分片数决定并行度。
2、一个函数会被作用在每一个分区。
3、一个RDD会依赖于其他多个RDD，RDD的每次转换都会生成一个新的RDD
RDD的算子分为两类:
1.Transformation转换操作:返回一个新的RDD
2.Action动作操作:返回值不是RDD
惰性计算，遇到Transformation不计算，遇到Action在真正计算。
Rdd数据持久化什么作用？
1、对多次使用的rdd进行缓存，缓存到内存，当后续频繁使用时直接在内存中读取缓存的数据，不需要重新计算。 (Persist、Cache)
2、将RDD结果写入硬盘（容错机制），当RDD丢失数据时，或依赖的RDD丢失数据时，可以使用持久化到硬盘的数据恢复。(MEMORY_ONLY（默认）、MEMORY_AND_DISK、DISK_ONLY)
SparkContext.setCheckpointDir(“目录”) //HDFS的目录
RDD.checkpoint()
cache和Checkpoint的区别(看此)(猜个旁应特)
位置
Persist 和 Cache将数据保存在内存
Checkpoint将数据保存在HDFS
生命周期
Persist 和 Cache 程序结束后会被清除或手动调用unpersist方法。
Checkpoint永久存储不会被删除。
RDD依赖关系（血统Lineage）
Persist和Cache，不会丢掉RDD间的依赖链/依赖关系
Checkpoint会斩断依赖链

什么是宽窄依赖
窄依赖:父RDD的一个分区只会被子RDD的一个分区依赖
宽依赖:父RDD的一个分区会被子RDD的多个分区依赖(涉及到shuffle)
什么是DAG
DAG：指的是数据转换执行的过程，有方向，无闭环(其实就是RDD执行的流程)
DAG边界
开始:通过SparkContext创建的RDD
结束:触发Action，一旦触发Action就形成了一个完整的DAG
说明：
一个Spark应用中可以有一到多个DAG，取决于触发了多少次Action
一个DAG中会有不同的阶段/stage，划分阶段/stage的依据就是宽依赖
一个阶段/stage中可以有多个Task，一个分区对应一个Task
Spark概念
1.Application：指的是用户编写的Spark应用程序/代码，包含了Driver功能代码和分布在集群中多个节点上运行的Executor代码。
2.Driver：Spark中的Driver即运行上述Application的Main()函数并且创建SparkContext，SparkContext负责和ClusterManager通信，进行资源的申请、任务的分配和监控等
3.Cluster Manager：指的是在集群上获取资源的外部服务，Standalone模式下由Master负责，Yarn模式下ResourceManager负责;
4.Executor：是运行在工作节点Worker上的进程，负责运行任务，并为应用程序存储数据，是执行分区计算任务的进程；
5.RDD：Resilient Distributed Dataset弹性分布式数据集，是分布式内存的一个抽象概念；
6.DAG：Directed Acyclic Graph有向无环图，反映RDD之间的依赖关系和执行流程；
7.Job：作业，按照DAG执行就是一个作业；Job==DAG
8.Stage：阶段，是作业的基本调度单位，同一个Stage中的Task可以并行执行，多个Task组成TaskSet任务集
9.Task：任务，运行在Executor上的工作单元，一个Task计算一个分区，包括pipline上的一系列操作
Spark执行任务的基本流程

1.Spark应用被提交–>SparkContext向资源管理器注册并申请资源 (??) -->启动Executor
2.RDD–>构建DAG–>DAGScheduler划分Stage形成TaskSet–>TaskScheduler提交Task–>Worker上的Executor执行Task

累加器的作用
累加器accumulators:累加器支持在所有不同节点之间进行累加计算

广播变量的作用
在每个机器上缓存一份、不可变的、只读的、相同的变量，该节点每个任务都能访问。起到节省资源的作用，和优化的所用。
SparkSQL基本介绍
什么是SparkSQL?
用于处理结构化数据的Spark模块。
SparkSQL底层的数据抽象
DataFrame和DataSet
Hive和SparkSQL的对比
Hive是将sql转化成MapReduce进行计算（降低学习成本、提高开发效率）
SparkSQL是将sql转化成rdd集进行计算（降低学习成本、提高开发效率）
什么是DataFrame？？
DataFrame是以RDD为基础的带有Schema元信息的分布式数据集。

什么是DataSet??
含有类型信息的DataFrame就是DataSet
（DataSaet=DataFrame+类型= Schema+RDD*n+类型）
SparkSQL查询数据的形态
1、类似方法调用，领域特定语言(DSL)。
personDF.select(" i d " , “id”,“id”,“name”," a g e " + 1 ) . f i l t e r ( “age”+1).filter(“age”+1).filter(“age”>25).show
2、SQL语句
spark.sql(“select * from personDFT where age >25”).show
添加Schema的方式
第1种：指定列名添加Schema
第2种：通过StructType指定Schema
第3种：编写样例类，利用反射机制推断Schema
指定列名添加Schema代码流程
1 创建sparksession
2 创建sc
3 读取数据并加工
4 设置表结构 ttRDD.toDF(“id”,“name”,“age”)
5 注册成表并查询
6 关闭sc sparksession
通过StructType指定Schema代码流程(StructType是抓个特不)
1 创建sparksession
2 创建sc
3 读取数据并加工
4 设置表结构
types.StructType(
// 字段类型 （字段名，字段类型，是否为空）
List(StructField(“id”,IntegerType,true)
)
)
5 创建DS DF
val ttDF: DataFrame = spark.createDataFrame(RowRDD,structTable)
6 注册成表并查询
7 关闭sc sparksession
利用反射机制推断Schema代码流程
准备样例类
1 创建sparksession
2 创建sc
3 读取数据并加工
val PersonRDD: RDD[Person] = ttRDD.map(z=>Person(z(0).toInt,z(1),z(2).toInt))
4 RDD转DF
val personDF: DataFrame = PersonRDD.toDF()
5 注册成表并查询
6 关闭sc sparksession
RDD、DF、DS三者之间的转化
转换成RDD .rdd
转换成DF .toDF()
转换成DS
RDD->DS .toDS()
DF->DS .as[Person]

Spark SQL自定义函数

spark.udf.register(“toUpperAdd123”,(str:String)=>{
//根据业务逻辑对数据进行处理
//str.toUpperCase()+ " 123"
//str.length10
str.length10/2/2.toDouble
})

开窗函数的作用
既显示聚集前/排序前的原始的数据，又显示聚集后/排序后的名次 的数据。

开窗函数的分类
1、聚和开窗函数
聚合函数(列) OVER(选项)，这里的选项可以是PARTITION BY 子句
2、排序聚和函数
排序函数(列) OVER(选项)，这里的选项可以是ORDER BY 子句，也可以是 OVER(PARTITION BY 子句 ORDER BY 子句)

聚和开窗函数
select name, class, score, count(name) over() name_count from scores
select name, class, score, count(name) over(PARTITION BY class) name_count from scores
排序聚和函数
select name, class, score, row_number() over(order by score) rank from scores
select name, class, score, row_number() over(partition by class order by score) rank from scores
RANK跳跃排序
select name, class, score, rank() over(order by score) rank from scores
select name, class, score, rank() over(partition by class order by score) rank from scores

DENSE_RANK连续排序
select name, class, score, dense_rank() over(order by score) rank from scores

NTILE分组排名
select name, class, score, ntile(6) over(order by score) rank from scores

什么是Spark Streaming (spark是吹明)

Spark Streaming是一个基于Spark Core之上的实时计算框架
什么是DStream(DS追们)
代表持续性的输入的数据流和经过各种Spark算子操作后的输出的结果数据流。
本质上就是按照时间间隔划分成一批一批的连续的RDD
阐明RDD、DataFrame、DataSet、DStream数据抽象之间的关系。

DStream=RDD1(t1)+ RDD2(t2)+ RDD3(t3)+ RDD4(t4)+….
DataSet = DataFrame+类型 = RDD+结构+类型
DataFrame = RDD+结构

SparkStreaming代码过程(spark是吹明)
1 创建sparkConf
2 创建一个sparkcontext
3 创建streamingcontext
4 接收数据并根据业务逻辑进行计算
5 开启计算任务
6 等待关闭
窗口宽度和滑动距离的关系

0.8版本SparkStreaming集成kafka是的差异
Receiver接收方式
1、多个Receiver接受数据效率高，但有丢失数据的风险。
2、开启日志（WAL）可防止数据丢失，但写两遍数据效率低。
3、Zookeeper维护offset有重复消费数据可能。
4、使用高层次的API
Direct直连方式
1、不使用Receiver，直接到kafka分区中读取数据
2、不使用日志（WAL）机制。
3、Spark自己维护offset
4、使用低层次的API

什么是Structured Streaming (是抓个吹特是吹明)
Structured Streaming是一个基于Spark SQL引擎的可扩展、容错的流处理引擎

Structured Streaming模型(是抓个吹特是吹明)
是一个不断增长的动态表格，新数据被持续不断地添加到表格的末尾
对动态数据源进行实时查询，就是对当前的表格内容执行一次 SQL 查询。

Structured Streaming应用场景(是抓个吹特是吹明)
将数据源映射为类似于关系数据库中的表，（SparkSQL中的DF/DS）
然后将经过计算得到的结果映射为另一张表.