Flink1.12-之JobManager&TaskManager内存管理

最新推荐文章于 2024-05-13 11:06:32 发布
最新推荐文章于 2024-05-13 11:06:32 发布
阅读量5.8k 收藏 30
点赞数 11
分类专栏： Flink 文章标签： flink flink内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shufangreal/article/details/118252026
版权

Flink1.12-之内存管理

1、前言

flink为了让用户更好的调整内存分配，达到资源的合理分配，在Fllink1.10引入了TaskManager的内存管理，后续在Flink1.11版本引入了JobManager的内存管理，用户可以通过配置的方式合理的分配资源。

不管是TaskManager还是JobManager都是单独的JVM进程，他们共用一套内存模型抽象（TaskManager的内存模型更加复杂），如下。
在这里插入图片描述

该模型由heap和off-heap内存组成，这里有以下3种调整内存的方式，3种方式必须选一种，不然会启动失败，最好不要同时指定2种方式，否则有可能会产生配置冲突。

for TaskManager:for JobManager:
taskmanager.memory.flink.sizejobmanager.memory.flink.size
taskmanager.memory.process.sizejobmanager.memory.process.size
taskmanager.memory.task.heap.size and taskmanager.memory.managed.sizejobmanager.memory.heap.size

  • 直接调整jobmanager.memory.process.size或者taskmanager.memory.process.size的方式

    • 该方式是最简单的方式，该配置下的所有的组件的内存分配都会有默认值，或者通过推导得到，通常在yarn或者k8s、mesos的时候这样指定，container部署通过该参数的配置来申请容器的大小。

  • 直接调整jobmanager.memory.flink.size或者taskmanager.memory.flink.size的方式

    • 这种方式通常在standalone的时候使用的比较多，其它组件的

  • 第三种是直接配置heap和off-heap组件的大小，达到更细粒度的控制,或者配合前2种方式中的其中之一使用也是可以的。

以上三种方式任选一种～！！

2、JobManager内存分配

JobManager的内存模型如下.

在这里插入图片描述

以上total process size的模型图可以分为以下的4个内存组件,如果在分配内存的时候，显示的指定了组件其中的1个或者多个，那么JVM overhead的值就是在其它组件确定的情况下，用total process size - 其它 获取的值，必须在min～max之间,如果没有指定组件的值，那么就按照0.1的fraction进行计算得到，如果计算出的值小于min取min，如果大于max取max，如果min、max指定的相等，那么这个JVM overhead就是一个确定的值！

内存组件配置选项内存组件的功能
JVM Heapjobmanager.memory.heap.size这个大小取决于提交的作业个数和作业的结构以及用户代码的要求。=>>>> 主要用来运行flink框架，执行作业提交时的用户代码以及checkpoint的回调代码
Off-heap Memoryjobmanager.memory.off-heap.size（默认128M）JM的对外内存的大小. 涵盖了所有direct和native的内存分配。=>>>>用来执行akka等外部依赖，同时也负责运行checkpoint回调及作业提交时的用户代码
JVM metaspacejobmanager.memory.jvm-metaspace.size（默认256M）JM的元空间大小，有默认值jobmanager.memory.jvm-metaspace.size = 256M， 属于native memory
JVM Overheadjobmanager.memory.jvm-overhead.min （192M）jobmanager.memory.jvm-overhead.max （1G）jobmanager.memory.jvm-overhead.fraction（0.1）为thread stacks, code cache, garbage collection space预留的native memory，有默认的faction of total process size，但是必须在其min & max之间

2.1、分配 total process size

  • jobmanager.memory.process.size

在这里插入图片描述
在这里插入图片描述

# 此时我们只显示指定了 jobmanager.memory.process.size 的值，没有指定其它组件，此时整个JobManager的JVM进程能占用的内存为2000M
0、total process size = 2000M(这是分配的基准值)
1、JVM overhead 因为没有指定其它组件内存，所以被按照0.1的fraction推断成 => 2000M * 0.1 * 1024 * 1024 = 209715203B（200M）
2、JVM Metaspace 默认值为 256M
3、Off-Heap Memeory 默认为 128M
4、JVM Heap最终被推断为 2000M - 200M - 256M - 128M = 1.38G（？？？？？？？？？？？？？）

