操作系统---进程通信

最新推荐文章于 2024-10-07 09:39:21 发布

薄荷364

最新推荐文章于 2024-10-07 09:39:21 发布

阅读量296

点赞数 3

文章标签： linux ubuntu

本文链接：https://blog.csdn.net/shadow364/article/details/141121869

版权

一、进程间通信介绍

什么是进程间通信：

进程间通信（Interprocess communication 也叫IPC）：指两个或多个进程之间进行数据交互的过程。

为什么进程之间需要通信：

由于进程采用的是虚拟空间+用户态/内核态机制，所以就导致进程与进程之间、进程与内核之间是互相独立的，如果想让多个进程协同工作解决复杂问题，就需要进程之间进行通信。

那类型的问题需要多进程协同工作：

进程的运行机制：

从人类的感知来讲，所有进程是并行执行，但实际情况是所以进程轮流使用CPU，只是轮转的速度比较快，人类感受不到，CPU的一个内核就是一个运算单位，可以供一个进行使用（这也是CPU厂商不断追求CPU内核的数量原因）,CPU内核越多，同时执行的进程就越多。

CPU密集型问题：

主要特点是需要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力，负责运算的进程越多，竞争得到的执行时间就越长。但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，是一种损人不利已的做法。所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。

IO密集型问题：

主要涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度，因为创建进程也需要相关的资源，比如代码段、栈、文件描述符表、环境变量表。

所以处理CPU密集型程序时可以选择多进程实现，有效的利用多核提升效率；而IO密集型的由于99%的时间都花在IO上，花在CPU上的时间很少，所以多线程也能提高很大效率。

二、简单的进程间通信

命令行参数：

情况1：在终端执行程序时，给子进程传递命令行参数。

情况2：使用vfork+exec创建进程时，给子进程传递命令行参数。

只能在父子进程之间，在父进行创建子进程时使用，只能由父进行传递给子进程，单向通信，并且只能传递一些简单的字符串数据。

环境变量表：

情况1：使用fork创建子进程时，子进程会拷贝一份父进程的环境变量表。

情况2：使用vfork+exec创建进程时，给子进程传递一份父进程的环境变量表，子进程拿到环境表后会进行拷贝。

只能在父子进程之间，父进行创建子进程时使用，只能由父进行传递给子进程，单向通信，并且只能传递一些简单的字符串数据。

信号：

情况1：使用kill向指定的进程发送信号进行通信。

情况2：使用sigqueue向指定的进程发送信号，也可以附带一些简单的数据。

可以在任意进程之间进行通信，但也只能是互相告知某某事件发生了，即使用能使用sigqueue带一些数据，但只有能传递一个int类型整数，只有通过fork创建的子进程才能传递内存地址。

文件：

情况1：使用文件+信号，让任意两个进程之间传递大量数据，但要各自控制好位置指针，协调好读写时间。

情况2：使用文件+文件锁，也可以让任意两个进程之间传递大量数据，但文件锁的操作比较麻烦，也有可能陷入死锁的情况。

单纯的使用文件进行通信，无法协调读取和写入的时间，空间造成文件内的数据混乱，所以必须配合使用信号或文件锁。

三、传统的进程间通信——管道通信

管道是UNIX系统中最古老的进程间通信方式，是一种特殊文件读写机制
当进程从管道文件中读取数据时，如果管道中没有数据则进程会进入阻塞状态，直到有数据读取出来才返回，因此不需要借助信号、文件锁来协调读写时间
管道中的数据一旦读取完毕就会消失，因此也不需要管理文件的位置指针，所以使用管道文件比普通文件的进程间通信要方便很多
古老的好处是所有系统都支持，早期的管道文件是半双工，现在有些系统支持管道文件的全双工，现在绝大多数情况已经不使用管道来通信了

有名管道：

在文件系统中创建出一个实体的有文件名的管道文件，然后通过系统I/O的相关API来进行相关操作

使用函数创建：

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

int mkfifo(const char *pathname, mode_t mode);
功能：创建一个有名管道文件
pathname:管道文件的名字
mode:管道文件的权限
返回值：成功返回0 失败-1

使用命令创建：

mkfifo <file>

管道单向通信的编程模型：

进程A      ->         进程B
创建有名管道      
打开管道              打开管道
写数据                读数据
关闭管道              关闭管道
删除管道

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc,const char* argv[])
{
    //  创建管道文件
    if(mkfifo("fifo",0644))
    {
        perror("mkfifo");
        return -1;
    }

    //  打开管道
    int fd = open("fifo",O_WRONLY);
    if(0 > fd)
    {
        perror("open");
        unlink("fifo");
        return -1;
    }

    char buf[256] = {};

    for(;;)
    {
        printf(">>>");
        //  使用封装好的my_gets()
        gets(buf);
        //  写文件 发送数据
        write(fd,buf,strlen(buf));
        //  检查是否quit
        if(0 == strcmp(buf,"quit"))
        {
            printf("通信结束\n");
            usleep(1000);
            break;
        }
    }
    
    //  关闭管道
    close(fd);

    //  删除管道
    unlink("fifo");
}

