面試題集錦

一.Hadoop

1.hdfs寫流程

2.hdfs讀流程

3.hdfs的體系結構

4.一個datanode 當機,怎麼一個流程恢複

5.hadoop 的 namenode 當機,怎麼解決

6.namenode對中繼資料的管理

7.中繼資料的checkpoint

8.yarn資源排程流程 

9.hadoop中combiner和partition的作用

10.用mapreduce怎麼處理資料傾斜問題？

11.shuffle 階段,你怎麼了解的

12.Mapreduce 的 map 數量 和 reduce 數量是由什麼決定的 ,怎麼配置

13.MapReduce優化經驗

14.分别舉例什麼情況要使用 combiner，什麼情況不使用？

15.MR運作流程解析

16.簡單描述一下HDFS的系統架構，怎麼保證資料安全?

17.在通過用戶端向hdfs中寫資料的時候，如果某一台機器當機了，會怎麼處理

18.Hadoop優化有哪些方面

19.大量資料求topN(寫出mapreduce的實作思路）

20.列出正常工作的hadoop叢集中hadoop都分别啟動哪些程序以及他們的作用

21.Hadoop總job和Tasks之間的差別是什麼？

22.Hadoop高可用HA模式

23.簡要描述安裝配置一個hadoop叢集的步驟

24.fsimage和edit的差別

25.yarn的三大排程政策

26.hadoop的shell指令用的多嗎?,說出一些常用的

二.Hive

1.大表join小表産生的問題，怎麼解決？

2.udf udaf udtf差別

3.hive有哪些儲存中繼資料的方式，個有什麼特點。

4.hive内部表和外部表的差別

5.生産環境中為什麼建議使用外部表？

6.insert into 和 override write差別？

7.hive的判斷函數有哪些

8.簡單描述一下HIVE的功能？用hive建立表幾種方式？hive表有幾種？

9.線上業務每天産生的業務日志（壓縮後>=3G），每天需要加載到hive的log表中，将每天産生的業務日志在壓縮之後load到hive的log表時，最好使用的壓縮算法是哪個,并說明其原因

10.若在hive中建立分區仍不能優化查詢效率，建表時如何優化

11.union all和union的差別

12.如何解決hive資料傾斜的問題

13.hive性能優化常用的方法

14.簡述delete，drop，truncate的差別

15.四個by的差別

16.Hive 裡邊字段的分隔符用的什麼？為什麼用\t？有遇到過字段裡 邊有\t 的情況嗎，怎麼處理的？為什麼不用 Hive 預設的分隔符，預設的分隔符是什麼？

17.分區分桶的差別，為什麼要分區

18.mapjoin的原理

19.在hive的row_number中distribute by 和 partition by的差別 

20.hive開發中遇到什麼問題?

21.什麼時候使用内部表,什麼時候使用外部表

22.hive都有哪些函數，你平常工作中用到哪些

23.手寫sql，連續活躍使用者

24.left semi join和left join差別

25.group by為什麼要排序

26.說說印象最深的一次優化場景，hive常見的優化思路

三.Spark

1.rdd的屬性

2.算子分為哪幾類(RDD支援哪幾種類型的操作)

3.建立rdd的幾種方式

4.spark運作流程

5.Spark中coalesce與repartition的差別

6.sortBy 和 sortByKey的差別

7.map和mapPartitions的差別

8.資料存入Redis  優先使用map mapPartitions  foreach  foreachPartions哪個

9.reduceByKey和groupBykey的差別

10.cache和checkPoint的比較

11.spark streaming流式統計單詞數量代碼

12.簡述map和flatMap的差別和應用場景

13.計算曝光數和點選數

14.分别列出幾個常用的transformation和action算子

15.按照需求使用spark編寫以下程式，要求使用scala語言

16.spark應用程式的執行指令是什麼？

17.Spark應用執行有哪些模式，其中哪幾種是叢集模式

18.請說明spark中廣播變量的用途

19.以下代碼會報錯嗎？如果會怎麼解決 val arr = new ArrayList[String]; arr.foreach(println)

20.寫出你用過的spark中的算子，其中哪些會産生shuffle過程

21.Spark中rdd與partition的差別

22.請寫出建立Dateset的幾種方式

23.描述一下RDD，DataFrame，DataSet的差別？

24.描述一下Spark中stage是如何劃分的？描述一下shuffle的概念

25.Spark 在yarn上運作需要做哪些關鍵的配置工作？如何kill -個Spark在yarn運作中Application

26.通常來說，Spark與MapReduce相比，Spark運作效率更高。請說明效率更高來源于Spark内置的哪些機制？請列舉常見spark的運作模式？

27.RDD中的資料在哪？

28.如果對RDD進行cache操作後，資料在哪裡？

29.Spark中Partition的數量由什麼決定

30.Scala裡面的函數和方法有什麼差別

31.SparkStreaming怎麼進行監控?

32.Spark判斷Shuffle的依據?

33.Scala有沒有多繼承？可以實作多繼承麼？

34.Sparkstreaming和flink做實時處理的差別

35.Sparkcontext的作用

36.Sparkstreaming讀取kafka資料為什麼選擇直連方式

37.離線分析什麼時候用sparkcore和sparksql

38.Sparkstreaming實時的資料不丢失的問題

39.簡述寬依賴和窄依賴概念，groupByKey,reduceByKey,map,filter,union五種操作哪些會導緻寬依賴，哪些會導緻窄依賴

40.資料傾斜可能會導緻哪些問題，如何監控和排查，在設計之初，要考慮哪些來避免

41.有一千萬條短信，有重複，以文本檔案的形式儲存，一行一條資料，請用五分鐘時間，找出重複出現最多的前10條

42.現有一檔案，格式如下，請用spark統計每個單詞出現的次數

43.共享變量和累加器

 44.當 Spark 涉及到資料庫的操作時，如何減少 Spark 運作中的資料庫連接配接數？

45.特别大的資料，怎麼發送到excutor中？

46.spark調優都做過哪些方面？

47.spark任務為什麼會被yarn kill掉？

48.Spark on Yarn作業執行流程？yarn-client和yarn-cluster有什麼差別？

49.Flatmap底層編碼實作？

        50.spark_1.X與spark_2.X差別 

        51.說說spark與flink

四.Kafka

1.Kafka名詞解釋和工作方式

2.Consumer與topic關系

3.kafka中生産資料的時候，如何保證寫入的容錯性？

4.如何保證kafka消費者消費資料是全局有序的

5.有兩個資料源，一個記錄的是廣告投放給使用者的日志，一個記錄使用者通路日志，另外還有一個固定的使用者基礎表記錄使用者基本資訊（比如學曆，年齡等等）。現在要分析廣告投放對與哪類使用者更有效，請采用熟悉的技術描述解決思路。另外如果兩個資料源都是實時資料源（比如來自kafka），他們資料在時間上相差5分鐘，需要哪些調整來解決實時分析問題？

6.Kafka和SparkStreaing如何內建?

7.列舉Kafka的優點，簡述Kafka為什麼可以做到每秒數十萬甚至上百萬消息的高效分發？

8.為什麼離線分析要用kafka？

9.Kafka怎麼進行監控?

10.Kafka與傳統的消息隊列服務有很麼不同

11.Kafka api  low-level與high-level有什麼差別，使用low-level需要處理哪些細節

12.Kafka的ISR副本同步隊列

13.Kafka消息資料積壓，Kafka消費能力不足怎麼處理？

14.Kafka中的ISR、AR又代表什麼？

15.Kafka中的HW、LEO等分别代表什麼？

16.哪些情景會造成消息漏消費？

17.當你使用kafka-topics.sh建立了一個topic之後，Kafka背後會執行什麼邏輯？

18.topic的分區數可不可以增加？如果可以怎麼增加？如果不可以，那又是為什麼？

19.topic的分區數可不可以減少？如果可以怎麼減少？如果不可以，那又是為什麼？

20.Kafka有内部的topic嗎？如果有是什麼？有什麼所用？

21.聊一聊Kafka Controller的作用？

22.失效副本是指什麼？有那些應對措施？

五.Hbase

1.Hbase調優

2.hbase的rowkey怎麼建立好？列族怎麼建立比較好？

3.hbase過濾器實作用途

4.HBase當機如何處理

5.hive跟hbase的差別是？

6.hbase寫流程

7.hbase讀流程

8.hbase資料flush過程

9.資料合并過程

10.Hmaster和Hgionserver職責

11.HBase列族和region的關系？

12.請簡述Hbase的實體模型是什麼

13.請問如果使用Hbase做即席查詢，如何設計二級索引

14.如何避免讀、寫HBaes時通路熱點問題？

15.布隆過濾器在HBASE中的應用

16.Hbase是用來幹嘛的?什麼樣的資料會放到hbase

六.數倉

1.維表和寬表的考查（主要考察維表的使用及次元退化手法）

2.數倉表命名規範

3.拉連結清單的使用場景

4.一億條資料查的很慢,怎麼查快一點

5.有什麼維表

6.資料源都有哪些

7.你們最大的表是什麼表,資料量多少

8.數倉架構體系

9.資料平台是怎樣的，用到了阿裡的那一套嗎？

10.你了解的排程系統有那些？，你們公司用的是哪種排程系統

11.你們公司數倉底層是怎麼抽資料的？

12.為什麼datax抽資料要比sqoop 快？

13.埋點資料你們是怎樣接入的

14.如果你們業務庫的表有更新，你們數倉怎麼處理的？

15.能獨立搭建數倉嗎

16.搭建過CDH 叢集嗎

17.說一下你們公司的大資料平台架構？你有參與嗎？

18.介紹一下你自己的項目和所用的技術

19.對目前的流和批處理的認識？就是談談自己的感受

20.你了解那些OLAP 引擎，MPP 知道一些嗎？clickHouse 了解一些嗎？你自己做過測試性能嗎？

21.Kylin 有了解嗎？介紹一下原理

22.datax 源碼有改造過嗎

23.你們數倉的APP 層是怎麼對外提供服務的？

24.資料接入進來，你們是怎樣規劃的，有考慮資料的膨脹問題嗎

25.簡述拉連結清單，流水表以及快照表的含義和特點

26.全量表(df),增量表(di),追加表(da)，拉連結清單(dz)的差別及使用場景

27.你們公司的數倉分層，每一層是怎麼處理資料的

28.什麼是事實表，什麼是維表

29.星型模型和雪花模型

30.緩慢變化維如何處理，幾種方式

31.datax與sqoop的優缺點

32.datax抽數碰到emoji表情怎麼解決

33.工作中碰到什麼困難，怎麼解決的

34.如何用資料給公司帶來收益

35.需求驅動和業務驅動，資料開發和ETL開發，實戰型和部落格型

36.如何用資料實作業務增長，黑客增長？

37.什麼是大資料？千萬級别的資料完全可以用傳統的關系型資料庫叢集解決，為什麼要用到大資料平台。

38.資料品質，中繼資料管理，名額體系建設，資料驅動

39.什麼是數倉,建設數倉時碰到過什麼問題

40.實時數倉技術選型及保證exactly-once

41.次元模組化和範式模組化的差別；

42.埋點的碼表如何設計；

43.集市層和公共層的差別；

44.緩慢變化維的處理方式

45.聊聊資料品質

46.說說你從0-1搭建數倉都做了什麼？你覺得最有挑戰的是什麼？

七.Flink

1.Flink實時計算時落磁盤嗎

2.日活DAU的統計需要注意什麼

3.Flink調優

4.Flink的容錯是怎麼做的

5.Parquet格式的好處？什麼時候讀的快什麼時候讀的慢

6.flink中checkPoint為什麼狀态有儲存在記憶體中這樣的機制？為什麼要開啟checkPoint?

7.flink保證Exactly_Once的原理？

8.flink的時間形式和視窗形式有幾種？有什麼差別，你們用在什麼場景下的？

9.flink的背壓說下？

10.flink的watermark機制說下，以及怎麼解決資料亂序的問題？

11.flink on yarn執行流程

12.說一說spark 和flink 的差別 

八.Java

1.hashMap底層源碼，資料結構

2.寫出你用過的設計模式，并舉例說明解決的實際問題

3.Java建立線程的幾種方式

4.請簡述作業系統的線程和程序的差別

5.Java程式出現OutOfMemoryError:unable to create new native thread 的原因可能有哪些？如何分析和解決？

6.采用java或自己熟悉的任何語言分别實作簡單版本的線性表和連結清單，隻需實作add,remove方法即可

7.ArrayList和LinkedList的差別

8.JVM 記憶體分哪幾個區，每個區的作用是什麼?

9.Java中疊代器和集合的差別？

10.HashMap 和 HashTable 差別

11.線程池使用注意哪些方面？

12.HashMap和TreeMap的差別？TreeMap排序規則？

13.用java實作單例模式

14.使用遞歸算法求n的階乘：n! ,語言不限

15.HashMap和Hashtable的差別是什麼

16.TreeSet 和 HashSet 差別

17.Stringbuffer 和 Stringbuild 差別

18.Final、Finally、Finalize

19..==和 Equals 差別

20.比較ArrayList，LinkedList的存儲特性和讀寫性能

21.Java 類加載過程

22.java中垃圾收集的方法有哪些?

23.如何判斷一個對象是否存活?(或者GC對象的判定方法)

24.jvm、堆棧

九.Elasticsearch

1.為什麼要用es？存進es的資料是什麼格式的，怎麼查詢

十.Flume

1.什麼是flume

2.flume運作機制

3.Flume采集資料到Kafka中丢資料怎麼辦

4.Flume怎麼進行監控?

5.Flume的三層架構，collector、agent、storage

十一.Sqoop

1.Sqoop底層運作的任務是什麼

2.sqoop的遷移資料的原理

3.Sqoop參數

4.Sqoop導入導出Null存儲一緻性問題

5.Sqoop資料導出一緻性問題

十二.Redis

1.緩存穿透、緩存雪崩、緩存擊穿

2.資料類型

3.持久化

4.悲觀鎖和樂觀鎖

5.redis 是單線程的，為什麼那麼快

6.redis的熱鍵問題？怎麼解決？

十三.Mysql

1.請寫出mysql登入指令，使用者名user，密碼123456，位址192.168.1.130

2.為什麼MySQL的索引要使用B+樹而不是其它樹形結構?比如B樹？

十四.資料結構與算法

1.二分查找

2.快排

3.歸并排序

4.冒泡排序

5.字元串反轉

6.Btree簡單講一下

7.動态規劃 最大連續子序列和

8.二叉樹概念，特點及代碼實作

9.連結清單

十五.Linux

一.Hadoop

1.hdfs寫流程

1. 用戶端跟namenode通信請求上傳檔案，namenode檢查目标檔案是否已存在，父目錄是否存在
2. namenode傳回是否可以上傳
3. client請求第一個 block該傳輸到哪些datanode伺服器上
4. namenode傳回3個datanode伺服器ABC
5. client請求3台dn中的一台A上傳資料（本質上是一個RPC調用，建立pipeline），A收到請求會繼續調用B，然後B調用C，将真個pipeline建立完成，逐級傳回用戶端
6. client開始往A上傳第一個block（先從磁盤讀取資料放到一個本地記憶體緩存），以packet為機關，A收到一個packet就會傳給B，B傳給C；A每傳一個packet會放入一個應答隊列等待應答
7. 當一個block傳輸完成之後，client再次請求namenode上傳第二個block的伺服器。

2.hdfs讀流程

1. client跟namenode通信查詢中繼資料，找到檔案塊所在的datanode伺服器
2. 挑選一台datanode（就近原則，然後随機）伺服器，請求建立socket流
3. datanode開始發送資料（從磁盤裡面讀取資料放入流，以packet為機關來做校驗）
4. 用戶端以packet為機關接收，現在本地緩存，然後寫入目标檔案

3.hdfs的體系結構

hdfs有namenode、secondraynamenode、datanode組成。為n+1模式

1. NameNode負責管理和記錄整個檔案系統的中繼資料
2. DataNode 負責管理使用者的檔案資料塊，檔案會按照固定的大小（blocksize）切成若幹塊後分布式存儲在若幹台datanode上，每一個檔案塊可以有多個副本，并存放在不同的datanode上，Datanode會定期向Namenode彙報自身所儲存的檔案block資訊，而namenode則會負責保持檔案的副本數量
3. HDFS的内部工作機制對用戶端保持透明，用戶端請求通路HDFS都是通過向namenode申請來進行
4. secondraynamenode負責合并日志

4.一個datanode 當機,怎麼一個流程恢複

Datanode當機了後，如果是短暫的當機，可以實作寫好腳本監控，将它啟動起來。如果是長時間當機了，那麼datanode上的資料應該已經被備份到其他機器了，那這台datanode就是一台新的datanode了，删除他的所有資料檔案和狀态檔案，重新啟動。

5.hadoop 的 namenode 當機,怎麼解決

先分析當機後的損失，當機後直接導緻client無法通路，記憶體中的中繼資料丢失，但是硬碟中的中繼資料應該還存在，如果隻是節點挂了，重新開機即可，如果是機器挂了，重新開機機器後看節點是否能重新開機，不能重新開機就要找到原因修複了。但是最終的解決方案應該是在設計叢集的初期就考慮到這個問題，做namenode的HA。

6.namenode對中繼資料的管理

namenode對資料的管理采用了三種存儲形式：

• 記憶體中繼資料(NameSystem)
• 磁盤中繼資料鏡像檔案(fsimage鏡像)
• 資料記錄檔檔案（可通過日志運算出中繼資料）(edit日志檔案)

7.中繼資料的checkpoint

每隔一段時間，會由secondary namenode将namenode上積累的所有edits和一個最新的fsimage下載下傳到本地，并加載到記憶體進行merge（這個過程稱為checkpoint）

namenode和secondary namenode的工作目錄存儲結構完全相同，是以，當namenode故障退出需要重新恢複時，可以從secondary namenode的工作目錄中将fsimage拷貝到namenode的工作目錄，以恢複namenode的中繼資料

8.yarn資源排程流程 

1. 使用者向YARN 中送出應用程式， 其中包括ApplicationMaster 程式、啟動ApplicationMaster 的指令、使用者程式等。
2. ResourceManager 為該應用程式配置設定第一個Container， 并與對應的NodeManager 通信，要求它在這個Container 中啟動應用程式的ApplicationMaster。
3. ApplicationMaster 首先向ResourceManager 注冊， 這樣使用者可以直接通過ResourceManage 檢視應用程式的運作狀态，然後它将為各個任務申請資源，并監控它的運作狀态，直到運作結束，即重複步驟4~7。
4. ApplicationMaster 采用輪詢的方式通過RPC 協定向ResourceManager 申請和領取資源。
5.  一旦ApplicationMaster 申請到資源後，便與對應的NodeManager 通信，要求它啟動任務。
6. NodeManager 為任務設定好運作環境（包括環境變量、JAR 包、二進制程式等）後，将任務啟動指令寫到一個腳本中，并通過運作該腳本啟動任務。
7. 各個任務通過某個RPC 協定向ApplicationMaster 彙報自己的狀态和進度，以讓ApplicationMaster 随時掌握各個任務的運作狀态，進而可以在任務失敗時重新啟動任務。在應用程式運作過程中，使用者可随時通過RPC 向ApplicationMaster 查詢應用程式的目前運作狀态。
8.  應用程式運作完成後，ApplicationMaster 向ResourceManager 登出并關閉自己。

9.hadoop中combiner和partition的作用

• combiner是發生在map的最後一個階段，父類就是Reducer，意義就是對每一個maptask的輸出進行局部彙總，以減小網絡傳輸量，緩解網絡傳輸瓶頸，提高reducer的執行效率。
• partition的主要作用将map階段産生的所有kv對配置設定給不同的reducer task處理，可以将reduce階段的處理負載進行分攤

10.用mapreduce怎麼處理資料傾斜問題？

資料傾斜：map /reduce程式執行時，reduce節點大部分執行完畢，但是有一個或者幾個reduce節點運作很慢，導緻整個程式的處理時間很長，這是因為某一個key的條數比其他key多很多（有時是百倍或者千倍之多），這條key所在的reduce節點所處理的資料量比其他節點就大很多，進而導緻某幾個節點遲遲運作不完，此稱之為資料傾斜。

（1）局部聚合加全局聚合。

第一次在 map 階段對那些導緻了資料傾斜的 key 加上 1 到 n 的随機字首，這樣本來相

同的 key 也會被分到多個 Reducer 中進行局部聚合，數量就會大大降低。

第二次 mapreduce，去掉 key 的随機字首，進行全局聚合。

思想：二次 mr，第一次将 key 随機散列到不同 reducer 進行處理達到負載均衡目的。第

二次再根據去掉 key 的随機字首，按原 key 進行 reduce 處理。

這個方法進行兩次 mapreduce，性能稍差。

（2）增加 Reducer，提升并行度

JobConf.setNumReduceTasks(int)

（3）實作自定義分區

根據資料分布情況，自定義散列函數，将 key 均勻配置設定到不同 Reducer

11.shuffle 階段,你怎麼了解的

shuffle: 洗牌、發牌——（核心機制：緩存，資料分區，排序，Merge進行局部value的合并）；

具體來說：就是将maptask輸出的處理結果資料，分發給reducetask，并在分發的過程中，對資料按key進行了分區和排序；

1）Map 方法之後 Reduce 方法之前這段處理過程叫 Shuffle

2）Map 方法之後，資料首先進入到分區方法，把資料标記好分區，然後把資料發送到 環形緩沖區；環形緩沖區預設大小 100m，環形緩沖區達到 80%時，進行溢寫；溢寫前對數 據進行排序，排序按照對 key 的索引進行字典順序排序，排序的手段快排；溢寫産生大量溢 寫檔案，需要對溢寫檔案進行歸并排序；對溢寫的檔案也可以進行 Combiner 操作，前提是彙總操作，求平均值不行。最後将檔案按照分區存儲到磁盤，等待 Reduce 端拉取。

3）每個 Reduce 拉取 Map 端對應分區的資料。拉取資料後先存儲到記憶體中，記憶體不夠 了，再存儲到磁盤。拉取完所有資料後，采用歸并排序将記憶體和磁盤中的資料都進行排序。

在進入 Reduce 方法前，可以對資料進行分組操作。

12.Mapreduce 的 map 數量 和 reduce 數量是由什麼決定的 ,怎麼配置

map的數量由輸入切片的數量決定，128M切分一個切片，隻要是檔案也分為一個切片，有多少個切片就有多少個map Task。

reduce數量自己配置。

13.MapReduce優化經驗

1.  設定合理的map和reduce的個數。合理設定blocksize
2. 避免出現資料傾斜
3. combine函數
4. 對資料進行壓縮
5. 小檔案處理優化：事先合并成大檔案，combineTextInputformat，在hdfs上用mapreduce将小檔案合并成SequenceFile大檔案（key:檔案名，value：檔案内容）
6. 參數優化

14.分别舉例什麼情況要使用 combiner，什麼情況不使用？

求平均數的時候就不需要用combiner，因為不會減少reduce執行數量。在其他的時候，可以依據情況，使用combiner，來減少map的輸出數量，減少拷貝到reduce的檔案，進而減輕reduce的壓力，節省網絡開銷，提升執行效率

15.MR運作流程解析

1. 一個mr程式啟動的時候，最先啟動的是MRAppMaster，MRAppMaster啟動後根據本次job的描述資訊，計算出需要的maptask執行個體數量，然後向叢集申請機器啟動相應數量的maptask程序
2. maptask程序啟動之後，根據給定的資料切片範圍進行資料處理，主體流程為：
   1. 利用客戶指定的inputformat來擷取RecordReader讀取資料，形成輸入KV對
   2. 将輸入KV對傳遞給客戶定義的map()方法，做邏輯運算，并将map()方法輸出的KV對收集到緩存
   3. 将緩存中的KV對按照K分區排序後不斷溢寫到磁盤檔案
3. MRAppMaster監控到所有maptask程序任務完成之後，會根據客戶指定的參數啟動相應數量的reducetask程序，并告知reducetask程序要處理的資料範圍（資料分區）
4. Reducetask程序啟動之後，根據MRAppMaster告知的待處理資料所在位置，從若幹台maptask運作所在機器上擷取到若幹個maptask輸出結果檔案，并在本地進行重新歸并排序，然後按照相同key的KV為一個組，調用客戶定義的reduce()方法進行邏輯運算，并收集運算輸出的結果KV，然後調用客戶指定的outputformat将結果資料輸出到外部存儲

16.簡單描述一下HDFS的系統架構，怎麼保證資料安全?

HDFS資料安全性如何保證？

1. 存儲在HDFS系統上的檔案，會分割成128M大小的block存儲在不同的節點上，block的副本數預設3份，也可配置成更多份；
2. 第一個副本一般放置在與client（用戶端）所在的同一節點上（若用戶端無datanode，則随機放），第二個副本放置到與第一個副本同一機架的不同節點，第三個副本放到不同機架的datanode節點，當取用時遵循就近原則；
3. datanode已block為機關，每3s報告心跳狀态，做10min内不報告心跳狀态則namenode認為block已死掉，namonode會把其上面的資料備份到其他一個datanode節點上，保證資料的副本數量；
4. datanode會預設每小時把自己節點上的所有塊狀态資訊報告給namenode；
5. 采用safemode模式：datanode會周期性的報告block資訊。Namenode會計算block的損壞率，當閥值<0.999f時系統會進入安全模式，HDFS隻讀不寫。HDFS中繼資料采用secondaryname備份或者HA備份

17.在通過用戶端向hdfs中寫資料的時候，如果某一台機器當機了，會怎麼處理

       在寫入的時候不會重新重新配置設定datanode。如果寫入時，一個datanode挂掉，會将已經寫入的資料放置到queue的頂部，并将挂掉的datanode移出pipline，将資料寫入到剩餘的datanode，在寫入結束後， namenode會收集datanode的資訊，發現此檔案的replication沒有達到配置的要求（default=3）,然後尋找一個datanode儲存副本。

18.Hadoop優化有哪些方面

0）HDFS 小檔案影響

（1）影響 NameNode 的壽命，因為檔案中繼資料存儲在 NameNode 的記憶體中

（2）影響計算引擎的任務數量，比如每個小的檔案都會生成一個 Map 任務

1）資料輸入小檔案處理：

（1）合并小檔案：對小檔案進行歸檔（Har）、自定義 Inputformat 将小檔案存儲成SequenceFile 檔案。

（2）采用 ConbinFileInputFormat 來作為輸入，解決輸入端大量小檔案場景。

（3）對于大量小檔案 Job，可以開啟 JVM 重用。

2）Map 階段

（1）增大環形緩沖區大小。由 100m 擴大到 200m

（2）增大環形緩沖區溢寫的比例。由 80%擴大到 90%

（3）減少對溢寫檔案的 merge 次數。（10 個檔案，一次 20 個 merge）

（4）不影響實際業務的前提下，采用 Combiner 提前合并，減少 I/O。

3）Reduce 階段

（1）合理設定 Map 和 Reduce 數：兩個都不能設定太少，也不能設定太多。太少，會導緻 Task 等待，延長處理時間；太多，會導緻 Map、Reduce 任務間競争資源，造成處理逾時等錯誤。

（2）設定 Map、Reduce 共存：調整 slowstart.completedmaps 參數，使 Map 運作到一定程度後，Reduce 也開始運作，減少 Reduce 的等待時間。

（3）規避使用 Reduce，因為 Reduce 在用于連接配接資料集的時候将會産生大量的網絡消耗。

（4）增加每個 Reduce 去 Map 中拿資料的并行數

（5）叢集性能可以的前提下，增大 Reduce 端存儲資料記憶體的大小。

4）IO 傳輸

（1）采用資料壓縮的方式，減少網絡 IO 的的時間。安裝 Snappy 和 LZOP 壓縮編碼器。

（2）使用 SequenceFile 二進制檔案

5）整體

（1）MapTask 預設記憶體大小為 1G，可以增加 MapTask 記憶體大小為 4-5g

（2）ReduceTask 預設記憶體大小為 1G，可以增加 ReduceTask 記憶體大小為 4-5g

（3）可以增加 MapTask 的 cpu 核數，增加 ReduceTask 的 CPU 核數

（4）增加每個 Container 的 CPU 核數和記憶體大小

（5）調整每個 Map Task 和 Reduce Task 最大重試次數

19.大量資料求topN(寫出mapreduce的實作思路）

20.列出正常工作的hadoop叢集中hadoop都分别啟動哪些程序以及他們的作用

1.NameNode它是hadoop中的主伺服器，管理檔案系統名稱空間和對叢集中存儲的檔案的通路，儲存有metadate。

2.SecondaryNameNode它不是namenode的備援守護程序，而是提供周期檢查點和清理任務。幫助NN合并editslog，減少NN啟動時間。

3.DataNode它負責管理連接配接到節點的存儲（一個叢集中可以有多個節點）。每個存儲資料的節點運作一個datanode守護程序。

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

5.NodeManager（TaskTracker）執行任務

6.DFSZKFailoverController高可用時它負責監控NN的狀态，并及時的把狀态資訊寫入ZK。它通過一個獨立線程周期性的調用NN上的一個特定接口來擷取NN的健康狀态。FC也有選擇誰作為Active NN的權利，因為最多隻有兩個節點，目前選擇政策還比較簡單（先到先得，輪換）。

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

21.Hadoop總job和Tasks之間的差別是什麼？

Job是我們對一個完整的mapreduce程式的抽象封裝

Task是job運作時，每一個處理階段的具體執行個體，如map task，reduce task，maptask和reduce task都會有多個并發運作的執行個體

22.Hadoop高可用HA模式

HDFS高可用原理：

Hadoop HA（High Available）通過同時配置兩個處于Active/Passive模式的Namenode來解決上述問題，狀态分别是Active和Standby. Standby Namenode作為熱備份，進而允許在機器發生故障時能夠快速進行故障轉移，同時在日常維護的時候使用優雅的方式進行Namenode切換。Namenode隻能配置一主一備，不能多于兩個Namenode。

主Namenode處理所有的操作請求（讀寫），而Standby隻是作為slave，維護盡可能同步的狀态，使得故障時能夠快速切換到Standby。為了使Standby Namenode與Active Namenode資料保持同步，兩個Namenode都與一組Journal Node進行通信。當主Namenode進行任務的namespace操作時，都會確定持久會修改日志到Journal Node節點中。Standby Namenode持續監控這些edit，當監測到變化時，将這些修改同步到自己的namespace。

當進行故障轉移時，Standby在成為Active Namenode之前，會確定自己已經讀取了Journal Node中的所有edit日志，進而保持資料狀态與故障發生前一緻。

為了確定故障轉移能夠快速完成，Standby Namenode需要維護最新的Block位置資訊，即每個Block副本存放在叢集中的哪些節點上。為了達到這一點，Datanode同時配置主備兩個Namenode，并同時發送Block報告和心跳到兩台Namenode。

確定任何時刻隻有一個Namenode處于Active狀态非常重要，否則可能出現資料丢失或者資料損壞。當兩台Namenode都認為自己的Active Namenode時，會同時嘗試寫入資料（不會再去檢測和同步資料）。為了防止這種腦裂現象，Journal Nodes隻允許一個Namenode寫入資料，内部通過維護epoch數來控制，進而安全地進行故障轉移。

23.簡要描述安裝配置一個hadoop叢集的步驟

1. 使用root賬戶登入。
2. 修改IP。
3. 修改Host主機名。
4. 配置SSH免密碼登入。
5. 關閉防火牆。
6. 安裝JDK。
7. 上傳解壓Hadoop安裝包。
8. 配置Hadoop的核心配置檔案hadoop-evn.sh，core-site.xml，mapred-site.xml，hdfs-site.xml，yarn-site.xml
9. 配置hadoop環境變量
10. 格式化hdfs # bin/hadoop  namenode  -format
11. 啟動節點start-all.sh

24.fsimage和edit的差別

fsimage：filesystem image 的簡寫，檔案鏡像。

用戶端修改檔案時候，先更新記憶體中的metadata資訊,隻有當對檔案操作成功的時候，才會寫到editlog。

fsimage是檔案meta資訊的持久化的檢查點。secondary namenode會定期的将fsimage和editlog合并dump成新的fsimage

25.yarn的三大排程政策

FIFO Scheduler把應用按送出的順序排成一個隊列，這是一個先進先出隊列，在進行資源配置設定的時候，先給隊列中最頭上的應用進行配置設定資源，待最頭上的應用需求滿足後再給下一個配置設定，以此類推。

Capacity（容量）排程器，有一個專門的隊列用來運作小任務，但是為小任務專門設定一個隊列會預先占用一定的叢集資源，這就導緻大任務的執行時間會落後于使用FIFO排程器時的時間。

在Fair（公平）排程器中，我們不需要預先占用一定的系統資源，Fair排程器會為所有運作的job動态的調整系統資源。當第一個大job送出時，隻有這一個job在運作，此時它獲得了所有叢集資源；當第二個小任務送出後，Fair排程器會配置設定一半資源給這個小任務，讓這兩個任務公平的共享叢集資源。

  需要注意的是，在下圖Fair排程器中，從第二個任務送出到獲得資源會有一定的延遲，因為它需要等待第一個任務釋放占用的Container。小任務執行完成之後也會釋放自己占用的資源，大任務又獲得了全部的系統資源。最終的效果就是Fair排程器即得到了高的資源使用率又能保證小任務及時完成。

26.hadoop的shell指令用的多嗎?,說出一些常用的

二.Hive

1.大表join小表産生的問題，怎麼解決？

mapjoin方案

join因為空值導緻長尾(key為空值是用随機值代替)

join因為熱點值導緻長尾，也可以将熱點資料和非熱點資料分開處理，最後合并

2.udf udaf udtf差別

UDF操作作用于單個資料行，并且産生一個資料行作為輸出。大多數函數都屬于這一類（比如數學函數和字元串函數）。

UDAF 接受多個輸入資料行，并産生一個輸出資料行。像COUNT和MAX這樣的函數就是聚集函數。

UDTF 操作作用于單個資料行，并且産生多個資料行-------一個表作為輸出。lateral view explore()

簡單來說：

UDF:傳回對應值，一對一

UDAF：傳回聚類值，多對一

UDTF：傳回拆分值，一對多

3.hive有哪些儲存中繼資料的方式，個有什麼特點。

• 記憶體資料庫derby，安裝小，但是資料存在記憶體，不穩定
• mysql資料庫，資料存儲模式可以自己設定，持久化好，檢視友善。

4.hive内部表和外部表的差別

内部表：加載資料到hive所在的hdfs目錄，删除時，中繼資料和資料檔案都删除

外部表：不加載資料到hive所在的hdfs目錄，删除時，隻删除表結構。

這樣外部表相對來說更加安全些，資料組織也更加靈活，友善共享源資料。 

5.生産環境中為什麼建議使用外部表？

1. 因為外部表不會加載資料到hive，減少資料傳輸、資料還能共享。
2. hive不會修改資料，是以無需擔心資料的損壞
3. 删除表時，隻删除表結構、不删除資料。

6.insert into 和 override write差別？

insert into：将資料寫到表中

override write：覆寫之前的内容。

7.hive的判斷函數有哪些

hive 的條件判斷（if、coalesce、case）

8.簡單描述一下HIVE的功能？用hive建立表有幾種方式？hive表有幾種？

hive主要是做離線分析的

hive建表有三種方式

• 直接建表法
• 查詢建表法(通過AS 查詢語句完成建表：将子查詢的結果存在新表裡，有資料，一般用于中間表)
• like建表法(會建立結構完全相同的表，但是沒有資料)

hive表有2種：内部表和外部表

9.線上業務每天産生的業務日志（壓縮後>=3G），每天需要加載到hive的log表中，将每天産生的業務日志在壓縮之後load到hive的log表時，最好使用的壓縮算法是哪個,并說明其原因

10.若在hive中建立分區仍不能優化查詢效率，建表時如何優化

11.union all和union的差別

union 去重

union oll 不去重

12.如何解決hive資料傾斜的問題

1）group by

注：group by 優于 distinct group

情形：group by 次元過小，某值的數量過多

後果：處理某值的 reduce 非常耗時

解決方式：采用 sum() group by 的方式來替換 count(distinct)完成計算。

2）count(distinct)

count(distinct xx)

情形：某特殊值過多

後果：處理此特殊值的 reduce 耗時；隻有一個 reduce 任務

解決方式：count distinct 時，将值為空的情況單獨處理，比如可以直接過濾空值的行，

在最後結果中加 1。如果還有其他計算，需要進行 group by，可以先将值為空的記錄單獨處

理，再和其他計算結果進行 union。

3）mapjoin

4）不同資料類型關聯産生資料傾斜

情形：比如使用者表中 user_id 字段為 int，log 表中 user_id 字段既有 string 類型也有 int 類型。當按照 user_id 進行兩個表的 Join 操作時。

後果：處理此特殊值的 reduce 耗時；隻有一個 reduce 任務

預設的 Hash 操作會按 int 型的 id 來進行配置設定，這樣會導緻所有 string 類型 id 的記錄都配置設定

到一個 Reducer 中。

解決方式：把數字類型轉換成字元串類型

select * from users a

left outer join logs b

on a.usr_id = cast(b.user_id as string)

5）開啟資料傾斜時負載均衡

set hive.groupby.skewindata=true;

思想：就是先随機分發并處理，再按照 key group by 來分發處理。

操作：當選項設定為 true，生成的查詢計劃會有兩個 MRJob。

第一個 MRJob 中，Map 的輸出結果集合會随機分布到 Reduce 中，每個 Reduce 做部分

聚合操作，并輸出結果，這樣處理的結果是相同的 GroupBy Key 有可能被分發到不同的

Reduce 中，進而達到負載均衡的目的；

第二個 MRJob 再根據預處理的資料結果按照 GroupBy Key 分布到 Reduce 中（這個過

程可以保證相同的原始 GroupBy Key 被分布到同一個 Reduce 中），最後完成最終的聚合操

作。

點評：它使計算變成了兩個 mapreduce，先在第一個中在 shuffle 過程 partition 時随機

給 key 打标記，使每個 key 随機均勻分布到各個 reduce 上計算，但是這樣隻能完成部分

計算，因為相同 key 沒有配置設定到相同 reduce 上。

是以需要第二次的 mapreduce,這次就回歸正常 shuffle,但是資料分布不均勻的問題在第

一次 mapreduce 已經有了很大的改善，是以基本解決資料傾斜。因為大量計算已經在第一次

mr 中随機分布到各個節點完成。

6）控制空值分布

将為空的 key 轉變為字元串加随機數或純随機數，将因空值而造成傾斜的資料分不到多

個 Reducer。

注：對于異常值如果不需要的話，最好是提前在 where 條件裡過濾掉，這樣可以使計算

量大大減少

13.hive性能優化常用的方法

1）MapJoin

如果不指定 MapJoin 或者不符合 MapJoin 的條件，那麼 Hive 解析器會将 Join 操作轉換

成 Common Join，即：在 Reduce 階段完成 join。容易發生資料傾斜。可以用 MapJoin 把小

表全部加載到記憶體在 map 端進行 join，避免 reducer 處理。

2）行列過濾

列處理：在 SELECT 中，隻拿需要的列，如果有，盡量使用分區過濾，少用 SELECT *。

行處理：在分區剪裁中，當使用外關聯時，如果将副表的過濾條件寫在 Where 後面，那

麼就會先全表關聯，之後再過濾。

3）列式存儲

4）采用分區技術

5）合理設定 Map 數

（1）通常情況下，作業會通過 input 的目錄産生一個或者多個 map 任務。

主要的決定因素有：input 的檔案總個數，input 的檔案大小，叢集設定的檔案塊大小。

（2）是不是 map 數越多越好？

答案是否定的。如果一個任務有很多小檔案（遠遠小于塊大小 128m），則每個小檔案

也會被當做一個塊，用一個 map 任務來完成，而一個 map 任務啟動和初始化的時間遠遠大

于邏輯處理的時間，就會造成很大的資源浪費。而且，同時可執行的 map 數是受限的。

（3）是不是保證每個 map 處理接近 128m 的檔案塊，就高枕無憂了？

答案也是不一定。比如有一個 127m 的檔案，正常會用一個 map 去完成，但這個檔案隻

有一個或者兩個小字段，卻有幾千萬的記錄，如果 map 處理的邏輯比較複雜，用一個 map

任務去做，肯定也比較耗時。

針對上面的問題 2 和 3，我們需要采取兩種方式來解決：即減少 map 數和增加 map 數；

6）小檔案進行合并

在 Map 執行前合并小檔案，減少 Map 數：CombineHiveInputFormat 具有對小檔案進行

合并的功能（系統預設的格式）。HiveInputFormat 沒有對小檔案合并功能。

7）合理設定 Reduce 數

Reduce 個數并不是越多越好

（1）過多的啟動和初始化 Reduce 也會消耗時間和資源；

（2）另外，有多少個 Reduce，就會有多少個輸出檔案，如果生成了很多個小檔案，那

麼如果這些小檔案作為下一個任務的輸入，則也會出現小檔案過多的問題；

在設定 Reduce 個數的時候也需要考慮這兩個原則：處理大資料量利用合适的 Reduce

數；使單個 Reduce 任務處理資料量大小要合适；

8）常用參數

// 輸出合并小檔案

SET hive.merge.mapfiles = true; -- 預設 true，在 map-only 任務結束時合并

小檔案

SET hive.merge.mapredfiles = true; -- 預設 false，在 map-reduce 任務結

束時合并小檔案

SET hive.merge.size.per.task = 268435456; -- 預設 256M

SET hive.merge.smallfiles.avgsize = 16777216; -- 當輸出檔案的平均大小

小于 16m 該值時，啟動一個獨立的 map-reduce 任務進行檔案 merge

9）開啟 map 端 combiner（不影響最終業務邏輯）

set hive.map.aggr=true；

10）壓縮（選擇快的）

設定 map 端輸出、中間結果壓縮。（不完全是解決資料傾斜的問題，但是減少了 IO 讀

寫和網絡傳輸，能提高很多效率）

11）開啟 JVM 重用

14.簡述delete，drop，truncate的差別

delet 删除資料

drop 删除表

truncate  摧毀表結構并重建

15.四個by的差別

1. Sort By：分區内有序；
2. Order By：全局排序，隻有一個 Reducer；
3. Distrbute By：類似 MR 中 Partition，進行分區，結合 sort by 使用。
4. Cluster By：當 Distribute by 和 Sorts by 字段相同時，可以使用 Cluster by 方式。Cluster by 除了具有 Distribute by 的功能外還兼具 Sort by 的功能。但是排序隻能是升序排序，不能 指定排序規則為 ASC 或者 DESC。

16.Hive 裡邊字段的分隔符用的什麼？為什麼用\t？有遇到過字段裡 邊有\t 的情況嗎，怎麼處理的？為什麼不用 Hive 預設的分隔符，預設的分隔符是什麼？

hive 預設的字段分隔符為 ascii 碼的控制符\001（^A）,建表的時候用 fields terminated by '\001'

遇到過字段裡邊有\t 的情況，自定義 InputFormat，替換為其他分隔符再做後續處理

17.分區分桶的差別，為什麼要分區

分區表：原來的一個大表存儲的時候分成不同的資料目錄進行存儲。如果說是單分區表，那麼在表的目錄下就隻有一級子目錄，如果說是多分區表，那麼在表的目錄下有多少分區就有多少級子目錄。不管是單分區表，還是多分區表，在表的目錄下，和非最終分區目錄下是不能直接存儲資料檔案的 

分桶表：原理和hashpartitioner 一樣，将hive中的一張表的資料進行歸納分類的時候，歸納分類規則就是hashpartitioner。（需要指定分桶字段，指定分成多少桶）

分區表和分桶的差別除了存儲的格式不同外，最主要的是作用：

• 分區表：細化資料管理，縮小mapreduce程式 需要掃描的資料量。
• 分桶表：提高join查詢的效率，在一份資料會被經常用來做連接配接查詢的時候建立分桶，分桶字段就是連接配接字段；提高采樣的效率。

分區表和分桶的差別除了存儲的格式不同外，最主要的是作用：

• 分區表：細化資料管理，縮小mapreduce程式 需要掃描的資料量。
• 分桶表：提高join查詢的效率，在一份資料會被經常用來做連接配接查詢的時候建立分桶，分桶字段就是連接配接字段；提高采樣的效率。

18.mapjoin的原理

           MapJoin通常用于一個很小的表和一個大表進行join的場景，具體小表有多小，由參數hive.mapjoin.smalltable.filesize來決定，該參數表示小表的總大小，預設值為25000000位元組，即25M。

Hive0.7之前，需要使用hint提示 才會執行MapJoin,否則執行Common Join，但在0.7版本之後，預設自動會轉換Map Join，由參數hive.auto.convert.join來控制，預設為true.

假設a表為一張大表，b為小表，并且hive.auto.convert.join=true,那麼Hive在執行時候會自動轉化為MapJoin。

MapJoin簡單說就是在Map階段将小表讀入記憶體，順序掃描大表完成Join。減少昂貴的shuffle操作及reduce操作

MapJoin分為兩個階段：

• 通過MapReduce Local Task，将小表讀入記憶體，生成HashTableFiles上傳至Distributed Cache中，這裡會HashTableFiles進行壓縮。
• MapReduce Job在Map階段，每個Mapper從Distributed Cache讀取HashTableFiles到記憶體中，順序掃描大表，在Map階段直接進行Join，将資料傳遞給下一個MapReduce任務。

19.在hive的row_number中distribute by 和 partition by的差別 

20.hive開發中遇到什麼問題?

21.什麼時候使用内部表,什麼時候使用外部表

每天收集到的ng日志和埋點日志資料,需要做大量的統計資料分析,是以可以使用外部表進行存儲，友善資料的共享，并且在對表做操作的時候不會誤删原始資料。

在做統計分析時候用到的中間表，結果表可以使用内部表，因為這些資料不需要共享，使用内部表更為合适。并且很多時候分區表我們隻需要保留最近3天的資料，用外部表的時候删除分區時無法删除資料

22.hive都有哪些函數，你平常工作中用到哪些

• 數學函數

round(DOUBLE a)

floor(DOUBLE a)

ceil(DOUBLE a)

rand()

• 集合函數

size(Map<K.V>)

map_keys(Map<K.V>)

map_values(Map<K.V>)

array_contains(Array<T>, value)

sort_array(Array<T>)

• 類型轉換函數

cast(expr as <type>)

• 日期函數

date_format函數（根據格式整理日期）

date_add、date_sub函數（加減日期）

next_day函數

last_day函數（求當月最後一天日期）

collect_set函數

get_json_object解析json函數

from_unixtime(bigint unixtime, string format)

to_date(string timestamp)

year(string date)

month(string date)

hour(string date)

weekofyear(string date)

datediff(string enddate, string startdate)

add_months(string start_date, int num_months)

date_format(date/timestamp/string ts, string fmt)

• 條件函數

if(boolean testCondition, T valueTrue, T valueFalseOrNull)

nvl(T value, T default_value)

COALESCE(T v1, T v2, ...)

CASE a WHEN b THEN c [WHEN d THEN e]* [ELSE f] END

isnull( a )

isnotnull ( a )

• 字元函數

concat(string|binary A, string|binary B...)

concat_ws(string SEP, string A, string B...)

get_json_object(string json_string, string path)

length(string A)

lower(string A) lcase(string A)

parse_url(string urlString, string partToExtract [, string keyToExtract])

regexp_replace(string INITIAL_STRING, string PATTERN, string REPLACEMENT)

reverse(string A)

split(string str, string pat)

substr(string|binary A, int start) substring(string|binary A, int start)

• 聚合函數

count  sum min max avg

• 表生成函數

explode(array<TYPE> a)

explode(ARRAY)

json_tuple(jsonStr, k1, k2, ...)

parse_url_tuple(url, p1, p2, ...)

23.手寫sql，連續活躍使用者

24.left semi join和left join差別

25.group by為什麼要排序

26.說說印象最深的一次優化場景，hive常見的優化思路

三.Spark

1.rdd的屬性

• 一組分片（Partition），即資料集的基本組成機關。對于RDD來說，每個分片都會被一個計算任務處理，并決定并行計算的粒度。使用者可以在建立RDD時指定RDD的分片個數，如果沒有指定，那麼就會采用預設值。預設值就是程式所配置設定到的CPU Core的數目。
• 一個計算每個分區的函數。Spark中RDD的計算是以分片為機關的，每個RDD都會實作compute函數以達到這個目的。compute函數會對疊代器進行複合，不需要儲存每次計算的結果。
• RDD之間的依賴關系。RDD的每次轉換都會生成一個新的RDD，是以RDD之間就會形成類似于流水線一樣的前後依賴關系。在部分分區資料丢失時，Spark可以通過這個依賴關系重新計算丢失的分區資料，而不是對RDD的所有分區進行重新計算。
• 一個Partitioner，即RDD的分片函數。目前Spark中實作了兩種類型的分片函數，一個是基于哈希的HashPartitioner，另外一個是基于範圍的RangePartitioner。隻有對于于key-value的RDD，才會有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函數不但決定了RDD本身的分片數量，也決定了parent RDD Shuffle輸出時的分片數量。
• 一個清單，存儲存取每個Partition的優先位置（preferred location）。對于一個HDFS檔案來說，這個清單儲存的就是每個Partition所在的塊的位置。按照“移動資料不如移動計算”的理念，Spark在進行任務排程的時候，會盡可能地将計算任務配置設定到其所要處理資料塊的存儲位置。

2.算子分為哪幾類(RDD支援哪幾種類型的操作)

轉換（Transformation）  現有的RDD通過轉換生成一個新的RDD。lazy模式，延遲執行。

轉換函數包括：map，filter，flatMap，groupByKey，reduceByKey，aggregateByKey，union,join, coalesce 等等。

動作（Action）  在RDD上運作計算，并傳回結果給驅動程式(Driver)或寫入檔案系統。

動作操作包括：reduce，collect，count，first，take，countByKey以及foreach等等。

collect  該方法把資料收集到driver端   Array數組類型

所有的transformation隻有遇到action才能被執行。

當觸發執行action之後，資料類型不再是rdd了，資料就會存儲到指定檔案系統中，或者直接列印結 果或者收集起來。

3.建立rdd的幾種方式

1.集合并行化建立(有資料)

val arr = Array(1,2,3,4,5)

val rdd = sc.parallelize(arr)

val rdd =sc.makeRDD(arr)

2.讀取外部檔案系統，如hdfs，或者讀取本地檔案(最常用的方式)(沒資料)

val rdd2 = sc.textFile("hdfs://hdp-01:9000/words.txt")

// 讀取本地檔案

val rdd2 = sc.textFile(“file:///root/words.txt”)

3.從父RDD轉換成新的子RDD

調用Transformation類的方法，生成新的RDD

4.spark運作流程

Worker的功能：定時和master通信；排程并管理自身的executor

executor：由Worker啟動的，程式最終在executor中運作，（程式運作的一個容器）

spark-submit指令執行時，會根據master位址去向 Master發送請求，

Master接收到Dirver端的任務請求之後，根據任務的請求資源進行排程，（打散的政策），盡可能的 把任務資源平均配置設定，然後向WOrker發送指令

Worker收到Master的指令之後，就根據相應的資源，啟動executor（cores,memory）

executor會向dirver端建立請求，通知driver，任務已經可以運作了

driver運作任務的時候，會把任務發送到executor中去運作。

5.Spark中coalesce與repartition的差別

1）關系：

兩者都是用來改變 RDD 的 partition 數量的，repartition 底層調用的就是 coalesce 方法：coalesce(numPartitions, shuffle = true)

2）差別：

repartition 一定會發生 shuffle，coalesce 根據傳入的參數來判斷是否發生 shuffle

一般情況下增大 rdd 的 partition 數量使用 repartition，減少 partition 數量時使用coalesce

6.sortBy 和 sortByKey的差別

sortBy既可以作用于RDD[K] ，還可以作用于RDD[(k,v)]

sortByKey  隻能作用于 RDD[K,V] 類型上。

7.map和mapPartitions的差別

8.資料存入Redis  優先使用map mapPartitions  foreach  foreachPartions哪個

使用 foreachPartition

   * 1,map mapPartition   是轉換類的算子， 有傳回值

   * 2, 寫mysql,redis 的連接配接

   foreach  * 100萬         100萬次的連接配接

   foreachPartions * 200 個分區     200次連接配接  一個分區中的資料，共用一個連接配接

foreachParititon 每次疊代一個分區，foreach每次疊代一個元素。

該方法沒有傳回值，或者Unit

主要作用于，沒有傳回值類型的操作（列印結果，寫入到mysql資料庫中）

在寫入到redis,mysql的時候，優先使用foreachPartititon

9.reduceByKey和groupBykey的差別

reduceByKey會傳一個聚合函數， 相當于  groupByKey + mapValues

reduceByKey 會有一個分區内聚合，而groupByKey沒有  最核心的差別  

結論：reduceByKey有分區内聚合，更高效，優先選擇使用reduceByKey。

10.cache和checkPoint的比較

都是做 RDD 持久化的

1.緩存，是在觸發action之後，把資料寫入到記憶體或者磁盤中。不會截斷血緣關系

（設定緩存級别為memory_only：記憶體不足，隻會部分緩存或者沒有緩存，緩存會丢失,memory_and_disk :記憶體不足，會使用磁盤）

2.checkpoint 也是在觸發action之後，執行任務。單獨再啟動一個job，負責寫入資料到hdfs中。（把rdd中的資料，以二進制文本的方式寫入到hdfs中，有幾個分區，就有幾個二進制檔案）

3.某一個RDD被checkpoint之後，他的父依賴關系會被删除，血緣關系被截斷，該RDD轉換成了CheckPointRDD，以後再對該rdd的所有操作，都是從hdfs中的checkpoint的具體目錄來讀取資料。緩存之後，rdd的依賴關系還是存在的。

11.spark streaming流式統計單詞數量代碼

object WordCountAll {              // newValues目前批次的出現的單詞次數， runningCount表示之前運作的單詞出現的結果              /* def updateFunction(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {              val newCount =  newValues.sum + runningCount.getOrElse(0)// 将曆史前幾個批次的值和目前批次的值進行累加傳回目前批次最終的結果              Some(newCount)              }*/              /**              * String : 單詞 hello              * Seq[Int] ：單詞在目前批次出現的次數              * Option[Int] ：曆史結果              */              val updateFunc = (iter: Iterator[(String, Seq[Int], Option[Int])]) => {              //iter.flatMap(it=>Some(it._2.sum + it._3.getOrElse(0)).map(x=>(it._1,x)))              iter.flatMap{case(x,y,z)=>Some(y.sum + z.getOrElse(0)).map(m=>(x, m))}              }              // 屏蔽日志              Logger.getLogger("org.apache").setLevel(Level.ERROR)              def main(args: Array[String]) {              // 必須要開啟2個以上的線程，一個線程用來接收資料，另外一個線程用來計算              val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")              // 設定sparkjob計算時所采用的序列化方式              .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")              .set("spark.rdd.compress", "true") // 節約大量的記憶體内容              // 如果你的程式出現垃圾回收時間過程，可以設定一下java的垃圾回收參數              // 同時也會建立sparkContext對象              // 批次時間 >= 批次處理的總時間 (批次資料量，叢集的計算節點數量和配置)              val ssc = new StreamingContext(conf, Seconds(5))              //做checkpoint 寫入共享存儲中              ssc.checkpoint("c://aaa")              // 建立一個将要連接配接到 hostname:port 的 DStream，如 localhost:9999              val lines: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.175.101", 44444)              //updateStateByKey結果可以累加但是需要傳入一個自定義的累加函數：updateFunc              val results = lines.flatMap(_.split(" ")).map((_,1)).updateStateByKey(updateFunc, new HashPartitioner(ssc.sparkContext.defaultParallelism), true)              //列印結果到控制台              results.print()              //開始計算              ssc.start()              //等待停止              ssc.awaitTermination()              }              }           

12.簡述map和flatMap的差別和應用場景

map是對每一個元素進行操作，flatmap是對每一個元素操作後并壓平

13.計算曝光數和點選數

14.分别列出幾個常用的transformation和action算子

• 轉換算子：map,map,filter,reduceByKey,groupByKey,groupBy
• 行動算子：foreach，foreachpartition,collect,collectAsMap,take,top,first,count,countByKey

15.按照需求使用spark編寫以下程式，要求使用scala語言

目前檔案a.txt的格式，請統計每個單詞出現的次數

A,b,c

B,b,f,e

object WordCount {              def main(args: Array[String]): Unit = {              val conf = new SparkConf()              .setAppName(this.getClass.getSimpleName)              .setMaster("local[*]")              val sc = new SparkContext(conf)              var sData: RDD[String] = sc.textFile("a.txt")              val sortData: RDD[(String, Int)] = sData.flatMap(_.split(",")).map((_,1)).reduceByKey(_+_)              sortData.foreach(print)              }              }           

16.spark應用程式的執行指令是什麼？

/usr/local/spark-current2.3/bin/spark-submit \

--class com.wedoctor.Application \

--master yarn \

--deploy-mode client \

--driver-memory 1g \

--executor-memory 2g \

--queue root.wedw \

--num-executors 200 \

--jars /home/pgxl/liuzc/config-1.3.0.jar,/home/pgxl/liuzc/hadoop-lzo-0.4.20.jar,/home/pgxl/liuzc/elasticsearch-hadoop-hive-2.3.4.jar \

/home/pgxl/liuzc/sen.jar

17.Spark應用執行有哪些模式，其中哪幾種是叢集模式

• 本地local模式
• standalone模式
• spark on yarn模式
• spark on mesos模式

其中，standalone模式，spark on yarn模式，spark on mesos模式是叢集模式

18.請說明spark中廣播變量的用途

使用廣播變量，每個 Executor 的記憶體中，隻駐留一份變量副本，而不是對 每個 task 都傳輸一次大變量，省了很多的網絡傳輸， 對性能提升具有很大幫助， 而且會通過高效的廣播算法來減少傳輸代價。

19.以下代碼會報錯嗎？如果會怎麼解決 val arr = new ArrayList[String]; arr.foreach(println)

val arr = new ArrayList[String]; 這裡會報錯，需要改成 val arr: Array[String] = new Array[String](10)

arr.foreach(println)列印不會報空指針

20.寫出你用過的spark中的算子，其中哪些會産生shuffle過程

reduceBykey：

groupByKey：

…ByKey:

21.Spark中rdd與partition的差別

22.請寫出建立Dateset的幾種方式

23.描述一下RDD，DataFrame，DataSet的差別？

1）RDD

優點:

編譯時類型安全

編譯時就能檢查出類型錯誤

面向對象的程式設計風格

直接通過類名點的方式來操作資料

缺點:

序列化和反序列化的性能開銷

無論是叢集間的通信, 還是 IO 操作都需要對對象的結構和資料進行序列化和反序列化。

GC 的性能開銷，頻繁的建立和銷毀對象, 勢必會增加 GC

2）DataFrame

DataFrame 引入了 schema 和 off-heap

schema : RDD 每一行的資料, 結構都是一樣的，這個結構就存儲在 schema 中。Spark 通過 schema 就能夠讀懂資料, 是以在通信和 IO 時就隻需要序列化和反序列化資料, 而結構的部分就可以省略了。

3）DataSet

DataSet 結合了 RDD 和 DataFrame 的優點，并帶來的一個新的概念 Encoder。

當序列化資料時，Encoder 産生位元組碼與 off-heap 進行互動，能夠達到按需通路資料的效果，而不用反序列化整個對象。Spark 還沒有提供自定義 Encoder 的 API，但是未來會加入。

三者之間的轉換：

24.描述一下Spark中stage是如何劃分的？描述一下shuffle的概念

25.Spark 在yarn上運作需要做哪些關鍵的配置工作？如何kill -個Spark在yarn運作中Application

26.通常來說，Spark與MapReduce相比，Spark運作效率更高。請說明效率更高來源于Spark内置的哪些機制？并請列舉常見spark的運作模式？

27.RDD中的資料在哪？

RDD中的資料在資料源，RDD隻是一個抽象的資料集，我們通過對RDD的操作就相當于對資料進行操作。

28.如果對RDD進行cache操作後，資料在哪裡？

資料在第一執行cache算子時會被加載到各個Executor程序的記憶體中，第二次就會直接從記憶體中讀取而不會區磁盤。

29.Spark中Partition的數量由什麼決定

和Mr一樣，但是Spark預設最少有兩個分區。

30.Scala裡面的函數和方法有什麼差別

31.SparkStreaming怎麼進行監控?

32.Spark判斷Shuffle的依據?

 父RDD的一個分區中的資料有可能被配置設定到子RDD的多個分區中

33.Scala有沒有多繼承？可以實作多繼承麼？

34.Sparkstreaming和flink做實時處理的差別

35.Sparkcontext的作用

36.Sparkstreaming讀取kafka資料為什麼選擇直連方式

37.離線分析什麼時候用sparkcore和sparksq

38.Sparkstreaming實時的資料不丢失的問題

39.簡述寬依賴和窄依賴概念，groupByKey,reduceByKey,map,filter,union五種操作哪些會導緻寬依賴，哪些會導緻窄依賴

40.資料傾斜可能會導緻哪些問題，如何監控和排查，在設計之初，要考慮哪些來避免

41.有一千萬條短信，有重複，以文本檔案的形式儲存，一行一條資料，請用五分鐘時間，找出重複出現最多的前10條

42.現有一檔案，格式如下，請用spark統計每個單詞出現的次數

18619304961，18619304064，186193008，186193009

18619304962，18619304065，186193007，186193008

18619304963，18619304066，186193006，186193010

43.共享變量和累加器

累加器（accumulator）是 Spark 中提供的一種分布式的變量機制，其原理類似于mapreduce，即分布式的改變，然後聚合這些改變。累加器的一個常見用途是在調試時對作業執行過程中的事件進行計數。而廣播變量用來高效分發較大的對象。

共享變量出現的原因：

通常在向 Spark 傳遞函數時，比如使用 map() 函數或者用 filter() 傳條件時，可以使用驅動器程式中定義的變量，但是叢集中運作的每個任務都會得到這些變量的一份新的副本，更新這些副本的值也不會影響驅動器中的對應變量。

Spark 的兩個共享變量，累加器與廣播變量，分别為結果聚合與廣播這兩種常見的通信模式突破了這一限制。

44.當 Spark 涉及到資料庫的操作時，如何減少 Spark 運作中的資料庫連接配接數？

使用 foreachPartition 代替 foreach，在 foreachPartition 内擷取資料庫的連接配接。

45.特别大的資料，怎麼發送到excutor中？

46.spark調優都做過哪些方面？

47.spark任務為什麼會被yarn kill掉？

48.Spark on Yarn作業執行流程？yarn-client和yarn-cluster有什麼差別？

Spark on Yarn作業執行流程？

1.Spark Yarn Client 向 Yarn 中送出應用程式。

2.ResourceManager 收到請求後，在叢集中選擇一個 NodeManager，并為該應用程式配置設定一個 Container，在這個 Container 中啟動應用程式的 ApplicationMaster， ApplicationMaster 進行 SparkContext 等的初始化。

3.ApplicationMaster 向 ResourceManager 注冊，這樣使用者可以直接通過 ResourceManager 檢視應用程式的運作狀态，然後它将采用輪詢的方式通過RPC協定為各個任務申請資源，并監控它們的運作狀态直到運作結束。

4.ApplicationMaster 申請到資源（也就是Container）後，便與對應的 NodeManager 通信，并在獲得的 Container 中啟動 CoarseGrainedExecutorBackend，啟動後會向 ApplicationMaster 中的 SparkContext 注冊并申請 Task。

5.ApplicationMaster 中的 SparkContext 配置設定 Task 給 CoarseGrainedExecutorBackend 執行，CoarseGrainedExecutorBackend 運作 Task 并向ApplicationMaster 彙報運作的狀态和進度，以讓 ApplicationMaster 随時掌握各個任務的運作狀态，進而可以在任務失敗時重新啟動任務。

6.應用程式運作完成後，ApplicationMaster 向 ResourceManager申請登出并關閉自己。

yarn-client和yarn-cluster有什麼差別？

1.了解YARN-Client和YARN-Cluster深層次的差別之前先清楚一個概念：Application Master。在YARN中，每個Application執行個體都有一個ApplicationMaster程序，它是Application啟動的第一個容器。它負責和ResourceManager打交道并請求資源，擷取資源之後告訴NodeManager為其啟動Container。從深層次的含義講YARN-Cluster和YARN-Client模式的差別其實就是ApplicationMaster程序的差別 2. YARN-Cluster模式下，Driver運作在AM(Application Master)中，它負責向YARN申請資源，并監督作業的運作狀況。當使用者送出了作業之後，就可以關掉Client，作業會繼續在YARN上運作，因而YARN-Cluster模式不适合運作互動類型的作業 3. YARN-Client模式下，Application Master僅僅向YARN請求Executor，Client會和請求的Container通信來排程他們工作，也就是說Client不能離開

49.Flatmap底層編碼實作？

Spark flatMap 源碼：

Scala flatMap 源碼：

flatMap其實就是将RDD裡的每一個元素執行自定義函數f，這時這個元素的結果轉換成iterator，最後将這些再拼接成一個

新的RDD，也可以了解成原本的每個元素由橫向執行函數f後再變為縱向。畫紅部分一直在回調，當RDD内沒有元素為止。

50.spark_1.X與spark_2.X差別 

51.說說spark與flink

四.Kafka

1.Kafka名詞解釋和工作方式

1. Producer ：消息生産者，就是向kafka broker發消息的用戶端。
2. Consumer ：消息消費者，向kafka broker取消息的用戶端
3. Topic ：咋們可以了解為一個隊列。
4. Consumer Group （CG）：這是kafka用來實作一個topic消息的廣播（發給所有的consumer）和單點傳播（發給任意一個consumer）的手段。一個topic可以有多個CG。topic的消息會複制（不是真的複制，是概念上的）到所有的CG，但每個partion隻會把消息發給該CG中的一個consumer。如果需要實作廣播，隻要每個consumer有一個獨立的CG就可以了。要實作單點傳播隻要所有的consumer在同一個CG。用CG還可以将consumer進行自由的分組而不需要多次發送消息到不同的topic。
5. Broker ：一台kafka伺服器就是一個broker。一個叢集由多個broker組成。一個broker可以容納多個topic。
6. Partition：為了實作擴充性，一個非常大的topic可以分布到多個broker（即伺服器）上，一個topic可以分為多個partition，每個partition是一個有序的隊列。partition中的每條消息都會被配置設定一個有序的id（offset）。kafka隻保證按一個partition中的順序将消息發給consumer，不保證一個topic的整體（多個partition間）的順序。
7. Offset：kafka的存儲檔案都是按照offset.kafka來命名，用offset做名字的好處是友善查找。例如你想找位于2049的位置，隻要找到2048.kafka的檔案即可。當然the first offset就是00000000000.kafka

2.Consumer與topic關系

本質上kafka隻支援Topic；

每個group中可以有多個consumer，每個consumer屬于一個consumer group；

通常情況下，一個group中會包含多個consumer，這樣不僅可以提高topic中消息的并發消費能力，而且還能提高"故障容錯"性，如果group中的某個consumer失效那麼其消費的partitions将會有其他consumer自動接管。

對于Topic中的一條特定的消息，隻會被訂閱此Topic的每個group中的其中一個consumer消費，此消息不會發送給一個group的多個consumer；

那麼一個group中所有的consumer将會交錯的消費整個Topic，每個group中consumer消息消費互相獨立，我們可以認為一個group是一個"訂閱"者。

在kafka中,一個partition中的消息隻會被group中的一個consumer消費(同一時刻)；

一個Topic中的每個partions，隻會被一個"訂閱者"中的一個consumer消費，不過一個consumer可以同時消費多個partitions中的消息。

kafka的設計原理決定,對于一個topic，同一個group中不能有多于partitions個數的consumer同時消費，否則将意味着某些consumer将無法得到消息。

kafka隻能保證一個partition中的消息被某個consumer消費時是順序的；事實上，從Topic角度來說,當有多個partitions時,消息仍不是全局有序的。

3.kafka中生産資料的時候，如何保證寫入的容錯性？

設定發送資料是否需要服務端的回報,有三個值0,1,-1

0: producer不會等待broker發送ack

1: 當leader接收到消息之後發送ack

-1: 當所有的follower都同步消息成功後發送ack

request.required.acks=0

4.如何保證kafka消費者消費資料是全局有序的

僞命題

每個分區内，每條消息都有一個offset，故隻能保證分區内有序。

如果要全局有序的，必須保證生産有序，存儲有序，消費有序。

由于生産可以做叢集，存儲可以分片，消費可以設定為一個consumerGroup，要保證全局有序，就需要保證每個環節都有序。

隻有一個可能，就是一個生産者，一個partition，一個消費者。這種場景和大資料應用場景相悖。

5.有兩個資料源，一個記錄的是廣告投放給使用者的日志，一個記錄使用者通路日志，另外還有一個固定的使用者基礎表記錄使用者基本資訊（比如學曆，年齡等等）。現在要分析廣告投放對與哪類使用者更有效，請采用熟悉的技術描述解決思路。另外如果兩個資料源都是實時資料源（比如來自kafka），他們資料在時間上相差5分鐘，需要哪些調整來解決實時分析問題？

6.Kafka和SparkStreaing如何內建?

7.列舉Kafka的優點，簡述Kafka為什麼可以做到每秒數十萬甚至上百萬消息的高效分發？

8.為什麼離線分析要用kafka？

Kafka的作用是解耦，如果直接從日志伺服器上采集的話，實時離線都要采集，等于要采集兩份資料，而使用了kafka的話，隻需要從日志伺服器上采集一份資料，然後在kafka中使用不同的兩個組讀取就行了

9.Kafka怎麼進行監控?

Kafka Manager

10.Kafka與傳統的消息隊列服務有很麼不同

11.Kafka api  low-level與high-level有什麼差別，使用low-level需要處理哪些細節

12.Kafka的ISR副本同步隊列

ISR（In-Sync Replicas），副本同步隊列。ISR中包括Leader和Follower。如果Leader程序挂掉，會在ISR隊列中選擇一個服務作為新的Leader。有replica.lag.max.messages（延遲條數）和replica.lag.time.max.ms（延遲時間）兩個參數決定一台服務是否可以加入ISR副本隊列，在0.10版本移除了replica.lag.max.messages參數，防止服務頻繁的進去隊列。

任意一個次元超過門檻值都會把Follower剔除出ISR，存入OSR（Outof-Sync Replicas）清單，新加入的Follower也會先存放在OSR中。

13.Kafka消息資料積壓，Kafka消費能力不足怎麼處理？

1）如果是Kafka消費能力不足，則可以考慮增加Topic的分區數，并且同時提升消費組的消費者數量，消費者數=分區數。（兩者缺一不可）

2）如果是下遊的資料處理不及時：提高每批次拉取的數量。批次拉取資料過少（拉取資料/處理時間<生産速度），使處理的資料小于生産的資料，也會造成資料積壓。

14.Kafka中的ISR、AR又代表什麼？

 ISR：in-sync replica set (ISR)，與leader保持同步的follower集合

    AR：分區的所有副本

15.Kafka中的HW、LEO等分别代表什麼？

LEO：每個副本的最後條消息的offset

    HW：一個分區中所有副本最小的offset

16.哪些情景會造成消息漏消費？

先送出offset，後消費，有可能造成資料的重複

17.當你使用kafka-topics.sh建立了一個topic之後，Kafka背後會執行什麼邏輯？

  1）會在zookeeper中的/brokers/topics節點下建立一個新的topic節點，如：/brokers/topics/first

    2）觸發Controller的監聽程式

    3）kafka Controller 負責topic的建立工作，并更新metadata cache

18.topic的分區數可不可以增加？如果可以怎麼增加？如果不可以，那又是為什麼？

可以增加

bin/kafka-topics.sh --zookeeper localhost:2181/kafka --alter --topic topic-config --partitions 3

19.topic的分區數可不可以減少？如果可以怎麼減少？如果不可以，那又是為什麼？

不可以減少，被删除的分區資料難以處理。

20.Kafka有内部的topic嗎？如果有是什麼？有什麼所用？

 __consumer_offsets,儲存消費者offset

21.聊一聊Kafka Controller的作用？

負責管理叢集broker的上下線，所有topic的分區副本配置設定和leader選舉等工作。

22.失效副本是指什麼？有那些應對措施？

不能及時與leader同步，暫時踢出ISR，等其追上leader之後再重新加入

五.Hbase

1.Hbase調優

• 高可用

在HBase中Hmaster負責監控RegionServer的生命周期，均衡RegionServer的負載，如果Hmaster挂掉了，那麼整個HBase叢集将陷入不健康的狀态，并且此時的工作狀态并不會維持太久。是以HBase支援對Hmaster的高可用配置。

• 預分區

       每一個region維護着startRow與endRowKey，如果加入的資料符合某個region維護的rowKey範圍，則該資料交給這個region         維護。那麼依照這個原則，我們可以将資料所要投放的分區提前大緻的規劃好，以提高HBase性能。

• 優化RowKey設計

       一條資料的唯一辨別就是rowkey，那麼這條資料存儲于哪個分區，取決于rowkey處于哪個一個預分區的區間内，設計rowkey          的主要目的 ，就是讓資料均勻的分布于所有的region中，在一定程度上防止資料傾斜

• 記憶體優化

HBase操作過程中需要大量的記憶體開銷，畢竟Table是可以緩存在記憶體中的，一般會配置設定整個可用記憶體的70%給HBase的Java堆。但是不建議配置設定非常大的堆記憶體，因為GC過程持續太久會導緻RegionServer處于長期不可用狀态，一般16~48G記憶體就可以了，如果因為架構占用記憶體過高導緻系統記憶體不足，架構一樣會被系統服務拖死。

2.hbase的rowkey怎麼建立好？列族怎麼建立比較好？

hbase存儲時，資料按照Row key的字典序(byte order)排序存儲。設計key時，要充分排序存儲這個特性，将經常一起讀取的行存儲放到一起。(位置相關性)

一個列族在資料底層是一個檔案，是以将經常一起查詢的列放到一個列族中，列族盡量少，減少檔案的尋址時間。

設計原則

1）rowkey 長度原則

2）rowkey 散列原則

3）rowkey 唯一原則

如何設計

1）生成随機數、hash、散列值

2）字元串反轉

3) 字元串拼接

3.hbase過濾器實作用途

增強hbase查詢資料的功能

減少服務端傳回給用戶端的資料量

4.HBase當機如何處理

答：當機分為HMaster當機和HRegisoner當機，如果是HRegisoner當機，HMaster會将其所管理的region重新分布到其他活動的RegionServer上，由于資料和日志都持久在HDFS中，該操作不會導緻資料丢失。是以資料的一緻性和安全性是有保障的。

如果是HMaster當機，HMaster沒有單點問題，HBase中可以啟動多個HMaster，通過Zookeeper的Master Election機制保證總有一個Master運作。即ZooKeeper會保證總會有一個HMaster在對外提供服務。

5.hive跟hbase的差別是？

共同點：

1.hbase與hive都是架構在hadoop之上的。都是用hadoop作為底層存儲

差別：

2.Hive是建立在Hadoop之上為了減少MapReduce jobs編寫工作的批處理系統，HBase是為了支援彌補Hadoop對實時操作的缺陷的項目 。

3.想象你在操作RMDB資料庫，如果是全表掃描，就用Hive+Hadoop,如果是索引通路，就用HBase+Hadoop 。

4.Hive query就是MapReduce jobs可以從5分鐘到數小時不止，HBase是非常高效的，肯定比Hive高效的多。

5.Hive本身不存儲和計算資料，它完全依賴于HDFS和MapReduce，Hive中的表純邏輯。

6.hive借用hadoop的MapReduce來完成一些hive中的指令的執行

7.hbase是實體表，不是邏輯表，提供一個超大的記憶體hash表，搜尋引擎通過它來存儲索引，友善查詢操作。

8.hbase是列存儲。

9.hdfs作為底層存儲，hdfs是存放檔案的系統，而Hbase負責組織檔案。

10.hive需要用到hdfs存儲檔案，需要用到MapReduce計算架構。

6.hbase寫流程

1/ 用戶端要連接配接zookeeper, 從zk的/hbase節點找到hbase:meta表所在的regionserver（host:port）;

2/ regionserver掃描hbase:meta中的每個region的起始行健，對比r000001這條資料在那個region的範圍内；

3/ 從對應的 info:server key中存儲了region是有哪個regionserver(host:port)在負責的；

4/ 用戶端直接請求對應的regionserver；

5/ regionserver接收到用戶端發來的請求之後，就會将資料寫入到region中

7.hbase讀流程

1/ 首先Client連接配接zookeeper, 找到hbase:meta表所在的regionserver;

2/ 請求對應的regionserver，掃描hbase:meta表，根據namespace、表名和rowkey在meta表中找到r00001所在的region是由那個regionserver負責的；

3/找到這個region對應的regionserver

4/ regionserver收到了請求之後，掃描對應的region傳回資料到Client

(先從MemStore找資料，如果沒有，再到BlockCache裡面讀；BlockCache還沒有，再到StoreFile上讀(為了讀取的效率)；

如果是從StoreFile裡面讀取的資料，不是直接傳回給用戶端，而是先寫入BlockCache，再傳回給用戶端。)

8.hbase資料flush過程

1）當MemStore資料達到門檻值（預設是128M，老版本是64M），将資料刷到硬碟，将記憶體中的資料删除，同時删除HLog中的曆史資料；

2）并将資料存儲到HDFS中；

3）在HLog中做标記點。

9.資料合并過程

1. 當資料塊達到4塊，hmaster将資料塊加載到本地，進行合并
2. 當合并的資料超過256M，進行拆分，将拆分後的region配置設定給不同的hregionserver管理
3. 當hregionser當機後，将hregionserver上的hlog拆分，然後配置設定給不同的hregionserver加載，修改.META.
4. 注意：hlog會同步到hdfs

10.Hmaster和Hgionserver職責

Hmaster

1、管理使用者對Table的增、删、改、查操作；

2、記錄region在哪台Hregion server上

3、在Region Split後，負責新Region的配置設定；

4、新機器加入時，管理HRegion Server的負載均衡，調整Region分布

5、在HRegion Server當機後，負責失效HRegion Server 上的Regions遷移。

Hgionserver

HRegion Server主要負責響應使用者I/O請求，向HDFS檔案系統中讀寫資料，是HBASE中最核心的子產品。

HRegion Server管理了很多table的分區，也就是region。

11.HBase列族和region的關系？

HBase有多個RegionServer，每個RegionServer裡有多個Region，一個Region中存放着若幹行的行鍵以及所對應的資料，一個列族是一個檔案夾，如果經常要搜尋整個一條資料，列族越少越好，如果隻有一部分的資料需要經常被搜尋，那麼将經常搜尋的建立一個列族，其他不常搜尋的建立列族檢索較快。

12.請簡述Hbase的實體模型是什麼

13.請問如果使用Hbase做即席查詢，如何設計二級索引

14.如何避免讀、寫HBaes時通路熱點問題？

（1）加鹽

這裡所說的加鹽不是密碼學中的加鹽，而是在rowkey的前面增加随機數，具體就是給rowkey配置設定一個随機字首以使得它和之前的rowkey的開頭不同。給多少個字首？這個數量應該和我們想要分散資料到不同的region的數量一緻（類似hive裡面的分桶）。

（ 自己了解：即region數量是一個範圍，我們給rowkey配置設定一個随機數，字首（随機數）的範圍是region的數量）

加鹽之後的rowkey就會根據随機生成的字首分散到各個region上，以避免熱點。

（2）哈希

哈希會使同一行永遠用一個字首加鹽。哈希也可以使負載分散到整個叢集，但是讀卻是可以預測的。使用确定的哈希可以讓用戶端重構完整的rowkey，可以使用get操作準确擷取某一個行資料。

（3）反轉

第三種防止熱點的方法是反轉固定長度或者數字格式的rowkey。這樣可以使得rowkey中經常改變的部分（最沒有意義的部分）放在前面。這樣可以有效的随機rowkey，但是犧牲了rowkey的有序性。反轉rowkey的例子：以手機号為rowkey，可以将手機号反轉後的字元串作為rowkey，進而避免諸如139、158之類的固定号碼開頭導 緻的熱點問題。

（4）時間戳反轉

一個常見的資料處理問題是快速擷取資料的最近版本，使用反轉的時間戳作為rowkey的一部分對這個問題十分有用，可以用Long.Max_Value – timestamp追加到key的末尾，例如[key][reverse_timestamp] ,[key] 的最新值可以通過scan [key]獲得[key]的第一條記錄，因為HBase中rowkey是有序的，第一條記錄是最後錄入的資料。

（5）盡量減少行和列的大小

在HBase中，value永遠和它的key一起傳輸的。當具體的值在系統間傳輸時，它的rowkey，列名，時間戳也會一起傳輸。如果你的rowkey和列名很大，HBase storefiles中的索引（有助于随機通路）會占據HBase配置設定的大量記憶體，因為具體的值和它的key很大。可以增加block大小使得storefiles索引再更大的時間間隔增加，或者修改表的模式以減小rowkey和列名的大小。壓縮也有助于更大的索引。

（6）其他辦法

列族名的長度盡可能小，最好是隻有一個字元。冗長的屬性名雖然可讀性好，但是更短的屬性名存儲在HBase中會更好。也可以在建表時預估資料規模，預留region數量，例如create ‘myspace:mytable’, SPLITS => [01,02,03,,…99]

15.布隆過濾器在HBASE中的應用

16.Hbase是用來幹嘛的?什麼樣的資料會放到hbase

六.數倉

1.維表和寬表的考查（主要考察維表的使用及次元退化手法）

維表資料一般根據ods層資料加工生成，在設計寬表的時候，可以适當的用一些次元退化手法，将次元退化到事實表中，減少事實表和維表的關聯

2.數倉表命名規範

每個公司都會有點差别

ODS

ods.庫名_表名_df/di/da/dz

CDM(dwd/dws)

dwd.主題_内容_df

3.拉連結清單的使用場景

1.資料量比較大

2.表中的部分字段會被更新

3.需要檢視某一個時間點或者時間段的曆史快照資訊

            檢視某一個訂單在曆史某一個時間點的狀态

            某一個使用者在過去某一段時間，下單次數

4.更新的比例和頻率不是很大

         如果表中資訊變化不是很大，每天都保留一份全量，那麼每次全量中會儲存很多不變的資訊，對存儲是極大的浪費

4.一億條資料查的很慢,怎麼查快一點

5.有什麼維表

時間維表，使用者維表，醫院維表等

6.資料源都有哪些

業務庫資料源:mysql,oracle,mongo

日志資料：ng日志，埋點日志

爬蟲資料

7.你們最大的表是什麼表,資料量多少

ng日志表，三端(app,web,h5)中app端日志量最大，清洗入庫後的資料一天大概xxxxW

8.數倉架構體系

9.資料平台是怎樣的，用到了阿裡的那一套嗎？

沒用到阿裡那一套，資料平台為自研産品

10.你了解的排程系統有那些？，你們公司用的是哪種排程系統

airflow，azkaban，ooize，我們公司使用的是airflow

11.你們公司數倉底層是怎麼抽資料的？

業務資料用的是datax

日志資料用的是logstash

12.為什麼datax抽資料要比sqoop 快？

13.埋點資料你們是怎樣接入的

logstash-->kafka-->logstash-->hdfs

14.如果你們業務庫的表有更新，你們數倉怎麼處理的？

根據表資料量及表特性，選擇用全量表，增量表，追加表和拉連結清單處理

15.能獨立搭建數倉嗎

可以

16.搭建過CDH 叢集嗎

17.說一下你們公司的大資料平台架構？你有參與嗎？

18.介紹一下你自己的項目和所用的技術

19.對目前的流和批處理的認識？就是談談自己的感受

20.你了解那些OLAP 引擎，MPP 知道一些嗎？clickHouse 了解一些嗎？你自己做過測試性能嗎？

21.Kylin 有了解嗎？介紹一下原理

22.datax 源碼有改造過嗎

改造過

23.你們數倉的APP 層是怎麼對外提供服務的？

1.直接存入mysql業務庫，業務方直接讀取

2.資料存入mysql，以接口的形式提供資料

3.資料存入kylin，需求方通過jdbc讀取資料

24.資料接入進來，你們是怎樣規劃的，有考慮資料的膨脹問題嗎

25.簡述拉連結清單，流水表以及快照表的含義和特點

拉連結清單：

（1）記錄一個事物從開始，一直到目前狀态的所有變化的資訊；

（2）拉連結清單每次上報的都是曆史記錄的最終狀态，是記錄在目前時刻的曆史總量；

（3）目前記錄存的是目前時間之前的所有曆史記錄的最後變化量（總量）；

（4）封鍊時間可以是2999，3000，9999等等比較大的年份；拉連結清單到期資料要報0；

流水表：對于表的每一個修改都會記錄，可以用于反映實際記錄的變更

　差別于拉連結清單：　

  拉連結清單通常是對賬戶資訊的曆史變動進行處理保留的結果，流水表是每天的交易形成的曆史；

  流水表用于統計業務相關情況，拉連結清單用于統計賬戶及客戶的情況

 快照表：

 按天分區，每一天的資料都是截止到那一天mysql的全量資料

26.全量表(df),增量表(di),追加表(da)，拉連結清單(dz)的差別及使用場景

27.你們公司的數倉分層，每一層是怎麼處理資料的

28.什麼是事實表，什麼是維表

29.星型模型和雪花模型

30.緩慢變化維如何處理，幾種方式

31.datax與sqoop的優缺點

32.datax抽數碰到emoji表情怎麼解決

33.工作中碰到什麼困難，怎麼解決的

34.如何用資料給公司帶來收益

35.需求驅動和業務驅動，資料開發和ETL開發，實戰型和部落格型

36.如何用資料實作業務增長，黑客增長？

37.什麼是大資料？千萬級别的資料完全可以用傳統的關系型資料庫叢集解決，為什麼要用到大資料平台。

38.資料品質，中繼資料管理，名額體系建設，資料驅動

39.什麼是數倉,建設數倉時碰到過什麼問題

40.實時數倉技術選型及保證exactly-once

41.次元模組化和範式模組化的差別；

42.埋點的碼表如何設計；

43.集市層和公共層的差別；

44.緩慢變化維的處理方式

45.聊聊資料品質

46.說說你從0-1搭建數倉都做了什麼？你覺得最有挑戰的是什麼？

七.Flink

1.Flink實時計算時落磁盤嗎

不落，是記憶體計算

2.日活DAU的統計需要注意什麼

3.Flink調優

4.Flink的容錯是怎麼做的

定期checkpoint存儲oprator state及keyedstate到stateBackend

5.Parquet格式的好處？什麼時候讀的快什麼時候讀的慢

6.flink中checkPoint為什麼狀态有儲存在記憶體中這樣的機制？為什麼要開啟checkPoint?

開啟checkpoint可以容錯，程式自動重新開機的時候可以從checkpoint中恢複資料

7.flink保證Exactly_Once的原理？

1.開啟checkpoint

2.source支援資料重發

3.sink支援事務，可以分2次送出，如kafka；或者sink支援幂等，可以覆寫之前寫入的資料，如redis

滿足以上三點，可以保證Exactly_Once

8.flink的時間形式和視窗形式有幾種？有什麼差別，你們用在什麼場景下的？

9.flink的背壓說下？

10.flink的watermark機制說下，以及怎麼解決資料亂序的問題？

11.flink on yarn執行流程

       Flink任務送出後，Client向HDFS上傳Flink的Jar包和配置，之後向Yarn ResourceManager送出任務，ResourceManager配置設定Container資源并通知對應的NodeManager啟動ApplicationMaster，ApplicationMaster啟動後加載Flink的Jar包和配置建構環境，然後啟動JobManager，之後ApplicationMaster向ResourceManager申請資源啟動TaskManager，ResourceManager配置設定Container資源後，由ApplicationMaster通知資源所在節點的NodeManager啟動TaskManager，NodeManager加載Flink的Jar包和配置建構環境并啟動TaskManager，TaskManager啟動後向JobManager發送心跳包，并等待JobManager向其配置設定任務。

12.說一說spark 和flink 的差別 

八.Java

1.hashMap底層源碼，資料結構

2.寫出你用過的設計模式，并舉例說明解決的實際問題

3.Java建立線程的幾種方式

1. 繼承Thread類，重寫run方法
2. 實作Runnable接口，實作run方法
3. 通過線程池擷取線程
4. 實作Callable接口并實作call方法，建立該類的執行個體，使用FutureTask類包裝Callable對象，使用FutureTask對象作為Thread對象的target建立并啟用新線程

4.請簡述作業系統的線程和程序的差別

5.Java程式出現OutOfMemoryError:unable to create new native thread 的原因可能有哪些？如何分析和解決？

6.采用java或自己熟悉的任何語言分别實作簡單版本的線性表和連結清單，隻需實作add,remove方法即可

7.ArrayList和LinkedList的差別

8.JVM 記憶體分哪幾個區，每個區的作用是什麼?

9.Java中疊代器和集合的差別？

集合是将所有資料加載到記憶體，然後通過集合的方法去記憶體中擷取，而疊代器是一個對象，實作了Iterator接口，實作了接口的hasNext和Next方法。

10.HashMap 和 HashTable 差別

1) 線程安全性不同

HashMap 是線程不安全的，HashTable 是線程安全的，其中的方法是 Synchronize 的，

在多線程并發的情況下，可以直接使用 HashTabl，但是使用 HashMap 時必須自己增加同步

處理。

2) 是否提供 contains 方法

HashMap 隻有 containsValue 和 containsKey 方法；HashTable 有 contains、containsKey

和 containsValue 三個方法，其中 contains 和 containsValue 方法功能相同。

3) key 和 value 是否允許 null 值

