大数据面试题

1、简述java中，throw和throws的区别

答：

throw：- throw关键字用于在方法体内抛出异常。- 它后面跟着一个异常对象。- 使用throw，你可以抛出自定义异常或标准异常。- 方法体中只能有一个throw语句被执行。

throws：- throws关键字用于方法签名中，用于声明该方法可能抛出的异常。- 它后面跟着一个或多个异常类名，用逗号分隔。- 使用throws，你可以声明方法可能会抛出的checked异常。- 一个方法可以声明抛出多个异常。

这两个关键字在处理异常时扮演不同的角色：
throw
用于抛出异常，而
throws
用于声明异常。

2、简述java中，==和equals方法的区别

答：

在Java中，
==
和
equals()
方法是用来比较两个对象是否相等的，但它们之间有显著的区别：

==操作符：- 用于比较两个对象的引用是否相同，即它们是否指向内存中的同一个位置。- 对于基本数据类型（如int, float等），==比较的是数值是否相等。- 对于对象，即使两个对象的内容完全相同，但如果它们是不同的实例，==也会返回false。

equals()方法：- 是Object类的一个方法，可以被继承和重写。- 默认的实现（即从Object类继承的）与==相同，比较的是引用。- 但在许多Java类中（如String, Integer等），equals()方法被重写，以比较对象的内容或状态。- 使用equals()时，需要考虑对象是否为null，因为对null对象调用equals()会抛出NullPointerException。

总结来说，
==
用于比较引用，而
equals()
用于比较内容，尽管其默认行为也是比较引用。在实际应用中，应根据需要选择使用哪种方法。

3、简述java集合框架中，集合框架的体系结构，以及他们之间的区别

答：

Collection接口：是集合框架的基础接口，用于存储一组不唯一、无序的对象。它包括List、Set和Queue等子接口。- List接口：继承自Collection，允许重复元素，元素有序，可以通过索引访问。主要实现类有ArrayList和LinkedList。 - ArrayList：基于动态数组实现，支持随机访问，适合查找和更新操作。- LinkedList：基于双向链表实现，支持快速插入和删除，适合列表中间的添加和删除操作。- Set接口：继承自Collection，不允许重复元素。主要实现类有HashSet、LinkedHashSet和TreeSet。 - HashSet：基于哈希表实现，无序，不保证元素的顺序。- LinkedHashSet：继承自HashSet，维护了元素的插入顺序。- TreeSet：基于红黑树实现，有序，元素按照自然顺序或自定义比较器排序。- Queue接口：用于存储待处理的元素序列，元素有序，主要实现类有LinkedList和PriorityQueue。 - LinkedList：可以用作栈、队列或双端队列。- PriorityQueue：基于优先级堆实现，元素按照优先级顺序出队。

Map接口：用于存储键值对，键唯一，值可以重复。主要实现类有HashMap、LinkedHashMap、TreeMap和Hashtable。- HashMap：基于哈希表实现，无序，允许使用null键和null值。- LinkedHashMap：继承自HashMap，维护了元素的插入顺序。- TreeMap：基于红黑树实现，有序，元素按照键的自然顺序或自定义比较器排序。- Hashtable：是HashMap的同步版本，不允许使用null键和null值。

这些集合类和接口的选择取决于具体的应用场景，例如对元素的排序、访问速度、插入和删除操作的频率等需求。

4、简述java的泛型可以使用的场景

答：

Java的泛型主要应用于以下场景：

集合框架：泛型最常见的应用是在Java的集合框架中，如List、Set、Map等。使用泛型可以保证集合中存储的对象类型安全，避免在运行时出现类型转换错误。

类和接口：泛型类和接口允许在类或接口的定义中指定类型参数，这样可以在实例化时指定具体的类型，增强代码的通用性和可重用性。

方法：泛型方法允许在方法签名中指定类型参数，使得方法可以接受不同类型的参数，提高方法的灵活性。

泛型通配符：用于表示未知的类型，例如List<?>，可以接受任何类型的List。通配符还可以指定上界或下界，如List<? extends Number>表示接受Number或其子类型的List。

泛型擦除和桥接方法：Java中的泛型是通过类型擦除来实现的，这意味着在编译后的字节码中不包含泛型信息。为了保持类型安全，编译器会生成桥接方法。

自定义泛型结构：除了使用Java提供的泛型集合和类外，还可以自定义泛型结构，如泛型类、接口和方法，以创建更加灵活和可重用的代码。

5、简述java中序列化和反序列化机制

答：

1、序列化机制是指将jvm内存中的对象转换成与操作平台无关的二进制流存储到外部设备如磁盘、U盘等

2、反序列化机制是指通过网络传输的形式将这种二进制流传到某个网络节点时，java程序会将其转换为java对象

6、简述java中，线程的5种状态

答：

要想实现多线程，必须在主线程中创建新的线程对象。Java 语言使用 Thread 类及其子类的

对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

①、新建：当一个 Thread 类或其子类的对象被声明并创建时，新生的线程对象处于新建

状态。

②、就绪：处于新建状态的线程被 start()后，将进入线程队列等待 CPU 时间片，此时它

已具备了运行的条件，只是没分配到 CPU 资源。

③、运行：当就绪的线程被调度并获得 CPU 资源时,便进入运行状态， run()方法定义了线

程的操作和功能。

④、阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中

止自己的执行，进入阻塞状态。

⑤、死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

7、简述java中8个基本数据类型是哪几个

答：byte、short、int、long、float、double、char、boolean

8、简述JDK、JRE、JVM三者的区别

答：

JDK = JRE + 开发工具集（例如 Javac 编译工具等）

JRE = JVM + Java SE 标准类库

9、面向对象的三大特征是哪三个

答：封装、继承、多态

10、简述java中，方法重写和重载的区别

答：

========重写========

①、子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

②、子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

③、子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，子类不能重写

父类中声明为 private 权限的方法

④、子类方法抛出的异常不能大于父类被重写方法的异常

========重载========

①、在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。调用时，根据方法参数列表的不同来区别

②、子类可以对父类中继承到的方法进行重载

11、请你谈谈对java中多线程的理解

答：

what：

若一个进程同一时间并行执行多个线程，就是支持多线程的。

why：

多线程程序的优点：

①、提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

②、提高计算机系统 CPU 的利用率。

③、改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

when：

①、程序需要同时执行两个或多个任务。

②、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

③、需要一些后台运行的程序时。

warning：

多个线程操作同一共享资源时，将引发数据不安全问题。解决的方案有：

Java 对于多线程的数据不安全问题提供了专业的解决方案：**同步机制 **

Java 的同步机制有两种方式：同步代码块和同步方法。

12、简单描述java中，通过反射获取Class对象的四种方式

答：

一、在知道类名称的情况下，可以通过 Class 类的 class 属性获取。

二、在有类的对象时，可以通过 getClass()方法获取。

三、已知类的完全限定名，可以通过 Class.forName(String)获取。

四、已知类的完全限定名，可以通过类的加载器加载获取。