#include <stdio.h>                        
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc,const char* argv[])
{
    //  打开管道
    int fd = open("fifo",O_RDONLY);
    if(0 > fd)
    {
        perror("open");
        return -1;
    }

    char buf[256] = {};

    //  读数据
    for(;;)
    {
        read(fd,buf,sizeof(buf));
        printf("read:%s\n",buf);

        if(0 == strcmp(buf,"quit"))
        {
            printf("通信结束\n");
            break;
        }
    }

    //  关闭管道
    close(fd);
}

思考作业：通过管道实现进程间的双向通信（两个管道文件、开子进程）

匿名管道：

只在内核中创建的管道文件对象并返回该对象的文件描述符，然后使用系统IO进行相关操作，匿名管道文件不会在文件系统中显示，在创建时不需要提供路径，也不会占用磁盘空间，只是使用内核空间来临时存储数据，当关闭文件描述符后会自动回收
注意：只适合fork创建的有关系的父子进程之间进行通信

编程模型：

    父进程     ->      子进程
   创建匿名管道           
   创建子进程         拷贝一对fd
   关闭读端(fd[0])    关闭写端(fd[1])
   写数据(fd[1])      读数据(fd[0])
   关闭写              关闭读

#include <stdio.h>          
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc,const char* argv[])
{
    //  创建匿名管道
    int fd[2] = {};
    if(pipe(fd))
    {
        perror("pipe");
        return -1;
    }

    //  创建子进程
    if(fork())
    {
        //  父进程  负责写 关闭读
        close(fd[0]);
        char buf[256] = {};
        for(;;)
        {
            printf("父进程>>>");
            gets(buf);
            write(fd[1],buf,strlen(buf));
            if(0 == strncmp(buf,"quit",4))
            {
                printf("通信结束\n");
                break;
            }
            usleep(1000);
        }
        usleep(1000);
        close(fd[1]);
        usleep(1000);
    }
    else
    {
        //  子进程  负责读 关闭写
        close(fd[1]);
        char buf[256] ={};

        for(;;)
        {
            read(fd[0],buf,sizeof(buf));
            printf("read:%s\n",buf);
            if(0 == strncmp(buf,"quit",4))
            {
                printf("父进程要结束通信\n");
                break;
            }
        }
        close(fd[0]);
    }
}

四、XSI机制的进程间通信

1、XSI介绍：

什么是XSI：

X/Open国际联盟有限公司是一个欧洲基金会，它的建立是为了向UNIX环境提供标准，XSI是X/Open System Interface的缩写，也就是X/Open设计的系统接口。

X/Open的主要的目标是促进对UNIX系统、接口、网络和应用的开放式系统协议的制定。它还促进在不同的UNIX环境之间的应用程序的互操作性，以及支持对电气电子工程师协会对UNIX的可移植操作系统接口规范。

IPC对象：

它用于进程间通信的XSI-IPC内核对象,类似于匿名管道、文件内核对象一样,通过使用XSI方式进行进程间通信时，系统会在内核中创建出一个XSI-IPC内核对象，让通信的进程能够共同访问该内核对象
XSI-IPC对象只存在于内核空间，不会在文件系统中显示，该对象需要通过IPC键值来创建和获取

IPC键值：

用于创建\获取 IPC对象的凭证，是一个无符号的整数，相当于IPC对象的名字，类似于文件名
在创建IPC对象时，需要创建者提供一个IPC键值，有点类似给文件取名字，但是所有已经存在的IPC对象都在同一个作用域下，因此所有进程都可以访问到，所有有很大重名的风险，所以不建议创建者自己瞎想一个IPC键值去创建IPC对象，而应该使用操作系统提供的一个自动生成IPC键值的API

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

key_t ftok(const char *pathname, int proj_id);
功能：根据项目路劲和项目编号 自动生成一个ipc键值
pathname：建议提供当前项目的路径
proj_id：项目编号
返回值：会根据项目路径和编号来计算出一个IPC键值，但是只是根据字符串内容来计算，不会检查路径是否为假
注意：使用时，建议提供当前的正确的工作路径，以及不同的项目编号，就可以获得不同的IPC键值，通过不同的IPC键值来创建不同的IPC对象
但是获取时，需要拿到相同的IPC对象，因此需要拿相同的IPC键值，因此提供相同路径和编号即可获取

IPC描述符：

类似于文件描述符，是一个非负整数，它是IPC内核对象的给用户空间来访问的凭证

显示IPC对象命令：

ipcs -m  #查看共享内存IPC对象   memory
ipcs -q  #查看消息队列IPC对象   queue
ipcs -s  #查看信号量IPC对象     sem
ipcs -a  #查看所有的IPC对象

