历程间通信大总结Linux

目次
历程间通信介绍
历程间通信目的
历程间通信发展
历程间通信分类
管道
System V IPC
POSIX IPC
管道
什么是管道
匿名管道
用fork来共享管道原理
站在文件描述符角度-深度理解管道

管道读写规则
管道特点
命名管道
创建一个命名管道
匿名管道与命名管道的区别
命名管道的打开规则

system V共享内存
共享内存示意图
共享内存数据布局
共享内存函数
shmget函数
shmat函数
shmdt函数
shmctl函数
自己总结
共享内存
​编辑

---

   

• 历程间通信介绍
  
• 管道
  
• 消息队列
  
• 共享内存
  
• 信号量
  

  历程间通信介绍

历程间通信目的

   

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

  历程间通信发展

   

• 管道
  
• System V历程间通信
  
• POSIX历程间通信
  

  历程间通信分类

管道

   

• 匿名管道pipe
  
• 命名管道
  

  System V IPC

   

• System V 消息队列
  
• System V 共享内存
  
• System V 信号量
  

  POSIX IPC

   

• 消息队列
  
• 共享内存
  
• 信号量
  
• 互斥量
  
• 条件变量
  
• 读写锁
  

  管道

什么是管道

   

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

  

匿名管道

匿名管道 Linux-CSDN博客    详细看这里

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

复制代码

管道
首先自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过体系调用（write）写到管道里，然后再通过read体系调用，被对方（读端）读取，就要从管道拷贝到读端，然后再表现到表现器上。
pipe创建一个管道
pipe的介绍

1完成这件事：

看图分析

运行效果

1. #include<iostream>
2. #include<unistd.h>
3. using namespace std;
4. int main()
5. {
6.     //创建管道
7.     //先创建一个pipefd数组
8.     int pipefd[2];
9.     //用n接受一下，判断是否成功
10.     int n = pipe(pipefd);
11.     if(n<0) return 1;//创建失败了
13.     //创建成功
14.     //测试一下文件描述符是3和4
15.     cout<<"pipefd[0]:"<<pipefd[0]<<"pipefd[1]:"<<pipefd[1]<<endl;
16.    
18.     return 0;
19. }

复制代码

2完成这件事：

创建一个子历程

1. pid_t id = fork();
2.     if(id < 0)return 2;//创建失败
3.     if(id == 0)//创建成功
4.     {
5.         //子进程
7.     }
8.     //父进程

复制代码

让子历程写入，父历程读取

要想让子历程历程写，就必要在历程中关闭读端

1. if(id == 0)//创建成功
2. {
3.      //子进程
4.      close(pipefd[0]);
5. }

复制代码

同理

1. //父进程
2. close(pipefd[1]);

复制代码

都用完竣事后，可以都关掉

1.     if(id == 0)//创建成功
2.     {
3.         //子进程
4.         close(pipefd[0]);
5.         //.....
6.         close(pipefd[1]);
7.     }
8.     //父进程
9.     close(pipefd[1]);
10.     //.....
11.     close(pipefd[0]);

复制代码

IPC code，写通信代码
3这件事也完成了：

布局就有了


然后在pipefd[1]这个管道里写，界说一个Writer函数ostream::write - C++ Reference (cplusplus.com)
istream::read - C++ Reference (cplusplus.com)

1.     if(id == 0)//创建成功
2.     {
3.         //子进程
4.         close(pipefd[0]);
5.         //.....IPC code，写通信代码
6.         //在pipefd[1]这个管道里写
7.         Writer(pipefd[1]);
10.         close(pipefd[1]);
12.         exit(0);//正常退出
13.     }

复制代码

同理父历程的        

1.     //父进程
2.     close(pipefd[1]);
3.     //.....IPC code，写通信代码
4.     //在pipefd[0]这个管道里写
5.     Reader(pipefd[0]);
8.     close(pipefd[0]);

复制代码

1. //子进程
2. void Writer(int wfd)
3. {
5. }
6. //父进程
7. void Reader(int rfd)
8. {
10. }

复制代码

Writer

1. //子进程
2. void Writer(int wfd)
3. {
4.     string s = "hello,I am child";
5.     pid_t self = getpid();
6.     int number = 0;
8.     char buffer[10];
9.     while(true)
10.     {
11.         buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
13.     }
14. }

复制代码

用到snprintfsnprintf - C++ Reference (cplusplus.com)
介绍

将s和self和number放进buffer

1.   char buffer[100];
2.     while(true)
3.     {
4.         buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
5.         snprintf(buffer,sizeof(buffer),"%s    pid:%d\n",s.c_str(),self);
6.         cout<< buffer <<endl;
7.         sleep(1);
8.     };

复制代码

用cout打印测试一下，打印成功分析写入buffer成功了

等待历程少不了，子历程exit后必要接纳

