大数据文档需求面试题执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程

54 阅读 0 评论 36 点赞

我是靠谱客的博主迅速薯片，最近开发中收集的这篇文章主要介绍大数据文档需求面试题执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

索引
问题
答案
配图
备注
A1
azkaban使用流程?
类似工具(oozie乌贼)
创建之前我们先了解下之间的关系，一个工程包含一个或多个flows，一个flow包含多个job。job是你想在azkaban中运行的一个进程，
可以是简单的linux命令，可是java程序，也可以是复杂的shell脚本，当然，如果你安装相关插件，也可以运行插件。一个job可以依赖
于另一个job，这种多个job和它们的依赖组成的图表叫做flow
1.Command 类型单一 job 示例
A.首先创建一个工程(project)，填写名称和描述,创建完成后,显示三部分
Flows：工作流程，有多个job组成
Permissions:权限管理
Project Logs:工程日志
B.job的创建
创建job很简单，只要创建一个以.job结尾的文本文件就行了
C.将 job 资源文件打包要求只能是zip格式
D.通过 azkaban web 管理平台创建 project 并上传压缩包 ,然后定时执行

2.Command 多类型job 示例
我们说过多个jobs和它们的依赖组成flow。怎么创建依赖，只要指定dependencies参数就行了。比如导入hive前，需要进行数据清洗，数据清洗前需要上传，上传之前需要从ftp获取日志。
定义5个job：

1、o2o_2_hive.job：将清洗完的数据入hive库

2、o2o_clean_data.job：调用mr清洗hdfs数据

o2o_2_hive.job
type=command

执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程

command=sh /job/o2o_2_hive.sh
dependencies=o2o_clean_data

azkaban(使用azkaban遇到过哪些问题)?
1.启动时候资源不足问题(启动的默认3G)
解决办法在配置文件中修改 memCheck.enabled=false
2.任务运行失败问题
查看日志
3.win系统和linux 系统换行符号不一致的问题
win CRLF
linux LF
4.安装认证的问题 ssl安全认证问题 keystore问题

azkaban支不支持参数传递?
不支持

azkaban离线调度错误之后怎么处理，怎么查看？
1.从azkaban的WEB UI上首先看jobList里面的status和details
2.然后可以从Flow log 看到日志信息

akka中actor模型？
1.并发模型的高度抽象
2.异步,非阻塞,高性能的事件驱动编程模型
3.轻量级事件处理(1GB内存可容纳百万级别个Actor)
Actor 本身封装了状态和行为，在进行并发编程时，Actor 只需要关注消息和它本身。而消息是一个不可变对象，所以 Actor 不需要去关注锁和内存原子性等一系列多线程常见的问题。
所以 Actor 是由状态（State）、行为（Behavior）和邮箱（MailBox，可以认为是一个消息队列）三部分组成：

状态：Actor 中的状态指 Actor 对象的变量信息，状态由 Actor 自己管理，避免了并发环境下的锁和内存原子性等问题。
行为：Actor 中的计算逻辑，通过 Actor 接收到的消息来改变 Actor 的状态。
邮箱：邮箱是 Actor 和 Actor 之间的通信桥梁，邮箱内部通过 FIFO（先入先出）消息队列来存储发送方 Actor 消息，接受方 Actor 从邮箱队列中获取消息

B1
闭包和科里化啥意思?以及应用场景
1.scala中的闭包：变量不在函数作用域中时，还可以访问。闭包可以作为变量或者返回值
2.柯里化的前提是scala支持闭包，才会有柯里化
柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数

悲观锁和乐观锁?
1.悲观锁
执行操作前假设当前的操作肯定（或有很大几率）会被打断（悲观）。基于这个假设，我们在做操作前就会把相关资源锁定，不允许自己执行期间有其他操作干扰。
2.乐观锁
执行操作前假设当前操作不会被打断（乐观）。基于这个假设，我们在做操作前不会锁定资源，万一发生了其他操作的干扰，那么本次操作将被放弃。Redis使用的就是乐观锁。

C1
CDH的版本?
5.1.4

coalesce和repartition的用法?
两个都是RDD的分区进行重新划分，repartition只是coalesce接口中shuffle为true的简易实现
1.N<M 一般情况下N个分区有数据分布不均匀的状况，利用HashPartitioner函数将数据重新分区为M个，这时需要将shuffle设置为true。
2.如果N>M 设为false 不涉及shuffle

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

D1
大数据整体应用场景分类?
1.静态大数据的批处理
2.移动中的数据实时处理
3.大数据的交互式浏览
4.基于数据的预测分析和机器学习

代码量(你开始工作到现在的scala代码量以及Java代码量)?
1.这个怎么说呢平均每天最少也的300/500行吧

惰性计算(spark/flink)的好处?
1.可以将代码的程序变成一块块的操作链(computer chain)，这样就能够很好的兼顾代码的可读性和减少耦合
A.pipeline 的思想:数据用的时候再算，而且数据是流到要计算的位置的。Result 产生的地方的就是要计算的位置，要确定 “需要计算的数据”，我们可以从后往前推，需要哪个 partition 就计算哪个 partition，如果 partition 里面没有数据，就继续向前推，形成 computing chain。
B.computing chain: 根据数据依赖关系自后向前建立，遇到 ShuffleDependency 后形成 stage。在每个 stage 中，每个 RDD 中的 compute() 调用 parentRDD.iter() 来将 parent RDDs 中的 records 一个个 fetch 过来。详见：Job 物理执行图
2.能够极大的减少中间计算过程提高计算效率；除非是真正需要用到的数据，才会计算；在普通的程序中，如果对每一步都进行计算，那效率将会是很低的，特别是如果最终的结果并不强依赖之前的中间结果，那么计算资源将会被浪费
3.降低时间复杂度和空间复杂度；因为spark程序并不执行所有中间操作，降低空间(中间结果落盘)和时间的开销（和第二点所表达的一样）

堆排序的理解?
1.堆其实就是一种叫做完全二叉树的数据结构任何一个父节点总是大于等于(或者小于等于)子节点
2.排序思想:以大(数值大)为顶
利用堆顶记录的是最大关键字这一特性，每一轮取堆顶元素放入有序区，就类似选择排序每一轮选择一个最大值放入有序区，可以把堆排序看成是选择排序的改进

端口占(win10)用问题解决?

输入win + R,输入cmd回车进入dos界面
输入netstat -ano|findstr 8080 查看占用8080端口的进程
输入taskkill /f /pid 进程ID

端口(Linux下)是否被监听(占用)，监听方法?
端口和进程是相互依存的,杀掉了进程,也就释放了端口
1.查看
A.lsof -i:端口号
B.netstat -tunlp | grep 端口号
C.ps -ef |grep 端口 ,然后再使用ps -aux | grep 项目名或者是端口号
2.关闭
A.通过iptables工具将该端口禁掉，如：
“sudo iptables -A INPUT -p tcp --dport $PORT -j DROP”
“sudo iptables -A OUTPUT -p tcp --dport $PORT -j DROP”
B.“kill -9 PID” (PID：进程号)

定时任务没有结果怎么排查?
定时任务没有结果怎么排查?

多线程实现的方式(java和scala)
1.java
A.继承Thread 类
B.实现Runnable 接口
C.自定义类实现Callable接口
2.scala
A.scala可以调用java中以上的方式
B.scala总有一个actor模型

Dataframe(spark)中na.fill/na.drop的用法?
对两个数据表如A，B取JOIN操作的时候，其结果往往会出现NULL值的出现。

这种情况是非常不利于后续的分析与计算的，特别是当涉及到对这个数值列进行各种聚合函数计算的时候。

Spark为此提供了一个高级操作，就是：na.fill的函数
na.drop 扔掉任何列包含na的行

Dstream(Spark)常用的算子?
同样分为两类:Transformation和Output Operations
1.Transformation
类似rdd的transforamtion 是将一个Dstream转换成另外一个DsTream 转换操作也是懒加载执行
map flatMap fliter repartition union count reduce countByValue reduceByKey join
cogroup transform updateStateByKey window(对每个窗口的数据执行自定义计算) countByWindow(对每个窗口的数据执行count操作) countByVaueAndWindow (对每个窗口的数据执行countByValue操作) reduceByWindow(对每个窗口执行reduce操作) reduceBykeyAndWindow(对每一个窗口执行reduceBykey操作) groupBykeyAndWindow(对每个窗口的数据执行groupBykey操作)
2.Output Operations
print saveAsTextFile savaAsObjectFile(将每个batch的数据以序列化对象的方式，保存到SequenceFile中) saveAsHadoopFile(将数据保存在hadoop中) foreachRDD

Dstream中的transform算子如何使用
1.把Dstream 转换成RDD 来操作(rdd 拥有更加丰富的算子)

E1
Equals和==的区别
== : 如果比较的是基本数据类型，那么比较的是变量的值
如果比较的是引用数据类型，那么比较的是地址值（两个对象是否指向同一块内存）
equals:如果没重写equals方法比较的是两个对象的地址值。
如果重写了equals方法后我们往往比较的是对象中的属性的内容

equals方法是从Object类中继承的，默认的实现就是使用==

二次排序问题(mr/spark)?
1.什么是二次排序?
首先按照第一个字段排序,如何第一个字段相同我们在按第二个字段排序
二次排序(secondary sort)问题是指在Reduce阶段对某个键关联的值排序. 利用二次排序技术,可以对传入Reduce的值完成升序/降序排序.
MapReduce框架会自动对Map生成的键完成排序. 所以, 在启动Reduce之前,中间文件 key-value 是按照key有序的(而不是按照值有序). 它们的值得顺序有可能是任意的.
2.spark
repartitionAndSortWithinPartitions 二次排序规则都需要在自定义的隐式变量my_self_Ordering中实现
3.mapreduce
第一种方案是让Reduce读取和缓存给定key的所有的value, 然后在Reduce中对这些值完成排序.(例如: 把一个key对应的所有value放到一个Array或List中,再排序). 但是这种方式有局限性, 如果数据量较少还可以使用,如果数据量太大,一个Reduce中放不下所有的值,就会导致内存溢出(OutOfMemory).
第二种方式是使用MapReduce框架来对值进行排序. 因为MapReduce框架会自动对Map生成的文件的key进行排序, 所以我们把需要排序的value增加到这个key上,这样让框架对这个new_key进行排序,来实现我们的目标.

应用场景:除了按照时间key 排序之外,还可以使用value 排序

ES节点类型和读写流程?
1.master node(主节点) 处理创建，删除索引等请求
2.data node (数据节点)储存分片数据
3.客户端节点:当主节点和数据节点配置都设置为false的时候，该节点只能处理路由请求，处理搜索，分发索引操作等，从本质上来说该客户节点表现为智能负载平衡器

es里面存的什么数据?
1.快速,经常查询的基本信息,详情信息一般存储在hbase中人物基本信息,如果点击详情的时候需要从hbase中溯源
当然如果把es完全当成数据库来用的话,还是有一定的局限性 A.关联这块无法实现多多的关联 B.没有用户限制和

es分页查询问题?
1.浅分页 from size(这种方式效率不高)
2.深度分页游标查询(scroll)
不允许使用分页(from&size)查询10000条以后的数据，因此如果要查询第10000条以后的数据，要使用ES提供的 scroll(游标) 来查询
scroll游标原理:
A.初始化时将所有符合搜索条件的搜索结果缓存起来，可以想象成快照

B.在遍历时，从这个快照里取数据
https://www.liangzl.com/get-article-detail-16379.html

es的版本(你们用的是什么版本)?
5.2.2

es的优化?
亿级规模的ES查询优化实战
能用filter就不用query
增加冗余字段将部分range aggregation查询变成terms aggregation
为常用字段增加配置，将fielddata的loading设成eager，尽量多加载到内存
增加集群的缓存资源，把内存尽量多的用起来
去掉_all字段可节省一半空间
开启索引压缩可节省空间，但会有10%-20%的性能损耗
不需分词的字符串字段设成not_analyzed

ES与Solr的区别?
1.当实时建立索引的时候，solr会产生io阻塞，而es则不会，es查询性能要高于solr
2.在不断动态添加数据的时候，solr的检索效率会变的低下，而es则没有什么变化
3.Solr利用zookeeper进行分布式管理，而es自身带有分布式系统管理功能。Solr一般都要部署到web服务器上，比如tomcat。
启动tomcat的时候需要配置tomcat与solr的关联。【Solr 的本质是一个动态web项目】
4.Solr支持更多的格式数据[xml,json,csv等]，而es仅支持json文件格式
5.Solr是传统搜索应用的有力解决方案，但是es更适用于新兴的实时搜索应用

ES是否支持join操作?
需求:select user.* ,blog.* from user inner join blog where user.uid = '查询的对象的uid ’ 类似这样的查询
1.ES中提供3种关联关系：Field collapsing（严格来说不是关联），Nested object，Parent-child。前两种都是直接将一个mapping声明在另一个mapping中，第三种关联是在创建子文档是指明他的父文档，但是一个子文档只能有一个父文档，因此也不能实现多对多的关联。其实如果理解了ES的目的是提升检索效率，就不难理解为什么没有多对多关联了，在关系数据库里这就是个效率瓶颈
2.使用父子查询可以，子文档每一篇指定父文档的id,但是父子查询性能比较差，并且当数据分布不均时，可能存在热点shard，最好结合业务测试一下