13、描述使用java实现单例模式的步骤

答：

①、如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将**类的构造器的访问 **

权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部

仍可以产生该类的对象。

②、因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态公共方法以返回

类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的**该类 **

对象的变量也必须定义成静态的。

14、简述在java网络编程中，TCP和UDP编程协议的区别

答：计算机间的信息传输需要遵守传输协议，常见的传输协议有TCP和UDP。当我们需要传输体量比较大的数据时，并且要求在传输过程中不丢失数据，这种情况下选用TCP协议；当我们需要快速传输体量比较小的数据，并且对传输过程中数据是否丢失不作要求的话，选用UDP。使用TCP时，我们需要创建两条进程，实现点对点传输，并且通过三次握手四次挥手来保证数据传输的安全性；使用UDP时，客户端向服务器端发送数据，服务器端对是否收到数据不会给出回应，客户端和服务器端是相互独立的，不需要建立连接。

15、谈谈你对java中注解的理解，可以从什么是注解，如何定义注解，如何使用注解三个方面谈谈

答：

什么是注解：注解（Annotation）是Java语言提供的一种用于为代码添加元数据的机制。它是一种特殊的注释，可以被编译器或其他工具读取并处理。

如何定义注解：定义注解使用@interface关键字。在注解中可以定义一些元素，这些元素可以有自己的默认值。

如何使用注解：注解可以直接用在代码中，比如类、方法或字段上。使用注解时，可以传递参数给注解的元素。

16、你是如何理解大数据技术的

17、JDBC中连接字符串作用

答：JDBC URL用来标识一个被注册的驱动程序，驱动程序管理器通过这个URL选择正确的驱动程序，从而建立到数据库的连接

18、JDBC获取数据库连接的三要素

答：

1、驱动类

2、连接字符串

3、用户名和密码

19、编写JDBC程序的步骤

答：

1、导入并添加java.sql包

2、通过反射加载并注册一个驱动程序

3、创建connection连接对象

4、创建一个statement对象

5、对数据库的增删改查操作中，增删改都只会返回int型数值，表示受影响的行数；对数据库的查询操作中，返回的数据会被封装打包为ResultSet供我们提取

6、依次关闭连接

20、JDBC有哪些常用接口

答：

JDBC（Java Database Connectivity）是Java语言用于数据库连接的一种标准规范，它定义了一系列接口，使得Java程序能够以一种统一的方式访问各种关系型数据库。常用的JDBC接口主要包括：

DriverManager：用于管理数据库驱动程序，可以注册和注销驱动，以及建立数据库连接。

Connection：代表与数据库的连接，通过它可以执行SQL语句，管理事务等。

Statement：用于执行静态SQL语句并返回结果。

PreparedStatement：继承自Statement，用于执行预编译的SQL语句。

CallableStatement：用于执行SQL存储过程。

ResultSet：代表SQL查询的结果集，可以从中获取查询到的数据。

21、事务的ACID属性

答：

1、原子性：原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

2、一致性：事务必须使数据库从一个一致性状态变换到另外一个一致性状态

3、隔离性：事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

4、持久性：持久性是指一个事务一旦被提及，它对数据库中数据的改变就是永久的，接下来的其他操作和数据库故障不应该对其有任何影响。

22、简述JDBC数据库连接池的作用

答：数据库连接池技术可以解决传统开发中的数据库连接问题。数据库连接池就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，但需要建立数据库连接时，只需要从“缓冲池”中取出一个，使用完毕之后再放回去。

23、简述maven的功能

24、简述maven的三个坐标

25、简述maven的scope依赖范围的常见取值

26、简述maven的三个生命周期

27、简述使用maven对main文件进行编译，使用什么命令？

28、请你使用maven对test文件进行编译，使用什么命令？

29、简述使用maven对项目进行打包，使用什么命令？

30、简述使用maven对项目进行安装，使用什么命令？

31、简述xml和json两种文件格式的作用和区别？

32、简述你对数据中台的理解？

33、Maven的作用

答：maven可以为java项目提供构建和依赖管理支持

34、git中，远程仓库拉下来与当前本地分支合并的命令

答：git pull 远程库地址别名远程分支名

35、git remote add 远程地址，该命令表示什么？

答：起别名

36、git创建分支的命令

答：git branch 分支名

37、简述大数据解决什么问题

答：主要解决海量数据的采集、存储和分析计算问题

38、简述hadoop解决什么问题

答：主要解决海量数据的存储和海量数据的分析计算问题

39、简述hadoop框架中，1.x、2.x、3.x在组件组成上的区别

答：

1、hadoop1.x由mapreduce、hdfs、common构成，其中mapreduce负责资源调度和计算，hdfs负责数据存储，common是辅助工具

2、hadoop2.x在1.x的基础上新增了yarn负责资源调度，mapreduce只负责计算

3、hadoop3.x在组成上没有变化

40、简述在hadoop的hdfs文件系统中，一个文件块的大小是由什么决定的？

答：文件块大小由磁盘传输速率决定，它的大小往往是2的次方，例如，一家公司磁盘传输速率在500~600MB/s，那么建议数据块大小设置为512M

41、简述在hadoop中，常见的端口号有哪些，写出他们的作用

答：

NameNode内部通信端口：8020

NameNode Http UI ：9870

MapReduce查看执行任务端口：8088

历史服务器通信端口：19888

42、简述hdfs中，常见的组件名字及其作用

答：

一、NameNode（NN），就是 Master，它是一个主管、管理者。

①、管理 HDFS 的名称空间；

②、配置副本策略；

③、管理数据块（Block）的映射信息；

④、处理客户端读写请求。

二、DataNode，就是 Slave。NameNode 下达命令，DataNode 执行实际的操作。

①、存储实际的数据块；

②、执行数据块的读写操作。

三、Secondary NameNode，并非 NameNode 的热备。当 NameNode 挂掉的时候，它并不能马****上替换 NameNode 并提供服务。

①、辅助 NameNode，分担其工作量，比如定期合并 Fsimage 和 Edits，并推送给 NameNode；

②、在紧急情况下，可辅助恢复 NameNode。

四、Client：就是客户端。

①、文件切分。文件上传 HDFS 的时候，Client 将文件切分成一个一个的 Block，然后进行上传；

②、先与 NameNode 交互，获取文件的位置信息；

③、与 DataNode 交互，读取或者写入数据；

④、Client 提供一些命令来管理 HDFS，比如 NameNode 格式化；

⑤、Client 可以通过一些命令来访问 HDFS，比如对 HDFS 增删改查操作。

43、简述yarn中，常见的组件名字及其作用

答：

一、ResourceManager(RM)

①、处理客户端请求

②、监控NodeManager

③、启动或监控ApplicationMaster

④、资源的分配与调度

二、NodeManager(NM)

①、管理单个节点上的资源

②、处理来自ResourceManager的命令

③、处理来自ApplicationMaster的命令

三、ApplicationMaster(AM)

①、为应用程序申请资源并分配给内部的任务

