Spark大數據針對性問題。

時間 2019-11-12

原文原文鏈接

一、海量日誌數據，提取出某日訪問百度次數最多的那個IP。css

解決方案：首先是將這一天，而且是訪問百度的日誌中的IP取出來，逐個寫入到一個大文件中。注意到IP是32位的，最多有個2^32個IP。一樣能夠採用映射的方法，好比模1000，把整個大文件映射爲1000個小文件，再找出每一個小文中出現頻率最大的IP(能夠採用hash_map進行頻率統計，而後再找出頻率最大的幾個)及相應的頻率。而後再在這1000個最大的IP中，找出那個頻率最大的IP，即爲所求。html

二、搜索引擎會經過日誌文件把用戶每次檢索使用的全部檢索串都記錄下來，每一個查詢串的長度爲1-255字節。java

假設目前有一千萬個記錄(這些查詢串的重複度比較高，雖然總數是1千萬，但若是除去重複後，不超過3百萬個。一個查詢串的重複度越高，說明查詢它的用戶越多，也就是越熱門。)，請你統計最熱門的10個查詢串，要求使用的內存不能超過1G。node

解決方案：第一步、先對這批海量數據預處理，在O(N)的時間內用Hash表完成排序;而後，第二步、藉助堆這個數據結構，找出Top K，時間複雜度爲N‘logK。即，藉助堆結構，咱們能夠在log量級的時間內查找和調整/移動。所以，維護一個K(該題目中是10)大小的小根堆，而後遍歷300萬的Query，分別和根元素進行對比因此，咱們最終的時間複雜度是：O(N) + N'*O(logK)，(N爲1000萬，N’爲300萬)。mysql

或者：採用trie樹，關鍵字域存該查詢串出現的次數，沒有出現爲0。最後用10個元素的最小推來對出現頻率進行排序。linux

三、有一個1G大小的一個文件，裏面每一行是一個詞，詞的大小不超過16字節，內存限制大小是1M。返回頻數最高的100個詞。ios

解決方案：順序讀文件中，對於每一個詞x，取hash(x)%5000，而後按照該值存到5000個小文件(記爲x0,x1,...x4999)中。這樣每一個文件大概是200k左右。nginx

若是其中的有的文件超過了1M大小，還能夠按照相似的方法繼續往下分，直到分解獲得的小文件的大小都不超過1M。對每一個小文件，統計每一個文件中出現的詞以及相應的頻率(能夠採用trie樹/hash_map等)，並取出出現頻率最大的100個詞(能夠用含100個結點的最小堆)，並把100個詞及相應的頻率存入文件，這樣又獲得了5000個文件。下一步就是把這5000個文件進行歸併(相似與歸併排序)的過程了。git

四、有10個文件，每一個文件1G，每一個文件的每一行存放的都是用戶的query，每一個文件的query均可能重複。要求你按照query的頻度排序。es6

解決方案：方案1：順序讀取10個文件，按照hash(query)%10的結果將query寫入到另外10個文件(記爲)中。這樣新生成的文件每一個的大小大約也1G(假設hash函數是隨機的)。找一臺內存在2G左右的機器，依次對用hash_map(query, query_count)來統計每一個query出現的次數。利用快速/堆/歸併排序按照出現次數進行排序。將排序好的query和對應的query_cout輸出到文件中。這樣獲得了10個排好序的文件(記爲)。

對這10個文件進行歸併排序(內排序與外排序相結合)。

方案2：通常query的總量是有限的，只是重複的次數比較多而已，可能對於全部的query，一次性就能夠加入到內存了。這樣，咱們就能夠採用trie樹/hash_map等直接來統計每一個query出現的次數，而後按出現次數作快速/堆/歸併排序就能夠了。

方案3：與方案1相似，但在作完hash，分紅多個文件後，能夠交給多個文件來處理，採用分佈式的架構來處理(好比MapReduce)，最後再進行合併。

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

解決方案：方案1：能夠估計每一個文件安的大小爲5G×64=320G，遠遠大於內存限制的4G。因此不可能將其徹底加載到內存中處理。考慮採起分而治之的方法。

通讀文件a，對每一個url求取hash(url)%1000，而後根據所取得的值將url分別存儲到1000個小文件(記爲a0,a1,...,a999)中。這樣每一個小文件的大約爲300M。

通讀文件b，採起和a相同的方式將url分別存儲到1000小文件(記爲b0,b1,...,b999)。這樣處理後，全部可能相同的url都在對應的小文件(a0vsb0,a1vsb1,...,a999vsb999)中，不對應的小文件不可能有相同的url。而後咱們只要求出1000對小文件中相同的url便可。

求每對小文件中相同的url時，能夠把其中一個小文件的url存儲到hash_set中。而後遍歷另外一個小文件的每一個url，看其是否在剛纔構建的hash_set中，若是是，那麼就是共同的url，存到文件裏面就能夠了。

方案2：若是容許有必定的錯誤率，能夠使用Bloom filter，4G內存大概能夠表示340億bit。將其中一個文件中的url使用Bloom filter映射爲這340億bit，而後挨個讀取另一個文件的url，檢查是否與Bloom filter，若是是，那麼該url應該是共同的url(注意會有必定的錯誤率)。

六、在2.5億個整數中找出不重複的整數，注，內存不足以容納這2.5億個整數。

解決方案：方案1：採用2-Bitmap(每一個數分配2bit，00表示不存在，01表示出現一次，10表示屢次，11無心義)進行，共需內存內存，還能夠接受。而後掃描這2.5億個整數，查看Bitmap中相對應位，若是是00變01，01變10，10保持不變。所描完過後，查看bitmap，把對應位是01的整數輸出便可。

方案2：也可採用與第1題相似的方法，進行劃分小文件的方法。而後在小文件中找出不重複的整數，並排序。而後再進行歸併，注意去除重複的元素。

七、騰訊面試題：給40億個不重複的unsigned int的整數，沒排過序的，而後再給一個數，如何快速判斷這個數是否在那40億個數當中?

解決方案：申請512M的內存，一個bit位表明一個unsigned int值。讀入40億個數，設置相應的bit位，讀入要查詢的數，查看相應bit位是否爲1，爲1表示存在，爲0表示不存在。

dizengrong：方案2：由於2^32爲40億多，因此給定一個數可能在，也可能不在其中;這裏咱們把40億個數中的每個用32位的二進制來表示假設這40億個數開始放在一個文件中。

而後將這40億個數分紅兩類: 1.最高位爲0 2.最高位爲1 並將這兩類分別寫入到兩個文件中，其中一個文件中數的個數<=20億，而另外一個>=20億(這至關於折半了);與要查找的數的最高位比較並接着進入相應的文件再查找

再而後把這個文件爲又分紅兩類: 1.次最高位爲0 2.次最高位爲1

並將這兩類分別寫入到兩個文件中，其中一個文件中數的個數<=10億，而另外一個>=10億(這至關於折半了); 與要查找的數的次最高位比較並接着進入相應的文件再查找。 ....... 以此類推，就能夠找到了,並且時間複雜度爲O(logn)，方案2完。

附：這裏，再簡單介紹下，位圖方法：使用位圖法判斷整形數組是否存在重複判斷集合中存在重複是常見編程任務之一，當集合中數據量比較大時咱們一般但願少進行幾回掃描，這時雙重循環法就不可取了。

位圖法比較適合於這種狀況，它的作法是按照集合中最大元素max建立一個長度爲max+1的新數組，而後再次掃描原數組，遇到幾就給新數組的第幾位置上1，如遇到5就給新數組的第六個元素置1，這樣下次再遇到5想置位時發現新數組的第六個元素已是1了，這說明此次的數據確定和之前的數據存在着重複。這種給新數組初始化時置零其後置一的作法相似於位圖的處理方法故稱位圖法。它的運算次數最壞的狀況爲2N。若是已知數組的最大值即能事先給新數組定長的話效率還能提升一倍。

八、怎麼在海量數據中找出重複次數最多的一個?

解決方案：先作hash，而後求模映射爲小文件，求出每一個小文件中重複次數最多的一個，並記錄重複次數。而後找出上一步求出的數據中重複次數最多的一個就是所求(具體參考前面的題)。

九、上千萬或上億數據(有重複)，統計其中出現次數最多的錢N個數據。

解決方案：上千萬或上億的數據，如今的機器的內存應該能存下。因此考慮採用hash_map/搜索二叉樹/紅黑樹等來進行統計次數。而後就是取出前N個出現次數最多的數據了，能夠用第2題提到的堆機制完成。

十、一個文本文件，大約有一萬行，每行一個詞，要求統計出其中最頻繁出現的前10個詞，請給出思想，給出時間複雜度分析。

解決方案：方案1：這題是考慮時間效率。用trie樹統計每一個詞出現的次數，時間複雜度是O(n*le)(le表示單詞的平準長度)。而後是找出出現最頻繁的前10個詞，能夠用堆來實現，前面的題中已經講到了，時間複雜度是O(n*lg10)。因此總的時間複雜度，是O(n*le)與O(n*lg10)中較大的哪個。

附、100w個數中找出最大的100個數。

方案1：在前面的題中，咱們已經提到了，用一個含100個元素的最小堆完成。複雜度爲O(100w*lg100)。

方案2：採用快速排序的思想，每次分割以後只考慮比軸大的一部分，知道比軸大的一部分在比100多的時候，採用傳統排序算法排序，取前100個。複雜度爲O(100w*100)。

方案3：採用局部淘汰法。選取前100個元素，並排序，記爲序列L。而後一次掃描剩餘的元素x，與排好序的100個元素中最小的元素比，若是比這個最小的要大，那麼把這個最小的元素刪除，並把x利用插入排序的思想，插入到序列L中。依次循環，知道掃描了全部的元素。複雜度爲O(100w*100)。

****************************************************************

大數據的本質：從數據中挖掘價值
雲計算的本質：共享服務

【某公司筆試面試題】
1\使用mr，spark ,spark sql編寫word count程序
【Spark 版本】
val conf=new SparkConf().setAppName("wd").setMaster("local[1]")
val sc=new SparkContext(conf,2)
//加載
val lines=sc.textFile("tructField("name",DataTypes.StringType,true)")
val paris=lines.flatMap(line=>line.split("^A"))
val words=paris.map((_,1))
val result=words.reduceByKey(_+_).sortBy(x=>x._1,false)

//打印
result.foreach(
wds=>{
println("單詞："+wds._1+" 個數："+wds._2)
}
)
sc.stop()
【spark sql版本】
val conf=new SparkConf().setAppName("sqlWd").setMaster("local[1]")
val sc=new SparkContext(conf)
val sqlContext=new SQLContext(sc)
//加載
val lines=sqlContext.textFile("E:\idea15\createRecommeder\data\words.txt")
val words=lines.flatMap(x=>x.split(" ")).map(y=>Row(y))

val structType=StructType(Array(StructField("name",DataTypes.StringType,true)))
val df=sqlContext.createDataFrame(rows,structType)

df.registerTempTable("t_word_count")
sqlContext.udf.register("num_word",(name:String)=>1)
sqlContext.sql("select name,num_word(name) from t_word_count").groupBy(df.col("name")).count().show()

sc.stop()

2\hive的使用，內外部表的區別，分區做用，UDF和Hive優化
(1)hive使用：倉庫、工具
(2)hive內外部表：內部表數據永久刪除，外部表數據刪除後、其餘人依然能夠訪問
(3)分區做用：防止數據傾斜
(4)UDF函數：用戶自定義的函數(主要解決格式，計算問題)，須要繼承UDF類
java代碼實現
class TestUDFHive extends UDF {
public String evalute(String str){
try{
return "hello"+str
}catch(Exception e){
return str+"error"
}
}
}
(5)Hive優化：看作mapreduce處理
a\排序優化：sort by 效率高於 order by
b\分區：使用靜態分區 (statu_date="20160516",location="beijin")，每一個分區對應hdfs上的一個目錄
c\減小job和task數量：使用表連接操做
d\解決groupby數據傾斜問題：設置hive.groupby.skewindata=true ，那麼hive會自動負載均衡
e\小文件合併成大文件：錶鏈接操做
f\使用UDF或UDAF函數：http://www.cnblogs.com/ggjucheng/archive/2013/02/01/2888819.html

3\Hbase的rk設計，Hbase優化
a\rowkey:hbase三維存儲中的關鍵(rowkey：行鍵，columnKey(family+quilaty)：列鍵，timestamp：時間戳)
\rowkey字典排序、越短越好
\使用id+時間：9527+20160517 \使用hash散列：dsakjkdfuwdsf+9527+20160518
\應用中，rowkey 通常10~100bytes,8字節的整數倍，有利於提升操做系統性能
b\Hbase優化
\分區：RegionSplit()方法 \NUMREGIONS=9
\column不超過3個
\硬盤配置，便於regionServer管理和數據備份及恢復
\分配合適的內存給regionserver

其餘：
hbase查詢
(1)get
(2)scan
使用startRow和endRow限制

4\Linux經常使用操做
a\awk：
awk -F:`BEGIN{print "name ip "}{print $1 $7} END{print "結束"}` /etc/passwd
last | head -5 |awk `BEGIN{print "name ip"}{print $1 $3}END{print "結束了"}`

b\sed

5\java線程2種方式實現、設計模式、鏈表操做、排序
(1)2種線程實現
a\Thread類繼承
TestCL th=new TestCL()//類繼承Thread
th.start()
b\實現Runnable接口
Thread th=new Thread(new Runnable(){
public void run(){
//實現
}
})
th.start()

(2)設計模式，分爲4類
a\建立模式：如工廠模式、單例模式
b\結構模式：代理模式
c\行爲模式：觀察者模式
d\線程池模式

6\【最熟悉的一個項目簡介、架構圖、使用的技術、你負責哪塊】

7\cdh集羣監控
(1)數據庫監控 (2)主機監控 (3)服務監控 (4)活動監控

8\計算機網絡工做原理
將分散的機器經過數據通訊原理鏈接起來，實現共享！

9\hadoop生態系統
hdfs\mapreduce\hive\hbase\zookeeper\flume
hdfs原理及各個模塊的功能 mapreduce原理 mapreduce優化數據傾斜

11系統維護：hadoop升級datanode節點

12\【講解項目要點：數據量、多少人、分工、運行時間、項目使用機器、算法、技術】

13\【學會向對方提問】

14\jvm運行機制及內存原理
運行：
I加載.class文件
II管理而且分配內存
III垃圾回收

內存原理：
IJVM裝載環境和配置
II裝載JVM.dll 並初始化JVM.dll
IV 處理class類

15\hdfs、yarn參數調優
mapreduce.job.jvm.num.tasks
默認爲1，設置爲 -1，重用jvm

16\Hbase、Hive、impala、zookeeper、Storm、spark原理和使用方法、使用其架構圖講解

【某公司筆試題】
一、如何爲一個hadoop任務設置mappers的數量
答案：
使用job.setNumMapTask(int n)手動分割，這是不靠譜的
官方文檔：「Note: This is only a hint to the framework」說明這個方法只是提示做用，不起決定性做用
實際上要用公式計算：
Max（min.split，min（max.split，block））就設置分片的最大最下值 computeSplitSize（）設置
參考：http://blog.csdn.net/strongerbit/article/details/7440111

二、有可能使hadoop任務輸出到多個目錄中麼？若是能夠，怎麼作？
答案：在1.X版本後使用MultipleOutputs.java類實現
源碼：
MultipleOutputs.addNamedOutput(conf, "text2", TextOutputFormat.class, Long.class, String.class);
MultipleOutputs.addNamedOutput(conf, "text3", TextOutputFormat.class, Long.class, String.class);
參考：http://my.oschina.net/leejun2005/blog/94706
發音：Multiple['m?lt?pl]--》許多的

三、如何爲一個hadoop任務設置要建立的reducer的數量
答案：job.setNumReduceTask(int n)
或者調整hdfs-site.xml中的mapred.tasktracker.reduce.tasks.maximum默認參數值

四、在hadoop中定義的主要公用InputFormats中，哪個是默認值：
(A)TextInputFormat
(B)KeyValueInputFormat
(C)SequenceFileInputFormat
答案：A

五、兩個類TextInputFormat和KeyValueTextInputFormat的區別？
答案：
?FileInputFormat的子類：
TextInputFormat（默認類型，鍵是LongWritable類型，值爲Text類型，key爲當前行在文件中的偏移量，value爲當前行自己）；
?KeyValueTextInputFormat(適合文件自帶key，value的狀況，只要指定分隔符便可，比較實用，默認是\t分割)；
源碼：
String sepStr =job.get("mapreduce.input.keyvaluelinerecordreader.key.value.separator","\t");
注意：在自定義輸入格式時，繼承FileInputFormat父類
參考：http://www.cnblogs.com/vichao/archive/2013/06/06/3118100.html

六、在一個運行的hadoop任務中，什麼是InputSpilt?
答案：InputSplit是MapReduce對文件進行處理和運算的輸入單位，只是一個邏輯概念，每一個InputSplit並無對文件實際的切割，只是記錄了要處理的數據的位置（包括文件的path和hosts）和長度（由start和length決定），默認狀況下與block同樣大。
拓展：須要在定義InputSplit後，展開講解mapreduce的原理

七、Hadoop框架中，文件拆分是怎麼被調用的？
答案：JobTracker，建立一個InputFormat的實例，調用它的getSplits()方法，把輸入目錄的文件拆分紅FileSplist做爲Mapper task 的輸入，生成Mapper task加入Queue。
源碼中體現了拆分的數量
long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize);//minSplitSize默認是1

八、分別舉例什麼狀況下使用combiner,什麼狀況下不會使用？
答案：Combiner適用於對記錄彙總的場景（如求和），可是，求平均數的場景就不能使用Combiner了

九、Hadoop中job和Tasks之間的區別是什麼？
答案：
job是工做的入口，負責控制、追蹤、管理任務，也是一個進程
包含map task和reduce task
Tasks是map和reduce裏面的步驟，主要用於完成任務，也是線程

十、Hadoop中經過拆分任務到多個節點運行來實現並行計算，可是某些節點運行較慢會拖慢整個任務的運行，hadoop採用何種機制應對這種狀況？
答案：結果查看監控日誌，得知產生這種現象的緣由是數據傾斜問題
解決：
(1)調整拆分mapper的數量（partition數量）
(2)增長jvm
(3)適當地將reduce的數量變大

十一、流API中的什麼特性帶來能夠使map reduce任務能夠以不一樣語言(如perl\ruby\awk等)實現的靈活性？
答案：用可執行文件做爲Mapper和Reducer，接受的都是標準輸入，輸出的都是標準輸出
參考：http://www.web520.cn/archives/9220

十二、參考下面的M/R系統的場景：
--HDFS塊大小爲64MB
--輸入類型爲FileInputFormat
--有3個文件的大小分別是：64k 65MB 127MB
Hadoop框架會把這些文件拆分爲多少塊？
答案：
64k------->一個block
65MB---->兩個文件：64MB是一個block，1MB是一個block
127MB--->兩個文件：64MB是一個block,63MB是一個block

1三、Hadoop中的RecordReader的做用是什麼？
答案：屬於split和mapper之間的一個過程
將inputsplit輸出的行爲一個轉換記錄，成爲key-value的記錄形式提供給mapper

1四、Map階段結束後，Hadoop框架會處理：Partitioning ,shuffle 和sort,在這個階段都會發生了什麼？
答案：
MR一共有四個階段，split map shuff reduce 在執行完map以後，能夠對map的輸出結果進行分區，
分區：這塊分片肯定到哪一個reduce去計算(彙總)
排序：在每一個分區中進行排序，默認是按照字典順序。
Group：在排序以後進行分組

1五、若是沒有定義partitioner,那麼數據在被送達reducer前是如何被分區的？
答案：
Partitioner是在map函數執行context.write()時被調用。
用戶能夠經過實現自定義的?Partitioner來控制哪一個key被分配給哪一個?Reducer。
查看源碼知道：
若是沒有定義partitioner，那麼會走默認的分區Hashpartitioner

