目录
非原创，经过摘录整合的，旧作者的文章似乎删了。
进程间通信（IPC）介绍：
进程间通信（IPC，InterProcess Communication）是指在不同的进程之间传播或交换信息。
IPC的方式有管道（包括无名管道和命名管道）、消息队列、信号量、共享内存、Socket、Streams等。其中Socket和Streams支持不同主机上的两个进程间通信。
1、管道
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
特点：
- 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
- 它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
- 它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
1.1 管道（无名管道）
特点
- 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
- 它只能用于父子进程之间的通信。
- 管道是创建在内存中，进程结束空间释放，管道不复存在。对于它的读写可以使用普通的read、write等函数。
函数原型
SYNOPSIS
#include <unistd.h>
int pipe(int pipefd[2]);
返回值：成功返回0，失败返回-1
当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。
管道（无名管道）代码demo：
流程：当数据流从父进程流向子进程，父进程打开写端，关闭读端。而子进程则是打开读端，关闭写端。如果数据流从子进程流向父进程，道理一样。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
//int pipe(int pipefd[2]);
//ssize_t write(int fd, const void *buf, size_t count);
//ssize_t read(int fd, void *buf, size_t count);
int main()
{
int fd[2];
int pid;
char buf[128];
if(pipe(fd) == -1){
printf("creat pipe fail\n");
}
pid = fork();
if(pid < 0 ){
printf("creat child fail\n");
}
else if(pid > 0){
sleep(3);
printf("this is father\n");
close(fd[0]);
write(fd[1],"hello from father",strlen("hello from father"));
wait();
}
else{
printf("this is child\n");
close(fd[1]);
read(fd[0],buf,128);
printf("read = %s \n",buf);
exit(0);
}
return 0;
}
1.2 管道（命名管道）
特点：
- 命名管道可以在无关的进程之间交换数据，与无名管道不同。
- 命名管道有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
函数原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
其中mode参数与open函数中的mode相同。一旦创建了一个FIFO，就可以用一般的文件I/O函数来操作。
当open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
- 若没有指定O_NONBLOCK（默认），只读open要阻塞到某个其他进程为写而打开FIFO。类似的，只写open要阻塞到某个其他进程为读而打开它。（一般选择默认）
- 若是指定O_NONBLOCK，则只读open立即返回。而只写open将出错返回-1，如果没有进程已经为读而打开该FIFO，其errno为ENXIO。
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清楚数据，并且”先进先出“。
管道（命名管道）代码demo：
read.c 文件
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
//ssize_t read(int fd, void *buf, size_t count);
//int mkfifo(const char *pathname, mode_t mode);
//int open(const char *pathname, int flags);
int main()
{
int fd;
char buf[128] = {0};
if(mkfifo("./file",0600) == -1 && errno != EEXIST){
printf("mkfifo fail\n");
perror("why");
}
fd = open("./file",O_RDONLY);
printf("read open success\n");
while(1){
int n_read = read(fd,buf,128);
printf("read %d byte,contxt = %s \n",n_read,buf);
}
close(fd);
return 0;
}
write.c 文件
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
//ssize_t write(int fd, const void *buf, size_t count);
//int mkfifo(const char *pathname, mode_t mode);
//int open(const char *pathname, int flags);
int main()
{
int fd;
char *str = "message from fifo";
int cnt = 0;
fd = open("./file",O_WRONLY);
printf("write open success\n");
while(1){
write(fd,str,strlen(str));
sleep(1);
}
close(fd);
return 0;
}
先运行 read 再运行 write 。运行结果：现象就是read文件读端在阻塞，直到write文件写端写入的时候，read文件读端才开始执行打印数据。
2、消息队列
消息队列，是信息的链接表，存放在内核中。一个消息队列由一个标识符（即队列 ID）来标识。
2.1 特点
- 消息队列是面向记录的，其中的消息具有特地那个的格式以及特定的优先级。
- 消息队列独立于发送与接收进程。进程终止时，消息队列及内容并不会删除。
- 消息队列可以实现信息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。
2.2 函数原型
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
//创建或打开消息队列：成功返回队列 ID ，失败返回 -1
int msgget(key_t key, int msgflg);
//添加消息：成功返回 0 ，失败返回 -1
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//读取信息：成功返回消息数据的长度，失败返回 -1
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
//控制消息队列:成功返回 0 ，失败返回 -1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
key值很关键，相当于一个索引。进程通过这个键值，在Linux内核中找到相应的队列（确保了队列是同一个）
在以下两种情况中，msgget 将创建一个新的消息队列：
- 如果没有与键值相对应的消息队列，并且flag中包含了 IPC_CREAT 标志位。
- key 参数为 IPC_PRIVATE。
函数msgrcv在读取消息队列时，type参数有下面几种情况。
- type == 0 ，返回队列中的第一个消息；
- type > 0 ，返回队列中消息类型为 type 的第一个消息；
- type < 0 ，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。
代码demo:
send.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//int msgget(key_t key, int msgflg);
//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
//int msgctl(int msqid, int cmd, struct msqid_ds *buf);
//key_t ftok(const char *pathname, int proj_id);
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[128]; /* message data */
};
int main()
{
key_t key;
int msgId;
struct msgbuf sendBuf = {888,"this is send's message\n"}; //第一个参数：消息的类型
struct msgbuf readBuf;
//获取key值
key = ftok(".",12); // “.” 表示当前路径
printf("key = %x \n",key);
//创建消息队列
msgId = msgget(key,IPC_CREAT|0777); //0777 可读可写可执行
if(msgId == -1){
printf("get que failure\n");
}
//发送数据
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
//接收数据
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),988,0); //第四个参数：0 的意思是默认的方式接收消息，接收不到消息会一直阻塞
printf("return form get is :%s\n",readBuf.mtext);
//关闭消息队列
msgctl(msgId,IPC_RMID,NULL);
return 0;
}
read.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//int msgget(key_t key, int msgflg);
//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
//int msgctl(int msqid, int cmd, struct msqid_ds *buf);
//key_t ftok(const char *pathname, int proj_id);
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[128]; /* message data */
};
int main()
{
int msgId;
struct msgbuf readBuf;
key_t key;
//获取key值
key = ftok(".",12); // “.” 表示当前路径，第二个参数随意，可以是数字，可以是字符
printf("key = %x \n",key);
// 获取/创建消息队列
msgId = msgget(key,IPC_CREAT|0777); //0777 可读可写可执行
if(msgId == -1){
printf("get que failure\n");
}
//接收数据
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0); //第三个参数：消息类型，第四个参数：0 的意思是默认的方式接收消息，接收不到消息会一直阻塞
printf("read message form send is :%s\n",readBuf.mtext);
//发送数据
struct msgbuf sendBuf = {988,"thank you your send\n"};
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
//关闭数据
msgctl(msgId,IPC_RMID,NULL); //第三个参数，通常设置为NULL
return 0;
}
运行结果：
3、共享内存（一般来说需要搭配 信号量 来使用）
共享内存（shared memory），指两个或多个进程共享一个给定的存储区。
查看共享内存的命令：ipcs -m （在共享内存创建之后，并在断开连接之前，可以加exit(0)退出程序，此时可以用查看命令看到创建的共享内存有哪些）
删除共享内存的命令：ipcs -m id号
3.1特点
共享内存是最快的一种IPC，因为进程是直接对内存进行存储，而不需要任何数据的拷贝。
它有一个特性：只能单独一个进程写或读，如果A和B进程同时写，会造成数据的混乱，（所以需要搭配信号量来使用，比较好）
3.2函数原型
//创建或获取一个共享内存：成功返回共享内存ID，失败返回 -1
int shmget(key_t key, size_t size, int shmflg);
//连接共享内存到当前进程的地址空间:成功返回指向共享内存的指针，失败返回 -1
void *shmat(int shmid, const void *shmaddr, int shmflg);
//断开与共享内存的连接：成功返回0，失败返回 -1
int shmdt(const void *shmaddr);
//控制共享内存的相关信息：成功返回0，失败返回 -1
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
1. 当 shmget函数创建一段共享内存的时候，必须指定其size，而且必须是以兆对齐的（一兆空间是：1024）；而如果引用一个已存在的共享内存，则将size指定为0。
shmget ，参数1：是一个key 。参数2：共享内存的大小，必须以兆对齐（一兆空间是：1024）。 参数3：一般是，创建+权限（可读可写），IPC_CREAT|0600
2.当一段共享内存被闯将以后，它并不能被任何进程访问。必须使用 shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区映射到调用进程的地址空间，随后可像本地空间一样访问。
shmat ，参数1：共享内存id ，参数2：一般写0，默认是由linux内核自行安排共享内存， 参数3：一般写0，代表映射的共享内存是可读可写。若是指定了 SHM_RDONLY ，则是以只读的方式。
3.shmdt函数函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能访问该共享内存而已。
4.shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。
shmctl ，参数2：删除指令，一般写IPC_RMID ，参数3：一般写0，因为我们一般不关心共享内存中的数据信息。
代码demo：
编程思路：
- 创建/打开共享内存
- 连接映射共享内存
- 写入数据 strcpy
- 断开释放共享内存
- 干掉共享内存
shm_write.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
//int shmget(key_t key, size_t size, int shmflg);
//void *shmat(int shmid, const void *shmaddr, int shmflg);
int main()
{
int shmid;
char *shmaddr;
key_t key;
key = ftok(".",1); //“.” 代表当前路径 ，第二个参数随意数字
//创建共享内存
shmid = shmget(key,1024*4,IPC_CREAT|0600);
if(shmid == -1){
printf("creat shm fail\n");
exit(-1);
}
//连接映射共享内存
shmaddr = shmat(shmid,0,0);
printf("shmat OK\n");
//将数据拷贝到共享内存
strcpy(shmaddr,"hello world\n");
sleep(5); //等待5秒，避免一下子断开连接。等待另外一个进程读完。
//断开共享内存连接
shmdt(shmaddr);
//删除共享内存
shmctl(shmid,IPC_RMID,0);
printf("quit\n");
return 0;
}
shm_get.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
//int shmget(key_t key, size_t size, int shmflg);
//void *shmat(int shmid, const void *shmaddr, int shmflg);
int main()
{
int shmid;
char *shmaddr;
key_t key;
key = ftok(".",1); //“.” 代表当前路径 ，第二个参数随意数字
//打开共享内存
shmid = shmget(key,1024*4,0); //以打开方式的时候，第三个参数写0，直接获取，不创建
if(shmid == -1){
printf("creat shm fail\n");
exit(-1);
}
//连接并映射共享内存
shmaddr = shmat(shmid,0,0);
printf("get from shm_write message is : %s",shmaddr);
//断开共享内存连接
shmdt(shmaddr);
//删除共享内存
shmctl(shmid,IPC_RMID,0);
printf("quit\n");
return 0;
}运行结果：
对比总结简图
4、信号
https://blog.csdn.net/jinchi_boke/article/details/116075370
5、信号量
https://blog.csdn.net/jinchi_boke/article/details/116130302
结合消息队列，共享内存，信号量三个知识的代码demo
下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。
- 共享内存用来传递数据；
- 信号量用来同步；
- 消息队列用来 在客户端修改了共享内存后 通知服务器读取。
get.c
#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h> // shared memory
#include<sys/sem.h> // semaphore
#include<sys/msg.h> // message queue
#include<string.h> // memcpy
// 消息队列结构
struct msg_form {
long mtype;
char mtext;
};
// 联合体，用于semctl初始化
union semun
{
int val; /*for SETVAL*/
struct semid_ds *buf;
unsigned short *array;
};
// 初始化信号量
int init_sem(int sem_id, int value)
{
union semun tmp;
tmp.val = value;
if(semctl(sem_id, 0, SETVAL, tmp) == -1)
{
perror("Init Semaphore Error");
return -1;
}
return 0;
}
// P操作:
// 若信号量值为1，获取资源并将信号量值-1
// 若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{
struct sembuf sbuf;
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = -1; /*P操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
{
perror("P operation Error");
return -1;
}
return 0;
}
// V操作：
// 释放资源并将信号量值+1
// 如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{
struct sembuf sbuf;
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = 1; /*V操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
{
perror("V operation Error");
return -1;
}
return 0;
}
// 删除信号量集
int del_sem(int sem_id)
{
union semun tmp;
if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
{
perror("Delete Semaphore Error");
return -1;
}
return 0;
}
// 创建一个信号量集
int creat_sem(key_t key)
{
int sem_id;
if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
{
perror("semget error");
exit(-1);
}
init_sem(sem_id, 1); /*初值设为1资源未占用*/
return sem_id;
}
int main()
{
key_t key;
int shmid, semid, msqid;
char *shm;
char data[] = "this is server";
struct shmid_ds buf1; /*用于删除共享内存*/
struct msqid_ds buf2; /*用于删除消息队列*/
struct msg_form msg; /*消息队列用于通知对方更新了共享内存*/
// 获取key值
if((key = ftok(".", 'z')) < 0)
{
perror("ftok error");
exit(1);
}
// 创建共享内存
if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
{
perror("Create Shared Memory Error");
exit(1);
}
// 连接共享内存
shm = (char*)shmat(shmid, 0, 0);
if((int)shm == -1)
{
perror("Attach Shared Memory Error");
exit(1);
}
// 创建消息队列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
{
perror("msgget error");
exit(1);
}
// 创建信号量
semid = creat_sem(key);
// 读数据
while(1)
{
msgrcv(msqid, &msg, 1, 888, 0); /*读取类型为888的消息*/
if(msg.mtext == 'q') /*quit - 跳出循环*/
break;
if(msg.mtext == 'r') /*read - 读共享内存*/
{
sem_p(semid);
printf("%s\n",shm);
sem_v(semid);
}
}
// 断开连接
shmdt(shm);
/*删除共享内存、消息队列、信号量*/
shmctl(shmid, IPC_RMID, &buf1);
msgctl(msqid, IPC_RMID, &buf2);
del_sem(semid);
return 0;
}send.c
#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h> // shared memory
#include<sys/sem.h> // semaphore
#include<sys/msg.h> // message queue
#include<string.h> // memcpy
// 消息队列结构
struct msg_form {
long mtype;
char mtext;
};
// 联合体，用于semctl初始化
union semun
{
int val; /*for SETVAL*/
struct semid_ds *buf;
unsigned short *array;
};
// P操作:
// 若信号量值为1，获取资源并将信号量值-1
// 若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{
struct sembuf sbuf;
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = -1; /*P操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
{
perror("P operation Error");
return -1;
}
return 0;
}
// V操作：
// 释放资源并将信号量值+1
// 如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{
struct sembuf sbuf;
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = 1; /*V操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
{
perror("V operation Error");
return -1;
}
return 0;
}
int main()
{
key_t key;
int shmid, semid, msqid;
char *shm;
struct msg_form msg;
int flag = 1; /*while循环条件*/
// 获取key值
if((key = ftok(".", 'z')) < 0)
{
perror("ftok error");
exit(1);
}
// 获取共享内存
if((shmid = shmget(key, 1024, 0)) == -1)
{
perror("shmget error");
exit(1);
}
// 连接共享内存
shm = (char*)shmat(shmid, 0, 0);
if((int)shm == -1)
{
perror("Attach Shared Memory Error");
exit(1);
}
// 创建消息队列
if ((msqid = msgget(key, 0)) == -1)
{
perror("msgget error");
exit(1);
}
// 获取信号量
if((semid = semget(key, 0, 0)) == -1)
{
perror("semget error");
exit(1);
}
// 写数据
printf("***************************************\n");
printf("* IPC *\n");
printf("* Input r to send data to server. *\n");
printf("* Input q to quit. *\n");
printf("***************************************\n");
while(flag)
{
char c;
printf("Please input command: ");
scanf("%c", &c);
switch(c)
{
case 'r':
printf("Data to send: ");
sem_p(semid); /*访问资源*/
scanf("%s", shm);
sem_v(semid); /*释放资源*/
/*清空标准输入缓冲区*/
while((c=getchar())!='\n' && c!=EOF);
msg.mtype = 888;
msg.mtext = 'r'; /*发送消息通知服务器读数据*/
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
break;
case 'q':
msg.mtype = 888;
msg.mtext = 'q';
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
flag = 0;
break;
default:
printf("Wrong input!\n");
/*清空标准输入缓冲区*/
while((c=getchar())!='\n' && c!=EOF);
}
}
// 断开连接
shmdt(shm);
return 0;
}
308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
