2021超全大数据面试宝典，吐血总结十万字，大数据面试收藏这一篇就够了_狂野大数据高薪面试宝典

1. 找工作流程

1. 学习技能

1.1.1

1. 编写简历

简历编写可在公众号【五分钟学大数据】后台发送：简历，获取大数据简历的模板，包含各个行业及各个项目，非常全。可直接扫码：

1. 投简历

如能内推，尽量走内推路线，可免简历筛选，如果找不到内推路径，可在牛客网上搜内推码，上面有很多公司的员工发内推码。

招聘软件推荐 Boss直聘，这个软件还是很靠谱的，其他的智联招聘，拉勾，前程无忧，猎聘也不错。

1. 约面试时间

1. 一般需要多轮面试
2. 不想去的公司先去面试，积累面试经验，想去的公司约到最后
3. 合理安排面试时间，给自己尽可能的留一些复习的时间

1. 面试

1. 人事面试，了解基本情况--笔试/填表
2. 一面：技术经理面试（面试官一般是入职之后你的直接上级，此面很重要）
3. 二面：技术老大面试
4. 三面：架构师/大Boss面试
5. .....

1. 等回复

1. 不要立马入职

1. 拿offer
2. 入职
3. 准备必备资料，签合同

1. 面试说明

1. 笔试

1. 试题量：一般两页纸，多的有3页纸
2. 考题类型：选择和简答，简答居多

选择题：基础知识类型的选择题（编程语言，数据库，操作系统，大数据要点知识，网络，计算机组成原理等）

    简答题：

1. 1. 知识点的详细解释类，比如，MapReduce的Shuffle详细过程
   2. 对比之类，Hive内部表和外部表的区别，MapReduce和Spark的异同？

    编程题：算法题（考察逻辑思维，考察解答问题的方式方法等）

    数据库类型的SQL编写题目（MySQL或者Hive）这是必出题，也是分必拿题。否则就全盘覆没了。

SQL题：必有（Hive和MySQL）

    场景题：

    给你假定一种场景，让你给出解决方案，面试问的最多的也是这种

    遇到了问题（集群节点宕机，任务运行出错，数据丢失等），该如何解决？

    简单脚本题：

    写出一个简单的数据处理脚本，或者运维脚本（会的就自己写，不会的就百度搜，或者求救于小伙伴）

1. 面试
   1. 1. 人事面试

聊基本情况，聊工作经历，聊人生价值观，聊对工作的态度，聊方方面面，就是不聊技术

请事先准备好针对你个人基本情况的面试题

1、比如你原来在上海，为何10月份来北京找工作？

2、比如工作经历中，有4个月是不上班的，怎么解释？

.....

1. 1. 1. ·手写代码

也就是做题 

当然技术面试过程中，也有可能会出现手写代码的问题

经典手写代码：

• 快速排序和归并排序，冒泡排序（优先级由高到低）
• 一个设计模式的实现：比如单例，比如代理，比如装饰器
• 多线程相关，比如两个线程交替执行
• java,mapreduce,scala,spark的wordcount
• 画出你的项目的架构图 或者 数据处理流程架构图
  1. 1. 技术经理面试

基本只聊技术。

基本套路：

• 先自我介绍
• 然后介绍项目
• 从项目入手
• 先聊业务
• 再切入到技术点
• 问如何实现、项目结构、数据处理流程
• 问遇到过什么难题，怎么解决的，怎么发现的和怎么避免
• 问相类似的场景，如何做技术选型
• 问相类似的突发情况，应该怎么决策快速解决问题

    考察广度的同时，也会考察深度

通俗的说，也就是会在不同的方向，不同的领域问各种问题，然后针对你能回答的问题，就深入探讨，以此得知你对这门技术的掌握程度

    所以：

    考察广度，就是看你的技术领域分布

    考察深度，就是看你你对这个技术掌握程度如何

    总体来说：

• 聊业务
• 聊技术
• 聊问题
• 聊解决方案
• ....
  1. 1. CTO/技术架构师等面试（如果过了技术经理面试）

    到了这种级别的面试，一般考察技术的就少了。

    更多的是考察发展，眼光更长远的，考察你的职业生涯规划，考察你的价值观，考察你是否符合公司的长期发展战略

    能了解公司更多信息，就切合公司实际去描述

    如果不了解公司的，那就尽量按照通用套路说

1. 机试

少数场景会有的。但是不要慌。按照自己的本事来。

有些是现场的，这种很少。有些是给出需求之后让你回来之后自己做。

1. 面试考察方式
   1. 1. 知识广度

编程语言方向

    java是重点（重中之重），其次：scala、python

    java中的重点考察方向：

        集合（优缺点，底层实现，更好的替代方案，如何根据场景选择和使用）

        并发（锁，JMM，各种关键字（volite），技术点，线程池，......）

        面向对象

    数据库方向

    mysql是重点，其次是hbase，redis

    sql语句的编写和优化就不说了，没有不考查的 

    Hadoop体系/Spark体系

    架构原理

    工作机制

    典型的常见流程

    某个功能的详细分析

    问题和运维难点

    集群规模/集群规划

    任务多少

    任务运行总时长

    每天数据量

    总数据量

    多少条记录

    每条记录多大

    每条记录多少个字段

    hive的总表数等等

    其他知识：

        ElasticSearch

        Flink

        机器学习

        架构

        优化

        源码

        数据结构

        算法

1. 1. 1. 知识深度

追根究底的问各种你答的上来的东西的底层实现细节，直到你答不上来为止，或者到他满意为止  

关于HashMap的问题：

• 什么是HashMap，能否自己实现一个？
• 什么时候使用HashMap，有没有替代品？有没有什么好的hasmap使用经验？
• HashMap和HashTable的区别？优缺点？如何选择在那种场景使用？有没有更好的map实现类？
• 你知道HashMap的内部数据结构么？/   put和get操作的原理么？
• HashMap的初始长度和扩容策略是怎样的？（什么时候触发扩容，扩大到多少，扩容的时候要考虑什么问题？）
• HashMap初始化传入的容量参数的值就是HashMap实际分配的空间么？
• HashMap解决hash冲突的策略是什么？
• HashMap能同步/线程安全么？怎么做？
• 了解HashMap的条件竞争么？
• JDK7和JDK8的hashmap一样么？
• HashMap的key的hash计算规则是怎样的？
• HashMap的key有什么要求？为什么最好是String或者Integer这种类型呢？为什么不要是自定义对象呢？
• 了解Hash攻击么？
• 了解ConcurrentHashMap么？了解他的工作原理么？和HashMap相比较，优势在哪里？

1. 面试过程最关键的是什么？

1. 不是你说了什么，而是你怎么说
2. 大大方方的聊，放松

1. 面试要点

1. 乐观开朗，不让要人觉得跟你很难交流，要善于交流，善于倾听

    别人说的合理的给予赞同和钦佩

    别人说的你不赞同的你不要反对，你可以用另外一种方式表现出你的看法和意见，这是讨论和交流，不是针锋相对

1. 积极向上，所有人都希望融入团队的新人都能给团队增添活力，带给团队乐趣，大家轻松工作，愉快生活
2. 上进好学，不是说别人一说到不会的，你就说我会去学的，而是要表现出我曾经就是这么学过来的
3. 有礼貌有情商有智商，不要看起来傻傻的没见过世面一样的，不妄自菲薄，但是也要谦卑，要表现出我有货，但是知道自己不够，自己正在努力
4. 面试要注意引导。尽量把面试官往你擅长的领域去引导。
5. 关于回答问题，记住，如果不懂这个问题，可以让面试官再叙述一遍的。如果是真回答不上来，就真诚的回答说不知道，不了解，不太清楚。如果你发现你回答的某些问题的答案，面试官在质疑你，你也不要质疑自己。就一口咬死就是这样的。当然不能是离谱的答案还要坚持。
6. 总之一切随机应变

1. 面试技巧
   1. 1. 六个常见问题

1. 你的优点是什么？

    大胆的说出自己各个方面的优势和特长

不要写消遣类的爱好，比如爬上，唱歌看电影

1. 你的缺点是什么？

    不要谈自己真实问题；用“缺点”衬托自己的优点

1. 你的离职原因是什么？

• 不说前东家坏话，哪怕被伤过
• 合情合理合法
• 不要说超过1个以上的原因

1. 您对薪资的期望是多少？

• 非终面不深谈薪资
• 只说区间，不说具体数字
• 底线是不低于当前薪资
• 非要具体数字，区间取中间值，或者当前薪资的+20%

