sparkcore 优化

数据倾斜处理

        1.etl处理  2.并行度  
        3.过滤倾斜key(需要null，聚合需求(随机分区预聚合，最终hash散列聚合) 
            拆分(单独拿出来处理，最终union起来)) 
        4.reduce join 转mapjoin  5.两阶段聚合  
        6.无前缀聚合(随机前缀:大表加随机前缀 小表*3)自定义Partation

Shuffle 介绍

        mapreduceShuffle当中：
            1.如果有reduce阶段就一定会进行shuffle
            2.如果有shuffle，那就一定会按照key排序
        spark优化：
            1.不用排序的shuffle   2.需要排序的shuffle 

        hashShuffleManager:生成为解决文件数=executor*hash
        优化的hashShuffleManager：
            Consolidate机制： 复用 ShuffleBlockFile 文件通过索引标记偏移量  1.NIO方式，通过Socket读取数据 2.Netty去获取数据
        SortShuffleManager：(map端聚合就排序，map端不聚合尽量不排序)
            map(聚合操作) array(join算子)      内存排序分批10000条写入磁盘   会产生多个数据文件
                最终将多个文件进行合并  一个数据文件  一个索引文件
        SortShuffleManager-bypass：
            上同  但是不会进行排序操作 会进行文件的合并 触发机制：spark.shuffle.sort.bypassMergeThreshold 不是聚合类算子

高性能算子

        尽可能用一个，缓存，避免重复(基于内存的文件系统tachyon)
        避免使用shuffle算子  (map join)
        map预聚合算子(reduceByKey/aggregateByKey替代groupByKey)  rdd

        mapPartitions替代普通map
        foreachPartitions替代foreach
        filter之后进行coalesce
        repartitionAndSortWithinPartitions替代repartition与sort
        conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer") //需要用户自定义序列化函数 默认不开启
        优化数据结构：尽量使用简单类型。使用fastutil  堆外内存(负责类型数据)

