linux进程管理基本概念

进程管理

博客链接：https://www.blog.23day.site

需要了解 进程，父进程，进程组,会话和控制终端的相关概念。

1. 进程和父进程：每个进程都有父进程，而所有的进程以init进程为根，形成一个树状结构

2. 进程组：每个进程都会属于一个进程组(process group)，每个进程组中可以包含多个进程。进程组会有一个进程组领导进程 (process group leader)，领导进程的PID成为进程组的ID (process group ID, PGID)，以识别进程组。

3. 会话：一个或是多个进程组集合。 一个会话有多个进程组，允许存在多个后台进程组 (backgroup process group) 和一个前台进程组 (foregroup process group)

可以看到执行ps -fj结果如下：

UID         PID   PPID   PGID    SID  C STIME TTY          TIME CMD
chen      36829  36825  36829  36829  0 10:56 pts/0    00:00:00 -bash
chen      37247  36829  37247  36829  0 10:57 pts/0    00:00:00 vim
chen      90490  36829  90490  36829  0 11:57 pts/0    00:00:00 ps -fj

其中PID就是进程id，PPID是父进程id，PGID为进程组id，SID为会话ID

进程树

在Linux系统中，除了系统启动之后的第一个进程由系统来创建，其余的进程都必须由已存在的进程来创建，新创建的进程叫做子进程，而创建子进程的进程叫做父进程。那个在系统启动及完成初始化之后，Linux自动创建的进程叫做根进程。根进程是Linux中所有进程的祖宗，其余进程都是根进程的子孙。具有同一个父进程的进程叫做兄弟进程。

某些进程会产生一些新的进程，我们把这些进程称作子进程，而把这个进程本身称作父进程。比如，我们必须正常登录到 Shell 环境中才能执行系统命令，而 Linux 的标准 Shell 是 bash。我们在 bash 当中执行了 ls 命令，那么 bash 就是父进程，而 ls 命令是在 bash 进程中产生的进程，所以 ls 进程是 bash 进程的子进程。也就是说，子进程是依赖父进程而产生的，如果父进程不存在，那么子进程也不存在了。

pstree 命令是以树形结构显示程序和进程之间的关系

选项	含义
-a	显示启动每个进程对应的完整指令，包括启动进程的路径、参数等。
-c	不使用精简法显示进程信息，即显示的进程中包含子进程和父进程。
-n	根据进程 PID 号来排序输出，默认是以程序名排序输出的。
-p	显示进程的 PID。
-u	显示进程对应的用户名称。

什么是进程和程序

程序是人使用计算机语言编写的，可以实现一定功能，并且可以执行的代码集合。而进程是正在执行中的程序。当程序被执行时，执行人的权限和属性，以及程序的代码都会被加载入内存，操作系统给这个进程分配一个 ID，称为 PID（进程 ID）。

也就是说，在操作系统中，所有可以执行的程序与命令都会产生进程。

启动进程

手工启动进程指的是由用户输入命令直接启动一个进程，根据所启动的进程类型和性质的不同，其又可以细分为前台启动和后台启动 2 种方式。

前台启动进程

这是手工启动进程最常用的方式，因为当用户输入一个命令并运行，就已经启动了一个进程，而且是一个前台的进程，此时系统其实已经处于一个多进程的状态（一个是 Shell 进程，另一个是新启动的进程）。

假如启动一个比较耗时的进程，然后再把该进程挂起，并使用 ps 命令查看，就会看到该进程在 ps 显示列表中，例如：

[root@localhost ~]# find / -name demo.jpg <--在根目录下查找 demo.jpg 文件，比较耗时
#此处省略了该命令的部分输出信息
#按“CTRL+Z”组合键，即可将该进程挂起
[root@localhost ~]# ps <--查看正在运行的进程
PID  TTY      TIME   CMD
2573 pts/0  00:00:00 bash
2587 pts/0  00:00:01 find
2588 pts/0  00:00:00 ps

通过运行 ps 命令查看进程信息，可以看到，刚刚执行的 find 命令的进程号为 2587，同时 ps 进程的进程号为 2588。

后台启动进程

进程直接从后台运行，用的相对较少，除非该进程非常耗时，且用户也不急着需要其运行结果的时候