√ 为啥JVM Heap只有1.33GB而不是1.38GB呢？

在这里插入图片描述

其实这个取决于你使用的GC算法会占用其中很小一部分固定内存作为Non-heap，该占用部分大小为：1.38-1.33 = 0.05GB。

2.2、分配 total flink size

  • jobmanager.memory.flink.size

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

# 此时我们只显示指定了 jobmanager.memory.flink.size 的值，也没有指定其它组件如heap size，此时整个JobManager的JVM进程除了JVM Overhead及JVM Metaspace之外能占用的内存为2000M
0、total flink size = 2000M = 1.95G（这属于total process size的组件之一，overhead只能最后按剩余的内存来被推断）
1、JVM Metaspace 默认值为 256M（固定默认值）
2、Off-Heap Memeory 默认值为 128M（固定默认值）
3、JVM heap = 2000M - 128M = 1.828GB - 80MB(GC算法占用) = 1.75GB
4、根据JVM overhead  = (JVM overhead + 256M(Metaspace) + 2000(flink size)) * 0.1  
=> total process size =  2.448GB
=> JVM overhead = 2.448GB * 0.1 =  262843055B =  250.667MB(在192M～1GB)，为有效
5、最终资源的分配如以上日志所示～～

2.3、单独分配 heap size

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 此时我们只显示指定了 jobmanager.memory.heap.size 的值，相当于显示配置了组件的值，此时整个JobManager的JVM Heap被指定为最大内存为1000M
0、Jvm heap被指定为 1000M，但是得从GC算法中扣除 41MB(GC算法占用) => JVM heap(实际) = 959MB
1、JVM Metaspace 默认值为 256M
2、Off-Heap Memeory 默认值为 128M
3、flink total size = 1128MB = 1.102GB
4、（1128MB + 256M + JVM overhead）* 0.1 = JVM overhead => JVM = 153.778 < 192MB(默认的min) => JVM overhead = 192MB
5、total process size = 1128MB + 256M + JVM overhead = 1576MB = 1.5390625GB = 1.539GB

2.4、分配process size和 heap size

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 由于指定了heap.size内存组件的的大小，那么JVM overhead就是取剩余的total process size的内存空间
0、total process size = 2000MB && JVM heap = 1000MB,实际只有959MB，因为减去了41MB的GC算法占用空间
1、JVM Metaspace 默认值为 256M
2、Off-Heap Memeory 默认值为 128M
3、total flink size = 1000MB + 128MB = 1128MB
4、JVM overhead = 2000MB - 1128MB - 256MB = 616MB

2.5、分配flink size和 heap size

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 由于指定了head.size组件的大小，那么overhead就按照剩余total process size的内存空间分配
0、total flink size = 2000MB && JVM heap = 1000MB，实际959MB，减去了GC算法的占用空间
1、JVM off-heap = 2000MB - 1000MB = 1000MB
2、JVM Metaspace = 256MB
3、首先根据JVM overhead  = (JVM overhead + 256M(Metaspace) + 2000(flink size)) * 0.1  
=> total process size =  2.448GB
=> JVM overhead = 2.448GB * 0.1 =  262843055B =  250.667MB(在192M～1GB)，为有效
4、最终确定 total process size = 2.448GB && JVM overhead = 250.667MB

3、TaskManager的内存分配

TaskManager是计算用户任务的节点，他比JobManager的模型更加复杂和精细，合理的分配内存可以使应用更加稳定，TaskManager的细粒度内存模型如下。

在这里插入图片描述

其中包含的组件如下表

