田野放空

ID: Java-level thread ID, note that this ID does not correspond one-to-one with the nativeID in jstack.
NAME: Thread name
GROUP: Thread group name
PRIORITY: Thread priority, a number between 1 and 10, with a higher number indicating a higher priority. setPriority(1-10)
STATE: Thread state
CPU%: Thread CPU usage. For example, if the sampling interval is 1000ms and a certain thread's incremental CPU time is 100ms, then CPU usage = 100/1000 = 10%
DELTA_TIME: Incremental CPU time the thread has run since the last sample, data format is seconds.
TIME: Total CPU time the thread has run, data format is minutes:seconds.
INTERRUPTED: Current interrupt status of the thread.
DAEMON: Whether it is a daemon thread.

C1 C2 CompilerThread:
Garbage collection count gc.ps_scavenge.count, garbage collection time gc.ps_scavenge.time, mark-sweep algorithm count gc.ps_marksweep.count, mark-sweep algorithm time.

View the threads with the highest CPU usage.  
1. thread / thread -n 3
2. thread id

1. The method is called in a loop.
2. There is an internal infinite loop.

We use the tt command to listen to the call situation of this method.
tt -t com.xx.xx.controller.ArthasController deadAdd -n 5 
When executing this command online, be sure to remember to add the -n parameter; otherwise, the huge traffic online may instantly overwhelm your JVM memory.

Decompile the method to see.
jad --source-only com.xx.xx.controller.ArthasController deadAdd


top --> top -Hp pid --> jstack pid 16 hexadecimal

dashboard View GC data.
 gc.ps_scavenge.count      gc.ps_marksweep.count  

Use the vmoption command to dynamically enable GC logs.
vmoption PrintGC true
vmoption PrintGCDetails true

Use vmtool to force GC.
vmtool --action forceGc
https://www.v2ex.com/t/792635

logger
By default, the logger command will execute under SystemClassloader. If the application is a traditional war application or a spring boot fat jar application, you need to specify the classloader.
 logger -c 685f4c2e  --name ROOT --level debug

jad --source-only com.xx.xx.controller.AutoCutController preprocessing

    monitor: This command is used to monitor the execution status of methods, including the number of calls, successful calls, failed calls, maximum time spent, minimum time spent, and average time spent. It is usually used to locate performance issues.
[arthas@19702]$ monitor com.xx.xx.service.impl.WjVideoServiceImpl preprocessingVideo  -n 10  --cycle 10
Press Q or Ctrl+C to abort.
Affect(class count: 1 , method count: 1) cost in 49 ms, listenerId: 3
 timestamp         class                     method                    total    success  fail    avg-rt(  fail-ra
                                                                                                 ms)      te
------------------------------------------------------------------------------------------------------------------
 2023-07-17 16:21  com.xx.xx.service.  preprocessingVideo        1        1        0       3755.98  0.00%
 :14               impl.WjVideoServiceImpl

 
 
    trace: This command is used to trace the call path and time spent of methods. It records the input parameters and return results of methods, as well as other methods called internally and their execution times.
 [arthas@19702]$  trace -E com.xx.xx.service.impl.VideoServiceImpl|com.xx.xx.controller.AutoCutController|com.xx.xx.service.impl.WjVideoServiceImpl preprocessing|preprocessingVideo -n 5  --skipJDKMethod false '1==1'