从后台启动进程，其实就是在命令结尾处添加一个 " &" 符号（注意，& 前面有空格）。输入命令并运行之后，Shell 会提供给我们一个数字，此数字就是该进程的进程号。然后直接就会出现提示符，用户就可以继续完成其他工作，例如：

[root@localhost ~]# find / -name install.log &
[1] 1920
#[1]是工作号，1920是进程号

创建进程

1 地址空间

每个进程都有自己的进程地址空间，格式大概是这个样子：

栈(Stack)以帧为单位，当程序调用函数(假如该函数名为fun01)时，stack会向下增长一帧，这个帧会存储该函数的参数、局部变量以及返回地址，计算机将控制权交给fun01，un01处于激活状态，这时 Global Data 和 该帧中的局部变量共同构成了context也就是环境上下文。当函数又进一步调用另一个函数的时候，一个新的帧会继续增加到栈的下方，控制权转移到新的函数中。当激活函数返回的时候，会从栈中弹出(pop，读取并从栈中删除)该帧，并根据帧中记录的返回地址，将控制权交给返回地址所指向的指令。

2 进程元数据

进程元数据可以用来区分进程，了解进程状态信息

每一个进程都有PID(进程id),PPID(进程的父进程id),PGID(进程组id)等，这些信息描述了进程的各种信息，但他们并不保存在进程的内存空间中。内核会为每个进程在内核自己的空间中分配一个变量(task_struct结构体)以保存上述信息。内核可以通过查看自己空间中的各个进程的附加信息就能知道进程的概况，而不用进入到进程自身的空间。每个进程的附加信息中有位置专门用于保存接收到的信号。

3 如何创建进程

一般情况下：

1 当一个程序调用fork的时候，实际上就是将本进程的内存空间，包括text, global data, heap和stack，又复制出来一个，构成一个新的进程。

因为在系统中表示一个进程的实体是进程控制块，创建新进程的主要工作就是要创建一个新控制块，而创建一个新控制块最简单的方法就是复制。

子进程的栈、数据以及栈段开始时是父进程内存相应各部分的完全拷贝，因此它们互不影响。从性能方面考虑，父进程到子进程的数据拷贝并不是创建时就拷贝了的，而是采用了写时拷贝（copy-on -write）技术来处理。

2 同时在内核中为改进程创建新的附加信息 (比如新的PID，而PPID为原进程的PID)。

3 然后，程序调用exec的时候，进程清空自身内存空间的text, global data, heap和stack，并根据新的程序文件重建text, global data, heap和stack (此时heap和stack大小都为0)，并开始运行。

特殊进程

任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个 子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。

僵尸进程

一个进程使用了fork创建了子进程，如果子进程终止进入僵死状态，而父进程并没有调用wait或者waitpid获取子进程的状态信息，那么子进程仍留下一个数据结构保存在系统中，这种进程称为僵尸进程

僵尸进程会占用一定的内存空间，还占用了进程号，所以一定要避免大量的僵尸进程产生。有很多方法可以避免僵尸进程

unix提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就可以得到。这种机制就是: 在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。 但是仍然为其保留一定的信息(包括进程号the process ID,退出状态the termination status of the process,运行时间the amount of CPU time taken by the process等)。直到父进程通过wait / waitpid来取时才释放。 但这样就导致了问题，如果进程不调用wait / waitpid的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害，应当避免。

孤儿进程

父进程退出，而它的子进程仍在运行，那么这些子进程就会成为孤儿进程。孤儿进程会被init进程（进程号为1）收养，并由init进程对它们完成状态收集工作

init进程会循环调用wait这些孤儿进程，所以，孤儿进程没有什么危害

孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

守护进程

它是运行在后台的一种特殊进程。它独立于控制终端并周期性执行某种任务或等待处理某些事件

守护进程的父进程是init进程，因为其父进程已经故意被终止掉了

守护进程相对于普通的孤儿进程需要做一些特殊处理

守护进程一般可以通过以下方式启动：

1. 在系统启动时由启动脚本启动，这些启动脚本通常放在/etc/rc.d目录下；
2. 利用inetd超级服务器启动，大部分网络服务都是这样启动的，如ftp、telnet等；
3. 由cron定时启动以及在终端用nohup启动的进程也是守护进程

查看进程

ps 命令是最常用的监控进程的命令，通过此命令可以查看系统中所有运行进程的详细信息。

ps 命令的基本格式如下：

