Linux知识点 -- 进程间通信（二）-Toy模板网

这篇具有很好参考价值的文章主要介绍了Linux知识点 -- 进程间通信（二）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Linux知识点 – 进程间通信（二）

一、System V共享内存

1.原理

Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
先在内存中申请空间，然后将这段空间映射到不同进程的地址空间中，这就叫做共享内存；
一般都是映射在进程的堆栈之间的共享区；
共享内存不属于任何一个进程，它属于操作系统；
操作系统对共享内存的管理，是先描述再组织，先通过内核数据结构描述共享内存的属性信息，再将它们组织起来；
共享内存 = 共享内存块 + 对应的共享内存的内核数据结构；
共享区属于用户空间，不用经过系统调用，直接可以访问；
双方进程如果要通信，直接进行内存级的读写即可；
之前的管道是一种文件。是OS中的一种数据结构，所以用户无权直接访问，需要进行系统调用；

2.申请共享内存

Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
shmget接口能够申请共享内存；

参数：
key：通信双方的进程，通过key值来保证是通信的双方来创建的共享内存，相当于一个验证值，需要在系统内是唯一的，通信双方使用同一个key；
size：内存大小，一般是页（4byte）的整数倍；
shmflag：有两个选项：IPC_CREAT和IPC_EXCL；
IPC_CREAT能单独出现，代表如果共享内存已存在，则获取之；如果不存在，就创建之，并返回；
IPC_EXCL必须和IPC_CREAT组合使用，代表如果共享内存不存在，就创建之，并返回；如果已存在，出错并返回；
0就代表IPC_CREAT；
返回值：成功会返回共享内存id，失败返回-1；

ftok函数：生成唯一的key
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维

参数：
==pathname：==文件路径，一定要保证用户有权限；
==id：==项目id，随便给，一般是0 - 255；
返回值：成功，返回key值；失败，返回-1；
ftok会拿路径文件的inode，和id形成一个唯一的key，生成结果是有可能重复的；

3.System V共享内存的使用

Makefile：

.PHONY:all
all:shmClient shmServer

shmServer:shmServer.cc
	g++ -o $@ $^ -std=c++11 
shmClient:shmClient.cc
	g++ -o $@ $^ -std=c++11 

.PHONY:clean
claen:
	rm -f shmServer shmClient

Log.hpp

#ifndef _LOG_H_
#define _LOG_H_

#include<iostream>
#include<ctime>

#define DeBug   0
#define Notice  1
#define Waring  2
#define Error   3

const std::string msg[] = {
    "DeBug",
    "Notice",
    "Waring",
    "Error"
};

std::ostream &Log(std::string message, int level)
{
    std::cout << " | " << (unsigned)time(nullptr) << " | " << msg[level] << " | " << message;
    return std::cout;
}
#endif

comm.hpp

#ifndef _COMM_H_
#define _COMM_H_

#include<iostream>
#include<cstdio>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<cassert>
#include "Log.hpp"

using namespace std;

#define PATH_NAME "/usr/lmx" //路径，一定保证有权限
#define PROJ_ID 0X66   
#define SHM_SIZE 4096 //共享内存大小，最好是页（4byte）的整数倍

#endif

shmServer.cc
#include “comm.hpp”

string TransToHex(key_t k)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), “0x%x”, k);
return buffer;
}

int main()
{
// 1.创建公共的key值
key_t key = ftok(PATH_NAME, PROJ_ID);
if (key == -1)
{
perror(“ftok”);
exit(1);
}

Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;

// 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者
int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
if (shmid == -1)
{
    perror("shmget");
    exit(2);
}
Log("shm creat done", DeBug) << "shmid : " << shmid << endl;

//3.将指定的共享内存，挂接到自己的地址空间
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
Log("attach shm done", DeBug) << "shmid : " << shmid << endl;

//这里就是通信逻辑了
//将共享内存看作一个大字符串
//shmaddr就是这个字符串的起始地址
for(;;)
{
    printf("%s\n", shmaddr);//不断打印这个字符串的内容
    if(strcmp(shmaddr, "quit") == 0)
    {
        break;
    }
    sleep(1);
}

//4.将指定的共享内存，从自己的地址空间中去关联
int n = shmdt(shmaddr);
if(n == -1)
{
    perror("shmdt");
    exit(3);
}
Log("detach shm done", DeBug) << "shmid : " << shmid << endl;

//5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
n = shmctl(shmid, IPC_RMID, nullptr);
if(n == -1)
{
    perror("shmctl");
    exit(4);
}
Log("delete shm done", DeBug) << "shmid : " << shmid << endl;

return 0;

}