1. //父进程
2.     close(pipefd[1]);
3.     //.....IPC code，写通信代码
4.     //在pipefd[0]这个管道里写
5.     Reader(pipefd[0]);
7.     //等待进程缺少不了
8.     pid_t rid = waitpid(id,nullptr,0);
9.     if(rid < 0) return 3;//等待失败了
11.     close(pipefd[0]);

复制代码

怎样把消息发送/写入给父历程
用到了write

用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0末端，和文件没有关系，wfd写入管道

1. //子进程
2. void Writer(int wfd)
3. {
4.     string s = "hello,I am child";
5.     pid_t self = getpid();
6.     int number = 0;
7.     char buffer[100];
8.     while(true)
9.     {
10.         buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
11.         snprintf(buffer,sizeof(buffer),"%s    pid:%d  %d\n",s.c_str(),self,number++);
12.         //用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道
13.         write(wfd,buffer,strlen(buffer));
14.         //cout<< buffer <<endl;
15.         sleep(1);
16.     };
17. }

复制代码

父历程该怎么读取呢
用到了read，fd是文件描述符，从特定的文件描述符里读取，放在这个buf里，buf的长度是count

这里就必要思量到\0，因为buffer中必要\0

1. //父进程
2. void Reader(int rfd)
3. {
4.     char buffer[100];
5.     while(true)
6.     {
7.         buffer[0] = 0;
8.                                     //用sizeof是为了留个空间放\0
9.         ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlen
10.         if(n > 0)
11.         {
12.             //添加\0，因为要放在buffer数组中读取
13.             buffer[n]=0;
14.             cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;
15.         }
16.     }
17. }

复制代码

运行效果
也会发现：为什么子历程sleep，父历程不sleep，父历程照旧会跟着子历程sleep，因为父子历程是要协同的

管道本质
通信是为了更好的发送变革的数据，管道本质上是文件
所以必须要用到体系调用接口来访问管道，其是由体系管理，read和write
，操纵体系相称于中介 
结论：管道的特征：
1：具有血缘关系的历程进行历程间通信
2：管道只能单向通信
3：父子历程是会历程协同的，同步与互斥的--掩护管道文件的数据安全
4：管道是面向字节省的
5：管道是基于文件的，而文件的生命周期是随历程的

1：具有血缘关系的历程进行历程间通信

2：管道只能单向通信

3：父子历程是会历程协同的，同步与互斥的--掩护管道文件的数据安全

4：管道是面向字节省的

5：管道是基于文件的，而文件的生命周期是随历程的

再测试，把子历程sleep去掉，就是让子历程写快一点，父历程sleep几秒，就是让父历程读慢一点，看有什么征象

 管道的四种情况

测试管道大小
把c一直往管道里写，把父历程中休眠50秒

效果差不多64kb

写端退了，测试效果

效果是：
读端正常读，写端关闭，读端就会读到0，表明读到了文件（pipe）末端，不会被阻塞
read读取成功会返回读到的字符个数，读到末端返回0

读到末端父历程也就可以停止读取了，break后去把僵尸的子历程接纳

break到这里

最后子历程会被waitpid接纳

测试子历程一直写，父历程读一会就退出
界说一个cnt控制退出的时间

这里也要修改一下，加个sleep(5),观察，close提前关闭

效果：通过13号信号杀死 

管道到的应用场景

都会酿成一个历程

写一个历程池(pipe_use)
首先创建好文件

创建5个历程

channel通道的意思

cmdfd文件描述符

slaverid代表哪个子历程

把它放进vector容器里

思绪步骤

管道创建
void（n），冒充利用一下，要不然编译不过

创建父子历程

父历程写，子历程读
子历程要读取，就要关闭自己的写端，父历程同理

子历程中的任务

子历程pid有了管道也有了，就差在父历程添加字段了

先更改一下，在class里构造一下

添加字段

测试一下：效果：文件描述符0，1，2是默认打开，3是从管道里读，4是写入管道

把初始化改造成函数

debug测试函数，纯输入函数

第二步开始控制历程了（想让子历程做什么）

这里打印的rfd都是3，正常吗，文件描述符是可以被子历程继承的

父历程对应的写端拿到的是4-8，子历程拿到的读端fd是3

改变一下，直接从键盘（0号描述符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不用传参了，父历程通过管道写，子历程通过标准输入读
用到了dup2，将从pipefd[0]中读酿成从0开始读

想让父历程固定的向管道里写入指定大小字节的内容，必须读取四个字节，四个字节四个字节的写和读，这里的管道64kb
必须读取四个字节

假如父历程不给子历程发送数据呢？阻塞等待!

开始控制子历程

生成一个随机数种子

可以随机选择任务和选择历程

cmd是任务码，测试一下，父历程控制子历程,父历程发送给子历程（通过cmdcode连续）

在Task.hpp里

要用到函数指针

main中的任务了就属于

再把任务装载进来

输出型参数用*

现在开始选择任务和历程

再把main中的任务弄玉成局的

进行判定一下

测试 ,comcode和任创建的任务同等

