网络安全：系统进程的基本概述

1.1 系统进程基本概述

1.1.1 进程概念介绍说明：

一般将开发编写的好代码称为是程序，当开发好的代码运行起来后，就可以称运行起来的代码为系统的进程。

简单来说：当运行一个程序时，可以将运行的程序称为进程；（系统需要处理任务）

当程序运行起来成为进程后，系统会为该进程分配内存存储空间，以及分配进程运行的用户身份和权限；

当程序运行起来成为进程时，系统会有各种指标来表示当前运行的状态

1.1.2 进程程序之间区别：

程序是数据和执行集合，是一个静态的概念，比如系统中常见的二进制文件，同时程序可以长期存在系统中；

进程是程序运行的过程，是一个动态的概念，进程是存在生命周期的概念的，会随着程序的终止而销毁；

1.1.3 进程运行生命周期：

生命周期就是指一个对象的生老病死的过程：

参考资料：

https://www.cnblogs.com/wannable/p/6021617.html
https://blog.51cto.com/u_12027605/1853917

当父进程接收到任务调度时，会通过fork派生子进程来处理，所以子进程会继承父进程属性：

子进程在处理任务代码时，父进程其实不会进入等待，其运行过程是由linux系统进行调度的；

子进程在处理任务代码后，会执行退出，然后唤醒父进程来回收子进程的资源；

子进程在处理任务代码中，如果出现异常退出，而父进程没有回收子进程资源，会导致子进程运行实体消失

但仍然在内核的进程表中占据一条记录，长期下去对于系统资源是一种浪费；（僵尸进程）

子进程在处理任务代码中，父进程退出了，子进程没有退出，那么子进程就没有父进程来管理了；

有系统的system进程管理；（孤儿进程）

说明：每个进程都有父进程（PPID）,对应的子进程为（PID）。

进行信息查看：

[root@xiaoq ~]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0       0 12:34   ?        00:00:01 /usr/lib/systemd/systemd --switched-root --system
root          2      0       0 12:34   ?        00:00:00 [kthreadd]
root          4      2       0 12:34   ?        00:00:00 [kworker/0:0H]
root          5      2       0 12:34   ?        00:00:01 [kworker/u256:0]
-- pid为子进程编号，ppid为父进程编号

1.2 系统进程状态监控

1.2.1 查看当前进程状态

程序在运行后，需要了解进程的运行状态，查看进程的状态分为两种方式：

静态进程状态查看：只查看某一时间段的进程运行情况
动态进程状态查看：实时监控进程信息占用资源的情况
01. 查看当前静态进程状态
命令介绍：

ps命令是“process status”的缩写，ps命令用于显示当前某一时刻系统的进程状态。

ps命令是最基本同时也是非常强大的进程查看命令，使用该命令可以确定有哪些进程：

正在运行和运行的状态
进程是否结束
进程有没有僵死
哪些进程占用了过多的资源等等
总之大部分信息都是可以通过执行该命令得到的。可以搭配kill指令随时中断、删除不必要的程序。

语法格式：

ps [参数]
 

参数信息：

系统中出现的进程信息会有两类：用户操作运行的进程/系统运行产生的进程

序号	参数信息	解释说明
01	-a	显示所有终端下执行的程序；
02	-A	显示系统中存在的所有程序信息
03	-u	显示进程所管理的用户信息，以及其他更详细的进程使用情况
04	-x	显示所有程序不以终端来区分，包含系统运行的进程
05	-e	此选项的效果和指定A选项相同
06	-f	显示更加详细的进程信息，包含UID,PPID等信息。

说明：以上参数在企业中经常采用组合方式使用：ps -ef （信息更简洁） / ps -aux（包含资源占用情况）

实践操作：

实践操作情况-01：查看进程信息、用户信息、pid编号、占用cpu百分比、占用内存宝百分比、状态、执行命令等；

对比windows系统进程情况：

[root@xiaoq ~]# ps -aux
-- 常见命令参数组合 -aux
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          2        0.0      0.0        0        0     ?          S      12:34     0:00  [kthreadd]
root          4        0.0      0.0        0        0     ?          S<    12:34     0:00  [kworker/0:0H]
root          5        0.0      0.0        0        0     ?          S      12:34     0:01  [kworker/u256:0]

…省略部分信息…

输出列信息说明：

编号	列信息	解释说明
01	USER	管理此进程或运行此进程信息的用户名称，每个进程都要有一个用户管理
02	PID	此进程的编号标识信息，也是一个子进程编号
03	%CPU	进程运行过程中占用CPU资源的百分比
04	%MEM	进程运行过程中占用内存资源的百分比
05	VSZ	虚拟内存的使用情况，单位是kb（表示最大使用的内存情况 类似建筑面积）
06	RSS	实际内存的使用情况，单位是kb（表示进程运行实际内存使用情况 类似使用面积）
07	TTY	表示连接主机的终端类型；？表示是系统运行的进程
08	STAT	表示进程的运行状态情况，需要重点关注
09	START	表示进程启动的时间信息，什么时候出现的进程
10	TIME	表示进程运行过程中占用了CPU多长时间的资源
11	COMMAND	表示进程运行调用的命令（代码程序）是什么 []表示系统内核启动的进程

进程状态信息详述：

编号	状态标识/状态符号	解释说明
 	状态标识	 
01	R	可以被CPU调度加载的执行或运行的状态
02	S	可将进程进行中断和睡眠挂起的状态
03	T	可以表示进程处于暂停状态或跟踪状态
04	D	不可中断睡眠状态
05	Z	进程处于僵尸状态
 	状态符号	 
01	s（a session leader）	进程是控制进程，Ss进程的领导者，即父进程
02	<（high-priority）	进程运行在高优先级上，S<表示优先级较高的进程
03	N（low-priority）	进行运行在低优先级上，SN表示优先级较低的进程
04	+（in the foreground process group）	当前进程运行在前台，R+表示该进程在前台运行
05	l（is multi-threaded）	进程是多线程的，Sl表示进程是以线程方式运行

说明：一般常见的进程状态有：R+ R S D T Ss S< Ssl；可以通过man ps获取详细说明；

for n in {1…1000};do echo $n;sleep 2;done

进程状态信息详述：

参考链接资料：https://blog.csdn.net/nilxin/article/details/7437671

R（running or runnable）：运行状态或可运行状态
只有在该状态的进程才可能在CPU上运行，而同一时刻可能有多个进程处于可执行状态；

将正在CPU上执行的进程定义为RUNNING状态、而将可执行但是尚未被调度执行的进程定义为READY状态；

这两种状态在linux下统一为TASK_RUNNING状态。

进程状态模拟：

[root@xiaoq ~]# ps -aux|grep ps
root       2133  0.0  0.1  51756  1720 pts/0    R+   21:36   0:00 ps -aux

S（interruptible sleep）：可中断的睡眠状态
处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。

当某些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。

一般情况下，进程列表中的绝大多数进程都处于task_interruptible状态（除非机器的负载很高）。

毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。

总结：出现挂起状态的情况：

某些进程在队列中等待CPU的唤醒；

某些进程已经被CPU处理完成后；

进程状态模拟：

[root@xiaoq ~]# ps -aux|grep bash
root       1846  0.0  0.3 116600  3164 pts/1    Ss   16:27    0:00 -bash
root       2074  0.0  0.2 116468  2952 pts/0    Ss+  21:27   0:00 -bash
-- 均可被中断或挂起的父进程
 

