1.從前到後從你教育背景(學過哪些課)到各個專案你負責的模組,問的很細(本以為他是物理學博士,但是所有的技術都懂)
2.hadoop 的 namenode 宕機,怎麼解決
先分析宕機後的損失，宕機後直接導致client無法訪問，記憶體中的元資料丟失，但是硬碟中的元資料應該還存在，如果只是節點掛了，
重啟即可，如果是機器掛了，重啟機器後看節點是否能重啟，不能重啟就要找到原因修復了。但是最終的解決方案應該是在設計叢集的初期
就考慮到這個問題，做namenode的HA。
3.一個datanode 宕機,怎麼一個流程恢復
Datanode宕機了後，如果是短暫的宕機，可以實現寫好指令碼監控，將它啟動起來。如果是長時間宕機了，那麼datanode上的資料應該已經
被備份到其他機器了，那這臺datanode就是一臺新的datanode了，刪除他的所有資料檔案和狀態檔案，重新啟動。
4.Hbase 的特性,以及你怎麼去設計 rowkey 和 columnFamily ,怎麼去建一個table
因為hbase是列式資料庫，列非表schema的一部分，所以在設計初期只需要考慮rowkey 和 columnFamily即可，rowkey有位置相關性，所以
如果資料是練習查詢的，最好對同類資料加一個字首，而每個columnFamily實際上在底層是一個檔案，那麼檔案越小，查詢越快，所以講經
常一起查詢的列設計到一個列簇，但是列簇不宜過多。
5.Redis,傳統資料庫,hbase,hive 每個之間的區別(問的非常細)
Redis是快取，圍繞著記憶體和快取說
Hbase是列式資料庫，存在hdfs上，圍繞著資料量來說
Hive是資料倉庫，是用來分析資料的，不是增刪改查資料的。
6.公司之後傾向用spark 開發,你會麼(就用java程式碼去寫)
會，spark使用scala開發的，在scala中可以隨意使用jdk的類庫，可以用java開發，但是最好用原生的scala開發，相容性好，scala更靈活。

10. 面試問題:
1.筆試: java基礎(基本全忘,做的很爛,複習大資料連單例都忘了怎麼寫)
複習java面試寶典
2.開始介紹專案,直接用大資料專案介紹,專案經理也懂大資料
3.Mapreduce 一些流程,經過哪些步驟
Map—combiner—partition—sort—copy—sort—grouping—reduce
4.說下對hadoop 的一些理解,包括哪些元件
詳談hadoop的應用，包括的元件分為三類，分別說明hdfs，yarn，mapreduce
5.詳細講解下你流式實時計算的專案部署以及收集的結果情況
講解storm叢集的部署方案，專案的大小，使用的worker數，資料收集在hbase或者hdfs，好處是什麼
6.你的資料庫是不是很大麼,有沒有分表,分割槽,你是怎麼實現的
資料庫的分表在設計初期是按照月份進行拆分的，不同的月份查詢不同的表。分割槽沒弄過。
7.開始問java的一些東西(從各種框架原理到各種複雜SQL)
8.多執行緒,併發,垃圾回收機制,資料結構(問這些,基本覺得看你是不是高階程式設計師了)
多執行緒要知道操作方式，執行緒安全的鎖，並且要知道lock鎖
垃圾回收機制需要詳細瞭解（見雲筆記），主要從記憶體劃分，垃圾回收主要的工作區域，垃圾回收器的種類，各有什麼優缺點，
用在哪裡合適。
資料結構基本的要知道，複雜的參考相關的書籍。