这里的write是父历程进行写入，向子历程发送，子历程不得闲，先写到管道里，等得闲了再读

也可以轮询选择，界说一个计数器，++弄，再%等


整理一下控制代码，这里是输入型参数，只必要读

这样就可以轮询方式选择历程了，不用随机了

效果

清算收尾
思绪：把全部文件的描述符都关掉

等待方式设置为0 

read返回0，就是失败了，然后slaver就会调完

竣事完就会exit直接退出

打印下更好表现

关闭文件描述符后sleep(10)秒，

然后这10个子历程一瞬间都应该break，然后最后到exit直接就退了，10秒竣事后，父历程再接纳他       

测试时不弄死循环，用cnt，5秒后自动竣事控制，正常退出流程

测试效果

手动控制一下

界说一个select，输入0就是退出了，判定完后，就走到了选择任务

然后直接把cmdcode改为选择的select，-1是因为是从下标0开始的，输入1就是0下标的

测试

bug的地方：
这样会有一些bug（一个子历程不是只有一个写端（每一次子历程的创建都是有继承））
 这样会有一些bug（一个子历程不是只有一个写端（每一次子历程的创建都是有继承））

按理说这样是对的，可是这样就错了

因为下面两个红线还没有关掉，它们历程了最开始的w

这样倒着接纳是可以的

正确改法

修改一下

最后一个push_back的就都是父历程的写入fd，

然后加一句这个红线的，每创建子历程后都先把上一次父历程的读端fd关掉就可以了，这里很妙，因为vector一开始是空的

方便看

这里这样就可以了        

管道已经完成

以上是匿名管道 

总文件总代码

makefile中代码

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

复制代码

Task.hpp中代码

1. #pragma once
3. #include<iostream>
4. #include<vector>
6. using namespace std;
8. typedef void (*task_t)();
10. void task1()
11. {
12.     cout<< "lol 刷新日志" <<endl;
13. }
15. void task2()
16. {
17.     cout<< "lol 更新野区" <<endl;
18. }
20. void task3()
21. {
22.     cout<< "lol 检测软件更新" <<endl;
23. }
25. void task4()
26. {
27.     cout<< "lol 释放技能" <<endl;
28. }

复制代码

ProcessPool.cc中代码