②、任务的监控与容错

四、Container

Container是YARN中的资源抽象，它封装了某个节点上的多维度资源，如内存、cpu、磁盘、网络等

44、在shell编程中，定义一个函数，计算两个数的和，并且调用该函数得出结果

在Shell编程中，定义一个函数来计算两个数的和并调用该函数非常简单。以下是一个示例：
# 定义函数
sum() {
    local num1=$1
    local num2=$2
    local result=$((num1 + num2))
    echo $result
}

# 调用函数并传递参数
result=$(sum 5 3)

# 输出结果
echo "The sum is: $result"
在这个例子中，我们定义了一个名为
sum
的函数，它接受两个参数
num1
和
num2
，计算它们的和，并返回结果。然后我们调用这个函数，传递两个数字作为参数，并将结果存储在变量
result
中。最后，我们输出这个结果。

45、简述HDFS文件系统的优缺点

答：

============优点============

1、高容错性
①、数据自动保存多个副本。它通过增加副本的形式，提高容错性。

②、某一个副本丢失以后，它可以自动恢复。
2、适合处理大数据
①、数据规模：能够处理数据规模达到 GB、TB、甚至 PB 级别的数据；

②、文件规模：能够处理百万规模以上的文件数量，数量相当之大。
3、可构建在廉价机器上，通过多副本机制，提高可靠性

============缺点============

1、不适合低延时数据访问，比如毫秒级的存储数据，是做不到的
2、无法高效的对大量小文件进行存储
①、存储大量小文件的话，它会占用 NameNode 大量的内容来存储文件目录和块信息。

   这样是不可取的，因为 NameNode 的内存总是有限的；

②、小文件存储的寻址时间会超过读取时间，它违反了 HDFS 的设计目标。
3、不支持并发写入和文件随机修改
①、一个文件只能有一个写，不允许多个线程同时写；

②、仅支持数据追加（append），不支持文件的随机修改。

46、简述hdfs的写数据流程

1、客户端会根据分布式文件系统向NameNode请求上传文件

2、NameNode 检查目标文件是否存在，父目录是否存在，返回是否可以上传

3、客户端请求第一个 Block 上传到哪几个 DataNode 服务器上

4、对于常见情况，当复制因子为3时，NameNode会根据机架感知策略返回3个DateNote节点信息，分别是DateNote1、DateNote2、DateNote3。HDFS 的放置策略是，**如果写入程序位于数据节点上， ****则将一个副本放置在本地机器上，否则放置在随机数据节点上；将另一个副本放在不同（远 **程）机架中的节点上，最后一个放在同一远程机架中的不同节点上。

5、客户端根据数据输出流向DataNode1节点请求建立block传输通道，DateNote1收到请求会继续调用DateNote2，然后DateNote2调用DateNote3，将这个通信管道建立完成

6、DateNote1、DateNote2、DateNote3逐级应答客户端

7、当客户端开始往DataNode1节点上传第一个数据块（先从磁盘读取数据放到一个本地内存缓存），一个128M的数据块会被分成很多64KB大小的packet包，dn1 收到一个 Packet 就会传给 dn2，dn2 传给 dn3；dn1 每传一个 Packet 会放入一个应答队列等待应答。

8、当一个 Block 传输完成之后，客户端再次请求 NameNode 上传第二个 Block 的服务

器。（重复执行 3~7 步）

47、简述hdfs的读数据流程

答：

1、客户端通过 DistributedFileSystem 模块向 NameNode 请求下载文件，NameNode 通

过查询元数据，找到文件块所在的 DataNode 地址。

2、挑选一台 DataNode（就近原则，然后随机）服务器，请求读取数据。
3、DataNode 开始传输数据给客户端（从磁盘里面读取数据输入流，以 Packet 为单位

来做校验）。

4、客户端以 Packet 为单位接收，先在本地缓存，然后写入目标文件。

48、简述NameNode和SecondaryNameNode的工作流程

答：

第一阶段：NameNode启动

1、第一次启动NameNode格式化后，创建FsImage和Edits文件。如果不是第一次启动，直接加载编辑日志和镜像文件到内存，形成最新的元数据。

2、客户端对元数据进行增删改的请求。

3、NameNode记录操作日志，更新滚动日志。

4、NameNode在内存中对元数据进行增删改。

第二阶段：SecondaryNameNode工作

1、SecondaryNameNode询问NameNode是否需要CheckPoint，直接带回NameNode的响应

2、SecondaryNameNode请求执行CheckPoint

3、NameNode滚动正在写的Edits日志

4、将滚动前的编辑日志和镜像文件拷贝到SecondaryNameNode

5、SecondaryNameNode加载编辑日志和镜像文件到内存，并合并

6、生成新的镜像文件fsimage.checkpoint

7、拷贝fsimage.checkpoint到NameNode

8、NameNode将fsimage.checkpoint重新命名成fsimage

49、简述DataNode的工作机制

答：

1、一个数据块在DataNode上以文件形式存储在磁盘上，包括两个文件，一个是数据本身，另一个是元数据，包括数据块的长度，快数据的校验和，以及时间戳

2、DataNode启动后向NameNode注册，通过后会立刻上报数据块，这是第一次上报，之后周期性（6小时）的向NameNode上报所有的块信息。

3、心跳是每3秒一次，心跳返回结果带有NameNode给该DataNode的命令，如复制块数据到另一台机器，或删除某个数据块。如果超过10分钟没有收到某个DataNode的心跳，则认为该节点不可用。

4、集群运行中可以安全加入和退出一些机器。

50、简述MapReduce中，序列化的步骤

答：

1、必须实现Writable接口

2、反序列化时，需要反射调用空参构造函数，所以必须有空参构造器

3、重写序列化方法

4、重写反序列化方法

5、注意反序列化的顺序和序列化的顺序完全一致

6、要想把结果显示在文件中，需要重写toString()方法，可用"\t"分开，方便后续用

7、如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序

51、叙述hadoop中的shuffle的流程

答：

    map方法输出之后，reduce方法输入之前这个过程称为shuffle，它只是一个逻辑过程，并不是任务启动阶段，它横跨了MapTask阶段和ReduceTask阶段。

    map方法的输出结果以<k,v>键值对的形式传给采集器，采集器将数据写入环形缓冲区。环形缓冲区中有两类数据，一类是数据本身，以<k,v>键值对形式存储；一类是元数据，有kvindex，partition，kstart，vstart，vallen。环形缓冲区默认大小为100M，默认溢写阈值为80M，这个溢写阈值可以自定义。当数据写入环形缓冲区，它是从0M开始写，写到占据内存的80%，再从100M这个位置往里反向写入。当数据量比较大时，会生成多个溢写文件。Mapper会处理所有数据，包括在内存缓冲区始终达不到溢写阈值的剩余数据，也会被写入磁盘。数据在写入环形缓冲区之前就已经分好区了，在溢写的时候，还会对元数据进行一次分区，并会以分区为单位对元数据进行快排。等到这个切片上所有数据都溢写完成，会将所有的溢写文件合并成一个大文件，并对同一分区的数据进行归并排序。之后我们可以选择进行combine合并，好处是传输数据量会变小，但是前提不能影响最终结果的准确性。我们还可以选择将数据压缩，写入磁盘。

   当所有MapTask进程处理完任务后，MrAppMaster会根据分区数量启动相同数目的ReduceTask并告知要处理的数据分区。ReduceTask就会去各个MapTask所在节点的磁盘上拷贝相应分区的数据到内存缓冲区，若数据量大也会溢写进磁盘。当数据全部拷贝结束，会对数据进行归并排序并将同一key值的value值放一块传给reduce方法。