Hashtable 中，key 和 value 都不允許出現 null 值。HashMap 中，null 可以作為鍵，這

樣的鍵隻有一個；可以有一個或多個鍵所對應的值為 null。

4) 數組初始化和擴容機制

HashTable 在不指定容量的情況下的預設容量為 11，而 HashMap 為 16，Hashtable 不

要求底層數組的容量一定要為 2 的整數次幂，而 HashMap 則要求一定為 2 的整數次幂。

Hashtable 擴容時，将容量變為原來的 2 倍加 1，而 HashMap 擴容時，将容量變為原

來的 2 倍。

11.線程池使用注意哪些方面？

線程池分為單線程線程池，固定大小線程池，可緩沖的線程池

12.HashMap和TreeMap的差別？TreeMap排序規則？

TreeMap會自動進行排序，根據key的Compare方法進行排序

13.用java實作單例模式

14.使用遞歸算法求n的階乘：n! ,語言不限

15.HashMap和Hashtable的差別是什麼

16.TreeSet 和 HashSet 差別

HashSet 是采用 hash 表來實作的。其中的元素沒有按順序排列，add()、remove()以及

contains()等方法都是複雜度為 O(1)的方法。

TreeSet 是采用樹結構實作（紅黑樹算法）。元素是按順序進行排列，但是 add()、