11. 面試問題:
1.BI小組的3個年輕學生一起技術面試(一個是南開博士）
2.資料量多少,叢集規模多大,型號
一般中型的電商或者網際網路企業，日誌量每天在200-500M左右，叢集規模在30-50臺左右，機器一般為dell的2000左右的伺服器，型號不定
大型的網際網路公司據網上資料顯示，日誌量在GP-PB不等，叢集規模在500-4000不等，甚至更多，機器型號不確定。
3.專案,mapreduce
介紹整個mapreduce專案流程，資料採集—資料聚合—資料分析—資料展示等
4.實時流式計算框架,幾個人,多長時間,細節問題,包括講flume ,kafka ,storm 的各個的元件組成,你負責那一塊,如果需要你搭建你可以
完成麼?
5.你覺得spark 可以完全替代hadoop 麼? 

12. 面試問題:
1.一些傳統的hadoop 問題,mapreduce 他就問shuffle 階段,你怎麼理解的
Shuffle意義在於將不同map處理後的資料進行合理分配，讓reduce處理，從而產生了排序、分割槽。
2.Mapreduce 的 map 數量 和 reduce 數量 怎麼確定 ,怎麼配置
Map無法配置，reduce隨便配置
3.唯一難住我的是他說實時計算,storm 如果碰上了複雜邏輯,需要算很長的時間,你怎麼去優化
拆分複雜的業務到多個bolt中，這樣可以利用bolt的tree將速度提升
4.Hive 你們用的是外部表還是內部表,有沒有寫過UDF(當然吹自己寫過了),hive 的版本
外部表，udf，udaf等，hive版本為1.0
5.Hadoop 的版本 
如果是1.0版本就說1.2，如果是2.0版本，就說2.6或者2.7
1.2為官方穩定版本，2.7為官方穩定版本。
Apache Hadoop 2.7.1於美國時間2015年07月06日正式釋出，本版本屬於穩定版本，是自Hadoop 2.6.0以來又一個穩定版，同時也是
Hadoop 2.7.x版本線的第一個穩定版本，也是 2.7版本線的維護版本，變化不大，主要是修復了一些比較嚴重的Bug
6.實時流式計算的結果內容有哪些,你們需要統計出來麼(我就說highchart展示)
簡單介紹日誌監控、風控等結果內容，統計出來顯示在報表或者郵件中。
7.開始問java相關,包括luecne,solr(倒排索引的原理),框架呀,redis呀

13. 京東商城 - 大資料
 

（1）Java篇
1、JVM，GC（演算法，新生代，老年代），JVM結構
2、hashcode，hashMap，list，hashSet，equals（結構原理），A extends  B（類的載入順序）
1.父類靜態程式碼塊；
2.子類靜態程式碼塊；
3.父類非靜態程式碼塊；
4.父類建構函式；
5.子類非靜態程式碼塊；
6.子類建構函式；
3、多執行緒，主執行緒，次執行緒，喚醒，睡眠
略
4、常見演算法：冒泡演算法，排序演算法，二分查詢，時間複雜度
略
（2）Flume篇
1、資料怎麼採集到Kafka，實現方式
使用官方提供的flumeKafka外掛，外掛的實現方式是自定義了flume的sink，將資料從channle中取出，通過kafka的producer寫入到kafka中，
可以自定義分割槽等。
2、flume管道記憶體，flume宕機了資料丟失怎麼解決
1、Flume的channel分為很多種，可以將資料寫入到檔案
2、防止非首個agent宕機的方法數可以做叢集或者主備
3、flume配置方式，flume叢集（問的很詳細）
Flume的配置圍繞著source、channel、sink敘述，flume的叢集是做在agent上的，而非機器上。
4、flume不採集Nginx日誌，通過Logger4j採集日誌，優缺點是什麼？
優點：Nginx的日誌格式是固定的，但是缺少sessionid，通過logger4j採集的日誌是帶有sessionid的，而session可以通過redis共享，
保證了叢集日誌中的同一session落到不同的tomcat時，sessionId還是一樣的，而且logger4j的方式比較穩定，不會宕機。
缺點：不夠靈活，logger4j的方式和專案結合過於緊密，而flume的方式比較靈活，拔插式比較好，不會影響專案效能。
5、flume和kafka採集日誌區別，採集日誌時中間停了，怎麼記錄之前的日誌。
Flume採集日誌是通過流的方式直接將日誌收集到儲存層，而kafka試講日誌快取在kafka叢集，待後期可以採集到儲存層。
Flume採集中間停了，可以採用檔案的方式記錄之前的日誌，而kafka是採用offset的方式記錄之前的日誌。
（3）Kafka篇
1、容錯機制
分割槽備份，存在主備partition
2、同一topic不同partition分割槽
？？？？
3、kafka資料流向
Producer  leader partition  follower partition(半數以上) consumer
4、kafka+spark-streaming結合丟資料怎麼解決？

spark streaming從1.2開始提供了資料的零丟失，想享受這個特性，需要滿足如下條件：

1. 資料輸入需要可靠的sources和可靠的receivers

2. 應用metadata必須通過應用driver checkpoint

3. WAL（write ahead log）

1.1. 可靠的sources和receivers

spark streaming可以通過多種方式作為資料sources（包括kafka），輸入資料通過receivers接收，通過replication儲存於spark中（為了faultolerance，預設複製到兩個spark executors），如果資料複製完成，receivers可以知道（例如kafka中更新offsets到zookeeper中）。這樣當receivers在接收資料過程中crash掉，不會有資料丟失，receivers沒有複製的資料，當receiver恢復後重新接收。

1.2. metadata checkpoint

可靠的sources和receivers，可以使資料在receivers失敗後恢復，然而在driver失敗後恢復是比較複雜的，一種方法是通過checkpoint metadata到HDFS或者S3。metadata包括：

· configuration

· code

· 一些排隊等待處理但沒有完成的RDD（僅僅是metadata，而不是data）

這樣當driver失敗時，可以通過metadata checkpoint，重構應用程式並知道執行到那個地方。

1.3. 資料可能丟失的場景

可靠的sources和receivers，以及metadata checkpoint也不可以保證資料的不丟失，例如：

· 兩個executor得到計算資料，並儲存在他們的記憶體中

· receivers知道資料已經輸入

· executors開始計算資料

· driver突然失敗

· driver失敗，那麼executors都會被kill掉

· 因為executor被kill掉，那麼他們記憶體中得資料都會丟失，但是這些資料不再被處理

· executor中的資料不可恢復

1.4. WAL

為了避免上面情景的出現，spark streaming 1.2引入了WAL。所有接收的資料通過receivers寫入HDFS或者S3中checkpoint目錄，這樣當driver失敗後，executor中資料丟失後，可以通過checkpoint恢復。

1.5. At-Least-Once

儘管WAL可以保證資料零丟失，但是不能保證exactly-once，例如下面場景：

· Receivers接收完資料並儲存到HDFS或S3

· 在更新offset前，receivers失敗了

· Spark Streaming以為資料接收成功，但是Kafka以為資料沒有接收成功，因為offset沒有更新到zookeeper

· 隨後receiver恢復了

· 從WAL可以讀取的資料重新消費一次，因為使用的kafka High-Level消費API，從zookeeper中儲存的offsets開始消費

1.6. WAL的缺點

通過上面描述，WAL有兩個缺點：

· 降低了receivers的效能，因為資料還要儲存到HDFS等分散式檔案系統

· 對於一些resources，可能存在重複的資料，比如Kafka，在Kafka中存在一份資料，在Spark Streaming也存在一份（以WAL的形式儲存在hadoop API相容的檔案系統中）

1.7. Kafka direct API

為了WAL的效能損失和exactly-once，spark streaming1.3中使用Kafka direct API。非常巧妙，Spark driver計算下個batch的offsets，指導executor消費對應的topics和partitions。消費Kafka訊息，就像消費檔案系統檔案一樣。

1. 不再需要kafka receivers，executor直接通過Kafka API消費資料

2. WAL不再需要，如果從失敗恢復，可以重新消費

3. exactly-once得到了保證，不會再從WAL中重複讀取資料

1.8. 總結

主要說的是spark streaming通過各種方式來保證資料不丟失，並保證exactly-once，每個版本都是spark streaming越來越穩定，越來越向生產環境使用發展。

5、kafka中儲存目錄data/dir.....topic1和topic2怎麼儲存的，儲存結構，data.....目錄下有多少個分割槽，每個分割槽的儲存格式是什麼樣的？
1、topic是按照“主題名-分割槽”儲存的
2、分割槽個數由配置檔案決定
3、每個分割槽下最重要的兩個檔案是0000000000.log和000000.index，0000000.log以預設1G大小回滾。
（4）Hive篇
1、hive partition分割槽
分割槽表，動態分割槽
2、insert into 和 override write區別？
insert into：將某一張表中的資料寫到另一張表中
override write：覆蓋之前的內容。
3、假如一個分割槽的資料主部錯誤怎麼通過hivesql刪除hdfs
alter table ptable drop partition (daytime='20140911',city='bj');
元資料，資料檔案都刪除，但目錄daytime= 20140911還在
（5）Storm篇         
 1、開發流程，容錯機制
開發流程：
1、寫主類（設計spout和bolt的分發機制）
2、寫spout收集資料
3、寫bolt處理資料，根據資料量和業務的複雜程度，設計並行度。
容錯機制：採用ack和fail進行容錯，失敗的資料重新發送。
2、storm和spark-streaming：為什麼用storm不同spark-streaming
3、mr和spark區別，怎麼理解spark-rdd
Mr是檔案方式的分散式計算框架，是將中間結果和最終結果記錄在檔案中，map和reduce的資料分發也是在檔案中。
spark是記憶體迭代式的計算框架，計算的中間結果可以快取記憶體，也可以快取硬碟，但是不是每一步計算都需要快取的。
Spark-rdd是一個數據的分割槽記錄集合………………

4、sqoop命令

sqoop import --connect jdbc:mysql://192.168.56.204:3306/sqoop --username hive --password hive --table jobinfo --target-dir /sqoop/test7 --inline-lob-limit 16777216 --fields-terminated-by '\t' -m 2

sqoop create-hive-table --connect jdbc:mysql://192.168.56.204:3306/sqoop --table jobinfo --username hive --password hive --hive-table sqtest --fields-terminated-by "\t" --lines-terminated-by "\n";

（6）Redis篇
1、基本操作，儲存格式
略
（7）Mysql篇
1、mysql叢集的分散式事務
京東自主開發分散式MYSQL集群系統
2、mysql效能優化（資料方面）
資料的分表、分庫、分割槽
（6）Hadoop篇
1、hadoop HA  兩個namenode和zk之間的通訊，zk的選舉機制？
HA是通過先後獲取zk的鎖決定誰是主
Zk的選舉機制，涉及到全新機群的選主和資料恢復的選主

2、mr執行機制

3、yarn流程

1) 使用者向YARN 中提交應用程式， 其中包括ApplicationMaster 程式、啟動ApplicationMaster 的命令、使用者程式等。
2) ResourceManager 為該應用程式分配第一個Container， 並與對應的NodeManager 通訊，要求它在這個Container 中啟動應用程式
的ApplicationMaster。
3) ApplicationMaster 首先向ResourceManager 註冊， 這樣使用者可以直接通過ResourceManage 檢視應用程式的執行狀態，然後它將
為各個任務申請資源，並監控它的執行狀態，直到執行結束，即重複步驟4~7。
4) ApplicationMaster 採用輪詢的方式通過RPC 協議向ResourceManager 申請和領取資源。
5) 一旦ApplicationMaster 申請到資源後，便與對應的NodeManager 通訊，要求它啟動任務。
6) NodeManager 為任務設定好執行環境（包括環境變數、JAR 包、二進位制程式等）後，將任務啟動命令寫到一個指令碼中，並通過執行
該指令碼啟動任務。
7) 各個任務通過某個RPC 協議向ApplicationMaster 彙報自己的狀態和進度，以讓ApplicationMaster 隨時掌握各個任務的執行狀態，
從而可以在任務失敗時重新啟動任務。在應用程式執行過程中，使用者可隨時通過RPC 向ApplicationMaster 查詢應用程式的當前執行狀態。
8) 應用程式執行完成後，ApplicationMaster 向ResourceManager 登出並關閉自己。
（7）Hbase
1、涉及到概念，文件
（8）Spark篇
1、spark原理  

