• 学习交流加（可免费帮忙下载CSDN资源）：
• 个人微信： liu1126137994
• 学习交流资源分享qq群1（已满）： 962535112
• 学习交流资源分享qq群2： 780902027

文章目录

• • 1、进程控制块PCB
  • 2、进程的生命周期
  • 3、作业控制（cpulimit）
  • 4、内存泄漏到底是什么
  • 5、初见fork
  • 6、总结

本篇文章主要记录以下学习内容：

• Linux进程生命周期（就绪、运行、睡眠、停止、僵尸）
• 僵尸的含义
• 停止状态与作业控制， cpulimit
• 内存泄漏的真实含义
• task_struct以及task_struct之间的关系
• 初见fork和僵尸

1、进程控制块PCB

Task_struct (PCB) 通俗一点的说就是描述进程资源的结构体，也可以称为进程描述符。在这个结构体中存放着这个进程所需要的所有资源的结构的描述。例如我们能想到的进程肯定有进程id，进程的内存管理，对文件的管理，对信号的管理等，那么PCB中就肯定存有类似于下面的结构：

其中PID的数量是有限的，在我自己的Linux系统中是32768

$ cat /proc/sys/kernel/pid_max
32768

所以我们不能无限制的创建进程。

那么在Linux中Task_struct是如何被管理的呢？

1. 形成链表

2. 形成树
   因为链表遍历的开销比较大，所以会在链表的基础上，形成树结构，这样会使对进程描述符的遍历的时间复杂度更低
   

3. 形成哈希 ：pid->task_struct
   为了更加快捷的访问到进程描述符，可以让进程的pid作为索引，形成哈希结构，这样在实现进程的调度算法时，效率会更高效。

2、进程的生命周期

上图表示了进程的六种状态，就绪态，运行态，深度睡眠态，浅睡眠态，停止态，僵尸态。

就绪态和运行态在数值上是相等的，都是由宏TASK_RUNNING定义。就绪态和运行太可以相互转换，运行态可以到停止态（例如ctrl+z），停止态可以恢复到就绪态。

其中，就绪态，运行态，停止态很好理解，这里不再赘述。

• 深睡眠
  进程处于睡眠态（调用sleep），等到资源到位，就可以被调度（变成就绪态TASK_RUNNING）。
• 浅睡眠
  进程处于睡眠态（调用sleep），等到资源到位，或者收到信号，就可以被调度（变成就绪态TASK_RUNNING）。

正常的进程睡眠都是浅睡眠，但是内核中有一些进程处于睡眠态不希望被信号打断，那么它就会处于深睡眠状态。

• 僵尸态
  资源已经释放，没有内存泄漏等！！！
  但是 Task_struct还在，这样的话，父进程可以根据子进程的Task_struct结构体存的退出码，查出子进程的死因。

有内核代码如下：

3、作业控制（cpulimit）

有时候我们的进程的CPU占用率非常高，为了使其他进程可以获得CPU时间，我们可以使用一些手段降低进程的CPU占用率。

其中cpulimit是之前比较常用的一个命令，它利用间断性的使进程处于停止态，从而降低进程的CPU占有率。

假设我的进程是一个死循环，且CPU占有率很高，则通过以下命令可以降低该使进程号为10111的进程的CPU占有率变为20%。

$ cpulimit -l 20 -p 10111

cpulimit的原理：

4、内存泄漏到底是什么

• 内存泄漏不是进程死了内存没释放

如果进程死了（退出或者变成僵尸），它所占有的内存资源会瞬间全部释放。

• 内存泄漏是进程活着，但随着时间的推移，内存消耗越来越多

5、初见fork

1. 初识fork

看下面程序打印几个hello？

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

假设p1是main函数这个进程，进入函数后，fork产生一个子进程p2，p1和p2各打印一个hello，接着p1和p2又各fork()，分别又产生两个hello，所以一共打印6个hello。

运行下面程序看如何打印：

#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>

int main(){
    pid_t pid;

    pid = fork();

    if(pid==-1){ /* 创建不成功 */
        perror("Can't creat new process");
        exit(1);
    }
    else if(pid==0){  /* pid==0，子进程运行代码 */
        printf("a\n");
    }
    else {     /* 父进程运行代码 */
        printf("b\n");
    }
	/* 父子进程都运行的代码 */
    printf("c\n");
    while(1);
}

运行结果为：

• 结果分析：

fork()函数的返回值是返回两次的，在父进程中返回子进程的pid，在子进程中返回0。借此我们可以在代码中区分开父子进程运行的代码。

进入函数后首先fork(),产生一个子进程，在子进程的进程空间的环境创建好之前，父进程就已经运行完并打印了b和c，然后子进程打印a和c。

2. 子死父清场（life_period.c）

#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
	pid_t pid,wait_pid;
	int status;

	pid = fork();

	if (pid==-1)	{
		perror("Cannot create new process");
		exit(1);
	} else 	if (pid==0) {
		printf("child process id: %ld\n", (long) getpid());
		pause();
		_exit(0);
	} else {
#if 1 /* define 1 to make child process always a zomie */
		printf("ppid:%d\n", getpid());
		while(1);
#endif
		do {
			wait_pid=waitpid(pid, &status, WUNTRACED | WCONTINUED);

			if (wait_pid == -1) {
				perror("cannot using waitpid function");
				exit(1);
			}

			if (WIFEXITED(status))
				printf("child process exites, status=%d\n", WEXITSTATUS(status));

			if(WIFSIGNALED(status))
				printf("child process is killed by signal %d\n", WTERMSIG(status));

			if (WIFSTOPPED(status))
				printf("child process is stopped by signal %d\n", WSTOPSIG(status));

			if (WIFCONTINUED(status))
				printf("child process resume running....\n");

		} while (!WIFEXITED(status) && !WIFSIGNALED(status));

		exit(0);
	}
}

• 在if 1不改为if 0的情况下

编译运行程序，杀死子进程，查看父进程的僵尸态

编译运行：

$ gcc life_period.c
$ ./a.out
Child process id:6426

另开一个终端先看父子进程的状态：

然后杀死子进程：

$ kill -9 6426

再查看状态：

可以看到，子进程（pid=6426）的状态已经变味僵尸态

• 在if 1改为if 0的情况下

编译运行程序，杀死子进程，查看父进程的僵尸态

编译运行：

$ gcc life_period.c
$ ./a.out
Child process id:6430

另开一个终端先看父子进程的状态：

然后杀死子进程

$ kill -9 6430

在第一个终端可以看到子进程被杀死的原因

然后父进程也退出。

可以看出父进程可以通过waitpid()函数回收子进程的task_struct结构。

6、总结

• 理解Linux进程的生命周期（六种状态）
• 理解task_struct结构
• 理解僵尸进程（资源已经释放，Task_struct结构还在）
• 理解内存泄漏的真实含义
• 理解fork与僵尸态
• 动手写上述实验代码并自己编译运行

学习探讨加：
个人微信：liu1126137994
个人qq ：1126137994