52、简述MapTask的5个阶段

答：

MapTask的5个阶段分为Read、Map、Collect、Spill、Merge阶段。

1、Read阶段：MapTask通过InputFormat获得一个个kv对

2、Map阶段：将Read阶段得到kv对交给map方法处理得到新的kv数据。

3、Collect阶段：收集map方法所产生数据并将数据写入环形缓冲区中。

4、Spill阶段：溢写，当环形缓冲区到达80%时，将数据快排并写入到磁盘中

53、简述ReduceTask的3个阶段

答：

ReduceTask的3个阶段分为Copy、Sort、Reduce阶段。

1、Copy阶段：将MapTask处理完的数据拷贝到内存中，如果数据过大会溢写。

2、Sort阶段：在拷贝的同时，会把内存和磁盘里相同分区的数据进行合并，然后再归并排序。

3、Reduce阶段：接收sort阶段数据，运行reduce方法，将计算结果发送给HDFS

54、论述mapreduce中，分区和reduceTask之间的数量问题

答：

ReduceTask数量可以自己设置，一般情况下等于分区数量，输出分区数个文件。

当ReduceTask为1时，分区等于没设置，只会有一个输出文件。

当ReduceTask数小于分区数大于1时，程序报错。

当ReduceTask数大于分区数时，会有空文件产生，浪费性能。

当ReduceTask为0时，没有Reduce阶段。

55、简述mapreduce中，FileInputFormat切片规则

答：

1、切片的时候不考虑数据集整体，而是逐个针对每一个文件单独切片。

2、简单地按照文件的内容长度进行切片

3、切片大小，默认等于Block的大小

4、当maxsize（切片最大值）<blocksize，会让切片变小，此时切片大小为maxsize

5、当minsize（切片最小值）>blocksize，会让切片变大，此时切片大小为minsize

6、当文件大小小于切片大小时，不对该文件进行切片；在切片时，检查剩余文件大小是否大于切片块的1.1倍，大于接着切，不大于不切。

56、没有行业工作经验，薪资要求高于预期怎么办

57、简述zookeeper中的选举机制和监听原理

答：

==========选举机制===========

假设有五台服务器组成的Zookeeper集群，他们的myid依次是1~5。假设他们都是最新启动的，那么在存放数据量这一点上，都一样没有历史数据。假设这些服务器按照id依次启动到半数以上的机器，也就是第三台服务器时，集群成功启动，选myid最大值的节点作为leader，其他服务器包括后面启动的服务器都会作为follower。

1）服务器1启动，此时只有它一台服务器启动了，它发出去的报文没有任何响应，所以它的选举状态一直是LOOKING状态。

2）服务器2启动，它与最开始启动的服务器1进行通信，互相交换自己的选举结果，由于两者都没有历史数据，所以id值较大的服务器2胜出，但是由于没有达到超过半数以上的服务器都同意选举它（这个例子中的半数以上是3），所以服务器1、2还是继续保持LOOKING状态。

3）服务器3启动，根据前面的理论分析，服务器3成为服务器1、2、3中的leader，而与上面不同的是，此时有三台服务器选举了它，所以它成为了这次选举的leader。

4）服务器4启动，根据前面的分析，理论上服务器4应该是服务器1、2、3、4中最大的，但是由于前面已经有半数以上的服务器选举了服务器3，所以它只能接收当小弟的命了。

5）服务器5启动，同4一样当小弟。

到半数以上的机器，也就是第三台服务器时，集群成功启动，选myid最大值的节点作为leader，其他服务器作为follower。

==========监听原理===========

1）首先要有一个main()线程

2）在main线程中创建Zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信(connect)，一个负责监听(listener)

3）通过connect线程将注册的监听事件发送给Zookeeper

4）在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中

5）Zookeeper监听到有数据或路径变化，就会将这个消息发送给listener线程

6）listener线程内部调用了process()方法

58、Hive 框架原理（非常重要）

*1）用户接口：*Client **

CLI（command-line interface）、JDBC/ODBC(jdbc 访问 hive)、WEBUI（浏览器访问 hive）

*2）元数据：*Metastore **

元数据包括：表名、表所属的数据库（默认是 default）、表的拥有者、列/分区字段、表的类型（是否是外部表）、表的数据所在目录等。默认存储在自带的 derby 数据库中，推荐使用 MySQL 存储 Metastore。

*3）*Hadoop **

使用 HDFS 进行存储，使用 MapReduce 进行计算。

*4）驱动器：*Driver **

（1）解析器（SQL Parser）：将 SQL 字符串转换成抽象语法树 AST，这一步一般都用第三方工具库完成，比如 antlr；对 AST 进行语法分析，比如表是否存在、字段是否存在、SQL 语义是否有误。

（2）编译器（Physical Plan）：将 AST 编译生成逻辑执行计划。

（3）优化器（Query Optimizer）：对逻辑执行计划进行优化。

（4）执行器（Execution）：把逻辑执行计划转换成可以运行的物理计划。对于 Hive 来说，就是 MR/Spark。

59、Hive 和数据库的关系与比较

答：

1、Hive的元数据表默认存放在Derby库中，但由于Derby不能满足并发需求，所以我们会将Hive的元数据地址改为MySQL。

2、Hive和数据库除了拥有类似的查询语句，再无类似之处。

3、查询语言方面，由于SQL被广泛的应用在数据仓库中，因此，专门针对Hive的特性设计了类SQL的查询语言HQL。熟悉SQL开发的开发者可以很方便的使用Hive进行开发。

4、数据更新方面，由于Hive是针对数据仓库应用设计的，而数据仓库的内容是读多写少的。因此，Hive中不建议对数据的改写，所有的数据都是在加载的时候确定好的。而数据库中的数据通常是需要经常进行修改的，因此可以使用INSERT INTO...VALUES添加数据，使用UPDATE...SET修改数据

5、执行延迟方面，Hive在查询数据的时候，由于没有索引，需要扫描整个表，因此延迟较高。另外一个导致Hive执行延迟高的因素是MapReduce框架。由于MapReduce本身具有较高的延迟，因此在利用MapReduce执行Hive查询时，也会有较高的延迟。相对的，数据库的执行延迟较低。当然，这个低是有条件的，即数据规模较小，当数据规模大到超过数据库的处理能力的时候，Hive的并行计算显然能体现出优势。