public class HashPartitioner<K, V> extends Partitioner<K, V> {
/** Use {@link Object#hashCode()} to partition. */
public int getPartition(K key, V value, int numReduceTasks) {
return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
}
}
參考：http://blog.csdn.net/gamer_gyt/article/details/47339755

1六、什麼是Combiner?
答案：這是一個hadoop優化性能的步驟，它發生在map與reduce之間
目的：解決了數據傾斜的問題，減輕網絡壓力，實際上時減小了maper的輸出
源碼信息以下：
public void reduce(Text key, Iterator<LongWritable> values,
OutputCollector<Text, LongWritable> output, Reporter reporter)
throws IOException {
LongWritable maxValue = null;
while (values.hasNext()) {
LongWritable value = values.next();
if (maxValue == null) {
maxValue = value;
} else if (value.compareTo(maxValue) > 0) {
maxValue = value;
}
}
output.collect(key, maxValue);
}
在collect實現類中，有這樣一段方法
public synchronized void collect(K key, V value)
throws IOException {
outCounter.increment(1);
writer.append(key, value);
if ((outCounter.getValue() % progressBar) == 0) {
progressable.progress();
}
}
下面是說明輸出數量達到10000時，開始合併爲一個maper
public static final long DEFAULT_COMBINE_RECORDS_BEFORE_PROGRESS = 10000;
Mapreduce原理詳解：

http://my.oschina.NET/itblog/blog/275294

***************************************************

公司A：

1.講講你作的過的項目。項目裏有哪些難點重點注意點呢？
2.講講多線程吧，要是你，你怎麼實現一個線程池呢？
3.講一下Mapreduce或者hdfs的原理和機制。map讀取數據分片。
4.shuffle 是什麼？怎麼調優？
5.項目用什麼語言寫？ Scala？ scala的特色？和Java的區別？
6.理論基礎怎麼樣，好比數據結構，裏面的快速排序，或者，樹？講一講你瞭解的樹的知識？
7.數學怎麼樣呢？
8.講一下數據庫，SQl ，左外鏈接，原理，實現？
9.還了解過數據的什麼知識？數據庫引擎？
10.Hadoop的機架怎麼配置的？
11.Hbase的設計有什麼心得？
12.Hbase的操做是用的什麼API仍是什麼工具？
13.對調度怎麼理解.? 用什麼工具嗎？
14.用kettle 這種工具仍是本身寫程序？大家公司是怎麼作的？
15.大家數據中心開發週期是多長？
16.大家hbase裏面是存一些什麼數據。

二面。三我的。

1.講講你作的項目。
2.平時對多線程這方面是怎麼處理呢？異步是怎麼思考呢？遇到的一些鎖啊，是怎麼作的呢？好比兩我的同時操做同樣東西。怎麼作的呢？一些併發操做設計到一些變量怎麼作的呢？
3.大家用的最可能是 http協議吧？有沒有特殊的頭呢？講講你對tcp/ip的理解？
4.有沒有用過Zookeeper呢？ Zookeeper的適用場景是什麼？ HA 狀態維護分佈式鎖全局配置文件管理操做Zookeeper是用的什麼？

Spark方面：

5.spark開發分兩個方面？哪兩個方面呢？
6.好比一個讀取hdfs上的文件，而後count有多少行的操做，你能夠說說過程嗎。那這個count是在內存中，仍是磁盤中計算的呢？磁盤中。
7.spark和Mapreduce快？爲何快呢？快在哪裏呢？ 1.內存迭代。2.RDD設計。 3,算子的設計。
8.spark sql又爲何比hive快呢？
10.RDD的數據結構是怎麼樣的？ Partition數組。 dependence
11.hadoop的生態呢。說說你的認識。 hdfs底層存儲 hbase 數據庫 hive數據倉庫 Zookeeper分佈式鎖 spark大數據分析

公司B：

1.Spark工做的一個流程。

提交任務。 
QQ圖片20161019131411.png 用戶提交一個任務。 入口是從sc開始的。 sc會去建立一個taskScheduler。根據不一樣的提交模式， 會根據相應的taskchedulerImpl進行任務調度。 同時會去建立Scheduler和DAGScheduler。DAGScheduler 會根據RDD的寬依賴或者窄依賴，進行階段的劃分。劃分好後放入taskset中，交給taskscheduler 。 appclient會到master上註冊。首先會去判斷數據本地化，儘可能選最好的本地化模式去執行。 打散 Executor選擇相應的Executor去執行。ExecutorRunner會去建立CoarseGrainerExecutorBackend進程。 經過線程池的方式去執行任務。 反向： Executor向 SchedulerBackend反向註冊 Spark On Yarn模式下。 driver負責計算調度。appmaster 負責資源的申請。

2.Hbase的PUT的一個過程。
3.RDD算子裏操做一個外部map好比往裏面put數據。而後算子外再遍歷map。有什麼問題嗎。
4.shuffle的過程。調優。
5.5個partition裏面分佈有12345678910.用算子求最大值或者和。不能用廣播變量和累加器。或者sortbykey.
6.大表和小表join.
7.知道spark怎麼讀hbase嗎？spark on hbase.。華爲的。
8.作過hbase的二級索引嗎？
9.sort shuffle的優勢？
10.stage怎麼劃分的？寬依賴窄依賴是什麼？

公司W：

1.講講你作過的項目(一個總體思路)
2.問問大概狀況。公司裏集羣規模。hbase數據量。數據規模。
3.而後挑選數據工廠開始詳細問。問hbase.。加閒聊。
4.問二次排序是什麼。topn是什麼。二次排序要繼承什麼接口？
5.計算的數據怎麼來的。
6.kakfadirect是什麼，。爲何要用這個，有什麼優勢？。和其餘的有什麼區別。

http://blog.csdn.net/erfucun/article/details/52275369 /** * Create an input stream that directly pulls messages from Kafka Brokers * without using any receiver. This stream can guarantee that each message * from Kafka is included in transformations exactly once (see points below). * * Points to note: * - No receivers: This stream does not use any receiver. It directly queries Kafka * - Offsets: This does not use Zookeeper to store offsets. The consumed offsets are tracked * by the stream itself. For interoperability with Kafka monitoring tools that depend on * Zookeeper, you have to update Kafka/Zookeeper yourself from the streaming application. * You can access the offsets used in each batch from the generated RDDs (see * [[org.apache.spark.streaming.kafka.HasOffsetRanges]]). * - Failure Recovery: To recover from driver failures, you have to enable checkpointing * in the [[StreamingContext]]. The information on consumed offset can be * recovered from the checkpoint. See the programming guide for details (constraints, etc.). * - End-to-end semantics: This stream ensures that every records is effectively received and * transformed exactly once, but gives no guarantees on whether the transformed data are * outputted exactly once. For end-to-end exactly-once semantics, you have to either ensure * that the output operation is idempotent, or use transactions to output records atomically. * See the programming guide for more details. * * @param ssc StreamingContext object * @param kafkaParams Kafka <a href="http://kafka.apache.org/documentation.html#configuration"> * configuration parameters</a>. Requires "metadata.broker.list" or "bootstrap.servers" * to be set with Kafka broker(s) (NOT zookeeper servers) specified in * host1:port1,host2:port2 form. * @param fromOffsets Per-topic/partition Kafka offsets defining the (inclusive) * starting point of the stream * @param messageHandler Function for translating each message and metadata into the desired type */

7.問了shuffle過程。
8.怎麼調優的，jvm怎麼調優的？
9.jvm結構？堆裏面幾個區？
10.數據清洗怎麼作的？
11.怎麼用spark作數據清洗
12.跟我聊了spark的應用，商場裏廣告投放，以及黃牛檢測
13.spark讀取數據，是幾個Partition呢？ hdfs幾個block 就有幾個 Partition？
14.spark on yarn的兩種模式? client 模式？和cluster模式？
15.jdbc？mysql的驅動包名字叫什麼？
16.region多大會分區？

公司Q

1.說說Mapreduce？一整個過程的理解。講一下。
2.hbase存數據用什麼rowkey？加時間戳的話，會不會出現時間戳重複的問題，怎麼作的呢？
3.Spring的兩大模塊？ AOP，IOC在大家項目中分別是怎麼用的呢？
4.大家集羣的規模，數據量？

公司M

1.畫圖，畫Spark的工做模式，部署分佈架構圖
2.畫圖，畫圖講解spark工做流程。以及在集羣上和各個角色的對應關係。
3.java自帶有哪幾種線程池。
4.數據是怎麼收集的。 kafka收集數據的原理？
5.畫圖，講講shuffle的過程。那你怎麼在編程的時候注意避免這些性能問題。
6.講講列式存儲的 parquet文件底層格式。
7.dataset和dataframe？
8.經過什麼方式學習spark的？
9.有哪些數據傾斜，怎麼解決？
10.寬依賴窄依賴？
11.yarn的原理？
12.BlockManager怎麼管理硬盤和內存的。
13.哪些算子操做涉及到shuffle
14.看過源碼？你熟悉哪幾個部分的源碼？
15.集羣上 nodemanager和ResourceManager的數量關係？
16.spark怎麼整合hive？大概這樣。 spark on hive 。 hive仍是hive 執行引擎是spark。

其餘人的：

1.Spark如何處理結構化數據，Spark如何處理非結構話數據？
2.Spark性能優化主要有哪些手段？
3.簡要描述Spark分佈式集羣搭建的步驟
4.對於Spark你以爲他對於現有大數據的現狀的優點和劣勢在哪裏？
5.對於算法是否進行過自主的研究設計？
6.簡要描述你瞭解的一些數據挖掘算法與內容基本我有印象的就這幾個問題，聊了2個多小時，腦子都差點被問幹了

*******************************************************************

1.給定a、b兩個文件，各存放50億個url，每一個url各佔64字節，內存限制是4G，讓你找出a、b文件共同的url?

　　假如每一個url大小爲10bytes，那麼能夠估計每一個文件的大小爲50G×64=320G，遠遠大於內存限制的4G，因此不可能將其徹底加載到內存中處理，能夠採用分治的思想來解決。

　　Step1：遍歷文件a，對每一個url求取hash(url)%1000，而後根據所取得的值將url分別存儲到1000個小文件(記爲a0,a1,...,a999，每一個小文件約300M);

　　Step2:遍歷文件b，採起和a相同的方式將url分別存儲到1000個小文件(記爲b0,b1,...,b999);

　　巧妙之處：這樣處理後，全部可能相同的url都被保存在對應的小文件(a0vsb0,a1vsb1,...,a999vsb999)中，不對應的小文件不可能有相同的url。而後咱們只要求出這個1000對小文件中相同的url便可。

　　Step3：求每對小文件ai和bi中相同的url時，能夠把ai的url存儲到hash_set/hash_map中。而後遍歷bi的每一個url，看其是否在剛纔構建的hash_set中，若是是，那麼就是共同的url，存到文件裏面就能夠了。

　　草圖以下(左邊分解A，右邊分解B，中間求解相同url)：

2.有一個1G大小的一個文件，裏面每一行是一個詞，詞的大小不超過16字節，內存限制大小是1M，要求返回頻數最高的100個詞。

　　Step1：順序讀文件中，對於每一個詞x，取hash(x)%5000，而後按照該值存到5000個小文件(記爲f0,f1,...,f4999)中，這樣每一個文件大概是200k左右，若是其中的有的文件超過了1M大小，還能夠按照相似的方法繼續往下分，直到分解獲得的小文件的大小都不超過1M;

　　Step2：對每一個小文件，統計每一個文件中出現的詞以及相應的頻率(能夠採用trie樹/hash_map等)，並取出出現頻率最大的100個詞(能夠用含100個結點的最小堆)，並把100詞及相應的頻率存入文件，這樣又獲得了5000個文件;

　　Step3：把這5000個文件進行歸併(相似與歸併排序);

　　草圖以下(分割大問題，求解小問題，歸併)：

3.現有海量日誌數據保存在一個超級大的文件中，該文件沒法直接讀入內存，要求從中提取某天出訪問百度次數最多的那個IP。

　　Step1：從這一天的日誌數據中把訪問百度的IP取出來，逐個寫入到一個大文件中;

　　Step2：注意到IP是32位的，最多有2^32個IP。一樣能夠採用映射的方法，好比模1000，把整個大文件映射爲1000個小文件;

　　Step3：找出每一個小文中出現頻率最大的IP(能夠採用hash_map進行頻率統計，而後再找出頻率最大的幾個)及相應的頻率;

　　Step4：在這1000個最大的IP中，找出那個頻率最大的IP，即爲所求。

　　草圖以下：

4.LVS和HAProxy相比，它的缺點是什麼?

　　以前，的確是用LVS進行過MySQL集羣的負載均衡，對HAProxy也有過了解，可是將這二者放在眼前進行比較，還真沒試着瞭解過。面試中出現了這麼一題，面試官給予的答案是LVS的配置至關繁瑣，後來查找了相關資料，對這兩種負載均衡方案有了更進一步的瞭解。LVS的負載均衡性能之強悍已經達到硬件負載均衡的F5的百分之60了，而HAproxy的負載均衡和Nginx負載均衡，均爲硬件負載均衡的百分之十左右。因而可知，配置複雜，相應的效果也是顯而易見的。在查找資料的過程當中，試着將LVS的10種調度算法瞭解了一下，看似數量挺多的10種算法其實在不一樣的算法之間，有些只是有着一些細微的差異。在這10種調度算法中，靜態調度算法有四種，動態調度算法有6種。

靜態調度算法：

　　①RR輪詢調度算法

　　這種調度算法不考慮服務器的狀態，因此是無狀態的，同時也不考慮每一個服務器的性能，好比我有1-N臺服務器，來N個請求了，第一個請求給第一臺，第二個請求給第二臺，，，第N個請求給第N臺服務器，就醬紫。

　　②加權輪詢

　　這種調度算法是考慮到服務器的性能的，你能夠根據不一樣服務器的性能，加上權重進行分配相應的請求。

　　③基於目的地址的hash散列

　　這種調度算法和基於源地址的hash散列殊途同歸，都是爲了維持一個session，基於目的地址的hash散列，將記住同一請求的目的地址，將這類請求發往同一臺目的服務器。簡而言之，就是發往這個目的地址的請求都發往同一臺服務器。而基於源地址的hash散列，就是來自同一源地址的請求都發往同一臺服務器。

　　④基於源地址的hash散列

　　上述已講，再也不贅述。

動態調度

　　①最少鏈接調度算法

　　這種調度算法會記錄響應請求的服務器上所創建的鏈接數，每接收到一個請求會相應的將該服務器的所創建鏈接數加1，同時將新來的請求分配到當前鏈接數最少的那臺機器上。

　　②加權最少鏈接調度算法

　　這種調度算法在最少鏈接調度算法的基礎上考慮到服務器的性能。固然，作這樣子的考慮是有其合理性存在的，若是是同一規格的服務器，那麼創建的鏈接數越多，必然越增長其負載，那麼僅僅根據最少鏈接數的調度算法，必然能夠實現合理的負載均衡。但若是，服務器的性能不同呢?好比我有一臺服務器，最多隻能處理10個鏈接，如今創建了3個，還有一臺服務器最多能處理1000條鏈接，如今創建了5個，若是單純地按照上述的最少鏈接調度算法，妥妥的前者嘛，但前者已經創建了百分之三十的鏈接了，然後者連百分之一的鏈接尚未創建，試問，這合理嗎?顯然不合理。因此加上權重，纔算合理。相應的公式也至關簡單：active*256/weight。

　　③最短時間望調度算法

　　這種算法，是避免出現上述加權最少鏈接調度算法中的一種特殊狀況，致使即便加上權重，調度器也無差異對待了，舉個栗子：

　　假設有三臺服務器ABC，其當前所創建的鏈接數相應地爲1,2,3，而權重也是1,2,3。那麼若是按照加權最少鏈接調度算法的話，算出來是這樣子的：

　　A:1256/1=256

　　B:2256/2=256

　　C:3256/3=256

　　咱們會發現，即使加上權重，A、B、C，通過計算仍是同樣的，這樣子調度器會無差異的在A、B、C中任選一臺，將請求發過去。

　　而最短時間望將active256/weight的算法改進爲(active+1)256/weight

　　那麼仍是以前的例子：

　　A:(1+1)256/1=2/1256=2256

　　B:(2+1)256/2=3/2256=1.5256

　　C:(3+1)25六、3=4/3256≈1.3256

　　顯然C

　　④永不排隊算法

　　將請求發給當前鏈接數爲0的服務器上。

　　⑤基於局部的最少鏈接調度算法

　　這種調度算法應用於Cache系統，維持一個請求到一臺服務器的映射，其實咱們仔細想一想哈，以前作的一系列最少鏈接相關的調度算法。考慮到的是服務器的狀態與性能，可是一次請求並非單向的，就像有一個從未合做過的大牛，他很閒，你讓他去解決一個以前碰到過的一個問題，未必有找一個以前已經跟你合做過哪怕如今不怎麼閒的臭皮匠效果好哦~，因此基於局部的最少鏈接調度算法，維持的這種映射的做用是，若是來了一個請求，相對應的映射的那臺服務器，沒有超載，ok交給老夥伴完事吧，俺放心，若是那臺服務器不存在，或者是超載的狀態且有其餘服務器工做在一半的負載狀態，則按最少鏈接調度算法在集羣其他的服務器中找一臺將請求分配給它。

　　⑥基於複製的局部最少鏈接調度算法

　　這種調度算法一樣應用於cache系統，但它維持的不是到一臺服務器的映射而是到一組服務器的映射，當有新的請求到來，根據最小鏈接原則，從該映射的服務器組中選擇一臺服務器，若是它沒有超載則交給它去處理這個請求，若是發現它超載，則從服務器組外的集羣中，按最少鏈接原則拉一臺機器加入服務器組，而且在服務器組有一段時間未修改後，將最忙的那臺服務器從服務器組中剔除。

5.Sqoop用起來感受怎樣?

　　說實話，Sqoop在導入數據的速度上確實十分感人，經過進一步瞭解，發現Sqoop1和Sqoop2在架構上仍是有明顯不一樣的，不管是從數據類型上仍是從安全權限，密碼暴露方面，Sqoop2都有了明顯的改進，同時同一些其餘的異構數據同步工具比較,如淘寶的DataX或者Kettle相比，Sqoop不管是從導入數據的效率上仍是從支持插件的豐富程度上，Sqoop仍是至關不錯滴!!

6.ZooKeeper的角色以及相應的Zookepper工做原理?

　　果真，人的記憶力是有衰減曲線的，當面試官拋出這個問題後，前者角色，我只答出了兩種(leader和follower)，後者原理壓根就模糊至忘記了。因此惡補了一下，涉及到Zookeeper的角色大概有以下四種：leader、learner(follower)、observer、client。其中leader主要用來決策和調度，follower和observer的區別僅僅在於後者沒有寫的職能，但都有將client請求提交給leader的職能，而observer的出現是爲了應對當投票壓力過大這種情形的，client就是用來發起請求的。而Zookeeper所用的分佈式一致性算法包括leader的選舉其實和-原始部落的得到神器爲酋長，或者得玉璽者爲皇帝相似，誰id最小，誰爲leader，會根據你所配置的相應的文件在相應的節點機下生成id，而後相應的節點會經過getchildren()這個函數獲取以前設置的節點下生成的id，誰最小，誰是leader。而且若是萬一這個leader掛掉了或者墮落了，則由次小的頂上。並且在配置相應的zookeeper文件的時候回有相似於以下字樣的信息：Server.x=AAAA:BBBB:CCCC。其中的x即爲你的節點號哈，AAAA對應你所部屬zookeeper所在的ip地址，BBBB爲接收client請求的端口，CCCC爲從新選舉leader端口。

7.HBase的Insert與Update的區別?

　　這個題目是就着最近的一次項目問的，當時實現的與hbase交互的三個方法分別爲insert、delete、update。因爲那個項目是對接的一個項目，對接的小夥伴和我協商了下，不將update合併爲insert，若是合併的話，按那個項目自己，其實經過insert執行overwrite至關於間接地Update，本質上，或者說在展示上是沒什麼區別的包括所調用的put。但那僅僅是就着那個項目的程序而言，若是基於HBaseshell層面。將同一rowkey的數據插入HBase，其實雖然展示一條，可是相應的timestamp是不同的，並且最大的版本數能夠經過配置文件進行相應地設置。