F1
Flink的运行架构(原理和流程)?
1.flink的整体架构是这样的核心是它runtime(运行时层),以jobGraph形式接受程序,
jobGraph 是一个并行化的数据流程图(data Flow) 它拥有任意数量的task 接受和
产生data stream
2.再往上的话是两种核心的api 一种是DataStream API 和 DataSet api,
分别对应我们的流处理和批处理,流处理上的又有CEP库和Table 批处理上面的
是FlinkML和Gelly,table
3.最下面是我们部署方式:local模式,集群模式(standAlone,yarn),Cloud(remote)
4.整体的编程过程是source–>transformation -->sink 的过程,transformation
使我们要实现的逻辑
写好程序之后,达成jar 开始运行,流出如下
1.client向hdfs 上传jar 包
2.向resourceMananger 提价任务申请资源
3.resourceMananger 分配资源并通知nodeManager 启动applicationMaster
4.applicationMaster启动后加载Flink 的jar并构建运行环境然后启动jobManager 和taskManager
5.jobManager 向taskManager 分配任务,并执行

flink 的窗口函数有几种？支持自定义吗？可以
1.Tumbling Window(滚动窗口)
2.Sliding Window(滑动窗口)
3.Session Window(会话窗口)
4.Global Window(全局窗口)
可以自定义,主要是一下步骤:
基本操作如下：
window：创建自定义窗口
trigger：自定义触发器
evictor：自定义evictor
apply：自定义window function

从定义窗口的基本操作可以看出，先调用window函数，定义一个WindowAssigner对象，
在WindowAssigner中通过 assignWindows 设定窗口类型，然后基于trigger，evictor来设定触发器，过滤器等，
最后apply来设定用户自定义的窗口函数，同时flink自身也集成了若干个窗口函数，如sum，max，maxBy，reduce等

Flink和spark区别?
1.架构设计方面
flink是真正意义上的流处理,spark 是微批处理
2.处理速度
Flink处理数据是在毫秒级别,spark是秒级别

Flink作业的监控怎么实现?
1.Metrics
首先，常用的如 Counter，写过 mapreduce 作业的开发人员就应该很熟悉 Counter，其实含义都是一样的，就是对一个计数器进行累加，即对于多条数据和多兆数据一直往上加的过程。
第二，Gauge(给鸡原意:测量)，Gauge 是最简单的 Metrics，它反映一个值。比如要看现在 Java heap 内存用了多少，就可以每次实时的暴露一个 Gauge，Gauge 当前的值就是heap使用的量。
第三，Meter，Meter 是指统计吞吐量和单位时间内发生“事件”的次数。它相当于求一种速率，即事件次数除以使用的时间。
第四，Histogram，Histogram 比较复杂，也并不常用，Histogram 用于统计一些数据的分布，比如说 Quantile、Mean、StdDev、Max、Min 等。

Flink的编程模型?
1.DataSet API用于批处理
2.DataStream API用于流式处理
A.获得执行环境，
B.加载/创建初始数据，
C.指定此数据的转换，
D.指定放置计算结果的位置，
E.触发程序执行

Flink 的反压机制?
1.反压机制出现的原因:在保证数据不丢失的前提下,以最高效的方式处理数据
2.把处理端的数据积压反馈到source端,从而增大和减少数据的获取数据的速度
具体原理如下:
1.5版本之前是采用TCP形式反压,这种形式弊端是:TM中会有多个Task运行，所以单个Task的反压会阻断整个TM的socket,此外反压传播路径长，导致生效延迟比较大。
因此1.5之后进行改进,引入了credit这种反压机制

flink的水印机制能说一下嘛？
1.水位线机制是针对于eventTime而言的,水印是Flink判断迟到数据的标准，同时也是窗口触发的标记
特点如下:
A.水印并不会影响原有Eventtime
B.当数据流添加水印后，会按照水印时间来触发窗口计算
C.一般会设置水印时间，比Eventtime小几秒钟
D.当接收到的水印时间 >= 窗口的endTime，则触发计算

Flink 提交jar 包的命令
A./app/flink-1.9.1/bin/flink run
-m node1:8081
/app/flink-1.9.1/examples/batch/flink-demo_1.0-SNAPSHOT_20200330120613.jar
-c com.dqu.flink.submit.task.KafkaOnHDFSAsHive
–para 10
B./bin/flink run -m yarn-cluster -yn 2 ./examples/batch/WordCount.jar --input /app/flink/flink-1.9.1standalone/README.txt --output /app/flink/flink-1.9.1standalone/

flink数据不丢失如何保证?
1.反压机制
2.水位线机制
3.基于状态(state)的存储
与批计算相比，State是流计算特有的，批计算的failover机制，是失败后重新计算；流计算在大多数场景下是增量计算，数据逐条处理，每次计算是在上一次计算结果之上进行处理的，这就要求对上一次的计算结果进行存储，当因为机器，网络，脏数据等原因导致程序错误的时候，可以重启Job进行state恢复。Flink就是基于state存储，通过CheckPoint机制来保证数据的准确性。

此外，State存储的内容还有流计算过程中计算节点的中间结果或元数据属性，比如Window方面的操作，需要累加数据；在aggregation过程中的中间聚合结果；在以Apache Kafka作为数据源时候，记录已经读取数据的offset等

flink 的state存储如何实现?
1.flink内部有三种状态的内部实现
A.(默认)基于内存的MemoryStateBackend- 在debug模式使用，在生产模式下不建议使用；

B.基于HDFS的FsStateBackend –基于分布式文件系统的持久化，每次读写都产生网络IO，整体性能不太好；

C.基于RocksDB的RocksDBStateBackend - 本地文件+异步HDFS持久化，当前版本在生产环境下使用的

flume的场景问题,使用过程当中,flume拉取日志拉取一半的时候,会产生一个.tmp文件？这个.tmp文件里面是什么? 如果删除了.tmp文件,kafka能不能接受到数据?
1…tmp文件是刷新之间的数据,删除之后会影响结果(待定)

Flume 拉取Nginx日志服务器和log4j的区别?
nginx的日志是埋点自定义的而log4j是标准输出日志

Flume的监控?
有两种方式:
A.Http监控
bin/flume-ng agent --conf conf --conf-file conf/flume_conf.properties --name collect -Dflume.monitoring.type=http -Dflume.monitoring.port=1234
B.ganglia 监控
这种监控方式需要先安装ganglia然后启动ganglia，然后再启动flume的时候加上监控配置
bin/flume-ng agent --conf conf --conf-file conf/producer.properties --name collect -Dflume.monitoring.type=ganglia -Dflume.monitoring.hosts=ip:port
Ganglia监控Flume发现发现尝试提交的次数大于最终成功的次数
（1）增加Flume内存
（2）增加Flume台数

Flume自定义拦截器(过滤)?
1.flume自带的拦截器
Timestamp Interceptor；时间戳拦截器
Host Interceptor；主机名称拦截器
Static Interceptor；
UUID Interceptor；UUID拦截器
Morphline Interceptor；
Search and Replace Interceptor；查询替换拦截器
Regex Filtering Interceptor；正则过滤拦截器
Regex Extractor Interceptor；正则抽取拦截器
2.自定义拦截器步骤
a）实现 Interceptor
b）重写四个方法
initialize 初始化
public Event intercept(Event event) 处理单个Event
public List intercept(List events) 处理多个Event，在这个方法中调用Event intercept(Event event)
close 方法
c）静态内部类，实现Interceptor.Builder

Flume支不支持一对多关系?
1.不支持
2.支持

flume写hdfs写入的时候产生很多小文件,怎么处理?
flume有三种滚动方式。
1.按照时间
2.按照大小
3.按照count.
如何时间不合适就用大小来处理

Flume+Spark streaming pull 和push 两种方式的区别?

flume和logtash的区别?
Logstash：有ELK 技术成熟使用场景广泛数据预处理带缓存
Flume：分布式业务场景事务传输配置复杂轻量级线程对接数据源有优势
Sqoop2：Hadoop和关系型数据库相互转换

flume的容灾机制和负载均衡?
1.负载均衡
首先了解一下文件内容是什么意思
a1.sinkgroups = g1
a1.sinkgroups.g1.sinks = k1 k2 k3
a1.sinkgroups.g1.processor.type = load_balance
a1.sinkgroups.g1.processor.backoff = true #如果开启，则将失败的 sink 放入黑名单
a1.sinkgroups.g1.processor.selector = round_robin # 另外还支持 random 随机round_robin 是轮训的意思
a1.sinkgroups.g1.processor.selector.maxTimeOut=10000 #在黑名单放置的超时时间，超时结
束时，若仍然无法接收，则超时时间呈指数增长
2.flume 的容错机制
Failover Sink Processor 能够实现 failover(失效备援) 功能。
Failover Sink Processor 维护一个优先级 Sink 组件列表，只要有一个 Sink
组件可用，Event 就被传递到下一个组件。故障转移机制的作用是将失败的 Sink
降级到一个池，在这些池中它们被分配一个冷却时间，随着故障的连续，在重试
之前冷却时间增加。一旦 Sink 成功发送一个事件，它将恢复到活动池。 Sink 具
有与之相关的优先级，数量越大，优先级越高。
例如，具有优先级为 100 的 sink 在优先级为 80 的 Sink 之前被激活。如果
在发送事件时汇聚失败，则接下来将尝试下一个具有最高优先级的 Sink 发送事
件。如果没有指定优先级，则根据在配置中指定 Sink 的顺序来确定优先级。

flume为什么选择kafkachannel

1.传统方式:TailFileSource–>MemoryChannel–>KafkaSink的这种方式
这种方式的弊端:
A.TailFileSource只能监听一个文件
B.MemoryChannel数据会有堆积，内存可能溢出（而FileChannel又比较慢）
C.这种方式经历多个组件，效率变低，出现问题的概率也变大。
2.新的思路：
使用TailFileSource–>KafkaChannel这种方式，将KafkaChannel作为缓冲，效率变高，而且数据不会丢失"

flume的事务机制?
1.Put事务(source–>channnel)
doput :先将批数据写入临时缓冲区putlist里面
docommit：去检查channel里面有没有空位置，如果有就传入数据，如果没有那么dorollback就把数据回滚到putlist里面。
2.Take事务(channel–>sink)
dotake：将数据读取到临时缓冲区takelist，并将数据传到hdfs上。
docommit :去判断数据发送是否成功，若成功那么清除临时缓冲区takelist
若不成功（比如hdfs系统服务器崩溃等）那么dorollback将数据回滚到channel里面

范式建模(范式建模和维度建模的区别)?
规范的数仓为了方便管理,通常分层级3层以上
ods dwd dws ads 等等
维度建模源自下而上（DM-DW）的数据仓库架构。
它的特点是:模型结构简单,星型模型为主,开发周期短,
能够快速迭代,维护成本高
方式建模是自上而下的数据仓库架构
同一份数据只存放在一个地方，因此只能从一个地方获取，没有数据冗余，保证了数据一致性；
解耦（系统级与业务级），方便维护；
开发周期较长，开发成本较高
1.范式建模
设计思路自上而下，适合上游基础数据存储，同一份数据只存储一份，没有数据冗余，方便解耦，易维护，缺点是开发周期一般比较长，维护成本高
2.维度建模
设计思路是自下而上，适合下游应用数据存储，适合统计多层次维度的汇总，开发周期短，缺点是维护成本高

G1
GC相关问题:
1.什么样的对象是垃圾2.是垃圾怎么回收,3用的什么算法,各有什么特点
1.判断对象是否"活着",死去的就是垃圾
2.通过算法判断
3.1 Mark-Sweep（标记-清除）算法
优点：标记-清除算法实现起来比较容易
缺点：但是有一个比较严重的问题就是容易产生内存碎片，碎片太多可能会导致后续过程中需要为大对象分配空间时无法找到足够的空间而提前触发新的一次垃圾收集动作。
3.2 Copying（复制）算法
优点：这种算法虽然实现简单，运行高效且不容易产生内存碎片。

缺点：但是却对内存空间的使用做出了高昂的代价，因为能够使用的内存缩减到原来的一半

3.3 Mark-Compact（标记-整理）算法
为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存
3.44.Generational Collection（分代收集）算法
分代收集算法是目前大部分JVM的垃圾收集器采用的算法。
它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。

一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation）
老年代的特点是每次垃圾收集时只有少量对象需要被回收
新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法

grouobykey和reducebykey和aggregateByKey三种对比?
1.groupByKey()是对RDD中的所有数据做shuffle,根据不同的Key映射到不同的partition中再进行aggregate。
2.reduceByKey()也是先在单台机器中计算，再将结果进行shuffle，减小运算量
3.aggregateByKey()是先对每个partition中的数据根据不同的Key进行aggregate，然后将结果进行shuffle，完成各个partition之间的aggregate。因此，和groupByKey()相比，运算量小了很多。
4.distinct()也是对RDD中的所有数据做shuffle进行aggregate后再去重。

ha的原理
1.主备关系:一主一备
2.难点:1)如何保证主备之间信息同步,这样才能保证无缝切换2)防止脑裂情况的发声
3.基于zk 并且有zkfc 机制 :