1. #include "Task.hpp"
2. #include<iostream>
3. #include<string>
4. #include<vector>
5. #include<unistd.h>
6. #include<assert.h>
7. #include <sys/types.h>
8. #include <sys/wait.h>
9. using namespace std;
11. //打算创建5个进程
12. const int processnum = 5;
13. //全局任务
14. vector<task_t> tasks;
17. //先描述
18. class channel//管道
19. {
20. public:
21.     channel(int cmdfd,pid_t slaverid,string& processname)
22.     :_cmdfd(cmdfd)
23.     ,_slaverid(slaverid)
24.     ,_processname(processname)
25.     {}
27. public:
28.     int _cmdfd;//文件描述符
29.     pid_t _slaverid;//代表哪个子进程
30.     string _processname;//子进程的名字,方便打印日志
31. };
33. //子进程中读的任务
34. // void slaver(int rfd)
35. // {
36. //     while(true)
37. //     {
38. //         cout<< getpid() <<" - "<< "read fd is->"<<rfd<<endl;
39. //         sleep(1000);
40. //     }
41. // }
42. //改变一下从fd为0的地方开始读
43. void slaver()
44. {
45.     //read(0);
46.     while(true)
47.     {
48.         int cmdcode = 0;
49.         int n = read(0, &cmdcode, sizeof(int));
50.         if(n == sizeof(int))
51.         {
52.             //执行cmdcode对应的任务列表
53.             cout<< "slaver say@ get a command:" << getpid() << ":cmdcode:" << cmdcode <<endl;
55.             //判断一下并执行
56.             if(cmdcode >= 0 && cmdcode < tasks.size())  tasks[cmdcode]();
57.         }
58.         if(n == 0) break;
59.     }
60. }
62. //初始化
63. void Init(vector<channel>& channels)
64. {
65.     for(int i =0;i < processnum;i++)
66.     {
67.         int pipefd[2];
68.         int n = pipe(pipefd);//创建管道
69.         //返回值小于0就创建失败了
70.         assert(!n);
71.         (void)n;
73.         pid_t id = fork();
74.         if(id == 0)
75.         {
76.             //子进程：读
77.             close(pipefd[1]);
79.             //改变一下从fd为0的地方读
80.             dup2(pipefd[0],0);
81.             close(pipefd[0]);
82.             //任务
83.             slaver();
84.             cout<< "process: " << getpid() << "quit" <<endl;
85.             //slaver(pipefd[0]);
87.             exit(0);
88.         }
89.         //父进程：写
90.         close(pipefd[0]);
91.         //channel添加字段
92.         string name = "processs-" + to_string(i);
93.         //插入的是自定义类型，要构造一下，第一个传的是文件描述符，要写入的fd
94.         channels.push_back(channel(pipefd[1], id, name));
95.     }
96. }
97. //测试函数,纯输入函数
98. //输入：const &
99. //输出：*
100. //输入输出：&
101. void debug(const vector<channel>& channels)
102. {
103.     for(auto&e : channels)
104.     {
105.         cout<< e._cmdfd <<"  "<<e._slaverid<<"   "<<e._processname<<endl;
106.     }
108. }
110. void Loadtask(vector<task_t> *tasks)
111. {   
112.     tasks->push_back(task1);
113.     tasks->push_back(task2);
114.     tasks->push_back(task3);
115.     tasks->push_back(task4);
116. }
117. void memu()
118. {
119.     cout<< "########################" <<endl;
120.     cout<< "1:lol 刷新日志     2:lol 更新野区" <<endl;
121.     cout<< "1:lol 检测软件更新   4:lol 释放技能" <<endl;
122.     cout<< "           0:退出             " <<endl;
123.     cout<< "########################" <<endl;
124. }
125. //2:开始控制子进程
126. void ctrlSlaver(vector<channel> &channels)
127. {
128.     int which = 0;
129.     int cnt = 5;
130.     while(true)
131.     {
132.         int select = 0;
133.         memu();
134.         cout<< "Please Enter@:";
135.         cin>> select;
136.         if(select == 0) break;
137.         //1：选择任务
138.         //int cmdcode = rand()%tasks.size();
139.         int cmdcode = select - 1;
141.         //2：随机选择进程
142.         //int processpos = rand()%channels.size();
143.         
144.         //2：轮询选择进程
145.         cout<< "father say:"<< "cmdcode:" << cmdcode << "   already sendto  " <<channels[which]._slaverid << "process name   "
146.             <<channels[which]._processname << endl;
148.         //3：发送任务
149.         write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));
150.         which++;
151.         which%=channels.size();//保证不大于其长度
152.         cnt--;
153.         if(cnt == 0) break;
154.         sleep(1);
155.     }
156. }
157. void QuitProcess(const vector<channel> &channels)
158. {
159.     for(const auto& e : channels) close(e._cmdfd);
160.     sleep(10);
161.     for(const auto& e : channels) waitpid(e._slaverid, nullptr, 0);//进程的pid=_slaverid，关上了以后记得回收
162. }
164. int main()
165. {
166.     Loadtask(&tasks);
168.     //srand(time(nullptr)^getpid()^1023);//种一个随机数种子
169.     //在组织
170.     vector<channel> channels;
171.     //1:初始化
172.     Init(channels);
174.     debug(channels);
176.     //2:开始控制子进程
177.     ctrlSlaver(channels);
179.     //3:清理收尾
180.     QuitProcess(channels);
182.     return 0;
183. }

复制代码

用fork来共享管道原理

站在文件描述符角度-深度理解管道

所以，看待管道，就犹如看待文件一样！管道的利用和文件同等，迎合了“Linux一切皆文件头脑”。

1. #include <unistd.h>
2. #include <stdlib.h>
3. #include <stdio.h>
4. #include <errno.h>
5. #include <string.h>

复制代码

1. #define ERR_EXIT(m) \ do \ { \ perror(m); \ exit(EXIT_FAILURE); \ } while(0)
2. int main(int argc, char *argv[]) { int pipefd[2]; if (pipe(pipefd) == -1) ERR_EXIT("pipe error");

复制代码

1. pid_t pid;
2. pid = fork();
3. if (pid == -1)
4. ERR_EXIT("fork error");
6. if (pid == 0) {
7. close(pipefd[0]);
8. write(pipefd[1], "hello", 5);
9. close(pipefd[1]);
10. exit(EXIT_SUCCESS);
11. }
13. close(pipefd[1]);
14. char buf[10] = {0};
15. read(pipefd[0], buf, 10);
16. printf("buf=%s\n", buf);
18. return 0;
19. }

复制代码

管道读写规则

   

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

  管道特点

   

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

  

命名管道

详细看这个
命名管道Linux-CSDN博客
   

• 管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的历程间通信。
  
• 假如我们想在不相干的历程之间交换数据，可以利用FIFO文件来做这项工作，它经常被称为命名管道。
  
• 命名管道是一种特殊类型的文件
  1. int main(int argc, char *argv[])
  2. {
  3. mkfifo("p2", 0644);
  4. return 0;
  5. }

  复制代码
  
  

  创建一个命名管道

   

• 命名管道可以从命令行上创建，命令行方法是利用下面这个命令：
  

1. $ mkfifo filename

复制代码

  

• 命名管道也可以从步伐里创建，相干函数有：
  

1. int mkfifo(const char *filename,mode_t mode);

复制代码

创建命名管道:

1. int main(int argc, char *argv[])
2. {
3. mkfifo("p2", 0644);
4. return 0;
5. }

复制代码

  管道是

