Linux进程控制

最新推荐文章于 2024-07-17 14:55:21 发布

蜥蜴梨

最新推荐文章于 2024-07-17 14:55:21 发布

阅读量49

点赞数 1

分类专栏：操作系统文章标签： linux 服务器 centos

本文链接：https://blog.csdn.net/m0_65540975/article/details/133868376

版权

操作系统专栏收录该内容

2 篇文章 0 订阅

订阅专栏

进程创建

fork函数初认识

在Linux中fork函数是非常重要的函数，它从已存在的进程中创建一个新进程。新进程为子进程，原进程为父进程。

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

pid_t fork(void);
功能：
    用于从一个已存在的进程中创建一个新进程，新进程称为子进程，原进程称为父进程。
参数：
    无
返回值：
    成功：子进程中返回 0，父进程中返回子进程 ID。pid_t，为整型。
    失败：返回-1。
    失败的两个主要原因是：
        1）当前的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN。
        2）系统内存不足，这时 errno 的值被设置为 ENOMEM。

进程调用fork，当控制转移到内核中的fork代码后，内核做：

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程
添加子进程到系统进程列表中
fork返回，开始调度器调度

代码：

运行结果：

从运行结果可以看见，fork（）函数之后，After被打印了两次，并且打印了两个进程号。说明fork函数确实创建了一个新进程，新进程为子进程，原来的进程为父进程。

Before只输出了一次，而Before是由父进程打印的，是fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意：fork之后，谁先执行完全由调度器决定。

fork函数返回值

子进程返回0
父进程返回子进程的pid

为什么子进程返回0，父进程返回子进程的pid？

因为父亲跟孩子是1：n的关系，子进程只有一个父进程，而父进程有多个子进程。父进程创建子进程的目的是用来执行任务的，父进程只有知道子进程的pid才能更好的分配任务。子进程自己不需要关心父进程的执行。

为什么fork函数两个返回值？

父进程调用fork函数时，为了创建子进程，fork函数内部进行一系列操作，包括创建子进程的PCB，创建子进程的进程地址空间，创建子进程的相应页表，然后操作系统将子进程放入到运行队列中，这样子进程就创建完毕了。

fork函数内部执行return之前，子进程就已经创建完毕，所以return语句父进程要执行，子进程也需要执行。这就是fork有两个返回值的原因。

同一个pid值，为什么会保存两个不同的值？

返回的本质，就是写入！所以谁先返回，谁就先写入pid，又因为进程具有独立性，写入的时候发生写时拷贝。所以同一个pid，地址是一样的，但是内容却不一样。

写时拷贝

使用fork（）函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间：包括进程上下文、进程堆栈、打开的文件描述符、进程优先级等。

子进程所独有的只有它的进程号，计时器等（只有少量信息）。因此使用fork（）函数的代价是很大的。

简单的说就是一个进程调用fork（）函数之后，系统给新的进程分配资源空间，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的进程中，只有少数值与原来的进程不同。相当与克隆了一个自己。

可以看出这样的方式代价太大了，所以Linux中的fork（）函数是通过写时拷贝(copy-on-write)实现。写时拷贝是一种可以推迟甚至避免拷贝的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。

只需要在写入的时候才会复制地址空间，从而使各自拥有各自的地址空间。

资源的复制是在要发生写入的时候，在此之前，以只读共享。

这样，进程便拥有了独立性。

fork常规用法

父进程想让子进程执行代码的一部分。例如：父进程等待客户端请求，生成子进程来处理请求
一个进程想要执行一个不同的程序。例如：子进程从fork返回后，调用exec函数

fork调用失败的原因

1）当前的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN。

2）系统内存不足，这时 errno 的值被设置为 ENOMEM。

进程终止

进程退出场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

进程退出码

我们写代码是为了完成某件事情，我该如何知道我的任务跑得如何呢？成功还是失败呢？

看一段简单的代码

我们想知道代码是否等于5050，如果不调用printf（）函数的情况下，如何知道这段代码是否正确，我们就要用到return，返回值是0，代表正确，返回值是1，代表不是5050。

我们可以使用echo $?命令来查看最近一次进程退出的退出码信息。

liyixi@liyixi-virtual-machine:~/test$ echo $?0

可以看见return的返回结果是1，说明我们的计算结果不是5050。

所以退出码可以让我们知道自己的任务跑得如何。

