service:jmx:rmi:///jndi/rmi://hostName:port/jmxrmi。JConsole为建立连接，需要在环境变量中设置mx.remote.credentials来指定用户名和密码，从而进行授权。
public class HeapInstanceTest {
byte [ ] bytes = new byte [ 1024 * 100 ] ;
public static void main ( String [ ] args) {
ArrayList < HeapInstanceTest > = new ArrayList < > ( ) ;
while ( true ) {
list. add ( new HeapInstanceTest ( ) ) ;
try {
Thread . sleep ( 10 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
}
}
}
-XX:NewRatio=2，所以新生代占200m内存空间
线程长时间停顿的原因： 等待外部资源（数据库连接、网络资源、设备资源等） 死循环、锁等待等
public class ThreadLoopTest {
public static void main ( String [ ] args) {
new Thread ( ( ) -> {
while ( true ) ;
} , "ThreadLoop" ) . start ( ) ;
}
}
public class ThreadLockWaitTest {
public static void main ( String [ ] args) {
Object obj = new Object ( ) ;
new Thread ( ( ) -> {
synchronized ( obj) {
try {
obj. wait ( ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
}
} , "ThreadLockWait" ) . start ( ) ;
}
}
线程处于正常的活锁等待中
public class ThreadDeadLock {
public static void main ( String [ ] args) {
Object A = new Object ( ) ;
Object B = new Object ( ) ;
new Thread ( ( ) -> {
synchronized ( A ) {
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - Lock A" ) ;
try {
sleep ( 1000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
synchronized ( B ) {
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - Lock B" ) ;
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - 操作..." ) ;
}
}
} , "ThreadDeadLock1" ) . start ( ) ;
new Thread ( ( ) -> {
synchronized ( B ) {
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - Lock B" ) ;
try {
sleep ( 500 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
synchronized ( A ) {
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - Lock A" ) ;
System . out. println ( new Date ( ) + "【" + Thread . currentThread ( ) . getName ( ) + "】 - 操作..." ) ;
}
}
} , "ThreadDeadLock2" ) . start ( ) ;
}
}
插件官网下载nbm包后 ，点击“工具 -> 已下载 -> 添加插件”，然后选择下载好的nbm包即可完成安装。独立安装的插件存储在VisualVM的根目录。
堆Dump
在监控Tab页面单击堆Dump
如果需要把堆转储快照保存或发送出去，就应在heapdump节点上右键选择“另存为”菜单，否则当VisualVM关闭时，生成的堆转储快照文件会被当作临时文件自动清理掉。
线程Dump
在线程Tab页面单击线程Dump
说明：生成与查看线程快照的方式与堆转储快照的操作一样
官方网站
public class BtraceTest {
public static void main ( String [ ] args) throws IOException {
BufferedReader reader = new BufferedReader ( new InputStreamReader ( System . in) ) ;
for ( int i = 0 ; i < 10 ; i++ ) {
reader. readLine ( ) ;
int a = ( int ) Math . round ( Math . random ( ) * 1000 ) ;
int b = ( int ) Math . round ( Math . random ( ) * 1000 ) ;
System . out. println ( add ( a, b) ) ;
}
}
public static int add ( int a, int b) {
return a + b;
}
}
reader.readLine()方法阻塞住，因此在应用程序中输入任意数字并按回车键，即可看到调试信息。
用于查找内存泄漏以及查看内存消耗情况。下载并使用MAT
-XX:+HeapDumpOnOutOfMemoryError：在程序发生OOM时，导出应用程序的当前堆快照 -XX:+HeapDumpBeforeFullGC：在程序发生FullGC之前，导出应用程序的当前堆快照 -XX:+HeapDumpAfterFullGC：在程序发生FullGC之后，导出应用程序的当前堆快照 -XX:HeapDumpPath=<filename.hprof>：指定dump文件的生成的位置（这个目录路径必须是已经创建好的，它不会自动创建目录路径），如果不指定该参数，则在当前目录下生成dump文件。
jps -l命令获取到进程id jmap -dump:format=b,file=d:\mat_dump\a.hprof jps查出的pid生成dump文件
public class OOMTest {
public static void main ( String [ ] args) {
ArrayList < Picture > = new ArrayList < > ( ) ;
while ( true ) {
try {
Thread . sleep ( 10 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
list. add ( new Picture ( 100 * 1024 ) ) ;
}
}
}
class Picture {
private byte [ ] pixels;
public Picture ( int length) {
this . pixels = new byte [ length] ;
}
}
通过此操作可以找到引用链，获取到对象的互相引用关系），选中局部变量右键->List objects
探秘HotSpot虚拟机对象与直接内存篇中【对象的内存布局】 只能通过对象A被直接或者间接访问到的所有对象的集合。当前深堆大小 = 当前对象的浅堆大小 + 对象中所包含对象的深堆大小
对象A支配对象B。如果对象A是离对象B最近的一个支配对象，则认为对象A为对象B的直接支配者。支配树是基于对象间的引用图所建立的，有以下性质：
public class Memoryleak {
static List list = new ArrayList ( ) ;
public void addList ( ) {
Object obj = new Object ( ) ;
list. add ( obj) ;
}
}
public static void main ( String [ ] args) {
try {
Connection conn = null ;
Class . forName ( "com.mysql.jdbc.Driver" ) ;
conn = DriverManager . getConnection ( "url" , "root" , "123456" ) ;
Statement st = conn. createStatement ( ) ;
ResultSet res = st. executeQuery ( "select * from users" ) ;
} catch ( Exception e) {
} finally {
}
}
public class UsingRandom {
private String mag;
public void receiveMsg ( ) {
readFromNet ( ) ;
saveMsg ( ) ;
}
}
public class ChangeHashCode1 {
public static void main ( String [ ] args) {
HashSet < Point > = new HashSet < > ( ) ;
Point p = new Point ( ) ;
p. setX ( 10 ) ;
sets. add ( p) ;
p. setX ( 20 ) ;
System . out. println ( "sets.remove = " + sets. remove ( p) ) ;
sets. add ( p) ;
System . out. println ( "sets size = " + sets. size ( ) ) ;
System . out. println ( sets) ;
}
}
class Point {
int x;
public int getX ( ) {
return x;
}
public void setX ( int x) {
this . x = x;
}
@Override
public int hashCode ( ) {
final int prime = 31 ;
int result = 1 ;
result = prime * result + x;
return result;
}
@Override
public boolean equals ( Object obj) {
if ( this == obj) return true ;
if ( obj == null ) return false ;
if ( getClass ( ) != obj. getClass ( ) ) return false ;
Point p = ( Point ) obj;
if ( x != p. x) return false ;
return true ;
}
@Override
public String toString ( ) {
return "Point{" +
"x=" + x +
'}' ;
}
}
public class MapTest {
static Map wMap = new WeakHashMap ( ) ;
static Map map = new HashMap ( ) ;
public static void main ( String [ ] args) {
init ( ) ;
testWeakHashMap ( ) ;
testHashMap ( ) ;
}
public static void init ( ) {
String ref1 = new String ( "obejct1" ) ;
String ref2 = new String ( "obejct2" ) ;
String ref3 = new String ( "obejct3" ) ;
String ref4 = new String ( "obejct4" ) ;
wMap. put ( ref1, "cacheObject1" ) ;
wMap. put ( ref2, "cacheObject2" ) ;
map. put ( ref3, "cacheObject3" ) ;
map. put ( ref4, "cacheObject4" ) ;
System . out. println ( "String引用ref1，ref2，ref3，ref4 消失" ) ;
}
public static void testWeakHashMap ( ) {
System . out. println ( "WeakHashMap GC之前" ) ;
for ( Object o : wMap. entrySet ( ) ) {
System . out. println ( o) ;
}
try {
System . gc ( ) ;
TimeUnit . SECONDS. sleep ( 5 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
System . out. println ( "WeakHashMap GC之后" ) ;
for ( Object o : wMap. entrySet ( ) ) {
System . out. println ( o) ;
}
}
public static void testHashMap ( ) {
System . out. println ( "HashMap GC之前" ) ;
for ( Object o : map. entrySet ( ) ) {
System . out. println ( o) ;
}
try {
System . gc ( ) ;
TimeUnit . SECONDS. sleep ( 5 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
System . out. println ( "HashMap GC之后" ) ;
for ( Object o : map. entrySet ( ) ) {
System . out. println ( o) ;
}
}
}
public class Stack {
private Object [ ] elements;
private int size = 0 ;
private static final int DEFAULT_INITIAL_CAPACITY = 16 ;
public Stack ( ) {
elements = new Object [ DEFAULT_INITIAL_CAPACITY] ;
}
public void push ( Object e) {
ensureCapacity ( ) ;
elements[ size++ ] = e;
}
public Object pop ( ) {
if ( size == 0 )
throw new EmptyStackException ( ) ;
Object result = elements[ -- size] ;
elements[ size] = null ;
return result;
}
private void ensureCapacity ( ) {
if ( elements. length == size)
elements = Arrays . copyOf ( elements, 2 * size + 1 ) ;
}
}
官网地址
注意：JProfiler本身没有指出数据的采集类型，这里的采集类型是针对方法调用的采集类型，因为JProfiler的绝大多数核心功能都依赖方法调用采集的数据，因此可以直接认为是JProfiler的数据采集类型，推荐使用Sampling方式。
main 方法或线程的run 方法。 从热点树中最深的节点开始，调用向上传递到顶层节点。
Object.wait() 或Thread.sleep() ， 在这种情况下，该线程状态称为"等待（Waiting）”。一个线程在试图获取Monitor时被阻塞， 例如在synchronized 代码块的边界处，则处于"阻塞（Blocking）"状态。最后，JProfiler增加了一个合成的"Net I/O"状态，用于跟踪线程等待网络数据的时间。 这对于分析服务器和数据库驱动程序很重要，因为该时间可能与性能分析有关，例如调查缓慢的SQL查询。
java.util.concurrent.locks 包中提供了实现更高级锁策略的类。该包中的锁不使用对象的Monitor，而是使用不同的本地实现。 java.util.concurrent.locks.Lock 实例，以及一个需要一定时间的等待或阻塞操作。 这些锁状态情况在Monitor历史视图中以表格的方式呈现，在锁状态历史图中以可视化的方式呈现。 锁状态历史图关注的是所有涉及的Monitor和线程的整体关系，而不是孤立的Monitor事件过程。 参与锁状态情况的线程和Monitor被涂成蓝色和灰色的矩形，如果它们是死锁的一部分，则被涂成红色。 黑色箭头表示Monitor的所有权，黄色箭头从等待的线程延伸到相关的Monitor， 而虚线的红色箭头则表示某个线程想要获取Monitor，并且当前正处于阻塞状态。 如果已经记录了CPU数据，则将鼠标悬停在阻塞或等待箭头上时，可以获得堆栈跟踪。 这些工具提示包含的超链接，可将你带到Monitor历史视图中的相应行。
public class JProfilerTest {
public static void main ( String [ ] args) {
while ( true ) {
ArrayList beanList = new ArrayList ( ) ;
for ( int i = 0 ; i < 500 ; i++ ) {
Info info = new Info ( ) ;
info. list. add ( new byte [ 1024 * 10 ] ) ;
beanList. add ( info) ;
}
try {
TimeUnit . MILLISECONDS. sleep ( 500 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
}
}
}
class Info {
int size = 10 ;
String desc = "Info" ;
static ArrayList list = new ArrayList ( ) ;
}
byte[]没有被回收，说明它存在问题。
static ArrayList list = new ArrayList();发现list是静态的，这不妥，因为我们的目的是while结束之后Info对象被回收，并且Info对象中的所有字段都被回收，但是list是静态的，那就是类的，众所周知，类变量随类而生，随类而灭，因此每次我们往list中添加值，都是往同一个list中添加值，这会造成list不断增大，并且不能回收，所以最终会导致OOM。
官方文档 、GitHub地址 Arthas可以帮助你解决：
arthas-boot.jar，然后再用java -jar方式启动 下载命令：curl -O https://arthas.aliyun.com/arthas-boot.jar java -jar启动arthas-boot.jar，第一次执行这个jar，会自动从服务上下载Arthas并安装，运行此命令会先检查是否有启动的Java进程，如果没有则无法运行这个jar
arthas-boot.jar，再java -jar启动
.开头的文件夹是隐藏的，可以通过ls -a命令来查看
rm -rf ~/.arthas/与rm -rf ~/logs/arthas java -jar arthas-boot.jar启动，还可以使用java -jar arthas-boot.jar PID启动，不过需要知道Java的进程ID（可以通过jps -l查看正在运行的Java程序的PID）java -jar arthas-boot.jar --telnet-port 端口号 -http-port -1java -jar arthas-boot.jar -h quit\exit：退出当前客户端 stop\shutdown：关闭Arthas服务端，并退出所有客户端
命令 说明 help 查看命令帮助信息 cat 打印文件内容，与Linux里的cat命令类似 echo 打印参数 grep 匹配查找 tee 复制标准输入到标准输出和指定的文件 pwd 返回当前的工作目录 cls 清空当前屏幕区域 session 查看当前会话的信息 reset 重置增强类，将被Arthas增强过的类全部还原，Arthas服务端关闭时会重置所有增强过的类 version 输出当前目标Java进程所加载的Arthas版本号 history 打印命令历史 quit 退出当前Arthas客户端，其他Arthas客户端不受影响 stop 关闭Arthas服务端，所有客户端退出 keymap Arthas快捷键列表及自定义快捷键
dashboard命令基本格式：dashboard -i 时间 -n 打印次数，每隔多少的时间间隔（默认5000ms）刷新实时数据共多少次 秒 分:秒
trace/watch/tt/redefine等命令后，可以看到JIT线程活动变得更频繁。因为JVM热更新class字节码时清除了此class相关的JIT编译结果，需要重新编译。 C1 CompilerThread0, C2 CompilerThread0 GC Thread0, G1 Young RemSet Sampling VM Periodic Task Thread, VM Thread, Service Thread
thread命令参数说明： 目前只支持找出synchronized关键字阻塞住的线程， 如果是java.util.concurrent.Lock，目前还不支持
heapdump命令 dump到指定文件：heapdump /tmp/dump.hprof 只dump存活对象：heapdump --live /tmp/dump.hprof 注意：如果直接使用heapdump命令，表示dump到临时文件
命令 说明 sc 查看JVM已加载的类信息 sm 查看已加载类的方法信息，只能看到由当前类所声明 (declaring) 的方法，父类则无法看到 jad 反编译指定已加载类的源码 mc 内存编译器，内存编译.java文件生成.class文件 retransform 加载外部的.class文件，retransform到JVM里 redefine 加载外部的.class文件，redefine到JVM里 dump dump已加载类的byte code到特定目录 classloader 查看classloader的继承树，urls，类加载信息，使用classloader去getResource，打印出所有查找到的resources的url。对于ResourceNotFoundException比较有用。
sc命令参数说明： /替换为.了 toString 输出 options disable-sub-class true开关
sm命令参数说明：
jad命令参数说明：
mc命令参数说明： 注意：编译生成.class文件之后，可以结合retransform、redefine命令实现热更新代码，mc命令有可能失败。如果编译失败可以在本地编译好.class文件，再上传到服务器 retransform、redefine命令的缺点： classloader命令参数说明：
注意：这些命令，都通过字节码增强技术来实现的，会在指定类的方法中插入一些切面来实现数据统计和观测，因此在线上、预发使用时，请尽量明确需要观测的类、方法以及条件，诊断结束要执行stop或将增强过的类执行reset命令
命令 说明 monitor 方法执行监控 watch 方法执行数据观测 trace 方法内部调用路径，并输出方法路径上的每个节点上耗时 stack 输出当前方法被调用的调用路径 tt 方法执行数据的时空隧道，记录下指定方法每次调用的入参和返回信息，并能对这些不同的时间下调用进行观测
monitor命令参数说明：对匹配class-pattern／method-pattern／condition-express的类、方法的调用进行监控，涉及方法的调用次数、执行时间、失败率等；是一个非实时返回命令 监控项 说明 timestamp 时间戳 class Java类 method 方法（构造方法、普通方法） total 调用次数 success 成功次数 fail 失败次数 rt 平均RT fail-rate 失败率
watch命令说明：观察到指定函数的调用情况。能观察到的范围为：返回值、抛出异常、入参，通过编写OGNL表达式进行对应变量的查看 {params, target, returnObj}，主要由OGNL 表达式组成 -b方法调用前，-e方法异常后，-s方法返回后，-f方法结束后 -b、-e、-s默认关闭，-f默认打开，当指定观察点被打开后，在相应事件点会对观察表达式进行求值并输出 方法入参和方法出参的区别，有可能在中间被修改导致前后不一致，除了-b事件点params代表方法入参外，其余事件都代表方法出参 -b时，由于观察事件点是在方法调用前，此时返回值或异常均不存在 location信息。location有三种可能值：AtEnter，AtExit，AtExceptionExit。对应方法入口，方法正常return，方法抛出异常。
trace命令说明：参数与watch命令类似 trace命令能主动搜索class-pattern／method-pattern对应的方法调用路径，渲染和统计整个调用链路上的所有性能开销和追踪调用链路。 trace能方便的帮助定位和发现因RT高而导致的性能问题缺陷，但其每次只能跟踪一级方法的调用链路。 trace在执行的过程中本身是会有一定的性能开销，在统计的报告中并未像JProfiler一样预先减去其自身的统计开销。所以这统计出来有些许的不准，渲染路径上调用的类、方法越多，性能偏差越大。但还是能让你看清一些事情的。
stack命令说明：参数与watch命令类似
tt命令说明： --replay-times指定调用次数，通过--replay-interval指定多次调用时间间隔（默认1000ms） 表格字段 字段解释 INDEX 时间片段记录编号，每一个编号代表着一次调用，后续tt还有很多命令都是基于此编号指定记录操作，非常重要。 TIMESTAMP 方法执行的本机时间，记录了这个时间片段所发生的本机时间 COST(ms) 方法执行的耗时 IS-RET 方法是否以正常返回的形式结束 IS-EXP 方法是否以抛异常的形式结束 OBJECT 执行对象的hashCode()，注意，曾经有人误认为是对象在JVM中的内存地址，但很遗憾他不是。但他能帮助你简单的标记当前执行方法的类实体 CLASS 执行的类名 METHOD 执行的方法名
880
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