6、数据规模方面，由于Hive建立在集群上并可以利用MapReduce进行并行计算，因此可以支持很大规模的数据；对应的，数据库可以支持的数据规模较小。

60、hadoop自定义分区的步骤

61、公司是如何处理小数据的

答：

hadoop框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。

CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。

62、yarn调度器的种类

答：

目前，Hadoop 作业调度器主要有三种：FIFO、容量（Capacity Scheduler）和公平（Fair Scheduler）。 Apache Hadoop3.1.3 默认的资源调度器是 Capacity Scheduler。

63、Hive的运行机制

Hive 通过给用户提供的一系列交互接口，接收到用户的HQL指令，通过解析器将HQL指令解析成语法树，通过编译器将语法树编译成逻辑执行计划，通过优化器优化逻辑执行计划，再通过执行器将逻辑执行计划转化成物理执行计划。之后结合元数据(MetaStore)，若计算引擎是MapReduce，就将这些指令翻译成 MapReduce程序，并提交给Hadoop 的yarn执行，最后，将执行返回的结果输出到用户交互接口。

64、hive中，内部表和外部表区别？你们公司在做数据分析的时候用什么表？什么场景下使用内部表、外部表？（非常重要）

答：

1、什么是内部表、外部表？

在Hive中，内部表（也称为管理表或Managed Table）和外部表（External Table）是两种不同的表类型。

2、内部表和外部表有什么区别？

它们在数据管理方式上存在一些关键区别：

1）内部表是由Hive完全管理的。当创建一个内部表时，Hive会控制表数据的整个生命周期，包括数据的存储和删除。具体来说，内部表的数据存储在Hive的数据仓库中，当删除一个内部表时，Hive会自动删除表的元数据以及存储在HDFS上的数据。

2）外部表则不同，Hive只管理外部表的元数据，而不控制实际的数据。外部表的数据存储在HDFS或其他外部文件系统中。当删除一个外部表时，Hive只会删除表的元数据，而不会删除存储在外部文件系统中的实际数据。

3、内部表和外部表有什么使用场景？

内部表适合于数据需要Hive完全管理的情况，而外部表则适用于数据需要在Hive之外进行共享或备份的情况。比如，每天将收集到的网站日志定期流入 HDFS 文本文件。在外部表（原始日志表）的基础上做大量的统计分析，用到的中间表、结果表使用内部表存储，数据通过 INSERT+SELECT 进入内部表。

65、hive中， Order By、Sort By、Distribute By、Cluster By这四种排序有什么区别？（非常重要）

答：

1、Order By是按照指定字段对表数据进行全局排序，只有一个Reducer

2、Sort By是在分区后，按照指定字段对表数据进行区内排序，常在Distribute By后使用

3、Distribute By是按照指定的字段对表数据进行分区，分区后用Sort By来对区内数据排序

4、当Distribute By和Sort By字段相同时，就可以使用Cluster By方式来排序，而且Cluster By只能是升序排序

66、hive中，数据表用什么来存的？

答：关于文件格式、压缩格式

67、hive中，分区表和分桶表有什么区别？

答：

分区针对的是数据的存储路径；分桶针对的是数据文件。

展开讲就是，分区表实际上就是对应一个HDFS文件系统上的独立的文件夹，该文件夹下是该分区所有的数据文件。而对于一张表或者分区，hive可以进一步组织成桶，也就是更为细粒度的数据范围划分。

分桶是怎么分的呢？hive的分桶采用对分桶字段的值进行哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中。

68、hive中自定义函数的步骤？有用过什么自定义函数？

答：

步骤：

在hive中，我们可以自定义的函数类别有UDF(一进一出)、UDAF(多进一出)、UDTF(一进多出)这三种。创建流程大体是一致的，我们以自定义UDF函数为例。
1、创建一个Maven工程，导入（hive-exec）依赖

2、创建一个自定义函数类，需要继承GenericUDF类，并重写里面的抽象方法，比如initialize、evaluate、getDisplayString方法（方法的作用）

3、打成jar包上传到hive安装目录的lib目录下，并重启hive服务使得对所有会话有效，或者通过 add jar命令动态地将jar包添加到当前会话的classpath中

4、接着在hive会话中创建临时或永久函数，并与开发好的自定义函数类做关联

5、这时候我们就可以在hql语句中使用自定义的函数了，但是我们还要注意测试和调试，验证自定义函数的功能是否正确，之后我们可以编写文档，说明它的功能和使用方法

有用过什么自定义函数:

通过自定义函数将一行字符串根据分隔符直接炸成多行字符串（虽然我们通过在explode函数中使用split函数也可以实现）

69、hive中，开窗函数用到over(),那over()怎么用的？

答：

over()指定分析函数工作的数据窗口大小，
OVER()
子句可以包含多个参数，用于定义窗口的边界和排序方式。

常用分析函数有：

lag(col,n,default_val)：用于访问结果集中当前行之前的第 n 行的数据

lead(col,n,default_val)：用于访问结果集中当前行之后的第 n 行的数据

ntile(n)：用于将结果集中的行分成指定数量的组（分区）

Rank函数：rank()、dense_rank()、row_number()

over()子句的常见参数：
OVER (
    [PARTITION BY partition_expression [, ...]],
    [ORDER BY order_expression [ASC | DESC], ...],
    [ROWS BETWEEN range_boundary_preceding AND range_boundary_following]
)
PARTITION BY：指定窗口的分区标准，每个分区内的数据独立进行窗口函数的计算。

ORDER BY：指定窗口内数据的排序方式，排序依据可以影响窗口函数的计算结果。

ROWS BETWEEN：指定窗口的大小，可以是固定的行数，也可以是当前行之前或之后的行数。

70、 hive中，最近用开窗函数分析的指标是什么？说一下sql语句怎么写的，有哪些表？哪些字段？如何开窗？开窗的语法是什么？为什么这么开窗？用什么样的分析函数？

答：

71、hive中如何实现覆盖写？

答：

在Hive中，覆盖写（Overwrite）是一种常用的操作，用于更新表中的数据。覆盖写可以用来更新表中某个分区或整张表的数据。以下是实现覆盖写的步骤：

选择要覆盖写的表：首先，需要确定要进行覆盖写的表。如果只是想更新表中的部分数据，可以选择特定的分区进行覆盖写。

创建查询：使用SELECT语句来选择要写入表中的数据。这个查询应该包括所有表中存在的列，以及需要更新的数据。

执行覆盖写操作：使用INSERT OVERWRITE语句来执行覆盖写操作。如果只想更新表的某个分区，可以使用PARTITION关键字来指定分区。

提交任务：执行完覆盖写操作后，提交Hive任务。

72、hive中，常见聚合函数？用过哪些聚合函数？

答：

常见的聚合函数包括：

**COUNT()**：计算指定列中非NULL值的个数，或者计算表中的行数。

**SUM()**：计算列中数值的总和。

**AVG()**：计算列中数值的平均值。

**MAX()**：返回列中的最大值。

**MIN()**：返回列中的最小值。