Spark應用轉換流程

1、 spark應用提交後，經歷了一系列的轉換，最後成為task在每個節點上執行

2、 RDD的Action運算元觸發Job的提交，生成RDD DAG

3、 由DAGScheduler將RDD DAG轉化為Stage DAG，每個Stage中產生相應的Task集合

4、 TaskScheduler將任務分發到Executor執行

5、 每個任務對應相應的一個數據塊，只用使用者定義的函式處理資料塊

Driver執行在Worker上

   通過org.apache.spark.deploy.Client類執行作業，作業執行命令如下：

作業執行流程描述：

1、客戶端提交作業給Master

2、Master讓一個Worker啟動Driver，即SchedulerBackend。Worker建立一個DriverRunner執行緒，DriverRunner啟動SchedulerBackend程序。

3、另外Master還會讓其餘Worker啟動Exeuctor，即ExecutorBackend。Worker建立一個ExecutorRunner執行緒，ExecutorRunner會啟動ExecutorBackend程序。

4、ExecutorBackend啟動後會向Driver的SchedulerBackend註冊。SchedulerBackend程序中包含DAGScheduler，它會根據使用者程式，生成執行計劃，並排程執行。對於每個stage的task，都會被存放到TaskScheduler中，ExecutorBackend向SchedulerBackend彙報的時候把TaskScheduler中的task排程到ExecutorBackend執行。

5、所有stage都完成後作業結束。

Driver執行在客戶端

作業執行流程描述：

1、客戶端啟動後直接執行使用者程式，啟動Driver相關的工作：DAGScheduler和BlockManagerMaster等。

2、客戶端的Driver向Master註冊。

3、Master還會讓Worker啟動Exeuctor。Worker建立一個ExecutorRunner執行緒，ExecutorRunner會啟動ExecutorBackend程序。

4、ExecutorBackend啟動後會向Driver的SchedulerBackend註冊。Driver的DAGScheduler解析作業並生成相應的Stage，每個Stage包含的Task通過TaskScheduler分配給Executor執行。

5、所有stage都完成後作業結束。

 
1.在Hadoop中定義的主要公用InputFormat中，預設是哪一個？（A）
 

A、 TextInputFormat

B、 KeyValueInputFormat

C、 SequenceFileInputFormat

1. 下面哪個程式負責 HDFS 資料儲存？（C）
 

A.NameNode

B.JobTracker

C.DataNode

D.SecondaryNameNode

E.tasktracker

2.HDFS 中的 block 預設儲存幾份？（A）
 

A.3 份

B.2 份

C.1 份

D.不確定

3.下列哪個程式通常與 NameNode 在一個節點啟動？（D）
 

A.SecondaryNameNode

B.DataNode

C.TaskTracker

D.JobTracker

hadoop的叢集是基於master/slave模式，namenode和jobtracker屬於master，datanode和tasktracker屬於slave，master只有一個，而slave有多個.

SecondaryNameNode記憶體需求和NameNode在一個數量級上，所以通常secondary NameNode（執行在單獨的物理機器上）和 NameNode 執行在不同的機器上。

JobTracker對應於NameNode,TaskTracker對應於DataNode.

DataNode和NameNode是針對資料存放來而言的.JobTracker和TaskTracker是對於MapReduce執行而言的.

mapreduce中幾個主要概念，mapreduce 整體上可以分為這麼幾條執行線索：

jobclient，JobTracker與TaskTracker。

1、JobClient會在使用者端通過JobClient類將已經配置引數打包成jar檔案的應用儲存到hdfs，並把路徑提交到Jobtracker,然後由JobTracker建立每一個Task（即 MapTask 和 ReduceTask） 並將它們分發到各個TaskTracker服務中去執行。

2、JobTracker是一master服務，軟體啟動之後JobTracker接收Job，負責排程Job的每一個子任務。task運行於TaskTracker上，並監控它們，如果發現有失敗的task就重新執行它。一般情況應該把JobTracker 部署在單獨的機器上。

3、TaskTracker是執行在多個節點上的slaver服務。TaskTracker主動與JobTracker通訊，接收作業，並負責直接執行每一個任務。 TaskTracker 都需要執行在HDFS的DataNode上。

4.關於 SecondaryNameNode 哪項是正確的？（C）
 

A.它是 NameNode 的熱備

B.它是記憶體沒有要求

C.他的目的使幫助 NameNode 合併編輯日誌，減少 NameNode 啟動時間

D. SecondaryNameNode 應與 NameNode 部署到一個節點

HDFS 預設 BlockSize 是2.0版本128M，之前低版本64M。
 

下列哪項通常是叢集的最主要瓶頸（C）
A.CPU

B.網路

C.磁碟 IO

D.記憶體

1. 下列哪項可以作為叢集的管理？（ABC）
 

A.Puppet

B.Pdsh

C.ClouderaManager

D.Zookeeper

2.Client 端上傳檔案的時候下列哪項正確？（BC）
 

A.資料經過 NameNode 傳遞 DataNode

B.Client 端將檔案切分為 Block，依次上傳

C.Client 只上傳資料到一臺 DataNode，然後由 NameNode 負責 Block 複製工作

3.下列哪個是 Hadoop 執行的模式？（ABC）
 

A.單機版

B.偽分散式

C.分散式

1.列舉幾個hadoop生態圈的元件並做簡要描述
 

Zookeeper:是一個開源的分散式應用程式協調服務,基於zookeeper可以實現同步服務，配置維護，命名服務。

Flume:一個高可用的，高可靠的，分散式的海量日誌採集、聚合和傳輸的系統。

Hbase:是一個分散式的、面向列的開源資料庫, 利用Hadoop HDFS作為其儲存系統.

Hive:基於Hadoop的一個數據倉庫工具，可以將結構化的資料檔對映為一張資料庫表，並提供簡單的sql 查詢功能，可以將sql語句轉換為MapReduce任務進行執行。

Sqoop:將一個關係型資料庫中的資料導進到Hadoop的 HDFS中，也可以將HDFS的資料導進到關係型資料庫中。

Hadoop中需要哪些配置檔案，其作用是什麼？
 

1>.Core-site.xml：

(1)fs.defaultFS:hdfs://cluster1(域名)，這裡的值指的是預設的HDFS路徑 。

(2)hadoop.tmp.dir:/export/data/hadoop_tmp,這裡的路徑預設是NameNode、DataNode、JournalNode等存放資料的公共目錄。使用者也可以自己單獨指定這三類節點的目錄。

