一、简介

VisualVM 是一款免费的，集成了多个JDK命令行工具的可视化工具，它能为您提供强大的分析能力，对Java应用程序做 性能分析和调优 。这些功能包括 生成和分析海量数据、跟踪内存泄漏、监控垃圾回收器、执行内存和CPU分析。本文主要介绍如何使用VisualVM进行性能分析及调优。

自从JDK 6 Update 7 以后已经作为Oracle JDK的一部分，位于JDK根目录的bin文件夹下，无需安装，直接运行即可。

JDK路径查看：

MAC查找JDK的路径
Windows查找JDK的路径

二、内存分析

VisualVM通过检测JVM中加载的类和对象信息等帮助我们分析内存使用情况，我们可以通过VisualVM的监视标签对应用程序进行内存分析。

1、Heap堆

首先写一个内存堆占用较大的例子，代码如下：

public class Main {
    public final static int OUTOFMEMORY = 200000000;
    public static String oom;
       public static StringBuffer tempOOM = new StringBuffer();
    public static void main(String[] args){
        threadHeap(OUTOFMEMORY);
    }
    public static void threadHeap(final int len){
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while(i < len){
                    i++;
                    try{
                        tempOOM.append("abcdefghijabcdefghijabcdefghijabcdefghijabcdefghij");
                        if(i%1000 == 1){
                            Thread.sleep(10);
                        }
                        //Thread.sleep(1);
                    } catch (Exception e){
                        e.printStackTrace();
                        break;
                    } catch (Error e){
                        e.printStackTrace();
                        break;
                    }
                }
                oom = tempOOM.toString();
                System.out.println("Thread Heap Length : " + oom.length());
            }
        });
        t.setName("ThreadHeap_1");
        t.start();
    }
}

运行该段代码，然后查看VisualVM Monitor（监视）, 堆内存会慢慢变大。

在程序运行结束之前， 点击 堆Dump 按钮， 等待一会儿，得到dump结果，可以看到一些摘要信息。

点击类， 发现char[]所占用的内存是最大的。

双击 char[] ，得到如下实例数结果。

StringBuffer类型的全局变量 tempOOM 占用内存特别大， 注意局部变量是无法通过堆dump来得到分析结果的。

另外，对于 堆 dump 来说，在远程监控jvm的时候，VisualVM是没有这个功能的，只有本地监控的时候才有。

三、CPU分析

CPU 性能分析的主要目的是统计函数的调用情况及执行时间，或者更简单的情况就是统计应用程序的 CPU 使用情况。

没有程序运行时的 CPU 使用情况如下图：

运行一段 占用CPU 的小程序，代码如下：

public class Main {
    public static void main(String[] args){
        cpuFix();
    }
    public static void cpuFix(){
        try{
            // 80%的占有率
            int busyTime = 8;
            // 20%的占有率
            int idelTime = 2;
            // 开始时间
            long startTime = 0;
            while (true) {
                // 开始时间
                startTime = System.currentTimeMillis();
                /*
                 * 运行时间
                 */
                while (System.currentTimeMillis() - startTime < busyTime) {
                    ;
                }
                // 休息时间
                Thread.sleep(idelTime);
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

结果如下：

过高的 CPU 使用率可能是由于我们的项目中存在低效的代码；

在我们对程序施压的时候，过低的 CPU 使用率也有可能是程序的问题。

点击【抽样器】， 点击【CPU】按钮， 启动CPU性能分析会话，VisualVM 会检测应用程序所有的被调用的方法，在【CPU 样例】下可以看到我们的方法cpuFix() 的自用时间最长， 如下图：

切换到【线程 CPU 时间】页面下，我们的 main 函数这个进程占用CPU时间最长， 如下图：

四、线程分析

Java 语言能够很好的实现多线程应用程序。当我们对一个多线程应用程序进行调试或者开发后期做性能调优的时候，往往需要了解当前程序中所有线程的运行状态，是否有死锁、热锁等情况的发生，从而分析系统可能存在的问题。

在 VisualVM 的监视标签内，我们可以查看当前应用程序中所有实时线程（Live threads）和守护线程（Daemon threads）的数量等实时信息。

运行一段小程序，代码如下：

public class Main {
    public static void main(String[] args){
        startThread("Thread_1");
        startThread("Thread_2");
    }
    public static void startThread(String threadName){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                }
            }
        });
        thread.setName(threadName);
        thread.start();
    }
}

VisualVM 的线程标签提供了三种视图，默认会以时间线的方式展现， 如下图：

可以看到两个我们run的程序里启的线程：Thread_1 和 Thread_2。

再来一段死锁的程序，看VisualVM 能否分析出来：

public class Main {
    public static void main(String[] args){
        diethread();
    }
    public static void diethread(){
        DieThread d1=new DieThread(true);
        DieThread d2=new DieThread(false);
        final Thread t1 = new Thread(d1);
        final Thread t2 = new Thread(d2);
        t1.setName("DieThread_1");
        t2.setName("DieThread_2");
        t1.start();
        t2.start();
    }
}
package com.javaagent.thread;
public class DieThread implements Runnable {
    public static Object obj1=new Object();
    public static Object obj2=new Object();
    private boolean flag;
    public DieThread(boolean bl){
        flag = bl;
    }
    @Override
    public void run() {
        if(flag) {
            while(true) {
                synchronized(obj1) {
                    try {
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + "获取obj1锁对象，等待获取obj2锁对象...");
                    synchronized(obj2) {
                        System.out.println(Thread.currentThread().getName() + " ---- obj2.");
                    }
                }
            }
        }
        else {
            while(true){
                synchronized(obj2) {
                    System.out.println("线程" + Thread.currentThread().getName() + "获取obj2锁对象，等待获取obj1锁对象...");
                    synchronized(obj1) {
                        System.out.println(Thread.currentThread().getName() + " ---- obj1.");
                    }
                }
            }
        }
    }
}

打开VisualVM检测到的JVM进程，我们可以看到这个tab在闪，VisualVM已经检测到死锁。

另外可以点击【线程 Dump】线程转储，进一步分析。