【Linux】进程通信

蔚落 2024-03-16 15:19 43阅读 0赞

**目录**

【1】进程通信

【1.1】什么是进程通信

【1.2】如何进行进程通信

【2】管道

【2.1】什么是管道

【2.2】匿名管道

【2.2.1】读写特征

【2.2.2】管道特征

【2.2.2】站在文件描述符角度深度理解管道

【2.2.3】站在内核角度管道本质

【2.2.4】基于匿名对象的进程池

【2.3】命名管道

【2.3.1】通过命令行创建命名管道

【2.3.2】通过程序中创建命名管道

【3】system V内存共享

【2.1】共享内存原理

【3.2】共享内存的概念

【3.3】共享内存数据结构

【3.4】使用shell查看共享内存

【3.5】使用shell删除共享内存

【3.6】共享内存函数

【3.6.1】shmget函数

【3.6.1】shmat函数

【3.6.1】shmdt函数

【3.6.1】shmctl函数

【3.7】代码实现共享内存

【4】system V消息队列

【4.1】msgget函数

【4.2】msgctl函数

【4.3】msgsnd函数

【4.4】msgrcv函数

【5】system V信号量

【5.1】semget函数

【5.2】semctl函数

【5.3】semop函数

【5.4】semtimedop函数

--------------------

## 【1】进程通信 ##

### 【1.1】什么是进程通信 ###

首先，进程是具有独立性的，有时候需要多进程协同的，**比如：cat file | grep ’Hello‘**，进程通信就是多进程协同，完成某种任务，进程间需要通信，通信的成本一定是不低！

**通讯的本质问题：**OS需要直接或者间接给通信双方的进程提供“内存空间”，需要通信的进程，必须看到一份公共的资源！

**不同的通讯类型：**本质上就是上面所说的资源，是OS中的哪一个模块提供的！

**通信的成本一定是不低：**由于进程具有独立性的特性，需要先让不同的进程看到同一份资源，然后在进行通讯。

通信的目的包括：

*  **数据传输：**一个进程需要将它的数据发送给另一个进程。
 *  **资源共享：**多个进程之间共享同样的资源。
 *  **通知事件：**一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
 *  **进程控制：**有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

### 【1.2】如何进行进程通信 ###

*  **管道**

依托于文件系统，**匿名管道、pipe命名管道。**

*  **System V进程间通信**

聚焦在本地通讯，**System V 消息队列、System V 共享内存、System V 信号量。**

*  **POSIX进程间通信**

让通信过程可以跨主机，**消息队列、共享内存、信号量、互斥量、条件变量、读写锁。**

## 【2】管道 ##

### 【2.1】什么是管道 ###

管道是Unix中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的一个数据流称为一个**“管道”。**

![98bef77e428d430e9e896473166aa02c.png][]

### 【2.2】匿名管道 ###

![adf3a989e1894b4faa7ee7a2176f9b2b.png][]

#include <unistd.h>
    功能:
        创建一无名管道
    原型:
    int pipe(int fd[2]);
    参数:
        fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
    返回值:
        成功返回0，失败返回错误代码

**实例代码：**从键盘读取数据，写入管道，读取管道，写到屏幕。

![a469dc9e3cb54a89afbcb49d7c26da2d.png][]

#### 【2.2.1】读写特征 ####

*  **当没有数据可读时：**
    
     *  O\_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
     *  O\_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
 *  **当管道满的时候：**
    
     *  O\_NONBLOCK disable： write调用阻塞，直到有进程读走数据。
     *  O\_NONBLOCK enable：调用返回-1，errno值为EAGAIN。
 *  如果所有管道写端对应的文件描述符被关闭，则read返回0。
 *  如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出。
 *  当要写入的数据量不大于PIPE\_BUF时，linux将保证写入的原子性。
 *  当要写入的数据量大于PIPE\_BUF时，linux将不再保证写入的原子性。

*  **读慢 - 写快**

