使用VisualVM分析日志_Java

很多人没毕业前以为学编程，以为工作后就只是写代码。工作后才发现，写代码只是一少部分工作。

jmeter 压测、remote jvm debug - 远程调试、arex - 流量录制&回放、elk - 分布式日志、普罗米修斯监控、arthas、dump日志分析等，但凡一样不会，基本就会在某一个场景踩坑。小则是报警异常，大则是线上事故！

从互联网草蜢时代，到现在工作了这么多年，也是见证了很多程序员因为写bug毕业啦，即使不是被开除，往往重大的事故也会影响未来的绩效、加薪和晋升。这些事故按；照影响时长、影响用户量、造成的资损、解决的时长等，会被定级为 p0、p1、p2、p3 不同级别的事故。

所以，到目前有越来越多的辅助工具，来帮助研发提高代码交付质量，以及各类系统异常分析工具，提高问题排查效率。类似这样的系统、服务、组件，今天给大家分享一个关于 visualvm 的使用。

一、关于 visualvm

visualvm 是一款可视化 java 故障排除工具，集成了 jdk 命令行工具和轻量级性能分析功能。专为开发和生产环境设计。

下载：https://visualvm.github.io/download.html(opens new window)

接下来，结合 visualvm 做一些常用的案例，方便伙伴学习。

二、案例 - 分析大对象

1. 测试工程

说明：这是一个简单的测试工程，通过访问接口产生大对象。之后在通过 jmapdumpcontroller 接口，执行命令，产生 dump 文件。之后在使用 visualvm 分析产生的 dump 日志，定位是哪个对象导致的问题。

2. 执行程序

首先，启动应用程序。之后执行 visualvm-test.sh 脚本，windows 用户需要在 powershell 里执行，mac 电脑可以直接在 intellij idea 点击绿色箭头执行。

首先，点击启动程序，本地运行即可。一般公司里线上的应用，也有专门下载 dump 日志的地方。
之后，执行 ./visualvm-test.sh 这部分写了测试程序的脚本和获取 dump 日志的操作。

2.1 接口；创建对象

@restcontroller
@requestmapping("/api/memory")
public class memorytestcontroller {

    // 用于存储大对象的静态变量，模拟内存泄漏
    private static final map<string, object> memory_cache = new concurrenthashmap<>();
    private static final list<byte[]> big_objects = new arraylist<>();

    /**
     * 大对象接口 - 创建大量对象占用内存
     */
    @getmapping("/big-object")
    public map<string, object> bigobjectapi() {
        // 创建大对象（10mb的字节数组）
        byte[] bigdata = new byte[10 * 1024 * 1024]; // 10mb
        for (int i = 0; i < bigdata.length; i++) {
            bigdata[i] = (byte) (i % 256);
        }
        
        // 将大对象存储到静态集合中，模拟内存泄漏
        big_objects.add(bigdata);
        
        map<string, object> result = new hashmap<>();
        result.put("status", "success");
        result.put("message", "创建了一个大对象（10mb）");
        result.put("timestamp", system.currenttimemillis());
        result.put("bigobjectscount", big_objects.size());
        result.put("totalmemoryused", big_objects.size() * 10 + "mb");
        
        return result;
    }

    /**
     * 内存泄漏接口 - 持续创建对象并缓存
     */
    @getmapping("/memory-leak")
    public map<string, object> memoryleakapi() {
        string key = "data_" + system.currenttimemillis();
        
        // 创建大量小对象并缓存
        list<string> datalist = new arraylist<>();
        for (int i = 0; i < 10000; i++) {
            datalist.add("这是第" + i + "个数据对象，包含一些文本内容用于占用内存空间");
        }
        
        memory_cache.put(key, datalist);
        
        map<string, object> result = new hashmap<>();
        result.put("status", "success");
        result.put("message", "创建了10000个小对象并缓存");
        result.put("timestamp", system.currenttimemillis());
        result.put("cachesize", memory_cache.size());
        result.put("cachekey", key);
        
        return result;
    }

    /**
     * 超大对象接口 - 创建超大对象
     */
    @getmapping("/huge-object")
    public map<string, object> hugeobjectapi() {
        // 创建超大对象（100mb的字节数组）
        byte[] hugedata = new byte[100 * 1024 * 1024]; // 100mb
        
        // 填充数据
        for (int i = 0; i < hugedata.length; i++) {
            hugedata[i] = (byte) (math.random() * 256);
        }
        
        big_objects.add(hugedata);
        
        map<string, object> result = new hashmap<>();
        result.put("status", "success");
        result.put("message", "创建了一个超大对象（100mb）");
        result.put("timestamp", system.currenttimemillis());
        result.put("bigobjectscount", big_objects.size());
        
        return result;
    }

}