remove()以及 contains()等方法都是複雜度為 O(log (n))的方法。它還提供了一些方法來處理

排序的 set，如 first()，last()，headSet()，tailSet()等等。

17.Stringbuffer 和 Stringbuild 差別

1、StringBuffer 與 StringBuilder 中的方法和功能完全是等價的。

2、隻是 StringBuffer 中的方法大都采用了 synchronized 關鍵字進行修飾，是以是線程

安全的，而 StringBuilder 沒有這個修飾，可以被認為是線程不安全的。

3、在單線程程式下，StringBuilder 效率更快，因為它不需要加鎖，不具備多線程安全

而 StringBuffer 則每次都需要判斷鎖，效率相對更低

18.Final、Finally、Finalize

final：修飾符（關鍵字）有三種用法：修飾類、變量和方法。修飾類時，意味着它不

能再派生出新的子類，即不能被繼承，是以它和 abstract 是反義詞。修飾變量時，該變量

使用中不被改變，必須在聲明時給定初值，在引用中隻能讀取不可修改，即為常量。修飾

方法時，也同樣隻能使用，不能在子類中被重寫。

finally：通常放在 try…catch 的後面構造最終執行代碼塊，這就意味着程式無論正常執

行還是發生異常，這裡的代碼隻要 JVM 不關閉都能執行，可以将釋放外部資源的代碼寫在

