• sparkcore 优化


    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(数据库)  
  • 相关阅读:
    使用阿里的EasyExcel实现表格导出功能
    推荐一款实用的java工具包---Hutool
    MySQL(二)锁机制【表级锁、页面锁、行级锁】
    MySQL(一)存储引擎
    使用redis的increment()方法实现计数器功能
    Redis缓存浅析
    Dubbo服务介绍
    SpringMVC工作执行流程详解
    GC垃圾回收机制----GC回收算法(GC机制必会知识点)
    数据结构之常见的数据结构
  • 原文地址:https://www.cnblogs.com/wuxiaolong4/p/16628898.html
Copyright © 2020-2023  润新知