注意：
（1）
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
要保证创建出唯一的key；*
（2）

创建全新的共享内存，0666代表共享内存的权限；
共享内存的大小最好是页的整数倍，否则会造成空间浪费，多开空间，但是没有权限访问；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
第二次创建的时候，提示共享内存已存在；

（3）ipcs -m：查看共享内存信息；

ipcrm -m shmid：删除共享内存（不能用key删除）
共享内存的生命周期随内核;
与文件不一样，文件的生命周期，如果进程退出，没有其他进程再关联这个文件，那么就会被回收;
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维

perms属性就是共享内存的权限，

（4）因此，当进程结束后，共享内存还存在，我们继续要删除它，使用系统接口：
shmctl：删除共享内存
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维

（5）nattch属性是挂接的共享内存个数，共享内存创建好之后，需要挂接在自己的进程地址空间；
shmat：挂接共享内存

参数：
shmid：共享内存id
shmaddr：挂接虚拟地址，直接设为0，让os挂接
shmflg：挂接方式
返回值：成功返回共享内存addr虚拟地址，失败返回-1
使用：
将返回值作为共享内存的起始地址；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
shmdt：去关联

参数：
shmaddr：共享内存地址
返回值：成功返回0，失败返回-1

shmClient.cc

#include "comm.hpp"

int main()
{
    // 客户端也获取key
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key < 0)
    {
        Log("creat key failed", Error) << "client key : " << key << endl;
        exit(1);
    }
    Log("creat key done", DeBug) << "client key : " << key << endl;

    // 获取共享内存
    int shmid = shmget(key, SHM_SIZE, 0);
    if (shmid == -1)
    {
        Log("creat shm failed", Error) << "client key : " << key << endl;
        exit(2);
    }
    Log("creat shm done", DeBug) << "client key : " << key << endl;


    // 挂接共享内存
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (shmaddr == nullptr)
    {
        Log("attach shm failed", Error) << "client key : " << key << endl;
    }
    Log("attach shm done", DeBug) << "client key : " << key << endl;
    
    // 使用
    //client将共享内存看作一个char类型的buffer
    //客户端从键盘读取消息，直接读到共享内存中
    while (true)
    {
        ssize_t s = read(0, shmaddr, SHM_SIZE - 1);
        if(s > 0)
        {
            shmaddr[s - 1] = 0;
            if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出
            {
                break;
            }
        }
    }
    
    // char a = 'a';
    // for(; a <= 'z'; a++)
    // {
    //     //每一次都向shmaddr（共享内存的起始地址）写入
    //     snprintf(shmaddr, SHM_SIZE - 1, 
    //             "hello server, 我是其他进程，我的pid： %d, inc: %c\n", 
    //             getpid(), a);
    //     sleep(2);
    // }

    // 去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "client key : " << key << endl;

    // client不需要删除shm

    return 0;
}

注意：
（1）共享内存的使用，直接将共享内存看作一个char类型的buffer，直接向里面写入数据
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
从stdin中键盘读取消息，直接读取到shmaddr这个地址，即共享内存的起始地址；

运行结果：
服务端：
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
客户端：

注：
（1）只要是通信双方使用shm，一方直接向共享内存中写入数据，另一方就可以立马看到对方写入的数据；共享内存是所有进程间通信中最快的，不需要过多的拷贝；
（2）管道通信中，一次通信需要多次拷贝，用户从键盘输入数据到缓冲区是一次拷贝，从缓冲区向管道文件写入数据又是一次拷贝，从管道文件向缓冲区读取数据是一次拷贝，从缓冲区将数据打印又是一次拷贝；

