zoukankan      html  css  js  c++  java

  • Linux查看进程线程个数

    1.根据进程号进行查询：

    # pstree -p 进程号

    # top -Hp 进程号

    2.根据进程名字进行查询：

    # pstree -p `ps -e | grep server | awk '{print $1}'`

    # pstree -p `ps -e | grep server | awk '{print $1}'` | wc -l

    这里利用了管道和命令替换，

    关于命令替换，我也是今天才了解，就是说用``括起来的命令会优先执行，然后以其输出作为其他命令的参数，

    上述就是用 ps -e | grep server | awk '{print $1}' 的输出（进程号），作为 pstree -p 的参数

    管道和命令替换的区别是：

    管道：管道符号"|"左边命令的输出作为右边命令的输入

    命令替换：将命令替换符"``"中命令的输出作为其他命令相应位置的参数

    windows:

    之前因为线程内出现异常导致Python部分线程退出，程序以单线程方式运行了好几个星期，浪费了很多时间。

    如何查看当前进程有多少个存活线程呢？

    方法1）pstree -p 4761（进程ID）。如下截图所示：

     
    方法2）cat /proc/4761（进程ID）/status。如下图所示：
     
     
    方法3）top -p 4761（进程ID），然后按H。如下图所示：
     
    为什么只有1个线程在running呢？ 由于GIL的缘故，Python同时只能使用一个CPU核心，线程间要轮换执行，所以同时最多有一个线程在运行。
    看下图，MySQL的多个线程就可以同时处于running状态，因为C++可以使用多个CPU核心。
     
     

    三种方法：

    1。 使用top命令，具体用法是 top -H

            加上这个选项，top的每一行就不是显示一个进程，而是一个线程。

    2。 使用ps命令，具体用法是 ps -xH

            这样可以查看所有存在的线程，也可以使用grep作进一步的过滤。

    3。 使用ps命令，具体用法是 ps -mq PID （ubuntu下貌似不能使用）

            这样可以看到指定的进程产生的线程数目。


    更进一步，其实一些系统监控工具，在本质上也是读取的系统产生的文件罢了。比如说进程这个事情，

    现在假设有进程号为 5000 的进程，查看这个进程的所有具体信息，在哪查看呢?

    看看这个目录吧，/proc/5000/ 这里面有你所有想要的。其实stat代表着当前的一些信息。

    例如：输入命令cat /proc/`pgrep vsftpd`/status

     

    Name:	vsftpd
