BigDATA面試題

Big Data 面試題總結

JAVA相關

1-1）List 與set 的區別？

老掉牙的問題了，還在這裏老生常談：List特色：元素有放入順序，元素可重複 ，Set特色：元素無放入順序，元素不可重複。

 

1-2）數據庫的三大範式？

原子性、一致性、惟一性

 

1-3）java 的io類的圖解

 

1-4）對象與引用對象的區別

對象就是好沒有初始化的對象，引用對象即便對這個對象進行了初始化，這個初始化可使本身的直接new的也能夠是直接其餘的賦值的，那麼背new或者背其餘賦值的咱們叫作是引用對象，最大的區別於

 

1-5）談談你對反射機制的理解及其用途？

反射有三種獲取的方式，分別是：forName  / getClass / 直接使用class方式 使用反射能夠獲取類的實例

1-6）列出至少五種設計模式

設計方式有工廠法，懶加載，觀察者模式，靜態工廠，迭代器模式，外觀模式、、、、

 

1-7）RPC 原理？

Rpc分爲同步調用和一部調用，異步與同步的區別在因而否等待服務器端的返回值。Rpc的組件有RpcServer,RpcClick,RpcProxy,RpcConnection,RpcChannel,RpcProtocol,RpcInvoker等組件，

 

1-8）ArrayList、Vector、LinkedList 的區別及其優缺點？HashMap、HashTable 的區別及優缺點？

    ArrayList 和 Vector 是採用數組方式存儲數據的,是根據索引來訪問元素的，均可以

根據須要自動擴展內部數據長度，以便增長和插入元素，都容許直接序號索引元素，但

是插入數據要涉及到數組元素移動等內存操做，因此索引數據快插入數據慢，他們最大

的區別就是 synchronized 同步的使用。

    LinkedList 使用雙向鏈表實現存儲，按序號索引數據須要進行向前或向後遍歷，但

是插入數據時只須要記錄本項的先後項便可，因此插入數度較快！

若是隻是查找特定位置的元素或只在集合的末端增長、移除元素，那麼使用 Vector

或 ArrayList 均可以。若是是對其它指定位置的插入、刪除操做，最好選擇 LinkedList

HashMap、HashTable 的區別及其優缺點：

     HashTable 中的方法是同步的 HashMap 的方法在缺省狀況下是非同步的 所以在多線程環境下須要作額外的同步機制。

    HashTable 不容許有 null 值 key 和 value 都不容許，而 HashMap 容許有 null 值 key和 value 都容許 所以 HashMap 使用 containKey（）來判斷是否存在某個鍵。

HashTable 使用 Enumeration ，而 HashMap 使用 iterator。

     Hashtable 是 Dictionary 的子類，HashMap 是 Map 接口的一個實現類。

1-9）使用 StringBuffer 而不是 String

當須要對字符串進行操做時，使用 StringBuffer 而不是 String，String 是 read-only 的，若是對它進行修改，會產生臨時對象，而 StringBuffer 是可修改的，不會產生臨時對象。

1-10）集合的擴充

ArrayList  list = new ArrayList(90000); list擴充多少次？？

 public ArrayList() {

        this(10);

}

默認的擴充是10由此計算

 

1-11）java的拆包與封包的問題

 

System.out.println("5" + 2);

52

 

1-12）Java中Class.forName和ClassLoader.loadClass的區別

Class.forName("xx.xx")等同於Class.forName("xx.xx",true,CALLClass.class.getClassLoader())，第二個參數(bool)表示裝載類的時候是否初始化該類，即調用類的靜態塊的語句及初始化靜態成員變量。

 

ClassLoader loader = Thread.currentThread.getContextClassLoader(); //也能夠用(ClassLoader.getSystemClassLoader())

 

Class cls = loader.loadClass("xx.xx"); //這句話沒有執行初始化

 

forName能夠控制是否初始化類，而loadClass加載時是沒有初始化的。

 

1-13）hashMap與hashTable的區別

                   HashMap                Hashtable

 

父類               AbstractMap          Dictiionary

 

是否同步            否                            是

 

k，v能否null        是                            否

 

 

Hashtable和HashMap採用的hash/rehash算法都大概同樣，因此性能不會有很大的差別。

 

1-14）怎樣實現數組的反轉

ArrayList arrayList = new ArrayList();  

 arrayList.add("A");  

 arrayList.add("B");

 

對數組進行反轉

Collections.reverse(arrayList);

 

1-15）請使用JAVA實現二分查找

通常的面試者都是些向看看你的思路，因此通常答題時只須要把思路寫出來便可。

具體的實現以下：

二分查找就是折半查找，要想折半就必須把原來的數據進行排序，才能方便的查找：

實現代碼以下：

 public static int binarySearch(int[] srcArray, int des){   

        int low = 0;   

        int high = srcArray.length-1;   

        while(low <= high) {   

            int middle = (low + high)/2;   

            if(des == srcArray[middle]) {   

                return middle;   

            }else if(des <srcArray[middle]) {   

                high = middle - 1;   

            }else {   

                low = middle + 1;   

            }  

        }  

        return -1;  

   }

 

 

1-16）java 中有兩個線程怎樣等待一個線程執行完畢

可使用join關鍵字

 

1-17）hashmap hashtable currentHashMap的使用區別

     hashmap hashtable 的醉的的區別在於hashtable 是線程安全的，而hashmap 不是線程安全的，currentHashMap也是線程安全的。

     ConcurrentHashMap是使用了鎖分段技術技術來保證線程安全的。所分段的技術是：講數據分紅一段一段的儲存，給每一段的數據添加一把鎖，當線程訪問一個數據時，其餘的數據能夠被訪問。

 

1-18）簡單描述一下java的gc機制，經常使用的JAVA調優的方法，OOM如何產生的，如何處理OOM問題？？？

一、程序在運行時會產生不少的對象的信息，當這些對象的信息沒有用時，則會被gc回收

二、調優的方式主要是調節年輕代與老年代的內存的大小

三、OOM是OutOfMemory的縮寫(搞得跟多高大上似的)就是線程建立的多了，沒有及時的回收過來所產生的，代碼以下：

public class JavaVMStackOOM {  

