Linux进程控制 2019.1.6（进程控制，单道程序和多道程序，进程的状态转化，MMU的作用，映射关系，进程控制块PCB，环境变量，fork函数，kill的各种信息，exec函数族）

最新推荐文章于 2023-12-06 19:57:34 发布
最新推荐文章于 2023-12-06 19:57:34 发布
阅读量652 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/85912397
版权

进程相关的概念

程序——编译好的二进制文件

进程——运行着的程序

站在程序员的角度——运行一系列指令的过程

站在操作系统的角度——分配系统资源的基本单位

区别

  1. 程序占用磁盘，不占用系统资源
  2. 内存占用系统资源
  3. 一个程序对应多个进程，一个进程对应一个程序
  4. 程序没有生命周期，进程有生命周期

 

 

单道程序和多道程序

多道——宏观上并行，微观上串行。

 

 

 

进程的状态转化

 

 

 

 

MMU的作用

1、虚拟地址和物理内存之间实现映射

2、修改内存访问级别

 

 

 

 

映射关系

 

 

 

进程控制块PCB

查找PCB这个结构体在哪

sudo grep -rn "struct task_struct{" /usr/

 

PCB中包含的内容

 

 

查看所有文件设置

ulimit -a

 

 

 

环境变量

 

查看所有环境变量

env

 

查看单个环境变量

echo $PATH

 

 

 

获取环境变量

char *getenv(const char *name);
#include<stdio.h>
#include<stdlib.h>

int main(){
    printf("homepath is [%s]\n", getenv("HOME"));
    return 0;
}

运行结果：

 

 

 

 

fork函数——创建新的进程

pid_t fork(void);

                                                             

 

获得pid, 进程ID, 获得当前进程

pid_t getpid(void);

 

获得当前进程的父进程id

pid_t getppid(void);

 

使用fork(),getpid(),getppid()的测试用例

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

int main(){
	pid_t pid=fork();
        //创建进程失败
	if(pid<0){
		perror("fork err");
		exit(1);
	}
	//子进程
	if(pid==0){
		//子进程
		printf("I am a child , pid= %d, ppid=%d\n", getpid(), getppid());
	}
        //父进程
	else if(pid>0){
		//父进程的逻辑
		printf("child=%d, self=%d, ppid=%d\n", pid, getpid(), getppid());
	}
	return 0;
}

运行结果（子进程的父进程pid号为1，因为父进程先死了，子进程成了孤儿）

 

 

 

 

进程控制命令

 

查看进程信息

ps aux

 

查看进程的进程组的信息

ps ajx

 

kill的各种信息

通过

kill -l

可以获取kill的详细信息

 

 

 

创建n个子进程

 

查看进程a.out有几个

ps -aux | grep a.out | grep -v grep | wc -l

-v 排除某些信息

wc  -l   统计数量

 

对于下面的代码，会产生32个子进程（原计划产生5个子进程）

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

int main(){
	pid_t pid=0;
	for (int i = 0; i < 5; i++) {
		pid = fork();
		if (pid == 0) {
			printf("I am child, pid=%d, ppid=%d", getpid(), getppid);
		}
		else if (pid > 0) {
			printf("I am father, pid=%d, ppid=%d", getpid(), getppid);
		}
	}
	while (1) {
		sleep(1);
	}
	return 0;
}

原理如图：（32=2的5次幂）

 

产生5个的方法（判断出来是子进程就跳出循环）

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

int main(){
	pid_t pid=0;
	for (int i = 0; i < 5; i++) {
		pid = fork();
		if (pid == 0) {
			printf("I am child, pid=%d, ppid=%d", getpid(), getppid);
			break;
		}
		else if (pid > 0) {
			printf("I am father, pid=%d, ppid=%d", getpid(), getppid);
		}
	}
	while (1) {
		sleep(1);
	}
	return 0;
}

 

 

 

让进程按创建的顺序退出，父进程最后退出

子进程被创建出来之后,break了，跳出了循环，继续执行循环下面的语句。我们可以根据此时的 i 的值来判断这是第几个被创建出来的子进程。

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