finally 塊中。

finalize：Object 類中定義的方法，Java 中允許使用 finalize() 方法在垃圾收集器将對象

從記憶體中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷毀對象時調用

的，通過重寫 finalize() 方法可以整理系統資源或者執行其他清理工作。

19..==和 Equals 差別

== : 如果比較的是基本資料類型，那麼比較的是變量的值

如果比較的是引用資料類型，那麼比較的是位址值（兩個對象是否指向同一塊内

存）

equals:如果沒重寫 equals 方法比較的是兩個對象的位址值。

如果重寫了 equals 方法後我們往往比較的是對象中的屬性的内容

equals 方法是從 Object 類中繼承的，預設的實作就是使用==

20.比較ArrayList，LinkedList的存儲特性和讀寫性能

21.Java 類加載過程

Java類加載需要經曆一下幾個過程：

• 加載

加載時類加載的第一個過程，在這個階段，将完成一下三件事情：

1. 通過一個類的全限定名擷取該類的二進制流。
2. 将該二進制流中的靜态存儲結構轉化為方法去運作時資料結構。 
3. 在記憶體中生成該類的Class對象，作為該類的資料通路入口。

•  驗證

驗證的目的是為了確定Class檔案的位元組流中的資訊不回危害到虛拟機.在該階段主要完成以下四鐘驗證: 