[root@localhost ~]# ps aux
\#查看系统中所有的进程，使用 BS 操作系统格式
[root@localhost ~]# ps -le
\#查看系统中所有的进程，使用 Linux 标准命令格式

选项：

• a：显示一个终端的所有进程，除会话引线外；
• u：显示进程的归属用户及内存的使用情况；
• x：显示没有控制终端的进程；
• -l：长格式显示更加详细的信息；
• -e：显示所有进程；

可以看到，ps 命令有些与众不同，它的部分选项不能加入"-“，比如命令"ps aux”，其中"aux"是选项，但是前面不能带“-”。

大家如果执行 “man ps” 命令，则会发现 ps 命令的帮助为了适应不同的类 UNIX 系统，可用格式非常多，不方便记忆。所以，我建议大家记忆几个固定选项即可。比如：

• “ps aux” 可以查看系统中所有的进程；
• “ps -le” 可以查看系统中所有的进程，而且还能看到进程的父进程的 PID 和进程优先级；
• “ps -l” 只能看到当前 Shell 产生的进程；

[root@localhost ~]# ps aux
#查看系统中所有的进程
USER PID %CPU %MEM  VSZ  RSS   TTY STAT START TIME COMMAND
root   1  0.0  0.2 2872 1416   ?   Ss   Jun04 0:02 /sbin/init
root   2  0.0  0.0    0    0   ?    S   Jun04 0:00 [kthreadd]
root   3  0.0  0.0    0    0   ?    S   Jun04 0:00 [migration/0]
root   4  0.0  0.0    0    0   ?    S   Jun04 0:00 [ksoftirqd/0]

表头	含义
USER	该进程是由哪个用户产生的。
PID	进程的 ID。
%CPU	该进程占用 CPU 资源的百分比，占用的百分比越高，进程越耗费资源。
%MEM	该进程占用物理内存的百分比，占用的百分比越高，进程越耗费资源。
VSZ	该进程占用虚拟内存的大小，单位为 KB。
RSS	该进程占用实际物理内存的大小，单位为 KB。
TTY	该进程是在哪个终端运行的。其中，tty1 ~ tty7 代表本地控制台终端（可以通过 Alt+F1 ~ F7 快捷键切换不同的终端），tty1~tty6 是本地的字符界面终端，tty7 是图形终端。pts/0 ~ 255 代表虚拟终端，一般是远程连接的终端，第一个远程连接占用 pts/0，第二个远程连接占用 pts/1，依次増长。
STAT	进程状态。常见的状态有以下几种：-D：不可被唤醒的睡眠状态，通常用于 I/O 情况。-R：该进程正在运行。-S：该进程处于睡眠状态，可被唤醒。-T：停止状态，可能是在后台暂停或进程处于除错状态。-W：内存交互状态（从 2.6 内核开始无效）。-X：死掉的进程（应该不会出现）。-Z：僵尸进程。进程已经中止，但是部分程序还在内存当中。-<：高优先级（以下状态在 BSD 格式中出现）。-N：低优先级。-L：被锁入内存。-s：包含子进程。-l：多线程（小写 L）。-+：位于后台。
START	该进程的启动时间。
TIME	该进程占用 CPU 的运算时间，注意不是系统时间。
COMMAND	产生此进程的命令名。

【例 2】"ps aux"命令可以看到系统中所有的进程，"ps -le"命令也能看到系统中所有的进程。由于 “-l” 选项的作用，所以 “ps -le” 命令能够看到更加详细的信息，比如父进程的 PID、优先级等。但是这两个命令的基本作用是一致的，掌握其中一个就足够了。

[root@localhost ~]# ps -le
F S UID PID PPID C  PRI Nl ADDR  SZ WCHAN TTY      TIME  CMD
4 S   0   1    0 0  80   0 -    718 -     ?    00:00:02  init
1 S   0   2    0 0  80   0 -      0 -     ?    00:00:00  kthreadd
1 S   0   3    2 0 -40   - -      0 -     ?    00:00:00  migration/0
1 S   0   4    2 0  80   0 -      0 -     ?    00:00:00  ksoflirqd/0
1 S   0   5    2 0 -40   - -      0 -     ?    00:00:00  migration/0