#include <iostream>
    #include <string.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    using namespace std;
    
    // 管道实例：目的是->父进程读取，子进程写入.
    int main() {
        // 第一步：创建管道文件，打开读写端.
        int fds[2] = {0};
        int ret = pipe(fds);
        assert(ret == 0);
        // 系统文件描述符0，1，2 -> n只能是3，4
        // [0]：读取，嘴巴，
        // [1]：写入，钢笔，
        cout << "fds[0]: " << fds[0] << endl;
        cout << "fds[1]: " << fds[1] << endl; 
    
        // 第二步：创建子进程.
        pid_t id = fork();
        assert(id >= 0);
        if(id == 0 ) {
            // 子进程关闭读
            close(fds[0]);
            // 子进程执行写入
            const char* str = "我是子进程，我正在给你发消息！";
            int count = 0;
            while(true) {
                char buffer[1024];
                snprintf(buffer, sizeof(buffer), "child->parent say: %s[%d][%d]", str, ++count, getpid());
                // 向特定的文件描述中写入数据
                // 如果写端写满的时候，在写端会阻塞，等待对方进行读取！
                write(fds[1], buffer, strlen(buffer));
                cout << count << endl;
            }
    
            // 子进程通讯代码.
            close(fds[1]);
            exit(0);
        }
    
    
        // 父进程关闭写入
        close(fds[1]);
        // 父进程执行读取
        while(true) {
            char buffer[1024];
            // 如果管道中没有数据，读端在读，默认回直接阻塞当前正在读取的进程！
            sleep(10);
            ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
            if(s > 0) {
                buffer[s] = '\0';
            }
            cout << "Get Message# " << buffer << " | My pid: " << getpid() << endl;
        }
    
        // 父进程等待子进程结束代码.
        ret = waitpid(id, nullptr, 0);
        assert(ret == id);
        close(fds[0]);
        return 0;
    }
    
    // 执行结果：
    [shaxiang@VM-8-14-centos pipe]$ ./myPipe 
    fds[0]: 3
    fds[1]: 4
    1
    2
    .....
    .....
    848
    849
    850
    Get Message# child->parent say: 我是子进程，我正在给你发消息！[1][11544]child->parent say: 我是子进程，我正在给你发消息！[2][11544]child->parent say: 我是子进程，我正在给你发消息！[3][11544]child->parent say: 我是子进程，我正在给你发消息！[4][11544]child->parent say: 我是子进程，我正在给你发消息！[5][11544]child->parent say: 我是子进程，我正在给你发消息！[6][11544]child->parent say: 我是子进程，我正在给你发消息！[7][11544]child->parent say: 我是子进程，我正在给你发消息！[8][11544]child->parent say: 我是子进程，我正在给你发消息！[9][11544]child->parent say: 我是子进程，我正在给你发消息！[10][11544]child->parent say: 我是子进程，我正在给你发消息！[11][11544]child->parent say: 我是子进程，我正在给你发消息！[12][11544]child->parent say: 我是子进程，我正在给你发消息！[13][11544]child->parent say: 我是子进程，我正在给你发洠| My pid: 11543
    Get Message# 息！[14][11544]child->parent say: 我是子进程，我正在给你发消息！[15][11544]child->parent say: 我是子进程，我正在给你发消息！[16][11544]child->parent say: 我是子进程，我正在给你发消息！[17][11544]child->parent say: 我是子进程，我正在给你发消息！[18][11544]child->parent say: 我是子进程，我正在给你发消息！[19][11544]child->parent say: 我是子进程，我正在给你发消息！[20][11544]child->parent say: 我是子进程，我正在给你发消息！[21][11544]child->parent say: 我是子进程，我正在给你发消息！[22][11544]child->parent say: 我是子进程，我正在给你发消息！[23][11544]child->parent say: 我是子进程，我正在给你发消息！[24][11544]child->parent say: 我是子进程，我正在给你发消息！[25][11544]child->parent say: 我是子进程，我正在给你发消息！[26][11544]child->parent say: 我是子进程，我正在给你发消息！[27][11544]child->parent say: 我是子轠| My pid: 11543

*  **读快 - 写慢**

*  **写关闭 - 读到零**

*  **读关闭 - 写会被OS终止会给写进程发送信号终止信号**