    private void dontStop() {  

        while (true) {  

              

        }  

    }  

      

    public void stackLeakByThread() {  

        while (true) {  

            Thread thread = new Thread(new Runnable() {  

                @Override  

                public void run() {  

                    dontStop();  

                }  

            });  

            thread.start();  

        }  

    }  

      

    public static void main(String[] args) {  

        JavaVMStackOOM oom = new JavaVMStackOOM();  

        oom.stackLeakByThread();  

}  

 

四、既然知道以上的現象，在寫代碼時應該注意，不要過多的建立線程的數目。

 

 

Linux 相關

2-1）關閉沒必要要的服務

A、使用ntsysv命令查看開啓與關閉的服務

B、中止打印服務

[root@hadoop1 /]# /etc/init.d/cups stop

[root@hadoop1 /]# chkconfig cups off

2-2）關閉IP6

[root@hadoop1 /]# vim /etc/modprobe.conf

在下面添加一下配置：

alias net-pf-10 off

alias ipv6 off

2-3）調整文件的最大的打開數

查看當前的文件的數量：[root@hadoop1 /]#ulimit -a

修改配置：
[root@hadoop1 /]# vi /etc/security/limits.conf 在文件最後加上：

• soft nofile 65535

• hard nofile 65535

• soft nproc 65535

• hard nproc 65535

2-4）修改 linux 內核參數

[root@hadoop1 /]# vi /etc/sysctl.conf

在文本的最後追加一下內容：

net.core.somaxconn = 32768

 

表示物理內存使用到 90%（100-10=90）的時候才使用 swap 交換區

2-5）關閉 noatime

在最後追加一下內容

/dev/sda2 /data ext3 noatime,nodiratime 0 0

 

 

2-6)請用shell命令把某一個文件下的全部的文件分發到其餘的機器上

Scp  -r  /user/local   hadoop2:/user/local

 

2-7）echo 1+1 && echo "1+1" 會輸出什麼

 

[root@hadoop1 ~]# echo 1+1 && echo "1+1"

1+1

1+1

 

[root@hadoop1 ~]# echo 1+1 && echo "1+1" && echo "1+" 1

1+1

1+1

1+ 1

 

2-8）在當前的額目錄下找出包含祖母a而且文件的額大小大於55K的文件

[root@hadoop1 test]# find  .|  grep -ri "a"

a.text:a

 

後半句沒有寫出來，有時間在搞

 

 

2-9）linux用什麼命令查看cpu,硬盤，內存的信息？

Top 命令

 

Hadoop相關

3-1）簡單概述hdfs原理，以及各個模塊的職責

 

 

 

 

一、客戶端向 nameNode 發送要上傳文件的請求

二、nameNode 返回給用戶是否能上傳數據的狀態

三、加入用戶端須要上傳一個 1024M 的文件，客戶端會經過 Rpc 請求 NameNode，並返回須要上傳給那些 DataNode(分配機器的距離以及空間的大小等),namonode會選擇就近原則分配機器。

四、客戶端請求創建 block 傳輸管道 chnnel 上傳數據

五、在上傳是 datanode 會與其餘的機器創建鏈接並把數據塊傳送到其餘的機器上

六、dataNode 向 namenode 彙報本身的儲存狀況以及本身的信息

七、檔第一個快上傳完後再去執行其餘的複製的傳送

 

 

 

3-2）mr的工做原理

 

 

 

 

一、當執行mr程序是，會執行一個Job

二、客戶端的jobClick會請求namenode的jobTracker要執行任務

三、jobClick會去HDFS端複製做業的資源文件

四、客戶端的jobClick會向namenode提交做業,讓namenode作準備

五、Namenode的jobTracker會去初始化建立的對象

六、Namenode會獲取hdfs的劃分的分區

七、Namenode去檢查TaskTracker的心跳信息，查看存活的機器

八、當執行的datenode執行任務時Datenode會去HDFS獲取做業的資源的文件

九、TaskTracker會去執行代碼，並登錄JVM的執行渠道

十、JVM或執行MapTask或者ReduceTask

十一、執行終結

 

 

3-3）怎樣判斷文件時候存在

這是linux上的知識，只須要在IF[ -f ] 括號中加上-f參數便可判斷文件是否存在

 

 

3-4）fsimage和edit的區別？

 

你們都知道namenode與secondary namenode 的關係，當他們要進行數據同步時叫作checkpoint時就用到了fsimage與edit，fsimage是保存最新的元數據的信息，當fsimage數據到必定的大小事會去生成一個新的文件來保存元數據的信息，這個新的文件就是edit，edit會回滾最新的數據。

 

3-5）hdfs中的block默認保存幾份？

無論是hadoop1.x 仍是hadoop2.x 都是默認的保存三份，能夠經過參數dfs.replication就行修改，副本的數目要根據機器的個數來肯定。

 

3-6）列舉幾個配置文件優化？

Core-site.xml 文件的優化

 

fs.trash.interval

默認值： 0

說明： 這個是開啓hdfs文件刪除自動轉移到垃圾箱的選項，值爲垃圾箱文件清除時間。通常開啓這個會比較好，以防錯誤刪除重要文件。單位是分鐘。

 

dfs.namenode.handler.count

默認值：10

說明：hadoop系統裏啓動的任務線程數，這裏改成40，一樣能夠嘗試該值大小對效率的影響變化進行最合適的值的設定。

 

mapreduce.tasktracker.http.threads

默認值：40

說明：map和reduce是經過http進行數據傳輸的，這個是設置傳輸的並行線程數。

 

3-7) 談談數據傾斜，如何發生的，並給出優化方案

     數據的傾斜主要是兩個的數據相差的數量不在一個級別上，在只想任務時就形成了數據的傾斜，能夠經過分區的方法減小reduce數據傾斜性能的方法，例如;抽樣和範圍的分區、自定義分區、數據大小傾斜的自定義側咯

 

3-8）簡單歸納安裝hadoop的步驟

1.建立 hadoop 賬戶。

2.setup.改 IP。

3.安裝 java，並修改/etc/profile 文件，配置 java 的環境變量。

4.修改 Host 文件域名。

5.安裝 SSH，配置無密鑰通訊。

6.解壓 hadoop。