表头	含义
F	进程标志，说明进程的权限，常见的标志有两个: 1：进程可以被复制，但是不能被执行；4：进程使用超级用户权限；
S	进程状态。具体的状态和"psaux"命令中的 STAT 状态一致；
UID	运行此进程的用户的 ID；
PID	进程的 ID；
PPID	父进程的 ID；
C	该进程的 CPU 使用率，单位是百分比；
PRI	进程的优先级，数值越小，该进程的优先级越高，越早被 CPU 执行；
NI	进程的优先级，数值越小，该进程越早被执行；
ADDR	该进程在内存的哪个位置；
SZ	该进程占用多大内存；
WCHAN	该进程是否运行。"-"代表正在运行；
TTY	该进程由哪个终端产生；
TIME	该进程占用 CPU 的运算时间，注意不是系统时间；
CMD	产生此进程的命令名；

【例 3】如果不想看到所有的进程，只想查看一下当前登录产生了哪些进程，那只需使用 “ps -l” 命令就足够了：

[root@localhost ~]# ps -l
#查看当前登录产生的进程
F S UID   PID  PPID C PRI NI ADDR SZ WCHAN TTY       TIME CMD
4 S 0   18618 18614 0  80  0 - 1681  -     pts/1 00:00:00 bash
4 R 0   18683 18618 4  80  0 - 1619  -     pts/1 00:00:00 ps

可以看到，这次从 pts/1 虚拟终端登录，只产生了两个进程：一个是登录之后生成的 Shell，也就是 bash；另一个是正在执行的 ps 命令。

top

ps 命令可以一次性给出当前系统中进程状态，但使用此方式得到的信息缺乏时效性，并且，如果管理员需要实时监控进程运行情况，就必须不停地执行 ps 命令，这显然是缺乏效率的。

为此，Linux 提供了 top 命令。top 命令可以动态地持续监听进程地运行状态，与此同时，该命令还提供了一个交互界面，用户可以根据需要，人性化地定制自己的输出，进而更清楚地了进程的运行状态。

top 命令的基本格式如下：

top [选项]

选项：

• -d 秒数：指定 top 命令每隔几秒更新。默认是 3 秒；
• -b：使用批处理模式输出。一般和"-n"选项合用，用于把 top 命令重定向到文件中；
• -n 次数：指定 top 命令执行的次数。一般和"-"选项合用；
• -p 进程PID：仅查看指定 ID 的进程；
• -s：使 top 命令在安全模式中运行，避免在交互模式中出现错误；
• -u 用户名：只监听某个用户的进程；

在 top 命令的显示窗口中，还可以使用如下按键，进行一下交互操作：

• ? 或 h：显示交互模式的帮助；
• P：按照 CPU 的使用率排序，默认就是此选项；
• M：按照内存的使用率排序；
• N：按照 PID 排序；
• T：按照 CPU 的累积运算时间排序，也就是按照 TIME+ 项排序；
• k：按照 PID 给予某个进程一个信号。一般用于中止某个进程，信号 9 是强制中止的信号；
• r：按照 PID 给某个进程重设优先级（Nice）值；
• q：退出 top 命令；

我们看看 top 命令的执行结果，如下：

[root@localhost ~]# top
top - 12:26:46 up 1 day, 13:32, 2 users, load average: 0.00, 0.00, 0.00
Tasks: 95 total, 1 running, 94 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.1%us, 0.1%sy, 0.0%ni, 99.7%id, 0.1%wa, 0.0%hi, 0.1%si, 0.0%st
Mem: 625344k total, 571504k used, 53840k free, 65800k buffers
Swap: 524280k total, 0k used, 524280k free, 409280k cached
PID   USER PR NI VIRT  RES  SHR S %CPU %MEM   TIME+ COMMAND
19002 root 20  0 2656 1068  856 R  0.3  0.2 0:01.87 top
1     root 20  0 2872 1416 1200 S  0.0  0.2 0:02.55 init
2     root 20  0    0    0    0 S  0.0  0.0 0:00.03 kthreadd
3     root RT  0    0    0    0 S  0.0  0.0 0:00.00 migration/0
4     root 20  0    0    0    0 S  0.0  0.0 0:00.15 ksoftirqd/0
5     root RT  0    0    0    0 S  0.0  0.0 0:00.00 migration/0
6     root RT  0    0    0    0 S  0.0  0.0 0:10.01 watchdog/0
7     root 20  0    0    0    0 S  0.0  0.0 0:05.01 events/0
8     root 20  0    0    0    0 S  0.0  0.0 0:00.00 cgroup
9     root 20  0    0    0    0 S  0.0  0.0 0:00.00 khelper
10    root 20  0    0    0    0 S  0.0  0.0 0:00.00 netns
11    root 20  0    0    0    0 S  0.0  0.0 0:00.00 async/mgr
12    root 20  0    0    0    0 S  0.0  0.0 0:00.00 pm
13    root 20  0    0    0    0 S  0.0  0.0 0:01.70 sync_supers
14    root 20  0    0    0    0 S  0.0  0.0 0:00.63 bdi-default
15    root 20  0    0    0    0 S  0.0  0.0 0:00.00 kintegrityd/0
16    root 20  0    0    0    0 S  0.0  0.0 0:02.52 kblockd/0
17    root 20  0    0    0    0 S  0.0  0.0 0:00.00 kacpid
18    root 20  0    0    0    0 S  0.0  0.0 0:00.00 kacpi_notify

