【Linux】进程状态与进程优先级及其相关概念

进程

基本概念

• 课本概念：程序的一个执行实例，正在执行的程序等
• 内核观点：担当分配系统资源（CPU时间，内存）的实体
  进程 = 内核数据结构(PCB) + 对应的磁盘代码

进程在调度运行的时候,就具有了动态属性!
如何退出进程:

1. kill -9 pid
2. ls /proc在该目录下有进程的目录,把他删了即可结束进程

描述进程-PCB

• 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
• 课本上称之为PCB（process control block）， Linux操作系统下的PCB是: task_struct

task_struct-PCB的一种

• 在Linux中描述进程的结构体叫做task_struct。
• task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存) 里并且包含着进程的信息.

task_ struct内容分类

• 标示符: 描述本进程的唯一标示符，用来区别其他进程。
• 状态: 任务状态，退出代码，退出信号等。
• 优先级: 相对于其他进程的优先级。
• 程序计数器: 程序中即将被执行的下一条指令的地址。
• 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
• 上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。
• I／ O状态信息: 包括显示的I/O请求,分配给进程的I／ O设备和被进程使用的文件列表。
• 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
• 其他信息

组织进程

可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。

查看进程

进程的信息可以通过 /proc 系统文件夹(内存级别,动态变化)查看

• 如：要获取PID为1的进程信息，你需要查看 /proc/1 这个文件夹.
  
  

• 大多数进程信息同样可以使用top和ps这些用户级工具来获取

#include <stdio.h>  
#include <sys/types.h>  
#include <unistd.h>  
int main()  
{  
	while(1){  
	sleep(1);  
}  
return 0;  
}

ps axj |head -1 && ps axj | grep myprocess | grep -v grep

通过系统调用获取进程标示符

• 进程id（PID）
• 父进程id（PPID）

#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>

int main()
{
    while(1)
    {
        printf("hello process,我是一个进程，我的pid是%d,我的父进程是%d\n",getpid(),getppid());
        sleep(1);
    }
    return 0;
}

我们发现,父进程的pid不变:

ps axj |head -1 && ps axj | grep 31194 | grep -v grep | grep -v ps

• bash命令行解释器,本质上他也是一个进程
• 命令行启动的所有程序,最终都会变成进程,而该对应的父进程都是bash(我这里是将bash配置成了zsh)
• 如何创建子进程?
  假如我们杀掉这个进程:
  

会导致直接崩溃,所以bash都是创建子进程,让子进程去执行任务.

通过系统调用创建进程-fork初识

• 运行 man fork 认识fork
• fork有两个返回值
• 作用:创建子进程
• 函数执行前:只有一个父进程->函数执行后:父进程+子进程
• 父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main()
{
    printf("AAAA:我的pid是%d,我的父进程是%d\n", getpid(), getppid());
    pid_t ret = fork();
    printf("BBBB:我的pid是%d,我的父进程是%d,ret=%d,&ret=%p\n", getpid(), getppid(), ret, &ret);
    sleep(1);
    return 0;
}

奇怪的事情是,明明ret的地址是一样的,但是为什么打印出来的值不一样呢?这就涉及到之后我们讲的进程地址空间的概念了,这里先按下不表

同时,我们也可以看出,fork的返回值:

给父进程返回子进程pid,给子进程返回0,失败返回-1

• fork 之后通常要用 if 进行分流

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>

int main()
{
    printf("AAAA:我的pid是%d,我的父进程是%d\n", getpid(), getppid());
    pid_t ret = fork();
    assert(ret != -1);
    if (ret == 0)
    {
        //子进程
        while(1)
        {
            printf("\033[0;32;31m我是子进程\033[m，我的pid是%d,我的父进程是%d\n", getpid(), getppid());
            sleep(1);
        }
    }
    else
    {
        //父进程
        while(1)
        {
            printf("我是父进程，我的pid是%d,我的父进程是%d\n", getpid(), getppid());
            sleep(2);
        }
    }
    return 0;
}

• 这里注意,关于fork后是先调用父进程还是子进程,是完全随机的,由操作系统的调度器来决定.
• fork之后,代码共享,我们通常用if else来分流

fork原理

fork做了什么?

进程=内核数据结构+进程的代码和数据

所以fork是创建了一个子进程的pcb

fork是如何看待进程的

进程在运行的时候,是具有独立性的,父子进程也是.
fork之后,就算子进程被杀掉了,父进程还会继续运行
代码:代码是只读的
数据:当有一个执行流尝试修改数据时候,OS会自动给我们当前的进程触发写时拷贝

fork如何理解两个返回值的功能

当我们函数内部准备执行return的时候,我们的主体功能肯定是已经完成了的

进程状态

进程状态：

运行 新建 就绪 挂起 阻塞 等待 停止 挂机 死亡 ...

两个比较核心的状态的概念:
阻塞:进程因为等待某种条件就绪,而导致的一种不推进的状态->就是进程卡住了->阻塞一定是在等待某种资源->为什么要阻塞:进程要通过等待的方式,等具体的资源(磁盘\网卡\显卡等各种外设)被别人使用完之后,再被自己使用.
挂起:全程阻塞挂起.当操作系统的内存不足时,操作系统会把正在被阻塞中的进程,包括它的代码和数据,交换给磁盘.(但是PCB还在内存中)

1.普遍的操作系统层面如何理解上面的概念

a.给大家搭建一个OS系统的宏观概念:

1. 一个CPU一个运行队列
   1. 进程是什么状态,一般也看这个进程在哪里排队
