目录
一.Hadoop
1.hdfs写流程
![]()
客户端跟namenode通信请求上传文件，namenode检查目标文件是否已存在，父目录是否存在
namenode返回是否可以上传
client请求第一个 block该传输到哪些datanode服务器上
namenode返回3个datanode服务器ABC
client请求3台dn中的一台A上传数据(本质上是一个RPC调用，建立pipeline)，A收到请求会继续调用B，然后B调用C，将真个pipeline建立完成，逐级返回客户端
client开始往A上传第一个block(先从磁盘读取数据放到一个本地内存缓存)，以packet为单位，A收到一个packet就会传给B，B传给C；A每传一个packet会放入一个应答队列等待应答
当一个block传输完成之后，client再次请求namenode上传第二个block的服务器。
2.hdfs读流程
![]()
client跟namenode通信查询元数据，找到文件块所在的datanode服务器
挑选一台datanode(就近原则，然后随机)服务器，请求建立socket流
datanode开始发送数据(从磁盘里面读取数据放入流，以packet为单位来做校验)
客户端以packet为单位接收，现在本地缓存，然后写入目标文件
3.hdfs的体系结构
hdfs有namenode、secondraynamenode、datanode组成。为n+1模式
NameNode负责管理和记录整个文件系统的元数据
DataNode 负责管理用户的文件数据块，文件会按照固定的大小(blocksize)切成若干块后分布式存储在若干台datanode上，每一个文件块可以有多个副本，并存放在不同的datanode上，Datanode会定期向Namenode汇报自身所保存的文件block信息，而namenode则会负责保持文件的副本数量
HDFS的内部工作机制对客户端保持透明，客户端请求访问HDFS都是通过向namenode申请来进行
secondraynamenode负责合并日志
4.一个datanode 宕机,怎么一个流程恢复
Datanode宕机了后，如果是短暂的宕机，可以实现写好脚本监控，将它启动起来。如果是长时间宕机了，那么datanode上的数据应该已经被备份到其他机器了，那这台datanode就是一台新的datanode了，删除他的所有数据文件和状态文件，重新启动。
5.hadoop 的 namenode 宕机,怎么解决
先分析宕机后的损失，宕机后直接导致client无法访问，内存中的元数据丢失，但是硬盘中的元数据应该还存在，如果只是节点挂了，重启即可，如果是机器挂了，重启机器后看节点是否能重启，不能重启就要找到原因修复了。但是最终的解决方案应该是在设计集群的初期就考虑到这个问题，做namenode的HA。
6.namenode对元数据的管理
namenode对数据的管理采用了三种存储形式：
内存元数据(NameSystem)
磁盘元数据镜像文件(fsimage镜像)
数据操作日志文件(可通过日志运算出元数据)(edit日志文件)
7.元数据的checkpoint
每隔一段时间，会由secondary namenode将namenode上积累的所有edits和一个最新的fsimage下载到本地，并加载到内存进行merge(这个过程称为checkpoint)
![]()
namenode和secondary namenode的工作目录存储结构完全相同，所以，当namenode故障退出需要重新恢复时，可以从secondary namenode的工作目录中将fsimage拷贝到namenode的工作目录，以恢复namenode的元数据
8.yarn资源调度流程
![]()
用户向YARN 中提交应用程序， 其中包括ApplicationMaster 程序、启动ApplicationMaster 的命令、用户程序等。
ResourceManager 为该应用程序分配第一个Container， 并与对应的NodeManager 通信，要求它在这个Container 中启动应用程序的ApplicationMaster。
ApplicationMaster 首先向ResourceManager 注册， 这样用户可以直接通过ResourceManage 查看应用程序的运行状态，然后它将为各个任务申请资源，并监控它的运行状态，直到运行结束，即重复步骤4~7。
ApplicationMaster 采用轮询的方式通过RPC 协议向ResourceManager 申请和领取资源。
一旦ApplicationMaster 申请到资源后，便与对应的NodeManager 通信，要求它启动任务。
NodeManager 为任务设置好运行环境(包括环境变量、JAR 包、二进制程序等)后，将任务启动命令写到一个脚本中，并通过运行该脚本启动任务。
各个任务通过某个RPC 协议向ApplicationMaster 汇报自己的状态和进度，以让ApplicationMaster 随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。在应用程序运行过程中，用户可随时通过RPC 向ApplicationMaster 查询应用程序的当前运行状态。
应用程序运行完成后，ApplicationMaster 向ResourceManager 注销并关闭自己。
9.hadoop中combiner和partition的作用
combiner是发生在map的最后一个阶段，父类就是Reducer，意义就是对每一个maptask的输出进行局部汇总，以减小网络传输量，缓解网络传输瓶颈，提高reducer的执行效率。
partition的主要作用将map阶段产生的所有kv对分配给不同的reducer task处理，可以将reduce阶段的处理负载进行分摊
10.用mapreduce怎么处理数据倾斜问题？
数据倾斜：map /reduce程序执行时，reduce节点大部分执行完毕，但是有一个或者几个reduce节点运行很慢，导致整个程序的处理时间很长，这是因为某一个key的条数比其他key多很多(有时是百倍或者千倍之多)，这条key所在的reduce节点所处理的数据量比其他节点就大很多，从而导致某几个节点迟迟运行不完，此称之为数据倾斜。
(1)局部聚合加全局聚合。
第一次在map阶段对那些导致了数据倾斜的key加上1到n的随机前缀，这样本来相
同的key也会被分到多个Reducer中进行局部聚合，数量就会大大降低。
第二次mapreduce，去掉key的随机前缀，进行全局聚合。
思想：二次mr，第一次将key随机散列到不同reducer进行处理达到负载均衡目的。第
二次再根据去掉key的随机前缀，按原key进行reduce处理。
这个方法进行两次mapreduce，性能稍差。
(2)增加Reducer，提升并行度
JobConf.setNumReduceTasks(int)
(3)实现自定义分区
根据数据分布情况，自定义散列函数，将key均匀分配到不同Reducer
11.shuffle 阶段,你怎么理解的
![]()
shuffle: 洗牌、发牌——(核心机制：缓存，数据分区，排序，Merge进行局部value的合并)；
具体来说：就是将maptask输出的处理结果数据，分发给reducetask，并在分发的过程中，对数据按key进行了分区和排序；
1)Map方法之后Reduce方法之前这段处理过程叫Shuffle
2)Map方法之后，数据首先进入到分区方法，把数据标记好分区，然后把数据发送到 环形缓冲区；环形缓冲区默认大小 100m，环形缓冲区达到80%时，进行溢写；溢写前对数 据进行排序，排序按照对 key的索引进行字典顺序排序，排序的手段快排；溢写产生大量溢 写文件，需要对溢写文件进行归并排序；对溢写的文件也可以进行 Combiner操作，前提是汇总操作，求平均值不行。最后将文件按照分区存储到磁盘，等待 Reduce端拉取。
3)每个Reduce拉取Map端对应分区的数据。拉取数据后先存储到内存中，内存不够 了，再存储到磁盘。拉取完所有数据后，采用归并排序将内存和磁盘中的数据都进行排序。
在进入Reduce方法前，可以对数据进行分组操作。
12.Mapreduce 的 map 数量 和 reduce 数量 怎么确定 ,怎么配置
map的数量由输入切片的数量决定，128M切分一个切片，只要是文件也分为一个切片，有多少个切片就有多少个map Task。
reduce数量自己配置。
13.MapReduce优化经验
设置合理的map和reduce的个数。合理设置blocksize
避免出现数据倾斜
combine函数
对数据进行压缩
小文件处理优化：事先合并成大文件，combineTextInputformat，在hdfs上用mapreduce将小文件合并成SequenceFile大文件(key:文件名，value：文件内容)
参数优化
14.分别举例什么情况要使用 combiner，什么情况不使用？
求平均数的时候就不需要用combiner，因为不会减少reduce执行数量。在其他的时候，可以依据情况，使用combiner，来减少map的输出数量，减少拷贝到reduce的文件，从而减轻reduce的压力，节省网络开销，提升执行效率
15.MR运行流程解析
![]()
一个mr程序启动的时候，最先启动的是MRAppMaster，MRAppMaster启动后根据本次job的描述信息，计算出需要的maptask实例数量，然后向集群申请机器启动相应数量的maptask进程
maptask进程启动之后，根据给定的数据切片范围进行数据处理，主体流程为：
利用客户指定的inputformat来获取RecordReader读取数据，形成输入KV对
将输入KV对传递给客户定义的map()方法，做逻辑运算，并将map()方法输出的KV对收集到缓存
将缓存中的KV对按照K分区排序后不断溢写到磁盘文件
MRAppMaster监控到所有maptask进程任务完成之后，会根据客户指定的参数启动相应数量的reducetask进程，并告知reducetask进程要处理的数据范围(数据分区)
Reducetask进程启动之后，根据MRAppMaster告知的待处理数据所在位置，从若干台maptask运行所在机器上获取到若干个maptask输出结果文件，并在本地进行重新归并排序，然后按照相同key的KV为一个组，调用客户定义的reduce()方法进行逻辑运算，并收集运算输出的结果KV，然后调用客户指定的outputformat将结果数据输出到外部存储
16.简单描述一下HDFS的系统架构，怎么保证数据安全?
![]()
HDFS数据安全性如何保证？
存储在HDFS系统上的文件，会分割成128M大小的block存储在不同的节点上，block的副本数默认3份，也可配置成更多份；
第一个副本一般放置在与client(客户端)所在的同一节点上(若客户端无datanode，则随机放)，第二个副本放置到与第一个副本同一机架的不同节点，第三个副本放到不同机架的datanode节点，当取用时遵循就近原则；
datanode已block为单位，每3s报告心跳状态，做10min内不报告心跳状态则namenode认为block已死掉，namonode会把其上面的数据备份到其他一个datanode节点上，保证数据的副本数量；
datanode会默认每小时把自己节点上的所有块状态信息报告给namenode；
采用safemode模式：datanode会周期性的报告block信息。Namenode会计算block的损坏率，当阀值<0.999f时系统会进入安全模式，HDFS只读不写。 HDFS元数据采用secondaryname备份或者HA备份
17.在通过客户端向hdfs中写数据的时候，如果某一台机器宕机了，会怎么处理
在写入的时候不会重新重新分配datanode。 如果写入时，一个datanode挂掉，会将已经写入的数据放置到queue的顶部，并将挂掉的datanode移出pipline，将数据写入到剩余的datanode，在写入结束后， namenode会收集datanode的信息，发现此文件的replication没有达到配置的要求(default=3),然后寻找一个datanode保存副本。
18.Hadoop优化有哪些方面
0)HDFS小文件影响
(1)影响NameNode的寿命，因为文件元数据存储在NameNode的内存中
(2)影响计算引擎的任务数量，比如每个小的文件都会生成一个Map任务
1)数据输入小文件处理：
(1)合并小文件：对小文件进行归档(Har)、自定义Inputformat将小文件存储成SequenceFile 文件。
(2)采用ConbinFileInputFormat来作为输入，解决输入端大量小文件场景。
(3)对于大量小文件Job，可以开启JVM重用。
2)Map阶段
(1)增大环形缓冲区大小。由100m扩大到200m
(2)增大环形缓冲区溢写的比例。由80%扩大到90%
(3)减少对溢写文件的merge次数。(10个文件，一次20个merge)
(4)不影响实际业务的前提下，采用Combiner提前合并，减少I/O。
3)Reduce阶段
(1)合理设置Map和Reduce数：两个都不能设置太少，也不能设置太多。太少，会导致 Task等待，延长处理时间；太多，会导致Map、Reduce任务间竞争资源，造成处理超时等错误。
(2)设置Map、Reduce共存：调整slowstart.completedmaps参数，使Map运行到一定程度后，Reduce也开始运行，减少Reduce的等待时间。
(3)规避使用Reduce，因为Reduce在用于连接数据集的时候将会产生大量的网络消耗。
(4)增加每个Reduce去Map中拿数据的并行数
(5)集群性能可以的前提下，增大Reduce端存储数据内存的大小。
4)IO传输
(1)采用数据压缩的方式，减少网络IO的的时间。安装Snappy和LZOP压缩编码器。
(2)使用SequenceFile二进制文件
5)整体
(1)MapTask默认内存大小为1G，可以增加MapTask内存大小为4-5g
(2)ReduceTask默认内存大小为1G，可以增加ReduceTask内存大小为4-5g
(3)可以增加MapTask的cpu核数，增加ReduceTask的CPU核数
(4)增加每个Container的CPU核数和内存大小
(5)调整每个Map Task和Reduce Task最大重试次数
19.大量数据求topN(写出mapreduce的实现思路)
20.列出正常工作的hadoop集群中hadoop都分别启动哪些进程以及他们的作用
1.NameNode它是hadoop中的主服务器，管理文件系统名称空间和对集群中存储的文件的访问，保存有metadate。
2.SecondaryNameNode它不是namenode的冗余守护进程，而是提供周期检查点和清理任务。帮助NN合并editslog，减少NN启动时间。
3.DataNode它负责管理连接到节点的存储(一个集群中可以有多个节点)。每个存储数据的节点运行一个datanode守护进程。
4.ResourceManager(JobTracker)JobTracker负责调度DataNode上的工作。每个DataNode有一个TaskTracker，它们执行实际工作。
5.NodeManager(TaskTracker)执行任务
6.DFSZKFailoverController高可用时它负责监控NN的状态，并及时的把状态信息写入ZK。它通过一个独立线程周期性的调用NN上的一个特定接口来获取NN的健康状态。FC也有选择谁作为Active NN的权利，因为最多只有两个节点，目前选择策略还比较简单(先到先得，轮换)。
7.JournalNode 高可用情况下存放namenode的editlog文件.
21.Hadoop总job和Tasks之间的区别是什么？
Job是我们对一个完整的mapreduce程序的抽象封装
Task是job运行时，每一个处理阶段的具体实例，如map task，reduce task，maptask和reduce task都会有多个并发运行的实例
22.Hadoop高可用
23.简要描述安装配置一个hadoop集群的步骤
使用root账户登录。
修改IP。
修改Host主机名。
配置SSH免密码登录。
关闭防火墙。
安装JDK。
上传解压Hadoop安装包。
配置Hadoop的核心配置文件hadoop-evn.sh，core-site.xml，mapred-site.xml，hdfs-site.xml，yarn-site.xml
配置hadoop环境变量
格式化hdfs # bin/hadoop namenode -format
启动节点start-all.sh
24.fsimage和edit的区别
fsimage：filesystem image 的简写，文件镜像。
客户端修改文件时候，先更新内存中的metadata信息,只有当对文件操作成功的时候，才会写到editlog。
fsimage是文件meta信息的持久化的检查点。secondary namenode会定期的将fsimage和editlog合并dump成新的fsimage
二.Hive
1.hive优化
hive最终都会转化为mapreduce的job来运行，要想hive调优，实际上就是mapreduce调优，可以有下面几个方面的调优。解决收据倾斜问题，减少job数量，设置合理的map和reduce个数，对小文件进行合并，优化时把我整体，单个task最优不如整体最优。按照一定规则分区。
reducer 会缓存 join 序列中除了最后一个表的所有表的记录，再通过最后一个表将结果序列化到文件系统。这一实现有助于在 reduce 端减少内存的使用量。实践中，应该把最大的那个表写在最后(否则会因为缓存浪费大量内存
当对3个或者更多个表进行join连接时，如果每个on子句都使用相同的连接键的话，那么只会产生一个MapReduce job。
尽量尽早的过滤数据，减少每个阶段的数据量,对于分区表要加分区，同时只选择需要使用到的字段。
4. order by & sort by
order by : 对查询结果进行全局排序，消耗时间长。需要 set hive.mapred.mode=nostrict
sort by : 局部排序，并非全局有序，提高效率。
5.避免数据倾斜
6.减少job数，对jobs数比较多的作业运行效率相对比较低，比如即使有几百行的表，如果多次关联多次汇总，产生十几个jobs，没半小时是跑不完的。map reduce作业初始化的时间是比较长的。
7.对小文件进行合并，是行至有效的提高调度效率的方法，假如我们的作业设置合理的文件数，对云梯的整体调度效率也会产生积极的影响。
2.udf udaf udtf区别
UDF操作作用于单个数据行，并且产生一个数据行作为输出。大多数函数都属于这一类(比如数学函数和字符串函数)。
UDAF 接受多个输入数据行，并产生一个输出数据行。像COUNT和MAX这样的函数就是聚集函数。
UDTF 操作作用于单个数据行，并且产生多个数据行-------一个表作为输出。lateral view explore()
简单来说：
UDF:返回对应值，一对一
UDAF：返回聚类值，多对一
UDTF：返回拆分值，一对多
3.hive有哪些保存元数据的方式，个有什么特点。
内存数据库derby，安装小，但是数据存在内存，不稳定
mysql数据库，数据存储模式可以自己设置，持久化好，查看方便。
4.hive内部表和外部表的区别
内部表：加载数据到hive所在的hdfs目录，删除时，元数据和数据文件都删除
外部表：不加载数据到hive所在的hdfs目录，删除时，只删除表结构。
这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。
5.生产环境中为什么建议使用外部表？
因为外部表不会加载数据到hive，减少数据传输、数据还能共享。
hive不会修改数据，所以无需担心数据的损坏
删除表时，只删除表结构、不删除数据。
6.insert into 和 override write区别？
insert into：将数据写到表中
override write：覆盖之前的内容。
7.hive的判断函数有哪些
hive 的条件判断(if、coalesce、case)
8.简单描述一下HIVE的功能？用hive创建表有几种方式？hive表有几种？
hive主要是做离线分析的
hive建表有三种方式
直接建表法
查询建表法(通过AS 查询语句完成建表：将子查询的结果存在新表里，有数据，一般用于中间表)
like建表法(会创建结构完全相同的表，但是没有数据)
hive表有2种：内部表和外部表
9.线上业务每天产生的业务日志(压缩后>=3G)，每天需要加载到hive的log表中，将每天产生的业务日志在压缩之后load到hive的log表时，最好使用的压缩算法是哪个,并说明其原因
10.若在hive中建立分区仍不能优化查询效率，建表时如何优化
11.简述拉链表，流水表以及快照表的含义和特点
拉链表：
(1)记录一个事物从开始，一直到当前状态的所有变化的信息；
(2)拉链表每次上报的都是历史记录的最终状态，是记录在当前时刻的历史总量；
(3)当前记录存的是当前时间之前的所有历史记录的最后变化量(总量)；
(4)封链时间可以是2999，3000，9999等等比较大的年份；拉链表到期数据要报0；
流水表：对于表的每一个修改都会记录，可以用于反映实际记录的变更
区别于拉链表：
拉链表通常是对账户信息的历史变动进行处理保留的结果，流水表是每天的交易形成的历史；
流水表用于统计业务相关情况，拉链表用于统计账户及客户的情况
快照表：
按天分区，每一天的数据都是截止到那一天mysql的全量数据
12.如何解决hive数据倾斜的问题
1)group by
注：group by优于distinct group
情形：group by维度过小，某值的数量过多
后果：处理某值的reduce非常耗时
解决方式：采用sum() group by的方式来替换count(distinct)完成计算。
2)count(distinct)
count(distinct xx)
情形：某特殊值过多
后果：处理此特殊值的reduce耗时；只有一个reduce任务
解决方式：count distinct时，将值为空的情况单独处理，比如可以直接过滤空值的行，
在最后结果中加1。如果还有其他计算，需要进行group by，可以先将值为空的记录单独处
理，再和其他计算结果进行union。
3)mapjoin
4)不同数据类型关联产生数据倾斜
情形：比如用户表中user_id字段为int，log表中user_id字段既有string类型也有int类型。当按照user_id进行两个表的Join操作时。
后果：处理此特殊值的reduce耗时；只有一个reduce任务
默认的Hash操作会按int型的id来进行分配，这样会导致所有string类型id的记录都分配
到一个Reducer中。
解决方式：把数字类型转换成字符串类型
select * from users a
left outer join logs b
on a.usr_id = cast(b.user_id as string)
5)开启数据倾斜时负载均衡
set hive.groupby.skewindata=true;
思想：就是先随机分发并处理，再按照key group by来分发处理。
操作：当选项设定为true，生成的查询计划会有两个MRJob。
第一个MRJob中，Map的输出结果集合会随机分布到Reduce中，每个Reduce做部分
聚合操作，并输出结果，这样处理的结果是相同的GroupBy Key有可能被分发到不同的
Reduce中，从而达到负载均衡的目的；
第二个MRJob再根据预处理的数据结果按照GroupBy Key分布到Reduce中(这个过
程可以保证相同的原始GroupBy Key被分布到同一个Reduce中)，最后完成最终的聚合操
作。
点评：它使计算变成了两个mapreduce，先在第一个中在shuffle过程partition时随机
给key打标记，使每个key随机均匀分布到各个reduce上计算，但是这样只能完成部分
计算，因为相同key没有分配到相同reduce上。
所以需要第二次的mapreduce,这次就回归正常shuffle,但是数据分布不均匀的问题在第
一次mapreduce已经有了很大的改善，因此基本解决数据倾斜。因为大量计算已经在第一次
mr中随机分布到各个节点完成。
6)控制空值分布
将为空的key转变为字符串加随机数或纯随机数，将因空值而造成倾斜的数据分不到多
个Reducer。
注：对于异常值如果不需要的话，最好是提前在where条件里过滤掉，这样可以使计算
量大大减少
13.hive性能优化常用的方法
1)MapJoin
如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换
成Common Join，即：在Reduce阶段完成join。容易发生数据倾斜。可以用MapJoin把小
表全部加载到内存在map端进行join，避免reducer处理。
2)行列过滤
列处理：在SELECT中，只拿需要的列，如果有，尽量使用分区过滤，少用SELECT *。
行处理：在分区剪裁中，当使用外关联时，如果将副表的过滤条件写在Where后面，那
么就会先全表关联，之后再过滤。
3)列式存储
4)采用分区技术
5)合理设置Map数
(1)通常情况下，作业会通过input的目录产生一个或者多个map任务。
主要的决定因素有：input的文件总个数，input的文件大小，集群设置的文件块大小。
(2)是不是map数越多越好？
答案是否定的。如果一个任务有很多小文件(远远小于块大小128m)，则每个小文件
也会被当做一个块，用一个map任务来完成，而一个map任务启动和初始化的时间远远大
于逻辑处理的时间，就会造成很大的资源浪费。而且，同时可执行的map数是受限的。
(3)是不是保证每个map处理接近128m的文件块，就高枕无忧了？
答案也是不一定。比如有一个127m的文件，正常会用一个map去完成，但这个文件只
有一个或者两个小字段，却有几千万的记录，如果map处理的逻辑比较复杂，用一个map
任务去做，肯定也比较耗时。
针对上面的问题2和3，我们需要采取两种方式来解决：即减少map数和增加map数；
6)小文件进行合并
在Map执行前合并小文件，减少Map数：CombineHiveInputFormat具有对小文件进行
合并的功能(系统默认的格式)。HiveInputFormat没有对小文件合并功能。
7)合理设置Reduce数
Reduce个数并不是越多越好
(1)过多的启动和初始化Reduce也会消耗时间和资源；
(2)另外，有多少个Reduce，就会有多少个输出文件，如果生成了很多个小文件，那
么如果这些小文件作为下一个任务的输入，则也会出现小文件过多的问题；
在设置Reduce个数的时候也需要考虑这两个原则：处理大数据量利用合适的Reduce
数；使单个Reduce任务处理数据量大小要合适；
8)常用参数
// 输出合并小文件
SET hive.merge.mapfiles = true; --默认true，在map-only任务结束时合并
小文件
SET hive.merge.mapredfiles = true; --默认false，在map-reduce任务结
束时合并小文件
SET hive.merge.size.per.task = 268435456; --默认256M
SET hive.merge.smallfiles.avgsize = 16777216; --当输出文件的平均大小
小于16m该值时，启动一个独立的map-reduce任务进行文件merge
9)开启map端combiner(不影响最终业务逻辑)
set hive.map.aggr=true；
10)压缩(选择快的)
设置map端输出、中间结果压缩。(不完全是解决数据倾斜的问题，但是减少了IO读
写和网络传输，能提高很多效率)
11)开启JVM重用
14.简述delete，drop，truncate的区别
15.四个by的区别
Sort By：分区内有序；
Order By：全局排序，只有一个Reducer；
Distrbute By：类似MR中Partition，进行分区，结合sort by使用。
Cluster By：当Distribute by和Sorts by字段相同时，可以使用Cluster by方式。Cluster by 除了具有Distribute by的功能外还兼具Sort by的功能。但是排序只能是升序排序，不能 指定排序规则为 ASC或者DESC。
16.Hive 里边字段的分隔符用的什么？为什么用\t？有遇到过字段里 边有\t的情况吗，怎么处理的？为什么不用Hive默认的分隔符，默认的分隔符是什么？
hive默认的字段分隔符为ascii码的控制符\001(^A),建表的时候用fields terminated by '\001'
遇到过字段里边有\t的情况，自定义InputFormat，替换为其他分隔符再做后续处理
三.Spark
1.rdd的属性
![]()
一组分片(Partition)，即数据集的基本组成单位。对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。
一个计算每个分区的函数。Spark中RDD的计算是以分片为单位的，每个RDD都会实现compute函数以达到这个目的。compute函数会对迭代器进行复合，不需要保存每次计算的结果。
RDD之间的依赖关系。RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。
一个Partitioner，即RDD的分片函数。当前Spark中实现了两种类型的分片函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。
一个列表，存储存取每个Partition的优先位置(preferred location)。对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。按照“移动数据不如移动计算”的理念，Spark在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。
2.算子分为哪几类(RDD支持哪几种类型的操作)
转换(Transformation) 现有的RDD通过转换生成一个新的RDD。lazy模式，延迟执行。
转换函数包括：map，filter，flatMap，groupByKey，reduceByKey，aggregateByKey，union,join, coalesce 等等。
动作(Action) 在RDD上运行计算，并返回结果给驱动程序(Driver)或写入文件系统。
动作操作包括：reduce，collect，count，first，take，countByKey以及foreach等等。
collect 该方法把数据收集到driver端 Array数组类型
所有的transformation只有遇到action才能被执行。
当触发执行action之后，数据类型不再是rdd了，数据就会存储到指定文件系统中，或者直接打印结 果或者收集起来。
3.创建rdd的几种方式
1.集合并行化创建(有数据)
val arr = Array(1,2,3,4,5)
val rdd = sc.parallelize(arr)
val rdd =sc.makeRDD(arr)
2.读取外部文件系统，如hdfs，或者读取本地文件(最常用的方式)(没数据)
val rdd2 = sc.textFile("hdfs://hdp-01:9000/words.txt")
// 读取本地文件
val rdd2 = sc.textFile(“file:///root/words.txt”)
3.从父RDD转换成新的子RDD
调用Transformation类的方法，生成新的RDD
4.spark运行流程
![]()
Worker的功能： 定时和master通信；调度并管理自身的executor
executor： 由Worker启动的，程序最终在executor中运行，(程序运行的一个容器)
spark-submit命令执行时，会根据master地址去向 Master发送请求，
Master接收到Dirver端的任务请求之后，根据任务的请求资源进行调度，(打散的策略)，尽可能的 把任务资源平均分配，然后向WOrker发送指令
Worker收到Master的指令之后，就根据相应的资源，启动executor(cores,memory)
executor会向dirver端建立请求，通知driver，任务已经可以运行了
driver运行任务的时候，会把任务发送到executor中去运行。
5.Spark中coalesce与repartition的区别
1)关系：
两者都是用来改变RDD的partition数量的，repartition底层调用的就是coalesce方法：coalesce(numPartitions, shuffle = true)
2)区别：
repartition一定会发生shuffle，coalesce根据传入的参数来判断是否发生shuffle
一般情况下增大rdd的partition数量使用repartition，减少partition数量时使用coalesce
6.sortBy 和 sortByKey的区别
sortBy既可以作用于RDD[K] ，还可以作用于RDD[(k,v)]
sortByKey 只能作用于 RDD[K,V] 类型上。
7.map和mapPartitions的区别
![]()
8.数据存入Redis 优先使用map mapPartitions foreach foreachPartions哪个
使用 foreachPartition
* 1,map mapPartition 是转换类的算子， 有返回值
* 2, 写mysql,redis 的连接
foreach * 100万 100万次的连接
foreachPartions * 200 个分区 200次连接 一个分区中的数据，共用一个连接
foreachParititon 每次迭代一个分区，foreach每次迭代一个元素。
该方法没有返回值，或者Unit
主要作用于，没有返回值类型的操作(打印结果，写入到mysql数据库中)
在写入到redis,mysql的时候，优先使用foreachPartititon
9.reduceByKey和groupBykey的区别
![]()
reduceByKey会传一个聚合函数， 相当于 groupByKey + mapValues
reduceByKey 会有一个分区内聚合，而groupByKey没有 最核心的区别
结论： reduceByKey有分区内聚合，更高效，优先选择使用reduceByKey。
10.cache和checkPoint的比较
都是做RDD持久化的
1.缓存，是在触发action之后，把数据写入到内存或者磁盘中。不会截断血缘关系
(设置缓存级别为memory_only： 内存不足，只会部分缓存或者没有缓存，缓存会丢失,memory_and_disk :内存不足，会使用磁盘)
2.checkpoint 也是在触发action之后，执行任务。单独再启动一个job，负责写入数据到hdfs中。(把rdd中的数据，以二进制文本的方式写入到hdfs中，有几个分区，就有几个二进制文件)
3.某一个RDD被checkpoint之后，他的父依赖关系会被删除，血缘关系被截断，该RDD转换成了CheckPointRDD，以后再对该rdd的所有操作，都是从hdfs中的checkpoint的具体目录来读取数据。 缓存之后，rdd的依赖关系还是存在的。
11.spark streaming流式统计单词数量代码
object WordCountAll {
// newValues当前批次的出现的单词次数， runningCount表示之前运行的单词出现的结果
/* def updateFunction(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
val newCount = newValues.sum + runningCount.getOrElse(0)// 将历史前几个批次的值和当前批次的值进行累加返回当前批次最终的结果
Some(newCount)
}*/
/**
* String : 单词 hello
* Seq[Int] ：单词在当前批次出现的次数
* Option[Int] ： 历史结果
*/
val updateFunc = (iter: Iterator[(String, Seq[Int], Option[Int])]) => {
//iter.flatMap(it=>Some(it._2.sum + it._3.getOrElse(0)).map(x=>(it._1,x)))
iter.flatMap{case(x,y,z)=>Some(y.sum + z.getOrElse(0)).map(m=>(x, m))}
}
// 屏蔽日志
Logger.getLogger("org.apache").setLevel(Level.ERROR)
def main(args: Array[String]) {
// 必须要开启2个以上的线程，一个线程用来接收数据，另外一个线程用来计算
val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
// 设置sparkjob计算时所采用的序列化方式
.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
.set("spark.rdd.compress", "true") // 节约大量的内存内容
// 如果你的程序出现垃圾回收时间过程，可以设置一下java的垃圾回收参数
// 同时也会创建sparkContext对象
// 批次时间 >= 批次处理的总时间 (批次数据量，集群的计算节点数量和配置)
val ssc = new StreamingContext(conf, Seconds(5))
//做checkpoint 写入共享存储中
ssc.checkpoint("c://aaa")
// 创建一个将要连接到 hostname:port 的 DStream，如 localhost:9999
val lines: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.175.101", 44444)
//updateStateByKey结果可以累加但是需要传入一个自定义的累加函数：updateFunc
val results = lines.flatMap(_.split(" ")).map((_,1)).updateStateByKey(updateFunc, new HashPartitioner(ssc.sparkContext.defaultParallelism), true)
//打印结果到控制台
results.print()
//开始计算
ssc.start()
//等待停止
ssc.awaitTermination()
}
}
12.简述map和flatMap的区别和应用场景
map是对每一个元素进行操作，flatmap是对每一个元素操作后并压平
13.计算曝光数和点击数
![]()
14.分别列出几个常用的transformation和action算子
转换算子：map,map,filter,reduceByKey,groupByKey,groupBy
行动算子：foreach，foreachpartition,collect,collectAsMap,take,top,first,count,countByKey
15.按照需求使用spark编写以下程序，要求使用scala语言
当前文件a.txt的格式，请统计每个单词出现的次数
A,b,c
B,b,f,e
object WordCount {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName(this.getClass.getSimpleName)
.setMaster("local[*]")
val sc = new SparkContext(conf)
var sData: RDD[String] = sc.textFile("a.txt")
val sortData: RDD[(String, Int)] = sData.flatMap(_.split(",")).map((_,1)).reduceByKey(_+_)
sortData.foreach(print)
}
}
16.spark应用程序的执行命令是什么？
/usr/local/spark-current2.3/bin/spark-submit \
--class com.wedoctor.Application \
--master yarn \
--deploy-mode client \
--driver-memory 1g \
--executor-memory 2g \
--queue root.wedw \
--num-executors 200 \
--jars /home/pgxl/liuzc/config-1.3.0.jar,/home/pgxl/liuzc/hadoop-lzo-0.4.20.jar,/home/pgxl/liuzc/elasticsearch-hadoop-hive-2.3.4.jar \
/home/pgxl/liuzc/sen.jar
17.Spark应用执行有哪些模式，其中哪几种是集群模式
18.请说明spark中广播变量的用途
使用广播变量，每个 Executor 的内存中，只驻留一份变量副本，而不是对 每个 task 都传输一次大变量，省了很多的网络传输， 对性能提升具有很大帮助， 而且会通过高效的广播算法来减少传输代价。
19.以下代码会报错吗？如果会怎么解决 val arr = new ArrayList[String]; arr.foreach(println)
20.写出你用过的spark中的算子，其中哪些会产生shuffle过程
reduceBykey：
groupByKey：
…ByKey:
21.Spark中rdd与partition的区别
22.请写出创建Dateset的几种方式
23.描述一下RDD，DataFrame，DataSet的区别？
1)RDD
优点:
编译时类型安全
编译时就能检查出类型错误
面向对象的编程风格
直接通过类名点的方式来操作数据
缺点:
序列化和反序列化的性能开销
无论是集群间的通信, 还是 IO 操作都需要对对象的结构和数据进行序列化和反序列化。
GC 的性能开销，频繁的创建和销毁对象, 势必会增加 GC
2)DataFrame
DataFrame 引入了 schema 和 off-heap
schema : RDD 每一行的数据, 结构都是一样的，这个结构就存储在 schema 中。 Spark 通过 schema 就能够读懂数据, 因此在通信和 IO 时就只需要序列化和反序列化数据, 而结构的部分就可以省略了。
3)DataSet
DataSet 结合了 RDD 和 DataFrame 的优点，并带来的一个新的概念 Encoder。
当序列化数据时，Encoder 产生字节码与 off-heap 进行交互，能够达到按需访问数据的效果，而不用反序列化整个对象。Spark 还没有提供自定义 Encoder 的 API，但是未来会加入。
三者之间的转换：
![]()
24.描述一下Spark中stage是如何划分的？描述一下shuffle的概念
25.Spark 在yarn上运行需要做哪些关键的配置工作？如何kill -个Spark在yarn运行中Application
26.通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？并请列举常见spark的运行模式？
27.RDD中的数据在哪？
RDD中的数据在数据源，RDD只是一个抽象的数据集，我们通过对RDD的操作就相当于对数据进行操作。
28.如果对RDD进行cache操作后，数据在哪里？
数据在第一执行cache算子时会被加载到各个Executor进程的内存中，第二次就会直接从内存中读取而不会区磁盘。
29.Spark中Partition的数量由什么决定
和Mr一样，但是Spark默认最少有两个分区。
30.Scala里面的函数和方法有什么区别
31.SparkStreaming怎么进行监控?
32.Spark判断Shuffle的依据?
父RDD的一个分区中的数据有可能被分配到子RDD的多个分区中
33.Scala有没有多继承？可以实现多继承么？
34.Sparkstreaming和flink做实时处理的区别
35.Sparkcontext的作用
36.Sparkstreaming读取kafka数据为什么选择直连方式
37.离线分析什么时候用sparkcore和sparksql
38.Sparkstreaming实时的数据不丢失的问题
39.简述宽依赖和窄依赖概念，groupByKey,reduceByKey,map,filter,union五种操作哪些会导致宽依赖，哪些会导致窄依赖
40.数据倾斜可能会导致哪些问题，如何监控和排查，在设计之初，要考虑哪些来避免
41.有一千万条短信，有重复，以文本文件的形式保存，一行一条数据，请用五分钟时间，找出重复出现最多的前10条
42.现有一文件，格式如下，请用spark统计每个单词出现的次数
18619304961，18619304064，186193008，186193009
18619304962，18619304065，186193007，186193008
18619304963，18619304066，186193006，186193010
43.共享变量和累加器
累加器(accumulator)是Spark中提供的一种分布式的变量机制，其原理类似于mapreduce，即分布式的改变，然后聚合这些改变。累加器的一个常见用途是在调试时对作业执行过程中的事件进行计数。而广播变量用来高效分发较大的对象。
共享变量出现的原因：
通常在向Spark传递函数时，比如使用map()函数或者用filter()传条件时，可以使用驱动器程序中定义的变量，但是集群中运行的每个任务都会得到这些变量的一份新的副本，更新这些副本的值也不会影响驱动器中的对应变量。
Spark的两个共享变量，累加器与广播变量，分别为结果聚合与广播这两种常见的通信模式突破了这一限制。
44.当Spark涉及到数据库的操作时，如何减少Spark运行中的数据库连接数？
使用foreachPartition代替foreach，在foreachPartition内获取数据库的连接。
四.Kafka
1.Kafka名词解释和工作方式
Producer ：消息生产者，就是向kafka broker发消息的客户端。
Consumer ：消息消费者，向kafka broker取消息的客户端
Topic ：咋们可以理解为一个队列。
Consumer Group (CG)：这是kafka用来实现一个topic消息的广播(发给所有的consumer)和单播(发给任意一个consumer)的手段。一个topic可以有多个CG。topic的消息会复制(不是真的复制，是概念上的)到所有的CG，但每个partion只会把消息发给该CG中的一个consumer。如果需要实现广播，只要每个consumer有一个独立的CG就可以了。要实现单播只要所有的consumer在同一个CG。用CG还可以将consumer进行自由的分组而不需要多次发送消息到不同的topic。
Broker ：一台kafka服务器就是一个broker。一个集群由多个broker组成。一个broker可以容纳多个topic。
Partition：为了实现扩展性，一个非常大的topic可以分布到多个broker(即服务器)上，一个topic可以分为多个partition，每个partition是一个有序的队列。partition中的每条消息都会被分配一个有序的id(offset)。kafka只保证按一个partition中的顺序将消息发给consumer，不保证一个topic的整体(多个partition间)的顺序。
Offset：kafka的存储文件都是按照offset.kafka来命名，用offset做名字的好处是方便查找。例如你想找位于2049的位置，只要找到2048.kafka的文件即可。当然the first offset就是00000000000.kafka
2.Consumer与topic关系
本质上kafka只支持Topic；
每个group中可以有多个consumer，每个consumer属于一个consumer group；
通常情况下，一个group中会包含多个consumer，这样不仅可以提高topic中消息的并发消费能力，而且还能提高"故障容错"性，如果group中的某个consumer失效那么其消费的partitions将会有其他consumer自动接管。
对于Topic中的一条特定的消息，只会被订阅此Topic的每个group中的其中一个consumer消费，此消息不会发送给一个group的多个consumer；
那么一个group中所有的consumer将会交错的消费整个Topic，每个group中consumer消息消费互相独立，我们可以认为一个group是一个"订阅"者。
在kafka中,一个partition中的消息只会被group中的一个consumer消费(同一时刻)；
一个Topic中的每个partions，只会被一个"订阅者"中的一个consumer消费，不过一个consumer可以同时消费多个partitions中的消息。
kafka的设计原理决定,对于一个topic，同一个group中不能有多于partitions个数的consumer同时消费，否则将意味着某些consumer将无法得到消息。
kafka只能保证一个partition中的消息被某个consumer消费时是顺序的；事实上，从Topic角度来说,当有多个partitions时,消息仍不是全局有序的。
3.kafka消息发送的应答机制
设置发送数据是否需要服务端的反馈,有三个值0,1,-1
0: producer不会等待broker发送ack
1: 当leader接收到消息之后发送ack
-1: 当所有的follower都同步消息成功后发送ack
request.required.acks=0
4.如何保证kafka消费者消费数据是全局有序的
伪命题
如果要全局有序的，必须保证生产有序，存储有序，消费有序。
由于生产可以做集群，存储可以分片，消费可以设置为一个consumerGroup，要保证全局有序，就需要保证每个环节都有序。
只有一个可能，就是一个生产者，一个partition，一个消费者。这种场景和大数据应用场景相悖。
5.有两个数据源，一个记录的是广告投放给用户的日志，一个记录用户访问日志，另外还有一个固定的用户基础表记录用户基本信息(比如学历，年龄等等)。现在要分析广告投放对与哪类用户更有效，请采用熟悉的技术描述解决思路。另外如果两个数据源都是实时数据源(比如来自kafka)，他们数据在时间上相差5分钟，需要哪些调整来解决实时分析问题？
6.Kafka和SparkStreaing如何集成?
7.列举Kafka的优点，简述Kafka为什么可以做到每秒数十万甚至上百万消息的高效分发？
8.为什么离线分析要用kafka？
Kafka的作用是解耦，如果直接从日志服务器上采集的话，实时离线都要采集，等于要采集两份数据，而使用了kafka的话，只需要从日志服务器上采集一份数据，然后在kafka中使用不同的两个组读取就行了
9.Kafka怎么进行监控?
10.Kafka与传统的消息队列服务有很么不同
11.Kafka api low-level与high-level有什么区别，使用low-level需要处理哪些细节
五.Hbase
1.Hbase调优
在库表设计的时候，尽量考虑rowkey和columnfamily的特性
进行hbase集群的调优：见hbase调优
2.hbase的rowkey怎么创建好？列族怎么创建比较好？
hbase存储时，数据按照Row key的字典序(byte order)排序存储。设计key时，要充分排序存储这个特性，将经常一起读取的行存储放到一起。(位置相关性)
一个列族在数据底层是一个文件，所以将经常一起查询的列放到一个列族中，列族尽量少，减少文件的寻址时间。
设计原则
1)rowkey长度原则
2)rowkey散列原则
3)rowkey唯一原则
如何设计
1)生成随机数、hash、散列值
2)字符串反转
3.hbase过滤器实现用途
增强hbase查询数据的功能
减少服务端返回给客户端的数据量
4.HBase宕机如何处理
答：宕机分为HMaster宕机和HRegisoner宕机，如果是HRegisoner宕机，HMaster会将其所管理的region重新分布到其他活动的RegionServer上，由于数据和日志都持久在HDFS中，该操作不会导致数据丢失。所以数据的一致性和安全性是有保障的。
如果是HMaster宕机，HMaster没有单点问题，HBase中可以启动多个HMaster，通过Zookeeper的Master Election机制保证总有一个Master运行。即ZooKeeper会保证总会有一个HMaster在对外提供服务。
5.hive跟hbase的区别是？
共同点：
1.hbase与hive都是架构在hadoop之上的。都是用hadoop作为底层存储
区别：
2.Hive是建立在Hadoop之上为了减少MapReduce jobs编写工作的批处理系统，HBase是为了支持弥补Hadoop对实时操作的缺陷的项目 。
3.想象你在操作RMDB数据库，如果是全表扫描，就用Hive+Hadoop,如果是索引访问，就用HBase+Hadoop 。
4.Hive query就是MapReduce jobs可以从5分钟到数小时不止，HBase是非常高效的，肯定比Hive高效的多。
5.Hive本身不存储和计算数据，它完全依赖于HDFS和MapReduce，Hive中的表纯逻辑。
6.hive借用hadoop的MapReduce来完成一些hive中的命令的执行
7.hbase是物理表，不是逻辑表，提供一个超大的内存hash表，搜索引擎通过它来存储索引，方便查询操作。
8.hbase是列存储。
9.hdfs作为底层存储，hdfs是存放文件的系统，而Hbase负责组织文件。
10.hive需要用到hdfs存储文件，需要用到MapReduce计算框架。
6.hbase写流程
client向hregionserver发送写请求。
hregionserver将数据写到hlog(write ahead log)。为了数据的持久化和恢复。
hregionserver将数据写到内存(memstore)
反馈client写成功。
7.hbase读流程
通过zookeeper和-ROOT- .META.表定位hregionserver。
数据从内存和硬盘合并后返回给client
数据块会缓存
8.hbase数据flush过程
当memstore数据达到阈值(默认是64M)，将数据刷到硬盘，将内存中的数据删除，同时删除Hlog中的历史数据。
并将数据存储到hdfs中。
在hlog中做标记点。
9.数据合并过程
当数据块达到4块，hmaster将数据块加载到本地，进行合并
当合并的数据超过256M，进行拆分，将拆分后的region分配给不同的hregionserver管理
当hregionser宕机后，将hregionserver上的hlog拆分，然后分配给不同的hregionserver加载，修改.META.
注意：hlog会同步到hdfs
10.Hmaster和Hgionserver职责
Hmaster
1、管理用户对Table的增、删、改、查操作；
2、记录region在哪台Hregion server上
3、在Region Split后，负责新Region的分配；
4、新机器加入时，管理HRegion Server的负载均衡，调整Region分布
5、在HRegion Server宕机后，负责失效HRegion Server 上的Regions迁移。
Hgionserver
HRegion Server主要负责响应用户I/O请求，向HDFS文件系统中读写数据，是HBASE中最核心的模块。
HRegion Server管理了很多table的分区，也就是region。
11.HBase列族和region的关系？
HBase有多个RegionServer，每个RegionServer里有多个Region，一个Region中存放着若干行的行键以及所对应的数据，一个列族是一个文件夹，如果经常要搜索整个一条数据，列族越少越好，如果只有一部分的数据需要经常被搜索，那么将经常搜索的建立一个列族，其他不常搜索的建立列族检索较快。
12.请简述Hbase的物理模型是什么
13.请问如果使用Hbase做即席查询，如何设计二级索引
六.Flink
1.Flink实时计算时落磁盘吗
2.日活DAU的统计需要注意什么
3.Flink调优
4.Flink的容错是怎么做的
5.Parquet格式的好处？什么时候读的快什么时候读的慢
七.Java
1.HashMap实现原理，比较ArrayList，LinkedList的存储特性和读写性能
2.写出你用过的设计模式，并举例说明解决的实际问题
3.Java创建线程的几种方式
继承Thread类，重写run方法
实现Runnable接口，实现run方法
通过线程池获取线程
实现Callable接口并实现call方法，创建该类的实例，使用FutureTask类包装Callable对象，使用FutureTask对象作为Thread对象的target创建并启用新线程
4.请简述操作系统的线程和进程的区别
5.Java程序出现OutOfMemoryError:unable to create new native thread 的原因可能有哪些？如何分析和解决？
6.采用java或自己熟悉的任何语言分别实现简单版本的线性表和链表，只需实现add,remove方法即可
7.ArrayList，LinkedList和Vector都实现了List接口，对于添加或删除元素哪个效率更高？
8.简述JVM GC算法
1)引用计数法应用于：微软的 COM/ActionScrip3/Python 等
a) 如果对象没有被引用，就会被回收，缺点：需要维护一个引用计算器
2)复制算法年轻代中使用的是 Minor GC，这种 GC 算法采用的是复制算法(Copying)
a) 效率高，缺点：需要内存容量大，比较耗内存
b) 使用在占空间比较小、刷新次数多的新生区
3)标记清除老年代一般是由标记清除或者是标记清除与标记整理的混合实现
a) 效率比较低，会差生碎片。
4)标记压缩老年代一般是由标记清除或者是标记清除与标记整理的混合实现
a) 效率低速度慢，需要移动对象，但不会产生碎片。
5)标记清除压缩标记清除-标记压缩的集合，多次 GC 后才 Compact
a) 使用于占空间大刷新次数少的养老区，是 3 4 的集合体
9.Java中迭代器和集合的区别？
集合是将所有数据加载到内存，然后通过集合的方法去内存中获取，而迭代器是一个对象，实现了Iterator接口，实现了接口的hasNext和Next方法。
10.HashMap 和 HashTable 区别
1)线程安全性不同
HashMap是线程不安全的，HashTable是线程安全的，其中的方法是Synchronize的，
在多线程并发的情况下，可以直接使用HashTabl，但是使用HashMap时必须自己增加同步
处理。
2)是否提供contains方法
HashMap只有containsValue和containsKey方法；HashTable有contains、containsKey
和containsValue三个方法，其中contains和containsValue方法功能相同。
3) key和value是否允许null值
Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这
样的键只有一个；可以有一个或多个键所对应的值为null。
4)数组初始化和扩容机制
HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不
要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原
来的2倍。
11.线程池使用注意哪些方面？
线程池分为单线程线程池，固定大小线程池，可缓冲的线程池
12.HashMap和TreeMap的区别？TreeMap排序规则？
TreeMap会自动进行排序，根据key的Compare方法进行排序
13.用java实现单例模式
14.使用递归算法求n的阶乘：n! ,语言不限
15.HashMap和Hashtable的区别是什么
16.TreeSet 和HashSet区别
HashSet是采用hash表来实现的。其中的元素没有按顺序排列，add()、remove()以及
contains()等方法都是复杂度为O(1)的方法。
TreeSet是采用树结构实现(红黑树算法)。元素是按顺序进行排列，但是add()、
remove()以及contains()等方法都是复杂度为O(log (n))的方法。它还提供了一些方法来处理
排序的set，如first()，last()，headSet()，tailSet()等等。
17.Stringbuffer 和 Stringbuild 区别
1、StringBuffer与StringBuilder中的方法和功能完全是等价的。
2、只是StringBuffer中的方法大都采用了synchronized关键字进行修饰，因此是线程
安全的，而StringBuilder没有这个修饰，可以被认为是线程不安全的。
3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全
而StringBuffer则每次都需要判断锁，效率相对更低
18.Final、Finally、Finalize
final：修饰符(关键字)有三种用法：修饰类、变量和方法。修饰类时，意味着它不
能再派生出新的子类，即不能被继承，因此它和abstract是反义词。修饰变量时，该变量
使用中不被改变，必须在声明时给定初值，在引用中只能读取不可修改，即为常量。修饰
方法时，也同样只能使用，不能在子类中被重写。
finally：通常放在try…catch的后面构造最终执行代码块，这就意味着程序无论正常执
行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在
finally块中。
finalize：Object类中定义的方法，Java中允许使用finalize()方法在垃圾收集器将对象
从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用
的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。
19..==和 Equals 区别
== :如果比较的是基本数据类型，那么比较的是变量的值
如果比较的是引用数据类型，那么比较的是地址值(两个对象是否指向同一块内
存)
equals:如果没重写equals方法比较的是两个对象的地址值。
如果重写了equals方法后我们往往比较的是对象中的属性的内容
equals方法是从Object类中继承的，默认的实现就是使用==
![]()
八.Elasticsearch
1.为什么要用es？存进es的数据是什么格式的，怎么查询
九.Flume
1.什么是flume
a.Flume是一个分布式、可靠、和高可用的海量日志采集、聚合和传输的系统。
b.Flume可以采集文件，socket数据包等各种形式源数据，又可以将采集到的数据输出到HDFS、hbase、hive、kafka等众多外部存储系统中
c.一般的采集需求，通过对flume的简单配置即可实现
d.ume针对特殊场景也具备良好的自定义扩展能力，因此，flume可以适用于大部分的日常数据采集场景
2.flume运行机制
Flume分布式系统中最核心的角色是agent，flume采集系统就是由一个个agent所连接起来形成
每一个agent相当于一个数据传递员，内部有三个组件：
Source：采集源，用于跟数据源对接，以获取数据
Sink：下沉地，采集数据的传送目的，用于往下一级agent传递数据或者往最终存储系统传递数据
Channel：angent内部的数据传输通道，用于从source将数据传递到sink
![]()
3.Flume采集数据到Kafka中丢数据怎么办
4.Flume怎么进行监控?
5.Flume的三层架构，collector、agent、storage
十.Sqoop
1.sqoop工作机制(原理)
Sqoop的原理其实就是将导入导出命令转化为mapreduce程序来执行，sqoop在接收到命令后，都要生成mapreduce程序
在翻译出的mapreduce中主要是对inputformat和outputformat进行定制
十一.Zookeeper
十二.Kylin
十三.Logstash
十四.Python
十五.Shell
十六.Redis
1.缓存穿透、缓存雪崩、缓存击穿
1)缓存穿透是指查询一个一定不存在的数据。由于缓存命不中时会去查询数据库，查不到
数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿
透。
解决方案：
① 是将空对象也缓存起来，并给它设置一个很短的过期时间，最长不超过5分钟
② 采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定
不存在的数据会被这个bitmap拦截掉，从而避免了对底层存储系统的查询压力
2)如果缓存集中在一段时间内失效，发生大量的缓存穿透，所有的查询都落在数据库上，
就会造成缓存雪崩。
解决方案：
尽量让失效的时间点不分布在同一个时间点
3)缓存击穿，是指一个key非常热点，在不停的扛着大并发，当这个key在失效的瞬间，
持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
可以设置key永不过期
2.数据类型
![]()
3.持久化
1)RDB 持久化：
① 在指定的时间间隔内持久化
② 服务 shutdown 会自动持久化
③ 输入 bgsave 也会持久化
2)AOF : 以日志形式记录每个更新操作
Redis重新启动时读取这个文件，重新执行新建、修改数据的命令恢复数据。
保存策略：
推荐(并且也是默认)的措施为每秒持久化一次，这种策略可以兼顾速度和安全性。
缺点：
1比起RDB占用更多的磁盘空间
2恢复备份速度要慢
3每次读写都同步的话，有一定的性能压力
4存在个别Bug，造成恢复不能
选择策略：
官方推荐：
string
字符串
list
可以重复的集合
set
不可以重复的集合
hash
类似于Map
zset(sorted set)
带分数的set
如果对数据不敏感，可以选单独用RDB；不建议单独用AOF，因为可能出现Bug;如果只是做纯内存缓存，可以都不用
4.悲观锁和乐观锁
悲观锁：执行操作前假设当前的操作肯定(或有很大几率)会被打断(悲观)。基于这个假设，我们在做操作前就会把相关资源锁定，不允许自己执行期间有其他操作干扰。
乐观锁：执行操作前假设当前操作不会被打断(乐观)。基于这个假设，我们在做操作前不会锁定资源，万一发生了其他操作的干扰，那么本次操作将被放弃。Redis使用的就是乐观锁。
5.redis是单线程的，为什么那么快
1)完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。
2)数据结构简单，对数据操作也简单，Redis 中的数据结构是专门进行设计的
3)采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗
4)使用多路 I/O 复用模型，非阻塞 IO
5)使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，
Redis 直接自己构建了 VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求
十七.Datax
十八.Mysql
1.请写出mysql登录命令，用户名user，密码123456，地址192.168.1.130
mysql -h 192.168.1.130 -uuser-p123456-P3306-Dwemeta_test
十九.数据结构与算法
1.在python，scala，java中任选两种实现快速排序和二分查找(接受伪代码)
2.快排的空间复杂度和原理
3.手写归并排序
4.二叉树的前中后序遍历
5.链表转置/二叉树转置
6.单向链表反转
7.字符串反转
8.冒泡的时间空间复杂度，原理
9.实现堆栈push pop min复杂度0(1)
二十.机器学习
1.请描述K邻近算法的原理
2.请描述朴素贝叶斯算法的原理
转播