我们解释一下命令的输出。top 命令的输出内容是动态的，默认每隔 3 秒刷新一次。命令的输出主要分为两部分：

1. 第一部分是前五行，显示的是整个系统的资源使用状况，我们就是通过这些输出来判断服务器的资源使用状态的；
2. 第二部分从第六行开始，显示的是系统中进程的信息；

我们先来说明第一部分的作用。

• 第一行为任务队列信息，具体内容如表 1 所示。

  内 容	说 明
  12:26:46	系统当前时间
  up 1 day, 13:32	系统的运行时间.本机己经运行 1 天 13 小时 32 分钟
  2 users	当前登录了两个用户
  load average: 0.00,0.00，0.00	系统在之前 1 分钟、5 分钟、15 分钟的平均负载。如果 CPU 是单核的，则这个数值超过 1 就是高负载：如果 CPU 是四核的，则这个数值超过 4 就是高负载 （这个平均负载完全是依据个人经验来进行判断的，一般认为不应该超过服务器 CPU 的核数）

• 第二行为进程信息，具体内容如表 2 所示。

  内 容	说 明
  Tasks: 95 total	系统中的进程总数
  1 running	正在运行的进程数
  94 sleeping	睡眠的进程数
  0 stopped	正在停止的进程数
  0 zombie	僵尸进程数。如果不是 0，则需要手工检查僵尸进程

• 第三行为 CPU 信息，具体内容如表 3 所示。

  内 容	说 明
  Cpu(s): 0.1 %us	用户模式占用的 CPU 百分比
  0.1%sy	系统模式占用的 CPU 百分比
  0.0%ni	改变过优先级的用户进程占用的 CPU 百分比
  99.7%id	空闲 CPU 占用的 CPU 百分比
  0.1%wa	等待输入/输出的进程占用的 CPU 百分比
  0.0%hi	硬中断请求服务占用的 CPU 百分比
  0.1%si	软中断请求服务占用的 CPU 百分比
  0.0%st	st（steal time）意为虚拟时间百分比，就是当有虚拟机时，虚拟 CPU 等待实际 CPU 的时间百分比

• 第四行为物理内存信息，具体内容如表 4 所示。

  内 容	说 明
  Mem: 625344k total	物理内存的总量，单位为KB
  571504k used	己经使用的物理内存数量
  53840k&ee	空闲的物理内存数量。我们使用的是虚拟机，共分配了 628MB内存，所以只有53MB的空闲内存
  65800k buffers	作为缓冲的内存数量

• 第五行为交换分区（swap）信息，如表 5 所示。

  内 容	说 明
  Swap: 524280k total	交换分区（虚拟内存）的总大小
  Ok used	已经使用的交换分区的大小
  524280k free	空闲交换分区的大小
  409280k cached	作为缓存的交换分区的大小

再来看 top 命令的第二部分输出，主要是系统进程信息，各个字段的含义如下：

• PID：进程的 ID。
• USER：该进程所属的用户。
• PR：优先级，数值越小优先级越高。
• NI：优先级，数值越小、优先级越高。
• VIRT：该进程使用的虚拟内存的大小，单位为 KB。
• RES：该进程使用的物理内存的大小，单位为 KB。
• SHR：共享内存大小，单位为 KB。
• S：进程状态。
• %CPU：该进程占用 CPU 的百分比。
• %MEM：该进程占用内存的百分比。
• TIME+：该进程共占用的 CPU 时间。
• COMMAND：进程的命令名。

