java thread dump and ps ‐o ‐ef , figure out which thread consume the largest portion of cpu , mem etc - unix1998/technical_notes GitHub Wiki

combination of a Java thread dump and system tools like ps to identify which Java thread is consuming the most CPU or memory. Here’s a detailed step-by-step guide on how to achieve this:

You can take a thread dump of a running Java application using tools like jstack, which is included with the JDK.

jstack <pid> > thread_dump.txt

Replace <pid> with the process ID of your Java application.

Use the ps command to get a list of threads and their CPU and memory usage.

ps -o pid,tid,%cpu,%mem -p <pid> -L

Replace <pid> with the process ID of your Java application. The -L option lists all threads of the specified process.

The thread dump will contain thread IDs in hexadecimal format, while ps outputs thread IDs in decimal format. You will need to convert the hexadecimal thread IDs from the thread dump to decimal format.

Match the thread IDs from the thread dump with the ps output to find which threads are consuming the most CPU or memory.

1. Take a Thread Dump:

   jstack 1234 > thread_dump.txt

   Example output snippet from thread_dump.txt:

   "Thread-1" #12 prio=5 os_prio=0 tid=0x00007f4c2c2e6000 nid=0x564 runnable [0x00007f4c105ae000]
   

   Here, nid=0x564 is the native thread ID in hexadecimal.

2. Get Thread Details Using ps:

   ps -o pid,tid,%cpu,%mem -p 1234 -L

   Example output:

     PID   TID %CPU %MEM
    1234  1380 25.0  0.5
    1234  1381  0.0  0.1
    1234  1382  0.1  0.1
    ...
   

3. Convert Hexadecimal to Decimal:

   Convert the hexadecimal thread ID 0x564 to decimal. You can do this using a calculator or using a simple script.

   hex_tid = "0x564"
   dec_tid = int(hex_tid, 16)
   print(dec_tid)  # Output will be 1380

   Now we know that 0x564 in hexadecimal is 1380 in decimal.

4. Match and Analyze:

   From the ps output, we see that thread 1380 is consuming 25.0% of CPU.

Here is a Python script to automate the conversion and matching process:

import re

def hex_to_dec(hex_tid):
    return int(hex_tid, 16)

# Read thread dump
with open('thread_dump.txt', 'r') as f:
    thread_dump = f.read()

# Extract hex thread IDs from thread dump
hex_tids = re.findall(r'nid=0x([0-9a-fA-F]+)', thread_dump)

# Convert hex thread IDs to decimal
dec_tids = {hex_tid: hex_to_dec(hex_tid) for hex_tid in hex_tids}

# Read ps output
ps_output = """
  PID   TID %CPU %MEM
 1234  1380 25.0  0.5
 1234  1381  0.0  0.1
 1234  1382  0.1  0.1
"""
ps_lines = ps_output.strip().split('\n')[1:]

# Parse ps output and match with thread dump
threads_info = []
for line in ps_lines:
    parts = line.split()
    pid, tid, cpu, mem = parts[0], parts[1], parts[2], parts[3]
    for hex_tid, dec_tid in dec_tids.items():
        if int(tid) == dec_tid:
            threads_info.append((hex_tid, tid, cpu, mem))

# Print matched threads info
for info in threads_info:
    print(f"Hex TID: {info[0]}, Dec TID: {info[1]}, CPU: {info[2]}%, MEM: {info[3]}%")

This script reads the thread dump, extracts the hexadecimal thread IDs, converts them to decimal, and then matches them with the output from the ps command, printing the CPU and memory usage for each thread.

Using these steps, you can identify which Java thread is consuming the most CPU or memory, helping you diagnose performance issues in your Java application.