【大数据】Flink 内存管理（四）：TaskManager 内存分配（实战篇）

2024-02-26 13:12
文章标签 数据 内存 分配 管理 flink 实战篇 taskmanager

本文主要是介绍【大数据】Flink 内存管理（四）：TaskManager 内存分配（实战篇），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Flink 内存管理》系列（已完结），共包含以下 4 篇文章：

  • Flink 内存管理（一）：设置 Flink 进程内存
  • Flink 内存管理（二）：JobManager 内存分配（含实际计算案例）
  • Flink 内存管理（三）：TaskManager 内存分配（理论篇）
  • Flink 内存管理（四）：TaskManager 内存分配（实战篇）

😊 如果您觉得这篇文章有用 ✔️ 的话，请给博主一个一键三连 🚀🚀🚀 吧 （点赞 🧡、关注 💛、收藏 💚）！！！您的支持 💖💖💖 将激励 🔥 博主输出更多优质内容！！！

Flink 内存管理（四）：TaskManager 内存分配（实战篇）

  • 1.单独分配 Total Process Size
  • 2.单独分配 Total Flink Size
  • 3.单独分配 Heap Size && Managed Memory
  • 4.分配 Total Process Size 和 Heap Size && Managed Memory
  • 5.分配 Total Flink Size 和 Heap Size && Managed Memory
  • 6.内存分配小结

在 《Flink 内存管理（一）：设置 Flink 进程内存》中我们提到，必须使用下述三种方法之一配置 Flink 的内存（本地执行除外），否则 Flink 启动将失败。这意味着必须明确配置以下选项子集之一，这些子集没有默认值。

序号for TaskManagerfor JobManager
1️⃣taskmanager.memory.flink.sizejobmanager.memory.flink.size
2️⃣taskmanager.memory.process.sizejobmanager.memory.process.size
3️⃣taskmanager.memory.task.heap.size 和 taskmanager.memory.managed.sizejobmanager.memory.heap.size

1.单独分配 Total Process Size

单独分配 Total Process Size，其它的组件都会自动分配。

taskmanager.memory.process.size: 2000m

在这里插入图片描述

内存分配步骤如下：

  • 首先 Total Process Size = 2000 M = 2000M =2000M
  • 因为没有显示分配组件中的任何参数，所以 JVM Overhead = 2000 M × 0.1 = 200 M = 2000M × 0.1 = 200M =2000M×0.1=200M
  • JVM Metaspace = 256 M = 256M =256M
  • ⭐ 所以 Native Memory = JVM Overhead + JVM Metaspace = 456 M = 456M =456M
  • Total Flink Size = 2000 M − 200 M − 256 M = 1544 M B = 1.508 G B = 2000M - 200M - 256M = 1544MB = 1.508GB =2000M−200M−256M=1544MB=1.508GB
  • Network Memory = 1544 × 0.1 = 154.4 M = 1544 × 0.1 = 154.4M =1544×0.1=154.4M
  • Task Off-Heap = = = 0 M B 0MB 0MB（默认）
  • Framework Off-Heap = = = 128 M 128M 128M（默认）
  • ⭐ 所以 Total Direct Memory = 154.4 M + 0 + 128 M = 282.4 M = 154.4M + 0 + 128M = 282.4M =154.4M+0+128M=282.4M
  • Managed Memory = 1544 M B × 0.4 = 617.6 M = 1544MB × 0.4 = 617.6M =1544MB×0.4=617.6M
  • Total JVM Heap Memory = 1544 M − 282.4 M − 617.6 M = 644 M B = 1544M - 282.4M - 617.6M = 644MB =1544M−282.4M−617.6M=644MB
  • Framework Heap = 128 M = 128M =128M
  • Task Heap = 644 M − 128 M = 516 M = 644M - 128M = 516M =644M−128M=516M

可以与以下的日志进行对比，完全能对上，😁😁😁！

在这里插入图片描述

2.单独分配 Total Flink Size

taskmanager.memory.flink.size: 2000m

