ps 和 top

ps

进程和线程的关系：

（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。

（3）处理机分给线程，即真正在处理机上运行的是线程。

（4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体.

程序是静态的文件，进程是动态的（运行的程序）

一个程序至少有一个进程，一个进程至少有一个线程，进程之间内存是独立的，线程之间内存共享，高并发高一些（工作效率高），安全性差一些

一个内存的使用出现故障，不会对另一个进程的使用造成影响

查看进程树

pstree -p | more 显示进程号（pid）父进程--子进程--子进程（显示出pid）

pstree显示进程的树状结构，-p显示所有进程的pid

tree（显示一个目录下，目录或文件是树状结构）

rpm -ivh /mnt/Packages/tree-1.6.0-10.e17.x86_.rpm（以绝对路径下载rpm包）

yum provides tree

tree -Ld 1 -L 1 只显示1级目录 -d 只显示目录

#显示
ps -aux  列出目前所有的正在内存当中的进程 (加不加- 显示不同)（默认以pid排序）（显示11列）
   -a 显示所有的终端进程
   -x 显示所有的非终端进程
   -u 显示用户
   -o 显示出指定的列（或字段）
   -f 显示主从关系

ps -axo tty   (显示终端进程，非终端进程，也就是所有进程的tty端口号)

[root@oldboy ~]# ps
   PID TTY          TIME CMD
 22956 pts/0    00:00:00 bash
 23230 pts/0    00:00:00 ps
 [root@oldboy ~]# ps ef
   PID TTY      STAT   TIME COMMAND
 22956 pts/0    Ss     0:00 -bash USER=root LOGNAME=root HOME=/root PATH=/usr/local/sbin:/us
 [root@oldboy ~]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 04:15 ?        00:00:01 /usr/lib/systemd/systemd --switched-root --
root          2      0  0 04:15 ?        00:00:00 [kthreadd]

[root@oldboy ~]# ps aux  (-可以省略 )
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.0  0.3 125324  3580 ?        Ss   04:15   0:01 /usr/lib/systemd/systemd --
root          2  0.0  0.0      0     0 ?        S    04:15   0:00 [kthreadd]
root          4  0.0  0.0      0     0 ?        S<   04:15   0:00 [kworker/0:0H]

USER：启动该进程的用户
PID：进程的ID号
%CPU：占用cpu的百分比
%MEM：占用内存的百分比
VSZ：虚拟内存集（进程占用虚拟内存的空间）
RSS：真实物理内存（进程占用物理内存的空间）

TTY：运行的终端
	？：内核运行的终端
	tty：机器运行的终端
	pts/0：远程连接的终端

STAT：进程的状态：
        D:      #无法中断的休眠状态（通IO的进程）
        R:      #正在运行的状态
        S:      #处于休眠的状态
        T:      #暂停或被追踪的状态
        W:      #进入内存交换（从内核2.6开始无效）
        X:      #死掉的进程（少见）
        Z:      #僵尸进程
        <:      #优先级高的进程
        N:      #优先级较低的进程
        L:      #有些页被锁进内存
        s:      #父进程（在它之下有子进程开启着）
        l:      #以线程的方式运行
        |:      #多进程的
        +:      #该进程运行在前台
START：进程被触发启动的时间
TIME：进程实际使用cpu的时间
COMMAND：进程启动的命令 (nginx就是nginx,/app/sbin/nginx就是/app/sbin/nginx)
启动的方式

#排序
ps -aux --sort=pid  # 以pid的大小进行排序（正序）（默认pid，默认以数字的大小）（首数字左右123，23）（数字大小右左）
ps -aux --sort=-pid #以pid的大小倒叙
ps -aux --sort=%cpu #以cpu的大小进行排序（正序）
ps -aux --sort=%mem #以内存的大小进行排序（正序）
ps -aux --sort=vsz  #以虚拟内存的使用量进行排序（小写）

ps axo user,pid,%cpu,%mem,command # -o 显示出指定的列（或字段）
ps axo pid，ppid
[root@oldboy ~]# ps axfo user,pid,%cpu,%mem,command（爸爸和儿子）

