Arthas

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class MathGame {
    private static Random random = new Random();
    public int illegalArgumentCount = 0;

    public static void main(String[] args) throws InterruptedException {
        MathGame game = new MathGame();
        while (true) {
            game.run();
            TimeUnit.SECONDS.sleep(1);
        }
    }

    public void run() throws InterruptedException {
        try {
            int number = random.nextInt()/10000;
            List<Integer> primeFactors = primeFactors(number);
            print(number, primeFactors);
        } catch (Exception e) {
            System.out.println(String.format("illegalArgumentCount:%3d, ", illegalArgumentCount) + e.getMessage());
        }
    }
    
    public static void print(int number, List<Integer> primeFactors) {
        StringBuffer sb = new StringBuffer(number + "=");
        for (int factor : primeFactors) {
            sb.append(factor).append('*');
        }
        if (sb.charAt(sb.length() - 1) == '*') {
            sb.deleteCharAt(sb.length() - 1);
        }
        System.out.println(sb);
    }

    public List<Integer> primeFactors(int number) {
        if (number < 2) {
            illegalArgumentCount++;
            throw new IllegalArgumentException("number is: " + number + ", need >= 2");
        }
        List<Integer> result = new ArrayList<Integer>();
        int i = 2;
        while (i <= number) { 
            if (number % i == 0) {
                result.add(i);
                number = number / i;
                i = 2;
            } else {
                i++;
            }
        }
        return result;
    }
}

1

java -jar arthas-boot.jar

1

java -jar arthas-boot.jar --telnet-port 9998 --http-port -1

1

%HOMEPATH%/logs/arthas

1

options disable-sub-class true

1
2
3
4
5

//模糊搜索，demo包下所有的类
sc demo.*

//打印类的详细信息
sc -d demo.MathGame

1
2
3
4
5

//显示String类加载的方法
sm java.lang.String

//显示String中的toString方法详细信息
sm -d java.lang.String toString

1
2
3
4
5
6
7
8

//编译java.lang.String
jad java.lang.String

//反编绎时只显示源代码,默认情况下,反编译结果里会带有ClassLoader信息,通过--source-only选项,可以只打印源代码.方便和mc/redefine命令结合使用.
jad --source-only demo.MathGame > C:/Users/XiaLuoHun/Desktop/jad/MathGame.java
    
//反编译指定的函数
jad demo.MathGame main

1
2
3
4
5

//在内存中编译Hello.java为Hello.class
mc C:/Users/XiaLuoHun/Desktop/jad/MathGame.java

//可以通过-d命令指定输出目录
mc -d C:/Users/XiaLuoHun/Desktop/jad C:/Users/XiaLuoHun/Desktop/jad/MathGame.java

1
2

