sparkcore 核心概念

Spark-core概念补充

Spark相对于hadoop的优势

        1.减少IO(如非必要不落盘)
        2.并行度(多线程)
        3.中间结果持久化(多次使用)
        4.shuffle方案(不排序) 
        5.内存管理(静态内存，动态内存，内存可配置)

概念

        Master节点，协调资源，连接worker节点运行Exxcutor。是协调节点
        Worker节点，是spark集群中的计算节点，用于和Master交互并管理Executor  
            job提交后创建SparkContext worker启动对应的Executor
        ExecutorBackend :worker通过ExecutorBackend 进行控制，、是一个进程，只有一个Executor对象
        一个Worker上存在一个或者多个 ExecutorBackend 进程
        Executor：和Driver保持交互认领自己的任务

        闭包：函数携带了一个外包的作用域，这个函数就是闭包。
            闭包就是函数  闭包就是对象

逻辑执行图

        HadoopRDD的partations对应了HDFS的Blocks，通过InoutFormat来确定Hadoop中Block的位置和边界
        HadoopRDD存放的是一个元组 (行号，Text对象)  通过map算子转为String一行行的数据

        map算子：
            就是生成一个MapPartationsRDD compute函数处理
            每个计算的含义就是将一个分区上的所有数据当做一个集合，通过map函数计算
            传入的函数会被处理闭包中的依赖，使得这闭包可以被序列化发往别的节点
        RDD三个属性：分区列表，依赖关系(getDependencies 函数)，计算函数，分区函数，最佳位置
        宽窄依赖判断：shuffle关系
            NarrowDependency窄依赖  ShuffleDependency宽依赖 OneToOneDependency一对一依赖  RangeDependency区间依赖
            宽依赖：把分区拆开，发送给下游不同的分区。  一对一一定是窄依赖  多对一不一定是宽依赖(笛卡尔积)
            RDD之间的关系其实是：文件分区之间的关系 
        窄依赖的类别：
            RangeDependency：只有union使用   多对一窄依赖：coalesce
        需要分析依赖关系的原因：看看RDD能否放在同一个流水线上执行(窄依赖可以放到一个task中运行)

物理执行图

        采用数据流动，分阶段运行，从后往前划分宽窄依赖
        数据计算发生在Action上，没有数据找父RDD要数据
        最终按照taskset调度的

checkpoint 使用

        val sparkconf = new SparkConf().setAppName("test_Spark_sql").setMaster("local[2]")
        val spark = SparkSession.builder().config(sparkconf).config("spark.driver.host", "localhost").getOrCreate().sparkContext
        spark.setCheckpointDir("/hdfs/")

        val data = spark.makeRDD(Array(("A", 88.0), ("B", 95.0), ("C", 91.0),("D", 93.0))).cache()  //建议先cache在checkpoint
        data.checkpoint()

内存管理

        堆内内存(executor-memory) 内存中被标记为释放的对象，JVM可能并没有被回收，会倒置OOM
        堆外空间(spark.memory.offHeap.size) 
        内存管理：
            Unified Memory(统一内存)60%
                Storage 缓存RDD和broadcast数据(spark.storage.storageFraction)50% 
                    内存被占用后，无法归还，因为Shuffle过程很多因素
                Execution(shuffle中间数据spark.storage.storageFraction)50% 
                    内存被占用后，可以归还，让对方先把数据转到硬盘
            其他内存(用户定义的数据结构 spark内部元数据)40%
            Reserved Memory 300M
        Executor中：Block是spark中数据存储的基本单元(一个文件 partation)
        Block序列化和非序列化两种存储：序列化用数组、非序列化用字节缓冲区
        有一个Map 结构（LinkedHashMap）来管理堆内和堆外存储内存中所有的 Block
        对这个LinkedHashMap操作记录了内存的申请和释放
        淘汰规则：MemoryMode相同（堆外或堆内内存） RDD不能被读   最近最少使用（LRU）的顺序

Shuffle 的内存占用

        Shuffle 是按照一定规则对 RDD 数据重新分区的过程
        Shuffle Write
            map端选择普通排序ExternalSorter排(堆内)  
            map端选择 Tungsten 排序ShuffleExternalSorter排(堆外或堆内)
        Shuffle Read
            reduce 端的数据进行聚合时，要将数据交给 Aggregator 处理，占用堆内执行空间
            最终结果排序，则要将再次将数据交给 ExternalSorter 处理，占用堆内执行空间

        ExternalSorter 和 Aggregator 中，Spark 会使用一种叫 AppendOnlyMap 的哈希表在堆内执行内存中存储数据
        哈希表占用的内存会进行周期性地采样估算，当其大到一定程度，无法再从 MemoryManager 申请到新的执行内存时
        Spark 就会将其全部内容存储到磁盘文件中，这个过程被称为溢存(Spill)