linux-进程控制

最新推荐文章于 2024-09-18 17:12:39 发布
最新推荐文章于 2024-09-18 17:12:39 发布
阅读量738 收藏 2
点赞数
分类专栏： # linux-系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43605009/article/details/118934435
版权

文章目录

1 学习目标

  • 了解进程相关的概念
  • 掌握fork/getpid/getppid函数的使用
  • 熟练掌握ps/kill命令的使用
  • 熟练掌握execl/execlp函数的使用
  • 说出什么是孤儿进程什么是僵尸进程
  • 熟练掌握wait函数的使用
  • 熟练掌握waitpid函数的使用

2 进程相关概念

2.1 程序和进程

  • 程序，是指编译好的二进制文件，在磁盘上，占用磁盘空间, 是一个静态的概念.
  • 进程，一个启动的程序， 进程占用的是系统资源，如：物理内存，CPU，终端等，是一个动态的概念
  • 程序 → 剧本(纸)
  • 进程 → 戏(舞台、演员、灯光、道具…)
    同一个剧本可以在多个舞台同时上演。同样，同一个程序也可以加载为不同的进程(彼此之间互不影响)

2.2 并行和并发

  • 并发，在一个时间段内, 是在同一个cpu上, 同时运行多个程序。
    如：若将CPU的1S的时间分成1000个时间片，每个进程执行完一个时间片必须无条件让出CPU的使用权，这样1S中就可以执行1000个进程。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

  • 并行性指两个或两个以上的程序在同一时刻发生(需要有多颗)。

在这里插入图片描述
在这里插入图片描述

2.3 PCB-进程控制块

每个进程在内核中都有一个进程控制块（PCB）来维护进程相关的信息，Linux内核的进程控制块是task_struct结构体。
/usr/src/linux-headers-4.4.0-96/include/linux/sched.h文件的1390行处可以查看struct task_struct 结构体定义。其内部成员有很多，我们重点掌握以下部分即可：

  • 进程id。系统中每个进程有唯一的id，在C语言中用pid_t类型表示，其实就是一个非负整数。
  • 进程的状态，有就绪、运行、挂起、停止等状态。
  • 进程切换时需要保存和恢复的一些CPU寄存器。
  • 描述虚拟地址空间的信息。
  • 描述控制终端的信息。
  • 当前工作目录（Current Working Directory）。
    getcwd --pwd
  • umask掩码。
  • 文件描述符表，包含很多指向file结构体的指针。
  • 和信号相关的信息。
  • 用户id和组id。
  • 会话（Session）和进程组。
  • 进程可以使用的资源上限（Resource Limit）。
    ulimit -a

2.4 进程状态(面试考)

  • 进程基本的状态有5种。分别为初始态，就绪态，运行态，挂起态与终止态。其中初始态为进程准备阶段，常与就绪态结合来看。
    在这里插入图片描述

3 创建进程

3.1 fork函数

  • 函数作用：创建子进程

  • 原型: pid_t fork(void);
    函数参数：无
    返回值：调用成功:父进程返回子进程的PID，子进程返回0；
    调用失败:返回-1，设置errno值。

  • fork函数代码片段实例
    在这里插入图片描述

  • 调用fork函数的内核实现原理:
    在这里插入图片描述

  • fork函数总结

  • fork函数的返回值？
    父进程返回子进程的PID，是一个大于0数;
    子进程返回0；
    特别需要注意的是：不是fork函数在一个进程中返回2个值，而是在父子进程各自返回一个值。

  • 子进程创建成功后，代码的执行位置？
    父进程执行到什么位置，子进程就从哪里执行

  • 如何区分父子进程
    通过fork函数的返回值

  • 父子进程的执行顺序
    不一定，哪个进程先抢到CPU，哪个进程就先执行

3.2 ps命令和kill命令