T（stopped）：暂停状态或跟踪状态
当进程正在被跟踪时处于暂停状态；正在被跟踪指的是进程暂停下来，等待跟踪它的进程对它进行操作。

处于task_traced状态的进程不能响应sigcont信号而被唤醒；只能通过ptrace系统调用执行；

或调试进程退出，被调试的进程才能恢复task_running状态。

当某个程序运行后的进程持续不断占用CPU资源时，可以临时先暂停进程运行，程序服务修复后，可以在恢复进程

进程状态模拟：

[root@xiaoq ~]# vim /etc/hosts
[1]+  Stopped                 vim /etc/hosts
-- 编写文件过程中，按下ctrl+z快捷键，显示进程被停止
​
[root@xiaoq ~]# ps -aux|grep vim
root       2070  0.1  0.5  45840  5220 pts/1    T    21:23   0:00 vim /etc/hosts
-- 表示vim执行编写文件信息任务的进程处于被暂停的状态

D（uninterruptible sleep）：不可中断的睡眠状态
与TASK_INTERRUPTIBLE状态类似，进程处于睡眠状态，但是此刻进程是不可中断的；

不可中断，指的并不是CPU不响应外部硬件的中断，而是指进程不响应异步信号；

简单理解就是，kill -9竟然杀不死一个正在睡眠的进程了；

TASK_UNINTERRUPTIBLE状态存在的意义就在于，内核的某些处理流程是不能被打断的；

进程状态模拟：
在一个会话窗口进行数据压缩打包

[root@xiaoq ~]# tar zcf /opt/data.tar.gz /etc /var /tmp /root

在另一个会话窗口进行压缩任务进程信息查看

[root@xiaoq ~]# ps -aux|grep tar|grep -v grep
root       2103 61.3  0.1  20212  1460 pts/1    D+   21:27   0:01 tar zcf /opt/data.tar.gz /etc /var /tmp /root

– 此时对磁盘进行写入操作的进程是不能被打断的

Z（zombie process）：僵尸进程状态
进程在退出的过程中，进程占有的所有资源将被回收，但当子进程资源还没有回收时，子进程就死掉了；

比如在shell中，$?变量就保存了最后一个退出的前台进程的退出码，而这个退出码往往被作为if语句的判断条件

只要父进程不退出，这个僵尸状态的子进程就一直存在。

进程状态模拟：

编写测试僵尸进程的代码文件，并生成可执行文件：

模拟实现僵尸进程脚本信息
[root@xiaoq ~]# cat test_zombie.c 
#include <stdio.h>
#include <unistd.h>
​
int main()
{
   pid_t pid;
​
   pid = fork();
   if(pid == -1)
     perror("create faild");
   if(pid == 0)//孩子进程
   {
      sleep(3);
      printf("pid process dead\n");
   }
   else if(pid >0)//父进程信息
   {
      int times = 10;
      while(times--)
      {
         printf("ppid process: %d\n",times);
         sleep(1);
      }
      printf("ppid process dead\n");
   }
   return 0;
}
​

# 生成可执行文件信息
[root@xiaoq ~]# gcc test_zombie.c -o test_zombie
 

执行测试代码执行文件：

[root@xiaoq ~]# ./test_zombie 
ppid process: 9      ---
ppid process: 8      --- 第一个阶段：父进程和子进程都存在时，进程正常运行阶段
ppid process: 7      ---
pid process dead   --- 第二个阶段：子进程消失，父进程继续运行
ppid process: 6
ppid process: 5
ppid process: 4
ppid process: 3
ppid process: 2
ppid process: 1
ppid process: 0
ppid process dead --- 第三个阶段：父进程消失，默认自动回收子进程产生的讲师进程
# 以上代码信息执行过程分为三个阶段，利用这个三个阶段可以获取不同的进程状态信息

执行测试代码进程状态信息变化：

# 第一个阶段：父进程和子进程都存在时
[root@xiaoq ~]# ps -aux|grep test_zombie
root      11126  3.0  0.0   4216   352 pts/7    S<+  19:40   0:00 ./test_zombie
root      11127  0.0  0.0   4212     88 pts/7    S<+  19:40   0:00 ./test_zombie
[root@xiaoq ~]# ps -ef|grep test_zombie
root      11126  10286  0 19:41 pts/7    00:00:00 ./test_zombie
root      11127  11126  0 19:41 pts/7    00:00:00 ./test_zombie
​
# 第二个阶段：父进程正常，子进程异常，出现僵尸进程阶段
[root@xiaoq ~]# ps -aux|grep test_zombie
root      11126  1.0  0.0   4216   352 pts/7    S<+  19:40   0:00 ./test_zombie
root      11127  0.0  0.0         0       0 pts/7    Z<+  19:40   0:00 [test_zombie] <defunct>
[root@xiaoq ~]# ps -ef|grep test_zombie
root      11126  10286  0 19:41 pts/7    00:00:00 ./test_zombie
root      11127  11126  0 19:41 pts/7    00:00:00 [test_zombie] <defunct>
​
# 第三个阶段：父进程中止，默认自动回收僵尸进程
[root@xiaoq ~]# ps -aux|grep test_zombie
[root@xiaoq ~]# ps -ef|grep test_zombie

僵尸进程一旦出现，或造成系统资源浪费，因此需要进行处理：

通过程序代码可以自动回收僵尸进程（开发处理）
通过终止服务程序主进程，让僵尸进程自动变为孤儿进程，随之被系统systemd主进程回收（运维处理）
当服务程序主进程停止后，僵尸进程并没有变为孤儿进程，仍旧存在僵尸进程，可以使用重启操作（服务/系统）
参考链接资料：https://blog.csdn.net/xiaozuo666/article/details/79833527

wh

命令介绍：

Linux系统中pstree命令的英文全称是“process tree”，即将所有行程以树状图显示；

树状图将会以 pid (如果有指定) 或是以systemd这个基本行程为根 (root)，如果有指定使用者 id；

则树状图会只显示该使用者所拥有的行程。

# centos7 系统中默认没有pstree命令，需要先进行安装
[root@k8s-node-01 ~]# yum install -y psmisc
 

语法格式：

pstree [参数]
 

参数信息：

序号	参数信息	解释说明
01	-a	显示启动每个进程对应的完整指令，包含启动进程的路径、参数等
02	-c	显示的进程中包含子进程和父进程
03	-h	列出树状图时，特别标明现在执行的程序
04	-n	根据进程PID号来排序输出，默认是以程序名称排序输出的
05	-p	显示进程的PID
06	-u	显示进程对应的用户名称
 

实践操作：

实践操作情况-01：显示启动的进程详细信息

[root@xiaoQ ~]# pstree -a
systemd --switched-root --system --deserialize 22
  ├─NetworkManager --no-daemon
  │   └─2*[{NetworkManager}]
  ├─VGAuthService -s
  ├─abrt-watch-log -F BUG: WARNING: at WARNING: CPU: INFO: possible recursive locking detected ernel BUG at list_del corruption
  ├─abrtd -d -s
  ├─agetty --noclear tty1 linux
  ├─auditd
  │   └─{auditd}
-- 省略部分信息 -- 

实践操作情况-02：显示运行进程的子父进程之间的关系