#include <iostream>
    #include <string.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    using namespace std;
    
    // 管道实例：目的是->父进程读取，子进程写入.
    int main() {
        // 第一步：创建管道文件，打开读写端.
        int fds[2] = {0};
        int ret = pipe(fds);
        assert(ret == 0);
        // 系统文件描述符0，1，2 -> n只能是3，4
        // [0]：读取，嘴巴，
        // [1]：写入，钢笔，
        cout << "fds[0]: " << fds[0] << endl;
        cout << "fds[1]: " << fds[1] << endl; 
    
        // 第二步：创建子进程.
        pid_t id = fork();
        assert(id >= 0);
        if(id == 0 ) {
            // 子进程关闭读
            close(fds[0]);
            // 子进程执行写入
            const char* str = "我是子进程，我正在给你发消息！";
            int count = 0;
            while(true) {
                char buffer[1024];
                snprintf(buffer, sizeof(buffer), "child->parent say: %s[%d][%d]", str, ++count, getpid());
                // 向特定的文件描述中写入数据
                // 如果写端写满的时候，在写端会阻塞，等待对方进行读取！
                write(fds[1], buffer, strlen(buffer));
            }
    
            // 子进程通讯代码.
            close(fds[1]);
            exit(0);
        }
    
    
        // 父进程关闭写入
        close(fds[1]);
        // 父进程执行读取
        while(true) {
            char buffer[1024];
            // 如果管道中没有数据，读端在读，默认回直接阻塞当前正在读取的进程！
            ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
            if(s > 0) 
                buffer[s] = '\0';
            else if(s == 0){
                cout << "read:" << s << endl;
                break;
            }
            cout << "Get Message# " << buffer << " | My pid: " << getpid() << endl;
            break;
        }
        close(fds[0]);
        cout << "父进程关闭读端！" << endl;
        // 父进程等待子进程结束代码.
        int status = 0;
        ret = waitpid(id, &status, 0);
        assert(ret == id);
        
        cout << "pid->" << ret << " " << (status & 0x7F) << endl;
        return 0;
    }
    
    
    // 执行结果：
    [shaxiang@VM-8-14-centos pipe]$ ./myPipe 
    fds[0]: 3
    fds[1]: 4
    Get Message# child->parent say: 我是子进程，我正在给你发消息！[1][13912]child->parent say: 我是子进程，我正在给你发消息！[2][13912]child->parent say: 我是子进程，我正在给你发消息！[3][13912]child->parent say: 我是子进程，我正在给你发消息！[4][13912]child->parent say: 我是子进程，我正在给你发消息！[5][13912]child->parent say: 我是子进程，我正在给你发消息！[6][13912]child->parent say: 我是子进程，我正在给你发消息！[7][13912]child->parent say: 我是子进程，我正在给你发消息！[8][13912]child->parent say: 我是子进程，我正在给你发消息！[9][13912]child->parent say: 我是子进程，我正在给你发消息！[10][13912]child->parent say: 我是子进程，我正在给你发消息！[11][13912]child->parent say: 我是子进程，我正在给你发消息！[12][13912]child->parent say: 我是子进程，我正在给你发消息！[13][13912]child->parent say: 我是子进程，我正在给你发洠| My pid: 13911
    父进程关闭读端！
    pid->13912 13
            // 退出码为13的错误码， 子进程是被杀掉的
    
    // 13的含义： 终止信号
    [shaxiang@VM-8-14-centos pipe]$ kill -l
     1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL     5) SIGTRAP
     6) SIGABRT     7) SIGBUS     8) SIGFPE     9) SIGKILL    10) SIGUSR1
    11) SIGSEGV    12) SIGUSR2    13) SIGPIPE    14) SIGALRM    15) SIGTERM
    16) SIGSTKFLT    17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
    21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ
    26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO    30) SIGPWR
    31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3
    38) SIGRTMIN+4    39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
    43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12    47) SIGRTMIN+13
    48) SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14    51) SIGRTMAX-13    52) SIGRTMAX-12
    53) SIGRTMAX-11    54) SIGRTMAX-10    55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7
    58) SIGRTMAX-6    59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
    63) SIGRTMAX-1    64) SIGRTMAX

#### 【2.2.2】管道特征 ####

*  只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
 *  管道提供流式服务。
 *  一般而言，进程退出，管道释放，所以管道的生命周期随进程。
 *  一般而言，内核会对管道操作进行同步与互斥，对共享资源进行保护。
 *  管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。

#### 【2.2.2】站在文件描述符角度深度理解管道 ####

父进程以读写方式打开同一个文件，所以自己进程也同样以读写方式同一个文件，**一般而言，管道只能用来单向的数据通信！建议关闭对应的读写描述符。**

![b08a2dad88c244b2b153efd9ad137451.png][]

#### 【2.2.3】站在内核角度管道本质 ####

看待管道，就如同看待文件一样！管道的使用和文件一致，**迎合了“Linux一切皆文件思想”。**

![0282f48742144acea075d49d8ca6f759.png][]

#### 【2.2.4】基于匿名对象的进程池 ####

