进程间的5种通信方式详细介绍

最新推荐文章于 2025-02-28 16:07:24 发布

你若盛开，清风自来！

最新推荐文章于 2025-02-28 16:07:24 发布

阅读量4.3k

点赞数 9

分类专栏： Linux 文章标签：进程间通信管道通信消息队列

原文链接：https://blog.youkuaiyun.com/daima3/article/details/103181824

版权

Linux 专栏收录该内容

12 篇文章

订阅专栏

进程间的5种通信方式详细介绍

一、管道
二、FIFO命名管道
三、消息队列
四、信号量
五、共享内存

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。

IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。

一、管道

无名管道
特点：

半双工通信，即数据流只能在一个方向上流动
亲缘进程之前的通信
特殊的一种文件，不属于任何文件系统，只存在于在内存中

包含头文件：#include <unistd.h>

 int pipe(int fd[2]);    // 返回值：若成功返回0，失败返回-1

当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。

在这里插入图片描述
函数名: ctime
功能: 把日期和时间转换为字符串
用法: char *ctime(const time_t *time);

（1）使用fork()之后的半双工通信管道
父子进程
（2）从父进程到子进程的通信管道
在这里插入图片描述
我们做个实例如下：

#include<stdio.h>
#include<unistd.h>

int main()
{
    int f[2];  // 两个文件描述符
     pid_t pid;
     char buff[20];
 
     if(pipe(f) < 0)  // 创建管道
         printf("Create Pipe Error!\n");

     if((pid = fork()) < 0)  // 创建子进程
         printf("Fork Error!\n");
    else if(pid > 0)  // 父进程
     {
         close(f[0]); // 关闭读端
         write(f[1], "hello world\n", 12);
     }
     else
     {
         close(f[1]); // 关闭写端
         read(f[0], buff, 20);
         printf("%s", buff);
    }
 
     return 0;
}

二、FIFO命名管道

1、FIFO也称命名管道，是一种特殊文件类型
2、命名管道的打开规则
（1）只读且阻塞方式
open(const char *pathname, O_RDONLY);
（2）只读且非阻塞方式
open(const char *pathname, O_RDONLY | O_NONBLOCK);
（3）只写且阻塞方式
open(const char *pathname, O_WRONLY);
（4）只写且非阻塞方式
open(const char *pathname, O_WRONLY | O_NONBLOCK);
3、特点
（1）可在无关进程间通信
（2）关联路径名，是一种存在于文件系统中的设备文件
4、实例如下：
（1）read_fifo.c文件内容如下：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>

int main()
{
     int fd;
     int len;
     pid_t pid;
     char buf[1024];
     printf("my pid is %d\n",getpid());
     if(mkfifo("fifo1", 0666) < 0 && errno!=EEXIST) // 创建FIFO管道
         perror("Create FIFO Failed");
     printf("xixi\n");
     if((fd = open("fifo1", O_RDONLY)) < 0)  // 以读打开FIFO
     {
         perror("Open FIFO Failed");
         exit(1);
     }
     printf("zixiniloveyou\n");
     len = read(fd,buf,1024);
     printf("len = %d\n",len);
     while((len = read(fd, buf, 1024)) > 0) // 读取FIFO管道
         printf("Read message: %s", buf);
 
     close(fd);  // 关闭FIFO文件
     return 0;
 }

（2）write_fifo.c文件内容如下：

#include<stdio.h>
 #include<stdlib.h>   // exit
 #include<fcntl.h>    // O_WRONLY
 #include<sys/stat.h>
 #include<time.h>     // time
 
 int main()
 {
     int fd;
     int n, i;
     char buf[1024];
     time_t tp;
 
     printf("I am %d process.\n", getpid()); // 说明进程ID
     
     if((fd = open("fifo1", O_WRONLY)) < 0) // 以写打开一个FIFO 
     {
         perror("Open FIFO Failed");
         exit(1);
     }
 
     for(i=0; i<10; ++i)
     {
         time(&tp);  // 取系统当前时间
         n=sprintf(buf,"Process %d's time is %s",getpid(),ctime(&tp));
         printf("Send message: %s", buf); // 打印
         if(write(fd, buf, n+1) < 0)  // 写入到FIFO中
         {
             perror("Write FIFO Failed");
             close(fd);
             exit(1);
         }
         sleep(1);  // 休眠1秒
     }
 
     close(fd);  // 关闭FIFO文件
     return 0;
 }

首先，为了看到结果，我们要打开两个终端，在两个终端上对这两个C文件进行编译和执行，结果如下：