State:	S (sleeping)
Tgid:	1735
Pid:	1735
PPid:	1
TracerPid:	0
Uid:	0	0	0	0
Gid:	0	0	0	0
FDSize:	32
Groups:	
VmPeak:	    4052 kB
VmSize:	    4036 kB
VmLck:	       0 kB
VmHWM:	    1036 kB
VmRSS:	    1036 kB
VmData:	     356 kB
VmStk:	      88 kB
VmExe:	     112 kB
VmLib:	    3280 kB
VmPTE:	      32 kB
Threads:	1
SigQ:	1/5926
SigPnd:	0000000000000000
ShdPnd:	0000000000000000
SigBlk:	0000000000000000
SigIgn:	0000000000000000
SigCgt:	0000000000012001
CapInh:	0000000000000000
CapPrm:	ffffffffffffffff
CapEff:	ffffffffffffffff
CapBnd:	ffffffffffffffff
Cpus_allowed:	ff
Cpus_allowed_list:	0-7
Mems_allowed:	1
Mems_allowed_list:	0
voluntary_ctxt_switches:	1
nonvoluntary_ctxt_switches:	3

    使用ps命令来查看进程的时候，进程状态分别对应的含义如下：

    D    不可中断睡眠 (通常是在IO操作) 收到信号不唤醒和不可运行, 进程必须等待直到有中断发生
    R   正在运行或可运行（在运行队列排队中）
    S   可中断睡眠 (休眠中, 受阻, 在等待某个条件的形成或接受到信号)
    T   已停止的 进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行
    W   正在换页(2.6.内核之前有效)
     X   死进程 (未开启)
     Z   僵尸进程  进程已终止, 但进程描述符存在, 直到父进程调用wait4()系统调用后释放BSD风格的
     <   高优先级(not nice to other users)
     N   低优先级(nice to other users)
     L   页面锁定在内存（实时和定制的IO）
     s   一个信息头
     l   多线程（使用 CLONE_THREAD，像NPTL的pthreads的那样）
     +   在前台进程组

     
     
     


    研究 Atlas 过程中，需要了解其进程模型（线程模型），那么如何查看其运行模式呢？

    前提：Atlas 配置了 daemon 模式和 keepalive 功能。
    ?
    1
    2
    3
    4
    5
    6
    7
    [root@Betty conf]# vi modb.cnf
     
    [mysql-proxy]
    ...
    daemon = true
    keepalive = true
    ...

    查看方式：
    1. ps 命令查看
    从 man ps 中可以如下说明，可以显示进程关系， 
    ?
    1
    2
    3
    To print a process tree:
       ps -ejH
       ps axjf
    但 ps -ejH 显示出来的东东比较难看，所以采用第二种方式查看，
    ?
    1
    2
    3
    [root@Betty conf]# ps axjf|grep mysql-proxy|grep -v grep
        1  3755  3754  3754 ?           -1 S        0   0:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
     3755  3756  3754  3754 ?           -1 Sl       0   0:00  \_ mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    那么如何显示线程关系呢？有如下说明，
    ?
    1
    2
    3
    To get info about threads:
       ps -eLf
       ps axms
    执行后输出（采用第一种方式查看，原因同上）
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    [root@Betty conf]# ps -eLf|grep mysql-proxy
    UID        PID  PPID   LWP  C NLWP STIME TTY          TIME CMD
    root      3755     1  3755  0    1 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3756  0    5 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3757  0    5 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3758  0    5 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3759  0    5 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3760  0    5 15:14 ?        00:00:00 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      4154 18711  4154  0    1 16:32 pts/5    00:00:00 grep mysql-proxy
    其中
    LWP -- 轻量级进程，即线程，这里显示的是 thread id。
    NLWP -- 线程数，即 number of threads in process。

    如果还想要查看线程究竟运行在哪个 CPU 上，则执行如下命令，
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    [root@Betty conf]# ps -eo ruser,pid,ppid,lwp,psr,args -L|grep mysql-proxy
    RUSER      PID  PPID   LWP PSR COMMAND
    root      3755     1  3755   2 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3756   1 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3757   0 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3758   3 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3759   1 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      3756  3755  3760   1 mysql-proxy --defaults-file=/usr/local/mysql-proxy/conf/modb.cnf
    root      4162 18711  4162   2 grep mysql-proxy
    [root@Betty conf]#
    关键参数说明如下：
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    To see every process with a user-defined format:
       ps -eo pid,tid,class,rtprio,ni,pri,psr,pcpu,stat,wchan:14,comm
       ps axo stat,euid,ruid,tty,tpgid,sess,pgrp,ppid,pid,pcpu,comm
    ...
    -L              Show threads, possibly with LWP and NLWP columns
    ...
    psr        PSR      processor that process is currently assigned to.
    ...

    2. pstree 命令查看
    查看 mysql-proxy 对应的进程 id 。
    ?
    1
    2
    3
    [root@Betty conf]# ps -e |grep mysql-proxy
     3755 ?        00:00:00 mysql-proxy
     3756 ?        00:00:00 mysql-proxy
    分别查看以上两个进程的树形关系。
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    [root@Betty conf]# pstree 3755
    mysql-proxy---mysql-proxy---4*[{mysql-proxy}]
     
    [root@Betty conf]# pstree -p 3756
    mysql-proxy(3756)-+-{mysql-proxy}(3757)
                      |-{mysql-proxy}(3758)
                      |-{mysql-proxy}(3759)
                      `-{mysql-proxy}(3760)
    [root@Betty conf]#

    3. top 命令查看
    查看 id 为 3756 的进程包含的线程。
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    [root@Betty conf]# top -Hp 3756
    top - 17:32:19 up  8:26,  6 users,  load average: 0.00, 0.00, 0.00
    Tasks:   5 total,   0 running,   5 sleeping,   0 stopped,   0 zombie
    Cpu(s):  0.0%us,  0.0%sy,  0.1%ni, 99.7%id,  0.1%wa,  0.0%hi,  0.0%si,  0.0%st
    Mem:   3941948k total,   897296k used,  3044652k free,   116232k buffers
    Swap:  5996536k total,        0k used,  5996536k free,   516676k cached
     
     
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                       
     3756 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 mysql-proxy
     3757 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 mysql-proxy
     3758 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 mysql-proxy
     3759 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 mysql-proxy
     3760 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 mysql-proxy
    按 f 后显示
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    Current Fields:  AEHIOQTWKNMbcdfgjplrsuvyzX  for window 1:Def
    Toggle fields via field letter, type any other key to return
     
    * A: PID        = Process Id
    * E: USER       = User Name
    * H: PR         = Priority
    * I: NI         = Nice value
    * O: VIRT       = Virtual Image (kb)
    * Q: RES        = Resident size (kb)
    * T: SHR        = Shared Mem size (kb)
    * W: S          = Process Status
    * K: %CPU       = CPU usage
    * N: %MEM       = Memory usage (RES)
    * M: TIME+      = CPU Time, hundredths
      b: PPID       = Parent Process Pid
      c: RUSER      = Real user name
      d: UID        = User Id
      f: GROUP      = Group Name
      g: TTY        = Controlling Tty
      j: P          = Last used cpu (SMP)
      p: SWAP       = Swapped size (kb)
      l: TIME       = CPU Time
      r: CODE       = Code size (kb)
      s: DATA       = Data+Stack size (kb)
      u: nFLT       = Page Fault count
      v: nDRT       = Dirty Pages count
      y: WCHAN      = Sleeping in Function
      z: Flags      = Task Flags <sched.h>
    * X: COMMAND    = Command name/line
     
    Flags field:
      0x00000001  PF_ALIGNWARN
      0x00000002  PF_STARTING
      0x00000004  PF_EXITING
      0x00000040  PF_FORKNOEXEC
      0x00000100  PF_SUPERPRIV
      0x00000200  PF_DUMPCORE
      0x00000400  PF_SIGNALED
      0x00000800  PF_MEMALLOC
      0x00002000  PF_FREE_PAGES (2.5)
      0x00008000  debug flag (2.5)
      0x00024000  special threads (2.5)
      0x001D0000  special states (2.5)
      0x00100000  PF_USEDFPU (thru 2.4)
    按 j 后变化的项为
    ?
    1
    * J: P          = Last used cpu (SMP)
    按回车或空格保存，退回到 top 界面，显示如下
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    top - 17:34:07 up  8:27,  6 users,  load average: 0.00, 0.00, 0.00
    Tasks:   5 total,   0 running,   5 sleeping,   0 stopped,   0 zombie
    Cpu(s):  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
    Mem:   3941948k total,   897172k used,  3044776k free,   116264k buffers
    Swap:  5996536k total,        0k used,  5996536k free,   516676k cached
     
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  P COMMAND                                                                    
     3756 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 1 mysql-proxy                                                                
     3757 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 0 mysql-proxy                                                                
     3758 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 1 mysql-proxy                                                                
     3759 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 1 mysql-proxy                                                                
     3760 root      15   0  195m 3752 1804 S  0.0  0.1   0:00.00 1 mysql-proxy
    在 top 的显示中会多出 P 这一列是最近一次运行该线程（进程）的CPU 。

    4. 到进程对应的目录下查看
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    [root@Betty conf]# cat /proc/3756/status
    Name:   mysql-proxy
    State:  S (sleeping)
    SleepAVG:       98%
    Tgid:   3756
    Pid:    3756
    PPid:   3755
    TracerPid:      0
    Uid:    0       0       0       0
    Gid:    0       0       0       0
    FDSize: 64
    Groups: 0 1 2 3 4 6 10
    VmPeak:   252512 kB
    VmSize:   200244 kB
    VmLck:         0 kB
    VmHWM:      3752 kB
    VmRSS:      3752 kB
    VmData:   118404 kB
    VmStk:        88 kB
    VmExe:        16 kB
    VmLib:     10888 kB
    VmPTE:       288 kB
    StaBrk: 0df5c000 kB
    Brk:    0e087000 kB
    StaStk: 7fffb0fea000 kB
    Threads:        5
    SigQ:   1/38784
    SigPnd: 0000000000000000
    ShdPnd: 0000000000000000
    SigBlk: 0000000000000000
    SigIgn: 0000000000381000
    SigCgt: 0000000180004a03
    CapInh: 0000000000000000
    CapPrm: 00000000fffffeff
    CapEff: 00000000fffffeff
    Cpus_allowed:   00000000,00000000,00000000,00000000,00000000,00000000,00000000,0000ffff
    Mems_allowed:   00000000,00000001
    [root@Betty conf]#
    其中
    ?
    1
    Threads:        5
    表示该进程下包含 5 个线程（3756 进程对应的线程 + 由其创建的工作线程）。
     
     
     
     
     
     
    方法一、
    cat /proc/${pid}/stat | awk '{print $20}'

    ps -Tfp PID


    3中方法：

    1. cat /proc/${pid}/status

    2. pstree -p ${pid}

    3. top -p ${pid} 再按H

        或者直接输入 top -bH -d 3 -p ${pid} 

     

    查看进程工作

    strace -p ${pid}

    开启iptables日志
    iptables -t raw -I PREROUTING 1 -p tcp --syn -m statistic --mode nth --every 5000 -j LOG --log-prefix "IPTABLES DETECTING SYN: "
    tail /var/log/message
    关闭iptables日志
    iptables -t raw -F

    查看是否被攻击
    netstat -n -p TCP | grep SYN_RECV | grep :80 | wc -l
    netstat -tn|grep ESTABLISH|wc -l 
    查出服务器是否受到DOS攻击 （看SYN_RECV）
    netstat -an |awk '{print $6}'|sort|uniq -c|sort -rn
       5116 TIME_WAIT
       1624 ESTABLISHED
        531 FIN_WAIT1
        512 FIN_WAIT2
        126 SYN_RECV
         10 CLOSING
          9 LISTEN

    查出服务器异常IP链接
    netstat -an | awk '{print $5}' | cut -d":" -f1 | sort | uniq -c | sort -rn | head

     
     
     
     
    使用 ps -Lf pid 查看对应进程下的线程数。
     
     
     
     
     

    在Linux中查看线程数的三种方法

    1、top -H
    手册中说：-H : Threads toggle
    加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。
    2、ps xH
    手册中说：H Show threads as if they were processes
    这样可以查看所有存在的线程。
    3、ps -mp <PID>
    手册中说：m Show threads after processes
    这样可以查看一个进程起的线程数。

    查看进程

    1. top 命令

    top命令查看系统的资源状况

    　　load average表示在过去的一段时间内有多少个进程企图独占CPU

    　　zombie 进程 ：不是异常情况。一个进程从创建到结束在最后那一段时间遍是僵尸。留在内存中等待父进程取的东西便是僵尸。任何程序都有僵尸状态，它占用一点内存资源，仅 仅是表象而已不必害怕。如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。kill是无任何效果的stop模式：与sleep进程应区 别，sleep会主动放弃cpu，而stop是被动放弃cpu ，例单步跟踪，stop(暂停)的进程是无法自己回到运行状态的。

    　　cpu states：

    　　nice：让出百分比irq：中断处理占用

    　　idle：空间占用百分比 iowait：输入输出等待(如果它很大说明外存有瓶颈，需要升级硬盘(SCSI))

    　　Mem：内存情况

    　　设计思想：把资源省下来不用便是浪费，如添加内存后free值会不变，buff值会增大。 判断物理内存够不够，看交换分区的使用状态。

    　　交互命令：

    　　[Space]立即刷新显示

    　　[h]显示帮助屏幕

    　　[k] 杀死某进程。你会被提示输入进程 ID 以及要发送给它的信号。 一般的终止进程可以使用15信号;如果不能正常结束那就使用信号9强制结束该进程。默认值是信号15。在安全模式中此命令被屏蔽。

    　　[n] 改变显示的进程数量。你会被提示输入数量。

    　　[u] 按用户排序。

    　　[M] 按内存用量排序。

    　　[o][O] 改变显示项目的顺序。

    　　[P] 根据CPU使用百分比大小进行排序。

    　　[T] 根据时间/累计时间进行排序。

    　　[Ctrl+L] 擦除并且重写屏幕。

    　　[q] 退出程序。

    　　[r] 重新安排一个进程的优先级别。系统提示用户输入需要改变的进程PID以及需要设置的进程优先级值。输入一个正值将使优先级降低，反之则可以使该进程拥有更高的优先权。默认值是10。

    　　[S] 切换到累计模式。

    　　[s] 改变两次刷新之间的延迟时间。系统将提示用户输入新的时间，单位为s。如果有小数，就换算成m s。输入0值则系统将不断刷新，默认值是5 s。需要注意的是如果设置太小的时间，很可能会引起不断刷新，从而根本来不及看清显示的情况，而且系统负载也会大大增加。

    　　缩写含义：

    　　PID每个进程的ID

    　　USER进程所有者的用户名

    　　PRI每个进程的优先级别

    　　NI每个优先级的值

    　　SIZE 进程的代码大小加上数据大小再加上堆栈空间大小的总数，单位是KB RSS 进程占用的物理内存的总数量，单位是KB

    　　SHARE进程使用共享内存的数量

    　　STAT 进程的状态。其中S代表休眠状态;D代表不可中断的休眠状态;R代表运行状态;Z代表僵死状态;T代表停止或跟踪状态

    　　%CPU进程自最近一次刷新以来所占用的CPU时间和总时间的百分比

    　　%MEM进程占用的物理内存占总内存的百分比

    　　TIME进程自启动以来所占用的总CPU时间

    　　CPU CPU标识

    　　COMMAND进程的命令名称

    2. ps命令

    ps查看当前用户的活动进程，如果加上参数可以显示更多的信息，如-a，显示所有用户的进程


    　　ps ax ：tty值为“?”是守护进程，叫deamon 无终端，大多系统服务是此进程，内核态进程是看不到的

          ps axf ：看进程树，以树形方式现实进程列表敲 ，init是1号进程，系统所有进程都是它派生的，杀不掉

          ps axm ：会把线程列出来。在linux下进程和线程是统一的，是轻量级进程的两种方式。

    　　ps axu ：显示进程的详细状态。

    　　vsz：说此进程一共占用了多大物理内存。

    　　rss：请求常驻内存多少

    查看线程

    其实linux没有线程，都是用进程模仿的

    1. ps -ef f
    用树形显示进程和线程，比如说我想找到proftp现在有多少个进程/线程，可以用
    $ ps -ef f | grep proftpd
    nobody 23117 1 0 Dec23 ? S 0:00 proftpd:  (accepting  connections) 
    jack 23121 23117 0 Dec23 ? S 7:57 \_ proftpd: jack - ftpsrv:  IDLE
    jack 28944 23117 0 Dec23 ? S 4:56 \_ proftpd: jack - ftpsrv:  IDLE
    这样就可以看到proftpd这个进程下面挂了两个线程。
    在Linux下面好像因为没有真正的线程，是用进程模拟的，有一个是辅助线程，所以真正程序开的线程应该只有一个。

    2. pstree -c也可以达到相同的效果
    $ pstree -c | grep proftpd
    |-proftpd-+-proftpd
    | `-proftpd

    3. cat /proc/${pid}/status
    可以查看大致的情况

    4.  pstack

    有些系统可以用这个东东，可以查看所有线程的堆栈

    如何查看进程中各线程的内存占用情况？

    用ps aux只能查看到进程，如果进程里面使用了pthread编程，用什么命令才能查询到进程里的线程资源占用？
    ps aux | grep不就是了

     
     
     
     
     
     
    TOP  -pid
     
     
     
    MAC实用工具里有一个活动监视器。
     
     
     
     
     

    本文主要介绍在CentOS系统上查看进程的线程数方法。

    方法一 pstack命令(推荐)

    首先得到进程的pid

    使用如下命令即可得出该进程的线程数

    # pstack pid |grep LWP |wc -l

    方法二 top查看 (最实用的实时监控)
    # ps -aux|grep IASTool (查找进程的pid)

    # top -p pid

    #输入H （显示Show threads On）即会显示该进程的线程

    1、top -H
    手册中说：-H : Threads toggle
    加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。

    2、ps xH
    手册中说：H Show threads as if they were processes
    这样可以查看所有存在的线程。

    3、ps -mp <PID>
    手册中说：m Show threads after processes
    这样可以查看一个进程起的线程数。

    更多详尽的解释还可以man ps，man top。

    如何在Linux中统计一个进程的线程数

    问题：我正在运行一个程序，它在运行时会派生出多个线程。我想知道程序在运行时会有多少线程。在 Linux 中检查进程的线程数最简单的方法是什么？

    如果你想看到 Linux 中每个进程的线程数，有以下两种方法可以做到这一点。

    方法一: /proc

    proc 伪文件系统，它驻留在 /proc 目录，这是最简单的方法来查看任何活动进程的线程数。 /proc 目录以可读文本文件形式输出，提供现有进程和系统硬件相关的信息如 CPU、中断、内存、磁盘等等。

    1. $ cat /proc/<pid>/status

    上面的命令将显示进程 <pid> 的详细信息，包括过程状态（例如, sleeping, running)，父进程 PID，UID，GID，使用的文件描述符的数量，以及上下文切换的数量。输出也包括进程创建的总线程数如下所示。

    1. Threads: <N>

    例如，检查 PID 20571进程的线程数：

    1. $ cat /proc/20571/status

    输出表明该进程有28个线程。

    或者，你可以在 /proc//task 中简单的统计子目录的数量，如下所示。

    1. $ ls /proc/<pid>/task | wc

    这是因为，对于一个进程中创建的每个线程，在 /proc/<pid>/task 中会创建一个相应的目录，命名为其线程 ID。由此在 /proc/<pid>/task 中目录的总数表示在进程中线程的数目。

    方法二: ps

    如果你是功能强大的 ps 命令的忠实用户，这个命令也可以告诉你一个进程（用“H”选项）的线程数。下面的命令将输出进程的线程数。“h”选项需要放在前面。

    1. $ ps hH p <pid> | wc -l

    Linux查看进程运行的完整路径方法

    通过ps及top命令查看进程信息时，只能查到相对路径，查不到的进程的详细信息，如绝对路径等。这时，我们需要通过以下的方法来查看进程的详细信息：

    Linux在启动一个进程时，系统会在/proc下创建一个以PID命名的文件夹，在该文件夹下会有我们的进程的信息，其中包括一个名为exe的文件即记录了绝对路径，通过ll或ls –l命令即可查看。

    ll /proc/PID

    cwd符号链接的是进程运行目录；

    exe符号连接就是执行程序的绝对路径；

    cmdline就是程序运行时输入的命令行命令；

    environ记录了进程运行时的环境变量；

    fd目录下是进程打开或使用的文件的符号连接。

    CreateToolhelp32Snapshot可以通过获取进程信息为指定的进程、进程使用的堆[HEAP]、模块[MODULE]、线程建立一个快照。

    函数通过获取进程信息为指定的进程、进程使用的堆[HEAP]、模块[MODULE]、线程建立一个快照.
    说到底，可以获取系统中正在运行的进程信息，线程信息，等
    #include "StdAfx.h"
    #include "windows.h"
    #include "tlhelp32.h"
    #include "stdio.h"
    int main(int argc, char* argv[])
    {
    PROCESSENTRY32 pe32;
    //在使用这个结构前，先设置它的大小
    pe32.dwSize = sizeof(pe32);
    //给系统内所有的进程拍个快照
    HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
    {
    printf("CreateToolhelp32Snapshot 调用失败. ");
    return -1;
    }
    //遍历进程快照，轮流显示每个进程的信息
    BOOL bMore = ::Process32First(hProcessSnap,&pe32);
    while (bMore)
    {
    printf("进程名称：%ls ",pe32.szExeFile); //这里得到的应该是宽字符，用%ls,不然无法正常打印
    printf("进程ID：%u ",pe32.th32ProcessID);
    bMore = ::Process32Next(hProcessSnap,&pe32);
    }
    //不要忘记清除掉snapshot对象
    ::CloseHandle(hProcessSnap);
    return 0;
    }
     
     
     

    Linux下查看进程和线程的方法，linux查看进程线程


    这篇文章主要介绍了Linux下查看进程和线程的方法,需要的朋友可以参考下
     

    在Linux中查看线程数的三种方法

    1、top -H
    手册中说：-H : Threads toggle
    加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。
    2、ps xH
    手册中说：H Show threads as if they were processes
    这样可以查看所有存在的线程。
    3、ps -mp <PID>
    手册中说：m Show threads after processes
    这样可以查看一个进程起的线程数。

    查看进程

    1. top 命令

    top命令查看系统的资源状况

    　　load average表示在过去的一段时间内有多少个进程企图独占CPU

    　　zombie 进程 ：不是异常情况。一个进程从创建到结束在最后那一段时间遍是僵尸。留在内存中等待父进程取的东西便是僵尸。任何程序都有僵尸状态，它占用一点内存资源，仅 仅是表象而已不必害怕。如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。kill是无任何效果的stop模式：与sleep进程应区 别，sleep会主动放弃cpu，而stop是被动放弃cpu ，例单步跟踪，stop(暂停)的进程是无法自己回到运行状态的。

    　　cpu states：

    　　nice：让出百分比irq：中断处理占用

    　　idle：空间占用百分比 iowait：输入输出等待(如果它很大说明外存有瓶颈，需要升级硬盘(SCSI))

    　　Mem：内存情况

    　　设计思想：把资源省下来不用便是浪费，如添加内存后free值会不变，buff值会增大。 判断物理内存够不够，看交换分区的使用状态。

    　　交互命令：

    　　[Space]立即刷新显示

    　　[h]显示帮助屏幕

    　　[k] 杀死某进程。你会被提示输入进程 ID 以及要发送给它的信号。 一般的终止进程可以使用15信号;如果不能正常结束那就使用信号9强制结束该进程。默认值是信号15。在安全模式中此命令被屏蔽。

    　　[n] 改变显示的进程数量。你会被提示输入数量。

    　　[u] 按用户排序。

    　　[M] 按内存用量排序。

    　　[o][O] 改变显示项目的顺序。

    　　[P] 根据CPU使用百分比大小进行排序。

    　　[T] 根据时间/累计时间进行排序。

    　　[Ctrl+L] 擦除并且重写屏幕。

    　　[q] 退出程序。

    　　[r] 重新安排一个进程的优先级别。系统提示用户输入需要改变的进程PID以及需要设置的进程优先级值。输入一个正值将使优先级降低，反之则可以使该进程拥有更高的优先权。默认值是10。

    　　[S] 切换到累计模式。

    　　[s] 改变两次刷新之间的延迟时间。系统将提示用户输入新的时间，单位为s。如果有小数，就换算成m s。输入0值则系统将不断刷新，默认值是5 s。需要注意的是如果设置太小的时间，很可能会引起不断刷新，从而根本来不及看清显示的情况，而且系统负载也会大大增加。

    　　缩写含义：

    　　PID每个进程的ID

    　　USER进程所有者的用户名

    　　PRI每个进程的优先级别

    　　NI每个优先级的值

    　　SIZE 进程的代码大小加上数据大小再加上堆栈空间大小的总数，单位是KB RSS 进程占用的物理内存的总数量，单位是KB

    　　SHARE进程使用共享内存的数量

    　　STAT 进程的状态。其中S代表休眠状态;D代表不可中断的休眠状态;R代表运行状态;Z代表僵死状态;T代表停止或跟踪状态

    　　%CPU进程自最近一次刷新以来所占用的CPU时间和总时间的百分比

    　　%MEM进程占用的物理内存占总内存的百分比

    　　TIME进程自启动以来所占用的总CPU时间

    　　CPU CPU标识

    　　COMMAND进程的命令名称

    2. ps命令

    ps查看当前用户的活动进程，如果加上参数可以显示更多的信息，如-a，显示所有用户的进程


    　　ps ax ：tty值为“?”是守护进程，叫deamon 无终端，大多系统服务是此进程，内核态进程是看不到的

          ps axf ：看进程树，以树形方式现实进程列表敲 ，init是1号进程，系统所有进程都是它派生的，杀不掉

          ps axm ：会把线程列出来。在linux下进程和线程是统一的，是轻量级进程的两种方式。

    　　ps axu ：显示进程的详细状态。

    　　vsz：说此进程一共占用了多大物理内存。

    　　rss：请求常驻内存多少

    查看线程

    其实linux没有线程，都是用进程模仿的

    1. ps -ef f
    用树形显示进程和线程，比如说我想找到proftp现在有多少个进程/线程，可以用

    $ ps -ef f | grep proftpd
    nobody 23117 1 0 Dec23 ? S 0:00 proftpd:  (accepting  connections) 
    jack 23121 23117 0 Dec23 ? S 7:57 \_ proftpd: jack - ftpsrv:  IDLE
    jack 28944 23117 0 Dec23 ? S 4:56 \_ proftpd: jack - ftpsrv:  IDLE

    这样就可以看到proftpd这个进程下面挂了两个线程。
    在Linux下面好像因为没有真正的线程，是用进程模拟的，有一个是辅助线程，所以真正程序开的线程应该只有一个。

    2. pstree -c也可以达到相同的效果
    $ pstree -c | grep proftpd
    |-proftpd-+-proftpd
    | `-proftpd

    3. cat /proc/${pid}/status
    可以查看大致的情况

    4.  pstack

    有些系统可以用这个东东，可以查看所有线程的堆栈

    如何查看进程中各线程的内存占用情况？

    用ps aux只能查看到进程，如果进程里面使用了pthread编程，用什么命令才能查询到进程里的线程资源占用？
    ps aux | grep不就是了

     
     

    已Nginx为例：

    方法一：

    1.pstree -p 14686（PID）

     获取到nginx的四个子进程（或 ps -ef |grep nginx）

    2. cat /proc/15178（PID）/status

    threads即为线程数：


    方法二：

    ps -eL -o pid,%cpu,lwp|grep -i pid


     

    LINUX最大线程数及最大进程数

    2013-12-12 08:17:25cnblogs.com-roucheng-点击数:591
     

    查看最大线程数：

    cat /proc/sys/kernel/threads-max

    ulimit

    User limits - limit the use of system-wide resources.

    Syntax
    ulimit [-acdfHlmnpsStuv] [limit]

    Options

    -S Change and report the soft limit associated with a resource. 
    -H Change and report the hard limit associated with a resource. 

    -a All current limits are reported. 
    -c The maximum size of core files created. 
    -d The maximum size of a process's data segment. 
    -f The maximum size of files created by the shell(default option) 
    -l The maximum size that may be locked into memory. 
    -m The maximum resident set size. 
    -n The maximum number of open file descriptors. 
    -p The pipe buffer size. 
    -s The maximum stack size. 
    -t The maximum amount of cpu time in seconds. 
    -u The maximum number of processes available to a single user. 
    -v The maximum amount of virtual memory available to the process. 

    ulimit provides control over the resources available to the shell and to processes started by it, on systems that allow such control.

    If limit is given, it is the new value of the specified resource. Otherwise, the current value of the soft limit for the specified resource is printed, unless the `-H' option is supplied.

    When setting new limits, if neither `-H' nor `-S' is supplied, both the hard and soft limits are set.

    Values are in 1024-byte increments, except for `-t', which is in seconds, `-p', which is in units of 512-byte blocks, and `-n' and `-u', which are unscaled values.

    The return status is zero unless an invalid option is supplied, a non-numeric argument other than unlimited is supplied as a limit, or an error occurs while setting a new limit.

    ulimit is a bash built in command.

    Ulimit命令
    设置限制 可以把命令加到profile文件里，也可以在/etc/security/limits.conf文件中定义
    限制。
    命令参数
    -a 显示所有限制
    -c core文件大小的上限
    -d 进程数据段大小的上限
    -f shell所能创建的文件大小的上限
    -m 驻留内存大小的上限
    -s 堆栈大小的上限
    -t 每秒可占用的CPU时间上限
    -p 管道大小
    -n 打开文件数的上限
    -u 进程数的上限
    -v 虚拟内存的上限
    除可用Ulimit命令设置外，也可以在/etc/security/limits.conf文件中定义限制。
    domino type item value
    domino是以符号@开头的用户名或组名，*表示所有用户，type设置为hard or soft。item指
    定想限制的资源。如cpu,core nproc or maxlogins。value是相应的限制值。

    系统限制默认值

    [root@flyinweb ~]# ulimit -a 
    core file size (blocks, -c) 0 
    data seg size (kbytes, -d) unlimited 
    scheduling priority (-e) 0 
    file size (blocks, -f) unlimited 
    pending signals (-i) 32764 
    max locked memory (kbytes, -l) 32 
    max memory size (kbytes, -m) unlimited 
    open files (-n) 1024 
    pipe size (512 bytes, -p) 8 
    POSIX message queues (bytes, -q) 819200 
    real-time priority (-r) 0 
    stack size (kbytes, -s) 10240 
    cpu time (seconds, -t) unlimited 
    max user processes (-u) 32764 
    virtual memory (kbytes, -v) unlimited 
    file locks (-x) unlimited[root@flyinweb ~]# lsb_release -a 
    LSB Version: :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch 
    Distributor ID: CentOS 
    Description: CentOS release 5.2 (Final) 
    Release: 5.2 
    Codename: Final

    linux 系统中单个进程的最大线程数有其最大的限制 PTHREAD_THREADS_MAX

    这个限制可以在 /usr/include/bits/local_lim.h 中查看

    对 linuxthreads 这个值一般是 1024，对于 nptl 则没有硬性的限制，仅仅受限于系统的资源

    这个系统的资源主要就是线程的 stack 所占用的内存，用 ulimit -s 可以查看默认的线程栈大小，一般情况下，这个值是 8M

    可以写一段简单的代码验证最多可以创建多少个线程

    int main() { int i = 0; pthread_t thread; while (1) { if (pthread_create(&thread, NULL, foo, NULL) != 0) return; i ++; printf("i = %d/n", i); } }


    试验显示，在 linuxthreads 上最多可以创建 381 个线程，之后就会返回 EAGAIN

    在 nptl 上最多可以创建 382 个线程，之后就会返回 ENOMEM

    这个值和理论完全相符，因为 32 位 linux 下的进程用户空间是 3G 的大小，也就是 3072M，用 3072M 除以 8M 得 384，但是实际上代码段和数据段等还要占用一些空间，这个值应该向下取整到 383，再减去主线程，得到 382。

    那为什么 linuxthreads 上还要少一个线程呢？这可太对了，因为 linuxthreads 还需要一个管理线程
    http://www.cnblogs.com/roucheng/
    为了突破内存的限制，可以有两种方法

    1) 用 ulimit -s 1024 减小默认的栈大小
    2) 调用 pthread_create 的时候用 pthread_attr_getstacksize 设置一个较小的栈大小

    要注意的是，即使这样的也无法突破 1024 个线程的硬限制，除非重新编译 C 库

    相关内容：

    一、2.4内核与2.6内核的主要区别 
    在 2.4内核的典型系统上（AS3/RH9），线程是用轻量进程实现的，每个线程要占用一个进程ID，在服务器程序上，如果遇到高点击率访问，会造成进程表 溢出，系统为了维护溢出的进程表，会有间歇的暂停服务现象，而2.6内核就不会发生由于大量线程的创建和销毁导致进程表溢出的问题二、线程结束必须释放线 程堆栈 
    就 是说，线程函数必 须调用pthread_exit()结束，否则直到主进程函数退出才释放，特别是2.6内核环境，线程创建速度飞快，一不小心立刻内存被 吃光，这一点反倒是2.4内核环境好，因为2.4内核创建的是进程，而且线程创建速度比2.6内核慢几个数量级。特别提醒，在64位CPU，2.6内核创 建线程的速度更加疯狂，要是太快的话，加上usleep ()暂停一点点时间比较好三、不要编需要锁的线程应用 
    只 有那些不需要互斥量的程序才能最大限度的利用线程编程带来的好处，否则只会更慢，2.6内核是抢占式内核，线程间共享冲突发生的几率远比2.4内核环境 高，尤其要注意线程安全，否则就算是单CPU也会发生莫名其妙的内存不同步（CPU的高速缓存和主存内容不一致），Intel的新CPU为了性能使用 NUMA架构，在线程编程中一定要注意扬长避短。四、单进程服务器最大并发线程数与内存 
    很有趣，在默认的ulimit参数下，不修改内核头文件 
    AS3 512M内存最多1000并发持续连接 
    CentOS4.3 512M内存最多300并发持续连接 
    似 乎是CentOS不如AS3，这里主要原因是ulimit的配置造成，两个系统默认的配置差距很大，要想单进程维持更多线程接收并发连接，就要尽量缩小 ulimit -s的参数，插更多的内存条，单进程服务器上2000并发一点都不难，POSIX默认的限制是每进程64线程，但NTPL并非纯正POSIX，不必理会这 个限制，2.6内核下真正的限制是内存条的插槽数目（也许还有买内存的钱数）最 近几天的编程中， 注意到在32位x86平台上2.6内核单进程创建最大线程数＝VIRT上限／stack，与总内存数关系不大，32位x86系统默认的 VIRT上限是3G（内存分配的3G+1G方式），默认 stack大小是10240K，因此单进程创建线程默认上限也就300（3072M / 10240K），用ulimit -s 修改stack到1024K则使上限升到大约3050。我手头没有64位系统，不知道2.6内核在64位上单进程创建线程上限（实际上是本人懒得在同事的 机器上装fc4_x86_64）。前些天买了一套廉价的64位x86系统(64位赛杨+杂牌915主板),安装了CentOS4.3的x86_64版本, 跑了一遍下面的小程序,得到的结果是:在ulimit -s 4096的情况下,单进程最大线程数在16000多一点,用top看 
    VIRT 的上限是64G,也就是36位, cat /proc/cpuinfo的结果是:address sizes : 36 bits physical, 48 bits virtual, 和我想象的标准64位系统不同, 我一直以为64位系统的内存空间也是64位的 
    附注1： 
    单 位里某BSD FANS用AMD64笔记本跑小程序测试线程创建速度（线程创建后立即phread_detach()然后紧跟着pthread_exit()，共计 100万个线程），同样源码OpenBSD竟然比FreeBSD快了3倍，什么时候OpenBSD也变得疯狂起来了？
     
     
     
     

    MySQL服务器的线程数查看方法

    新客网 XKER.COM 时间:2010-11-20 14:37:35  评论:
    0
    条
     

    MySQL服务器的线程数需要在一个合理的范围之内，这样才能保证MySQL服务器健康平稳地运行。Threads_created表示创建过的线程数，通过查看Threads_created就可以查看MySQL服务器的进程状态。

    1. mysql> show global status like 'Thread%';  
    2. +-------------------+-------+  
    3. | Variable_name | Value |  
    4. +-------------------+-------+  
    5. | Threads_cached | 46 |  
    6. | Threads_connected | 2 |  
    7. | Threads_created | 570 |  
    8. | Threads_running | 1 |  
    9. +-------------------+-------+ 

    如果我们在MySQL服务器配置文件中设置了thread_cache_size，当客户端断开之后，服务器处理此客户的线程将会缓存起来以响应下一个客户而不是销毁(前提是缓存数未达上限)。

    Threads_created表示创建过的线程数，如果发现Threads_created值过大的话，表明MySQL服务器一直在创建线程，这也是比较耗资源，可以适当增加配置文件中thread_cache_size值，查询服务器
    thread_cache_size配置：

    1. mysql> show variables like 'thread_cache_size';  
    2. +-------------------+-------+  
    3. | Variable_name | Value |  
    4. +-------------------+-------+  
    5. | thread_cache_size | 64 |  
    6. +-------------------+-------+ 

    示例中的服务器还是挺健康的。

     
     
     

    有些时候需要确实进程内部当前运行着多少线程，那么以下几个方法值得一用。

    1.根据进程号进行查询：

    # pstree -p 进程号

    # top -Hp 进程号

    2.根据进程名字进行查询：

    # pstree -p `ps -e | grep server | awk '{print $$1}'`

    # pstree -p `ps -e | grep server | awk '{print $$1}'` | wc -l

    这里利用了管道和命令替换，

    关于命令替换，我也是今天才了解，就是说用``括起来的命令会优先执行，然后以其输出作为其他命令的参数，

    上述就是用 ps -e | grep server | awk '{print $$1}' 的输出（进程号），作为 pstree -p 的参数

    管道和命令替换的区别是：

    管道：管道符号"|"左边命令的输出作为右边命令的输入

    命令替换：将命令替换符"``"中命令的输出作为其他命令相应位置的参数

     
     
     

    pslist是用命令行查看线程；ProcessExplorer是图形化的查看线程，都在附件中。

    1.查看进程

         tasklist 

    or  pslist -t

    Name                             Pid Pri Thd  Hnd      VM      WS    Priv
    Idle                               0   0   2    0       0      28       0
      System                           4   8  69 1222    1824     308       0
        smss                         832  11   3   20    3748     408     172
          csrss                      900  13  12  807   72428   16152    2568
          winlogon                   924  13  21  516   61272    4704    8536
            services                 968   9  15  280   22556    4516    1868
              avp                    256   8  36 7185  190528   22332   50308
    explorer                        2060   8  16  575  122880   13400   17752
      msnmsgr                       1604   8  33  778  222560   19240   32792
      cmd                           3680   8   1   31   31084    3004    2164
        pslist                      5476  13   2   91   30500    2744    1236
      notepad                       4276   8   1   45   33692    3956    1344
      IEXPLORE                      5184   8  61 2143  403392   31236  105436
      eclipse                       6088   8   1   33   29884    3184     960
        javaw                       4484   8  40 1197  729124  139424  193496
          javaw                     4252   8  11(十一个线程)  310  187820    8080   13908

    2.查看进程中的线程 http://technet.microsoft.com/en-us/sysinternals/bb896682.aspx

    pslist -dmx 4252

    Name                Pid      VM      WS    Priv Priv Pk   Faults   NonP Page
    javaw              4252  202224   21848   23968   24476     7927      4   47
     Tid Pri    Cswtch            State     User Time   Kernel Time   Elapsed Time
    5428   8      2617     Wait:UserReq  0:00:01.312   0:00:00.515    0:06:41.625
    5312  15       614     Wait:UserReq  0:00:00.078   0:00:00.000    0:06:41.484
    1380  15         7     Wait:UserReq  0:00:00.000   0:00:00.000    0:06:41.468
    2012  10         7     Wait:UserReq  0:00:00.000   0:00:00.000    0:06:41.468
    3876   9      1037     Wait:UserReq  0:00:00.046   0:00:00.187    0:06:41.187
    5884   9        65     Wait:UserReq  0:00:00.000   0:00:00.015    0:06:41.187
    4444  10       236     Wait:UserReq  0:00:00.000   0:00:00.015    0:06:41.171
    4564  15        12     Wait:UserReq  0:00:00.000   0:00:00.000    0:06:40.953
    4644  15       270     Wait:UserReq  0:00:00.234   0:00:00.015    0:06:40.953
    4292   8         5     Wait:UserReq  0:00:00.000   0:00:00.000    0:06:40.953
    5964  15      6422   Wait:DelayExec  0:00:00.000   0:00:00.000    0:06:40.937

    Introduction

    pslist exp would show statistics for all the processes that start with "exp", which would include Explorer.
    -d Show thread detail.
    -m Show memory detail.
    -x Show processes, memory information and threads.
    -t Show process tree.
    -s [n] Run in task-manager mode, for optional seconds specified. Press Escape to abort.
    -r n Task-manager mode refresh rate in seconds (default is 1).
    \computer Instead of showing process information for the local system, PsList will show information for the NT/Win2K system specified. Include the -u switch with a username and password to login to the remote system if your security credentials do not permit you to obtain performance counter information from the remote system.
    -u username If you want to kill a process on a remote system and the account you are executing in does not have administrative privileges on the remote system then you must login as an administrator using this command-line option. If you do not include the password with the -p option then PsList will prompt you for the password without echoing your input to the display.
    -p password This option lets you specify the login password on the command line so that you can use PsList from batch files. If you specify an account name and omit the -p option PsList prompts you interactively for a password.
    name Show information about processes that begin with the name specified.
    -e Exact match the process name.
    pid Instead of listing all the running processes in the system, this parameter narrows PsList's scan to tthe process that has the specified PID. Thus:
    pslist 53
    would dump statistics for the process with the PID 53.

    How it Works

    Like Windows NT/2K's built-in PerfMon monitoring tool, PsList uses the Windows NT/2K performance counters to obtain the information it displays. You can find documentation for Windows NT/2K performance counters, including the source code to Windows NT's built-in performance monitor, PerfMon, in MSDN.

    Memory Abbreviation Key

    All memory values are displayed in KB.

    • Pri: Priority
    • Thd: Number of Threads
    • Hnd: Number of Handles
    • VM: Virtual Memory
    • WS: Working Set
    • Priv: Private Virtual Memory
    • Priv Pk: Private Virtual Memory Peak
    • Faults: Page Faults
    • NonP: Non-Paged Pool
    • Page: Paged Pool
    • Cswtch: Context Switches

    以下是非Windows系统本身附带的外部命令，均存放于光盘 PE 系统目录下的 System32 目录下。 

    AUTORAMRESIZER.EXE 自动根据物理内存调整虚拟盘大小（PE）。 
    CHOICE.EXE DOS 选择命令支持扩展 
    DEVCON.EXE 设备控制台命令行工具 
    FINDPASS.EXE 查找系统管理员口令的命令行工具（可能有病毒虚警） 
    FPORT.EXE TCP/IP与端口检测工具 
    HWPnp.exe 重新检测即插即用硬件的实用工具，可激活移动存储器等 
    KEYBOARD.EXE 更改键盘区域属性的命令行工具 
    KEYDOWN.EXE 检测键盘按键的命令行工具 
    NC.EXE 大名鼎鼎的网络强力命令行工具！ 
    NETCFG.EXE Windows PE 环境的网络配置命令行工具 
    PASSWDRENEW.EXE Windows 口令离线修改工具 
    PENETCFG.EXE 牛人编写的 PE 网络环境配置工具 
    PSINFO.EXE 本地和远程系统信息检测命令行工具 
    PSKILL.EXE 结束本地或远程进程的命令行工具 
    PSLIST.EXE 系统进程查看工具 
    PSPASSWD.EXE 更改本地或远程系统口令命令行工具 
    PSSERVICE.EXE 管理系统服务的命令行工具 
    PULIST.EXE 系统进程列表查看 
    TCPVCON.EXE 查看活动进程的TCP连接状态 
    TFTPD32.EXE 简单的 TFTP 工具 
    WGET.EXE 功能强大的命令行下载工具 
    XCACLS.EXE 文件及目录访问控制列表的命令行加强工具 
    XNVIEW.EXE 袖珍图像查看工具（小巧够用，不需升级）

    1、总结系统限制有：

    /proc/sys/kernel/pid_max #查系统支持的最大线程数，一般会很大，相当于理论值
    /proc/sys/kernel/thread-max
    max_user_process（ulimit -u） #系统限制某用户下最多可以运行多少进程或线程
    /proc/sys/vm/max_map_count
    硬件内存大小


    2、Java虚拟机本身限制：
    -Xms #intial java heap size
    -Xmx #maximum java heap size
    -Xss #the stack size for each thread


    3、查询当前某程序的线程或进程数
    pstree -p `ps -e | grep java | awk '{print $1}'` | wc -l
    或
    pstree -p 3660 | wc -l


    4、查询当前整个

    系统已用的线程或进程数
     

    pstree -p | wc -l

    1、 cat /proc/${pid}/status

    2、pstree -p ${pid}

    3、top -p ${pid} 再按H 或者直接输入 top -bH -d 3 -p ${pid}

    top -H
    手册中说：-H : Threads toggle
    加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。

    4、ps xH
    手册中说：H Show threads as if they were processes
    这样可以查看所有存在的线程。

    5、ps -mp <PID>
    手册中说：m Show threads after processes
    这样可以查看一个进程起的线程数。

    1、总结系统限制有：

    /proc/sys/kernel/pid_max #查系统支持的最大线程数，一般会很大，相当于理论值

    /proc/sys/kernel/thread-max

    max_user_process（ulimit -u） #系统限制某用户下最多可以运行多少进程或线程

    /proc/sys/vm/max_map_count

    硬件内存大小

    2、Java虚拟机本身限制：

    -Xms  #intial java heap size

    -Xmx  #maximum java heap size

    -Xss  #the stack size for each thread

    3、查询当前某程序的线程或进程数

    pstree -p ps -e | grep java | awk '{print $1}' | wc -l

    或

    pstree -p 3660 | wc -l

    4、查询当前整个系统已用的线程或进程数

    pstree -p | wc -l

    1、 cat /proc/${pid}/status

    2、pstree -p ${pid}

    3、top -p ${pid} 再按H  或者直接输入 top -bH -d 3 -p  ${pid}

    top -H

    手册中说：-H : Threads toggle

    加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。

    4、ps xH

    手册中说：H Show threads as if they were processes

    这样可以查看所有存在的线程。

    5、ps -mp <PID>

    手册中说：m Show threads after processes

    这样可以查看一个进程起的线程数。
  • 相关阅读:
    漏斗算法 java
    servlet request参数只能取一次解决方法
    redis的使用
    关于Http协议与TCP协议的一些简单理解
    OSI七层与TCP/IP五层网络架构详解
    linux命令详解——eval
    使用apache benchmark(ab) 测试报错: apr_socket_recv: Connection timed out (110)
    hadoop相关随记
    mesos-master启动失败，报错Failed to load unknown flag 'quorum.rpmsave'
    根目录/缺少执行权限x产生的两种错误
  • 原文地址：https://www.cnblogs.com/timssd/p/4966102.html
Copyright © 2011-2022 走看看