ps auxf   #显示出主进程和子进程的关系
master process 主进程
worker process 子进程

[root@oldboy ~]# ps aux
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
[root@oldboy ~]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD

#批量显示指定的字段
[root@oldboy ~]# pgrep nginx  只列出当前nginx所有进程的pid (竖着列出来)
[root@oldboy ~]# pidof nginx   只列出当前nginx所有进程的pid (横着列出来)
8748 8888 9999

#拼凑
[root@oldboy ~]# pgrep nginx -l
8748 nginx
[root@oldboy ~]# pgrep nginx -la
8748 nginx worker process

[root@oldboy ~]# pidof nginx|xargs kill -9  杀掉nginx的主进程，所有子进程
[root@oldboy ~]# pstree  (su bash,查看当前终端的覆盖)
systemd (爸爸进程)

[root@oldboy ~]# ps -ef | grep nginx
[root@oldboy ~]# !ps
[root@oldboy ~]# ps -ef | grep [n]ginx  不显示原始行外所有,原理是ps不认识基本和扩展 正则表达式（【】）（ps字段）grep认识基本正则，不认识扩展正则
[a-z][a-c][l-p]
[root@oldboy ~]# ps -ef | grep -v grep

[root@oldboy ~]# vim /etc/profile.d/nginx.sh  #判断当前系统有没有运行nginx进程
#!/bin/bash
count_pro='ps -ef | grep [n]ginx | wc -l'  #自定义（数字）变量
if [ $count_pro -gt 0 ];then               #a=b,$a 出来b （小心空格）
	echo '存在nginx进程在运行'
else
	echo '没有nginx进程运行'
fi

echo 'export PATH="/app/nginx/sbin:$PATH"' >>/etc/profile.d/nginx.sh
# 让nginx加入全局环境变量，这样源码nginx就可以用systemctl命令管理了（记得source）

source

[root@oldboy ~]# ps aux
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          2  0.0  0.0      0     0 ?        S    04:59   0:00 [kthreadd]

[root@oldboy ~]# tty #tty是一个命令。显示当前系统的终端
/dev/pts/0

USER：运行此进程的用户名

PID：该process（进程）的号码

%CPU：该进程使用掉的cpu资源百分比

%MEM：该进程所占用的物理内存百分比

VSZ：该进程使用掉的虚拟内存量（kbytes）

RSS：该进程占用的固定的内存量（kbytes） ##

​		0表示进程是没用运行的，真正运行的进程会显示数字  #

TTY：该进程是在哪个终端机上面运作，若于终端机无关，则显示 ? ，另外，tty1-tty6 是本机上面的登入者程序，若为pts/0 等等的，则表示为由网络连接进主机的程序

STAT：该进程目前的状态，Linux进程有5种基本状态

​			R ：（正在运行或者在运行队列中等待的）

​			S  ： （sleep）该程序目前正在睡眠当中，但是随时可能被某些讯号唤醒

​			T   ： 该程序目前暂停了（CTRL+z放到后台的进程），ps -aux 可以找到

​			Z    ： 该程序应该已经终止，但是其父程序却无法正常的终止他，造成zombie   （  僵  尸） 程序的状态

​						关机--子进程--父进程--程序关闭

​			D   ： 不可中断状态，强行中断的话，可能会对系统产生一定的影响，甚至损坏硬件 （kill -9 ）

<  :高优先级的   首先执行的（老总--员工）

N ：低优先级的（忽略）

s ：包含子进程（Ss）

|  ：该进程是多线程的

+： 前台程序，比如vim a.txt ，可以看到的，就是一个前台程序，可以用CTRL+z 把前台程序掉到后台，也就是说暂停的进程就是一个后台进程

CTRL+c ：终止（停止）一个进程

CTRL+z ：挂起（暂停）一个进程（T）

START ：该进程被触发启动的时间

TIME ：该进程实际使用CPU运作的时间

COMMAND ：该进程的实际指令

[root@oldboy ~]# ps -aux               终端                       使用的命令
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
用户        进程号cpu 内存   占用虚拟内存 物理内存 运行状态     运行多长时间