（3）共享内存只需要两次拷贝，从键盘输入的数据直接写入shm，这是一次拷贝，直接将shm的数据打印出来，这是第二次拷贝；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维

4.为共享内存添加访问控制

从上面的结果可以看出，即便是客户端还没有挂接共享内存，服务端就已经开始不停读取数据了，这就表明共享内存是不带访问控制的，会带来一定的并发问题；
然而，管道是自带访问控制的，我们可以利用管道通信来为共享内存添加访问控制；
comm.hpp

#ifndef _COMM_H_
#define _COMM_H_

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cassert>
#include <cstring>
#include <sys/stat.h>
#include <fcntl.h>
#include "Log.hpp"

using namespace std;

#define PATH_NAME "/home/lmx" // 路径，一定保证有权限
#define PROJ_ID 0X66
#define SHM_SIZE 4096 // 共享内存大小，最好是页（4byte）的整数倍

#define FIFO_NAME "./fifo"

class Init
{
public:
    Init()
    {
        umask(0);
        int n = mkfifo(FIFO_NAME, 0666);
        assert(n == 0);
        (void)n;
        Log("creat fifo succsee", Notice) << "\n";
    }

    ~Init()
    {
        unlink(FIFO_NAME);
        Log("remove fifo succsee", Notice) << "\n";
    }
};


#define READ O_RDONLY
#define WRITE O_WRONLY

int OpenFIFO(std::string pathname, int flags)
{
    int fd = open(pathname.c_str(), flags);
    assert(fd >= 0);
    return fd;
}

void Wait(int fd)
{
    Log("waiting...", Notice) << "\n";
    uint32_t temp = 0;
    ssize_t s = read(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
}

void Signal(int fd)
{
    uint32_t temp = 1;
    ssize_t s = write(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
    Log("aweaking...", Notice) << "\n";
}

void CloseFIFO(int fd)
{
    close(fd);
}

#endif

注：
（1）创建了一个类，类的构造函数有创建管道文件，一旦类实例化出对象，调用构造函数，就能够创建一个管道文件，后面就是对管道文件的读写控制了；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
shmServer.cc

#include "comm.hpp"

string TransToHex(key_t k)
{
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "0x%x", k);
    return buffer;
}

int main()
{
    Init init;
    // 对应的程序在加载的时候，会自动构建全局变量，就要调用该类构造函数 -- 创建管道文件
    // 程序退出的时候，全局变量会被析构，会自动删除管道文件

    // 1.创建公共的key值
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key == -1)
    {
        perror("ftok");
        exit(1);
    }

    Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;

    // 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者
    int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid == -1)
    {
        perror("shmget");
        exit(2);
    }
    Log("shm creat done", DeBug) << "shmid : " << shmid << endl;

    // 3.将指定的共享内存，挂接到自己的地址空间
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    Log("attach shm done", DeBug) << "shmid : " << shmid << endl;

    // 这里就是通信逻辑了
    // 将共享内存看作一个大字符串
    // shmaddr就是这个字符串的起始地址

    //使用管道进行访问控制
    int fd = OpenFIFO(FIFO_NAME, READ);

    for (;;)
    {
        Wait(fd);//等待客户端响应，
                    //使用管道文件的访问控制，如果客户端没有向管道内写入数据，那么该进程会一直阻塞
        printf("%s\n", shmaddr); // 不断打印这个字符串的内容
        if (strcmp(shmaddr, "quit") == 0)
        {
            break;
        }
        sleep(1);
    }

    CloseFIFO(fd);

    // 4.将指定的共享内存，从自己的地址空间中去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "shmid : " << shmid << endl;

    // 5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    n = shmctl(shmid, IPC_RMID, nullptr);
    if (n == -1)
    {
        perror("shmctl");
        exit(4);
    }
    Log("delete shm done", DeBug) << "shmid : " << shmid << endl;

    return 0;
}

注：
（1）在服务端先创建一个管道文件
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
（2）在读取共享内存中的数据前，先读取管道数据，看客户端是否响应；

shmClient.cc

#include "comm.hpp"

