【Linux】13.Linux进程概念（2）

3. 进程

进程

看看Linux内核源代码怎么说。

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）。

下面的状态在kernel源代码里定义。

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char * const task_state_array[] = {
"R (running)", /* 0 */
"S (sleeping)", /* 1 */
"D (disk sleep)", /* 2 */
"T (stopped)", /* 4 */
"t (tracing stop)", /* 8 */
"X (dead)", /* 16 */
"Z (zombie)", /* 32 */
};

• R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。

• S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））。

• D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。

• T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。

• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

• Z僵尸进程 (zombie) 状态：是指进程已经终止，但其父进程还没有回收它的资源（没有调用 wait/waitpid）。

例如我们在myproc.c文件里先写一个简单的hello Linux打印程序，运行程序的时候查询到进程是这样的。

ydk_108@iZuf68hz06p6s2809gl3i1Z:~/108/lesson12$ ps axj |grep myproc
 252493  252598  252598  252493 pts/0     252598 S+    1001   0:00 ./myproc
 252581  252600  252599  252581 pts/1     252599 S+    1001   0:00 grep --color=auto myproc

然后我们把里面的程序改成下面这样：（把while循环里面的东西去掉）

运行程序的时候查询到进程是这样的：

ydk_108@iZuf68hz06p6s2809gl3i1Z:~/108/lesson12$ ps axj |grep myproc
 252493  252619  252619  252493 pts/0     252619 R+    1001   0:02 ./myproc
 252581  252621  252620  252581 pts/1     252620 S+    1001   0:00 grep --color=auto myproc

为什么一开始是S睡眠状态，后面去掉打印语句又变成了R运行状态呢？

调用printf语句的时候，涉及到对显示器设备的访问，但是设备不一定处于等待写入的状态，可能有很大的概率一直在等待IO状态就绪。所以是S睡眠状态。对应上操作系统原理的阻塞状态。而且我们使用的是云服务器，不是本地机器，所以还要涉及到网络传输的速率。

后面去掉了printf语句后就不面临这些问题了，所以是R运行状态。

我们把代码继续改一下：

#include <stdio.h>
  
int main()
{
        int a=0;
        printf("Ether# ");
        scanf("%d",&a);
        printf("echo :%d\n",a);
        return 0;
}

运行的时候，我不输入的时候查看进程：

ydk_108@iZuf68hz06p6s2809gl3i1Z:~/108/lesson12$ ps axj |grep myproc
 252493  252653  252653  252493 pts/0     252653 S+    1001   0:00 ./myproc
 252581  252655  252654  252581 pts/1     252654 S+    1001   0:00 grep --color=auto myproc

果然是处在S睡眠状态，对应上操作系统原理的阻塞状态。进程在等待我的输入。

D磁盘休眠状态和S睡眠状态实际上是有点像的。前者是深度睡眠，后者是浅度睡眠。

操作系统如果内存告急，是会杀掉进程的。处于D磁盘休眠状态的进程不会被杀掉，处于S睡眠状态的进程可能会被杀掉。

一般系统里出现D状态，哪怕是一个D状态，说明操作系统已经快崩溃了。想要从D状态出来，要么等待读写成功，要么断电。

D状态也是阻塞状态的一种。

T停止状态称为暂停状态。

我们把myproc.c的代码重新改成这样：

#include <stdio.h>
#include <unistd.h>

int main()
{
    while(1)
    {
        sleep(1);
        printf("hello linux\n");
    }
    return 0;
}

然后我们使用kill的第19号命令来实现停止进程。

可以看到进程现在处于停止状态。

S和T有点像，都可以认为是操作系统的阻塞状态，但是S是肯定在等待事件完成，而T可能在等待，也可能就是被停止的。

那么我们为什么要停止进程呢？

这个我们进行gdb调试的时候可以用得到。

X死亡状态和Z状态有联系。

当一个进程退出的时候，需要将进程的信息维持一端时间。（父进程关心这个）

Z(zombie)-僵尸进程

僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程没有读取到子进程退出的返回代码时就会产生僵死(尸)进程。

僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

我们更改一下myproc.c程序代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    pid_t id = fork();
    if(id==0){
        //child
        int cnt=5;
        while(cnt){
            printf("i am child, pid:%d, ppid:%d, cnt:%d\n",getpid(),getppid(),cnt);
            cnt--;
            sleep(1);
        }
        exit(0);
    }
    else{
        //father
        while(1){
            printf("i am father, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        //父进程没有对子进程做任何调用
    }
    return 0;
}

这里父子进程会交替打印，直到子进程结束，父进程继续打印。

执行后，我们可以发现进程：

ydk_108@iZuf68hz06p6s2809gl3i1Z:~$ ps axj |grep myproc
 252797  252861  252861  252797 pts/2     252861 S+    1001   0:00 ./myproc
 252861  252862  252861  252797 pts/2     252861 Z+    1001   0:00 [myproc] <defunct>
 252829  252867  252866  252829 pts/3     252866 S+    1001   0:00 grep --color=auto myproc

父进程没有对子进程做任何调用，所以子进程一直处在一种僵尸状态，等待着父进程的调用。

父进程没有调用wait()或waitpid()等待子进程结束

这会导致子进程在结束后变成僵尸进程(zombie process)

子进程结束后，其资源不能被完全释放，会在系统中留下一个僵尸进程条目

这是一个不太好的编程习惯，正确做法应该是父进程要等待并回收子进程

进程一般退出的时候，如果父进程没有主动回收子进程信息，子进程会一直让自己处于Z状态，进程的相关资源尤其是task_struct结构体不能被释放。

这个资源会一直被占用。这个可以叫做：内存泄漏。

进程状态查看

ps aux / ps axj 命令

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的。

维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的。

那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的。

因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间。

内存泄漏?是的。

如何避免？后面讲。

孤儿进程

父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？

父进程先退出，子进程就称之为“孤儿进程”

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    pid_t id = fork();
    
    if(id == 0){
        //child
        while(1){
            printf("I am child, pid:%d, ppid:%d\n", getpid(), getppid());
            sleep(1);
        }
    }
    else{
        //parent
        printf("I am parent, pid:%d\n", getpid());
        sleep(5);  // 父进程睡眠5秒后退出
        exit(0);   // 父进程退出
    }
    return 0;
}

