一、簡答題

1.Spark master使用zookeeper進行HA的，有哪些元資料儲存在Zookeeper？
答：spark通過這個引數spark.deploy.zookeeper.dir指定master元資料在zookeeper中儲存的位置，包括Worker，Driver和Application以及Executors。standby節點要從zk中，獲得元資料資訊，恢復叢集執行狀態，才能對外繼續提供服務，作業提交資源申請等，在恢復前是不能接受請求的。另外，Master切換需要注意2點
1）在Master切換的過程中，所有的已經在執行的程式皆正常執行！因為Spark Application在執行前就已經通過Cluster Manager獲得了計算資源，所以在執行時Job本身的排程和處理和Master是沒有任何關係的！
2） 在Master的切換過程中唯一的影響是不能提交新的Job：一方面不能夠提交新的應用程式給叢集，因為只有Active Master才能接受新的程式的提交請求；另外一方面，已經執行的程式中也不能夠因為Action操作觸發新的Job的提交請求；
2.Spark master HA 主從切換過程不會影響叢集已有的作業執行，為什麼？
答：因為程式在執行之前，已經申請過資源了，driver和Executors通訊，不需要和master進行通訊的。
3.Spark on Mesos中，什麼是的粗粒度分配，什麼是細粒度分配，各自的優點和缺點是什麼？
答：1）粗粒度：啟動時就分配好資源， 程式啟動，後續具體使用就使用分配好的資源，不需要再分配資源；好處：作業特別多時，資源複用率高，適合粗粒度；不好：容易資源浪費，假如一個job有1000個task，完成了999個，還有一個沒完成，那麼使用粗粒度，999個資源就會閒置在那裡，資源浪費。2）細粒度分配：用資源的時候分配，用完了就立即回收資源，啟動會麻煩一點，啟動一次分配一次，會比較麻煩。
4.如何配置spark master的HA？
1)配置zookeeper
2)修改spark_env.sh檔案,spark的master引數不在指定，新增如下程式碼到各個master節點
  export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=zk01:2181,zk02:2181,zk03:2181 -Dspark.deploy.zookeeper.dir=/spark"
3) 將spark_env.sh分發到各個節點
4)找到一個master節點，執行./start-all.sh，會在這裡啟動主master,其他的master備節點，啟動master命令: ./sbin/start-master.sh 
5)提交程式的時候指定master的時候要指定三臺master，例如
./spark-shell --master spark://master01:7077,master02:7077,master03:7077
5.Apache Spark有哪些常見的穩定版本，Spark1.6.0的數字分別代表什麼意思？
答：常見的大的穩定版本有Spark 1.3,Spark1.6, Spark 2.0 ，Spark1.6.0的數字含義
1）第一個數字：1 
major version : 代表大版本更新，一般都會有一些 api 的變化，以及大的優化或是一些結構的改變；
2）第二個數字：6 
minor version : 代表小版本更新，一般會新加 api，或者是對當前的 api 就行優化，或者是其他內容的更新，比如說 WEB UI 的更新等等；
3）第三個數字：0
patch version ， 代表修復當前小版本存在的一些 bug，基本不會有任何 api 的改變和功能更新；記得有一個大神曾經說過，如果要切換 spark 版本的話，最好選 patch version 非 0 的版本，因為一般類似於 1.2.0, … 1.6.0 這樣的版本是屬於大更新的，有可能會有一些隱藏的 bug 或是不穩定性存在，所以最好選擇 1.2.1, … 1.6.1 這樣的版本。
通過版本號的解釋說明，可以很容易瞭解到，spark2.1.1的釋出時是針對大版本2.1做的一些bug修改，不會新增功能，也不會新增API，會比2.1.0版本更加穩定。
6.driver的功能是什麼？
答： 1）一個Spark作業執行時包括一個Driver程序，也是作業的主程序，具有main函式，並且有SparkContext的例項，是程式的人口點；2）功能：負責向叢集申請資源，向master註冊資訊，負責了作業的排程，，負責作業的解析、生成Stage並排程Task到Executor上。包括DAGScheduler，TaskScheduler。
7.spark的有幾種部署模式，每種模式特點？
1）本地模式
Spark不一定非要跑在hadoop叢集，可以在本地，起多個執行緒的方式來指定。將Spark應用以多執行緒的方式直接執行在本地，一般都是為了方便除錯，本地模式分三類
·  local：只啟動一個executor
·  local[k]:啟動k個executor
·  local
：啟動跟cpu數目相同的 executor
2)standalone模式
分散式部署叢集， 自帶完整的服務，資源管理和任務監控是Spark自己監控，這個模式也是其他模式的基礎，
3)Spark on yarn模式
分散式部署叢集，資源和任務監控交給yarn管理，但是目前僅支援粗粒度資源分配方式，包含cluster和client執行模式，cluster適合生產，driver執行在叢集子節點，具有容錯功能，client適合除錯，dirver執行在客戶端
4）Spark On Mesos模式。官方推薦這種模式（當然，原因之一是血緣關係）。正是由於Spark開發之初就考慮到支援Mesos，因此，目前而言，Spark執行在Mesos上會比執行在YARN上更加靈活，更加自然。使用者可選擇兩種排程模式之一執行自己的應用程式：
1)   粗粒度模式（Coarse-grained Mode）：每個應用程式的執行環境由一個Dirver和若干個Executor組成，其中，每個Executor佔用若干資源，內部可執行多個Task（對應多少個“slot”）。應用程式的各個任務正式執行之前，需要將執行環境中的資源全部申請好，且執行過程中要一直佔用這些資源，即使不用，最後程式執行結束後，回收這些資源。
2)   細粒度模式（Fine-grained Mode）：鑑於粗粒度模式會造成大量資源浪費，Spark On Mesos還提供了另外一種排程模式：細粒度模式，這種模式類似於現在的雲端計算，思想是按需分配。
8.Spark技術棧有哪些元件，每個元件都有什麼功能，適合什麼應用場景？
答：可以畫一個這樣的技術棧圖先，然後分別解釋下每個元件的功能和場景

