Linux_进程通信_管道_system V共享内存_6

---

通信背景：
1.进程是具有独立性的，但进程间想要交互数据（多进程协同处理一件事情），成本会非常高 。
2.不要以为，进程独立了，就是彻底独立，我们需要双方能够进行一定程度的信息交互。

一、进程通信分类

1. 管道
   a.匿名管道
   b.命名管道
2. System V IPC
   a.System V 消息队列
   b.System V 共享内存
   c.System V 信号量
3. POSIX IPC
   a.消息队列
   b.共享内存
   c.信号量
   d.互斥量
   e.条件变量
   f.读写锁

二、管道

1.什么是管道

通信之前，让不同的进程看到同一份资源（文件，内存块…）。我们要学的进程间通信，不是告诉我们如何通信，而是让两个进程看到同一份资源，因为资源不同，所以决定了不同种类的通信方式，而管道就是提供共享资源的一种手段。

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

1.原理

站在文件角度看管道：

站在内核角度看管道：

简单来说，看待管道，就如同看待文件一样，（不过是不在磁盘而是在内存里的文件）！管道的使用和文件一致，迎合了“Linux一切皆文件思想”。

为什么父进程要分别打开读写？
为了子进程继承，让子进程不用再打开了！
为什么父子要关闭对应的读写？
管道必须是单向通信
谁决定父子关闭什么读写？
不是由管道本身决定的，是由需求决定的！

2.管道的特点

生活中的管道都有什么共同特点：
a.都是单向的！
b.管道传输资源的
所以进程间通信管道是单向的，传输数据的！

2.匿名管道

创建管道——系统接口pipe

#include<iostream>
#include<unistd.h>
#include<cstring>
#include<sys/types.h>
#include<sys/wait.h>
using namespace std;
int main()
{
    //1.创建管道
    int pipefd[2] = {0};
    if(pipe(pipefd)!=0)
    {
        cerr<<"pipe error"<<endl;
        return 1;
    }
    //pipefd[0] 是读端
    //pipefd[1] 是写端
    //快速记忆  读写-01 0就是读 1就是写
    //2.创建子进程
    pid_t id = fork();
    if(id<0)
    {
        cerr<<"fork error"<<endl;
        return 2;
    }
    else if(id==0)
    {
        //child
        //子进程进行读取,要关闭写端
        close(pipefd[1]);
        #define NUM 1024
        char buffer[NUM];
        while(true)
        {
            memset(buffer,'\0',sizeof(buffer));

            //read返回值
            //0表示管道对端已经关闭,那么子进程是如何知道 ？
            //管道也是类似文件，和文件一样有硬链接数，当硬链接数为1时表示只有子进程在读，就表示对端已经关闭了。
            //大于0表示读到的字符长度
            //-1表示读取错误
            ssize_t s = read(pipefd[0],buffer,sizeof(buffer)-1);

            if(s>0)
            {
                //读取成功
                buffer[s] = '\0';
                cout<<"子进程收到消息，内容是: "<<buffer<<endl;
            }
            else if(s==0)
            {
                //父进程关闭管道
                cout<<"父进程写完了，我也退出啦"<<endl;
                break;
            }
            else
            {
                cerr<<"read error"<<endl;
                return 3;
            }
        }
        close(pipefd[0]);
    }
    else
    {
        //parent
        //父进程来进行写入，要关闭读端
        close(pipefd[0]);
        string msg = "你好子进程，我的父进程!,这次发送的信息编号是";
        int cnt = 0;
        while(cnt<5)
        {
            char sendBuffer[1024];
            sprintf(sendBuffer,"%s : %d",msg.c_str(),cnt);
            //不用把'\0'也写进去
            write(pipefd[1],sendBuffer,strlen(sendBuffer));
            sleep(1);
            cnt++;
        }
        close(pipefd[1]);
        cout<<"父进程写完了"<<endl;
        pid_t res  =waitpid(id,nullptr,0);
        if(res>0)
        {
            cout<<"等待子进程成功"<<endl;
        }
    }
    

    return 0;
}