这部分和 ps 命令的输出比较类似，只是如果在终端执行 top 命令，则不能看到所有的进程，而只能看到占比靠前的进程。接下来我们举几个 top 命令常用的实例。

【例 1】如果只想让 top 命令查看某个进程，就可以使用 “-p 选项”。命令如下：

[root@localhost ~]# top -p 15273
#只查看 PID为 15273的apache进程
top - 14:28:47 up 1 day, 15:34, 3 users, load average: 0.00,0.00,0.00
Tasks: 1 total, 0 running, 1 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: 625344k total, 574124k used, 51220k free, 67024k buffers
Swap: 524280k total, Ok used, 524280k free, 409344k cached
PID     USER PR NI VIRT  RES SHR S %CPU %MEM  TIME+  COMMAND
15273 daemon 20 0  4520 1192 580 S  0.0  0.2 0:00.00   httpd

【例 2】top 命令如果不正确退出，则会持续运行。在 top 命令的交互界面中按 “q” 键会退出 top 命令；也可以按 “?” 或 “h” 键得到 top 命令交互界面的帮助信息；还可以按键中止某个进程。比如：

[root@localhost ~]# top
top - 14:10:15 up 1 day, 15:15， 3 users, load average: 0.00，0.00, 0.00
Tasks: 97 total, 1 running, 96 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: 625344k total, 574248k used, 51096k free, 66840k buffers
Swap: 524280k total, Ok used, 524280k free, 409324k cached
PID to kill:15273
#按"k"键，会提示输入要杀死进程的PID
PID     USER PR NI VIRT  RES SHR S %CPU %MEM   TIME+ COMMAND
15273 daemon 20  0 4520 1192 580 S  0.0 0.2  0:00.00 httpd
..省略部分输出...

【例 3】输入要中止进程的 PID，比如要中止 15273 这个 apache 进程，命令如下：

top - 14:11:42 up 1 day, 15:17， 3 users, load average: 0.00，0.00, 0.00
Tasks: 97 total, 1 running, 96 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 625344k total, 574248k used, 51096k free, 66856k buffers
Swap: 524280k total, 0k used, 524280k free, 409324k cached
Kill PID 15273 with signal [15]:9
#提示输入信号，信号9代表强制中止
PID     USER PR NI VIRT  RES SHR S %CPU %MEM   TIME+ COMMAND
15273 daemon 20  0 4520 1192 580 S 0.0   0.2 0:00.00 httpd
…省略部分输出…

接下来 top 命令提示我们输入信号，信号 9 代表强制中止，这时就能够强制中止 15273 进程了。

【例 4】如果要改变某个进程的优先级，就要利用 “r” 交互命令。需要注意的是，我们能够修改的只有 Nice 的优先级，而不能修改 Priority 的优先级。具体修改命令如下：

[root@localhost ~]# top -p 18977
top - 14:17:09 up 1 day, 15:22, 3 users, load average: 0.00，0.00, 0.00
Tasks: 97 total, 1 running, 96 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
Mem: 625344k total, 574124k used, 51220k free, 66896k buffers
Swap: 524280k total, 0k used, 524280k free, 409324k cached
PID to renice:
#输入"r"交互命令之后，提示输入要修改优先级的进程的PID
PID   USER PR NI  VIRT  RES SHR  S %CPU %MEM   TIME+ COMMAND
18977 root 20 0  11592 3304 2572 S  0.0 0.5  0:04.37 sshd

输入 “r” 交互命令，会提示输入需要修改优先级的进程的 PID。例如，我们想要修改 18977 这个 sshd 远程连接进程的优先级，就输入该进程的 PID。命令如下：

Renice PID 18977 to value: 10
#输入PID后，需要输入Nice的优先级号
#我们把18977进程的优先级调整为10,回车后就能看到
PID   USER PR NI  VIRT  RES SHR  S %CPU %MEM   TIME+ COMMAND
18977 root 30 10 11592 3304 2572 R  0.0 0.5  0:04.38 sshd
#18977进程的优先级已经被修改了

【例 5】如果在操作终端执行 top 命令，则并不能看到系统中所有的进程，默认看到的只是 CPU 占比靠前的进程。如果我们想要看到所有的进程，则可以把 top 命令的执行结果重定向到文件中。不过 top 命令是持续运行的，这时就需要使用 “-b” 和 “-n” 选项了。具体命令如下：

