Linux知识点 -- 进程间通信(二)

Linux知识点 – 进程间通信(二)

文章目录

  • Linux知识点 -- 进程间通信(二)
  • 一、System V共享内存
    • 1.原理
    • 2.申请共享内存
    • 3.System V共享内存的使用
    • 4.为共享内存添加访问控制
  • 二、信号量(概念理解)
    • 1.概念
    • 2.信号量


一、System V共享内存

1.原理

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

2.申请共享内存

Linux知识点 -- 进程间通信(二)_第2张图片
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知识点 -- 进程间通信(二)_第3张图片

  • 参数:
    ==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
#include

#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
#include
#include
#include
#include
#include
#include
#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知识点 -- 进程间通信(二)_第4张图片
要保证创建出唯一的key;*
(2)
Linux知识点 -- 进程间通信(二)_第5张图片
创建全新的共享内存,0666代表共享内存的权限;
共享内存的大小最好是页的整数倍,否则会造成空间浪费,多开空间,但是没有权限访问;
在这里插入图片描述
第二次创建的时候,提示共享内存已存在;
Linux知识点 -- 进程间通信(二)_第6张图片
(3)ipcs -m:查看共享内存信息;
Linux知识点 -- 进程间通信(二)_第7张图片
ipcrm -m shmid:删除共享内存(不能用key删除)
共享内存的生命周期随内核;
与文件不一样,文件的生命周期,如果进程退出,没有其他进程再关联这个文件,那么就会被回收;

在这里插入图片描述
在这里插入图片描述
perms属性就是共享内存的权限,

(4)因此,当进程结束后,共享内存还存在,我们继续要删除它,使用系统接口:
shmctl:删除共享内存
Linux知识点 -- 进程间通信(二)_第8张图片
在这里插入图片描述
(5)nattch属性是挂接的共享内存个数,共享内存创建好之后,需要挂接在自己的进程地址空间;
shmat:挂接共享内存
Linux知识点 -- 进程间通信(二)_第9张图片
参数:
shmid:共享内存id
shmaddr:挂接虚拟地址,直接设为0,让os挂接
shmflg:挂接方式
返回值:成功返回共享内存addr虚拟地址,失败返回-1

使用:
将返回值作为共享内存的起始地址;
在这里插入图片描述
shmdt:去关联
Linux知识点 -- 进程间通信(二)_第10张图片
参数:
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知识点 -- 进程间通信(二)_第11张图片
从stdin中键盘读取消息,直接读取到shmaddr这个地址,即共享内存的起始地址;

运行结果:
服务端:
Linux知识点 -- 进程间通信(二)_第12张图片
客户端:
Linux知识点 -- 进程间通信(二)_第13张图片

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

    Linux知识点 -- 进程间通信(二)_第14张图片

(3)共享内存只需要两次拷贝,从键盘输入的数据直接写入shm,这是一次拷贝,直接将shm的数据打印出来,这是第二次拷贝;
Linux知识点 -- 进程间通信(二)_第15张图片

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

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

#ifndef _COMM_H_
#define _COMM_H_

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#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知识点 -- 进程间通信(二)_第16张图片
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知识点 -- 进程间通信(二)_第17张图片
(2)在读取共享内存中的数据前,先读取管道数据,看客户端是否响应;
Linux知识点 -- 进程间通信(二)_第18张图片
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知识点 -- 进程间通信(二)_第19张图片

运行结果:
当运行服务端,但是客户端未响应时,服务端会等待客户端响应,进程阻塞;
在这里插入图片描述
当客户端响应时,服务端会被唤醒,读取共享内存中的数据:
Linux知识点 -- 进程间通信(二)_第20张图片
退出:
Linux知识点 -- 进程间通信(二)_第21张图片

二、信号量(概念理解)

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知识点 -- 进程间通信(二)_第22张图片

你可能感兴趣的:(Linux,linux,chrome,运维)