一般来说退出码0代表成功，其他数字有不同的含义。特定的数据代表特定的错误。

C语言中的strerror函数可以通过退出码，获取该退出码在C语言中对应的退出信息。

Linux中ls，mkdir等命令都是可执行程序，也有对应的退出码。我们也可以通过echo $?来进行查看

成功执行退出码是0

没有正确执行的退出码是非0的

退出码有对应的字符串含义，具体的含义具体由人来决定，不同环境下相同的退出码可能含义不同。

进程正常终止

在main函数中返回

return退出，在main函数中return退出进程是我们常用的方法

执行程序

调用exit （）函数

exit（）函数是我们退出进程的经常使用的方法，exit函数可以在代码任意位置退出进程。exit退出进程前会做一系列的工作：

1、执行用户通过atexit或on_exit定义的清理函数

2、关闭所有打开的流，所有的缓冲数据均被写入

3、调用_exit()函数

exit函数可以在代码任意位置退出进程

看下面一段函数，Add函数本来的功能是执行加法求和，main函数打印求和结果。

执行结果：屏幕没有打印求和的结果，我们用echo $?查看发现进程退出码是1，是我们自己设定的值，说明进程直接退出了，没有将对应的求和结果返回给main函数。

exit()函数可以刷新缓冲区

执行结果：正常执行

_exit（）函数

_exit()函数是系统调用，没有刷新缓冲区的功能，功能是直接终止进程。

执行结果：并没有打印出hello world

return、exit和_exit之间的区别

return只有在main函数中才能起到退出进程的作用，其他函数中return不能退出进程，而exit和_exit函数在代码的任何位置中使用都可以立即退出进程。

使用exit函数退出进程时，系统会执行会执行用户定义的清理函数，刷新缓冲，关闭流等操作，然后调用_exit函数终止进程。

exit和_exit区别是exit会执行用户定义的清理函数，刷新缓冲，关闭流等,而_exit是直接终止进程。

return、exit和_exit之间的联系

执行return num等同于执行exit（num),因为调用main函数return时，会将main的返回值当成exit的参数来调用exit函数，然后exit()执行用户定义的清理函数，刷新缓冲，关闭流等操作,最后调用_exit函数终止进程。

进程异常终止

对野指针的使用和变量除0等情况会使进程异常终止
向正在运行的进程发送kill -9或者Ctrl+C使得进程异常退出。

进程等待

进程等待的必要性

子进程退出，内核释放该进程的所有资源，但为其保留一定的信息，这些信息主要是指进程控制块PCB信息（进程号、退出状态、运行时间等），父进程不管不顾，就可能造成僵尸进程的问题，进而造成内存泄露
进程变成僵尸状态，kill -9也不能杀死僵尸状态
父进程给派给子进程的任务需要知道完成如何。如子进程运行完成，结果对还是不对，是否正常退出
父进程通过进程等待的方式，回收子进程的资源，获取子进程退出信息

父进程可以调用wait和waitpid得到子进程的退出状态同时彻底清除掉这个进程

wait（）和waitpid（）函数功能一样，区别在于wait（）函数会阻塞，waitpid（）函数可以设置不阻塞，waitpid（）函数还可以指定等待哪个子进程结束。

注意：wait和waitpid一次调用只能清理一个子进程，清理多个子进程应该用循环。

进程等待的方法

wait函数

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);
功能：
    等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收该子进程的资源。
参数：
    status : 进程退出时的状态信息。不关心可以设置成NULL
返回值：
    成功：已经结束子进程的进程号
    失败： -1

调用wait（）函数会阻塞，直到有一个子进程退出或者收到一个不能忽视的信号才被唤醒，继续向下执行代码。

调用进程没有子进程，该函数立即返回。如果子进程已经结束，该函数同样立即返回，回收结束进程的资源。

代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
	pid_t id = fork();
	if(id == 0){
		//child
		int count = 5;
		while(count--){
			printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(1);
		}
		exit(0);
	}
	//father
	int status = 0;
	pid_t ret = wait(&status);
	if(ret > 0){
		//wait success
		printf("wait child success...,sig number:%d,child exit code:%d\n",(status&0x7F),(status>>8)&0xFF);
	}
	return 0;
}

执行结果：

waitpid函数


#include <sys/types.h>
#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);
功能：
    等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。