linux下ps命令使用详解.rar

  • ps -ef |grep “xxx”
  • ps -aux | grep “xxx”
  • ps -ajx | grep “xxx”
    -a：（all）当前系统所有用户的进程
    -u：查看进程所有者及其他一些信息
    -x：显示没有控制终端的进程 – 不能与用户进行交互的进程【输入、输出】
    -j: 列出与作业控制相关的信息
  • kill -l 查看系统有哪些信号
  • kill -9 pid 杀死某个线程

3.3 getpid/getppid

  • getpid - 得到当前进程的PID
    pid_t getpid(void);
  • getppid - 得到当前进程的父进程的PID
    pid_t getppid(void);

3.3 练习题

在这里插入图片描述

  1. 编写程序，循环创建多个子进程，多个子进程是兄弟关系。
//循环创建n个子进程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
	int i = 0;
	for(i=0; i<3; i++)
	{
		//创建子进程
		pid_t pid = fork();
		if(pid<0) //fork失败的情况
		{
			perror("fork error");
			return -1;
		}
		else if(pid>0)//父进程
		{
			printf("father: pid==[%d], fpid==[%d]\n", getpid(),getppid());
			//sleep(1);
		}
		else if(pid==0) //子进程
		{
			printf("child: pid==[%d], fpid==[%d]\n", getpid(), getppid());
		}
	}
	sleep(10);
	return 0;
}
  1. 判断子进程是第几个子进程，注意：若让多个子进程都是兄弟进程，必须不能让子进程再去创建新的子进程。
//循环创建n个子进程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
	int i = 0;
	for(i=0; i<3; i++)
	{
		//创建子进程
		pid_t pid = fork();
		if(pid<0) //fork失败的情况
		{
			perror("fork error");
			return -1;
		}
		else if(pid>0)//父进程
		{
			printf("father: pid==[%d], fpid==[%d]\n", getpid(),getppid());
			//sleep(1);
		}
		else if(pid==0) //子进程
		{
			printf("child: pid==[%d], fpid==[%d]\n", getpid(), getppid());
			break;
		}
	}

	//第1个子进程
	if(i==0)
	{
		printf("[%d]--[%d]: child\n", i, getpid());	
	}

	//第2个子进程
	if(i==1)
	{
		printf("[%d]--[%d]: child\n", i, getpid());	
	}
	//第3个子进程
	if(i==2)
	{
		printf("[%d]--[%d]: child\n", i, getpid());	
	}
	//父进程
	if(i==3)
	{
		printf("[%d]--[%d]: child\n", i, getpid());	
	}
	sleep(10);

	return 0;
}
  1. 编写程序，测试父子进程是否能够共享全局变量：重点通过这个案例讲解读时共享，写时复制，不能共享。
    结果：父子进程不能共享全局变量。
    在这里插入图片描述
//fork函数测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
int g_var = 99;

int main()
{
	//创建子进程
	pid_t pid = fork();
	if(pid<0) //fork失败的情况
	{
		perror("fork error");
		return -1;
	}
	else if(pid>0)//父进程
	{
		printf("father: [%d], pid==[%d], fpid==[%d]\n", pid, getpid(),getppid());
		g_var++;
		printf("[%p]", &g_var);
	}
	else if(pid==0) //子进程
	{
		sleep(1); //为了避免父进程还没有执行, 子进程已经结束了
		printf("[%p]", &g_var);
		printf("child: pid==[%d], fpid==[%d]\n", getpid(), getppid());
		printf("child: g_var==[%d]\n", g_var);
	}
	
	return 0;
}

4 exec函数族

4.1 函数作用和函数介绍

有的时候需要在一个进程里面执行其他的命令或者是用户自定义的应用程序，此时就用到了exec函数族当中的函数。
使用方法一般都是在父进程里面调用fork创建处子进程，然后在子进程里面调用exec函数。

4.2 execl函数