8.請簡述大數據的結果展示方式。

　　1)報表形式

　　基於數據挖掘得出的數據報表，包括數據表格、矩陣、圖形和自定義格式的報表等，使用方便、設計靈活。

　　2)圖形化展示

　　提供曲線、餅圖、堆積圖、儀表盤、魚骨分析圖等圖形形式宏觀展示模型數據的分佈狀況，從而便於進行決策。

　　3)KPI展示

　　提供表格式績效一覽表並可自定義績效查看方式，如數據表格或走勢圖，企業管理者可根據可度量的目標快速評估進度。

　　4)查詢展示

　　按數據查詢條件和查詢內容，以數據表格來彙總查詢結果，提供明細查詢功能，並可在查詢的數據表格基礎上進行上鑽、下鑽、旋轉等操做。

　　9.例舉身邊的大數據。

　　i.QQ，微博等社交軟件產生的數據

　　ii.天貓，京東等電子商務產生的數據

　　iii.互聯網上的各類數據

　　10.簡述大數據的數據管理方式。

　　答：對於圖像、視頻、URL、地理位置等類型多樣的數據，難以用傳統的結構化方式描述，所以須要使用由多維表組成的面向列存儲的數據管理系統來組織和管理數據。也就是說，將數據按行排序，按列存儲，將相同字段的數據做爲一個列族來聚合存儲。不一樣的列族對應數據的不一樣屬性，這些屬性能夠根據需求動態增長，經過這樣的分佈式實時列式數據庫對數據統一進行結構化存儲和管理，避免了傳統數據存儲方式下的關聯查詢。

　　11.什麼是大數據?

　　答：大數據是指沒法在允許的時間內用常規軟件工具對其內容進行抓取、管理和處理的數據。

　　12.海量日誌數據，提取出某日訪問百度次數最多的那個IP。

　　首先是這一天，而且是訪問百度的日誌中的IP取出來，逐個寫入到一個大文件中。注意到IP是32位的，最多有個2^32個IP。一樣能夠採用映射的方法，好比模1000，把整個大文件映射爲1000個小文件，再找出每一個小文中出現頻率最大的IP(能夠採用hash_map進行頻率統計，而後再找出頻率最大的幾個)及相應的頻率。而後再在這1000個最大的IP中，找出那個頻率最大的IP，即爲所求。

　　或者以下闡述(雪域之鷹)：

　　算法思想：分而治之+Hash

　　1)IP地址最多有2^32=4G種取值狀況，因此不能徹底加載到內存中處理;

　　2)能夠考慮採用「分而治之」的思想，按照IP地址的Hash(IP)%1024值，把海量IP日誌分別存儲到1024個小文件中。這樣，每一個小文件最多包含4MB個IP地址;

　　3)對於每個小文件，能夠構建一個IP爲key，出現次數爲value的Hashmap，同時記錄當前出現次數最多的那個IP地址;

　　4)能夠獲得1024個小文件中的出現次數最多的IP，再依據常規的排序算法獲得整體上出現次數最多的IP;

　　13.搜索引擎會經過日誌文件把用戶每次檢索使用的全部檢索串都記錄下來，每一個查詢串的長度爲1-255字節。

　　假設目前有一千萬個記錄(這些查詢串的重複度比較高，雖然總數是1千萬，但若是除去重複後，不超過3百萬個。一個查詢串的重複度越高，說明查詢它的用戶越多，也就是越熱門。)，請你統計最熱門的10個查詢串，要求使用的內存不能超過1G。

　　典型的TopK算法，仍是在這篇文章裏頭有所闡述，詳情請參見：11、從頭至尾完全解析Hash表算法。

　　文中，給出的最終算法是：

　　第一步、先對這批海量數據預處理，在O(N)的時間內用Hash表完成統計(以前寫成了排序，特此訂正。July、2011.04.27);

　　第二步、藉助堆這個數據結構，找出TopK，時間複雜度爲N‘logK。

　　即，藉助堆結構，咱們能夠在log量級的時間內查找和調整/移動。所以，維護一個K(該題目中是10)大小的小根堆，而後遍歷300萬的Query，分別和根元素進行對比因此，咱們最終的時間複雜度是：O(N)+N’*O(logK)，(N爲1000萬，N’爲300萬)。ok，更多，詳情，請參考原文。

　　或者：採用trie樹，關鍵字域存該查詢串出現的次數，沒有出現爲0。最後用10個元素的最小推來對出現頻率進行排序。

　　14.有一個1G大小的一個文件，裏面每一行是一個詞，詞的大小不超過16字節，內存限制大小是1M。返回頻數最高的100個詞。

　　方案：順序讀文件中，對於每一個詞x，取hash(x)%5000，而後按照該值存到5000個小文件(記爲x0,x1,…x4999)中。這樣每一個文件大概是200k左右。

　　若是其中的有的文件超過了1M大小，還能夠按照相似的方法繼續往下分，直到分解獲得的小文件的大小都不超過1M。

　　對每一個小文件，統計每一個文件中出現的詞以及相應的頻率(能夠採用trie樹/hash_map等)，並取出出現頻率最大的100個詞(能夠用含100個結點的最小堆)，並把100個詞及相應的頻率存入文件，這樣又獲得了5000個文件。下一步就是把這5000個文件進行歸併(相似與歸併排序)的過程了。

　　15.有10個文件，每一個文件1G，每一個文件的每一行存放的都是用戶的query，每一個文件的query均可能重複。要求你按照query的頻度排序。

　　仍是典型的TOPK算法，解決方案以下：

　　方案1：

　　順序讀取10個文件，按照hash(query)%10的結果將query寫入到另外10個文件(記爲)中。這樣新生成的文件每一個的大小大約也1G(假設hash函數是隨機的)。

　　找一臺內存在2G左右的機器，依次對用hash_map(query,query_count)來統計每一個query出現的次數。利用快速/堆/歸併排序按照出現次數進行排序。將排序好的query和對應的query_cout輸出到文件中。這樣獲得了10個排好序的文件(記爲)。

　　對這10個文件進行歸併排序(內排序與外排序相結合)。

　　方案2：

　　通常query的總量是有限的，只是重複的次數比較多而已，可能對於全部的query，一次性就能夠加入到內存了。這樣，咱們就能夠採用trie樹/hash_map等直接來統計每一個query出現的次數，而後按出現次數作快速/堆/歸併排序就能夠了。

　　方案3：

　　與方案1相似，但在作完hash，分紅多個文件後，能夠交給多個文件來處理，採用分佈式的架構來處理(好比MapReduce)，最後再進行合併。

　　16.給定a、b兩個文件，各存放50億個url，每一個url各佔64字節，內存限制是4G，讓你找出a、b文件共同的url?

　　方案1：能夠估計每一個文件安的大小爲5G×64=320G，遠遠大於內存限制的4G。因此不可能將其徹底加載到內存中處理。考慮採起分而治之的方法。

　　遍歷文件a，對每一個url求取hash(url)%1000，而後根據所取得的值將url分別存儲到1000個小文件(記爲a0,a1,…,a999)中。這樣每一個小文件的大約爲300M。

　　遍歷文件b，採起和a相同的方式將url分別存儲到1000小文件(記爲b0,b1,…,b999)。這樣處理後，全部可能相同的url都在對應的小文件(a0vsb0,a1vsb1,…,a999vsb999)中，不對應的小文件不可能有相同的url。而後咱們只要求出1000對小文件中相同的url便可。

　　方案2：若是容許有必定的錯誤率，能夠使用Bloomfilter，4G內存大概能夠表示340億bit。將其中一個文件中的url使用Bloomfilter映射爲這340億bit，而後挨個讀取另一個文件的url，檢查是否與Bloomfilter，若是是，那麼該url應該是共同的url(注意會有必定的錯誤率)。

　　Bloomfilter往後會在本BLOG內詳細闡述。

　　17.在2.5億個整數中找出不重複的整數，注，內存不足以容納這2.5億個整數。

　　方案1：採用2-Bitmap(每一個數分配2bit，00表示不存在，01表示出現一次，10表示屢次，11無心義)進行，共需內存2^32*2bit=1GB內存，還能夠接受。而後掃描這2.5億個整數，查看Bitmap中相對應位，若是是00變01，01變10，10保持不變。所描完過後，查看bitmap，把對應位是01的整數輸出便可。

　　方案2：也可採用與第1題相似的方法，進行劃分小文件的方法。而後在小文件中找出不重複的整數，並排序。而後再進行歸併，注意去除重複的元素。

　　18.騰訊面試題：給40億個不重複的unsignedint的整數，沒排過序的，而後再給一個數，如何快速判斷這個數是否在那40億個數當中?

　　與上第6題相似，個人第一反應時快速排序+二分查找。如下是其它更好的方法：

　　方案1：oo，申請512M的內存，一個bit位表明一個unsignedint值。讀入40億個數，設置相應的bit位，讀入要查詢的數，查看相應bit位是否爲1，爲1表示存在，爲0表示不存在。

　　dizengrong：

　　方案2：這個問題在《編程珠璣》裏有很好的描述，你們能夠參考下面的思路，探討一下：

　　又由於2^32爲40億多，因此給定一個數可能在，也可能不在其中;

　　這裏咱們把40億個數中的每個用32位的二進制來表示

　　假設這40億個數開始放在一個文件中。

　　而後將這40億個數分紅兩類:

　　1.最高位爲0

　　2.最高位爲1

　　並將這兩類分別寫入到兩個文件中，其中一個文件中數的個數<=20億，而另外一個>=20億(這至關於折半了);

　　與要查找的數的最高位比較並接着進入相應的文件再查找

　　再而後把這個文件爲又分紅兩類:

　　1.次最高位爲0

　　2.次最高位爲1

　　並將這兩類分別寫入到兩個文件中，其中一個文件中數的個數<=10億，而另外一個>=10億(這至關於折半了);

　　與要查找的數的次最高位比較並接着進入相應的文件再查找。

　　…….

　　以此類推，就能夠找到了,並且時間複雜度爲O(logn)，方案2完。

　　附：這裏，再簡單介紹下，位圖方法：

　　使用位圖法判斷整形數組是否存在重複

　　判斷集合中存在重複是常見編程任務之一，當集合中數據量比較大時咱們一般但願少進行幾回掃描，這時雙重循環法就不可取了。

　　歡迎，有更好的思路，或方法，共同交流。

　　19.怎麼在海量數據中找出重複次數最多的一個?

　　方案1：先作hash，而後求模映射爲小文件，求出每一個小文件中重複次數最多的一個，並記錄重複次數。而後找出上一步求出的數據中重複次數最多的一個就是所求(具體參考前面的題)。

　　20.上千萬或上億數據(有重複)，統計其中出現次數最多的錢N個數據。

　　方案1：上千萬或上億的數據，如今的機器的內存應該能存下。因此考慮採用hash_map/搜索二叉樹/紅黑樹等來進行統計次數。而後就是取出前N個出現次數最多的數據了，能夠用第2題提到的堆機制完成。

　　21.一個文本文件，大約有一萬行，每行一個詞，要求統計出其中最頻繁出現的前10個詞，請給出思想，給出時間複雜度分析。

　　方案1：這題是考慮時間效率。用trie樹統計每一個詞出現的次數，時間複雜度是O(n*le)(le表示單詞的平準長度)。而後是找出出現最頻繁的前10個詞，能夠用堆來實現，前面的題中已經講到了，時間複雜度是O(n*lg10)。因此總的時間複雜度，是O(n*le)與O(n*lg10)中較大的哪個。

　　附、100w個數中找出最大的100個數。

　　方案1：在前面的題中，咱們已經提到了，用一個含100個元素的最小堆完成。複雜度爲O(100w*lg100)。

　　第二部分、十個海量數據處理方法大總結

　　ok，看了上面這麼多的面試題，是否有點頭暈。是的，須要一個總結。接下來，本文將簡單總結下一些處理海量數據問題的常見方法，而往後，本BLOG內會具體闡述這些方法。

　　1、Bloomfilter

　　適用範圍：能夠用來實現數據字典，進行數據的判重，或者集合求交集

　　基本原理及要點：

　　對於原理來講很簡單，位數組+k個獨立hash函數。將hash函數對應的值的位數組置1，查找時若是發現全部hash函數對應位都是1說明存在，很明顯這個過程並不保證查找的結果是100%正確的。同時也不支持刪除一個已經插入的關鍵字，由於該關鍵字對應的位會牽動到其餘的關鍵字。因此一個簡單的改進就是countingBloomfilter，用一個counter數組代替位數組，就能夠支持刪除了。

　　還有一個比較重要的問題，如何根據輸入元素個數n，肯定位數組m的大小及hash函數個數。當hash函數個數k=(ln2)*(m/n)時錯誤率最小。在錯誤率不大於E的狀況下，m至少要等於n*lg(1/E)才能表示任意n個元素的集合。但m還應該更大些，由於還要保證bit數組裏至少一半爲0，則m應該>=nlg(1/E)*lge大概就是nlg(1/E)1.44倍(lg表示以2爲底的對數)。

　　舉個例子咱們假設錯誤率爲0.01，則此時m應大概是n的13倍。這樣k大概是8個。

　　注意這裏m與n的單位不一樣，m是bit爲單位，而n則是以元素個數爲單位(準確的說是不一樣元素的個數)。一般單個元素的長度都是有不少bit的。因此使用bloomfilter內存上一般都是節省的。

　　擴展：

　　Bloomfilter將集合中的元素映射到位數組中，用k(k爲哈希函數個數)個映射位是否全1表示元素在不在這個集合中。Countingbloomfilter(CBF)將位數組中的每一位擴展爲一個counter，從而支持了元素的刪除操做。SpectralBloomFilter(SBF)將其與集合元素的出現次數關聯。SBF採用counter中的最小值來近似表示元素的出現頻率。

　　問題實例：給你A,B兩個文件，各存放50億條URL，每條URL佔用64字節，內存限制是4G，讓你找出A,B文件共同的URL。若是是三個乃至n個文件呢?

　　根據這個問題咱們來計算下內存的佔用，4G=2^32大概是40億*8大概是340億，n=50億，若是按出錯率0.01算須要的大概是650億個bit。如今可用的是340億，相差並很少，這樣可能會使出錯率上升些。另外若是這些urlip是一一對應的，就能夠轉換成ip，則大大簡單了。

　　2、Hashing

　　適用範圍：快速查找，刪除的基本數據結構，一般須要總數據量能夠放入內存

　　基本原理及要點：

　　hash函數選擇，針對字符串，整數，排列，具體相應的hash方法。

　　碰撞處理，一種是openhashing，也稱爲拉鍊法;另外一種就是closedhashing，也稱開地址法，openedaddressing。

　　擴展：

　　d-lefthashing中的d是多個的意思，咱們先簡化這個問題，看一看2-lefthashing。2-lefthashing指的是將一個哈希表分紅長度相等的兩半，分別叫作T1和T2，給T1和T2分別配備一個哈希函數，h1和h2。在存儲一個新的key時，同時用兩個哈希函數進行計算，得出兩個地址h1[key]和h2[key]。這時須要檢查T1中的h1[key]位置和T2中的h2[key]位置，哪個位置已經存儲的(有碰撞的)key比較多，而後將新key存儲在負載少的位置。若是兩邊同樣多，好比兩個位置都爲空或者都存儲了一個key，就把新key存儲在左邊的T1子表中，2-left也由此而來。在查找一個key時，必須進行兩次hash，同時查找兩個位置。

　　問題實例：

　　1).海量日誌數據，提取出某日訪問百度次數最多的那個IP。

　　IP的數目仍是有限的，最多2^32個，因此能夠考慮使用hash將ip直接存入內存，而後進行統計。

　　3、bit-map

　　適用範圍：可進行數據的快速查找，判重，刪除，通常來講數據範圍是int的10倍如下

　　基本原理及要點：使用bit數組來表示某些元素是否存在，好比8位電話號碼

　　擴展：bloomfilter能夠看作是對bit-map的擴展

　　問題實例：

　　1)已知某個文件內包含一些電話號碼，每一個號碼爲8位數字，統計不一樣號碼的個數。

　　8位最多99999999，大概須要99m個bit，大概10幾m字節的內存便可。

　　2)2.5億個整數中找出不重複的整數的個數，內存空間不足以容納這2.5億個整數。

　　將bit-map擴展一下，用2bit表示一個數便可，0表示未出現，1表示出現一次，2表示出現2次及以上。或者咱們不用2bit來進行表示，咱們用兩個bit-map便可模擬實現這個2bit-map。

　　4、堆

　　適用範圍：海量數據前n大，而且n比較小，堆能夠放入內存

　　基本原理及要點：最大堆求前n小，最小堆求前n大。方法，好比求前n小，咱們比較當前元素與最大堆裏的最大元素，若是它小於最大元素，則應該替換那個最大元素。這樣最後獲得的n個元素就是最小的n個。適合大數據量，求前n小，n的大小比較小的狀況，這樣能夠掃描一遍便可獲得全部的前n元素，效率很高。

　　擴展：雙堆，一個最大堆與一個最小堆結合，能夠用來維護中位數。

　　問題實例：

　　1)100w個數中找最大的前100個數。

　　用一個100個元素大小的最小堆便可。

　　5、雙層桶劃分—-其實本質上就是【分而治之】的思想，重在「分」的技巧上!

　　適用範圍：第k大，中位數，不重複或重複的數字

　　基本原理及要點：由於元素範圍很大，不能利用直接尋址表，因此經過屢次劃分，逐步肯定範圍，而後最後在一個能夠接受的範圍內進行。能夠經過屢次縮小，雙層只是一個例子。

　　擴展：

　　問題實例：

　　1).2.5億個整數中找出不重複的整數的個數，內存空間不足以容納這2.5億個整數。

　　有點像鴿巢原理，整數個數爲2^32,也就是，咱們能夠將這2^32個數，劃分爲2^8個區域(好比用單個文件表明一個區域)，而後將數據分離到不一樣的區域，而後不一樣的區域在利用bitmap就能夠直接解決了。也就是說只要有足夠的磁盤空間，就能夠很方便的解決。

　　2).5億個int找它們的中位數。

　　這個例子比上面那個更明顯。首先咱們將int劃分爲2^16個區域，而後讀取數據統計落到各個區域裏的數的個數，以後咱們根據統計結果就能夠判斷中位數落到那個區域，同時知道這個區域中的第幾大數恰好是中位數。而後第二次掃描咱們只統計落在這個區域中的那些數就能夠了。

　　實際上，若是不是int是int64，咱們能夠通過3次這樣的劃分便可下降到能夠接受的程度。便可以先將int64分紅2^24個區域，而後肯定區域的第幾大數，在將該區域分紅2^20個子區域，而後肯定是子區域的第幾大數，而後子區域裏的數的個數只有2^20，就能夠直接利用directaddrtable進行統計了。

　　6、數據庫索引

　　適用範圍：大數據量的增刪改查

　　基本原理及要點：利用數據的設計實現方法，對海量數據的增刪改查進行處理。

　　7、倒排索引(Invertedindex)

　　適用範圍：搜索引擎，關鍵字查詢

　　基本原理及要點：爲什麼叫倒排索引?一種索引方法，被用來存儲在全文搜索下某個單詞在一個文檔或者一組文檔中的存儲位置的映射。

　　以英文爲例，下面是要被索引的文本：

　　T0=「itiswhatitis」

　　T1=「whatisit」

　　T2=「itisabanana」

　　咱們就能獲得下面的反向文件索引：

　　「a」:{2}

　　「banana」:{2}

　　「is」:{0,1,2}

　　「it」:{0,1,2}

　　「what」:{0,1}

　　檢索的條件」what」,」is」和」it」將對應集合的交集。

　　正向索引開發出來用來存儲每一個文檔的單詞的列表。正向索引的查詢每每知足每一個文檔有序頻繁的全文查詢和每一個單詞在校驗文檔中的驗證這樣的查詢。在正向索引中，文檔佔據了中心的位置，每一個文檔指向了一個它所包含的索引項的序列。也就是說文檔指向了它包含的那些單詞，而反向索引則是單詞指向了包含它的文檔，很容易看到這個反向的關係。

