转载至《【Unix】进程间通信（IPC）》

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

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

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

一. 管道

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

1、特点

它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

tips:

流管道能解决半双工的问题
命名管道能解决只能在关联进程中通信的问题

2、原型

#include <unistd.h>
int pipe(int fd[2]);    // 返回值：若成功返回0，失败返回-1；fd[0]读，fd[1]写

当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：
（转载）进程间通信
要关闭管道只需将这两个文件描述符关闭即可。

3、例子

单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：（转载）进程间通信
若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。

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

/*
(匿名)管道：
    1. 半双工（数据只能在一个方向上流动：父->子、子->父），具有固定的读写端；可创建两个管道实现双向通信
    2. 只能用于父子或兄弟进程间通信
    3. 可以使用write、read等函数，但不属于任何文件系统，只存在与内存中

流程：
    1. 创建管道pipe
    2. 关闭读或写端close
    3. 写数据write
    4. 读数据read
*/

int main()
{
    int fd[2]; // 两个文件描述符，fd[0]读，fd[1]写
    pid_t pid;
    char buff[20] = {0};
    int i = 0;

    if (pipe(fd) < 0) // 创建管道
    {
        printf("Create Pipe Error \n");
        return -1;
    }

    // fork()拷贝创建新进程，将会同时在主进程和子进程中返回pid，主进程返回的pid>0，子进程返回的pid=0
    if ((pid = fork()) < 0)
    {
        printf("Fork Error!\n");
        return -1;
    }
    else if (pid > 0) //父进程
    {
        close(fd[0]);   //关闭读端
        while (i < 10)
        {
            sprintf(buff, "send times %d", i);
            write(fd[1], buff, 12);
            i++;
            sleep(1);
        }
    }
    else
    {
        close(fd[1]);   // 关闭写端
        while (i < 10)
        {
            // sleep(1);
            read(fd[0], buff, 20);
            printf("%s \n", buff);
            i++;
        }
    }

    return 0;
}

二、FIFO

FIFO ，也称为命名管道，它是一种文件类型。

1、特点

FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2、原型

#include <sys/stat.h>
// 返回值：成功返回0，出错返回-1
// pathname 文件名，会创建一个真实的FIFO文件
// mode 指定文件的读写权限（0666、0777）
int mkfifo(const char *pathname, mode_t mode);

// 打开FIFO文件的四种方式
open(const char *path, O_RDONLY); // 1
open(const char *path, O_RDONLY | O_NONBLOCK); // 2
open(const char *path, O_WRONLY); // 3
open(const char *path, O_WRONLY | O_NONBLOCK); // 4

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

若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

3、例子

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

// fifo_writer.cpp
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

#define FIFO_NAME "/var/tmp/fifo_test"

/*
FIFO 命名管道：
    1. 可在无关的进程间交换数据
    2. 与特定路径名关联，以一种特殊的设备文件形式存在于文件系统中
    3. 在创建命名管道的进程关闭后释放

流程：
    1. 创建命名管道mkfifo
    2. 打开FIFO命名管道open
    3. 写数据write/读数据read
    4. 关闭命名管道close

每个客户端和服务端都创建一个FIFO管道（根据文件名区分，客户端发送消息时带上文件名），可实现一个服务端对多个客户端的通信
*/

int main()
{
    int fd;
    int n, i;
    char buf[1024];
    time_t tp;

    if ((fd = open(FIFO_NAME, O_WRONLY)) < 0)
    {
        perror("Open FIFO Failed");
        exit(1);
    }

    for (size_t 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)
        {
            perror("Write FIFO Failed");
            close(fd);
            exit(1);
        }
        sleep(1);
    }

    close(fd);
    return 0;
}

//fifo_reader.cpp
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>

#define FIFO_NAME "/var/tmp/fifo_test"



int main()
{
    int fd;
    int len;
    char buf[1024];

    //int mkfifo(const char * pathname,mode_t mode); mode 文件权限
    if (mkfifo(FIFO_NAME, 0666) < 0 && errno != EEXIST)
        perror("Create FIFO Failed");

    if ((fd = open(FIFO_NAME, O_RDONLY)) < 0)
    {
        perror("Open FIFO Failed");
        exit(1);
    }

    while ((len = read(fd, buf, 1024)) > 0)
    {
        printf("Read message: %s", buf);
    }

    close(fd);
    return 0;
}