函数原型: int execl(const char *path, const char arg, … / (char *) NULL */);
参数介绍：

  • path: 要执行的程序的绝对路径
  • 变参arg: 要执行的程序的需要的参数
  • arg:占位，通常写应用程序的名字
  • arg后面的: 命令的参数
  • 参数写完之后: NULL

返回值：若是成功，则不返回，不会再执行exec函数后面的代码；若是失败，会执行execl后面的代码，可以用perror打印错误原因。execl函数一般执行自己写的程序。

4.3 execlp函数

函数原型: int execlp(const char *file, const char arg, …/ (char *) NULL */);
参数介绍：

  • file: 执行命令的名字, 根据PATH环境变量来搜索该命令
  • arg:占位
  • arg后面的: 命令的参数
  • 参数写完之后: NULL

返回值：若是成功，则不返回，不会再执行exec函数后面的代码；若是失败，会执行exec后面的代码，可以用perror打印错误原因。execlp函数一般是执行系统自带的程序或者是命令.

4.4 exec函数族原理介绍

exec族函数的实现原理图：
如：execlp(“ls”, “ls”, “-l”, NULL); 一般第二个参数都是应用名字，为了方便他人ps查看是哪个应用，如果不是也可以的。
在这里插入图片描述
总结：exec函数是用一个新程序替换了当前进程的代码段、数据段、堆和栈；原有的进程空间没有发生变化，并没有创建新的进程，进程PID没有发生变化。

4.5 exec函数练习

  • 使用execl函数执行一个用户自定义的应用程序
  • 使用execlp函数执行一个linux系统命令

注意：当execl和execlp函数执行成功后，不返回，并且不会执行execl后面的代码逻辑，原因是调用execl函数成功以后，exec函数指定的代码段已经将原有的代码段替换了。

5 进程回收

5.1 为什么要进行进程资源的回收

当一个进程退出之后，进程能够回收自己的用户区的资源，但是不能回收内核空间的PCB资源，必须由它的父进程调用wait或者waitpid函数完成对子进程的回收，避免造成系统资源的浪费。

5.2 孤儿进程

  • 孤儿进程的概念：
    若子进程的父进程已经死掉，而子进程还存活着，这个进程就成了孤儿进程。
  • 为了保证每个进程都有一个父进程，孤儿进程会被init进程领养，init进程成为了孤儿进程的养父进程，当孤儿进程退出之后，由init进程完成对孤儿进程的回收。
  • 模拟孤儿进程的案例
    编写模拟孤儿进程的代码讲解孤儿进程，验证孤儿进程的父进程是否由原来的父进程变成了init进程。

5.3 僵尸进程

  • 僵尸进程的概念:
    若子进程死了，父进程还活着， 但是父进程没有调用wait或waitpid函数完成对子进程的回收，则该子进程就成了僵尸进程。
  • 如何解决僵尸进程
    • 由于僵尸进程是一个已经死亡的进程，所以不能使用kill命令将其杀死
    • 通过杀死其父进程的方法可以消除僵尸进程。杀死其父进程后，这个僵尸进程会被init进程领养，由init进程完成对僵尸进程的回收。
  • 模拟僵尸进程的案例：编写模拟僵尸进程的代码讲解僵尸进程, 验证若子进程先于父进程退出, 而父进程没有调用wait或者waitpid函数进行回收, 从而使子进程成为了僵尸进程.

5.4 进程回收函数

wait函数原型：pid_t wait(int *status);

  • 函数作用：

    1. 阻塞并等待子进程退出
    2. 回收子进程残留资源
    3. 获取子进程结束状态(退出原因)。

  • 返回值：

    1. 成功：清理掉的子进程ID；
    2. 失败：-1 (没有子进程)

  • status参数：子进程的退出状态 – 传出参数

    1. WIFEXITED(status)：为非0 → 进程正常结束
      WEXITSTATUS(status)：获取进程退出状态
    2. WIFSIGNALED(status)：为非0 → 进程异常终止
      WTERMSIG(status)：取得进程终止的信号编号。

  • wait函数练习：使用wait函数完成父进程对子进程的回收