1. 您还有什么想问的问题？

• 这是体现个人眼界和层次的问题
• 问题本身不在于面试官想得到什么样的答案，而在于你跟别的应聘者的对比
• 标准答案：

公司希望我入职后的3-6个月内，给公司解决什么样的问题

公司（或者对这个部门）未来的战略规划是什么样子的？

1. 您最快多长时间能入职？

    一周左右，如果公司需要，可以适当提前

1. 1. 1. 两个注意事项

1. 职业化的语言
2. 职业化的形象

1. 1. 1. 自我介绍（控制在4分半以内，不超过5分钟）
2. 个人基本信息
3. 工作履历

    时间、公司名称、任职岗位、主要工作内容、工作业绩、离职原因

1. 深度沟通（也叫压力面试）

    刨根问底下沉式追问（注意是下沉式，而不是发散式的）

    基本技巧：往自己熟悉的方向说

1. 手写代码
   1. 冒泡排序

/**
 
 * 冒泡排序 时间复杂度 O(n^2) 空间复杂度O(1)
 
 */
 
  public class BubbleSort {
 
    public static void bubbleSort(int[] data) {
 
        System.out.println("开始排序");
 
        int arrayLength = data.length;
 
        for (int i = 0; i < arrayLength - 1; i++) {
 
            boolean flag = false;
 
            for (int j = 0; j < arrayLength - 1 - i; j++) {
 
                if(data[j] > data[j + 1]){
 
                    int temp = data[j + 1];
 
                    data[j + 1] = data[j];
 
                    data[j] = temp;
 
                    flag = true;
 
                }
 
            }
 
            System.out.println(java.util.Arrays.toString(data));
 
            if (!flag)
 
                break;
 
        }
 
    }
 
    public static void main(String[] args) {
 
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
 
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
 
        bubbleSort(data);
 
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
 
    }
 
}

1. 1. 二分查找

实现代码：

/**
 
 * 二分查找 时间复杂度O(log2n);空间复杂度O(1)
 
 */
 
  def binarySearch(arr:Array[Int],left:Int,right:Int,findVal:Int): Int={
 
  if(left>right){//递归退出条件，找不到，返回-1
 
    -1
 
  }
 
  val midIndex = (left+right)/2
 
  
 
  if (findVal < arr(midIndex)){//向左递归查找
 
    binarySearch(arr,left,midIndex,findVal)
 
  }else if(findVal > arr(midIndex)){//向右递归查找
 
    binarySearch(arr,midIndex,right,findVal)
 
  }else{//查找到，返回下标
 
    midIndex
 
  }
 
}

拓展需求：当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到。

代码实现如下：