假如直接只分配 taskmanager.memory.flink.size: 2000m

  • Total Flink Size = 2000 M = 2000M =2000M
  • Managed Memory = 2000 M × 0.4 = 800 M = 2000M × 0.4 = 800M =2000M×0.4=800M
  • NetWork Memory = 2000 M × 0.1 = 200 M = 2000M × 0.1 = 200M =2000M×0.1=200M
  • Framework Off-Heap = 128 M = 128M =128M
  • Task Off-Heap = 0 B y t e = 0 M = 0Byte = 0M =0Byte=0M
  • ⭐ 所以 Total Direct Memory = 200 M + 128 M + 0 M = 328 M = 200M + 128M + 0M= 328M =200M+128M+0M=328M
  • Total Off-Heap Memory = 800 M + 328 M = 1128 M = 800M + 328M = 1128M =800M+328M=1128M
  • Total JVM Heap = 2000 M − 800 M − 328 M = 872 M = 2000M - 800M - 328M = 872M =2000M−800M−328M=872M
  • Framework Heap = 128 M = 128M =128M
  • Task Heap = 872 M − 128 M = 744 M = 872M - 128M = 744M =872M−128M=744M
  • JVM MetaSpace = 256 M = 256M =256M（默认）
  • JVM Overhead = ( = ( =(JVM Overhead + 256 M +\ 256M + 256M Metaspace + 2000 M +\ 2000M + 2000M Total Flink Size ) × 0.1 ) × 0.1 )×0.1，求解 JVM Overhead = 250.667 M = 250.667M =250.667M 在 192 M B ～ 1 G B 192MB ～ 1GB 192MB～1GB，生效
  • Total Process Size = 2000 M + 256 M + 250.667 M = 2506.667 M = 2.448 G B = 2000M + 256M + 250.667M = 2506.667M = 2.448GB =2000M+256M+250.667M=2506.667M=2.448GB

在这里插入图片描述

3.单独分配 Heap Size && Managed Memory

taskmanager.memory.task.heap.size: 1000m
taskmanager.memory.managed.size: 1000m
  • Framework Heap = 128 M = 128M =128M（默认）
  • Task Heap = 1000 M = 1000M =1000M（配置）
  • Total JVM Heap = 1000 M + 128 M = 1128 M = 1.102 G B = 1000M + 128M = 1128M = 1.102GB =1000M+128M=1128M=1.102GB
  • Managed Memory = 1000 M = 1000M =1000M（配置）
  • Framework Off-Heap = 128 M = 128M =128M
  • Task Off-Heap = 0 M = 0M =0M
  • NetWork = = = Total Flink Size × 0.1 ×\ 0.1 × 0.1 = ( = ( =(NetWork + 1128 M + 1000 M + 128 M + 0 M ) × 0.1 +\ 1128M + 1000M + 128M + 0M) × 0.1 + 1128M+1000M+128M+0M)×0.1，计算得到 Network = 250.667 M B = 250.667MB =250.667MB，处于 64 M B ～ 1 G B 64MB ～ 1GB 64MB～1GB，有效
  • ⭐ 所以 Total Direct Memory = 128 M + 250.667 M = 378.667 M = 128M + 250.667M = 378.667M =128M+250.667M=378.667M
  • Total Flink Size = 1128 M + 1378.667 M = 2506.667 M = 2.448 G B = 1128M + 1378.667M = 2506.667M = 2.448GB =1128M+1378.667M=2506.667M=2.448GB
  • JVM Metaspace = 256 M = 256M =256M（默认）
  • JVM Overhead = ( = ( =(JVM Overhead + 1128 M + 1000 M + 378.667 M + 256 M ) × 0.1 = 306.963 M +\ 1128M + 1000M + 378.667M + 256M) × 0.1 = 306.963M + 1128M+1000M+378.667M+256M)×0.1=306.963M，处于 192 M ～ 1 G B 192M ～ 1GB 192M～1GB，有效
  • Total Process Size = 2506.667 M + 256 M + 306.963 M = 3069.63 M = 2.998 G = 2506.667M + 256M + 306.963M = 3069.63M = 2.998G =2506.667M+256M+306.963M=3069.63M=2.998G