(3)ha.zookeeper.quorum:hadoop101:2181,hadoop102:2181,hadoop103:2181,這裡是ZooKeeper叢集的地址和埠。注意，數量一定是奇數，且不少於三個節點 。

2>.Hadoop-env.sh: 只需設定jdk的安裝路徑，如：export JAVA_HOME=/usr/local/jdk 本機j位置 

3>.Hdfs-site.xml：

(1) dfs.replication:他決定著系統裡面的檔案塊的資料備份個數，預設為3個。

(2) dfs.data.dir:datanode節點儲存在檔案系統的目錄 。

(3) dfs.name.dir:是namenode節點儲存hadoop檔案系統資訊的本地系統路徑 。

4>.Mapred-site.xml：

(1)mapred.job.tracker:是jobtracker的主機和埠配置 。

4. 請列出正常工作的Hadoop叢集中Hadoop都分別需要啟動哪些程序，它們的作用分別是什麼?
 

a) NameNode它是hadoop中的主伺服器，管理檔案系統名稱空間和對叢集中儲存的檔案的訪問，儲存有 metadate.

b).SecondaryNameNode它不是namenode的冗餘守護程序，而是提供週期檢查點和清理任務。幫助NN合併editslog，減少NN啟動時間。

c)DataNode它負責管理連線到節點的儲存（一個叢集中可以有多個節點）。每個存

儲資料的節點執行一個datanode守護程序。

d)ResourceManager（JobTracker）JobTracker負責排程DataNode上的工作。每個DataNode有一個TaskTracker，它們執行實際工作。

e) NodeManager（TaskTracker）執行任務

f) DFSZKFailoverController高可用時它負責監控NN的狀態，並及時的把狀態資訊寫入ZK。它通過一個獨立執行緒週期性的呼叫NN上的一個特定介面來獲取NN的健康狀態。FC也有選擇誰作為Active NN的權利，因為最多隻有兩個節點，目前選擇策略還比較簡單（先到先得，輪換）。

g) JournalNode 高可用情況下存放namenode的editlog檔案.

HDFS資料寫入實現機制
3. HDFS的儲存機制？

寫入HDFS過程：

Client呼叫DistributedFileSystem物件的create方法，建立一個檔案輸出流（FSDataOutputStream）物件，通過DistributedFileSystem物件與Hadoop叢集的NameNode進行一次RPC遠端呼叫，在HDFS的Namespace中建立一個檔案條目（Entry），該條目沒有任何的Block，通過FSDataOutputStream物件，向DataNode寫入資料，資料首先被寫入FSDataOutputStream物件內部的Buffer中，然後資料被分割成一個個Packet資料包，以Packet最小單位，基於Socket連線傳送到按特定演算法選擇的HDFS叢集中一組DataNode（正常是3個，可能大於等於1）中的一個節點上，在這組DataNode組成的 Pipeline上依次傳輸 Packet， 這組 DataNode 組成的 Pipeline反方向上，傳送 ack，最終由 Pipeline 中第一個 DataNode 節點將 Pipeline ack傳送給Client，完成向檔案寫入資料，Client 在檔案輸出流（FSDataOutputStream）物件上呼叫close方法，關閉流.呼叫DistributedFileSystem物件的complete 方法，通知 NameNode 檔案寫入成功.

讀取檔案過程：

使用HDFS提供的客戶端開發庫Client，向遠端的Namenode發起RPC請求；Namenode會視情況返回檔案的部分或全部block列表，對於每個block，Namenode都會返回有該block拷貝的DataNode地址；客戶端開發庫Client會選取離客戶端最接近的DataNode來讀取block；如果客戶端本身就是DataNode,那麼將從本地直接獲取資料.讀取完當前block的資料後，關閉與當前的DataNode連線，併為讀取下一個block尋找最佳的DataNode；當讀完列表的block後，且檔案讀取還沒有結束，客戶端開發庫會繼續向Namenode獲取下一批的block列表。讀取完一個block都會進行 checksum 驗證，如果讀取 datanode 時出現錯誤，客戶端會通知 Namenode，然後再從下一個擁有該 block 拷貝的 datanode 繼續讀。

2.HDFS的儲存機制是什麼
 

客戶端通過把請求傳送給NameNode active，NN會把檔案切成1個到N個固定大小的block（一般預設為128M）並上傳到DN中。當所有block拷貝結束時，NN會立即通知客戶端上傳結果。但此時上傳的流程還未結束。DN還需要根據配置資訊的副本數量，在不同的機架節點上通過區域網作資料拷貝工作。

6Hadoop 是由哪幾個元件組成

hadoop 是一套處理大資料的生態系統，包括檔案儲存HDFS ，計算框架MapReduce排程框架Yarn，資料庫Hbase ，資料倉庫Hive，協調與鎖服務zookeeper，關係型數 據庫與Hbase轉換工具sqoop，工作流模組Oozie,機器學習模組mahout.

1.6 hadoop 節點動態上線下線怎麼操作?
 

節點上線操作：

當要新上線資料節點的時候，需要把資料節點的名字追加在 dfs.hosts 檔案中

一，關閉新增節點的防火牆

二，在 NameNode 節點的 hosts 檔案中加入新增資料節點的 hostname

三，在每個新增資料節點的 hosts 檔案中加入 NameNode 的 hostname

四，在 NameNode 節點上增加新增節點的 SSH 免密碼登入的操作

五，在 NameNode 節點上的 dfs.hosts 中追加上新增節點的 hostname,

六，在其他節點上執行重新整理操作：hdfs dfsadmin -refreshNodes

七，在 NameNode 節點上，更改 slaves 檔案，將要上線的資料節點 hostname 追加

到 slaves 檔案中

八，啟動 DataNode 節點

九，檢視 NameNode 的監控頁面看是否有新增加的節點

節點下線操作：

一，修改/conf/hdfs-site.xml 檔案

二，確定需要下線的機器，dfs.osts.exclude 檔案中配置好需要下架的機器，這個是阻

止下架的機器去連線 NameNode

三，配置完成之後進行配置的重新整理操作./bin/hadoop dfsadmin -refreshNodes,這個

操作的作用是在後臺進行 block 塊的移動

四，當執行三的命令完成之後，需要下架的機器就可以關閉了，可以檢視現在集

群上連線的節點，正在執行 Decommission，會顯示：

Decommission Status : Decommission in progress 執行完畢後，會顯示：

Decommission Status : Decommissioned

五，機器下線完畢，將他們從 excludes 檔案中移除。

10.Hadoop 中 job 和 task 之間的區別是什麼？
 

JobTracker 是一個 master 服務，軟體啟動之後 JobTracker 接收 Job，負責排程 Job

的每一個子任務 task 運行於 TaskTracker 上，並監控它們，如果發現有失敗的 task 就重新

執行它。一般情況應該把 JobTracker 部署在單獨的機器上。

TaskTracker 是執行在多個節點上的 slaver 服務。TaskTracker 主動與 JobTracker 通訊，

接收作業，並負責直接執行每一個任務11.Hadoop 中通過拆分任務到多個節點執行來實現並行計

算，但某些節點執行較慢會拖慢整個任務的執行，Hadoop

採用何種機制應對這個情況？

答: 推測執行機制是 Hadoop 對“拖後腿”的任務的一種優化機制，當一個作業的某些任務

執行速度明顯慢於同作業的其他任務時，Hadoop 會在另一個節點 上為“慢任務”啟動一

