Arthas 详解

Arthas 是 Alibaba 在 2018 年 9 月开源的 Java 诊断 工具。支持 JDK6+，采用命令行交互模式，可以方便的定位和诊断线上程序运行问题。Arthas 官方文档十分详细，详见：https://arthas.aliyun.com/doc/

Arthas 使用场景

提供全局视角查看系统的运行状况
监控 CPU 运行状态
监控线程运行状态
监测程序运行耗时
产科指定类从哪个 jar 包加载的
反编译线上环境代码，验证 commit 是否生效
遇到问题在线上 debug 无需通过加日志再重新发布
监控 JVM 的实时运行状态

Arthas 使用

下载

从 Maven 仓库下载

最新版本，点击下载：

1	wget https://arthas.aliyun.com/download/latest_version?mirror=aliyun -O arthas-packaging-bin.zip

从 Github Releases 页下载

https://github.com/alibaba/arthas/releases

启动

首先解压下载的压缩包

使用 as.sh 启动

在文件夹里有 as.sh，直接用./as.sh 的方式启动：

./as.sh

打印帮助信息：

1	./as.sh -h

用 arthas-boot 启动

在文件夹里有 arthas-boot.jar，直接用java -jar 的方式启动：

1	java -jar arthas-boot.jar

打印帮助信息：

1	java -jar arthas-boot.jar -h

下载离线文档

下载文档

使用示例

Arthas 测试程序，代码见下方

import java.util.HashSet;

public class ArthasDemo {

    private static HashSet hashSet = new HashSet();

    public static void main(String[] args) {
        // 模拟 CPU 过高
        cpuHigh();
        // 模拟线程死锁
        deadThread();
        // 不断的向 hashSet 集合增加数据
        addHashSetThread();
    }

    /**
     * 不断的向 hashSet 集合添加数据
     */
    public static void addHashSetThread() {
        // 初始化常量
        new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    hashSet.add("count" + count);
                    Thread.sleep(1000);
                    count++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    public static void cpuHigh() {
        new Thread(() -> {
            while (true) {

            }
        }).start();
    }

    /**
     * 死锁
     */
    private static void deadThread() {
        /** 创建资源 */
        Object resourceA = new Object();
        Object resourceB = new Object();
        // 创建线程
        Thread threadA = new Thread(() -> {
            synchronized (resourceA) {
                System.out.println(Thread.currentThread() + " get ResourceA");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resourceB");
                synchronized (resourceB) {
                    System.out.println(Thread.currentThread() + " get resourceB");
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (resourceB) {
                System.out.println(Thread.currentThread() + " get ResourceB");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resourceA");
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + " get resourceA");
                }
            }
        });
        threadA.start();
        threadB.start();
    }
}