　　擴展：

　　問題實例：文檔檢索系統，查詢那些文件包含了某單詞，好比常見的學術論文的關鍵字搜索。

　　8、外排序

　　適用範圍：大數據的排序，去重

　　基本原理及要點：外排序的歸併方法，置換選擇敗者樹原理，最優歸併樹

　　擴展：

　　問題實例：

　　1).有一個1G大小的一個文件，裏面每一行是一個詞，詞的大小不超過16個字節，內存限制大小是1M。返回頻數最高的100個詞。

　　這個數據具備很明顯的特色，詞的大小爲16個字節，可是內存只有1m作hash有些不夠，因此能夠用來排序。內存能夠當輸入緩衝區使用。

　　9、trie樹

　　適用範圍：數據量大，重複多，可是數據種類小能夠放入內存

　　基本原理及要點：實現方式，節點孩子的表示方式

　　擴展：壓縮實現。

　　問題實例：

　　1).有10個文件，每一個文件1G，每一個文件的每一行都存放的是用戶的query，每一個文件的query均可能重複。要你按照query的頻度排序。

　　2).1000萬字符串，其中有些是相同的(重複),須要把重複的所有去掉，保留沒有重複的字符串。請問怎麼設計和實現?

　　3).尋找熱門查詢：查詢串的重複度比較高，雖然總數是1千萬，但若是除去重複後，不超過3百萬個，每一個不超過255字節。

　　10、分佈式處理mapreduce

　　適用範圍：數據量大，可是數據種類小能夠放入內存

　　基本原理及要點：將數據交給不一樣的機器去處理，數據劃分，結果歸約。

　　擴展：

　　問題實例：

　　1).ThecanonicalexampleapplicationofMapReduceisaprocesstocounttheappearancesof

　　eachdifferentwordinasetofdocuments:

　　2).海量數據分佈在100臺電腦中，想個辦法高效統計出這批數據的TOP10。

　　3).一共有N個機器，每一個機器上有N個數。每一個機器最多存O(N)個數並對它們操做。如何找到N^2個數的中數(median)?

　　經典問題分析

　　上千萬or億數據(有重複)，統計其中出現次數最多的前N個數據,分兩種狀況：可一次讀入內存，不可一次讀入。

　　可用思路：trie樹+堆，數據庫索引，劃分子集分別統計，hash，分佈式計算，近似統計，外排序

　　所謂的是否能一次讀入內存，實際上應該指去除重複後的數據量。若是去重後數據能夠放入內存，咱們能夠爲數據創建字典，好比經過map，hashmap，trie，而後直接進行統計便可。固然在更新每條數據的出現次數的時候，咱們能夠利用一個堆來維護出現次數最多的前N個數據，固然這樣致使維護次數增長，不如徹底統計後在求前N大效率高。

　　若是數據沒法放入內存。一方面咱們能夠考慮上面的字典方法可否被改進以適應這種情形，能夠作的改變就是將字典存放到硬盤上，而不是內存，這能夠參考數據庫的存儲方法。

　　固然還有更好的方法，就是能夠採用分佈式計算，基本上就是map-reduce過程，首先能夠根據數據值或者把數據hash(md5)後的值，將數據按照範圍劃分到不一樣的機子，最好可讓數據劃分後能夠一次讀入內存，這樣不一樣的機子負責處理各類的數值範圍，實際上就是map。獲得結果後，各個機子只需拿出各自的出現次數最多的前N個數據，而後彙總，選出全部的數據中出現次數最多的前N個數據，這實際上就是reduce過程。

　　實際上可能想直接將數據均分到不一樣的機子上進行處理，這樣是沒法獲得正確的解的。由於一個數據可能被均分到不一樣的機子上，而另外一個則可能徹底彙集到一個機子上，同時還可能存在具備相同數目的數據。好比咱們要找出現次數最多的前100個，咱們將1000萬的數據分佈到10臺機器上，找到每臺出現次數最多的前100個，歸併以後這樣不能保證找到真正的第100個，由於好比出現次數最多的第100個可能有1萬個，可是它被分到了10臺機子，這樣在每臺上只有1千個，假設這些機子排名在1000個以前的那些都是單獨分佈在一臺機子上的，好比有1001個，這樣原本具備1萬個的這個就會被淘汰，即便咱們讓每臺機子選出出現次數最多的1000個再歸併，仍然會出錯，由於可能存在大量個數爲1001個的發生彙集。所以不能將數據隨便均分到不一樣機子上，而是要根據hash後的值將它們映射到不一樣的機子上處理，讓不一樣的機器處理一個數值範圍。

　　而外排序的方法會消耗大量的IO，效率不會很高。而上面的分佈式方法，也能夠用於單機版本，也就是將總的數據根據值的範圍，劃分紅多個不一樣的子文件，而後逐個處理。處理完畢以後再對這些單詞的及其出現頻率進行一個歸併。實際上就能夠利用一個外排序的歸併過程。

　　另外還能夠考慮近似計算，也就是咱們能夠經過結合天然語言屬性，只將那些真正實際中出現最多的那些詞做爲一個字典，使得這個規模能夠放入內存。

　　【某公司筆試面試題】

　　1使用mr，spark,sparksql編寫wordcount程序

　　【Spark版本】

　　valconf=newSparkConf().setAppName("wd").setMaster("local[1]")

　　valsc=newSparkContext(conf,2)

　　//加載

　　vallines=sc.textFile("tructField("name",DataTypes.StringType,true)")

　　valparis=lines.flatMap(line=>line.split("^A"))

　　valwords=paris.map((_,1))

　　valresult=words.reduceByKey(_+_).sortBy(x=>x._1,false)

　　//打印

　　result.foreach(

　　wds=>{

　　println("單詞："+wds._1+"個數："+wds._2)

　　}

　　)

　　sc.stop()

　　【sparksql版本】

　　valconf=newSparkConf().setAppName("sqlWd").setMaster("local[1]")

　　valsc=newSparkContext(conf)

　　valsqlContext=newSQLContext(sc)

　　//加載

　　vallines=sqlContext.textFile("E:idea15createRecommederdatawords.txt")

　　valwords=lines.flatMap(x=>x.split("")).map(y=>Row(y))

　　valstructType=StructType(Array(StructField("name",DataTypes.StringType,true)))

　　valdf=sqlContext.createDataFrame(rows,structType)

　　df.registerTempTable("t_word_count")

　　sqlContext.udf.register("num_word",(name:String)=>1)

　　sqlContext.sql("selectname,num_word(name)fromt_word_count").groupBy(df.col("name")).count().show()

　　sc.stop()

　　2hive的使用，內外部表的區別，分區做用，UDF和Hive優化

　　(1)hive使用：倉庫、工具

　　(2)hive內外部表：內部表數據永久刪除，外部表數據刪除後、其餘人依然能夠訪問

　　(3)分區做用：防止數據傾斜

　　(4)UDF函數：用戶自定義的函數(主要解決格式，計算問題)，須要繼承UDF類

　　java代碼實現