個備份任務，這樣兩個任務同時處理一份資料，而 Hadoop 最終會將優先完成的那個任務

的結果作為最終結果，並將另一個任務殺掉。

2. mapred.job.tracker 命令的作用
連線jobtrack伺服器的配置項，預設不寫是local，在本地執行，預設 map 數1，reduce數1。

7 如何決定一個job的map和reduce的數量?
splitSize=max{minSize,min{maxSize,blockSize}}

map數量由處理的資料分成的block數量決定default_num = total_size / split_size;

reduce的數量job.setNumReduceTasks(x);x 為reduce的數量.

14.如何為一個Hadoop任務設定mappers的數量？
 

具體的資料分片是這樣的，InputFormat在預設情況下會根據hadoop叢集HDFS塊大小進行分片，每一個分片會由一個map任務來進行處理，當然使用者還是可以通過引數mapred.min.split.size引數在作業提交客戶端進行自定義設定。還有一個重要引數就是mapred.map.tasks，這個引數設定的map數量僅僅是一個提示，只有當InputFormat決定了map任務的個數比mapred.map.tasks值小時才起作用。同樣，Map任務的個數也能通過使用JobConf的conf.setNumMapTasks(int num)方法來手動地設定。這個方法能夠用來增加map任務的個數，但是不能設定任務的個數小於Hadoop系統通過分割輸入資料得到的值。

15.如何為一個Hadoop任務設定要建立的 reducer的數量？
純粹的 mapreduce task 的 reduce task 數很簡單，就是引數 mapred.reduce.tasks

的值，hadoop-site.xml 檔案中和 mapreduce job 執行時。不設定的話預設為 1。

10 yarn 的新特性
 

ResourceManager HA：在apache hadoop 4.4 或者CDH5.0.0 版本之後，增加了ResourceMangerHA 特性，支援基於Zookeeper 的熱主備切換。

磁碟容錯：增加了幾個對多磁碟非常友好地引數，這些引數允許YARN 更好地使用NodeManager 上的多塊磁碟.

資源排程器：Fair Scheduler 增加了允許使用者線上將一個應用程式從一個佇列轉移到另外一個佇列。

11 如何使用mapReduce實現兩個表的join?
 

reduce side join : 在map 階段，map 函式同時讀取兩個檔案File1 和File2，為了區分

兩種來源的key/value 資料對，對每條資料打一個標籤（tag）,比如：tag=0 表示來自檔案File1，

tag=2 表示來自檔案File2。

map side join : Map side join 是針對以下場景進行的優化：兩個待連線表中，有一個表非常大，而另一個表非常小，以至於小表可以直接存放到記憶體中。這樣，我們可以將小表複製多份，讓每個map task 記憶體中存在一份（比如存放到hash table 中），然後只掃描大表：對於大表中的每一條記錄key/value，在hash table 中查詢是否有相同的key 的記錄，如果有，

則連線後輸出即可。

Semi Join : Semi Join，也叫半連線，是從分散式資料庫中借鑑過來的方法。它的產生動機是：對於reduce side join，跨機器的資料傳輸量非常大，這成了join 操作的一個瓶頸，

如果能夠在map 端過濾掉不會參加join 操作的資料，則可以大大節省網路IO。

reduce side join + BloomFilter : BloomFilter 最常見的作用是：判斷某個元素是否在一個集合裡面。它最重要的兩個方法是：add() 和contains()。最大的特點是不會存在 falsenegative，即：如果contains()返回false，則該元素一定不在集合中，但會存在一定的 falsepositive，即：如果contains()返回true，則該元素一定可能在集合中。

參考網址：http://my.oschina.net/leejun2005/blog/95186?fromerr=cDqkUyup

8 Hadoop的sequencefile的格式，並說明下什麼是java序列化，如何實現java序列化?
 

SequenceFile檔案是Hadoop用來儲存二進位制形式的key-value 對而設計的一種平面檔案;Hadoop 的HDFS 和MapReduce子框架主要是針對大資料檔案來設計的，在小檔案的處理上不但效率低下，而且十分消耗磁碟空間(每一個小檔案佔用一個Block,HDFS 預設block大小為64M)。

解決辦法通常是選擇一個容器，將這些小檔案組織起來統一儲存。HDFS提供了兩種型別的容器，分別是SequenceFile和MapFile。

SequenceFile的每條記錄是可序列化的字元陣列。

序列化是指將結構化的物件轉化為位元組流以便在網路上傳輸或寫入到磁碟進行永久存 儲的過程，反序列化是指將位元組流轉回結構化物件的過程.

9 簡述hadoop1與hadoop2 的架構異同.
 

加入了yarn 解決了資源排程的問題。

加入了對zookeeper 的支援實現比較可靠的高可用.

http://blog.csdn.net/fenglibing/article/details/32916445

13 請描述mapReduce二次排序原理
 

二次排序:就是首先按照第一欄位排序，然後再對第一欄位相同的行按照第二欄位排序，注意不能破壞第一次排序的結果。

在Hadoop中，預設情況下是按照key進行排序。對於同一個key，reduce函式接收到的value list是按照value 排序的。

有兩種方法進行二次排序，分別為：buffer and in memory sort和value-to-key conversion。

對於buffer and in memory sort，主要思想是：在reduce()函式中，將某個key對應的所有value儲存下來，然後進行排序。 這種方法最大的缺點是：可能會造成 out of memory。

對於value-to-key conversion，主要思想是：將key和部分value拼接成一個組合key（實現WritableComparable介面或者呼叫setSortComparatorClass函式），這樣reduce獲取的結果便是先按key排序，後按value排序的結果，需要注意的是，使用者需要自己實現Paritioner，以便只按照key進行資料劃分。Hadoop顯式的支援二次排序，在Configuration 類中有個 setGroupingComparatorClass()方法，可用於設定排序 group的 key 值。

具體參考：http://www.cnblogs.com/xuxm2007/archive/2011/09/03/2165805.html

參考網址：http://my.oschina.net/leejun2005/blog/95186?fromerr=cDqkUyup

14 請描述mapReduce中排序發生的幾個階段
 

一個是在map side發生在spill後partition前。

一個是在reduce side發生在copy後 reduce前。

mapReduce的四個階段：

Splitting :在進行map 計算之前，mapreduce 會根據輸入檔案計算輸入分片（inputsplit），每個輸入分片（input split）針對一個map 任務。輸入分片（input split）儲存的並非資料本身，而是一個分片長度和一個記錄資料位置的陣列，輸入分片（input split）往往和hdfs 的block（塊）關係很密切，假如我們設定hdfs 的塊的大小是64mb，如果我們輸入有三個檔案，大小分別是3mb、65mb 和127mb，那麼mapreduce 會把3mb 檔案分為一個輸入分片（input split），65mb 則是兩個輸入分片（input split）而127mb 也是兩個輸入分片（input split），換句話說我們如果在map 計算前做輸入分片調整，例如合併小檔案，那麼就會有5 個map 任務將執行，而且每個map 執行的資料大小不均，這個也是mapreduce 優化計算的一個關鍵點。

Mapping:就是程式設計師編寫好的map 函數了，因此map 函式效率相對好控制，而且一般map 操作都是本地化操作也就是在資料儲存節點上進行；

Shuffle:描述著資料從map task 輸出到reduce task 輸入的這段過程。

Reduce:對Map階段多個檔案的資料進行合併。

15 請描述mapReduce中shuffle階段的工作流程，如何優化shuffle階段
 

