精华内容
下载资源
问答
  • 服务端开发者必备技能、面试必问技巧,下载者也可以延伸为如何找到占用内存最大的线程
  • Java线程CPU占用高原因排查方法,Java线程CPU占用高原因排查方法
  • 线程CPU使用率到底该如何计算

    千次阅读 2020-06-01 22:07:53
    来源:公众号【鱼鹰谈单片机】作者:鱼鹰OspreyID :emOsprey这篇笔记有如下内容:1、为什么需要计算各个线程CPU使用率?2、该如何计算线程CPU使用率?3、FreeR...

    来源:公众号【鱼鹰谈单片机】

    作者:鱼鹰Osprey

    ID   :emOsprey

    这篇笔记有如下内容:

    1、为什么需要计算各个线程的CPU使用率?

    2、该如何计算线程CPU使用率?

    3、FreeRTOS线程计算的弊端?如何打破 FreeRTOS 线程计算方式的时间限制?

    4、关键代码介绍。

    上次介绍了如何计算整个系统的CPU使用率:

    单片机里面的CPU使用率是什么鬼?

    实操RT-Thread系统CPU利用率功能添加

    但是却没有介绍该如何计算每个线程(任务)的CPU使用率。

    为什么要计算线程CPU使用率?

    首先要问的是,为什么要计算线程的CPU使用率,有啥用?

    我们知道系统的CPU使用率关注的是整个系统的使用情况,使用率越低,表示越能更及时的响应外部情况,整个系统的性能也会越好。

    但这是从系统整体考量的,并不能反映单个线程的执行情况。

    比如虽然整体的CPU使用率是30%,但是有一个线程占据了25%的使用率,一个线程使用率是5%,那么你肯定会想,为啥这个线程需要占用这么高的CPU使用率,是不是代码写的有问题,是不是代码可以优化一下?

    当系统运行时,如果你能实时观察各个线程的CPU使用率,那么你就能知道平时这个线程的CPU使用情况是怎样的,为什么后来又高那么多,那么你就可以由此分析出这个线程可能出现了问题,也就可以针对性的进行检查了。

    这点对于合作开发的项目更是明显,很多时候因为有些线程的代码不是自己写的,所以根本不知道代码执行情况,一旦系统出现问题,那么可能就是互相甩锅了。

    而当计算了线程的CPU使用率,一旦发现某个线程执行异常,那么就能交给负责的人去查看了。

    所以说,使用操作系统的项目是非常有必要计算各个线程(任务)的CPU使用率的。

    就好比你的电脑,风扇嗡嗡响(CPU高负荷运行),如果只有一个系统CPU使用率,发现高达90%,但是你却根本不知道为什么这么高,所以只能重启。

    而一旦有了进程CPU使用率,查看一下哪个进程CPU使用率高,把对应的进程关闭就行了,根本不需要重启电脑。

            

    如何计算线程CPU使用率?

    那么现在就来看看该如何计算各个线程的CPU使用率。

    从前面的笔记,我们其实也可以猜测该如何计算,无非就是获取每个线程的执行时间罢了。

    比如,1秒时间内,空闲任务执行700毫秒,任务1执行200毫秒,任务2执行100毫秒,那么各个任务的CPU使用率分别是 70%、20%、10%。

    以前计算系统的CPU使用率的时候,采用了软件方法计算空闲任务的运行时间,这必然是不够准确的,所以最好的方式是采用硬件计时。

    因为鱼鹰采用STM32F103进行测试,所以使用DWT外设进行精确计时,不过麻烦的是,在KEIL 软件仿真情况下,DWT外设是无法工作的,所以如果要测试的话,必须使用硬件仿真的方式,不过如果真要KEIL软件仿真的话,也不是没有办法,就是使用硬件定时器,这个按下不表。

    毕竟,DWT外设的功能在这里说白了也就是个定时器而已。

    既然要获取线程的执行时间,关键一点就是,我们要知道操作系统什么时候会切换到某一个线程运行,什么时候又会从这个线程切出,到另一个线程执行呢?

    这个关键还是在系统内置的钩子函数。上次的笔记鱼鹰介绍过空闲钩子函数,今天介绍另一个钩子,任务切换钩子函数。

    这个钩子函数的特点就是,每当系统需要切换到下一个任务时,就会先执行这个函数。这个函数一般有两个参数,当前任务和即将切换的任务。

    只要设置任务切换的钩子函数,并且有时间戳,那么计算一个任务的执行时间也就不那么困难了。

    比如,操作系统在时刻12345 ms 切换到空闲任务执行,突然一个任务就绪,开始准备执行,所以在时刻12445切换到那个就绪任务执行,那么空闲任务的执行时间我们也就可以准确计算出来了。

    12445 – 12345 = 100 ms

    也就是说,这一次空闲任务执行了 100 毫秒。

    如果我们要计算单位时间(比如1秒内)空闲任务的执行时间,我们只要在每次运行到空闲任务时累计时间即可。

    比如1秒内,空闲任务执行了 5 次,分别是 10、200、100、200、50,累计时间为

    10 + 200 + 100 + 200 + 50 = 560毫秒

    由此,可计算空闲任务的CPU使用率为 56%,从而可计算出系统的CPU使用率是44%。

    是的,通过线程的CPU使用率方法,我们其实也可以计算整个系统的CPU使用率。而且这种计算方式比前面所说的计算方法更准确,更科学。

    前面采用时间戳进行计算,但是时间戳是会溢出的,那个时候,你的时间计算还是准确的吗?

    FreeRTOS线程计算限制?

    现在鱼鹰就来说说第三个问题,FreeRTOS线程计算的弊端?如何打破 FreeRTOS 线程计算方式的时间限制?

    从网上查找FreeRTOS任务CPU计算相关的资料,可以得到以下信息:

    1、需要开一个定时器,这个定时器中断频率是操作系统时钟的十几倍(为了保证计算精度)。

    2、一个64 位的变量在定时器自加更新,一旦变量溢出,时间计算就会出现问题。

    (相关细节可查看安富莱教程)

    第一个问题会导致系统性能下降(中断频率太高,一般是微秒级别的),而第二个问题导致在一段时间内(小时级别)线程CPU使用率计算准确,超出时间后,计算会有问题,所以教程中不建议在正式版本加入此功能。

    第一个问题其实很好解决,就是使用硬件定时器,不再由CPU去更新时间,这样不会占用CPU时间,第二个问题其实也非常好解决,就是通过《延时功能进化论(合集)》的方式解决溢出问题,这里不再展开说其中的奥妙。

    任务切换钩子函数的实现

    总之,鱼鹰接下来的实现方式解决了以上两个痛点,即使无限执行下去,也不会影响到计算精度问题,唯一对系统产生的一点影响,只有在任务切换时消耗的一点计算时间(微秒级别)。

    那么先上任务切换钩子函数关键实现代码(RT-Thread):

    void thread_stats_scheduler_hook(struct rt_thread *from, struct rt_thread *to)
    {
        static uint32_t schedule_last_time;
        
        uint32_t time;
        
        time = get_curr_time();
        
        from->user_data   += (time - schedule_last_time);
        schedule_last_time = time;
    }
    

    如何将这个函数注册到操作系统中被系统调用呢?

    通过这个函数即可:

    那么现在来分析这个钩子函数实现:

    一个静态变量,用于记录切换时的时间戳。

    每次任务开始切换时,更新这个时间戳,同时累积时间,这个时间保存在当前任务的user_data里面。

    难理解?看下图就清楚了。

    假设系统调度是从任务1切换到任务2,即from为任务1,to为任务2,此时获取的时间戳为 T1。

    上一次的时间戳我们已经通过静态变量保留了,这里为T0,那么T1-T0就是from任务即任务1在本次运行的时间,只要下次运行任务1时继续不断的累积这个时间,那么就可以得到任务1的总运行时间。

    任务2同理。

    当然我们不可能一直累积下去,不然肯定会溢出,所以隔一段时间就需要清零,这个时间其实就是线程CPU计算的周期。

        这里还有一个函数没有说,就是 get_curr_time(),在这里使用DWT,为了可以重新实现该函数,鱼鹰使用了弱属性 weak(关于这个看参考:《困惑多年,为什么 printf 可以重定向? 》)。

    __weak
    uint32_t get_curr_time() 
    {
        return DWT->CYCCNT; // don't use the function rt_tick_get()
    }
    

    这里可以看到有个注释,不要使用 rt_tick_get 函数,为啥?

    精度太低,有些任务本来执行了的,但是因为执行时间小于操作系统的时钟(比如1毫秒),那么就无法累积时间了,那么即使这个任务运行再多,时间累积也为 0,这肯定是我们不希望看到的。

    然后再说一个点,为了简化代码(钩子函数代码只有短短几行),鱼鹰这样的实现是有两个问题的。

    1、首次运行计算有误,因为静态变量应该在运行任务之前就初始化的(不应该初始化为 0),而钩子函数是在任务运行之后才调用的,所以从开机以来的时间被累加到第一个运行任务中了,这肯定是有问题的,不过后面随着系统的运行,静态变量被持续更新,就不会再出现这个问题了。

    2、为了减少修改,鱼鹰把线程的use_data当成一个变量使用了,实际上这个变量的功能应该是存储线程私有变量地址的,但是因为鱼鹰懒得修改太多代码,所以直接拿来用了。正因为如此,所以鱼鹰添加线程CPU计算时,只要修改很少的代码就可以了。

    线程CPU的计算

    目前我们已经能够通过钩子函数获取各个线程的CPU执行时间,现在就看该如何计算了。

    为了计算各个线程的CPU使用率,我们需要确定计算周期,这里我们可以设置1秒计算一次。

    其次,我们需要确定在哪个任务执行计算。

    原理上来说,可以是系统中的任何一个任务,但是为了减少对系统的干扰,可以将计算工作放到优先级比较低的任务中进行,比如空闲任务。

    现在,看看函数是如何实现的:

    // can call the function 1 s (max 60s when stm32f1xx because of dwt)
    void thread_cal_usage(thread_run_info_def *run_info)
    {
        static uint32_t total_time_last; 
        
        uint32_t time, total_time;
        struct rt_list_node *node;
        struct rt_list_node *list;
        struct rt_thread *thread;
        uint32_t i;
     
        rt_enter_critical(); // 关闭系统调度,防止在计算过程中更新线程时间,影响计算
      
      time = get_curr_time(); // 获取当前时间戳
        total_time             = time - total_time_last;   // 计算运行总时间
        total_time_last = time; // 更新时间
        
        list = &(rt_object_get_information(RT_Object_Class_Thread)->object_list); // 获取线程列表指针
      // 搜索类别
        for(i = 0, node = list->next; (node != list) && i < THREAD_NBR_MAX; node = node->next, i++){
            thread            = rt_list_entry(node, struct rt_thread, list); // 获取线程地址
            run_info[i].name  = thread->name;     // 保存线程名
            run_info[i].time  = thread->user_data;  // 保存线程执行时间
            thread->user_data = 0;          // 清除线程执行时间
        }
            
        rt_exit_critical();// 开启系统调度
        
      // 计算各个线程的 CPU 使用率
        total_time /= 100; 
        if(total_time > 0){
            for(uint32_t j = i, i = 0; i < j; i++)
            {
                run_info[i].usage = run_info[i].time / total_time;
            }
        }
    }
    
    
    

    注释已经很详尽了,所以不多做讨论。主要说以下几点:

    1、为什么需要关闭调度器,可以使用关中断吗?

    关调度器是为了防止在获取各个线程执行时间时,因为系统调度而导致执行时间被更新,从而导致计算有误,所以需要关闭调度器。

    那么为什么不使用关中断的方式呢?没有必要。一旦关中断,那么中断就无法响应了,所以在可以关调度器的情况下满足要求,就不应该关中断。

    2、为什么分两步计算,为什么不将最终的计算放在第一个循环中执行呢?

    节省时间,为了尽量减少关调度器的时间,能省一点是一点。毕竟只要能获取到关键信息,啥时候计算都一样。

    3、因为线程CPU计算周期是自动计算的,所以,计算周期其实就是该函数的调用周期,即2秒调用一次,那么线程CPU计算周期就是2秒,但是需要注意的是,调用周期必须小于定时器的溢出时间,即当你使用 DWT 时,调用周期应该在 60 秒以下(72 M 系统时钟),否则计算是有问题的。

    现在我们已经算是完成了线程CPU计算问题,但为了使用方便,我们需要把它打印出来,或者把这些信息字符串化:

    void thread_stats_print(void)
    {
        thread_run_info_def run_info[THREAD_NBR_MAX] = {0};
        thread_run_info_def *p_info;
    
    
        thread_cal_usage(run_info);
        
        rt_kprintf("thread\t\t\ttime\t usage\n");
        for(uint32_t i = 0; i < THREAD_NBR_MAX; i++)
        {
            p_info = &run_info[i]; 
            if(p_info->name != NULL)
            {
                if(p_info->usage > 0)  // CPU 使用率大于 1 %
                {
                        rt_kprintf("%-16s\t%u\t%2u%%\n",  p_info->name, 
                                                         (uint32_t)p_info->time, 
                                                         (uint32_t)p_info->usage);
                }
                else  
                {
                        rt_kprintf("%-16s\t%u\t<1%%\n", p_info->name, 
                                                       (uint32_t)p_info->time,  
                                                       (uint32_t)p_info->usage);
                }
            }
            else
            {
                break;
            }
        }
    }
    

    这里将线程名、线程执行时间、线程使用率都打印出来了,但是需要注意的是,这里的time 时间单位是定时器的单位,而不是微秒、毫秒,比如如果使用 DWT,那么单位就是 1/72 微秒,即如果 time 值为 1000,那么换算到微秒,应该是 1000/72 秒,当然了,你也可以在打印的同时就把时间换算一下,这个自由发挥就好。

    最后,鱼鹰将代码提交到了 RT-Thread 官方工程里面,这是鱼鹰第一次使用 Git 提交开源项目(操作不熟练,还是上网搜的教程),也不知道最后合并了没有。

    如果对完整代码感兴趣的,也可以在后台回复关键字领取。

    推荐阅读:

    终极串口接收方式,极致效率

    为什么说你一定要掌握 KEIL 调试方法?

    延时功能进化论(合集)

    指针,很难吗?| 解析指针的过程与意义(一)

    如何写一个健壮且高效的串口接收程序?

    KIEL 调试那些事儿之窗口展示——变量(二)

    打了多年的单片机调试断点到底应该怎么设置?| 颠覆认知

    -THE END-


    如果对你有帮助,记得转发分享哦

    微信公众号「鱼鹰谈单片机」

    每周一更单片机知识

    长按后前往图中包含的公众号关注

    鱼鹰,一个被嵌入式耽误的畅销书作家

    个人微信「EmbeddedOsprey」

    长按后打开对方的名片关注

    展开全文
  • windows下只能查看进程的cpu占用率,要查看线程cpu占用率要借助该工具,线程信息一目了然。
  • 本文的目的是在 Java进程中确定哪个线程正在占用CPU时间。 当系统 CPU 负载居高不下时,这是一种有用的故障排除技术。 步骤: 首先确定进程的 ID ,可以使用 jps -v 或者 top 命令直接查看 [root@garcia-kvc0s ~...

    本文的目的是在 Java进程中确定哪个线程正在占用CPU的时间。
    当系统 CPU 负载居高不下时,这是一种有用的故障排除技术。

    步骤:

    • 首先确定进程的 ID ,可以使用 jps -v 或者 top 命令直接查看
    [root@garcia-kvc0s ~]# ps -ef | grep kiev
    root       132   117 20 Sep20 ?        1-19:03:29 /data/java/bin/java ...
    
    • 查看该进程中哪个线程占用大量 CPU,执行 top -H -p [PID] 结果如下:

    image

    键盘按 ctrl+p 可以进行cpu排序,发现线程 544 占用cpu最高

    首先将 544 转成 16 进制是 220 (可以用开源中国在线工具转换)

    image

    • 接下来我们将进程中的所有线程输出到一个文件中,执行:jstack [PID] > jstack.txt

    • 在进程中查找对应的线程 ID,执行:cat jstack.txt | grep -A 10 -i nid=0x220

    结果是:

    [root@garcia-kvc0s ~]# cat jstack.txt | grep -A 10 -i nid=0x220
    "pool-13-thread-6" prio=10 tid=0x00007eff24004000 nid=0x220 waiting on condition [0x00007efdf2aaa000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000006c7a42fe8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
            at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
            at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
            at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
            at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
            at java.lang.Thread.run(Thread.java:722)
    

    找到问题后,接下来去解决就好了!

    useful-scripts

    在github上也有一个大佬贡献的脚本,非常方便,详见
    useful-scripts

    展开全文
  • 在windows系统下,默认只能够查看进程的使用情况而不能查看线程的详细信息,使用此工具能够查看所有的线程的详细信息
  • 1、下载Windows系统和应用程序监视工具Process Explorer ... 2、打开ProcessExplorer,找到cpu占用高的java.exe,记下进程编号PID,比如当前是9520 ...3、双击java.exe进程,打开查看CPU占用高的线程,记下线程编号TID...

    1、下载Windows系统和应用程序监视工具Process Explorer

    https://download.sysinternals.com/files/ProcessExplorer.zip

    2、打开ProcessExplorer,找到cpu占用高的java.exe,记下进程编号PID,比如当前是9520

    3、双击java.exe进程,打开查看CPU占用高的线程,记下线程编号TID,比如当前19600,转成16进制为4C90

     

    4、使用的java的jstack工具

    打开doc命令行,执行命令:jstack -l 9520 >> D:\\jstack.txt

    打开D盘下的jstack.txt文件,搜索16进制的线程编号4C90,找到后就可定位到有问题的代码。

    5、linux系统下查找java占cpu高的线程

    1,使用top 命令动态的展示占用前几的进程PID, CPU消耗, TIME, RES 等信息,然后找到CPU占用最高的PID。

    2 , top -Hp  19600(pid)  显示PID进程消耗的线程各个情况。着到一个认为TIME最长的线程的PID,将PID转成16进制4C90,例如:

    printf "%x\n" 19600(PID)。

    3、使用jstack工具定位问题的原因 ./jstatck -l 9520 | grep 4C90  -A 80 。

    说明:-A 80 是关键字后的80行代码

    展开全文
  • Linux查看线程信息,定位某线程占用CPU高问题 相关命令:top, ps aux | grep pid, jstack 1、首先使用top命令定位到占用CPU高的进程PID [root@QIANZI-BASE home]# top 查看进程的详细信息 [root@QIANZI-BASE ...

    Linux查看线程信息,定位某线程占用CPU高问题

    相关命令:top, ps aux | grep pid, jstack

    1、首先使用top命令定位到占用CPU高的进程PID

    [root@QIANZI-BASE home]# top

    查看进程的详细信息

    [root@QIANZI-BASE home]# ps aux | grep PID

    2、获取线程信息,并找到占用CPU高的线程

    [root@QIANZI-BASE home]# ps -mp pid -o THREAD,tid,time | sort -rn

    3、将需要的线程ID转换为16进制格式

    [root@QIANZI-BASE home]# printf "%x\n" tid

    4、打印线程堆栈信息

    [root@QIANZI-BASE home]# jstack pid | grep tid -A 30

     

    展开全文
  • 1. 查找进程 top查看进程占用资源情况 ...查看线程占用情况 3.查找java的堆栈信息 将线程id转换成十六进制 #printf %x 15664 #3d30 然后再使用jstack查询线程的堆栈信息 语法:jstack <pid> | gre...
  • https://blog.csdn.net/xnn2s/article/details/11865339
  • (4)查看cpu占用100%的问题,关键在于查看进程中各个线程占用cpu时间,我们可以使用命令 “!runaway” ,运行如下 0:027> !runaway  User Mode Time  Thread Time  20:978 0 days 0:07...
  • 一次GC线程占用系统CPU过高处理过程

    千次阅读 2018-12-12 20:18:52
    因为测试人员报告说,最近订单系统总是超时,要重启才能恢复正常,但是第二次复现的时间不固定。 然后先是查看下应用状态是否正常,没有问题。...发现订单应用的CPU已经100%,但是内存还有剩余,内存占用 大概30...
  • CPU,进程, 线程占用关系

    千次阅读 2020-09-15 22:35:21
    并发和并行的概念区分: 并发,指的是多个事情,在...只有在多CPU或者一个CPU多核的情况中,才会发生并行。否则,看似同时发生的事情,其实都是并发执行的。 ...
  • 可以用下面的命令将 cpu 占用率高的线程找出来: ps H -eo user,pid,ppid,tid,time,%cpu,cmd --sort=%cpu这个命令首先指定参数'H',显示线程相关的信息,格式输出中包含:user,pid,ppid,tid,time,%cpu,cmd,然后再用%...
  • 分析java线程占用cpu或者内存高的代码 1、通过top查看占用cpu或者内存高的进程截图如下【备注输入大写P以cpu从大到小排序,大写M以内存大小排序】 2、通过对应的cpu找到PID也就是进程对应的pid,然后找到java...
  • 有时候要进行压力測试,那么怎样来看呢,一般我们会通过top命令查看各个进程的cpu和内存占用情况,获得到了我们的进程id,然后我们或许会通过pstack命令查看里边的各个线程id以及相应的线程如今正在做什么事情,分析...
  • 如何查询进程中占用CPU线程

    千次阅读 2019-02-28 15:38:50
    如何查询进程中占用CPU线程 (1)命令查找进程PID top -c 或jps -v (2)找进程中的线程号 top -Hp PID (3)将线程转换成16进制(对应nid) printf %x PID 线程号 (4)查看具体的线程 jstack PID |grep ...
  • C# 多线程造成CPU占用率高解决办法

    万次阅读 多人点赞 2018-08-19 08:26:40
    在C#开发中我们难免会用到多线程操作,而且很多时候需要开启多个线程一直监视某个状态,当线程多的时候就会造成CPU内存占用率过高。电脑配置低的根本吃不消。 private void button1_Click(object sender, ...
  • 我写了一个死循环当满足条件就跳出,然后用线程开始这个循环,但是一启动线程CPU占用就很高,即使死循环里面什么代码都没有。请问怎么解决这个问题,用计时器的话CPU占用就很低,但是用计时器键盘钩子经常掉。一会就...
  • 可以查看多线程cpu占用率的工具

    热门讨论 2010-04-21 18:08:57
    用在嵌入式linux平台上,通常busybox的top无法看到多线程应用的每个线程cpu占用率,特地编写了这个小工具.
  • 可以用下面的命令将 cpu 占用率高的线程找出来:  ps H -eo user,pid,ppid,tid,time,%cpu,cmd --sort=%cpu 这个命令首先指定参数'H',显示线程相关的信息,格式输出中包含:user,pid,ppid,tid,time,%cpu,cmd,然后...
  • 利用CPU的多核并行计算能力 现在的CPU基本上都是多核的。使用多线程,可以利用多核同时执行多个线程,而不至于单线程时一个核心满载,而其他核心空闲。 1.2 多线程弊端 线程切换是有开销的,这会导致程序运行变慢...
  • 通过查看每个线程占用CPU时间

    千次阅读 2014-07-28 17:27:46
    通过查看每个线程占用CPU时间缩小到具体线程,然后跟代码调试找到的。[喝小酒的网摘]http://blog.const.net.cn/a/17246.htm 在proc/pid/task下包含了该进程所有的线程,例如线程号2012,那么在proc/pid/task/...
  • JVM找出占用CPU最高的线程

    万次阅读 2018-05-05 21:11:43
    服务器CPU占用达到300%多开始以为只是可能只是意外事件,重启一下就好,但是发现重启之后没几分钟服务器马上又反应无法访问,我就开始检查自己写的代码是不是有什么非常消耗CPU资源的逻辑,但是找了一段时间之后还是...
  • 获取当前所有进程线程Cpu占用率,系统进程管理源代码
  • 查看进程中启动线程的方法 top -H -p pid -d 0.3 1 按f键进入选择界面,按空格可以选择下面配置选项 P = Last Used Cpu (SMP) 按Esc 退回到top界面可以看到多了一列进程所在cpu信息 ...
  • [Java] 查看占用 CPU 最高的线程

    千次阅读 2018-10-06 14:53:44
    先用 top 命令找出进程中占用 CPU 最高的线程pid,再用 jstack 找出具体的线程堆栈。
  • 获取每个线程CPU使用率源代码,很不错啊
  • 获取当前所有进程线程Cpu占用率.rar

    热门讨论 2009-01-12 23:25:22
    可以查看当前系统运行的各进程cpu占用率 可以选择一个进程,查询里面各线程cpu占用率。...获取两次统计间隔的cpu时间,除以间隔时间。得到占用率 用途:查看自己写的程序那个线程运行时间最多,耗资源等。
  • 线程的生命周期及五种基本状态 关于Java中线程的生命周期,首先看一下下面这张较为经典的图: 上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点,Java中的多线程也就基本上掌握了。主要包括: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 248,063
精华内容 99,225
关键字:

如何计算线程占用cpu时间