73、hive中，rank()、dense_rank()、row_number()有什么区别？

答：

RANK() 排序相同时会重复，总数不会变。

DENSE_RANK() 排序相同时会重复，总数会减少。

ROW_NUMBER() 会根据顺序计算。

74、hive的内置函数包括哪几种？怎么用的

答：

1、NVL(value，default_value)。它的作用：给值为 NULL 的数据赋值，如果 value 为 NULL，则 NVL 函数返回 default_value 的值，否则返回 value 的值，如果两个参数都为 NULL ，则返回 NULL

2、CASE WHEN THEN ELSE END

3、行转列：
1）CONCAT(string A/col, string B/col…)：返回输入字符串连接后的结果，支持任意个输入字符串; 



   2）CONCAT_WS(separator, str1, str2,...)：它是一个特殊形式的 CONCAT()。第一个参数是剩余参数间的分隔符 



   3）COLLECT_SET(col)：函数只接受基本数据类型，它的主要作用是将某字段的值进行去重汇总，产生 Array 类型字段 
4、列转行：
   1） 
EXPLODE(col)：将 hive 一列中复杂的 Array 或者 Map 结构拆分成多行
2）LATERAL VIEW udtf(expression) tableAlias AS columnAlias：用于和 split, explode 等 UDTF 一起使用，它能够将一列数据拆成多行数据，在此基础上可以对拆分后的数据进行聚合。 
5、开窗函数：
   1） 
LAG(col,n,default_val)：往前第 n 行数据，若为空，则返回设置的默认值default_val
2）LEAD(col,n, default_val)：往后第 n 行数据，若为空，则返回设置的默认值default_val

3）NTILE(n)：把有序窗口的行分发到指定数据的组中，各个组有编号，编号从 1 开始，对于每一行，NTILE 返回此行所属的组的编号。 
注意：n 必须为 int 类型。

6、排序函数：
1）RANK() 排序相同时会重复，总数不会变。 

2）DENSE_RANK() 排序相同时会重复，总数会减少。 

3）ROW_NUMBER() 会根据顺序计算。

75、简述Hive中分析函数Lag和Lead的区别。

答：
   1） 
LAG(col,n,default_val)：往前第 n 行数据，若为空，则返回设置的默认值default_val
2）LEAD(col,n, default_val)：往后第 n 行数据，若为空，则返回设置的默认值default_val

76、hive中治理数据倾斜的方法

答：

1、针对group by 造成的数据倾斜，可以考虑将
hive.map.aggr
配置选项设置为
true
，使Hive尽可能地在Map端完成聚合操作，从而减少Reduce任务的数量和数据倾斜问题。

2、针对小表 join 大表出现的数据倾斜，将Reduce join 改为Map join，这样避免了Shuffle阶段，从而避免了数据倾斜，前提是小表的大小的不能太大，一般也就几百兆

3年数据工程师总结：Hive数据倾斜保姆教程（手册指南） (qq.com)

Hive调优——数据倾斜的解决指南_hive数据倾斜解决办法-CSDN博客

77、 flume采集数据的时候会丢吗？

答：

==============事务机制=================

Flume通过其内部的事务机制来确保数据的完整性和一致性。Flume的事务性可以分为两个阶段：从Source到Channel的传输（put事务）和从Channel到Sink的传输（take事务）：

put事务原理：

1、当Source接收到数据时，它会将这些数据封装成事件（Event）并写入到Channel。

2、写入操作是事务性的，意味着Source会尝试将事件写入Channel，并在成功写入后提交事务。如果写入操作失败（例如，Channel已满或Channel不可用），Source会回滚事务，确保数据不会被部分写入。

3、只有当所有事件都成功写入Channel并提交事务后，Source才会认为这些事件已经成功处理，并继续处理下一批事件。

take事务原理：

1、Sink从Channel读取事件的过程也是事务性的。Sink会尝试从Channel中读取事件，并在成功读取后提交事务。

2、如果读取操作失败（例如，Channel中没有可用的事件或Channel不可用），Sink会回滚事务，确保没有对事件进行处理。

3、只有当所有事件都成功读取并提交事务后，Sink才会认为这些事件已经被处理，并继续读取下一批事件。

78、在kafka中，生产者消息发送的流程有哪些步骤？

答：

1、首先在消息发送的过程中，涉及到两个线程，分别是main线程和sender线程。

2、生产者在main线程创建一个ProducerRecord对象，这个对象包含目标主题（Topic）和要发送的消息，还可以指定键（Key）、分区（Partition）和副本数量。

3、通过序列化器，生产者将消息的键和值序列化为字节数组。

4、如果ProducerRecord中没有指定分区，那么分区器会根据键（Key）来选择一个分区。如果消息中没有键，那么分区器会使用轮询（Round-Robin）策略来选择一个分区。

5、序列化后的数据会被添加到双端队列缓冲区（RecordAccumulator）的不同队列中，sender线程会不断轮询队列，看是否有消息批次达到配置的阈值（批处理大小或等待时间），如果满足触发条件就会从缓冲区中读取这些消息批次，并将其发送给NetworkClient（网络客户端）。每个消息批次都会形成一个请求request，默认每个broker节点最多缓存5个请求。

6、Selector通过网络将请求request发送到Kafka集群的Broker

7、如果在发送过程中发生异常，如网络问题或Broker节点故障，NetworkClient会根据生产者的配置进行重试。

8、发送完成后，NetworkClient会等待Broker的应答。默认是Leader 和 isr 队列里面的所有节点收齐数据后应答。可以通过生产者的配置，修改应答级别。

0：生产者发送过来的数据，不需要等数据落盘应答。

1：生产者发送过来的数据，Leader 收到数据后应答。

-1（all****）：生产者发送过来的数据，Leader 和 isr 队列里面的所有节点收齐数据后应答。

9、producer收到响应时会调用回调函数，回调函数有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败。

79、遍历Map集合的常见方法

答：

1、使用for-each循环和Map.Entry遍历：这是一种非常常用的方法，通过Map.Entry对象可以同时获取键和值

2、使用Iterator遍历：使用Map的entrySet()方法获取迭代器

3、只遍历键或值：如果只需要键或值，可以使用keySet()或values()方法

4、使用Java 8的Stream API： Java 8引入了Stream API，也可以用来遍历Map

80、stringbuffer和stringbuilder的区别

答：
1、StringBuffer
的方法都是同步的，使用
synchronized
关键字来保证线程安全；
  StringBuilder
不是线程安全的，它没有同步方法

2、
StringBuffer
由于其线程安全的特性，通常比
StringBuilder
慢

3、
StringBuffer
适用于多线程环境下的字符串操作，而
StringBuilder
适用于单线程环境下的高性能字符串操作

81、kafka基础架构

答：

1、生产者：生产者是向Kafka集群发送消息的客户端应用程序。它们可以发送消息到Kafka集群中的一个或多个主题（Topic），每个主题可以有多个分区（Partition）

2、kafka集群

