• Linux【进程间通信】

    目录

    一、什么是进程间通信

    管道

    管道的原理 

    二、匿名管道 

    1.简单写一个管道

    2.总结管道的特点，理解以前的管道

    3.扩展 

    如何写一个进程池？

    创建Makefile文件

    创建我们的任务头文件Task.cpp

    创建我们的主程序文件

    管道读写规则

    三、命名管道

    mkfifo 

    制作管道实验

    1.日志头文件Log.hpp

    2.公共头文件comm.hpp

    3.客户端文件client.cc

    4.服务端文件server.cc 

    四、system v共享内存

    shmget

    ftok

    shmctl

    SHMAT

    SHMDT

     1.创建makefile文件

    2.日志头文件Log.hpp

    3.共享的头文件comm.hpp

    4.客户端文件shmClient.cc

    5.服务端头文件shmServer.cc

    6.初步实现进程间通信

     进程间通信（客户端我们自己输入，服务器端读取数据）

    用管道控制共享内存的访问控制 

    五、信号量

    一、什么是进程间通信

    进程的运行具有独立性，有独立的页表，pcb，等等父子进程之间，数据不相干扰

    这就让我们进程想要通信的难度比较大。

    因为操作系统在设计的时候，它本身就是独立的。

    进程间通信的本质： 

    先让不同的进程看到同一份资源（内存空间） 

    为什么要进行进程间通信？

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

    （交换数据、空值、通知等目标）

    进程间通信的必要性

    单进程的，那么也就无法使用并发能力，更加无法实现多进程协同 

    进程间通信不是目的，而是手段，为了实现多进程协同。

    进程通信的技术背景

    1.进程是具有独立性的。虚拟地址空间+页表 保证进程运行的独立性（进程内核数据接口+进程的代码和数据） 

    2.通信的成本会比较高

    进程间通信的本质理解

    1.进程间通信的前提，首先需要让不同的进程看到同一块“内存”（特定的结构组织） 

    2.所以所谓的进程看到同一块“内存”，属于哪一个进程呢？不能隶属于任何一个进程，而应该更强调共享。

    进程间通信分类：

    进程间通信的方式也有一些标准

    1.Linux原生提供--管道
            匿名管道pipe
            命名管道


    2.System V IPC（侧重于本地通信（单机通信））--多进程
            System V 消息队列
            System V 共享内存
            System V 信号量


    3.POSIX IPC（侧重于网络通信）--多线程
            消息队列
            共享内存
            信号量
            互斥量
            条件变量
            读写锁

            

    标准在我们使用者看来，都是接口上具有一定的规律

    管道

    什么是管道？

    （天然气管道、石油管道、自来水管道……）

    （这里我们简化一下，有一个入口和一个出口的管道）

    1.只能单向通信。

    （一般都是天然气公司把天然气输送到你家，不是你家把天然气输送到天然气公司）

    2.管道内传输的都是资源

    计算机通信领域的设计者，设计了一种单向通信的方式--管道

    计算机中的管道：

    传输资源->数据！ 

    管道的原理 

    管道通信背后是进程之间通过管道进行通信

    下面的|就是将第一个命令的执行结果作为参数传给后面那个命令 

     因为中间的数据资源不属于任何一个进程。

    ​​​​​​​

    上面是我们的再基础IO中所说过的文件系统。

    那么当前进程如果创建了子进程，会发生什么呢？

    struct file*fd_array[]文件描述符表要不要拷贝给子进程呢？

    首先这个表表示这个进程和文件的描述符表之间的关系，可就是当前的进程可以看到哪些被打开的文件。这个必须拷贝给子进程！

    拷贝只是第一次拷贝，之后父子进程持有的就是独立的表结构。

    那么这个表指向的一堆文件要不要拷贝给子进程呢？

    不 ，我们不需要。与进程相关的都会被拷贝，与文件相关的并不会被拷贝！

    父子进程的struct file_struct是一样的，所以里面的文件指针都是一样的，所以我们打开的文件也是一样的。

    （比防说我们父子进程在打印到屏幕上的时候，都是打印到1号文件中，都是打印到同一个显示器上！）

    所以我们这里的struct file是能被父进程访问，也能被子进程访问！

    所以我们的父子进程是不是看到了一份公共文件，这个也就是我们的管道！ 

    （管道的临时文件不需要刷新到磁盘）

    双方进程各自关闭不需要的文件描述符

    让父进程进行写入，子进程进行读取，父进程写，就需要关闭读，保留写，子进程关闭写，保留读的功能。每个进程内部都有各自的文件描述符。

    也就是让不同的进程看到同一份资源。 

    Linux下，一切皆文件，管道就是我们上面的共享文件。 

    这里的文件是属于内核的，所有的进程间通信都是内核级别的。

    那两进程进行通信，需不需要将这个管道文件保存到磁盘？

    不需要！

    进程间通信的管道必须在内存中，是一个纯内存的通信方式，如果还要写磁盘的话，我们的通信效率就太低了。

    并且进程间通信的数据往往属于临时数据，不需要将数据持久化保存 

    二、匿名管道 

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

    像下面的|就是一个简单的管道 

    ps axj |head -1 && ps axj|grep sleep

     管道使用完毕之后，记得要关闭文件描述符。

    1.简单写一个管道

    如何做到让不同的进程，看到同一份资源的呢？

    fork让子进程继承的--能够让具有血缘关系的进程进行进程间通信--常用于父子进程。

    pipefd[0]：读端

    pipefd[1]：写端

    int pipe(int pipefd[2]);输出型参数，希望通过它来验证我们的管道成功搭建

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5. int main()
    6. {
    7.   //1.创建管道
    8.   int pipefd[2]={0};
    9.   int n=pipe(pipefd);
    10.   //在debug模式下assert是有效的，但是release版本下是会无效的
    11.   assert(n!=-1);
    12.   //所以我们这里需要写下面的代码，证明n被使用过
    13.   (void)n;
    14.  
    15.   cout<<"pipefd[0]"<0]<
    16.   cout<<"pipefd[1]"<1]<
    17.   return 0;
    18. }

     ok，我们这里的文件描述符已经成功打开了，接下来我们在进一步搭建我们的管道

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10. int main()
    11. {
    12.     //1.创建管道
    13.     int pipefd[2]={0};//pipefd[0]：读端,pipefd[1]：写端
    14.     int n=pipe(pipefd);
    15.     //在debug模式下assert是有效的，但是release版本下是会无效的
    16.     assert(n!=-1);
    17.     //所以我们这里需要写下面的代码，证明n被使用过
    18.     (void)n;
    19.  
    20.     //如果是DEBUG模式下就不打印了，相当于就是注释掉了
    21.   #ifdef DEBUG
    22.     cout<<"pipefd[0]"<0]<
    23.     cout<<"pipefd[1]"<1]<
    24.   #endif
    25.  
    26.     //2.创建子进程
    27.     pid_t id=fork();
    28.     assert(id!=-1);
    29.     if(id==0)
    30.     {
    31.       //子进程
    32.       //3.构建单向通信的信道
    33.       //父进程写入，子进程读取，让父子关闭不需要的文件描述符
    34.       //3.1关闭子进程不需要的fd
    35.       //子进程进行读取，将写端给关闭
    36.       close(pipefd[1]);
    37.       char buffer[1024];
    38.       while (true)
    39.       {
    40.         //从0号文件描述符中读取，读取到缓冲区buffer中
    41.         size_t s=read(pipefd[0],buffer,sizeof(buffer)-1);
    42.         if(s>0)
    43.         {
    44.           //添加\0
    45.           buffer[s]=0;
    46.           cout<<"child get a message["<<getpid()<<"] Father#"<
    47.         }
    48.       }
    49.       // close(pipefd[0]);
    50.       exit(0);
    51.     }
    52.     //父进程
    53.     //3.构建单向通信的信道
    54.     //父进程进行写入，将读取端进行关闭
    55.     close(pipefd[0]);
    56.     string message="我是父进程，我正在给你发消息";
    57.     int count=0;
    58.     char send_buffer[1024];
    59.     while(true)
    60.     {
    61.        //3.2构建一个变化的字符串
    62.        //将printf的内容格式化到字符串中
    63.       snprintf(send_buffer,sizeof(send_buffer),"%s[%d]:%d",message.c_str(),getpid(),count++);
    64.       //3.3写入
    65.       //这里strlen不需要+1,\0写入也没有意义。
    66.       write(pipefd[1],send_buffer,strlen(send_buffer));
    67.  
    68.       //3.4故意sleep
    69.       sleep(1);
    70.     }
    71.     pid_t ret=waitpid(id,nullptr,0);
    72.     assert(ret<0);
    73.     (void)ret;
    74.     close(pipefd[1]);
    75.     //子进程中的pipefd[0]关闭可写可不写，因为进程退出了，进程中的文件描述符也会被关掉
    76.     return 0;
    77. }

     

    为什么我们不写一个全局的缓冲区（buffer）来进行通信呢？

    因为有写时拷贝的存在，无法更改通信。

    2.总结管道的特点，理解以前的管道

    1.管道是一种进程间通信的方式，管道是用来进行具有血缘关系的进程进行进程间通信，常用于父子进程。

    2.我们上面的代码中，我们的父进程是1秒钟发送一条消息，但是我们的子进程并没有设置读取信息的时间间隔，但是我们的子进程依旧是跟随父进程的节奏在打印。

    那么我们父进程在sleep的期间，子进程在干什么呢？

    子进程在等待父进程的写入。

    管道是一个文件，显示器也是一个文件，父子同时往显示器写入的时候，有没有说一个会等另一个的情况呢？

    没有！

    之前我们往显示器上打印的时候，都是交错着疯狂往显示器上打印的。

    这种情况，我们将其称为缺乏访问控制！

    那我们上面的子进程等待父进程的写入，就是具有访问控制。 

    也就是说，管道具有通过让进程间协同，提供了访问控制！

    管道里满的时候，写的一方要等待读的一方将数据读取

    管道空的时候，读取的一方要等待写的一方写入。

    下面我们验证一下，下面我们是将父进程循环写入，但是子进程需要等待20秒才写入 

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10. int main()
    11. {
    12.     //1.创建管道
    13.     int pipefd[2]={0};//pipefd[0]：读端,pipefd[1]：写端
    14.     int n=pipe(pipefd);
    15.     //在debug模式下assert是有效的，但是release版本下是会无效的
    16.     assert(n!=-1);
    17.     //所以我们这里需要写下面的代码，证明n被使用过
    18.     (void)n;
    19.  
    20.     //如果是DEBUG模式下就不打印了，相当于就是注释掉了
    21.   #ifdef DEBUG
    22.     cout<<"pipefd[0]"<0]<
    23.     cout<<"pipefd[1]"<1]<
    24.   #endif
    25.  
    26.     //2.创建子进程
    27.     pid_t id=fork();
    28.     assert(id!=-1);
    29.     if(id==0)
    30.     {
    31.       //子进程
    32.       //3.构建单向通信的信道
    33.       //父进程写入，子进程读取，让父子关闭不需要的文件描述符
    34.       //3.1关闭子进程不需要的fd
    35.       //子进程进行读取，将写端给关闭
    36.       close(pipefd[1]);
    37.       char buffer[1024*8];
    38.       while (true)
    39.       {
    40.         //从0号文件描述符中读取，读取到缓冲区buffer中
    41.         size_t s=read(pipefd[0],buffer,sizeof(buffer)-1);
    42.         if(s>0)
    43.         {
    44.           sleep(20);
    45.           //添加\0
    46.           buffer[s]=0;
    47.           cout<<"child get a message["<<getpid()<<"] Father#"<
    48.         }
    49.         
    50.         
    51.       }
    52.       // close(pipefd[0]);
    53.       exit(0);
    54.     }
    55.     //父进程
    56.     //3.构建单向通信的信道
    57.     //父进程进行写入，将读取端进行关闭
    58.     close(pipefd[0]);
    59.     string message="我是父进程，我正在给你发消息";
    60.     int count=0;
    61.     char send_buffer[1024*8];
    62.     while(true)
    63.     {
    64.        //3.2构建一个变化的字符串
    65.        //将printf的内容格式化到字符串中
    66.       snprintf(send_buffer,sizeof(send_buffer),"%s[%d]:%d",message.c_str(),getpid(),count++);
    67.       //3.3写入
    68.       //这里strlen不需要+1,\0写入也没有意义。
    69.       write(pipefd[1],send_buffer,strlen(send_buffer));
    70.  
    71.       //3.4故意sleep
    72.       cout<
    73.       // sleep(10);
    74.     }
    75.     pid_t ret=waitpid(id,nullptr,0);
    76.     assert(ret<0);
    77.     (void)ret;
    78.     close(pipefd[1]);
    79.     //子进程中的pipefd[0]关闭可写可不写，因为进程退出了，进程中的文件描述符也会被关掉
    80.     return 0;
    81. }

     如果缓冲区满了，就不能写入了，就只能等待子进程读取。所以这里子进程读取一次的数据可能是父进程写了好几次的结果

    3.管道提供的是面向流式的通信服务--面向字节流（需要对应的协议）

    你写了十次，但是我可能一次就全部都读取完了。

    4.管道是基于文件的，文件的生命周期是随进程的，管道的生命周期是随进程的。

    写入的一方，fd没有关闭，如果有数据，就读，没有数据，就等

    写入的一方，fd关闭，读取的一方，read会返回0，表示读到了文件的结尾（将缓冲区中的内容读取完毕之后，就可以退出了！）

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10. int main()
    11. {
    12.     //1.创建管道
    13.     int pipefd[2]={0};//pipefd[0]：读端,pipefd[1]：写端
    14.     int n=pipe(pipefd);
    15.     //在debug模式下assert是有效的，但是release版本下是会无效的
    16.     assert(n!=-1);
    17.     //所以我们这里需要写下面的代码，证明n被使用过
    18.     (void)n;
    19.  
    20.     //如果是DEBUG模式下就不打印了，相当于就是注释掉了
    21.   #ifdef DEBUG
    22.     cout<<"pipefd[0]"<0]<
    23.     cout<<"pipefd[1]"<1]<
    24.   #endif
    25.  
    26.     //2.创建子进程
    27.     pid_t id=fork();
    28.     assert(id!=-1);
    29.     if(id==0)
    30.     {
    31.       //子进程
    32.       //3.构建单向通信的信道
    33.       //父进程写入，子进程读取，让父子关闭不需要的文件描述符
    34.       //3.1关闭子进程不需要的fd
    35.       //子进程进行读取，将写端给关闭
    36.       close(pipefd[1]);
    37.       char buffer[1024*8];
    38.       while (true)
    39.       {
    40.         //从0号文件描述符中读取，读取到缓冲区buffer中
    41.         size_t s=read(pipefd[0],buffer,sizeof(buffer)-1);
    42.         if(s>0)
    43.         {
    44.           // sleep(20);
    45.           //写入的一方，fd没有关闭，如果有数据，就读，没有数据，就等
    46.           //写入的一方，fd关闭，读取的一方，read会返回0，表示读到了文件的结尾
    47.           //添加\0
    48.           buffer[s]=0;
    49.           cout<<"child get a message["<<getpid()<<"] Father#"<
    50.         }
    51.         else if(s==0)
    52.         {
    53.           cout<<"writer quit(father),me quit"<
    54.           break;
    55.         }
    56.       }
    57.       // close(pipefd[0]);
    58.       exit(0);
    59.     }
    60.     //父进程
    61.     //3.构建单向通信的信道
    62.     //父进程进行写入，将读取端进行关闭
    63.     close(pipefd[0]);
    64.     string message="我是父进程，我正在给你发消息";
    65.     int count=0;
    66.     char send_buffer[1024*8];
    67.     while(true)
    68.     {
    69.        //3.2构建一个变化的字符串
    70.        //将printf的内容格式化到字符串中
    71.       snprintf(send_buffer,sizeof(send_buffer),"%s[%d]:%d",message.c_str(),getpid(),count++);
    72.       //3.3写入
    73.       //这里strlen不需要+1,\0写入也没有意义。
    74.       write(pipefd[1],send_buffer,strlen(send_buffer));
    75.  
    76.       //3.4故意sleep
    77.       sleep(1);
    78.       cout<
    79.       if(count==5) 
    80.       {
    81.         cout<<"writer quit(father)"<
    82.         break;
    83.       }
    84.  
    85.     }
    86.     close(pipefd[1]);
    87.     pid_t ret=waitpid(id,nullptr,0);
    88.     cout<<"id："<"ret："<
    89.     assert(ret>0);
    90.     (void)ret;
    91.     //子进程中的pipefd[0]关闭可写可不写，因为进程退出了，进程中的文件描述符也会被关掉
    92.     return 0;
    93. }

     

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

     

    5.管道是单向通信的，就会半双工通信的一种特殊情况

    作为通信的一方，要么我在发送，要么我在接收，我不能同时接收和发送，这种就称为半双工通信。

    有时候呢，我们既可以收，又可以发，这就称为全双工通信。

    比防说我们在听老师上课，老师在将，我们在听，这就是半双工通信。

    但是如果两个人在吵架，你在吵的时候我也在吵，同时我也在听你说什么，你也在听我说什么，这就是全双工通信。

    a.写快，读慢，写满的时候就不能再写了

    b.写慢，读快，管道没有数据的时候，读的这一方就必须等待

    c.写关，读0，表示读到了文件结尾

    d.读关，写继续写，OS终止写进程 

    3.扩展 

    如何写一个进程池？

    我们给父进程和每一个子进程建立一个管道，并以固定大小的方式command_code（4kb），给我们的子进程发送指令。

    创建Makefile文件

    1. ProcessPool:ProcessPool.cc
    2. 	g++ -o $@ $^ -std=c++11 -DEBUG
    3. .PHONY:clean
    4. clean:
    5. 	rm -f ProcessPool

    创建我们的任务头文件Task.cpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. //返回void，参数为()
    9. typedef std::function<void()> func;
    10. std::vector callbacks;
    11. std::unordered_map<int,std::string> desc;
    12. void readMySQL()
    13. {
    14.     std::cout<<"sub process["<<getpid()<<"]执行访问数据库的任务\n"<
    15. }
    16.  
    17. void execuleUrl()
    18. {
    19.     std::cout<<"sub process["<<getpid()<<"]执行url解析\n"<
    20. }
    21.  
    22. void cal()
    23. {
    24.     std::cout<<"sub process["<<getpid()<<"]执行加密任务\n"<
    25. }
    26.  
    27. void save()
    28. {
    29.     std::cout<<"sub process["<<getpid()<<"]执行数据持久化任务\n"<
    30. }
    31.  
    32. void load()
    33. {
    34.     desc.insert({callbacks.size(),"readmySQL：读取数据库"});
    35.     callbacks.push_back(readMySQL);
    36.     desc.insert({callbacks.size(),"execuleUrl：进行URL解析"});
    37.     callbacks.push_back(execuleUrl);
    38.     desc.insert({callbacks.size(),"cal：进行加密计算"});
    39.     callbacks.push_back(cal);
    40.     desc.insert({callbacks.size(),"save：进行数据的文件保存"});
    41.     callbacks.push_back(save);
    42. }
    43.  
    44. void showHandler()
    45. {
    46.     for(const auto& iter:desc)
    47.     {
    48.         std::cout<"\t"<
    49.     }
    50. }
    51. //返回有多少个任务
    52. int handlerSize()
    53. {
    54.     return callbacks.size();
    55. }

    创建我们的主程序文件

    自动派发任务的版本

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include"Task.hpp"
    8. #include
    9. #include
    10. //默认创建的进程个数
    11. #define PROCESS_NUM 5
    12.  
    13. using namespace std;
    14.  
    15.  
    16. //等待命令
    17. int waitCommand(int waitfd,bool&quit)
    18. {
    19.     uint32_t command=0;
    20.     ssize_t s=read(waitfd,&command,sizeof(command));
    21.     //如果读取到对应的0，那么就是文件描述符关掉了，就直接退出
    22.     if(s==0)
    23.     {
    24.         quit=true;
    25.         return -1;
    26.     }
    27.     //看看有没有读取成功
    28.     assert(s==sizeof(uint32_t));
    29.     return command;
    30. }
    31.  
    32. //拖过文件描述符像进程发送命令
    33. void SendAndWakeup(pid_t who,int fd,uint32_t command)
    34. {
    35.     write(fd,&command,sizeof(command));
    36.     cout<<"main process: call process"<"execute"<"through"<
    37. }
    38.  
    39. int main()
    40. {
    41.     //将任务装载进来
    42.     load();
    43.     //子进程的pid_t，信道pipfd的键值对
    44.     //表示一个一个进程相关的信息
    45.     vectorpid_t,int>> slots;
    46.     //先创建多个进程
    47.     for(int i=0;i
    48.     {
    49.         //创建管道
    50.         int pipedf[2]={0};
    51.         int n=pipe(pipedf);
    52.         assert(n==0);
    53.         (void)n;
    54.  
    55.         //创建子进程
    56.         pid_t id=fork();
    57.         assert(id!=-1);
    58.         //子进程我们让他进行读取
    59.         if(id==0)
    60.         {
    61.             //child，进行读取，关闭写入端
    62.             close(pipedf[1]);
    63.             while(true)
    64.             {
    65.                 //等待命令
    66.                 bool quit=false;
    67.                 int command=waitCommand(pipedf[0],quit);//如果对方不发，我们就阻塞
    68.                 if(quit)
    69.                    break;
    70.                 //执行对应的命令
    71.                 if(command>=0&&command<handlerSize())
    72.                 {
    73.                     callbacks[command]();
    74.                 }
    75.                 else
    76.                 {
    77.                     cout<<"非法command"<
    78.                 }
    79.             }
    80.             exit(1);
    81.         }
    82.         //father，进行写入，关闭读取端
    83.         close(pipedf[0]);
    84.         slots.push_back(pair<pid_t,int>(id,pipedf[1]));
    85.     }
    86.     //父进程派发任务
    87.     //将任务均衡地拍付给每一个任务称为单机版的负载均衡
    88.     srand((unsigned long)time(nullptr) ^ getpid()^2332313L);//让我们的数据源更随机
    89.     while(true)
    90.     {
    91.         int command=rand()%handlerSize();
    92.         //采用随机数的方式，选择子进程来完成任务，这是一种随机数的方式来实现负载均衡。
    93.         int choice=rand()%slots.size();
    94.             //布置任务
    95.             //把任务给指定的进程
    96.             SendAndWakeup(slots[choice].first,slots[choice].second,command);
    97.             sleep(1);
    98.     }
    99.     //关闭fd，结束所有的进程
    100.     //关闭所有的写的文件描述符
    101.     //所有的子进程在读取完之后都会退出
    102.     for(const auto &slot:slots)
    103.     {
    104.         close(slot.second);
    105.     }
    106.  
    107.     //回收所有的子进程。
    108.     for(const auto &slot:slots)
    109.     {
    110.         //等待全部的子进程
    111.         waitpid(slot.first,nullptr,0);
    112.     }
    113. }

    手动派发任务的版本 

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include"Task.hpp"
    8. #include
    9. #include
    10. //默认创建的进程个数
    11. #define PROCESS_NUM 5
    12.  
    13. using namespace std;
    14.  
    15.  
    16. //等待命令
    17. int waitCommand(int waitfd,bool&quit)
    18. {
    19.     uint32_t command=0;
    20.     ssize_t s=read(waitfd,&command,sizeof(command));
    21.     //如果读取到对应的0，那么就是文件描述符关掉了，就直接退出
    22.     if(s==0)
    23.     {
    24.         quit=true;
    25.         return -1;
    26.     }
    27.     //看看有没有读取成功
    28.     assert(s==sizeof(uint32_t));
    29.     return command;
    30. }
    31.  
    32. //拖过文件描述符像进程发送命令
    33. void SendAndWakeup(pid_t who,int fd,uint32_t command)
    34. {
    35.     write(fd,&command,sizeof(command));
    36.     cout<<"main process: call process"<"execute"<"through"<
    37. }
    38.  
    39. int main()
    40. {
    41.     //将任务装载进来
    42.     load();
    43.     //子进程的pid_t，信道pipfd的键值对
    44.     //表示一个一个进程相关的信息
    45.     vectorpid_t,int>> slots;
    46.     //先创建多个进程
    47.     for(int i=0;i
    48.     {
    49.         //创建管道
    50.         int pipedf[2]={0};
    51.         int n=pipe(pipedf);
    52.         assert(n==0);
    53.         (void)n;
    54.  
    55.         //创建子进程
    56.         pid_t id=fork();
    57.         assert(id!=-1);
    58.         //子进程我们让他进行读取
    59.         if(id==0)
    60.         {
    61.             //child，进行读取，关闭写入端
    62.             close(pipedf[1]);
    63.             while(true)
    64.             {
    65.                 //等待命令
    66.                 bool quit=false;
    67.                 int command=waitCommand(pipedf[0],quit);//如果对方不发，我们就阻塞
    68.                 if(quit)
    69.                    break;
    70.                 //执行对应的命令
    71.                 if(command>=0&&command<handlerSize())
    72.                 {
    73.                     callbacks[command]();
    74.                 }
    75.                 else
    76.                 {
    77.                     cout<<"非法command:"<
    78.                 }
    79.             }
    80.             exit(1);
    81.         }
    82.         //father，进行写入，关闭读取端
    83.         close(pipedf[0]);
    84.         slots.push_back(pair<pid_t,int>(id,pipedf[1]));
    85.     }
    86.     //父进程派发任务
    87.     //将任务均衡地拍付给每一个任务称为单机版的负载均衡
    88.     srand((unsigned long)time(nullptr) ^ getpid()^2332313L);//让我们的数据源更随机
    89.     while(true)
    90.     {
    91.         int select;
    92.         int command;
    93.         cout<<"##########################################"<
    94.         cout<<"#  1. show functions    2.send command   #"<
    95.         cout<<"##########################################"<
    96.         cout<<"Please Select>"<
    97.         cin>>select;
    98.         if(select==1)
    99.         {
    100.             showHandler();
    101.         }
    102.         else if(select=2)
    103.         {
    104.             cout<<"Enter Your Command>";
    105.             //选择任务
    106.             cin>>command;
    107.             //发送命令，并且唤醒子进程
    108.             //选择进程
    109.  
    110.         //选择一个任务，如果这个任务是从网络中来的？
    111.         // int command=rand()%handlerSize();
    112.         //采用随机数的方式，选择进程来完成任务，这是一种随机数的方式来实现负载均衡。
    113.             int choice=rand()%slots.size();
    114.         //     //布置任务
    115.         //     //把任务给指定的进程
    116.             SendAndWakeup(slots[choice].first,slots[choice].second,command);
    117.             // sleep(1);
    118.         }else
    119.         {
    120.             cout<<"该指令不再可以选择的范围内"<
    121.             continue;
    122.         }
    123.     }
    124.     //关闭fd，结束所有的进程
    125.     //关闭所有的写的文件描述符
    126.     //所有的子进程在读取完之后都会退出
    127.     for(const auto &slot:slots)
    128.     {
    129.         close(slot.second);
    130.     }
    131.  
    132.     //回收所有的子进程。
    133.     for(const auto &slot:slots)
    134.     {
    135.         //等待全部的子进程
    136.         waitpid(slot.first,nullptr,0);
    137.     }
    138. }

    管道读写规则

    当没有数据可读时
    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将不再保证写入的原子性。

    三、命名管道

    要两个不同的进程看到同一份资源，才能建立起管道。

    磁盘上可以创建一个管道文件。

    管道文件可以被打开，但是不会将内存数据进行刷新到磁盘。

    该文件一定在系统路径中，路径具有唯一性。

    双方进程就可以通过管道文件的路径，看到同一份资源！

    与匿名文件的差别是匿名文件仅仅是在内存中创建了一个文件，由父子进程进行访问

     而命名管道的管道文件也是内存中的文件，但是在磁盘上有一个映射，有文件目录。

    mkfifo 

    mkfifo name_pipe

    p开头的，我们将其称为管道文件

    echo "hello world" >name_pipe

    我写了，但是对方还没有打开，此时这个文件就处于阻塞状态

    我们将数据从管道中独取出来

    cat

     

    现在我们尝试循环输入hello world 

     while :; do echo "hello world"; sleep 1; done >name_pipe

    在另外一个终端进行接收 

    cat

    删除管道文件

    unlink name_pipe

    制作管道实验

    man 3 mkfifo

    1.日志头文件Log.hpp

    1. #ifndef _LOG_H_
    2. #define _LOG_H_
    3.  
    4. #include
    5. #include
    6.  
    7.  
    8. #define Debug 0
    9. #define Notice 1
    10. #define Waring 2
    11. #define Error 3
    12.  
    13.  
    14. //定义日志的几种状态
    15. const std::string msg[]={
    16.     "Debug",
    17.     "Notice",
    18.     "Warning",
    19.     "Error"
    20. };
    21. std::ostream &Log(std::string message,int level)
    22. {
    23.     //时间，日志信息
    24.     std::cout<<"|"<<(unsigned)time(nullptr)<<"|"<"|"<
    25.     return std::cout;
    26. }
    27.  
    28. #endif

    2.公共头文件comm.hpp

    1. #ifndef _COMM_H_
    2. #define _COMM_H_
    3.  
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include "Log.hpp"
    13. using namespace std;
    14. //设置管道文件的权限
    15. #define MODE 0666
    16. //缓冲区的大小
    17. #define SIZE 128
    18. //管道文件的路径
    19. string ipcPath="./fifo.ipc";
    20.  
    21.  
    22. #endif

    3.客户端文件client.cc

    1. #include"comm.hpp"
    2.  
    3. int main()
    4. {
    5.     //1.获取管道文件，以写的方式打开
    6.     int fd=open(ipcPath.c_str(),O_WRONLY);
    7.     if(fd<0)
    8.     {
    9.         perror("open");
    10.         exit(1);
    11.     }
    12.     //2.ipc过程
    13.     //创建要发送的字符串
    14.     string buffer;
    15.     while(true)
    16.     {
    17.         cout<<"Please Enter Messaage Line  :> ";
    18.         //将字符串放入buffer中
    19.         std::getline(std::cin,buffer);
    20.         //将buffer写入管道文件中
    21.         write(fd,buffer.c_str(),buffer.size());
    22.     }
    23.     //3.关闭文件
    24.     close(fd);
    25.     return 0;
    26. }

    4.服务端文件server.cc 

    1. #include"comm.hpp"
    2. #include
    3. static void getMessage(int fd)
    4. {
    5.     char buffer[SIZE];
    6.     while(true)
    7.     {
    8.         memset(buffer,'\0',sizeof(buffer));
    9.         ssize_t s=read(fd,buffer,sizeof(buffer)-1);
    10.         if(s>0){
    11.             cout<<"["<<getpid()<<"]"<<"client say>"<
    12.         }else if(s=0){
    13.             //end of file
    14.             cerr<<"["<<getpid()<<"]"<<"read end of file,clien quit,server quit too!"<
    15.             break;
    16.         }else{
    17.             //read error
    18.             perror("read");
    19.             break;
    20.         }
    21.     }
    22. }
    23. int main()
    24. {
    25.     //1、创建管道文件
    26.     if(mkfifo(ipcPath.c_str(),MODE)<0)
    27.     {
    28.         perror("mkfifo");
    29.         exit(1);
    30.         
    31.     }
    32.     //写日志
    33.     Log("创建管道文件成功",Debug)<<"step 1"<
    34.     //2.正常的文件操作
    35.     int fd=open(ipcPath.c_str(),O_RDONLY);
    36.     if(fd<0)
    37.     {
    38.         perror("open");
    39.         exit(2);
    40.     }
    41.     Log("打开管道文件成功",Debug)<<"step 2"<
    42.  
    43.     //这里我们创建了三个进程来读取
    44.     int nums=3;
    45.     for(int i=0;i
    46.     {
    47.         pid_t id=fork();
    48.         if(id==0)
    49.         {
    50.             //通信
    51.             getMessage(fd);
    52.             exit(2);
    53.         }
    54.     }
    55.     //回收子进程
    56.     for(int i=0;i
    57.     {
    58.         waitpid(-1,nullptr,0);
    59.     }
    60.     //3.编写正常的通信代码
    61.     //创建缓冲区
    62.     char buffer[SIZE];
    63.     while(true)
    64.     {
    65.         //将缓冲区清空
    66.         memset(buffer,'\0',sizeof(buffer));
    67.         //将管道中的内容读取到缓冲区中
    68.         ssize_t s=read(fd,buffer,sizeof(buffer)-1);
    69.         //如果读取成功的话
    70.         if(s>0){
    71.             cout<<"["<<getpid()<<"]"<<"client say>"<
    72.         }else if(s=0){
    73.         //如果读取到了结尾的位置
    74.             //end of file
    75.             cerr<<"["<<getpid()<<"]"<<"read end of file,clien quit,server quit too!"<
    76.             break;
    77.         //如果读取失败了
    78.         }else{
    79.             //read error
    80.             perror("read");
    81.             break;
    82.         }
    83.     }
    84.     //4.关闭文件
    85.     close(fd);
    86.     Log("关闭管道文件成功",Debug)<<"step 3"<
    87.     unlink(ipcPath.c_str());//通信完毕，删除文件
    88.     Log("删除管道文件成功",Debug)<<"step 4"<
    89.     return 0;
    90. }

    使用makefile创建我们的工程 

    1. .PHONY:all
    2. all:client mutiServer
    3.  
    4. client:client.cc
    5. 	g++ -o $@ $^ -std=c++11
    6. mutiServer:server.cc
    7. 	g++ -o $@ $^ -std=c++11
    8. .PHONY:clean
    9. clean:
    10. 	rm -f client mutiServer

    我们观察到这里是我们创建的三个管道争抢着接收我们的客户端发送的信息的，谁抢到了谁就将信息发送出来。

    四、system v共享内存

    1.原理：

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

    共享内存的建立

    这一块共享内存既不属于左边的进程也不属于右边的进程，它属于操作系统。共享内存的提供者是操作系统。

    共享内存是操作系统单独设立的内核模块，专门负责进程间通信。

    如果每一对进程通信都需要用共享内存，那么操作系统要不要对其进行管理呢？

    （管道的管理和文件系统的管理差不多，所以操作系统不用单独地去管理）

    先描述，再组织！

    重新理解共享内存

     共享内存=共享内存块+对应的共享内存的内核数据结构

    shmget

    创建并获取共享内存，size为大小，shmflg为IPC_CREAT或者IPC_EXCL，其中IPC_CREAT就是0

    IPC_CREAT：创建共享内存的时候，如果系统底层已经存在，那么直接获取之，并且返回，如果不存在，就创建之，并返回。

    IPC_EXCL：单独使用IPC_EXCL是没有意义的

    IPC_CREAT和IPC_EXCL合起来使用，如果底层不存在，创建之，并返回，如果底层存在，出错返回。

    返回成功，一定是一个全新的shm。

    返回值共享内存的用户层标识符，类似曾经的fd

    这里的key是什么呢

    要通信的对方进程，怎么保证对方能看到，并且看到的就是我创建饿共享内存呢？

    通过key，key的数据是多少不重要，只要能够在系统中唯一即可。server&&client使用同一个key，只要key值相同，就是看到了同一个共享内存。

    使用同样的算法规则，形成唯一的key值就可以了。

    只有创建的时候用key，大部分情况用户访问共享内存，都用的是shmid

    ftok

    需要传入一个路径（pathname）和项目ID， 

    ftok算法就是将路径和项目id合并起来，形成一个唯一值。但是由于这里创建出来的键值底层可能也会有，所以我们这里的ftok不一定会创建成功

    让我们客户端和服务器端的key值相同

    客户端 

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     key_t k =ftok(PATH_NAME,PROJ_ID);
    5.     Log("create key done",Debug)<<"Client say :"<
    6.     return 0;
    7. }

    服务器端 

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     //1.创建公共的key值
    5.     key_t k =ftok(PATH_NAME,PROJ_ID);
    6.     Log("create key done",Debug)<<"Server say:"<
    7.  
    8.     return 0;
    9. }

    comm.hpp

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include "Log.hpp"
    9. using namespace std;
    10.  
    11. #define PATH_NAME "/home/zhuyuan"
    12. #define  PROJ_ID 0x66

    makefile

    1. .PHONY:all
    2. all:client server
    3.  
    4. client:shmClient.cc
    5. 	g++ -o $@ $^ -std=c++11
    6. server:shmServer.cc
    7. 	g++ -o $@ $^ -std=c++11
    8. .PHONY:clean
    9. clean:
    10. 	rm -f client server

     ipcs -m查看系统当中的共享内存

    我运行完了，但是共享内存还在。

    ipcrm -m关闭共享内存

     

    system V IPC资源的生命周期随内核！除非重启，否则一直存在

    1.手动删除

    2.代码删除

    我们可以使用下面的shmctl来关闭共享内存

    shmctl

    监控脚本

    while :; do ipcs -m ;sleep 1; done

    attach关联 detach不关联，

    n表示个数，attach表示关联，表示有多少个进程和我们的共享内存是关联的

    ​​​​​​​ 

    SHMAT

    接下来我们就要创建共享内存

    shmat的参数中,shmaddr共享内存的虚拟地址，我们写0，让操作系统帮我们填写，shmflg，选择挂载方式，我们写0，让操作系统进行填写 

    SHMDT

     然后将我们创建的共享内存和我们的程序关联起来，shmaddr就是我们共享内存的虚拟地址

     1.创建makefile文件

    1. .PHONY:all
    2. all:client server
    3.  
    4. client:shmClient.cc
    5. 	g++ -o $@ $^ -std=c++11
    6. server:shmServer.cc
    7. 	g++ -o $@ $^ -std=c++11
    8. .PHONY:clean
    9. clean:
    10. 	rm -f client server

    2.日志头文件Log.hpp

    1. #ifndef _LOG_H_
    2. #define _LOG_H_
    3.  
    4. #include
    5. #include
    6.  
    7.  
    8. #define Debug 0
    9. #define Notice 1
    10. #define Waring 2
    11. #define Error 3
    12.  
    13. //不同的状态
    14. const std::string msg[]={
    15.     "Debug",
    16.     "Notice",
    17.     "Warning",
    18.     "Error"
    19. };
    20. //将时间，状态和信息介入日志中，并且打印出来
    21. std::ostream &Log(std::string message,int level)
    22. {
    23.     //时间，日志信息
    24.     std::cout<<"|"<<(unsigned)time(nullptr)<<"|"<"|"<
    25.     return std::cout;
    26. }
    27.  
    28. #endif

    3.共享的头文件comm.hpp

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include "Log.hpp"
    9. #include
    10. #include
    11. using namespace std;
    12.  
    13. //定义项目的路径，为了我们的key值的生成
    14. #define PATH_NAME "/home/zhuyuan"
    15. //定义项目的id，这个值可以自己取
    16. #define  PROJ_ID 0x66
    17. #define SHM_SIZE 4096//共享内存的大小，最好是页（PAGE:4096）的整数倍

    4.客户端文件shmClient.cc

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     //创建我们上述的key值，用于我们的两个进程都找到这一块共享内存
    5.     key_t k =ftok(PATH_NAME,PROJ_ID);
    6.     //如果key值创建失败了，也就是我们的底层已经有这一个key值了，它会返回-1
    7.     if(k<0)
    8.     {
    9.         Log("create key failed",Error)<<"Client say :"<
    10.         exit(1);
    11.     }
    12.     //如果创建成功，就将其写入日志当中
    13.     Log("create key done",Debug)<<"Client say :"<
    14.  
    15. //获取共享内存
    16. //shmid(key值，需要开辟的共享内存的大小，也就是定义在comm.hpp中的4096，以及创建共享内存的模式0就是我们上述的IPC_CREATE)
    17.     int shmid=shmget(k,SHM_SIZE,0);
    18.     //如果我们的共享内存开辟失败了，就返回失败信息，并且退出
    19.     if(shmid<0)
    20.     {
    21.         Log("create key failed",Error)<<"Client say :"<
    22.         exit(2);
    23.     }
    24.     Log("create key success",Debug)<<"Client say :"<
    25.     //睡眠10秒，便于我们下面的测试实验
    26.     sleep(10);
    27.  
    28.     //shmat(打开的共享内存的地址，链接地址shmaddr设置为nullptr，系统会帮我们填写，shmflg填写为0，也就是让系统帮我们填写权限)
    29.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    30.     //将共享内存段链接进地址空间
    31.     //如果链接失败了，就直接打印日志并返回
    32.     if(shmaddr==nullptr)
    33.     {
    34.         Log("attach shm failed",Error)<<"Client say :"<
    35.         exit(3);
    36.     }
    37.     Log("create shm success",Debug)<<"Client say :"<
    38.     sleep(10);
    39.  
    40.     //去关联
    41.     //将共享内存段与当前进程脱离
    42.     int n=shmdt(shmaddr);
    43.     //如果脱离失败了，就打印日志
    44.     assert(n!= -1);
    45.     Log("detach shm success",Debug)<<"Client say :"<
    46.     sleep(10);
    47.  
    48.     //client要不要chmctl删除呢？不需用server会删的。
    49.     return 0;
    50. }

    5.服务端头文件shmServer.cc

    1. #include"comm.hpp"
    2.  
    3. //将k转换成十六进制进行输出
    4. string TransToHex(key_t k)
    5. {
    6.     char buffer[32];
    7.     snprintf(buffer,sizeof buffer,"0x%x",k);
    8.     return buffer;
    9. }
    10. int main()
    11. {
    12.     //1.创建公共的key值
    13.     //这里的创建key值的参数和我们的客户端是一样的，所以我们能够得到一个和客户端相同的key值
    14.     key_t k =ftok(PATH_NAME,PROJ_ID);
    15.     //如果创建失败了
    16.     assert(k!=-1);
    17.     Log("create key done",Debug)<<"Server say:"<<TransToHex(k)<
    18.  
    19.     //2.创建共享内存，建议要创建一个全新的共享内存--通信的发起者
    20.     //0666表明我们的操作权限
    21.     //这里的标志位我们是通过或的方式拼装的
    22.     int shmid =shmget(k,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    23.     //如果创建失败了就写日志，并且退出
    24.     if(shmid==-1)
    25.     {
    26.         perror("shmget");
    27.         exit(1);
    28.     }
    29.     Log("create shm done",Debug)<<" shmid :"<
    30.  
    31.     sleep(10);
    32.     //3.将指定的共享内存，挂载到自己的地址空间
    33.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    34.     Log("attach shm done",Debug)<<" shmid :"<
    35.  
    36.     sleep(10);
    37.  
    38.     //这里就是通信的逻辑了
    39.  
    40.  
    41.     //4.将指定的共享内存，从自己的地址中空间中去关联
    42.     int n=shmdt(shmaddr);
    43.     assert(n!=-1);
    44.     (void)n;
    45.     Log("detach shm done",Debug)<<" shmid :"<
    46.     sleep(10);
    47.  
    48.  
    49.     //last.删除共享内存,IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    50.     //shmid是我们共享内存的地址
    51.     n=shmctl(shmid,IPC_RMID,nullptr);
    52.     assert(n!=-1);
    53.     (void)n;
    54.     Log("del shm done",Debug)<<" shmid :"<
    55.  
    56.     return 0;
    57. }

    这里我们先启动server，也就是服务器的程序，然后启动客户端的程序，然后在监控脚本中查看我们的共享内存的连接状况

    ​​​​​​​ 

    监控脚本的结果截图 

    这里我们的服务器端程序先被启动，创建了共享内存，在将共享内存挂载到自己的地中空间之后休眠了10秒，然后再去除与共享内存的关联，然后再等待10秒过后，我们的客户端将共享内存的空间给释放 

    这里我们的客户端程序后被启动，在开辟了共享内存之后休眠了10秒，在链接了共享内存之后由休眠了10秒，然后再等待10秒过后

    所以我们观察到我们的共享内存的链技术先是从0变成了1，也就是我们的服务器端连接了，然后再变成了2，也就是我们的客户端也连接了，然后又变成了1，也就是我们的服务器端退出了，然后变成0，也就是我们的客户端也退出了

    堆栈之间的共享区域是属于内核的还是用户的？

    这一部分区域是属于用户空间的。

    也就是不用经过系统调用，可以直接访问

    双方进程如果想要通信，直接进行内存级的读和写即可。

    为什么pipe,fifo都要通过read,write来进行通信，为什么？

    像read和write都是系统调用接口。

    这样的接口调用都是属于系统调用。

    因为其调用的管道其实都是属于文件，而文件是内核当中的特定数据结构，是由操作系统进行维护的。

    而我们的共享内存是在堆栈之间的，是属于用户的空间

    ​​​​​​​我们上面的所有的工作 属于什么工作呢？

    让不同的进程看到同一份资源

    6.初步实现进程间通信

    shmClient

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     Log("child pid is:",Debug)<<getpid()<
    5.     //创建我们上述的key值，用于我们的两个进程都找到这一块共享内存
    6.     key_t k =ftok(PATH_NAME,PROJ_ID);
    7.     //如果key值创建失败了，也就是我们的底层已经有这一个key值了，它会返回-1
    8.     if(k<0)
    9.     {
    10.         Log("create key failed",Error)<<"Client say :"<
    11.         exit(1);
    12.     }
    13.     //如果创建成功，就将其写入日志当中
    14.     Log("create key done",Debug)<<"Client say :"<
    15.  
    16. //获取共享内存
    17. //shmid(key值，需要开辟的共享内存的大小，也就是定义在comm.hpp中的4096，以及创建共享内存的模式0就是我们上述的IPC_CREATE)
    18.     int shmid=shmget(k,SHM_SIZE,0);
    19.     //如果我们的共享内存开辟失败了，就返回失败信息，并且退出
    20.     if(shmid<0)
    21.     {
    22.         Log("create key failed",Error)<<"Client say :"<
    23.         exit(2);
    24.     }
    25.     Log("create key success",Debug)<<"Client say :"<
    26.     //睡眠10秒，便于我们下面的测试实验
    27.     // sleep(10);
    28.  
    29.     //shmat(打开的共享内存的地址，链接地址shmaddr设置为nullptr，系统会帮我们填写，shmflg填写为0，也就是让系统帮我们填写权限)
    30.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    31.     //将共享内存段链接进地址空间
    32.     //如果链接失败了，就直接打印日志并返回
    33.     if(shmaddr==nullptr)
    34.     {
    35.         Log("attach shm failed",Error)<<"Client say :"<
    36.         exit(3);
    37.     }
    38.     Log("create shm success",Debug)<<"Client say :"<
    39.     // sleep(10);
    40.  
    41.     //使用
    42.     //client将共享内存看做一个char类型的buffer
    43.     char a='a';
    44.     for(;a<='c';a++)
    45.     {
    46.         //我们是每一次都向shmaddr[共享内存的起始地址]写入
    47.         snprintf(shmaddr,SHM_SIZE-1,"hello serve,我是其它进程，我的pid，%d,inc:%c\n",getpid(),a);
    48.         sleep(5);
    49.     }
    50.     //想共享内存中拷贝一个quit
    51.     strcpy(shmaddr,"quit");
    52.     //去关联
    53.     //将共享内存段与当前进程脱离
    54.     int n=shmdt(shmaddr);
    55.     //如果脱离失败了，就打印日志
    56.     assert(n!= -1);
    57.     Log("detach shm success",Debug)<<"Client say :"<
    58.     // sleep(10);
    59.  
    60.     //client要不要chmctl删除呢？不需用server会删的。
    61.     return 0;
    62. }

     shmServer

    1. #include"comm.hpp"
    2.  
    3. //将k转换成十六进制进行输出
    4. string TransToHex(key_t k)
    5. {
    6.     char buffer[32];
    7.     snprintf(buffer,sizeof buffer,"0x%x",k);
    8.     return buffer;
    9. }
    10. int main()
    11. {
    12.     //1.创建公共的key值
    13.     //这里的创建key值的参数和我们的客户端是一样的，所以我们能够得到一个和客户端相同的key值
    14.     key_t k =ftok(PATH_NAME,PROJ_ID);
    15.     //如果创建失败了
    16.     assert(k!=-1);
    17.     Log("create key done",Debug)<<"Server say:"<<TransToHex(k)<
    18.  
    19.     //2.创建共享内存，建议要创建一个全新的共享内存--通信的发起者
    20.     //0666表明我们的操作权限
    21.     //这里的标志位我们是通过或的方式拼装的
    22.     int shmid =shmget(k,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    23.     //如果创建失败了就写日志，并且退出
    24.     if(shmid==-1)
    25.     {
    26.         perror("shmget");
    27.         exit(1);
    28.     }
    29.     Log("create shm done",Debug)<<" shmid :"<
    30.  
    31.     // sleep(10);
    32.     //3.将指定的共享内存，挂载到自己的地址空间
    33.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    34.     Log("attach shm done",Debug)<<" shmid :"<
    35.  
    36.     // sleep(10);
    37.  
    38.     //这里就是通信的逻辑了
    39.     //将共享内存当成一个大字符串
    40.     char bvuffeer[SHM_SIZE];
    41.     for(;;)
    42.     {
    43.         //共享内存上读取到了什么就打印什么
    44.         printf("%s\n",shmaddr);
    45.         if(strcmp(shmaddr,"quit")==0)
    46.         {
    47.             break;
    48.         }
    49.         sleep(1);
    50.     }
    51.  
    52.     strcmp(shmaddr,"quit");
    53.  
    54.     //4.将指定的共享内存，从自己的地址中空间中去关联
    55.     int n=shmdt(shmaddr);
    56.     assert(n!=-1);
    57.     (void)n;
    58.     Log("detach shm done",Debug)<<" shmid :"<
    59.     // sleep(10);
    60.  
    61.  
    62.     //last.删除共享内存,IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    63.     //shmid是我们共享内存的地址
    64.     n=shmctl(shmid,IPC_RMID,nullptr);
    65.     assert(n!=-1);
    66.     (void)n;
    67.     Log("del shm done",Debug)<<" shmid :"<
    68.  
    69.     return 0;
    70. }

    结论1：只要是通信双方使用共享内存，一方直接向共享内存中写入数据，另一方马上就可以看见这些数据

    所以共享内存是所有的进程间通信（IPC）速度最快的！

    为什么呢？

    因为共享内存不需要过多的拷贝。

    不需要将操作数据交给操作系统

     管道

    1.从键盘到我们的自己定义的缓冲区是我们的第一次拷贝

    2.从我们自己定义的缓冲区到管道文件是第二次拷贝

    3.从我们的管道文件拷贝到我们的用户层缓冲区是我们的第三次拷贝

    4.从我们的自己定义的缓冲区到打印到我们的屏幕上是我们的第四次拷贝

     共享内存

     进程间通信（客户端我们自己输入，服务器端读取数据）

    shmClient

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     Log("child pid is:",Debug)<<getpid()<
    5.     //创建我们上述的key值，用于我们的两个进程都找到这一块共享内存
    6.     key_t k =ftok(PATH_NAME,PROJ_ID);
    7.     //如果key值创建失败了，也就是我们的底层已经有这一个key值了，它会返回-1
    8.     if(k<0)
    9.     {
    10.         Log("create key failed",Error)<<"Client say :"<
    11.         exit(1);
    12.     }
    13.     //如果创建成功，就将其写入日志当中
    14.     Log("create key done",Debug)<<"Client say :"<
    15.  
    16. //获取共享内存
    17. //shmid(key值，需要开辟的共享内存的大小，也就是定义在comm.hpp中的4096，以及创建共享内存的模式0就是我们上述的IPC_CREATE)
    18.     int shmid=shmget(k,SHM_SIZE,0);
    19.     //如果我们的共享内存开辟失败了，就返回失败信息，并且退出
    20.     if(shmid<0)
    21.     {
    22.         Log("create key failed",Error)<<"Client say :"<
    23.         exit(2);
    24.     }
    25.     Log("create key success",Debug)<<"Client say :"<
    26.     //睡眠10秒，便于我们下面的测试实验
    27.     // sleep(10);
    28.  
    29.     //shmat(打开的共享内存的地址，链接地址shmaddr设置为nullptr，系统会帮我们填写，shmflg填写为0，也就是让系统帮我们填写权限)
    30.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    31.     //将共享内存段链接进地址空间
    32.     //如果链接失败了，就直接打印日志并返回
    33.     if(shmaddr==nullptr)
    34.     {
    35.         Log("attach shm failed",Error)<<"Client say :"<
    36.         exit(3);
    37.     }
    38.     Log("create shm success",Debug)<<"Client say :"<
    39.     // sleep(10);
    40.  
    41.     while(true)
    42.     {
    43.         //从0号文件中读取数据，也就是从我们的标准输入读取数据，直接放入我们的缓冲区中，大小为SHM_SIZE
    44.         ssize_t s=read(0,shmaddr,SHM_SIZE-1);
    45.         //如果我们的数据成功读取了
    46.         if(s>0)
    47.         {   //我们从标准输入读取到的字符串假设是abcd回车，也就是abcd\n
    48.             //但是由于我们是想要和沃尔玛的呢字符串quit进行比较，所以我们需要将\n修改成是\0
    49.             shmaddr[s-1]=0;
    50.             if(strcmp(shmaddr,"quit")==0)
    51.             {
    52.                 break;
    53.             }
    54.         }
    55.     }
    56.     
    57.     //去关联
    58.     //将共享内存段与当前进程脱离
    59.     int n=shmdt(shmaddr);
    60.     //如果脱离失败了，就打印日志
    61.     assert(n!= -1);
    62.     Log("detach shm success",Debug)<<"Client say :"<
    63.     // sleep(10);
    64.  
    65.     //client要不要chmctl删除呢？不需用server会删的。
    66.     return 0;
    67. }

     shmServer

    1. #include"comm.hpp"
    2.  
    3. //将k转换成十六进制进行输出
    4. string TransToHex(key_t k)
    5. {
    6.     char buffer[32];
    7.     snprintf(buffer,sizeof buffer,"0x%x",k);
    8.     return buffer;
    9. }
    10. int main()
    11. {
    12.     //1.创建公共的key值
    13.     //这里的创建key值的参数和我们的客户端是一样的，所以我们能够得到一个和客户端相同的key值
    14.     key_t k =ftok(PATH_NAME,PROJ_ID);
    15.     //如果创建失败了
    16.     assert(k!=-1);
    17.     Log("create key done",Debug)<<"Server say:"<<TransToHex(k)<
    18.  
    19.     //2.创建共享内存，建议要创建一个全新的共享内存--通信的发起者
    20.     //0666表明我们的操作权限
    21.     //这里的标志位我们是通过或的方式拼装的
    22.     int shmid =shmget(k,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    23.     //如果创建失败了就写日志，并且退出
    24.     if(shmid==-1)
    25.     {
    26.         perror("shmget");
    27.         exit(1);
    28.     }
    29.     Log("create shm done",Debug)<<" shmid :"<
    30.  
    31.     // sleep(10);
    32.     //3.将指定的共享内存，挂载到自己的地址空间
    33.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    34.     Log("attach shm done",Debug)<<" shmid :"<
    35.  
    36.     // sleep(10);
    37.  
    38.     //这里就是通信的逻辑了
    39.     //将共享内存当成一个大字符串
    40.     char bvuffeer[SHM_SIZE];
    41.     for(;;)
    42.     {
    43.         //共享内存上读取到了什么就打印什么
    44.         printf("%s\n",shmaddr);
    45.         if(strcmp(shmaddr,"quit")==0)
    46.         {
    47.             break;
    48.         }
    49.         sleep(1);
    50.     }
    51.  
    52.     strcmp(shmaddr,"quit");
    53.  
    54.     //4.将指定的共享内存，从自己的地址中空间中去关联
    55.     int n=shmdt(shmaddr);
    56.     assert(n!=-1);
    57.     (void)n;
    58.     Log("detach shm done",Debug)<<" shmid :"<
    59.     // sleep(10);
    60.  
    61.  
    62.     //last.删除共享内存,IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    63.     //shmid是我们共享内存的地址
    64.     n=shmctl(shmid,IPC_RMID,nullptr);
    65.     assert(n!=-1);
    66.     (void)n;
    67.     Log("del shm done",Debug)<<" shmid :"<
    68.  
    69.     return 0;
    70. }

    如果管道里面没有数据了，我们就没有办法读取了，如果我们的管道已经被写满了，我们的写入端就没有办法写入了。这就是管道的阻塞，也就是管道的访问控制，可以协调管道两端的访问控制。

    结论二：共享内存缺乏访问控制。

    共享内存天生就是为了给我们提供一种快速地访问内存的操作机制，所以我们的共享内存没有任何关于访问控制。

    无论共享内存中有没有数据，我们的server都会不停地读取，甚至读取和写入方根本就不知道对方的存在！不会因为没有内容就没有办法读取 

    这会导致并发问题

    假设我们的客户端想要完整地发送hello world

    如果没有控制的话，我们就可能在客户端只输入了hello的时候，我们的服务器端就将数据读取走了。

    我们就将其称为数据不一致问题

    上面的相关问题称为临界区和临界区资源问题

    用管道控制共享内存的访问控制 

    如果我想实现共享内存的访问控制呢？

    能实现，可以通过管道来实现。

    可以将管道的同步共享能力迁移到我们的共享内存中

    也就是我们的数据写完了，让server读取的时候，server才能读取，没有让server读的时候，server就不能读取

    log.hpp

    1. #ifndef _LOG_H_
    2. #define _LOG_H_
    3.  
    4. #include
    5. #include
    6.  
    7.  
    8. #define Debug 0
    9. #define Notice 1
    10. #define Waring 2
    11. #define Error 3
    12.  
    13. //不同的状态
    14. const std::string msg[]={
    15.     "Debug",
    16.     "Notice",
    17.     "Warning",
    18.     "Error"
    19. };
    20. //将时间，状态和信息介入日志中，并且打印出来
    21. std::ostream &Log(std::string message,int level)
    22. {
    23.     //时间，日志信息
    24.     std::cout<<"|"<<(unsigned)time(nullptr)<<"|"<"|"<
    25.     return std::cout;
    26. }
    27.  
    28. #endif

    comm.hpp

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include "Log.hpp"
    15. using namespace std;
    16.  
    17. #define PATH_NAME "/home/zhuyuan"
    18. #define  PROJ_ID 0x66
    19. #define SHM_SIZE 4096//共享内存的大小，最好是页（PAGE:4096）的整数倍
    20. #include 
    21.  
    22. //创建一个管道文件名的宏定义
    23. #define FIFO_NAME "./fifo"
    24.  
    25. //创建一个类，用于创建管道
    26. class Init
    27. {
    28. public:
    29.     Init()
    30.     {
    31.         //将权限掩码设置为0
    32.         umask(0);
    33.         //创建我们的管道，分别传入管道文件的地址，还有我们的读写的权限
    34.         int n = mkfifo(FIFO_NAME, 0666);
    35.  
    36.         //判断我们的管道是否创建成功
    37.         assert(n == 0);
    38.         //让其不要有告警
    39.         (void)n;
    40.         Log("create fifo success",Notice) << "\n";
    41.     }
    42.     ~Init()
    43.     {
    44.         //将我们的管道删除
    45.         unlink(FIFO_NAME);
    46.         Log("remove fifo success",Notice) << "\n";
    47.     }
    48. };
    49.  
    50. //定义我们的读取和写入模式
    51. #define READ O_RDONLY
    52. #define WRITE O_WRONLY
    53.  
    54. //封装接口，打开我们的文件
    55. int OpenFIFO(std::string pathname, int flags)
    56. {
    57.     //要打开的文件的路径还有打开文件的模式
    58.     int fd = open(pathname.c_str(), flags);
    59.     //判断是否打开成功
    60.     assert(fd >= 0);
    61.     return fd;
    62. }
    63.  
    64. //让进程进行等待
    65. void Wait(int fd)
    66. {
    67.     Log("等待中....", Notice) << "\n";
    68.     //将我们的temp写入我们的管道中。
    69.  
    70.     uint32_t temp = 0;
    71.     //将数据从fd管道中读取到我们的tmp中，读取4个字节的大小
    72.     ssize_t s = read(fd, &temp, sizeof(uint32_t));
    73.     //返回的s是否是我们读取到的字节的个数
    74.     assert(s == sizeof(uint32_t));
    75.     //置于从管道中读取到了是什么不重要，只是为了让它在这里进行等待
    76.     (void)s;
    77. }
    78.  
    79. //唤醒另外一个进程
    80. void Signal(int fd)
    81. {
    82.     uint32_t temp = 1;
    83.     //将我们的1写入我们的管道中
    84.     ssize_t s = write(fd, &temp, sizeof(uint32_t));
    85.     assert(s == sizeof(uint32_t));
    86.     (void)s;
    87.     Log("唤醒中....", Notice) << "\n";
    88. }
    89. //关闭我们的管道文件
    90. void CloseFifo(int fd)
    91. {
    92.     close(fd);
    93. }

    shmClint.cc

    1. #include"comm.hpp"
    2. int main()
    3. {
    4.     Log("child pid is:",Debug)<<getpid()<
    5.     //创建我们上述的key值，用于我们的两个进程都找到这一块共享内存
    6.     key_t k =ftok(PATH_NAME,PROJ_ID);
    7.     //如果key值创建失败了，也就是我们的底层已经有这一个key值了，它会返回-1
    8.     if(k<0)
    9.     {
    10.         Log("create key failed",Error)<<"Client say :"<
    11.         exit(1);
    12.     }
    13.     //如果创建成功，就将其写入日志当中
    14.     Log("create key done",Debug)<<"Client say :"<
    15.  
    16. //获取共享内存
    17. //shmid(key值，需要开辟的共享内存的大小，也就是定义在comm.hpp中的4096，以及创建共享内存的模式0就是我们上述的IPC_CREATE)
    18.     int shmid=shmget(k,SHM_SIZE,0);
    19.     //如果我们的共享内存开辟失败了，就返回失败信息，并且退出
    20.     if(shmid<0)
    21.     {
    22.         Log("create key failed",Error)<<"Client say :"<
    23.         exit(2);
    24.     }
    25.     Log("create key success",Debug)<<"Client say :"<
    26.     //睡眠10秒，便于我们下面的测试实验
    27.     // sleep(10);
    28.  
    29.     //shmat(打开的共享内存的地址，链接地址shmaddr设置为nullptr，系统会帮我们填写，shmflg填写为0，也就是让系统帮我们填写权限)
    30.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    31.     //将共享内存段链接进地址空间
    32.     //如果链接失败了，就直接打印日志并返回
    33.     if(shmaddr==nullptr)
    34.     {
    35.         Log("attach shm failed",Error)<<"Client say :"<
    36.         exit(3);
    37.     }
    38.     Log("create shm success",Debug)<<"Client say :"<
    39.     // sleep(10);
    40.  
    41.     int fd=OpenFIFO(FIFO_NAME,WRITE);
    42.     while(true)
    43.     {
    44.         //从0号文件中读取数据，也就是从我们的标准输入读取数据，直接放入我们的缓冲区中，大小为SHM_SIZE
    45.         ssize_t s=read(0,shmaddr,SHM_SIZE-1);
    46.         //如果我们的数据成功读取了
    47.         if(s>0)
    48.         {   //我们从标准输入读取到的字符串假设是abcd回车，也就是abcd\n
    49.             //但是由于我们是想要和沃尔玛的呢字符串quit进行比较，所以我们需要将\n修改成是\0
    50.             shmaddr[s-1]=0;
    51.             //客户端写入成功之后，唤醒服务端
    52.             Signal(fd);
    53.             if(strcmp(shmaddr,"quit")==0)
    54.             {
    55.                 break;
    56.             }
    57.         }
    58.     }
    59.     CloseFifo(fd);
    60.     //去关联
    61.     //将共享内存段与当前进程脱离
    62.     int n=shmdt(shmaddr);
    63.     //如果脱离失败了，就打印日志
    64.     assert(n!= -1);
    65.     Log("detach shm success",Debug)<<"Client say :"<
    66.     // sleep(10);
    67.  
    68.     //client要不要chmctl删除呢？不需用server会删的。
    69.     return 0;
    70. }

    shmServer

    1. #include"comm.hpp"
    2. //创建一个全局对象，对应的程序在加载的时候会自动构建全局变量，也就是调用该类的构造函数
    3. //也就是会帮我们自动创建管道文件
    4. //在我们的程序退出的时候，会自动进行析构，然后删除我们的管道文件
    5.  
    6. Init init;
    7.  
    8.  
    9. //将k转换成十六进制进行输出
    10. string TransToHex(key_t k)
    11. {
    12.     char buffer[32];
    13.     snprintf(buffer,sizeof buffer,"0x%x",k);
    14.     return buffer;
    15. }
    16. int main()
    17. {
    18.     //1.创建公共的key值
    19.     //这里的创建key值的参数和我们的客户端是一样的，所以我们能够得到一个和客户端相同的key值
    20.     key_t k =ftok(PATH_NAME,PROJ_ID);
    21.     //如果创建失败了
    22.     assert(k!=-1);
    23.     Log("create key done",Debug)<<"Server say:"<<TransToHex(k)<
    24.  
    25.     //2.创建共享内存，建议要创建一个全新的共享内存--通信的发起者
    26.     //0666表明我们的操作权限
    27.     //这里的标志位我们是通过或的方式拼装的
    28.     int shmid =shmget(k,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    29.     //如果创建失败了就写日志，并且退出
    30.     if(shmid==-1)
    31.     {
    32.         perror("shmget");
    33.         exit(1);
    34.     }
    35.     Log("create shm done",Debug)<<" shmid :"<
    36.  
    37.     // sleep(10);
    38.     //3.将指定的共享内存，挂载到自己的地址空间
    39.     char *shmaddr=(char*)shmat(shmid,nullptr,0);
    40.     Log("attach shm done",Debug)<<" shmid :"<
    41.  
    42.     // sleep(10);
    43.     //打开我们的管道文件，以读取的方式打开
    44.     int fd=OpenFIFO(FIFO_NAME,READ);
    45.     //这里就是通信的逻辑了
    46.     //将共享内存当成一个大字符串
    47.     char bvuffeer[SHM_SIZE];
    48.     for(;;)
    49.     {
    50.         //等待客户端将其唤醒
    51.         Wait(fd);
    52.         //共享内存上读取到了什么就打印什么
    53.         printf("%s\n",shmaddr);
    54.         if(strcmp(shmaddr,"quit")==0)
    55.         {
    56.             break; 
    57.         }
    58.         // sleep(1);
    59.     }
    60.     //strcmp(shmaddr,"quit");
    61.  
    62.     //4.将指定的共享内存，从自己的地址中空间中去关联
    63.     int n=shmdt(shmaddr);
    64.     assert(n!=-1);
    65.     (void)n;
    66.     Log("detach shm done",Debug)<<" shmid :"<
    67.     // sleep(10);
    68.  
    69.  
    70.     //last.删除共享内存,IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    71.     //shmid是我们共享内存的地址
    72.     n=shmctl(shmid,IPC_RMID,nullptr);
    73.     assert(n!=-1);
    74.     (void)n;
    75.     Log("del shm done",Debug)<<" shmid :"<
    76.     //关闭管道
    77.     CloseFifo(fd);
    78.  
    79.     return 0;
    80. }

    上面的代码就是利用了我们管道的特性，如果我们的管道中没有内容，我们的读取的进程就会被阻塞，如果我们的管道已经填满了，我们的管道的写入进程就会被阻塞。

    这里我们的server端进行wait等待我们的client端往管道中写入数据，一旦我们的client端往管道中写入数据的话，我们的server端就会读取到，然后进行打印我们从客户端读取到的信息 

    五、信号量

    基于对于共享内存的理解

    1.为了让进程间通信->首先让不同的进程之间看到同一份资源

    ->我们之前讲的所有的通信方式，本质都是优先解决一个问题

    ->让我们的不同进程看到同一份资源

    ->让不同的进程看到了同一份资源，比如内存共享，也带来了一些时序问题，造成数据不一致的问题！

    也就是我写我的，你写你的，我们两个之间没有任何的相关的问题。

    1.我们把多个进程（执行流）看到的公共的一份资源称为临界资源 

    2.我们把自己的进程，访问临界资源的代码称为临界区

    3.所以多个执行流互相运行的时候互相干扰，主要是我们不加保护地访问了同样的一份资源（临界资源）。在非临界区，多个执行流互相是不影响的！

            为了更好地进行临界区的保护，可以让多执行流在任何时候，都只有一个进程进入临界区，也就是我们所说的互斥。

    （你需要等到我访问完了，你才能进行访问）

    什么是信号量

    假设我们去看电影，电影里面只有一个VIP放映的位置。

    我们都想要去座那个位置。但是这个位置在任何时刻只能由一个人座。当我坐的时候，你不能打扰我。我占有这个座位，就称为我正在执行自己的临界区代码。

    这就是互斥

    互斥的本质是串行，但是串行的话，我们的多线程的效率就会降低。

    但是，如果我们的电影院中实际上有几百个位置，一般所有人在看电影之前都需要买票，来解决谁坐在哪里的问题。

    电影院就是我们的临界资源。

    我们每个人都想看电影，也就是我们每一个人都想执行自己的临界区代码

    看电影一定要有座位（放映厅里面的一个资源）

    那么这个座位真正属于你，是不是你自己坐在这个位置上，这个座位才属于你呢？

    并不是！

    我们为了避免多个人竞争同一个位置，我们先买票。

    在整个放映期间，这个位置都是给你留着的。

    也就是说，只要你买了票，你就拥有这个座位的使用权。

    这里的买票的本质就是座位的预定机制。

    也就是说我们有多个线程，想要访问这个临界区资源的不同部分，只要保证这些进程在临界区中访问的是不同的部分，就能够保证这些进程并发地执行。

    这就好比是我们上面的例子中，有200个人看电影，每一个人都有一个不同的位置的话，这两百个人就可以同时看一场电影。

    为了做到这一点，我们必须让每一个进程想进入临界资源，访问临界资源中的一部分，我们不能让进程直接去使用临界资源，正如不能让用户直接去电影院占座位。也就是说你得先申请信号量（也就是说你得先买票！）

    买票的时候，每一张票都有不同的编号，不同的座位编号。

    信号量的本质就是一个计数器，也及时类似于int count =n;（不准确）

    比方说我们的票有200张，我们这里的计数器也就是200。

    每一个进程想要进入临界区都需要申请信号量。 

    申请信号量的本质：

    让信号量计数器--

    也就是卖出了一张票，我们的作为就少了一个

    只要申请信号量成功，我们临界资源内部一定给你预留了你想要的资源。

    所以说申请信号量的本质其实是对临界资源的一种预定机制 

    申请信号量->访问临界资源->释放信号量（你把电影看晚了，这个票就作废了，这个椅子又可以给别人使用了。）

    释放信号量也就是让我们的信号量++ 

     信号量是一个计数器

    int n=10用一个整数，能不能表示信号量呢？

    父进程n--

    子进程n--

    不能用一个整型去代表信号量。因为即便是父子进程，在发生n--的时候，也会发生写时拷贝，并不能同时对一个n进行操作，父子进程的n是一人一个的，没办法同时进行影响。

    假设能让多个进程（整数n在共享内存中）看到同一份全局变量，大家都进行申请信号量n--

    也是不可以的！

    对于我们的client端

    先n--

     写入数据到共享内存中

    n++

    对于我们的server端

    也先n--

    读取共享内存

    然后n++

    他们同时对一个变量进行n--的时候是会出问题的！

    在我们的计算机中，我们想要进行n--，其是一种数据运算，我们的计算机汇总只有cpu具有计算能力，而我们的数据放在n的位置上，而n在内存中。也就是计算要在cpu内，而变量在内存中。

    那么cpu在执行我们的指令的时候

    1、首先需要load将内存中的数据加载到cpu内的寄存器中（读指令） 

    2.n--（分析&&执行指令）

    3.将CPU修改完毕的n写回内存（写回结果）

    执行流在执行的时候，在任何时候都可能被切换！

    上面的执行--操作有三步，随时可能会被切换掉。

    寄存器只有一套，被所有的执行流共享，但是寄存器里面的数据属于每一个执行流，是与该执行流的上下文！

    进程在被切换的时候，是需要进行上下文保护&&上下文恢复的。 

    假设这里我们的n是2

    所以我们的client进入到cpu中，此时我们得到n等于2，也就是我们运行到上述的第一步，我们的client进程就被切换掉了，我们将client对应的数据和需要执行第几部（n=2，第二步）都记录下来。那我们寄存器中的n还是2，我们进程client中的n是2。

    然后server 进程到CPU上运行了，将2--变成了1。

    然后我们的client回来了，我们的client回来的时候需要将我们的原先的进程上下文给恢复，也就是直接将我们此时为1的信号量重置为了2，然后执行--操作，变成了1。

    也就代表着我们此时的信号量已经不能准确地表示我们的进入临界区的进程个数了！

    n--：因为时序问题，而导师n有中间状态，可能导致数据不一致！

    我们称这里的n为不安全的。

    如果一个n--操作只有一行汇编，

    那么该操作是原子的！

    （我们上面的n--并不是原子的） 

    什么是原子性？

    原子性：要么不做，要么做完，没有中间状态，我们就将其称为原子性！ 

    上面我们的整数计数器也成了临界资源！

    所以上面的整数计数器首先需要保证自身是安全的，然后才能保证我们的线程是安全的。 

    信号量计数器

    申请信号量-》计数器--      -》P操作-》必须是原子的

    释放信号量-》计数器++     -》V操作-》必须是原子的 

    信号量是对临界资源的预定机制！

    信号量本身也是一份临界资源，也需要保持其原子性 

     想要让我们所有的进程都看到这一份同样的信号量就需要进程间通信。（看到一份同样的资源）

  • 相关阅读:
    简单实现接口自动化测试(基于python+unittest)
    【MySQL】-【变量、流程控制、游标】
    MYSQL学习笔记2-mysql数据文件
    关于 passing ‘const xx’ as ‘this’ argument of 的错误
    46、video-nerf
    Python算法——树的最大深度和最小深度
    （AtCoder Beginner Contest 321）(退背包，二叉树)
    用 Wireshark 在 Firefox 或 Google Chrome 上使用 SSLKEYLOGFILE 环境变量解密 SSL 流量
    面试官：Redis如何保证高可用？
    PWmat案例赏析：计算精度高、速度快的第一性原理计算，研究表面终端结构对NV色心影响
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/127706206