　　classTestUDFHiveextendsUDF{

　　publicStringevalute(Stringstr){

　　try{

　　return"hello"+str

　　}catch(Exceptione){

　　returnstr+"error"

　　}

　　(5)Hive優化：看作mapreduce處理

　　a排序優化：sortby效率高於orderby

　　b分區：使用靜態分區(statu_date="20160516",location="beijin")，每一個分區對應hdfs上的一個目錄

　　c減小job和task數量：使用表連接操做

　　d解決groupby數據傾斜問題：設置hive.groupby.skewindata=true，那麼hive會自動負載均衡

　　e小文件合併成大文件：錶鏈接操做

　　f使用UDF或UDAF函數：hive中UDTF編寫和使用(轉) - ggjucheng - 博客園

　　3Hbase的rk設計，Hbase優化

　　aowkey:hbase三維存儲中的關鍵(rowkey：行鍵，columnKey(family+quilaty)：列鍵，timestamp：時間戳)

　　owkey字典排序、越短越好

　　使用id+時間：9527+20160517使用hash散列：dsakjkdfuwdsf+9527+20160518

　　應用中，rowkey通常10~100bytes,8字節的整數倍，有利於提升操做系統性能

　　bHbase優化

　　分區：RegionSplit()方法NUMREGIONS=9

　　column不超過3個

　　硬盤配置，便於regionServer管理和數據備份及恢復

　　分配合適的內存給regionserver

　　其餘：

　　hbase查詢

　　(1)get

　　(2)scan

　　使用startRow和endRow限制

　　4Linux經常使用操做

　　aawk：

　　awk-F:`BEGIN{print"nameip"}{print$1$7}END{print"結束"}`/etc/passwd

　　last|head-5|awk`BEGIN{print"nameip"}{print$1$3}END{print"結束了"}`

　　bsed

　　5java線程2種方式實現、設計模式、鏈表操做、排序

　　(1)2種線程實現

　　aThread類繼承

　　TestCLth=newTestCL()//類繼承Thread

　　th.start()

　　b實現Runnable接口

　　Threadth=newThread(newRunnable(){

　　publicvoidrun(){

　　//實現

　　}

　　})

　　th.start()

　　(2)設計模式，分爲4類

　　a建立模式：如工廠模式、單例模式

　　b結構模式：代理模式

　　c行爲模式：觀察者模式

　　d線程池模式

　　6【最熟悉的一個項目簡介、架構圖、使用的技術、你負責哪塊】

　　7cdh集羣監控

　　(1)數據庫監控(2)主機監控(3)服務監控(4)活動監控

　　8計算機網絡工做原理

　　將分散的機器經過數據通訊原理鏈接起來，實現共享!

　　9hadoop生態系統

　　hdfsmapreducehivehbasezookeeperlume

　　hdfs原理及各個模塊的功能mapreduce原理mapreduce優化數據傾斜

　　11系統維護：hadoop升級datanode節點

　　12【講解項目要點：數據量、多少人、分工、運行時間、項目使用機器、算法、技術】

　　13【學會向對方提問】

　　14jvm運行機制及內存原理

　　運行：

　　I加載.class文件

　　II管理而且分配內存

　　III垃圾回收

　　內存原理：

　　IJVM裝載環境和配置

　　II裝載JVM.dll並初始化JVM.dll

　　IV處理class類

　　15hdfs、yarn參數調優

　　mapreduce.job.jvm.num.tasks

　　默認爲1，設置爲-1，重用jvm

　　16Hbase、Hive、impala、zookeeper、Storm、spark原理和使用方法、使用其架構圖講解

　　【某公司筆試題】

　　一、如何爲一個hadoop任務設置mappers的數量

　　答案：

　　使用job.setNumMapTask(intn)手動分割，這是不靠譜的

　　官方文檔：「Note:Thisisonlyahinttotheframework」說明這個方法只是提示做用，不起決定性做用

　　實際上要用公式計算：

　　Max(min.split，min(max.split，block))就設置分片的最大最下值computeSplitSize()設置

　　參考：深度分析如何在Hadoop中控制Map的數量 - 張貴賓的技術專欄 - 博客頻道 - CSDN.NET

　　二、有可能使hadoop任務輸出到多個目錄中麼?若是能夠，怎麼作?

　　答案：在1.X版本後使用MultipleOutputs.java類實現

　　源碼：

　　MultipleOutputs.addNamedOutput(conf,"text2",TextOutputFormat.class,Long.class,String.class);

　　MultipleOutputs.addNamedOutput(conf,"text3",TextOutputFormat.class,Long.class,String.class);

　　參考：MapReduce中的自定義多目錄/文件名輸出HDFS - leejun2005的我的頁面 - 開源中國社區

　　發音：Multiple['m?lt?pl]--》許多的

　　三、如何爲一個hadoop任務設置要建立的reducer的數量

　　答案：job.setNumReduceTask(intn)

　　或者調整hdfs-site.xml中的mapred.tasktracker.reduce.tasks.maximum默認參數值

　　四、在hadoop中定義的主要公用InputFormats中，哪個是默認值：

　　(A)TextInputFormat

　　(B)KeyValueInputFormat

　　(C)SequenceFileInputFormat

　　答案：A

　　五、兩個類TextInputFormat和KeyValueTextInputFormat的區別?

　　答案：

　　?FileInputFormat的子類：

　　TextInputFormat(默認類型，鍵是LongWritable類型，值爲Text類型，key爲當前行在文件中的偏移量，value爲當前行自己);

　　?KeyValueTextInputFormat(適合文件自帶key，value的狀況，只要指定分隔符便可，比較實用，默認是分割);

　　源碼：

　　StringsepStr=job.get("mapreduce.input.keyvaluelinerecordreader.key.value.separator","");

　　注意：在自定義輸入格式時，繼承FileInputFormat父類

　　六、在一個運行的hadoop任務中，什麼是InputSpilt?

　　答案：InputSplit是MapReduce對文件進行處理和運算的輸入單位，只是一個邏輯概念，每一個InputSplit並無對文件實際的切割，只是記錄了要處理的數據的位置(包括文件的path和hosts)和長度(由start和length決定)，默認狀況下與block同樣大。

　　拓展：須要在定義InputSplit後，展開講解mapreduce的原理

　　七、Hadoop框架中，文件拆分是怎麼被調用的?

　　答案：JobTracker，建立一個InputFormat的實例，調用它的getSplits()方法，把輸入目錄的文件拆分紅FileSplist做爲Mappertask的輸入，生成Mappertask加入Queue。

　　源碼中體現了拆分的數量

　　longgoalSize=totalSize/(numSplits==0?1:numSplits);

　　longminSize=Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.

　　FileInputFormat.SPLIT_MINSIZE,1),minSplitSize);//minSplitSize默認是1

　　八、分別舉例什麼狀況下使用combiner,什麼狀況下不會使用?

　　答案：Combiner適用於對記錄彙總的場景(如求和)，可是，求平均數的場景就不能使用Combiner了

　　九、Hadoop中job和Tasks之間的區別是什麼?

　　答案：

　　job是工做的入口，負責控制、追蹤、管理任務，也是一個進程

　　包含maptask和reducetask

　　Tasks是map和reduce裏面的步驟，主要用於完成任務，也是線程

　　十、Hadoop中經過拆分任務到多個節點運行來實現並行計算，可是某些節點運行較慢會拖慢整個任務的運行，hadoop採用何種機制應對這種狀況?

　　答案：結果查看監控日誌，得知產生這種現象的緣由是數據傾斜問題

　　解決：

　　(1)調整拆分mapper的數量(partition數量)

　　(2)增長jvm

　　(3)適當地將reduce的數量變大

　　十一、流API中的什麼特性帶來能夠使mapreduce任務能夠以不一樣語言(如perlubyawk等)實現的靈活性?

　　答案：用可執行文件做爲Mapper和Reducer，接受的都是標準輸入，輸出的都是標準輸出

　　十二、參考下面的M/R系統的場景：

　　--HDFS塊大小爲64MB

　　--輸入類型爲FileInputFormat

　　--有3個文件的大小分別是：64k65MB127MB

　　Hadoop框架會把這些文件拆分爲多少塊?

　　答案：

　　64k------->一個block

　　65MB---->兩個文件：64MB是一個block，1MB是一個block

　　127MB--->兩個文件：64MB是一個block,63MB是一個block

　　1三、Hadoop中的RecordReader的做用是什麼?

　　答案：屬於split和mapper之間的一個過程

　　將inputsplit輸出的行爲一個轉換記錄，成爲key-value的記錄形式提供給mapper

　　1四、Map階段結束後，Hadoop框架會處理：Partitioning,shuffle和sort,在這個階段都會發生了什麼?

　　答案：

　　MR一共有四個階段，splitmapshuffreduce在執行完map以後，能夠對map的輸出結果進行分區，

　　分區：這塊分片肯定到哪一個reduce去計算(彙總)

　　排序：在每一個分區中進行排序，默認是按照字典順序。

　　Group：在排序以後進行分組

　　1五、若是沒有定義partitioner,那麼數據在被送達reducer前是如何被分區的?

　　答案：

　　Partitioner是在map函數執行context.write()時被調用。

　　用戶能夠經過實現自定義的?Partitioner來控制哪一個key被分配給哪一個?Reducer。

　　查看源碼知道：

　　若是沒有定義partitioner，那麼會走默認的分區Hashpartitioner

　　publicclassHashPartitionerextendsPartitioner{

　　/**Use{@linkObject#hashCode()}topartition.*/

　　publicintgetPartition(Kkey,Vvalue,intnumReduceTasks){

　　return(key.hashCode()&Integer.MAX_VALUE)%numReduceTasks;

　　}

　　1六、什麼是Combiner?

　　答案：這是一個hadoop優化性能的步驟，它發生在map與reduce之間

　　目的：解決了數據傾斜的問題，減輕網絡壓力，實際上時減小了maper的輸出

　　源碼信息以下：

　　publicvoidreduce(Textkey,Iteratorvalues,

　　OutputCollectoroutput,Reporterreporter)

　　throwsIOException{

　　LongWritablemaxValue=null;

　　while(values.hasNext()){

　　LongWritablevalue=values.next();

　　if(maxValue==null){

　　maxValue=value;

　　}elseif(value.compareTo(maxValue)>0){

　　maxValue=value;

　　}

　　output.collect(key,maxValue);

　　}

　　在collect實現類中，有這樣一段方法

　　publicsynchronizedvoidcollect(Kkey,Vvalue)

　　throwsIOException{

　　outCounter.increment(1);

　　writer.append(key,value);

　　if((outCounter.getValue()%progressBar)==0){

　　progressable.progress();

　　}

**********************************************

Spark面試經典系列之數據傾斜

Spark面試經典系列之數據傾斜：數據傾斜之痛

一、Spark性能真正的殺手
二、數據傾斜之痛

數據傾斜兩大直接致命性的後果：
一、OOM，通常OOM都是因爲數據傾斜所致
二、速度變慢

數據傾斜基本形態特徵：個別Task處理大量數據

數據傾斜的定位：
一、Web UI,能夠清晰看見哪些Task運行的數據量大小
二、Log，Log的一個好處是能夠清晰的告訴是哪一行出現問題OOM，同時能夠清晰的看到在具體哪一個Stage出現了數據傾斜（數據傾斜通常會在Shuffle過程當中產生的），從而定位具體Shuffle的代碼。也有可能發現絕大多數Task很是快，可是個別Task很是慢。
三、代碼走讀，重點看join、groupByKey、reduceByKey等關鍵代碼
四、對數據特徵分佈進行分析；

解決原理和方法總論

一、Spark數據傾斜解決的原理總論
二、Spark數據傾斜解決方法總論

使數據膨脹，tachyon，複用RDD

Map端Reduce及問題思考

一、Spark數據傾斜解決之Map端Reduce
二、Map端Reduce的問題思考

給小的一段broadcast，而後在大的一端使用mapPartition。
若是數據量太大，有可能引發OOM

採樣分而治之解決方案

一、採樣算法解決數據傾斜的思想
二、採樣算法在Spark數據傾斜中的具體操做

某個或某幾個Key的Value很是大，從而致使數據傾斜
RDD1和RDD2進行join操做，其中咱們採用採樣的方式發現RDD1中有嚴重的數據傾斜的Key
第一步:採用Spark RDD中提供的採樣接口，咱們能夠很方便的對全體（例如100億條數據）進行採樣，而後基於採樣的數據，咱們能夠計算出哪一個（哪些）Key的Value個數最多；
第二步：把全體數據分紅兩部分，即把原來RDD1變成RDD11和RDD12，其中RDD11表明致使數據傾斜的Key，RDD12中包含的是不會產生數據傾斜的Key；
第三步：把RDD11和RDD2進行join操做，且把RDD12和RDD2進行join操做，而後把分別join操做後的結果進行Union操做，從而得出和RDD1與RDD2直接進行join操做相同的結果

Spark本身的機制保證的不會產生數據傾斜。

上述流程中：
第一種狀況：若是RDD11中的數據量不是不少，能夠採用map端的join操做，避免了shuffle和數據傾斜。
第二種狀況：若是RDD11中的數據量特別多，此時之因此可以緩解數據傾斜是由於採用了Spark Core自然的並行機制對RDD11中的一樣一個Key的數據進行了拆分。從而達到讓本來傾斜的Key分散到不一樣的Task的目的，就緩解了數據傾斜。

思考：在上述過程當中若是把傾斜的Key加上隨機數，會怎麼樣？
增長隨機數，並行Task數量可能增長，具體是如何操做的？
RDD11中傾斜的Key加上1000之內的隨機數，而後和RDD2進行join操做？不行！此時必定須要把RDD11中的Key在RDD2中的相同的Key進行1000之內的隨機數，而後再進行join操做，這樣作的好處：讓傾斜的Key更加不傾斜，在實際生產環境下，會極大的解決在兩個進行join的RDD數量都很大且其中一個RDD有一個或者兩三個明顯傾斜的Key的狀況下的數據傾斜問題。

對於兩個RDD數據量都很大且傾斜的Key特別多如何解決？

一、數據量都很大且傾斜的Key多的狀況
二、此種狀況下具體操做步驟

兩個RDD數據都特別多且傾斜的Key成千上萬個，該如何解決數據傾斜的問題？
初步的想法：在傾斜的Key上面加上隨機數
該想法的緣由：shuffle的時候把key的數據分到不一樣的task裏去

可是如今的傾斜的key很是多，成千上萬，因此若是說採樣找出傾斜的key的話並非一個很是好的想法

擴容？
首先，什麼是擴容？就是把該RDD中的每一條數據變成5條、10條、20條等，例如RDD中原來是10億條數據，擴容後可能變成1000億條數據；
其次，如何作到擴容？flatMap中對要進行擴容的每一條數據都經過0~N-1個不一樣的前綴變成N條數據（例如變成）
問題：N的值能夠隨便取嗎？須要考慮當前程序可以使用的Core的數量
答案：N的數值通常不能取的太大，一般小於50，不然會對磁盤、內存、網絡都會造成極大負擔，例如會形成OOM

N這個數值取成10和1000除了OOM等不一樣之外，是否還有其餘影響呢？其實N的數值的大小還會對數據傾斜的解決程度構成直接的影響！N越大，越不容易傾斜，可是也會佔用更多的內存、磁盤、網絡以及（沒必要要的）消耗更多的CPU時間

模擬代碼:
RDD1 join RDD2

rdd22 = RDD2.flatMap{
for(0 to 9) {
0_item
}
}

rdd11 = RDD1.map{
Random(10)
random_item
}

result = rdd11.join(rdd22)

result.map{
item_1.split 去掉前綴
}

並行度的深度使用

一、並行度的初級使用
二、並行度的高級使用

用並行度解決數據傾斜的基本應用：例如reduceByKey
改變並行度之因此可以改善數據傾斜的緣由在於，若是某個Task有100個Key且數據量特別大，就極有可能致使OOM或者任務運行特別緩慢，此時若是把並行度變大，則能夠分解該Task的數據量，例如把本來該Task的100個Key分解給10個Task，這個就能夠減小每一個Task的數據量，從而有可能解決OOM和任務慢的問題。
對於reduceByKey而言，你能夠傳入並行度的參數，也能夠自定義Partitioner
增長Executor：改變計算資源，從僅僅數據傾斜的角度來看並不可以直接去解決數據傾斜的問題，可是也有好處，好處是能夠同時併發運行更多的Task，結果是可能加快了運行速度。

用並行度解決數據傾斜的高級使用：例如reduceByKey
假設說有傾斜的Key，咱們給全部的Key加上一個隨機數，而後進行reduceByKey操做；此時同一個Key會有不一樣的隨機數前綴，在進行reduceByKey操做的時候原來的一個很是大的傾斜的Key就分而治之變成若干個更小的Key，不過此時結果和原來不同，怎麼破？進行map操做，目的是把隨機數前綴去掉，而後再次進行reduceByKey操做。（固然，若是你很無聊，能夠再次作隨機數前綴），這樣咱們就能夠把本來傾斜的Key經過分而治之方案分散開來，最後又進行了全局聚合，在這裏的本質仍是經過改變並行度去解決數據傾斜的問題。

解決方案的「銀彈」是什麼？

一、數據傾斜解決方案總結
二、方案以外的方案
三、數據傾斜解決方案的「銀彈」?

逃離Spark技術自己以外如何解決數據傾斜的問題？
之因此會有這樣的想法，是由於從結果上來看，數據傾斜的產生來自於數據和數據的處理技術，前面幾節課和你們分享都是數據的處理技術層面如何解決數據傾斜，所以，咱們如今須要回到數據的層面去解決數據傾斜的問題。
數據自己就是Key-Value的存在方式，所謂的數據傾斜就是說某（幾）個Key的Values特別多，因此若是要解決數據傾斜，實質上是解決單一的Key的Values的個數特別多的狀況。新的數據傾斜解決方案由此誕生了。
一、把一個大的Key-Values數據分解成爲Key-subKey-Values的方式
二、預先和其餘的表進行join，將數據傾斜提早到上游的Hive ETL
三、能夠把大的Key-Values中的Values組拼成爲一個字符串，從而造成只有一個元素的Key-Value。
四、加一箇中間適配層，當數據進來的時候進行Key的統計和動態排名，基於該排名動態調整Key分佈

假如10萬個Key都發生了數據傾斜，如何解決呢？此時通常就是加內存和Core

******************************************************

一、將現有邏輯在Spark上面實現。

二、數據傾斜怎麼處理？

數據傾斜有不少解決方案，本例子簡要介紹一種實現方式，假設表A 和表B鏈接，表A 數據傾斜，只有一個key傾斜，首先對A進行採樣，統計出最傾斜的key，將A 表分隔爲A1 只有傾斜 key， A2 不包含傾斜key，而後分別與表B 鏈接。

最後將結果合併， union

3 、各完成一個awk和sed的例子，最簡單的應用便可，並說明。

   cat /etc/passwd |awk  -F ':'  '{print $1}'   讀取文件，指定文本分隔符，而後打印第一個域

cat test.sh | sed '2,50d' 讀取文件的每一行，而後對每一行進行處理後打印在控制檯，有不少模式，不少方法。還能夠直接修改文件

四、簡要描述你知道的數據挖掘算法和使用場景

（一）基於分類模型的案例

（ 1）垃圾郵件的判別一般會採用樸素貝葉斯的方法進行判別

（2）醫學上的腫瘤判斷經過分類模型識別

（二）基於預測模型的案例

（1）紅酒品質的判斷分類迴歸樹模型進行預測和判斷紅酒的品質

（ 2）搜索引擎的搜索量和股價波動

（三）基於關聯分析的案例：沃爾瑪的啤酒尿布

（四）基於聚類分析的案例：零售客戶細分

（五）基於異常值分析的案例：支付中的交易欺詐偵測

（六）基於協同過濾的案例：電商猜你喜歡和推薦引擎

（七）基於社會網絡分析的案例：電信中的種子客戶

（八）基於文本分析的案例

（1）字符識別：掃描王APP

（2）文學著做與統計：紅樓夢歸屬

五、列舉你知道的經常使用的Hadoop管理和監控的命令、好比hdfs dfs -mkdir /usr

-ls -cat -text -cp -put -chmod -chown

-du -get -copyFromLocal -copyToLocal

-mv -rm - tail -chgrp

六、評述hadoop運行原理

站在高處，大的方面講解

一、有hdfs 負責數據存放是Hadoop的分佈式文件存儲系統

將大文件分解爲多個Block，每一個Block保存多個副本。提供容錯機制，副本丟失或者宕機時自動恢復。
默認每一個Block保存3個副本，64M爲1個Block。
將Block按照key-value映射到內存當中。

二、有mapreduce負責計算，Map（映射）和Reduce（歸約）

七、講述mapreduce的原理

ApplicationMaster 是一個詳細的框架庫，它結合從 ResourceManager 得到的資源和 NodeManager 協同工做來運行和監控任務。

ResourceManager 支持分層級的應用隊列，這些隊列享有集羣必定比例的資源。從某種意義上講它就是一個純粹的調度器，

ApplicationMaster 的職責有：向調度器索要適當的資源容器，運行任務，跟蹤應用程序的狀態和監控它們的進程，處理任務的失敗緣由。

輸入分片（input split）

map階段：

combiner階段：

八、JVM&垃圾回收機制

三個代：年輕代（Young Generation）、年老代（Old Generation）和持久代（Permanent Generation）。

九、找出公共好友：

http://www.cnblogs.com/lucius/p/3483494.html

http://www.aboutyun.com/thread-18826-1-1.html

原理：A 有好友 B ,C,D F 有好友 D E F

其實A 的好友也是他好友的好友

其實F 的好友也是他的好友的好友

那麼D 的共同好友就是 A F

十、combiner做用

Combiner最基本是實現本地key的聚合，對map輸出的key排序、value進行迭代。

Combiner還有本地reduce功能（其本質上就是一個reduce）：

使用Combiner先完成在map端的本地聚合，能夠減小網絡傳輸數據量，提升性能。

平均數的歸約算法不能屢次調用。

十一、在mr環節中，那些環節須要優化，如何優化，請詳細說明。

一、 setNumReduceTasks 適當的設置reduce的數量，若是數據量比較大，那麼能夠增長reduce的數量

二、適當的時候使用 combine 函數，減小網絡傳輸數據量

三、壓縮map和reduce的輸出數據

四、使用SequenceFile二進制文件。

五、經過application 的ui頁面觀察job的運行參數

六、太多小文件，形成map任務過多的問題，應該能夠先合併小文件，或者有一個特定的map做爲處理小文件的輸入

七、map端效率低緣由分析

源文件的大小遠小於HDFS的塊的大小。這意味着任務的開啓和中止要耗費更多的時間，就沒有足夠的時間來讀取並處理輸入數據。
源文件沒法分塊。這致使須要經過網絡IO從其餘節點讀取文件塊。
一個節點的本地磁盤或磁盤控制器運行在降級模式中，讀取寫入性能都不好。這會影響某個節點，而不是所有節點。
源文件不來自於HDFS。則多是Hadoop節點和數據源之間的延遲致使了性能低下。
Map任務從其餘數據節點讀取數據。能夠從JobTracker的map任務細節信息和任務運行嘗試中找到輸入塊的位置。若是輸入塊的位置不是任務執行的節點，那就不是本地數據了。

技術33 Reduce實例不足或過多

技術34 診斷reduce段的數據傾斜的問題

技術35 肯定reduce任務是否存在總體吞吐量太低

技術36 緩慢的洗牌（shuffle）和排序

技術37 做業競爭和調度器限制

1.查找硬件的失效

CPU競爭

3 內存交換

4 磁盤健康

網絡

技術46 規避使用reduce

技術48 使用combine

技術50 收集傾斜數據

減少Reduce端數據傾斜的性能損失

抽樣和範圍分區

方法2：自定義分區

方法3：Combine

方法4：Map端鏈接和半鏈接

數據大小傾斜的自定義策略

1.正則表達式（少用）

2.字符串令牌化（TOKENIZATION）Apache commons中的StringUtils類效率要更好

3.對象重用

4字符串鏈接

5對象的內存資源消耗

6.4.6 優化數據序列化

壓縮

二進制文件格式使用二進制文件格式，如Avro和SequenceFile，能夠使數據的表達更爲緊湊，並提升編組（marshalling）和逆編組的效率，相比文本格式要更爲高效。

確保精確的度量，理解如何得到MapReduce和系統的性能指標
使用性能指標來減小潛在的性能問題
經過檢查MapRecue/HDFS配置，優化MapReduce洗牌/排序階段，優化用戶JAVA代碼，來修復常見的性能問題

5.1 小文件

技術24 使用Avro存儲多個小文件

最簡單的方案就是將HDFS中的小文件打包到一個大的文件容器中。這個技術中將本地磁盤中全部的目標文件存儲到HDFS中的一個單獨的Avro文件。而後在MapReduce中處理Avro文件和其中的小文件。

壓縮依賴

CombineFileInputFormat

基於壓縮的高效存儲

-------------------------------

Hadoop（1）MapReduce 性能調優：性能測量（Measuring）
http://www.aboutyun.com/thread-15514-1-1.html

Hadoop（2）MapReduce 性能調優：理解性能瓶頸，診斷map性能瓶頸
http://www.aboutyun.com/thread-15517-1-1.html

Hadoop（3）MapReduce 性能調優：診斷reduce性能瓶頸
http://www.aboutyun.com/thread-15522-1-1.html

Hadoop（4）MapReduce 性能調優：診斷通常性能瓶頸
http://www.aboutyun.com/thread-15660-1-1.html

Hadoop（5）MapReduce 性能調優：診斷硬件性能瓶頸
http://www.aboutyun.com/thread-15534-1-1.html

Hadoop（6）MapReduce 性能調優：優化洗牌（shuffle）和排序階段
http://www.aboutyun.com/thread-15545-1-1.html

Hadoop（7）MapReduce 性能調優：減少數據傾斜的性能損失
http://www.aboutyun.com/thread-15544-1-1.html

Hadoop（8）MapReduce 性能調優：優化MapReduce的用戶Java代碼
http://www.aboutyun.com/thread-15583-1-1.html

Hadoop（9）MapReduce 性能調優：優化數據序列化
http://www.aboutyun.com/thread-15658-1-1.html

Hadoop（10）MapReduce 文件處理：小文件
http://www.aboutyun.com/thread-15592-1-1.html

Hadoop（11）MapReduce 文件處理：基於壓縮的高效存儲（一）
http://www.aboutyun.com/thread-15626-1-1.html

Hadoop（12）MapReduce 文件處理：基於壓縮的高效存儲（二）
http://www.aboutyun.com/thread-15629-1-1.html

****************************************************************

使用案例機器學習

1.商品特徵未讀降維：SVD 、PCA
2.商品掛錯頁面檢查：TF-IDF、SVM、Logistic - -Regression
3.相關推薦算法模型訓練：Loginistic Regression、kmeans、SVM
4.商品爆品預測：Loginistic Regression
5.關聯性分析：FPGrowth
6.開發了基於Mllib的機器學習平臺

經驗分享

用戶常見錯誤

1.
問題：Collect 大量數據到Driver端，致使driver oom；算法開發的時候沒有注意

解決：driver不能堆積大量數據，儘可能不要在driver保存數據

2.
問題：維表數據沒用cache內存或者repartition數目太多
解決：將維表數據cache到內存，分區數目不能太多

3.
問題：未對Spark的持久化級別進行選擇，須要根據實際的業務需求進行選擇
解決：統計RDD的數據量，大數據量將Memory_AND_DISK做爲首選

4.
問題：讀寫DB沒有設置合理的分區數目，併發量過高，影響業務
解決：統計DB的表分區結構，監控DB服務load，壓測到位

5.
問題：Spark使用Hbase scan性能不穩定
解決：Get性能相對穩定，儘可能使用Get

6.
問題：History server 重啓須要回放180G日誌，須要4個小時，新完成的app在History server沒法當即看到
解決：改成多線程會放 SPARK-13988

7.
問題常常回出現class not found ，可是class文件再包裏面存在
解決辦法打印classloadder分析，建議不要輕易修改源碼classloader

8.
PCA算法只能支持小於14W feature特性
解決辦法使用SVD進行降維

9.
問題 FPGrowth不支持 KryoSerializer
解決辦法 1.6.2 以前使用Java Serializer

10.
Spark在使用JDBC接口創建DataFrame時，需經過執行SQL來獲取該JDBC數據源的Schema，致使建立大量的DataFrame的時候很是耗時

解決辦法：Schema相同的table能夠不用重複獲取schema
地址：https://github.com/ouyangshourui/SparkJDBCSchema/wiki
4000個DataFrame的初始化時間從原先的25分鐘縮短爲10分鐘之內

Spark平臺權限

1.4.0 Standalone cluster模式不支持多用戶
相關組件讀寫權限問題沒法解決，好比讀取Hive、hbase、HDFS數據的權限問題
解決辦法：修改SparkContext sparkuser 和system username
代碼地址：https://github.com/ouyangshourui/ouyangshourui/StandalongClusterAuthorization/wiki

Spark Sql hive元數據密碼加密，javax.jdo.option.ConnectionPassword暴露給用戶比較危險
解決辦法：修改HiveContext.Scala文件中的metadataHive變量，選擇自定義的解密算法解密
代碼地址： https://github.com/ouyangshourui/HivePasswordEncryptionDecryption/wiki

Spark1.5.2 Sql放大了Hive讀權限，任何用戶均可以讀取別的用戶的Hive表數據
臨時解決辦法，生成HiveTableScan operator時調用driver已有的Hive Client 權限接口檢查當前用戶的讀權限

https://github.com/ouyangshourui/HiveReadpermission/wiki

升級遇到的問題

1.4.0 Standalone 升級到1.5.2 on Yarn

用戶代碼使用system.exit(-1) RM web UI卻顯示正常，建議直接hrow exception

自定義封裝MySQL PostgreSql JDBC 沒有考慮driver JDBC Dialect的實現致使數據沒法返回。
每一個Executor都與Hive簡歷connection去獲取HiveConf 沒有broadcast HiveConf（SPARK -10679）

多版本Spark Dynamic Persource Allocation沒法共存，DRA需重啓Yarn NodeManger ，耦合性太強（沒有解決）

TODO

Spark Streaming 全面落地，吸取Apache Bean思想
Spark Sql替代大部分Hive任務
SPark現有任務優化加速
完善機器學習平臺覆蓋大部分電商和金融領域機器學習算法庫

全面擁抱Spark2.0 參與社區

************************************************************************

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);

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

[root@hadoop1 ~]# echo 1+1 && echo "1+1" && echo "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

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

task 的最大數

</property>

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

ducetask 的最大數

</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 爲例：

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

</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）兩個文件合併的問題

給定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 <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)你在項目中遇到了哪些難題，是怎麼解決的？

一、在執行任務時發現副本的個數不對，通過一番的查找發現是超時的緣由，修改了配置文件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中

*****************************************************************************

面試回來以後把其中比較重要的問題記了下來寫了個總結：
（答案在後面）

一、簡答說一下hadoop的map-reduce編程模型

二、hadoop的TextInputFormat做用是什麼，如何自定義實現

三、hadoop和spark的都是並行計算，那麼他們有什麼相同和區別

四、爲何要用flume導入hdfs，hdfs的構架是怎樣的

五、map-reduce程序運行的時候會有什麼比較常見的問題

六、簡單說一下hadoop和spark的shuffle過程

如下是本身的理解，若是有不對的地方但願各位大俠能夠幫我指出來~：

一、簡答說一下hadoop的map-reduce編程模型

首先map task會從本地文件系統讀取數據，轉換成key-value形式的鍵值對集合

使用的是hadoop內置的數據類型，好比longwritable、text等

將鍵值對集合輸入mapper進行業務處理過程，將其轉換成須要的key-value在輸出

以後會進行一個partition分區操做，默認使用的是hashpartitioner，能夠經過重寫hashpartitioner的getpartition方法來自定義分區規則

以後會對key進行進行sort排序，grouping分組操做將相同key的value合併分組輸出，在這裏能夠使用自定義的數據類型，重寫WritableComparator的Comparator方法來自定義排序規則，重寫RawComparator的compara方法來自定義分組規則

以後進行一個combiner歸約操做，其實就是一個本地段的reduce預處理，以減少後面shufle和reducer的工做量

reduce task會經過網絡將各個數據收集進行reduce處理，最後將數據保存或者顯示，結束整個job

二、hadoop的TextInputFormat做用是什麼，如何自定義實現

InputFormat會在map操做以前對數據進行兩方面的預處理
1是getSplits，返回的是InputSplit數組，對數據進行split分片，每片交給map操做一次
2是getRecordReader，返回的是RecordReader對象，對每一個split分片進行轉換爲key-value鍵值對格式傳遞給map

經常使用的InputFormat是TextInputFormat，使用的是LineRecordReader對每一個分片進行鍵值對的轉換，以行偏移量做爲鍵，行內容做爲值

自定義類繼承InputFormat接口，重寫createRecordReader和isSplitable方法
在createRecordReader中能夠自定義分隔符

三、hadoop和spark的都是並行計算，那麼他們有什麼相同和區別

二者都是用mr模型來進行並行計算，hadoop的一個做業稱爲job，job裏面分爲map task和reduce task，每一個task都是在本身的進程中運行的，當task結束時，進程也會結束

spark用戶提交的任務成爲application，一個application對應一個sparkcontext，app中存在多個job，每觸發一次action操做就會產生一個job

這些job能夠並行或串行執行，每一個job中有多個stage，stage是shuffle過程當中DAGSchaduler經過RDD之間的依賴關係劃分job而來的，每一個stage裏面有多個task，組成taskset有TaskSchaduler分發到各個executor中執行，executor的生命週期是和app同樣的，即便沒有job運行也是存在的，因此task能夠快速啓動讀取內存進行計算

hadoop的job只有map和reduce操做，表達能力比較欠缺並且在mr過程當中會重複的讀寫hdfs，形成大量的io操做，多個job須要本身管理關係

spark的迭代計算都是在內存中進行的，API中提供了大量的RDD操做如join，groupby等，並且經過DAG圖能夠實現良好的容錯

四、爲何要用flume導入hdfs，hdfs的構架是怎樣的

flume能夠實時的導入數據到hdfs中，當hdfs上的文件達到一個指定大小的時候會造成一個文件，或者超過指定時間的話也造成一個文件

文件都是存儲在datanode上面的，namenode記錄着datanode的元數據信息，而namenode的元數據信息是存在內存中的，因此當文件切片很小或者不少的時候會卡死

五、map-reduce程序運行的時候會有什麼比較常見的問題

好比說做業中大部分都完成了，可是總有幾個reduce一直在運行

這是由於這幾個reduce中的處理的數據要遠遠大於其餘的reduce，多是由於對鍵值對任務劃分的不均勻形成的數據傾斜

解決的方法能夠在分區的時候從新定義分區規則對於value數據不少的key能夠進行拆分、均勻打散等處理，或者是在map端的combiner中進行數據預處理的操做

六、簡單說一下hadoop和spark的shuffle過程

hadoop：map端保存分片數據，經過網絡收集到reduce端
spark：spark的shuffle是在DAGSchedular劃分Stage的時候產生的，TaskSchedule要分發Stage到各個worker的executor

減小shuffle能夠提升性能

部分答案不是十分準確歡迎補充:-)

——-補充更新———

一、Hive中存放是什麼？
表。
存的是和hdfs的映射關係，hive是邏輯上的數據倉庫，實際操做的都是hdfs上的文件，HQL就是用sql語法來寫的mr程序。

二、Hive與關係型數據庫的關係？
沒有關係，hive是數據倉庫，不能和數據庫同樣進行實時的CURD操做。
是一次寫入屢次讀取的操做，能夠當作是ETL工具。

三、Flume工做機制是什麼？
核心概念是agent，裏面包括source、chanel和sink三個組件。
source運行在日誌收集節點進行日誌採集，以後臨時存儲在chanel中，sink負責將chanel中的數據發送到目的地。
只有成功發送以後chanel中的數據纔會被刪除。
首先書寫flume配置文件，定義agent、source、chanel和sink而後將其組裝，執行flume-ng命令。

四、Sqoop工做原理是什麼？
hadoop生態圈上的數據傳輸工具。
能夠將關係型數據庫的數據導入非結構化的hdfs、hive或者bbase中，也能夠將hdfs中的數據導出到關係型數據庫或者文本文件中。
使用的是mr程序來執行任務，使用jdbc和關係型數據庫進行交互。
import原理：經過指定的分隔符進行數據切分，將分片傳入各個map中，在map任務中在每行數據進行寫入處理沒有reduce。
export原理：根據要操做的表名生成一個java類，並讀取其元數據信息和分隔符對非結構化的數據進行匹配，多個map做業同時執行寫入關係型數據庫

五、Hbase行健列族的概念，物理模型，表的設計原則？
行健：是hbase表自帶的，每一個行健對應一條數據。
列族：是建立表時指定的，爲列的集合，每一個列族做爲一個文件單獨存儲，存儲的數據都是字節數組，其中的數據能夠有不少，經過時間戳來區分。
物理模型：整個hbase表會拆分爲多個region，每一個region記錄着行健的起始點保存在不一樣的節點上，查詢時就是對各個節點的並行查詢，當region很大時使用.META表存儲各個region的起始點，-ROOT又能夠存儲.META的起始點。
rowkey的設計原則：各個列簇數據平衡，長度原則、相鄰原則，建立表的時候設置表放入regionserver緩存中，避免自動增加和時間，使用字節數組代替string，最大長度64kb，最好16字節之內，按天分表，兩個字節散列，四個字節存儲時分毫秒。
列族的設計原則：儘量少（按照列族進行存儲，按照region進行讀取，沒必要要的io操做），常常和不常用的兩類數據放入不一樣列族中，列族名字儘量短。

六、Spark Streaming和Storm有何區別？
一個實時毫秒一個準實時亞秒，不過storm的吞吐率比較低。

七、mllib支持的算法？
大致分爲四大類，分類、聚類、迴歸、協同過濾。

八、簡答說一下hadoop的map-reduce編程模型？
首先map task會從本地文件系統讀取數據，轉換成key-value形式的鍵值對集合。
將鍵值對集合輸入mapper進行業務處理過程，將其轉換成須要的key-value在輸出。
以後會進行一個partition分區操做，默認使用的是hashpartitioner，能夠經過重寫hashpartitioner的getpartition方法來自定義分區規則。
以後會對key進行進行sort排序，grouping分組操做將相同key的value合併分組輸出。
在這裏能夠使用自定義的數據類型，重寫WritableComparator的Comparator方法來自定義排序規則，重寫RawComparator的compara方法來自定義分組規則。
以後進行一個combiner歸約操做，其實就是一個本地段的reduce預處理，以減少後面shufle和reducer的工做量。
reduce task會經過網絡將各個數據收集進行reduce處理，最後將數據保存或者顯示，結束整個job。

九、Hadoop平臺集羣配置、環境變量設置？
zookeeper：修改zoo.cfg文件，配置dataDir，和各個zk節點的server地址端口，tickTime心跳時間默認是2000ms，其餘超時的時間都是以這個爲基礎的整數倍，以後再dataDir對應目錄下寫入myid文件和zoo.cfg中的server相對應。

hadoop：修改
hadoop-env.sh配置java環境變量
core-site.xml配置zk地址，臨時目錄等
hdfs-site.xml配置nn信息，rpc和http通訊地址，nn自動切換、zk鏈接超時時間等
yarn-site.xml配置resourcemanager地址
mapred-site.xml配置使用yarn
slaves配置節點信息
格式化nn和zk。

hbase：修改
hbase-env.sh配置java環境變量和是否使用自帶的zk
hbase-site.xml配置hdfs上數據存放路徑，zk地址和通信超時時間、master節點
regionservers配置各個region節點
zoo.cfg拷貝到conf目錄下

spark：
安裝Scala
修改spark-env.sh配置環境變量和master和worker節點配置信息

環境變量的設置：直接在/etc/profile中配置安裝的路徑便可，或者在當前用戶的宿主目錄下，配置在.bashrc文件中，該文件不用source從新打開shell窗口便可，配置在.bash_profile的話只對當前用戶有效。

十、Hadoop性能調優？

調優能夠經過系統配置、程序編寫和做業調度算法來進行。
hdfs的block.size能夠調到128/256（網絡很好的狀況下，默認爲64）
調優的大頭：mapred.map.tasks、mapred.reduce.tasks設置mr任務數（默認都是1）
mapred.tasktracker.map.tasks.maximum每臺機器上的最大map任務數
mapred.tasktracker.reduce.tasks.maximum每臺機器上的最大reduce任務數
mapred.reduce.slowstart.completed.maps配置reduce任務在map任務完成到百分之幾的時候開始進入
這個幾個參數要看實際節點的狀況進行配置，reduce任務是在33%的時候完成copy，要在這以前完成map任務，（map能夠提早完成）
mapred.compress.map.output,mapred.output.compress配置壓縮項，消耗cpu提高網絡和磁盤io
合理利用combiner
注意重用writable對象

十一、Hadoop高併發？
首先確定要保證集羣的高可靠性，在高併發的狀況下不會掛掉，支撐不住能夠經過橫向擴展。
datanode掛掉了使用hadoop腳本從新啓動。

十二、hadoop的TextInputFormat做用是什麼，如何自定義實現？
InputFormat會在map操做以前對數據進行兩方面的預處理。
1是getSplits，返回的是InputSplit數組，對數據進行split分片，每片交給map操做一次。
2是getRecordReader，返回的是RecordReader對象，對每一個split分片進行轉換爲key-value鍵值對格式傳遞給map。
經常使用的InputFormat是TextInputFormat，使用的是LineRecordReader對每一個分片進行鍵值對的轉換，以行偏移量做爲鍵，行內容做爲值。
自定義類繼承InputFormat接口，重寫createRecordReader和isSplitable方法。
在createRecordReader中能夠自定義分隔符。

1三、hadoop和spark的都是並行計算，那麼他們有什麼相同和區別？
二者都是用mr模型來進行並行計算，hadoop的一個做業稱爲job，job裏面分爲map task和reduce task，每一個task都是在本身的進程中運行的，當task結束時，進程也會結束。
spark用戶提交的任務成爲application，一個application對應一個sparkcontext，app中存在多個job，每觸發一次action操做就會產生一個job。
這些job能夠並行或串行執行，每一個job中有多個stage，stage是shuffle過程當中DAGSchaduler經過RDD之間的依賴關係劃分job而來的，每一個stage裏面有多個task，組成taskset有TaskSchaduler分發到各個executor中執行，executor的生命週期是和app同樣的，即便沒有job運行也是存在的，因此task能夠快速啓動讀取內存進行計算。
hadoop的job只有map和reduce操做，表達能力比較欠缺並且在mr過程當中會重複的讀寫hdfs，形成大量的io操做，多個job須要本身管理關係。
spark的迭代計算都是在內存中進行的，API中提供了大量的RDD操做如join，groupby等，並且經過DAG圖能夠實現良好的容錯。

1四、爲何要用flume導入hdfs，hdfs的構架是怎樣的？
flume能夠實時的導入數據到hdfs中，當hdfs上的文件達到一個指定大小的時候會造成一個文件，或者超過指定時間的話也造成一個文件。
文件都是存儲在datanode上面的，namenode記錄着datanode的元數據信息，而namenode的元數據信息是存在內存中的，因此當文件切片很小或者不少的時候會卡死。

1五、map-reduce程序運行的時候會有什麼比較常見的問題？
好比說做業中大部分都完成了，可是總有幾個reduce一直在運行。
這是由於這幾個reduce中的處理的數據要遠遠大於其餘的reduce，多是由於對鍵值對任務劃分的不均勻形成的數據傾斜。
解決的方法能夠在分區的時候從新定義分區規則對於value數據不少的key能夠進行拆分、均勻打散等處理，或者是在map端的combiner中進行數據預處理的操做。

1六、簡單說一下hadoop和spark的shuffle過程？
hadoop：map端保存分片數據，經過網絡收集到reduce端。
spark：spark的shuffle是在DAGSchedular劃分Stage的時候產生的，TaskSchedule要分發Stage到各個worker的executor。
減小shuffle能夠提升性能。

1七、RDD機制？
rdd分佈式彈性數據集，簡單的理解成一種數據結構，是spark框架上的通用貨幣。
全部算子都是基於rdd來執行的，不一樣的場景會有不一樣的rdd實現類，可是均可以進行互相轉換。
rdd執行過程當中會造成dag圖，而後造成lineage保證容錯性等。
從物理的角度來看rdd存儲的是block和node之間的映射。

1八、spark有哪些組件？
（1）master：管理集羣和節點，不參與計算。
（2）worker：計算節點，進程自己不參與計算，和master彙報。
（3）Driver：運行程序的main方法，建立spark context對象。
（4）spark context：控制整個application的生命週期，包括dagsheduler和task scheduler等組件。
（5）client：用戶提交程序的入口。

1九、spark工做機制？
用戶在client端提交做業後，會由Driver運行main方法並建立spark context上下文。
執行add算子，造成dag圖輸入dagscheduler，按照add之間的依賴關係劃分stage輸入task scheduler。
task scheduler會將stage劃分爲task set分發到各個節點的executor中執行。

20、spark的優化怎麼作？
經過spark-env文件、程序中sparkconf和set property設置。
（1）計算量大，造成的lineage過大應該給已經緩存了的rdd添加checkpoint，以減小容錯帶來的開銷。
（2）小分區合併，太小的分區形成過多的切換任務開銷，使用repartition。

2一、kafka工做原理？
producer向broker發送事件，consumer從broker消費事件。
事件由topic區分開，每一個consumer都會屬於一個group。
相同group中的consumer不能重複消費事件，而同一事件將會發送給每一個不一樣group的consumer。

2二、ALS算法原理？
答：對於user-product-rating數據，als會創建一個稀疏的評分矩陣，其目的就是經過必定的規則填滿這個稀疏矩陣。
als會對稀疏矩陣進行分解，分爲用戶-特徵值，產品-特徵值，一個用戶對一個產品的評分能夠由這兩個矩陣相乘獲得。
經過固定一個未知的特徵值，計算另一個特徵值，而後交替反覆進行最小二乘法，直至差平方和最小，便可得想要的矩陣。

2三、kmeans算法原理？
隨機初始化中心點範圍，計算各個類別的平均值獲得新的中心點。
從新計算各個點到中心值的距離劃分，再次計算平均值獲得新的中心點，直至各個類別數據平均值無變化。

2四、canopy算法原理？
根據兩個閾值來劃分數據，以隨機的一個數據點做爲canopy中心。
計算其餘數據點到其的距離，劃入t一、t2中，劃入t2的從數據集中刪除，劃入t1的其餘數據點繼續計算，直至數據集中無數據。

2五、樸素貝葉斯分類算法原理？
對於待分類的數據和分類項，根據待分類數據的各個特徵屬性，出如今各個分類項中的機率判斷該數據是屬於哪一個類別的。

2六、關聯規則挖掘算法apriori原理？
一個頻繁項集的子集也是頻繁項集，針對數據得出每一個產品的支持數列表，過濾支持數小於預設值的項，對剩下的項進行全排列，從新計算支持數，再次過濾，重複至全排列結束，可獲得頻繁項和對應的支持數。

做者：@小黑

如下是本身的理解，若是有不對的地方但願各位大俠能夠幫我指出來~：

一、簡答說一下hadoop的map-reduce編程模型

首先map task會從本地文件系統讀取數據，轉換成key-value形式的鍵值對集合

使用的是hadoop內置的數據類型，好比longwritable、text等

將鍵值對集合輸入mapper進行業務處理過程，將其轉換成須要的key-value在輸出

以後會進行一個partition分區操做，默認使用的是hashpartitioner，能夠經過重寫hashpartitioner的getpartition方法來自定義分區規則

以後進行一個combiner歸約操做，其實就是一個本地段的reduce預處理，以減少後面shufle和reducer的工做量

reduce task會經過網絡將各個數據收集進行reduce處理，最後將數據保存或者顯示，結束整個job

二、hadoop的TextInputFormat做用是什麼，如何自定義實現

經常使用的InputFormat是TextInputFormat，使用的是LineRecordReader對每一個分片進行鍵值對的轉換，以行偏移量做爲鍵，行內容做爲值

自定義類繼承InputFormat接口，重寫createRecordReader和isSplitable方法
在createRecordReader中能夠自定義分隔符

三、hadoop和spark的都是並行計算，那麼他們有什麼相同和區別

spark用戶提交的任務成爲application，一個application對應一個sparkcontext，app中存在多個job，每觸發一次action操做就會產生一個job

hadoop的job只有map和reduce操做，表達能力比較欠缺並且在mr過程當中會重複的讀寫hdfs，形成大量的io操做，多個job須要本身管理關係

spark的迭代計算都是在內存中進行的，API中提供了大量的RDD操做如join，groupby等，並且經過DAG圖能夠實現良好的容錯

四、爲何要用flume導入hdfs，hdfs的構架是怎樣的

flume能夠實時的導入數據到hdfs中，當hdfs上的文件達到一個指定大小的時候會造成一個文件，或者超過指定時間的話也造成一個文件

文件都是存儲在datanode上面的，namenode記錄着datanode的元數據信息，而namenode的元數據信息是存在內存中的，因此當文件切片很小或者不少的時候會卡死

五、map-reduce程序運行的時候會有什麼比較常見的問題

好比說做業中大部分都完成了，可是總有幾個reduce一直在運行

這是由於這幾個reduce中的處理的數據要遠遠大於其餘的reduce，多是由於對鍵值對任務劃分的不均勻形成的數據傾斜

解決的方法能夠在分區的時候從新定義分區規則對於value數據不少的key能夠進行拆分、均勻打散等處理，或者是在map端的combiner中進行數據預處理的操做

六、簡單說一下hadoop和spark的shuffle過程

hadoop：map端保存分片數據，經過網絡收集到reduce端
spark：spark的shuffle是在DAGSchedular劃分Stage的時候產生的，TaskSchedule要分發Stage到各個worker的executor

減小shuffle能夠提升性能

部分答案不是十分準確歡迎補充:-)

