精华内容
下载资源
问答
  • Linux进程查看命令 PS命令 1.不带参数的ps使用 2.显示所有的当前进程 ps –ax -a 代表 all。同时加上x参数会显示没有控制终端的进程。 ps -ax | less 可以结合less命令和管道来使用以方便查看。 3.通过cpu和...

    Linux进程查看命令

    PS命令

    • 1.不带参数的ps使用
      这里写图片描述

    • 2.显示所有的当前进程

      ps –ax  -a 代表 all。同时加上x参数会显示没有控制终端的进程。
      ps -ax | less 可以结合less命令和管道来使用以方便查看。
      
    • 3.通过cpu和内存使用来过滤进程

      ps -aux | less
      默认的结果集是未排好序的。可以通过 –sort命令来排序。
      

    根据 CPU 使用来升序排序
    ps -aux --sort -pcpu | less
    根据 内存使用 来升序排序
    ps -aux --sort -pmem | less
    我们也可以将它们合并到一个命令,并通过管道显示前10个结果:
    ps -aux --sort -pcpu,+pmem | head -n 10

    ```
    
    • 4.通过进程名和PID过滤

      ps -f -C [进程名]
      ps -f -C mysqld
      

    这里写图片描述

    • 5.树形显示进程
      这里写图片描述

    • 6.查看所有关于java的进程

      ps -ef | grep java
      

    top命令

    • 1.top命令经常用来监控Linux的系统状况,比如cpu、内存的使用。
      这里写图片描述

    • 2.第一行:

      第一块:当前系统时间
      第二块:系统已经运行了3天23小时26分
      第三块:当前有1个用户登录系统
      第四块:load average后面的三个数分别是1分钟、5分钟、15分钟的负载情况。load average数据是每隔5秒钟检查一次活跃的进程数,然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量,结果高于5的时候就表明系统在超负荷运转了。
      
    • 3.第二行:

      第一块:系统现在有431个进程
      第二块:有一个进程处于运行状态
      第三块:428个进程处于休眠状态
      第四块:0个进程处于stopped状态
      第五块:2个进程处于zombie状态
      
    • 4.第三行:cpu状态

      0.4 us — 用户空间占用CPU的百分比。
      0.5 sy — 内核空间占用CPU的百分比。
      0.0 ni — 改变过优先级的进程占用CPU的百分比
      99.0 id — 空闲CPU百分比
      0.0 wa — IO等待占用CPU的百分比
      0.0 hi — 硬中断(Hardware IRQ)占用CPU的百分比
      0.0 si — 软中断(Software Interrupts)占用CPU的百分比
      

    用户空间就是用户进程所在的内存区域,相对的,系统空间就是操作系统占据的内存区域。用户进程和系统进程的所有数据都在内存中。
    ```

    • 5.第四行:内存状态(单位k)

      16237008 total — 物理内存总量(16.2GB)
      10904524 used — 使用中的内存总量(10.9GB)
      1984320  free — 空闲内存总量(2.0G)
      3348164  buffers — 缓存的内存量 (3.3G)
      
    • 6.第五行:swap交换分区

      5119996 total — 交换区总量(5GB)
      0       used — 使用的交换区总量(0)
      5119996 free — 空闲交换区总量(5GB)
      4800960 cached — 缓冲的交换区总量(4.8GB)
      

      可用内存数的近似的计算公式:第四行的free + 第四行的buffers + 第五行的cached。
      我们最关心的内存监控是第五行swap(类似于虚拟内存)交换分区的used,如果这个数值在不断的变化,说明内核在不断进行内存和swap的数据交换,这是可以判定服务器的内存不够用了。

    • 7.第六行:各进程(任务)的状态监控

      PID — 进程id
      USER — 进程所有者
      PR — 进程优先级
      NI — nice值。负值表示高优先级,正值表示低优先级
      VIRT — 进程使用的虚拟内存总量,单位kb。VIRT=SWAP+RES
      RES — 进程使用的、未被换出的物理内存大小,单位kb。RES=CODE+DATA
      SHR — 共享内存大小,单位kb
      S — 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
      %CPU — 上次更新到现在的CPU时间占用百分比
      %MEM — 进程使用的物理内存百分比
      TIME+ — 进程使用的CPU时间总计,单位1/100秒
      COMMAND — 进程名称(命令名/命令行)
      

    线程查看命令

    top –H(列出所有的线程)

    这里写图片描述

    让top输出某个特定进程[pid]并检查该进程内运行的线程状况

    ```
    让top输出某个特定进程[pid]并检查该进程内运行的线程状况:
    top -H -p [pid]
    
    ```
    

    这里写图片描述

    查看由进程号为[pid]的进程创建的所有线程

    ```
    ps -T -p [pid]
    ```
    

    这里写图片描述

    Java线程监控分析(一般流程)

    1.先用top命令找出占用资源比较多的java进程id

    这里写图片描述
    我们以第一个进程为例,对该进程的所有线程进行监控

    2.查看相关进程的所有线程

    这里写图片描述
    接下来我们以第一个线程为例,对其进行监控分析

    3.然后借助JVM的 jconsole.exe 工具对相应线程进行具体分析

    这里写图片描述
    jconsole具体使用细节可以参考 https://blog.csdn.net/ithomer/article/details/9923311 ,这里就不做过多的介绍了。

    扫码关注公众号

    • 后台回复“Linux及Docker学习资料”免费获取更多Linux及Docker学习教材及实战资料
      在这里插入图片描述
    展开全文
  • 1.top命令 在linux环境下,可以通过top命令查看各个进程的cpu使用情况,默认按cpu使用率排序。 这样可以查看到进程的PID,我们通过PID进一步查看每个进程 。2.通过top -Hp PID 可以查看该进程下各个线程的cpu使用...


        系统调优,看到CPU一直满的,一定是代码不符合规范了。怎样去定位代码问题,如何查看占用CPU较高的线程呢?


    1.top命令

         在linux环境下,可以通过top命令查看各个进程的cpu使用情况,默认按cpu使用率排序。 这样可以查看到进程的PID,我们通过PID进一步查看每个进程 。


    2.通过top -Hp PID 

          可以查看该进程下各个线程的cpu使用情况。可以看出哪个PID的线程占了较多的cpu资源,利用jstack命令可以继续查看该线程当前的堆栈状态。


    3.jstack命令

         通过top命令定位到cpu占用率较高的线程之后,继续使用jstack pid命令查看当前java进程的堆栈状态。jstack命令生成的thread dump信息包含了JVM中所有存活的线程,为了分析指定线程,必须找出对应线程的调用栈。

         在top命令中,已经获取到了占用cpu资源较高的线程pid,将该pid转成16进制的值,在thread dump中每个线程都有一个nid,找到对应的nid即可;隔段时间再执行一次stack命令获取thread dump,区分两份dump是否有差别。


    4.通过thread dump分析线程状态

          除了上述的分析,大多数情况下会基于thead dump分析当前各个线程的运行情况,如是否存在死锁、是否存在一个线程长时间持有锁不放等等。

    在dump中,线程一般存在如下几种状态:
    1、RUNNABLE,线程处于执行中
    2、BLOCKED,线程被阻塞
    3、WAITING,线程正在等待



    展开全文
  • /**  *   * @author doctor  *  * @date 2014年8月23日 下午8:46:37 ...* 1、linux 命令 kill -3 pid 对于线程状态观察,eclipse console 会输出 * 2、java 命令 jstack pid 观察线程状态。 * @param args

    /*
     * Copyright (C) 2009 The doctor Authors
     * https://github.com/doctorwho1986
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */


    /**

     * 
     * @author doctor
     *
     * @date 2014年8月23日 下午8:46:37
     */
    public class DeadLock {
    /**
    * 1、linux 命令 kill -3 pid 对于线程状态观察,eclipse console 会输出
    * 2、java 命令 jstack pid 观察线程状态。
    * @param args
    */
    public static void main(String[] args) {

    //得到jvm线程pid,用命令观察线程死锁信息
    System.out.println(ManagementFactory.getRuntimeMXBean().getName());
    DeadLockAB deadLockAB = new DeadLockAB();
    new Thread(new Dead1(deadLockAB)).start();
    new Thread(new Dead2(deadLockAB)).start();


    }


    }


    class DeadLockAB{
    private Object a = new Object();
    private Object b = new Object();

    public void callAB() {
    synchronized (a) {
    System.out.println(Thread.currentThread().getName() + " get a");
    synchronized (b) {
    System.out.println(Thread.currentThread().getName() + " get b");
    }
    System.out.println(Thread.currentThread().getName() + " release b");
    }
    System.out.println(Thread.currentThread().getName() + " release a");
    }

    public void callBA() {
    synchronized (b) {
    System.out.println(Thread.currentThread().getName() + "get b");
    synchronized (a) {
    System.out.println(Thread.currentThread().getName() + " get a");
    }
    System.out.println(Thread.currentThread().getName() + " release a");
    }
    System.out.println(Thread.currentThread().getName() + " release b");
    }
    }


    class Dead1 implements Runnable{


    private DeadLockAB deadLockAB;

    public Dead1(DeadLockAB deadLockAB) {
    this.deadLockAB = deadLockAB;
    }
    @Override
    public void run() {
    try {
    while(true){
    deadLockAB.callAB();
    TimeUnit.SECONDS.sleep((int)Math.random()*10L);
    }

    } catch (Exception e) {
    e.printStackTrace();
    }
    }

    }




    class Dead2 implements Runnable{


    private DeadLockAB deadLockAB;

    public Dead2(DeadLockAB deadLockAB) {
    this.deadLockAB = deadLockAB;
    }
    @Override
    public void run() {
    try {
    while(true){
    deadLockAB.callBA();
    TimeUnit.SECONDS.sleep((int)Math.random()*10L);
    }

    } catch (Exception e) {
    e.printStackTrace();
    }
    }

    }


    当eclipse console 不再出现信息即死锁状态时候,用注释中的两条命令观察信息。


    贴出信息;


    [doctor@localhost ~]$ jstack 18773
    2014-08-23 21:33:17
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.11-b03 mixed mode):


    "Attach Listener" #12 daemon prio=9 os_prio=0 tid=0x00007fd268001000 nid=0x4982 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "DestroyJavaVM" #11 prio=5 os_prio=0 tid=0x00007fd2a4009800 nid=0x495b waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "Thread-1" #10 prio=5 os_prio=0 tid=0x00007fd2a40fc000 nid=0x496b waiting for monitor entry [0x00007fd290aea000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    at com.github.jdk.concurrent.DeadLockAB.callBA(DeadLock.java:49)
    - waiting to lock <0x00000000d810a108> (a java.lang.Object)
    - locked <0x00000000d810a118> (a java.lang.Object)
    at com.github.jdk.concurrent.Dead2.run(DeadLock.java:91)
    at java.lang.Thread.run(Thread.java:745)


    "Thread-0" #9 prio=5 os_prio=0 tid=0x00007fd2a40fa000 nid=0x496a waiting for monitor entry [0x00007fd290beb000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    at com.github.jdk.concurrent.DeadLockAB.callAB(DeadLock.java:38)
    - waiting to lock <0x00000000d810a118> (a java.lang.Object)
    - locked <0x00000000d810a108> (a java.lang.Object)
    at com.github.jdk.concurrent.Dead1.run(DeadLock.java:68)
    at java.lang.Thread.run(Thread.java:745)


    "Service Thread" #8 daemon prio=9 os_prio=0 tid=0x00007fd2a40d7000 nid=0x4968 runnable [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "C1 CompilerThread2" #7 daemon prio=9 os_prio=0 tid=0x00007fd2a40b1800 nid=0x4967 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "C2 CompilerThread1" #6 daemon prio=9 os_prio=0 tid=0x00007fd2a40b0000 nid=0x4966 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "C2 CompilerThread0" #5 daemon prio=9 os_prio=0 tid=0x00007fd2a40ad000 nid=0x4965 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "Signal Dispatcher" #4 daemon prio=9 os_prio=0 tid=0x00007fd2a40ab000 nid=0x4964 runnable [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE


    "Finalizer" #3 daemon prio=8 os_prio=0 tid=0x00007fd2a407c000 nid=0x4963 in Object.wait() [0x00007fd2a837d000]
       java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000000d81809b0> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:142)
    - locked <0x00000000d81809b0> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:158)
    at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)


    "Reference Handler" #2 daemon prio=10 os_prio=0 tid=0x00007fd2a4078000 nid=0x4962 in Object.wait() [0x00007fd2a847e000]
       java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000000d81889d8> (a java.lang.ref.Reference$Lock)
    at java.lang.Object.wait(Object.java:502)
    at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:157)
    - locked <0x00000000d81889d8> (a java.lang.ref.Reference$Lock)


    "VM Thread" os_prio=0 tid=0x00007fd2a4072800 nid=0x4961 runnable 


    "GC task thread#0 (ParallelGC)" os_prio=0 tid=0x00007fd2a401f000 nid=0x495d runnable 


    "GC task thread#1 (ParallelGC)" os_prio=0 tid=0x00007fd2a4020800 nid=0x495e runnable 


    "GC task thread#2 (ParallelGC)" os_prio=0 tid=0x00007fd2a4022800 nid=0x495f runnable 


    "GC task thread#3 (ParallelGC)" os_prio=0 tid=0x00007fd2a4024000 nid=0x4960 runnable 


    "VM Periodic Task Thread" os_prio=0 tid=0x00007fd2a40e1800 nid=0x4969 waiting on condition 


    JNI global references: 18




    Found one Java-level deadlock:
    =============================
    "Thread-1":
      waiting to lock monitor 0x00007fd274006168 (object 0x00000000d810a108, a java.lang.Object),
      which is held by "Thread-0"
    "Thread-0":
      waiting to lock monitor 0x00007fd274003828 (object 0x00000000d810a118, a java.lang.Object),
      which is held by "Thread-1"


    Java stack information for the threads listed above:
    ===================================================
    "Thread-1":
    at com.github.jdk.concurrent.DeadLockAB.callBA(DeadLock.java:49)
    - waiting to lock <0x00000000d810a108> (a java.lang.Object)
    - locked <0x00000000d810a118> (a java.lang.Object)
    at com.github.jdk.concurrent.Dead2.run(DeadLock.java:91)
    at java.lang.Thread.run(Thread.java:745)
    "Thread-0":
    at com.github.jdk.concurrent.DeadLockAB.callAB(DeadLock.java:38)
    - waiting to lock <0x00000000d810a118> (a java.lang.Object)
    - locked <0x00000000d810a108> (a java.lang.Object)
    at com.github.jdk.concurrent.Dead1.run(DeadLock.java:68)
    at java.lang.Thread.run(Thread.java:745)


    Found 1 deadlock.


    [doctor@localhost ~]$ 

    展开全文
  • 通过这种方式获取耗CPU的线程后查看ThreadDump文件做进一步分析 获取ThreadDump的方法: [code="java"]jstack -l pid >jstack.log[/code] [code="java"]"Attach Listener&...
    在Linux上输入top
    进入top后按【shift】+【H】组合键,按线程方式查看线程ID、CPU消耗状况等
    通过这种方式获取耗CPU的线程后查看ThreadDump文件做进一步分析
    获取ThreadDump的方法:
    jstack -l pid >jstack.log




    "Attach Listener" daemon prio=10 tid=0x00007fd388001000 nid=0x76e6 waiting on condition [0x0000000000000000]



    线程名称: Attach Listener
    * 线程类型:daemon
    * 优先级:10,默认是5
    * jvm线程id:jvm内部线程的唯一标识, 0x00007fd388001000
    * 对应系统线程id:和top命令查看的pid对应,不过一个是10进制,一个是16进制。0x76e6
    * 线程状态:waiting on condition
    * 起始栈地址: [0x0000000000000000]
    线程状态详解

    [b]Runnable[/b]
    _The thread is either running or ready to run when it gets its CPU turn.
    [b]Wait on condition[/b]
    _The thread is either sleeping or waiting to be notified by another thread._
    [b] Waiting for Monitor Entry and in Object.wait()[/b]
    _The thread is waiting to get the lock for an object (some other thread may be holding the lock). This happens if two or more threads try to execute synchronized code. Note that the lock is always for an object and not for individual methods._
    展开全文
  • 关于Linux线程线程栈以及TLS

    万次阅读 2014-03-23 22:52:22
    本文描述Linux NPTL的线程栈简要实现以及线程本地存储的原理,实验环境中Linux内核版本为2.6.32,glibc版本是2.12.1,Linux发行版为ubuntu,硬件平台为x86的32位系统。 b.对于Linux NPTL线程,有很多话题。本文挑选...
  • 在高并发,多线程环境下的java程序经常需要分析线程状态,本本是一个分析步骤无具体讲解(具体命令可自行google学习) 一般流程: 1.使用 jps-l 查看有哪些java程序在运行 2.使用 top 查看步骤1中进程号(pid或者...
  • Linux线程内存占用分析

    千次阅读 2014-08-11 22:39:11
    大概现象为,一个很简单的程序逻辑,开启了几个线程,程序本身并没有过多的申请内存,或者说根本没有申请内存,但是在实际运行起来后,通过PS命令和status 查看内存占用居然达到了40M,详细分析了smaps文件没有得到...
  • Linux进程与线程的区别

    千次阅读 2019-12-12 16:28:34
    Linux进程与线程的区别 ** 本文较长,耐心阅读,必有收获! 进程与线程的区别,早已经成为了经典问题。自线程概念诞生起,关于这个问题的讨论就没有停止过。无论是初级程序员,还是资深专家,都应该考虑过这个问题,...
  • op命令是Linux下常用的性能...linux系统top命令分析CPU和内存详解-linux top命令详解 其中各参数含义分别如下: 第一行top:显示了系统当前时间、系统运行了多长时间、当前登录用户、以及系统在1分钟/5分钟/15分钟...
  • linux 内核进程 线程

    千次阅读 2012-08-02 10:14:59
    Linux进程、线程问题   http://www.54xue.com/w/19/n-28919.html    2010年8月15日,今天研究的是Linux的进程管理,昨天是内存寻址,感慨颇深啊,《深入理解Linux内核》这本书真是浪得虚名,根本没有说到问题...
  • Linux中使用线程

    万次阅读 多人点赞 2013-10-11 22:56:23
    我并不假定你会使用Linux线程,所以在这里就简单的介绍一下。如果你之前有过多线程方面的编程经验,完全可以忽略本文的内容,因为它非常的初级。
  • 这里对linux下、sun(oracle) JDK的线程资源占用问题的查找步骤做一个小结; linux环境下,当发现java进程占用CPU资源很高,且又要想更进一步查出哪一个java线程占用了CPU资源时,按照以下步骤进行查找: (一):通过...
  • 对于cpu爆满问题,常常会分析是否存在问题线程,本文记录一种通过top快速找到问题线程nid的方式。 找到问题进程PID 通过top找到问题进程,例如下面有个进程CPU占用率高达99%,他的PID=270973。 PID USER PR NI VIRT...
  • Linux内核多线程

    千次阅读 2013-04-23 12:16:51
    Linux内核多线程 前言: 从内核的角度来说,它并没有线程这个概念。Linux把所有线程都当做进程来实现。内核并没有准备特别的调度算法或者定义特别的数据结构来表示线程。相反,线程仅仅被视为一个与其他...
  • Linux线程间死锁分析

    2018-11-06 15:47:10
    死锁 (deadlocks): 是指两个或两个以上的进程(线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的...
  • linux 创建内核线程

    千次阅读 2017-06-12 11:22:21
    Linux内核可以看作一个服务进程(管理软硬件资源,响应用户进程的种种合理以及不合理的请求)。内核需要多个执行流并行,为了防止可能的阻塞,支持多线程是必要的。内核线程就是内核的分身,一个分身可以处理一件特定...
  • 本文分析linux的多线程调试的实现机制和代码框架,给出基于jtag调试方式的ecos多任务调试的代码框架和实现机制的设计。
  • Linux进程线程实验

    千次阅读 2017-04-18 13:12:24
    Linux 进程线程实验
  • TOP命令 1,如果某个线程cpu利用率一直100%, 则说明这个线程有可能有死循环. 2,如果某个线程长期除以top位置,说明这个线程可能有性能问题 3,cpu利用率高的线程不停的变化,说明并不是某一个线程导致CPU偏高. 如果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,436
精华内容 39,374
关键字:

linux命令分析线程

linux 订阅