[root@xiaoQ ~]# pstree -c
systemd─┬─NetworkManager─┬─{NetworkManager}
        │                └─{NetworkManager}
        ├─VGAuthService
        ├─abrt-watch-log
        ├─abrtd
        ├─agetty
        ├─auditd───{auditd}
        ├─chronyd
        ├─containerd─┬─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            ├─{containerd}
        │            └─{containerd}
-- 省略部分信息 --
 

实践操作情况-03：显示正在处理的进程信息

[root@xiaoQ ~]# pstree -h
├─sshd───sshd───bash───pstree
-- 省略部分信息 --

2. 查看当前动态进程状态
   命令介绍：

top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，常用于服务端性能分析；

top命令中按f可以查看显示的列信息，按对应字母来开启/关闭列，大写字母表示开启，小写字母表示关闭。

带*号的是默认列。

语法格式：

top [参数]
 

参数信息：

序号	参数信息	解释说明
01	-d	改变显示的更新速度，或是在交谈式指令列( interactive command)按 s
02	-i	不显示任何闲置 (idle) 或无用 (zombie) 的行程
03	-n	更新的次数，完成后将会退出 top
04	-b	批次归档模式，搭配 “n” 参数一起使用，可以用来将 top 的结果输出到文件内
 

常见指令：（ interactive command）

序号	指令信息	解释说明
01	h	查看获取帮助信息
02	1	显示所有CPU核心的负载情况（默认显示的是平均的）
03	z	以高亮显示数据信息
04	b	高亮显示处于R状态的进程信息
05	M	按照内存使用百分比排序输出
06	P	按照CPU使用百分比排序输出
07	q	退出top动态监控状态

实践操作：

实践操作情况-01：查看实时的进程情况信息

[root@xiaoq ~]# top
top - 21:58:17 up  9:24,  2 users,  load average: 0.00, 0.01, 0.05
Tasks: 107 total,   1 running, 105 sleeping,   1 stopped,   0 zombie
%Cpu(s):  0.2 us,  0.2 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :   995712 total,    82648 free,   124420 used,   788644 buff/cache
KiB Swap:  1572860 total,  1572860 free,        0 used.   719464 avail Mem 
-- 上半部分，系统资源使用情况汇总说明
   PID USER     PR  NI    VIRT     RES    SHR  S  %CPU %MEM     TIME+ COMMAND
   813  root      20   0  305280   6400   5024 S     0.3     0.6      1:01.48  vmtoolsd
  2174 root      20   0   58308    2072   1480 R     0.3     0.2      0:00.13  top
       1  root      20   0  125888   4324   2568 S     0.0     0.4      0:02.17  systemd
-- 下半部分，具体进程使用资源详细情况

输出内容信息说明：

行号/列数 信息内容 解释说明
上半部分

01行	21:58:17 up 9:24	表示当前时间，以及系统运行了多久
 	2 users	多少用户在登录管理系统
 	load average	平均负载情况（每分钟 每五分钟 每十五分钟）
02行	xx total	表示系统中总的进程数量
 	xx running	表示系统中进程处于R状态数量
 	xx sleeping	表示系统中进程处于S状态数量
 	xx stopped	表示系统中进程处于T状态数量
 	xx zombie	表示系统中进程处于Z状态数量
03行	xx us	表示用户进程占用CPU百分比情况（用户控制的操作）
 	xx sy	表示内核进程占用CPU百分比情况（控制硬件的操作）
 	xx ni	表示优先级高的进程占用CPU百分比
 	xx id	表示系统CPU空闲状态的百分比（数值越大，表示服务器越空闲）
 	xx wa	表示系统CPU等待硬件资源处理任务的等待百分比（数据库存储数据）
 	xx hi	表示硬中断占用CPU的百分比
 	xx si	表示软中断占用CPU的百分比
 	xx st	表示服务器运行了很多的虚拟主机，虚拟主机占用了物理CPU资源百分比

下半部分	 

01列	PID	表示相应进程的标识信息，一般是子进程ID
02列	USER	表示相应进程的管理用户
03列	PR	表示相应进程任务的调度优先级
04列	NI	表示相应进程任务本身优先级数值
05列	VIRT	表示相应进程任务占用了多少虚拟内存（建筑面积）
06列	RES	表示相应进程任务占用了多少实际内存（使用面积）
07列	SHR	表示相应进程任务占用了多少共享内存（公摊面积）
08列	S	表示相应进程所处的进程状态
09列	%CPU	表示进程运行过程中占用CPU资源的百分比
10列	%MEM	表示进程运行过程中占用内存资源的百分比
11列	TIME+	表示进程运行过程中占用了CPU多长时间的资源
12列	COMMAND	表示进程运行调用的命令（代码程序）是什么

说明：以上信息部分的重要核心知识会在后续内容讲解，大体以了解为主，可以利用man top获取详细说明。

1.2.2 系统进程中断概念

01. 中断概念介绍说明：

中断是系统用来响应硬件设备请求的一种机制，会打断进程的正常调度的执行，然后调用内核的中断处理程序来响应设备的请求。

从本质上讲中断是一种电信号，当设备有某种事件发生时，就会产生中断，通过总线把电信号发送给中断控制器。如果中断的线是激活的，中断控制器就把电信号发送给处理器的某个特定引脚；处理器于是立即停止自己正在做的事，跳到中断处理程序的入口点，进行中断处理；

简而言之，就是可以控制CPU中断正在处理的进程任务，完成一些特定的任务进程；

形象比喻：类似于和别人微信视频聊天，来了电话的情况；

02. 中断概念作用说明：

用生活的案例进行说明，比如订了一份外卖，但是不确定外卖什么时候送到，也没有别的方法了解外卖的进度；

所以你只能苦苦等待，时不时到门口去看看外卖送到没，而不能干其他事情。

但是，如果在订外卖的时候，和配送员约定好，让他送到后给你打个电话，那你就不用苦苦等待了，可去忙别的；

一旦电话响起，接完电话去取外卖就可以了。这里的“打电话”，其实就是一个中断；

没接到电话的时候，可以做其他的事情，只有接到了电话（也就是发生了中断），才要进行另一个动作：取外卖；

通过此例子就可以发现，中断其实是一种异步的事件处理机制，可以提高系统的并发处理能力。

03. 中断存在问题说明：

由于中断处理程序会打断其他进程的运行，为了减少对正常进程运行调度的影响，中断处理需要尽可能快运行；

如果中断本身要做的事情不多，那么处理中断服务程序就只是花费较少的时间；

如果中断本身要做的事情很多，那么处理中断服务程序就将会花费很长的时间；

需要注意：中断处理程序在响应中断时，还会关闭接收处理其他的中断，会导致其他中断不能响应，造成中断丢失

比如在订外卖时，订了2份外卖：

两个不同的配送员配送外卖时，都约订了外卖送到时进行电话确认；

第一份外卖送到时，配送员给你打了个很长的电话，比如确认地址或外卖发票的问题；

第二份外卖送到时，配送员给你打电话将无法拨通，可能尝试几次后配送员就走了；（类似丢失了一次中断）

总结：多个中断出现时，尽量让中断进程消耗的时间越短越好，保证其他中断可以正常处理，否则会出现中断丢失

04. 中断概念类别说明：

为了解决中断处理程序执行时间过长或中断丢失的问题，Linux将中断处理过程分成了两个阶段：

上半部阶段：用来快速处理中断，在中断禁止模式下运行，主要处理和硬件紧密相关的工作；

下半部阶段：用来延迟处理上半部未完成的工作，通常以内核线程的方式运行；