1. 檔案格式驗證：驗證位元組流是否符合Class檔案的規範，如主次版本号是否在目前虛拟機範圍内，常量池中的常量是否有不被支援的類型.
2. 中繼資料驗證:對位元組碼描述的資訊進行語義分析，如這個類是否有父類，是否內建了不被繼承的類等。
3. 位元組碼驗證：是整個驗證過程中最複雜的一個階段，通過驗證資料流和控制流的分析，确定程式語義是否正确，主要針對方法體的驗證。如：方法中的類型轉換是否正确，跳轉指令是否正确等。
4. 符号引用驗證：這個動作在後面的解析過程中發生，主要是為了確定解析動作能正确執行。
5. 準備

準備階段是為類的靜态變量配置設定記憶體并将其初始化為預設值，這些記憶體都将在方法區中進行配置設定。準備階段不配置設定類中的執行個體變量的記憶體，執行個體變量将會在對象執行個體化時随着對象一起配置設定在Java堆中。

• 解析

該階段主要完成符号引用到直接引用的轉換動作。解析動作并不一定在初始化動作完成之前，也有可能在初始化之後。

• 初始化

初始化時類加載的最後一步，前面的類加載過程，除了在加載階段使用者應用程式可以通過自定義類加載器參與之外，其餘動作完全由虛拟機主導和控制。到了初始化階段，才真正開始執行類中定義的Java程式代碼。

