JAVA相關

1-1）List 與set 的區別？

加拿大28原始碼軟體下載【大神原始碼論壇】dsluntan.com  【布丁原始碼論壇】budingbbs.com 企娥3393756370 掉牙的問題了，還在這裡老生常談：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問題？？？

1、程式在執行時會產生很多的物件的資訊，當這些物件的資訊沒有用時，則會被gc回收

2、調優的方式主要是調節年輕代與老年代的記憶體的大小

3、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();  
}  

4、既然知道以上的現象，在寫程式碼時應該注意，不要過多的建立執行緒的數目。

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

修改配置： [[email protected] /]# vi /etc/security/limits.conf 在檔案最後加上：

* soft nofile 65535

* hard nofile 65535

* soft nproc 65535

* hard nproc 65535

2-4）修改 linux 核心引數

[[email protected] /]# 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" 會輸出什麼

[[email protected] ~]# echo 1+1 && echo "1+1"

1+1

1+1

[[email protected] ~]# echo 1+1 && echo "1+1" && echo "1+" 1

1+1

1+1

1+ 1

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

[[email protected] test]# find  .|  grep -ri "a"

a.text:a

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

2-9）linux用什麼命令檢視cpu,硬碟，記憶體的資訊？

Top 命令

Hadoop相關

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

1、客戶端向 nameNode 傳送要上傳檔案的請求

2、nameNode 返回給使用者是否能上傳資料的狀態

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

4、客戶端請求建立 block 傳輸管道 chnnel 上傳資料

5、在上傳是 datanode 會與其他的機器建立連線並把資料塊傳送到其他的機器上

6、dataNode 向 namenode 彙報自己的儲存情況以及自己的資訊

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

3-2）mr的工作原理

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

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

3、jobClick會去HDFS端複製作業的資原始檔

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

5、Namenode的jobTracker會去初始化建立的物件

6、Namenode會獲取hdfs的劃分的分割槽

7、Namenode去檢查TaskTracker的心跳資訊，檢視存活的機器

8、當執行的datenode執行任務時Datenode會去HDFS獲取作業的資源的檔案

9、TaskTracker會去執行程式碼，並登陸JVM的執行渠道

10、JVM或執行MapTask或者ReduceTask

11、執行終結

3-3）怎樣判斷檔案時候存在

這是Linux上的知識，只需要在IF[ -f ] 括號中加上-f引數即可判斷檔案是否存在

3-4）fsimage和edit的區別？

大家都知道namenode加拿大28原始碼軟體下載【大神原始碼論壇】dsluntan.com  【布丁原始碼論壇】budingbbs.com 企娥3393756370 與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的步驟

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

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

2、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的優化

1、優化的思路可以從配置檔案和系統以及程式碼的設計思路來優化

2、配置檔案的優化：調節適當的引數，在調引數時要進行測試

3、程式碼的優化：combiner的個數儘量與reduce的個數相同，資料的型別保持一致，可以減少拆包與封包的進度

4、系統的優化：可以設定linux系統開啟最大的檔案數預計網路的頻寬MTU的配置

5、為 job 新增一個 Combiner，可以大大的減少shuffer階段的maoTask拷貝過來給遠端的   reduce task的資料量，一般而言combiner與reduce相同。

6、在開發中儘量使用stringBuffer而不是string，string的模式是read-only的，如果對它進行修改，會產生臨時的物件，二stringBuffer是可修改的，不會產生臨時物件。

7、修改一下配置：

一下是修改 mapred-site.xml 檔案

修改最大槽位數

槽位數是在各個 tasktracker 上的 mapred-site.xml 上設定的，預設都是 2

<property>

<name>mapred.tasktracker.map.tasks.maximum</name>

task 的最大數

<value>2</value>

</property>

<property>

<name>mapred.tasktracker.reduce.tasks.maximum</name>

ducetask 的最大數

<value>2</value>

</property>

調整心跳間隔

叢集規模小於 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 為例：

<property>

<name>mapred.compress.map.output</name>

<value>true</value>

</property>

<property>

<name>mapred.map.output.compression.codec</name>

<value>org.apache.hadoop.io.compress.SnappyCodec</value>

</property>

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

這個 datanode 的資料會在其他的 datanode 上重新做備份。

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

在mapreduce中map是有塊的大小來決定的，reduce的數量可以按照使用者的業務來配置。

3-37）兩個檔案合併的問題

    主要的思想是把檔案分開進行計算，在對每個檔案進行對比，得出相同的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的序列化

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

2、Java的序列化是講物件的內容進行流化

3、實現序列化需要實現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儲存元資料的方式以及各有什麼特點？

1、Hive有記憶體資料庫derby資料庫，特點是儲存資料小，不穩定

2、mysql資料庫，儲存方式可以自己設定，持久化好，一般企業開發都用mysql做支撐

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

1、外部表不會載入到hive中只會有一個引用加入到元資料中

2、在刪除時不會刪除表，只會刪除元資料，所以不必擔心資料的

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雜湊原則加拿大28原始碼軟體下載【大神原始碼論壇】dsluntan.com  【布丁原始碼論壇】budingbbs.com 企娥3393756370  、 Rowkey唯一原則 、 針對事務資料Rowkey設計 、 針對統計資料的Rowkey設計 、 針對通用資料的Rowkey設計、 支援多條件查詢的RowKey設計。 

總結設計列族：

1、一般不建議設計多個列族

2、資料塊的快取的設計

3、激進快取設計

4、布隆過濾器的設計(可以提高隨機讀取的速度)

5、生產日期的設計

6、列族壓縮

7、單元時間版本

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的查詢實現只提供兩種方式： 1、按指定RowKey獲取唯一一條記錄，get方法（org.apache.hadoop.hbase.client.Get） 2、按指定的條件獲取一批記錄，scan方法（org.apache.hadoop.hbase.client.Scan） 實現條件查詢功能使用的就是scan方式

      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太大時分佈會不均衡，同時對於大批量的代入資料建議如下：

1、還是必須讓業務方對rowkey進行預分片，對業務資料rowkey進行md5或者其他的hash策略，讓資料儘量隨機分佈而不是順序寫入。

2、隨時觀察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.....目錄下有多少個分割槽，每個分割槽的儲存格式是什麼樣的？

1、topic 是按照“主題名-分割槽”儲存的

2、分割槽個數由配置檔案決定

3、每個分割槽下最重要的兩個檔案是 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 <console>:22

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

res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at <console>: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 <console>: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 <console>: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)你在專案中遇到了哪些難題，是怎麼解決的？

1、在執行任務時發現副本的個數不對，經過一番的查詢發現是超時的原因，修改了配置檔案hdfs-site.xml：中修改了超時時間。

2、由於當時在分配各個目錄空間大小時，沒有很好的分配導致有的目錄的空間浪費，於是整體商量後把儲存的空間調大了一些。加拿大28原始碼軟體下載【大神原始碼論壇】dsluntan.com  【布丁原始碼論壇】budingbbs.com 企娥3393756370 

設計題

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中