H1
fsimage和edit的区别?
1.当NN SN 同步数据同步的时候就用到了fsimage与edit,edit记录我们对hdfs的最新的操作,达到周期值(可以自行设置),把edit的信息合并到fsimage ,生成一个新的fsimage

Hadoop(datanode)宕机的原因和解决办法?
1.主从节点ID 不一致原因多数是对nameNode 多次format 造成
2.dataNode 磁盘空间占满

hashMap的底层原理?
数组：其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量彼此之间没有任何的关联。存储区间连续，占用内存严重，数组有下标，查询数据快，但是增删比较慢；

链表：一种常见的基础数据结构，是一种线性表，但是不会按照线性的顺序存储数据，而是每一个节点里存到下一个节点的指针。存储区间离散，占用内存比较宽松，使用链表查询比较慢，但是增删比较快；

哈希表：Hash table 既满足了数据的快速查询（根据关键码值key value 而直接进行访问的数据结构），也不会占用太多的内存空间，十分方便。哈希表是数组加链表组成。
1.HashMap底层就是一个数组结构，数组中的每一项又是一个链表。数组+链表结构

hashshuffle 为什么被淘汰而是采用采用sortShuffle?
1.总概括
Spark2.0X版本前，使用的是hashShuffle和优化过后的hashShuffle两种模式
Spark2.0X版本后，开始使用sortShuffle和bypass模式下的sortShuffle两种模式
2.前提:
在Spark中Executor的一个core一次性只能处理一个task的数据，
在Spark中一个partition对应一个task
3.hashShuffle的缺点
因为hashShuffle 的是依据reduceTask 进行hash 散列,一个task的数据溢写到一个磁盘file中，一个file对应一个reducetask去读取
这种模式的缺点就是小文件太多,优化之后小文件仍然很多
4.sortShuffle的优点
Spark的sortShuffle模式，对数据进行sort全排序，然后写入磁盘，一个task只生成一个file文件；并且在索引文件中记录了每个reducetask需要拉取的那部分数据的start offset和end offset，所以reducetask在拉取file数据前需要先读取索引文件，然后再去数据结构中拿到相应的那部分切片数据。
5.总结
采用sortShuffle起到了两点好处：

小文件明显变少了，一个task只生成一个file文件
2.file文件整体有序，加上索引文件的辅助，查找变快，虽然排序浪费一些性能，但是查找变快很多

HashMap和HashTable区别?
1.线程安全性不同
hashTable 线程安全,效率低下 hashMap 相反
2.key和value是否允许null值
hashTable key 不能是null 但是hashMap可以有一个
3.数组初始化和扩容机制
ashtable的初始长度是11，之后每次扩充容量变为之前的2n+1（n为上一次的长度）
而HashMap的初始长度为16，之后每次扩充变为原来的两倍
创建时，如果给定了容量初始值，那么Hashtable会直接使用你给定的大小，而HashMap会将其扩充为2的幂次方大小

hadoop的机架感知(或者说是扩普)?
数据块会优先储存在namenode机架近的机器上
1.如果一个机架出回题,不会影响数据读写
2.写入数据的时候会写到不同机架的 DataNode中
3. MapReduce会根据机架获取离自己比较近的网络数据(就近原则)

hadoop的TextInputFormat作用是什么，如何自定义实现
1.作用InputFormat会在map操作之前对数据进行两方面的预处理
A.是getSplits，返回的是InputSplit数组，对数据进行split分片，每片交给map操作一次
B.是getRecordReader，返回的是RecordReader对象，对每个split分片进行转换为key-value键值对格式传递给map
常用的InputFormat是TextInputFormat，使用的是LineRecordReader对每个分片进行键值对的转换，以行偏移量作为键，行内容作为值
2.自定义实现
自定义类继承InputFormat接口，重写createRecordReader和isSplitable方法
在createRecordReader中可以自定义分隔符

Hbase的读写流程(结合架构图说)
1.读流程
A.客户端通过zookeeper以及root表和meta表找到目标数据所在的regionserver
B.联系regionserver查询目标数据
C.regionserver定位到目标数据所在的region，发出查询请求
D.region先在memstore中查找，命中则返回
E.如果在memstore中找不到，则在storefile中扫描,最后结果返回
2.写流程
A.client向region server提交写请求
B.region server找到目标region
C.region检查数据是否与schema（表结构）一致
D.如果客户端没有指定版本，则获取当前系统时间作为数据版本
E.将更新写入WAL log 和 Memstore
F.判断Memstore的是否需要flush为StoreFile文件。完成!!

hbsae的协处理器
为什么会出现协处理器:
在0.92版本之前创建二级索引较难，很难进行简单的排序、求和、计数等操作。这里是指在该版本限制下难以进行上述操作，不是不行。为了降低难度，提出了协处理器的概念。
两类
1.observer(类似于关系数据库的触发器)
A、RegionObserver：用户可以通过这种处理器来处理数据修改事件，它们与表的Region紧密关联。region级的操作。对应的操作是：put/delete/scan/get
B、MasterObserver：可以用作管理或DDL类型的操作，是集群级的操作。对应的操作是：创建、删除、修改表。
C、WALObserver：提供控制WAL的钩子函数。
2.endPoint(类似于关系数据库的存储过程)
将用户的自定义操作添加到服务器端，endPoint可以通过添加远程过程调用来扩展RPC协议。用户可以将自定义完成某项操作代码部署到服务器端。例如：服务器端的计算操作。

Hbase优化有哪些?
1.AutoFlush 设置为false ,然后可以批量导入数据
2.WAL Flag hbase 写入数据的时候,首先会吓到WAL(Write Ahead Log)日志,既Hlog日志,一个RegionServer上的所有Region共享一个HLog,只有当WAL日志写成功后，再接着写MemStore,如果写入数据失败,客户端被告知提交失败，这样做的好处是可以做到RegionServer宕机后的数据恢复 ,当然对于不太重要的数据,可以调用Put.setWriteToWAL(false)或Delete.setWriteToWAL(false)函数，放弃写WAL日志，以提高数据写入的性能。
3.Compression 压缩
数据量大，边压边写也会提升性能的，毕竟IO是大数据的最严重的瓶颈，哪怕使用了SSD也是一样。众多的压缩方式中，推荐使用SNAPPY。从压缩率和压缩速度来看，性价比最高
4.批量写
调用HTable.put(Put)方法可以将一个指定的row key记录写入HBase,HTable.put(List)方法可以将指定的row key列表，批量写入多行记录
5.多并发编程
写在客户端开启多个 HTable 写线程，每个写线程负责一个 HTable 对象的 flush 操作，这样结合定时 flush 和写 buffer（writeBufferSize），可以既保证在数据量小的时候，数据可以在较短时间内被 flush（如1秒内），同时又保证在数据量大的时候，写 buffer 一满就及时进行 flush。
6.HMaster 配置成主备形式高可用
7.rowkey 设计优化
8.创建表的时候,开启预分区

hbsae的热点问题?
1.当大量的client访问hbase集群的一个或少数几个节点，造成少数region server的读/写请求过多、负载过大，而其他region server负载却很小，就造成了“热点”现象
2.热点带了的问题
大量访问会使热点region所在的单个主机负载过大，引起性能下降甚至region不可用
3.引发热点的原因
有大量连续编号的row key ==> 大量row key相近的记录集中在个别region

hbase数据(使用spark读取)具体写了什么代码？
1.val hbaseRDD = sc.newAPIHadoopRDD(configuration, classOf[TableInputFormat], classOf[ImmutableBytesWritable], classOf[Result])

hbase一整表能存多大数据?
1.亿如10亿条

hbase LSM?
https://blog.csdn.net/u014432433/article/details/51557834

hbase的导入批量数据的方式?
1.sql (hive/phoenix) 批量执行sql
2.hbase api (put) putList
3.bulkLoad :在外生成Hfile 不在经过wal–>memorystore ,直接存放到hbase中
弊端是:1.只适合初次数据导入 2.hbase和hadoop 必须同在一个集群

hbase的过滤器
1.行键过滤器 RowFilter
2.列簇过滤器 FamilyFilter
3.列过滤器 QualifierFilter
4.值过滤器 ValueFilter
5.时间戳过滤器 TimestampsFilter
6.专用过滤器
A.单列值过滤器 SingleColumnValueFilter ----会返回满足条件的整行
B.单列值排除器 SingleColumnValueExcludeFilter
C.前缀过滤器 PrefixFilter----针对行键
D.列前缀过滤器 ColumnPrefixFilter
E.分页过滤器 PageFilter

Hbase 支持事务吗？
支持 Hbase事务原子性
Hbase的数据会先写入WAL,再写入Memstore,写入Memstore的时候出现异常可以回滚
Hbase的事务一致性保证:强制一致性保证
Hbase的事务隔离
每次都是在写入的时候先获取行锁，如果获取不到就说明其他线程已经获取了行锁，就需要不断的等待直到其他线程释放该锁才可以写入数据
Hbase的持久化
HBase事务持久化可以理解为WAL持久化ASYNC_WAL表示异步将WAL持久化到硬盘

hbase中WAL和HLog是什么?
WAL（Write Ahead Log）相似于MySQL BIN日志; 它记录了数据中发生的所有变化。它是Hadoop的标准序列文件，它存储HLogkey。这些密钥由序列号和实际数据组成，使用于在服务器崩溃后重放尚未保留的数据。因而，在服务器故障的现金中，WAL作为生命线工作并检索丢失的数据。

hbase的关健组件是什么？
1.HMaster的作用：
A.为region server 分配region；
B.负责region server的负载均衡，region分裂完成监控；
C.处理schema更新请求，数据表的创建，更新；
D.HDFS上的垃圾文件回收；
E.发现失效的region server并重新分配上面的region；

2.HRegionServer的作用：
A.切分过大的region，合并region；
B.维护master分配的给的region，并处理这些io请求；
C.负责数据的读写功能，如果hmaster挂了，不影响数据的读写操作。

3.zookeeper的作用：
A.HRegionServer向zookeeper注册，提供是否还在线的信息；
B.Hbase启动的时候将hbase系统表加载到zk cluster，zk cluster获取当前表上有的regionserver信息；
C.Hmaster提供是否在线，避免单点故障；
4.Region：它包含在内存数据存储（MemStore）和Hfile中。
5.目录表：目录表由ROOT和META组成

Hbase rowkey设计的原则,你们怎么设计的?
1.rouwkey长度不超过16个字节，最好加上时间戳，按天分表，提高查询效率
2.防止热点问题:高位做散列（最好两字节做散列，四个字节存时间）在rowkey加盐（类如在rowkey前拼接字符串–UUID）
3.rowkey 是按照字典顺序排列的
rowkey:
区号|间戳|身份证号/设备id/手机号|tableName

HDP的版本?
2.6.5

Hdfs如何实现磁盘挂载问题?
0.使用mount 增加磁盘空间

修改配置文件hdfs-site.xml

dfs.datanode.data.dir /data1/appData/hdfs/data /data2/appData/hdfs/data 2.添加修改磁盘存放选择策略 dfs.datanode.fsdataset.volume.choosing.policy org.apache.hadoop.hdfs.server.datanode.fsdataset.AvailableSpaceVolumeChoosingPolicy

hdfs的读写流程图(边画边讲)?
1.读流程
(1)使用HDFS提供的客户端开发库，向远程的Namenode发起RPC请求；
(2)Namenode会视情况返回文件的部分或者全部block列表，对于每个block，Namenode都会返回有该block拷贝的datanode地址；
(3)客户端拿到block的位置信息后调用FSDataInputStream API的read方法并行的读取block信息，图中4和5流程是并发的，block默认有3个副本，所以每一个block只需要从一个副本读取就可以。客户端开发库会选取离客户端最接近的datanode来读取block；
(4)读取完当前block的数据后，关闭与当前的datanode连接，并为读取下一个block寻找最佳的datanode；返回给客户端。
(5)当读完列表的block后，且文件读取还没有结束，客户端开发库会继续向Namenode获取下一批的block列表。
读取完一个block都会进行checksum验证，如果读取datanode时出现错误，客户端会通知Namenode，然后再从下一个拥有该block拷贝的datanode继续读。
2.写流程
（1）客户端向NameNode发出写文件请求。
（2）检查是否已存在文件、检查权限。若通过检查，直接先将操作写入EditLog，并返回输出流对象。
（3）client端按128MB的块切分文件。
（4）client将NameNode返回的分配的可写的DataNode列表和Data数据一同发送给最近的第一个DataNode节点
client端和NameNode分配的多个DataNode构成pipeline管道，client端向输出流对象中写数据。
（5）每个DataNode写完一个块后，会返回确认信息。
（6）写完数据，关闭输输出流。
（7）发送完成信号给NameNode

hive的参数优化:
1.map 和reducer 的数量
2.tez将会根据vertice的输出大小动态预估调整reduce的个数(底层引擎设置)
3.Map Join优化, 不太大的表直接通过map过程做join(map 端join)
set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;

hdfs的调优经验?
1.小文件提前合并
2.配置压缩格式 / 备份数目
3.配置datanode 的文件存储路径
4.开启JVM重用
5.合理设置block的大小(dfs.block.size)
6.将中间结果目录设置为分布在多个磁盘以提升写入速度（mapred.local.dir）
7.设置DadaNode处理RPC的线程数，大集群可以适当加大。（dfs.datanode.handler.count）