分割槽，排序，溢寫，拷貝到對應reduce機器上，增加combiner，壓縮溢寫的檔案。

16 請描述mapReduce 中combiner 的作用是什麼，一般使用情景，哪些情況不需要？
 

在MR作業中的Map階段會輸出結果資料到磁碟中。

Combiner只應該適用於那種Reduce的輸入（key：value與輸出（key：value）型別完全一致，且不影響最終結果的場景。比如累加，最大值等，也可以用於過濾資料，在 map端將無效的資料過濾掉。

在這些需求場景下，輸出的資料是可以根據key值來作合併的，合併的目的是減少輸出的資料量，減少IO的讀寫，減少網路傳輸,以提高MR的作業效率。

1.combiner的作用就是在map端對輸出先做一次合併,以減少傳輸到reducer的資料量.

2.combiner最基本是實現本地key的歸併,具有類似本地reduce,那麼所有的結果都是reduce完成,效率會相對降低。

3.使用combiner,先完成的map會在本地聚合,提升速度.

3. 簡述Hadoop的幾個預設埠及其含義
 

dfs.namenode.http-address:50070

dfs.datanode.address:50010

fs.defaultFS:8020

yarn.resourcemanager.webapp.address:8088

5. 談談你對MapReduce的優化建議。
 

一.mapper調優

mapper調優主要就一個目標：減少輸出量。

我們可以通過增加combine階段以及對輸出進行壓縮設定進行mapper調優。

1>combine合併：

    實現自定義combine要求繼承reducer類。比較適合map的輸出是數值型的，方便進行統計。

2>壓縮設定：

    在提交job的時候分別設定啟動壓縮和指定壓縮方式。

二.reducer調優

 reducer調優主要是通過引數調優和設定reducer的個數來完成。

 reducer個數調優：

  要求：一個reducer和多個reducer的執行結果一致，不能因為多個reducer導致執行結果異常。

規則：一般要求在hadoop叢集中的執行mr程式，map執行完成100%後，儘量早的看到reducer執行到33%，可以通過命令hadoop job -status job_id或者web頁面來檢視。

   原因：map的執行process數是通過inputformat返回recordread來定義的；而reducer是有三部分構成的，分別為讀取mapper輸出資料、合併所有輸出資料以及reduce處理，其中第一步要依賴map的執行，所以在資料量比較大的情況下，一個reducer無法滿足效能要求的情況下，我們可以通過調高reducer的個數來解決該問題。

優點：充分利用叢集的優勢。

缺點：有些mr程式沒法利用多reducer的優點，比如獲取top n的mr程式。

hadoop家族如此強大，為什麼還要結合R語言？
 

hadoop和R語言在各自的領域都相當的強大，由RevolutionAnalytics發起的一個開源專案RHadoop將R語言與Hadoop結合在一起，很好發揮了R語言特長。廣大R語言愛好者藉助強大工具RHadoop，可以在大資料領域大展拳腳。

1. Hadoop家族的強大之處，在於對大資料的處理，讓原來的不可能（TB,PB資料量計算），成為了可能。

2.R語言的強大之處，在於統計分析，在沒有Hadoop之前，我們對於大資料的處理，要取樣本，假設檢驗，做迴歸，長久以來R語言都是統計學家專屬的工具。

3. hadoop重點是全量資料分析，而R語言重點是樣本資料分析。 兩種技術放在一起，剛好是取長補短。     4.用R語言，通過分析少量資料，對業務目標迴歸建模，並定義指標，用Hadoop從海量日誌資料中，提取指標資料，用R語言模型，對指標資料進行測試和調優

5.R和Hadoop分別都起著非常重要的作用，以計算機開發人員的思路，所有有事情都用Hadoop去做，沒有資料建模和證明，”預測的結果”一定是有問題的。以統計人員的思路，所有的事情都用R去做，以抽樣方式，得到的“預測的結果”也一定是有問題的。所以讓二者結合，是產界業的必然的導向，也是產界業和學術界的交集，同時也為交叉學科的人才提供了更廣闊的發展空間。

5.Mapreduce的工作原理，請舉例子說明mapreduce是怎麼執行的？
 

離線計算框架，過程分為split map shuffle reduce四個過程 。

架構節點有：Jobtracker TaskTracker 。

Split將檔案分割，傳輸到mapper，mapper接收KV形式的資料，經過處理，再傳到shuffle過程。

Shuffle先進行HashPartition或者自定義的partition，會有資料傾斜和reduce的負載均衡問題；再進行排序，預設按字典排序；為減少mapper輸出資料，再根據key進行合併，相同key的資料value會被合併；最後分組形成（key,value{}）形式的資料，輸出到下一階段 。

Reduce輸入的資料就變成了，key+迭代器形式的資料，再進行處理。

2.兩個類TextInputFormat和KeyValueInputFormat的區別是什麼？
 

相同點：

TextInputformat和KeyValueTextInputFormat都繼承了FileInputFormat類，都是每一行作為一個記錄；

區別：

TextInputformat將每一行在檔案中的起始偏移量作為 key，每一行的內容作為value。預設以\n或回車鍵作為一行記錄。

KeyValueTextInputFormat 適合處理輸入資料的每一行是兩列，並用 tab 分離的形式。

3.在一個執行的 Hadoop 任務中，什麼是 InputSplit？
 

在執行 mapreduce 之前，原始資料被分割成若干個 split，每個 split 作為一個 map

任務的輸入，在 map 執行過程中 split 會被分解成一個個記錄（key-value 對）。

4.Hadoop 框架中檔案拆分是怎麼被呼叫的？
 

InputFormat 是 MapReduce 中一個很常用的概念是檔案拆分必須實現的一個介面，包含了兩個方法：

public interface InputFormat<K, V> {

InputSplit[] getSplits(JobConf job, int numSplits) throws IOException;

RecordReader<K, V> createRecordReader(InputSplit split, TaskAttemptContext

context) throws IOException;

}

這兩個方法分別完成以下工作：

方法 getSplits 將輸入資料切分成 splits，splits 的個數即為 map tasks 的個數，

splits 的大小預設為塊大小，即 64M

方法 getRecordReader 將每個 split 解析成 records, 再依次將 record 解析成

<K,V>對，也就是說 InputFormat 完成以下工作：InputFile --> splits --> <K,V>

系 統 常 用 的 InputFormat 又 有 哪 些 呢 ？ TextFileInputFormat ，

KeyValueTextFileInputFormat，SequenceFileInputFormat<key,value>,

NLineInputFormat 其中 Text InputFormat 便是最常用的，它的 <K,V>就代表 <行偏移,

該行內容>

然而系統所提供的這幾種固定的將 InputFile 轉換為 <K,V>的方式有時候並不能滿足我

們的需求：

此時需要我們自定義 InputFormat ，從而使 Hadoop 框架按照我們預設的方式來將

InputFile 解析為<K,V>

在領會自定義 InputFormat 之前，需要弄懂一下幾個抽象類、介面及其之間的關係：

InputFormat(interface), FileInputFormat(abstract class), TextInputFormat(class),

RecordReader (interface), Line RecordReader(class)的關係FileInputFormat implements InputFormat

TextInputFormat extends FileInputFormat

TextInputFormat.get RecordReader calls Line RecordReader

Line RecordReader implements RecordReader

對於 InputFormat 介面，上面已經有詳細的描述

再看看 FileInputFormat，它實現了 InputFormat 介面中的 getSplits 方法，而將

getRecordReader 與 isSplitable 留給具體類(如 TextInputFormat )實現， isSplitable 方