运行上面的代码发现现象：
当父进程没有写入数据的时候，子进程在等！所以，父进程写入之后，子进程才会read（会返回）到数据，子进程打印读取数据要以父进程的节奏为主！
父进程和子进程读写的时候，是有一定的顺序的！！->父子进程各自printf的时候（向显示器写入），会有顺序吗？
不会，而这种乱序，就是缺乏访问控制。
管道内部，没有数据，reader就必须阻塞等待（read）——等管道有数据
管道内部，如果数据被写满，writer就必须阻塞等待（write）——等管道有空间
pipe内部，自带访问控制机制——同步和互斥机制！
阻塞等待，在哪个等待队列里等待？
管道资源的等待队里等待。

特征总结：
1.管道只能用来进行具有血缘关系的进程之间，进行进程通信。通常用于父子通信
2.管道只能单向通信（内核实现决定的），半双工的一种特殊情况
3.管道自带同步机制（pipe满，writer等。pipe空，reader等）——自带访问控制
4.管道是面向字节流的——先写的字符，一定是先被读取的，没有格式边界，需要用户来定义区分内容的边界
5.管道的生命周期——管道是文件吗？是——进程退出了，曾经打开的文件会怎么办？退出

3.命名管道

用于毫不相干的进程之间进行通信。

1.创建命名管道文件 - mkfifo (命令)

mkfifo 管道名

2.创建命名管道文件 - mkfifo (函数)

命名管道：通过一个fifo文件，有路径就 可以确认唯一性，通过路径找到同一个资源。

#include <iostream>
#include <sys/types.h>
#include 
#define IPC_PATH "./.fifo"
using namespace std;

int main()
{
    if (mkfifo(IPC_PATH,0600)!=0)
    {
        cerr<<"mkfifo error"<<endl;
        return 1;
    }
}

运行代码就创建了命名管道：

使用就和用文件一样，open,read,write。

三、system V共享内存

进程间通信的前提是：先让不同的进程，看到同一份资源！

1.原理

2.共享内存函数

1.fotk

作用：生成key值。

---

原型： key_t ftok(const char *pathname, int proj_id);

---

参数：
pathname ：路径
proj_id ：数字

---

返回值：成功返回key值，失败返回-1。

#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/ipc.h>
#include<string.h>
#include<errno.h>
#include<unistd.h>

#define PATH_NAME "/home/whc/study/24_4_1"
#define PROJ_ID 0x14


key_t Creatkey()
{
    key_t key =  ftok(PATH_NAME,PROJ_ID);
    if(key<0)
    {
        std::cerr<<"Creatkey error"<<strerror(errno)<<std::endl;
        exit(1);
    }
}

using namespace std;
int main()
{
    key_t key = Creatkey();
    std::cout<<"key:"<<key<<endl;


    return 0;
}

2.shmget

作用：用来创建共享内存

---

原型 ：int shmget(key_t key, size_t size, int shmflg);

---

参数：
key：这个共享内存段名字

size：共享内存大小，建议设置成为页（4KB）的整数倍

shmflg：它们的用法和创建文件时使用的mode模式标志是一样的
IPC_CREAT：创建共享内存，如果已经存在，就获取之，不存在，就创建之
IPC_EXCL：不单独使用，必须和IPC_CREAT配合使用。如果不存在指定的共享内存，创建之，如果存在了，出错返回。可以保证，如果shmegt函数调用成功，一定是一个全新的share
memory！
0600：权限

---

返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

共享内存存在哪？
内核中，内核会给我们维护发现内存的结构！
对于OS来说，共享内存也要被管理起来，如何管理，先描述，再组织！
struct shmid_ds{
//各种数据
key_t kye;
};

我怎么知道，这个共享内存属于存在还是不存在？
先有方法，标识共享内存的唯一性，就是上面说的key。而这个key值一般是由用户提供的，让他们拥有同一个key值。

匿名管道通过约定使用同一文件。
共享内存通过约定使用同一个唯一key,来进行通信的！！

#include<iostream>
#include<time.h>
#include<iostream>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#include<errno.h>
#include<unistd.h>