7.配置 conf 文件下 hadoop-env.sh、core-site.sh、mapre-site.sh、hdfs-site.sh。

8.配置 hadoop 的環境變量。

9.Hadoop namenode -format

10.Start-all.sh

 

3-9）簡單概述hadoop中的角色的分配以及功能

Namenode:負責管理元數據的信息

SecondName:作namenode冷備份，對於namenode的機器當掉後能快速切換到制定的Secondname上

DateNode:主要作儲存數據的。

JobTracker:管理任務，並把任務分配到taskTasker

TaskTracker：執行任務的

 

3-10）怎樣快速的殺死一個job

一、執行hadoop  job -list  拿到job-id

二、Hadoop job kill hadoop-id

 

3-11)新增一個節點時怎樣快速的啓動

Hadoop-daemon.sh start datanode

 

3-12)你認爲用java , streaming , pipe 方式開發map/reduce,各有什麼優勢

開發mapReduce只用過java與hive,不過使用java開發mapreduce顯得笨拙，效率也慢，基於java慢的緣由因而hive，這樣就方便了查詢與設計

 

3-13）簡單概述hadoop的join的方法

Hadoop 經常使用的jion有reduce side join  , map side  join ,  SemiJoin 不過reduce side join 與 map side join 比較經常使用，不過都是比較耗時的。

 

3-14）簡單概述hadoop的combinet與partition的區別

combine和partition都是函數，中間的步驟應該只有shuffle！ combine分爲map端和reduce端，做用是把同一個key的鍵值對合並在一塊兒，能夠自定義的,partition是分割map每一個節點的結果，按照key分別映射給不一樣的reduce，也是能夠自定義的。這裏其實能夠理解歸類。

3-15 ) hdfs 的數據壓縮算法

 Hadoop 的壓縮算法有不少，其中比較經常使用的就是gzip算法與bzip2算法，均可以可經過CompressionCodec來實現

 

3-16）hadoop的調度

Hadoop 的調度有三種其中fifo的調度hadoop的默認的，這種方式是按照做業的優先級的高低與到達時間的前後執行的，還有公平調度器：名字見起意就是分配用戶的公平獲取共享集羣唄!容量調度器:讓程序都能貨到執行的能力，在隊列中得到資源。

 

3-17）reduce 後輸出的數據量有多大？

輸出的數據量還不是取決於map端給他的數據量，沒有數據reduce也無法運算啊!!

 

3-18) datanode 在什麼狀況下不會備份？

Hadoop保存的三個副本若是不算備份的話，那就是在正常運行的狀況下不會備份，也是就是在設置副本爲1的時候不會備份，說白了就是單臺機器唄！！還有datanode 在強制關閉或者非正常斷電不會備份。

3-19）combine 出如今那個過程？

Hadoop的map過程，根據意思就知道結合的意思嗎，剩下的大家就懂了。想一想wordcound

 

3-20) hdfs 的體系結構？

HDFS有 namenode、secondraynamenode、datanode 組成。

namenode 負責管理 datanode 和記錄元數據

secondraynamenode 負責合併日誌

datanode 負責存儲數據

3-21) hadoop flush 的過程？

Flush 就是把數據落到磁盤，把數據保存起來唄!

 

3-22) 什麼是隊列

隊列的實現是鏈表，消費的順序是先進先出。

 

3-23）三個 datanode，當有一個 datanode 出現錯誤會怎樣？

第一不會給儲存帶來影響，由於有其餘的副本保存着，不過建議儘快修復，第二會影響運算的效率，機器少了，reduce在保存數據時選擇就少了，一個數據的塊就大了因此就會慢。

 

3-24）mapReduce 的執行過程

首先map端會Text 接受到來自的數據，text能夠把數據進行操做，最後經過context把key與value寫入到下一步進行計算，通常的reduce接受的value是個集合能夠運算，最後再經過context把數據持久化出來。

 

3-25）Cloudera 提供哪幾種安裝 CDH 的方法

· Cloudera manager

· Tarball

· Yum

· Rpm

 

3-26）選擇題與判斷題

http://blog.csdn.net/jiangheng0535/article/details/16800415

 

3-27）hadoop的combinet與partition效果圖

 

 

3-28）hadoop 的機架感知（或者說是擴普）

看圖說話

數據塊會優先儲存在離namenode進的機器或者說成離namenode機架近的機器上，正好是驗證了那句話不走網絡就不走網絡，不用磁盤就不用磁盤。

 

3-29）文件大小默認爲 64M，改成 128M 有啥影響？

這樣減小了namenode的處理能力，數據的元數據保存在namenode上，若是在網絡很差的狀況下會增到datanode的儲存速度。能夠根據本身的網絡來設置大小。

 

3-30）datanode 首次加入 cluster 的時候，若是 log 報告不兼容文件版本，那須要namenode 執行格式化操做，這樣處理的緣由是？

     這樣處理是不合理的，由於那麼 namenode 格式化操做，是對文件系統進行格式

化，namenode 格式化時清空 dfs/name 下空兩個目錄下的全部文件，以後，會在目

錄 dfs.name.dir 下建立文件。

     文本不兼容，有可能時 namenode 與 datanode 的 數據裏的 namespaceID、

clusterID 不一致，找到兩個 ID 位置，修改成同樣便可解決。

3-31）什麼 hadoop streaming？

提示：指的是用其它語言處理

 

3-32）MapReduce 中排序發生在哪幾個階段？這些排序是否能夠避免？爲何？

     一個 MapReduce 做業由 Map 階段和 Reduce 階段兩部分組成，這兩階段會對數

據排序，從這個意義上說，MapReduce 框架本質就是一個 Distributed Sort。在 Map

階段，在 Map 階段，Map Task 會在本地磁盤輸出一個按照 key 排序（採用的是快速

排序）的文件（中間可能產生多個文件，但最終會合併成一個），在 Reduce 階段，每

個 Reduce Task 會對收到的數據排序，這樣，數據便按照 Key 分紅了若干組，以後以

組爲單位交給 reduce（）處理。不少人的誤解在 Map 階段，若是不使用 Combiner

便不會排序，這是錯誤的，無論你用不用 Combiner，Map Task 均會對產生的數據排

