进程间通信——IPC（Linux）

最新推荐文章于 2024-05-20 16:40:58 发布

kpl_20

最新推荐文章于 2024-05-20 16:40:58 发布

阅读量982

点赞数 16

分类专栏： Linux 文章标签： linux IPC

本文链接：https://blog.csdn.net/kpl_20/article/details/136498704

版权

Linux 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

前言

1. 概念

进程间通信（IPC）：不同进程之间进行数据交换和信息传递的过程。

因为进程独立性的原因，所以进程之间通信是有成本的。
成本：需要通过特定的机制来实现，这个过程会增加额外的开销和复杂性。还有数据传输、同步、互斥等方面的开销。

2. 目的

其实概念就是IPC存在的目的。
进一步解释：

数据传输：一个进程需要把数据传输到另一个进程。
资源共享：多个进程共享同一个资源
通知：一个进程通知另一个（不限于一个）发生了某些事件。（eg:子进程退出，要通知父进程）
进程控制：控制进程希望拦截被控制进程的异常，并及时知道它的状态改变
协同：… (eg：信号量)

3. 怎么做

让不同的进程看到同一份“资源” —— 特定形式的内存空间
“资源”一般是由OS提供。因为如果是通信双方的进程提供，那这一份资源本质就是这个进程独有的，会破坏进程间的独立性
进程通信本质就是访问OS，进程代表的就是用户。 “资源”的创建 -> 使用 -> 释放 ——>都离不开system call （因为群众有坏人，OS不放心把底层暴露出来）。

4. 分类

system call -> 从底层设计，接口设计，都要由OS设计。一般OS会有独立的通信模块（IPC通信模块）——> 隶属文件系统
既然出现通信，就要制定标准，进程间通信的标准：
System V（本机通信）
POSIX （网络方便）

本文先介绍的是System V和基于文件级别的通信方式——管道
System V IPC：

System V 共享内存（主讲）
System V 消息队列（介绍原理）
System V 信号量（介绍原理）

一、管道

因为设计是数据从一端进去从另一端出去，是一种单向的通信方式，所以命名为管道

1. 管道原理

管道：基于文件级别的通信方式
原理图：介绍如何基于文件

再叙述一下：

文件本身是不会继承下去的，被子进程继承的是文件描述符，所以通过文件描述符父子（具有血缘关系的）进程就可以对同一份资源进行访问。这就是管道的前提条件
因为进程间通信的数据基本不需要落盘，所以内存级文件通信提高了效率，减少拷贝和与外设的交互

注：因为和文件有关，这里涉及文件的知识就不再介绍，想要了解可以看另一篇文章IO Linux

2. 匿名管道

①理解匿名管道

匿名管道：用于父子进程、兄弟进程，具有亲缘关系的进程之间通信。管道是一种单向通信方式，数据只能在一个方向上流动。

简化图：

匿名管道的特殊性导致：

只能用于共同祖先的进程（具有亲缘关系）之间进行通信。通常一个管道由一个进程创建，然后fork，此后父子进程就都可以使用该管道。
不能双向通信，所以想要双向通信，再建立一条匿名管道
到这里只是让通信进程看到了同一份“资源”，还没有进行通信。所以因为进程独立性，进程间通信是需要成本的。

注：
数据为脏：无论读写都要先把数据加载到内存中。如果进行修改，在内存中修改好，此时内存中的数据和磁盘上的数据不一致，此时内存中的就是脏数据

②创建匿名管道——pipe

系统调用介绍：pipe

头文件：
	#include <unistd.h>

函数声明：
	int pipe(int pipefd[2]);

函数参数：
	pipefd[2]：两个整型元素的数组。输出型参数：这两个元素带出来的是管道的文件描述符。
	pipefd[0]：读端的文件描述符
	pipefd[1]：写端的文件描述符

返回值：
	1. 成功返回0
	2. 失败返回-1，错误码被设置

输出型参数pipefd[2]：根据上面匿名管道的简化图，可以看到想要建立任取一方读或写的单向通信。就需要在父进程时，以读和写两种方式打开管道文件然后fork，子进程继承这两种方式，然后根据需要再关闭通信进程对应一端。

使用系统调用——pipe：

介绍下面这串代码的逻辑：
创建管道 -> 子进程继承，然后关闭子进程的读端和父进程的写端。子进程每秒写一条信息，父进程读。对子进程的写和父进程的读都进行封装，读写方法我会单独拿出来验证管道的四种状态。

#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cerrno>

using namespace std;

#define SIZE 1024