22.java中垃圾收集的方法有哪些?

23.如何判斷一個對象是否存活?(或者GC對象的判定方法)

判斷一個對象是否存活有兩種方法: 

1. 引用計數法
2. 可達性算法(引用鍊法)

24.jvm、堆棧

九.Elasticsearch

1.為什麼要用es？存進es的資料是什麼格式的，怎麼查詢

十.Flume

1.什麼是flume

a.Flume是一個分布式、可靠、和高可用的海量日志采集、聚合和傳輸的系統。

b.Flume可以采集檔案，socket資料包等各種形式源資料，又可以将采集到的資料輸出到HDFS、hbase、hive、kafka等衆多外部存儲系統中

c.一般的采集需求，通過對flume的簡單配置即可實作

d.ume針對特殊場景也具備良好的自定義擴充能力，是以，flume可以适用于大部分的日常資料采集場景

2.flume運作機制

1. Flume分布式系統中最核心的角色是agent，flume采集系統就是由一個個agent所連接配接起來形成
2. 每一個agent相當于一個資料傳遞員，内部有三個元件：
   1. Source：采集源，用于跟資料源對接，以擷取資料
   2. Sink：下沉地，采集資料的傳送目的，用于往下一級agent傳遞資料或者往最終存儲系統傳遞資料
   3. Channel：angent内部的資料傳輸通道，用于從source将資料傳遞到sink