删除IPC对象命令：

ipcrm -m  id    #删除共享内存IPC对象
ipcrm -q  id    #删除消息队列IPC对象
ipcrm -s  id    #删除信号量IPC对象

2、共享内存：

基本原理：

在内核中开辟一块内存，可以让其它进程的虚拟地址与这块内存进行映射，从而达到让多个进程共享一块内存的目的，当一个进程向这块内存写数据时，其它进程就都可以读取到，这就达到了通信的目的
优点：这种通信方式不存在数据的复制，是最快的进程间通信方式
缺点：需要考虑同步访问的问题（用信号）

使用方式：

当一个进程向共享内存写入数据时，内核不会通知其他进程，进程从共享内存读取数据时，也无法分辨是否是通信的对方新写入的数据，为解决该问题，有以下方式：

读写：一个进程只负责写，另一个只负责读，这要负责读的进程使用的是最新即可，是一种单向通信
轮询：配合定时器或者闹钟，每隔一段时间就读取一次
中断：配合信号，进程只要往共享内存中写入数据，就给对方发送一个约定好的信号，其它进程如果已经读取完共享内存也可以发送一个约定好的信号

编程模型：

    进程A             进程B
  创建共享内存        获取共享内存
  映射共享内存        映射共享内存
  写数据并通知对方    接收到通知后读取数据
  接收到通知后读取数据 写数据并通知对方
  取消映射           取消映射
  删除共享内存

//  shmA.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

static int shmid;
static char* shm;

//  接收到对方发送信号 才读取数据
void sigread(int num)
{
    printf("\nread:%s\n",shm);
    if(0 == strncmp(shm,"quit",4))
    {   
        printf("对方不想鸟你了\n");

        //  取消映射
        if(shmdt(shm))
        {
            perror("shmdt");
            exit(EXIT_FAILURE);
        }

        //  删除共享内存
        if(shmctl(shmid,IPC_RMID,NULL))
        {
            perror("shmctl");
            exit(EXIT_FAILURE);
        }      
        //  必须结束进程 return没有用
        exit(EXIT_SUCCESS);
    }   
}
int main(int argc,const char* argv[])
{
    signal(SIGRTMIN,sigread);
    printf("我是进程%u\n",getpid());

    //  创建共享内存
    shmid = shmget(ftok(".",110),4096,IPC_CREAT|0644);
    if(0 > shmid)
    {
        perror("shmget");
        return EXIT_FAILURE;
    }

    //  映射共享内存
    shm = shmat(shmid,NULL,0);
    if((void*)-1 == shm)
    {
        perror("shmat");
        return EXIT_FAILURE;
    }

    //  获取对方的进程id
    pid_t pid = 0;
    printf("请输入与我通信的进程ID:");
    scanf("%u",&pid);

    //  写入数据并通知对方
    for(;;)
    {
        printf(">>>");
        scanf("%s",shm);

        //  发送信号
        kill(pid,SIGRTMIN);
        if(0 == strncmp(shm,"quit",4))
        {
            printf("你终止通信了\n");
            break;
        }
    }

    //  取消映射
    if(shmdt(shm))
    {
        perror("shmdt");
        return EXIT_FAILURE;
    }
    //  删除共享内存
    if(shmctl(shmid,IPC_RMID,NULL))
    {
        perror("shmctl");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

3、消息队列：

基本原理：

由系统内核维护的一个链式队列，每个节点称为一条消息，每条消息由消息类型、数据、长度信息组成
和管道类似，可以双向通信，并且从中读取一个消息后，会自动出队，而且不是按照顺序读取，是按照消息类型读取

编程模型：

        进程A             进程B
    创建消息队列        获取消息队列
    发送消息(type:a)    接收消息(type:a)
    接收消息(type:b)    发送消息(type:b) 
    销毁消息队列

4、信号量

基本原理：

所谓信号量就是内核中维护的一个全局变量，当做计数器，用于计数多进程工作中的共享资源数，也是为了限制多进程对共享资源的使用
信号量是一种数据操作锁，本身是不具备数据交换通信功能的，而是通过控制其他进程的通信资源来协助实现进程间通信
- 假设操作系统中有n个共享资源，需要把信号量的值设置为n
- 当有m个进程需要以独占的形式使用k个共享资源，并且m*k>n，需要使用信号量
- 每个进程在使用共享资源之前先尝试执行信号量-1操作
- 如果信号量>0时，说明剩余共享资源够用，则-1后拿到共享资源去执行，当执行完毕后，需要把共享资源归还，信号量+1操作
- 如果信号量<=0时，说明共享资源不足，则进程阻塞等待，直到信号量的值>0,才重新唤醒后，继续尝试-1
注意：进程之间资源几乎都是相互独立的，共享资源很少，所以很少用到信号量