在这里插入图片描述

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
  • Total Process Size = 3000 M = 3000M =3000M
  • Framework Heap = 128 M = 128M =128M（默认）
  • Task Heap = 1000 M = 1000M =1000M（配置）
  • Total JVM Heap = = = Framework Heap + + + Task Heap = 128 M + 1000 M = 1128 M = 1.102 G = 128M + 1000M = 1128M = 1.102G =128M+1000M=1128M=1.102G
  • Managed Memory = 1000 M = 1000M =1000M（配置）
  • Framework Off-Heap = 128 M = 128M =128M（默认）
  • Task Off-Heap = 0 M = 0M =0M（默认）
  • Network Memory = ( = ( =(Network Memory + 1128 M + 1128 M ) × 0.1 = 250.667 M +\ 1128M + 1128M) × 0.1 = 250.667M + 1128M+1128M)×0.1=250.667M，在 64 M ～ 1 G B 64M ～ 1GB 64M～1GB 之间，满足要求
  • Total Off-Heap = 1000 M + 128 M + 250.667 M + 0 M = 1378.667 M = 1.346 G B = 1000M + 128M + 250.667M + 0M = 1378.667M = 1.346GB =1000M+128M+250.667M+0M=1378.667M=1.346GB
  • Total Flink Size = 1128 M + 1378.667 M = 2506.667 M = 2.448 G B = 1128M + 1378.667M = 2506.667M = 2.448GB =1128M+1378.667M=2506.667M=2.448GB
  • JVM Metaspace = 256 M = 256M =256M
  • JVM Overhead = 3000 M − 2506.667 M − 256 M = 237.333 M = 3000M - 2506.667M - 256M = 237.333M =3000M−2506.667M−256M=237.333M，在 192 M ～ 1 G B 192M ～ 1GB 192M～1GB 之间，满足要求

在这里插入图片描述

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
  • Total Flink Size = 3000 M = 2.93 G B = 3000M = 2.93GB =3000M=2.93GB（配置）
  • Managed Memory = 1000 M = 1000M =1000M（配置）
  • Task Heap = 1000 M = 1000M =1000M（配置）
  • Framework Heap = 128 M = 128M =128M（默认）
  • Total JVM Heap = = = Framework Heap + Task Heap = 128 M + 1000 M = 1128 M = 128M + 1000M =1128M =128M+1000M=1128M
  • Total Off-Heap Memory = 3000 M − 1128 M = 1872 M = 1.828 G B = 3000M - 1128M = 1872M = 1.828GB =3000M−1128M=1872M=1.828GB
  • Direct Memory = = = Total Off-Heap Memory - Managed Memory = 1872 M − 1000 M = 872 M = 1872M - 1000M = 872M =1872M−1000M=872M
  • Task Off-Heap = 0 M = 0M =0M（默认）
  • Framework Off-Heap = 128 M = 128M =128M（默认）
  • Network Memory = = = Direct Memory − - − Task Off-Heap - Framework Off-Heap = 872 M − 0 M − 128 M = 744 M = 872M - 0M - 128M = 744M =872M−0M−128M=744M
  • JVM Metaspace = 256 M = 256M =256M（默认）
  • JVM Overhead = ( = ( =(JVM Overhead + 3000 M + 256 M ) × 0.1 +\ 3000M + 256M) × 0.1 + 3000M+256M)×0.1，计算得到 JVM Overhead = 361.778 M = 361.778M =361.778M，处于 192 M ～ 1 G 192M～1G 192M～1G 之间，符合条件
  • Total Process Size = 3000 M + 256 M + 361.778 M = 3617.778 M = 3.533 G B = 3000M + 256M + 361.778M = 3617.778M = 3.533GB =3000M+256M+361.778M=3617.778M=3.533GB

在这里插入图片描述

6.内存分配小结

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

  • 指定 Total Process Size 或 Total Flink Size，取决于你用什么方式部署。
  • 单独指定某个组件，比如 Task-Heap 的大小，其它的组件都会被推导出来。
  • 指定 Total Process / Flink Size && Heap or Off-Heap 其中之一，其它的组件通过默认值进行填充或者进推导，如：
    • Total Flink Size = Total Heap Size + Total Off-Heap Size
    • Total Heap Size = Task Heap + Framework Heap
    • Total Off-Heap = Task Off-Heap + Framework Off-Heap + Network Memory + Managed Memory
    • Network = Total Flink Size × 0.1 ×\ 0.1 × 0.1（没有指定其它组件情况下）
    • JVM Overhead = Total Process Size × 0.1 ×\ 0.1 × 0.1（没有指定其它组件情况下）
    • … …

这篇关于【大数据】Flink 内存管理（四）：TaskManager 内存分配（实战篇）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/748987。

相关文章