root          1  0.0  0.3 125328  3748 ?        Ss   Apr29   0:00 /usr/lib/
root          2  0.0  0.0      0     0 ?        S    Apr29   0:00 [kthreadd

swapoff -a  关闭虚拟内存
swapon  -a
I/O  磁盘吞吐量，写入和读取

ps -ef 

显示风格不一样

[root@oldboy ~]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 Apr29 ?        00:00:00 /usr/lib/systemd/systemd --switched-
root          2      0  0 Apr29 ?        00:00:00 [kthreadd]

[root@oldboy ~]# vim /app/nginx/conf/nginx.conf
work_processes   10;  在配置文件这里可以修改为=cpu核心数,,(10个子进程)
[root@oldboy ~]# systemctl restart nginx

top

top  htop （高亮）

top - 09:10:31 up 1 day, 28 min,  1 user,  load average: 0.00, 0.01, 0.05
# 09:10:31          ：当前系统时间
# up 1 day, 28 min  ：系统运行时间
# 1 user            ：当前在线用户数量
# load average: 0.00, 0.01, 0.05
0.00 : 1分钟的负载
0.01 : 5分钟的负载
0.05 : 15分钟的负载

cpu核心数---队列长度---线程

Tasks: 105 total,   1 running, 104 sleeping,   0 stopped,   0 zombie
# 105 total    ： 总共有多少个工作任务
# 1 running    ： 1个在运行
# 104 sleeping ： 104个在等待
# 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
# 0.0 us ： 用户态 总体上来说，用户使用cpu的百分比
# 0.0 sy ： 内核态 总体上来说，用户占用cpu的百分比
# 0.0 ni ： 优先级 # nice值越高，进程的优先级越低
# 100.0 id ： cpu空闲百分比  #要适中
# 0.0 wa ：等待
# 0.0 hi ： 硬中断
# 0.0 si ： 软中断
# 0.0 st ： （虚拟产品KVM,vitural box,cen）（虚拟机占用物理机cpu百分比）

# top
-d：指定变化时间
[root@oldboy ~]# top -d 1  一秒一次

-p：只查看指定PID的进程
[root@oldboy ~]# top -p 18   查看pid是18的进程的详细信息

-u：只查看指定用户的进程
[root@oldboy ~]# top -u root

-b：保存到文件(把top命令的完整输出保存到文件中，开头--内容)
[root@oldboy ~]# top -b >123  更新一次保存一次(tail -f)

-n：指定次数
[root@oldboy ~]# top -bn 1 >123   更新一次保存一次，但是保存一次

# top 常见指令
h   查看帮出
z   高亮显示
1   显示所有CPU的负载 #
s   设置刷新时间
b   高亮现实处于R状态的进程
M   按内存使用百分比排序输出   #
P   按CPU使用百分比排序输出	#
R   对排序进行反转 #
f   自定义显示字段 #find
k   kill掉指定PID进程 #
W   保存top环境设置 ~/.toprc
q   退出

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
# PID：进程id号
# USER：用户

# PR：优先级
# NI：nice值

# VIRT：虚拟内存
# RES：真实内存
# SHR：共享内存

# S：进程状态

# %CPU：占用cpu的百分比
# %MEM：占用内存的百分比
# TIME+：进程运行时间    （忘记他）
# COMMAND：进程运行的命令

什么是中断

### 什么是中断？
中断是系统用来影响硬件设备 请求 的一种机制，它会打断进程的正常调度和执行，然后调用内核中的 中断处理程序 来影响设备的请求。用户请求--中断--中断处理程序

中断处理程序在影响中断时，还会临时关闭中断，这就会导致上一次中断处理完成之前，其他中断都能不能响应，也就是说中断有可能会 丢失， 用户请求--中断--中断处理程序--中断中断。。。（中断丢失）

软中断，1.中断处理时间较长的进程，优先处理跟硬件紧密相关工作，2.处理中断前的进程

生产实例，网卡更新数据包--硬中断内核进程--1.中断处理程序更新内存，2.软中断处理

第一阶段：直接处理硬件请求，也就是我们常说的硬中断，特点是快速执行。
第二阶段：由内核触发该请求，也就是我们常说的软中断，特点是延迟执行
1.Linux中中断处理程序分为上半部和下半部：
上半部对应硬中断，用来快速处理
下半部对应软中断，用来异步处理上半部未完成的工作

kill

[root@qls ~]# kill -l
 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX	

# kill 选项 PID
数字信号        信号别名        作用

1       HUP     挂起信号，往往可以让进程重新配置（平滑重置服务）#
kill -s HUP
kill -1

2       INT     中断信号，起到结束进程的作用，和ctrl + c 的作用一样
kill -s INT
kill -2

3       QUIT        让进程退出，结果是进程退出
kill -s QUIT
kill -3

9       KILL        直接结束进程，不能被进程捕获 （小心杀死写入磁盘的进程）
kill -9
kill -s KILL

15      TERM        进程终止，这是默认信号 #平滑杀死
kill -15
kill -s TERM
kill

18      CONT        被暂停的进程将继续恢复运行
19      STOP        暂停进程
20      TSTP        用户停止请求，作用类似于ctrl + z 把进程放到后台并暂停

killall + 程序名 ：通过程序的名字直接杀死该程序的所有进程（多个）
pkill   + 程序名 ：通过程序的名字直接杀死该程序的所有进程（多个）（-9）（优先考虑）
httpd   + 程序名 ：通过程序的名字直接杀死该程序的所有进程（多个）
pgrep   + 服务|xaegs kill -9
pidof   + 服务|xaegs kill -9

kill -1 + pid进程号   :重新加载配置文件，类似重启（服务）(平滑重启，不影响用户的正常访问)
kill -s HUP +pid进程好  ：重新加载配置文件（同上）(pid不变)  #

kill -2  ： 中断信号，起到结束进程的作用，和ctrl + c 的作用一样  #
kill -9  ：强行中断（可能造成数据丢失） #
kill -15 ：   进程终止，这是 #默认信号  （kill pts/0）只有重启才能连上虚拟机
kill -19 : 暂停进程 （状态变成S）
kill -20 ：把进程放到后台 （和ctrl+z一样） #

优先级

当用nice命令指定了一个服务的优先级。那么，pid不变，该程序的优先级不变，服务重启，优先级恢复成0

# nice
-n：运行服务或命令之前 指定优先级
[root@qls ~]# nice -n -20 tail -f /var/log/messages

# renice
[root@qls ~]# ps axo nice,command|grep sshd
[root@qls ~]# renice 19 9962（进程pid）

[root@oldboy ~]# nice -n -20 systemctl start nginx  该命令优先级（同时启动nginx，nginx的优先级是默认的0）
 2600 root       0 -20  162016   2220   1544 R  0.0  0.2   0:00.19 top
 [root@oldboy ~]# pgrep nginx|xargs renice -n -20  批量重置优先级
2620 (process ID) old priority 0, new priority -20
2621 (process ID) old priority 0, new priority -20
2622 (process ID) old priority 0, new priority -20

后台进程管理

&:将进程放在后台执行---开始执行直接放后台
Ctrl + z：----------状态不变，放后台

bg：（background）后台
[root@oldboy ~]# sh miao.sh bg  命令行假死，CTRL+c结束后台执行的内容
^C
fg：调出		 #通过后台进程的序列号把后台进程调出来
[root@oldboy ~]# fg 1
sh miao.sh

^C  CTRL+c结束

[root@oldboy ~]# vim a.sh &   每隔2秒输出一次，ctrl+c 结束
#!/bin/bash
while true;do
	echo syy >> /tmp/syy.txt
	sleep 2       #2秒一次
	date +%F-%T   #2020-04-21-12:07:26
done

[root@oldboy ~]# date +%F-%R
2020-04-22-08:10

# screen-------------------screen不会因为开关终端机而改变状态，会因为开关虚拟机而改变状态
[root@qls ~]# yum install -y screen
# 查看有几个screen起的后台进程
[root@qls ~]# screen -ls
No Sockets found in /var/run/screen/S-root.

# 调出后台进程
[root@qls ~]# screen -r 10694

#不能用kill直接杀死这样的后台进程
[root@oldboy ~]# screen -ls
There are screens on:
        1450.aaa        (Detached)  #1450不是pid（序列号），类似pid，kill不了又不会报错
5 Sockets in /var/run/screen/S-root.

[root@oldboy ~]# kill 1450
[root@oldboy ~]# screen -ls
        1464.aaa        (Detached)

# 创建后台进程
[root@qls ~]# screen   screen一次就打开了一次终端，CTRL+C退出编辑

# 创建后台进程并命名
[root@qls ~]# screen -S 111
vim a.txt
CTRL z  # 中途退出，把进程放到后台
                                                                               1,2           All

[1]+  Stopped                 vim a.txt  # [1]序列号
[root@oldboy ~]# ps -ef |grep [v]im
root       3245   3234  0 14:14 pts/4    00:00:00 vim a.txt
[root@oldboy ~]# screen -ls
There are screens on:
	3233.111	(Attached)
	3156.pts-0.oldboy	(Detached)
2 Sockets in /var/run/screen/S-root.

# nohup
[root@qls ~]# nohup sh a.sh &

[root@oldboy ~]# nohup sh a.sh &  使用nohup命令,把输出放到文件，（可以用来启动服务）
[root@oldboy ~]# ll
----------- nohup.out (类似于日志)
[root@oldboy ~]# tail -f nohup

#screen会打开一个新的bash，连接主bash
[root@oldboy ~]# screen     创建一个后台进程（傻傻分不清）
[root@oldboy ~]# screen -S xx 创建后台进程并命名（打开了一个新的终端）
ping baidu.com
ctrl ad 结束

[root@oldboy ~]# screen -ls 查看
[root@oldboy ~]# screen -r PID 调出后台进程
[root@oldboy ~]# kill PID

[root@oldboy ~]# ps -aufx|grep ssh
root        785  0.0  0.4 112920  4352 ?        S<s  02:41   0:00 /usr/sbin/sshd -D
root       1917  0.0  0.6 161532  6088 ?        S<s  06:37   0:00  \_ sshd: root@pts/0
root       2768  0.0  0.0 112712   952 pts/8    S+   08:35   0:00      \_ grep --color=auto ssh

/usr/sbin/sshd -D  虚拟机
sshd: root@pts/8  当前端口

#jobs 注意是哪个终端  （对象是一个持续的过程，对ll无意义）
[root@oldboy ~]# jobs  查看后台进程
[1]+  Stopped                 vim a.txt
[1]+ 后台指令的序列号，代表第几个后台进程（第一个）

[root@oldboy ~]# vim b.txt &
[2] 1431
[root@oldboy ~]# !j
jobs
[1]-  Stopped                 vim a.txt
[2]+  Stopped                 vim b.txt

显示系统内存使用及空闲情况的命令是？（以M为单位显示）
[root@qiwenjie ~]# free -m

总结

如何理解平均负载？

[root@oldboy ~]# top
top - 15:26:08 up 12:44,  4 users,  load average: 0.00, 0.01, 0.05
[root@oldboy ~]# watch -d uptime :查看负载数值，变化部分高亮显示
[root@oldboy ~]# uptime
 15:26:59 up 12:45,  4 users,  load average: 0.13, 0.04, 0.05

平均负载 是指，单位时间内，系统处于可运行状态（R）和不可中断状态（D）的 平均进程数，也就 是平均活跃进程数

平均负载指的是系统的平均负载，跟cpu，磁盘挂载（需要重新挂载），内存有关

可运行状态指定是正在运行，或者在等待队列中的进程

不可中断状态，（打包，磁盘数据的写入，强行中断的话会导致磁盘损坏）

机器的卡与内存的使用率有关，磁盘的使用率过高也会导致磁盘的写入和读取

# 进程和线程的关系：
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程(#对应)
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。（#共享）
（3）处理机分给线程，即真正在处理机上运行的是线程。（#真正，线程是执行单位）
（4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的#可调度实体.

[root@oldboy ~]# top
top - 15:26:08 up 12:44,  4 users,  load average: 0.00, 0.01, 0.05
Tasks: 107 total,   1 running, 106 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.3 us,  0.0 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st