吃透 JVisualVM 与 JConsole：Java 性能调优实战指南

java -jar \
-Djava.rmi.server.hostname=192.168.1.100 \  # 服务器IP地址
-Dcom.sun.management.jmxremote \             # 开启JMX远程监控
-Dcom.sun.management.jmxremote.port=8888 \   # JMX监听端口（自定义，需开放防火墙）
-Dcom.sun.management.jmxremote.ssl=false \   # 关闭SSL（生产环境建议开启，需配置证书）
-Dcom.sun.management.jmxremote.authenticate=false \  # 关闭身份验证（生产环境建议开启，配置用户名密码）
demo.jar

-Dcom.sun.management.jmxremote.authenticate=true \
-Dcom.sun.management.jmxremote.password.file=jmxremote.password \  # 密码文件路径
-Dcom.sun.management.jmxremote.access.file=jmxremote.access \      # 权限文件路径

chmod 600 jmxremote.access jmxremote.password

package com.jam.demo.jconsole;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.v3.oas.annotations.Api;
import io.swagger.v3.oas.annotations.Operation;

/**
 * 线程死锁演示案例
 * @author ken
 */
@RestController
@RequestMapping("/deadlock")
@Api(tags = "线程死锁演示接口")
@Slf4j
publicclass DeadlockDemoController {

    // 定义两个锁对象
    privatestaticfinal Object LOCK_A = new Object();
    privatestaticfinal Object LOCK_B = new Object();

    /**
     * 触发死锁
     */
    @GetMapping("/trigger")
    @Operation(summary = "触发线程死锁", description = "启动两个线程，互相持有对方所需的锁，导致死锁")
    public String triggerDeadlock() {
        // 线程1：先获取LOCK_A，再尝试获取LOCK_B
        new Thread(() -> {
            synchronized (LOCK_A) {
                log.info("线程1：已获取LOCK_A，准备获取LOCK_B");
                try {
                    // 模拟业务耗时，让线程2有机会获取LOCK_B
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    log.error("线程1睡眠被中断", e);
                    Thread.currentThread().interrupt();
                }
                synchronized (LOCK_B) {
                    log.info("线程1：已获取LOCK_B");
                }
            }
        }, "Thread-Deadlock-1").start();

        // 线程2：先获取LOCK_B，再尝试获取LOCK_A
        new Thread(() -> {
            synchronized (LOCK_B) {
                log.info("线程2：已获取LOCK_B，准备获取LOCK_A");
                try {
                    // 模拟业务耗时，让线程1有机会获取LOCK_A
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    log.error("线程2睡眠被中断", e);
                    Thread.currentThread().interrupt();
                }
                synchronized (LOCK_A) {
                    log.info("线程2：已获取LOCK_A");
                }
            }
        }, "Thread-Deadlock-2").start();

        return"已启动两个线程，大概率已触发死锁，请通过JConsole排查";
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version>
        <relativePath/>
    </parent>

    <groupId>com.jam.demo</groupId>
    <artifactId>jvm-tuning-demo</artifactId>
    <version>1.0.0</version>
    <name>jvm-tuning-demo</name>
    <description>JVM调优工具实战演示项目</description>

    <properties>
        <java.version>17</java.version>
        <fastjson2.version>2.0.47</fastjson2.version>
        <mybatis-plus.version>3.5.5</mybatis-plus.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
            <scope>provided</scope>
        </dependency>

        <!-- Swagger3 -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>2.2.0</version>
        </dependency>

        <!-- FastJSON2 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>

        <!-- MyBatis-Plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!-- MySQL Driver -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- Spring Boot Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

// 线程1：顺序不变，先LOCK_A再LOCK_B
// 线程2：修改顺序，先LOCK_A再LOCK_B
new Thread(() -> {
    synchronized (LOCK_A) {
        log.info("线程2：已获取LOCK_A，准备获取LOCK_B");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            log.error("线程2睡眠被中断", e);
            Thread.currentThread().interrupt();
        }
        synchronized (LOCK_B) {
            log.info("线程2：已获取LOCK_B");
        }
    }
}, "Thread-Deadlock-2").start();

package com.jam.demo.jvisualvm;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.v3.oas.annotations.Api;
import io.swagger.v3.oas.annotations.Operation;

import java.util.ArrayList;
import java.util.List;

/**
 * CPU过高问题演示案例
 * @author ken
 */
@RestController
@RequestMapping("/cpu")
@Api(tags = "CPU过高演示接口")
@Slf4j
publicclass HighCpuDemoController {

    /**
     * 触发CPU过高（无限循环+大量字符串拼接）
     */
    @GetMapping("/high")
    @Operation(summary = "触发CPU过高", description = "通过无限循环和非高效字符串拼接，导致CPU使用率飙升")
    public String highCpu() {
        log.info("开始执行CPU过高的任务");
        // 无限循环，持续消耗CPU
        while (true) {
            // 非高效字符串拼接（创建大量临时对象，且消耗CPU）
            String str = "";
            for (int i = 0; i < 1000; i++) {
                str += "cpu-high-" + i;
            }
            // 模拟业务逻辑，避免代码被编译器优化掉
            if (str.length() > 0) {
                continue;
            }
        }
    }

    /**
     * 正常业务方法（对比用）
     */
    @GetMapping("/normal")
    @Operation(summary = "正常业务方法", description = "普通的列表查询业务，CPU使用率正常")
    public List<String> normal() {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            result.add("normal-data-" + i);
        }
        log.info("正常业务方法执行完成，返回数据量：{}", result.size());
        return result;
    }
}