******************************************************************

單項選擇題

1. 下面哪一個程序負責 HDFS 數據存儲。

a)NameNode
b)Jobtracker
c)Datanode
d)secondaryNameNode
e)tasktracker

2. HDfS 中的 block 默認保存幾份？

a)3 份
b)2 份
c)1 份
d)不肯定

3. 下列哪一個程序一般與 NameNode 在一個節點啓動？

a)SecondaryNameNode
b)DataNode
c)TaskTracker
d)Jobtracker

4. Hadoop 做者

a)Martin Fowler
b)Kent Beck
c)Doug cutting

5. HDFS 默認 Block Size

a)32MB
b)64MB
c)128MB

6. 下列哪項一般是集羣的最主要瓶頸

a)CPU
b)網絡
c)磁盤
d)內存

7. 關於 SecondaryNameNode 哪項是正確的？

a)它是 NameNode 的熱備
b)它對內存沒有要求
c)它的目的是幫助 NameNode 合併編輯日誌，減小 NameNode 啓動時間
d)SecondaryNameNode 應與 NameNode 部署到一個節點

多選題：

8. 下列哪項能夠做爲集羣的管理工具

a)Puppet
b)Pdsh
c)Cloudera Manager
d)d)Zookeeper

9. 配置機架感知的下面哪項正確

a)若是一個機架出問題，不會影響數據讀寫
b)寫入數據的時候會寫到不一樣機架的 DataNode 中
c)MapReduce 會根據機架獲取離本身比較近的網絡數據

10. Client 端上傳文件的時候下列哪項正確

a)數據通過 NameNode 傳遞給 DataNode
b)Client 端將文件切分爲 Block，依次上傳
c)Client 只上傳數據到一臺 DataNode，而後由 NameNode 負責 Block 複製工做

11. 下列哪一個是 Hadoop 運行的模式

a)單機版
b)僞分佈式
c)分佈式

12. Cloudera 提供哪幾種安裝 CDH 的方法

a)Cloudera manager
b)Tar ball
c)Yum d)Rpm

判斷題：

13. Ganglia 不只能夠進行監控，也能夠進行告警。（）

14. Block Size 是不能夠修改的。（）

15. Nagios 不能夠監控 Hadoop 集羣，由於它不提供 Hadoop 支持。（）

16. 若是 NameNode 意外終止，SecondaryNameNode 會接替它使集羣繼續工做。（）

17. Cloudera CDH 是須要付費使用的。（）

18. Hadoop 是 Java 開發的，因此 MapReduce 只支持 Java 語言編寫。（）

19. Hadoop 支持數據的隨機讀寫。（）

20. NameNode 負責管理 metadata，client 端每次讀寫請求，它都會從磁盤中讀取或則會寫入 metadata 信息並反饋 client 端。（）