/*
 
{1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.
 
//分析
 
1. 返回的结果是一个可变数组 ArrayBuffer
 
2. 在找到结果时，向左边扫描，向右边扫描 [条件]
 
3. 找到结果后，就加入到ArrayBuffer
 
 */
 
  def binarySearch2(arr: Array[Int], l: Int, r: Int,
 
                  findVal: Int): ArrayBuffer[Int] = {
 
  
 
  //找不到条件?
 
  if (l > r) {
 
    return ArrayBuffer()
 
  }
 
  
 
  val midIndex = (l + r) / 2
 
  val midVal = arr(midIndex)
 
  if (midVal > findVal) {
 
    //向左进行递归查找
 
    binarySearch2(arr, l, midIndex - 1, findVal)
 
  } else if (midVal < findVal) { //向右进行递归查找
 
    binarySearch2(arr, midIndex + 1, r, findVal)
 
  } else {
 
    println("midIndex=" + midIndex)
 
    //定义一个可变数组
 
    val resArr = ArrayBuffer[Int]()
 
    //向左边扫描
 
    var temp = midIndex - 1
 
    breakable {
 
      while (true) {
 
        if (temp < 0 || arr(temp) != findVal) {
 
          break()
 
        }
 
        if (arr(temp) == findVal) {
 
          resArr.append(temp)
 
        }
 
        temp -= 1
 
      }
 
    }
 
    //将中间这个索引加入
 
    resArr.append(midIndex)
 
    //向右边扫描
 
    temp = midIndex + 1
 
    breakable {
 
      while (true) {
 
        if (temp > arr.length - 1 || arr(temp) != findVal) {
 
          break()
 
        }
 
        if (arr(temp) == findVal) {
 
          resArr.append(temp)
 
        }
 
        temp += 1
 
      }
 
    }
 
    return resArr
 
  }

1. 1. 快排

代码实现：

/**
 
 * 快排 
 
 * 时间复杂度:平均时间复杂度为O(nlogn)
 
 * 空间复杂度:O(logn)，因为递归栈空间的使用问题
 
 */
 
  public class QuickSort {
 
    public static void main(String[] args) {
 
        int [] a = {1,6,8,7,3,5,16,4,8,36,13,44};
 
        QKSourt(a,0,a.length-1);
 
        for (int i:a) {
 
            System.out.print(i + " ");
 
        }
 
    }
 
    private static void QKSourt(int[] a, int start, int end) {
 
        if (a.length < 0){
 
            return ;
 
        }
 
        if (start >= end){
 
            return ;
 
        }
 
        int left = start;
 
        int right = end;
 
        int temp = a[left];
 
        while (left < right){
 
            while (left < right && a[right] > temp){
 
                right -- ;
 
            }
 
            a[left] = a[right];
 
            while (left < right && a[left] < temp){
 
                left ++ ;
 
            }
 
            a[right] = a[left];
 
        }
 
        a[left] = temp;
 
        System.out.println(Arrays.toString(a));
 
        QKSourt(a, start, left -1);
 
        QKSourt(a,left+1,end);
 
    }
 
}

1. 1. 归并

核心思想：不断的将大的数组分成两个小数组，直到不能拆分为止，即形成了单个值。此时使用合并的排序思想对已经有序的数组进行合并，合并为一个大的数据，不断重复此过程，直到最终所有数据合并到一个数组为止。

代码实现：

/**
 
 * 快排 
 
 * 时间复杂度:O(nlogn)
 
 * 空间复杂度:O(n)
 
 */
 
  def merge(left: List[Int], right: List[Int]): List[Int] = (left, right) match {
 
  case (Nil, _) => right
 
  case (_, Nil) => left
 
  case (x :: xTail, y :: yTail) =>
 
    if (x <= y) x :: merge(xTail, right)
 
    else y :: merge(left, yTail)
 
}

1. 1. 二叉树之Scala实现
      1. 二叉树概念

1. 1. 1. 二叉树的特点
2. 树执行查找、删除、插入的时间复杂度都是O(logN)
3. 遍历二叉树的方法包括前序、中序、后序
4. 非平衡树指的是根的左右两边的子节点的数量不一致
5. 在非空二叉树中，第i层的结点总数不超过 , i>=1；
6. 深度为h的二叉树最多有个结点(h>=1)，最少有h个结点；
7. 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；
   1. 1. 二叉树的Scala代码实现

定义节点以及前序、中序、后序遍历

class TreeNode(treeNo:Int){
 
  val no = treeNo
 
  var left:TreeNode = null
 
  var right:TreeNode = null
 
  
 
  //后序遍历
 
  def postOrder():Unit={
 
    //向左递归输出左子树
 
    if(this.left != null){
 
      this.left.postOrder
 
    }
 
    //向右递归输出右子树
 
    if (this.right != null) {
 
      this.right.postOrder
 
    }
 
  
 
    //输出当前节点值
 
    printf("节点信息 no=%d \n",no)
 
  }
 
  
 
  //中序遍历
 
  def infixOrder():Unit={
 
    //向左递归输出左子树
 
    if(this.left != null){
 
      this.left.infixOrder()
 
    }
 
  
 
    //输出当前节点值
 
    printf("节点信息 no=%d \n",no)
 
  
 
    //向右递归输出右子树
 
    if (this.right != null) {
 
      this.right.infixOrder()
 
    }
 
  }
 
  
 
  //前序遍历
 
  def preOrder():Unit={
 
    //输出当前节点值
 
    printf("节点信息 no=%d \n",no)
 
  
 
    //向左递归输出左子树
 
    if(this.left != null){
 
      this.left.postOrder()
 
    }
 
  
 
    //向右递归输出右子树
 
    if (this.right != null) {
 
      this.right.preOrder()
 
    }
 
  }
 
  
 
  //后序遍历查找
 
  def postOrderSearch(no:Int): TreeNode = {
 
    //向左递归输出左子树
 
    var resNode:TreeNode = null
 
    if (this.left != null) {
 
      resNode = this.left.postOrderSearch(no)
 
    }
 
    if (resNode != null) {
 
      return resNode
 
    }
 
    if (this.right != null) {
 
      resNode = this.right.postOrderSearch(no)
 
    }
 
    if (resNode != null) {
 
      return resNode
 
    }
 
    println("ttt~~")
 
    if (this.no == no) {
 
      return this
 
    }
 
    resNode
 
  }
 
  
 
  //中序遍历查找
 
  def infixOrderSearch(no:Int): TreeNode = {
 
  
 
    var resNode : TreeNode = null
 
    //先向左递归查找
 
    if (this.left != null) {
 
      resNode = this.left.infixOrderSearch(no)
 
    }
 
    if (resNode != null) {
 
      return resNode
 
    }
 
    println("yyy~~")
 
    if (no == this.no) {
 
      return this
 
    }
 
    //向右递归查找
 
    if (this.right != null) {
 
      resNode = this.right.infixOrderSearch(no)
 
    }
 
    return resNode
 
  
 
  }
 
  
 
  //前序查找
 
  def preOrderSearch(no:Int): TreeNode = {
 
    if (no == this.no) {
 
      return this
 
    }
 
    //向左递归查找
 
    var resNode : TreeNode = null
 
    if (this.left != null) {
 
      resNode = this.left.preOrderSearch(no)
 
    }
 
    if (resNode != null){
 
      return  resNode
 
    }
 
    //向右边递归查找
 
    if (this.right != null) {
 
      resNode = this.right.preOrderSearch(no)
 
    }
 
  
 
    return resNode
 
  }
 
  
 
  //删除节点
 
  //删除节点规则
 
  //1如果删除的节点是叶子节点，则删除该节点
 
  //2如果删除的节点是非叶子节点，则删除该子树
 
  
 
  def delNode(no:Int): Unit = {
 
    //首先比较当前节点的左子节点是否为要删除的节点
 
    if (this.left != null && this.left.no == no) {
 
      this.left = null
 
      return
 
    }
 
    //比较当前节点的右子节点是否为要删除的节点
 
    if (this.right != null && this.right.no == no) {
 
      this.right = null
 
      return
 
    }
 
    //向左递归删除
 
    if (this.left != null) {
 
      this.left.delNode(no)
 
    }
 
    //向右递归删除
 
    if (this.right != null) {
 
      this.right.delNode(no)
 
    }
 
  }
 
}

定义二叉树，前序、中序、后序遍历，前序、中序、后序查找，删除节点

class BinaryTree {
 
  var root: TreeNode = null
 
  
 
  //后序遍历
 
  def postOrder(): Unit = {
 
    if (root != null) {
 
      root.postOrder()
 
    } else {
 
      println("当前二叉树为空，不能遍历")
 
    }
 
  }
 
  
 
  //中序遍历
 
  def infixOrder(): Unit = {
 
    if (root != null) {
 
      root.infixOrder()
 
    } else {
 
      println("当前二叉树为空，不能遍历")
 
    }
 
  }
 
  
 
  //前序遍历
 
  def preOrder(): Unit = {
 
    if (root != null) {
 
      root.preOrder()
 
    } else {
 
      println("当前二叉树为空，不能遍历")
 
    }
 
  }
 
  
 
  //后序遍历查找
 
  def postOrderSearch(no: Int): TreeNode = {
 
    if (root != null) {
 
      root.postOrderSearch(no)
 
    } else {
 
      null
 
    }
 
  }
 
  
 
  //中序遍历查找
 
  def infixOrderSeacher(no: Int): TreeNode = {
 
    if (root != null) {
 
      return root.infixOrderSearch(no)
 
    } else {
 
      return null
 
    }
 
  }
 
  
 
  //前序查找
 
  def preOrderSearch(no: Int): TreeNode = {
 
  
 
    if (root != null) {
 
      return root.preOrderSearch(no)
 
    } else {
 
      //println("当前二叉树为空，不能查找")
 
      return null
 
    }
 
  }
 
  
 
  //删除节点
 
  def delNode(no: Int): Unit = {
 
    if (root != null) {
 
      //先处理一下root是不是要删除的
 
      if (root.no == no) {
 
        root = null
 
      } else {
 
        root.delNode(no)
 
      }
 
    }
 
  
 
  }
 
}

1. 1. 手写Spark-WordCount

val conf: SparkConf =
 
  new SparkConf().setMaster("local[*]").setAppName("WordCount")
 
  
 
  val sc = new SparkContext(conf)
 
  
 
  sc.textFile("/input")
 
  .flatMap(_.split(" "))
 
  .map((_, 1))
 
  .reduceByKey(_ + _)
 
  .saveAsTextFile("/output")
 
  
 
  sc.stop()

1. 项目架构
   1. 数仓概念

数据仓库的输入数据源和输出系统分别是什么？

输入系统：埋点产生的用户行为数据、JavaEE后台产生的业务数据。

输出系统：报表系统、用户画像系统、推荐系统

1. 1. 系统数据流程设计

1. 1. 框架版本选型
2. Apache：运维麻烦，组件间兼容性需要自己调研。（一般大厂使用，技术实力雄厚，有专业的运维人员）
3. CDH：国内使用最多的版本，但 CM不开源，但其实对中、小公司使用来说没有影响（建议使用）
4. HDP：开源，可以进行二次开发，但是没有CDH稳定，国内使用较少
   1. 服务器选型

服务器使用物理机还是云主机？

1. 机器成本考虑：
   1. 物理机：以128G内存，20核物理CPU，40线程，8THDD和2TSSD硬盘，单台报价4W出头，需考虑托管服务器费用。一般物理机寿命5年左右
   2. 云主机，以阿里云为例，差不多相同配置，每年5W
2. 运维成本考虑：
   1. 物理机：需要有专业的运维人员
   2. 云主机：很多运维工作都由阿里云已经完成，运维相对较轻松

1. 1. 集群规模

1. 1. 人员配置参考
      1. 整体架构

属于研发部，技术总监下面有各个项目组，我们属于数据组，其他还有后端项目组，基础平台等。总监上面就是副总等级别了。其他的还有产品运营部等。

1. 1. 1. 你们部门的职级等级，晋升规则

职级就分初级，中级，高级。晋升规则不一定，看公司效益和职位空缺。

1. 1. 1. 人员配置参考

小型公司（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个人左右，因此根据所选公司规模确定一个合理范围，在面试前必须将这个人员配置考虑清楚，回答时要非常确定。

1. 项目涉及技术
   1. Linux&Shell相关总结
      1. Linux常用命令

1. 1. 1. Shell常用工具

awk、sed、cut、sort

1. 1. Hadoop相关总结
      1. Hadoop常用端口号

Hadoop 2.x 版本：

• dfs.namenode.http-address:50070
• dfs.datanode.http-address:50075
• SecondaryNameNode辅助名称节点端口号：50090
• dfs.datanode.address:50010
• fs.defaultFS:8020 或者9000
• yarn.resourcemanager.webapp.address:8088
• 历史服务器web访问端口：19888

Hadoop 3.x版本：(仅列出相对于2.x版本有更改的端口，箭头前为2.x，箭头后为3.x)

NameNode 的端口:

50070 --> 9870

8020 --> 9820,

50470 --> 9871

Secondary NameNode的端口:

50091 --> 9869

50090 --> 9868

DataNode 的端口:

 50020 --> 9867

 50010 --> 9866

 50475 --> 9865

50075 --> 9864

Hadoop KMS 的端口:

16000 --> 9600

1. 1. 1. Hadoop配置文件以及简单的Hadoop集群搭建
2. 配置文件：

core-site.xml、hdfs-site.xml、mapred-site.xml、yarn-site.xml

hadoop-env.sh、yarn-env.sh、mapred-env.sh、slaves

1. 简单的集群搭建过程：

JDK安装

配置SSH免密登录

配置hadoop核心文件: 

格式化namenode

1. 1. 1. HDFS读流程和写流程

HDFS读数据：

HDFS写数据：

1. 1. 1. MapReduce的Shuffle过程及Hadoop优化（包括：压缩、小文件、集群优化）

MapReduce的详细工作流程：

一、Shuffle机制

1. Map方法之后Reduce方法之前这段处理过程叫Shuffle
2. Map方法之后，数据首先进入到分区方法，把数据标记好分区，然后把数据发送到环形缓冲区；环形缓冲区默认大小100m，环形缓冲区达到80%时，进行溢写；溢写前对数据进行排序，排序按照对key的索引进行字典顺序排序，排序的手段快排；溢写产生大量溢写文件，需要对溢写文件进行归并排序；对溢写的文件也可以进行Combiner操作，前提是汇总操作，求平均值不行。最后将文件按照分区存储到磁盘，等待Reduce端拉取。
3. 每个Reduce拉取Map端对应分区的数据。拉取数据后先存储到内存中，内存不够了，再存储到磁盘。拉取完所有数据后，采用归并排序将内存和磁盘中的数据都进行排序。在进入Reduce方法前，可以对数据进行分组操作。

二、Hadoop优化

1. HDFS小文件影响
   1. 影响NameNode的寿命，因为文件元数据存储在NameNode的内存中
   2. 影响计算引擎的任务数量，比如每个小的文件都会生成一个Map任务
2. 数据输入小文件处理：
   1. 合并小文件：对小文件进行归档（Har）、自定义Inputformat将小文件存储成SequenceFile文件。
   2. 采用ConbinFileInputFormat来作为输入，解决输入端大量小文件场景。
   3. 对于大量小文件Job，可以开启JVM重用。
3. Map阶段
   1. 增大环形缓冲区大小。由100m扩大到200m
   2. 增大环形缓冲区溢写的比例。由80%扩大到90%
   3. 减少对溢写文件的merge次数。
   4. 不影响实际业务的前提下，采用Combiner提前合并，减少 I/O。
4. Reduce阶段
   1. 合理设置Map和Reduce数：两个都不能设置太少，也不能设置太多。太少，会导致Task等待，延长处理时间；太多，会导致 Map、Reduce任务间竞争资源，造成处理超时等错误。
   2. 设置Map、Reduce共存：调整slowstart.completedmaps参数，使Map运行到一定程度后，Reduce也开始运行，减少Reduce的等待时间。
   3. 规避使用Reduce，因为Reduce在用于连接数据集的时候将会产生大量的网络消耗。
   4. 增加每个Reduce去Map中拿数据的并行数
   5. 集群性能可以的前提下，增大Reduce端存储数据内存的大小。
5. IO传输
   1. 采用数据压缩的方式，减少网络IO的的时间。安装Snappy和LZOP压缩编码器。
   2. 使用SequenceFile二进制文件
6. 整体
   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最大重试次数

三、压缩

提示：如果面试过程问起，我们一般回答压缩方式为Snappy，特点速度快，缺点无法切分（可以回答在链式MR中，Reduce端输出使用bzip2压缩，以便后续的map任务对数据进行split）

四、切片机制

1. 简单地按照文件的内容长度进行切片
2. 切片大小，默认等于Block大小
3. 切片时不考虑数据集整体，而是逐个针对每一个文件单独切片

提示：切片大小公式：max(0,min(Long_max,blockSize))

1. 1. 1. Yarn的Job提交流程

1. 1. 1. Yarn的默认调度器、调度器分类、以及他们之间的区别
2. Hadoop调度器重要分为三类：

FIFO（先进先出调度器）、Capacity Scheduler（容量调度器）和Fair Sceduler（公平调度器）。

Hadoop2.7.2默认的资源调度器是 容量调度器

1. 区别：

FIFO调度器：先进先出，同一时间队列中只有一个任务在执行。

容量调度器：多队列；每个队列内部先进先出，同一时间队列中只有一个任务在执行。队列的并行度为队列的个数。

公平调度器：多队列；每个队列内部按照缺额大小分配资源启动任务，同一时间队列中有多个任务执行。队列的并行度大于等于队列的个数。

1. 一定要强调生产环境中不是使用的FifoScheduler，面试的时侯会发现候选人大概了解这几种调度器的区别，但是问在生产环境用哪种，却说使用的FifoScheduler（企业生产环境一定不会用这个调度的）

1. 1. 1. 项目经验之LZO压缩

启用lzo的压缩方式对于小规模集群是很有用处，压缩比率大概能降到原始日志大小的1/3。同时解压缩的速度也比较快。

Hadoop默认不支持LZO压缩，如果需要支持LZO压缩，需要添加jar包，并在hadoop的cores-site.xml文件中添加相关压缩配置。

1. 环境准备

maven（下载安装，配置环境变量，修改sitting.xml加阿里云镜像）
    gcc-c++
    zlib-devel
    autoconf
    automake
    libtool
    通过yum安装即可

yum -y install gcc-c++ lzo-devel zlib-devel autoconf automake libtool

1. 下载、安装并编译LZO

wget http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz

tar -zxvf lzo-2.10.tar.gz

cd lzo-2.10

./configure -prefix=/usr/local/hadoop/lzo/

make

make install

1. 编译hadoop-lzo源码
   1. 下载hadoop-lzo的源码

下载地址：https://github.com/twitter/hadoop-lzo/archive/master.zip

1. 1. 解压之后，修改pom.xml

<hadoop.current.version>2.7.2</hadoop.current.version>

1. 1. 声明两个临时环境变量

 export C_INCLUDE_PATH=/usr/local/hadoop/lzo/include

 export LIBRARY_PATH=/usr/local/hadoop/lzo/lib

1. 1. 进入hadoop-lzo-master，执行maven编译命令

mvn package -Dmaven.test.skip=true

1. 1. 进入target，将hadoop-lzo-0.4.21-SNAPSHOT.jar放到hadoop的classpath下

如${HADOOP_HOME}/share/hadoop/common

1. 1. 修改core-site.xml增加配置支持LZO压缩

<configuration>

        <property>

            <name>io.compression.codecs</name>

            <value>

            org.apache.hadoop.io.compress.GzipCodec,

            org.apache.hadoop.io.compress.DefaultCodec,

            org.apache.hadoop.io.compress.BZip2Codec,

            org.apache.hadoop.io.compress.SnappyCodec,

            com.hadoop.compression.lzo.LzoCodec,

            com.hadoop.compression.lzo.LzopCodec

            </value>

        </property>

        <property>

            <name>io.compression.codec.lzo.class</name>

            <value>com.hadoop.compression.lzo.LzoCodec</value>

        </property>

</configuration>

注意：

LZO本身是不支持分片的，但是我们给LZO压缩的文件加上索引，就支持分片了

1. 1. 1. Hadoop参数调优
2. 在hdfs-site.xml文件中配置多目录，最好提前配置好，否则更改目录需要重新启动集群
3. NameNode有一个工作线程池，用来处理不同DataNode的并发心跳以及客户端并发的元数据操作。

dfs.namenode.handler.count=20 * log2(Cluster Size)，比如集群规模为10台时，此参数设置为60

1. 编辑日志存储路径dfs.namenode.edits.dir设置与镜像文件存储路径dfs.namenode.name.dir尽量分开，达到最低写入延迟
2. 服务器节点上YARN可使用的物理内存总量，默认是8192（MB），注意，如果你的节点内存资源不够8GB，则需要调减小这个值，而YARN不会智能的探测节点的物理内存总量。yarn.nodemanager.resource.memory-mb
3. 单个任务可申请的最多物理内存量，默认是8192（MB）。yarn.scheduler.maximum-allocation-mb
   1. 1. 项目经验之基准测试

Hadoop 带有一些基准测试程序，可以最少的准备成本轻松运行。基准测试被打包在测试程序JAR文件中，通过无参调用JAR文件可以得到其列表

1. 查看信息：

[root@node1 hadoop-2.6.0-cdh5.14.0]# bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.6.0-cdh5.14.0-tests.jar

1. 写入速度测试

测试写入10个10M文件

[root@node1 hadoop-2.6.0-cdh5.14.0]# bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.6.0-cdh5.14.0-tests.jar TestDFSIO -write -nrFiles 10 -fileSize 10MB

1. 测试读文件速度

[root@node1 hadoop-2.6.0-cdh5.14.0]# bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.6.0-cdh5.14.0-tests.jar TestDFSIO -read -nrFiles 10 -fileSize 10MB

1. 命令查看

[root@node1 hadoop-2.6.0-cdh5.14.0]# cat TestDFSIO_results.log

----- TestDFSIO ----- : write

           Date & time: Fri Nov 08 10:43:20 CST 2019

       Number of files: 10

Total MBytes processed: 100.0

     Throughput mb/sec: 4.551039912620034

Average IO rate mb/sec: 5.2242536544799805

 IO rate std deviation: 2.1074511594328245

    Test exec time sec: 52.394

----- TestDFSIO ----- : read

           Date & time: Fri Nov 08 10:45:28 CST 2019

       Number of files: 10

Total MBytes processed: 100.0

     Throughput mb/sec: 73.85524372230428

Average IO rate mb/sec: 135.5804901123047

 IO rate std deviation: 111.20953898062095

    Test exec time sec: 28.231

1. 1. 1. Hadoop宕机
2. 如果MR造成系统宕机。此时要控制Yarn同时运行的任务数，和每个任务申请的最大内存。调整参数：yarn.scheduler.maximum-allocation-mb（单个任务可申请的最多物理内存量，默认是8192MB）
3. 如果写入文件过量造成NameNode宕机。那么调高Kafka的存储大小，控制从Kafka到HDFS的写入速度。高峰期的时候用Kafka进行缓存，高峰期过去数据同步会自动跟上。
   1. Zookeeper相关总结
      1. 选举机制

半数机制

三个核心选举原则：

1. Zookeeper集群中只有超过半数以上的服务器启动，集群才能正常工作；
2. 在集群正常工作之前，myid小的服务器给myid大的服务器投票，直到集群正常工作，选出Leader；
3. 选出Leader之后，之前的服务器状态由Looking改变为Following，以后的服务器都是Follower

比如：

集群半数以上存活，集群可用

假设有五台服务器组成的zookeeper集群，它们的id从1-5，同时它们都是最新启动的

1. 1启动，选自己
2. 2启动，选自己（比1大，12选2）
3. 3启动，选自己（123都选3，超过半数）当选leader
4. 4启动，已有leader3
5. 5启动，已有leader3
   1. 1. 常用命令

ls、get、create

1. 1. Flume相关总结
      1. Flume组成，Put事务，Take事务
2. flume组成，Put事务，Take事务

Taildir Source：断点续传、多目录。Flume1.6以前需要自己自定义Source记录每次读取文件位置，实现断点续传。

File Channel：数据存储在磁盘，宕机数据可以保存。但是传输速率慢。适合对数据传输可靠性要求高的场景，比如，金融行业。

Memory Channel：数据存储在内存中，宕机数据丢失。传输速率快。适合对数据传输可靠性要求不高的场景，比如，普通的日志数据。

Kafka Channel：减少了Flume的Sink阶段，提高了传输效率。          

Source到Channel是Put事务

Channel到Sink是Take事务

1. 1. 1. Flume拦截器
2. 拦截器注意事项

项目中自定义了：ETL拦截器和区分类型拦截器。

采用两个拦截器的优缺点：优点，模块化开发和可移植性；缺点，性能会低一些

1. 自定义拦截器步骤
   1. 实现 Interceptor
   2. 重写四个方法

1. 1. initialize 初始化
   2. public Event intercept(Event event) 处理单个Event
   3. public List<Event> intercept(List<Event> events) 处理多个Event，在这个方法中调用Event intercept(Event event)
   4. close 方法

1. 1. 静态内部类，实现Interceptor.Builder
      1. Flume Channel选择器

1. 1. 1. Flume监控器

Ganglia监控

加州伯克利大学千禧计划的其中一个开源项目.是一个集群汇总监控用的的软件，和Cacti不同，cacti是详细监控集群中每台服务器的运行状态，而Ganglia是将集群中的服务器数据进行汇总然后监控。有时通过cacti或者zabbix（监控软件）看不出来的集群总体负载问题，却能够在Ganglia中体现。被监控的主机(即client)安装ganglia-gmond并启动该进程。服务器端需要安装gmetad和web程序。大致大构图如下：

    参考链接：https://www.cnblogs.com/yinzhengjie/p/9798739.html

1. 1. 1. Flume采集数据会丢失吗?（防止数据丢失的机制）

不会，Channel存储可以存储在File中，数据传输自身有事务。

1. 1. 1. Flume内存

开发中在flume-env.sh中设置JVM heap为4G或更高，部署在单独的服务器上（4核8线程16G内存）

-Xmx（设定程序运行期间最大可占用的内存大小）与-Xms（设定程序启动时占用内存大小）最好设置一致，减少内存抖动带来的性能影响，如果设置不一致容易导致频繁fullgc。

1. 1. 1. FileChannel优化

通过配置dataDirs指向多个路径，每个路径对应不同的硬盘，增大Flume吞吐量。

官方说明如下：

Comma separated list of directories for storing log files. Using multiple directories on separate disks can improve file channel peformance

checkpointDir和backupCheckpointDir也尽量配置在不同硬盘对应的目录中，保证checkpoint坏掉后，可以快速使用backupCheckpointDir恢复数据

1. 1. 1. HDFS Sink小文件处理
2. HDFS存入大量小文件，有什么影响？

元数据层面：每个小文件都有一份元数据，其中包括文件路径，文件名，所有者，所属组，权限，创建时间等，这些信息都保存在Namenode内存中。所以小文件过多，会占用Namenode服务器大量内存，影响Namenode性能和使用寿命

计算层面：默认情况下MR会对每个小文件启用一个Map任务计算，非常影响计算性能。同时也影响磁盘寻址时间。

1. HDFS小文件处理

官方默认的这三个参数配置写入HDFS后会产生小文件，hdfs.rollInterval、hdfs.rollSize、hdfs.rollCount

基于以上hdfs.rollInterval=3600，hdfs.rollSize=134217728，hdfs.rollCount =0，hdfs.roundValue=10，hdfs.roundUnit= second几个参数综合作用，效果如下：

（1）tmp文件在达到128M时会滚动生成正式文件

（2）tmp文件创建超10分时会滚动生成正式文件

举例：在2018-01-01 05:23的时侯sink接收到数据，那会产生如下tmp文件：

/itcast/20180101/itcast.201801010520.tmp

即使文件内容没有达到128M，也会在05:33时滚动生成正式文件

1. 1. Kafka相关总结
      1. Kafka架构

1. 1. 1. Kafka压测

Kafka官方自带压力测试脚本（kafka-consumer-perf-test.sh、kafka-producer-perf-test.sh）。Kafka压测时，可以查看到哪个地方出现了瓶颈（CPU，内存，网络IO）。一般都是网络IO达到瓶颈。

1. 1. 1. Kafka的机器数量

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

1. 1. 1. Kafka的日志保存时间

7天

1. 1. 1. Kafka的硬盘大小

每天的数据量*7天

1. 1. 1. Kafka监控

公司自己开发的监控器；

开源的监控器：KafkaManager、KafkaMonitor

1. 1. 1. Kakfa分区数

分区数并不是越多越好，一般分区数不要超过集群机器数量。分区数越多占用内存越大（ISR等），一个节点集中的分区也就越多，当它宕机的时候，对系统的影响也就越大。

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

1. 1. 1. 副本数设定

一般我们设置成2个或3个，很多企业设置为2个。

1. 1. 1. 多少个Topic

通常情况：多少个日志类型就多少个Topic。也有对日志类型进行合并的。

1. 1. 1. Kafka丢不丢数据

Ack=0，相当于异步发送，消息发送完毕即offset增加，继续生产。

Ack=1，leader收到leader replica 对一个消息的接受ack才增加offset，然后继续生产。

Ack=-1，leader收到所有replica 对一个消息的接受ack才增加offset，然后继续生产。

1. 1. 1. Kafka的ISR副本同步队列

ISR（In-Sync Replicas），副本同步队列。ISR中包括Leader和Follower。如果Leader进程挂掉，会在ISR队列中选择一个服务作为新的Leader。有replica.lag.max.messages（延迟条数）和replica.lag.time.max.ms（延迟时间）两个参数决定一台服务是否可以加入ISR副本队列，在0.10版本移除了replica.lag.max.messages参数，防止服务频繁的进去队列。

任意一个维度超过阈值都会把Follower剔除出ISR，存入OSR（Outof-Sync Replicas）列表，新加入的Follower也会先存放在OSR中。

1. 1. 1. Kafka中数据量计算

每天总数据量100g，每天产生1亿条日志， 10000万/24/60/60=1150条/每秒钟

平均每秒钟：1150条

低谷每秒钟：400条

高峰每秒钟：1150条*（2-20倍）=2300条->23000条

每条日志大小：0.5k-2k

每秒多少数据量：2.3M-20MB

1. 1. 1. Kafka挂掉
2. Flume记录
3. 日志有记录
4. 短期没事
   1. 1. Kafka消息数据积压，Kafka消费能力不足怎么处理？

1. 如果是Kafka消费能力不足，则可以考虑增加Topic的分区数，并且同时提升消费组的消费者数量，消费者数=分区数。（两者缺一不可）
2. 如果是下游的数据处理不及时：提高每批次拉取的数量。批次拉取数据过少（拉取数据/处理时间<生产速度），使处理的数据小于生产的数据，也会造成数据积压。
   1. 1. Kafka的再平衡机制
         1. 什么是再平衡

所谓的再平衡，指的是在kafka consumer所订阅的topic发生变化时发生的一种分区重分配机制。一般有三种情况会触发再平衡：

1. consumer group中的新增或删除某个consumer，导致其所消费的分区需要分配到组内其他的consumer上；
2. consumer订阅的topic发生变化，比如订阅的topic采用的是正则表达式的形式，如test-*此时如果有一个新建了一个topic test-user，那么这个topic的所有分区也是会自动分配给当前的consumer的，此时就会发生再平衡；
3. consumer所订阅的topic发生了新增分区的行为，那么新增的分区就会分配给当前的consumer，此时就会触发再平衡。

Kafka提供的再平衡策略主要有三种：Round Robin，Range和Sticky，默认使用Range。这三种分配策略的主要区别在于：

1. Round Robin：会采用轮询的方式将当前所有的分区依次分配给所有的consumer；
2. Range：首先会计算每个consumer可以消费的分区个数，然后按照顺序将指定个数范围的分区分配给各个consumer；
3. Sticky：这种分区策略是最新版本中新增的一种策略，其主要实现了两个目的：
   1. 将现有的分区尽可能均衡的分配给各个consumer，存在此目的的原因在于Round Robin和Range分配策略实际上都会导致某几个consumer承载过多的分区，从而导致消费压力不均衡；
   2. 如果发生再平衡，那么在重新分配前的基础上会尽力保证当前未宕机的consumer所消费的分区不会被分配给其他的consumer上；

本文主要会通过几个示例来对上面讲解的三种分区重分配策略的基本实现原理进行讲解。

1. 1. 1. 1. Round Robin

关于Round Robin重分配策略，其主要采用的是一种轮询的方式分配所有的分区，该策略主要实现的步骤如下。这里我们首先假设有三个topic：t0、t1和t2，这三个topic拥有的分区数分别为1、2和3，那么总共有六个分区，这六个分区分别为：t0-0、t1-0、t1-1、t2-0、t2-1和t2-2。这里假设我们有三个consumer：C0、C1和C2，它们订阅情况为：C0订阅t0，C1订阅t0和t1，C2订阅t0、t1和t2。那么这些分区的分配步骤如下：

1. 首先将所有的partition和consumer按照字典序进行排序，所谓的字典序，就是按照其名称的字符串顺序，那么上面的六个分区和三个consumer排序之后分别为：

1. 然后依次以按顺序轮询的方式将这六个分区分配给三个consumer，如果当前consumer没有订阅当前分区所在的topic，则轮询的判断下一个consumer：

1. 尝试将t0-0分配给C0，由于C0订阅了t0，因而可以分配成功；
2. 尝试将t1-0分配给C1，由于C1订阅了t1，因而可以分配成功；
3. 尝试将t1-1分配给C2，由于C2订阅了t1，因而可以分配成功；
4. 尝试将t2-0分配给C0，由于C0没有订阅t2，因而会轮询下一个consumer；
5. 尝试将t2-0分配给C1，由于C1没有订阅t2，因而会轮询下一个consumer；
6. 尝试将t2-0分配给C2，由于C2订阅了t2，因而可以分配成功；
7. 同理由于t2-1和t2-2所在的topic都没有被C0和C1所订阅，因而都不会分配成功，最终都会分配给C2。

按照上述的步骤将所有的分区都分配完毕之后，最终分区的订阅情况如下：

从上面的步骤分析可以看出，轮询的策略就是简单的将所有的partition和consumer按照字典序进行排序之后，然后依次将partition分配给各个consumer，如果当前的consumer没有订阅当前的partition，那么就会轮询下一个consumer，直至最终将所有的分区都分配完毕。但是从上面的分配结果可以看出，轮询的方式会导致每个consumer所承载的分区数量不一致，从而导致各个consumer压力不均一。

1. 1. 1. 1. Range（默认策略）

所谓的Range重分配策略，就是首先会计算各个consumer将会承载的分区数量，然后将指定数量的分区分配给该consumer。这里我们假设有两个consumer：C0和C1，两个topic：t0和t1，这两个topic分别都有三个分区，那么总共的分区有六个：t0-0、t0-1、t0-2、t1-0、t1-1和t1-2。那么Range分配策略将会按照如下步骤进行分区的分配：

1. 需要注意的是，Range策略是按照topic依次进行分配的，比如我们以t0进行讲解，其首先会获取t0的所有分区：t0-0、t0-1和t0-2，以及所有订阅了该topic的consumer：C0和C1，并且会将这些分区和consumer按照字典序进行排序；
2. 然后按照平均分配的方式计算每个consumer会得到多少个分区，如果没有除尽，则会将多出来的分区依次计算到前面几个consumer。比如这里是三个分区和两个consumer，那么每个consumer至少会得到1个分区，而3除以2后还余1，那么就会将多余的部分依次算到前面几个consumer，也就是这里的1会分配给第一个consumer，总结来说，那么C0将会从第0个分区开始，分配2个分区，而C1将会从第2个分区开始，分配1个分区；
3. 同理，按照上面的步骤依次进行后面的topic的分配。

最终上面六个分区的分配情况如下：

可以看到，如果按照Range分区方式进行分配，其本质上是依次遍历每个topic，然后将这些topic的分区按照其所订阅的consumer数量进行平均的范围分配。这种方式从计算原理上就会导致排序在前面的consumer分配到更多的分区，从而导致各个consumer的压力不均衡。

1. 1. 1. 1. Sticky

Sticky策略是新版本中新增的策略，顾名思义，这种策略会保证再分配时已经分配过的分区尽量保证其能够继续由当前正在消费的consumer继续消费，当然，前提是每个consumer所分配的分区数量都大致相同，这样能够保证每个consumer消费压力比较均衡。关于这种分配方式的分配策略，我们分两种情况进行讲解，即初始状态的分配和某个consumer宕机时的分配情况。

1. 1. 1. 1. 1. 初始分配

初始状态分配的特点是，所有的分区都还未分配到任意一个consumer上。这里我们假设有三个consumer：C0、C1和C2，三个topic：t0、t1和t2，这三个topic分别有1、2和3个分区，那么总共的分区为：t0-0、t1-0、t1-1、t2-0、t2-1和t2-2。关于订阅情况，这里C0订阅了t0，C1订阅了t0和1，C2则订阅了t0、t1和t2。这里的分区分配规则如下：

1. 首先将所有的分区进行排序，排序方式为：首先按照当前分区所分配的consumer数量从低到高进行排序，如果consumer数量相同，则按照分区的字典序进行排序。这里六个分区由于所在的topic的订阅情况各不相同，因而其排序结果如下：

1. 然后将所有的consumer进行排序，其排序方式为：首先按照当前consumer已经分配的分区数量有小到大排序，如果两个consumer分配的分区数量相同，则会按照其名称的字典序进行排序。由于初始时，这三个consumer都没有分配任何分区，因而其排序结果即为其按照字典序进行排序的结果：

1. 然后将各个分区依次遍历分配给各个consumer，首先需要注意的是，这里的遍历并不是C0分配完了再分配给C1，而是每次分配分区的时候都整个的对所有的consumer从头开始遍历分配，如果当前consumer没有订阅当前分区，则会遍历下一个consumer。然后需要注意的是，在整个分配的过程中，各个consumer所分配的分区数是动态变化的，而这种变化是会体现在各个consumer的排序上的，比如初始时C0是排在第一个的，此时如果分配了一个分区给C0，那么C0就会排到最后，因为其拥有的分区数是最多的。上面的六个分区整体的分配流程如下：
   1. 首先将t2-0尝试分配给C0，由于C0没有订阅t2，因而分配不成功，继续轮询下一个consumer；
   2. 然后将t2-0尝试分配给C1，由于C1没有订阅t2，因而分配不成功，继续轮询下一个consumer；
   3. 接着将t2-0尝试分配给C2，由于C2订阅了t2，因而分配成功，此时由于C2分配的分区数发生变化，各个consumer变更后的排序结果为：

1. 1. 接下来的t2-1和t2-2，由于也只有C2订阅了t2，因而其最终还是会分配给C2，最终在t2-0、t2-1和t2-2分配完之后，各个consumer的排序以及其分区分配情况如下：

1. 1. 接着继续分配t1-0，首先尝试将其分配给C0，由于C0没有订阅t1，因而分配不成功，继续轮询下一个consumer；
   2. 然后尝试将t1-0分配给C1，由于C1订阅了t1，因而分配成功，此时各个consumer以及其分配的分区情况如下：

1. 1. 同理，接下来会分配t1-1，虽然C1和C2都订阅了t1，但是由于C1排在C2前面，因而该分区会分配给C1，即：

1. 1. 最后，尝试将t0-0分配给C0，由于C0订阅了t0，因而分配成功，最终的分配结果为：

上面的分配过程中，需要始终注意的是，虽然示例中的consumer顺序始终没有变化，但这是由于各个分区分配之后正好每个consumer所分配的分区数量的排序结果与初始状态一致。这里读者也可以比较一下这种分配方式与前面讲解的Round Robin进行对比，可以很明显的发现，Sticky重分配策略分配得更加均匀一些。

1. 1. 1. 1. 1. 模拟consumer宕机

由于前一个示例中最终的分区分配方式模拟宕机的情形比较简单，因而我们使用另一种订阅策略。这里我们的示例的consumer有三个：C0、C1和C2，topic有四个：t0、t1、t2和t3，每个topic都有两个分区，那么总的分区有：t0-0、t0-1、t1-0、t1-1、t2-0、t2-1、t3-0和t3-1。这里的订阅情况为三个consumer订阅所有的主题，那么如果按照Sticky的分区分配策略，初始状态时，分配情况如下，读者可以按照前一示例讲解的方式进行推算：

这里我们假设在消费的过程中，C1发生了宕机，此时就会发生再平衡，而根据Sticky策略，其再分配步骤如下：

1. 首先会将宕机之后未分配的分区进行排序，排序方式为：首先按照分区所拥有的consumer数量从低到高进行排序，如果consumer数量相同，则按照分区的字典序进行排序。这里需要注意的是，由于只有C1宕机，因而未分配的分区为：t0-1、t2-0和t3-1，排序之后的结果为：

1. 然后将所有的consumer进行排序，排序方式为：首先将consumer按照其所拥有的consumer数量从小到大排序，如果数量相同，则按照consumer名称的字典序进行排序，排序结果如下：

1. 接着依次遍历各个分区，将其分配给各个consumer，需要注意的是，在分配的过程中，consumer所分配的分区数量是在变化的，而这种变化是会反应在consumer的排序上的：
   1. 首先尝试将t0-1分配给C2，由于C2订阅了t0，因而可以分配成功，此时consumer排序和分区分配情况如下，需要注意的是，虽然分配之后，C2和C0的分区数量相同，但是由于按照字典序，C0在C2前面，因而排序情况还是会发生变化：

1. 1. 然后尝试将t2-0分配给C0，由于C0订阅了t2，因而分配可以成功，此时consumer排序和分区分配情况如下：

1. 1. 最后尝试分配t3-1给C2，由于C2订阅了t3，因而分配可以成功，此时consumer排序与分区分配情况如下：

在上面的分区分配过程中，我们可以看到，由于分区的不断分配，各个consumer所拥有的分区数量也在不断变化，因而其排序情况也在变化，但是最终可以看到，各个分区是均匀的分配到各个consumer的，并且还保证了当前consumer已经消费的分区是不会分配到其他的consumer上的。

1. 1. Hive相关总结
      1. Hive的架构

1. 1. 1. Hive和数据库比较

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

1. 数据存储位置

Hive存储在HDFS。数据库将数据保存在块设备或者本地文件系统中。

1. 数据更新

Hive中不建议对数据的改写。而数据库中的数据通常是需要经常进行修改的，

1. 执行延迟

Hive执行延迟较高。数据库的执行延迟较低。当然，这个是有条件的，即数据规模较小，当数据规模大到超过数据库的处理能力的时候，Hive的并行计算显然能体现出优势。

1. 数据规模

Hive支持很大规模的数据计算；数据库可以支持的数据规模较小。

1. 1. 1. 内部表和外部表
2. 内部表：当我们删除一个内部表时，Hive也会删除这个表中数据。内部表不适合和其他工具共享数据。
3. 外部表：删除该表并不会删除掉原始数据，删除的是表的元数据
   1. 1. 4个By区别

1. Sort By：分区内有序；
2. Order By：全局排序，只有一个Reducer；
3. Distrbute By：类似MR中Partition，进行分区，结合sort by使用。
4. Cluster By：当Distribute by和Sorts by字段相同时，可以使用Cluster by方式。Cluster by除了具有Distribute by的功能外还兼具Sort by的功能。但是排序只能是升序排序，不能指定排序规则为ASC或者DESC。
   1. 1. 窗口函数

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

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

ROW_NUMBER() 会根据顺序计算

1. OVER()：指定分析函数工作的数据窗口大小，这个数据窗口大小可能会随着行的变而变化
2. CURRENT ROW：当前行
3. n PRECEDING：往前n行数据
4. n FOLLOWING：往后n行数据
5. UNBOUNDED：起点，UNBOUNDED PRECEDING 表示从前面的起点， UNBOUNDED FOLLOWING表示到后面的终点
6. LAG(col,n)：往前第n行数据
7. LEAD(col,n)：往后第n行数据
8. NTILE(n)：把有序分区中的行分发到指定数据的组中，各个组有编号，编号从1开始，对于每一行，NTILE返回此行所属的组的编号。注意：n必须为int类型。
   1. 1. 自定义UDF、UDTF

在项目中是否自定义过UDF、UDTF函数，以及用他们处理了什么问题，及自定义步骤？

1. 自定义过。
2. 用UDF函数解析公共字段；用UDTF函数解析事件字段。

自定义UDF：继承UDF，重写evaluate方法

自定义UDTF：继承自GenericUDTF，重写3个方法：initialize(自定义输出的列名和类型)，process（将结果返回forward(result)），close

为什么要自定义UDF/UDTF，因为自定义函数，可以自己埋点Log打印日志，出错或者数据异常，方便调试.

1. 1. 1. Hive优化
2. MapJoin

如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成Common Join，即：在Reduce阶段完成join。容易发生数据倾斜。可以用MapJoin把小表全部加载到内存在map端进行join，避免reducer处理。

1. 行列过滤

列处理：在SELECT中，只拿需要的列，如果有，尽量使用分区过滤，少用SELECT *。

行处理：在分区剪裁中，当使用外关联时，如果将副表的过滤条件写在Where后面，那么就会先全表关联，之后再过滤。

1. 采用分桶技术
2. 采用分区技术
3. 合理设置Map数
   1. 通常情况下，作业会通过input的目录产生一个或者多个map任务。

主要的决定因素有：input的文件总个数，input的文件大小，集群设置的文件块大小。

1. 1. 是不是map数越多越好？

答案是否定的。如果一个任务有很多小文件（远远小于块大小128m），则每个小文件也会被当做一个块，用一个map任务来完成，而一个map任务启动和初始化的时间远远大于逻辑处理的时间，就会造成很大的资源浪费。而且，同时可执行的map数是受限的。

1. 1. 是不是保证每个map处理接近128m的文件块，就高枕无忧了？

答案也是不一定。比如有一个127m的文件，正常会用一个map去完成，但这个文件只有一个或者两个小字段，却有几千万的记录，如果map处理的逻辑比较复杂，用一个map任务去做，肯定也比较耗时。

针对上面的问题2和3，我们需要采取两种方式来解决：即减少map数和增加map数；

1. 小文件进行合并

在Map执行前合并小文件，减少Map数：CombineHiveInputFormat具有对小文件进行合并的功能（系统默认的格式）。HiveInputFormat没有对小文件合并功能。

1. 合理设置Reduce数

Reduce个数并不是越多越好

1. 1. 过多的启动和初始化Reduce也会消耗时间和资源；
   2. 另外，有多少个Reduce，就会有多少个输出文件，如果生成了很多个小文件，那么如果这些小文件作为下一个任务的输入，则也会出现小文件过多的问题；

在设置Reduce个数的时候也需要考虑这两个原则：处理大数据量利用合适的Reduce数；使单个Reduce任务处理数据量大小要合适；

1. 常用参数

// 输出合并小文件

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; -- 当输出文件的平均大小小于该值时，启动一个独立的map-reduce任务进行文件merge

1. 1. HBase相关总结
      1. HBase存储结构

1. 1. 1. 读流程

1. Client先访问zookeeper，从meta表读取region的位置，然后读取meta表中的数据。meta中又存储了用户表的region信息；
2. 根据namespace、表名和rowkey在meta表中找到对应的region信息；
3. 找到这个region对应的regionserver；
4. 查找对应的region；
5. 先从MemStore找数据，如果没有，再到BlockCache里面读；
6. BlockCache还没有，再到StoreFile上读(为了读取的效率)；
7. 如果是从StoreFile里面读取的数据，不是直接返回给客户端，而是先写入BlockCache，再返回给客户端。
   1. 1. 写流程

图2  HBase写数据流程

1. Client向HregionServer发送写请求；
2. HRegionServer将数据写到HLog（write ahead log）。为了数据的持久化和恢复；
3. HRegionServer将数据写到内存（MemStore）；
4. 反馈Client写成功。
   1. 1. 数据flush过程

1. 当MemStore数据达到阈值（默认是128M，老版本是64M），将数据刷到硬盘，将内存中的数据删除，同时删除HLog中的历史数据；
2. 并将数据存储到HDFS中；
3. 在HLog中做标记点。
   1. 1. 数据合并过程

1. 当数据块达到3块，Hmaster触发合并操作，Region将数据块加载到本地，进行合并；
2. 当合并的数据超过256M，进行拆分，将拆分后的Region分配给不同的HregionServer管理；
3. 当HregionServer宕机后，将HregionServer上的hlog拆分，然后分配给不同的HregionServer加载，修改.META.；
4. 注意：HLog会同步到HDFS。
   1. 1. hbase-default.xml中相关参数

1. 1. 1. rowkey设计原则
2. rowkey长度原则（Rowkey的长度被很多开发者建议说设计在10~100个字节，不过建议是越短越好，不要超过16个字节）
3. rowkey散列原则
4. rowkey唯一原则
   1. 1. RowKey如何设计

1. 生成随机数、hash、散列值
2. 字符串反转

1. Sqoop参数

/opt/module/sqoop/bin/sqoop import \

--connect \

--username \

--password \

--target-dir \

--delete-target-dir \

--num-mappers \

--fields-terminated-by   \

--query   "$2" ' and $CONDITIONS;'

1. 1. 1. Sqoop导入导出Null存储一致性问题

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

1. 1. 1. Sqoop数据导出一致性问题

1）场景1：如Sqoop在导出到Mysql时，使用4个Map任务，过程中有2个任务失败，那此时MySQL中存储了另外两个Map任务导入的数据，此时老板正好看到了这个报表数据。而开发工程师发现任务失败后，会调试问题并最终将全部数据正确的导入MySQL，那后面老板再次看报表数据，发现本次看到的数据与之前的不一致，这在生产环境是不允许的。

官网：http://sqoop.apache.org/docs/1.4.6/SqoopUserGuide.html

Since Sqoop breaks down export process into multiple transactions, it is possible that a failed export job may result in partial data being committed to the database. This can further lead to subsequent jobs failing due to insert collisions in some cases, or lead to duplicated data in others. You can overcome this problem by specifying a staging table via the --staging-table option which acts as an auxiliary table that is used to stage exported data. The staged data is finally moved to the destination table in a single transaction.

–staging-table方式

sqoop export --connect jdbc:mysql://192.168.137.10:3306/user_behavior --username root --password 123456 --table app_cource_study_report --columns watch_video_cnt,complete_video_cnt,dt --fields-terminated-by "\t" --export-dir "/user/hive/warehouse/tmp.db/app_cource_study_analysis_${day}" --staging-table app_cource_study_report_tmp --clear-staging-table --input-null-string '\N'

2）场景2：设置map数量为1个（不推荐，面试官想要的答案不只这个）

多个Map任务时，采用–staging-table方式，仍然可以解决数据一致性问题。

1. 1. 1. Sqoop底层运行的任务是什么

只有Map阶段，没有Reduce阶段的任务。

1. 1. 1. Sqoop数据导出的时候一次执行多长时间

Sqoop任务5分钟-2个小时的都有。取决于数据量。

1. Scala相关总结
   1. 1. 元组

1. 元组的创建

val tuple1 = (1, 2, 3, "heiheihei")

println(tuple1)

1. 元组数据的访问，注意元组元素的访问有下划线，并且访问下标从1开始，而不是0

val value1 = tuple1._4

println(value1)

1. 元组的遍历

方式1：

for (elem <- tuple1.productIterator  ) {

   print(elem)

}

println()

方式2：

tuple1.productIterator.foreach(i => println(i))

tuple1.produIterator.foreach(print(_))

1. 1. 1. 隐式转换

隐式转换函数是以implicit关键字声明的带有单个参数的函数。这种函数将会自动应用，将值从一种类型转换为另一种类型。

implicit def a(d: Double) = d.toInt

//不加上边这句你试试

val i1: Int = 3.5

println(i1)

1. 1. 1. 函数式编程理解

1）Scala中函数的地位：一等公民 
2） Scala中的匿名函数(函数字面量) 
3）Scala中的高阶函数 
4）Scala中的闭包 
5）Scala中的部分应用函数 
6）Scala中的柯里化函数

1. 1. 1. 样例类

case class Person(name:String,age:Int)

一般使用在 ds=df.as[Person]

1. 1. 1. 柯里化

函数编程中，接受多个参数的函数都可以转化为接受单个参数的函数，这个转化过程就叫柯里化，柯里化就是证明了函数只需要一个参数而已。其实我们刚的学习过程中，已经涉及到了柯里化操作，所以这也印证了，柯里化就是以函数为主体这种思想发展的必然产生的结果。

1）柯里化的示例

def mul(x: Int, y: Int) = x * y

println(mul(10, 10))

def mulCurry(x: Int) = (y: Int) => x * y

println(mulCurry(10)(9))

def mulCurry2(x: Int)(y:Int) = x * y

println(mulCurry2(10)(8))

2）柯里化的应用

比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务：

• 全部转大写（或小写）
• 比较是否相等

针对这两个操作，我们用一个函数去处理的思想，其实无意间也变成了两个函数处理的思想。示例如下：

val a = Array("Hello", "World")

val b = Array("hello", "world")

println(a.corresponds(b)(_.equalsIgnoreCase(_)))

其中corresponds函数的源码如下：

def corresponds[B](that: GenSeq[B])(p: (A,B) => Boolean): Boolean = {

val i = this.iterator

val j = that.iterator

while (i.hasNext && j.hasNex  t)

  if (!p(i.next(), j.next()    ))

    return fals

!i.hasNext && !j.hasNext

}

尖叫提示：不要设立柯里化存在义这样的命题，柯里化，是面向函数思想的必然产生结果。 

1. 1. 1. 闭包

一个函数把外部的那些不属于自己的对象也包含(闭合)进来。

案例1：

def minusxy(x: Int) = (y: Int) => x - y

这就是一个闭包：

1) 匿名函数(y: Int) => x -y嵌套在minusxy函数中。

2) 匿名函数(y: Int) => x -y使用了该匿名函数之外的变量x

3) 函数minusxy返回了引用了局部变量的匿名函数

案例2

def minusxy(x: Int) = (y: Int) => x - y

val f1 = minusxy(10)

val f2 = minusxy(10)

println(f1(3) + f2(3))

此处f1,f2这两个函数就叫闭包。

1. 1. 1. Some、None、Option的正确使用

val map = Map("Tom"-> 23)

map("Jack") // 抛出异常 java.util.NoSuchElementException: key not found: Jack

map.get("Jack") // None

map("Tom") // 23

map.get("Tom") // Some(23)

使用模式匹配取出最后结果

val optionAge = map.get("Tom")

val age = optionAge match {

 case Some(x) => optionAge.get

 case None => 0

}

1.  Spark相关总结
   1. 1. Spark有几种部署方式？请分别简要论述

1. Local:运行在一台机器上，通常是练手或者测试环境。
2. Standalone:构建一个基于Master+Slaves的资源调度集群，Spark任务提交给Master运行。是Spark自身的一个调度系统。
3. Yarn: Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。
4. Mesos：国内大环境比较少用。
   1. 1. Spark任务使用什么进行提交，javaEE界面还是脚本