组件配置选项描述
Framework Heap Memorytaskmanager.memory.framework.heap.size（默认128M）专用于运行Flink框架，通常不用修改该值,它可能与特定的部署环境或作业结构有关，例如高并行度.
Task Heap Memorytaskmanager.memory.task.heap.size专用于用户提交作业划分的Tasks
Managed memorytaskmanager.memory.managed.size taskmanager.memory.managed.fraction（默认0.4）这是一块被Flink管理的堆外内存，属于Native Memory, 用于批处理作业的排序，hash运算，缓存中间结果，以及RocksDB状态后端的元数据
Framework Off-heap Memorytaskmanager.memory.framework.off-heap.size（默认128M）专用于运行Flink框架，通常不用修改该值,它可能与特定的部署环境或作业结构有关，例如高并行度.
Task Off-heap Memorytaskmanager.memory.task.off-heap.size（默认0Byte）专用于用户提交作业划分的Tasks，不受GC的影响
Network Memorytaskmanager.memory.network.min （默认64MB）taskmanager.memory.network.max （默认1GB）taskmanager.memory.network.fraction（默认0.1）为Task之间的数据交换预留的内存，比如说网络缓冲区，默认是total flink size的0.1,通常不需要去调整这个值
JVM metaspacetaskmanager.memory.jvm-metaspace.size（默认256M）JM的元空间大小，有默认值256M， 属于native memory
JVM Overheadtaskmanager.memory.jvm-overhead.min （192MB）taskmanager.memory.jvm-overhead.max （1GB）taskmanager.memory.jvm-overhead.fraction（0.1）为thread stacks, code cache, garbage collection space预留的native memory，有默认的faction of total process size，但是必须在其min & max之间

3.1、单独分配total process size

# 单独分配total process size，其它的组件都会自动分配
taskmanager.memory.process.size: 2000m

在这里插入图片描述

在这里插入图片描述

# 内存分配步骤如下
# 1
1、首先 total process size = 2000M
# 2 native memory = 【456M】
2、因为没有显示分配组件中的任何参数，所以 JVM overhead = 200M
3、JVM MetaSpace = 默认256M
# 3
4、total flink size = 2000M - 200M - 256M = 1544MB = 1.508GB

# 4 total direct memory = 154.4M + 0 + 128M = 【282.4M】
5、network memory = 1544 * 0.1 = 154.4M
6、Task offheap = 默认0MB
7、FrameWork Off-heap = 默认128M

# 5 managed memeory = 【617.6M】
8、Managed Memory = 1544MB * 0.4 = 617.6M

# 6 total JVM heap memory = 1544M - 282.4M - 617.6M = 644MB
9、FrameWork Heap = 128M
10、Task Heap = 644M - 128M = 516M

# 7 与以上的日志进行对比，完全能对上，okay！！

3.2、单独分配total flink size

# 单独分配 total flink size 
taskmanager.memory.flink.size: 2000m

在这里插入图片描述

# 假如直接只分配 taskmanager.memory.flink.size: 2000m，没有设计以上表格中的组件

# 1 total flink size = 【2000M】
total flink size = 2000M

# 2 managed memory 
Managed Memory = 2000M * 0.4 = 800M
# 3 total direct memory = 200M + 128M = 328M
NetWork Memory = 2000M * 0.1 = 200M
FrameWork Off-Heap = 128M
Task Off-Heap = 0Byte = 0M
# 4 total off heap = 800M + 328M = 【1128M】

# 5 total JVM heap = 【872M】
total jvm heap = 2000M - 800M - 328M = 872M 
FrameWork heap = 128M 
Task Heap = 872M - 128M = 744M

# 6 native memory 
JVM MetaSpace = 默认 256M
JVM overhead = （JVM overhead + 256M(Metaspace)+ 2000M(total flink size)）* 0.1
	=> JVM overhead = 250.667M 在[192MB~1GB]，生效
	
# 7 total process size 
total process size = 2000M + 256 + 250.667 = 2506.667M = 2.448GB

3.3、单独分配 heap size && managed memory

# 单独分配组件JVM heap 和 mamaged memory
taskmanager.memory.task.heap.size: 1000m
taskmanager.memory.managed.size: 1000m

在这里插入图片描述

# total JVM heap = 【1128M】 = 【1.102 GB】
FrameWork heap = 128M（默认）
Task Heap = 1000M