file:///E:/%E5%AE%89%E8%A3%85%E8%BD%AF%E4%BB%B6/%E6%9C%89%E9%81%93%E7%AC%94%E8%AE%B0%E6%96%87%E4%BB%B6/qq19B99AF2399E52F466CC3CF7E3B24ED5/dc318cd93346448487e9f423ce499b4b/d1d97571615f01111094fdcae4bed078.jpg
1）Spark core：是其它元件的基礎，spark的核心，主要包含：有向迴圈圖、RDD、Lingage、Cache、broadcast等，並封裝了底層通訊框架，是Spark的基礎。
2）SparkStreaming是一個對實時資料流進行高通量、容錯處理的流式處理系統，可以對多種資料來源（如Kdfka、Flume、Twitter、Zero和TCP 套接字）進行類似Map、Reduce和Join等複雜操作，將流式計算分解成一系列短小的批處理作業。
3）Spark sql：Shark是SparkSQL的前身，Spark SQL的一個重要特點是其能夠統一處理關係表和RDD，使得開發人員可以輕鬆地使用SQL命令進行外部查詢，同時進行更復雜的資料分析
4）BlinkDB ：是一個用於在海量資料上執行互動式 SQL 查詢的大規模並行查詢引擎，它允許使用者通過權衡資料精度來提升查詢響應時間，其資料的精度被控制在允許的誤差範圍內。
5）MLBase是Spark生態圈的一部分專注於機器學習，讓機器學習的門檻更低，讓一些可能並不瞭解機器學習的使用者也能方便地使用MLbase。MLBase分為四部分：MLlib、MLI、ML Optimizer和MLRuntime。
6）GraphX是Spark中用於圖和圖平行計算
9.Spark中Work的主要工作是什麼？
答：主要功能：管理當前節點記憶體，CPU的使用狀況，接收master分配過來的資源指令，通過ExecutorRunner啟動程式分配任務，worker就類似於包工頭，管理分配新程序，做計算的服務，相當於process服務。需要注意的是：1）worker會不會彙報當前資訊給master，worker心跳給master主要只有workid，它不會發送資源資訊以心跳的方式給mater，master分配的時候就知道work，只有出現故障的時候才會傳送資源。2）worker不會執行程式碼，具體執行的是Executor是可以執行具體appliaction寫的業務邏輯程式碼，操作程式碼的節點，它不會執行程式的程式碼的。
10.Spark為什麼比mapreduce快？
答：1）基於記憶體計算，減少低效的磁碟互動；2）高效的排程演算法，基於DAG；3)容錯機制Linage，精華部分就是DAG和Lingae
11.簡單說一下hadoop和spark的shuffle相同和差異？
答：1）從 high-level 的角度來看，兩者並沒有大的差別。 都是將 mapper（Spark 裡是 ShuffleMapTask）的輸出進行 partition，不同的 partition 送到不同的 reducer（Spark 裡 reducer 可能是下一個 stage 裡的 ShuffleMapTask，也可能是 ResultTask）。Reducer 以記憶體作緩衝區，邊 shuffle 邊 aggregate 資料，等到資料 aggregate 好以後進行 reduce() （Spark 裡可能是後續的一系列操作）。
2）從 low-level 的角度來看，兩者差別不小。 Hadoop MapReduce 是 sort-based，進入 combine() 和 reduce() 的 records 必須先 sort。這樣的好處在於 combine/reduce() 可以處理大規模的資料，因為其輸入資料可以通過外排得到（mapper 對每段資料先做排序，reducer 的 shuffle 對排好序的每段資料做歸併）。目前的 Spark 預設選擇的是 hash-based，通常使用 HashMap 來對 shuffle 來的資料進行 aggregate，不會對資料進行提前排序。如果使用者需要經過排序的資料，那麼需要自己呼叫類似 sortByKey() 的操作；如果你是Spark 1.1的使用者，可以將spark.shuffle.manager設定為sort，則會對資料進行排序。在Spark 1.2中，sort將作為預設的Shuffle實現。
3）從實現角度來看，兩者也有不少差別。 Hadoop MapReduce 將處理流程劃分出明顯的幾個階段：map(), spill, merge, shuffle, sort, reduce() 等。每個階段各司其職，可以按照過程式的程式設計思想來逐一實現每個階段的功能。在 Spark 中，沒有這樣功能明確的階段，只有不同的 stage 和一系列的 transformation()，所以 spill, merge, aggregate 等操作需要蘊含在 transformation() 中。
如果我們將 map 端劃分資料、持久化資料的過程稱為 shuffle write，而將 reducer 讀入資料、aggregate 資料的過程稱為 shuffle read。那麼在 Spark 中，問題就變為怎麼在 job 的邏輯或者物理執行圖中加入 shuffle write 和 shuffle read 的處理邏輯？以及兩個處理邏輯應該怎麼高效實現？ 
Shuffle write由於不要求資料有序，shuffle write 的任務很簡單：將資料 partition 好，並持久化。之所以要持久化，一方面是要減少記憶體儲存空間壓力，另一方面也是為了 fault-tolerance。
12.Mapreduce和Spark的都是平行計算，那麼他們有什麼相同和區別
答：兩者都是用mr模型來進行平行計算:
1)hadoop的一個作業稱為job，job裡面分為map task和reduce task，每個task都是在自己的程序中執行的，當task結束時，程序也會結束。 
2)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可以快速啟動讀取記憶體進行計算。 
3)hadoop的job只有map和reduce操作，表達能力比較欠缺而且在mr過程中會重複的讀寫hdfs，造成大量的io操作，多個job需要自己管理關係。 
spark的迭代計算都是在記憶體中進行的，API中提供了大量的RDD操作如join，groupby等，而且通過DAG圖可以實現良好的容錯。
13.RDD機制？ 
答：rdd分散式彈性資料集，簡單的理解成一種資料結構，是spark框架上的通用貨幣。 
所有運算元都是基於rdd來執行的，不同的場景會有不同的rdd實現類，但是都可以進行互相轉換。 
rdd執行過程中會形成dag圖，然後形成lineage保證容錯性等。 從物理的角度來看rdd儲存的是block和node之間的對映。
14、spark有哪些元件？ 
答：主要有如下元件：
1）master：管理叢集和節點，不參與計算。 
2）worker：計算節點，程序本身不參與計算，和master彙報。 
3）Driver：執行程式的main方法，建立spark context物件。 
4）spark context：控制整個application的生命週期，包括dagsheduler和task scheduler等元件。 
5）client：使用者提交程式的入口。
15、spark工作機制？ 
答：使用者在client端提交作業後，會由Driver執行main方法並建立spark context上下文。 
執行add運算元，形成dag圖輸入dagscheduler，按照add之間的依賴關係劃分stage輸入task scheduler。 task scheduler會將stage劃分為task set分發到各個節點的executor中執行。
16、spark的優化怎麼做？ 
答： spark調優比較複雜，但是大體可以分為三個方面來進行，1）平臺層面的調優：防止不必要的jar包分發，提高資料的本地性，選擇高效的儲存格式如parquet，2）應用程式層面的調優：過濾操作符的優化降低過多小任務，降低單條記錄的資源開銷，處理資料傾斜，複用RDD進行快取，作業並行化執行等等，3）JVM層面的調優：設定合適的資源量，設定合理的JVM，啟用高效的序列化方法如kyro，增大off head記憶體等等
17.簡要描述Spark分散式叢集搭建的步驟
1）準備linux環境，設定叢集搭建賬號和使用者組，設定ssh，關閉防火牆，關閉seLinux，配置host，hostname
2）配置jdk到環境變數
3）搭建hadoop叢集，如果要做master ha，需要搭建zookeeper叢集
   修改hdfs-site.xml,hadoop_env.sh,yarn-site.xml,slaves等配置檔案