在终端分别用g++编译：

> g++ fifo_writer.cpp -o fifo_writer.o
> g++ fifo_reader.cpp -o fifo_reader.o

运行：

./fifo_write.o
Send message: Process 7901's time is Thu Mar 21 15:01:15 2019
Send message: Process 7901's time is Thu Mar 21 15:01:16 2019
Send message: Process 7901's time is Thu Mar 21 15:01:17 2019
Send message: Process 7901's time is Thu Mar 21 15:01:18 2019
Send message: Process 7901's time is Thu Mar 21 15:01:19 2019
Send message: Process 7901's time is Thu Mar 21 15:01:20 2019
Send message: Process 7901's time is Thu Mar 21 15:01:21 2019
Send message: Process 7901's time is Thu Mar 21 15:01:22 2019
Send message: Process 7901's time is Thu Mar 21 15:01:23 2019
Send message: Process 7901's time is Thu Mar 21 15:01:24 2019

./fifo_reader.o
Read message: Process 7901's time is Thu Mar 21 15:01:15 2019
Read message: Process 7901's time is Thu Mar 21 15:01:16 2019
Read message: Process 7901's time is Thu Mar 21 15:01:17 2019
Read message: Process 7901's time is Thu Mar 21 15:01:18 2019
Read message: Process 7901's time is Thu Mar 21 15:01:19 2019
Read message: Process 7901's time is Thu Mar 21 15:01:20 2019
Read message: Process 7901's time is Thu Mar 21 15:01:21 2019
Read message: Process 7901's time is Thu Mar 21 15:01:22 2019
Read message: Process 7901's time is Thu Mar 21 15:01:23 2019
Read message: Process 7901's time is Thu Mar 21 15:01:24 2019

上述例子可以扩展成客户进程—服务器进程通信的实例，fifo_writer的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，fifo_reader类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：
（转载）进程间通信

三、消息队列

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

1、特点

消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

2、原型

#include <sys/msg.h>
// 创建或打开消息队列：成功返回队列ID，失败返回-1
// flag: 获取消息队列的标志与存取权限
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将创建一个新的消息队列：

如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
key参数为IPC_PRIVATE。

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

type == 0，返回队列中的第一个消息；
type > 0，返回队列中消息类型为 type 的第一个消息；
type < 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。

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

3、例子

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

// msg_server.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <errno.h>
#include <unistd.h>

/*
消息队列：
    1. 消息具有特定的格式以及特定的优先级
    2. 消息队列独立于收发进程，进程终止时，消息队列的内容并不会删除
    3. 消息队列可实现消息的随机查询，消息不一定要以先进先出的顺序读取，也可以按消息的类型读取

流程：
    1. 创建IPC的key ftok
    2. 创建消息队列msgget
    3. 发送消息msgsnd
    4. 接收消息msgrcv
*/

// 文件名
#define MSG_FILE "/etc/passwd"

// msg struct
struct msg_form
{
    long mtype;     // 第一个字段必须为long类型
    char mtext[256];
};