2. 让进程进入队列,本质:将该进程的task_struct 结构体对象放入运行队列中!
3. 进程PCB在运行队列(runqueue)中,就是R(运行状态).并不是这个进程正在在运行,才是运行状态
   1. 状态->进程内部的属性->task_struct->int(1:run,2:stop,3:hup,4;dead…)
4. 不要只以为,你的进程只会等待(占用)CPU资源,你的进程也可能随时随地要外设资源!!!
5. 所谓的进程不同状态,本质是进程在不同的队列中,等待某种资源

看看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的结束。

  • 深度睡眠,不可以被终止->当进程需要向磁盘写入大体积的数据时，一时半会儿拷不完，为了防止进程被系统杀掉，就给该进程一个“免死金牌”，让他不能被杀掉！
    

  • 在该状态的进程,无法被OS杀掉,只能通过断电,或者进程自己醒来来解决->在高IO的情况下,才会出现

• T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。 暂停:kill -19 编号 ; 继续:kill -18 编号
  • 在暂停以后再继续,状态变成了S(没有了+号)(意思是在后台运行),此时不能直接结束进程,必须kill -9
  • 状态后面带加号:前台进程,可以用ctrl C 终止
  • 状态后面不带加号:后台进程,不可以用ctrl C终止,可以用kill -9杀掉
• t状态(tracing stop):调试的时候暂停
• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

写一个打印函数:为什么运行状态会是S呢?
因为这个速度快慢是相对于cpu来说的,显示器的响应是很慢的,我们在等待IO,而且是99%的时间都在等待,只有1%的时间在运行
所以大部分情况下,一旦有访问外部设备的操作,我们查询状态时基本都是S状态

进程状态查看

ps aux / ps axj 命令

Z(zombie)-僵尸进程

感性认识

进程被创建出来->完成任务->
1.要知道它完成的如何->进程退出的时候,不能立即释放该进程对应的资源,应该保存一段时间,让父进程或者OS来进行读取
2.可以不关心结果,但是虽然你可以不要,我必须要有

认识

• 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
• 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
• 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
  来一个创建维持30秒的僵死进程例子：

#include <stdio.h>  
#include <stdlib.h>  
int main()  
{  
	pid_t id = fork();  
	if(id < 0){  
				perror("fork");  
				return 1;
				}  
	else if(id > 0){ //parent  
		printf("parent[%d] is sleeping...\n", getpid());  
		sleep(30);  
	}else{  
		printf("child[%d] is begin Z...\n", getpid());  
		sleep(5);  
		exit(EXIT_SUCCESS);  
	}  
	return 0;  
}

编译并在另一个终端下启动监控:

开始测试:

看到结果:

ptrace系统调用追踪进程运行，有兴趣研究一下:Ptrace 详解 - tangr206 - 博客园 (cnblogs.com)

僵尸进程的危害

• 进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！
• 维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说， Z状态一直不退出， PCB一直都要维护？是的！
• 那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！

孤儿进程

父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？
父进程先退出，子进程就称之为“孤儿进程”
孤儿进程被1号init进程领养，当然要有init进程回收喽。

父进程先退出:
1.这种现象是一定会存在的
2.子进程会被操作系统(1号进程)领养
3.为什么要这么干?:如果不领养,那么子进程退出的时候,对应的僵尸便没有人能够回收了->就会"内存泄漏"
4.被领养的进程->孤儿进程
5.前台进程创建的子进程如果变成了孤儿进程,会自动变成后台进程,无法被ctrl C杀死

杀进程的两种方式:
1.kill -9 进程编号
2.killall 进程名

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
	pid_t id = fork();
	if (id < 0) {
		perror("fork");
		return 1;
	}
	else if (id == 0) {//child
		printf("I am child, pid : %d\n", getpid());
		sleep(10);
	}
	else {//parent
		printf("I am parent, pid: %d\n", getpid());
		sleep(3);
		exit(0);
	}
	return 0;
}

进程优先级(了解就行)

认识

1. 什么叫做优先级:
   1. 权限决定的是能还是不能
   2. 优先级决定的是先做还是后做的问题->先还是后获得资源
2. 为什么会存在优先级:因为资源太少
3. Linux优先级特点->很快
   1. 优先级本质就是PCB里面的一个整数数字(也可能是几个)
   2. 最终优先级=老的优先级(默认都是80开始的)+nice(Linux支持在进程运行中进行优先级调整的,调整的策略就是更改nice值完成的)
   3. nice∈[-20 , 19]

基本概念

• cpu资源分配的先后顺序，就是指进程的优先权（priority）。
• 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
• 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个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
  • 这里的old,默认是80(至少在某些机器上这个;每个机器的额默认不同)
• 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
• 所以，调整进程优先级，在Linux下，就是调整进程nice值
• nice其取值范围是-20至19，一共40个级别.

PRI vs NI

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

查看进程优先级的命令

• top

用top命令更改已存在进程的nice：

• top
• 进入top后按“r”–>输入进程PID–>输入nice值

其他概念

• 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
• 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
• 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
• 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发
• 进程切换:
  • 进程在切换的时候,要进行进程的上下文保护;当进程在恢复运行的时候,要进行上下文的恢复
  • 在任何时刻,CPU里面的寄存器里面的数据,看起来是在大家都能看到的寄存器上,实际上是只属于当前运行的进程.换句话说,就是寄存器被所有的进程共享,寄存器内的数据是每个进程各自私有的
  •