[root@localhost ~]# top -b -n 1 > /root/top.log
#让top命令只执行一次，然后把执行结果保存到top.log文件中，这样就能看到所有的进程了

pgrep

grep：文本搜索工具，支持正则

1.1 语法

pgrep(选项)(参数)

1.2 选项

选项	描述
-o	仅显示找到的最小（起始）进程号；
-n	仅显示找到的最大（结束）进程号；
-l	显示进程名称；
-P	指定父进程号；
-g	指定进程组；
-t	指定开启进程的终端；
-u	指定进程的有效用户ID。

1.3 参数

进程名称：指定要查找的进程名称，同时也支持类似grep指令中的匹配模式

kill

kill 从字面来看，就是用来杀死进程的命令，但事实上，这个或多或少带有一定的误导性。从本质上讲，kill 命令只是用来向进程发送一个信号，至于这个信号是什么，是用户指定的。

也就是说，kill 命令的执行原理是这样的，kill 命令会向操作系统内核发送一个信号（多是终止信号）和目标进程的 PID，然后系统内核根据收到的信号类型，对指定进程进行相应的操作。

kill 命令的基本格式如下：

[root@localhost ~]# kill [信号] PID

kill 命令是按照 PID 来确定进程的，所以 kill 命令只能识别 PID，而不能识别进程名。Linux 定义了几十种不同类型的信号，读者可以使用 kill -l 命令查看所有信号及其编号，这里仅列出几个常用的信号，如表 1 所示。

信号编号	信号名	含义
0	EXIT	程序退出时收到该信息。
1	HUP	挂掉电话线或终端连接的挂起信号，这个信号也会造成某些进程在没有终止的情况下重新初始化。
2	INT	表示结束进程，但并不是强制性的，常用的 “Ctrl+C” 组合键发出就是一个 kill -2 的信号。
3	QUIT	退出。
9	KILL	杀死进程，即强制结束进程。
11	SEGV	段错误。
15	TERM	正常结束进程，是 kill 命令的默认信号。

需要注意的是，表中省略了各个信号名称的前缀 SIG，也就是说，SIGTERM 和 TERM 这两种写法都对，kill 命令都可以理解。

下面，我们举几个例子来说明一下 kill 命令。

【例 1】 标准 kill 命令。