序（若是沒有 Reduce Task，則不會排序，實際上 Map 階段的排序就是爲了減輕 Reduce

端排序負載）。因爲這些排序是 MapReduce 自動完成的，用戶沒法控制，所以，在

hadoop 1.x 中沒法避免，也不能夠關閉，但 hadoop2.x 是能夠關閉的。

 

3-33）hadoop的shuffer的概念

Shuffer是一個過程，實在map端到reduce在調reduce數據以前都叫shuffer,主要是分區與排序，也就是內部的緩存分分區以及分發（是reduce來拉數據的）和傳輸

 

3-34）hadoop的優化

一、優化的思路能夠從配置文件和系統以及代碼的設計思路來優化

二、配置文件的優化：調節適當的參數，在調參數時要進行測試

三、代碼的優化：combiner的個數儘可能與reduce的個數相同，數據的類型保持一致，能夠減小拆包與封包的進度

四、系統的優化：能夠設置linux系統打開最大的文件數預計網絡的帶寬MTU的配置

五、爲 job 添加一個 Combiner，能夠大大的減小shuffer階段的maoTask拷貝過來給遠程的   reduce task的數據量，通常而言combiner與reduce相同。

六、在開發中儘可能使用stringBuffer而不是string，string的模式是read-only的，若是對它進行修改，會產生臨時的對象，二stringBuffer是可修改的，不會產生臨時對象。

七、修改一下配置：

一下是修改 mapred-site.xml 文件

修改最大槽位數

槽位數是在各個 tasktracker 上的 mapred-site.xml 上設置的，默認都是 2

mapred.tasktracker.map.tasks.maximum

task 的最大數

2

mapred.tasktracker.reduce.tasks.maximum

ducetask 的最大數

2

調整心跳間隔

集羣規模小於 300 時，心跳間隔爲 300 毫秒

mapreduce.jobtracker.heartbeat.interval.min 心跳時間

北京市昌平區建材城西路金燕龍辦公樓一層 電話：400-618-9090

mapred.heartbeats.in.second 集羣每增長多少節點，時間增長下面的值

mapreduce.jobtracker.heartbeat.scaling.factor 集羣每增長上面的個數，心跳增多少

啓動帶外心跳

mapreduce.tasktracker.outofband.heartbeat 默認是 false

配置多塊磁盤

mapreduce.local.dir

配置 RPC hander 數目

mapred.job.tracker.handler.count 默認是 10，能夠改爲 50，根據機器的能力

配置 HTTP 線程數目

tasktracker.http.threads 默認是 40，能夠改爲 100 根據機器的能力

選擇合適的壓縮方式

以 snappy 爲例：

mapred.compress.map.output

true

mapred.map.output.compression.codec

org.apache.hadoop.io.compress.SnappyCodec

 

3-35)3 個 datanode 中有一個 個datanode 出現錯誤會怎樣？

這個 datanode 的數據會在其餘的 datanode 上從新作備份。

 

3-36）怎樣決定mapreduce的中的map以及reduce的數量

在mapreduce中map是有塊的大小來決定的，reduce的數量能夠按照用戶的業務來配置。

 

3-37）兩個文件合併的問題

給定a、b兩個文件，各存放50億個url，每一個url各佔用64字節，內存限制是4G，如何找出a、b文件共同的url？

 

    主要的思想是把文件分開進行計算，在對每一個文件進行對比，得出相同的URL,由於以上說是含有相同的URL因此不用考慮數據傾斜的問題。詳細的解題思路爲：

 

能夠估計每一個文件的大小爲5G*64=300G，遠大於4G。因此不可能將其徹底加載到內存中處理。考慮採起分而治之的方法。 
    遍歷文件a，對每一個url求取hash(url)%1000，而後根據所得值將url分別存儲到1000個小文件（設爲a0,a1,...a999）當中。這樣每一個小文件的大小約爲300M。遍歷文件b，採起和a相同的方法將url分別存儲到1000個小文件(b0,b1....b999)中。這樣處理後，全部可能相同的url都在對應的小文件(a0 vs b0, a1 vs b1....a999 vs b999)當中，不對應的小文件（好比a0 vs b99）不可能有相同的url。而後咱們只要求出1000對小文件中相同的url便可。 
    好比對於a0 vs b0，咱們能夠遍歷a0，將其中的url存儲到hash_map當中。而後遍歷b0，若是url在hash_map中，則說明此url在a和b中同時存在，保存到文件中便可。 
    若是分紅的小文件不均勻，致使有些小文件太大（好比大於2G），能夠考慮將這些太大的小文件再按相似的方法分紅小小文件便可

 

3-38）怎樣決定一個job的map和reduce的數量

map的數量一般是由hadoop集羣的DFS塊大小肯定的，也就是輸入文件的總塊數，reduce端是複製map端的數據，相對於map端的任務，reduce節點資源是相對於比較缺乏的，同時運行的速度會變慢，爭取的任務的個數應該是0.95過着1.75。

 

3-39）hadoop的sequencefile的格式，並說明下什麼是JAVA的序列化，如何實現JAVA的序列化

一、hadoop的序列化(sequencefile)是一二進制的形式來保存的

二、Java的序列化是講對象的內容進行流化

三、實現序列化須要實現Serializable接口即可以了

 

3-40）簡單概述一下hadoop1與hadoop2的區別

Hadoop2與hadoop1最大的區別在於HDFS的架構與mapreduce的很大的區別，並且速度上有很大的提高，hadoop2最主要的兩個變化是：namenode能夠集羣的部署了，hadoop2中的mapreduce中的jobTracker中的資源調度器與生命週期管理拆分紅兩個獨立的組件，並命名爲YARN

 

3-41）YARN的新特性

YARN是hadoop2.x以後纔出的，主要是hadoop的HA(也就是集羣)，磁盤的容錯，資源調度器

 

3-42）hadoop join的原理

實現兩個表的join首先在map端須要把表標示一下，把其中的一個表打標籤，到reduce端再進行笛卡爾積的運算，就是reduce進行的實際的連接操做。

 

3-43）hadoop的二次排序

Hadoop默認的是HashPartitioner排序，當map端一個文件很是大另一個文件很是小時就會產生資源的分配不均勻，既可使用setPartitionerClass來設置分區，即造成了二次分區。

 