// shell的监控脚本记录：
    // while :; do ps ajx | head -1 && ps ajx | grep myProcessPool | grep -v grep ; sleep 1; done
    #include <iostream>
    #include <string>
    #include <vector>
    #include <stdlib.h>
    #include <assert.h>
    #include <time.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    
    #define Make_Rand_Seed() srand((unsigned long)time(nullptr) ^ getpid() ^ 0x171237 ^ rand()%1234)
    #define PROCESS_NUM 10
    /// 子进程要完成的任务 /
    // 定义函数指针重命名，返回类型void，没有参数.
    typedef void(*func_t)();
    void DownloadTask(){
        std::cout << getpid() <<"->下载任务\n" << std::endl;
        sleep(1);
    }
    
    void IoTask(){
        std::cout << getpid() << "->IO任务\n" << std::endl;
        sleep(1);
    }
    
    void FlushTask(){
        std::cout << getpid() << "->刷新任务\n" << std::endl;
        sleep(1);
    }
    
    void PrintTask(){
        std::cout << getpid() << "->打印任务\n" << std::endl;
        sleep(1);
    }
    
     多进程程序代码 /
    class SubEp{
    public:
        SubEp(pid_t subId, int writeFd) : _subId(subId), _writeFd(writeFd){
            char nameBuffer[1024];
            snprintf(nameBuffer, sizeof(nameBuffer), "Process->%d[pid(%d) fd(%d)]", num++, subId, writeFd);
            _name = nameBuffer;
        }
    
    
        static int num;
        std::string _name;          // 名称.
        pid_t _subId;               // 子进程id.
        int _writeFd;               // 管道写入文件描述符.
    };
    int SubEp::num = 0;
    
    
    int RecvTask(int readFd){
        int code = 0;
        ssize_t s = read(readFd, &code, sizeof(code));
        if(s == 4)
            return code;
        else if(s <= 0)
            return -1;
        else 
            return -1;
    }
    
    
    void CreateSubProcess(std::vector<SubEp> *subs, std::vector<func_t> &funcs){
        for(size_t  i = 0; i < PROCESS_NUM; ++i){
            // 处理Bug?
            std::vector<int> deleteFd;
    
            // 创建管道 -> [0]读 [1]写.
            int fds[2];      
            int ret = pipe(fds);// 返回值为0代表成功. 
            assert(ret == 0); (void)ret;
    
    
            pid_t id = fork();
            if(id == 0){ // id == 0 是子进程.
                // 先清空写时拷贝中的文件描述符指向.
                for(int i = 0; i < deleteFd.size(); i++)    
                    close(deleteFd[i]);
    
                // 子进程关闭写文件描述符.
                close(fds[1]);
    
                while(true){
                    // 获取命令码，如果没有发送，子进程进行阻塞.
                    int commandCode = RecvTask(fds[0]);
                    
                    // 完成任务.
                    if(commandCode >= 0 && commandCode < funcs.size())
                        funcs[commandCode]();
                    else if(commandCode == -1) {
                        break;       
                    }
                }
    
                // 子程序退出.
                exit(0);
            }
            // 父进程关闭读文件描述符.
            close(fds[0]);
    
            // 构建管道对象.
            SubEp sub(id, fds[1]);
            subs->push_back(sub);
            // 处理Bug->保存写时拷贝是的文件描述符id。
            deleteFd.push_back(fds[1]);
        }
    }
    
    void LoadTaskFunc(std::vector<func_t> *funcs){
        assert(funcs);
        funcs->push_back(DownloadTask);
        funcs->push_back(IoTask);
        funcs->push_back(FlushTask);
        funcs->push_back(PrintTask);
    }
    
    void SeedTask(const SubEp &process, int teskIndex){
        std::cout << "Seed task Num: " << teskIndex << " Seed to-> " << process._name << std::endl;
        int n = write(process._writeFd, &teskIndex, sizeof(teskIndex));
        assert(n == sizeof(int)); (void)n;
        
    };
    
    void LoadBlanceControl(const std::vector<SubEp> &subs, const std::vector<func_t> &funcs, int taskCnt){
        int countSub = subs.size();
        int countTask = funcs.size();
        
        bool flag = (taskCnt == 0 ? true : false);
        while(true){
            // 选择进程.
            int subIndex = rand() % countSub;
            // 选择任务.
            int taskIndex = rand() % countTask;
            // 任务发送给选择的进程完成.
            SeedTask(subs[subIndex], taskIndex);
            usleep(500000);
            
            if(!flag){
                taskCnt--;
                if(taskCnt == 0) 
                    break;
            }
        }
    
        // 关闭父进程的写入通道.
        for(int i = 0; i < countSub; i++){
            close(subs[i]._writeFd);
        }
    }
    
    void WaitProcess(std::vector<SubEp> subs){
        int countSub = subs.size();
        for(int i = 0; i < countSub; i++){
            waitpid(subs[i]._subId, nullptr, 0);
            std::cout << "Wait Sub Process Success -> " << subs[i]._subId << std::endl;
        }
    }
    
    int main(){
        Make_Rand_Seed();
        // --建立子进程，并且建立了和子进程通信的通道.
        std::vector<func_t> funcs;  // 存放函数指针的vector.
        LoadTaskFunc(&funcs);
        std::vector<SubEp> subs;    // 存放子进程信息的vector.
        CreateSubProcess(&subs, funcs);
    
        // --子进程创建好了，开始控制子进程.
        int taskCnt = 10;
        LoadBlanceControl(subs, funcs, taskCnt);
        
        // --回收子进程信息
        WaitProcess(subs);
        return 0;
    }

