java中的内存分析图
内存分析工具MAT的使用
内存分析工具MAT的使用MAT（Memory Analyzer Tool）是一个开源的Java内存分析工具，可以帮助开发人员分析和优化Java应用程序的内存使用情况。
在开发和调试过程中，MAT可以帮助我们找到内存泄漏、大对象、重复对象以及内存使用高的地方，从而提高应用程序的性能和稳定性。
以下是使用MAT进行内存分析的一般步骤：2. 创建内存快照：在使用MAT进行内存分析之前，我们需要创建Java应用程序的内存快照。
可以通过以下几种方式创建内存快照：- 在Eclipse中启动的Java应用程序中，可以使用"Eclipse Memory Analyzer"菜单中的"Dump HPROF File"选项来创建内存快照。
- 在Java命令行应用程序中，可以通过添加JVM参数"-XX:+HeapDumpOnOutOfMemoryError"来在内存溢出错误发生时自动创建内存快照。
- 对于正在运行的Java进程，可以使用jmap命令手动创建内存快照。
3. 打开内存快照：启动MAT后，可以通过"File"菜单中的"Open Heap Dump"选项打开已经创建的内存快照。
MAT支持打开多种格式的内存快照文件，包括HPROF、IBM PHD、Eclipse MAT等。
4. 分析内存使用情况：在打开内存快照后，MAT会对内存进行解析和分析，并显示内存使用的概览信息。
在"Overview"选项卡中，我们可以查看内存占用的总大小、对象数量和最常见的对象类型。
5. 查找内存泄露：MAT提供了多种工具和视图，可以帮助我们找到内存泄漏的原因。
其中，"Leak Suspects"视图可以显示潜在的内存泄漏问题，"Path to GC Roots"视图可以展示垃圾回收根对象的引用链，帮助我们找到导致对象无法被回收的原因。
java内存使用情况的命令
java内存使用情况的命令Java是一种面向对象的编程语言，它在开发应用程序时需要使用内存来存储数据和执行代码。
因此，了解Java的内存使用情况对于开发人员来说是非常重要的。
Java虚拟机（JVM）负责管理Java应用程序的内存，它使用垃圾回收机制来自动管理内存的分配和释放。
JVM的内存可以分为以下几个部分：1. 堆（Heap）：堆是Java程序运行时动态分配的内存区域，用于存储对象实例。
堆的大小可以通过命令行参数-Xmx和-Xms来设置。
-Xms表示JVM启动时初始分配的堆内存大小，-Xmx表示堆能够达到的最大内存大小。
2. 方法区（Method Area）：方法区用于存储已加载的类信息、常量、静态变量等数据。
方法区的大小可以通过命令行参数-XX:PermSize和-XX:MaxPermSize来设置。
-XX:PermSize表示JVM启动时初始分配的方法区大小，-XX:MaxPermSize表示方法区能够达到的最大大小。
3. 栈（Stack）：栈用于存储Java方法中的局部变量以及方法调用时的状态信息。
每个Java线程都有一个独立的栈，栈的大小是固定的，并且在线程创建时被分配。
栈的大小可以通过命令行参数-Xss来设置。
除了上述部分，JVM还会使用一些额外的内存空间，如直接内存（DirectMemory）和本地方法栈（Native Method Stack），用于存储一些特殊的数据和执行本地方法。
了解Java的内存使用情况对于定位内存泄漏和优化程序性能非常有帮助。
下面是几个常用的命令，可以用于监控和调整Java程序的内存使用情况：1. jps：该命令用于列出当前运行的Java进程，以及对应的进程ID。
2. jstat：该命令用于监控Java虚拟机的各种运行状态，包括堆的使用情况、类加载数量、垃圾回收情况等。
常用的参数包括-jstat -gcutil <pid>和-jstat-gccapacity <pid>。
Java进程占用内存过高，排查解决方法
Java进程占⽤内存过⾼，排查解决⽅法最近收到邮件报警，说内存使作率达到84%。
如下图：解决⽅法：A:可能是代码原因导致的问题：1、使⽤命令：top 查看当前进程的状态2、从上图可以看到PID：916的java进程占⽤内存较⼤。
定位线程问题（通过命令查看PID 为25894 进程的线程情况）,命令：# ps p 916 -L -o pcpu,pmem,pid,tid,time,tname,cmd由此可以看到这PID：916的进程产⽣了很多线程。
接下来就可以通过jstack查看内存使⽤的堆栈。
3、查看内存使⽤的堆栈：在这⾥我们挑选了TID=934的线程进⾏分析，⾸先需要将934这个id转换为16进制。
需输⼊如下命令，printf "%x\n" 97314、将PID为916的堆栈信息打印到jstack.log中，命令：jstack -l 916 > jstack.log5、查看堆栈信息⽂件，命令：vim jstack.log在进⾏搜索TID为2603的相关信息。
如图：6、分析可以看到这个线程状态为：RUNNABLE。
是正在运⾏状态的另外其它的⼤部分线程状态为：WAITING。
通过查看⽂件分析看到⼤量 Java Thread State。
说明它在等待另⼀个条件的发⽣，来把⾃⼰唤醒，或者⼲脆它是调⽤了 sleep(N)。
此时线程状态⼤致为以下⼏种：ng.Thread.State: WAITING (parking)：⼀直等那个条件发⽣；ng.Thread.State: TIMED_WAITING (parking或sleeping)：定时的，那个条件不到来，也将定时唤醒⾃⼰。
7.代码优化：将⽂件发送给开发。
优化下线程B:可能是其他原因导致的问题：1、使⽤ps命令:ps -ef | grep java | grep -v grep查看当前java进程列表root 83410 May13 ? 00:30:09 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKey root 129413 May13 ? 14:41:25 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 208510 Mar05 ? 01:57:08 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKey root 1280810 Mar08 ? 01:16:03 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 1939210 May09 ? 00:36:19 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 1983811 May09 ? 05:32:17 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 2154310 May27 ? 00:22:03 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 2275015 May27 ? 02:28:41 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe 由上图所⽰，可以看到java进程是Tomcat的启动进程，开启多个Tomcat启动进程，并且是同⼀个端⼝。
java内存溢出排查方法解析
java内存溢出排查方法解析内存溢出（out of mem or y），通俗理解就是内存不够，通常在运行大型软件或游戏时，软件或游戏所需要的内存远远超出了你主机内安装的内存所承受大小，就叫内存溢出。
此时软件或游戏就运行不了，系统会提示内存溢出，有时候会自动关闭软件，重启电脑或者软件后释放掉一部分内存又可以正常运行该软件或游戏一段时间。
内存溢出已经是软件开发历史上存在了近40年的“老大难”问题，像在“红色代码”病毒事件中表现的那样，它已经成为黑客攻击企业网络的“罪魁祸首”。
如在一个域中输入的数据超过了它的要求就会引发数据溢出问题，多余的数据就可以作为指令在计算机上运行。
据有关安全小组称，操作系统中超过50%的安全漏洞都是由内存溢出引起的，其中大多数与微软的技术有关。
定义及原因内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。
为了解决Java中内存溢出问题，我们首先必须了解Java是如何管理内存的。
Java的内存管理就是对象的分配和释放问题。
在Java中，内存的分配是由程序完成的，而内存的释放是由垃圾收集器（GarbageCollec ti on，GC）完成的，程序员不需要通过调用GC函数来释放内存，因为不同的JVM实现者可能使用不同的算法管理GC，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是中断式执行GC。
但GC只能回收无用并且不再被其它对象引用的那些对象所占用的空间。
Java的内存垃圾回收机制是从程序的主要运行对象开始检查引用链，当遍历一遍后发现没有被引用的孤立对象就作为垃圾回收。
1、内存溢出的原因是什么？内存溢出是由于没被引用的对象（垃圾）过多造成JVM没有及时回收，造成的内存溢出。
如果出现这种现象可行代码排查：一）是否App中的类中和引用变量过多使用了Stat ic修饰如publicst ai tc Student s；在类中的属性中使用 static修饰的最好只用基本类型或字符串。
Java内存分析工具jmap
Java内存分析⼯具jmap1.简述 jmap是⼀个多功能的命令，它可以⽣成java程序的dump⽂件，也可以查看堆内对象⽰例的统计信息、查看ClassLoader的信息以及finalizer队列。
2.jmap的⽤法 （1）jmap参数说明 参数说明：option：选项参数。
pid：需要打印配置信息的进程ID。
executable：产⽣核⼼dump的Java可执⾏⽂件。
core：需要打印配置信息的核⼼⽂件。
server-id：可选的唯⼀id，如果相同的远程主机上运⾏了多台调试服务器，⽤此选项参数标识服务器。
remote server IP or hostname：远程调试服务器的IP地址或主机名。
option选项参数说明：no option：查看进程的内存映像信息。
heap：显⽰Java堆详细信息。
histo[:live]：显⽰堆中对象的统计信息。
permstat：打印类加载器信息。
finalizerinfo：显⽰在F-Queue队列等待Finalizer线程执⾏finalizer⽅法的对象。
dump:<dump-options>：⽣成堆转储快照。
F：当-dump没有响应时，使⽤-dump或者-histo参数，在这个模式下,live⼦参数⽆效。
help：打印帮助信息。
J<flag>：指定传递给运⾏jmap的JVM的参数。
（2）no option⽰例 命令：jmap pid 描述：使⽤不带选项参数的jmap打印共享对象映射，将会打印⽬标虚拟机中加载的每个共享对象的起始地址、映射⼤⼩以及共享对象⽂件的路径全称。
这与Solaris的pmap⼯具⽐较相似。
（3）heap⽰例 命令：jmap -heap pid 描述：打印⼀个堆的摘要信息，包括使⽤的GC算法、堆配置信息和各内存区域内存使⽤信息。
C:\Users\Administrator>jmap -heap 1760Attaching to process ID 1760, please wait...Debugger attached successfully.Server compiler detected.JVM version is 24.80-b11using thread-local object allocation. #新⽣代采⽤的是并⾏线程处理⽅式Parallel GC with 4 thread(s) #同步并⾏垃圾回收Heap Configuration: #堆配置情况，也就是JVM参数配置的结果【平常说的tomcat配置JVM参数，就是在配置这些】MinHeapFreeRatio = 0 #最⼩堆使⽤⽐例MaxHeapFreeRatio = 100 #最⼤堆可⽤⽐例MaxHeapSize = 2147483648 (2048.0MB) #最⼤堆空间⼤⼩NewSize = 1310720 (1.25MB) #新⽣代分配⼤⼩MaxNewSize = 536870912 (512.0MB) #最⼤可新⽣代分配⼤⼩OldSize = 5439488 (5.1875MB) #⽼年代⼤⼩NewRatio = 2 #新⽣代⽐例SurvivorRatio = 8 #新⽣代与suvivor的⽐例PermSize = 21757952 (20.75MB) #perm区永久代⼤⼩MaxPermSize = 2147483648 (2048.0MB) #最⼤可分配perm区也就是永久代⼤⼩G1HeapRegionSize = 0 (0.0MB)Heap Usage: #堆使⽤情况【堆内存实际的使⽤情况】PS Young GenerationEden Space: #伊甸区capacity = 413663232 (394.5MB) #伊甸区容量used = 41933104 (39.99052429199219MB) #伊甸区已经使⽤⼤⼩free = 371730128 (354.5094757080078MB) #剩余容量10.137015029655814% used #伊甸区使⽤情况From Space: #survior1区capacity = 58195968 (55.5MB) #survior1区容量used = 0 (0.0MB) #surviror1区已使⽤情况free = 58195968 (55.5MB) #surviror1区剩余容量0.0% used #survior1区使⽤⽐例To Space: #survior2区capacity = 56623104 (54.0MB) #survior2区容量used = 0 (0.0MB) #survior2区已使⽤情况free = 56623104 (54.0MB) #survior2区剩余容量0.0% used #survior2区使⽤⽐例PS Old Generation #⽼年代使⽤情况capacity = 458227712 (437.0MB) #⽼年代容量used = 243170504 (231.90546417236328MB) #⽼年代已使⽤容量free = 215057208 (205.09453582763672MB) #⽼年代剩余容量53.0676119387559% used #⽼年代使⽤⽐例PS Perm Generation #永久代使⽤情况capacity = 176685056 (168.5MB) #perm区容量used = 92300856 (88.02495574951172MB) #perm区已使⽤容量free = 84384200 (80.47504425048828MB) #perm区剩余容量52.240329821668674% used #perm区使⽤⽐例62625 interned Strings occupying 7287440 bytes.View Code（4）histo[:live]⽰例 命令：jmap -histo:live pid 描述：包括每个Java类、对象数量、内存⼤⼩（单位：字节）、完全限定的类名。
memoryanalyzer 用法 -回复
memoryanalyzer 用法-回复MemoryAnalyzer（简称MAT）是一个Java堆转储文件分析工具，它提供了一种方式来检测和解决Java应用程序运行时的内存问题。
MAT 可以帮助我们找出内存泄漏、大对象占用、对象生命周期不当等问题，并提供了各种工具和功能来优化应用程序的内存使用。
本文将逐步介绍MemoryAnalyzer的用法，帮助读者更好地了解和使用这个强大的分析工具。
第一步：安装和启动MemoryAnalyzer首先，我们需要从Eclipse官网的MAT插件页面下载并安装MemoryAnalyzer插件。
安装成功后，在Eclipse的菜单栏中选择“Window”-> “Open Perspective”-> “Other”-> “Memory Analyzer”以切换到MemoryAnalyzer的透视图。
第二步：导入Java堆转储文件在MemoryAnalyzer的透视图中，我们可以通过点击工具栏中的“Open Heap Dump”按钮来导入Java堆转储文件。
选择已经生成的Java堆转储文件，点击“OK”按钮即可开始分析。
第三步：分析内存使用情况一旦Java堆转储文件导入成功，MemoryAnalyzer将显示一个面板，其中包含关于内存使用情况的各种信息。
首先，我们可以查看堆转储文件的总体概况，包括堆转储文件的大小、堆大小、垃圾回收器信息等。
在“Histogram”选项卡下，我们可以看到各个类的实例数和内存占用情况。
通过点击某个类，我们可以查看该类的实例列表，并对实例进行进一步的分析。
第四步：查找内存泄漏问题MemoryAnalyzer提供了一个强大的工具来检测内存泄漏问题，即“Leak Suspects”（内存泄漏嫌疑人）。
在MemoryAnalyzer的透视图中，点击工具栏中的“Leak Suspects”按钮，它将分析堆转储文件并生成一个内存泄漏报告。
Java 技术栈(思维导图)
Spark：Core、SQL、Streaming、MLib、GraphX……
大数据
Flink、ELK、Ansible……
Jenkins、JIRA、GitlabCI、TravisCI……
DevOps
JWT、SSO、ELK、秒杀……
解决方案
进阶
Java 技术栈
初级
Java 平台
发行版；面向对象；类加载、运行机制；编译、解释、JIT……
微服务
MySQL：B树、B+树、Hash表、隔离性、一致性、原子性、分布式事务、锁、 binlog、redolog、主从同步……
Redis：线程模型、缓存穿透/雪崩、集群和哨兵、分布式锁……
消息队列：RabbitMQ、Kafka、RocketMQ……
Nginx：反向代理、负载均衡…… Elasticsearch、MongoDB、图数据库……
TCP、UDP、HTTP(s)、RPC、WebSocket……
常用协议
内存分配、线程模型…… GC日志、诊断工具、问题定位、调优策略……
JVM
锁：自旋锁、偏向锁、锁粗化/锁消除、分段锁、读写锁、公平锁、非公平锁、乐 观锁、悲观锁……
同步器：CAS、AQS、自旋…… 并发模型：并行、响应式、函数式、Actor、Channel……
Redis
缓存、持久化……
算法 & 数据结构
树、堆、链表、数组…… 查找、排序、递归……
设计模式
单例、工厂、构建器、装饰器、迭代器、观察者……
开发框架
Spring MyBatis
基础：Context、IOC、AOP、Bean、MVC…… SpringBoot：自动装配、嵌入式容器……
SqlSession、Executor……
java基本数据类型所占用的内存空间大小
java基本数据类型所占⽤的内存空间⼤⼩⼀、基本数据类型 Java语⾔提供了⼋种基本类型。
六种数值类型（四个整数型，两个浮点型），⼀种字符类型，还有⼀种布尔型。
java中基本数据类型中没有⽆符号类型（C、C++中有），只有有符号类型。
在计算机内，定点数有3种表⽰法：原码、反码和补码原码：⼆进制定点表⽰法，即最⾼位为符号位，“0”表⽰正，“1”表⽰负，其余位表⽰数值的⼤⼩。
反码：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码：正数的补码与其原码相同；负数的补码是将其原码的除符号位外的所有位，逐位取反，然后加1。
计算机中数据的运算都是通过补码进⾏的。
反码是为了解决减法运算，补码是为了解决反码产⽣的±0的问题。
计算机中负数是⽤补码的形式保存、并⽤它参与加减法运算的，减法会被转换为加法，计算机中没有减法运算。
在计算机中减法运算可以转换成加法运算，⽐如8-1 --> 8+(-1) = 7原码： 8: 0000 1000 -1: 1000 0001反码： 8: 0000 1000 -1: 1111 1110补码： 8: 0000 1000 -1: 1111 1111补码运算： (0000 1000) + (11111111) = 0000 0111 --> 4+2+1=7⽐如：-128+127 --> 127+(-128) = -1 0111 1111 + (1000 0000) = 1111 1111(补码) --> 1111 1110（反码） --> 1000 0001(原码) --> -1计算机都是以补码来存储的： ⑴⼀个数为正，则它的原码、反码、补码相同。
⑵⼀个数为负，则符号位为1，其余各位是对原码取反（符号位不变），然后整个数加1。
先⽤⼀个正数1举例原码：0000 0001反码：0000 0001补码：0000 0001正数的原码=反码=补码对于-1来说原码：1000 0001反码：1111 1110（符号位不变，其他相反）补码：1111 1111（补码是反码+1） Java中⽤补码表⽰⼆进制数。
java常见的内存资源分析、性能分析工具有哪些？
VisualVM是一个资源分析工具，一直从JDK 6更新到7，它默认内存和CPU的监视，它可以告诉你哪个类和方法消耗资源，但它不会显示代码流程。
2.JProfiler
JProfiler很容易安装，并且通过向导，你可以选择应用服务器用来运行应用程序。我不得不选择使用JPofiler应用服务器的主目录，以及向导生成的一个单独的启动脚本。然后运行服务器。在监听会话的过程中，它会提供几个选项，它可以记录内存的使用和CPU的使用率。在查看CPU使用率的同时，可以看到执行路径。这让我看到应用程序大部分时间都花在请求上。我们可以将IntelliJ插件安装到IDE上，那么运行JProfiler会更加便利。比如，可以直接帮我启动Tomcat。
我刚开始创建JProbe时遇到点困难。安装并不是直接完成，我需要对它进行配置。它采用了类似JProfiler一样的设置。它会在你的Tomcat目录中生成启动脚本，可以通过脚本启动服务器并监听会话。它的界面包含有按钮和表格，其中可以看到内存的使用，但无法在进程中找到执行路径。 5来自Spring Insight
结 论
如果你有基于Spring的应用程序，那么选择Spring Insight显然是最佳的。它一直是免费的，但你需要部署你的应用在TC Server上。
如果你想监听本地和远程的进程，我会选择JProfiler或YourKit.这两个也可以帮助Spring Insight来监测、找到性能瓶颈。
JProfiler和YourKit已经能满足我的上述要求。JProfiler、YourKit和Spring Insight都可以跟踪应用程序的类和方法的流向。JProfiler和YourKit可以显示内存使用情况。虽然Spring Insight不可以显示内存使用情况，但它可以很好的显示吞吐量的趋势。这三款性能分析工具功能很清楚，不混乱，而且容易使用。最后，他们都有自己的 IDE插件。希望本文能帮助你做出正确的选择。
内存分析
JAVA虚拟机内部体系结构：方法区：1.将被装载类型的信息放到方法区2.方法区中包含了在整个程序中永远唯一的元素（类的代码信息、常量、静态变量、字符串常量）3.被所有线程共享堆：1.存储的全部都是对象(即new出来的东东)2.JVM只有一个堆区，被所有线程共享3.堆是不连续的内存空间，是由new分配的，获得比较灵活，但是速度慢。
栈：1.每个线程一个栈，栈中的数据是私有的，其他栈不能访问2.局部变量在栈中存放3.栈是一块连续的内存空间，由系统自动分配，速度快。
程序运行过程内存分析：public class TestMemory{public static void main(String[] args){int i = 3;Man man = new Man();="gao";man.age=18;String str = "nihao";String str2 = "nihao";String str3 = new String("hi");String str4 = new String("hi");}}class Man{String name;int age;}字符串在内存中的表示形式：String类对象称作不可变的字符串，这样的话编译器可以安排共享的字符串，同时也意味着String类中不提供这样的方法，它可以改变已存在的字符串中的单个字符。
Java中的字符串分配又有点特殊，如果直接声明称这样：String s1 = “hello”，则”hello”字符串是在内存中方法区的字符串池中分配，如果再次有需要用到”hello”,就直接在字符串池中查看有没有存在此字符串，如果有则直接用，没有则创建。
如果声明成String s3 = new String(”hello”)，则”hello”是在堆内存中分配。
Java应用Top命令RES内存占用高分析（转）
Java应⽤Top命令RES内存占⽤⾼分析（转）分析给⼤拇指，转存ps aux命令执⾏结果的⼏个列的信息的含义USER 进程所属⽤户PID 进程ID%CPU 进程占⽤CPU百分⽐%MEM 进程占⽤内存百分⽐VSZ 虚拟内存占⽤⼤⼩单位：kb（killobytes）RSS 实际内存占⽤⼤⼩单位：kb（killobytes）TTY 终端类型STAT 进程状态START 进程启动时刻TIME 进程运⾏时长,进程已经消耗的CPU时间COMMAND 启动进程的命令的名称和参数top 命令 VSZ,RSS,TTY,STAT, VIRT,RES,SHR,DATA的含义VIRT：virtual memory usage 虚拟内存1、进程“需要的”虚拟内存⼤⼩，包括进程使⽤的库、代码、数据等2、假如进程申请100m的内存，但实际只使⽤了10m，那么它会增长100m，⽽不是实际的使⽤量RES：resident memory usage 常驻内存1、进程当前使⽤的内存⼤⼩，但不包括swap out2、包含其他进程的共享3、如果申请100m的内存，实际使⽤10m，它只增长10m，与VIRT相反4、关于库占⽤内存的情况，它只统计加载的库⽂件所占内存⼤⼩SHR：shared memory 共享内存1、除了⾃⾝进程的共享内存，也包括其他进程的共享内存2、虽然进程只使⽤了⼏个共享库的函数，但它包含了整个共享库的⼤⼩3、计算某个进程所占的物理内存⼤⼩公式：RES – SHR4、swap out后，它将会降下来DATA1、数据占⽤的内存。
如果top没有显⽰，按f键可以显⽰出来。
2、真正的该程序要求的数据空间，是真正在运⾏中要使⽤的。
top 运⾏中可以通过 top 的内部命令对进程的显⽰⽅式进⾏控制。
内部命令如下：s – 改变画⾯更新频率l – 关闭或开启第⼀部分第⼀⾏ top 信息的表⽰t – 关闭或开启第⼀部分第⼆⾏ Tasks 和第三⾏ Cpus 信息的表⽰m – 关闭或开启第⼀部分第四⾏ Mem 和第五⾏ Swap 信息的表⽰N – 以 PID 的⼤⼩的顺序排列表⽰进程列表P – 以 CPU 占⽤率⼤⼩的顺序排列进程列表M – 以内存占⽤率⼤⼩的顺序排列进程列表h – 显⽰帮助n – 设置在进程列表所显⽰进程的数量q – 退出 tops – 改变画⾯更新周期序号列名含义a PID 进程idb PPID ⽗进程idc RUSER Real user named UID 进程所有者的⽤户ide USER 进程所有者的⽤户名f GROUP 进程所有者的组名g TTY 启动进程的终端名。
JAVA内存分配算法分析
内存空洞及内存分配算法研究前言 (2)几个简单的场景(Linux 64位下测试)： (2)Linux默认的内存分配机制 (3)1.glibc的内存分配机制： (4)2.glibc的内存释放机制： (5)为什么会有内存空洞 (5)Fastbin介绍 (6)3.Linux多线程环境下内存空洞所占内存可能会翻数倍 (6)4.Stlport内存管理相关说明 (8)Glibc常见内存管理参数介绍 (9)如何消除内存空洞的影响 (10)1.内存空洞的外在现象 (11)2.一个判断是否有内存空洞的脚本 (11)3.自己实现并使用一个内存分配器 (13)其它的内存分配器介绍及使用 (18)4.实现的一个内存泄露检查工具 (18)总结 (19)前言内存泄露一直是C或C++程序员的一个很头疼的问题，但更严重的是有些时候我们发现即使我们调用free或delete释放了内存，进程占用内存也不下降，这也给很多程序员以藉口，如果发现内存使用量增长，要求排查时，我们往往会说，“内存我都释放了，Purify也跑过了，这是内存空洞造成的，是glibc 的行为我也无能为力。
事实上也是，简单的分配不释放的内存泄露问题一般在开发者测试阶段甚至之前就可以排查掉，但这并不代表没有内存问题，特别是对于电信领域，很多程序运行数月甚至数年都不会停，很多很小的问题在乘以时间后会无限放大。
本文首先介绍了Linux的内存分配机制，以及在真实场景下引发的问题，并提出了一些解决方法，并介绍了如何实现并使用一个简单的内存分配器，以及项目组实现的判断是否有内存空洞的一个脚本，和一个内存泄露检查工具。
几个简单的场景(Linux 64位下测试)：✧连续分配1001块100K的内存，把前面分配的1000块内存释放掉，此时通过top检查进程所占内存，发现内存完全不会下降；✧每次分配一块8字节内存，和一块100K的内存，连续分配1000次，然后依次把这些内存全部释放，此时通过top检查进程所占内存，发现内存不会下降；✧多线程下同样的内存使用不当的程序，Linux上内存上涨量可能会是数倍于AIX10M左右的文本数据，如果以一定的格式存储于stlport的数据结构中，实际占用内存会膨胀100倍以上上述的几种场景看似简单，但实际上却都是真实的血淋淋的案例抽象出来的，有些案例的定位花费了大量的人力，而这些场景往往都是purify之类工具测试不出来的，下面通过介绍linux的内存分配机制来解释上述场景，并提出解决方案。
内存分析工具-MAT（MemoryAnalyzerTool）
内存分析⼯具-MAT（MemoryAnalyzerTool）内存分析⼯具-MAT(Memory Analyzer Tool)⾸先查看如下代码,main函数中有⼀个成员变量map，map⾥被循环放⼊对象Hanson，hanson持有姓名和age还有friends字段，friends字段为字符串数组，此应⽤会造成内存增长。
package com.hanson.heap;import java.util.HashMap;import java.util.Map;public class App {public static void main(String[] args) throws InterruptedException {Map<String,Hanson> map = new HashMap<String,Hanson>();int counter = 1;while(true) {Thread.sleep(1);Hanson h = new Hanson();String [] friends = new String[counter];for (int i = 0; i < friends.length; i++) {friends[i] = "friends"+i;}h.setAge(counter);h.setName("hanson"+counter);h.setFriends(friends);map.put(h.getName(),h);if(counter%100==0)System.out.println("put"+counter);counter++;}}}模拟内存溢出程序使⽤参数-Xms200m -Xmx200m –Xmn200m -XX:+HeapDumpOnOutOfMemoryError，指定内存200m并启动应⽤,并且在内存溢出时dump堆信息。
Java工程师学习之路思维导图
Java⼯程师学习之路思维导图前⾯看Hollis的微信公众号更新了Java⼯程师成神之路的⽂档，感觉⾥⾯的内容清晰、齐全，可以⽤来审视⾃⼰，也能够知道⾃⼰在那些⽅⾯可以继续前⾏，想着有时间分享出来。
⼀、基础篇JVMJVM内存结构堆、栈、⽅法区、直接内存、堆和栈区别Ja va内存模型内存可见性、重排序、顺序⼀致性、volatile、锁、final垃圾回收内存分配策略、垃圾收集器（G1）、GC算法、GC参数、对象存活的判定JVM参数及调优Ja va对象模型oop-klass、对象头H o tSpo t即时编译器、编译优化类加载机制classLoader、类加载过程、双亲委派（破坏双亲委派）、模块化（jboss modules、osgi、jigsaw）虚拟机性能监控与故障处理⼯具jps, jstack, jmap、jstat, jconsole, jinfo, jhat, javap, btrace、TProfiler编译与反编译javac 、javap 、jad 、CRFJava基础知识阅读源代码String、Integer、Long、Enum、BigDecimal、ThreadLocal、ClassLoader & URLClassLoader、ArrayList & LinkedList、 HashMap & LinkedHashMap & TreeMap & CouncurrentHashMap、HashSet & LinkedHashSet & TreeSetJa va中各种变量类型熟悉Ja va Str ing的使⽤，熟悉String的各种函数JDK 6和JDK 7中substring的原理及区别、replaceFirst、replaceAll、replace区别、String对“+”的重载、String.valueOf和Integer.toString的区别、字符串的不可变性⾃动拆装箱Integer的缓存机制熟悉Ja va中各种关键字transient、instanceof、volatile、synchronized、final、static、const 原理及⽤法。
Java中的String到底占用多大的内存空间？你所了解的可能都是错误的！！
Java中的String到底占⽤多⼤的内存空间？你所了解的可能都是错误的！！写在前⾯最近⼩伙伴加群时，我总是问⼀个问题：Java中的String类占⽤多⼤的内存空间？很多⼩伙伴的回答着实让我哭笑不得，有说不占空间的，有说1个字节的，有说2个字节的，有说3个字节的，有说不知道的，更让⼈哭笑不得的是竟然还有⼈说是2的31次⽅。
那如果真是这样的话，服务器的内存空间还放不下⼀个字符串呀！作为程序员的我们，可不能闹这种笑话呀。
今天，我们就⼀起来聊聊Java中的String到底占⽤多⼤的内存空间！Java对象的结构⾸先，我们来下Java对象在虚拟机中的结构，这⾥，以HotSpot虚拟机为例。
从上⾯的这张图⾥⾯可以看出，对象在内存中的结构主要包含以下⼏个部分：Mark Word(标记字段)：对象的Mark Word部分占4个字节，其内容是⼀系列的标记位，⽐如轻量级锁的标记位，偏向锁标记位等等。
Klass Pointer（Class对象指针）：Class对象指针的⼤⼩也是4个字节，其指向的位置是对象对应的Class对象（其对应的元数据对象）的内存地址对象实际数据：这⾥⾯包括了对象的所有成员变量，其⼤⼩由各个成员变量的⼤⼩决定，⽐如：byte和boolean是1个字节，short和char是2个字节，int和float是4个字节，long和double是8个字节，reference是4个字节对齐：最后⼀部分是对齐填充的字节，按8个字节填充。
换种说法就是：对象头（object header）：8 个字节（保存对象的 class 信息、ID、在虚拟机中的状态）Java 原始类型数据：如 int, float, char 等类型的数据引⽤（reference）：4 个字节填充符（padding）Java中的String类型空String占⽤的空间这⾥，我们以Java8为例进⾏说明。
⾸先，我们来看看String类中的成员变量。
idea插件篇之java内存分析工具（JProfiler）
idea插件篇之java内存分析⼯具（JProfiler）前⾔在运⾏java的时候有时候想测试云运⾏时占⽤内存情况，这时候就需要使⽤测试⼯具查看了。
在eclipse⾥⾯有 Eclipse Memory Analyzer tool(MAT)插件可以测试，⽽在idea中也有这么⼀个插件，就是JProfilerl。
下载安装打开idea，进⼊设置界⾯安装之后重启即可。
安装成功后查看情况。
这是什么情况呢，这是这个插件启动需要依赖⼀个可执⾏的⽂件，就是源⽣的JAVA PROFILER 去官⽹下载进⼊官⽹下载。
下载之后安装。
双击进⾏安装这⾥他会让你输⼊注册码，不输⼊注册码只有10天试⽤时间。
注册码⽹上有，随便去弄⼀个。
注意这⾥。
我⽤的是最新的 10.1.4版本。
⽹络上⽬前没有最新的激活码，所以我们需要在官⽹弄⼀个注册码。
填⼊信息，然后填邮箱，这个邮箱他会发送⼀个注册码给你。
然后去邮箱复制注册码填⼊进去。
这⾥是让你选择集成的⼯具。
我这⾥是idea2018.x版本的。
所以我这样选择的。
然后点击integrate会出现提⽰框。
这个时候需要把idea给关闭掉才⾏。
这个时候会选择集成⼯具。
你选择的版本他会⾃动帮你寻找，然后chose就⾏了。
出现下⾯提⽰就说明你集成成功了。
如果你没有关闭idea会出现红⾊的乱码情况。
安装完成了。
上⾯提到使⽤idea的时候缺少执⾏⽂件。
这个时候我们去idea集成⼀下。
找到插件界⾯。
进⼊到选择⽂件的界⾯。
然后找到刚才安装的路径。
看图跟着选择。
⼀路ok 就⾏了。
如果上⾯步骤在安装插件后不点击分析按钮，就不⽤选择，会⾃动关联⼯具，最后出现的界⾯和下⾯弹出的⼀样测试在idea使⽤JProfiler启动项⽬测试。
会⾃动打开JProfiler⼯具。
这⾥会验证⼀下注册码提⽰。
出现⼀下情况说明启动成功了。
这样就集成了idea了。
使⽤的⽅法可以去官⽹看⼀下。
Java程序内存分析：使用mat工具分析内存占用
Java程序内存分析：使⽤mat⼯具分析内存占⽤------------------------------------------------------------------------------------------------------------------------------------------------------------------在⼯作中可能会遇到内存溢出这种灾难性的问题，那么程序肯定是存在问题，找出问题⾄关重要，上⼀篇⽂章讲了jmap命令的使⽤⽅法，当然⽤jmap导出的⽂件我们也看不懂啊，那就交给memory analyzer(mat)这个⼯具，让他帮助我们来观察程序的内存分布情况吧。
造成OutOfMemoryError原因⼀般有2种：1、内存泄露，对象已经死了，⽆法通过垃圾收集器进⾏⾃动回收，通过找出泄露的代码位置和原因，才好确定解决⽅案；2、内存溢出，内存中的对象都还必须存活着，这说明Java堆分配空间不⾜，检查堆设置⼤⼩（-Xmx与-Xms），检查代码是否存在对象⽣命周期太长、持有状态时间过长的情况。
1. ⽤jmap⽣成堆信息这样在E盘的jmap⽂件夹⾥会有⼀个map.bin的堆信息⽂件2. 将堆信息导⼊到mat中分析3. ⽣成分析报告mat可以为我们⽣成多个报告：下⾯来看看⽣成的这些数据对我们有什么帮助从上图可以看到它的⼤部分功能，在饼图上,你会发现转储的⼤⼩和数量的类,对象和类加载器。
正确的下⾯,饼图给出了⼀个印象最⼤的对象转储。
移动你的⿏标⼀⽚看到对象中的对象的细节检查在左边。
下⾯的Action标签中：Histogram可以列出内存中的对象，对象的个数以及⼤⼩。
Dominator Tree可以列出那个线程，以及线程下⾯的那些对象占⽤的空间。
Top consumers通过图形列出最⼤的object。
Leak Suspects通过MA⾃动分析泄漏的原因。
Java程序内存低效使用问题的分析
地 将其称为蚍蜉对象。 Ｊｖ ａ ａ程序 还存在这样 的状况一一对象被分配后长时间处 于空闲状态。这 些对 象生存时间往往较长 ，但其活动通常只 集中于某几个短时间段内。该类对象最终被 ＧＣ 回收 ，但从
（． ｃ ｏ ｌ ｆ ｍｐ ￣ Ｂｅ ｉｇＵｎｖ ｒｉ ｆ ｒｎ ｕｉｓ Ａｓ ｏ ａｔ ｓＢｅ ｉｇ１０ ８ ； ． ｃ ｏ ｌ ｆ ｏ ｕ ｎ ｆｒ ｔ ｎＴ ｃｎ ｌｇ， １ Ｓ ｈ ｏ ｏ Ｃｏ ｕ ｉｎ ｉｅｓｔ ｏ Ａｅｏ ａ ｔ ＆ ｔ ｎｕｉ ， ｉｎ ０ ０ ３ ２ Ｓ ｈ ｏ ｏ ｍｐ ｍｒ ｄＩ ｏｍａｉ ｅ ｈｏｏ ｙ ｊ ｙ ｃ ｒ ｃ ｊ Ｃ ａ ｎ ｏ ＤａｉｇＰ ｔ ｌｕ Ｉｓｉ ｔ， ｑｎ ６ ３ ８ ３ Ｈｉｈ ｒ ｄ ｃｔ ｎＰｅｓＢ ｉｎ ０ ０ ９ ｑｎ ｅｒ ｅｍ ｔｕｅ Ｄａｉｇ１ ３ １ ； ． ｇ ｅ ｕ ａｉ ｒｓ， ｅ ｉｇ１ ０ ２ ） ｏ ｎ ｔ Ｅ ｏ ｊ
特别是运行时间很长 、提供关键服务的 Ｓ ｒｅ 端程序 ，这种 ｅｖｒ 崩溃是致命 的。 本文在分析 Ｊｖ 内存低效使用 问题及其对程序运 行效率 ａａ
［ ｓｒ ｃ］Ｔ ｅｍａ ｍｏｙｕａ ｅｗｉ ｏ ｆｃｅ ｃ ｓ ｅ ａｔｒｔ ｏ ｇａｅＪｖ ｒｇａ ｐ ｒ ｒ ｎｅ Ｔ ｒｅｃ ｓｓｉｃｕ ｉｇｌａｅ Ａｂｔａｔ ｈ ｉ ｍｅ ｒ ｓｇ ｔ ｌｗ ｅ ｉｎｙｉ ｋ ｙｆｃｏ ｄ ｗｎ ｒｄ ａ ａｐｏ ｒｍ ｅｆ ｍａ ｃ． ｈｅ ａｅ ｎｌｄｎ ｅｋ ｄ ｎ ｈ ｉ ｏ ｏ
++i与i++在底层的区别分析
++i与i++在底层的区别分析1.计算机中应用程序（Application）的内存布局在我们学习编程语言的过程中熟练掌握自己编写的程序的内存布局是十分重要的，“掌握了内存就掌握了一切”。
我们知道我们编写的程序（源代码）要经过编译器（compiler）的编译才可以变成能够在计算机上执行的程序（C++是.exe可执行文件，Java中是编译成字节码(.class)文件才能在虚拟计算机（JWM）上运行）。
鉴于此我们就知道编译器为我们的程序编制做了大量的工作，但是却隐藏了从源程序到目标程序转换的过程，很多时候就会出现许多的困惑，所以我建议大家不要死抠编程语言的语法规则，而是要试着从内存的角度分析程序的运行。
在这里主要使用VC++的VS2010强大的调试功能分析一下基本原理。
首先，我们需要知道程序运行要使用的4大内存区域：代码段（code segment）、数据段（data segment）、堆栈（stack）、堆（heap）。
他们的作用分别如下：1.代码段（code segment）：存储程序运行的代码2.数据段（data segment）：Java中的字符串常量、静态变量（使用static关键字修饰的）3.堆栈（stack）：局部变量4.堆（heap）：Java中使用new关键字申请的注意：在Java中除了基础数据类型中的4类8种数据类型，其他的数据类型就是引用类型（类、接口、数组），需要引起注意的是如下的Java语句：int [] score = {89, 79, 76}; //静态初始化数组有过C++编程经验的程序员知道它在线程堆栈中分配，然而在Java中数组作为引用数据类型它会占用两块内存，如下所示：图1 一维基础数据类型数组内存结构之所以我们在Java的语法书上看到上面的那一句int型静态初始化数组等价于: int [] score = new int[]{89, 79, 76};是因为我们写的“int [] score = {89, 79, 76};”Java编译器会做类似上面的替换，而实际中的内存布局依然是上面那样的。