硬中断概念作用（上半部）
由与系统相连的外设(比如网卡、硬盘)自动产生的，主要是用来通知操作系统系统外设状态的变化。

比如当网卡收到数据包的时候，就会发出一个中断。我们通常所说的中断指的是硬中断(hardirq)。

软中断概念作用（下半部）
为了满足实时系统的要求，中断处理应该是越快越好。

linux为了实现这个特点，当中断发生的时候，硬中断处理那些短时间就可以完成的工作；

而将那些处理事件比较长的工作，放到中断之后来完成，也就是软中断(softirq)来完成。

总结：CPU正在处理进程任务–网卡接收数据（硬中断–数据临时保存到内存中）-- 到内存中处理数据（软中断）

— CPU恢复处理之前进程任务

举例详细说明-01：生活外卖派送过程

上半部阶段：是接电话后，告诉配送员已经知晓快递送到的事情，其他事情回头再说，然后挂断电话；

下半部阶段：是具体外卖的一些情况说明，比如商量是否开发票，具体怎么开等等；

这样设计后，第一个配送员不会占用你太多时间，第二个配送员过来时，照样能正常打通你的电话。

举例详细说明-02：网卡收取数据过程

网卡接收到数据包后，会通过硬件中断的方式，通知内核有新的数据到了，内核会中断处理程序响应它；

上半部阶段：

需要进行快速处理，就要把网卡的数据读取到内存中，然后更新硬件寄存器状态（表示数据已读好）

最后再发送一个软中断信号，通知下半部做进一步的处理。

下半部阶段：

被软中断信号唤醒后，需要从内存中找到网络数据，再按照网络协议栈，对数据进行逐层解析处理；

两个阶段简单理解：

上半部直接处理硬件请求，也就是常说的硬中断，特点是快速执行；

下半部则是有内核触发的，也就是常说的软中断，特点是延迟执行；

Linux中的软中断包含：网络收发、定时任务、数据调度等各种类型，可通过查看/proc/softirqs观察软中断情况

05. 中断概念类别区别：

软中断是执行中断指令产生的，而硬中断是由外设引发的。
硬中断的中断信号是由中断控制器提供的，软中断的中断信号由指令直接控制，无需使用中断控制器。
硬中断是可屏蔽的，软中断不可屏蔽。
硬中断处理程序要确保它能快速地完成任务，这样程序执行时才不会等待较长时间，称为上半部。
软中断处理硬中断未完成的工作，是一种推后执行的机制，属于下半部。

1.3 系统进程状态管理

在进行状态管理知识学习前，需要掌握系统进程启动的方式和系统进程停止的方式：

进程启动方式：操作命令+参数信息+程序代码/配置文件，即表示实现将程序运行起来变为进程；

进程停止方式：可以利用系统专门的进程停止命令，向运行的进程发出停止信号，随之停止进程；

1.3.1 进程停止命令详述

01. 系统进程停止命令-kill
命令介绍：

kill命令正如这个单词的意思一样，就是杀死，在linux系统会使用此命令来删除执行中的程序或工作。

kill命令可将指定的信号发送给相应的进程或工作。 kill命令默认使用信号为15，用于结束进程或工作。

如果进程或工作忽略此信号，则可以使用信号9，强制杀死进程或作业。

语法格式：

kill [参数] [进程号]
 

参数信息：

序号	参数信息	解释说明
01	-l	列出系统可以支持的进程控制信号
02	-s	指定向进程发送的控制信号
03	-a	处理当前进程时不限制命令名和进程号的对应关系
04	-p	指定处理进程时只打印相关进程的进程号，而不发送任何信号

实践应用：

实践操作情况-01：列出当前系统所支持的所有进程控制信号

[root@xiaoq ~]# kill -l

虽然，Linux系统支持的信号很多，但是在日常企业应用环节中比较常用的有以下3种信号：

序号	信号信息	信号作用说明
01	1) SIGHUP	表示重新加载服务配置文件
02	9) SIGKILL	表示强制杀死终止指定进程
03	15) SIGTERM	表示终止指定进程（默认使用的进程信号）

实践操作情况-02：利用各种信号测试停止进程的情况

# 进程管理模拟环境准备
[root@xiaoq ~]# yum install -y httpd
[root@xiaoq ~]# systemctl start httpd
[root@xiaoq ~]# systemctl is-active httpd
active
-- 确认测试服务程序已经启动成功
​
# 查看测试服务进程信息
[root@xiaoq ~]# ps -ef|grep httpd
root          2590         1  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2591   2590  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2592   2590  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2593   2590  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2594   2590  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2595   2590  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
​
# 使用命令停止指定进程
# 发送进程控制信号-SIGHUP
[root@xiaoq ~]# kill -1 2590
[root@xiaoq ~]# ps -ef|grep httpd
root          2590         1  0 00:51 ?        00:00:00 /usr/sbin/httpd -DFOkilREGROUND
apache     2599   2590  0 00:55 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2600   2590  0 00:55 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2601   2590  0 00:55 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2602   2590  0 00:55 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2603   2590  0 00:55 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
-- 主进程收到SIGHUP信号，会重载配置文件信息，主进程编号不变，子进程信息重新启动
​
# 发送进程控制信号-SIGTERM
[root@xiaoq ~]# kill 2590
[root@xiaoq ~]# ps -ef|grep httpd
-- 主进程收到SIGTERM信号，会确认进程是否有未完成的工作，如果闲置状态，会立即终止进程
​
# 发送进程控制信号-SIGKILL
[root@xiaoq ~]# ps -ef|grep httpd
root          2636         1  1 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2637   2636  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2638   2636  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2639   2636  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2640   2636  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2641   2636  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
[root@xiaoq ~]# kill -9 2636
-- 主进程收到SIGKILL信号，无论进程是否有未完成的工作，都立即终止进程
[root@xiaoq ~]# ps -ef|grep httpd
apache     2637         1  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2638         1  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2639         1  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2640         1  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2641         1  0 01:05 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
-- 主进程会被立刻杀死，但子进程依然存在，产生出大量孤儿进程，已不能提供任何服务
[root@xiaoq ~]# systemctl start httpd
[root@xiaoq ~]# ps -ef|grep httpd
root          2656         1  2 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2657   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2658   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2659   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2660   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2661   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
-- 在此启动服务程序后，原有的孤儿进程会被销毁，重新生成服务的主进程和相应子进程
 

02. 系统进程停止命令-pkill
命令介绍：

pkill命令可以按照进程名杀死进程；pkill和killall应用方法差不多，也是直接杀死运行中的程序。

如果想杀掉单个进程，请用kill来杀掉。

语法格式：

pkill [参数] [进程名]
 

参数信息：

序号	参数信息	解释说明
01	-o	仅向找到的最小（起始）进程号发送信号
02	-n	仅向找到的最大（结束）进程号发送信号
03	-P	指定父进程号发送信号
04	-g	指定进程组
05	-t	指定开启进程的终端
 

实践应用：

实践操作情况-01：根据进程名称杀死进程

# 查看测试服务进程信息
[root@xiaoq ~]# systemctl start httpd
[root@xiaoq ~]# ps -ef|grep httpd
root          2656         1  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2657   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2658   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2659   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2660   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2661   2656  0 01:09 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
​
# 使用命令停止指定进程
[root@xiaoq ~]# pkill httpd
[root@xiaoq ~]# ps -ef|grep httpd
-- 将指定服务进程进行终止
 