// child -> w
void Writer(int wfd)
{
    string s = "hello, I am child";
    pid_t child_pid = getpid();
    int number = 0;  //展现数据是变化的

    char buffer[SIZE];
    while (true)
    {
        buffer[0] = 0; // 字符串情况，告诉阅读代码的人，这个数组被当成字符串使用
        // 通过上面三个数据构建字符串
        snprintf(buffer, sizeof(buffer), "%s-%d-%d\n", s.c_str(), child_pid, number++);

        // 发送/写入给父进程信息 system call
        write(wfd, buffer, strlen(buffer));
        sleep(1); //一秒写一条信息
    }
}

// father -> r
void Reader(int rfd)
{
    char buffer[SIZE];
    while (true)
    {
        buffer[0] = 0; // 告诉阅读代码的人，这个数组被当成字符串使用
        ssize_t n = read(rfd, buffer, sizeof(buffer));
        if (n < 0)
            break;
        else if (n == 0)
        {
            printf("read file done!\n");
            break;
        }
        else
        {
            buffer[n] = 0; // 因为是字符串，所以读出来要注意
            cout << "father get a message[" << getpid() << "]#" << buffer << endl;
        }
    }
}

int main()
{
	//创建管道
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    if (n < 0)
        exit(errno);  //创建失败直接退出

    // child -> w,  father -> r
    pid_t id = fork();
    if (id < 0)
        exit(errno);
    else if (id == 0)
    {
        // child 关闭读端
        close(pipefd[0]);
        // 写方法
        Writer(pipefd[1]);

        close(pipefd[1]);
        exit(0);
    }
    // father
    close(pipefd[1]);
    // 读方法
    Reader(pipefd[0]);

    // wait child process
    pid_t rid = waitpid(id, nullptr, 0);
    if (rid < 0)
        exit(errno);
    close(pipefd[0]);
    return 0;
}

运行结果：

管道的四种情况：

读写端正常，写方法改成从键盘输入，其余代码不变

改变写方法代码：

void Writer(int wfd)
{
    pid_t child_pid = getpid();

    char buffer[SIZE];
    while (true)
    {
        buffer[0] = 0; 
        cout << "Please Enter@";
        fgets(buffer, sizeof(buffer), stdin);
        buffer[strlen(buffer) - 1] = '\0';      //把换行符去掉

        // 发送/写入给父进程信息 system call
        write(wfd, buffer, strlen(buffer));
        sleep(1);
    }
}

实验结果：

现象：

在子进程输入数据然后向父进程发送消息，父进程进行读取，再一次写的时候，上一次信息清空（调整位置），父进程读取新内容
子进程写完之后父进程读取，因此子进程未写之前，父进程读端处于阻塞状态

读写端正常，写端写满

改变读写方法代码：

void Writer(int wfd)
{
    int cnt = 0;
    while(true)
    {
        cout << cnt++ << endl;
        write(wfd, "c", 1);
    } 
}
void Reader(int rfd)
{
    while(true)
    {
        sleep(5);
        break;
    }
}

实验结果：

现象：

写端写满，写端陷入阻塞，管道写入了65536字节，即64KB
不同内核，可能有一定差别

读端正常，写端关闭

改变写方法代码：

void Writer(int wfd)
{
    string s = "hello, I am child";
    pid_t child_pid = getpid();
    int cnt = 3;
    char buffer[SIZE];
    while (cnt)
    {
        buffer[0] = 0; 
        snprintf(buffer, sizeof(buffer), "%s-%d-%d\n", s.c_str(), child_pid, cnt--);
        write(wfd, buffer, strlen(buffer));

		//读三次之后关闭文件描述符
        if(cnt == 0)
        {
            close(wfd);
            cout << "wfd close!!" << endl;
        }
        sleep(1);
    }
}

实验结果：

现象：

正常读写三次之后，写端关闭，读端会返回0，表面读到文件尾，不会被阻塞

写端正常，读端关闭

改变读方法代码，并且在父进程等待处获取子进程退出状态

void Reader(int rfd)
{
    char buffer[SIZE];
    int cnt = 3;
    while (cnt)
    {
        buffer[0] = 0; // 告诉阅读代码的人，这个数组被当成字符串使用
        ssize_t n = read(rfd, buffer, sizeof(buffer));
        if (n < 0)
            break;
        else if (n == 0)
        {
            printf("read file done!\n");
            break;
        }
        else
        {
            buffer[n] = 0; // 因为是字符串，所以读出来要注意
            cout << "father get a message[" << getpid() << "]#" << buffer << endl;
        }

        cnt--;
        if(cnt == 0)
        {
            close(rfd);
        }
    }
}



	//在main函数最后多加了几行的内容 ——> 获取子进程退出状态
	int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid < 0)
        exit(errno);
    cout << "wait success pid:" << id;
    cout << " exit code:" << ((status >> 8)&0xFF) << " exit signal:" << (status&0x7F) << endl;