HQL转化为MR?
1.交互接口提交SQL
2.驱动器驱动
3.解析器,进行解析
4.编译器,进行编译
5.优化器,进行优化
6.执行器进行执行的过程

hive的数据倾斜问题?
1.数据倾斜(join)
a.大表（2.8G）与小表关联（580K）(会发生)
b.大表（2.8G）与大表（3.0G）关联(不会发生)
：由于大表与小表数据量相差3000倍，遍历整个过程需要大表数据条数X小表的数据条数=总量。这样会导致数据严重倾斜。具体表现：后台数据写入一直出去某种状态如控制台一直处于38%处理状态。二，磁盘的容量被大量占用，严重会导致集群崩溃。

解决方案：左右表关联查询将小表置于左侧。这样其数据先读入磁盘中（原理仅用map在磁盘中处理），减少线上（reduce）数据处理的压力。
2.group by (每一个字段值过多)

A.map 端提前解决提前聚合相当于Combiner

hvieSql的优化?
1.分区设置
动态分区和静态分区尽量是动态分区使用起来比较方便
set hive.exec.dynamic.partition=true;
set hive.exec.dynamic.partition.mode=nonstrict;
2.分桶
set hive.enforce.bucketing=true;
set hive.enforce.sorting=true;
3.join优化
hive.optimize.skewjoin=true;如果是join过程中出现倾斜应该设置为true
set hive.skewjoin.key=100000; 这个是join的键对应的记录条数，超过这个值则会进行优化
4.mapjoin
set hive.auto.convert.join=true;
hive.mapjoin.smalltable.filesize默认值是25mb
select /+mapjoin(A)/f.a, f.b from A t join B f on (f.a=t.a)
5.group by优化
hive.group.skewindata=true; 如果是group by过程出现倾斜，应该设置为true
set hive.groupby.mapaggr.checkinterval=100000; 这个是group的键对应的记录条数超过这个值则会进行优化
6.并行化执行
set hive.exec.parallel=true;
set hive.exec.parallel.thread.number=8;
7.输入输出小文件合并
8.jvm 的重用
set mapred.job.reuse.jvm.num.tasks=20;
9.压缩格式
中间压缩就是处理hive查询的多个job之间的数据，对于中间压缩，最好选择一个节省CPU耗时的压缩方式比如snappy

hiveSql训练:
1.rowNumber() over() :打标函数例题:找出所有学生中成绩从来没有低于60分的学生student_id
2.

hive和hbase的整合？怎么整合？
1.复制hbase 的jar 包到hive 的目录下面
hbase-client-0.98.13-hadoop2.jar
hbase-common-0.98.13-hadoop2.jar
hbase-server-0.98.13-hadoop2.jar
hbase-common-0.98.13-hadoop2-tests.jar
hbase-protocol-0.98.13-hadoop2.jar
htrace-core-2.04.jar
hive-hbase-handler-1.0.0.jar
zookeeper-3.4.5.jar
2.修改hive-site.xml 的目录
hive.aux.jars.path 把对应的jar 配上去
3.修改hive.zookeeper.quorum 属性

hive支持的底层数据格式?他们之间的差别
1.TextFile:默认的类型，行存储不对文本进行压缩,效率比较低下
2.rcfile:按行块，每块再按列存储
3.avro:二进制 Avro是一个数据序列化系统，设计用于支持大批量数据交换的应用。
4.ORC rcfile:的升级版，默认是zlib,支持snappy 其格式不支持
5.parquet :列式快
6.SEQUENCEFILE:二进制文件,以<key,value>的形式序列化到文件中,可分割,可压缩,优势是文件和Hadoop api中的mapfile是相互兼容的

hive如何自定义函数?
1.继承类如 UDF
2.重写方法如evaluate
3.打成jar包
4.添加jar 到lib 目录
5.配置hive-site.xml
6.注册成函数

hive内部表和外部表的区别?
1.hive创建表的时候通过 external修饰的来创建外部表,没有 external的则是内部表,
2.当删除内部表时,存储在HDFS的数据将会被一起删除,而删除外部表时,数据则会保留

hvie的条件函数coalesce?
从左到右返回第一个不为NULL

hive 使用窗口函数切割url
1.parse_url 使用此函数就能解决问题
parse_url(url, partToExtract[, key]) - extracts a part from a URL
artToExtract的选项包含[HOST,PATH,QUERY,REF,PROTOCOL,FILE,AUTHORITY,USERINFO]
A.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘PROTOCOL’) from dual;
–http
B.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘PROTOCOL’) from dual;
–http
C.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘REF’) from dual;
—空
D.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘PATH’) from dual;
—/category/12258437290
E.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘QUERY’) from dual;
—query=test
F.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘QUERY’) from dual;
—query=test
G.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘QUERY’) from dual;
—query=test
H.select parse_url(‘http://hujiang.com/category/12258437290?query=test’, ‘USERINFO’) from dual;
—空

hive常见的基础函数使用
rpad: rpad(string str, int len, string pad)。将str进行用pad进行右补足到len位
lpad:(string str, int len, string pad)。将str进行用pad进行左补足到len位
Split:split(string str, string pat)。按照pat字符串分割str，会返回分割后的字符串数组
举例：select split(‘abtcdtef’,‘t’) from dual; ##返回值为[“ab”,“cd”,“ef”]
explode函数可以将一个array或者map展开，其中explode(array)使得结果中将array列表里的每个元素生成一行；explode(map)使得结果中将map里的每一对元素作为一行，key为一列，value为一列，一般情况下，直接使用即可，但是遇到以下情况时需要结合lateral view 使用
regexp_replace:替换函数

Hive的分区和分桶的区别?
1.partition By( )
分区就是分文件夹，在表文件夹下多一个文件夹，分区字段是虚拟的，用于标识文件，分区字段一定不是表中存在的字段，否则会便宜报错
2.cluster into
分桶功能默认不开启，需要手动开启，分桶个数自定义，是相对于分区更细粒度的划分，是分文件

hive的窗口函数?
RANK() 排序相同时会重复，总数不会变
DENSE_RANK() 排序相同时会重复，总数会减少
ROW_NUMBER() 会根据顺序计算

验证实例如下:

hive的动态分区和静态分区的区别?
静态分区 SP（static partition）
1、静态分区是在编译期间指定的指定分区名
2、支持load和insert两种插入方式
2.1load方式
1）会将分区字段的值全部修改为指定的内容
2）一般是确定该分区内容是一致的时候才会使用
2.2insert方式
1）必须先将数据放在一个没有设置分区的普通表中
2）该方式可以在一个分区内存储一个范围的内容
3）从普通表中选出的字段不能包含分区字段
3、适用于分区数少，分区名可以明确的数据

动态分区 DP（dynamic partition）
1、根据分区字段的实际值，动态进行分区
2、是在sql执行的时候进行分区
3、需要先将动态分区设置打开（set hive.exec.dynamic.partition.mode=nonstrict ）
4、只能用insert方式
5、通过普通表选出的字段包含分区字段，分区字段放置在最后，多个分区字段按照分区顺序放置

I1
idea 中安全删除啥意思?
删除的时候,给你做调用地方检查,如果有就给你提示,如果没有就直接删除

impala(presto kylin )组件的调优
1.大数据量来说，Parquet文件格式是最佳的选择合适的Parquet块大小
2.防止入库时产生大量的小文件(insert … values会产生大量小文件，应该避免使用)
在impala外生成数据时，最好是text格式或者Avro，这样你就可以逐行的构建文件，到了impala之后，再通过简单的insert … select语句将其转换为Parquet格式
3.根据实际的数据量大小选择合适的分区粒度
4.确认查询是以高效的逻辑方式进行规划
在执行之前使用EXPLAIN来查看逻辑规划，分析执行逻辑

J1
job (spark运行有多少job/job界定的方式)?
一个action算子就是一个job
一个类的有30左右,然后循环使用

join(mapjoin跟redurcejoin的区别以及代码实现)？
hive 中的join可分为俩类，一种是common join（也叫Reduce join或shuffle join),另一种是 map join，后者是对hive join的一个优化，
利用本地的task对较小的表hash生产一个hashtable文件，然后直接和map出来另一个表进行匹配，最终完成join
set hive.auto.convert.join = false 在0.7.0到0.10.0版本默认是false，表示不使用优化
set hive.auto.convert.join = true在0.11.0到之后的版本是ture,代表使用优化

集群的规模和版本(遇到哪些坑)?
1.hdp 集群规模问题
2.kafka版本问题
3.phonenix 版本对SQL 支持的问题
4.impala 和ambari 平台集成的问题

计算引擎(公司主要的计算引擎)是什么?
hive(mr) spark flink storm(逐渐淘汰)

棘手的问题(工作和项目遇到的)?
1.数据倾斜
2.即时查询问题
3.数据丢失问题
4.hbase 增量导入问题

java -jar 和java -cp 的区别?
1.java -jar 执行命令的时候会用到会用到目录META-INFMANIFEST.MF文件，在该文件中，有一个叫Main－Class的参数，它说明了java -jar命令执行的类
2.java -cp 和 -classpath 一样，是指定类运行所依赖其他类的路径，通常是类库，jar包之类，需要全路径到jar包，window上分号“;”
A.打包时指定了主类，可以直接用java -jar xxx.jar。当然也可以使用 -cp 但是需要手动指定主类
B.打包时没有指定主类就是java -cp jarName mainClass
C.要引用其他的jar包，可以用java -classpath $CLASSPATH:xxxx.jar 主类名称（绝对路径）。其中 -classpath 指定需要引入的类。

jvm 每一个区存储的内容:
1.虚拟机(jvm)主要有程序计算器,虚拟机栈,本地方法栈,堆和方法区
A.程序计算器是一块比较小的内存空间,主要存放代码执行的位置,分支,循环,跳转,异常处理,线程回复等基本功能都需要一个计数器来完成
B.经常有人把java内存分为堆内存和栈内存。这里所说的栈指的就是虚拟机栈虚拟机栈中存放了各种基本数据类型和对象引用
C.堆和方法区是各个线程共享的内存区域堆是jvm所管理的内存中最大的一块,在虚拟机启动的时候创建,此区域的唯一目的就是为了存放对象实例
D.方法区:用于存放被虚拟机加载的类信息,常量,变量,也就是编译器编译之后的代码
另外运行时常量池用于存放编译器生产的各种字面量和符号引用

jvm垃圾收集器,各自的优缺点?
1.如果说

jvm调优经验
https://www.cnblogs.com/baizhanshi/p/6590406.html

java实现同或|异或操作?
1.同或 :相同为真不同为假
2.异或 :不同为真相同为假

java中垃圾收集的方法有哪些?
1.引用计数法
2.复制算法
3.标记清除
4.标记压缩
5.标记清除压缩

Java自带有哪几种线程池？
Java通过Executors提供四种线程池，分别为：
1.newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
2.newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
3.newScheduledThreadPool创建一个定长线程池，支持定时和周期性任务执行
4.newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO，LIFO，优先级）执

K1
java语言和scala语言的区别?

二者的共性都是基于jvm运行,并且可以相互调用 scala和java最大区别就是scala是多范式的语言支持函数式编程当然具体细节方面有很多如:
A.源文件后缀名不一样 B.变量常量修饰不一样 var val C.函数定义不一样 D.循环写法不一样 E.集合类型 scala 独有tuple F.scala 独有的隐式转换功能 G.get set方法不一样
1,首先scala中没有interface scala 中有trait(类似java中抽象类)
2.scala中比较灵活可以不定义变量/常量声明类型
3.scala中的单例类是用ibject修饰,java需要自己实现
4.scala中通配符_ java中通配符*
5.scala 的返回值可以直接写 java 需要些return

课程回顾(各个组件的作用)?
主要所学技术:
1.数据采集传输:flume kafka sqoop logstash DataX
2.数据存储 :mysql hdfs hbsae redis mongpodb es
3.数据计算 :hive tez spark flink storm
4.数据查询 :presto impala Druid kylin

Kafka分区分配策略?
在 Kafka内部存在两种默认的分区分配策略：Range和 RoundRobin。
Range是默认策略。Range是对每个Topic而言的（即一个Topic一个Topic分），首先对同一个Topic里面的分区按照序号进行排序，并对消费者按照字母顺序进行排序。然后用Partitions分区的个数除以消费者线程的总数来决定每个消费者线程消费几个分区。如果除不尽，那么前面几个消费者线程将会多消费一个分区。

kafka出现数据积压问题,怎么解决?
1.增加分区数据和消费者的数量,提高消费能力
2.提高每批次拉取的数量和缩短批次等待时长

kafka跟sparkstreaming的两种连接方式
两种:awl 和直连 (公司常用的是直连)
1.awl
Awl :（createStream）自动维护偏移量有接收者 PUSH推送数据调用的Kafka高级API
2.直接
直连:（createDirectStream）手动维护偏移量没有接收者 PULL拉取数据调用kafka低级API