实践操作情况-02：将指定用户的远程连接断开（踢掉滚蛋）

# 获取当前系统登录用户信息
[root@xiaoq ~]# w
 01:40:24 up 13:50,  2 users,  load average: 0.00, 0.01, 0.05
USER     TTY      FROM       LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts/0    10.0.0.1         23:34    0.00s  1.23s  0.01s  w
root     pts/1    10.0.0.1         01:40    3.00s  0.05s  0.05s -bash
-- 此时有两个用户在登录系统
[root@xiaoq ~]# ps -ef|grep pts
root       2408   1265  0  Jan26 ?           00:00:02  sshd: root@pts/0,pts/1
root       2410   2408  0  Jan26 pts/0    00:00:01 -bash
root       2780   2408  0  01:40  pts/1    00:00:00 -bash
-- 进程中也查看到有两个用户终端建立的远程连接
​
# 中断指定相应终端建立的连接
[root@xiaoq ~]# pkill -9 -t pts/1
[root@xiaoq ~]# w
 01:43:51 up 13:53,  1 user,  load average: 0.00, 0.01, 0.05
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts/0    10.0.0.1              23:34    7.00s  1.27s   0.01s w
[root@xiaoq ~]# ps -ef|grep pts
root       2408   1265  0 Jan26 ?           00:00:02 sshd: root@pts/0
root       2410   2408  0 Jan26 pts/0    00:00:01 -bash
-- 中断后，显示只有一个用户在远程控制管理系统

3. 系统进程停止命令-killall
   命令介绍：

killall命令使用进程的名称来杀死进程，使用此指令可以杀死一组同名进程。

默认此命令在系统中可能不存在，需要单独进行软件包安装部署。

[root@xiaoq ~]# yum install -y psmisc
 

语法格式：

killall [参数] [进程名]
 

参数信息：

序号	参数信息	解释说明
01	-e	对长名称进行精确匹配
02	-l	输出所有已知信号列表
03	-p	杀死进程所属的进程组
04	-i	交互式杀死进程，杀死进程前需要进行确认
05	-r	使用正则表达式匹配要杀死的进程名称
06	-s	用指定的进程号代替默认信号“SIGTERM”
07	-u	杀死指定用户的进程

实践应用：

实践操作情况-01：根据进程名称杀死进程

# 查看测试服务进程信息
[root@xiaoq ~]# systemctl start httpd
[root@xiaoq ~]# ps -ef|grep httpd
root          2763         1  1 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2764   2763  0 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2765   2763  0 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2766   2763  0 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2767   2763  0 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
apache     2768   2763  0 01:38 ?        00:00:00 /usr/sbin/httpd -DFOREGROUND
​
# 使用命令停止指定进程
[root@xiaoq ~]# killall httpd
[root@xiaoq ~]# ps -ef|grep httpd
-- 将指定服务进程进行终止

总结：kill pkill killall三个杀进程命令之间区别：

kill：是可以杀死进程信息，会根据pid进行杀进程，多次杀进程会有提示信息
pkill：是可以杀死进程信息，会根据进程名进行杀进程，多次杀进程不会有提示信息
killall：是可以杀死进程信息，会根据进程名进行杀进程，但是命令软件程序包需要单独安装

1.4 系统后台进程管理

1.4.1 后台进程概念介绍

01. 后台进程概念介绍

通常情况进程信息会在终端前台运行，一旦关闭终端，进程也会随着结束；因此就希望进程能在后台运行，

就是将前台运行的进程放入后台运行，这样即使关闭了终端也不影响进程的正常运行。

02. 后台进程作用说明

早期国内服务器向国外服务器传输大文件时，由于网络的因素问题，需要传输很长时间；

如果在传输的过程中出现网络抖动或者不小心关闭了终端则会导致传输失败；

所以若能将传输的进程放入后台，将会解决诸如此类问题。

1.4.2 后台进程管理命令

早期的Linux系统环境中，若想让一些前台运行的程序进程在后台运行，都会选择使用&符号将进程放入后台；

但是在使用jobs、bg、fg等方式查看或管理进程状态时，会很麻烦，也不直观，所以诞生了screen管理进程命令。

01. 系统进程管理命令-jobs bg fg
命令介绍：

命令-jobs 用于做查看工作的
主要可以用于显示任务号及其对应的进程号；

任务号是以普通用户的角度进行的，进程号是从系统管理员角度来看的；一个任务可以对应一个或者多个进程号。

命令-bg 将进程作业信息放入后台运行
用于将作业放到后台运行，使前台可以执行其他任务。

该命令的运行效果与在指令后面添加符号&的效果是相同的，都是将其放到系统后台执行。

命令-fg 将进程作业信息放入前台运行
用于将后台作业（在后台运行的或者在后台挂起的作业）放到前台终端运行。

与bg命令一样，若后台任务中只有一个，则使用该命令时，可以省略任务号。

参数信息：

序号	参数信息	解释说明
 	jobs	 
01	-l	显示作业列表时包括进程号
02	-n	显示上次使用jobs后状态发生变化的作业
03	-p	显示作业列表时仅显示其对应的进程号
04	-r	仅显示运行的（running）作业
05	-s	仅显示暂停的（stopped）作业
 	bg	 
01	作业标识	指定需要放到后台的作业标识号
 	fg	 
01	作业标识	指定需要放到后台的作业标识号

实践应用：

实践操作情况-01：实现灵活管理进程任务在前台或后台

# 利用早期&符实现将操作任务放入后台
[root@xiaoq ~]# sleep 3000 &
[1] 2992
[root@xiaoq ~]#ps -ef|grep sleep
root       2992   2968  0 11:27 pts/0    00:00:00 sleep 3000
-- 此方法如果远程连接会话断开后，后台的任务也会随之消失
​
# 利用ctrl+z将操作任务进行挂起
[root@xiaoq ~]# sleep 3000 &
[1] 3025
[root@xiaoq ~]# sleep 4000
-- 执行快捷键ctrl+z，将正在运行的任务进程挂起
[2]+  Stopped                 sleep 4000
[root@xiaoq ~]# ps aux|grep sleep
root       3025  0.1  0.0   4364   356 pts/0    S    11:29    0:00 sleep 3000
root       3027  0.0  0.0   4364   356 pts/0    T    11:29    0:00 sleep 4000
[root@xiaoq ~]# jobs             
[1]-  Running                  sleep 3000 &
[2]+  Stopped                 sleep 4000
​
# 控制进程任务在前后台运行
[root@xiaoq ~]#  bg 2
[2]+ sleep 4000 &
-- 让任务作业 2 在后台运行
[root@xiaoq ~]#  fg 1
sleep 3000
-- 让任务作业 1 在前台运行
-- 可以利用kill命令终止指定的前后台的进程信息
​
# 控制进程任务输出的信息位置
[root@xiaoq ~]#  (while : ; do date; sleep 2; done) & 
-- 进程在后台运行，但输出依然在当前终端前台输出
[root@xiaoq ~]#  (while : ; do date; sleep 2; done) &>/dev/null &
or
[root@xiaoq ~]#  (while : ; do date; sleep 2; done) &>/tmp/date.log &
-- 将进程产生的信息输出到系统黑洞，或者将产生的所有信息输出到指定日志文件中

02. 系统进程管理命令-screen
命令介绍：

screen命令为多重视窗管理程序。此处所谓的视窗，是指一个全屏幕的文字模式画面。