int main(){
	int i = 0;
	pid_t pid=0;
	for ( i = 0; i < 5; i++) {
		pid = fork();
		if (pid == 0) {
			printf("I am child, pid=%d, ppid=%d", getpid(), getppid);
                        break;
		}
	}
	sleep(i);
	if (i < 5) {
		printf("I am child， will exit, pid=%d, ppid=%d", getpid(), getppid());
	}
	else {
		printf("I am father, pid=%d, ppid=%d", getpid(), getppid());
	}
	return 0;
}

运行结果

 

 

 

进程共享

 

父子进程共享的内容

 父子进程fork之后，有哪些异同？

相同点：全局变量、data、text、堆栈、环境变量、用户ID、宿主目录、进程工作目录、信号处理方式

不同点：进程ID、fork返回值、父进程ID、进程运行时间

 

那么是子进程是复制了一份父进程0-3G用户空间的内容，以及父进程的PCB，然后在映射到物理内存吗？当然不是

父子进程遵循读时共享写时复制的原则。

 

 

父子进程不共享的内容

全局变量，读共享，写复制的例子。

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

int var=00；
int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("var=%d, child, pid=%d, ppid=%d", var, getpid(), getppid());
		var = 1001;
		printf("var=%d, child, pid=%d, ppid=%d", var, getpid(), getppid());
		sleep(3);
		printf("var=%d, child, pid=%d, ppid=%d", var, getpid(), getppid());
	}
	else if (pid > 0) {
		sleep(1);//保证子进程可以修改var的值
		printf("var=%d, father, pid=%d, ppid=%d", var, getpid(), getppid());
		var = 2000;
		printf("var=%d, father, pid=%d, ppid=%d", var, getpid(), getppid());
	}
	return 0;
}

运行结果

 

 

验证子进程是否共享文件描述符表，子进程负责写入数据，父进程负责读取数据

父子进程共享文件描述符。一个写，另一个能读。共享的。

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

int main(int argc, char *argv[]){
	if (argc != 2) {
		printf("./a.out filename\n");
		return -1;
	}
	int fd = open(argv[1], O_RDWR);
	if (fd < 0) {
		perror("open err");
		exit(1);
	}
	pid_t pid fork();
	if (pid == 0) {
		write(fd, "hello\n", 6);
	}
	else if (pid > 0) {
		sleep(1);
		write(fd, "world\n", 6);
		wait(NULL);
	}
	return 0;
}

运行结果

 

 

 

exec函数族——用于执行其他程序

重点掌握execl和execlp

一旦开始执行就再也不回来了，除非出错了

 

测试一下ececlp函数

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

int var=00；
int main(){
	//execlp(const char *_file, const char *_arg, ...)
	execlp("ls", "ls", "-l". NULL);

	//不需要判断返回值
	perror("exec err");
	return 0;
}

运行结果（发现和ls -l还是有一点不一样）

 

把传入的参数改一下

execlp("ls", "ls", "-l", "--clolr=auto". NULL);

这样就和ls -l 的命令一样了，不然我们的程序执行出来是黄色的。

 

测试一下ececl函数

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

int var=00；
int main(){
	//execlp(const char *_file, const char *_arg, ...)
	execl("/bin/ls", "ls", "--color=auto", "-l". NULL);

	//不需要判断返回值
	perror("exec err");
	printf("hello \n");
	return 0;
}

执行结果

 

底层调用

 

 

 

 

 

 

孤儿进程和僵尸进程

 

孤儿进程——父进程死了，子进程还活着

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child\n");
		while (1) {
			printf("I am child\n");
		}
	}
	else if (pid > 0) {
		printf("I am father\n");
		sleep(1);
		printf("I am father, I will die \n");
	}

	return 0;
}

父进程死掉之后，ctrl+c也不能杀死子进程，因为他变成了孤儿进程，不归现在的shell管了。只能kill掉了。

 

僵尸进程——子进程死了，父进程并没有回收他的PCB资源等

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child\n");
		sleep(1);
		printf("I am child, I will die \n");
	}
	else if (pid > 0) {
		printf("I am father\n");
		while (1) {
			printf("I am father, very happy\n");
		}
	}

	return 0;
}

查看执行结果，会发现子进程的标志位Z，zombie，僵尸

 

 

 

如何回收僵尸

 

wait

作用：

1、阻塞等待子进程的死亡

2、回收进程资源

3、查看死亡原因

pid_t wait(int *stasus);//status传出参数

返回值：

失败返回 -1，成功返回进程ID

 