3.Flume采集資料到Kafka中丢資料怎麼辦

4.Flume怎麼進行監控?

5.Flume的三層架構，collector、agent、storage

十一.Sqoop

1.Sqoop底層運作的任務是什麼

隻有Map階段，沒有Reduce階段的任務。

2.sqoop的遷移資料的原理

3.Sqoop參數

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

--connect \

--username \

--password \

--target-dir \

--delete-target-dir \

--num-mappers \

--fields-terminated-by   \

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

4.Sqoop導入導出Null存儲一緻性問題

Hive中的Null在底層是以“\N”來存儲，而MySQL中的Null在底層就是Null，為了保證資料兩端的一緻性。在導出資料時采用--input-null-string和--input-null-non-string兩個參數。導入資料時采用--null-string和--null-non-string。

5.Sqoop資料導出一緻性問題

1）場景1：如Sqoop在導出到Mysql時，使用4個Map任務，過程中有2個任務失敗，那此時MySQL中存儲了另外兩個Map任務導入的資料，此時老闆正好看到了這個報表資料。而開發工程師發現任務失敗後，會調試問題并最終将全部資料正确的導入MySQL，那後面老闆再次看報表資料，發現本次看到的資料與之前的不一緻，這在生産環境是不允許的。

2）場景2：設定map數量為1個（不推薦，面試官想要的答案不隻這個）