3-44）hadoop的mapreduce的排序發生在幾個階段？

發生在兩個階段即便map與reduce階段

 

3-45）請描述mapreduce中shuffer階段的工做流程，如何優化shuffer階段的？

 

Mapreduce的shuffer是出在map task到reduce task的這段過程當中，首先會進入到copy過程，會經過http方式請求map task所在的task Tracker獲取map task 的輸出的文件，所以當map  task結束，這些文件就會落到磁盤中，merge實在map端的動做，只是在map拷貝過來的數值，會放到內存緩衝區中，給shuffer使用，reduce階段，不斷的merge後最終會把文件放到磁盤中。

 

 

3-46）mapreduce的combiner的做用是什麼，何時不易使用？？

Mapreduce中的Combiner就是爲了不map任務和reduce任務之間的數據傳輸而設置的，Hadoop容許用戶針對map task的輸出指定一個合併函數。即爲了減小傳輸到Reduce中的數據量。它主要是爲了削減Mapper的輸出從而減小網絡帶寬和Reducer之上的負載。

在數據量較少時不宜使用。

 

3-47）

Zookeeper 相關

4-1）寫出你對zookeeper的理解

     隨着大數據的快速發展，多機器的協調工做，避免主要機器單點故障的問題，因而就引入管理機器的一個軟件，他就是zookeeper來協助機器正常的運行。

     Zookeeper有兩個角色分別是leader與follower ，其中leader是主節點，其餘的是副節點，在安裝配置上必定要注意配置奇數個的機器上，便於zookeeper快速切換選舉其餘的機器。

在其餘的軟件執行任務時在zookeeper註冊時會在zookeeper下生成相對應的目錄，以便zookeeper去管理機器。

 

4-2）zookeeper 的搭建過程

主要是配置文件zoo.cfg 配置dataDir 的路徑一句dataLogDir 的路徑以及myid的配置以及server的配置，心跳端口與選舉端口

 

 

Hive 相關

5-1）hive是怎樣保存元數據的

保存元數據的方式有：內存數據庫rerdy，本地mysql數據庫，遠程mysql數據庫，可是本地的mysql數據用的比較多，由於本地讀寫速度都比較快

 

5-2）外部表與內部表的區別

 

先來講下Hive中內部表與外部表的區別： 

Hive 建立內部表時，會將數據移動到數據倉庫指向的路徑；若建立外部表，僅記錄數據所在的路徑，不對數據的位置作任何改變。在刪除表的時候，內部表的元數據和數據會被一塊兒刪除，而外部表只刪除元數據，不刪除數據。這樣外部表相對來講更加安全些，數據組織也更加靈活，方便共享源數據。

 

5-3）對於 hive，你寫過哪些 UDF 函數，做用是什麼

UDF: user  defined  function  的縮寫，編寫hive udf的兩種方式extends UDF 重寫evaluate第二種extends GenericUDF重寫initialize、getDisplayString、evaluate方法

 

5-4)Hive 的 sort by 和 order by 的區別

  order by 會對輸入作全局排序，所以只有一個reducer（多個reducer沒法保證全局有序）只有一個reducer，會致使當輸入規模較大時，須要較長的計算時間。

   sort by不是全局排序，其在數據進入reducer前完成排序.

所以，若是用sort by進行排序，而且設置mapred.reduce.tasks>1， 則sort by只保證每一個reducer的輸出有序，不保證全局有序。

 

5-5）hive保存元數據的方式以及各有什麼特色？

一、Hive有內存數據庫derby數據庫，特色是保存數據小，不穩定

二、mysql數據庫，儲存方式能夠本身設定，持久化好，通常企業開發都用mysql作支撐

5-6）在開發中問什麼建議使用外部表？

一、外部表不會加載到hive中只會有一個引用加入到元數據中

二、在刪除時不會刪除表，只會刪除元數據，因此沒必要擔憂數據的

 

5-7）hive partition 分區

分區表，動態分區

 

5-8）insert into 和 override write 區別？

insert into：將某一張表中的數據寫到另外一張表中

override write：覆蓋以前的內容。

 

Hbase 相關

6-1）Hbase 的 rowkey 怎麼建立比較好？列族怎麼建立比較好？

 

 

Rowkey是一個二進制碼流，Rowkey的長度被不少開發者建議說設計在10~100個字節，不過建議是越短越好，不要超過16個字節。在查找時有索引會加快速度。

 

Rowkey散列原則 、 Rowkey惟一原則 、 針對事務數據Rowkey設計 、 針對統計數據的Rowkey設計 、 針對通用數據的Rowkey設計、 支持多條件查詢的RowKey設計。 

 

 

總結設計列族：

一、通常不建議設計多個列族

二、數據塊的緩存的設計

三、激進緩存設計

四、布隆過濾器的設計(能夠提升隨機讀取的速度)

五、生產日期的設計

六、列族壓縮

七、單元時間版本

 

6-2）Hbase 的實現原理

Hbase  的實現原理是rpc Protocol 

 

6-3) hbase 過濾器實現原則

感受這個問題有問題，過濾器多的是啦，說的是哪個不知道!!!!

Hbase的過濾器有：RowFilter、PrefixFilter、KeyOnlyFilter、RandomRowFilter、InclusiveStopFilter、FirstKeyOnlyFilter、ColumnPrefixFilter、ValueFilter、ColumnCountGetFilter、SingleColumnValueFilter、SingleColumnValueExcludeFilter、WhileMatchFilter、FilterList 

   你看這麼多過濾波器呢，誰知道你問的那個啊！！

   比較經常使用的過濾器有：RowFilter 一看就知道是行的過濾器，來過濾行的信息。PrefixFilter前綴的過濾器，就是把前綴做爲參數來查找數據唄！剩下的不解釋了看過濾器的直接意思就OK了很簡單。

 

6-4）描述 HBase, zookeeper 搭建過程

Zookeeper 的問題樓上爬爬有步驟，hbase 主要的配置文件有hbase.env.sh 主要配置的是JDK的路徑以及是否使用外部的ZK，hbase-site.xml 主要配置的是與HDFS的連接的路徑以及zk的信息，修改regionservers的連接其餘機器的配置。

 

