进程间通信简称IPC(interprocess communication),就是在不同进程之间消息传递的方式
主要的方式有管道、消息队列、共享内存、信号量等
1、管道
管道包括无名管道和命名管道,它们两个有什么特点呢?
无名管道:
- 具有固定的读写端、是一种单双工的通信模式
- 只能用于有亲缘关系的进程(父进程和子进程)
- 只存在内核当中
命名管道:
- 可以在无关的进程之间进行通信
- 以一种特殊的文件形式存在文件系统之间(FIFO是一种文件类型) 它们之间的相同点:都可以阻塞读写,都用于scoket的网络通信
无名管道
管道创建成功会返回值为0,失败返回值为-1。
管道建立成功时,会生成固定的读写端:fd[0]为读端、fd[1]为写端,同样可以利用read函数和write函数对管道进行读写,需要关闭管道时,只需要用close函数将fd[0]和fd[1]关闭就可以了。
如果我们想要实现从父进程发送消息到子进程,则关闭父进程的fd[0]读端和子进程的fd[1]写端,反之,子进程向父进程发送消息,则需要关闭父进程的fd[1]写端和子进程的fd[0]读端。
如果不好记忆,可以这样记:父进程要向子进程发送消息,所需要写东西给子进程,所以就需要关闭读端,子进程跟父进程相反,反之也是一样的。
代码实现:
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main() {
int fd[2];
int pid;
char buf[128];
if (pipe(fd) == -1) { //判断管道是否创建成功
printf("creat pipe failed\n");
}
pid = fork();//创建子进程
if (pid < 0) {
printf("creat child failed\n");
} else if (pid > 0) {
sleep(3);
printf("this is father\n");
close(fd[0]);//关闭读端
write(fd[1], "hello", strlen("hello"));//将hello发送给子进程
wait();
} else {
printf("this is child\n");
close(fd[1]);//关闭写端
read(fd[0], buf, 128);//接收从父进程发来的消息
printf("read from father:%s\n", buf);
exit(0);
}
return 0;
}
再实现一个例子:实现文件拷贝,要求使用父子进程加管道的方式做
具体需求:
父进程负责读取指定文件,将读取内容通过管道发送给子进程,子进程通过管道读取到父进程发来的消息,并创建文件,保存内容
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char **argv) {
int fd1;
int fd2;
int fd[2];
int pid;
int n_write;
int n_read;
char buf[128];
if (pipe(fd) == -1) {
printf("creat pipe failed\n");
}
pid = fork();
if (pid < 0) {
printf("creat child failed\n");
} else if (pid > 0) {
sleep(3);
printf("this is father\n");
fd1 = open(argv[1], O_RDWR);//父进程打开文件1
if (fd1 == -1) {
perror("open file fail");
exit(0);
}
memset(buf, '\0', strlen(buf));//对字符串内容清空
n_read = read(fd1, buf, 128);//对文件1内容进行读
if (n_read > 0) {
printf("get %s context successfully\n", argv[1]);
}
close(fd1);//关闭文件1
close(fd[0]);//关闭父进程的读端
write(fd[1], buf, strlen(buf));//通过管道向子进程发送所读取的内容
wait();
n_read = 0;
} else {
printf("this is child\n");
close(fd[1]);//关闭子进程的写端
memset(buf, '\0', 128);//清空字符串内容
n_read = read(fd[0], buf, 128);//读取从父进程发送过来的内容
if (n_read > 0) {
printf(
"read from father successfully\n this context copy is "
"beginning\n");
}
fd2 = open(argv[2], O_CREAT | O_RDWR, 0600);//创建文件2
if (fd2 == -1) {
printf("creat file2 failed");
}
n_write= write(fd2, buf, strlen(buf));//将读取的内容写入文件2
if(n_write>0){
printf("copy to %s successfully\n",argv[2]);
}
// printf("read from father:%s\n", buf);
close(fd2);//关闭文件2
exit(0);
}
return 0;
}
FIFO(命名管道)
函数原型:int mkfifo(const char *pathname,mode_t mode)
mode参数:跟open的mode参数相同
pathname:文件名(含路径)
返回值:成功:0,失败:-1
代码实现创建:
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
int main(){
int ret=mkfifo("./file",0600);
if(ret==0){
printf("mkfifo sucessfully\n");
}
if(ret==-1){
printf("mkfifo failed\n");
}
return 0;
}
例子:利用FIFO实现文件之间的数据传输
read.c
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
int main(){
char buf[30]={0};
int n_read=0;
if((mkfifo("./file",0600)==-1)&&errno!=EEXIST){ //创建FIFO
printf("mkfifo failed\n");
perror("why");
}
int fd=open("./file",O_RDONLY); //只读方式打开
printf("open sucessfully\n");
while(1){
n_read=read(fd,buf,30);
printf("read from %d byte from fifo,context:%s\n",n_read,buf);
sleep(1);
}
return 0;
}
write.c
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
int main() {
int cnt;
char *buf = "message from fife";
int fd = open("./file", O_WRONLY); //只写方式打开
printf("WRITE open sucessfully\n");
while(1){ //不断写入,写入3次后不再写入
write(fd, buf, strlen(buf));
sleep(1);
if(cnt==3) break;
cnt++;
}
close(fd);
return 0;
}
运行结果:
共享内存
什么是共享内存?–简单地说就是允许不同的进程访问同一个内存,
共享内存适用于一个程序的多进程通信,通常也跟信号量一起使用
使用共享内存有以下步骤:
- 创建共享内存/打开共享内存
- 映射
- 数据交换
- 释放共享内存
- 删除共享内存
头文件:#include <sys/shm.h>
主要的函数:
int shmget(key_t key,size_t size,int flag);//创建或者打开一个共享内存
返回值:成功:共享内存ID,失败:-1
void *shmat(int shm_id,const void *addr,int flag);//连接共享内存到当前进程
返回值:成功:共享内存ID,失败:-1
int shmdt(void *addr);//断开共享内存
返回值:成功:0,失败:-1
int shmctl(int shm_id,int cmd,struct shmid_de *buf);//控制共享内存的相关信息
返回值:成功:0,失败:-1
参数 cmd :执行相应的操作。常用的是IPC_RMID(从系统中删除该共享内存)
代码实现:
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(){
int shmid;
char *shmaddr;
key_t key;
key=ftok(".",1);//建立IPC通讯,获取id值
shmid=shmget(key,1024*4,IPC_CREAT|0666);//创建共享内存/获取共享内存
if(shmid== -1){
printf("shmget nook\n");
exit(-1);
}
shmaddr=shmat(shmid,0,0); //连接共享内存
printf("shmat ok\n");
strcpy(shmaddr,"kkkk");
sleep(5);
shmdt(shmaddr);// 断开共享内存
shmctl(shmid,IPC_RMID,0);//删除共享内存
printf("quit\n");
return 0;
}
主要功能:系统建立IPC通讯(如消息队列、共享内存时)必须指定一个ID值 。
参数说明:
pathname:指定的文档名
id:子序号,可以随意设定,unix系统的取值是1到255
信号量
信号量(semaphore)与已经介绍过的 IPC 结构不同,它是一个计数器。信号量用于实现进程间的互斥与同步,而不是用于存储进程间通信数据。
1、特点
信号量用于进程间同步,若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作,程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1,而且可以加减任意正整数。
支持信号量组。
2、原型
最简单的信号量是只能取 0 和 1 的变量,这也是信号量最常见的一种形式,叫做二值信号量(Binary Semaphore)。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作,而不是在一个单一的二值信号量上进行操作。
#include <sys/sem.h>
// 创建或获取一个信号量组:若成功返回信号量集ID,失败返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作,改变信号量的值:成功返回0,失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);
// 控制信号量的相关信息
int semctl(int semid, int sem_num, int cmd, ...);
当semget创建新的信号量集合时,必须指定集合中信号量的个数(即num_sems),通常为1; 如果是引用一个现有的集合,则将num_sems指定为 0 。
在semop函数中,sembuf结构的定义如下:
1 struct sembuf
2 {
3 short sem_num; // 信号量组中对应的序号,0~sem_nums-1
4 short sem_op; // 信号量值在一次操作中的改变量
5 short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }
其中 sem_op 是一次操作中的信号量的改变量:
若sem_op > 0,表示进程释放相应的资源数,将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量,则换行它们。
若sem_op < 0,请求 sem_op 的绝对值的资源。
sem_flg通常为IPC_NOWAIT 或 SEM_UNDO.
sem_flg 指定IPC_NOWAIT,则semop函数出错返回EAGAIN。
sem_flg 没有指定IPC_NOWAIT,则将该信号量的semncnt值加1,然后进程挂起直到下述情况发生:
此信号量被删除,函数smeop出错返回EIDRM;
进程捕捉到信号,并从信号处理函数返回,此情况下将此信号量的semncnt值减1,函数semop出错返回EINTR
若sem_op == 0,进程阻塞直到信号量的相应值为0:
当信号量已经为0,函数立即返回。
- 信号量值为0,将信号量的semzcnt的值减1,函数semop成功返回; 此信号量被删除,函数smeop出错返回EIDRM;
进程捕捉到信号,并从信号处理函数返回,在此情况将此信号量的semncnt值减1,函数semop出错返回EINTR
在semctl函数中的命令有多种,这里就说两个常用的:
**SETVAL:**用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
**IPC_RMID:**删除一个信号量集合。如果不删除信号量,它将继续在系统中存在,即使程序已经退出,它可能在你下次运行此程序时引发问题,而且信号量是一种有限的资源。
转载:本文为CSDN博主「南宫凌霄」的原创文章。
原文链接:https://blog.csdn.net/wh_sjc/article/details/70283843
代码实现:信号量和共享内存的使用
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *_buf;
};
void getkey(int id){
struct sembuf set;
set.sem_num=0;
set.sem_op=-1; //请求资源
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("getkey\n");
}
void putkey(int id){
struct sembuf set;
set.sem_num=0;
set.sem_op=1;//释放资源
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("putkey\n");
}
int main(int argc,char **argv){
key_t key;
int semid;
key=ftok(".",2);
semid=semget(key,1,IPC_CREAT|0666);//创建信号量组
union semun initsem;
initsem.val=0;
semctl(semid,0,SETVAL,initsem); //控制信号量组
int pid=fork();//创建进程
if(pid>0){
getkey(semid);//获取钥匙
printf("this is father\n");
putkey(semid);//释放钥匙
semctl(semid,0,IPC_RMID);
}else if(pid==0){
printf("this is child\n");
putkey(semid);//释放钥匙
}else{
printf("fork error\n");
}
return 0;
}