### 【2.3】命名管道 ###

*  匿名管道应用的一个限制就是只能在具有共同祖先**（具有亲缘关系）的进程间通信。**
 *  如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
 *  命名管道是一种特殊类型的文件。

#### 【2.3.1】通过命令行创建命名管道 ####

$ mkfifo filename

**实验：**

[shaxiang@VM-8-14-centos name_pipe]$ mkfifo name_pipe            // 创建命名管道.
    [shaxiang@VM-8-14-centos name_pipe]$ ll
    total 12
    -rw-rw-r-- 1 shaxiang shaxiang 107 Jun  2 22:22 client.cc
    -rw-rw-r-- 1 shaxiang shaxiang 156 Jun  2 22:22 Makefile
    prw-rw-r-- 1 shaxiang shaxiang   0 Jun  2 22:33 name_pipe        // 以p开头的文件称为管道
    -rw-rw-r-- 1 shaxiang shaxiang 107 Jun  2 22:22 server.cc
    
    // 实现进程通信，一边向管道里输入，一边从管道里输出
    // 向管道内打印脚本
    [shaxiang@VM-8-14-centos name_pipe]$ cnt=0; while :; do echo "Hello World->$cnt"; let cnt++; sleep 1; done > name_pipe
    // 从管道内输出脚本
    [shaxiang@VM-8-14-centos name_pipe]$ cat < name_pipe

![b724d91aa92648b493700bae945d6b5a.png][]

#### 【2.3.2】通过程序中创建命名管道 ####

// 创建
    #include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *filename,mode_t mode);
    
    // 移除
     #include <unistd.h>
    int unlink(const char *path);

**实验：用命名管道实现server&client通信**

*  **Makefile文件**

.PHONY:all
    all:client server
    
    client:client.cc
        g++ -o $@ $^ -std=c++11
    server:server.cc 
        g++ -o $@ $^ -std=c++11
    
    .PHONY:clean
    clean:
        rm -f client server

*  **Common.hpp文件**

#pragma once
    #include <iostream>
    #include <string>
    #include <assert.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <sys/fcntl.h>
    
    // 定义管道文件的路径.
    #define NAMED_PIPE "/tmp/myPipe"
    
    /* 创建管道文件 */
    bool CreateFifo(const std::string &path){
        umask(0);
        int n = mkfifo(path.c_str(), 0600);
        if(n == 0)
            return true;    // 创建成功返回true
        else
        {
            std::cout << "errno:" << errno << "errno string:" << strerror(errno) << std::endl;
            return false;   // 创建失败返回false
        }
    }
    
    void RemoveFifo(const std::string &path){
        int n = unlink(path.c_str());
        assert(n == 0); (void)n;
    }

*  **server.cc文件**

#include "Common.hpp"
    
    int main(){
        // 创建管道文件
        bool ret = CreateFifo(NAMED_PIPE);
        assert(ret);(void)ret;
    
        // 以读方式打开文件
        int rfd = open(NAMED_PIPE, O_RDONLY);
        if(rfd < 0)
            exit(-1);
        
        // 读
        char buffer[1024];
        while(true){
            ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
            if(n > 0){
                buffer[n] = '\0';
                std::cout << "client->server# " << buffer;
            }
            else if(n <= 0){
                std::cout << "client quit, me too" << std::endl;
                break;
            }
        }
    
        // 关闭以度房室打开的文件
        close(rfd);
        // 回收管道文件
        RemoveFifo(NAMED_PIPE);
        return 0;
    }

*  **client.cc文件**

#include "Common.hpp"
    using namespace std;
    
    int main(){
         // 以写方式打开文件
        int wfd = open(NAMED_PIPE, O_WRONLY);
        if(wfd < 0)
            exit(-1);
        
        // 写
        char buffer[1024];
        while(true){
            std::cout << "Please Say# ";
            fgets(buffer, sizeof(buffer) - 1, stdin);
            ssize_t n = write(wfd, buffer, strlen(buffer));
            assert(n == strlen(buffer)); (void)n; 
        }
    
        // 关闭以写方式打开的文件
        close(wfd);
        return 0;
    }

![787ec4436926403ebc22e91c9d9a89e4.png][]

## 【3】system V内存共享 ##

### 【2.1】共享内存原理 ###

**原理：**