实验结果：

现象：

首先我们没有对写代码做任何更改，只是读端被我们读了三次关闭了。结果OS杀掉正在写入的进程，子进程异常退出。
父进程等待子进程，获取的子进程退出信息，退出码没有问题，退出信号是13号信号

③模拟实现进程池——管道

注：我们可以使用管道模拟实现进程池

由父进程创建一批进程，父子进程之间建立管道，当父进程有任务时，给子进程发送信号，让指定的子进程去完成该任务。进程池代码实现链接：本质上这个进程池的实现，体现了OS底层的模式：先描述再组织的思想。首先创建一个结构体进行描述，然后使用C++的容器进行管理。
简易图解：

每次有任务时，父进程只需要把任务码通过管道发送给空闲的子进程。（判断是否是空闲的子进程，可以在结构体中添加一些属性，然后派送任务的时候进行遍历，判断该进程是否空闲）

3. 命名管道

①理解命名管道

命名管道：命名管道是一种特殊的管道，可以在无关的进程之间进行通信。命名管道是一种有名字的通信方式，可以通过文件系统中的路径来访问。

②使用命名管道——mkfifo

命名管道可以直接使用命令创建
mkfifo [filename]
也可以使用系统调用接口mkfifo

注：

Linux下，创建一个命名管道（也称为FIFO）时，无论用户设置的权限是什么，最终创建出来的命名管道的权限都会被内核自动修改为0666（即所有用户都有读写权限）。
管道创建出来，属于内存级文件，内容不会进行落盘，所以管道不占用磁盘空间

拓展 —— 日志

日志简单介绍：

日志类实现的一些函数、宏和结构体介绍：
time、localtime、struct tm、snprintf、可变参数（va_list、va_start、va_end）、vsnprintf
注：可变参数，至少要有一个具体参数

//time —— 返回时间戳
头文件：
	#include <time.h>

函数声明：
	time_t time(time_t *t);

参数：
	t:输出型参数，放的是当前的时间戳

函数返回值：
	1. 成功返回时间戳
	2. 失败返回-1，错误码被设置
注：使用时，参数设为nullptr即可

time使用：
#include <iostream>
#include <time.h>

int main()
{
    time_t t1  = 0;
    time_t t2 = time(&t1);
    std::cout << "t1:" << t1 << " t2:" << t2 << std::endl;
    return 0;
}

//output:
//t1:1710156476 t2:1710156476

//
//localtime 和 struct tm
头文件：
	#include <time.h>

函数声明：
	struct tm *localtime(const time_t *timep);

参数：
	timep:指向要转换成本地时间的时间戳

返回值：
	1. 成功返回结构体指针（struct tm），包含了转换后的本地之间信息。
	2. 失败返回nullptr
		struct tm定义：
		struct tm 
		{
		    int tm_sec;   // 秒，范围为 0-59
		    int tm_min;   // 分，范围为 0-59
		    int tm_hour;  // 时，范围为 0-23
		    int tm_mday;  // 一个月中的日期，范围为 1-31
		    int tm_mon;   // 月份，范围为 0-11
		    int tm_year;  // 年份，从 1900 年开始
		    int tm_wday;  // 一周中的天数，范围为 0-6 (0 表示周日)
		    int tm_yday;  // 一年中的天数，范围为 0-365
		    int tm_isdst; // 夏令时标识符，负数表示不可确定，0 表示不使用夏令时，正数表示使用夏令时
		};
localtime使用：
#include <iostream>
#include <time.h>
#include <cstdio>

