Linux系统-----进程管理（进程的创建、控制与互斥）

Fitz&

已于 2023-12-03 14:21:44 修改

阅读量1.9k

点赞数 25

分类专栏： Linux操作系统文章标签： linux 运维服务器操作系统进程管理

于 2023-11-29 20:34:42 首次发布

本文链接：https://blog.csdn.net/m0_73633088/article/details/134692439

版权

Linux操作系统专栏收录该内容

6 篇文章 2 订阅

订阅专栏

3. execl( )和fork( )联合使用

4. exit（）终止函数

三、进程的互斥

lockf( )互斥锁

前言

前面我们学习了Linux系统的基本指令以及如何在Linux系统里面去书写C语言代码，那这一次我们就来学习Linux系统中的进程管理，包括进程的创建、进程的控制和进程的互斥。

进程

1.基本概念

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。

2.特征

动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
并发性：任何进程都可以同其他进程一起并发执行
独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；
异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进
结构特征：进程由程序、数据和进程控制块三部分组成。
多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

详细可查阅此处：进程（一段程序的执行过程）_百度百科 (baidu.com)

3.Linux系统的进程

UNIX中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。

PCB的数据结构如下：

1、进程表项（Process Table Entry）。包括一些最常用的核心数据：

进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB的指针P_Link、指向U区进程正文、数据及栈在内存区域的指针。

2、U区（U Area）。用于存放进程表项的一些扩充信息。