6-5）hive 如何調優？

在優化時要注意數據的問題，儘可能減小數據傾斜的問題，減小job的數量，同事對小的文件進行成大的文件，若是優化的設計那就更好了，由於hive的運算就是mapReduce因此調節mapreduce的參數也會使性能提升，如調節task的數目。

 

6-6）hive的權限的設置

Hive的權限須要在hive-site.xml文件中設置纔會起做用，配置默認的是false，須要把hive.security.authorization.enabled設置爲true，並對不一樣的用戶設置不一樣的權限，例如select ,drop等的操做。

 

6-7 ) hbase 寫數據的原理

 

1. 首先，Client經過訪問ZK來請求目標數據的地址。

2. ZK中保存了-ROOT-表的地址，因此ZK經過訪問-ROOT-表來請求數據地址。

3. 一樣，-ROOT-表中保存的是.META.的信息，經過訪問.META.表來獲取具體的RS。

4. .META.表查詢到具體RS信息後返回具體RS地址給Client。

5. Client端獲取到目標地址後，而後直接向該地址發送數據請求。

 

 

6-8）hbase宕機瞭如何處理？

HBase的RegionServer宕機超過必定時間後，HMaster會將其所管理的region從新分佈到其餘活動的RegionServer上，因爲數據和日誌都持久在HDFS中，
該操做不會致使數據丟失。因此數據的一致性和安全性是有保障的。
可是從新分配的region須要根據日誌恢復原RegionServer中的內存MemoryStore表，這會致使宕機的region在這段時間內沒法對外提供服務。
而一旦重分佈，宕機的節點從新啓動後就至關於一個新的RegionServer加入集羣，爲了平衡，須要再次將某些region分佈到該server。 
所以，Region Server的內存表memstore如何在節點間作到更高的可用，是HBase的一個較大的挑戰。

 

6-9）Hbase 中的 metastore 用來作什麼的？

Hbase的metastore是用來保存數據的，其中保存數據的方式有有三種第一種於第二種是本地儲存，第二種是遠程儲存這一種企業用的比較多

 

6-10)hbase客戶端在客戶端怎樣優化？

Hbase使用JAVA來運算的，索引Java的優化也適用於hbase，在使用過濾器事記得開啓bloomfilter能夠是性能提升3-4倍，設置HBASE_HEAPSIZE設置大一些

 

6-11）hbase是怎樣預分區的？

如何去進行預分區，能夠採用下面三步：
  1.取樣，先隨機生成必定數量的rowkey,將取樣數據按升序排序放到一個集合裏
  2.根據預分區的region個數，對整個集合平均分割，便是相關的splitKeys.
  3.HBaseAdmin.createTable(HTableDescriptor tableDescriptor,byte[][] splitkeys)能夠指定預分區的splitKey，便是指定region間的rowkey臨界值

6-12）怎樣將 mysql 的數據導入到 hbase 中？

不能使用 sqoop，速度太慢了，提示以下：

A、一種能夠加快批量寫入速度的方法是經過預先建立一些空的 regions，這樣當

數據寫入 HBase 時，會按照 region 分區狀況，在集羣內作數據的負載均衡。

B、hbase 裏面有這樣一個 hfileoutputformat 類，他的實現能夠將數據轉換成 hfile

格式，經過 new 一個這個類，進行相關配置,這樣會在 hdfs 下面產生一個文件，這個

時候利用 hbase 提供的 jruby 的 loadtable.rb 腳本就能夠進行批量導入。

 

6-13）談談 HBase 集羣安裝注意事項？

     須要注意的地方是 ZooKeeper 的配置。這與 hbase-env.sh 文件相關，文件中

HBASE_MANAGES_ZK 環境變量用來設置是使用 hbase 默認自帶的 Zookeeper 還

是使用獨立的 ZooKeeper。HBASE_MANAGES_ZK=false 時使用獨立的，爲 true 時

使用默認自帶的。

    某個節點的 HRegionServer 啓動失敗，這是因爲這 3 個節點的系統時間不一致相

差超過集羣的檢查時間 30s。

6-14)簡述 HBase 的瓶頸

Hbase主要的瓶頸就是傳輸問題，在操做時大部分的操做都是須要對磁盤操做的

 

6-15）Redis, 傳統數據庫,hbase,hive  每一個之間的區別

Redis 是基於內存的數據庫，注重實用內存的計算，hbase是列式數據庫，沒法建立主鍵，地從是基於HDFS的，每一行能夠保存不少的列，hive是數據的倉庫，是爲了減輕mapreduce而設計的，不是數據庫是用來與紅薯作交互的。

 

6-16）Hbase 的特性,以及你怎麼去設計 rowkey 和 columnFamily ,怎麼去建一個 table

由於hbase是列式數據庫，列非表schema的一部分，因此只須要考慮rowkey和columnFamily 便可，rowkey有爲的相關性，最好數據庫添加一個前綴，文件越小，查詢速度越快，再設計列是有一個列簇，可是列簇不宜過多。

 

 

6-17）Hhase與hive的區別

     Apache HBase是一種Key/Value系統，它運行在HDFS之上。和Hive不同，Hbase的可以在它的數據庫上實時運行，而不是運行MapReduce任務。Hive被分區爲表格，表格又被進一步分割爲列簇。列簇必須使用schema定義，列簇將某一類型列集合起來（列不要求schema定義）。例如，「message」列簇可能包含：「to」, 」from」 「date」, 「subject」, 和」body」. 每個 key/value對在Hbase中被定義爲一個cell，每個key由row-key，列簇、列和時間戳。在Hbase中，行是key/value映射的集合，這個映射經過row-key來惟一標識。Hbase利用Hadoop的基礎設施，能夠利用通用的設備進行水平的擴展。

 

6-18）描述hbase的scan和get功能以及實現的異同

 

      HBase的查詢實現只提供兩種方式： 一、按指定RowKey獲取惟一一條記錄，get方法（org.apache.hadoop.hbase.client.Get） 二、按指定的條件獲取一批記錄，scan方法（org.apache.hadoop.hbase.client.Scan） 實現條件查詢功能使用的就是scan方式

 