int main()
{
    time_t t = time(nullptr);
    struct tm *ctime = localtime(&t);
    printf("%d-%d-%d %d:%d:%d\n", ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
             ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
    return 0;
}

//output:
// 2024-3-11 19:47:31

/
//snprintf
头文件：
	#include <stdio.h>

函数声明：
	int snprintf(char *str, size_t size, const char *format, ...);

参数：
	1. 区别sprintf，snprintf限制输出的字符数
	2. 将可变参数(...)按照format格式化成字符串，然后复制到str中
	3. size：要写入的大小，超过size会被截断，最终写size-1大小，末尾添加'\0'

返回值：
	1. 成功返回想要写入str的长度，而不是实际写入的长度
	2. 失败返回负值

使用：
#include <cstdio>
 
int main()
{
    char buffer[50];
    const char* s = "runoobcom";
 
    int j = snprintf(buffer, 6, "%s\n", s);
 
    printf("string:%s\ncharacter count = %d\n", buffer, j);
 
    return 0;
}

// string:
// runoo
// character count = 10

/
//可变参数va_list、va_start(ap, last_arg)、va_end(ap)、va_arg(ap,type)
头文件：
	#include <stdarg.h>

四个宏：
	1. va_list:实际就是char*类型
	2. va_start:初始化可变参数列表，ap是va_list类型的变量，last_arg是最后一个固定参数的名称（可变参数裂变前一个参数）。目的是为了将ap指向可变参数列表中第一个参数
	3. va_end:结束可变参数裂变访问，ap置为nullptr
	4. va_arg:获取可变参数列表中下一个参数,ap是一个va_list类型的变量，type是下一个参数的类型。返回值是type类型的值，并将ap指向下一个参数

可变参数使用：
int sum(int n, ...)
{
    va_list s;   // va_list <==> char*
    va_start(s, n);
    int sum = 0;
    while (n--)
    {
        sum += va_arg(s, int);
    }
    va_end(s); // s=NULL
    return sum;
}
int main()
{
    int c = sum(4, 1, 2, 3, 4);
    int d = sum(5, 1, 2, 3, 4, 5);
    cout << "c = " << c << ", d = " << d <<endl;
    return 0;
}
//output: c = 10, d = 15

/
//vsnprintf
头文件：
	#include <stdio.h>

函数声明：
	int vsnprintf(char *str, size_t size, const char *format, va_list ap);

参数：
	1. str:用于存储格式化后的字符串
	2. size:字符数组大小
	3. format:类似printf函数中的格式化字符串
	4. ap:va_list类型的参数列表，包含要格式化的数据

返回值：
	1. 成功返回想要写入str的长度，而不是实际写入的长度
	2. 失败返回负值

vsnprintf使用：
#include <cstdio>
#include <stdarg.h>

void my_vsnprintf(const char *format, ...) {
    va_list args;
    va_start(args, format);

    char buffer[100]; 
    int n = vsnprintf(buffer, sizeof(buffer), format, args);

    va_end(args);
    printf("string:%s return val:%d\n", buffer, n);
}

int main() 
{
    my_vsnprintf("Hello, %s Size: %d", "world", 42);
    return 0;
}

//output:
// string:Hello, world Size: 42 return val:21

实现一个简单的日志类：
文件名：log.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <cstdarg>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

// 定义日志等级
#define Info 0
#define Debug 1
#define Waring 2
#define Error 3
#define Fatal 4

// 输出方式
#define Screen 1
#define OneFile 2
#define SortFile 3

#define LOG_MODE 0666
#define SIZE 1024

// 输出到一个文件的文件名   输出到多个文件时，可以加日志等级作为后缀，进行区分
#define LogFile "log.txt"

class Log
{
public:
    Log(int printMethod = Screen, std::string path = "./log/")
        : _printMethod(printMethod), _path(path)
    {}

    // 改变输出方式，使用者设置
    void Enable(int method)
    {
        _printMethod = method;
    }

    // 根据等级转字符串
    std::string LevelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Waring:
            return "Waring";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }

    void PrintLog(int level, const std::string &logtxt)
    {
        switch (_printMethod)
        {
        case Screen:
            std::cout << logtxt << std::endl;
            break;
        case OneFile:
            PrintOneFile(LogFile, logtxt);
            break;
        case SortFile:
            PrintSortFile(level, logtxt);
            break;
        default:
            break;
        }
    }

    // 写在一个文件中
    void PrintOneFile(const std::string &logname, const std::string &logtxt)
    {
        std::string _logname = _path + logname;
        int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, LOG_MODE);
        if (fd < 0)
            return;
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }

	//根据日志等级不同，写在多个文件中
    void PrintSortFile(int level, const std::string &logtxt)
    {
        std::string filename = LogFile;
        filename += '.';
        filename += LevelToString(level);
        PrintOneFile(filename, logtxt);
    }

    // 可变参数
    void operator()(int level, const char *format, ...)
    {
        // 获取时间
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", LevelToString(level).c_str(),
                 ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
                 ctime->tm_hour, ctime->tm_min, ctime->tm_sec);

        va_list s;
        va_start(s, format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);

        char logtxt[SIZE * 2];
        snprintf(logtxt, sizeof(logtxt), "%s %s\n", leftbuffer, rightbuffer);

        // std::cout << logtxt << std::endl;
        PrintLog(level, logtxt);
    }

    ~Log()
    {}

private:
    int _printMethod;
    std::string _path;
};

俩无关进程通信

mkfifo接口介绍：

头文件：
	#include <sys/types.h>
    #include <sys/stat.h>

函数声明：
	int mkfifo(const char *pathname, mode_t mode);

函数参数：
	1. pathname:要创建的所在路径+管道名
	2. mode：所创建管道的权限
	
返回值：
	1. 成功返回0
	2. 失败返回-1，错误码被设置

使用： 实现两个无关的进程间的通信，使用命名管道，同时引用我们上面刚刚实现的日志类。