测试wait函数

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child,, I iwil die!");
		sleep(1);
	}
	else if (pid > 0) {
		printf("I am father, wait for child die!\n");
		pid_t wpid = wait(NULL);
		printf("wait ok, wpid=%d, pid=%d\n", wpid, pid);
		while (1) {
			sleep(1);
		}
	}

	return 0;
}

运行结果

 

查看死亡原因

1、正常死亡 WIFEXITED

如果WIFEXITED为真，使用WEXITSTATUS得到退出状态

2、非正常死亡 WIFSIGNALED

如果WIFSIGNALED为真，使用WTERMSIG得到信号。

 

正常死亡的例子

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child,, I iwil die!");
		sleep(1);
		return 101;
	}
	else if (pid > 0) {
		printf("I am father, wait for child die!\n");
		int status;
		pid_t wpid = wait(&status);
		printf("wait ok, wpid=%d, pid=%d\n", wpid, pid);
		//子进程正常死亡
		if (WIFEXITED(status)) {
			printf("child exit with %d\n", WEXITSTATUS(status));
		}
		//子进程非正常死亡
		if (WIFSIGNALED(status)) {
			printf("child killed by %d\n", WTERMSIG(status));
		}
		while (1) {
			sleep(1);
		}
	}

	return 0;
}

运行结果

把上面的return 101;  改成 exir(102); 都是可以的。

 

非正常死亡的例子

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child,, I iwil die!");
		while (1) {
			printf("I am chile, guo lai da wo!\n");
			sleep(1);
		}
		return 101;
	}
	else if (pid > 0) {
		printf("I am father, wait for child die!\n");
		int status;
		pid_t wpid = wait(&status);
		printf("wait ok, wpid=%d, pid=%d\n", wpid, pid);
		//子进程正常死亡
		if (WIFEXITED(status)) {
			printf("child exit with %d\n", WEXITSTATUS(status));
		}
		//子进程非正常死亡
		if (WIFSIGNALED(status)) {
			printf("child killed by %d\n", WTERMSIG(status));
		}
		while (1) {
			sleep(1);
		}
	}

	return 0;
}

运行结果

 

 

 

waitpid

 

对比wait和waitpid

不设置参数，waitpid就是非阻塞，如果把第三个参数不设置为0的话，要写个类似自旋锁的东西。waitpid的测试代码如下：

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

int main(){
	pid_t pid = fork();
	if (pid == 0) {
		printf("I am child,, I iwil die!");
		sleep(2);
	}
	else if (pid > 0) {
		printf("I am father, pid=%d\n", getpid());
		int ret;
		//waitpid(-1, NULL, WHOHANG)的返回值大于0才代表回收成功
		while ((ret = waitpid(-1, NULL, WNOHANG)) == 0) {
			sleep(1);
		}
		printf("ret=%d\n", ret);
		ret= waitpid(-1, NULL, WNOHANG);
		if (ret < 0) {
			perror("wait err");
		}
		while (1) {
			sleep(1);
		}
	}

	return 0;
}

运行结果

 

 

wait回收多个子进程

生成五个子进程，然后回收他们。

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

int main(){
	int n = 5;
	int i = 0;
	pid_t pid;
	for (int i = 0; i < 5; i++) {
		pid = fork();
		if (pid == 0) {
			printf("I am child , pid=%d\n", getpid());
			break;
		}
	}
	sleep(i);
	//此时是父进程
	if (i == 5) {
		for (int i = 0; i < 5; i++) {
			pid_t wpid=wait(NULL);
			printf("wpid=%d\n", wpid);
		}
		while (1) sleep(1);
	}

	return 0;
}

运行结果

 

 

waitpid回收多个子进程

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

int main(){
	int n = 5;
	int i = 0;
	pid_t pid;
	for (int i = 0; i < 5; i++) {
		pid = fork();
		if (pid == 0) {
			printf("I am child , pid=%d\n", getpid());
			break;
		}
	}
	//此时是父进程
	if (i == 5) {
		printf("I am parent!\n");
		//-1代表子进程全都死掉了
		while (1) {
			pid_t wpid = waitpid(-1, NULL, WNOHANG);
			//回收工作完成，所有子进程都被回收了
			if (wpid == -1) break;
			//说明成功回收到了一个子进程
			else if (wpid > 0) {
				printf("wpid=%d\n", wpid);
			}
		}
		while (1) sleep(1);
	}
	if (i < 5) {
		printf("I am a child, i=%d, pid=%d\n", i, getpid());
	}
	return 0;
}

 

 