2.2 接口；获取日志（dump）

@restcontroller
@requestmapping("/api/jmap")
public class jmapdumpcontroller {

    // 使用相对路径，基于项目根目录
    private static final string dump_dir = "docs/dump";

    /**
     * 获取绝对路径的dump目录
     */
    private string getdumpdirectory() {
        // 获取项目根目录
        string userdir = system.getproperty("user.dir");
        // 如果当前目录是xfg-dev-tech-app，则需要回到上级目录
        if (userdir.endswith("xfg-dev-tech-app")) {
            userdir = new file(userdir).getparent();
        }
        return userdir + file.separator + dump_dir;
    }

    /**
     * 生成堆转储文件
     */
    @getmapping("/dump")
    public map<string, object> generateheapdump() {
        map<string, object> result = new hashmap<>();
        
        try {
            // 获取dump目录的绝对路径
            string dumpdir = getdumpdirectory();
            
            // 确保目录存在
            file dir = new file(dumpdir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            
            // 获取当前进程的pid
            string pid = managementfactory.getruntimemxbean().getname().split("@")[0];
            
            // 生成文件名（包含时间戳）
            simpledateformat sdf = new simpledateformat("yyyymmdd_hhmmss");
            string timestamp = sdf.format(new date());
            string filename = "heap_dump_" + timestamp + ".hprof";
            string filepath = dumpdir + file.separator + filename;
            
            // 执行jmap命令生成堆转储
            string command = "jmap -dump:format=b,file=" + filepath + " " + pid;
            process process = runtime.getruntime().exec(command);
            int exitcode = process.waitfor();
            
            if (exitcode == 0) {
                result.put("status", "success");
                result.put("message", "堆转储文件生成成功");
                result.put("filepath", filepath);
                result.put("filename", filename);
            } else {
                result.put("status", "error");
                result.put("message", "堆转储文件生成失败");
                result.put("exitcode", exitcode);
            }
            
        } catch (ioexception | interruptedexception e) {
            result.put("status", "error");
            result.put("message", "生成堆转储文件时发生异常: " + e.getmessage());
        }
        
        result.put("timestamp", system.currenttimemillis());
        return result;
    }

}

2.3 脚本；统一执行

#!/bin/bash

# visualvm 内存测试自动化脚本
# 作者: xiaofuge
# 用途: 自动化测试内存接口并生成dump文件

# 配置参数
base_url="http://localhost:8091"
dump_dir="../dump"
log_file="$dump_dir/test_log_$(date +%y%m%d_%h%m%s).txt"

# 颜色输出
red='\033[0;31m'
green='\033[0;32m'
yellow='\033[1;33m'
blue='\033[0;34m'
nc='\033[0m' # no color

# 日志函数
log() {
    echo "[$(date '+%y-%m-%d %h:%m:%s')] $1" | tee -a "$log_file"
}

log_info() {
    echo -e "${blue}[info]${nc} $1" | tee -a "$log_file"
}

log_success() {
    echo -e "${green}[success]${nc} $1" | tee -a "$log_file"
}

log_warning() {
    echo -e "${yellow}[warning]${nc} $1" | tee -a "$log_file"
}

log_error() {
    echo -e "${red}[error]${nc} $1" | tee -a "$log_file"
}

# 检查应用是否启动
check_app_status() {
    log_info "检查应用状态..."
    response=$(curl -s -o /dev/null -w "%{http_code}" "$base_url/api/memory/status")
    if [ "$response" = "200" ]; then
        log_success "应用已启动，状态正常"
        return 0
    else
        log_error "应用未启动或状态异常 (http: $response)"
        return 1
    fi
}

# 等待应用启动
wait_for_app() {
    log_info "等待应用启动..."
    for i in {1..30}; do
        if check_app_status > /dev/null 2>&1; then
            log_success "应用启动成功"
            return 0
        fi
        log_info "等待中... ($i/30)"
        sleep 2
    done
    log_error "应用启动超时"
    return 1
}

# 调用api接口
call_api() {
    local endpoint=$1
    local description=$2
    local count=${3:-1}
    
    log_info "调用接口: $description"
    for ((i=1; i<=count; i++)); do
        response=$(curl -s "$base_url$endpoint")
        status=$(echo "$response" | grep -o '"status":"[^"]*"' | cut -d'"' -f4)
        if [ "$status" = "success" ]; then
            log_success "[$i/$count] $description - 成功"
        else
            log_error "[$i/$count] $description - 失败: $response"
        fi
        sleep 1
    done
}

# 显示内存状态
show_memory_status() {
    log_info "获取内存状态..."
    response=$(curl -s "$base_url/api/memory/status")
    echo "$response" | python3 -m json.tool 2>/dev/null || echo "$response"
    echo ""
}

# 生成dump文件
generate_dump() {
    log_info "生成堆转储文件..."
    response=$(curl -s "$base_url/api/jmap/dump")
    status=$(echo "$response" | grep -o '"status":"[^"]*"' | cut -d'"' -f4)
    if [ "$status" = "success" ]; then
        filename=$(echo "$response" | grep -o '"filename":"[^"]*"' | cut -d'"' -f4)
        log_success "堆转储文件生成成功: $filename"
    else
        log_error "堆转储文件生成失败: $response"
    fi
}

# 生成内存信息文件
generate_memory_info() {
    log_info "生成内存信息文件..."
    response=$(curl -s "$base_url/api/jmap/memory-info")
    status=$(echo "$response" | grep -o '"status":"[^"]*"' | cut -d'"' -f4)
    if [ "$status" = "success" ]; then
        filename=$(echo "$response" | grep -o '"filename":"[^"]*"' | cut -d'"' -f4)
        log_success "内存信息文件生成成功: $filename"
    else
        log_error "内存信息文件生成失败: $response"
    fi
}

# 清理缓存
clear_cache() {
    log_info "清理缓存..."
    response=$(curl -s "$base_url/api/memory/clear-cache")
    status=$(echo "$response" | grep -o '"status":"[^"]*"' | cut -d'"' -f4)
    if [ "$status" = "success" ]; then
        log_success "缓存清理成功"
    else
        log_error "缓存清理失败: $response"
    fi
}

# 主测试流程
run_test() {
    log_info "开始visualvm内存测试"
    
    # 检查dump目录
    if [ ! -d "$dump_dir" ]; then
        log_info "创建dump目录: $dump_dir"
        mkdir -p "$dump_dir"
    fi
    
    # 等待应用启动
    if ! wait_for_app; then
        log_error "应用启动失败，退出测试"
        exit 1
    fi
    
    # 显示初始内存状态
    log_info "=== 初始内存状态 ==="
    show_memory_status
    
    # 测试普通接口
    call_api "/api/memory/normal" "普通接口测试" 5
    
    # 显示内存状态
    log_info "=== 普通接口调用后内存状态 ==="
    show_memory_status
    
    # 测试大对象接口
    call_api "/api/memory/big-object" "大对象接口测试" 10
    
    # 显示内存状态
    log_info "=== 大对象创建后内存状态 ==="
    show_memory_status
    
    # 生成第一次dump
    generate_dump
    generate_memory_info
    
    # 测试内存泄漏接口
    call_api "/api/memory/memory-leak" "内存泄漏接口测试" 20
    
    # 显示内存状态
    log_info "=== 内存泄漏测试后内存状态 ==="
    show_memory_status
    
    # 测试超大对象接口
    call_api "/api/memory/huge-object" "超大对象接口测试" 5
    
    # 显示内存状态
    log_info "=== 超大对象创建后内存状态 ==="
    show_memory_status
    
    # 生成第二次dump
    generate_dump
    generate_memory_info
    
    # 清理缓存
    clear_cache
    
    # 显示清理后内存状态
    log_info "=== 缓存清理后内存状态 ==="
    show_memory_status
    
    # 生成第三次dump
    generate_dump
    generate_memory_info
    
    log_success "visualvm内存测试完成"
    log_info "日志文件: $log_file"
    log_info "dump文件目录: $dump_dir"
}

# 显示帮助信息
show_help() {
    echo "visualvm 内存测试脚本"
    echo ""
    echo "用法: $0 [选项]"
    echo ""
    echo "选项:"
    echo "  test          运行完整测试流程"
    echo "  check         检查应用状态"
    echo "  status        显示内存状态"
    echo "  dump          生成堆转储文件"
    echo "  memory-info   生成内存信息文件"
    echo "  clear         清理缓存"
    echo "  help          显示帮助信息"
    echo ""
    echo "示例:"
    echo "  $0 test       # 运行完整测试"
    echo "  $0 check      # 检查应用状态"
    echo "  $0 dump       # 生成dump文件"
}

# 主程序
case "${1:-test}" in
    "test")
        run_test
        ;;
    "check")
        check_app_status
        ;;
    "status")
        show_memory_status
        ;;
    "dump")
        generate_dump
        ;;
    "memory-info")
        generate_memory_info
        ;;
    "clear")
        clear_cache
        ;;
    "help")
        show_help
        ;;
    *)
        log_error "未知选项: $1"
        show_help
        exit 1
        ;;
esac