可以更加便捷的操作管理相应任务的进程，使其在后台运行时，也可以轻松的进行管理。

此命令在系统中可能不是默认窜存在的，需要进行软件包的安装部署：

[root@xiaoq ~]# yum install -y screen

语法格式：

screen [参数]
 

参数信息：

序号	参数信息	解释说明
01	-A	将所有的视窗都调整为目前终端机的大小
02	-v	显示版本信息
03	-x ※	恢复之前离线的screen作业，实现共享屏幕操作screen作业任务
04	-ls/-list ※	显示目前所有的screen作业
05	-wipe	检查目前所有的screen作业，并删除已经无法使用的screen作业
06	-d<作业名称> ※	将指定的screen作业离线（挂起）
07	-r<作业名称> ※	将指定的screen离线作业恢复
08	-S<作业名称> ※	指定screen作业的名称
09	-m	即使目前已在作业中的screen作业，仍强制建立新的screeN作业
10	-R	先试图恢复离线的作业，若找不到离线的作业，即建立新的screen作业
11	-s	指定建立新视窗时，所要执行的shell

实践应用：

实践操作情况-01：创建screen管理窗口，并指定管理的进程作业名称

# 创建screen管理窗口界面
[root@xiaoq ~]# screen -S xiaoQ-screen-01
or
[root@xiaoq ~]# screen 
-- 输出组合键ctrl+a->d可以暂时退出screen操作界面
-- 输出组合键shift+alt+d表示彻底中止screen操作界面（等价于执行了exit命令）
 

实践操作情况-02：查看screen管理窗口

# 创建screen管理窗口界面
[root@xiaoq ~]# screen -S xiaoQ-screen-01
or
[root@xiaoq ~]# screen 
-- 输出组合键ctrl+a->d可以退出screen操作界面
​
# 查看screen管理窗口界面
[root@xiaoq ~]# screen -list
There are screens on:
    3539.pts-0.xiaoq            (Detached)
    3520.xiaoQ-screen-01    (Detached)
2 Sockets in /var/run/screen/S-root.
 

实践操作情况-03：进入screen指定窗口

# 查看screen管理窗口界面
[root@xiaoq ~]# screen -list
There are screens on:
    3539.pts-0.xiaoq            (Detached)
    3520.xiaoQ-screen-01    (Detached)
2 Sockets in /var/run/screen/S-root.
​
# 进入screen指定管理窗口
[root@xiaoq ~]# screen -r 3539
 

实践操作情况-04：设置screen指定窗口为离线挂起状态

# 当screen作业任务是非挂起状态是无法进入的
[root@xiaoq ~]# screen -list
There are screens on:
    3539.pts-0.xiaoq             (Attached)  -- 非挂起状态
    3520.xiaoQ-screen-01    (Detached)
2 Sockets in /var/run/screen/S-root.
[root@xiaoq ~]# screen -r 3539
There is a screen on:
    3539.pts-0.xiaoq              (Attached)
There is no screen to be resumed matching 3539.
-- 进入非挂起作业状态窗口会报错

​

# 设置screen指定作业任务为挂起状态
[root@xiaoq ~]# screen -d 3539
[3539.pts-0.xiaoq detached.]
-- 调整为了挂起状态
[root@xiaoq ~]# screen -list
There are screens on:
    3539.pts-0.xiaoq              (Detached)
    3520.xiaoQ-screen-01     (Detached)
2 Sockets in /var/run/screen/S-root.
-- 再次进入就没有问题
​
# 还可以使用共享窗口方式进行操作
[root@xiaoq ~]# screen -list
There are screens on:
    3539.pts-0.xiaoq            (Attached)
    3520.xiaoQ-screen-01    (Detached)
2 Sockets in /var/run/screen/S-root.
-- 非挂起状态，有可能有其他操作者正在管理作业任务
[root@xiaoq ~]# screen -x 3539
-- 实现多个操作共享屏幕状态，但是操作人只能是一个，否则会产生冲突（了解即可）
 

screen命令操作总结：

创建screen操作界面空间：screen -S 空间名称
查看screen操作界面空间：screen -list
进入screen操作界面空间：screen -r 空间编号/空间名称 （退出 ctrl+a+d 挂起 exit 彻底退出）
修改screen操作界面空间：screen -d 空间编号/空间名称 将指定空间设置为挂起状态
共享screen操作界面空间：screen -x 空间编号/空间名称 实现多个不同终端用户共享操作界面

说明：如何判断你在screen中,可以先按ctrl+a再按w，查看xshell或crt工具栏下方或上方会有提示显示

1.5 系统进程的优先级

1.5.1 进程优先级概念介绍

01. 进程优先级概念介绍

进程优先级指的是优先享有资源，比如排队买票时，军人优先，老人优先，孕妇优先等等。

02. 进程优先级作用说明

比如海底捞火锅正常情况下就餐响应就特别慢，当节假日来临时就餐人员激增会导致处理请求更加慢；

那么假设我是海底捞VIP客户（最高优先级），无论门店多繁忙，我都不用排队，会优先给我提供服务；

对于没有VIP的人员（较低优先级）则进入排队等待状态；

同理，在系统中如果有些特殊的进程服务需要优先运行，就可以调整优先级使之成为VIP。

1.5.2 进程优先级配置方法

在启动服务进程时，会为不同的进程使用不同的调度策略：（不同优先级分配）

nice值越高：表示优先级越低，例如+20，该进程容易将CPU资源使用量先让给其他进程；
nice值越低：表示优先级越高，例如-20，该进程不会将CPU资源使用量先让给其他进程；
总结：nice越高优先级越低；nice越低优先级越高。

使用命令获取进程优先级信息：

[root@xiaoq ~]# top
PID    USER     PR  NI    VIRT      RES    SHR  S  %CPU %MEM     TIME+   COMMAND  
3961   root      20   0            0         0         0  S   1.3      0.0        0:01.03   kworker/+
  813   root      20   0  305280   6400   5024  S   0.3      0.6        1:49.38   vmtoolsd 
3964   root      20   0    58304   2108   1488  R   0.3      0.2        0:00.07   top      
      1   root      20   0  125452   3792   2408  S   0.0      0.4        0:04.06   systemd 
-- 查看nice优先级：ni表示实际nice级别（默认为0）；pr显示nice数值，20映射级别0，0映射级别-20
​
# 查看指定进程信息的优先级
[root@xiaoq ~]# ps -axo command,nice|grep sshd
/usr/sbin/sshd -D                  0
sshd: root@pts/0,pts/1        0
nice级别与nice数值对应表：

状态	nice级别（NI）	nice数值（PR）
最低状态	+20	40
正常状态	0	20
最高状态	-20	0

说明：nice级别数值和nice优先级数值信息换算为：PR=NI+20

使用命令调整进程优先级信息：

方式一：nice命令指定程序进程的优先级

# 调整前查看指定进程的优先级
[root@xiaoq ~]# vim /etc/hosts
[root@xiaoq ~]# ps -axo pid,command,nice|grep vim
  4015 vim /etc/hosts                0
-- 默认的nice优先级设置为0
​
# 调整后查看指定进程的优先级
[root@xiaoq ~]# nice -n -5 vim /etc/hosts
[root@xiaoq ~]# ps -axo pid,command,nice|grep vim
  4027 vim /etc/hosts               -5

方式二：renice命令修改正在运行的进程优先级