# total off-heap = 【1378.667M】
# managed memory
Managed Memory = 1000M
# total direct memory = 378.667M
FrameWork off-heap = 128M
Task off-heap = 0M
NetWork = (NetWork + 1128M + 1000M + 128M + 0M ) * 0.1   =>  NetWork = 250.667MB 处于[64MB ～ 1GB]
=> total direct memory = 128M + 250.667M = 378.667M

# total flink size = 【2506.667M】
total flink size = 1128M + 1378.667M  = 2506.667M = 2.448GB

# native memory
JVM Metaspace = 256M
JVM overhead = （JVM overhead + 1128M + 1000M + 378.667M + 256M）* 0.1 = 306.963M 处于[192M ～ 1GB]，生效

# total process size = 【3069.63M】= 【2.998G】
total process size = 2506.667M + 256M + 306.963M = 3069.63M = 2.998G

3.4、分配 total process size 和 heap size && managed memory

# 指定total process size，同时显式分配组件JVM heap 和 mamaged memory
taskmanager.memory.process.size: 3000m
taskmanager.memory.task.heap.size: 1000m
taskmanager.memory.managed.size: 1000m

在这里插入图片描述

# 1 total process size = 【3000M】

# 2 total flink size = 【1128M + 1378.667M】=【2506.667M】=【2.448GB】

# 3 total JVM heap = 【1128M】= 【1.102M】
FrameWork heap = 128M
Task heap = 1000M 

# 4 total off-heap = 【1000M + 128M + 250.667M】= 【1378.667M】 = 【1.346GB】
# managed memory
managed memory = 1000M
# direct memory
FrameWork off-heap = 128M
Task off-heap = 0M
NetWork memory = (NetWork memory + 1128M + 1128M) * 0.1 = 250.667M 在[64M ～ 1GB]之间，满足要求

# native memory
JVM Metaspace = 256M
JVM overhead = 3000M - 2506.667M - 256M = 237.333M 在[192M ～ 1GB]之间，满足要求

3.5、分配 total flink size 和 heap size && managed memory

# 指定total flink size，同时显式分配组件JVM heap 和 mamaged memory
taskmanager.memory.flink.size: 3000m
taskmanager.memory.task.heap.size: 1000m
taskmanager.memory.managed.size: 1000m

在这里插入图片描述

# 1 已知
total flink size = 3000M = 2.93GB
managed memory = 1000M
Task heap = 1000M

# total JVM heap = 【1128M】
Task heap = 1000M
Frame heap = 128M

# total off-heap = 【3000M - 1128M】 = 【1872M】 = 【1.828GB】
# managed memory = 1000M
# direct memory = 1872M - 1000M = 872M
Task off-heap = 0M
Frame off-heap = 128M
network memory = 872M - 128M = 744M 

# native memory 
JVM Metaspace = 256M
JVM overhead = (JVM overhead + 3000M + 256M) * 0.1 = 361.778M 处于[min192M ～  max1G]之间 符合条件

# total process size = 【3617.778M】= 【3.533GB】
3000M + 256M + 361.778M. = 3617.778M = 3.533GB

4、内存分配汇总

在Flink的集群内存分配的过程中，我们大致可以通过3种方式进行分配

  • 指定 total process size ｜｜ total flink size 取决于你用什么方式部署

  • 单独指定某个组件比如Task-heap的大小，其它的组件都会被推导出来

  • 指定 total size && heap or off-heap其中之一，其它的组件通过默认值进行填充或者进推导

    • 如total flink size = total heap size + total off-heap size

    • total heap size = task heap + frame heap

    • total off-heap = task off-heap + frame off-heap + network memory

    • network = 0.1* total flink size（没有指定其它组件情况下）

    • JVM overhead = 0.1 * total process size (没有指定其它组件情况下)

    • …其它