//父进程调用wait函数完成对子进程的回收
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
	//创建子进程
	pid_t pid = fork();
	if(pid<0) //fork失败的情况
	{
		perror("fork error");
		return -1;
	}
	else if(pid>0)//父进程
	{
		printf("father: [%d], pid==[%d], fpid==[%d]\n", pid, getpid(),getppid());
		int status;
		pid_t wpid = wait(&status);
		printf("wpid==[%d]\n", wpid);
		if(WIFEXITED(status)) //正常退出
		{
			printf("child normal exit, status==[%d]\n", WEXITSTATUS(status));
		}
		else if(WIFSIGNALED(status)) //被信号杀死
		{
			printf("child killed by signal, signo==[%d]\n", WTERMSIG(status));
		}
		
	}
	else if(pid==0) //子进程
	{
		
		printf("child: pid==[%d], fpid==[%d]\n", getpid(), getppid());
		sleep(20);
		return 9;
	}

	return 0;
}


// (base) lzy@lzy-virtual-machine:~/system_programming/day5$ ./wait 
// father: [14146], pid==[14145], fpid==[10625]
// child: pid==[14146], fpid==[14145]
// wpid==[14146]
// child normal exit, status==[9]


// (base) lzy@lzy-virtual-machine:~/system_programming/day5$ ./wait 
// father: [14470], pid==[14469], fpid==[10625]
// child: pid==[14470], fpid==[14469]
// kill -9 14470
// wpid==[14470]
// child killed by signal, signo==[9]

waitpid函数函数原型：pid_t waitpid(pid_t pid, int *status, in options);

  • 函数作用：同wait函数
  • 函数参数
    • pid = -1 等待任一子进程。与wait等效。
    • pid > 0 等待其进程ID与pid相等的子进程。
    • pid = 0 等待进程组ID与目前进程相同的任何子进程，也就是说任何和调用waitpid()函数的进程在同一个进程组的进程。
    • pid < -1 等待其组ID等于pid的绝对值的任一子进程。(适用于子进程在其他组的情况)
    • status: 子进程的退出状态，用法同wait函数。
    • options：设置为WNOHANG，函数非阻塞，设置为0，函数阻塞。
  • 函数返回值
    • >0：返回回收掉的子进程ID；
    • -1：无子进程
    • =0：参3为WNOHANG，且子进程正在运行。
  • waitpid函数练习：使用waitpid函数完成对子进程的回收。

6 作业

6.1 作业1

测试父子进程之间是否共享文件

6.2 作业2

父进程fork三个子进程:

  1. 一个调用ps命令;
  2. 一个调用自定义应用程序;
  3. 一个调用会出现段错误的程序。

父进程回收三个子进程(waitpid)，并且打印三个子进程的退出状态。

=== 段错误 ===
1>. 访问了非法内存
2>. 访问了不可写的区域进行写操作
3>. 栈空间溢出

char* p = “hello，world”        
p[0]=‘a’；

/*
 * @Descripttion:   父进程fork三个子进程:
                    一个调用ps命令;
                    一个调用自定义应用程序;
                    一个调用会出现段错误的程序。
                    父进程回收三个子进程(waitpid)，并且打印三个子进程的退出状态。
 * @version: 
 * @Author: Lzy
 * @Date: 2021-07-20 18:18:24
 * @LastEditors: Lzy
 * @LastEditTime: 2021-07-20 18:58:34
 */

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