# 调整前查看指定进程的优先级
[root@xiaoq ~]# ps -axo pid,command,nice|grep sshd
  1265 /usr/sbin/sshd -D                  0
  3843 sshd: root@pts/0,pts/1        0
​
# 调整后查看指定进程的优先级
[root@xiaoq ~]# renice -n -20 1265
1265 (process ID) old priority 0, new priority -20
[root@xiaoq ~]# ps -axo pid,command,nice|grep sshd
  1265 /usr/sbin/sshd -D              -20
  3843 sshd: root@pts/0,pts/1        0
-- 已经存在的sshd进程已经由默认0调整为-20的最高优先级
 

说明：在企业实践应用中，调整进程优先级是可以尽量避免系统假死情况出现的。

1.6 系统平均负载概念

每次发现系统变慢时，运维人员通常做的第一件事，就是执行top或者uptime/w命令，来查询系统负载情况。

[root@xiaoq ~]# w
 16:32:29 up 19:25,  4 users,  load average: 0.00, 0.01, 0.05
USER     TTY      FROM             LOGIN@   IDLE   JCPU PCPU  WHAT
root     pts/3    10.0.0.1:S.0     12:31    1:18m  0.15s  0.15s  /bin/bash
root     pts/4    10.0.0.1:S.1     12:53    5.00s   0.58s  0.01s  w
root     pts/5    10.0.0.1:S.2     12:53    3:39m  0.06s  0.06s  /bin/bash
root     pts/6    10.0.0.1:S.3     12:53    3:38m  0.09s  0.09s  /bin/bash
​
[root@xiaoq ~]# uptime
 16:16:12 up 19:08,  4 users,  load average: 0.70, 0.04, 0.05
-- 平均负载的信息分别是 1分钟 5分钟 以及15分钟的平均负载（load average）

1.6.1 系统平均负载概念介绍

平均负载不就是单位时间内的CPU使用率情况吗？上面的0.70就代表CPU使用率是70%。但其实并不是这样…

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

说明：平均负载与CPU使用率并没有直接关系。

可运行状态进程：
是指正在使用CPU或者正在等待CPU的进程，也就是通过ps命令查看到处于R状态的进程。

不可中断状态进程：
是系统中最常见的等待硬件设备的I/O响应的进程，也就是通过ps命令查看到的D状态（Disk sleep）的进程。

当一个进程向磁盘写入数据时，为了保证数据的一致性，在得到磁盘回复前，是不能被其他进程中断的，

这个时候的进程就处于不可中断状态。如果此时的进程被打断了，就容易出现磁盘数据与进程数据不一致情况；

所以，不可中断状态实际上是系统对进程和硬件设备的一种保护机制。

说明：平均负载其实是单位时间内的活跃进程数量，活跃进程数量=可运行状态进程+不可中断状态进程

1.6.2 系统平均负载合理范围

最理想的状态是每个CPU核心上都刚好运行着一个进程，这样每个CPU核心都得到了充分利用。

系统平均负载数值==系统CPU总核心数-- 4核心CPU 活跃进程数4 低CPU没有充分利用 高CPU出现负载压力过大

因此在评判平均负载时，首先你要知道系统有几个CPU核心，可以通过top命令获取，或者命令获取：

[root@xiaoq ~]# grep  "processor" /proc/cpuinfo            
processor       : 0
processor       : 1
[root@xiaoq ~]# grep  "processor" /proc/cpuinfo|wc -l
2
​
[root@xiaoq ~]# grep "model name" /proc/cpuinfo 
/proc/cpuinfo:model name        : Intel(R) Core(TM) i5-4300U CPU @ 1.90GHz
/proc/cpuinfo:model name        : Intel(R) Core(TM) i5-4300U CPU @ 1.90GHz
 

假设在4 2 1核心的CPU上，如果平均负载为2时，表示的含义是什么？

在4个CPU核心的系统上，表示CPU的使用率为50%，有50%资源是空闲的；
在2个CPU核心的系统上，表示CPU的使用率为100%，刚好完全占用；
在1个CPU核心的系统上，表示CPU的使用率为200%，有一半的进程竞争不到CPU资源，只能处于等待状态；

平均负载的三个数值，需要重点关注哪个？

实际上，三个数值都需要关注，就好比北京4月的天气：

如果只看晚上天气，感觉还是比较冷的状态，感觉冬天还没过去；

如果只看中午天气，感觉还是比较暖的状态，感觉春天已经来了；

但只有结合早上、中午、晚上三个时间点的温度来看，基本可以全方位了解一天的天气情况。

如果三个值基本相同，或者相差不大，那就说明系统负载很平稳；

如果1分钟的值远小于15分钟的值，就说明系统最近1分钟的负载在减少，而过去15分钟内却有很大的负载；

如果1分钟的值远大于15分钟的值，就说明系统最近1分钟的负载在增加，这种增加可能是临时或持续的，需要关注

说明：1分钟平均负载接近或超过CPU核心数，表示正处于过载状态，就需要进行分析和优化调整了。

假设在2个核心CPU系统上看到平均负载为：2.73 6.90 12.98

说明在过去的01分钟内，系统有136%的超载（2.73/2*100%=136%）

说明在过去的05分钟内，系统有345%的超载（6.90/2*100%=345%）

说明在过去的15分钟内，系统有649%的超载（12.98/2*100%=649%）

但从整体趋势来看，系统的负载是在逐步的降低的。

实际生产环境中，平均负载多高时，需要重点关注？

当平均负载占用CPU核心数量高于70%的时候，就应该分析排查负载高的问题了。

一旦负载过高，就可能导致进程响应变慢，进行影响服务的正常运行功能。

但所说的70%这个数字并不是绝对的，最推荐的方法还是把系统的平均负载监控起来；

然后根据大量的历史数据和趋势图，来判断负载的变化情况，当发现负载明显升高趋势时，再去做分析和处理。

平均负载与CPU使用率有什么关系吗？

在实际工作中，经常容易把平均负载和CPU使用率混淆，在这里进行一下区分说明：

平均负载是指单位时间内，处于可运行状态和不可中断状态的进程数量。

不仅包含了正在使用CPU的进程，还包含了等待CPU和等待I/O的进程。

而CPU使用率，是单位时间内CPU繁忙情况的统计，和平均负载并不一定完全对应。

对于CPU密集型进程，使用大量CPU计算会导致平均负载升高，利用率也升高，此时两者是一致的；
对于I/O密集型进程，等待I/O也会导致平均负载升高，但CPU使用率不一定很高；
大量的CPU进程调度也会导致平均负载升高，此时的CPU使用率也会比较高。

1.6.3 系统平均负载案例实战

结合上面三个实例分别来看三种企业情况，并用stress、mpstat、pidstat等工具，找出平均负载升高的根源：

stress：是Linux系统压力测试工具，可以用作异常进程模拟平均负载升高的场景；

mpstat：是多核CPU性能分析工具，用来实时查看每个CPU的性能指标，以及所有CPU的平均指标；

pidstat：是常用的进程性能分析工具，用来实时查看进程的CPU、内存、I/O以及上下文切换等性能指标；

以上命令信息中，stress mpstat pidstat命令默认不存在，需要下载指定软件包：

# 软件下载安装过程
[root@xiaoq ~]# yum install -y sysstat
[root@xiaoq ~]# yum install -y stress
​
# 软件升级部署过程
[root@xiaoq ~]# wget http://pagesperso-orange.fr/sebastien.godard/sysstat-11.7.3-1.x86_64.rpm
[root@xiaoq ~]# rpm -Uvh sysstat-11.7.3-1.x86_64.rpm