稳哥的哥
关注
  • 11
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【FLink】Flink 1.12 TaskManager 内存结构
九师兄
08-17 225
1.概述 视频地址： 尚硅谷2021最新Flink内核源码解析课程（从入门到精通） 在配置文件中有提现 process 是进程的意思 内存体现在源码中是 TaskExecutorFlinkMemory 类 flink内存 /** * Memory components which constitute the Total Flink Memory. * * <p&g.
Flink1.12 flink-conf.yaml配置
GavinKai
11-24 6416
1.配置及注释 1.1定位 flink-conf.yaml是flink的配置文件，优先级在代码和提交参数之后是通用配置 1.2注意点 flink-conf.yaml中配置key/value时候在“:”后面需要有一个空格，否则配置不会生效。 1.3参数解析 #============================================================================== # 集群通用配置 #==============================
flink内存管理，设置思路，oom问题，一文全
Direction_Wind的博客
02-20 2816
这里以flink1.12 的 flink webUI 来展示内存管理，后续版本的内存可能会有变更不一致的地方，详细的解释主要放在taskManager中。
Flink 性能优化总结（内存配置篇）
pp1981002445的博客
03-11 1678
flink 性能优化 内存配置
一次Flink on yarn 任务JobManager内存超用问题排查
最新发布
weixin_41461158的博客
05-13 1308
有道实时平台的所有flink任务运行在yarn集群上，前段时间，为提升和改善有道flink任务运行稳定性，对实时yarn集群进行了迁移（将实时yarn nodemanger机器进行独立，并将所有实时任务迁移至新机器上）。迁移后，发现约200个任务频繁发生JobManager重试，几乎每30min出现一次重试，严重影响任务稳定性。yarn看到flink任务的application_id在不断attempt重试，几乎每30min重试一次。点击失败的一次“Attempt ID”，查看失败原因。
Flink1.12 - 概述、安装部署及快速入门
erainm
03-05 2887
1. Flink概述 1.1 Flink官方介绍 flink官网地址 1.2 Flink组件栈 一个计算框架要有长远的发展，必须打造一个完整的 Stack。只有上层有了具体的应用，并能很好的发挥计算框架本身的优势，那么这个计算框架才能吸引更多的资源，才会更快的进步。所以 Flink 也在努力构建自己的 Stack。 Flink分层的组件栈如下图所示：每一层所包含的组件都提供了特定的抽象，用来服务于上层组件。 各层详细介绍： 物理部署层：Flink 支持本地运行、能在独立集群或者在被 YARN 管理
Flink1.12 -- 高级API
erainm
03-05 823
1. Flink四大基石 Flink之所以能这么流行，离不开它最重要的四个基石：Checkpoint、State、Time、Window。 Checkpoint 这是Flink最重要的一个特性。  Flink基于Chandy-Lamport算法实现了一个分布式的一致性的快照，从而提供了一致性的语义。  Chandy-Lamport算法实际上在1985年的时候已经被提出来，但并没有被很广泛的应用，而Flink则把这个算法发扬光大了。  Spark最近在实现Continue streaming，Conti
【Flink专题】基于Flink1.12的知识点总结
zuo1057559550的博客
07-06 774
内容非常详细哦~
Flink 1.12 内存和提交参数
热门推荐
禅与计算机程序设计艺术
12-28 1万+
flink1.12 内存和提交参数 在使用yarn cluster模式提交flink的任务时候，往往会涉及到很多内存参数的配置 例如下面的提交命令： flink run -d -m yarn-cluster -yjm 512 -ytm 5028 -yD jobmanager.memory.off-heap.size=64m -yD jobmanager.memory.jvm-metaspa...
flink1.12 单机安装
胖虎儿的博客
03-07 6545
Local本地模式 运行流程： Flink程序由JobClient进行提交 JobClient将作业提交给JobManager JobManager负责协调资源分配和作业执行。资源分配完成后，任务将提交给相应的TaskManager TaskManager启动一个线程以开始执行。TaskManager会向JobManager报告状态更改,如开始执行，正在进行或已完成。 作业执行完成后，结果将发送回客户端(JobClient) 下载 https://mirrors.bfsu.edu.cn/apache/
flink-1.12-CDH-6.3.2.zip
03-19
标题“flink-1.12-CDH-6.3.2.zip”指的是一个包含Apache Flink 1.12版本与Cloudera Data Hub (CDH) 6.3.2集成的压缩文件。这个文件是为在CDH环境中运行Flink作业而准备的，确保了兼容性和优化。 描述“flink1.12...
flink-1.12-sql-demo:基于flink1.12，使用java，flink sql的demo，包含Mylsql，flinkcdc内置的Mysqlcdc
03-28
flink1.12.1 sql演示个人练习flink的演示。代码里自带数据生成，附带合适的数据演示。 pom.xml包含了flink绝大部分的依赖，maven下载会比较久。目前项目内容包含了环境Windows 10 ltsc 的Mysql8.0.23 Idea社区版2020...
flink 1.12及以上 兼容cdh6所需要的flink-shaded-hadoop jar包
02-11
flink 1.12及以上 兼容cdh6所需要的flink-shaded-hadoop jar包
apache-doris-flink-connector-1.12_2.12-1.0.3
05-05
Flink Doris Connector（apache-doris-flink-connector-1.12_2.12-1.0.3-incubating-src.tar.gz） Flink Doris Connector Version：1.0.3 Flink Version：1.12 Scala Version：2.12 Apache Doris是一个现代MPP...
flink-connector-clickhouse-1.12.0.jar
02-15
flink 以connector形式连接clickhouse，资源稀缺，阿里云已经找不到了 id Int, age Int, sex Int, create_date Date ) WITH ( 'connector' = 'clickhouse', 'url' = 'jdbc:clickhouse://10.1.3.176:8123/test'...
Flink-1.12 - 之Flink SQL 与 kafka connector实践
shufangreal的博客
06-09 6811
Flink-1.12 - 之kafka connector实践 1 前言(消息更新模式) 阅读之前可以先了解一下，动态table抓换成data stream的3种模式，这个在动态Table转换成DataStream或者写入外部系统的时候是有严格的约束的。 Append Mode 一个只有Insert操作的动态表,才能转换成Append-only stream（或写入到支持AppendMode的外部系统如：文件、Kafka、Hive等） Retract Mode 这种模式有2种类型的消息：add 和
Flink之State状态编程
shufangreal的博客
03-05 5868
Flink中的状态State 在flink中，状态始终与特定算子相关联，像reduce、sum等算子都是默认带状态的，而map、flatmap本身时不带状态的，如果需要用到状态，可以自定义 为了使运行的flink了解算子的状态，算子需要预先注册其状态 总的来说，有2种类型的状态 算子状态(Operator State) 算子状态的作用范围限定为算子任务 键控状态(keyed State)...
Flink-kryo序列化方式&类型管理
shufangreal的博客
05-04 4227
Flink类型管理与序列化 Flink作为一个强大的实时计算引擎，底层大部分源码都是Java编写的，所以flink对pojo有着很好的支持，类似于Spark中DataFrame引入的schema，Flink也能够很好的infer推断数据类型的schema，可以将推断出的schema当作一个database，所以TypeInformation中包含了一个类的很多基本信息。TypeInformatio...
配置Flink依赖的pom文件时报错：flink-clients_2.11 & flink-streaming-java_2.11
06-07
这个问题可能是由于你在pom文件中引入了不兼容的Flink版本所引起的。请检查你的pom文件，确保所有的Flink依赖项都使用相同的版本号，并且与你正在使用的Java版本兼容。 如果你使用的是Java 8，则需要使用Flink 1.9.x或更高版本，因为这些版本是兼容Java 8的。如果你使用的是Java 7，则需要使用Flink 1.6.x版本。 你可以尝试在pom文件中引入以下依赖项，来解决这个问题： ```xml <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-streaming-java_${scala.binary.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-clients_${scala.binary.version}</artifactId> <version>${flink.version}</version> </dependency> ``` 请确保`${flink.version}`和`${scala.binary.version}`的值是一致的，并且与你正在使用的Flink版本和Scala版本相匹配。 如果问题仍然存在，请提供更多的错误信息或上下文内容，以便我可以更好地帮助你解决问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值