int main(int argc, char **argv)
{
    u_int8_t i = 0;
    //创建三个进程
    for (i = 0; i < 3; i++)
    {
        int pid = fork();
        if (pid == -1)
        {
            perror("fork error:");
        }
        else if (pid > 0)
        { //父进程
            printf("father: [%d], child: [%d]\n", getpid(), pid);
        }
        else if (pid == 0)
        { //子进程
            printf("child: [%d], father: [%d]\n", getpid(), getppid());
            break;
        }
    }

    if (i == 0) //第一个进程
    { 
        printf("this is first child [%d]\n", getpid());
        execl("/usr/bin/ps", "ps", "-ef", NULL);
        perror("perror error:");
        return -1;
    }
    else if (i == 1)    //第二个进程
    { 
        printf("this is second child [%d]\n", getpid());
        execl("/home/lzy/system_programming/day5/hello", "hello", "hello", "world!\n", NULL);
        perror("perror error:");
        return -1;
    }
    else if (i == 2)    //第三个进程
    { 
        printf("this is third child [%d]\n", getpid());
        char *p = "hello，world";
        p[0] = 'a';
        perror("write error: ");
        return -1;
    }
    else if (i == 3)    //父进程
    { 
        printf("this is father [%d]\n", getpid());
        while (1)
        {
            int status = 0;
            pid_t wpid = waitpid(-1, &status, WNOHANG);
            if (wpid == 0)      //没有子进程退出
            { 
            }
            else if (wpid > 0)  //对应wpid进程退出
            { 
                if (WIFEXITED(status))
                {
                    printf("child:[%d] normal exit,status is [%d]\n", wpid, WEXITSTATUS(status));
                }
                else if (WIFSIGNALED(status))
                {
                    printf("child:[%d] killed by [%d]\n", wpid, WTERMSIG(status));
                }
            }
            else if (wpid == -1) //所有子进程全部退出
            { 
                printf("all child had quited!\n");
                exit(0);
            }
        }
    }
    return 0;
}
进程控制
wolfGuiDao的博客
12-31 1016
进程控制 一、进程创建： 1.Linux中fork函数可以从已存在的进程中创建一个新进程。新进程为子进程，而原来的进程为父进程 头文件：#include <unistd.h> pid_t fork(void); 返回值：子进程中返回0；父进程中返回子进程pid，创建失败返回-1 3.原理： 进程调用fork后，内核做： a.分配新的内存块和内核数据结构给子进程。 b.将父...
Linux-进程控制详解（进程创建+进程终止+进程等待+进程程序替换）
热门推荐
X_Mrjw的博客
12-01 1万+
Linux进程控制1. 进程创建1.1 fork1.2 vfork2. 进程终止3. 进程等待4. 进程程序替换 1. 进程创建 1.1 fork 在Linux中，我们通常使用fork函数来为一个已经存在的进程创建一个新进程。而这个新创建出来的进程被称为原进程的子进程，原进程被称为该进程的父进程。 该函数其实是一个系统调用接口，原型如下： #include <unistd.h> pid_t fork(void); 特性：子进程会复制父进程的PCB，二者之间代码共享，数据独有，拥有各自的进程虚拟
linux进程控制
weixin_30580341的博客
06-01 90
linux 进程控制 1 首先，linux是一个多任务多进程的操作系统，所以必须要讨论进程的控制。 进程： 进程是一个动态的实体，是程序的一次执行过程，它是操作系统的资源分配的基本单位，简单来说线程和进程区别不大，一个主要的区别就是进程有自己的内存空间，并且占用系统资源。 进程标识...
[Linux]进程控制详解
最新发布
m0_73802195的博客
09-18 472
任何进程的最终执行情况我们用两个数字表示==（异常）信号编号+进程退出码如何让进程退出？1.main函数return2.exit(退出码)——终止进程，status（进程退出码）这个进程退出码status会在进程等待中详细的说。
Linux进程控制
mz474920631的博客
02-27 1612
进程控制一、进程创建fork函数fork函数返回值写时拷贝fork常规用法fork调用失败的原因二、进程终止进程退出场景进程常见退出方法_exit函数exit函数return退出三、进程等待进程等待必要性进程等待的方法总结 一、进程创建 fork函数 在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。 其中，fork创建子进程是以父进程为“模板”的。一个父进程可以创建出多个子进程。父：子=1：n，任何孩子都需要知道父亲，父亲需要去标识孩子。 返回
Linux 进程控制编程
echo_little_pig的博客
12-06 295
一.进程控制理论基础 1.进程的定义 进程 是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元2.进程与程序 程序是放到磁盘的可执行文件 进程 是指程序执行的实例 进程是动态的，程序是静态的：程序是有序代码的集合；进程是程序的执行。通常进程不可在计算机之间迁移；而程序通常对应着文件、静态和可以复制 进程是暂时的，程序使长久的：进程是一个状态变化的过程，程序可长久保存
Linux-进程控制
AI_ELF的博客
01-29 6439
Linux-进程控制进程创建fork函数fork函数返回值fork常规用法fork调用失败的原因写时拷贝进程终止进程退出场景进程常见退出方法_exit函数&&exit函数&&return退出 进程创建 进程的创建： 命令行启动命令（程序、指令……） 通过程序自身，fork出来的子进程 fork函数 在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。 语法： #include <unistd.h&gt
linux学习-进程（虚拟内存、进程控制/进程间通信）
10-18
本文将深入探讨Linux中的进程管理，包括虚拟内存机制以及进程控制和进程间通信（IPC）的概念。 首先，让我们来理解虚拟内存。在Linux系统中，每个进程都有自己的独立地址空间，这就是虚拟内存。它为每个进程提供了...
Linux实验二：Linux-基本命令-进程管理.doc
10-29
本实验报告主要关注Linux中的进程组织结构、进程与控制终端的关系，以及作业管理。 首先，通过`pstree`命令我们可以观察到系统中进程的父子关系。在Linux启动后，`init`进程是最先启动的，它是所有其他进程的始祖。...
Linux进程控制编程
CS752303201的博客
03-11 278
1、进程是系统资源分配的最小单位。2、进程的状态：   执行状态：进程正在占用CPU；    就绪状态：进程已具备一切条件，正在等待分配CPU的处理时间片；   等待状态：进程不能使用CPU，若等待时间发生则可将其唤醒。3、Linux中心进程包含3个段：数据段、代码段、堆栈段。临界资源：操作系统中将一次只允许一个进程访问的资源成为临界资源。   进程中访问临界资源的那段程序代码成为临界区。4、调度...
Linux多进程
xinianbuxiu的博客
10-18 986
一、进程 1.定义：进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元； 2、进程与程序的区别： (1)程序是放到磁盘的可执行文件 ；进程是指程序执行的实例； (2)进程是动态的，程序使静态的：程序是有序代码的集合；进程是程序的执行。通常进程不可在计算机之间迁移；而程序通常对应着文件、静态和可以复制 (3)进程是暂时的，程序使长久的：进程是一个状态变化的过程，程序
linux 进程控制编程
qq_42232643的博客
08-15 266
       在语句pid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的几乎完全相同，将要执行的下一条语句都是if(pid == -1)……    为什么两个进程的pid不同呢，这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：    1）在父进程中，fork返回新创建子进程...
LINUX进程控制编程
ZCzhouchao1的博客
08-16 368
1.进程的定义： 进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元。   2.进程的生命周期： 创建:   每个进程都是由其父进程创建，进程可以创建子进程，子进程又可以创建子进程的子进程 。 运行:   多个进程可以同时存在，进程间可以通信 。 撤销:    进程可以被撤销，从而结束一个进程的运行。   3.进程的三种状态： 执行状态：进程正在占用CPU...
Linux系统进程控制开发详解
"嵌入式Linux应用程序开发详解——进程控制开发" 在Linux操作系统中，进程是系统管理和调度的核心概念。本章深入探讨了进程控制开发的相关知识，旨在帮助读者掌握进程的基本概念、结构、创建与管理，以及守护进程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值