进程间通信（IPC）介绍

发布时间：2022-10-24 15:07:41 所属栏目：Unix 来源：

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

　　以Linux中的C语言编程为例。

　　一、管道

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

　　以Linux中的C语言编程为例。

　　一、管道

　　管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。

　　1、特点：

　　它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。

　　它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。

　　它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

　　2、原型：

　　1 #include
　　2 int pipe(int fd[2]);    // 返回值：若成功返回0，失败返回-1
　　当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：

　　什么层实现进程到进程之间的通信_unix进程通信_unix根据端口查看进程

　　要关闭管道只需将这两个文件描述符关闭即可。

　　3、例子

　　单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：

　　unix进程通信_unix根据端口查看进程_什么层实现进程到进程之间的通信

　　左图- fork之后的半双工管道右图-从父进程到子进程的管道

　　若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。

　　#include
　　#include
　　int main()
　　{
　　    int fd[2]; // 两个文件描述符
　　    pid_t pid;
　　    char buff[20];
　　    if(pipe(fd) < 0) // 创建管道
　　        printf("Create Pipe Error!\n");
　　    if((pid = fork()) < 0) // 创建子进程
　　        printf("Fork Error!\n");
　　    else if(pid > 0) // 父进程
　　    {
　　        close(fd[0]); // 关闭读端
　　        write(fd[1], "hello world\n", 12);
　　    }
　　    else
　　    {
　　        close(fd[1]); // 关闭写端
　　        read(fd[0], buff, 20);
　　        printf("%s", buff);
　　    }
　　    return 0;
　　}
　　二、FIFO 1、特点

　　FIFO可以在无关的进程之间交换数据，与无名管道不同。

　　FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

　　2、原型

　　1 #include
　　2 // 返回值：成功返回0，出错返回-1
　　3 int mkfifo(const char *pathname, mode_t mode);
　　其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

　　当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

　　3、例子

　　FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”。下面的例子演示了使用 FIFO 进行 IPC 的过程：

　　write_fifo.c

　　#include
　　#include   // exit
　　#include    // O_WRONLY
　　#include
　　#include     // 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;
　　}
　　read_fifo.c

　　#include
　　#include
　　#include
　　#include
　　#include
　　int main()
　　{
　　    int fd;
　　    int len;
　　    char buf[1024];
　　    if(mkfifo("fifo1", 0666) < 0 && errno!=EEXIST) // 创建FIFO管道
　　        perror("Create FIFO Failed");
　　    if((fd = open("fifo1", O_RDONLY)) < 0) // 以读打开FIFO
　　    {
　　        perror("Open FIFO Failed");
　　        exit(1);
　　    }
　　    while((len = read(fd, buf, 1024)) > 0) // 读取FIFO管道
　　        printf("Read message: %s", buf);
　　    close(fd); // 关闭FIFO文件
　　    return 0;
　　}
　　上述例子可以扩展成客户进程—服务器进程通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：

　　什么层实现进程到进程之间的通信_unix根据端口查看进程_unix进程通信

　　三、消息队列

　　消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。

　　1、特点

　　消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

　　消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。

　　消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

　　2、原型

　　#include
　　// 创建或打开消息队列：成功返回队列ID，失败返回-1
　　int msgget(key_t key, int flag);
　　// 添加消息：成功返回0，失败返回-1
　　int msgsnd(int msqid, const void *ptr, size_t size, int flag);
　　// 读取消息：成功返回消息数据的长度，失败返回-1
　　int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
　　// 控制消息队列：成功返回0，失败返回-1
　　int msgctl(int msqid, int cmd, struct msqid_ds *buf);
　　在以下两种情况下，msgget将创建一个新的消息队列：

　　函数msgrcv在读取消息队列时，type参数有下面几种情况：

　　可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。（其他的参数解释，请自行Google之）

　　3、例子

　　下面写了一个简单的使用消息队列进行IPC的例子，服务端程序一直在等待特定类型的消息，当收到该类型的消息以后，发送另一种特定类型的消息作为反馈，客户端读取该反馈并打印出来。

　　msg_server.c