kafka高阶Api和低阶Api的区别
1.高级 API 写起来简单不需要去自行去管理offset，系统通过 zookeeper 自行管理
2.低级API 能够开发者自己控制 offset，想从哪里读取就从哪里读取。自行控制连接分区，对分区自定义进行负载均衡
对 zookeeper 的依赖性降低（如：offset 不一定非要靠 zk 存储，自行存储 offset 即可，比如存在文件或者内存中）

kafka消费者和分区的关系
topic下的一个分区只能被同一个consumer group下的一个consumer线程来消费，但反之并不成立，
即一个consumer线程可以消费多个分区的数据，比如Kafka提供的ConsoleConsumer，默认就只是一个线程来消费所有分区的数据。

即分区数决定了同组消费者个数的上限

kafka怎么增加消费者?
这取决于Topic/Partition的数量,假设M个topic，N个partition，那么可以用M * N个consumer扩展消费速度

kafka扩展一个节点，怎么保证分区分配一致，新加的kafka怎么和其他节点的kafka结合?
问题:
新增一台kafka 但是数据不经过这个节点?
迁移数据的过程是手动启动的(手动)==>整个过程自动化的
如何进行分区和数据的迁移?
执行bin下面重新分区命令 :
bin/kafka-reassign-partitions.sh --zookeeper localhost:2181 --topics-to-move-json-file topics-to-move.json --broker-list “5,6”
–generate
有三种模式:
–generate：在此模式下，给定主题列表和代理列表，该工具会生成候选重新分配，以将指定主题的所有分区移动到新代理。此选项仅提供了一种方便的方法，可在给定主题和目标代理列表的情况下生成分区重新分配计划。
–execute：在此模式下，该工具根据用户提供的重新分配计划启动分区的重新分配。（使用–reassignment-json-file选项）。这可以是由管理员手工制作的自定义重新分配计划，也可以使用–generate选项提供
–verify：在此模式下，该工具将验证最后一次–execute期间列出的所有分区的重新分配状态。状态可以是成功完成，失败或正在进行中
kafka 注册?
broker.id=2 配置文件给的(区别其他的节点)
zookeeper.connect=vm0:2181,vm1:2181,vm2:2181 启动的时候想zk 中注册自己信息

kafka的三种部署模式?
1)单broker模式
2)单机多broker模式 (伪集群)
3)多机多broker模式 (真正的集群模式)

kafka的hw和isr机制
1.HW(high waterMark):高水位,它标识了一个特定的消费偏移量(offset),
消费者只能拉去到offset 之前的数据
2.isr机制:kafka为了保证消息的一致性二提一种机制

Kafka的三种语义(你们用的是哪一种)?
1.最多一次
2.最少一次
3.仅有一次

Kafka有几种数据保留的策略？
Kafka有两种保存数据的策略:
1.按照过期时间保留
2.按照存储消息大小保留

kafka的数据如何做下一步的落地工作?
1.flink/Spark streaming 进行消费,然后逻辑分析
2.flume拉去kafka数据,然后写入我们数仓中

kafka为什么速度快?
1.Kafka速度的秘诀在于，它把所有的消息都变成一个批量的文件，并且进行合理的批量压缩，减少网络IO损耗
2.通过map提高I/O速度，写入数据的时候由于单个Partion是末尾添加所以速度最优读取数据的时候配合sendfile直接暴力输出
3.零拷贝技术，可以有效的减少上下文切换和拷贝次数
4.顺序写磁盘的性能是随机写入的性能的6000倍的提升，媲美内存随机访问的性能，磁盘不再是瓶颈点。

kafka如何做数据迁移?
https://www.cnblogs.com/smartloli/p/10551165.html

kafka多个partition如何保证顺序消费?
1.写入数据的时候通过partitionKey 将某类消息写入同一个partition
一个partition只能对应组内的一个消费线程，以保证数据有序。

Kafka的消费保证消息不重复,不丢失?
幂等原则,kafka ack机制(事务)
https://www.cnblogs.com/smartloli/p/11922639.html

kafka如何重置offset?
1.查看topic 的offset 范围
用下面命令可以查询到topic:DynamicRange broker:SparkMaster:9092的offset的最小值：
bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list slave6:9092 -topic videoplay --time -2
输出
DynamicRange:0:1288
查询offset的最大值：
bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list slave6:9092 -topic videoplay --time -1
输出
DynamicRange:0:7885
结论:从上面的输出可以看出topic:DynamicRange只有一个partition:0 offset范围为:[1288,7885]
2.设置consumer group的offset
启动zookeeper client
/zookeeper/bin/zkCli.sh
通过下面命令设置consumer group:DynamicRangeGroup topic:DynamicRange partition:0的offset为1288:
set /consumers/DynamicRangeGroup/offsets/DynamicRange/0 1288
注意如果你的kafka设置了zookeeper root，比如为/kafka，那么命令应该改为：
set /kafka/consumers/DynamicRangeGroup/offsets/DynamicRange/0 1288
生效
重启相关的应用程序，就可以从设置的offset开始读数据了

kafka(自己维护offset 代码演示)
https://blog.csdn.net/qq_38483094/article/details/99118140

kafka的offset过期了怎么办?
1.offset存放位置 0.9 版本之前放在zk中 0.9之后放在自己的一个topic中(__consumer_offsets),同时也保留了zk的接口,可以通过 offsets.storage 属性来进行设置
升级的原因是:ZKClient的API操作Zookeeper频繁的Write很低效,后期扩展受zk 影响比较大
2.offset 在zookeeper 中或者自身的一个topic中,默认保存的时间是24小时数据默认保存的时间是7天
offset过期造成的影响分情况来定:
过期分两种:1.offset过期 2.源数据过期
A.
B.
kafka_2.11-1.0.1 中的offset 默认失效时间是 24小时，也就是1440分钟。

配置参数为offsets.retention.minutes，单位是分钟。

kafka每10分钟运行一次清理过期offset数据。

所以如果offsets.retention.minutes 设置小于10分钟，则仍为10分钟清理。

就是说，默认情况下，如果你已经读到第5条了，然后停了24小时后再读，如果数据还没过期（log.retention.hours），则会从第一条重新开始读；而在24小时内重新开始读，则从第6条开始

kafka的group关系新添加一个group 对于offset的划分 ?

kafka怎么保证数据不丢失?
1.每个partition中有多个replication备份类似hdfs的备份机制
2.生产者 ack机制三种状态（0 1 -1）
0：不管接受没有接受数据，都发送下一条数据
1：只要leader确认接收到消息，才发送下一条数据
-1：只要follwer确认接收到消息，才发送下一条数据
3.Consumer 端保证数据不丢失
3.offset 偏移量，它是存放在zookeeper中保证数据不重复不丢失。Enable.auto.commit=true 开启自动提交（false关闭自动提交），一般是关闭，避免数据的丢失。新的版本0.9存在自己的topic

Kylin技术的理解?

K8s的理解和应用?

Kappa 架构(什么事kappa架构)?
真正意义上的流处理架构

L1
链表和数组的区别?
1.链表不用要连续的存储空间但是数组需要
2.链表的大小可动态变化,但是数组是固定的
3.链表增删较快数组较慢
4.链表查询较慢数组查询较快因为链表必须顺序访问,数组可以随机访问

零拷贝(kafka)是什么?
零拷贝就是一种避免 CPU 将数据从一块存储拷贝到另外一块存储的技术。针对操作系统中的设备驱动程序、文件系统以及网络协议堆栈而出现的各种零拷贝技术极大地提升了特定应用程序的性能，并且使得这些应用程序可以更加有效地利用系统资源。这种性能的提升就是通过在数据拷贝进行的同时，允许 CPU 执行其他的任务来实现的。
零拷贝技术可以减少数据拷贝和共享总线操作的次数，消除传输数据在存储器之间不必要的中间拷贝次数，从而有效地提高数据传输效率。而且，零拷贝技术减少了用户应用程序地址空间和操作系统内核地址空间之间因为上下文切换而带来的开销。进行大量的数据拷贝操作其实是一件简单的任务，从操作系统的角度来说，如果 CPU 一直被占用着去执行这项简单的任务，那么这将会是很浪费资源的；如果有其他比较简单的系统部件可以代劳这件事情，从而使得 CPU 解脱出来可以做别的事情，那么系统资源的利用则会更加有效。综上所述，零拷贝技术的目标可以概括如下：
避免数据拷贝
①避免操作系统内核缓冲区之间进行数据拷贝操作。
②避免操作系统内核和用户应用程序地址空间这两者之间进行数据拷贝操作。
③用户应用程序可以避开操作系统直接访问硬件存储。
④数据传输尽量让 DMA 来做。
将多种操作结合在一起
①避免不必要的系统调用和上下文切换。
②需要拷贝的数据可以先被缓存起来。
③对数据进行处理尽量让硬件来做

类加载的原理(过程)?
类装载器就是寻找类的字节码文件，并构造出类在JVM内部表示的对象组件。在Java中，类装载器把一个类装入JVM中，要经过以下步骤：

 装载：查找和导入Class文件。
链接：把类的二进制数据合并到JRE中。
校验：检查载入Class文件数据的正确性。
准备：给类的静态变量分配存储空间。
解析：将符号引用转成直接引用。
初始化：对类的静态变量，静态代码块执行初始化操作。

链表反转操作(java/scala)(一个单向链表如何实现反转)?
1.单链表:每个节点包含两部分,一部分存放数据变量的data,另一部分是指向下一节点的next指针
2.双联表:每个节点包含两部分,一部分存放数据变量的data,另一部分是指向下一节点的next指针
链表的优点在于,不需要连续的存储单元,修改链表的复杂度为O(1) (在不考虑查找时)
但是缺点也很明显:无法直接找到指定节点,只能从头节点一步一步寻找复杂度为O(n)

listBuffer ==> rdd 如何转换?
sc.mkRDD(list) sc.parallzie(list)

拉链表(什么是拉链表?怎么设计?你们业务怎么用)
https://blog.csdn.net/qq_27657429/article/details/103020761

Lambda 架构(什么事Lamdba架构)?
同时维护两种架构

Lucene是啥啊?
1.lucene是apache的一个开源项目,是一个全文检索引擎的架构,提供了完整的查询引擎和索引引擎

linux的目录结构?
https://www.cnblogs.com/pythonywy/p/11752701.html

Linux常用命令?
1.有关文件目录操作命令:ls cd pwd mkdir rmdir cp rm mv touch cat more head tail
2.用户管理的命令 :useradd userdel sermod passwd groupadd groupdel groupmod
3.磁盘管理的命令 :df du fdisk fsck mount unmount top
4.文件赋权命令 :chmod chwon
5.定时的命令 :crontab
6.进程相关命令 :ps jps kill
7.重启关系 :shutdown half
8.搜索查找 :find which grep
9.压缩解压 :gzip tar bzip2 zip unzip

M1
离线过程遇到哪些问题？你是怎么解决的？
1.问题:断点续传
解决:添加增量的标识 ,下次导入的时候读取上次的记录的增量继续导入
2.问题:数据倾斜
解决: 对key进行处理(加盐,hash,翻转) ,增加分区,提高并行度
3.问题:文件格式 Windows换行字符 cr lf linux换行符 lf 读取文件的时候出现问题
解决:直接在linux创建文件
4.问题: hbase热点
解决: rowkey重新设置
预分区的数量的添加(hbase shell命令常见分区,java API进行设置)

mapreduce的原理
“分而治之”

mapreduce的数据倾斜原因和解决办法?
1.原因
A.key分布不均匀 B.业务数据本身的特性 C.建表时考虑不周 D.某些SQL语句本身就有数据倾斜
2.解决办法
A.key 的打散两次mr B.map阶段对应某些key 提前进行一次合并 C.增加reduce个数

mapreducer的分区策略(如何分区的),分区如何确定的?
1.hashPartition (默认)
KV对根据key的hashcode值与reduceTask个数进行取模,决定该键值归哪一个reduceTask

mr的map端任务数量如何指定?reducer 数怎么指定?
1.map的个数是有文件的大小决定的,一般不需要我们设置,FileInputFormat分成了几个切片就会有几个mapper,当然如果文件是.gz格式的文件,无法进行切分,每个文件会生成一个mapper
2.reducer的个数如果不设置,会根据两个参数自动计算:
（1）hive.exec.reducers.bytes.per.reducer
这是每个reduce处理的数据量，默认为1G=1000000000
（2）hive.exec.reducers.max(每个任务的最大reduce个数，默认1009)
reduce个数=min(参数2，map端输出数据总量/参数1)
当然也可以直接设置:set mapred.reduce.tasks=5;

MR中排序发生在哪几个阶段？这些排序是否可以避免?
1.一个MapReduce作业由Map阶段和Reduce阶段两部分组成，这两个阶段会对数据排序
2.Map Task会在本地磁盘输出一个按照key排序（采用的是快速排序）的文件（中间可能产生多个文件，但最终会合并成一个）
3.在Reduce阶段，每个Reduce Task会对收到的数据排序，这样，数据便按照key分成了若干组，之后以组为单位交给reduce()处理
4.map阶段的提前合并是为了减轻reduce 的压力

mapreduce的调优
调优三原则：
1.增大作业并行程度
2.给每个任务足够的资源
3.在满足前两个的条件下，尽可能地给shuffle预留资源