4）啟動hadoop叢集，啟動前要格式化namenode
5）配置spark叢集，修改spark-env.xml，slaves等配置檔案，拷貝hadoop相關配置到spark conf目錄下
6)啟動spark叢集。
18.什麼是RDD寬依賴和窄依賴？
RDD和它依賴的parent RDD(s)的關係有兩種不同的型別，即窄依賴（narrow dependency）和寬依賴（wide dependency）。
1）窄依賴指的是每一個parent RDD的Partition最多被子RDD的一個Partition使用
2）寬依賴指的是多個子RDD的Partition會依賴同一個parent RDD的Partition
19.spark-submit的時候如何引入外部jar包 
方法一：spark-submit –jars
根據spark官網，在提交任務的時候指定–jars，用逗號分開。這樣做的缺點是每次都要指定jar包，如果jar包少的話可以這麼做，但是如果多的話會很麻煩。
命令：spark-submit --master yarn-client --jars ***.jar,***.jar
方法二：extraClassPath
提交時在spark-default中設定引數，將所有需要的jar包考到一個檔案裡，然後在引數中指定該目錄就可以了，較上一個方便很多：
spark.executor.extraClassPath=/home/hadoop/wzq_workspace/lib/* spark.driver.extraClassPath=/home/hadoop/wzq_workspace/lib/*
需要注意的是,你要在所有可能執行spark任務的機器上保證該目錄存在，並且將jar包考到所有機器上。這樣做的好處是提交程式碼的時候不用再寫一長串jar了，缺點是要把所有的jar包都拷一遍。
20.cache和pesist的區別 
答：1）cache和persist都是用於將一個RDD進行快取的，這樣在之後使用的過程中就不需要重新計算了，可以大大節省程式執行時間；2） cache只有一個預設的快取級別MEMORY_ONLY ，cache呼叫了persist，而persist可以根據情況設定其它的快取級別；3）executor執行的時候，預設60%做cache，40%做task操作，persist最根本的函式，最底層的函式

二、選擇題
1. Spark 的四大元件下面哪個不是 (D )
A.Spark Streaming    B. Mlib 
C Graphx    D.Spark R

2.下面哪個埠不是 spark 自帶服務的埠 (C )
A.8080 B.4040 C.8090 D.18080
備註：8080：spark叢集web ui埠，4040：sparkjob監控埠，18080：jobhistory埠

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

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

【Spark面試2000題41-70】Spark core面試篇02
這批Spark面試題由志願者Taffry（某高校研究生）提供，非常感謝志願者的優質題集，大家如果有好的面試題可以私信給群主（可加入志願者群QQ群：233864572）。為確保題集質量，志願者貢獻出來的題集，群主及各位梅峰谷平臺組成員會稽核，個別地方會略加修改，還請志願者理解。
一、面試30題
1.cache後面能不能接其他運算元,它是不是action操作？
答：cache可以接其他運算元，但是接了運算元之後，起不到快取應有的效果，因為會重新觸發cache。
cache不是action操作
2.reduceByKey是不是action？
答：不是，很多人都會以為是action，reduce rdd是action
3.資料本地性是在哪個環節確定的？
具體的task執行在那他機器上，dag劃分stage的時候確定的
4.RDD的彈性表現在哪幾點？
1）自動的進行記憶體和磁碟的儲存切換；
2）基於Lingage的高效容錯；
3）task如果失敗會自動進行特定次數的重試；
4）stage如果失敗會自動進行特定次數的重試，而且只會計算失敗的分片；
5）checkpoint和persist，資料計算之後持久化快取
6）資料排程彈性，DAG TASK排程和資源無關
7）資料分片的高度彈性，a.分片很多碎片可以合併成大的，b.par
5.常規的容錯方式有哪幾種類型？
1）.資料檢查點,會發生拷貝，浪費資源
2）.記錄資料的更新，每次更新都會記錄下來，比較複雜且比較消耗效能
6.RDD通過Linage（記錄資料更新）的方式為何很高效？
1）lazy記錄了資料的來源，RDD是不可變的，且是lazy級別的，且rDD
之間構成了鏈條，lazy是彈性的基石。由於RDD不可變，所以每次操作就
產生新的rdd，不存在全域性修改的問題，控制難度下降，所有有計算鏈條
將複雜計算鏈條儲存下來，計算的時候從後往前回溯
900步是上一個stage的結束，要麼就checkpoint
2）記錄原資料，是每次修改都記錄，代價很大
如果修改一個集合，代價就很小，官方說rdd是
粗粒度的操作，是為了效率，為了簡化，每次都是
操作資料集合，寫或者修改操作，都是基於集合的
rdd的寫操作是粗粒度的，rdd的讀操作既可以是粗粒度的
也可以是細粒度，讀可以讀其中的一條條的記錄。
3）簡化複雜度，是高效率的一方面，寫的粗粒度限制了使用場景
如網路爬蟲，現實世界中，大多數寫是粗粒度的場景
7.RDD有哪些缺陷？
1）不支援細粒度的寫和更新操作（如網路爬蟲），spark寫資料是粗粒度的
所謂粗粒度，就是批量寫入資料，為了提高效率。但是讀資料是細粒度的也就是
說可以一條條的讀
2）不支援增量迭代計算，Flink支援
8.說一說Spark程式編寫的一般步驟？
答：初始化，資源，資料來源，並行化，rdd轉化，action運算元列印輸出結果或者也可以存至相應的資料儲存介質，具體的可看下圖：
file:///E:/%E5%AE%89%E8%A3%85%E8%BD%AF%E4%BB%B6/%E6%9C%89%E9%81%93%E7%AC%94%E8%AE%B0%E6%96%87%E4%BB%B6/qq19B99AF2399E52F466CC3CF7E3B24ED5/069fa7b471f54e038440faf63233acce/640.webp
9. Spark有哪兩種運算元？
答：Transformation（轉化）運算元和Action（執行）運算元。
10. Spark提交你的jar包時所用的命令是什麼？
答：spark-submit。
11. Spark有哪些聚合類的運算元,我們應該儘量避免什麼型別的運算元？
答：在我們的開發過程中，能避免則儘可能避免使用reduceByKey、join、distinct、repartition等會進行shuffle的運算元，儘量使用map類的非shuffle運算元。這樣的話，沒有shuffle操作或者僅有較少shuffle操作的Spark作業，可以大大減少效能開銷。
12. 你所理解的Spark的shuffle過程？
答：從下面三點去展開
1）shuffle過程的劃分
2）shuffle的中間結果如何儲存
3）shuffle的資料如何拉取過來
可以參考這篇博文：http://www.cnblogs.com/jxhd1/p/6528540.html
13. 你如何從Kafka中獲取資料？
1)基於Receiver的方式
這種方式使用Receiver來獲取資料。Receiver是使用Kafka的高層次Consumer API來實現的。receiver從Kafka中獲取的資料都是儲存在Spark Executor的記憶體中的，然後Spark Streaming啟動的job會去處理那些資料。
2)基於Direct的方式
這種新的不基於Receiver的直接方式，是在Spark 1.3中引入的，從而能夠確保更加健壯的機制。替代掉使用Receiver來接收資料後，這種方式會週期性地查詢Kafka，來獲得每個topic+partition的最新的offset，從而定義每個batch的offset的範圍。當處理資料的job啟動時，就會使用Kafka的簡單consumer api來獲取Kafka指定offset範圍的資料
14. 對於Spark中的資料傾斜問題你有什麼好的方案？
1）前提是定位資料傾斜，是OOM了，還是任務執行緩慢，看日誌，看WebUI
2)解決方法，有多個方面
· 避免不必要的shuffle，如使用廣播小表的方式，將reduce-side-join提升為map-side-join
·分拆發生資料傾斜的記錄，分成幾個部分進行，然後合併join後的結果
·改變並行度，可能並行度太少了，導致個別task資料壓力大
·兩階段聚合，先區域性聚合，再全域性聚合
·自定義paritioner，分散key的分佈，使其更加均勻
詳細解決方案參考博文《Spark資料傾斜優化方法》
15.RDD建立有哪幾種方式？
1).使用程式中的集合建立rdd
2).使用本地檔案系統建立rdd
3).使用hdfs建立rdd，
4).基於資料庫db建立rdd
5).基於Nosql建立rdd，如hbase
6).基於s3建立rdd，
7).基於資料流，如socket建立rdd
如果只回答了前面三種，是不夠的，只能說明你的水平還是入門級的，實踐過程中有很多種建立方式。
16.Spark並行度怎麼設定比較合適
答：spark並行度，每個core承載2~4個partition,如，32個core，那麼64~128之間的並行度，也就是
設定64~128個partion，並行讀和資料規模無關，只和記憶體使用量和cpu使用
時間有關
17.Spark中資料的位置是被誰管理的？
答：每個資料分片都對應具體物理位置，資料的位置是被blockManager，無論
資料是在磁碟，記憶體還是tacyan，都是由blockManager管理
18.Spark的資料本地性有哪幾種？
答：Spark中的資料本地性有三種：
a.PROCESS_LOCAL是指讀取快取在本地節點的資料
b.NODE_LOCAL是指讀取本地節點硬碟資料
c.ANY是指讀取非本地節點資料
通常讀取資料PROCESS_LOCAL>NODE_LOCAL>ANY，儘量使資料以PROCESS_LOCAL或NODE_LOCAL方式讀取。其中PROCESS_LOCAL還和cache有關，如果RDD經常用的話將該RDD cache到記憶體中，注意，由於cache是lazy的，所以必須通過一個action的觸發，才能真正的將該RDD cache到記憶體中。
19.rdd有幾種操作型別？
1）transformation，rdd由一種轉為另一種rdd
2）action，
3）cronroller，crontroller是控制運算元,cache,persist，對效能和效率的有很好的支援
三種類型，不要回答只有2中操作
19.rdd有幾種操作型別？
1）transformation，rdd由一種轉為另一種rdd
2）action，
3）cronroller，crontroller是控制運算元,cache,persist，對效能和效率的有很好的支援
三種類型，不要回答只有2中操作
20.Spark如何處理不能被序列化的物件？
將不能序列化的內容封裝成object
21.collect功能是什麼，其底層是怎麼實現的？
答：driver通過collect把叢集中各個節點的內容收集過來彙總成結果，collect返回結果是Array型別的，collect把各個節點上的資料抓過來，抓過來資料是Array型，collect對Array抓過來的結果進行合併，合併後Array中只有一個元素，是tuple型別（KV型別的）的。
22.Spaek程式執行，有時候預設為什麼會產生很多task，怎麼修改預設task執行個數？
答：1）因為輸入資料有很多task，尤其是有很多小檔案的時候，有多少個輸入
block就會有多少個task啟動；2）spark中有partition的概念，每個partition都會對應一個task，task越多，在處理大規模資料的時候，就會越有效率。不過task並不是越多越好，如果平時測試，或者資料量沒有那麼大，則沒有必要task數量太多。3）引數可以通過spark_home/conf/spark-default.conf配置檔案設定:
spark.sql.shuffle.partitions 50 spark.default.parallelism 10
第一個是針對spark sql的task數量
第二個是非spark sql程式設定生效
23.為什麼Spark Application在沒有獲得足夠的資源，job就開始執行了，可能會導致什麼什麼問題發生?
答：會導致執行該job時候叢集資源不足，導致執行job結束也沒有分配足夠的資源，分配了部分Executor，該job就開始執行task，應該是task的排程執行緒和Executor資源申請是非同步的；如果想等待申請完所有的資源再執行job的：需要將spark.scheduler.maxRegisteredResourcesWaitingTime設定的很大；spark.scheduler.minRegisteredResourcesRatio 設定為1，但是應該結合實際考慮
否則很容易出現長時間分配不到資源，job一直不能執行的情況。
24.map與flatMap的區別
map：對RDD每個元素轉換，檔案中的每一行資料返回一個數組物件
flatMap：對RDD每個元素轉換，然後再扁平化
將所有的物件合併為一個物件，檔案中的所有行資料僅返回一個數組
物件，會拋棄值為null的值
25.列舉你常用的action？
collect，reduce,take,count,saveAsTextFile等
26.Spark為什麼要持久化，一般什麼場景下要進行persist操作？
為什麼要進行持久化？
spark所有複雜一點的演算法都會有persist身影,spark預設資料放在記憶體，spark很多內容都是放在記憶體的，非常適合高速迭代，1000個步驟
只有第一個輸入資料，中間不產生臨時資料，但分散式系統風險很高，所以容易出錯，就要容錯，rdd出錯或者分片可以根據血統算出來，如果沒有對父rdd進行persist 或者cache的化，就需要重頭做。
以下場景會使用persist
1）某個步驟計算非常耗時，需要進行persist持久化
2）計算鏈條非常長，重新恢復要算很多步驟，很好使，persist
3）checkpoint所在的rdd要持久化persist，
lazy級別，框架發現有checnkpoint，checkpoint時單獨觸發一個job，需要重算一遍，checkpoint前
要持久化，寫個rdd.cache或者rdd.persist，將結果儲存起來，再寫checkpoint操作，這樣執行起來會非常快，不需要重新計算rdd鏈條了。checkpoint之前一定會進行persist。
4）shuffle之後為什麼要persist，shuffle要進性網路傳輸，風險很大，資料丟失重來，恢復代價很大
5）shuffle之前進行persist，框架預設將資料持久化到磁碟，這個是框架自動做的。
27.為什麼要進行序列化
序列化可以減少資料的體積，減少儲存空間，高效儲存和傳輸資料，不好的是使用的時候要反序列化，非常消耗CPU
28.介紹一下join操作優化經驗？
答：join其實常見的就分為兩類： map-side join 和  reduce-side join。當大表和小表join時，用map-side join能顯著提高效率。將多份資料進行關聯是資料處理過程中非常普遍的用法，不過在分散式計算系統中，這個問題往往會變的非常麻煩，因為框架提供的 join 操作一般會將所有資料根據 key 傳送到所有的 reduce 分割槽中去，也就是 shuffle 的過程。造成大量的網路以及磁碟IO消耗，執行效率極其低下，這個過程一般被稱為 reduce-side-join。如果其中有張表較小的話，我們則可以自己實現在 map 端實現資料關聯，跳過大量資料進行 shuffle 的過程，執行時間得到大量縮短，根據不同資料可能會有幾倍到數十倍的效能提升。
備註：這個題目面試中非常非常大概率見到，務必搜尋相關資料掌握，這裡拋磚引玉。
29.介紹一下cogroup rdd實現原理，你在什麼場景下用過這個rdd？
答：cogroup的函式實現:這個實現根據兩個要進行合併的兩個RDD操作,生成一個CoGroupedRDD的例項,這個RDD的返回結果是把相同的key中兩個RDD分別進行合併操作,最後返回的RDD的value是一個Pair的例項,這個例項包含兩個Iterable的值,第一個值表示的是RDD1中相同KEY的值,第二個值表示的是RDD2中相同key的值.由於做cogroup的操作,需要通過partitioner進行重新分割槽的操作,因此,執行這個流程時,需要執行一次shuffle的操作(如果要進行合併的兩個RDD的都已經是shuffle後的rdd,同時他們對應的partitioner相同時,就不需要執行shuffle,)，
場景：表關聯查詢
30 下面這段程式碼輸出結果是什麼？
--------------------------
def joinRdd(sc:SparkContext) {
val name= Array(
Tuple2(1,"spark"),
Tuple2(2,"tachyon"),
Tuple2(3,"hadoop")
)
val score= Array(
Tuple2(1,100),
Tuple2(2,90),
Tuple2(3,80)
)
val namerdd=sc.parallelize(name);
val scorerdd=sc.parallelize(score);
val result = namerdd.join(scorerdd);
result .collect.foreach(println);
}
--------------------------
答案:
(1,(Spark,100))
(2,(tachyon,90))
(3,(hadoop,80))

本主題由 admin 於 2018-4-3 16:53 稽核通過
分享到:  
QQ好友和群QQ好友和群
 
QQ空間QQ空間
 
騰訊微博騰訊微博
 
騰訊朋友騰訊朋友
 
微信微信
 收藏收藏1
 
轉播轉播
 
分享分享
 
分享淘帖 
贊贊 
踩踩

 
回覆 使用道具 舉報
wangxiaojian

1
主題    
5
聽眾    
1
收聽
中級會員
Rank: 3Rank: 3
積分223
收聽TA 發訊息    
沙發
  樓主| 發表於 2018-4-3 10:18:31 | 只看該作者
about雲課程：大資料日誌實時分析
---------------------------------------------------------------------------------------------------------------------
【Spark面試2000題71-100】Spark core面試篇03
Spark Core是Spark的基石，有很多知識點，面試題集的知識點比較跳躍和分散，建議系統學習了Spark知識再看面試題集。今天繼續放送最新整理和設計的《Spark面試2000題》題集，僅供參考學習。本篇博文屬於梅峰谷原創，轉載請註明出處，如果您覺得對您有幫助，請不要吝嗇點贊，你的贊，是志願者們堅持的動力，是早日做出2000道高質量Spark面試題的動力，如有不準確的地方，請留言說明。

一、面試30題(第71-100題)
1.Spark使用parquet檔案儲存格式能帶來哪些好處？
1) 如果說HDFS 是大資料時代分散式檔案系統首選標準，那麼parquet則是整個大資料時代檔案儲存格式實時首選標準
2) 速度更快：從使用spark sql操作普通檔案CSV和parquet檔案速度對比上看，絕大多數情況
會比使用csv等普通檔案速度提升10倍左右，在一些普通檔案系統無法在spark上成功執行的情況
下，使用parquet很多時候可以成功執行
3) parquet的壓縮技術非常穩定出色，在spark sql中對壓縮技術的處理可能無法正常的完成工作
（例如會導致lost task，lost executor）但是此時如果使用parquet就可以正常的完成
4) 極大的減少磁碟I/o,通常情況下能夠減少75%的儲存空間，由此可以極大的減少spark sql處理
資料的時候的資料輸入內容，尤其是在spark1.6x中有個下推過濾器在一些情況下可以極大的
減少磁碟的IO和記憶體的佔用，（下推過濾器）
5) spark 1.6x parquet方式極大的提升了掃描的吞吐量，極大提高了資料的查詢速度spark1.6和spark1.5x相比而言，提升了大約1倍的速度，在spark1.6X中，操作parquet時候cpu也進行了極大的優化，有效的降低了cpu
6) 採用parquet可以極大的優化spark的排程和執行。我們測試spark如果用parquet可以有效的減少stage的執行消耗，同時可以優化執行路徑
2.Executor之間如何共享資料？
答：基於hdfs或者基於tachyon
3.Spark累加器有哪些特點？
1）累加器在全域性唯一的，只增不減，記錄全域性叢集的唯一狀態
2）在exe中修改它，在driver讀取
3）executor級別共享的，廣播變數是task級別的共享
兩個application不可以共享累加器，但是同一個app不同的job可以共享
4.如何在一個不確定的資料規模的範圍內進行排序？
為了提高效率，要劃分劃分，劃分的範圍並且是有序的
要麼有序，要麼降序？
水塘抽樣：目的是從一個集合中選取，集合非常答，適合記憶體
無法容納資料的時候使用
從N中抽取出K個，N是隨機數
5.spark hashParitioner的弊端是什麼？
答:HashPartitioner分割槽的原理很簡單，對於給定的key，計算其hashCode，併除於分割槽的個數取餘，如果餘數小於0，則用餘數+分割槽的個數，最後返回的值就是這個key所屬的分割槽ID；弊端是資料不均勻，容易導致資料傾斜，極端情況下某幾個分割槽會擁有rdd的所有資料
6.RangePartitioner分割槽的原理?
答:RangePartitioner分割槽則儘量保證每個分割槽中資料量的均勻，而且分割槽與分割槽之間是有序的，也就是說一個分割槽中的元素肯定都是比另一個分割槽內的元素小或者大；但是分割槽內的元素是不能保證順序的。簡單的說就是將一定範圍內的數對映到某一個分割槽內。其原理是水塘抽樣。可以參考這篇博文
https://www.iteblog.com/archives/1522.html
7.介紹parition和block有什麼關聯關係？
答：1）hdfs中的block是分散式儲存的最小單元，等分，可設定冗餘，這樣設計有一部分磁碟空間的浪費，但是整齊的block大小，便於快速找到、讀取對應的內容；2）Spark中的partion是彈性分散式資料集RDD的最小單元，RDD是由分佈在各個節點上的partion組成的。partion是指的spark在計算過程中，生成的資料在計算空間內最小單元，同一份資料（RDD）的partion大小不一，數量不定，是根據application裡的運算元和最初讀入的資料分塊數量決定；3）block位於儲存空間、partion位於計算空間，block的大小是固定的、partion大小是不固定的，是從2個不同的角度去看資料。
8.Spark應用程式的執行過程是什麼？
1)構建Spark Application的執行環境（啟動SparkContext），SparkContext向資源管理器（可以是Standalone、Mesos或YARN）註冊並申請執行Executor資源；
2).資源管理器分配Executor資源並啟動StandaloneExecutorBackend，Executor執行情況將隨著心跳傳送到資源管理器上；
3).SparkContext構建成DAG圖，將DAG圖分解成Stage，並把Taskset傳送給Task Scheduler。Executor向SparkContext申請Task，Task Scheduler將Task發放給Executor運行同時SparkContext將應用程式程式碼發放給Executor。
4).Task在Executor上執行，執行完畢釋放所有資源。
9.hbase預分割槽個數和spark過程中的reduce個數相同麼
答：和spark的map個數相同，reduce個數如果沒有設定和reduce前的map數相同。
10.如何理解Standalone模式下，Spark資源分配是粗粒度的？
答：spark預設情況下資源分配是粗粒度的，也就是說程式在提交時就分配好資源，後面執行的時候
使用分配好的資源，除非資源出現了故障才會重新分配。比如Spark shell啟動，已提交，一註冊，哪怕沒有任務，worker都會分配資源給executor。
11.Spark如何自定義partitioner分割槽器？
答：1）spark預設實現了HashPartitioner和RangePartitioner兩種分割槽策略，我們也可以自己擴充套件分割槽策略，自定義分割槽器的時候繼承org.apache.spark.Partitioner類，實現類中的三個方法
def numPartitions: Int：這個方法需要返回你想要建立分割槽的個數；
def getPartition(key: Any): Int：這個函式需要對輸入的key做計算，然後返回該key的分割槽ID，範圍一定是0到numPartitions-1；
equals()：這個是Java標準的判斷相等的函式，之所以要求使用者實現這個函式是因為Spark內部會比較兩個RDD的分割槽是否一樣。
2）使用，呼叫parttionBy方法中傳入自定義分割槽物件
參考：http://blog.csdn.net/high2011/article/details/68491115
12.spark中task有幾種型別？
答：2種類型：1）result task型別，最後一個task，2是shuffleMapTask型別，除了最後一個task都是
13.union操作是產生寬依賴還是窄依賴？
答：窄依賴
14.rangePartioner分割槽器特點？
答：rangePartioner儘量保證每個分割槽中資料量的均勻，而且分割槽與分割槽之間是有序的，一個分割槽中的元素肯定都是比另一個分割槽內的元素小或者大；但是分割槽內的元素是不能保證順序的。簡單的說就是將一定範圍內的數對映到某一個分割槽內。RangePartitioner作用：將一定範圍內的數對映到某一個分割槽內，在實現中，分界的演算法尤為重要。演算法對應的函式是rangeBounds
15.什麼是二次排序，你是如何用spark實現二次排序的？（網際網路公司常面）
答：就是考慮2個維度的排序，key相同的情況下如何排序，參考博文：http://blog.csdn.net/sundujing/article/details/51399606
16.如何使用Spark解決TopN問題？（網際網路公司常面）
答：常見的面試題,參考博文：http://www.cnblogs.com/yurunmiao/p/4898672.html
17.如何使用Spark解決分組排序問題？（網際網路公司常面）
組織資料形式：
aa 11
bb 11
cc 34
aa 22
bb 67
cc 29
aa 36
bb 33
cc 30
aa 42
bb 44
cc 49
需求：
1、對上述資料按key值進行分組
2、對分組後的值進行排序
3、擷取分組後值得top 3位以key-value形式返回結果
答案：如下
----------------------
val groupTopNRdd = sc.textFile("hdfs://db02:8020/user/hadoop/groupsorttop/groupsorttop.data")
groupTopNRdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey().map(
x => {
val xx = x._1
val yy = x._2
(xx,yy.toList.sorted.reverse.take(3))
}
).collect
---------------------
18.窄依賴父RDD的partition和子RDD的parition是不是都是一對一的關係？
答：不一定，除了一對一的窄依賴，還包含一對固定個數的窄依賴（就是對父RDD的依賴的Partition的數量不會隨著RDD數量規模的改變而改變），比如join操作的每個partiion僅僅和已知的partition進行join，這個join操作是窄依賴，依賴固定數量的父rdd，因為是確定的partition關係
19.Hadoop中，Mapreduce操作的mapper和reducer階段相當於spark中的哪幾個運算元？
答：相當於spark中的map運算元和reduceByKey運算元，當然還是有點區別的,MR會自動進行排序的，spark要看你用的是什麼partitioner
20.什麼是shuffle，以及為什麼需要shuffle？
shuffle中文翻譯為洗牌，需要shuffle的原因是：某種具有共同特徵的資料匯聚到一個計算節點上進行計算
21.不需要排序的hash shuffle是否一定比需要排序的sort shuffle速度快？
答：不一定！！當資料規模小，Hash shuffle快於Sorted Shuffle資料規模大的時候；當資料量大，sorted Shuffle會比Hash shuffle快很多，因為數量大的有很多小檔案，不均勻，甚至出現數據傾斜，消耗記憶體大，1.x之前spark使用hash，適合處理中小規模，1.x之後，增加了Sorted shuffle，Spark更能勝任大規模處理了。
22.Spark中的HashShufle的有哪些不足？
答：1）shuffle產生海量的小檔案在磁碟上，此時會產生大量耗時的、低效的IO操作；2）.容易導致記憶體不夠用，由於記憶體需要儲存海量的檔案操作控制代碼和臨時快取資訊，如果資料處理規模比較大的化，容易出現OOM；3）容易出現數據傾斜，導致OOM
23.conslidate是如何優化Hash shuffle時在map端產生的小檔案？
答：1）conslidate為了解決Hash Shuffle同時開啟過多檔案導致Writer handler記憶體使用過大以及產生過多檔案導致大量的隨機讀寫帶來的低效磁碟IO；2）conslidate根據CPU的個數來決定每個task shuffle map端產生多少個檔案，假設原來有10個task，100個reduce，每個CPU有10個CPU
那麼使用hash shuffle會產生10*100=1000個檔案，conslidate產生10*10=100個檔案
備註：conslidate部分減少了檔案和檔案控制代碼，並行讀很高的情況下（task很多時）還是會很多檔案
24.Sort-basesd shuffle產生多少個臨時檔案
答：2*Map階段所有的task數量，Mapper階段中並行的Partition的總數量，其實就是Mapper端task
25.Sort-based shuffle的缺陷?
1) 如果mapper中task的數量過大，依舊會產生很多小檔案，此時在shuffle傳遞資料的過程中reducer段，reduce會需要同時大量的記錄進行反序列化，導致大量的記憶體消耗和GC的巨大負擔，造成系統緩慢甚至崩潰
2）如果需要在分片內也進行排序，此時需要進行mapper段和reducer段的兩次排序
26.Spark shell啟動時會啟動derby?
答： spark shell啟動會啟動spark sql，spark sql預設使用derby儲存元資料，但是儘量不要用derby，它是單例項，不利於開發。會在本地生成一個檔案metastore_db,如果啟動報錯，就把那個檔案給刪了 ，derby資料庫是單例項，不能支援多個使用者同時操作，儘量避免使用
27.spark.default.parallelism這個引數有什麼意義，實際生產中如何設定？
答：1）引數用於設定每個stage的預設task數量。這個引數極為重要，如果不設定可能會直接影響你的Spark作業效能；2）很多人都不會設定這個引數，會使得叢集非常低效，你的cpu，記憶體再多，如果task始終為1，那也是浪費，spark官網建議task個數為CPU的核數*executor的個數的2~3倍。
28.spark.storage.memoryFraction引數的含義,實際生產中如何調優？
答：1）用於設定RDD持久化資料在Executor記憶體中能佔的比例，預設是0.6,，預設Executor 60%的記憶體，可以用來儲存持久化的RDD資料。根據你選擇的不同的持久化策略，如果記憶體不夠時，可能資料就不會持久化，或者資料會寫入磁碟。2）如果持久化操作比較多，可以提高spark.storage.memoryFraction引數，使得更多的持久化資料儲存在記憶體中，提高資料的讀取效能，如果shuffle的操作比較多，有很多的資料讀寫操作到JVM中，那麼應該調小一點，節約出更多的記憶體給JVM，避免過多的JVM gc發生。在web ui中觀察如果發現gc時間很長，可以設定spark.storage.memoryFraction更小一點。
29.spark.shuffle.memoryFraction引數的含義，以及優化經驗？
答：1）spark.shuffle.memoryFraction是shuffle調優中 重要引數，shuffle從上一個task拉去資料過來，要在Executor進行聚合操作，聚合操作時使用Executor記憶體的比例由該引數決定，預設是20%
如果聚合時資料超過了該大小，那麼就會spill到磁碟，極大降低效能；2）如果Spark作業中的RDD持久化操作較少，shuffle操作較多時，建議降低持久化操作的記憶體佔比，提高shuffle操作的記憶體佔比比例，避免shuffle過程中資料過多時記憶體不夠用，必須溢寫到磁碟上，降低了效能。此外，如果發現作業由於頻繁的gc導致執行緩慢，意味著task執行使用者程式碼的記憶體不夠用，那麼同樣建議調低這個引數的值
30.介紹一下你對Unified Memory Management記憶體管理模型的理解？
答：Spark中的記憶體使用分為兩部分：執行（execution）與儲存（storage）。執行記憶體主要用於shuffles、joins、sorts和aggregations，儲存記憶體則用於快取或者跨節點的內部資料傳輸。1.6之前，對於一個Executor,記憶體都有哪些部分構成：
1）ExecutionMemory。這片記憶體區域是為了解決 shuffles,joins, sorts and aggregations 過程中為了避免頻繁IO需要的buffer。 通過spark.shuffle.memoryFraction(預設 0.2) 配置。
2）StorageMemory。這片記憶體區域是為了解決 block cache(就是你顯示呼叫dd.cache, rdd.persist等方法), 還有就是broadcasts,以及task results的儲存。可以通過引數 spark.storage.memoryFraction(預設0.6)。設定
3）OtherMemory。給系統預留的，因為程式本身執行也是需要記憶體的。 (預設為0.2).
傳統記憶體管理的不足：
1).Shuffle佔用記憶體0.2*0.8，記憶體分配這麼少，可能會將資料spill到磁碟，頻繁的磁碟IO是很大的負擔，Storage記憶體佔用0.6，主要是為了迭代處理。傳統的Spark記憶體分配對操作人的要求非常高。（Shuffle分配記憶體：ShuffleMemoryManager, TaskMemoryManager,ExecutorMemoryManager）一個Task獲得全部的Execution的Memory，其他Task過來就沒有記憶體了，只能等待。
2).預設情況下，Task線上程中可能會佔滿整個記憶體，分片資料特別大的情況下就會出現這種情況，其他Task沒有記憶體了，剩下的cores就空閒了，這是巨大的浪費。這也是人為操作的不當造成的。
3).MEMORY_AND_DISK_SER的storage方式，獲得RDD的資料是一條條獲取，iterator的方式。如果記憶體不夠（spark.storage.unrollFraction），unroll的讀取資料過程，就是看記憶體是否足夠，如果足夠，就下一條。unroll的space是從Storage的記憶體空間中獲得的。unroll的方式失敗，就會直接放磁碟。
4). 預設情況下，Task在spill到磁碟之前，會將部分資料存放到記憶體上，如果獲取不到記憶體，就不會執行。永無止境的等待，消耗CPU和記憶體。
在此基礎上，Spark提出了UnifiedMemoryManager，不再分ExecutionMemory和Storage Memory,實際上還是分的，只不過是Execution Memory訪問Storage Memory，Storage Memory也可以訪問Execution Memory，如果記憶體不夠，就會去借。

---------------------------------------------------------------------------------------------------------------------
【Spark面試2000題101-130】Spark on Yarn面試篇04

本篇題集主要是Spark on Yarn相關的面試題，主要涉及Spark on Yarn、Yarn、Mapreduce相關面試題。

一、面試題30題
1.MRV1有哪些不足？
1)可擴充套件性（對於變化的應付能力）
a) JobTracker記憶體中儲存使用者作業的資訊
b) JobTracker使用的是粗粒度的鎖
2)可靠性和可用性
a) JobTracker失效會多事叢集中所有的執行作業，使用者需手動重新提交和恢復工作流
3)對不同程式設計模型的支援
HadoopV1以MapReduce為中心的設計雖然能支援廣泛的用例，但是並不適合所有大型計算,如storm，spark
2.描述Yarn執行一個任務的過程？
1）客戶端client向ResouceManager提交Application，ResouceManager接受Application
並根據叢集資源狀況選取一個node來啟動Application的任務排程器driver（ApplicationMaster）
2）ResouceManager找到那個node，命令其該node上的nodeManager來啟動一個新的
JVM程序執行程式的driver（ApplicationMaster）部分，driver（ApplicationMaster）啟動時會首先向ResourceManager註冊，說明由自己來負責當前程式的執行
3）driver（ApplicationMaster）開始下載相關jar包等各種資源，基於下載的jar等資訊決定向ResourceManager申請具體的資源內容。
4）ResouceManager接受到driver（ApplicationMaster）提出的申請後，會最大化的滿足
資源分配請求，併發送資源的元資料資訊給driver（ApplicationMaster）；
5）driver（ApplicationMaster）收到發過來的資源元資料資訊後會根據元資料資訊發指令給具體
機器上的NodeManager，讓其啟動具體的container。
6）NodeManager收到driver發來的指令，啟動container，container啟動後必須向driver（ApplicationMaster）註冊。
7）driver（ApplicationMaster）收到container的註冊，開始進行任務的排程和計算，直到
任務完成。
補充：如果ResourceManager第一次沒有能夠滿足driver（ApplicationMaster）的資源請求
，後續發現有空閒的資源，會主動向driver（ApplicationMaster）傳送可用資源的元資料資訊
以提供更多的資源用於當前程式的執行。

3.Yarn中的container是由誰負責銷燬的，在Hadoop Mapreduce中container可以複用麼？
答：ApplicationMaster負責銷燬，在Hadoop Mapreduce不可以複用，在spark on yarn程式container可以複用
4.提交任務時，如何指定Spark Application的執行模式？
1）cluster模式：./spark-submit --class xx.xx.xx --master yarn --deploy-mode cluster xx.jar
2) client模式:./spark-submit --class xx.xx.xx --master yarn --deploy-mode client xx.jar
5. 不啟動Spark叢集Master和work服務，可不可以執行Spark程式？
答：可以，只要資源管理器第三方管理就可以，如由yarn管理，spark叢集不啟動也可以使用spark；spark叢集啟動的是work和master，這個其實就是資源管理框架，yarn中的resourceManager相當於master，NodeManager相當於worker，做計算是Executor，和spark叢集的work和manager可以沒關係，歸根接底還是JVM的執行，只要所在的JVM上安裝了spark就可以。
6.Spark中的4040埠由什麼功能?
答：收集Spark作業執行的資訊
7.spark on yarn Cluster 模式下，ApplicationMaster和driver是在同一個程序麼？
答：是,driver 位於ApplicationMaster程序中。該程序負責申請資源，還負責監控程式、資源的動態情況。
8.如何使用命令檢視application執行的日誌資訊
答：yarn logs -applicationId <app ID>
9.Spark on Yarn 模式有哪些優點？
1)與其他計算框架共享叢集資源（eg.Spark框架與MapReduce框架同時執行，如果不用Yarn進行資源分配，MapReduce分到的記憶體資源會很少，效率低下）；資源按需分配，進而提高叢集資源利用等。
2)相較於Spark自帶的Standalone模式，Yarn的資源分配更加細緻
3)Application部署簡化，例如Spark，Storm等多種框架的應用由客戶端提交後，由Yarn負責資源的管理和排程，利用Container作為資源隔離的單位，以它為單位去使用記憶體,cpu等。
4)Yarn通過佇列的方式，管理同時執行在Yarn叢集中的多個服務，可根據不同型別的應用程式負載情況，調整對應的資源使用量，實現資源彈性管理。
10.談談你對container的理解？
1）Container作為資源分配和排程的基本單位，其中封裝了的資源如記憶體，CPU，磁碟，網路頻寬等。 目前yarn僅僅封裝記憶體和CPU
2)Container由ApplicationMaster向ResourceManager申請的，由ResouceManager中的資源排程器非同步分配給ApplicationMaster
3) Container的執行是由ApplicationMaster向資源所在的NodeManager發起的，Container執行時需提供內部執行的任務命令.
11.執行在yarn中Application有幾種型別的container？
1） 執行ApplicationMaster的Container：這是由ResourceManager（向內部的資源排程器）申請和啟動的，使用者提交應用程式時，可指定唯一的ApplicationMaster所需的資源；
2） 執行各類任務的Container：這是由ApplicationMaster向ResourceManager申請的，並由ApplicationMaster與NodeManager通訊以啟動之。
12.Spark on Yarn架構是怎麼樣的？（要會畫哦，這個圖）

Yarn提到的App Master可以理解為Spark中Standalone模式中的driver。Container中執行著Executor,在Executor中以多執行緒並行的方式執行Task。執行過程和第二題相似。
13.Executor啟動時，資源通過哪幾個引數指定？
1)num-executors是executor的數量
2)executor-memory 是每個executor使用的記憶體
3)executor-cores 是每個executor分配的CPU
14.為什麼會產生yarn，解決了什麼問題，有什麼優勢?
1)為什麼產生yarn，針對MRV1的各種缺陷提出來的資源管理框架
2)解決了什麼問題，有什麼優勢，參考這篇博文：http://www.aboutyun.com/forum.php?mod=viewthread&tid=6785
15.Mapreduce的執行過程?
階段1：input/map/partition/sort/spill
階段2：mapper端merge
階段3：reducer端merge/reduce/output
詳細過程參考這個http://www.cnblogs.com/hipercomer/p/4516581.html

16.一個task的map數量由誰來決定？
一般情況下，在輸入源是檔案的時候，一個task的map數量由splitSize來決定的，那麼splitSize是由以下幾個來決定的
goalSize = totalSize / mapred.map.tasks
inSize = max {mapred.min.split.size, minSplitSize}
splitSize = max (minSize, min(goalSize, dfs.block.size))
一個task的reduce數量，由partition決定。
17.reduce後輸出的資料量有多大？
並不是想知道確切的資料量有多大這個，而是想問你，MR的執行機制，開發完程式，有沒有認真評估程式執行效率
1）用於處理redcue任務的資源情況，如果是MRV1的話，分了多少資源給map，多少個reduce
   如果是MRV2的話，可以提一下，叢集有分了多少記憶體、CPU給yarn做計算 。
2）結合實際應用場景回答，輸入資料有多大，大約多少條記錄，做了哪些邏輯操作，輸出的時候有多少條記錄，執行了多久，reduce執行時候的資料有沒有傾斜等
3）再提一下，針對mapReduce做了哪幾點優化，速度提升了多久，列舉1,2個優化點就可以
18.你的專案提交到job的時候資料量有多大？
答：1）回答出資料是什麼格式，有沒有采用什麼壓縮，採用了壓縮的話，壓縮比大概是多少；2）檔案大概多大：大概起了多少個map，起了多少個reduce，map階段讀取了多少資料，reduce階段讀取了多少資料，程式大約執行了多久，3）叢集什麼規模，叢集有多少節點，多少記憶體，多少CPU核數等。把這些點回答進去，而不是給個數字了事。
19.你們提交的job任務大概有多少個？這些job執行完大概用多少時間？
還是考察你開發完程式有沒有認真觀察過程式的執行，有沒有評估程式執行的效率
20.你們業務資料量多大？有多少行資料？
這個也是看你們有沒有實際的經驗,對於沒有實戰的同學，請把回答的側重點放在MR的執行機制上面，
MR執行效率方面，以及如何優化MR程式（看別人的優化demo，然後在虛擬機器上拿demo做一下測試）。
22.如何殺死一個正在執行的job
殺死一個job
MRV1：Hadoop job kill jobid
YARN: yarn application -kill applicationId
23.列出你所知道的排程器，說明其工作原理
a) Fifo schedular 預設的排程器  先進先出
b) Capacity schedular  計算能力排程器  選擇佔用記憶體小  優先順序高的
c) Fair schedular 調肚臍  公平排程器  所有job 佔用相同資源
24.YarnClient模式下，執行Spark SQL報這個錯，Exception in thread "Thread-2" java.lang.OutOfMemoryError: PermGen space，但是在Yarn Cluster模式下正常執行，可能是什麼原因？
1）原因查詢過程中呼叫的是Hive的獲取元資料資訊、SQL解析，並且使用Cglib等進行序列化反序列化，中間可能產生較多的class檔案，導致JVM中的持久代使用較多
Cluster模式的持久代預設大小是64M，Client模式的持久代預設大小是32M，而Driver端進行SQL處理時，其持久代的使用可能會達到90M，導致OOM溢位，任務失敗。
yarn-cluster模式下出現，yarn-client模式執行時倒是正常的，原來在$SPARK_HOME/bin/spark-class檔案中已經設定了持久代大小：
JAVA_OPTS="-XX:MaxPermSize=256m $OUR_JAVA_OPTS"
2）解決方法:在Spark的conf目錄中的spark-defaults.conf裡，增加對Driver的JVM配置，因為Driver才負責SQL的解析和元資料獲取。配置如下：
spark.driver.extraJavaOptions -XX:PermSize=128M -XX:MaxPermSize=256M   
25.spark.driver.extraJavaOptions這個引數是什麼意思，你們生產環境配了多少？
傳遞給executors的JVM選項字串。例如GC設定或者其它日誌設定。注意，在這個選項中設定Spark屬性或者堆大小是不合法的。Spark屬性需要用SparkConf物件或者spark-submit指令碼用到的spark-defaults.conf檔案設定。堆記憶體可以通過spark.executor.memory設定
26.導致Executor產生FULL gc 的原因，可能導致什麼問題？
答：可能導致Executor僵死問題，海量資料的shuffle和資料傾斜等都可能導致full gc。以shuffle為例，伴隨著大量的Shuffle寫操作，JVM的新生代不斷GC，Eden Space寫滿了就往Survivor Space寫，同時超過一定大小的資料會直接寫到老生代，當新生代寫滿了之後，也會把老的資料搞到老生代，如果老生代空間不足了，就觸發FULL GC，還是空間不夠，那就OOM錯誤了，此時執行緒被Blocked，導致整個Executor處理資料的程序被卡住
27.Combiner 和partition的作用
combine分為map端和reduce端，作用是把同一個key的鍵值對合並在一起，可以自定義的。combine函式把一個map函式產生的<key,value>對（多個key,value）合併成一個新<key2,value2>.將新的<key2,value2>作為輸入到reduce函式中這個value2亦可稱之為values，因為有多個。這個合併的目的是為了減少網路傳輸。partition是分割map每個節點的結果，按照key分別對映給不同的reduce，也是可以自定義的。這裡其實可以理解歸類。我們對於錯綜複雜的資料歸類。比如在動物園裡有牛羊雞鴨鵝，他們都是混在一起的，但是到了晚上他們就各自牛回牛棚，羊回羊圈，雞回雞窩。partition的作用就是把這些資料歸類。只不過在寫程式的時候，mapreduce使用雜湊HashPartitioner幫我們歸類了。這個我們也可以自定義。shuffle就是map和reduce之間的過程，包含了兩端的combine和partition。Map的結果，會通過partition分發到Reducer上，Reducer做完Reduce操作後，通OutputFormat，進行輸出shuffle階段的主要函式是fetchOutputs(),這個函式的功能就是將map階段的輸出，copy到reduce 節點本地
28.Spark執行任務時出現java.lang.OutOfMemoryError: GC overhead limit exceeded和java.lang.OutOfMemoryError: java heap space原因和解決方法？
答：原因：載入了太多資源到記憶體，本地的效能也不好，gc時間消耗的較多
解決方法：
1）增加引數，-XX:-UseGCOverheadLimit，關閉這個特性，同時增加heap大小，-Xmx1024m
2）下面這個兩個引數調大點
export SPARK_EXECUTOR_MEMORY=6000M
export SPARK_DRIVER_MEMORY=7000M
可以參考這個：http://www.cnblogs.com/hucn/p/3572384.html
29.請列出在你以前工作中所使用過的開發map /reduce的語言
答：java，Scala，Python，shell
30.你認為/etc/hosts配置錯誤，會對叢集有什麼影響？
答：1）直接導致域名沒法解析，主節點與子節點，子節點與子節點沒法正常通訊，2）間接導致配置錯誤的相關節點刪的服務不正常，甚至沒法啟動，job執行失敗等等

--------------------------------------------------------------------------------------------------
回覆 支援 反對 使用道具 舉報
wangxiaojian

1
主題    
5
聽眾    
1
收聽
中級會員
Rank: 3Rank: 3
積分223
收聽TA 發訊息    
板凳
  樓主| 發表於 2018-4-3 10:20:22 | 只看該作者
---------------------------------------------------------------------------------------------------------------------
Spark Core面試篇05
原創 2017-06-12 梅峰谷 大資料梅峰谷
Spark RDD是Spark的程式設計基礎，掌握RDD