*  系统申请一块TODO空间 **- 称为共享内存。**
 *  将创建好的内存映射进程的地址空间，将创建好的内存映射进程的地址空间 **- 称与共享内存进**行挂接。
 *  通讯完成后取消进程和内存的映射关系 **- 去关联。**
 *  释放内存 **- 释放共享内存。**

**理解：**

*  system V进程通信，是专门设计出来的，用来IPC。
 *  共享内存是一种通讯方式，所有想通讯的进程，都可以用。
 *  OS中一定可能会同时存在的很多的共享内存。

### 【3.2】共享内存的概念 ###

享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。

共享内存也是**先描述在组织：共享内存=物理内存快+共享内存相关属性**

![132df21a802b488eab0f800f1423bbd4.png][]

### 【3.3】共享内存数据结构 ###

struct shmid_ds {
    struct ipc_perm shm_perm; /* operation perms */
    int shm_segsz; /* size of segment (bytes) */
    __kernel_time_t shm_atime; /* last attach time */
    __kernel_time_t shm_dtime; /* last detach time */
    __kernel_time_t shm_ctime; /* last change time */
    __kernel_ipc_pid_t shm_cpid; /* pid of creator */
    __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
    unsigned short shm_nattch; /* no. of current attaches */
    unsigned short shm_unused; /* compatibility */
    void *shm_unused2; /* ditto - used by DIPC */
    void *shm_unused3; /* unused */
    };

### 【3.4】使用shell查看共享内存 ###

[shaxiang@VM-8-14-centos shm]$ ipcs -m                                    // 命令查共享内存
    ------ Shared Memory Segments --------                                    // 结果
    key        shmid      owner      perms      bytes      nattch     status      
    0x66011b1f 0          shaxiang   0          4096       0  
    
    [shaxiang@VM-8-14-centos shm]$ ipcs -q                                     // 命令查消息队列
    
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages    
    
    [shaxiang@VM-8-14-centos shm]$ ipcs -s                                    // 命令查信号
    
    ------ Semaphore Arrays --------
    key        semid      owner      perms      nsems     
    
    // 共享内存的生命周期是跟随OS的，不是跟随进程的。

![3e9f45dcf99b4ef5a9a9a26b9c1fbd50.png][]

### 【3.5】使用shell删除共享内存 ###

[shaxiang@VM-8-14-centos shm]$ ipcs -m                       // 查看共享内存指令                         
    
    ------ Shared Memory Segments --------
    key        shmid      owner      perms      bytes      nattch     status      
    0x66011b1f 0          shaxiang   0          4096       0                       
    
    [shaxiang@VM-8-14-centos shm]$ ipcrm -m 0                    // 命令删除共享内存指令
    [shaxiang@VM-8-14-centos shm]$ ipcs -m
                            // 再次查看
    ------ Shared Memory Segments --------
    key        shmid      owner      perms      bytes      nattch     status

### 【3.6】共享内存函数 ###

#### 【3.6.1】shmget函数 ####

头文件
    #include <sys/ipc.h>
    #include <sys/shm.h>
    功能：用来创建共享内存
    原型
    int shmget(key_t key, size_t size, int shmflg);
    参数
        key:这个共享内存段名字，能进行唯一标识，通过ftok()函数获取key值。
        size:共享内存大小
        shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
               IPC_CREAT: 如果要创建的共享内存不存在，就创建，如果存在，就获取
               IPC_EXCL : 无法单独使用
               IPC_CREAT | IPC_EXCL 如果不存在，就创建(一定是一个新的共享内存)，如果存在，就出错
    返回值：
        成功返回一个非负整数，即该共享内存段的标识码；失败返回-1
    
    
    头文件
    #include <sys/types.h>
    #include <sys/ipc.h>
    功能：将路径名和项目标识符转换为系统V IPC密钥
    原型：
    
    key_t ftok(const char *pathname, int proj_id);
    参数
        pathname：形成key值的字符串.
        proj_id：形成key值的id.
    返回值：
        失败会返回-1，erron会被设置.

#### 【3.6.1】shmat函数 ####

头文件
    #include <sys/types.h>
    #include <sys/shm.h>
    功能：将共享内存段连接到进程地址空间
    原型
    void *shmat(int shmid, const void *shmaddr, int shmflg);
    参数
        shmid: 共享内存标识
        shmaddr:指定连接的地址
        shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
    返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1
    // 说明：
    shmaddr为NULL，核心自动选择一个地址
    shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
    shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr -
    (shmaddr % SHMLBA)
    shmflg=SHM_RDONLY，表示连接操作用来只读共享内存

#### 【3.6.1】shmdt函数 ####