MapJoin的原理
https://blog.csdn.net/u010010664/article/details/79731044

mapreduce的shuffle工作原理:
https://blog.csdn.net/youngflycode/article/details/82349680

MongoDB和Redis区别
1.MongODB更类似Mysq,支持字段索引、游标操作,其优势在于查询功能比较强大,擅长查询]SON数据,能存储海量数据,但是不支持事务。
Mysql在大数据量时效率显著下降, MongoDB更多时候作为关系数据库的一种替代

2.内存管理机制
Redis数据全部存在内存,定期写入磁盘,当内存不够时,可以选择指定的LRU算法删除数据。
MongoDB数据存在内存,由inux系统mmap实现,当内存不够时,只将热点数据放入内存,其他数据存在磁盘

3.支持的数据结构
Redis支持的数据结构丰富,包括hash、set、list等
MongoDB数据结构比较单一,但是支持丰富的数据表达,索引,最类似关系型数据库,支持的查询语言非常丰富

mysql的索引失效的场景
1.当语句中带有or的时候即使有索引也会失效
select * from USER where name=‘xzz’ or age=16； name 为索引
2.语句索引 like 带%的时候索引失效（注意：如果上句为 like‘xzz’此时索引是生效的）
select * from USER where name like‘%xzz’ ；
3.如果列类型是字符串，那一定要在条件中将数据使用引号引用起来,否则不使用索引
4.假如上述将name和age设置为联合索引，一定要注意顺序，mysql联合所以有最左原则，下面以name，age的顺序讲下

（1）select * from USER where name=‘xzz’ and age =11；

（2）select * from USER where age=11 and name=‘xzz’；

例如上诉两种情况：以name，age顺序为联合索引，（1）索引是生效的，（2）索引是失效的
5.比如age为索引：select * from USER where age-1>11;

例如这种情况：索引失效，不要在索引上进行操作，否则索引会失效（是有类似时间转换的问题和上诉问题一样）

mysql 的存储过程?
SQL语句需要先编译然后执行，而存储过程（Stored Procedure）是一组为了完成特定功能的SQL语句集，经编译后存储在数据库中，
用户通过指定存储过程的名字并给定参数（如果该存储过程带有参数）来调用执行它

mysql索引的原理?
B-Tree和B+Tree

mysql存储引擎?
1.InnoDB(默认)(支持事务)
2.MyISAM(不支持事务)
3.MEMORY
4.MERGE

MySQL的事务?
1.事务是一个最小的不可再分的工作单元
2.事务的特性
A.原子性
B.一致性
C.隔离性
D.持久性

N1
mysql/oracle中有的话就更新没有的话就插入?
1.mysql
INSERT INTO tableName (_id,password) VALUES (‘1’,‘多条插入1’)
ON DUPLICATE KEY UPDATE
password = VALUES(password);
2.oracle
merge into

npm 的介绍?
https://www.npmjs.cn/

你这边还有什么问题?
1.贵公司大数据岗位人员怎么分配的 2.咱们公司现在大数据情况、 3.公司用的什么框架

O1
sort by 和order by的区别
order by 是全局排序 sort by 局部排序整体无序

OLAP什么是OLTP(说一下他们思想)?

P1
Presto的优化?
1）合理设置分区

与Hive类似，Presto会根据元信息读取分区数据，合理的分区能减少Presto数据读取量，提升查询性能。

2）使用列式存储

Presto对ORC文件读取做了特定优化，因此在Hive中创建Presto使用的表时，建议采用ORC格式存储。相对于Parquet，Presto对ORC支持更好。

3）使用压缩

数据压缩可以减少节点间数据传输对IO带宽压力，对于即席查询需要快速解压，建议采用Snappy压缩。

4）预先排序

对于已经排序的数据，在查询的数据过滤阶段，ORC格式支持跳过读取不必要的数据。比如对于经常需要过滤的字段可以预先排序。

INSERT INTO table nation_orc partition§ SELECT * FROM nation SORT BY n_name;

如果需要过滤n_name字段，则性能将提升。

SELECT count(*) FROM nation_orc WHERE n_name=’AUSTRALIA’;

爬虫技术介绍
1.爬虫的目的是从互联网上获取对业务有价值的信息
2.爬虫的流程是:从一个或者是若干个url开始,在抓取网页内容的过程中,不断的从当前的页面抽取新的url,然后一直打到某一个条件的时候停止(如指定爬取深度)
3.一个完整的爬虫系统包含三个模块:网络请求模块,爬取流程控制模块,内容分析提取模块
4.顺手语言:python
5.现有爬虫工具:八爪鱼,集搜客,queryList,
6.工程师必备工具:Chrome(谷歌浏览器),Charles:Chrome对应只不过是分析APP的,cUrl:分析反爬虫的工具,Postman:url测试工具,Online JavaScript Beautifier:格式化js,Sketch:设计爬虫结构

Q1
全链路(谈谈你认为的数据全链路)?

清洗(数据)的规则怎么制定的?
1.1 非空校核
要求字段为非空的情况下，对该字段数据进行校核。如果数据为空，需要进行相应处理。
1.2 重复校核
多个业务系统中同类数据经过清洗后，在统一保存时，为保证主键唯一性，需进行校核工作。
1.3 异常值校核
包括取值错误、格式错误、逻辑错误、数据不一致等，需根据具体情况进行校核及修正。
1.4 无用值校核
目前业务中不需要使用到的、无价值的数据字段，需要进行校核及去除。

二、具体规则
2.1缺失值清洗
2.1.1确定缺失值范围：按照缺失比例和字段重要性，分别制定策略：
(a) 重要性高，缺失率低：通过计算进行填充；通过经验或业务知识估计；
(b) 重要性高，缺失率高：尝试从其他渠道取数补全；使用其他字段通过计算获取；
© 重要性低，缺失率低：不做处理或简单填充；
(d) 重要性低，缺失率高：去掉该字段。
2.1.2填充缺失内容，某些缺失值可以进行填充，方法有以下三种：
(a) 以业务知识或经验推测填充缺失值；
(b) 从其他业务系统数据中取数补全；
© 以同一指标的计算结果(均值、中位数、众数等)填充缺失值；
(d) 以不同指标的计算结果填充缺失值。

2.2重复值清洗
重复数据可以进行去重或者进行标记。

2.3 异常值清洗
2.3.1 取值错误清洗：
(a) 范围错误：可以通过添加约束的方式过滤掉指定字段数值超出范围的数据。
(b) 位数错误：可以通过其他业务系统数据进行更改。
2.3.2 格式错误清洗：格式内容问题主要有以下几类：
(a) 时间、日期、数值、全半角等显示格式不一致：在整合多来源数据时也有可能遇到，将其处理成一致的某种格式即可；
(b) 内容中有不该存在的字符：某些内容可能只包括一部分字符，比如身份证号是数字+字母，中国人姓名是汉字。最典型的就是头、尾、中间的空格，也可能出现姓名中存在数字符号、身份证号中出现汉字等问题。这种情况下，需要以半自动校验半人工方式来找出可能存在的问题，并去除不需要的字符；
© 内容与该字段应有内容不符：某些字段内容应该是数值，而实际数据中字段的内容却是字符串。这种情况可以采用类型转换来处理。
2.3.3逻辑错误清洗，主要包含以下几个步骤：
(a) 去除/替换不合理值；
(b) 修正矛盾内容。

2.4.无用数据清洗
无用数据字段可以直接进行删除。但在进行该过程的时候，要注意备份原始数据

R1
Repartition和Coalesce关系与区别?
1）关系：
两者都是用来改变RDD的partition数量的，repartition底层调用的就是coalesce方法：coalesce(numPartitions, shuffle = true)
2）区别：
repartition一定会发生shuffle，coalesce根据传入的参数来判断是否发生shuffle
一般情况下增大rdd的partition数量使用repartition，减少partition数量时使用coalesce

redis持久化?
1.RDB 指定的时间间隔内保存数据快照
2.AOF 先把命令追加到操作日志的尾部，保存所有的历史操作

redis没有持久化，内存满了，插入数据会怎么样? 解决办法
1.会根据配置的内存淘汰策略,淘汰相应的消息
解决办法有三种:
1.增加内存
2.使用内存淘汰策略(maxmemory-policy) 其中默认的是:其默认值是noeviction。
具体规则如下:
volatile-lru 使用LRU算法删除一个键（只对设置了生存时间的键）
allkeys-lru 使用LRU算法删除一个键
volatile-random 随机删除一个键（只对设置了生存时间的键）
allkeys-random 随机删除一个键
volatile-ttl 删除生存时间最近的一个键
noeviction 不删除键，只返回错误
3.集群管理redis cluster

redis的五种数据类型?
set
string
zset
hash
list

redis的key是怎么设计?

Reids 为什么快(效率高)?

1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O
2、数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的；
3、采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
4、使用多路I/O复用模型，非阻塞IO；
5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

Redis的哨兵模式？
1.哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。
当发现主的不行的时候就slave 变成Master

RDD中map 操作一个变多行
使用ListBuffer()承接,然后使用flatMap操作

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，但是未来会加入。

RDD的特性(五大特性)?
1.可分区
2.函数作用在所有的分区
3.血缘关系 rdd 之间有相互依赖的关系
4.可以按照k v 存储
5.每一个分片计算时都要遵循数据本地性原则。（计算和存储最好在同一个节点

RDD中map 操作多行变一行
groupby + reduce

S1
RPC协议(谈谈你对rpc 协议的理解)?
1、RPC是一种API，HTTP是一种无状态的网络协议。RPC可以基于HTTP协议实现，也可以直接在TCP协议上实现。

2、RPC主要是用在大型网站里面，因为大型网站里面系统繁多，业务线复杂，而且效率优势非常重要的一块，这个时候RPC的优势就比较明显了。
HTTP主要是用在中小型企业里面，业务线没那么繁多的情况下

scala的隐式转换？
（1）隐式转换就是：当Scala编译器进行类型匹配时，如果找不到合适的候选，那么隐式转化提供了另外一种途径来告诉编译器如何将当前的类型转换成预期类型。
（2）隐式转换两种定义方法：旧的定义方法指是的“implict def”形式，这是Scala 2.10版本之前的写法，
在Scala 2.10版本之后，Scala推出了“隐式类”用来替换旧的隐式转换语法，“隐式类”是一种更加安全的方式，对被转换的类型来说，它的作用域更加清晰可控。
（3）隐式转换有四种常见的使用场景：
a.将某一类型转换成预期类型
b.类型增强与扩展
c.模拟新的语法
d.类型类

设计模式？
工厂模式、原型模式、单例模式、代理模式
1.工厂模式主要解决了接口选择的问题，让其子类去继承接口，不会透露出逻辑
2.原型模式需要实现Cloneable接口可以快速复制已有的实例
3.单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。
代理模式为其他对象提供一种代理以控制对这个对象的访问。

Shell 的是使用?
cut:在文件中剪切内容使用
sed:是一个流处理器,一次处理一行数据
awk: 强大的文本分析工具
sort:将文件进行排序，并将排序结果标准输出

数据中台?数据中台和数据仓库的区别?

项目中数据质量的监控问题?
（阈值，空值，重复数据。。。）

数据库存储(公司主要的数据库)?
oracle(mysql)/redis/mongodb sqlServer / hbase kudu / es

spark 自定义任务监控?
1.rest api
http://spark.apache.org/docs/latest/monitoring.html#rest-api

sparkstream和struct Streaming的区别
struct Streaming 新特性

spark的shuffle的原理(流程)?