参数：
    pid : 参数 pid 的值有以下几种类型：
      pid > 0  等待进程 ID 等于 pid 的子进程。
      pid = 0  等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid 不会等待它。
      pid = -1 等待任一子进程，此时 waitpid 和 wait 作用一样。
      pid < -1 等待指定进程组中的任何子进程，这个进程组的 ID 等于 pid 的绝对值。

    status : 进程退出时的状态信息。和 wait() 用法一样。

    options : options 提供了一些额外的选项来控制 waitpid()。
            0：同 wait()，阻塞父进程，等待子进程退出。
            WNOHANG：没有任何已经结束的子进程，则立即返回。
            WUNTRACED：如果子进程暂停了则此函数马上返回，并且不予以理会子进程的结束状态。（由于涉及到一些跟踪调试方面的知识，加之极少用到）
                 
返回值：
    waitpid() 的返回值比 wait() 稍微复杂一些，一共有 3 种情况：
        1) 当正常返回的时候，waitpid() 返回收集到的已经回收子进程的进程号；
        2) 如果设置了选项 WNOHANG，而调用中 waitpid() 发现没有已退出的子进程可等待，则返回 0；
        3) 如果调用中出错，则返回-1，这时 errno 会被设置成相应的值以指示错误所在，如：当 pid 所对应的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid() 就会出错返回，这时 errno 被设置为 ECHILD；

代码:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)
    {
		//child          
		int count = 10;
		while (count--)
        {
			printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(1);
		}
		exit(0);
	}
	//father           
	int status = 0;
	pid_t ret = waitpid(id, &status, 0);
	if (ret >= 0)
    {
		//wait success                    
		printf("wait child success...\n");
		if (WIFEXITED(status))
        {
			//exit normal                                 
			printf("exit code:%d\n", WEXITSTATUS(status));
		}
		else
        {
			//signal killed                              
			printf("killed by siganl %d\n", status & 0x7F);
		}
	}
	
	return 0;
}

父进程运行过程中，我们可以尝试使用kill- 9杀死子进程

子进程被信号杀死，父进程成功等待子进程退出。

多进程等待

父进程可以创建多个子进程来执行多个任务，我们也可以让父进程依次等待子进程退出。

下面代码中创建了10子进程，将10个子进程的pid放入到ids数组中，父进程循环waitpid等待子进程退出。子进程的退出码设置成子进程在数组ids中的下标。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t ids[10];
	for (int i = 0; i < 10; i++)
    {
		pid_t id = fork();
		if (id == 0)
        {
			//child
			printf("child process created successfully...PID:%d\n", getpid());
			sleep(3);
			exit(i); //将子进程的退出码设置为该子进程PID在数组ids中的下标
		}
		//father
		ids[i] = id;
	}
	for (int i = 0; i < 10; i++)
    {
		int status = 0;
		pid_t ret = waitpid(ids[i], &status, 0);
		if (ret >= 0)
        {
			//wait child success
			printf("wiat child success..PID:%d\n", ids[i]);
			if (WIFEXITED(status))
            {
				//exit normal
				printf("exit code:%d\n", WEXITSTATUS(status));
			}
			else
            {
				//signal killed
				printf("killed by signal %d\n", status & 0x7F);
			}
		}
	}
	return 0;
}

执行结果:

非阻塞的轮询等待

上述的例子中父进程都是阻塞等待子进程退出，父进程也想不用阻塞等待，因为父进程有自己的代码需要执行，在等待子进程退出的时间段可以干其他的活。

有这么一种方案，可以让子进程没有退出的时候父进程做自己的事情，这种方案叫轮询等待。

向waitpid的第三个参数传递WNOHANG ,若等待的子进程没有结束，waitpid立即返回0，等待的子进程结束了，返回子进程的pid

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t id = fork();
	if (id == 0)
    {
		//child
		int count = 3;
		while (count--)
        {
			printf("child do something...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(3);
		}
		exit(0);
	}
	//father
	while (1)
    {
		int status = 0;
		pid_t ret = waitpid(id, &status, WNOHANG);//如果子进程没有结束，立即返回0
		if (ret > 0)
        {
			printf("wait child success...\n");
			printf("exit code:%d\n", WEXITSTATUS(status));
			break;
		}
		else if (ret == 0)
        {
			printf("father things...\n");
			sleep(1);
		}
		else
        {
			printf("waitpid error...\n");
			break;
		}
	}
	return 0;
}