3、消费者：每个消费者可以订阅多个topic，可以指定订阅的分区，并且可以同时消费来自不同分区的数据，这种并行读取可以显著提高消息处理的吞吐量。

4、消费者组：消费者组用于管理一组消费者的协调和负载均衡。一个消费者组可以消费多个Topic，组内每个消费者负责消费不同的分区，从而实现负载均衡。如果多个消费者订阅了相同的Topic，但它们属于不同的消费者组，这些消费者可以并行消费消息，而不会产生重复。

5、zookeeper：Zookeeper用于协调Kafka集群中的代理。它维护代理的元数据信息，如主题和分区的信息，以及领导者副本的选举。Zookeeper还帮助实现代理之间的通信。

82、生产者如何保证数据可以百分百发送给kafka？

答：

83、生产者要往kafka发送数据，如何保证数据不重复不丢？

答主题

实现精确一次有两种方法：

1、幂等性+至少一次（...）

2、幂等性+事务机制

84、kafka中，如何保证数据单分区有序？

答：

85、kafka中，开启并使用事务的步骤

答：

1、设置事务 id（必须），事务 id 任意起名

properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transactional_id_0");

2、初始化事务

kafkaProducer.initTransactions();

3、开启事务

kafkaProducer.beginTransaction();

4、提交事务

kafkaProducer.commitTransaction();

5、终止事务

kafkaProducer.abortTransaction();

86、kafka中，分区在生产环境中带来什么样的好处？

答：

一、便于合理使用存储资源，每个 Partition 在一个 Broker 上存储，可以把海量的数据按照

分区切割成一块一块数据存储在多台 Broker 上。合理控制分区的任务，可以实现**负载均衡 **

的效果。

二、提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数****据。

87、kafka中的三种应答级别

88、kafka的几种分区策略

答：

89、kafka三种数据传递语义，用ack的应答级别怎么设置？

答：

1、至少一次（At Least Once）=ACK级别设置为-1+分区副本大于等于2+ISR里应答的最小副本数量大于等于2

2、最多一次（At Most Once）=ACK级别设置为0或1

3、精确一次（Exactly Once）：幂等性+至少一次（ack=-1+分区副本书>=2+ISR最小副本数量>=2）

90、kafka中，生产者如何实现自定义分区器？

答：

1、定义类实现 Partitioner 接口。

2、重写 partition()方法

3、使用分区器的方法，在生产者的配置中添加分区器参数

91、kafka中，broker的工作流程

答：

1、broker启动后会把自身的元数据信息注册到zookeeper中

2、每个broker中都会有一个controller进程，当kafka集群启动时，各个broker中的controller谁先在zookeeper中注册，这个controller就会去监听brokers节点变化，并管理副本leader的选举。

3、选举过程中，controller会根据“在isr中存活为前提，按照AR中排在前面的优先”这样的规则选举leader，其他存活的副本作为follower。

4、controller会将节点信息上传到zookeeper上，包括副本的leader所在的节点，以及isr队列中会记录存储该副本的存活的节点有哪些（包括leader和follewer）

5、其他broker上的controller进程会从zookeeper同步相关信息。

6、假设broker1中的leader挂了，controller会监听到节点变化，从zookeeper中获取isr列表信息，并会根据“在isr中存活为前提，按照AR中排在前面的优先”这样的规则重新选举leader。如果follower挂了，不会影响leader。

7、当生产者往leader所在节点发送消息，，由于应答级别设置为-1，leader会等isr列表里的所有节点收齐消息后应答producer。数据在broker逻辑上是以分片的形式存储的，分片大小最大1G，实际数据存储在.log文件中，.index是索引文件。

92、kafka中，LEO和HW的区别？

答：

1、LEO（Log End Offset）：每个副本的最后一个offset，LEO其实就是最新的offset+1

2、HW（High Watermark）：所有副本中最小的LEO

93、kafka中，AR、ISR和OSR之间的关系？

答：

AR（Assigned Replicas）:是kafka分区中的所有副本所在节点的broker id的列表

ISR：kafka分区中所有活着的副本所在节点的broker id的列表

OSR：kafka分区中挂了的副本所在节点的broker id的列表

关系：AR = ISR + OSR

94、kafka是如何实现高效读写数据的？

答：

1、kafka本身是分布式集群，可以采用分区技术，并行度高

2、读数据采用稀疏索引，可以快速定位要消费的数据

3、kafka的producer生产数据，会写进日志文件中，写的过程是顺序写，顺序写可以省去大量磁头寻址的时间

4、零拷贝：kafka的数据加工处理操作交由kafka生产者和kafka消费者来处理，而kafka Broker应用层不关心存储的数据，所以读取数据时不用走应用层，传输效率高
**PageCache页缓存**：kafka重度依赖底层操作系统提供的页缓存功能。当上层有写操作是，操作系统只是将数据写入页缓存中。当读操作发生时，先从页缓存中查找，如果找不到，再去磁盘中读取。实际上，页缓存是把尽可能多的空闲内存都当作了磁盘缓存来使用。

95、kafka中，假设一个主题的数据有4个分区，配几个消费者可以达到最好的性能？

答：4个消费者

96、kafka中，消费者组初始化流程

答：

1、消费者启动时，会指定它所属的消费者组id，并连接到kafka集群。

2、消费者向kafka集群发送一个加入消费者组的请求，这个请求会被发送给kafka集群中的组协调器，由组协调器来管理加入消费者组。

3、如果消费者组是第一次启动，kafka会从各节点的协调器中选举一个协调器负责管理这个消费者组的所有请求，包括消费者加入和离开组、分区分配等。

选举规则：consumer_offsets主题的第 “hashcode值%50” 个分区所在节点的协调器为该消费者组的组协调器。（50为consumer_offsets主题的默认分区数量）

4、组协调器在消费者组中选出一个consumer作为leader

5、组协调器把要消费的topic情况发送给consumer leader

6、consumer leader会负责制定消费方案，并把消费方案发给组协调器

7、组协调器会把消费方案下发给组内各个消费者实例

8、组内每个消费者实例都会和组协调器保持默认3秒一次的心跳，一旦超过默认的45s没有响应，该消费者就会被移除，并触发再平衡；或者消费者处理消息的时长超过默认的5分钟，也会触发再平衡。

97、kafka中，消费者组详细消费流程

答：

1、组内消费者通过网络客户端向分区发送消费请求

2、当分区内写入消息，数据量达到默认的50M阈值，或者等待时间达到默认的500ms时，消费者从分区拉取消息，一次拉取的消息条数最大值默认500条，这些消息被存储到消费者的内存缓冲区中。

3、消费者对拉取到的消息进行反序列化处理、业务逻辑处理等

4、在处理完消息后，消费者需要向Kafka提交offset，表示这些消息已经被消费。

98、kafka中，生产经验--消费者分区的分配以及再平衡

答：

==============分区分配策略=================

1、kafka中默认的分区分配策略是什么？它的工作原理是什么？

Range+CooperativeSticky

这种默认分配策略结合了Range策略的均衡性和CooperativeSticky策略的粘性