int main()
{
    int msqId;
    key_t key;
    struct msg_form msg;

    //获取key值，系统建立IPC通讯 （消息队列、信号量和共享内存） 时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。
    //key_t ftok(const char *__pathname,int __proj_id)  // __pathname: 指定的文件名称，__proj_id: 子序号
    if ((key = ftok(MSG_FILE, 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    printf("Message Queue - Server key is: %d.\n", key);

    // 创建消息队列
    if ((msqId = msgget(key, IPC_CREAT | 0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msqid is: %d.\n", msqId);
    printf("My pid is: %d.\n", getpid());

    // 循环读取消息
    for (;;)
    {
        msgrcv(msqId, &msg, 256, 888, 0); // 返回类型为888的第一个消息
        printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
        printf("Server: receive msg.mtype is: %d.\n", msg.mtype);

        msg.mtype = 999;    // 设置消息类型为999
        sprintf(msg.mtext, "hello, I'm server %d", getpid());
        msgsnd(msqId, &msg, sizeof(msg.mtext), 0);  // 发送消息
    }

    return 0;
}

//msg_client.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <errno.h>
#include <unistd.h>

// 文件路径
#define MSG_FILE "/etc/passwd"

// msg struct
struct msg_form
{
    long mtype;
    char mtext[256];
};

int main()
{
    int msqId;
    key_t key;
    struct msg_form msg;

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

    printf("Message Queue - Client key is: %d.\n", key);

    // 打开消息队列
    //int msgget (key_t __key, int __msgflg) __msgflg: 消息队列的建立标志与存取权限
    if ((msqId = msgget(key, IPC_CREAT | 0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msqid is: %d.\n", msqId);
    printf("My pid is: %d.\n", getpid());

    // 添加消息，类型为888
    msg.mtype = 888;
    sprintf(msg.mtext, "hello, I'm client %d", getpid());
    msgsnd(msqId, &msg, sizeof(msg.mtext), 0);

    // 读取类型为999的消息
    msgrcv(msqId, &msg, 256, 999, 0);
    printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
    printf("Client: receive msg.mtype is: %d.\n", msg.mtype);

    return 0;
}

4、一对多的双向消息队列

一个服务端与多个客户端之间的消息队列通信。

// msg_mc_common.h
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <errno.h>

// 文件路径
#define MSG_FILE "."

// msg struct
struct msg_form
{
    long mtype;
    long stype; // 数据发送者方的type
    char mtext[256];
};

// msg_mc_client.cpp
/*
利用消息队列，多个客户端与一个服务端通信，服务端接收到客户端的消息后将数据返回值相应的客户端
*/

#include "msg_mc_common.h"

int main()
{
    int msqId;
    key_t key;
    struct msg_form msg;

    long server_type = 888;

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

    printf("Message Queue - Client key is: %d.\n", key);

    // 打开消息队列
    //int msgget (key_t __key, int __msgflg) __msgflg: 消息队列的建立标志与存取权限
    if ((msqId = msgget(key, IPC_CREAT | 0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msqid is: %d.\n", msqId);
    printf("My pid is: %d.\n", getpid());

    long mtype = getpid();      // 设置当前的消息类型
    // 添加消息
    msg.mtype = server_type;    // 消息接收端type
    msg.stype = mtype;          // 消息发送端type
    sprintf(msg.mtext, "hello, I'm client %d", getpid());
    msgsnd(msqId, &msg, sizeof(msg) - sizeof(long), 0);

    // 读取当前消息类型中的数据
    msgrcv(msqId, &msg, sizeof(msg) - sizeof(long), mtype, 0);
    printf("Client: receive msg.mtext is: %s from msg.stype: %d.\n", msg.mtext, msg.stype);
    printf("Client: receive msg.mtype is: %d.\n", msg.mtype);

    return 0;
}

// msg_mc_server.cpp
/*
利用消息队列，多个客户端与一个服务端通信
*/

#include "msg_mc_common.h"

int main()
{
    int msqId;
    key_t key;
    struct msg_form msg;

    // 服务端在消息队列中的type值
    long mtype = 888;

    //获取key值，系统建立IPC通讯 （消息队列、信号量和共享内存） 时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。
    //key_t ftok(const char *__pathname,int __proj_id)  // __pathname: 指定的文件名称，__proj_id: 子序号
    if ((key = ftok(MSG_FILE, 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    printf("Message Queue - Server key is: %d.\n", key);

    // 创建消息队列
    if ((msqId = msgget(key, IPC_CREAT | 0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msqid is: %d.\n", msqId);
    printf("My pid is: %d.\n", getpid());

    // 循环读取消息
    for (;;)
    {
        msgrcv(msqId, &msg, sizeof(msg) - sizeof(long), mtype, 0); // 返回类型为888的第一个消息
        printf("Server: receive msg.mtext is: %s from msg.stype: %d.\n", msg.mtext, msg.stype);
        printf("Server: receive msg.mtype is: %d.\n", msg.mtype);

        // 根据消息数据的前4位得到消息类型，根据消息类型发送消息至不同的客户端
        msg.mtype = msg.stype; // 设置消息类型为发送方的类型
        msg.stype = mtype;
        sprintf(msg.mtext, "hello, I'm server %d", getpid());
        msgsnd(msqId, &msg, sizeof(msg) - sizeof(long), 0); // 发送消息
    }

    return 0;
}

四、信号量

信号量（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结构的定义如下：

/* Structure used for argument to `semop' to describe operations.  */
struct sembuf
{
  unsigned short int sem_num;	/* semaphore number,信号量序号 */
  short int sem_op;		/* semaphore operation，操作改变量1|-1或其他 */
  short int sem_flg;		/* operation flag，IPC_NOWAIT, SEM_UNDO */
};

其中 sem_op 是一次操作中的信号量的改变量：

若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。
若sem_op < 0，请求 sem_op 的绝对值的资源。
- 如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
- 当相应的资源数不能满足请求时，这个操作与sem_flg有关。
  - sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
  - sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
    1. 当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
    2. 此信号量被删除，函数smeop出错返回EIDRM；
    3. 进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
- 若sem_op == 0，进程阻塞直到信号量的相应值为0：
  - 当信号量已经为0，函数立即返回。
  - 如果信号量的值不为0，则依据sem_flg决定函数动作：
    - sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
    - sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
      1. 信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
      2. 此信号量被删除，函数smeop出错返回EIDRM；
      3. 进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

在semctl函数中的命令有多种，这里就说两个常用的：

SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

3、例子

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

/*
信号量：
    1. 通过系统的PV操作解决进程同步和互斥
    2. 进程独立，信号量不删除将会一直保留在系统中，即使程序已退出

流程：
    1. 使用ftok创建IPC的key值
    2. 创建信号量semctl（参数 IPC_CREAT，信号量初始值）
    3. 初始化信号量semctl （参数 SETVAL，信号量初始值）
    4. P操作 semop（sembuf.sem_op = -1)
    5. V操作 semop（sembuf.sem_op = 1)
    6. 删除信号量 semctl（参数 IPC_RMID）
*/


// 联合体，用于semctl初始化
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

// 初始化信号量
int init_sem(int sem_id, int value)
{
    union semun tmp;
    tmp.val = value;

    // Semaphore控制
    // 初始化id为sem_id，序号为0的信号量，值为tmp.val
    if (semctl(sem_id, 0, SETVAL, tmp) == -1)
    {
        perror("Init Semaphore Error");
        return -1;
    }

    return 0;
}

// P操作（通过）
// 将信号量值减1
// 若信号量值 < 0，进程挂起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; // 序号，取值0 - _nsems-1(根据semget函数的_nsems参数)
    sbuf.sem_op = -1; // 信号量值在一次操作中的改变量，<0 P操作，判断信号量>=0则表示资源可用，进程继续执行，否则进程置为等待状态
    sbuf.sem_flg = SEM_UNDO;    // 退出时撤销操作，IPC_NOWAIT/SEM_UNDO

    // Semaphore操作
    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操作，释放信号量资源，并将信号量值+1
    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);
    }

    // 创建信号量集，_nsems 信号量个数
    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;
}

上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。

五、共享内存

共享内存（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);

当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

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

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

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

3、例子

//shm_server.cpp
#include <stdio.h>
#include <stdlib.h> // 标准库函数头文件
#include <sys/shm.h>

/*
共享内存：
    1. 共享内存是一种最快的IPC，因为进程是直接对内存进行存取
    2. 多个进程可用同时操作，所以需要进行同步
    3. 信号量+共享内存通常结合一起使用，信号量可用来同步对共享内存的访问
    4. 进程独立，共享内存不删除将一直保留在系统中

流程：
    1. 创建IPC的key
    2. 创建共享内存/获取共享内存shmget
    3. 连接共享内存shmat
    4. 读写数据（和普通内存一样读写）
    5. 断开连接shmdt
    6. 删除共享内存shmctl

*/

int main()
{
    key_t key;
    int shmid;
    char *shm = nullptr;
    struct shmid_ds buf1; /*用于删除共享内存*/

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

    // // 创建共享内存
    // if ((shmid = shmget(key, 1024, IPC_CREAT | 0666)) == -1) // 0666 八进制
    // {
    //     perror("create shared memory error");
    //     exit(1);
    // }

    // 获取共享内存
    if ((shmid = shmget(key, 1024, 0)) == -1)
    {
        perror("shmget error");
        exit(1);
    }

    // 连接共享内存
    shm = (char *)shmat(shmid, 0, 0);
    if (nullptr == shm)
    {
        perror("attach shared memory error");
        exit(1);
    }

    // 读数据
    printf("%s\n", shm);

    // 断开连接
    shmdt(shm);

    // 删除共享内存
    shmctl(shmid, IPC_RMID, &buf1);

    return 0;
}

//shm_client.cpp
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <string.h>

int main()
{
    key_t key;
    int shmid;
    char *shm = nullptr;

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

    // 创建共享内存
    if ((shmid = shmget(key, 1024, IPC_CREAT | 0666)) == -1) // 0666 八进制
    {
        perror("create shared memory error");
        exit(1);
    }

    // // 获取共享内存
    // if ((shmid = shmget(key, 1024, 0)) == -1)
    // {
    //     perror("shmget error");
    //     exit(1);
    // }

    // 连接共享内存
    shm = (char *)shmat(shmid, 0, 0);
    if (nullptr == shm)
    {
        perror("attach shared memory error");
        exit(1);
    }

    // 写数据
    // scanf("%s", shm);
    memcpy(shm, "hello world", 12);

    // 断开连接
    shmdt(shm);

    return 0;
}

4、共享内存+信号量+消息队列实现通信

下面这个例子，使用了 【共享内存+信号量+消息队列】 的组合来实现服务器进程与客户进程间的通信。

共享内存用来传递数据；
信号量用来同步；
消息队列用来在客户端修改了共享内存后通知服务器读取。

//shm_sem_msg_common.h
/*
1. 使用共享内存进行进程间通信
2. 使用信号量做共享内存数据读写控制
3. 使用消息队列用于通知对方有新数据
*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <string.h>

#define SERVER_MSG_TYPE 888

// 消息队列结构
struct msg_form
{
    long mtype;
    char mtext;
};

// 联合体，共用体，在一个union中可以定义多种不同的数据类型，长度为最长的成员数据类型长度
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;

    // Semaphore控制
    // 初始化id为sem_id，序号为0的信号量，值为tmp.val
    if (semctl(sem_id, 0, SETVAL, tmp) == -1)
    {
        perror("Init Semaphore Error");
        return -1;
    }

    return 0;
}

// P操作（通过）
// 将信号量值减1
// 若信号量值 < 0，进程挂起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0;        // 序号，取值0 - _nsems-1(根据semget函数的_nsems参数)
    sbuf.sem_op = -1;        // 信号量值在一次操作中的改变量，<0 P操作，判断信号量>=0则表示资源可用，进程继续执行，否则进程置为等待状态
    sbuf.sem_flg = SEM_UNDO; // 退出时撤销操作，IPC_NOWAIT/SEM_UNDO

    // Semaphore操作
    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操作，释放信号量资源，并将信号量值+1
    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;
}

//shm_sem_msg_client.cpp
#include "shm_sem_msg_common.h"

int main()
{
    key_t key;
    int shmid, semid, msqid;
    char *shm = nullptr;
    struct msg_form msg;

    int flag = 1;

    // 获取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 (nullptr == shm)
    {
        perror("shmat 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); //P操作
            scanf("%s", shm);
            sem_v(semid); //V操作

            printf("1 start send\n");

            // 清空标准输入缓冲区
            while ((c = getchar()) != '\n' && c != EOF)
                ;

            printf("start send\n");
            msg.mtype = SERVER_MSG_TYPE;
            msg.mtext = 'r'; //read 发送数据到服务端，告知服务端有数据可读
            msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
            break;
        case 'q':
            msg.mtype = SERVER_MSG_TYPE;
            msg.mtext = 'q';
            msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
            flag = 0;
            break;
        default:
            printf("wrong input!\n");
            // 清空标准输入缓冲区
            while ((c = getchar()) != '\n' && c != EOF)
                ;
            break;
        }
    }

    // 断开共享内存连接
    shmdt(shm);
    return 0;
}

//shm_sem_msg_server.cpp
#include "shm_sem_msg_common.h"

int main()
{
    key_t key;
    int shmid, semid, msqid;

    char *shm = nullptr;
    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)) < 0)
    {
        perror("shmget error");
        exit(1);
    }

    // 连接共享内存
    shm = (char *)shmat(shmid, 0, 0);
    if (nullptr == shm)
    {
        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 (true)
    {
        // 读取消息队列中的数据（阻塞）
        msgrcv(msqid, &msg, 1, SERVER_MSG_TYPE, 0);

        if (msg.mtext == 'q') //quit 退出
            break;
        if (msg.mtext == 'r') //read 读取共享内存
        {
            sem_p(semid); // P操作
            printf("%s\n", shm);
            sem_v(semid); // V操作
        }
    }

    // 断开共享内存连接
    shmdt(shm);

    // 删除共享内存、消息队列、信号量
    shmctl(shmid, IPC_RMID, &buf1);
    msgctl(msqid, IPC_RMID, &buf2);
    del_sem(semid);

    return 0;
}

注意：当scanf()输入字符或字符串时，缓冲区中遗留下了\n，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持fflush(stdin)（它只是标准C的扩展），所以我们使用了替代方案：

while((c=getchar())!='\n' && c!=EOF);

注释已经很详细了，所以代码的其他部分我就不解释了，下面是运行结果截图：
（转载）进程间通信

(发现空格都没发过去…)

六、本地socket

Unix domain socket 又叫 IPC(inter-process communication 进程间通信) socket，用于实现同一主机上的进程间通信。socket 原本是为网络通讯设计的，但后来在 socket 的框架上发展出一种 IPC 机制，就是 UNIX domain socket。

1、特点

虽然网络 socket 也可用于同一台主机的进程间通讯(通过 loopback 地址 127.0.0.1)，但是 UNIX domain socket 用于 IPC 更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC 机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。
UNIX domain socket 是全双工的，API 接口语义丰富，相比其它 IPC 机制有明显的优越性，目前已成为使用最广泛的 IPC 机制，比如 X Window 服务器和 GUI 程序之间就是通过 UNIX domain socket 通讯的。
Unix domain socket 是 POSIX 标准中的一个组件。

2、原型

// family 指定为 AF_UNIX或AF_LOCAL，使用 AF_UNIX 会在系统上创建一个 socket 文件，不同进程通过读写这个文件来实现通信。
// type 可以选择 SOCK_DGRAM(udp) 或 SOCK_STREAM(tcp)。SOCK_STREAM 意味着会提供按顺序的、可靠、双向、面向连接的比特流。SOCK_DGRAM 意味着会提供定长的、不可靠、无连接的通信。
// protocol 参数指定为 0 即可。
int socket(int family, int type, int protocol);

/* Structure describing the address of an AF_LOCAL (aka AF_UNIX) socket.  
本地socket的地址结构体，这个 socket 文件由 bind() 调用创建，如果调用 bind() 时该文件已存在，则 bind() 错误返回。因此，一般在调用 bind() 前会检查 socket 文件是否存在，如果存在就删除掉。
*/
struct sockaddr_un
{
    __SOCKADDR_COMMON (sun_);
    char sun_path[108];		/* Path name.  */
};

/*
网络 socket 编程类似，在 bind 之后要 listen，表示通过 bind 的地址（也就是 socket 文件）提供服务。
接下来必须用 accept() 函数初始化连接。accept() 为每个连接创立新的套接字并从监听队列中移除这个连接。
*/

/* Give the socket FD the local address ADDR (which is LEN bytes long).  */
int bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);

/* Prepare to accept connections on socket FD.
   N connection requests will be queued before further requests are refused.
   Returns 0 on success, -1 for errors.  */
int listen (int __fd, int __n);

3、例子

下面通过一个简单的 demo 来理解相关概念。程序分为服务器端和客户端两部分，它们之间通过 unix domain socket 进行通信。

//sock_server.cpp
/*
本地socket实现IPC
    1. 虽然网络socket也可用于同一台主机的进程间通讯(通过 loopback 地址 127.0.0.1)，但是 UNIX domain socket 用于 IPC 更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC 机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。
    2. UNIX domain socket 是全双工的，API 接口语义丰富，相比其它 IPC 机制有明显的优越性，目前已成为使用最广泛的 IPC 机制，比如 X Window 服务器和 GUI 程序之间就是通过 UNIX domain socket 通讯的。
    3. Unix domain socket 是 POSIX 标准中的一个组件。

流程：
    1. 创建本地socket（参数 AF_UNIX）
    2. 检查socket地址文件是否存在，存在则删除，unlink删除一个文件的目录项并减少它的链接数
    3. 绑定socket，并根据socket地址创建本地文件
    4. 监听listen
    5. 接收客户端的连接accept
    6. 读/写数据read/write
    7. 关闭socket close
*/

#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>

#define MAXLINE 80

char *socket_path = "server.socket";

int main(void)
{
    struct sockaddr_un serun, cliun;
    socklen_t cliun_len;
    int listenfd, connfd, size;
    char buf[MAXLINE];
    int i, n;

    if ((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error");
        exit(1);
    }

    printf("%s\n", socket_path);

    memset(&serun, 0, sizeof(serun));
    serun.sun_family = AF_UNIX;
    strcpy(serun.sun_path, socket_path);
    size = offsetof(struct sockaddr_un, sun_path) + strlen(serun.sun_path);
    unlink(socket_path);

    // bind时将会创建socket文件，有可能会因为权限文件导致bind失败
    if (bind(listenfd, (struct sockaddr *)&serun, size) < 0)
    {
        perror("bind error");
        exit(1);
    }
    printf("UNIX domain socket bound\n");

    if (listen(listenfd, 20) < 0)
    {
        perror("listen error");
        exit(1);
    }
    printf("Accepting connections ...\n");

    while (1)
    {
        cliun_len = sizeof(cliun);
        if ((connfd = accept(listenfd, (struct sockaddr *)&cliun, &cliun_len)) < 0)
        {
            perror("accept error");
            continue;
        }

        while (1)
        {
            n = read(connfd, buf, sizeof(buf));
            if (n < 0)
            {
                perror("read error");
                break;
            }
            else if (n == 0)
            {
                printf("EOF\n");
                break;
            }

            printf("received: %s", buf);

            for (i = 0; i < n; i++)
            {
                buf[i] = toupper(buf[i]);
            }
            write(connfd, buf, n);
        }
        close(connfd);
    }
    close(listenfd);
    return 0;
}

//sock_client.cpp
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

#define MAXLINE 80

char *client_path = "client.socket";
char *server_path = "server.socket";

int main()
{
    struct sockaddr_un cliun, serun;
    int len;
    char buf[100];
    int sockfd, n;

    if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    {
        perror("client socket error");
        exit(1);
    }

    memset(&cliun, 0, sizeof(cliun));
    cliun.sun_family = AF_UNIX;
    strcpy(cliun.sun_path, client_path);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(cliun.sun_path);
    unlink(cliun.sun_path);
    
    // 一般显式调用bind函数，以便服务器区分不同客户端
    if (bind(sockfd, (struct sockaddr *)&cliun, len) < 0)
    {
        perror("bind error");
        exit(1);
    }

    memset(&serun, 0, sizeof(serun));
    serun.sun_family = AF_UNIX;
    strcpy(serun.sun_path, server_path);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(serun.sun_path);
    if (connect(sockfd, (struct sockaddr *)&serun, len) < 0)
    {
        perror("connect error");
        exit(1);
    }

    while (fgets(buf, MAXLINE, stdin) != NULL)
    {
        write(sockfd, buf, strlen(buf));
        n = read(sockfd, buf, MAXLINE);
        if (n < 0)
        {
            printf("the other side has been closed.\n");
        }
        else
        {
            write(STDOUT_FILENO, buf, n);
        }
    }
    close(sockfd);
    return 0;
}

七、总结

方式	是否进程无关	特点
pipe	否	速度慢，容量有限，只能在关联进程（父子、兄弟）之间通信
FIFO	是	速度慢
消息队列	是	容量受系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题
信号量	是	不能传递复杂消息，只能用来同步
共享内存	是	能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存

博客全部代码：https://github.com/BuildSoftwareBetter/IPC

参考：Unix domain socket 简介

（转载）进程间通信

文章目录

一. 管道

1、特点

2、原型

3、例子

二、FIFO

1、特点

2、原型

3、例子

三、消息队列

1、 特点

2、原型

3、例子

4、一对多的双向消息队列

四、信号量

1、特点

2、原型

3、例子

五、共享内存

1、特点

2、原型

3、例子

4、共享内存+信号量+消息队列 实现通信

六、本地socket

1、特点

2、原型

3、例子

七、总结

相关推荐

1、特点

4、共享内存+信号量+消息队列实现通信