执行结果：父进程没有阻塞等待子进程，而是在子进程工作的时候执行自己的代码。这就是非阻塞轮询。

获取子进程status

wait和waitpid都有一个status参数，该参数是一个输出型参数，由操作系统填充
如果传递NULL，表示不关心子进程的退出状态信息
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程
status不能简单的当作整形来看代，可以当作位图，具体细节如下（只研究status低16比特位）

低16比特位的次低8位（8-15）保存的是退出状态，我们可以将次低8位跟0xFF按位&，就能获得这个数字。

0-7位是保存被信号所杀的终止信号位，跟0x7F按位&，也能获得这个数字

int status = 0;
wait(&status);
(status>>8)&0xFF;//退出码
(status)&0x7F;//退出信号

系统提供了一些宏来取出每个字段

1) WIFEXITED(status)

为非0 → 进程正常结束

WEXITSTATUS(status)

如上宏为真，使用此宏 → 获取进程退出状态 (exit的参数)

2) WIFSIGNALED(status)

为非0 → 进程异常终止

WTERMSIG(status)

如上宏为真，使用此宏 → 取得使进程终止的那个信号的编号。

进程替换

替换原理

用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要执行exec函数以执行另一个程序。

当一个进程调用exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。

调用exec函数并不创建新进程，所以调用exec函数前后该进程的pid并没有发生改变。

fork创建子进程后，由子进程来执行替换代码。那么子进程进行进程替换后，会影响父进程的代码和数据吗？

答案是不会的。因为有写时拷贝机制。子进程刚被创建时，与父进程共享代码和数据。当子进程进行进程替换时，意味着有数据和代码的写入，这时候要将父进程的代码拷贝一份，然后子进程在进行替换的时候就不会影响父进程的代码与数据。

替换函数

进程替换函数有六种以exec开头的函数，统称exec函数

一、int execl(const char* path, const char* arg, ...);

第一个参数path是我们要传入要执行程序的路径，第二个参数是可变参数列表，并以NULL结尾。

execl中的l就是list，将参数一个一个的传入exec类函数。

看一段代码：

进程被替换执行了ls -l，但是并没有输出HELLO WORLD。

这是因为调用execl之后，当前进程的内存空间被新进程替换，原进程被终止。

注意：新进程执行成功，原进程将被终止；执行失败，原进程继续执行。

比如我们这样写：

进程执行失败，原进程继续执行，所以打印出来了HELLO WORLD

值得注意的是exec类的函数没有成功的返回值，因为成功了就跟接下来的代码无关了，没有判断价值。exec类只要返回了，一定是错误了。

二、int execlp(const char *file, const char *arg, ...);

第一个参数是要执行程序的名字，第二个参数是可变参数列表，表示你要如何执行这个程序，并以NULL结尾。

execlp中的p是path，如何找到程序的功能，带p字符的函数，不用告诉程序路径，只需告诉执行程序的名字，函数会自动在环境变量PATH，进行可执行程序的查找。

例如执行ls程序

execlp("ls", "ls", "-l", NULL);

三、int execle(const char* path, const char* arg, ..., char* const envp[]);

第一个参数是要执行程序的路径，第二个参数是可变参数列表，表示你要如何执行这个程序，并以NULL结尾，第三个参数是自己设置的环境变量。

例如，设置自己的环境变量，在mybin程序内部就可以使用该环境变量。如果父进程设置了环境变量，那么子进程自然就继承了父进程设置的环境变量。

char* const envp_[] = {"MYENV=112233", NULL};
execle("./mybin", "mybin", NULL, envp_);

四、int execv(const char* path, char* const argv[]);

第一个参数是要执行程序的路径，第二个参数是一个指针数组，数组中需要存放你想怎样执行这个程序，数组以NULL结尾。

execv中v是vector，将所有的执行参数，放入数组中，统一传递，而不用进行使用可变参数方案。

例如执行ls程序

char* const argv_[] = {"ls", "-l", NULL};
execv（"/usr/bin/ls", argv_);

五、int execvp(const char* file, char* const argv[]);

第一个参数是要执行程序的名字，第二个参数是一个指针数组，数组中需要存放你想怎样执行这个程序，数组以NULL结尾。

例如执行ls程序