21. NameNode 本地磁盤保存了 Block 的位置信息。（）

22. DataNode 經過長鏈接與 NameNode 保持通訊。（）

23. Hadoop 自身具備嚴格的權限管理和安全措施保障集羣正常運行。（）

24. Slave 節點要存儲數據，因此它的磁盤越大越好。（）

25. hadoop dfsadmin –report 命令用於檢測 HDFS 損壞塊。（）

26. Hadoop 默認調度器策略爲 FIFO（）

27. 集羣內每一個節點都應該配 RAID，這樣避免單磁盤損壞，影響整個節點運行。（）

28. 由於 HDFS 有多個副本，因此 NameNode 是不存在單點問題的。（）

29. 每一個 map 槽就是一個線程。（）

30. Mapreduce 的 input split 就是一個 block。（）

31. NameNode 的 Web UI 端口是 50030，它經過 jetty 啓動的 Web 服務。（）

32. Hadoop 環境變量中的 HADOOP_HEAPSIZE 用於設置全部 Hadoop 守護線程的內存。它默認是 200 GB。（）

33. DataNode 首次加入 cluster 的時候，若是 log 中報告不兼容文件版本，那須要 NameNode執行「Hadoop namenode -format」操做格式化磁盤。（）

別走開，答案在後面哦！

1. 下面哪一個程序負責 HDFS 數據存儲。答案C datanode

a)NameNode
b)Jobtracker
c)Datanode
d)secondaryNameNode
e)tasktracker

2. HDfS 中的 block 默認保存幾份？答案A默認3分

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和TaskTracker

JobTracker 對應於 NameNode

TaskTracker 對應於 DataNode

DataNode 和NameNode 是針對數據存放來而言的

JobTracker和TaskTracker是對於MapReduce執行而言的

mapreduce中幾個主要概念，mapreduce總體上能夠分爲這麼幾條執行線索：obclient，JobTracker與TaskTracker。

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

二、JobTracker是一個master服務，軟件啓動以後JobTracker接收Job，負責調度Job的每個子任務task運行於TaskTracker上，並監控它們，若是發現有失敗的task就從新運行它。通常狀況應該把JobTracker部署在單獨的機器上。

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

4. Hadoop 做者答案C Doug cutting

a)Martin Fowler
b)Kent Beck
c)Doug cutting

5. HDFS 默認 Block Size 答案：B

a)32MB
b)64MB
c)128MB

(由於版本更換較快，這裏答案只供參考)

6. 下列哪項一般是集羣的最主要瓶頸：答案：C磁盤

a)CPU
b)網絡
c)磁盤IO
d)內存

該題解析：

首先集羣的目的是爲了節省成本，用廉價的pc機，取代小型機及大型機。小型機和大型機有什麼特色？

1.cpu處理能力強

2.內存夠大

因此集羣的瓶頸不多是a和d

3.網絡是一種稀缺資源，可是並非瓶頸。

4.因爲大數據面臨海量數據，讀寫數據都須要io，而後還要冗餘數據，hadoop通常備3份數據，因此IO就會打折扣。

7. 關於 SecondaryNameNode 哪項是正確的？答案C

a)它是 NameNode 的熱備
b)它對內存沒有要求
c)它的目的是幫助 NameNode 合併編輯日誌，減小 NameNode 啓動時間
d)SecondaryNameNode 應與 NameNode 部署到一個節點。

多選題：

8. 下列哪項能夠做爲集羣的管理？答案：ABD

a)Puppet
b)Pdsh
c)Cloudera Manager
d)Zookeeper

9. 配置機架感知的下面哪項正確：答案ABC

a)若是一個機架出問題，不會影響數據讀寫
b)寫入數據的時候會寫到不一樣機架的 DataNode 中
c)MapReduce 會根據機架獲取離本身比較近的網絡數據

10. Client 端上傳文件的時候下列哪項正確？答案B

a)數據通過 NameNode 傳遞給 DataNode

b)Client 端將文件切分爲 Block，依次上傳

c)Client 只上傳數據到一臺 DataNode，而後由 NameNode 負責 Block 複製工做

該題分析：

Client向NameNode發起文件寫入的請求。

NameNode根據文件大小和文件塊配置狀況，返回給Client它所管理部分DataNode的信息。

Client將文件劃分爲多個Block，根據DataNode的地址信息，按順序寫入到每個DataNode塊中。

11. 下列哪一個是 Hadoop 運行的模式：答案ABC

a)單機版
b)僞分佈式
c)分佈式

12. Cloudera 提供哪幾種安裝 CDH 的方法？答案：ABCD

a)Cloudera manager
b)Tarball
c)Yum
d)Rpm

判斷題：

13. Ganglia 不只能夠進行監控，也能夠進行告警。（正確）

分析：此題的目的是考Ganglia的瞭解。嚴格意義上來說是正確。ganglia做爲一款最經常使用的Linux環境中的監控軟件，它擅長的的是從節點中按照用戶的需求以較低的代價採集數據。可是ganglia在預警以及發生事件後通知用戶上並不擅長。最新的ganglia已經有了部分這方面的功能。可是更擅長作警告的還有Nagios。Nagios，就是一款精於預警、通知的軟件。經過將Ganglia和Nagios組合起來，把Ganglia採集的數據做爲Nagios的數據源，而後利用Nagios來發送預警通知，能夠完美的實現一整套監控管理的系統。

14. Block Size 是不能夠修改的。（錯誤）

分析：它是能夠被修改的Hadoop的基礎配置文件是hadoop-default.xml，默認創建一個Job的時候會創建Job的Config，Config首先讀入hadoop-default.xml的配置，而後再讀入hadoop-site.xml的配置（這個文件初始的時候配置爲空），hadoop-site.xml中主要配置須要覆蓋的hadoop-default.xml的系統級配置。

15. Nagios 不能夠監控 Hadoop 集羣，由於它不提供 Hadoop 支持。（錯誤）

分析：Nagios是集羣監控工具，並且是雲計算三大利器之一

16. 若是 NameNode 意外終止，SecondaryNameNode 會接替它使集羣繼續工做。（錯誤）

分析：SecondaryNameNode是幫助恢復，而不是替代，如何恢復，能夠查看.

17. Cloudera CDH 是須要付費使用的。（錯誤）

分析：第一套付費產品是Cloudera Enterpris，Cloudera Enterprise在美國加州舉行的 Hadoop 大會 (Hadoop Summit) 上公開，以若干私有管理、監控、運做工具增強 Hadoop 的功能。收費採起合約訂購方式，價格隨用的 Hadoop 叢集大小變更。

18. Hadoop 是 Java 開發的，因此 MapReduce 只支持 Java 語言編寫。（錯誤）

分析：rhadoop是用R語言開發的，MapReduce是一個框架，能夠理解是一種思想，能夠使用其餘語言開發。

19. Hadoop 支持數據的隨機讀寫。（錯）

分析：lucene是支持隨機讀寫的，而hdfs只支持隨機讀。可是HBase能夠來補救。HBase提供隨機讀寫，來解決Hadoop不能處理的問題。HBase自底層設計開始即聚焦於各類可伸縮性問題：表能夠很「高」，有數十億個數據行；也能夠很「寬」，有數百萬個列；水平分區並在上千個普通商用機節點上自動複製。表的模式是物理存儲的直接反映，使系統有可能提升高效的數據結構的序列化、存儲和檢索。

20. NameNode 負責管理 metadata，client 端每次讀寫請求，它都會從磁盤中讀取或則會寫入 metadata 信息並反饋 client 端。（錯誤）

此題分析：

NameNode 不須要從磁盤讀取 metadata，全部數據都在內存中，硬盤上的只是序列化的結果，只有每次 namenode 啓動的時候纔會讀取。

1）文件寫入
Client向NameNode發起文件寫入的請求。
NameNode根據文件大小和文件塊配置狀況，返回給Client它所管理部分DataNode的信息。
Client將文件劃分爲多個Block，根據DataNode的地址信息，按順序寫入到每個DataNode塊中。

2）文件讀取
Client向NameNode發起文件讀取的請求。

21. NameNode 本地磁盤保存了 Block 的位置信息。（我的認爲正確，歡迎提出其它意見）

分析：DataNode是文件存儲的基本單元，它將Block存儲在本地文件系統中，保存了Block的Meta-data，同時週期性地將全部存在的Block信息發送給NameNode。NameNode返回文件存儲的DataNode的信息。

Client讀取文件信息。

22. DataNode 經過長鏈接與 NameNode 保持通訊。（）

這個有分歧：具體正在找這方面的有利資料。下面提供資料可參考。

首先明確一下概念：

（1）.長鏈接
Client方與Server方先創建通信鏈接，鏈接創建後不斷開，而後再進行報文發送和接收。這種方式下因爲通信鏈接一直存在，此種方式經常使用於點對點通信。

（2）.短鏈接
Client方與Server每進行一次報文收發交易時才進行通信鏈接，交易完畢後當即斷開鏈接。此種方式經常使用於一點對多點通信，好比多個Client鏈接一個Server.

23. Hadoop 自身具備嚴格的權限管理和安全措施保障集羣正常運行。（錯誤）

分析：hadoop只能阻止好人犯錯，可是不能阻止壞人幹壞事

24. Slave 節點要存儲數據，因此它的磁盤越大越好。（錯誤）

分析：一旦Slave節點宕機，數據恢復是一個難題

25. hadoop dfsadmin –report 命令用於檢測 HDFS 損壞塊。（錯誤）

26. Hadoop 默認調度器策略爲 FIFO（正確）

27. 集羣內每一個節點都應該配 RAID，這樣避免單磁盤損壞，影響整個節點運行。（錯誤）

分析：首先明白什麼是RAID，能夠參考百科磁盤陣列。這句話錯誤的地方在於太絕對，具體狀況具體分析。題目不是重點，知識才是最重要的。由於hadoop自己就具備冗餘能力，因此若是不是很嚴格不須要都配備RAID。具體參考第二題。

28. 由於 HDFS 有多個副本，因此 NameNode 是不存在單點問題的。（錯誤）

29. 每一個 map 槽就是一個線程。（錯誤）

分析：首先咱們知道什麼是map 槽,map 槽->map slotmap slot 只是一個邏輯值 ( org.apache.hadoop.mapred.TaskTracker.TaskLauncher.numFreeSlots )，而不是對應着一個線程或者進程

30. Mapreduce 的 input split 就是一個 block。（錯誤）

31. NameNode 的 Web UI 端口是 50030，它經過 jetty 啓動的 Web 服務。（錯誤）

32. Hadoop 環境變量中的 HADOOP_HEAPSIZE 用於設置全部 Hadoop 守護線程的內存。它默認是 200 GB。（錯誤）

分析：hadoop爲各個守護進程（namenode,secondarynamenode,jobtracker,datanode,tasktracker）統一分配的內存在hadoop-env.sh中設置，參數爲HADOOP_HEAPSIZE，默認爲1000M。

33. DataNode 首次加入 cluster 的時候，若是 log 中報告不兼容文件版本，那須要 NameNode執行「Hadoop namenode -format」操做格式化磁盤。（錯誤）

分析：

首先明白介紹，什麼ClusterID

ClusterID。添加了一個新的標識符ClusterID用於標識集羣中全部的節點。當格式化一個Namenode，須要提供這個標識符或者自動生成。這個ID能夠被用來格式化加入集羣的其餘Namenode。

二次整理

有的同窗問題的重點不是上面分析內容：內容以下：

這個報錯是說明 DataNode 所裝的Hadoop版本和其它節點不一致，應該檢查DataNode的Hadoop版本

*******************************************************

　　一、你會Java語言嗎？熟悉到什麼程度？

　　二、你最喜歡的編程語言是什麼？爲何？

　　三、處理過的最大的數據量？你是如何處理他們的？處理的結果如何。

　　二、在處理大數據過程當中，如何保證獲得指望值？

　　三、如何讓一個網絡爬蟲速度更快、抽取更好的信息以及更好總結數據從而獲得一干淨的數據庫？

　　四、點擊流數據應該是實時處理？爲何？哪部分應該實時處理？

　　六、如何把非結構化的數據轉換成結構化的數據？這是否真的有必要作這樣的轉換？把數據存成平面文本文件是否比存成關係數據庫更好？

　　七、如何判別mapreduce過程有好的負載均衡？什麼是負載均衡？

　　八、Spark和Hive的區別，以及Spark和Hive的數據傾斜調優問題？

　　九、Hive和Hbase的區別？

　　十、MapReduce的思想，以及MapReduce調優問題？

　　十一、你所瞭解的開源網站？

　　十二、有兩個集羣，每一個集羣有3個節點，使用hive分析相同的數據，sql語句徹底同樣，一個集羣的分析結果比另一個慢的多，給出形成這種現象的可能緣由？
　　1三、Hbase的優化？

　　1四、集羣的版本，以及集羣的瓶頸問題？

　　1五、CRM項目，怎麼跟Spark結合？

　　1六、如何建立一個關鍵字分類？

　　1七、海量日誌數據，提取出某日訪問百度次數最多的那個IP？

　　1八、Hadoop和Spark處理數據時，出現內存溢出的處理方法？

　　1九、有一個1G大小的一個文件，裏面每一是一個詞，詞的大小不超過16字節，內存大小限制大小1M，返回頻率最高的50個詞。

　　20、你是如何處理缺乏數據的？你是推薦使用什麼樣的處理技術，或者說你是用什麼樣的技術處理呢？

　　若是不會Java，面試第一題就答不會，這樣難道不尷尬嗎？正如加里·金(崇拜/崇拜)說：「這是一場革命，龐大的數據資源使得各個領域開始了量化進程，不管學術界、商界仍是政府，全部領域都將開始這種進程。」大數據時代，沒有Java基礎，如何開啓你的大數據時代？

**********************************************************************

1.簡要描述如何安裝配置一個apache開源版hadoop，描述便可，列出步驟更好

2.請列出正常工做的hadoop集羣中hadoop都須要啓動哪些進程，他們的做用分別是什麼？

3.啓動hadoop報以下錯誤，該如何解決？
error org.apache.hadoop.hdfs.server.namenode.NameNode

org.apache.hadoop.hdfs.server.common.inconsistentFSStateExceptio

n Directory /tmp/hadoop-root/dfs/name is in an inconsistent

state storage direction does not exist or is not accessible?

4.請寫出如下執行命令
1）殺死一個job?
2)刪除hdfs上的/tmp/aaa目錄
3加入一個新的存儲節點和刪除一個計算節點須要刷新集羣狀態命令？

5.請列出你所知道的hadoop調度器，並簡要說明其工做方法？
6.請列出在你之前工做中所使用過的開發mapreduce的語言？
7.當前日誌採樣格式爲

a,b,c,d
b,b,f,e
a,a,c,f

複製代碼

請用你最熟悉的語言編寫一個mapreduce，並計算第四列每一個元素出現的個數

8.你認爲用Java，Streaming,pipe方式開發mapreduce,各有哪些優缺點？
9.hive有哪些方式保存元數據，各有哪些特色？
10.請簡述hadoop怎麼樣實現二級排序？
11.簡述hadoop實現join的幾種方法？
12.請用Java實現非遞歸二分查找？
13.請簡述mapreduce中，combiner，partition做用？
14.某個目錄下有兩個文件a.txt和b.txt,文件格式爲（ip，username）,

列如：

a.txt
127.0.0.1 zhangsan
127.0.0.1 wangxiaoer
127.0.0.2 lisi
127.0.0.3 wangwu

b.txt
127.0.0.4 lixiaolu
127.0.0.1 lisi

每一個文件至少100萬行，請使用Linux命令完成以下工做：

1）每一個文件各自的ip數
2）出如今b.txt而沒有出如今a.txt的ip
3）每一個user出現的次數以及每一個user對應的ip數

**************************************************************************

1.Hadoop集羣能夠運行的3個模式？

單機（本地）模式
僞分佈式模式
全分佈式模式

2. 單機（本地）模式中的注意點？

在單機模式（standalone）中不會存在守護進程，全部東西都運行在一個JVM上。這裏一樣沒有DFS，使用的是本地文件系統。單機模式適用於開發過程當中運行MapReduce程序，這也是最少使用的一個模式。

3. 僞分佈模式中的注意點？

僞分佈式（Pseudo）適用於開發和測試環境，在這個模式中，全部守護進程都在同一臺機器上運行。

4. VM是否能夠稱爲Pseudo？

不是，兩個事物，同時Pseudo只針對Hadoop。

5. 全分佈模式又有什麼注意點？

全分佈模式一般被用於生產環境，這裏咱們使用N臺主機組成一個Hadoop集羣，Hadoop守護進程運行在每臺主機之上。這裏會存在Namenode運行的主機，Datanode運行的主機，以及task tracker運行的主機。在分佈式環境下，主節點和從節點會分開。

6. Hadoop是否遵循UNIX模式？

是的，在UNIX用例下，Hadoop還擁有「conf」目錄。

7. Hadoop安裝在什麼目錄下？

Cloudera和Apache使用相同的目錄結構，Hadoop被安裝在cdusrlibhadoop-0.20。

8. Namenode、Job tracker和task tracker的端口號是？

Namenode，70；Job tracker，30；Task tracker，60。

9. Hadoop的核心配置是什麼？

Hadoop的核心配置經過兩個xml文件來完成：1，hadoop-default.xml；2，hadoop-site.xml。這些文件都使用xml格式，所以每一個xml中都有一些屬性，包括名稱和值，可是當下這些文件都已不復存在。

10. 那當下又該如何配置？

Hadoop如今擁有3個配置文件：1，core-site.xml；2，hdfs-site.xml；3，mapred-site.xml。這些文件都保存在conf子目錄下。

11. RAM的溢出因子是？

溢出因子（Spill factor）是臨時文件中儲存文件的大小，也就是Hadoop-temp目錄。

12. fs.mapr.working.dir只是單一的目錄？

fs.mapr.working.dir只是一個目錄。

13. hdfs-site.xml的3個主要屬性？

dfs.name.dir決定的是元數據存儲的路徑以及DFS的存儲方式（磁盤或是遠端）
dfs.data.dir決定的是數據存儲的路徑
fs.checkpoint.dir用於第二Namenode

14. 如何退出輸入模式？

退出輸入的方式有：1，按ESC；2，鍵入q（若是你沒有輸入任何當下）或者鍵入wq（若是你已經輸入當下），而且按下Enter。

15. 當你輸入hadoopfsck 形成「connection refused java exception’」時，系統究竟發生了什麼？

這意味着Namenode沒有運行在你的VM之上。

16. 咱們使用Ubuntu及Cloudera，那麼咱們該去哪裏下載Hadoop，或者是默認就與Ubuntu一塊兒安裝？

這個屬於Hadoop的默認配置，你必須從Cloudera或者Edureka的dropbox下載，而後在你的系統上運行。固然，你也能夠本身配置，可是你須要一個Linux box，Ubuntu或者是Red Hat。在Cloudera網站或者是Edureka的Dropbox中有安裝步驟。

17. 「jps」命令的用處？

這個命令能夠檢查Namenode、Datanode、Task Tracker、 Job Tracker是否正常工做。

18. 如何重啓Namenode？

點擊stop-all.sh，再點擊start-all.sh。
鍵入sudo hdfs（Enter），su-hdfs （Enter），etcinit.dha（Enter），及etcinit.dhadoop-0.20-namenode start（Enter）。

19. Fsck的全名？

全名是：File System Check。

20. 如何檢查Namenode是否正常運行？

若是要檢查Namenode是否正常工做，使用命令etcinit.dhadoop-0.20-namenode status或者就是簡單的jps。

21. mapred.job.tracker命令的做用？

可讓你知道哪一個節點是Job Tracker。

22. etc init.d命令的做用是？

etc init.d說明了守護進程（服務）的位置或狀態，實際上是LINUX特性，和Hadoop關係不大。

23. 如何在瀏覽器中查找Namenode？

若是你確實須要在瀏覽器中查找Namenode，你再也不須要localhost8021，Namenode的端口號是50070。

24. 如何從SU轉到Cloudera？

從SU轉到Cloudera只須要鍵入exit。

25. 啓動和關閉命令會用到哪些文件？