法通常不用修改，所以只需要在自定義的 InputFormat 中實現

getRecordReader 方 法 即 可 ， 而 該 方 法 的 核 心 是 調 用 Line RecordReader( 即 由

LineRecorderReader 類來實現 " 將每個 s plit 解析成 records, 再依次將 record 解析成

<K,V>對" )，該方法實現了介面 RecordReader

public interface RecordReader<K, V> {

boolean next(K key, V value) throws IOException;

K createKey();

V createValue();

long getPos() throws IOException;

public void close() throws IOException;

float getProgress() throws IOException;

}

定義一個 InputFormat 的核心是定義一個類似於LineRecordReader的RecordReader

5.參考下面的M/R系統的場景：HDFS 塊大小為64MB；輸入型別為FileInputFormat；有三個檔案大小分別是：

64KB65MB 127MB。Hadoop框架會把這些檔案拆分為多少塊？

分別為 1 塊，2 塊，2 塊。

6.Hadoop 中 RecordReader 的作用是什麼?
 

Hadoop 的 MapReduce 框架來處理資料，主要是面向海量大資料，對於這類資料，Hadoop 能夠使其真正發揮其能力。對於海量小檔案，不是說不能使用 Hadoop 來處理，只不過直接進行處理效率不會高，實際應用中，我們在使用 Hadoop 進行計算的時候，需要考慮將小資料轉換成大資料，比如通過合併壓縮等方法，我們通過自定義 InputFormat和RecordReader來實現對海量小檔案的並行處理。

8.如果沒有定義 partitioner，那資料在被送達 reducer 前
是如何被分割槽的？
 

如果沒有自定義的 partitioning，則預設的 partition 演算法，即根據每一條資料的 key

的 hashcode 值摸運算（%）reduce 的數量，得到的數字就是“分割槽號“。

7.Map 階段結束後， Hadoop 框架會處理： Partitioning，Shuffle 和 Sort，在這個階段都發生了什麼？
 

map task上的洗牌（shuffle）結束，此時 reducer task 上的洗牌開始，抓取 fetch 所

屬於自己分割槽的資料，同時將這些分割槽的資料進行排序sort（預設的排序是根據每一條資料的鍵的字典

排序），進而將資料進行合併merge，即根據key相同的，將其 value 組成一個集合，最後輸出結果。

5. 請列出你所知道的Hadoop排程器，並簡要說明其工作方法。
 

（1）預設的排程器 FIFO

Hadoop中預設的排程器，它先按照作業的優先順序高低，再按照到達時間的先後選擇被執行的作業。

（2）計算能力排程器 Capacity Scheduler

支援多個佇列，每個佇列可配置一定的資源量，每個佇列採用FIFO排程策略，為了防止同一個使用者的作業獨佔佇列中的資源，該排程器會對同一使用者提交的作業所佔資源量進行限定。排程時，首先按以下策略選擇一個合適佇列：計算每個佇列中正在執行的任務數與其應該分得的計算資源之間的比值，選擇一個該比值最小的佇列；然後按以下策略選擇該佇列中一個作業：按照作業優先順序和提交時間順序選擇，同時考慮使用者資源量限制和記憶體限制。

（3）公平排程器 Fair Scheduler

同計算能力排程器類似，支援多佇列多使用者，每個佇列中的資源量可以配置，同一佇列中的作業公平共享佇列中所有資源。實際上， Hadoop的排程器遠不止以上三種，最近，出現了很多針對新型應用的Hadoop排程器。

（4）適用於異構叢集的排程器LATE

現有的 Hadoop 排程器都是建立在同構叢集的假設前提下，具體假設如下：

1）叢集中各個節點的效能完全一樣

2）對於 reduce task，它的三個階段：copy、 sort 和 reduce，用時各佔 1/3

3）同一 job 的同類型的 task 是一批一批完成的，他們用時基本一樣。

現有的Hadoop排程器存在較大缺陷，主要體現在探測落後任務的演算法上：如果一個task 的進度落後於同類型 task進度的20%，則把該task當做落後任務(這種任務決定了job的完成時間，需儘量縮短它的執行時間)，從而為它啟動一個備份任務（speculative task）。

如果叢集異構的，對於同一個task，即使是在相同節點上的執行時間也會有較大差別，因而在異構叢集中很容易產生大量的備份任務。

LATE排程器從某種程度上解決了現有排程器的問題，它定義三個閾值 ：

SpeculativeCap，系統中最大同時執行的speculative task 數目（作者推薦值為總slot數的10%）； SlowNodeThreshold（作者推薦值為25%）：得分（分數計算方法見論文）低於該閾值的node（快節點）上不會啟動 speculative task；SlowTaskThreshold（作者推薦值為 25%）：當 task 進度低於同批同類 task 的平均進度的 SlowTaskThreshold 時，會為該 task 啟動 speculative task。它的排程策略是：當一個節點出現空閒資源且系統中總的備份任務數小 於 SpeculativeCap 時， a.如果該節點是慢節點（節點得分高 於SlowNodeThreshold），則忽略這個請求。 b.對當前正在執行的 task 按估算的剩餘完成時間排序 c.選擇剩餘完成時間最大且進度低於 SlowTaskThreshold 的 task，為該 task 啟動備份任務。

（5）適用於實時作業的排程器Deadline Scheduler和Constraint-based Scheduler

這種排程器主要用於有時間限制的作業（Deadline Job），即給作業一個deadline時間，讓它在該時間內完成。實際上，這類排程器分為兩種，軟實時（允許作業有一定的超時）作業排程器和硬實時（作業必須嚴格按時完成）作業排程器。

Deadline Scheduler 主要針對的是軟實時作業，該排程器根據作業的執行進度和剩餘時間動態調整作業獲得的資源量，以便作業儘可能的在 deadline 時間內完成。

Constraint-based Scheduler 主要針對的是硬實時作業，該排程器根據作業的deadline和當前系統中的實時作業執行情況，預測新提交的實時作 業能不能在 deadline時間內完成，如果不能，則將作業反饋給使用者，讓他重調整作業的 deadline。

13.有可能使 Hadoop 任務輸出到多個目錄中麼？如果可以，怎麼做？
 

Hadoop 內建的輸出檔案格式有：

MultipleOutputs<K,V> 可以把輸出資料輸送到不同的目錄；

在自定義的reduce的函式中首先使用setup函式（注：該函式在task啟動後資料處理前就呼叫一次）new出MultipleOutputs 物件，利用該物件呼叫 write 方法定義輸出的目錄。

12.Hadoop API 中的什麼特性可以使 map reducer 任務以不同語言（如 Perl，ruby，awk 等）實現靈活性？
 

Hadoop序列化機制，支援多語言的互動。

1.3Hadoop叢集有幾種角色的節點，每個節點對應的程序有哪些？

Hadoop 叢集從三個角度劃分為兩個角色。 Hadoop 叢集包括 hdfs 作為檔案儲存系統，mapreduce 作為分散式計算框架。

(1)最基本的劃分為主節點和從節點

(2)在 hdfs 中，Namenode 作為主節點，接收客戶端的讀寫服務。 儲存檔案的的元資料如檔名，檔案目錄結構，檔案屬性(生成時間，副本數，檔案許可權)，以及 block所在的datanode 等等，namenode 的元資料資訊會在啟動後加載到記憶體，metadata儲存到磁碟檔名為” fsimage” ,block 的資訊不會儲存到 fsimage,edits 記錄對metadata 的操作日誌datanode 作為從節點。 Datanode 的作用是儲存資料即 block，啟動 datanode 執行緒的時候會向 namenode 彙報 block 資訊，通過向 namenode 傳送心跳保持與其聯絡，如果 namenode10 分鐘沒有收到 datanode 的心跳，則認為 datanode 掛了，並複製其上的 block 到其他 datanode。

(3)在 mapreduce 中的主節點為 jobTracker 和 tasktracker。

JobTracker 作為主節點，負責排程分配每一個子任務 task 運行於 taskTracker上，如果發現有失敗的task 就重新分配到其他節點，每個 Hadoop 叢集一般有一個JobTaskTracker，執行在 master 節點上。

TaskTracker主動與JobTracker通訊，接收作業，並負責直接執行每一個任務，為了減少網路頻寬TaskTracker 最好執行在 datanode 上

1.7mapreduce 的優化方法有哪些?

Mapreduce 程式效率的瓶頸在於兩點：

一計算機效能

二 I/O 操作優化

優化分為時間和空間兩種常見的優化策略如下：

1,輸入的檔案儘量使用大檔案，眾多的小檔案會導致map的數量眾多，每個map任務都會造成一些效能的損失，如果輸入的是小的檔案可以在進行mapreduce處理之前整合成為大檔案，或者直接採用ConbinFileInputFormat來作為輸入方式，此時，hadoop 會考慮節點和叢集的位置資訊，決定將哪些檔案打包到一個單元中。

2,合理的分配 map 和 reduce 的任務的數量.

3,壓縮中間資料，減少 I/O.

4,在 map 之後先進行 combine 處理，減少 I/O.

1.10 列舉你瞭解的海量資料的處理方法及適用範圍，如果有相關使用經驗，可簡要說明。
 

mapreduce 分散式計算 mapreduce 的思想就是分而治之

倒排索引:一種索引方法，用來儲存在全文搜尋下某個單詞在一個文件或者一組文件中的儲存位置的對映，在倒排索引中單詞指向了包含單詞的文件。

訊息佇列:大量的資料寫入首先存入訊息佇列進行緩衝，再把訊息佇列作為資料來源進行資料讀取。

資料庫讀寫分離:向一臺資料庫寫入資料，另外的多臺資料庫從這臺數據庫中進行讀取。

2 程式設計題MR作業設計: 有兩種格式的海量日誌檔案存放於hdfs上，可以通過檔名字首區分，其中登入日誌格式：
 

user,ip,time,oper(列舉值:1 為上線， 2 位下線 )；

訪問日誌格式:ip,time,url,假設登入日誌中user上下線資訊完整，且同一上下線時間段內使用的ip唯一，要計算訪問日誌中獨立 user 數量最多的前 10個url，請給出MapReduce設計思路，如需要幾個MapReduce，及每個 MapReduce 演算法虛擬碼。

思路:

將 userid ,ip ,url 封裝成一個物件，map 類輸入資料，按照 userid 為 key 輸出，value

為 1（intwritable）,按照 reduce 計算寫一個排序類然後按照 value 降序輸出前十個。

2. 執行一個 hadoop 任務的流程是什麼樣的。
1、 匯入資料對需分析的資料進行分片，片的大小預設與 datanode 塊大小相同。

2、 每個資料片由一個 mapper 進行分析，mapper 按照需求將資料拆分為一個個 keyvalue 格式的資料。

3、 每個 key-value 資料呼叫一次 map 方法，對資料進行相應的處理後輸出。

4、 將輸出的資料複製到對應的分割槽，預設一個鍵一個區，相同鍵放在同一個區中。

5、 將輸出的資料進行合併為 key-Iterable 格式。

6、 每個分割槽有一個 reduce，每個 reduce 將同一個分割槽的資料進行合併處理為自己所需的資料格式。

7、 將資料輸出至 hdfs。

3. secondary namenode / HAnamenode 是如何工作的?
 

1、 secondary namenode 在 namenode 的 edits log 檔案超過規定值（預設 64M）時，或者每隔3600秒（預設值）時會剪下 edits log 檔案，複製 namenode 上的 fsimage檔案（若沒有 fsimage）。

2、 namenode 節點建立一個新的 edits 檔案。

3、 將 edits log 檔案及 fsimage 檔案進行合併為一個新 fsimage。

4、 將 fsimage 檔案回傳至 namenode 節點。

5、 Namenode 節點使用 seconday namenode 節點回傳的 fsimage 檔案覆蓋本地的fsimage 檔案。

6、 當 namenode 節點啟動時可以從 seconday namenode 節點複製 fsimage 檔案達到快速啟動的目的。

4. 什麼樣的計算不能用 mr 來提速，舉 5 個例子。
 

1、 資料量很小。

2、 繁雜的小檔案。

3、 索引是更好的存取機制的時候。

4、 事務處理。

5、 只有一臺機器的時候。

5. 一個 mr 作業跑的比較慢，如何來優化。至少給出 6 個方案。
 

mr跑的慢可能有很多原因，如：資料傾斜、map和reduce數設定不合理、reduce等待過久、小檔案過多、spill 次數過多、 merge 次數過多等。

1、解決資料傾斜：資料傾斜可能是partition不合理，導致部分partition中的資料過多，部分過少。可通過分析資料，自定義分割槽器解決。

2、合理設定map和reduce數：兩個都不能設定太少，也不能設定太多。太少，會導致task等待，延長處理時間；太多，會導致 map、 reduce 任務間競爭資源，造成處理超時等錯誤。

3、設定map、reduce共存：調整slowstart.completedmaps引數，使map執行到一定程度後，reduce也開始執行，減少 reduce 的等待時間。

4、合併小檔案：在執行mr任務前將小檔案進行合併，大量的小檔案會產生大量的map任務，增大map任務裝載次數，而任務的裝載比較耗時，從而導致 mr 執行較慢。

5、減少spill次數：通過調整io.sort.mb及sort.spill.percent引數值，增大觸發spill的記憶體上限，減少spill 次數，從而減少磁碟 IO。

6、減少merge次數：通過調整io.sort.factor引數，增大merge的檔案數目，減少merge的次數，從而縮短mr處理時間。

6. Hadoop會有哪些重大故障，如何應對？至少給出 5個。
 

1、 namenode 單點故障：通過 zookeeper 搭建 HA 高可用，可自動切換 namenode。

2、ResourceManager單點故障：可通過配置YARN的HA，並在配置的namenode上手動啟動ResourceManager作為Slave，在 Master 故障後，Slave 會自動切換為Master。

3、reduce階段記憶體溢位：是由於單個reduce任務處理的資料量過多，通過增大reducetasks數目、優化partition 規則使資料分佈均勻進行解決。

4、datanode記憶體溢位：是由於建立的執行緒過多，通過調整linux的maxuserprocesses引數，增大可用執行緒數進行解決。

5、 叢集間時間不同步導致執行異常：通過配置內網時間同步伺服器進行解決。

7. 什麼情況下會觸發 recovery 過程， recover 是怎麼做的。
 

當 jobtracker.restart.recover 引數值設定為 true， jobtracker 重啟之時會觸發recovery。

在JobTracker重啟前，會在history log中記錄各個作業的執行狀態，這樣在JobTracker關閉後，系統中所有資料目錄、 臨時目錄均會被保留，待 JobTracker 重啟之後，JobTracker 自動重新提交這些作業，並只對未執行完成的 task 進行重新排程，這樣可避免已經計算完的 task 重新計算。

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 介