毫不相干的历程历程间通信::命名管道
管道
首先自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过体系调用（write）写到管道里，然后再通过read体系调用，被对方（读端）读取，就要从管道拷贝到读端，然后再表现到表现器上。
mkfifo命名管道
1号手册是指令，。2号体系调用接口

创建一个管道，p开头就是命名管道，并不会直接革新到磁盘中，现实是个符号

这样会阻塞

这样会表现出来（先输入左边的，再输入右边的就会表现），左右两边是两个历程

>>追加写入的方式，但空间一直是0

所以这就是文件里大小一直是0的原因         

你怎么知道打开的是同一个文件

正好符合前提

所以要创建两个可执行步伐，各自跑各自的，创建一个common是为了方便利用头文件        
client是客户   server是服务者

makefile中一下运行两个步伐

mkfifo，用步伐的方式创建管道，第一个参数是要创建的这个管道在那个路径下叫什么名字，也就是要保持唯一性的那些点，第二个是创建一个管道
这里是3号手册是函数。

返回 -1创建失败 

创建一个共享文件
./myfifo

server.cc和client.cc想看到同一个文件，包罗上头文件就可以了

这里先用server控制管道文件

创建管道失败了设置为1 ,假如失败了就exit(1)

谁控制的先运行运行谁就好了
make一下生成两个可执行步伐,因为是server控制的，所以要先运行server

运行后就会多一个myfifo命名管道

命名管道的删除

想删除这个myfifo用unlink(成功返回0 ，失败返回-1） 
命令行删除

代码也可以删(成功返回0 ，失败返回-1)，头文件是unistd.h


创建完文件，5秒后就删除了

思绪

用到了open

打开管道文件，第二个参数是只进行读取

enum中

fd<0打开失败了

服务端读取数据

客户端，只要用就行
 第二个参数就是打开文件为了写入的

用户输入完成以后，就要发送输入的消息到另一端

打开顺序肯定
然后打开的顺序就肯定了，先打开server，然后再打开另一个cc
先打开服务端，会阻塞在这里，然后再打开客户端，进行输入

右边输入啥，左边就会有啥

无法输入空格问题（getline）
但有一个问题就是cin没法输入空格，，要用到getline

会发现一个问题，客户端退出了，服务端还没退出
客户端退出，会read到0，所以服务端（读端）也要退出

 改正

sever端

等待写入方式打开后，自己才会打开文件，向后执行，open阻塞了！


优化一下

写成历程池的样子

日志
创建一个新文件

用到了可变参数(形参实例化是从右到左)
可变参数必须右至少一个详细的参数
举个例子：步骤：s指向可变部门
这里的sum第一个参数是几个数求和的意思，传差别的类型不可以的，因为上面va_arg里已经写死了

开始写日志，level日志品级

先界说时间，time，时间戳

ctime
头文件

打印详细年月日 
年是从1900年开始的

 年月日时分秒

vsnprint
vsnprint，跟不带v的区别就是，去除了...换成了可变参数部门

把日志品级转换成字符串风格,全部有大概的地方都必要返回

改进
va_start(s,format)，用format修饰s的指向，上面的sum是（s,n),类似
这里要用c_str，因为返回的是string

用完以后再用end

这里是往表现器打印的,这里要*3，以为%s和%s中间有几个空格，空间不敷

把这里修改一下,打开失败的话

这样就形成日志了

打印最后一行就是正常打开

这里也改一下

测试，先./server，然后会阻塞，然后./client，就会打印出,logmessage里的信息
为啥./client之前不打印
因为等待写入方式打开后，自己才会打开文件，向后执行，open阻塞了！

往文件里打印（上面是往屏幕打印）
先把这些内容全放在Log,日志类

分类
1：向屏幕打印
2：向一个文件打印
3：分类打印

打印格式printMethod

这里构造默认往屏幕去印

析构

打印方式也改一下

打印单个
以0666的权限打开这个文件

打印多个文件（添加一下level）

实现一下

优化一下

以后再打印日志就不用这样打了

这样就可以了，要记住先创建一个Log对象

这样以后就写入一个文件了，写入log.txt

这样就把日志分类了

效果

但是日志文件这么多太杂乱了
这样操纵后就统一进入一个文件了

makefile也修改一下，先把path界说的log目次创建一下

日志放入一个文件测试效果：

日志分类测试效果：

log.hpp里头文件

优化一下调用

然后修改一下server.cc

 

client.cc

1. #include "common.hpp"
2. #include "log.hpp"
4. int main()
5. {
6.     int fd = open(FIFO_FILE,O_WRONLY);
7.     if(fd < 0)
8.     {
9.         perror("open");
10.         exit(FIFO_OPEN_ERR);
11.     }
12.     string line;
13.     while(true)
14.     {
15.         cout<< "Please Enter@ ";
16.         // cin>> line;
17.         getline(cin, line);
19.         write(fd, line.c_str(),line.size());
20.     }
22.     close(fd);
23.     return 0;
24. }