Spark窗口函数注意事项?
1.整个 SparkStreaming每个批次的时间间隔假设为N秒
2.通过构建 Streaming Context对象设置 Streaming Context(sc, Seconds(N)
3.设置开窗函数参数第一个时间为窗口长度第二个参数为窗体滑动间隔
reduce BykeyAndWindow((a: Int, b: Int)=>a+b, Seconds(2N), Seconds(2N))

需要注意的是
1.窗体滑动时间和长度要为每个批次的整数倍避免资源浪费
2.窗口长度应该与滑动时间相同,若是窗口长度大于滑动时间数据会被重复读取反之会丢失数据

spark如何自定义累加器?
1.spark 两个版本有差别
2.在2.0中使用自定义累加器需要继承AccumulatorV2这个抽象类,同时必须对以下6个方法进行实现:

1.reset 方法: 将累加器进行重置;

abstract defreset(): Unit

Resets this accumulator, which is zero value.

2.add 方法: 向累加器中添加另一个值;

abstract defadd(v: IN): Unit

3.merge方法: 合并另一个类型相同的累加器;

abstract defmerge(other: AccumulatorV2[IN, OUT]): Unit

Merges another same-type accumulator into this one and update its state, i.e.

4.value 取值

abstract defvalue: OUT

Defines the current value of this accumulator

5.复制:Creates a new copy of this accumulator.

abstract defcopy(): AccumulatorV2[IN, OUT]

abstract defisZero: Boolean

Returns if this accumulator is zero value or not

spark的共享变量?
1.广播变量
A.广播变量缓存到各个节点的内存中,而不是每个Task
B.广播变量被创建后,能在集群中运行的任何函数调用
C.广播变量是只读的,不能在被广播后修改
D.对于大数据集的广播, Spark尝试使用高效的广播算法来降低通信成本
val broadcaster= sc. broad cast(Aray(1,2,3)方法参数中是要广播的变量
2.累加器
A.累加器只支持加法操作,可以高效地并行,用于实现计数器和变量求和。 Spark原生支持数值类型和标准可变集合的计数器,但用户可以添加新的类型。只有驱动程序才能获取累加器的值

spark的高级算子?

Spark常用的算子?
1.action 算子
reduce,collect,first,take,aggregate,countByKey,foreach,saveAsTextFile
2.transformation算子
map mapPartition reduceByKey,aggregateByKey,combineByKey,join,cogroup,glom,union,fliter
3.设计到shuffle的算子
reduceBykey：
groupByKey：
…ByKey:

spark程序运行原理(流程)?
简单版:
1、Spark通过SparkContext向Cluster manager(资源管理器)申请所需执行的资源（cpu、内存等）
2、Cluster manager分配应用程序执行需要的资源，在Worker节点上创建Executor
3、SparkContext 将程序代码（jar包或者python文件）和Task任务发送给Executor执行，并收集结果给Driver。
详细版:
1.构建sparkApplication的运行环境 2.向资源管理器注册sparkContext 3.sparkContext 向资源管理器申请运行executor 4.资源管理器分配并启动executor 5.executor 发送心跳到资源管理器 6.SparkContext 构建有向无环图,并划分stage,stage中划分具体的taskSet 7.将taskset 发送给taskSchedular 8.executor 向sparkContext 申请task 9.taskSchedular 将task 分配至executor同时spark context 将应用程序发送给executor 10.收集结果导driver端

spark 提交集群的命令
spark-submit
–master local[5]
–driver-cores 2
–driver-memory 8g
–executor-cores 4
–num-executors 10
–executor-memory 8g
–class PackageName.ClassName XXXX.jar
–name “Spark Job Name”
InputPath
OutputPath

spark 相关的优化经验?

采用高性能序列化类库(kryo序列化机制)
2.优化数据结构
3.提高并行度
4.广播共享数据
5.数据本地化
6.shuffle性能优化(算子的选择:比如reducebykey和groupbykey)
7.尽量避免shuffle的过程
A.使用广播变量+fliter算子替代 join

spark默认的序列化架构?
spark 默认的是java 的序列化,kyro 的性能java 的10多倍,Spark之所以没有默认使用Kryo作为序列化类库，是因为它不支持所有对象的序列化，同时Kryo需要用户在使用前注册需要序列化的类型，不够方便

spark 的task not serializable 问题解决?

spark 如何处理不能被序列化的对象?
1.封装成object 2.封装成样例类

sortshuffle的好处，为什么bypass机制不需要排序?
1.产生更少的中间磁盘文件,性能优于hashShuffle,尤其是下游task的read操作
2.它有两种机制:普通运行机制和byPass机制

Sql这块的优化经验:
1.大表join小表时，小表放在前面
2.用索引提高效率
3.尽量早过滤数据，减少每个阶段的数据量
4.查询分区表要加分区
5.尽量减少子查询，使用关联查询（left join,right join,inner join）替代
6.使用表的别名(Alias)：
7.用IN来替换OR
8.SELECT子句中避免使用 ‘ *’
9.建表的时候能使用数字类型的字段就使用数字类型,数字类型的字段作为条件查询比字符串的快
那些可以过滤掉最大数量记录的条件必须写在WHERE子句的最末尾

SparkSql的执行过程?
SQL 文本
—> ANLTRV4解析器–>未解析的逻辑计划
—> 分析器 -->解析后的逻辑计划
—> 优化器 -->优化后的逻辑计划
—> 转换器 -->可执行的物理计划

Spark的checkpoint的过程?什么时候使用checkPoint?
checkpoint的使用很简单
1、对于普通应用，首先要设置checkpoint目录，使用SparkContext的setCheckpointDir设置，然后对具体的RDD数据集调用checkpoint方法即可。
2、对流处理应用（结构化流），写出流时必须设置checkpoint，否则会报错，未设置checkpoint目录异常。用.option(“checkpointLocation”, “your checkpoint-pathname”)设置即可。
https://blog.csdn.net/weixin_43878293/article/details/90752738

spark2.X的内存管理模型?
1.spark的内存大致分为两种类型一种是执行一种是执行
执行内存是指用于用于shuffle、join、排序、聚合等计算的内存，而存储内存是指用于在集群中持久化和广播内部数据的内存.在Spark中，执行内存和存储内存共享一个统一的区域。当没有使用执行内存时，存储内存可以获取所有可用内存，反之亦然。如有必要，执行内存可以占用存储存储，但仅限于总存储内存使用量低于某个阈值
虽然有两种相关配置，但一般情况下不需要调整它们，因为默认值适用于大多数工作负载：


spark.memory.fraction默认大小为（JVM堆内存 - 300MB）的一小部分（默认值为0.6）。剩下的空间（40％）保留用于用户数据结构，Spark中的内部元数据，以及在稀疏和异常大的记录的情况下防止OOM错误。
spark.memory.storageFraction默认大小为(JVM堆内存 - 300MB)*0.6*0.5。

spark sql 三种自定义函数的应用场景?实现步骤

spark有几种部署方式?
1)本地模式
2) standalone模式
3) spark on yarn模式
A.yarn-client B.yarn-cluster
4) mesos模式

spark Streaming从哪看任务进行度看task任务量数据倾斜
1.通过4040端口界面 4041 4042

sparkstreaming拉取数据的时候有没有遇到数据丢失
1.有
原因可能如下:
A.窗口时间设置不合理
B.oom 导致数据的溢出
C.kafka offset丢失导致数据丢失

spark streaming 几个重要参数
spark.streaming.backpressure.enabled 开启反压机制
spark.streaming.blockInterval 每一批的间隔
spark.streaming.recevier.maxRate 接受的最大速率
spark.streaming.recevier.writeAheadLog.enabled 开启WL
spark.streaming.stopGracefullyOnShutdown 优雅关闭
spark.streaming.kafka.maxRatePerPartition 直连最大速率

SpringBoot了解多少?
SpringBoot解决的问题
1、使编码变得简单
2、使配置变得简单
3、使部署变得简单
4、使监控变得简单
springboot的核心功能
1、独立运行spring项目。springboot可以以jar包的形式进行独立运行，使用java -jar xx.jar 就可以成功运行项目。
2、内嵌servlet容器。内嵌容器，使得我们可以执行运行项目的主程序main函数，使得项目可以快速运行。
3、提供starter简化Maven配置。springboot提供了一系列的start pol用来简化maven依赖。如：常用的spring-boot-starter-web、spring-boot-starter-tomcat、spring-boot-starter-actuator等
4、自动配置spring。springboot会根据我们项目中类路径的jar包，为jar包的类进行自动装配bean。
5、应用监控。springboot提供了基于HTTP、ssh、telnet对运行时的项目进行监控。

Sql的执行顺序?
1.写的顺序：select … from… where… group by… having… order by… limit [offset,]

(rows)

2.执行顺序：from… where…group by… having… select … order by… limit

Sqoop数据导出Parquet?
hdfs数据用Sqoop往MySql中导入数据的时候，如果是Parquet不能导入，需转化成text格式才行

Sqoop导入导出Null存储一致性问题?
Hive中的Null在底层是以“N”来存储，而MySQL中的Null在底层就是Null，为了保证数据两端的一致性。在导出数据时采用–input-null-string和–input-null-non-string两个参数。导入数据时采用–null-string和–null-non-string。

sqoop适用于那些场景?
1.hive 和关系型数据之间的同步

sqoop导入导出给4m,说一下他的工作原理? 4m 的情况下如何保证数据一致性

1.Sqoop导入底层工作原理

（1）在导入前，Sqoop使用JDBC来检查将要导入的数据表。

（2）Sqoop检索出表中所有的列以及列的SQL数据类型。

（3）把这些SQL类型的映射到java数据类型，例如（VARCHAR、INTEGER）———>（String，Integer）。

（4）在MapReduce应用中将使用这些对应的java类型来保存字段的值。

（5）Sqoop的代码生成器使用这些信息来创建对应表的类，用于保存从表中抽取的记录。

注意：对于导入来说，更关键的是DBWritable接口的序列化方法，这些方法能使（生成的类）和JDBC进行交互。
2.Sqoop导出底层工作原理

（1）在导出前，sqoop会根据数据库连接字符串来选择一个导出方法 ————>对于大部分系统来说，sqoop会选择JDBC。

（2）Sqoop会根据目标表的定义生成一个java类。

（3）这个生成的类能够从文本中解析出记录，并能够向表中插入类型合适的值（除了能够读取ResultSet中的列）。

（4）然后启动一个MapReduce作业，从HDFS中读取源数据文件。

（5）使用生成的类解析出记录，并且执行选定的导出方法。

sqoop常用的参数?
https://blog.csdn.net/qq_41610418/article/details/81713319

Sqoop导入是否可以断点续传?
1.可以类似于增量导入
2.增量数据导入分两种，一是基于递增列的增量数据导入（Append方式）。二是基于时间列的增量数据导入（LastModified方式）

Sqoop 如何将两张mysql 表导入到一张hive 表中?
1.存在覆盖的问题 2.可以在mysql中提前合并

sqoop传递数据时最终结果会比原数据量多十几条数据，怎么解决?
1.value中特殊符号引起字段的数据增多或者减少,解决办法是,导入hive时使用 --hive-drop-import-delims 命令去掉特殊符号如:n,r,01

Sqoop导数据效率?
1.适当增加m 的参数
补充:
-m N ：开启N个map来导入数据
–query ：从查询结果导入数据，注意，如果使用了该参数，那么必须指定–target-dir参数，并且查询条件中要包含$CONDITIONS
–target-dir ：指定数据在HDFS中的存放目录
–hive-table ：导入到hive的目标表名
–fetch-size ：一次从数据库中读取的记录数
-null-string ：对于string类型的字段，如果值为null，那么使用替代
–non-null-string ：对于非string类型的字段，如果值为null，那么使用替代

S手写代码:冒泡排序,快速排序,归并排序,二叉树,斐波那契,以及排序算法的复杂度?

String buffer和String build区别
1、StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，
2、只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。
3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低

实时数仓的理解?
https://blog.csdn.net/weixin_44904816/article/details/104285711

实时数仓和离线数仓的差异?
1.业务场景
2.架构选型
离线:hive+hdfs
实时:Druid impala clickhouse es
3.

T1
TreeSet和HashSet区别?
HashSet是采用hash表来实现的。其中的元素没有按顺序排列，add()、remove()以及contains()等方法都是复杂度为O(1)的方法。
TreeSet是采用树结构实现(红黑树算法)。元素是按顺序进行排列，但是add()、remove()以及contains()等方法都是复杂度为O(log (n))的方法。它还提供了一些方法来处理排序的set，如first(), last(), headSet(), tailSet()等等。

TaskSetManager 的 Locality Levels 分为以下五个级别
https://www.cnblogs.com/jxhd1/p/6702224.html?utm_source=itdadao&utm_medium=referral

吞吐量(各个组件的吞吐量)?
1.sparkStreaming中100个节点（每节点4个core），数秒延迟可处理6GB/s的shujuliang 。吞吐量是storm的2~5倍。
2.kafka
10个broker 每秒百万级别
3.flume
5.flink

TEZ查询引擎你们用过嘛，特点

Tez引擎优点？
Tez可以将多个有依赖的作业转换为一个作业，这样只需写一次HDFS，且中间节点较少，从而大大提升作业的计算性能。

W1
维度建模(详细说一下维度建模)/实体建模/范式建模?
https://dantezhao.gitbooks.io/data-warehouse-in-action/content/di-san-zhang-xiang-jie-wei-du-jian-mo.html

X1
系统升级优化(系统升级优化)?
A.是这样的,我们的大部分结果数据还是存在hbase中，但是hbase的查询响应速度满足不了我们的业务需求，我们这样改进把我们最近3个月的数据存储在ES中，也就是Hbase结合ES使用
B.我们向Hbase数据库写入数据的时候遇到了热点问题，我是提出了预分区和重新设计rowkey的方案很好的解决了我们的问题
你是怎么预分区的
1）拼接区号设置两位 00-99，把区号拼接在rowkey前面
2）创建表的时候调用 createTable(HTableDescriptor var1, byte[][] va2)
C. 对hbase的优化，第一加入布隆过滤器，数据数据格式的压缩，减少存储空间等

Y1
Yarn的内存和CPU怎么分配 ?
https://www.cnblogs.com/wwcom123/p/10561806.html
https://blog.csdn.net/qq_43688472/article/details/92796141

Hadoop Yarn 的三种资源调度器?
1.FIFO调度器(FIFO Scheduler )
先进先出，但不适合资源公平性
2.容量调度器(Capacity Scheduler)
独立的专门队列保证小作业也可以提交后就启动，队列容量是专门保留的
以整个集群的利用率为代价，与FIFO比，大作业执行的时间要长
3.公平调度器(FairS cheduler)
不需要预留资源，调度器可以在运行的作业之间动态平衡资源，大作业启动时，因为是唯一运行的，所以获得集群的所有资源，之后小作业启动时，被分配到集群的一半的资源，这样每个作业都能公平共享资源