首先要先看到同一份资源：
comm.hpp

#pragma once
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>

//创建的管道文件名 + 权限
#define FIFO_FILE "./myfifo"
#define MODE 0666
#define MAX_SIZE 1024

//程序退出码都封装在枚举中
enum exit
{
    FIFO_CREAT_ERR = 1,
    FIFO_DESTROY_ERR,
    FIFO_OPEN_ERR,
    FIFO_READ_ERR,
    FIFO_WRITE_ERR
};


//把创建管道和销毁管道，封装成一个类
class InitPipe
{
public:
    //创建管道
    InitPipe()
    {
        int n = mkfifo(FIFO_FILE, MODE);
        if (n == -1)
        {
            perror("mkfifo");
            exit(FIFO_CREAT_ERR);
        }
    }

    // 销毁管道
    ~InitPipe()
    {
        int m = unlink(FIFO_FILE);
        if (m == -1)
        {
            perror("unlink");
            exit(FIFO_DESTROY_ERR);
        }
    }
};

服务端：server.cc

#include "comm.hpp"
#include "log.hpp"

int main()
{
    // 借用命名管道类，实现创建和销毁管道
    InitPipe Init;

	//使用日志类定义对象，并选择输出方式
    Log log;
    log.Enable(OneFile);
    
    log(Info, "already creat pipe success!");
    
    // 打开管道 以读的方式
    int fd = open(FIFO_FILE, O_RDONLY);
    if (fd == -1)
    {
        perror("open");
        log(Fatal, "error string:%s, errno code:%d", strerror(errno), errno);
        exit(FIFO_OPEN_ERR);
    }

	//这里主要是为了测试日志类，下面这四条语句
    log(Info, "server already open fifo_file, error string:%s, errno code:%d", strerror(errno), errno);
    log(Waring, "server already open fifo_file, error string:%s, errno code:%d", strerror(errno), errno);
    log(Fatal, "server already open fifo_file, error string:%s, errno code:%d", strerror(errno), errno);
    log(Debug, "server already open fifo_file, error string:%s, errno code:%d", strerror(errno), errno);

    // 开始通信
    while (true)
    {
        char buffer[MAX_SIZE] = {0};
        int x = read(fd, buffer, sizeof(buffer));
        if (x > 0)
        {
            buffer[x] = 0;
            std::cout << "client say:" << buffer << std::endl;
        }
        else if (x == 0)
        {
            log(Debug, "client quit, server too!error string:%s, errno code:%d", strerror(errno), errno);
            break;
        }
        else
        {
            perror("read");
            exit(FIFO_READ_ERR);
        }
    }

    close(fd);
    return 0;
}

客户端：client.cc

#include "comm.hpp"
#include "log.hpp"

int main()
{
    // 服务端创建好管道，客户端打开即可
    // 打开管道
    int fd = open(FIFO_FILE, O_WRONLY);
    if (fd == -1)
    {
        perror("open");
        exit(FIFO_OPEN_ERR);
    }
    log(Info, "client already open fifo_file!");

    std::string line;
    // 通信
    while (true)
    {
        std::cout << "Please Enter@ ";
        getline(std::cin, line);
        int w = write(fd, line.c_str(), line.size());
        if(w < 0)
        {
            perror("write");
            exit(FIFO_WRITE_ERR);
        }
    }

    close(fd);
    return 0;
}

3. 小结

①管道总结

管道的四种状态：
读写端正常，管道为空，读端阻塞
读写端正常，管道被写满，写端阻塞
读端正常，写端关闭，读端就会读到0，表示读到文件结尾，不会被阻塞
写端正常，读端关闭，OS就会杀掉正在写入的进程，使用13号信号杀掉

管道的特征：
进程间会进行协同：内核会对管道操作进行同步和互斥——保护管道文件的数据安全
管道是面向字节流的

匿名管道和命名管道的区别：
匿名管道由pipe接口创建，并打开，后续要关闭相应的文件描述符。命名管道由mkfifo接口创建，打开要使用open，要决定用读还是写的方式打开
匿名管道只有具有亲缘关系的进程才能进行通信。命名管道，无关的进程间也可以通信
管道只能单向通信
管道是基于文件的，文件的声明周期是随进程的，所以管道的生命周期随进程。（匿名管道的声明周期随进程，命名管道的声明周期要显示的删除）

原子性：
当要写入的数据量小于PIPE_BUF时，Linux保证写入的原子性
当要写入的数据量大于PIPE_BUF时，Linux不再保证写入的原子性

注：
PIPE_BUF——大概意思就是向管道写入的内容小于PIPE_BUF就是原子的，PIPE_BUF的大小是4KB。
原子性： 是一个操作要么完全执行成功，要么完全不执行