功能：将共享内存段与当前进程脱离
    原型
    int shmdt(const void *shmaddr);
    参数
        shmaddr: 由shmat所返回的指针
    返回值：成功返回0；失败返回-1
    注意：将共享内存段与当前进程脱离不等于删除共享内存段

#### 【3.6.1】shmctl函数 ####

功能：用于控制共享内存
    原型
    int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    参数
        shmid:由shmget返回的共享内存标识码
        cmd:将要采取的动作（有三个可取值）
            IPC_STAT: 把shmid_ds结构中的数据设置为共享内存的当前关联值。
            IPC_SET : 在进程有足够权限的前提下，把共享内存的当前关联之设置为shimd_ds数据结构中给出的值。
            IPC_RMID: 立即删除共享内存段
            IPC_INFO:
        buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
    返回值：
        成功返回0；失败返回-1

### 【3.7】代码实现共享内存 ###

**演示：文件(comm.hpp、shm\_client.cpp、shm\_server.cpp)**

文件：Makefile 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    .PHONY:all
    all:shm_client shm_server
    
    shm_client:shm_client.cpp
        g++ -o $@ $^ -std=c++11
    shm_server:shm_server.cpp
        g++ -o $@ $^ -std=c++11
    
    .PHONY:clean
    clean:
        rm -f shm_client shm_server
    
    文件：comm.hpp 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    #ifndef _COMM_HPP_
    #define _COMM_HPP_
    
    #include <iostream>
    #include <cerrno>
    #include <cstring>
    #include <unistd.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    
    #define PATHNAME "."
    #define PROJ_ID 0X66
    // 共享内存的大小，一般建议4kb的整数倍，因为系统分配共享内存是以4kb为单位的！
    // 内存划分内存块的基本单位，如果不是，内核会给向上取整！
    #define MAX_SIZE 4098
    
    /* 创建key_t值 */
    key_t GetKey() {
        key_t k = ftok(PATHNAME, PROJ_ID);
        if(k < 0) {
            std::cerr << errno << ":" << strerror(errno) << std::endl;
            exit(1);
        }
        // 程序走到这里，说明创建key_t值成功.
        return k;
    }
    
    /* 创建 | 获取共享内存 */
    int GetShmHelper(key_t k, int flags) {
        // k是要通过shmget()函数，设置进入内存属性中的！用来表示该共享内存，在内核中的唯一性！
        // shmid vs k 类似于 fd vs inode
        int shmid = shmget(k, MAX_SIZE,flags);
        if(k < 0) {
            std::cerr << errno << ":" << strerror(errno) << std::endl;
            exit(2);
        }
        return shmid;
    }
    
    /* 创建共享内存 */
    int CreateShm(key_t k) {
        return GetShmHelper(k, IPC_CREAT  | IPC_EXCL | 0666);
    }
    
    /* 获取共享内存 */
    int GetShm(key_t k) {
        return GetShmHelper(k, IPC_CREAT);
    }
    
    /* 进程关联共享内存 */
    void* AttachShm(int shmid){
        void* mem = shmat(shmid, nullptr, 0);
        if((long long)mem == -1L){
            std::cerr << errno << ":" << strerror(errno) << std::endl;
            exit(3);
        }
        return mem;
    }
    
    /* 进程去除关联共享内存 */
    void DetaShm(void *pStart){
        if(shmdt(pStart) == -1){
            std::cerr << errno << ":" << strerror(errno) << std::endl;
        }
    }
    
    /* 删除共享内存 */
    void DelShm(int shmid) {
        if(shmctl(shmid, IPC_RMID, nullptr) == -1){
            std::cerr << errno << ":" << strerror(errno) << std::endl;
        }
    }
    
    #endif//_COMM_HPP_
    
    文件：shm_client.cpp 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    #include "comm.hpp"
    int main(){
        // 获取共享内存所需要的key值
        key_t k = GetKey();
        printf("0x%x\n", k);
        // 获取共享内存id
        int shmid = GetShm(k);
        printf("shmid: %d\n", shmid);
        sleep(5);
    
        // 进程关联共享内存
        char* pStart = (char*)AttachShm(shmid);
        printf("Attach success, Address start: %p\n", pStart);
        sleep(5);
    
        // 发送信息给server
        const char* message = "Hello Server，我是另一个进程，正在和您通信";
        int count = 0;
        pid_t id = getpid();
    
        // char buffer[1024] = {'\0'};
        while(true){
            // snprintf(buffer, sizeof(buffer), "%s[我的pid:%d] [消息编号：%d]", message, id, ++count);
            // memcpy(pStart, buffer, strlen(buffer));
            snprintf(pStart, MAX_SIZE, "%s[我的pid:%d] [消息编号：%d]", message, id, ++count);
            sleep(1);
        }
    
        // 去除进程关联共享内存
        DetaShm(pStart);
        sleep(5);
    
        // 不负责删除server会操作
        return 0;
    } 
    
    文件：shm_server.cpp 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    // shell脚本监控命令：while :; do ipcs -m; sleep 1; done
    #include "comm.hpp"
    int main(){
        // 获取共享内存所需要的key值
        key_t k = GetKey();
        printf("0x%x\n", k);
        
        // 创建共享内存
        int shmid = CreateShm(k);
        printf("shmid: %d\n", shmid);
        sleep(5);
    
        // 进程关联共享内存
        char* pStart = (char*)AttachShm(shmid);
        printf("Attach success, Address start: %p\n", pStart);
        sleep(5);
    
        // 接收client的信息
        while(true){
            printf("Client say:%s\n", pStart);
            // 打印共享内存的属性
            struct shmid_ds ds;
            shmctl(shmid, IPC_STAT, &ds);
            printf("获取属性：size：%d，pid：%d，myself：%d，key：0x%x\n", 
                ds.shm_segsz, ds.shm_cpid, getpid(), ds.shm_perm.__key);
    
            sleep(1);
        }
    
        // 去除进程关联共享内存ls
        DetaShm(pStart);
        sleep(10);
    
        // 删除共享内存
        DelShm(shmid);
        return 0;
    }

