目录
进程间通信（Inter-Process Communication, IPC）是指在两个或者多个不同得劲进程间传递或者交换信息，通过信息的传递建立几个进程间的联系，协调一个系统中的多个进程之间的行为。
进程与进程之间是相互独立的，各自运行在自己的虚拟内存中。要想在进程与进程间建立联系，需要通过内核，在内核中开辟一块缓冲区，两个进程的信息在缓冲区中进行交换或者传递。
进程间通信原理是：进程A中的数据写入到内核中，进程B中的数据也写入到内核中，两者在内核中进行交换。交换后，进程A读取内核中的数据，进程B也读取内核中的数据，这样两个进程间交换数据的通信就完成了。两个进程通过内核建立了联系，那么交换数据、传递数据、发送事件等行为就都可以实现了。
在Linux系统中，常见的进程间通信主要包括管道通信、共享内存通信、信号量通信、消息队列通信、套接口（SOCKET）通信和全双工通信。
Linux系统除了支持信号和管道外，还支持SYSV(System V)子系统中的进程间通信机制。在SYSV的IPC机制中，包括共享内存、信号量、消息队列通信。
一、管道通信
管道主要用于父子或者兄弟进程间的数据读写，命名管道则可以在无关联的进程间进行沟通传递数据。
在Linux系统中的进程通信中，管道这个概念也是如此，某一时刻只能单一方向传递数据，不能双向传递数据，这种工作模式就叫做半双工模式。半双工工作模式的管道通信是只能从一端写数据，从另一端读数据。
管道分为标准流管道，无名管道(PIPE)，命名管道(FIFO)。
1.1 有名管道
若是没有关系的进程间通信就要用命名管道。命名管道通常被称为FIFO。它作为特殊的设备文件存在于文件系统中。
(1)创建一个命名管道
命名管道可以从命令行上创建，命令行方法是使用下面这个命令：
$ mkfifo filename
也可以从程序里创建，相关函数：
#include <sys/tyoes.h>
#include <sys/stat.h>
int mkfifo(const char* pathname, mode_t mode);
该函数的参数pathname是一个文件的路径名，是创建的一个命名管道的文件名；参数mode是指文件的权限，文件权限取决于(mode)的值。
使用mkfifo()函数创建的命名管道文件与前面介绍的管道通信相似，只是它们创建方式不同。访问命名管道文件与访问文件系统中的其他文件一样，都是需要首先打开文件，然后对文件进行读写数据。如果在命名管道文件中读取数据时，并没有其他进程向命名管道文件中写入数据，则会出现进程阻塞状态；如果在写入数据的同时，没有进程从命名管道中读取数据，也会出现进程阻塞状态。
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define MAXSIZE 100
int main()
{
int fd[2], pid, line;
char message[MAXSIZE];
/*创建管道*/
if(pipe(fd) == -1)
{
perror("create pipe failed!");
return -1;
}
/*创建新进程*/
else if((pid = fork()) < 0)
{
perror("not create a new process!");
return -1;
}
/*子进程*/
else if(pid == 0)
{
close(fd[0]);//关闭读
printf("child process SEND message!\n");
write(fd[1], "Hello Linux!",12); /*向文件中写入数据*/
}
else
{
close(fd[1]);//关闭写
printf("parent process RECEIVE message is:\n");
line = read(fd[0], message, MAXSIZE); /*读取消息，返回消息长度*/
printf("%s",message);
printf("\n");
usleep(500000);
}
return 0;
}
1.2 无名管道
管道特点：
只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork()，此后父子进程之间就可以应用该管道。
一般而言，进程退出，管道释放，所以管道的生命周期跟随进程。
一般而言，内核会对管道操作进行同步与互斥
管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。
受限制之一就是两个进程必须是相关联的进程。若是没有关系的进程间通信就要用命名管道。
管道流程：
1.创建无名管道
2.关闭读，向管道写数据
3. 关闭写，向管道读数据
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define MAXSIZE 100
int main()
{
int fd[2], pid, line;
char message[MAXSIZE];
/*创建管道*/
if(pipe(fd) == -1)
{
perror("create pipe failed!");
return -1;
}
/*创建新进程*/
else if((pid = fork()) < 0)
{
perror("not create a new process!");
return -1;
}
/*子进程*/
else if(pid == 0)
{
close(fd[0]);//关闭读
printf("child process SEND message!\n");
write(fd[1], "Hello Linux!",12); /*向文件中写入数据*/
}
else
{
close(fd[1]);//关闭写
printf("parent process RECEIVE message is:\n");
line = read(fd[0], message, MAXSIZE); /*读取消息，返回消息长度*/
printf("%s",message);
printf("\n");
usleep(500000);
}
return 0;
}
1.3 相关函数
（1）pipe()函数
#include <unistd.h>
int pipe(int filedes[2]);
pipe()函数用于在内核中创建一个管道，该管道一端用于读取管道中的数据，另一端用于将数据写入管道。在创建一个管道后，会获得一对文件描述符，用于读取和写入，然后将参数数组filedes中的两个值传递给获取到的两个文件描述符，filedes[0]指向管道的读端，filedes[1]指向写端。
（2）mkfifo()函数
二、消息队列
2.1 消息队列
消息队列就是一个存储消息的链表，这些消息具有特定的格式，以及特定的优先级。对消息队列有写权限的进程可以向其中添加新消息，对消息队列有读权限的进程则可以从其中读取消息。
消息队列是随内核持续的，只有在内核重启，或者删除一个消息队列时，该消息队列才会真正地被删除。对消息队列的操作有下面3种：
- 打开或创建消息队列。
- 读写操作。
- 获得或设置消息队列属性。
2.2 发送
1.打开或创建消息队列
2.读写操作
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/msg.h>
#include <errno.h>
#define MAX_TEXT 512
struct msg_st {
long int msg_type;
char text[MAX_TEXT];
};
int main (int argc,char **argv )
{
struct msg_st data;
char buffer[BUFSIZ];
int msgid = -1;
msgid = msgget ( ( key_t ) 1234, 0666 | IPC_CREAT );
if ( msgid == -1 ) {
fprintf ( stderr, "msgget failed error: %d\n", errno );
exit ( EXIT_FAILURE );
}
while ( 1 )
{
printf ( "Enter some text: \n" );
fgets ( buffer, BUFSIZ, stdin );
data.msg_type = 1;
strcpy ( data.text, buffer );
if ( msgsnd ( msgid, ( void * ) &data, MAX_TEXT, 0 ) == -1 ) {
fprintf ( stderr, "msgsnd failed\n" );
exit ( EXIT_FAILURE );
}
if ( strncmp ( buffer, "end", 3 ) == 0 ) {
break;
}
sleep (1);
}
exit (EXIT_SUCCESS);
}
2.3 接收
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <errno.h>
struct msg_st {
long int msg_type;
char text[BUFSIZ];
};
int main (int argc, char **argv ) {
int msgid = -1;
struct msg_st data;
long int msgtype = 0;
msgid = msgget ( ( key_t ) 1234, 0666 | IPC_CREAT );
if ( msgid == -1 ) {
fprintf ( stderr, "msgget failed width error: %d\n", errno );
exit ( EXIT_FAILURE );
}
while ( 1 )
{ /* 从队列中获取消息，直至遇到“end” */
if ( msgrcv ( msgid, ( void * ) &data, BUFSIZ, msgtype, 0 ) == -1 )
{
fprintf ( stderr, "msgrcv failed width erro: %d", errno );
}
printf ( "You wrote: %s", data.text );
if (strncmp ( data.text, "end", 3 ) == 0)
{
break;
}
}
if ( msgctl ( msgid, IPC_RMID, 0 ) == -1 ) { /* 删除消息队列 */
fprintf ( stderr, "msgctl(IPC_RMID) failed\n" );
}
exit ( EXIT_SUCCESS );
}
2.4 相关函数
(1) ftok函数
消息队列的内核持续性要求每个消息队列都要在系统范围内有对应的唯一键值，可以使用ftok获取键值：
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok ( char *pathname, char proj ); /* f是file，k是key */
pathname是文件名；proj是项目名，不为0即可。
key_t可直接创建，不需要ftok
key_t Video_Transmit_Key = 0x5003;
key_t Vehicle_Control_Key = 0x5005;
(2) msgget函数
使用msgget来创建消息队列，函数返回与健值key相对应的消息队列描述符：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget ( key_t key, int msgflg );
key是键值，由ftok获得msgflg是标志位，有如下选项，这些选项可以进行或操作：
IPC_CREAT：创建新的消息队列。IPC_EXCL：与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。IPC_NOWAIT：当消息队列无法满足读写需求时，msgsnd与msgrcv不被阻塞。
在消息队列中，每一个消息的格式为struct msgbuf：
struct msgbuf {
long mtype; // 消息类型
char mtext[1]; // 消息数据的首地址
};
(3)msgsnd函数
msgsnd的功能是向消息队列发送一条消息，发送成功则返回0，否则返回-1：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd ( int msqid, struct msgbuf *msgp, int msgsz, int msgflg );msqid：已打开的消息队列id。msgp：存放消息的结构。msgsz：消息数据长度。msgflg：发送标志，常用0和IPC_NOWAIT。
- 如果
msgflg为0，则当消息队列没有足够空间容纳要发送的消息时，msgsnd将被阻塞。 - 如果
msgflg为IPC_NOWAIT，则当消息队列没有足够空间容纳要发送的消息时，msgsnd不会被阻塞。
(4)msgrcv函数
msgrcv从消息队列msqid中读取一个msgtyp类型的消息，消息长度为msgsz，并把消息存储在msgp指向的msgbuf结构中：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv ( int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg );
在成功地读取了一条消息以后，消息队列中的这条消息将被删除。
msgtype可以实现一种简单的接收优先级：
- 如果
msgtype为0，就获取队列中的第一个消息。 - 如果
msgtype大于零，就获取具有相同消息类型的第一个消息。 - 如果
msgtype小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg有如下选项，这些选项可以进行或操作：
0：忽略msgflg。IPC_NOWAIT：如果没有满足条件的消息，则函数立即返回。IPC_EXCEPT：与msgtyp > 0配合使用，返回消息队列中第一个类型不为msgtyp的消息。IPC_NOERROR：如果消息队列中满足条件的消息内容大于所请求的msgsz字节，则把该消息截断，截断部分将丢失。
(5)msgctl函数
msgctl对消息队列msqid执行cmd操作：
int msgctl ( int msqid, int cmd, struct msqid_ds *buf );
共有3种cmd操作：
IPC_STAT：用来获取消息队列的属性，返回的属性存储在buf指向的msqid结构中。IPC_SET：用来设置消息队列的属性，要设置的属性存储在buf指向的msqid结构中。IPC_RMID：删除的消息队列msqid。
如果函数执行成功，则返回0，否则返回-1。
三、共享内存
共享存储允许两个或多个进程共享一个给定的存储区，是进程间通信最快的一种方式。不要同时对共享存储空间进行写操作，通常，信号量用于同步共享存储访问。
最简单的共享内存的使用流程
①ftok函数生成键值
②shmget函数创建共享内存空间
③shmat函数获取第一个可用共享内存空间的地址
④shmdt函数进行分离（对共享存储段操作结束时的步骤，并不是从系统中删除共享内存和结构）
⑤shmctl函数进行删除共享存储空间
3.1 发送端 写入
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//#include<strsep.h>
int main ()
{
char *shmaddr;
key_t key;
// key_t ftok(const char *path ,int id);
key = ftok("./",24);
int shmgetId;
shmgetId = shmget(key,1024*4,IPC_CREAT|0666);
if (shmgetId == -1)
{
printf("shmget fail! \n");
exit(-1);
}
printf("shmget success !\n");
//函数原型： void *shmat(int shmid, const void *addr, int flag);
shmaddr = shmat(shmgetId,0,0);
printf("shmat success!");
strcpy(shmaddr," tea eggs hansome !");
printf("write sucee\n");
sleep(5);
//函数原型： int shmdt(const void *addr);
shmdt(shmaddr);
//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
shmctl(shmgetId,IPC_RMID,0);
return 0;
}
3.2 接收端 读取
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//#include<strsep.h>
int main ()
{
char *shmaddr;
// 所需头文件：#include<sys/ipc.h>
key_t key;
// key_t ftok(const char *path ,int id);
key = ftok("./",24);
int shmgetId;
shmgetId = shmget(key,1024*4,0);
if (shmgetId == -1)
{
printf("shmget fail! \n");
exit(-1);
}
printf("shmget success !\n");
//函数原型： void *shmat(int shmid, const void *addr, int flag);
shmaddr = shmat(shmgetId,0,0);
printf("shmat success!");
printf("data: %s\n",shmaddr);
//函数原型： int shmdt(const void *addr);
shmdt(shmaddr);
//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
return 0;
}
3.3 相关函数
(1)ftok函数
每一个共享存储段都有一个对应的键值（key）相关联（消息队列、信号量也同样需要）。
所需头文件：#include<sys/ipc.h>
函数原型 ：key_t ftok(const char *path ,int id);
path为一个已存在的路径名
id为0~255之间的一个数值，代表项目ID，自己取
返回值：成功返回键值（相当于32位的int）。出错返回-1
例如：key_t key = ftok( “/tmp”, 66);
(2)shmget函数
创建共享存储空间并返回一个共享存储标识符
所需头文件：#include<sys/shm.h>
函数原型： int shmget(key_t key, size_t size,int flag);
key为ftok生成的键值
size为共享内存的长度，以字节为单位
flag为所需要的操作和权限，可以用来创建一个共享存储空间并返回一个标识符或者获得一个共享标识符。
flag的值为IPC_CREAT：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空间，并返回一个共享存储标识符。如果存在，则直接返回共享存储标识符。
flag的值为 IPC_CREAT | IPC_EXCL：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空间，并返回一个共享存储标识符。如果存在，则产生错误。
返回值：成功返回共享存储ID；出错返回-1
例如：int id = shmget(key,4096,IPC_CREAT|IPC_EXCL|0666);创建一个大小为4096个字节的权限为0666（所有用户可读可写，具体查询linux权限相关内容）的共享存储空间，并返回一个整形共享存储标识符，如果key值已经存在有共享存储空间了，则出错返回-1。
int id = shmget(key,4096,IPC_CREAT|0666);创建一个大小为4096个字节的权限为0666（所有用户可读可写，具体查询linux权限相关内容）的共享存储空间，并返回一个共享存储标识符，如果key值已经存在有共享存储空间了，则直接返回一个共享存储标识符。
(3)shmat函数
所需头文件：#include<sys/shm.h>
函数原型： void *shmat(int shmid, const void *addr, int flag);
shmid为shmget生成的共享存储标识符
addr指定共享内存出现在进程内存地址的什么位置，直接指定为NULL让内核自己决定一个合适的地址位置
flag为对数据的操作，如果指定为SHM_RDONLY则以只读方式连接此段，其他值为读写方式连接此段。
翻阅linux下shm.c文件得到#define SHM_RDONLY 010000 /* read-only access */
返回值：成功返回指向共享存储段的指针；错误返回-1（打印出指针的值为全F）
例如：char *addr = shmat(id, NULL, 0);就会返回第一个可用的共享内存地址的指针的值给addr
(4)shmdt函数
当不需要对此共享内存进行操作时候，调用shmdt函数进行分离，不是删除此共享存储空间哟。
所需头文件：#include<sys/shm.h>
函数原型： int shmdt(const void *addr);
addr为shmat函数返回的地址指针
返回值：成功返回0；错误返回-1
例如：int ret = shmdt(addr);
(5)shmctl函数
简单的操作就是删除共享存储空间了，也可以获取和改变共享内存的状态
所需头文件：#include<sys/shm.h>
函数原型：int shmctl(int shmid, int cmd, struct shmid_ds *buf);
shmid就是shmget函数返回的共享存储标识符
cmd有三个，常用删除共享内存的为IPC_RMID；IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中；IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内。（内核为每个共享存储段维护着一个结构，结构名为shmid_ds，这里就不讲啦，里面存放着共享内存的大小，pid，存放时间等一些参数）
buf就是结构体shmid_ds
返回值：成功返回0；错误返回-1
例如：int ret = shmctl(id, IPC_RMID,NULL);删除id号的共享存储空间
四、信号量
五、信号
5440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