②拓展命令和接口

ulimit -a OS对一些重要资源的限制
写代码时最好有一套规范，参数传参规范：
- 输入型参数： const &
- 输出型参数： *
- 输入输出型参数：&
unlink删除文件，不论是管道文件还是普通文件，软链接和硬链接等都可以删除。
gettimeofday也可以获取时间

二、System V

1. 共享内存

共享内存是最快的IPC形式，允许多个进程共享同一块内存区域。进程可以直接读写共享内存中的数据，不再涉及到内核（不需要执行内核的系统调用来传递彼此的数据），也无需进行数据拷贝。

①原理

共享内存看到同一份资源的原理
图解：

上图的内容可以理解为创建共享内存，让进程拿到这块内存。用完还是要和进程地址空间去关联，然后释放共享内存。这些操作只能由OS来做 —— 系统调用
OS中肯定不止一份共享内存，所以OS就要对共享内存进行管理——先描述，再组织（后面对System V总结时，介绍其内核结构体）
共享内存映射到进程地址空间的共享区，并且会把映射的起始虚拟位置返回给上层用户
因为这块内存空间是映射到不同进程的进程地址空间内，可以直接使用（都以为是自己的），通信时不需要更多的拷贝。
共享内存的生命周期是随内核的，需要手动关闭，如果忘记也是内存泄漏

②使用共享内存

接口介绍

1. shmget和ftok： 共享内存的创建

/ftok///
头文件：
	#include <sys/types.h>
	#include <sys/ipc.h>

函数声明：
	key_t ftok(const char *pathname, int proj_id);

参数：
	1. pathname：指向路径（现有，可访问的路径）的字符串
	2. proj_id:自定义整数

返回值：
	1. 成功，返回key_t类型的唯一键值
	2. 失败，返回-1，错误码被设置


/shmget///
头文件：
	#include <sys/ipc.h>
    #include <sys/shm.h>

函数声明：
	int shmget(key_t key, size_t size, int shmflg);

参数：
	1. key:共享内存的内核标识符，通常使用ftok生成。（保证了让不同进程获得同一个共享内存）
	2. size:开辟共享内存的大小（单位字节）
	3. shmflg：创建方式
		IPC_CREAT(单独使用)：没有就创建，有就返回
		IPC_CREAT | IPC_EXIT:有就出错返回,没有就创建。（保证是新创建的共享内存）
		IPC_EXIT：不单独使用
		在最后可以直接给共享内存|一个权限
返回值：
	1. 成功，返回共享内存的标识符
	2. 失败，返回-1，错误码被设置

上述两个接口的介绍：

ftok：
ftok函数本质就是一套算法，将pathname转换成一个唯一的整数值，然后和proj_id再组合，生成唯一键值，用于创建、获取IPC对象的标识符。
key能让不同进程进行唯一性标识，第一个进程通过key（这个唯一键值）创建共享内存，第二个之后的进程，只要拿着同一个key就可以和第一个进程看到同一个共享内存
key类似路径（具有唯一性）
注：生成的值可能存在冲突的风险。

shmget：
通过ftok接口获取的key，创建一个新的共享内存或者获取一个已存在的共享内存的shmid
shmid就是shmget的返回值，其是为了用户接下来控制共享内存。

上述两个函数的返回值对比：shmid和key

测试shmget和ftok接口：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <iostream>
#include <string>
#include <cerrno>
#include <cstdio>

// 为了获取key值设置的两个参数 -> ftok
const std::string pathname = "/home/kpl_2023";
const int proj_id = 0x32231;

// 开辟共享内存的大小
// 共享内存的大小建议4096的整数倍
#define SIZE 4096

// 创建共享内存的权限.实际权限可能在OS内核中被限制和管理
#define SHM_MODE 0666

int main()
{

    // 获取key，用来创建共享内存
    key_t key = ftok(pathname.c_str(), proj_id);   // key_t 实际就是 int
    if (key < 0)
    {
        perror("ftok");
        exit(errno);
    }
    printf("get key success! key:0x%x\n", key);
    
    // 创建共享内存
    int shmid = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | SHM_MODE); //权限直接在最后的位置 |上即可
    if (shmid < 0)
    {
        perror("shmget");
        exit(errno);
    }
    printf("Create shm success! shmid:%d\n", shmid);

    return 0;
}

注：

查看系统中共享内存的命令
ipcs -m
删除系统中共享内存的命令
ipcrm -m [shmid]

测试结果：
运行结果

2. shmat和shmdt： 共享内存操作

/shmat///
头文件：
	#include <sys/types.h>
	#include <sys/shm.h>

函数声明：
	void *shmat(int shmid, const void *shmaddr, int shmflg);