复制代码

common.hpp

1. #pragma noce
2. #include<iostream>
3. #include<vector>
4. #include<string>
5. #include<unistd.h>
6. #include <sys/types.h>
7. #include <sys/wait.h>
8. #include <sys/stat.h>
9. #include<fcntl.h>
10. #include<stdio.h>
11. using namespace std;
13. #define FIFO_FILE "./myfifo"
14. #define MODE 0664 //用于设置文件的权限，0664代表着8进制写法，4是其他用户可读不可写
16. enum
17. {
18.     FIFO_CREATE_ERR = 1,
19.     FIFO_DELETE_ERR,
20.     FIFO_OPEN_ERR
21. };
23. class Init
24. {
25. public:
26.     Init()
27.     {
28.         //创建管道
29.         int n = mkfifo(FIFO_FILE,MODE);
30.         if(n == -1)
31.         {
32.             perror("mkfofi");
33.             exit(FIFO_CREATE_ERR);
34.         }
35.     }
36.     ~Init()
37.     {
38.          //删除命名管道
39.         int m = unlink(FIFO_FILE);
40.         if(m == -1)
41.         {
42.             perror("unlink");
43.             exit(FIFO_DELETE_ERR);
44.         }      
45.     }
46. };

复制代码

log.hpp

1. #pragma noce
2. #include <stdarg.h>
3. // #include "common.hpp"
4. #include <iostream>
5. #include <stdio.h>
6. #include<string.h>//strerror(errno)头文件
7. #include<stdlib.h>
8. using namespace std;
10. #define Info        0
11. #define Debug       1
12. #define Warning     2
13. #define Error       3
14. #define Fatal       4 // 致命的
16. //打印方式
17. #define Screen      1 //屏幕
18. #define Onefile     2 //一个文件
19. #define Classfile   3 //多个文件
21. #define LogFile    "log.txt"
23. class Log
24. {
25. public:
26.     Log()
27.     {
28.         printMehod = Screen;
29.         path = "./log/";
30.     }
31.     void Enable(int method)
32.     {
33.         printMehod = method;
34.     }
35.     string levelToString(int level)
36.     {
37.         switch (level)
38.         {
39.         case Info:
40.             return "Info";
41.         case Debug:
42.             return "Debug";
43.         case Warning:
44.             return "Warning";
45.         case Error:
46.             return "Error";
47.         case Fatal:
48.             return "Fatal";
49.         default:
50.             return "";
51.         }
52.         return "";
53.     }
54.     // void logmessage(int level, const char *format, ...)
55.     // {
56.     //     time_t t = time(nullptr);
57.     //     struct tm *ctime = localtime(&t);
58.     //     char leftbuffer[1024];
59.     //     snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
60.     //             ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
62.     //     va_list s;
63.     //     va_start(s, format);
64.     //     char rightbuffer[1024];
65.     //     vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
66.     //     va_end(s);
68.     //     // 格式：默认部分+自定义部分
69.     //     char logtxt[1024 * 3];
70.     //     snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
71.     //     //cout << logtxt << endl; // 暂时打印
72.     //     printLog(level, logtxt);
73.     // }
74.     void operator()(int level, const char* format, ...)
75.     {
76.         time_t t = time(nullptr);
77.         struct tm *ctime = localtime(&t);
78.         char leftbuffer[1024];
79.         snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
80.                 ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
82.         va_list s;
83.         va_start(s, format);
84.         char rightbuffer[1024];
85.         vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
86.         va_end(s);
88.         // 格式：默认部分+自定义部分
89.         char logtxt[1024 * 3];
90.         snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
91.         //cout << logtxt << endl; // 暂时打印
92.         printLog(level, logtxt);
93.     }
95.     void printLog(int level, const string &logtxt)
96.     {
97.         switch(printMehod)
98.         {
99.             case Screen:
100.                 cout<< logtxt <<endl;
101.             break;
102.             case Onefile:
103.                 printOneFile(LogFile, logtxt);//"log.txt"
104.             break;
105.             case Classfile:
106.                 printClassFile(level, logtxt);
107.             break;
108.             default:
109.             break;
110.         }
112.     }
113.     void printOneFile(const string &logname, const string &logtxt)
114.     {
115.         //          "./log/" "log.txt"
116.         string _logname =path + logname;
117.         int fd = open(_logname.c_str(), O_WRONLY|O_CREAT|O_APPEND, 0666);
118.         if(fd < 0) return;
119.         write(fd, logtxt.c_str(), logtxt.size());
120.         close(fd);
121.     }
122.     void printClassFile(int level, const string &logtxt)
123.     {
124.         string filename = LogFile;//"log.txt"
125.         filename += ".";//"log.txt."
126.         filename += levelToString(level); //log.txt.Debug/Waring/Fatal
127.         printOneFile(filename, logtxt);
128.     }
129.     ~Log()
130.     {}
131. private:
132.     int printMehod;
133.     string path;
134. };