2、列举消费者主流的分区分配策略是什么？

1）Range：

对于每个主题，将分区按范围分给消费者。每个消费者负责一个连续的分区范围。这种策略可以保证负载均衡，但可能会导致某些消费者处理更多的数据。

2）RoundRobin：

把消费者组订阅的所有主题的所有分区当作一个整体，分别对分区和消费者排序，然后通过轮询的方式，按照顺序将分区分配给消费者。

3）Sticky、CooperativeSticky：

对于每个主题，将分区均衡的分配给消费者，在发生再平衡时，会尽量保持原有的分区分配不变，即保持消费者与分区的粘性，这种策略通过最小化分区的移动来实现

==============再平衡================

1、什么时候会触发消费者的分区再平衡？
消费者加入或离开消费者组、主题的分区数发生变化
2、如果一个消费者在处理消息时超过了max.poll.interval.ms设置的时间，会发生什么？
移出消费者组，触发消费者分区再平衡
3、在使用range分区策略时，如果一个消费者宕机，其他消费者如何重新分配这个消费者的分区？
分区会作为一个整体分配给其他某个消费者
4、在使用粘性分区策略时，如果一个消费者宕机，其他消费者如何重新分配这个消费者的分区？

分区会通过轮询的方式，分配给其他消费者

5、如果在使用RoundRobin分区策略时，一个消费者宕机，其他消费者如何重新分配这个消费者的分区？

分区会按照粘性规则，尽可能均衡、随机地分配给其他消费者

99、kafka中，面对数据积压的情况，消费者如何提高吞吐量

答：

1、增加topic的分区数，并同时增加消费组的消费者数量，保证消费者数=分区数

2、提高每次从分区拉取消息数量的最大值，即max.poll.records

100、kafka中，什么是重复消费、漏消费？怎么能做到既不漏消费也不重复消费？

答：

重复消费:

是指将数据拉到消费者的内存缓冲区后，此时数据还没有被处理，所以offset并没有被自动提交。此时，消费者挂了，当重启消费者后，会从上一次提交的offset处重新消费数据。

漏数据:

是指数据已经在消费者的内存缓冲区内处理过了，在数据落盘持久化前，我们就手动提交了offset。此时若消费者挂了，内存里的数据丢失，而由于已经提交了offset，当重启消费者后，并不会重新消费数据。

怎么能做到既不漏消费也不重复消费？(。。。)

1、建议在业务逻辑处理完数据并确认数据已经被成功持久化后，再手动提交offset，这样可以避免在消费者线程kill或其他故障情况下导致的数据丢失或重复消费。

2、将kafka消费端的消费过程和提交offset过程做原子绑定，下游消费者支持事务，将kafka的offset保存到支持事务的自定义介质（如MySQL）

101、给集群加机器或者给机器加硬盘后，如何实现数据均衡？

答：

*1***）节点间数据均衡 **

开启数据均衡命令：

start-balancer.sh -threshold 10

对于参数 10，代表的是集群中各个节点的磁盘空间利用率相差不超过 10%，可根据实

际情况进行调整。

停止数据均衡命令：

stop-balancer.sh

2****）磁盘间数据均衡（单个节点）

（1）生成均衡计划

hdfs diskbalancer -plan hadoop183

（2）执行均衡计划

hdfs diskbalancer -execute hadoop183.plan.json

（3）查看当前均衡任务的执行情况

hdfs diskbalancer -query hadoop183

（4）取消均衡任务

hdfs diskbalancer -cancel hadoop183.plan.json

102、hadoop参数调优

==========问题1=============

情景描述：总共 7 台机器，每天几亿条数据，数据源->Flume->Kafka->HDFS->Hive

面临问题：数据统计主要用 HiveSQL，没有数据倾斜，小文件已经做了合并处理，开

启的 JVM 重用，而且 IO 没有阻塞，内存用了不到 50%。但是还是跑的非常慢，而且数据

量洪峰过来时，整个集群都会宕掉。基于这种情况有没有优化方案。

解决办法：

内存利用率不够。这个一般是 Yarn 的 2 个配置造成的，单个任务可以申请的最大内存

大小，和 Hadoop 单个节点可用内存大小。在yarn-site.xml配置文件中，调节这两个参数能提高系统内存的利用率。

（a）yarn.nodemanager.resource.memory-mb

表示该节点上 YARN 可使用的物理内存总量，默认是 8192（MB），注意，如果你的节点

内存资源不够 8GB，则需要调减小这个值，而 YARN 不会智能的探测节点的物理内存总量。

（b）yarn.scheduler.maximum-allocation-mb

单个任务可申请的最多物理内存量，默认是 8192（MB）。

==========问题2==============

问题描述：当HDFS 集群面临高并发访问时，例如有很多客户端同时进行文件操作，如何提高 NameNode 处理请求的能力？

解决办法：

在配置文件hdfs-site.xml中，调大参数 dfs.namenode.handler.count，它的默认值为10。
<property>
<name>dfs.namenode.handler.count</name>

<value>10</value>
</property>
如何确定这个值？

dfs.namenode.handler.count=20 × $\log_{e}Cluster Size$ ，比如集群规模为 8 台时，此参数设置为 41。可通过简单的 python 代码计算该值，代码如下。
[bdqn@hadoop182 ~]$ python
Python 2.7.5 (default, Apr 11 2018, 07:36:10)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more
information.
>>> import math
>>> print int(20*math.log(8))
41
>>> quit()

103、如何确定kafka机器数量？

答：

Kafka 机器数量（经验公式）=2（峰值生产速度副本数/100）+1

先拿到峰值生产速度，再根据设定的副本数，就能预估出需要部署 Kafka 的数量。

比如：

我们的峰值生产速度是 50M/s。副本数为 2。

Kafka 机器数量=2（502/100）+ 1=3 台

104、如何确定kafka分区数量？

答：

1）创建一个只有 1 个分区的 topic

2）测试这个 topic 的 producer 吞吐量和 consumer 吞吐量。（通过kafka压力测试获得吞吐量）

3）假设他们的值分别是 Tp 和 Tc，单位可以是 MB/s。

4）然后假设总的目标吞吐量是 Tt，那么分区数=Tt / min（Tp，Tc）

5）尽量保持kafka集群规模和分区数量相等

比如：

producer 吞吐量=20m/s；consumer 吞吐量=50m/s，期望吞吐量 100m/s；

分区数=100 / 20 =5 分区

https://blog.csdn.net/weixin_42641909/article/details/89294698

分区数一般设置为：3-10 个

105、维度建模

答：《03-大数据项目之电商数据仓库系统》2.3、2.4、2.5

spark常见算子，转化算子

spark血缘

spark怎么提交资源

spark宽依赖窄依赖

mysql中添加一个字段，用sqoop统计字段的时候会有影响吗

标签：面试

本文转载自: https://blog.csdn.net/qq_45113659/article/details/140477013
版权归原作者 田小带 所有，如有侵权，请联系我们删除。