char* const argv_[] = {"ls", "-l", NULL};
execvp("ls", argv_);

六、int execve(const char* path, char* const argv[], char* const envp[]);

第一个参数是要执行程序的路径，第二个参数是一个指针数组，数组中需要存放你想怎样执行这个程序，数组以NULL结尾，第三个参数是自己设置的环境变量。

例如，设置自己的环境变量，在mybin程序内部就可以使用该环境变量。如果父进程设置了环境变量，那么子进程自然就继承了父进程设置的环境变量。

char* const argv_ = {"ls", "-l", NULL};
char* const envp_[] = {"MYENV=112233", NULL};
execle("./mybin", argv_ ,envp_);

函数解释

这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。
如果出错则返回-1

注意：exec类的函数没有成功的返回值，因为成功了就跟接下来的代码无关了，没有判断价值。exec类只要返回了，一定是错误了。

事实上，只有execve是真正的系统调用，其它五个函数最终都调用execve，所以execve在man手册第2节，其他函数在man手册第3节。这些函数之间的关系如下图所示：

做一个简单的shell

下面是与shell典型的互动：

shell就是命令行解释器。

shell从用户读入字符串“ls”。shell创建一个子进程，在子进程中运行ls程序并且等待子进程结束。

然后shell读取新一行的输入，建立一个新的子进程，子进程执行ps命令，shell等待子进程的结束。

所以写一个shell的步骤：

1、获取命令行

2、解析命令行

3、创建一个子进程（fork）

4、替换子进程（execvp）

5、父进程等待子进程退出

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

#define NUM 1024
#define OPT_NUM 64

char lineCommand[NUM];
char *myargv[OPT_NUM]; //指针数组
int  lastCode = 0;
int  lastSig = 0;

int main()
{
    while(1)
    {
        // 输出提示符
        printf("用户名@主机名 当前路径# ");
        fflush(stdout);

        // 获取用户输入, 输入的时候，输入\n
        char *s = fgets(lineCommand, sizeof(lineCommand)-1, stdin);
        assert(s != NULL);
        (void)s;
        // 清除最后一个\n , abcd\n
        lineCommand[strlen(lineCommand)-1] = 0;

        // "ls -a -l -i" -> "ls" "-a" "-l" "-i" 
        // 字符串切割
        myargv[0] = strtok(lineCommand, " ");
        int i = 1;
        if(myargv[0] != NULL && strcmp(myargv[0], "ls") == 0)
        {
            myargv[i++] = (char*)"--color=auto";
        }

        // 如果没有子串了，strtok->NULL, myargv[end] = NULL
        while(myargv[i++] = strtok(NULL, " "));

        // 如果是cd命令，不需要创建子进程,让shell自己执行对应的命令，本质就是执行系统接口
        // 像这种不需要让我们的子进程来执行，而是让shell自己执行的命令 --- 内建/内置命令
        if(myargv[0] != NULL && strcmp(myargv[0], "cd") == 0)
        {
            if(myargv[1] != NULL) chdir(myargv[1]);
            continue;
        }
        if(myargv[0] != NULL && myargv[1] != NULL && strcmp(myargv[0], "echo") == 0)
        {
            if(strcmp(myargv[1], "$?") == 0)
            {
                printf("%d, %d\n", lastCode, lastSig);
            }
            else
            {
                printf("%s\n", myargv[1]);
            }
            continue;
        }
        // 内建命令 --> echo

        // 执行命令
        pid_t id = fork();
        assert(id != -1);

        if(id == 0)
        {
            execvp(myargv[0], myargv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        (void)ret;
        lastCode = ((status>>8) & 0xFF);
        lastSig = (status & 0x7F);
    }
}

蜥蜴梨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Linux进程控制

父进程调用fork函数时，为了创建子进程，fork函数内部进行一系列操作，包括创建子进程的PCB，创建子进程的进程地址空间，创建子进程的相应页表，然后操作系统将子进程放入到运行队列中，这样子进程就创建完毕了。当子进程进行进程替换时，意味着有数据和代码的写入，这时候要将父进程的代码拷贝一份，然后子进程在进行替换的时候就不会影响父进程的代码与数据。execlp中的p是path，如何找到程序的功能，带p字符的函数，不用告诉程序路径，只需告诉执行程序的名字，函数会自动在环境变量PATH，进行可执行程序的查找。
复制链接

扫一扫