首先执行read_fifo.c,你会发现，进程一直处于阻塞状态，这和上文中第2点命名管道的打开规则有关，请看这行代码fd = open(“fifo1”, O_RDONLY)，此行代码规定了命名管道的打开规则是只读阻塞方式，就是说该命名管道是只读的，一旦打开了该管道，如果管道没有内容的话就会就会处于阻塞状态。
在这里插入图片描述
如果我们将规则设置为fd = open(“fifo1”, O_RDONLY|O_NONBLOCK)，即使命名管道没有内容，该进程也会正常结束。
我们在另一个终端上执行write_fifo.c，结果如下：

你会发现，与此同时的read_fifo.c文件所在的终端也运行起来了：
在这里插入图片描述

而上述这种实例我们可以扩展为服务器进程与客户进程通信，read_fifo是服务器端，write_fifo是客户端，服务器端实时监控着用户端，当有数据时，读出并处理。

三、消息队列

1 、消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制
2、消息队列跟命名管道有不少的相同之处，通过与命名管道一样，消息队列进行通信的进程可以是不相关的进程，同时它们都是通过发送和接收的方式来传递数据的。在命名管道中，发送数据用write，接收数据用read，则在消息队列中，发送数据用msgsnd，接收数据用msgrcv。而且它们对每个数据都有一个最大长度的限制。

3、与命名管道相比，消息队列的优势在于，1、消息队列也可以独立于发送和接收进程而存在，从而消除了在同步命名管道的打开和关闭时可能产生的困难。2、同时通过发送消息还可以避免命名管道的同步和阻塞问题，不需要由进程自己来提供同步方法。3、接收程序可以通过消息类型有选择地接收数据，而不是像命名管道中那样，只能默认地接收。

#include <sys/msg.h>
2 // 创建或打开消息队列：成功返回队列ID，失败返回-1
3 int msgget(key_t key, int flag);
4 // 添加消息：成功返回0，失败返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 读取消息：成功返回消息数据的长度，失败返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制消息队列：成功返回0，失败返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);

4、各个函数详解：
（1）创建或打开消息队列函数
int msgget(key_t, key, int msgflg);

与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。
在程序中若要使用消息队列，必须要能知道消息队列key,因为应用进程无法直接访问内核消息队列中的数据结构，因此需要一个消息队列的标识，让应用进程知道当前操作的是哪个消息队列，同时也要保证每个消息队列key值的唯一性。
申请一块内存，创建一个新的消息队列（数据结构msqid_ds)，将其初始化后加入到msgque向量表中的某个空位置处，返回标示符。或者在msgque向量表中找键值为key的消息队列。

（2）添加消息函数
int msgsnd(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);

msgid是由msgget函数返回的消息队列标识符。
msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：
struct my_message{ long int message_type; /* The data you wish to transfer*/ };
msg_sz是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。

如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.
（3）从一个消息队列中获取消息：
int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);
msgid, msg_ptr, msg_st的作用也函数msgsnd函数的一样。

msgtype可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg用于控制当队列中没有相应类型的消息可以接收时将发生的事情。

调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1.
（4）消息队列控制函数：
int msgctl(int msgid, int command, struct msgid_ds *buf);
command是将要采取的动作，它可以取3个值，

IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。

IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值

IPC_RMID：删除消息队列
buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：
struct msgid_ds { uid_t shm_perm.uid; uid_t shm_perm.gid; mode_t shm_perm.mode; };
成功时返回0，失败时返回-1.
5、废话不多说，直接上实例如下：
消息发送端：send.c文件内容如下

#include <stdio.h>   
#include <stdlib.h>//exit()
#include <string.h>//strcpy()
#include <sys/types.h>   
#include <sys/ipc.h>   
#include <sys/msg.h>   
#include <errno.h>    
#define MSGKEY 1024     
struct msgstru  {     
long msgtype;     
char msgtext[2048];   
};    
main()  
{    

    struct msgstru msgs;
    int msg_type;
	char str[256];    
	int ret_value;    
	int msqid;      
	msqid=msgget(MSGKEY,IPC_EXCL);  /*检查消息队列是否存在*/    
	if(msqid < 0)
	{      
	   	msqid = msgget(MSGKEY,IPC_CREAT|0666);/*创建消息队列*/      
		if(msqid <0)
		{      
		    printf("failed to create msq | errno=%d [%s]\n",errno,strerror(errno));      
		    exit(-1);      
		}  
	}       
	while (1)
	{      
		printf("input message type(end:0):");      
		scanf("%d",&msg_type);      
		if (msg_type == 0)         
		break;      
		printf("input message to be sent:");      
		scanf ("%s",str);      
		msgs.msgtype = msg_type;      
		strcpy(msgs.msgtext, str);      
		/* 发送消息队列 */      
		ret_value = msgsnd(msqid,&msgs,sizeof(struct msgstru),IPC_NOWAIT);      
		if ( ret_value < 0 ) 
		{         
			printf("msgsnd() write msg failed,errno=%d[%s]\n",errno,strerror(errno));         
			exit(-1);      
		}    
	}    
	msgctl(msqid,IPC_RMID,0); //删除消息队列   
}