2019.4.7补充

——表示进程在休眠

——表示进程的优先度高

——表示优先度比较低

——控制台进程

——运行在前端的进程

 

王小闹儿
关注
专栏目录
MMU.rar_linux mmu作用_mmu
09-24
MMU，全称为Memory Management Unit，即内存管理单元，是计算机系统中的关键硬件组件，尤其是在操作系统如Linux中发挥着至关重要的作用。本文将深入探讨MMU在Linux系统中的功能及其对系统性能的影响。 首先，MMU的...
《Linux命令行大全》重点笔记——第一部分 学习shell
liuwp5的博客
01-28 428
《Linux命令行大全》重点笔记 第一部分 学习shell 第一章 shell是什么 1.3 简单命令 1、date：系统时间、日期 2、cal：当月日历 3、df：磁盘可用空间 4、free：可用内存 5、exit：关闭终端会话 第二章 导航 2.2 简单命令 1、pwd：当前工作目录（Print Working Directory） 2、ls：列出当前工作目录的文件和目录 ​ ls -a：可以列出隐藏文件 3、cd：更改工作目录 绝对路径：从根目录开始写起（/） 相对路径：从工作目录开始写起（./
Linux基础学习—exec组函数
Aaronlxx的博客
11-29 748
exec函数 功能： 　 在调用进程内部执行一个可执行文件。可执行文件既可以是二进制文件，也可以是任何Linux下可执行的脚本文件。 exec函数族提供了一个在进程中启动另一个程序执行的方法。它可以根据指定的文件名或目录名找到可执行文件， 并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程号外，其他全部被新的进程替换了。 这6个函数可以划分为两组： (1)execl、execle和execlp。 (2)execv、execve和execvp。 exec函数的原型如下：
Java笔记（四）——基础知识（郝斌）
Mr_John
03-14 1510
96.什么叫程序 所谓“程序”，是一个严格有序的指令集合，程序规定了完成某一任务时，计算机所需做的各种操作，以及这些操作的执行顺序 97.单道程序设计环境中程序特点 单道程序设计环境是指：计算机中除了操作系统之外，只存在一个用户程序，即用户程序独享了整个计算机资源 单道程序有如下特点： 资源的独占性：任何时候，位于内存中的程序都可以使用系统中的一切资源，不可能有其他程序与之竞争 执行的顺序性：内存中每次只有一个程序，各个程序都是按次序执行的，即做完一个，再做下一个 结果的再现性：只要执行环境和
操作系统第二章 ---- 处理机管理 知识点整理及梳理
xiaohajiang的博客
11-17 4089
文章目录
操作系统概述
lizhuangabby的博客
06-04 363
操作系统
完整版系统进程管理原始代码.e.rar
04-03
系统进程管理是操作系统的核心组成部分，它负责控制、调度和协调计算机系统中的各个程序执行。这份“完整版系统进程管理原始代码.e.rar”压缩包显然包含了关于这个关键领域的源代码，对于学习和理解操作系统原理，...
MMU.rar_ARM MMU_linux_linux mmu_mmu_mmu linux
09-14
标题"MMU.rar_ARM MMU_linux_linux mmu_mmu_mmu linux"揭示了这个压缩包的内容主要关注的是ARM架构下的内存管理单元（MMU）在Linux操作系统中的应用。其中，“MMU”是Memory Management Unit的缩写，它是处理器硬件...
mmu.rar_linux mmu_mmu
09-24
Linux MMU，即Memory Management Unit（内存管理单元），在操作系统中扮演着至关重要的角色，尤其在多任务环境中，...通过阅读"mmu.pdf"文档，你将能更全面地理解这些内容，从而更好地理解和优化Linux系统的内存管理。
linux-MMU.rar_LINUX ??MMU_mmu
09-22
了解Linux MMU的工作原理对于系统管理员和开发者来说非常重要，它有助于优化系统性能，解决内存相关的问题，以及编写更高效的程序。通过深入研究Linux MMU，我们可以更好地理解和利用Linux内存管理的特性，提升系统...
Java 里的thread (线程)简介
nvd11的专栏
02-14 3217
在Java里 thread 就是线程的意思. 说到线程的概念, 自然离不开另外两个词: 程序和进程. 从最基本的程序讲起: 一. 什么是程序 所谓程序, 就是1个严格有序的指令集合. 程序规定了完成某一任务时,计算机所需要做的各种操作, 以及操作的顺序. 一. 什么是进程
02进程学习之并发，时钟中断，单道程序设计和多道程序设计的区别
weixin_44517656的博客
10-29 2992
02进程学习之并发，时钟中断，单道程序设计和多道程序设计的区别 1 并发的概念 并发：一个时间段内可以运行多个程序。注意并不是同一时刻运行，即不是并行。 2 时钟中断 时钟中断：发送指令使当前占用CPU的进程停止并记录时间，好让其它进程可以执行。 由于我们程序可以并发执行，所以每个程序都会争夺CPU，当我们需要切换另一个进程时，就是利用时钟中断来暂停它，记录本次时间等待其它进程执行完再回到被中断的那个时刻执行该进程。例如酷狗和微信的切换。 3 单道程序设计 单道程序设：“所有进程一个一个排对执行。若A阻塞，
Linux高级系统编程-3 进程
最新发布
weixin_50963877的博客
12-06 1055
父子进程，系统允许一个进程可以创建新进程，该进程即为新进程的父进程，新进程即为子进程。
DJ1-2 操作系统引论
狂放不羁霸的博客
03-08 1010
一、操作系统的发展过程 1. 无操作系统 2. 单道批处理系统 3. 多道批处理系统 4. 分时操作系统 5. 实时系统 二、操作系统的基本特征 1. 并发性 2. 共享性 3. 虚拟性 4. 异步性 三、操作系统的主要功能 1. 处理机管理功能 2. 存储器管理功能 3. 设备管理功能 4. 文件管理功能 5. 用户接口
C++项目实战-多进程(一篇文章)
weixin_46120107的博客
08-14 1万+
程序和进程的基本概念 单道程序设计和多道程序设计 并行和并发 进程控制块PCB 进程常用的命令 环境变量 环境变量操作函数
面试--操作系统--进程管理
暗月下捉迷藏
09-18 655
进程管理概念性知识
操作系统——进程的定义、组成、组织方式、特征
然后就去远行
04-29 1183
目录1、进程描述1.1 进程的定义1.1.1 单道程序阶段1.1.2 多道程序阶段1.1.3 进程实体1.2 进程的组织1.2.1 链接方式1.2.2 索引方式1.3 进程的特点1.4 总结 1、进程描述 1.1 进程的定义 在看进程之前，先看看程序的定义： 程序：就是一个指令序列； 1.1.1 单道程序阶段 早期的计算机只支持单道程序，在计算机中同一时间段只能有一道程序在运行，正在运行的程序，C...
单道批处理系统，多道批处理系统，分时系统比较（概念，特点，优缺点）
热门推荐
qq_43606914的博客
04-29 5万+
本文关于单道批处理系统，多道批处理系统及分时系统的三者对比主要是从概念，特点，优缺点等方面展开； 参考内容：华中科技大学软件学院苏曙光老师的操作系统原理课程及现代操作系统第四版。 一.单道批处理系统 1.概念 2.特点 自动：作业自动运行，无需干预 批量：磁带上的各个作业按顺序地进入内存，先调入先完成 单道：内存中仅有一道程序运行，可以看成是串行的 3.CPU的利用情况 分析：外设和CPU...
单道程序系统几个特点：
hyqsong的专栏
05-25 1万+
单道程序系统几个特点： 1. 资源独占性 任何时候，位于内存中的程序可以使用系统中的一切资源，不可能有其他程序与之竞争 2. 执行的顺序性 内存中只有一个程序，各个程序是按次序执行的。在做完一个程序的过程中，不可能夹杂进另一个程序执行 3. 结果的可再现性 只要执行环境和初始条件相同，重复执行一个程序，获得的结果总是一样的 4. 运行结果的无关性 程序的运行结果与程序执行的速度无关。
Linux内核 fork详解：进程创建流程与task_struct、PCB
本文将深入探讨Linux内核创建新进程的全过程，从进程描述符（task_struct）和进程控制块（PCB）的角度解析这一关键操作。首先，我们将介绍进程描述符，它是一个数据结构，包含了进程的各种属性，如状态和PID，task_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值