　　#include
　　#include
　　#include
　　#include
　　#include
　　      // 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);
　　
　　     //      key_t ftok(const char *pathname, int proj_id);
　　     //      int msgctl(int msqid, int cmd, struct msqid_ds *buf);
　　struct msgbuf {
　　               long mtype;       /* message type, must be > 0 */
　　               char mtext[128];    /* message data */
　　};
　　int main()
　　{
　　       key_t key;
　　       key=ftok(".",35);
　　       printf("key=%x\n",key);
　　       struct msgbuf readbuf;
　　       struct msgbuf sendbuf={999,"thank for your send"};
　　       int msgId=msgget(key, IPC_CREAT|0777);
　　       if(msgId == -1){
　　           printf("msgget faild\n");
　　       }
　　       msgrcv(msgId,&readbuf, sizeof(readbuf.mtext),888,0);
　　       printf("read from quie:%s\n",(readbuf.mtext));
　　
　　       msgsnd(msgId,&sendbuf,strlen(sendbuf.mtext),0);
　　
　　      msgctl(msgId, IPC_RMID,NULL);
　　      return 0;
　　}
　　msg_client.c

　　#include
　　#include
　　#include
　　#include
　　#include
　　      // 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);
　　
　　struct msgbuf {
　　               long mtype;       /* message type, must be > 0 */
　　               char mtext[128];    /* message data */
　　};
　　int main()
　　{
　　       key_t key;
　　       key=ftok(".",35);
　　       printf("key=%x\n",key);
　　       struct msgbuf readbuf;
　　       struct msgbuf sendbuf={888,"this is massage from quie"};
　　       int msgId=msgget(key, IPC_CREAT|0777);
　　       if(msgId == -1){
　　           printf("msgget faild\n");
　　       }
　　       msgsnd(msgId, &sendbuf, strlen(sendbuf.mtext),0);
　　       msgrcv(msgId,&readbuf,sizeof(sendbuf.mtext),999,0);
　　       printf("%s\n",readbuf.mtext);
　　       msgctl(msgId, IPC_RMID,NULL);
　　     return 0;
　　}
　　四、共享内存

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

　　1、特点

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

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

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

　　2、原型

　　#include
　　// 创建或获取一个共享内存：成功返回共享内存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);
　　当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

　　当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。

　　shmdt函数是用来断开shmat建立的连接的。注意unix进程通信，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。

　　shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。

　　3、例子

　　server.c

　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　      // void *shmat(int shmid, const void *shmaddr, int shmflg);
　　      // int shmdt(const void *shmaddr);
　　      // int shmget(key_t key, size_t size, int shmflg);
　　      // int shmctl(int shmid, int cmd, struct shmid_ds *buf);
　　int main()
　　{
　　     int shmId;
　　     char *shmaddr=NULL;
　　     char *p="wu guo qing so hangson";
　　     key_t key;
　　     key=ftok(".",25);
　　     printf("key=%x\n",key);
　　     shmId=shmget(key,1024*4,IPC_CREAT|0777);
　　     if(shmId == -1){
　　        printf("shmget failed\n");
　　        exit(-1);
　　     }
　　    // exit(0);
　　     shmaddr=shmat(shmId,0,0);
　　
　　     strcpy(shmaddr,"wu guo qing so hangson");
　　
　　     sleep(6);
　　     shmdt(shmaddr);
　　     shmctl(shmId, IPC_RMID,NULL);
　　     printf("quit\n");
　　     return 0;
　　}
　　clinet.c

　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　      // void *shmat(int shmid, const void *shmaddr, int shmflg);
　　      // int shmdt(const void *shmaddr);
　　      // int shmget(key_t key, size_t size, int shmflg);
　　      // int shmctl(int shmid, int cmd, struct shmid_ds *buf);
　　int main()
　　{
　　     int shmId;
　　     char *shmaddr=NULL;
　　
　　     key_t key;
　　     key=ftok(".",25);
　　     printf("key=%x\n",key);
　　     shmId=shmget(key,1024*4,0);
　　
　　     shmaddr=shmat(shmId,0,0);
　　
　　     printf("content:%s\n",shmaddr);
　　
　　     shmdt(shmaddr);
　　     shmctl(shmId, IPC_RMID,NULL);
　　     printf("That over!\n");
　　     return 0;
　　}
　　实验结果：

　　补充：在linux中，ipcs -m指令可查询共享内存，ipcrm -m （共享内存的ID号），例如：ipcrm -m 65544

（编辑：我爱资讯网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!