消息接收端：receive.c文件如下：

/*receive.c */  
#include <stdio.h>   
#include <sys/types.h>   
#include <sys/ipc.h>   
#include <sys/msg.h>   
#include <errno.h>     
#define MSGKEY 1024     
struct msgstru  
{     
	long msgtype;     
	char msgtext[2048];  
};    
/*子进程，监听消息队列*/  
void childproc()
{    
	struct msgstru msgs;    
	int msgid,ret_value;    
	char str[512];        
	while(1)
	{       
		msgid = msgget(MSGKEY,IPC_EXCL );
		/*检查消息队列是否存在 */       
		if(msgid < 0){          
						printf("msq not existed! errno=%d [%s]\n",errno,strerror(errno));          
						sleep(2);          
						continue;       
					}       
		/*接收消息队列*/       
		ret_value = msgrcv(msgid,&msgs,sizeof(struct msgstru),0,0);       
		printf("text=[%s] pid=[%d]\n",msgs.msgtext,getpid());    
		}    
	return;  
	}    
void main()  
{
    int i,cpid;      
	/* create 5 child process */    
	for (i=0;i<5;i++)
	{       
	cpid = fork();       
	if (cpid < 0)          
	printf("fork failed\n");      
	else if (cpid ==0) /*child process*/          
	childproc();    
	}  
}

四、信号量

1、信号量本质上是一个计数器（不设置全局变量是因为进程间是相互独立的，而这不一定能看到，看到也不能保证++引用计数为原子操作）,用于多进程对共享数据对象的读取，它和管道有所不同，它不以传送数据为主要目的，它主要是用来保护共享资源（信号量也属于临界资源），使得资源在一个时刻只有一个进程独享。
2、特点

信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。

3、信号量工作原理

由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

（1）P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行

（2）V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

在信号量进行PV操作时都为原子操作（因为它需要保护临界资源）

注：原子操作：单指令的操作称为原子的，单条指令的执行是不会被打断的
实验代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<sys/sem.h>

// 联合体，用于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 main()
{
    int sem_id;  // 信号量集ID
    key_t key;  
    pid_t pid;

    // 获取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 创建信号量集，其中只有一个信号量
    if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
    {
        perror("semget error");
        exit(1);
    }

    // 初始化：初值设为0资源被占用
    init_sem(sem_id, 0);

    if((pid = fork()) == -1)
        perror("Fork Error");
    else if(pid == 0) /*子进程*/ 
    {
        sleep(2);
        printf("Process child: pid=%d\n", getpid());
        sem_v(sem_id);  /*释放资源*/
    }
    else  /*父进程*/
    {
        sem_p(sem_id);   /*等待资源*/
        printf("Process father: pid=%d\n", getpid());
        sem_v(sem_id);   /*释放资源*/
        del_sem(sem_id); /*删除信号量集*/
    }
    return 0;
}

实验结果如下：
在这里插入图片描述
从结果我们可以看出，父进程等待子进程运行结束后在运行。分析代码，我们知道，子进程释放了父进程需要的资源，子进程执行V原语操作，父进程执行P原语操作。

五、共享内存

共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。

1、特点
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

因为多个进程可以同时操作，所以需要进行同步。

信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

2、原型

#include <sys/shm.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接：成功返回0，失败返回-1
int shmdt(void *addr); 
// 控制共享内存的相关信息：成功返回0，失败返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

实验代码：

在这里插入代码片

实验结果：
客户端进程执行情况如下：
在这里插入图片描述

服务器端进程处理情况如下：
在这里插入图片描述
注意：当scanf()输入字符或字符串时，缓冲区中遗留下了\n，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持fflush(stdin)（它只是标准C的扩展），所以我们使用了替代方案：

作者： ZH奶酪——张贺
Q Q： 1203456195
邮箱： cheesezh@qq.com
出处： http://www.cnblogs.com/CheeseZH/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
注：本文大部分内容皆来源于此，文章也有自己的总结，与原文有一部分不一样。