6-19）HBase scan setBatch和setCaching的區別

      can能夠經過setCaching與setBatch方法提升速度（以空間換時間），

setCaching設置的值爲每次rpc的請求記錄數，默認是1；cache大能夠優化性能，可是太大了會花費很長的時間進行一次傳輸。

   setBatch設置每次取的column size；有些row特別大，因此須要分開傳給client，就是一次傳一個row的幾個column。

6-20）hbase 中cell的結構

cell中的數據是沒有類型的，所有是字節碼形式存貯。

 

6-21）hbase 中region太多和region太大帶來的衝突

Hbase的region會自動split，當region太時，regio太大時分佈會不均衡，同時對於大批量的代入數據建議以下：

一、仍是必須讓業務方對rowkey進行預分片，對業務數據rowkey進行md5或者其餘的hash策略，讓數據儘可能隨機分佈而不是順序寫入。

二、隨時觀察region的大小，是否出現大region的狀況。

Flume相關

7-1）flume 不採集 Nginx 日誌，經過 Logger4j 採集日誌，優缺點是什麼？

在nginx採集日誌時沒法獲取session的信息，然而logger4j則能夠獲取session的信息，logger4j的方式比較穩定，不會宕機。缺點：不夠靈活，logger4j的方式和項目結合過濾緊密，二flume的方式就比較靈活，便於插拔式比較好，不會影響項目的性能。

 

7-2）flume 和 kafka 採集日誌區別，採集日誌時中間停了，怎麼記錄以前的日誌。

Flume 採集日誌是經過流的方式直接將日誌收集到存儲層，而 kafka 試講日誌緩存在 kafka

集羣，待後期能夠採集到存儲層。Flume 採集中間停了，能夠採用文件的方式記錄以前的日誌，而 kafka 是採用 offset(偏移量) 的方式記錄以前的日誌。

 

Kafka 相關

8-1）kafka 中怎樣儲存數據，喲及結構的，data.....目錄下有多少個分區，每一個分區的存儲格式是什麼樣的？

一、topic 是按照「主題名-分區」存儲的

二、分區個數由配置文件決定

三、每一個分區下最重要的兩個文件是 0000000000.log 和 000000.index，0000000.log

以默認 1G 大小回滾。

 

 

Spark 相關

9-1）mr 和 spark 區別，怎麼理解 spark-rdd

     Mr 是文件方式的分佈式計算框架，是將中間結果和最終結果記錄在文件中，map 和 reduce的數據分發也是在文件中。

 

spark 是內存迭代式的計算框架，計算的中間結果能夠緩存內存，也能夠緩存硬盤，可是不是每一步計算都須要緩存的。

 

Spark-rdd 是一個數據的分區記錄集合，是利用內存來計算的，spark之因此快是由於有內存的模式

 

9-2）簡單描述spark的wordCount的執行過程

scala> sc.textFile("/usr/local/words.txt")

res0: org.apache.spark.rdd.RDD[String] = /usr/local/words.txt MapPartitionsRDD[1] at textFile at :22

 

scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" "))

res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at :22

 

scala> sc.textFile("/usr/local/words.txt").flatMap(.split(" ")).map((,1))

res3: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at map at :22

 

scala> sc.textFile("/usr/local/words.txt").flatMap(.split(" ")).map((,1)).reduceByKey(+)

res5: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[17] at reduceByKey at :22

 

scala> sc.textFile("/usr/local/words.txt").flatMap(.split(" ")).map((,1)).reduceByKey(+).collect

res6: Array[(String, Int)] = Array((dageda,1), (xiaoli,1), (hellow,4), (xisdsd,1), (xiaozhang,1))

 

 

9-3）按照需求使用spark編寫一下程序

A、當前文件a.text的格式爲，請統計每一個單詞出現的個數

A,b,c,d

B,b,f,e

A,a,c,f

 

sc.textFile(「/user/local/a.text」).flatMap(.split(「,」)).map((,1)).ReduceByKey(+).collect()

或：

package cn.bigdata

 

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

 

object Demo {

 

  /*

a,b,c,d

b,b,f,e

a,a,c,f

c,c,a,d

   * 計算第四列每一個元素出現的個數

   */

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("demo").setMaster("local")

    val sc: SparkContext = new SparkContext(conf)

    val data: RDD[String] = sc.textFile("f://demo.txt")

    //數據切分

    val fourthData: RDD[(String, Int)] = data.map { x =>

      val arr: Array[String] = x.split(",")

      val fourth: String = arr(3)

      (fourth, 1)

    }

    val result: RDD[(String, Int)] = fourthData.reduceByKey(_ + _);

    println(result.collect().toBuffer)

  }

}

 

B、HDFS中有兩個文件a.text與b.text,文件的格式爲(ip,username),如：a.text,b.text

a.text

127.0.0.1  xiaozhang

127.0.0.1  xiaoli

127.0.0.2  wangwu

127.0.0.3  lisi

 

B.text

127.0.0.4  lixiaolu

127.0.0.5  lisi

 

每一個文件至少有1000萬行，請用程序完成一下工做，

1）每一個文件的個子的IP

2)出如今b.text而沒有出如今a.text的IP

3)每一個user出現的次數以及每一個user對應的IP的個數

 

代碼以下：

1）各個文件的ip數

package cn.bigdata

 

import java.util.concurrent.Executors

 

import org.apache.hadoop.conf.Configuration

import org.apache.hadoop.fs.FileSystem

import org.apache.hadoop.fs.LocatedFileStatus

import org.apache.hadoop.fs.Path

import org.apache.hadoop.fs.RemoteIterator

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

import org.apache.spark.rdd.RDD.rddToPairRDDFunctions

 

//各個文件的ip數

object Demo2 {

 

  val cachedThreadPool = Executors.newCachedThreadPool()

 

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("demo2").setMaster("local")

    val sc: SparkContext = new SparkContext(conf)

    val hdpConf: Configuration = new Configuration

    val fs: FileSystem = FileSystem.get(hdpConf)

    val listFiles: RemoteIterator[LocatedFileStatus] = fs.listFiles(new Path("f://txt/2/"), true)