SpringBoot 多环境开发实战(从配置、管理与控制)

SpringBoot 多环境开发实战(从配置、管理与控制)

《SpringBoot多环境开发实战(从配置、管理与控制)》本文详解SpringBoot多环境配置,涵盖单文件YAML、多文件模式、MavenProfile分组及激活策略,通过优先级控制灵活切换环境... 目录一、多环境开发基础（单文件 YAML 版）（一）配置原理与优势（二）实操示例二、多环境开发多文件版
阅读更多...
MyBatis-plus处理存储json数据过程

MyBatis-plus处理存储json数据过程

《MyBatis-plus处理存储json数据过程》文章介绍MyBatis-Plus3.4.21处理对象与集合的差异：对象可用内置Handler配合autoResultMap,集合需自定义处理器继承F... 目录1、如果是对象2、如果需要转换的是List集合总结对象和集合分两种情况处理，目前我用的MP的版本
阅读更多...
GSON框架下将百度天气JSON数据转JavaBean

GSON框架下将百度天气JSON数据转JavaBean

《GSON框架下将百度天气JSON数据转JavaBean》这篇文章主要为大家详细介绍了如何在GSON框架下实现将百度天气JSON数据转JavaBean,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下... 目录前言一、百度天气jsON1、请求参数2、返回参数3、属性映射二、GSON属性映射实战1、类对象映
阅读更多...
Redis实现高效内存管理的示例代码

Redis实现高效内存管理的示例代码

《Redis实现高效内存管理的示例代码》Redis内存管理是其核心功能之一,为了高效地利用内存,Redis采用了多种技术和策略,如优化的数据结构、内存分配策略、内存回收、数据压缩等,下面就来详细的介绍... 目录1. 内存分配策略jemalloc 的使用2. 数据压缩和编码ziplist示例代码3. 优化的
阅读更多...
C# LiteDB处理时间序列数据的高性能解决方案

C# LiteDB处理时间序列数据的高性能解决方案

《C#LiteDB处理时间序列数据的高性能解决方案》LiteDB作为.NET生态下的轻量级嵌入式NoSQL数据库,一直是时间序列处理的优选方案,本文将为大家大家简单介绍一下LiteDB处理时间序列数... 目录为什么选择LiteDB处理时间序列数据第一章：LiteDB时间序列数据模型设计1.1 核心设计原则
阅读更多...
SpringBoot集成XXL-JOB实现任务管理全流程

SpringBoot集成XXL-JOB实现任务管理全流程

《SpringBoot集成XXL-JOB实现任务管理全流程》XXL-JOB是一款轻量级分布式任务调度平台,功能丰富、界面简洁、易于扩展,本文介绍如何通过SpringBoot项目,使用RestTempl... 目录一、前言二、项目结构简述三、Maven 依赖四、Controller 代码详解五、Service
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
Java+AI驱动实现PDF文件数据提取与解析

Java+AI驱动实现PDF文件数据提取与解析

《Java+AI驱动实现PDF文件数据提取与解析》本文将和大家分享一套基于AI的体检报告智能评估方案,详细介绍从PDF上传、内容提取到AI分析、数据存储的全流程自动化实现方法,感兴趣的可以了解下... 目录一、核心流程：从上传到评估的完整链路二、第一步：解析 PDF，提取体检报告内容1. 引入依赖2. 封装
阅读更多...
Python内存优化的实战技巧分享

Python内存优化的实战技巧分享

《Python内存优化的实战技巧分享》Python作为一门解释型语言,虽然在开发效率上有着显著优势,但在执行效率方面往往被诟病,然而,通过合理的内存优化策略,我们可以让Python程序的运行速度提升3... 目录前言python内存管理机制引用计数机制垃圾回收机制内存泄漏的常见原因1. 循环引用2. 全局变
阅读更多...
MySQL中查询和展示LONGBLOB类型数据的技巧总结

MySQL中查询和展示LONGBLOB类型数据的技巧总结

《MySQL中查询和展示LONGBLOB类型数据的技巧总结》在MySQL中LONGBLOB是一种二进制大对象（BLOB）数据类型,用于存储大量的二进制数据,：本文主要介绍MySQL中查询和展示LO... 目录前言1. 查询 LONGBLOB 数据的大小2. 查询并展示 LONGBLOB 数据2.1 转换为十
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2