每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符u-ruid(read user ID)、有效用户标识符u-euid(effective user ID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。

由于UNIX系统采用段页式存储管理，为了把段的起始虚地址变换为段在系统中的物理地址，便于实现区的共享，所以还有：

3、系统区表项。以存放各个段在物理存储器中的位置等信息。

系统把一个进程的虚地址空间划分为若干个连续的逻辑区，有正文区、数据区、栈区等。这些区是可被共享和保护的独立实体，多个进程可共享一个区。为了对区进行管理，核心中设置一个系统区表，各表项中记录了以下有关描述活动区的信息：

区的类型和大小、区的状态、区在物理存储器中的位置、引用计数、指向文件索引结点的指针。

4、进程区表

系统为每个进程配置了一张进程区表。表中，每一项记录一个区的起始虚地址及指向系统区表中对应的区表项。核心通过查找进程区表和系统区表，便可将区的逻辑地址变换为物理地址。

5、进程映像

UNIX系统中，进程是进程映像的执行过程，也就是正在执行的进程实体。它由三部分组成：

1、用户级上、下文。主要成分是用户程序；

2、寄存器上、下文。由CPU中的一些寄存器的内容组成，如PC，PSW，SP及通用寄存器等；

3、系统级上、下文。包括OS为管理进程所用的信息，有静态和动态之分。

一、进程的创建

1. fork()函数

功能：创建一个新进程。

系统调用格式： pid=fork( )

参数定义：

int fork()

fork( )返回值意义如下：

0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。
>0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。
-1：创建失败。

执行过程：

如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。此时OS在内存中建立一个新进程，所建的新进程是调用fork( )父进程（parent process）的副本，称为子进程（child process）。子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。父进程与子进程并发执行。

下面看个示例，在Linux系统下写此C语言代码：（不记得或者不熟悉怎么在Linux系统下写编程的可以看看这个：Linux系统编写C语言程序并执行（图文详解）-CSDN博客）

#include<stdio.h>
#include<unistd.h> //Linux 头文件
int main()
{
    int pid;
    pid = fork();
    printf("pid: %d\n", pid);
    if (!pid)
        printf("I'm the child process!\n");
    else if (pid > 0)
        printf("I'm the parent process!\n ");
    else
        printf("Fork fail!\n");
    return 0;
}

执行结果：

这里我们可以看出，总体来看pid调用fork() 函数是有两个返回结果的，一个是在父进程的结果，其数值为子进程的PID，而在子进程中的返回结果是0。

核心为fork( )完成以下操作：

（1）为新进程分配一进程表项和进程标识符

进入fork( )后，核心检查系统是否有足够的资源来建立一个新进程。若资源不足，则fork( )系统调用失败；否则，核心为新进程分配一进程表项和唯一的进程标识符。

（2）检查同时运行的进程数目

超过预先规定的最大数目时，fork( )系统调用失败。

（3）拷贝进程表项中的数据

将父进程的当前目录和所有已打开的数据拷贝到子进程表项中，并置进程的状态为“创建”状态。

（4）子进程继承父进程的所有文件

对父进程当前目录和所有已打开的文件表项中的引用计数加1。

（5）为子进程创建进程上、下文

进程创建结束，设子进程状态为“内存中就绪”并返回子进程的标识符。

（6）子进程执行

虽然父进程与子进程程序完全相同，但每个进程都有自己的程序计数器PC(注意子进程的PC开始位置)，然后根据pid变量保存的fork( )返回值的不同，执行了不同的分支语句。

2. 多进程的创建与输出

这里我们以示例来说明，在Linux系统下执行以下C语言程序。

（1）案例1：

#include<stdio.h>
#include<unistd.h> //Linux 头文件
int main()
{
	int p1, p2;
	while ((p1 = fork()) == -1);        /*创建子进程p1*/
	if (p1 == 0)
		printf("b\n");
	else
	{
		while ((p2 = fork()) == -1);   /*创建子进程p2*/
		if (p2 == 0)
			printf("c\n");
		else
			printf("a\n");
	}
	return 0;
}

输出结果：

实际上输出结果bca，bac, abc ,……都有可能。

（2）案例2：

#include<stdio.h>
#include<unistd.h> //Linux 头文件
int main()
{
    int p1, p2, i;
    while ((p1 = fork()) == -1);          /*创建子进程p1*/
    if (p1 == 0)
        for (i = 0; i < 4; i++)
            printf("daughter  %d\n", i);
    else
    {
        while ((p2 = fork()) == -1);   /*创建子进程p2*/
        if (p2 == 0)
            for (i = 0; i < 4; i++)
                printf("son  %d\n", i);
        else
            for (i = 0; i < 4; i++)
                printf("parent  %d\n", i);
    }
    return 0;
}

输出结果：

同样的，输出结果也是不唯一，所有情况都是有可能的。

原因分析：

1、从进程并发执行来看，各种情况都有可能。上面的三个进程没有同步措施，所以父进程与子进程的输出内容会叠加在一起。输出次序带有随机性。

2、由于函数printf( )在输出字符串时不会被中断，因此，字符串内部字符顺序输出不变。但由于进程并发执行的调度顺序和父子进程抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化。这与打印单字符的结果相同。

我这个Linux系统给到的是2核处理器，所以输出结果不一定是按照从上往下的输出结果，实际上所有情况的输出结果都有可能，因为多核处理器的执行过程是并发执行的，每次输出都是具有随机性的。

如果想了解具体执行过程，可以输入 ltrace -f -i -S ./文件名字 查看以上程序执行过程。

下面我把此虚拟机的处理器设置为单核，再此测试上面的程序

我们执行案例1的程序，输出结果只有abc 这一种可能。

二、进程的控制

进程的控制包括进程的睡眠、同步、撤消等进程控制方法。

1. exec()系列

系统调用exec( )系列，也可用于新程序的运行。fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id 与调用进程相同。

exec( )没有建立一个与调用进程并发的子进程，而是用新进程取代了原来进程。所以exec( )调用成功后，没有任何数据返回，这与fork( )不同。exec( )系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp五个，其基本功能相同，只是以不同的方式来给出参数。

一种是直接给出参数的指针，如：

int execl(path,arg0[,arg1,...argn],0);

char *path,*arg0,*arg1,...,*argn;

另一种是给出指向参数表的指针，如：

int execv(path,argv);

char *path,*argv[ ];

具体使用可参考有关书。

2. wait() 函数

等待子进程运行结束。如果子进程没有完成，父进程一直等待。wait( )将调用进程挂起，直至其子进程因暂停或终止而发来软中断信号为止。如果在wait( )前已有子进程暂停或终止，则调用进程做适当处理后便返回。

系统调用格式：

int wait(status)

int *status;

其中，status是用户空间的地址。它的低8位反应子进程状态，为0表示子进程正常结束，非0则表示出现了各种各样的问题；高8位则带回了exit( )的返回值。exit( )返回值由系统给出。

核心对wait( )作以下处理：

（1）首先查找调用进程是否有子进程，若无，则返回出错码；

（2）若找到一处于“僵死状态”的子进程，则将子进程的执行时间加到父进程的执行时间上，并释放子进程的进程表项；

（3）若未找到处于“僵死状态”的子进程，则调用进程便在可被中断的优先级上睡眠，等待其子进程发来软中断信号时被唤醒。

3. execl( )和fork( )联合使用

系统调用exec和fork( )联合使用能为程序开发提供有力支持。用fork( )建立子进程，然后在子进程中使用exec( )，这样就实现了父进程与一个与它完全不同子进程的并发执行。

一般，wait、exec联合使用的模型为：

int status;
      ............
if (fork( )= =0)
  {
      ...........;
      execl(...);
      ...........;
  }
wait(&status);

4. exit（）终止函数

功能：终止进程的执行。

系统调用格式：

void exit(status)

int status;

其中，status是返回给父进程的一个整数。

为了及时回收进程所占用的资源并减少父进程的干预，UNIX/LINUX利用exit( )来实现进程的自我终止，通常父进程在创建子进程时，应在进程的末尾安排一条exit( )，使子进程自我终止。exit(0)表示进程正常终止，exit(1)表示进程运行有错，异常终止。

如果调用进程在执行exit( )时，其父进程正在等待它的终止，则父进程可立即得到其返回的整数。核心须为exit( )完成以下操作：

（1）关闭软中断

（2）回收资源

（3）写记帐信息

（4）置进程为“僵死状态”

下面看个示例：

#include<stdio.h>
#include <stdlib.h>
#include<unistd.h>
int main()
{
    int pid;
    pid = fork();         /*创建子进程*/
    switch (pid)
    {
    case  -1:                          /*创建失败*/
        printf("fork fail!\n");
        exit(1);
    case  0:                                 /*子进程*/
        execl("/bin/ls", "ls", "-1", "-color", NULL);
        printf("exec fail!\n");
        exit(1);
    default:                                 /*父进程*/
        wait(0);              /*同步*/
        printf("ls completed !\n");
        exit(0);
    }
    return 0;
}

输出结果：执行命令ls -l -color ，（按倒序）列出当前目录下所有文件和子目录；

ls completed!

进程分析：

程序在调用fork( )建立一个子进程后，马上调用wait( )，使父进程在子进程结束之前，一直处于睡眠状态。子进程用exec( )装入命令ls ，exec( )后，子进程的代码被ls的代码取代，这时子进程的PC指向ls的第1条语句，开始执行ls的命令代码。

注意在这里wait( )给我们提供了一种实现进程同步的简单方法。

三、进程的互斥

lockf( )互斥锁

用作：锁定文件的某些段或者整个文件。

本函数的头文件为：#include "unistd.h"

参数定义：

int lockf(files,function,size)

int files,function;

long size;

其中：files是文件描述符；function是锁定和解锁：1表示锁定，0表示解锁。size是锁定或解锁的字节数，为0，表示从文件的当前位置到文件尾。

示例：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include <sys/wait.h>
int main()
{
    int p1, p2, i;
    while ((p1 = fork()) == -1);       /*创建子进程p1*/
    if (p1 == 0)
    {
        lockf(1, 1, 0);          /*加锁，这里第一个参数为stdout（标准输出设备的描述符）*/
        for (i = 0; i < 10; i++)
            printf("daughter %d\n", i);
        lockf(1, 0, 0);                     /*解锁*/
    }
    else
    {
        while ((p2 = fork()) == -1);  /*创建子进程p2*/
        if (p2 == 0)
        {
            lockf(1, 1, 0);        /*加锁*/
            for (i = 0; i < 10; i++)
                printf("son %d\n", i);
            lockf(1, 0, 0);            /*解锁*/
        }
        else
        {
            lockf(1, 1, 0);         /*加锁*/
            for (i = 0; i < 10; i++)
                printf(" parent %d\n", i);
            lockf(1, 0, 0);         /*解锁*/
        }
    }
}

运行结果

parent…

son…

daughter..

或parent…

son…

parent…

daughter…

大致与未上锁的输出结果相同，也是随着执行时间不同，输出结果的顺序有所不同。