多個Map任務時，采用–staging-table方式，仍然可以解決資料一緻性問題。

十二.Redis

1.緩存穿透、緩存雪崩、緩存擊穿

1）緩存穿透是指查詢一個一定不存在的資料。由于緩存命不中時會去查詢資料庫，查不到

資料則不寫入緩存，這将導緻這個不存在的資料每次請求都要到資料庫去查詢，造成緩存穿

透。

解決方案：

① 是将空對象也緩存起來，并給它設定一個很短的過期時間，最長不超過 5 分鐘

② 采用布隆過濾器，将所有可能存在的資料哈希到一個足夠大的 bitmap 中，一個一定

不存在的資料會被這個 bitmap 攔截掉，進而避免了對底層存儲系統的查詢壓力

2）如果緩存集中在一段時間内失效，發生大量的緩存穿透，所有的查詢都落在資料庫上，

就會造成緩存雪崩。

解決方案：

盡量讓失效的時間點不分布在同一個時間點

3）緩存擊穿，是指一個 key 非常熱點，在不停的扛着大并發，當這個 key 在失效的瞬間，

持續的大并發就穿破緩存，直接請求資料庫，就像在一個屏障上鑿開了一個洞。

可以設定 key 永不過期

2.資料類型

3.持久化

1）RDB 持久化：

① 在指定的時間間隔内持久化

② 服務 shutdown 會自動持久化

③ 輸入 bgsave 也會持久化

2）AOF : 以日志形式記錄每個更新操作

Redis 重新啟動時讀取這個檔案，重新執行建立、修改資料的指令恢複資料。

儲存政策：

推薦（并且也是預設）的措施為每秒持久化一次，這種政策可以兼顧速度和安全性。

缺點：

1 比起 RDB 占用更多的磁盤空間

2 恢複備份速度要慢

3 每次讀寫都同步的話，有一定的性能壓力

4 存在個别 Bug，造成恢複不能

選擇政策：

官方推薦：

string

字元串

list

可以重複的集合

set

不可以重複的集合

hash

類似于 Map<String,String>

zset(sorted set）

帶分數的 set  

如果對資料不敏感，可以選單獨用 RDB；不建議單獨用 AOF，因為可能出現 Bug;如果隻是做純記憶體緩存，可以都不用

4.悲觀鎖和樂觀鎖

悲觀鎖：執行操作前假設目前的操作肯定（或有很大幾率）會被打斷（悲觀）。基于這個假設，我們在做操作前就會把相關資源鎖定，不允許自己執行期間有其他操作幹擾。

樂觀鎖：執行操作前假設目前操作不會被打斷（樂觀）。基于這個假設，我們在做操作前不會鎖定資源，萬一發生了其他操作的幹擾，那麼本次操作将被放棄。Redis 使用的就是樂觀鎖。

5.redis 是單線程的，為什麼那麼快

1)完全基于記憶體，絕大部分請求是純粹的記憶體操作，非常快速。

2)資料結構簡單，對資料操作也簡單，Redis 中的資料結構是專門進行設計的

3)采用單線程，避免了不必要的上下文切換和競争條件，也不存在多程序或者多線程導緻的切換而消耗 CPU，不用去考慮各種鎖的問題，不存在加鎖釋放鎖操作，沒有因為可能出現死鎖而導緻的性能消耗

4)使用多路 I/O 複用模型，非阻塞 IO

5)使用底層模型不同，它們之間底層實作方式以及與用戶端之間通信的應用協定不一樣，

Redis 直接自己建構了 VM 機制 ，因為一般的系統調用系統函數的話，會浪費一定的時間去移動和請求

6.redis的熱鍵問題？怎麼解決？

十三.Mysql

1.請寫出mysql登入指令，使用者名user，密碼123456，位址192.168.1.130

mysql -h 192.168.1.130 -uuser -p123456 -P3306 -Dwemeta_test

2.為什麼MySQL的索引要使用B+樹而不是其它樹形結構?比如B樹？

B樹

       B樹不管葉子節點還是非葉子節點，都會儲存資料，這樣導緻在非葉子節點中能儲存的指針數量變少（有些資料也稱為扇出）

指針少的情況下要儲存大量資料，隻能增加樹的高度，導緻IO操作變多，查詢性能變低；

B+樹

             1.單一節點存儲更多的元素，使得查詢的IO次數更少。

　　　　2.所有查詢都要查找到葉子節點，查詢性能穩定。

　　　　3.所有葉子節點形成有序連結清單，便于範圍查詢,遠遠高于B-樹

十四.資料結構與算法

1.二分查找

package com.wedoctor.search;              public class Binarysearch {              public static int bsearchWithoutRecursion(int arr[], int key) {              int low = 0;              int high = arr.length - 1;              while (low <= high) {              int mid = low + (high - low) / 2;              if (arr[mid] > key)              high = mid - 1;              else if (arr[mid] < key)              low = mid + 1;              else              return mid;              }              return -1;              }              public static void main(String[] args) {              int arr[] = {1,3,5,6,8,9,11,14,23};              int num = bsearchWithoutRecursion(arr, 9);              System.out.println(num);              }              }           

2.快排

3.歸并排序

4.冒泡排序

package com.wedoctor.sort;              import java.util.Arrays;              public class BubbleSort {              public static void main(String[] args) {              int[] arr = new int[] { 2, 8, 7, 9, 4, 1, 5, 0 };              bubbleSort(arr);              }              public static void bubbleSort(int[] arr) {              //控制多少輪              for (int i = 1; i < arr.length; i++) {              //控制每一輪的次數              for (int j = 0; j <= arr.length -1 - i; j++) {              if (arr[j] > arr[j + 1]) {              int temp;              temp = arr[j];              arr[j] = arr[j + 1];              arr[j + 1] = temp;              }              }              }              System.out.println(Arrays.toString(arr));              }              }           

5.字元串反轉

package com.wedoctor.str;              public class StrReverse {              public  static  String getNewStr(String str){              StringBuffer sb = new StringBuffer(str);              String newStr = sb.reverse().toString();              return newStr;              }              public static void main(String[] args) {              System.out.println(getNewStr("thjymhr"));              }              }           

6.Btree簡單講一下

B樹(B-樹)是一種适合外查找的搜尋樹，是一種平衡的多叉樹 

B樹的每個結點包含着結點的值和結點所處的位置

7.動态規劃 最大連續子序列和

package com.wedoctor;              import java.util.Arrays;              public class MaxSum {              public static int findMax(int arr[]){              if (arr.length == 1){              return arr[0];              }              int mid = (arr.length) / 2;              int[] leftArr = Arrays.copyOfRange(arr, 0, mid);              int[] rightArr = Arrays.copyOfRange(arr, mid, arr.length);              int lenLeft = findMax(leftArr);              int lenRight = findMax(rightArr);              int lenMid = maxInMid(leftArr, rightArr);              int max = Math.max(Math.max(lenLeft,lenRight),lenMid);              return max;              }              public static int maxInMid(int left[],int right[]){              int maxLeft = 0;              int maxRight = 0;              int tmpLeft = 0;              int tmpRight = 0;              for (int i = 0;i< left.length;i++){              tmpLeft = tmpLeft + left[left.length - 1 - i];              maxLeft = Math.max(tmpLeft,maxLeft);              }              for (int i = 0;i< right.length;i++){              tmpRight = tmpRight + right[i];              maxRight = Math.max(tmpRight,maxRight);              }              return  maxRight + maxLeft;              }              public static void main(String[] args) {              int arr[] = {3,-1,10};              System.out.println(findMax(arr));              }              }           

8.二叉樹概念，特點及代碼實作

二叉樹是n(n>=0)個結點的有限集合，該集合或者為空集（稱為空二叉樹），或者由一個根結點和兩棵互不相交的、分别稱為根結點的左子樹和右子樹組成。

特點：

• 每個結點最多有兩顆子樹，是以二叉樹中不存在度大于2的結點。
• 左子樹和右子樹是有順序的，次序不能任意颠倒。
• 即使樹中某結點隻有一棵子樹，也要區分它是左子樹還是右子樹。

實作：

package com.wedoctor;              public class BinaryTreeNode {              int data;              BinaryTreeNode left;              BinaryTreeNode right;              BinaryTreeNode (int x) {              data= x;              }              public BinaryTreeNode(int data, BinaryTreeNode left, BinaryTreeNode right) {              this.data = data;              this.left = left;              this.right = right;              }              public int getData() {              return data;              }              public void setData(int data) {              this.data = data;              }              public BinaryTreeNode getLeft() {              return left;              }              public void setLeft(BinaryTreeNode left) {              this.left = left;              }              public BinaryTreeNode getRight() {              return right;              }              public void setRight(BinaryTreeNode right) {              this.right = right;              }              }           

9.連結清單

十五.Linux

序号	指令	指令解釋
1	top	檢視記憶體
2	df -h	檢視磁盤存儲情況
3	iotop	檢視磁盤IO讀寫(yum install iotop安裝）
4	iotop -o	直接檢視比較高的磁盤讀寫程式
5	netstat -tunlp | grep 端口号	檢視端口占用情況
6	uptime	檢視報告系統運作時長及平均負載
7	ps  aux	檢視程序