参数：
	1. shmid：共享内存标识（shmget成功的返回值）
	2. shmaddr：指定连接的地址（一般设置成nullptr，由OS自己分配。如果设置了，并且该被挂接的地址空间位置又被占用，返回-1）
	3. shmflg：进程映射共享内存的方式，一般设置成0。两个可能取值：
		SHM_RND:这可以提高内存访问的效率。
		SHM_RDONLY:进程只能读取共享内存中的数据，而不能修改数据。
		shmaddr不为nullptr且shmflg设置SHM_RND标记，则连接地址会自动向下调整SHMLBA的整数倍。

返回值：
	1. 成功，返回共享内存映射到进程地址空间的地址
	2. 失败，返回-1，错误码被设置

/shmdt///
头文件：
	#include <sys/types.h>
	#include <sys/shm.h>

函数声明：
	int shmdt(const void *shmaddr);

参数：
	shmaddr：共享内存映射到进程地址空间的地址

返回值：
	1. 成功返回0
	2. 失败返回-1，错误码被设置

上述两个接口的作用

shmat：将共享内存段连接到进程地址空间
shadt：将共享内存段与当前进程脱离

3. shmctl： 共享内存控制

头文件：
	#include <sys/ipc.h>
    #include <sys/shm.h>

函数声明：
	int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数：
	1. shmid:共享内存标识（shmget成功的返回值）
	2. cmd:要控制的动作：IPC_STAT、IPC_SET、IPC_RMID
		IPC_STAT:获取共享内存的状态信息，放在buf中
		IPC_SET:在进程有足够的权限下，把共享内存当前的管理值设置为shmid_ds数据结构中给出的值
		IPC_RMID:删除共享内存段
	3. buf:根据选项不同可以是输入型参数也可以是输出型参数，指向一个保存着共享内存的模式状态和访问权限的数据结构

返回值：
	1. 成功，返回0
	2. 失败返回-1，错误码被设置

可以删除共享内存、获取共享内存的信息

使用

两个进程间的通信，使用共享内存

首先创建同一份资源：
comm.hpp

#ifndef __COMM_HPP__
#define __COMM_HPP__

#include <iostream>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>


// 为了获取key值
const std::string pathname = "/home/kpl_2023";
const int proj_id = 0x32231;

// 开辟共享内存的大小
// 共享内存的大小简易4096的整数倍
#define SIZE 4096

// 创建共享内存的权限
#define SHM_MODE 0666

enum exit
{
    SHM_FTOK_ERR = 1,
    SHM_SHMGET_ERR,
    SHM_SHMAT_ERR,
    SHM_SHMDT_ERR,
    SHM_SHMCTL_IPC_RMID_ERR,

    FIFO_CREATE_ERR = 10,
    FIFO_DELETE_ERR,
    FIFO_OPEN_ERR
};

// 获取key
key_t GetKey()
{
    key_t key = ftok(pathname.c_str(), proj_id); // key_t 实际就是 int
    if (key < 0)
    {
        perror("ftok");
        exit(SHM_FTOK_ERR);
    }
    return key;
}

// 获取shmid
int GetShareMemHelper(int flag)
{
    key_t key = GetKey();
    int shmid = shmget(key, SIZE, flag);
    if (shmid < 0)
    {
        perror("shmget");
        exit(SHM_SHMGET_ERR);
    }

    return shmid;
}

// 给服务端的接口
int CreatShm()
{
    return GetShareMemHelper(IPC_CREAT | IPC_EXCL | SHM_MODE);
}

// 给客户端的接口
int GetShm()
{
    return GetShareMemHelper(IPC_CREAT);
}

#endif

进程1：
share_mema.cc

#include "comm.hpp"

int main()
{
    //创建共享内存
    int shmid = CreatShm();

    // shm挂接到进程地址空间 ->  返回的时挂接在进程地址空间处的地址
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (*shmaddr < 0)
    {
        perror("shamt");
        exit(SHM_SHMAT_ERR);
    }


    // OS提供的结构体
    struct shmid_ds shmds;
    // 通信
    while (true)
    {
        std::cout << "client say@ " << shmaddr << std::endl; // 直接访问地址即可
        sleep(1);

        shmctl(shmid, IPC_STAT, &shmds);
        std::cout << "shm size: " << shmds.shm_segsz << std::endl;
        std::cout << "shm nattch: " << shmds.shm_nattch << std::endl;
        printf("shm key: 0x%x\n", shmds.shm_perm.__key);
    }

    // 去挂接
    int shmdtid = shmdt(shmaddr);
    if (shmdtid < 0)
    {
        perror("shmdt");
        exit(SHM_SHMDT_ERR);
    }
    // 删除共享内存
    int rmid = shmctl(shmid, IPC_RMID, nullptr);
    if (rmid < 0)
    {
        perror("shmctl::IPC_RMID");
        exit(SHM_SHMCTL_IPC_RMID_ERR);
    }

    return 0;
}