[root@localhost ~】# service httpd start
#启动RPM包默认安装的apache服务
[root@localhost ~]# pstree -p 丨 grep httpd | grep -v “grep”
#查看 httpd 的进程树及 PID。grep 命令査看 httpd 也会生成包含"httpd"关键字的进程，所以使用“-v”反向选择包含“grep”关键字的进程，这里使用 pstree 命令来查询进程，当然也可以使用 ps 和 top 命令
|-httpd(2246)-±httpd(2247)
| |-httpd(2248)
| |-httpd(2249)
| |-httpd(2250)
| |-httpd(2251)
[root@localhost ~]# kill 2248
#杀死PID是2248的httpd进程，默认信号是15，正常停止
#如果默认信号15不能杀死进程，则可以尝试-9信号，强制杀死进程
[root@localhost ~]# pstree -p | grep httpd | grep -v “grep”
|-httpd(2246>-±httpd(2247)
| |-httpd(2249)
| |-httpd(2250)
| |-httpd(2251)
#PID是2248的httpd进程消失了

【例 2】使用“-1”信号，让进程重启。

[root@localhost ~]# kill -1 2246
使用“-1 (数字1)”信号，让httpd的主进程重新启动
[root@localhost ~]# pstree -p | grep httpd | grep -v “grep”
|-httpd(2246)-±httpd(2270)
| |-httpd(2271)
| |-httpd(2272)
| |-httpd(2273)
| |-httpd(2274)
#子httpd进程的PID都更换了，说明httpd进程已经重启了一次

【例 3】 使用“-19”信号，让进程暂停。

[root@localhost ~]# vi test.sh #使用vi命令编辑一个文件，不要退出
[root@localhost ~]# ps aux | grep “vi” | grep -v “grep”
root 2313 0.0 0.2 7116 1544 pts/1 S+ 19:2.0 0:00 vi test.sh
#换一个不同的终端，查看一下这个进程的状态。进程状态是S（休眠）和+（位于后台），因为是在另一个终端运行的命令
[root@localhost ~]# kill -19 2313
#使用-19信号，让PID为2313的进程暂停。相当于在vi界面按 Ctrl+Z 快捷键
[root@localhost ~]# ps aux | grep “vi” | grep -v “grep”
root 2313 0.0 0.2 7116 1580 pts/1 T 19:20 0:00 vi test.sh
#注意2313进程的状态，变成了 T（暂停）状态。这时切换回vi的终端,发现vi命令已经暂停，又回到了命令提示符，不过2313进程就会卡在后台。如果想要恢复，可以使用"kill -9 2313”命令强制中止进程，也可以利用后续章节将要学习的工作管理来进行恢复

学会如何使用 kill 命令之后，再思考一个问题，使用 kill 命令一定可以终止一个进程吗？

答案是否定的。文章开头说过，kill 命令只是“发送”一个信号，因此，只有当信号被程序成功“捕获”，系统才会执行 kill 命令指定的操作；反之，如果信号被“封锁”或者“忽略”，则 kill 命令将会失效。

killall 也是用于关闭进程的一个命令，但和 kill 不同的是，killall 命令不再依靠 PID 来杀死单个进程，而是通过程序的进程名来杀死一类进程，也正是由于这一点，该命令常与 ps、pstree 等命令配合使用。

killall 命令的基本格式如下：

[root@localhost ~]# killall [选项] [信号] 进程名

注意，此命令的信号类型同 kill 命令一样，因此这里不再赘述，此命令常用的选项有如下 2 个：

• -i：交互式，询问是否要杀死某个进程；
• -I：忽略进程名的大小写；

pkill

当作于管理进程时，pkill 命令和 killall 命令的用法相同，都是通过进程名杀死一类进程，该命令的基本格式如下：

[root@localhost ~]# pkill [信号] 进程名

表 1 罗列了此命令常用的信号及其含义。

信号编号	信号名	含义
0	EXIT	程序退出时收到该信息。
1	HUP	挂掉电话线或终端连接的挂起信号，这个信号也会造成某些进程在没有终止的情况下重新初始化。
2	INT	表示结束进程，但并不是强制性的，常用的 “Ctrl+C” 组合键发出就是一个 kill -2 的信号。
3	QUIT	退出。
9	KILL	杀死进程，即强制结束进程。
11	SEGV	段错误。
15	TERM	正常结束进程，是 kill 命令的默认信号。

pkill命令踢出登陆用户

除此之外，pkill 还有一个更重要的功能，即按照终端号来踢出用户登录，此时的 pkill 命令的基本格式如下：

[root@localhost ~]# pkill [-t 终端号] 进程名

[-t 终端号] 选项用于按照终端号踢出用户；

学习 killall 命令时，不知道大家发现没有，通过 killall 命令杀死 sshd 进程的方式来踢出用户，非常容易误杀死进程，要么会把 sshd 服务杀死，要么会把自己的登录终端杀死。

所以，不管是使用 kill 命令按照 PID 杀死登录进程，还是使用 killall 命令按照进程名杀死登录进程，都是非常容易误杀死进程的，而使用 pkill 命令则不会，举个例子：

[root@localhost ~]# w
#使用w命令查询本机已经登录的用户
20:06:34 up 28 min, 3 users, load average: 0.00, 0.00, 0.00
USER  TTY           FROM LOGIN@  IDLE  JCPU  PCPU WHAT
root ttyl              -  19:47 18:52 0.01s 0.01s -bash
root pts/0 192.168.0.100  19:47 0.00s 0.09s 0.04s w
root pts/1 192.168.0.100  19:51 14:56 0.02s 0.02s -bash
#当前主机已经登录了三个root用户，一个是本地终端ttyl登录，另外两个是从192.168.0.100登陆的远程登录
[root@localhost ~]# pkill -9 -t pts/1
#强制杀死从pts/1虚拟终端登陆的进程
[root@localhost ~]# w
20:09:09 up 30 min, 2 users, load average: 0.00, 0.00,0.00
USER   TTY          FROM LOGIN@  IDLE  JCPU  PCPU WHAT
root  ttyl             -  19:47 21:27 0.01s 0.01s -bash
root pts/0 192.168.0.100  19:47 0.00s 0.06s 0.00s w
#虚拟终端pts/1的登录进程已经被杀死了
``