yarn两种运行模式的区别?
1.yarn-client和yarn-cluster
2.区别:
SparkContext初始化不同，这也导致了Driver所在位置的不同，YarnCluster的Driver是在集群的某一台NM上，但是Yarn-Client就是在RM在机器上；

（2）而Driver会和Executors进行通信，这也导致了Yarn_cluster在提交App之后可以关闭Client，而Yarn-Client不可以；

（3）最后再来说应用场景，Yarn-Cluster适合生产环境，Yarn-Client适合交互和调试

yarn出现的原因?

yarn调优
yarn的资源表示模型Container，Container将资源抽象为两个维度，内存和虚拟CPU核（vcore）

选择正确的调度器(FIFO Fair Caption)
动态分配资源，减少资源浪费

元数据管理?
1.用一张oracle的表记录了我们所有的元数据信息
2.apache

移动计算比移动数据更容易?

隐式转换(scala)的应用场景
1.用于从一种类型到另一种类型的转换(批量转换)
2.用于缺少参数方法的调用(隐式参数)
3.丰富类的功能

源码查看(你都看过哪些源码)?
1.看过mr的map个数和reduce个数源码
2.case class 的源码
3.kafka的底层源码
4.spark 底层通信的源码 actor模型
5.cache和persist的源码讲解

zookeeper的四种类型的节点?

Z1
z自我介绍?

Zookeeper的假死和脑裂?
1.假死是心跳机制的误判leader死亡重新选举leader 造成脑裂
2.脑裂是因为假死会有两个leader

Zookeeper zab协议?
1.ZAB协议是为分布式协调服务Zookeeper专门设计的一种支持崩溃恢复的原子广播协议。
2.ZAB协议包括两种基本的模式：崩溃恢复和消息广播。
当整个zookeeper集群刚刚启动或者Leader服务器宕机、重启或者网络故障导致不存在过半的服务器与Leader服务器保持正常通信时，所有进程（服务器）进入崩溃恢复模式，首先选举产生新的Leader服务器，然后集群中Follower服务器开始与新的Leader服务器进行数据同步，当集群中超过半数机器与该Leader服务器完成数据同步之后，退出恢复模式进入消息广播模式，Leader服务器开始接收客户端的事务请求生成事物提案来进行事务请求处理。

ZK节点宕机如何处理？
Zookeeper本身也是集群，推荐配置不少于3个服务器。Zookeeper自身也要保证当一个节点宕机时，其他节点会继续提供服务。
如果是一个Follower宕机，还有2台服务器提供访问，因为Zookeeper上的数据是有多个副本的，数据并不会丢失；
如果是一个Leader宕机，Zookeeper会选举出新的Leader。
ZK集群的机制是只要超过半数的节点正常，集群就能正常提供服务。只有在ZK节点挂得太多，只剩一半或不到一半节点能工作，集群才失效。
所以
3个节点的cluster可以挂掉1个节点(leader可以得到2票>1.5)
2个节点的cluster就不能挂掉任何1个节点了(leader可以得到1票<=1)

zookeeper的选举机制？
zookeeper 提供三种选举机制
A.LeaderElection
B.AuthFastLeaderElection
C.FastLeaderElection （最新默认）
选举流程简述:
目前有5台服务器，每台服务器均没有数据，它们的编号分别是1,2,3,4,5,按编号依次启动，它们的选择举过程如下：

服务器1启动，给自己投票，然后发投票信息，由于其它机器还没有启动所以它收不到反馈信息，服务器1的状态一直属于Looking(选举状态)。
服务器2启动，给自己投票，同时与之前启动的服务器1交换结果，由于服务器2的编号大所以服务器2胜出，但此时投票数没有大于半数，所以两个服务器的状态依然是LOOKING。
服务器3启动，给自己投票，同时与之前启动的服务器1,2交换信息，由于服务器3的编号最大所以服务器3胜出，此时投票数正好大于半数，所以服务器3成为领导者，服务器1,2成为小弟。
服务器4启动，给自己投票，同时与之前启动的服务器1,2,3交换信息，尽管服务器4的编号大，但之前服务器3已经胜出，所以服务器4只能成为小弟。
服务器5启动，后面的逻辑同服务器4成为小弟。

Zookeeper怎么保证消息一致性的
zab 协议消息同步机制 Zab协议有两种模式，它们分别是恢复模式和广播模式

A2
安全行业数仓和分析统计业务:
1.人物画像(一张宽表(A.B.C.D.买车等级(汽车模型),是否是孕妇(孕妇模型)))…
2.要素抽取:人员基本表交通信息表 … ==>要素表
3.关系图谱:根据我们现有的信息,分析人物之间关系
4.话单分析:谁跟谁通话通话的时长和频率(区域) 通话方式
5.模型挖掘:同户分析(户号) 同行分析(规则) 通联分析(电话/微信/qq)
6.重点人物分析:社交度影响力涉恐度

B2
部门的人员组成和分工?
小型公司（3人左右）：组长1人，剩余组员无明确分工，并且可能兼顾javaEE和前端。
中小型公司（3~6人左右）：组长1人，离线2人左右，实时1人左右（离线一般多于实时），JavaEE 1人（有或者没有人单独负责JavaEE，有时是有组员大数据和JavaEE一起做，或者大数据和前端一起做）。
中型公司（5_{10人左右）：组长1人，离线3}5人左右（离线处理、数仓），实时2人左右，JavaEE 1人左右（负责对接JavaEE业务），前端1人左右（有或者没有人单独负责前端）。
中大型公司（5_{20人左右）：组长1人，离线5}10人（离线处理、数仓），实时5人左右，JavaEE2人左右（负责对接JavaEE业务），前端1人（有或者没有人单独负责前端）。（发展比较良好的中大型公司可能大数据部门已经细化拆分，分成多个大数据组，分别负责不同业务）
上面只是参考配置，因为公司之间差异很大，例如ofo大数据部门只有5个人左右，因此根据所选公司规模确定一个合理范围，在面试前必须将这个人员配置考虑清楚，回答时要非常确定。

C2
null
null

D2
对我们公司有什么期待吗
1.尽快上班 2.晋升规则 3.能在公司长久发展提升自身实力 4.接触更多地业务

打算在我们公司待几年
1.长久发展 2.

代码提交(实战当中写完代码的流程如何提交)?那个工具?
svn

电商行业数仓和分析统计业务:
1.你们的数据是通过什么方式收集的？简单谈谈
2.收集的原始数据是什么格式的？举例子
3.你们数仓怎么分层？每一层存放的都是什么数据？
4.活跃设备数你们是怎么计算的（你们的规则是什么）？
5.每日新增设备数据你们是怎么计算的？
6.你们的留存用户是怎么定义的？留存率比例是怎么计算的？
7.你们的沉默用户是怎么计算的？
8.你们的本周回流数目怎么计算的？
9.你们的流失用户是怎么计算的？
10.你们的连续三周活跃用户怎么计算的？
11.最近七天内连续三天内的活跃用户你们怎么计算的？
16.你们数据建模的时候，遵循哪些原则？
17.全量表、增量表、新增及变化表、拉链表？数据是怎么同步？
18.GMV成交总额指标计算的规则？
19.你们的转化率怎么计算的？
20.你们的用户新鲜度怎么计算的？
20.你们的品牌复购率怎么计算的？

电商行业实时业务指标:
A.实时统计每个分类被点击的次数
B.实时计算商品销售额,成交量
C.实时统计网站动态行为pv，uv
D.实时展示客户在线数量
https://blog.csdn.net/qq_22473611/article/details/88085050

E2
ES(es/redis/hbsae/hdfs/mysql存的是什么数据)?
null

F2
房产行业
null

G2
公司的工作内容(说一下你公司的主要业务)?
1.自己做好准备不至于尬场

H2
回流用户的计算规则?
1.这次登陆距离上次登陆已经有三周的时间
亮点:这样的指标只是对我们的用户做一个宏观的把控,但是并不能起到实质性的作用(效果)
其实呀.,我们真正的精力应该放在如何降低(提高)这个指标

Hbase的查询延迟?
1.3s作用(建立索引的前提下) 如果没有索引 5s开外

Hsql:连续七天统计三天登录次数(手写sql)
null

行业定位和案例
1.房屋租赁
二手房,新房贝壳找房我爱我家链家安居客找房网搜房网蛋壳公寓麦田房产
2.车辆行业
易车网太平洋汽车网第一车网淘车网搜狐汽车二手车之家卡车之家爱车网滴滴出行首汽约车快拼车神州专车嘀嗒拼车
3.电商行业
惠客商城贝贝母婴母婴之家妈乐购优购网卷皮网易迅网返利网一淘网易购网当当网唯品会苏宁易购牛摩网
4.新闻/资讯/娱乐/视频/广告
直播吧九秀网斗鱼TV 新浪体育虎牙直播央视网搜狐体育球探网虎扑体育黑夜影视小窝电影院抖音快手火山战旗TV 优酷网一点资讯网易新闻知乎日报读读日报头条
5.游戏行业
腾讯手游爱游戏立即玩 4399小游戏游戏盒子逗游乐玩游戏沃游戏 360手游网易游戏
6.旅游/游乐/酒店行业
携程捡人网穷游网途牛旅游旅妈妈美团约伴旅游网乐途艺龙旅行网北京旅行网同程
芒果网
7.物流行业
中铁快运速易递闪送全峰快递国通快递立通快递佳吉快运华宇物流百世汇通妙优车
8.电信业务
移动联通电信手机靓号网好号网号码网抢卡网挑卡网找号网晒号网卡号网
9.“智慧领域”
高德地图百度地图智慧交通智慧物流智慧校园智慧能源车联网系统智慧医疗

J2
交通行业
http://www.raincent.com/content-10-12364-1.html

加班(咱们公司会有加班你感觉可以吗？)
1.可以没问题

教育日志分析报表系统
1.用户分析
2.课程分析
3.资源分析
4.精品分析

K2
空白字段怎么操作?
1.过滤掉
2.数值类型:取平均数或者中位数
3.字符类型:就近原则

L2
留存率是怎么计算?

流程图(画出你项目的流程图,并讲解)?

Q2
企业合作(项目都和那些企业合作)?

清洗(数据)的规则怎么制定的?

R2
热力图的数据划分?基于热力图的数据对客流的走向判断?
1.热力图是利用获取的手机基站定位该区域的用户数量,通过用户数量渲染地图颜色
例如:百度慧眼
http://www.360doc.com/content/19/0512/14/276037_835190545.shtml

日志拉去使用几台服务器(flume几台,kafka几台)?

S2
数据量(你每天数据量多大，总共数据量多大，每天增量多少)?
1.100万的日活差不多每天产生80G
2.数据总量 50T 左右

实时数仓的应用场景:
https://blog.csdn.net/weixin_44904816/article/details/104285711

事实表(具体说出两种事实表都有哪些)

数据流程(手绘项目的数据流程图)?

T2
调试(打jar包的方式,有没有在编译器打断点,然后上传到集群,如何实现连调?

脱敏(数据脱敏)怎么做?
数据脱敏是指对某些敏感信息通过脱敏规则进行数据的变形，实现敏感隐私数据的可靠保护

图书综合管理系统
1.图书管理
2.用户分析
3.广告推广
4.客户分析
5.精准推荐
6.物流管理

推荐系统(电商)
例如:有货网商品多维度个性分析推荐系统
针对网站用户以及商品进行分析，分析出多维度的信息使用算法来分析用户的喜好，利用协同过滤来分析用户行为，商家可以利用电子商务网站向客户提供商品信息和建议，帮助用户决定应该购买什么产品，模拟销售人员帮助客户完成购买过程。根据用户的兴趣特点和购买行为，向用户推荐用户感兴趣的信息和商品。

W2
物流行业
1.
2.
3.
4.

为什么从上一家离职?
1.合同到期 2.没有晋升空间 3.疫情裁员

为什么来北京?
1.寻找更好的发展机遇多,提升快 2.北京距离家近 3.

维度表(具体说说你们的维度表)?

X2
项目周期问题(多长)?
1.半年左右
2.知识扩展:https://cj.sina.com.cn/articles/view/1720289731/668989c301900n0c6?from=finance

项目需求谁去对接?
产品

项目每个环节遇到的问题?

新的环境中能给自己带来什么

薪资组成?
底薪+KPI+奖金

新闻/资讯/娱乐/视频/广告行业

用户画像系统
https://www.sensorsdata.cn/product/userTag.html?utm_source=360sem&utm_medium=cpc&utm_term=%E7%94%A8%E6%88%B7%E7%94%BB%E5%83%8F&utm_content=%E7%94%BB%E5%83%8F%5F%E5%90%8D%E8%AF%8D%5F%E7%94%BB%E5%83%8F&utm_campaign=%E4%BA%A7%E5%93%81%2D%E7%A5%9E%E7%AD%96%E7%94%A8%E6%88%B7%E7%94%BB%E5%83%8F%5FN

Z2
主题(数据分析的时候都是以什么为主)?
1.用户消费
2.用户活跃
3.用户流失
4.用户年龄/区域

资源分配问题(大家一起提交,资源怎么管理)
1.分时段跑任务错开高峰
2.流处理按比例分配资源10%