![29d4e78ea98a404ba53a194954387dbe.png][]

**共享内存优点：**

*  共享内存是所有进程通讯最快的，能大大的减少数据的拷贝次数。
 *  同样的代码分别用管道和共享内存实现，综合考虑管道和共享内存，考虑键盘输入和显示器输出，那么共享内存有几次拷贝？管道几次拷贝？
    
     *  管道：单纯收发消息4(4+2)
     *  共享内存：单纯收发消息2(2+2)

**共享内存缺点：**

*  共享内存是不对数据进行保护的，需要用户自助添加保护功能。

## 【4】system V消息队列 ##

*  消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法
 *  每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值
 *  特性方面：IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内

### 【4.1】msgget函数 ###

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    功能：获取消息队列
    原型
    
    
    int msgget(key_t key, int msgflg);

### 【4.2】msgctl函数 ###

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    功能：驱除消息队列
    原型
    int msgctl(int msqid, int cmd, struct msqid_ds *buf);

### 【4.3】msgsnd函数 ###

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    功能：发送
    原型
    
    
    int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

### 【4.4】msgrcv函数 ###

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    功能：接收
    原型
    ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
    int msgflg);

### 【5】system V信号量 ###

信号量主要用于同步和互斥的，下面先来看看什么是同步和互斥。

**进程互斥：**

*  由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥。
 *  系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。
 *  在进程中涉及到互斥资源的程序段叫临界区。
 *  特性方面:IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核。

## 【5.1】semget函数 ##

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>
    功能：获取信号量
    原型
    int semget(key_t key, int nsems, int semflg);

## 【5.2】semctl函数 ##

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>
    功能：删除信号量
    原型
    int semctl(int semid, int semnum, int cmd, ...);

## 【5.3】semop函数 ##

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>
    功能：设置信号量P
    原型
    
    
    int semop(int semid, struct sembuf *sops, unsigned nsops);

## 【5.4】semtimedop函数 ##

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>
    功能：设置信号量V
    原型
    
    
    int semtimedop(int semid, struct sembuf *sops, unsigned nsops,
    struct timespec *timeout);

[98bef77e428d430e9e896473166aa02c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/fd6f4790b88d45d18af24f9d41f3fdb5.png
[adf3a989e1894b4faa7ee7a2176f9b2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b219dbdb8428405ead6453e82d4ceb54.png
[a469dc9e3cb54a89afbcb49d7c26da2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/bf33faca56d34d52829019da525e959a.png
[b08a2dad88c244b2b153efd9ad137451.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8ec846a3035841ee9e4d5876df304247.png
[0282f48742144acea075d49d8ca6f759.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/672b397b7cb0465c976aa7bbb3457212.png
[b724d91aa92648b493700bae945d6b5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b722fc9d5d8548eaa2dd1b239f3c4c93.png
[787ec4436926403ebc22e91c9d9a89e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/9ac4e2d2b3834615877dd9d9eee7f572.png
[132df21a802b488eab0f800f1423bbd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0a728382b6b0451fba35d29e9da8d804.png
[3e9f45dcf99b4ef5a9a9a26b9c1fbd50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d13dbfdfc63e4579a3371f7431668cb3.png
[29d4e78ea98a404ba53a194954387dbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0ef2592020834836b007efb2c3240817.png