@GetMapping("/high")
@Operation(summary = "触发CPU过高（优化后）", description = "修复无限循环，使用StringBuilder优化字符串拼接")
public String highCpuOptimized() {
    log.info("开始执行优化后的CPU任务");
    // 移除无限循环，添加退出条件
    int count = 0;
    while (count < 1000) {
        // 使用StringBuilder优化字符串拼接
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("cpu-high-").append(i);
        }
        if (sb.length() > 0) {
            count++;
        }
    }
    log.info("CPU任务执行完成");
    return"CPU任务执行完成";
}

package com.jam.demo.jvisualvm;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.v3.oas.annotations.Api;
import io.swagger.v3.oas.annotations.Operation;

import java.util.ArrayList;
import java.util.List;

/**
 * 内存泄漏演示案例（静态集合持有对象引用）
 * @author ken
 */
@RestController
@RequestMapping("/memory")
@Api(tags = "内存泄漏演示接口")
@Slf4j
publicclass MemoryLeakDemoController {

    // 静态集合（GC Roots之一），持有User对象引用
    privatestaticfinal List<User> USER_CACHE = new ArrayList<>();

    /**
     * 添加用户到静态集合（不释放）
     */
    @GetMapping("/addUser")
    @Operation(summary = "添加用户到静态缓存", description = "将用户对象添加到静态集合，不进行移除，导致内存泄漏")
    public String addUser(String name, Integer age) {
        // 每次调用创建新的User对象，添加到静态集合
        User user = new User(name, age);
        USER_CACHE.add(user);
        log.info("添加用户成功，当前缓存用户数：{}", USER_CACHE.size());
        return"添加用户成功，当前缓存用户数：" + USER_CACHE.size();
    }

    /**
     * 查看缓存用户数
     */
    @GetMapping("/getUserCount")
    @Operation(summary = "获取缓存用户数", description = "查看静态集合中的用户数量")
    public String getUserCount() {
        return"当前缓存用户数：" + USER_CACHE.size();
    }

    // 内部类User
    staticclass User {
        private String name;
        private Integer age;

        public User(String name, Integer age) {
            this.name = name;
            this.age = age;
        }

        // getter/setter省略
    }
}