//使用redefine命令加载新的字节码
redefine C:/Users/XiaLuoHun/Desktop/jad/demo/MathGame.class

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class MathGame {

    public static void main(String[] args) throws InterruptedException {
        MathGame game = new MathGame();
        while (true) {
            game.run();
            TimeUnit.SECONDS.sleep(1);
            // 这个不生效，因为代码一直跑在 while里
            System.out.println("in loop");
        }
    }

    public void run() throws InterruptedException {
        // 这个生效，因为run()函数每次都可以完整结束
        System.out.println("call run()");
        try {
            int number = random.nextInt();
            List<Integer> primeFactors = primeFactors(number);
            print(number, primeFactors);
        } catch (Exception e) {
            System.out.println(String.format("illegalArgumentCount:%3d, ", illegalArgumentCount) + e.getMessage());
        }
    }
    
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

//加载指定的.class文件,然后解析出class name,再retransform jvm中已加载的对应的类
//每加载一个.class 文件,则会记录一个retransform entry
retransform C:/Users/XiaLuoHun/Desktop/jad/demo/MathGame.class
    
//查看retransform entry
retransform -l
    
//删除指定retransform entry
retransform -d 1

//删除所有retransform entry
retransform --deleteAll
    
//显式触发 retransform
retransform --classPattern demo.MathGame

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class MathGame {

    public static void main(String[] args) throws InterruptedException {
        MathGame game = new MathGame();
        while (true) {
            game.run();
            TimeUnit.SECONDS.sleep(1);
            // 这个不生效，因为代码一直跑在 while里
            System.out.println("in loop");
        }
    }

    public void run() throws InterruptedException {
        // 这个生效，因为run()函数每次都可以完整结束
        System.out.println("call run()");
        try {
            int number = random.nextInt();
            List<Integer> primeFactors = primeFactors(number);
            print(number, primeFactors);
        } catch (Exception e) {
            System.out.println(String.format("illegalArgumentCount:%3d, ", illegalArgumentCount) + e.getMessage());
        }
    }
    
}

1
2

//把demo包下所有的类的字节码文件保存到~/logs/arthas/classdump/目录下
dump demo.*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//默认按类加载器的类型查看统计信息
classloader

//按类加载器的实例查看统计信息，可以看到类加载的hashCode
classloader -l
    
//查看ClassLoader的继承树
classloader -t
    
//通过类加载器的hash，查看此类加载器实际所在的位置
classloader -c 798f84d5
    
//使用ClassLoader去查找类的class文件所在的位置
classloader -c 798f84d5 -r java/lang/String.class
    
//使用ClassLoader去加载类
classloader -c 798f84d5 --load java.lang.String

1
2

//过5秒监控一次，类demo.MathGame中primeFactors方法
monitor -c 5 demo.MathGame primeFactors

1
2
3

//观察demo.MathGame类中primeFactors方法出参和返回值,结果属性遍历深度为2
//params表示所有参数数组(因为不确定是几个参数)，returnObject表示返回值
watch demo.MathGame primeFactors "{params,returnObj}" -x 2

1
2

//观察方法入参,对比前一个例子,返回值为空(事件点为方法执行前,因此获取不到返回值)
watch demo.MathGame primeFactors "{params,returnObj}" -x 2 -b

1
2
3
4

//同时观察方法调用前和方法返回后,参数里-n 2,表示只执行两次
//这里输出结果中,第一次输出的是方法调用前的观察表达式的结果,第二次输出的是方法返回后的表达式的结果
//params表示参数,target表示执行方法的对象,returnObject表示返回值
watch demo.MathGame primeFactors "{params,target,returnObj}" -x 2 -b -s -n 2

1
2

//条件表达式的例子，输出第1参数小于的情况
watch demo.MathGame primeFactors "{params[0],target}" "params[0]<0"

1
2

//trace函数指定类的指定方法
trace demo.MathGame run

1
2

//如果方法调用的次数很多,那么可以用-n参数指定捕捉结果的次数.比如下面的例子里,捕捉到一次调用就退出命令
trace demo.MathGame run -n 1

1
2

//默认情况下,trace不会包含jdk里的函数调用,如果希望trace jdk里的函数,需要显式设置--skipJDKMethod false
trace --skipJDKMethod false demo.MathGame run

1
2

//获取primeFactors的调用路径
stack demo.MathGame primeFactors

1
2

//条件表达式来过滤，第0个参数的值小于0，-n表示获取2次
stack demo.MathGame primeFactors 'params[0]<0' -n 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//记录下当前方法的每次调用环境现场。
tt -t demo.MathGame primeFactors
    
//检索调用记录
tt -l

//筛选出primeFactors方法的调用信息
tt -s 'method.name=="primeFactors"'

//查看调用信息
//-i 参数后边跟着对应的INDEX编号查看到详细信息
tt -i 1002

//重做一次调用
//tt命令由于保存了当时调用的所有现场信息,所以我们可以自己主动对一个INDEX编号的时间片自主发起一次调用,从而解放你的沟通成本
//可以通过--replay-times指定调用次数,通过 `--replay-interval` 指定多次调用间隔(单位ms, 默认1000ms)
tt -i 1002 -p

1
2
3
4
5
6
7
8

//查看所有的options
options

//获取option的值
options json-format

//设置指定的option
options save-result true