Slaves及Masters。

26. Slaves由什麼組成？

Slaves由主機的列表組成，每臺1行，用於說明數據節點。

27. Masters由什麼組成？

Masters一樣是主機的列表組成，每臺一行，用於說明第二Namenode服務器。

28. hadoop-env.sh是用於作什麼的？

hadoop-env.sh提供了Hadoop中. JAVA_HOME的運行環境。

29. Master文件是否提供了多個入口？

是的你能夠擁有多個Master文件接口。

30. Hadoop-env.sh文件當下的位置？

hadoop-env.sh如今位於conf。

31. 在Hadoop_PID_DIR中，PID表明了什麼？

PID表明了「Process ID」。

32. varhadooppids用於作什麼？

varhadooppids用來存儲PID。

33. hadoop-metrics.properties文件的做用是？

hadoop-metrics.properties被用作「Reporting」，控制Hadoop報告，初始狀態是「not to report」。

34. Hadoop需求什麼樣的網絡？

Hadoop核心使用Shell（SSH）來驅動從節點上的服務器進程，並在主節點和從節點之間使用password-less SSH鏈接。

35. 全分佈式環境下爲何需求password-less SSH？

這主要由於集羣中通訊過於頻繁，Job Tracker須要儘量快的給Task Tracker發佈任務。

36. 這會致使安全問題嗎？

徹底不用擔憂。Hadoop集羣是徹底隔離的，一般狀況下沒法從互聯網進行操做。不同凡響的配置，所以咱們徹底不須要在乎這種級別的安全漏洞，好比說經過互聯網侵入等等。Hadoop爲機器之間的鏈接提供了一個相對安全的方式。

37. SSH工做的端口號是？

SSH工做的端口號是NO.22，固然能夠經過它來配置，22是默認的端口號。

38. SSH中的注意點還包括？

SSH只是個安全的shell通訊，能夠把它當作NO.22上的一種協議，只須要配置一個密碼就能夠安全的訪問。

39. 爲何SSH本地主機須要密碼？

在SSH中使用密碼主要是增長安全性，在某些狀況下也根本不會設置密碼通訊。

40. 若是在SSH中添加key，是否還須要設置密碼？

是的，即便在SSH中添加了key，仍是須要設置密碼。

41. 假如Namenode中沒有數據會怎麼樣？

沒有數據的Namenode就不能稱之爲Namenode，一般狀況下，Namenode確定會有數據。

42. 當Job Tracker宕掉時，Namenode會發生什麼？

當Job Tracker失敗時，集羣仍然能夠正常工做，只要Namenode沒問題。

43. 是客戶端仍是Namenode決定輸入的分片？

這並非客戶端決定的，在配置文件中以及決定分片細則。

44. 是否能夠自行搭建Hadoop集羣？

是的，只要對Hadoop環境足夠熟悉，你徹底能夠這麼作。

45. 是否能夠在Windows上運行Hadoop？

你最好不要這麼作，Red Hat Linux或者是Ubuntu纔是Hadoop的最佳操做系統。在Hadoop安裝中，Windows一般不會被使用，由於會出現各類各樣的問題。所以，Windows絕對不是Hadoop的推薦系統。

*************************************************************

問題導讀
一、當前集羣的可用資源不能知足應用程序的需求，怎麼解決？
二、內存裏堆的東西太多了，有什麼好辦法嗎？

一、WARN TaskSchedulerImpl: Initial job has not accepted any resources; check your cluster uito ensure that workers are registered and have sufficient memory
當前的集羣的可用資源不能知足應用程序所請求的資源。
資源分2類： cores 和 ram
Core表明對執行可用的executor slots
Ram表明每一個Worker上被須要的空閒內存來運行你的Application。
解決方法：
應用不要請求多餘空閒可用資源的
關閉掉已經執行結束的Application

二、Application isn’t using all of the Cores: How to set the Cores used by a Spark App
設置每一個App所能得到的core
解決方法：
spark-env.sh裏設置spark.deploy.defaultCores
或
spark.cores.max

三、Spark Executor OOM: How to set Memory Parameters on Spark
OOM是內存裏堆的東西太多了
一、增長job的並行度，即增長job的partition數量，把大數據集切分紅更小的數據，能夠減小一次性load到內存中的數據量。InputFomart， getSplit來肯定。

二、spark.storage.memoryFraction
管理executor中RDD和運行任務時的內存比例，若是shuffle比較小，只須要一點點shuffle memory，那麼就調大這個比例。默認是0.6。不能比老年代還要大。大了就是浪費。

三、spark.executor.memory若是仍是不行，那麼就要加Executor的內存了，改完executor內存後，這個須要重啓。

四、Shark Server/ Long Running Application Metadata Cleanup
Spark程序的元數據是會往內存中無限存儲的。spark.cleaner.ttl來防止OOM，主要出如今Spark Steaming和Shark Server裏。
export SPARK_JAVA_OPTS +="-Dspark.kryoserializer.buffer.mb=10 -Dspark.cleaner.ttl=43200"

五、Class Not Found: Classpath Issues
問題一、缺乏jar，不在classpath裏。
問題二、jar包衝突，同一個jar不一樣版本。

解決1：
將全部依賴jar都打入到一個fatJar包裏，而後手動設置依賴到指定每臺機器的DIR。
val conf = new SparkConf().setAppName(appName).setJars(Seq(System.getProperty("user.dir") + "/target/scala-2.10/sparktest.jar"))

解決2：
把所須要的依賴jar包都放到default classpath裏，分發到各個worker node上。

關於性能優化：
第一個是sort-based shuffle。這個功能大大的減小了超大規模做業在shuffle方面的內存佔用量，使得咱們能夠用更多的內存去排序。
第二個是新的基於Netty的網絡模塊取代了原有的NIO網絡模塊。這個新的模塊提升了網絡傳輸的性能，而且脫離JVM的GC本身管理內存，下降了GC頻率。
第三個是一個獨立於Spark executor的external shuffle service。這樣子executor在GC的時候其餘節點還能夠經過這個service來抓取shuffle數據，因此網絡傳輸自己不受到GC的影響。

過去一些的參賽系統軟件方面的處理都沒有能力達到硬件的瓶頸，甚至對硬件的利用率還不到10%。而此次咱們的參賽系統在map期間用滿了3GB/s的硬盤帶寬，達到了這些虛擬機上八塊SSD的瓶頸，在reduce期間網絡利用率到了1.1GB/s，接近物理極限。

**********************************************************

1. Spark 的四大組件下面哪一個不是 (D )
A.Spark Streaming B Mlib
C Graphx D Spark R

2.下面哪一個端口不是 spark 自帶服務的端口 (C )
A.8080 B.4040 C.8090 D.18080

3.spark 1.4 版本的最大變化 (B )
A spark sql Release 版本 B 引入 Spark R
C DataFrame D支持動態資源分配

4. Spark Job 默認的調度模式 (A )
A FIFO B FAIR
C 無 D 運行時指定

5.哪一個不是本地模式運行的個條件 ( D)
A spark.localExecution.enabled=true B 顯式指定本地運行 C finalStage 無父 Stage D partition默認值

6.下面哪一個不是 RDD 的特色 (C )
A. 可分區 B 可序列化 C 可修改 D 可持久化

7. 關於廣播變量，下面哪一個是錯誤的 (D )
A 任何函數調用 B 是隻讀的 C 存儲在各個節點 D 存儲在磁盤或 HDFS

8. 關於累加器，下面哪一個是錯誤的 (D )
A 支持加法 B 支持數值類型
C 可並行 D 不支持自定義類型

9.Spark 支持的分佈式部署方式中哪一個是錯誤的 (D )
A standalone B spark on mesos
C spark on YARN D Spark on local

10.Stage 的 Task 的數量由什麼決定 (A )
A Partition B Job C Stage D TaskScheduler

11.下面哪一個操做是窄依賴 (B )
A join B filter
C group D sort

12.下面哪一個操做確定是寬依賴 (C )
A map B flatMap
C reduceByKey D sample

13.spark 的 master 和 worker 經過什麼方式進行通訊的？ (D )
A http B nio C netty D Akka

14 默認的存儲級別 (A )
A MEMORY_ONLY B MEMORY_ONLY_SER
C MEMORY_AND_DISK D MEMORY_AND_DISK_SER

15 spark.deploy.recoveryMode 不支持那種 (D )
A.ZooKeeper B. FileSystem
D NONE D Hadoop

16.下列哪一個不是 RDD 的緩存方法 (C )
A persist() B Cache()
C Memory()

17.Task 運行在下來哪裏個選項中 Executor 上的工做單元 (C )
A Driver program B. spark master
C.worker node D Cluster manager

18.hive 的元數據存儲在 derby 和 MySQL 中有什麼區別 (B )
A.沒區別 B.多會話 C.支持網絡環境 D數據庫的區別

19.DataFrame 和 RDD 最大的區別 (B )
A.科學統計支持 B.多了 schema
C.存儲方式不同 D.外部數據源支持

20.Master 的 ElectedLeader 事件後作了哪些操做 (D )
A. 通知 driver B.通知 worker
C.註冊 application D.直接 ALIVE

**************************************************************

Volatile的特徵：

A、禁止指令重排（有例外）
B、可見性

Volatile的內存語義：

當寫一個volatile變量時，JMM會把線程對應的本地內存中的共享變量值刷新到主內存。

當讀一個volatile變量時，JMM會把線程對應的本地內存置爲無效，線程接下來將從主內存中讀取共享變量。

Volatile的重排序

一、當第二個操做爲volatile寫操作時,無論第一個操做是什麼(普通讀寫或者volatile讀寫),都不能進行重排序。這個規則確保volatile寫以前的全部操做都不會被重排序到volatile以後;

二、當第一個操做爲volatile讀操做時,無論第二個操做是什麼,都不能進行重排序。這個規則確保volatile讀以後的全部操做都不會被重排序到volatile以前;

三、當第一個操做是volatile寫操做時,第二個操做是volatile讀操做,不能進行重排序。

這個規則和前面兩個規則一塊兒構成了:兩個volatile變量操做不可以進行重排序；

除以上三種狀況之外能夠進行重排序。

好比：

一、第一個操做是普通變量讀/寫,第二個是volatile變量的讀；
二、第一個操做是volatile變量的寫,第二個是普通變量的讀/寫；

內存屏障/內存柵欄

內存屏障（Memory Barrier，或有時叫作內存柵欄，Memory Fence）是一種CPU指令，用於控制特定條件下的重排序和內存可見性問題。Java編譯器也會根據內存屏障的規則禁止重排序。（也就是讓一個CPU處理單元中的內存狀態對其它處理單元可見的一項技術。）

內存屏障能夠被分爲如下幾種類型：

LoadLoad屏障：對於這樣的語句Load1; LoadLoad; Load2，在Load2及後續讀取操做要讀取的數據被訪問前，保證Load1要讀取的數據被讀取完畢。

StoreStore屏障：對於這樣的語句Store1; StoreStore; Store2，在Store2及後續寫入操做執行前，保證Store1的寫入操做對其它處理器可見。

LoadStore屏障：對於這樣的語句Load1; LoadStore; Store2，在Store2及後續寫入操做被刷出前，保證Load1要讀取的數據被讀取完畢。

StoreLoad屏障：對於這樣的語句Store1; StoreLoad; Load2，在Load2及後續全部讀取操做執行前，保證Store1的寫入對全部處理器可見。它的開銷是四種屏障中最大的。

在大多數處理器的實現中，這個屏障是個萬能屏障，兼具其它三種內存屏障的功能。

內存屏障阻礙了CPU採用優化技術來下降內存操做延遲，必須考慮所以帶來的性能損失。爲了達到最佳性能，最好是把要解決的問題模塊化，這樣處理器能夠按單元執行任務，而後在任務單元的邊界放上全部須要的內存屏障。採用這個方法可讓處理器不受限的執行一個任務單元。合理的內存屏障組合還有一個好處是：緩衝區在第一次被刷後開銷會減小，由於再填充改緩衝區不須要額外工做了。

happens-before原則

Java是如何實現跨平臺的？

跨平臺是怎樣實現的呢？這就要談及Java虛擬機（Java Virtual Machine，簡稱 JVM）。

JVM也是一個軟件，不一樣的平臺有不一樣的版本。咱們編寫的Java源碼，編譯後會生成一種 .class 文件，稱爲字節碼文件。Java虛擬機就是負責將字節碼文件翻譯成特定平臺下的機器碼而後運行。也就是說，只要在不一樣平臺上安裝對應的JVM，就能夠運行字節碼文件，運行咱們編寫的Java程序。

而這個過程當中，咱們編寫的Java程序沒有作任何改變，僅僅是經過JVM這一」中間層「，就能在不一樣平臺上運行，真正實現了」一次編譯，處處運行「的目的。

JVM是一個」橋樑「，是一個」中間件「，是實現跨平臺的關鍵，Java代碼首先被編譯成字節碼文件，再由JVM將字節碼文件翻譯成機器語言，從而達到運行Java程序的目的。

注意：編譯的結果不是生成機器碼，而是生成字節碼，字節碼不能直接運行，必須經過JVM翻譯成機器碼才能運行。不一樣平臺下編譯生成的字節碼是同樣的，可是由JVM翻譯成的機器碼卻不同。

因此，運行Java程序必須有JVM的支持，由於編譯的結果不是機器碼，必需要通過JVM的再次翻譯才能執行。即便你將Java程序打包成可執行文件（例如 .exe），仍然須要JVM的支持。

注意：跨平臺的是Java程序，不是JVM。JVM是用C/C++開發的，是編譯後的機器碼，不能跨平臺，不一樣平臺下須要安裝不一樣版本的JVM。

手機掃二維碼登陸是怎麼實現的？

友情連接：掃碼登陸是如何實現的？

Java 線程有哪些狀態，這些狀態之間是如何轉化的？

新建(new)：新建立了一個線程對象。
可運行(runnable)：線程對象建立後，其餘線程(好比main線程）調用了該對象的start()方法。該狀態的線程位於可運行線程池中，等待被線程調度選中，獲取cpu 的使用權。
運行(running)：可運行狀態(runnable)的線程得到了cpu 時間片（timeslice），執行程序代碼。
阻塞(block)：阻塞狀態是指線程由於某種緣由放棄了cpu 使用權，也即讓出了cpu timeslice，暫時中止運行。直到線程進入可運行(runnable)狀態，纔有機會再次得到cpu timeslice 轉到運行(running)狀態。阻塞的狀況分三種：

(一). 等待阻塞：運行(running)的線程執行o.wait()方法，JVM會把該線程放入等待隊列(waitting queue)中。

(二). 同步阻塞：運行(running)的線程在獲取對象的同步鎖時，若該同步鎖被別的線程佔用，則JVM會把該線程放入鎖池(lock pool)中。

(三). 其餘阻塞：運行(running)的線程執行Thread.sleep(long ms)或t.join()方法，或者發出了I/O請求時，JVM會把該線程置爲阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程從新轉入可運行(runnable)狀態。

死亡(dead)：線程run()、main() 方法執行結束，或者因異常退出了run()方法，則該線程結束生命週期。死亡的線程不可再次復生。

List接口、Set接口和Map接口的區別

友情連接：List接口、Set接口和Map接口的區別

Cookie和Session的區別？

友情連接：Cookies 和 Session的區別

Java中的equals和hashCode方法詳解

友情連接：Java提升篇——equals()與hashCode()方法詳解

Java中CAS算法

友情連接：樂觀的併發策略——基於CAS的自旋

TimSort原理

友情連接：TimSort原理

comparable與comparator的區別？

友情連接：Comparable和Comparator的區別

手寫單例模式（線程安全）

友情連接：快速理解Java中的五種單例模式

Java線程間的通訊方式？

友情連接：Java 多線程（七）線程間的通訊——wait及notify方法
友情連接：Java線程間的通訊方式詳解

Java8的內存分代改進

友情連接：Java七、Java8的堆內存有啥變化？

對Java內存模型的理解以及其在併發當中的做用？

友情連接：對Java內存模型的理解以及其在併發當中的做用？

Arrays和Collections 對於sort的不一樣實現原理？

一、Arrays.sort()
該算法是一個通過調優的快速排序，此算法在不少數據集上提供N*log(N)的性能，這致使其餘快速排序會下降二次型性能。

二、Collections.sort()
該算法是一個通過修改的合併排序算法（其中，若是低子列表中的最高元素效益高子列表中的最低元素，則忽略合併）。此算法可提供保證的N*log(N)的性能，此實現將指定列表轉儲到一個數組中，而後再對數組進行排序，在重置數組中相應位置處每一個元素的列表上進行迭代。這避免了因爲試圖原地對連接列表進行排序而產生的

Java中object經常使用方法

一、clone()
二、equals()
三、finalize()
四、getclass()
五、hashcode()
六、notify()
七、notifyAll()
八、toString()

對於Java中多態的理解

所謂多態就是指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編程時並不肯定，而是在程序運行期間才肯定，即一個引用變量到底會指向哪一個類的實例對象，該引用變量發出的方法調用究竟是哪一個類中實現的方法，必須在由程序運行期間才能決定。由於在程序運行時才肯定具體的類，這樣，不用修改源程序代碼，就可讓引用變量綁定到各類不一樣的類實現上，從而致使該引用調用的具體方法隨之改變，即不修改程序代碼就能夠改變程序運行時所綁定的具體代碼，讓程序能夠選擇多個運行狀態，這就是多態性。

多態的定義：指容許不一樣類的對象對同一消息作出響應。即同一消息能夠根據發送對象的不一樣而採用多種不一樣的行爲方式。（發送消息就是函數調用）

Java實現多態有三個必要條件：繼承、重寫、父類引用指向子類對象。

繼承：在多態中必須存在有繼承關係的子類和父類。

重寫：子類對父類中某些方法進行從新定義，在調用這些方法時就會調用子類的方法。

父類引用指向子類對象：在多態中須要將子類的引用賦給父類對象，只有這樣該引用纔可以具有技能調用父類的方法和子類的方法。

實現多態的技術稱爲：動態綁定（dynamic binding），是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。

多態的做用：消除類型之間的耦合關係。

Session機制？

友情連接：Session機制詳解

Java序列化與反序列化是什麼？爲何須要序列化與反序列化？如何實現Java序列化與反序列化？

友情連接： Java序列化與反序列化

spring AOP 實現原理？

友情連接：Spring AOP 實現原理

Servlet 工做原理？

友情連接：Servlet 工做原理解析

java NIO和IO的區別？

友情連接：Java NIO和IO的區別

Java中堆內存和棧內存區別？

友情連接：Java中堆內存和棧內存詳解

反射講一講，主要是概念,都在哪須要反射機制，反射的性能，如何優化？

反射機制的定義：

是在運行狀態中，對於任意的一個類，都可以知道這個類的全部屬性和方法，對任意一個對象都可以經過反射機制調用一個類的任意方法，這種動態獲取類信息及動態調用類對象方法的功能稱爲java的反射機制。

反射的做用：

一、動態地建立類的實例，將類綁定到現有的對象中，或從現有的對象中獲取類型。

二、應用程序須要在運行時從某個特定的程序集中載入一個特定的類。

如何保證RESTful API安全性？

友情連接：如何設計好的RESTful API之安全性

如何預防MySQL注入？

友情連接：MySQL 及 SQL 注入與防範方法

******************************************************

spark-submit的時候如何引入外部jar包
spark shuffle的具體過程，你知道幾種shuffle方式
spark 如何防止內存溢出
cache和pesist的區別
怎麼處理數據傾斜
簡要描述Spark分佈式集羣搭建的步驟

spark使用：
1）當前文件a.text的格式爲，請統計每一個單詞出現的個數、計算第四列每一個元素出現的個數
A,b,c,d
B,b,f,e
A,a,c,f

2）在（url,user）的鍵值對中，如 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 127.0.0.3 zhangsan 每一個文件至少有1000萬行，請用程序完成一下工做， 1）各個文件的ip數 2)出如今b.text而沒有出如今a.text的IP 3)每一個user出現的次數以及每一個user對應的IP的個數 4)對應IP數最多的前K個user