进程2：
share_memb.cc

#include "comm.hpp"

// 客户端不能先运行，因为我们没有让它创建共享内存，所以没有设置权限，
//  所以shmat挂接不上会出现段错误

int main()
{
    //获取共享内存shmid
    int shmid = GetShm();

    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (*shmaddr < 0)
    {
        perror("shamt");
        exit(SHM_SHMAT_ERR);
    }

    std::cout << "shmat success !!!" << std::endl;

    // 通信
    while (true)
    {
        std::cout << "Please Enter@ ";
        fgets(shmaddr, SIZE, stdin);
    }

    // 去挂接
    int shmdtid = shmdt(shmaddr);
    if (shmdtid < 0)
    {
        perror("shmdt");
        exit(SHM_SHMDT_ERR);
    }
    return 0;
}

③小结

共享内存没有同步互斥之类的保护机制
共享内存是所有进程间通信中，速度最快的，拷贝少
共享内存内部的数据，由用户自己维护

2. 消息队列

消息队列是一种消息传递机制。消息队列可以实现进程之间的异步通信。
允许不同的进程，向内核中发送带类型的数据块，接收者进程接收的数据块可以有不同类型。
看到同一份资源：不同进程看到同一个队列（内核中）
消息的生命周期是随内核的，需要手动删除，如果忘记也是内存泄漏

原理：

内核中，OS管理着消息队列，进程（用户）想要使用这块资源，OS一定会提供系统调用给用户。

3. 信号量

信号量是一种用于进程同步和互斥的机制，可以用来解决进程之间的竞争条件和临界区问题。
信号量的生命周期是随内核的，需要手动删除，如果忘记也是内存泄漏

信号量是进程间通信的原因：

通信不仅仅是数据的交互，互相协同也是
信号量可以被所有通信进程看到

①引入

数据不一致问题： A、B进程看到同一份资源（共享资源），如果不加保护，会导致数据不一致问题。eg:共享内存
互斥： 任何时刻只允许一个执行流访问共享资源。加锁——互斥访问
临界资源： 共享资源，任何时刻只允许一个执行流访问——一般是内存空间
临界区： 访问临界资源的代码

②原理

1. 理解信号量

信号量的本质就是一把计数器（描述临界资源中资源数量的多少）

信号量解释：

所以申请计数器成功，那就代表还有资源，具有访问资源的权限
申请计数器资源，并不表示我（执行流）访问要的资源了，而是对资源的预定机制
计数器可以有效保证进入这一份资源（共享资源）的执行流数量

所以每个执行流，想要访问共享资源的一部分时，不能直接访问，而是要先申请计数器资源，而这个计数器就是信号量

2. 二元信号量（锁）

当我们把上面那个临界资源当成一个整体，那么计数器cnt就是1。这就只能一个执行流访问，当再来执行流时计数器是0，就不能再有执行流访问了——互斥
所以，我们把值只能为1、0两态的计数器叫做二元信号量——本质就是一个锁

3. 共享资源——信号量：

要访问临界资源，就得先申请信号量（计数器）资源，它保护着临界资源。但是计数器也被很多执行流共享，所以也是共享资源，那也得被保护。
申请计数器本质就是对计数器减一，但是虽然在C语言上计数器减一是一条语句，但是转成汇编就是三条（也可能多条）汇编。进程在运行时随时被切换，所以这减一操作是不安全的
所以为了保护这个信号量资源，在底层做了工作
P操作：申请信号量，本质是对计数器减一
V操作：释放资源，释放信号量，本质是对计数器加一

结论：信号量的PV操作都是原子的——要么不做，要么做完

4. 总结

1. 共享内存、消息队列和信号量的接口：

观察发现三者的接口相似，原因：System V标准规定
所以：

消息队列
查看系统中的消息队列的命令
ipcs -q
删除系统中消息队列的命令
ipcrm -q [msgid]

信号量
查看系统中信号量的命令
ipcs -s
删除系统中信号量的命令
ipcs -s [semid]

IPC在内核中的数据结构设计：

kpl_20

关注

16
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
进程间通信——IPC（Linux）

匿名管道脏数据 pipe 进程池原子性 PIPE_BUF命名管道mkfifo ulimit -a 参数传参规范 unlink日志time localtime struct tm snprintf 可变参数(va_list va_start va_end) vsnprintfSystem V共享内存shmget ftok ipcs ipcrm shmat shmdt shmctl消息队列信号量数据不一致问题互斥临界资源临界区二元信号量对资源的预定机制计数器 IPC
复制链接

扫一扫