文章目录
通信背景:
1.进程是具有独立性的,但进程间想要交互数据(多进程协同处理一件事情),成本会非常高 。
2.不要以为,进程独立了,就是彻底独立,我们需要双方能够进行一定程度的信息交互。
一、进程通信分类
- 管道
a.匿名管道
b.命名管道 - System V IPC
a.System V 消息队列
b.System V 共享内存
c.System V 信号量 - 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.互斥
任何时刻,只允许一个进程,访问临界资源——互斥