代码解释：

1. 子进程：
   • 进入死循环，持续打印自己的PID和父进程PID
   • 每秒打印一次
2. 父进程：
   • 打印一次自己的PID
   • 睡眠5秒
   • 然后退出

运行结果：

• 最初5秒：子进程打印的ppid是父进程的PID
• 5秒后：父进程退出，子进程变成孤儿进程
• 此时子进程打印的ppid会变成1(在某些系统中可能是其他值)，因为被init进程收养

孤儿进程的特点：

1. 父进程先于子进程结束
2. 子进程会被init进程(PID=1)收养
3. 与僵尸进程不同，孤儿进程能正常运行且能正常结束
4. init进程会自动回收其收养的子进程，所以不会有资源浪费问题

孤儿进程和僵尸进程对比

孤儿进程不会有资源浪费，僵尸进程会有资源浪费

孤儿进程：

• 父进程先退出，子进程被init进程收养
• init进程会负责回收这些被收养的子进程
• 当孤儿进程结束时，init进程会自动完成回收工作
• 所以不会造成系统资源的浪费

僵尸进程：

• 子进程已经结束，但父进程没有回收子进程（没有调用wait/waitpid）
• 子进程的PCB（进程控制块）等信息仍然存在于系统中
• 这些信息会一直占用系统资源，直到父进程回收或父进程退出
• 如果产生大量僵尸进程，会浪费系统资源
• 严重时可能导致系统无法创建新的进程（因为进程号用尽）

简单来说：

• 孤儿进程：有"监护人"(init进程)，会被妥善处理
• 僵尸进程：没人处理，会一直占用系统资源直到父进程退出

4. 进程优先级

基本概念

cpu资源分配的先后顺序，就是指进程的优先权（priority）。

优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。

还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。

1. 优先级是什么？

   优先级是对于资源的访问，谁先访问，谁后访问

2. 为什么会有优先级？

   因为资源是有限的，进程是多个的，注定了进程之间是竞争关系。

   操作系统必须确保大家良性竞争，确认优先级。

   如果进程长时间得不到CPU资源，该进程的代码长时间无法得到推进，会导致该进程的饥饿问题。

查看系统进程

在linux或者unix系统中，用ps –l命令则会类似输出以下几个内容

我们很容易注意到其中的几个重要信息，有下：

• UID : 代表执行者的身份

• PID : 代表这个进程的代号

• PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号

• PRI ：代表这个进程可被执行的优先级，其值越小越早被执行

• NI ：代表这个进程的nice值，是进程优先级的修正数据

PRI and NI

• PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高
• 那NI呢？就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值
• PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
• 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
• 所以，调整进程优先级，在Linux下，就是调整进程nice值
• nice其取值范围是-20至19，一共40个级别。

PRI vs NI

• 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
• 可以理解nice值是进程优先级的修正修正数据

使用top更改进程优先级

得先换到root模式

su -

我们先更改一下myproc.c的代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    while(1){
        printf("I am a process, pid:%d\n",getpid());
        sleep(1);
    }
    return 0;
}

这个进程默认优先级是80

ydk_108@iZuf68hz06p6s2809gl3i1Z:~$ ps -al
F S   UID     PID    PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1001  252931  252797  0  80   0 -   622 hrtime pts/2    00:00:00 myproc
0 R  1001  252939  252829  0  80   0 -  2852 -      pts/3    00:00:00 ps

然后输入top，回车，输入r，输入进程号

然后回车，输入调整的数字：-30

可以看到这里只少了20，说明nice其取值范围是-20开始的。

root@iZuf68hz06p6s2809gl3i1Z:~# ps -al
F S   UID     PID    PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1001  252931  252797  0  60 -20 -   622 hrtime pts/2    00:00:00 myproc
0 T  1001  252941  252829  0  80   0 -  2932 do_sig pts/3    00:00:00 top
4 S     0  252945  252829  0  80   0 -  2846 do_wai pts/3    00:00:00 su
4 S     0  252946  252945  0  80   0 -  2690 do_wai pts/3    00:00:00 bash
4 R     0  252957  252946  0  80   0 -  2852 -      pts/3    00:00:00 ps

然后输入top，回车，输入r，输入进程号

然后回车，输入调整的数字：100

可以看到这里只比一开始的80多了了19，说明nice其取值范围是-20至19，一共40个级别。

而且这里的99不是比60多了19，说明Linux的PRI(new)=PRI(old)+nice里面的PRI(old)每次调整都是从80开始的。

root@iZuf68hz06p6s2809gl3i1Z:~# ps -al
F S   UID     PID    PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1001  252931  252797  0  99  19 -   622 hrtime pts/2    00:00:00 myproc
0 T  1001  252941  252829  0  80   0 -  2932 do_sig pts/3    00:00:00 top
4 S     0  252945  252829  0  80   0 -  2846 do_wai pts/3    00:00:00 su
4 S     0  252946  252945  0  80   0 -  2690 do_wai pts/3    00:00:00 bash
4 R     0  252963  252946  0  80   0 -  2852 -      pts/3    00:00:00 ps

PRI(new)=PRI(old)+nice