int main()
{
    // 客户端也获取key
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key < 0)
    {
        Log("creat key failed", Error) << "client key : " << key << endl;
        exit(1);
    }
    Log("creat key done", DeBug) << "client key : " << key << endl;

    // 获取共享内存
    int shmid = shmget(key, SHM_SIZE, 0);
    if (shmid == -1)
    {
        Log("creat shm failed", Error) << "client key : " << key << endl;
        exit(2);
    }
    Log("creat shm done", DeBug) << "client key : " << key << endl;


    // 挂接共享内存
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (shmaddr == nullptr)
    {
        Log("attach shm failed", Error) << "client key : " << key << endl;
    }
    Log("attach shm done", DeBug) << "client key : " << key << endl;
    
    // 使用
    //client将共享内存看作一个char类型的buffer
    //客户端从键盘读取消息，直接读到共享内存中

    //使用管道进行访问控制
    int fd = OpenFIFO(FIFO_NAME, WRITE);

    while (true)
    {
        ssize_t s = read(0, shmaddr, SHM_SIZE - 1);
        if(s > 0)
        {
            shmaddr[s - 1] = 0;
            Signal(fd);//向管道写入数据
            if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出
            {
                break;
            }
        }
    }

    CloseFIFO(fd);
    
    // 去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "client key : " << key << endl;

    // client不需要删除shm

    return 0;
}

注：
（1）在向共享内存写入数据前，先向管道写入信号，表明客户端准备写入数据，唤醒服务端：
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维

运行结果：
当运行服务端，但是客户端未响应时，服务端会等待客户端响应，进程阻塞；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维
当客户端响应时，服务端会被唤醒，读取共享内存中的数据：

退出：

二、信号量（概念理解）

1.概念

基于对共享内存的理解：
为了让进程间通信，让不同的进程之间，看到同一份资源，我们之前讲的所有的进程间通信都是基于这种方式；
而让不同的进程看到同一份资源，比如共享内存，也带来了一些时序问题，会造成数据的不一致
概念
（1）临界资源：多个进程（执行流）看到的公共的一份资源；
（2）临界区：自己的进程，访问临界资源的代码；
（3）互斥：为了更好的进行临界区的维护，可以让多执行流在任何时刻，都只能有一个进程进入临界区；
（4）原子性：要么不做，要么做完，没有中间状态；

2.信号量

我们平常看电影前，会先买票，电影院中的座位就相当于资源，当你买了票，这个座位就真正属于你，买票的本质就是对座位的预定机制；
对于进程来说，访问临界资源中的一部分，不能让进程直接去使用临界资源，需要先申请信号量；
信号量的本质是一个计数器；

申请信号量：
（1）申请信号量的本质，就是让信号量技术器 - -；
（2）申请信号量成功，临界资源内部，一定给进程预留了需要的资源，申请信号量的本质就是对临界资源的一种预定机制；
释放信号量：
释放信号量就是将计数器++；

如果将信号量计数器设为全局变量（整数n，存放在共享内存），让多个进程看到同一个全局变量，大家都能够进行信号量的申请，这样是不行的；
因为CPU在执行n++这个指令的时候，其实执行了三条语句：
（1）将内存中的数据加载到CPU内的寄存器（读指令）；
（2）n–（执行指令）；
（3）将CPU修改完毕的值再写入内存（写指令）；
而执行流在执行的时候，在任何时刻都是能被切换的；
例如：
如果信号量刚开始是5，client在申请信号量的时候，第一步就被切换了，寄存器里的数据保存为上下文数据，
由server申请信号量，如果server将信号量减到2了，此时server被切换，client回来
client回来的时候就会将上下文数据恢复，将信号量恢复为5，再申请信号量，这时信号量就变为了4；

寄存器只有一套，被所有执行流共享，但是寄存器内的数据，属于每一个执行流，属于该执行流的上下文数据；
这样设计，会导致信号量是不安全的；
因此，申请和释放信号量这两个操作，必须是原子的；
Linux知识点 -- 进程间通信（二）,Linux,linux,chrome,运维文章来源地址https://www.toymoban.com/news/detail-631405.html