#define PATH_NAME "/home/whc/study/24_4_1"
#define PROJ_ID 0x14
#define MEM_SIZE 4096


key_t Creatkey()
{
    key_t key =  ftok(PATH_NAME,PROJ_ID);
    if(key<0)
    {
        std::cerr<<"Creatkey error"<<strerror(errno)<<std::endl;
        exit(1);
    }
}
std::ostream &Log()
{
    std::cout<<"For Debug | "<<"timestamp:"<<(uint64_t)time(nullptr)<<"  | ";
    return std::cout;
}
using namespace std;
int main()
{
    key_t key = Creatkey();
    Log() << "key:" << key << endl;
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT|IPC_EXCL|0600);
    if(shmid<0)
    {
        Log()<<"shmget: "<<strerror(errno)<<endl;
        return 2;
    }

    Log()<<"create shm success, shmid "<<shmid<< endl;

    return 0;
}

当我们运行完毕创建全新共享内存的代码后（代码退出），但是第二（n）次时候，该代码无法运行，告诉我们file存在，共享内存是存在的，system v下的共享内存的生命周期是内核的。如果不显示的删除，只能通过kernel(OS)重启来解决。

1.如何知道有哪些IPC资源 - ipcs （命令）

作用：查看当前用户创建的共享内存

ipcs -m

2.如何显示删除 - ipcrm (命令)

ipcrm -m shmid

3.如何使用共享内存 - shmat - shmdt

作用：将共享内存和自己的进程产生关联attach

---

原型：void *shmat(int shmid, const void *shmaddr, int shmflg);

---

参数 ：
shmid ： shmid
shmaddr ： 不管 设为nullptr
shmflg : 是读还是写，不管设为默认：0

---

返回值：
出错返回-1，成功返回地址空间，怎么使用malloc的空间，就怎么使用共享内存的空间！

shmat(shmid,nullptr,0);

---

作用：将共享内存和直接的进程去关联detach

---

原型：int shmdt(const void *shmaddr);

---

参数：
shmaddr：就是shmat的返回值

---

返回值：失败返回-1

    //关联
    char *str = (char*)shmat(shmid, NULL, 0);
    Log()<<"attach shm: "<<shmid<< " success\n";
    sleep(5);
    //用共享内存
    while(true)
    {
        cout<<"."<<str<<endl;
        sleep(1);
    }
    //去关联
    shmdt(str);
    Log()<<"detach shm: "<<shmid<<" succsee\n";

    // 关联
    char *str = (char *)shmat(shmid, nullptr, 0);

    // 用它
    //我们把共享内存实际上是映射到了我们进程地址空间的用户空间了（堆栈之间），对每一个进程而言
    //挂接到自己的上下文的共享内存，属于自己的空间，类似于堆空间或者栈空间，可以被用户直接使用。
    int cnt = 0;
    while (cnt < 26)
    {
        str[cnt] = 'A' + cnt;
        cnt++;
        str[cnt] ='\0';
        sleep(1);
    }
    // 去关联
    shmdt(str);

共享内存，因为他自身的特性，他没有任何访问控制，共享内存被双方之间看到，属于双方的用户空间，可以直接通信，但是不安全！ 共享内存是所有进程通信，速度最快的！

4.系统接口删共享内存 -shmctl

作用：删除共享内存

---

原型：
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

---

参数：
shmid：shmid

cmd : 如果要删除就传 IPC_RMID

buf：nullptr

---

返回值：-1就是失败

shmid(shmid,IPC_RMID,nullptr);

四、进程互斥

1.临界资源

被多个进程，能够看到的资源——临界资源。
如果没有对临界资源进行任何保护，对于临界资源的访问，双方进程在进行方法的时候，就都是乱序，可能会因为读写交叉而导致各种乱码，废弃数据，访问控制方法的问题！

2临界区

对于多个进程而言，访问临界资源的代码——临界区
我的进程中，有大量的代码没有访问临界资源，而只有一部分代码才会访问临界资源。

3.原子性

一件事，要么没做，要么做完了，没有中间状态——原子性

4.互斥

任何时刻，只允许一个进程，访问临界资源——互斥