When debugging performance issues or optimizing multithreaded applications, examining CPU usage at the thread level provides crucial insights. Modern operating systems expose this information through various interfaces.

On Linux systems, the most comprehensive thread monitoring comes from these approaches:

# Method 1: Using top with thread display
top -H -p [PID]

# Method 2: Using ps with custom output format
ps -eLo pid,tid,pcpu,comm --sort=-pcpu | grep [process_name]

# Method 3: Direct proc filesystem access
cat /proc/[PID]/task/[TID]/stat

Windows provides several APIs and tools for thread monitoring:

// C++ example using GetThreadTimes
#include <windows.h>

void GetThreadCpuUsage(DWORD threadID) {
    FILETIME creationTime, exitTime, kernelTime, userTime;
    HANDLE hThread = OpenThread(THREAD_QUERY_INFORMATION, FALSE, threadID);
    
    if (GetThreadTimes(hThread, &creationTime, &exitTime, &kernelTime, &userTime)) {
        ULARGE_INTEGER kernel, user;
        kernel.LowPart = kernelTime.dwLowDateTime;
        kernel.HighPart = kernelTime.dwHighDateTime;
        user.LowPart = userTime.dwLowDateTime;
        user.HighPart = userTime.dwHighDateTime;
        
        // Calculate CPU usage percentage
    }
    CloseHandle(hThread);
}

For developers working across multiple platforms, these tools provide consistent thread monitoring:

• htop (Linux) with tree view enabled
• Process Explorer (Windows)
• perf (Linux performance counters)
• VTune (Intel's advanced profiler)

Here's a cross-platform Python solution using psutil:

import psutil

def monitor_threads(pid):
    process = psutil.Process(pid)
    for thread in process.threads():
        print(f"Thread ID: {thread.id}, CPU %: {thread.cpu_percent(interval=1)}")
        print(f"Memory: {thread.memory_info().rss / 1024} KB")

When analyzing thread CPU usage, consider:

• Consistent high usage may indicate tight loops
• Spikes often correlate with specific operations
• Compare with I/O wait times from iostat or similar tools
• Watch for thread starvation or excessive context switching

For deep performance analysis, consider these low-level approaches:

# Linux ftrace example for thread scheduling
echo function_graph > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/events/sched/sched_switch/enable
cat /sys/kernel/debug/tracing/trace_pipe

When debugging performance issues or optimizing multi-threaded applications, getting per-thread CPU usage is crucial. Here's how to access this data on different platforms:

The most powerful tool is top with thread display mode:

top -H -p [PID]
# Press 'f' to add columns, select 'P' (Last Used CPU) and 'p' (CPU Usage)

For programmatic access, read /proc/[PID]/task/[TID]/stat:

# Sample Python implementation
import os

def get_thread_cpu(pid):
    task_path = f"/proc/{pid}/task"
    for tid in os.listdir(task_path):
        with open(f"{task_path}/{tid}/stat") as f:
            stats = f.read().split()
            utime = int(stats[13])
            stime = int(stats[14])
            print(f"Thread {tid}: User={utime} System={stime}")

Use PowerShell with WMI:

Get-WmiObject Win32_Thread | Where-Object {$_.ProcessHandle -eq [PID]} | 
Select-Object Handle, UserModeTime, KernelModeTime

For C++ developers, the Thread API provides precise metrics:

// C++ example using GetThreadTimes()
FILETIME createTime, exitTime, kernelTime, userTime;
GetThreadTimes(hThread, &createTime, &exitTime, &kernelTime, &userTime);

• htop (Linux): Interactive viewer with thread tree
• Process Explorer (Windows): Detailed thread activity
• perf (Linux): Low-overhead profiling with perf stat -t [TID]

Key metrics to analyze:

• User vs System time ratio
• CPU migration between cores
• Context switch frequency

For Java applications, combine OS tools with jstack to map native threads to Java threads.