调优参数

        yarn Container内存分配：
            yarn.nodemanager.resource.memory-mb=64G    //nodemanager分配给Container的资源内存大小
            yarn.nodemanager.resource.cpu-vcores=16    //nodemanager分配给Container的资源cpu核数
            yarn.scheduler.maximum-allocation-mb=64G   //yarn Container能够使用的最大资源
            yarn.scheduler.minimum-allocation-mb=512M  //yarn Container能够使用的最小资源

        spark 静态资源内存分配：
            spark.shuffle.memoryFraction    分配给shuffle read task进行聚合操作的内存比例，默认是20%
            spark.executor.memory(Exexution&Storage 计算存储)   spark.executor.memoryOverhead(JVM的额外开销)
            spark.executor.memory(10) : spark.executor.memoryOverhead(1)

        spark 动态资源内存分配：
            spark.dynamicAllocation.enabled=true   //动态分配资源
            spark.shuffle.service.enabled=true     //Executors完成以后资源就关闭了 需要这个服务保存文件
            spark.dynamicAllocation.initialExecutors=true     //初始化Executors 数量
            spark.dynamicAllocation.minExecutors=true     //最小 Executors 数量
            spark.dynamicAllocation.maxExecutors=true     //最大 Executors 数量
            spark.dynamicAllocation.executorIdleTimeout=60s //Task执行完成等待这个时间就关掉
            spark.dynamicAllocation.schedulerBacklogTimeout  1s task等待时长

        数据拉取 缓冲区：
            spark.shuffle.file.buffer 32K  shuffle write 缓冲区大小
            spark.reducer.maxSizeInFlight  shuffle read 拉取数据大小
            spark.shuffle.io.maxRetries     拉取最大次数
            spark.shuffle.io.retryWait      拉取间隔时间
            spark.shuffle.memoryFraction    分配给shuffle read task进行聚合操作的内存比例
            //read task 的数量小于等于spark.shuffle.sort.bypassMergeThreshold参数 不需要map预聚合  自动开启bypass
            spark.shuffle.sort.bypassMergeThreshold   如果shuffle read task 小于200 则不会进行排序
            spark.shuffle.consolidateFiles            开启优化后的hashShuffleManager
            PROCESS_LOCAL(数据本地)、NODE_LOCAL(节点)、RACK_LOCAL(机架)、ANY
            spark.locality.wait(6,10)
            spark.locality.wait.peocess(60)
            spark.locality.wait.node(30)
            spark.locality.wait.rack(20)
        序列化：conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
        内存：
            1.使用原始类型和对象数组，而不是集合类
            2.尽可能避免大量小对象和指针的嵌套
            3.考虑使用数字ID或枚举对象，而不是字符串作为键
            4.内存小于32G，-XX:+UseCompressedOops是指针为4个字节，而不是八个
        GC相关优化：（添加GC日志：-verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps）
            1.如果多次调用full jc 说明没有足够的内存
            2.如果次要jc太多，主要jc不多说明为：需要为Eden分配更多内存会有所帮助
            3.(4/3)预测的Eden内存大小
            4.打印的gc信息中，如果OldGen 快满了，请降低spark.memory.fraction
            5.老年代默认占堆的2/3。他应该超过 spark.memory.fraction
            6.预估Eden 的大小为3*(128M)块大小
            7.程序执行GC的标志可以通过：spark.executor.defaultJavaOptions
                或spark.executor.extraJavaOptions在作业的配置中指定

        广播大变量(containner内存大小)
        执行计划:
            explain 物理执行计划 | explain(mode=extended) 逻辑和物理执行计划 | 
            explain (mode=codegen) 可执行java代码  |   explain (mode=formatted) 格式化物理执行计划

        内存计算:
            spark.mamory.fraction = storage+Execution/(storage+Execution+Other)
            spark.mamory.storageFraction = storage/storage+Execution
            storage堆内内存=(spark.executor.memory-300M)*spark.mamory.fraction*spark.mamory.storageFraction
            Execution内存 = spark.executor.memory-300M - storage堆内内存

        并行度
            分区个数：
                spark.default.parallelism=200  rdd使用的
                spark.sql.shuffle.partitions=200 sparksql使用
            文件读取并行度：
                RDD：spark.hadoop.mapreduce.input.fileinputformat.list-status.num-threads
                sparksql：spark.sql.sources.parallelPartitionDiscovery.threshold
                          spark.sql.sources.parallelPartitionDiscovery.parallelism
        CBO 执行成本：数据本身的特点，操作的特点
            ANALYZE TABLE data COMPUTE STATISTICS /desc table data;//表信息统计 
            ANALYZE TABLE data COMPUTE STATISTICS FOR COLUMNS a,b,c / desc table data a;//列信息统计
            spark.sql.statistics.rawDataSize 解压到内存可能需要的空间  spark.sql.statistics.totalSize HDFS文件大小
            spark.sql.statistics.numRows 行数       //按照某一列进行存储
            spark.sql.cbo.enabled=true 
            spark.sql.cbo.joinReorder.enabled=true     //自动调整 inner join顺序
            spark.sql.cbo.joinReorder.dp.threshold=12   //多少表才进行调整，超过不调整

        桶表相关：
            sore merge bucket：两表分桶，桶的个数相同。join列=排序列=分桶列

        输出文件合并：
            spark.sql.files.maxParttionBytes=128M    //
            spark.files.openCostinByte=4M 文件开销不能太大

Spark 3.X 新特性

        AQE：基于动态的统计信息，动态修改执行计划。
            1.Shuffle分区数量  2.join策略  3.动态优化倾斜join
            spark.sql.adaptive.enabled=true AQE是否开启
            spark.sql.adaptive.coalescePartitions.enabled=true 动态分区是否开启
            spark.sql.adaptive.coalescePartitions.initialPartitionNum=100 初始化并行度
            spark.sql.adaptive.coalescePartitions.minPartitionNum=10    //最小分区数
            spark.sql.adaptive.advisoryPartitionSizeInBytes=256M 合并后分区大小

            spark.sql.autoBroadcastJoinThreshold=10M broadcast的数据大小
            spark.sql.adaptive.skewJoin.enabled=true 是否开启数据倾斜

            spark.sql.adaptive.skewJoin.skewedPartitionFactor=5 数据倾斜判断因子
            spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes=256M 数据倾斜判断大小 (>中位数大小 * 因子 & >当前值)

        动态分区裁剪：先扫描小表，在进行大表的分区裁剪
            spark.sql.optimizer.dynamicPartitionPruning.enabled=true 动态分区裁剪
        加速器感知调度(GPU 加速)  PostgreSQL(数据库)