// 改用WeakReference的List，避免强引用
privatestaticfinal List<WeakReference<User>> USER_CACHE = new ArrayList<>();

/**
 * 添加用户到静态集合（优化后，使用弱引用）
 */
@GetMapping("/addUserOptimized")
@Operation(summary = "添加用户到静态缓存（优化后）", description = "使用弱引用持有用户对象，避免内存泄漏")
public String addUserOptimized(String name, Integer age) {
    User user = new User(name, age);
    // 用WeakReference包裹User对象
    WeakReference<User> weakUser = new WeakReference<>(user);
    USER_CACHE.add(weakUser);
    // 清理已被GC回收的弱引用
    USER_CACHE.removeIf(ref -> ref.get() == null);
    log.info("添加用户成功，当前缓存用户数（含已回收）：{}", USER_CACHE.size());
    return"添加用户成功，当前缓存用户数（含已回收）：" + USER_CACHE.size();
}

/**
 * 向Redis设置值（存在性能问题）
 * @param key 键
 * @param value 值
 * @param expire 过期时间（秒）
 */
public void set(String key, Object value, long expire) {
    // 问题1：每次都创建新的ObjectMapper对象，序列化效率低
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        String jsonValue = objectMapper.writeValueAsString(value);
        // 问题2：未使用Redis连接池，每次都创建新的连接
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.setex(key, expire, jsonValue);
        jedis.close();
    } catch (JsonProcessingException e) {
        log.error("Redis序列化失败", e);
    }
}

// 静态Map缓存订单信息，无过期清理
private static final Map<String, JSONObject> ORDER_CACHE = new HashMap<>();

/**
 * 创建订单时缓存订单信息
 */
public OrderDTO createOrder(OrderCreateDTO createDTO) {
    // 业务逻辑：创建订单、扣减库存、生成支付信息...
    OrderDTO orderDTO = orderMapper.insertOrder(createDTO);
    // 缓存订单信息（无过期清理）
    JSONObject orderJson = JSONObject.from(getOrderDetail(orderDTO.getId()));
    ORDER_CACHE.put(orderDTO.getId(), orderJson);
    return orderDTO;
}

package com.jam.demo.util;

import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类（优化后）
 * @author ken
 */
@Component
@Slf4j
publicclass RedisUtil {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 向Redis设置值（优化后：复用连接池，使用fastjson2序列化）
     * @param key 键
     * @param value 值
     * @param expire 过期时间（秒）
     */
    public void set(String key, Object value, long expire) {
        try {
            // 使用fastjson2序列化，避免重复创建ObjectMapper
            String jsonValue = JSONObject.toJSONString(value);
            // 使用StringRedisTemplate（底层使用连接池）
            stringRedisTemplate.opsForValue().set(key, jsonValue, expire, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error("Redis设置值失败，key：{}", key, e);
        }
    }
}

// 替换为Guava Cache，设置过期时间和最大容量
privatestaticfinal LoadingCache<String, JSONObject> ORDER_CACHE = CacheBuilder.newBuilder()
        .expireAfterWrite(30, TimeUnit.MINUTES)  // 30分钟过期
        .maximumSize(10000)  // 最大缓存1万个订单
        .build(new CacheLoader<>() {
            @Override
            public JSONObject load(String orderId) {
                // 缓存未命中时，从数据库查询
                return JSONObject.from(getOrderDetail(orderId));
            }
        });

/**
 * 创建订单时缓存订单信息（优化后）
 */
public OrderDTO createOrder(OrderCreateDTO createDTO) {
    OrderDTO orderDTO = orderMapper.insertOrder(createDTO);
    // 缓存订单信息（自动过期）
    JSONObject orderJson = JSONObject.from(getOrderDetail(orderDTO.getId()));
    ORDER_CACHE.put(orderDTO.getId(), orderJson);
    return orderDTO;
}