Press Q or Ctrl+C to abort.
Affect(class count: 4 , method count: 4) cost in 157 ms, listenerId: 2
`---ts=2023-07-17 16:20:42;thread_name=http-nio-8183-exec-8;id=2b;is_daemon=true;priority=5;TCCL=org.springframework.boot.web.embedded.tomcat.TomcatEmbeddedWebappClassLoader@3576ddc2
    `---[1.069325ms] com.xx.xx.controller.AutoCutController$$EnhancerBySpringCGLIB$$333516af:preprocessing()
        `---[83.17% 0.889312ms ] org.springframework.cglib.proxy.MethodInterceptor:intercept()
            `---[43.36% 0.385619ms ] com.xx.xx.controller.AutoCutController:preprocessing()
                +---[6.45% 0.024868ms ] org.slf4j.MDC:get() #31
                +---[1.90% 0.007333ms ] com.xx.xx.common.vo.ProcessingVO:setTaskId() #31
                +---[70.24% 0.270861ms ] com.xx.xx.service.VideoService:preprocessingVideo() #32
                `---[2.93% 0.011295ms ] com.xx.xx.base.model.Result:success() #33


    tt: This command is used to record the historical call situation of methods, including input parameters, return results, and exception information. It can not only view the current call situation of methods but also view historical call situations and retry historical calls.
[arthas@19702]$ tt -t com.kscs.capcut.controller.AutoCutController preprocessing -n 5
Press Q or Ctrl+C to abort.
Affect(class count: 2 , method count: 2) cost in 39 ms, listenerId: 4
 INDEX  TIMESTAMP         COST(ms  IS-RE  IS-EX  OBJECT       CLASS                     METHOD
                          )        T      P
------------------------------------------------------------------------------------------------------------------
 1000   2023-07-17 16:23  0.20207  true   false  0x5ec8b24c   AutoCutController         preprocessing
        :17               4
 1001   2023-07-17 16:23  1.94166  true   false  0xe637be2a   AutoCutController$$Enhan  preprocessing
        :17               4                                   cerBySpringCGLIB$$333516
                                                              af

1. Decompile the source code of the loaded class.
jad --source-only com.kscs.capcut.controller.ArthasController 

2. Modify the local code and compile/test. After passing, find the compiled .class file in the target directory.
3. Hot update.
retransform /Users/edy/IdeaProjects/ArthasController.class
2. View retransform entries.
    retransform -l 
3. Delete retransform entities:
    retransform -d 1
    retransform --deleteAll

When executing commands like trace/watch/tt/monitor in Arthas, it essentially inserts code before and after the method, which invalidates the code originally generated by JIT compilation in the JVM, requiring a rollback to the original code and re-JIT compilation. Therefore, high concurrency function calls may cause jitter.
Thus, it is advisable to avoid tracing/watching a large number of classes at once.
It is recommended to select a machine with low load in the cluster for analysis in online environments. If there is only one machine, use it with caution.

public class ArthasController {
    public static boolean flag = true;
    private List<ProcessingVO> stringList = new ArrayList<>();

    @RequestMapping(method = RequestMethod.POST, value = "flag")
    public Result<Map<String, String>> flag(Integer param1, Integer param2) {
        flag = !flag;
        return Result.success();
    }

    @RequestMapping(method = RequestMethod.POST, value = "oom")
    public Result<List<ProcessingVO>> oom() {
        stringList.clear();
        for (int i = 0; i < 1000000; i++) {
            if (stringList.size() > 500000) {
                continue;
            }
            ProcessingVO vo = new ProcessingVO();
            vo.setVideoName("videoName" + i);
            vo.setTaskId("taskId" + i);
            stringList.add(vo);
        }
        return Result.success();
    }

    @RequestMapping(method = RequestMethod.POST, value = "deadLock")
    public Result<Map<String, String>> deadLock() {
        Thread thread1 = new Thread(() -> {
            synchronized (String.class) {
                log.info("thread1 get String lock");
                try {
                    Thread.sleep(10000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (Integer.class) {
                    log.info("thread1 get Integer lock");
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (Integer.class) {
                log.info("thread2 get Integer lock");
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (String.class) {
                    log.info("thread2 get String lock");
                }
            }
        });
        thread1.setName("deadlock-thread1");
        thread2.setName("deadlock-thread2");
        thread1.start();
        thread2.start();
        return Result.success();
    }

    @RequestMapping(method = RequestMethod.POST, value = "highCPU")
    public Result<Map<String, String>> highCPU() {
        Thread highCpuThread = new Thread(this::deadAdd);
        highCpuThread.setName("HighCpu");
        highCpuThread.start();
        return Result.success();
    }
    //0<-1<-2<-0
    private void deadAdd() {
        ListNode node2 = new ListNode(2, null); // Create node (data + reference)
        ListNode node1 = new ListNode(1, node2);
        ListNode node = new ListNode(0, node1);
        node2.next = node;
        while (node != null) {
            if (flag) {
                node = node.next;
            } else {
                break;
            }
        }
        System.out.println("stop deadAdd");

    }

    class ListNode {        // Class name: Java class is a custom data structure.
        int val;            // Data: Node data.
        ListNode next;      // Object: Reference to the next node object. In Java, there is no concept of pointers; references in Java are similar to pointers in C language.

        ListNode(int val, ListNode next) {  // Constructor: The constructor has the same name as the class.
            this.val = val;   // Assign the received parameter to the current class's val variable.
            this.next = next;
        }
    }


}