模拟CPU密集型情况：
在A终端运行stress命令，模拟一个CPU核心使用率100%场景：

[root@xiaoq ~]# stress --cpu 1 --timeout 600

在B终端运行uptime查看平均负载的变化情况

[root@xiaoq ~]# watch -d uptime

-- watch -d 表示高亮显示数据实时变化的信息
00:51:56 up 21:24,  8 users,  load average: 0.98, 0.89, 0.58
-- 发现平均负载数值持续升高

在C终端运行mpstat查看CPU使用率的变化情况

[root@xiaoq ~]# mpstat -P ALL 5
-- -P ALL表示监控所有CPU，后面数字5表示间隔5秒输出一组数据
Linux 3.10.0-1127.el7.x86_64 (xiaoq.edu)    xx/xx/xx    _x86_64_    (2 CPU)
00:53:17     CPU    %usr   %nice  %sys %iowait  %irq  %soft %steal %guest  %gnice   %idle
00:53:22     all       50.05   0.00    0.20     0.00      0.00    0.10    0.00      0.00       0.00      49.65
00:53:22       0     100.00    0.00    0.00     0.00      0.00    0.00    0.00      0.00      0.00        0.00
00:53:22       1         0.20    0.00    0.60     0.00      0.00    0.00    0.00      0.00      0.00      99.20

– 如果是单核CPU，会显示只有一个all和0的CPU信息；
– 如果是多核CPU，会显示所有CPU核心信息和总的核心使用率平均值

在B终端中可以看到：1分钟平均负载慢慢增加到将近1；

在C终端中可以看到：正好一个CPU核心的使用率为100%，但是iowait只有0；

说明平均负载的升高正是由于CPU使用率为100%；

如何获得哪个进程导致了CPU使用率为100%，可以使用pidstat来查询：

[root@xiaoq ~]# pidstat -u 5 1
-- 间隔5秒后输出一组数据
Linux 3.10.0-1127.el7.x86_64 (xiaoq.edu)        _x86_64_    (2 CPU)
01:03:20      UID     PID    %usr %system  %guest    %CPU   CPU  Command
01:03:25        0      6238  100.00    0.20         0.00     100.00     0       stress
-- 这里明显看到，stress进程CPU使用率为100%

模拟IO密集型情况：

在A终端运行stress命令，模拟系统磁盘I/O压力，即不停地执行sync：
[root@xiaoq ~]# stress --io 10 --timeout 600
-- 将数值调整为10，是为了给系统磁盘的I/O压力更大些

在B终端运行uptime查看平均负载的变化情况
[root@xiaoq ~]# watch -d uptime
15:46:54 up 1 day,  3:38,  3 users,  load average: 5.50, 1.54, 0.57

在C终端运行mpstat查看CPU使用率的变化情况
[root@xiaoq ~]# mpstat -P ALL 5
-- -P ALL表示监控所有CPU，后面数字5表示间隔5秒输出一组数据
15:47:07     CPU    %usr %nice  %sys %iowait %irq  %soft %steal %guest %gnice %idle
15:47:12     all       0.83    0.00   94.81    0.00    0.00    0.00    0.00      0.00      0.00     4.36
15:47:12       0       0.83    0.00   93.33    0.00    0.00    0.00    0.00      0.00      0.00      5.83
15:47:12       1       0.62    0.00   96.48    0.00    0.00    0.00    0.00      0.00      0.00      2.90
-- 可以看出内核态消耗的CPU资源更多

在B终端中可以看到：1分钟平均负载慢慢增加到将近1；

在C终端中可以看到：正好一个CPU核心的内核使用率为100%，但是用户使用率只有0.83；

说明平均负载的升高正是由于I/O压力增大造成；

如何获得哪个进程导致了I/O压力增加的，可以使用pidstat来查询：

[root@xiaoq ~]# pidstat -u 5 1
-- 间隔5秒后输出一组数据
Linux 3.10.0-1127.el7.x86_64 (xiaoq.edu)    01/29/22    _x86_64_    (2 CPU)
Average:      UID     PID    %usr %system  %guest  %wait  %CPU   CPU  Command
Average:        0      8394    0.20   21.16        0.00      65.07    21.36     -         stress
Average:        0      8395    0.20   11.78        0.00      76.65    11.98     -         stress
Average:        0      8396    0.40   16.17        0.00      71.46    16.57     -         stress
Average:        0      8397    0.20   17.37        0.00      70.86    17.56     -         stress
-- 可以看出，stress进程导致CPU资源占用，对应I/O压力升高

模拟CPU大量进程调用：
当系统中运行进程超过CPU运行能力时，就会出现等待CPU的进程；

在A终端运行stress命令，模拟产生出8个进程情况：

[root@xiaoq ~]# stress -c 8 --timeout 600

在B终端运行uptime查看平均负载的变化情况

[root@xiaoq ~]# watch -d uptime
16:15:21 up 1 day,  4:07,  3 users,  load average: 3.40, 7.00, 6.66
-- 由于系统CPU总核心数为2，明显比8个进程要少得多，因此系统的CPU处于严重过载状态

在C终端运行pidstat查看目前进程应用的情况

[root@xiaoq ~]# pidstat -u 5 1
-- 间隔5秒后输出一组数据
[root@xiaoq ~]# pidstat -u 5 1
Linux 3.10.0-1127.el7.x86_64 (xiaoq.edu)    01/29/22    _x86_64_    (2 CPU)
16:15:43      UID       PID    %usr %system  %guest   %wait  %CPU   CPU  Command
16:15:48        0        9104   24.95    0.00         0.00     75.85     24.95     1     stress
16:15:48        0        9105   25.15    0.00         0.00     75.05     25.15     0     stress
16:15:48        0        9106   25.15    0.00         0.00     74.85     25.15     0     stress
16:15:48        0        9107   24.75    0.00         0.00     75.05     24.75     1     stress
-- 显示不同CPU核心的进程占用资源情况，但没有top命令查看的更加直观。

可以看出，8个进程在争抢2个CPU核心，每个进程等待CPU的时间（也就是命令输出%wait列）高达75%；

这些超过CPU计算能力的进程，最终导致CPU过载。

三种平均负载升高实战情况总结：

序号	负载升高场景	平均负载变化	use%	sys%	wait%	CPU整体使用率	磁盘IO消耗
01	CPU密集型进程	升高	消耗多	消耗少	消耗少	使用率高（某个核心）	磁盘消耗小
02	IO密集型进程	升高	消耗少	消耗多	消耗多	使用率低	磁盘消耗大
03	大量进程产生	升高	消耗多	消耗少	消耗多	使用率高（所有核心）	磁盘消耗小

异常问题处理思路总结：

查看获取系统的负载情况：

可以利用uptime/w/top的命令进行查看获取。

查看分析系统的使用情况：mpstat

CPU使用率高的原因：进程等待高、内核态占用高、软中断数量多、更高优先级进程多。

查看哪个进程造成的问题：

可以利用top命令获取到哪个进程造成了CPU资源占用率高的情况。

追踪指定进程的运行情况：ps pidstat

可以通过命令追踪进程的整体运行情况，了解进程对应的服务信息。

根据服务的日志进行分析：

在追踪进程过程中获取到服务程序信息，可以根据服务程序产生的日志信息，细化分析具体问题原因。