    while (listFiles.hasNext) {

      val fileStatus = listFiles.next

      val pathName = fileStatus.getPath.getName

      cachedThreadPool.execute(new Runnable() {

        override def run(): Unit = {

          println("=======================" + pathName)

          analyseData(pathName, sc)

        }

      })

    }

  }

 

  def analyseData(pathName: String, sc: SparkContext): Unit = {

    val data: RDD[String] = sc.textFile("f://txt/2/" + pathName)

    val dataArr: RDD[Array[String]] = data.map(_.split(" "))

    val ipAndOne: RDD[(String, Int)] = dataArr.map(x => {

      val ip = x(0)

      (ip, 1)

    })

    val counts: RDD[(String, Int)] = ipAndOne.reduceByKey(_ + _)

    val sortedSort: RDD[(String, Int)] = counts.sortBy(_._2, false)

    sortedSort.saveAsTextFile("f://txt/3/" + pathName)

  }

}

 

2）出如今b.txt而沒有出如今a.txt的ip

package cn.bigdata

 

import java.util.concurrent.Executors

 

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

 

/*

 * 出如今b.txt而沒有出如今a.txt的ip

 */

object Demo3 {

  

  val cachedThreadPool = Executors.newCachedThreadPool()

  

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("Demo3").setMaster("local")

    val sc = new SparkContext(conf)

    val data_a = sc.textFile("f://txt/2/a.txt")

    val data_b = sc.textFile("f://txt/2/b.txt")

    val splitArr_a = data_a.map(_.split(" "))

    val ip_a: RDD[String] = splitArr_a.map(x => x(0))

    val splitArr_b = data_b.map(_.split(" "))

    val ip_b: RDD[String] = splitArr_b.map(x => x(0))

    val subRdd: RDD[String] = ip_b.subtract(ip_a)

    subRdd.saveAsTextFile("f://txt/4/")

  }

}

 

3）

package cn.bigdata

 

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

import scala.collection.mutable.Set

 

/*

 * 每一個user出現的次數以及每一個user對應的ip數

 */

object Demo4 {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("Demo4").setMaster("local")

    val sc = new SparkContext(conf)

    val data: RDD[String] = sc.textFile("f://txt/5/")

    val lines = data.map(_.split(" "))

    val userIpOne = lines.map(x => {

      val ip = x(0)

      val user = x(1)

      (user, (ip, 1))

    })

 

    val userListIpCount: RDD[(String, (Set[String], Int))] = userIpOne.combineByKey(

      x => (Set(x._1), x._2),

      (a: (Set[String], Int), b: (String, Int)) => {

        (a._1 + b._1, a._2 + b._2)

      },

      (m: (Set[String], Int), n: (Set[String], Int)) => {

        (m._1 ++ n._1, m._2 + n._2)

      })

 

    val result: RDD[String] = userListIpCount.map(x => {

      x._1 + ":userCount:" + x._2._2 + ",ipCount:" + x._2._1.size

    })

 

    println(result.collect().toBuffer)

 

  }

}

 

Sqoop 相關

10-1）sqoop在導入到MySql數據庫是怎樣保證數據重複，若是重複了該怎麼辦？？

在導入時在語句的後面加上一下命令做爲節點：

--incremental append
--check-column id
--last-value 1208

 

Redis 相關

10-1）redis保存磁盤的時間

  Note: you can disable saving at all commenting all the "save" lines.

  It is also possible to remove all the previously configured save

  points by adding a save directive with a single empty string argument

  like in the following example:

  save ""

 

save 900 1

save 300 10

save 60 10000

 

 

 

 

環境配置

1）大家的集羣規模？

這個得看我的在公司的規模，下面介紹一下咱們公司的一些配置：

 

聯想System x3750  服務器，價格3.5萬，內存容量32G，產品類型機架式，硬盤接口SSD,CPU頻率2.6GH,CPU數量2顆，三級緩存15MB,cpu核心6核，cpu線程數12線程,最大內存支持1.5T,網絡是千兆網卡,可插拔時硬盤接口12個卡槽,配置1T的容量

 

詳細：http://detail.zol.com.cn/server/index1101243.shtml

 

名字                               軟件                     運行管理

Hadoop1                           JDK,hadoop                namenode

Hadoop2                           JDK,hadoop                namenode

Hadoop3                           JDK,hadoop                secondaryNamenode

Hadoop4                           JDK,hadoop                secondaryNamenode

Hadoop5                           JDK,hadoop                datanode

Hadoop6                           JDK,hadoop                datanode

Hadoop7                           JDK,hadoop                datanode

Hadoop8                           JDK,hadoop                datanode

Hadoop9                           JDK,hadoop                datanode

Hadoop10                          JDK,zookeeper,tomcat,mvn,kafka leader

Hadoop11                          JDK,zookeeper,tomcat,mvn,kafka  follower

Hadoop12                          JDK,zookeeper,tomcat,mvn,kafka  follower

Hadoop13                          JDK,hive,mysql,svn,logstarh    hive,mysql,svn

Hadoop14                          JDK,hbase,mysql備份        datanode

Hadoop15                          JDK,nginx,Log日誌手機       datanode

 

 

數據就是天天訪問的Log日誌不是很大，有的時候大有的時候小的可憐

 

2)你在項目中遇到了哪些難題，是怎麼解決的？

一、在執行任務時發現副本的個數不對，通過一番的查找發現是超時的緣由，修改了配置文件hdfs-site.xml：中修改了超時時間。

二、因爲當時在分配各個目錄空間大小時，沒有很好的分配致使有的目錄的空間浪費，因而總體商量後把儲存的空間調大了一些。

 

 

設計題

1-1）採集nginx產生的日誌，日誌的格式爲user  ip   time  url   htmlId  天天產生的文件的數據量上億條，請設計方案把數據保存到HDFS上，並提供一下實時查詢的功能（響應時間小於3s）

A、某個用戶某天訪問某個URL的次數

B、某個URL某天被訪問的總次數

 

實時思路是：使用Logstash + Kafka + Spark-streaming + Redis + 報表展現平臺

離線的思路是：Logstash + Kafka + Elasticsearch +  Spark-streaming + 關係型數據庫

 

A、B、數據在進入到Spark-streaming 中進行過濾，把符合要求的數據保存到Redis中