复制代码

makefile

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

复制代码

server.cc

1. #include "common.hpp"
2. #include "log.hpp"
5. int main()
6. {
7.     //logmessage(Info, "hello");
8.     //创建管道
9.     Init init;
10.     Log log;
11.     //log.Enable(Onefile);
12.     log.Enable(Classfile);
14.     // //创建管道
15.     // int n = mkfifo(FIFO_FILE,MODE);
16.     // if(n == -1)
17.     // {
18.     //     perror("mkfofi");
19.     //     exit(FIFO_CREATE_ERR);
20.     // }
21.     // sleep(5);
22.     //打开管道
23.     int fd = open(FIFO_FILE,O_RDONLY);
24.     if(fd < 0)
25.     {
26.         //log.logmessage(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
27.         //优化后
28.         log(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
29.         exit(FIFO_OPEN_ERR);
30.     }
31.     // log.logmessage(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
32.     // log.logmessage(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
33.     //优化后
34.     log(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
35.     log(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
36.     //......
37.     //开始通信
38.     while(true)
39.     {
40.         char buffer[1024] = {0};
41.         int x = read(fd, buffer, sizeof(buffer));
42.         if(x > 0)
43.         {
44.             buffer[x] = 0;
45.             cout<< "client say# " << buffer <<endl;
46.         }
47.         else if(x == 0)
48.         {
49.             //log.logmessage(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
50.             //优化后
51.             log(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
53.             //cout<< "client quit too!\n" <<endl;
54.             break;
55.         }
56.         else break;
57.     }
58.     close(fd);
60.     // //删除命名管道
61.     // int m = unlink(FIFO_FILE);
62.     // if(n == -1)
63.     // {
64.     //     perror("unlink");
65.     //     exit(FIFO_DELETE_ERR);
66.     // }
69.     return 0;
70. }

复制代码

匿名管道与命名管道的区别

   

• 匿名管道由pipe函数创建并打开。
  
• 命名管道由mkfifo函数创建，打开用open
  
• FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式差别，一但这些工作完 成之后，它们具有相同的语义。
  

  命名管道的打开规则

   

• 假如当前打开操纵是为读而打开FIFO时
  
• O_NONBLOCK disable：阻塞直到有相应历程为写而打开该FIFO
  
• O_NONBLOCK enable：立即返回成功
  
• 假如当前打开操纵是为写而打开FIFO时
  
• O_NONBLOCK disable：阻塞直到有相应历程为读而打开该FIFO
  
• O_NONBLOCK enable：立即返回失败，错误码为ENXIO
  

  

system V共享内存

详细看这里：
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的历程的地点空间，这些历程间数据通报不再涉及到 内核，换句话说是历程不再通过执行进入内核的体系调用来通报相互的数据
共享内存示意图

共享内存数据布局

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

复制代码

共享内存函数

shmget函数

   功能：用来创建共享内存
  原型
  int shmget(key_t key, size_t size, int shmflg);
  参数
  key:这个共享内存段名字
  size:共享内存大小
  shmflg:由九个权限标记构成，它们的用法和创建文件时利用的mode模式标记是一样的返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1
  shmat函数

   功能：将共享内存段毗连到历程地点空间
  原型
  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，表示毗连操纵用来只读共享内存
  shmdt函数

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

   功能：用于控制共享内存
  原型
  int shmctl(int shmid, int cmd, struct shmid_ds *buf);
  参数
  shmid:由shmget返回的共享内存标识码
  cmd:将要接纳的动作（有三个可取值）
  buf:指向一个保存着共享内存的模式状态和访问权限的数据布局返回值：成功返回0；失败返回-1
  

命令	分析
IPC_STAT	把shmidds布局中的数据设置为共享内存的当前关联值
IPC_SET	在历程有充足权限的前提下，把共享内存的当前关联值设置为Shmidds数据布局中给出的值
IPC_RMID	删除共享内存段

自己总结

共享内存

文件

shmget

申请一个共享V的内存，从内存中开辟一段空间
第二个参数：创建共享内存的大小（问题1），单元是字节

在man中输入这个，这样就可以找到，错了返回一个-1，对了返回共享内存标识符（问题2，与文件描述符有关系吗）

 第三个参数可以临时选这两个
 

 

权限问题：
你怎么保证让差别的历程看到同一个共享内存呢？
你怎么知道这个共享内存存在照旧存在呢？？？
答：key来保证，唯一标识，key也是唯一的

路径也有唯一性 

怎么形成一个key(ftok)
转化一个路径名和一个项目的标识符酿成一个System V IPC的key

一个路径字符串，一个叫项目id（由用户自由指定）

key实在是啥不紧张，只要能保持唯一性就好
创建共享内存也是有大概失败       


使两个通信的历程看到同一个key
pathname和proj_id随便写，一样平常不会冲突

获取共享内存

创建一个key
shmget中的三个参数，第一个key必要先创建一个key，-1创建失败，创建失败最好再把日志打印出来(用c_str！！！！！！！！)

1. #pragma once
2. #include <iostream>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/ipc.h>
7. using namespace std;
9. const string pathname = "/home/ljw";
10. const int proj_id = 0x99999;
12. int GetShareMen()
13. {
14.     int shmid = shmget();
15. }
17. key_t GetKey()
18. {
19.     key_t k = ftok(pathname.c_str(), proj_id);
20.     if(k < 0)
21.     {
22.         exit(1);
23.     }
24.     return k;
25. }

复制代码

把log.hpp（日志）拷贝进来，日志也写上，可变参数和printf类似

Info就是正常创建成功了，log.hpp中默认是往屏幕上打印     

key有后就可以美满GetShareMem中的shmget
GetShareMem，key有了，共享内存也创建成功了，创建成功返回共享内存的标识符 ，失败-1返回，创建一个全新的共享内存
先把第二个参数创建一下

返回共享内存的标识符
创建成功了，就Info，返回共享内存的标识符

两个文件里都是共同的头文件，调用共同的key

 照旧为了这个本质

测试一下

创建失败的话可以改一下数字

key  vs  shmid

历程退了共享内存还存在

ipcs -m 检察共享内存的资源，历程退了还存在

关掉共享内存，用shmid删除（ipcrm）不行要用key
用户层统一用shmid删除，key有操纵体系控制

16进制打印key

perms权限问题和nattch关联问题

添加权限

这样就是一个创建（全新的共享内存）一个获取(存在的共享内存)

创建新的就CreateShm

内存大小
申请多少就能用多少，虽然操纵体系给了2倍的

shmat叫做挂接 
让当前历程和指定的共享内存进行关联起来
第一个：参数就是上面获取的shmid，
第二个：你想挂接到共享区的什么位置，不知道，由体系去决定就可以了，填null
第三个：共享内存的默认权限，设置为0就行
返回值是void*，跟malloc类似，必要强转，在假造地点空间创建的

挂接起来：attach挂接
运行后，CreateShm创建一个共享内存，创建好以后，5秒以后，就会发现自己的历程就把当前的共享内存挂接到地点空间了，挂接到地点空间之后，就能看到我们对应的，nattch的0就会变1，又过5秒历程退出后，nattch就酿成0了

去关联shmdt

只必要起始的地点就可以释放，返回值也是成功返回0，失败返回1 
去关联

申请内存，关联，去关联完成


释放共享内存(shmctl)
第一个：参数，共享内存的ip

1. #include "comm.hpp"
3. int main()
4. {
5.     int shmid = CreateShm();
6.     log(Debug, "createShm done...");
8.     sleep(5);
10.     char *shmaddr = (char*)shmat(shmid, nullptr, 0);
11.     log(Debug, "attach shm done...");
12.     sleep(5);
14.     shmdt(shmaddr);
15.     log(Debug, "detach shm done,shmaddr:0x%x...", shmaddr);
16.     sleep(5);
18.     shmctl(shmid, IPC_RMID, nullptr);
19.     log(Debug, "destory shm done,shmaddr:0x%x...", shmaddr);
20.     sleep(5);
23.     return 0;
24. }  

复制代码

开始让两个历程通信
a来历程创建，b就不用创建，只必要获取就行，也要挂接
b中也不用删除，a删除就可以

测试
要让a先跑要创建，两个都挂接成功nattch就酿成2了

目前为止还没有通信
有没有通信呢？？？没有！
让差别历程看到同一个共享资源！

a的通信代码在这里

b的在这里

写一个最简单的通信
这就是通信了

b中输入，这样就可以通信了
 1和2的区别

b中这样更简单，直接写进去共享内存里

processa会一直读，不会管b写没写

小结
a不会等待b，a会一直读，不会跟管道一样，没数据还会等等你

为什么速度最快：拷贝少

跟管道比
首先自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过体系调用（write）写到管道里，然后再通过read体系调用，被对方（读端）读取，就要从管道拷贝到读端，然后再表现到表现器上。

 看看共享内存的属性（没有同步机制）
管道有同步机制

获取共享内存的属性

把管道移入（实现同步问题）（用管道关照）
把这个（创建和释放管道）

放进这里 

再打开管道文件，就可以对管道文件进行读写了

记得关掉

b中以写的方式打开

两边通信要怎么通呢
b中往管道里写入一个字符

a中的写这个进行读，b中假如不输入，则a会一直在read这阻塞

测试：先a运行，创建好共享内存，但阻塞了，等b输入
阻塞在这，不会像只有共享内存那样一直读

b输入后a才会表现，不输入，你就要等我

b（ctrl C）后，read就读到0了，就break了（实现同步问题）以为原来，a不管b写不写，都会读

用到的体系调用接口
创建成功返回一个消息队列标识符，否则返回-1

消息队列和信号量（通信方式）

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。