深刻理解Linux进程间通信(IPC)(六)

序

  本节内容来自这儿。
  linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间通信方面的侧重点有所不同。前者对Unix早期的进程间通信手段进行了系统的改进和扩充，形成了“system V IPC”，通信进程局限在单个计算机内；后者则跳过了该限制，形成了基于套接口（socket）的进程间通信机制。Linux则把两者继承了下来，如图示：

  其中，最初Unix IPC包括：管道、FIFO、信号；System V IPC包括：System V消息队列、System V信号灯、System V共享内存区；Posix IPC包括： Posix消息队列、Posix信号灯、Posix共享内存区。有两点需要简单说明一下：1）由于Unix版本的多样性，电子电气工程协会（IEEE）开发了一个独立的Unix标准，这个新的ANSI Unix标准被称为计算机环境的可移植性操作系统界面（POSIX）。现有大部分Unix和流行版本都是遵循POSIX标准的，而Linux从一开始就遵循POSIX标准；2）BSD并不是没有涉足单机内的进程间通信（socket本身就可以用于单机内的进程间通信）。事实上，很多Unix版本的单机IPC留有BSD的痕迹，如4.4BSD支持的匿名内存映射、4.3+BSD对可靠信号语义的实现等等。
  图一给出了linux 所支持的各种IPC手段，在本文接下来的讨论中，为了避免概念上的混淆，在尽可能少提及Unix的各个版本的情况下，所有问题的讨论最终都会归结到Linux环境下的进程间通信上来。并且，对于Linux所支持通信手段的不同实现版本（如对于共享内存来说，有Posix共享内存区以及System V共享内存区两个实现版本），将主要介绍Posix API。
  linux下进程间通信的几种主要手段简介：

1. 管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
2. 信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；
3. 报文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
4. 共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
5. 信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
6. 套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

  下面将对上述通信机制做具体阐述。
  附1：参考文献[2]中对linux环境下的进程进行了概括说明：
  一般来说，linux下的进程包含以下几个关键要素：

• 有一段可执行程序；
• 有专用的系统堆栈空间；
• 内核中有它的控制块（进程控制块），描述进程所占用的资源，这样，进程才能接受内核的调度；
• 具有独立的存储空间。

  进程和线程有时候并不完全区分，而往往根据上下文理解其含义。

---

  相关主题

• UNIX环境高级编程，作者：W.Richard Stevens，译者：尤晋元等，机械工业出版社。具有丰富的编程实例，以及关键函数伴随Unix的发展历程。
• linux内核源代码情景分析（上、下），毛德操、胡希明著，浙江大学出版社，提供了对linux内核非常好的分析，同时，对一些关键概念的背景进行了详细的说明。
• UNIX网络编程第二卷：进程间通信，作者：W.Richard Stevens，译者：杨继张，清华大学出版社。一本比较全面阐述Unix环境下进程间通信的书（没有信号和套接口，套接口在第一卷中）。

---

一 管道( pipe )

  管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。无名管道由pipe（）函数创建：

#include <unistd.h>
int pipe(int filedis[2])；
//参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。

  下面的例子示范了如何在父进程和子进程间实现通信。

#define INPUT 0 
#define OUTPUT 1 
 
void main()
 { 
　　int file_descriptors[2]; 
　　/*定义子进程号 */ 
　　pid_t pid; 
　　char buf[256]; 
　　int returned_count; 
　　/*创建无名管道*/ 
　　pipe(file_descriptors); 
　　/*创建子进程*/ 
　　if((pid = fork()) == -1) 
　　{ 
　　　　printf("Error in fork/n"); 
　　　　exit(1); 
　　} 
　　/*执行子进程*/ 
　　if(pid == 0)
　　{ 
　　　　printf("in the spawned (child) process.../n"); 
　　　　/*子进程向父进程写数据，关闭管道的读端*/ 
　　　　close(file_descriptors[INPUT]); 
　　　　write(file_descriptors[OUTPUT], "test data", strlen("test data")); 
　　　　exit(0); 
　　} 
　　else
　　{ 
　　　　/*执行父进程*/ 
　　　　printf("in the spawning (parent) process.../n"); 
　　　　/*父进程从管道读取子进程写的数据，关闭管道的写端*/ 
　　　　close(file_descriptors[OUTPUT]); 
　　　　returned_count = read(file_descriptors[INPUT], buf, sizeof(buf)); 
　　　　printf("%d bytes of data received from spawned process: %s/n", returned_count, buf); 
　　} 
}

二 有名管道 (namedpipe)

  有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
  在Linux系统下，有名管道可由两种方式创建：命令行方式mknod和系统调用函数mkfifo。当前目录下生成了一个名为myfifo的有名管道：
  方式一：mkfifo(“myfifo”,“rw”);
  方式二：mknod myfifo p
  生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。
  读有名管道：

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

void main() 
{ 
　　FILE * in_file; 
　　int count = 1; 
　　char buf[80]; 
　　in_file = fopen("mypipe", "r"); 
　　if (in_file == NULL)
　　 { 
　　　　printf("Error in fdopen./n"); 
　　　　exit(1); 
　　} 
　　while ((count = fread(buf, 1, 80, in_file)) > 0) 
　　printf("received from pipe: %s/n", buf); 
　　fclose(in_file); 
}

  写有名管道

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

void main()
 { 
    FILE * out_file; 
    int count = 1; 
    char buf[80]; 
    out_file = fopen("mypipe", "w"); 
    if (out_file == NULL) 
    { 
        printf("Error opening pipe."); 
        exit(1); 
    } 
    sprintf(buf,"this is test data for the named pipe example/n"); 
    fwrite(buf, 1, 80, out_file); 
    fclose(out_file); 
} 

三 共享内存(shared memory )

  共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利 用共享内存进行存储的。

• shmget 创建/访问 共享内存对象
• shmat 把共享内存区对象映射到调用进程的地址空间
• shmdt 断开共享内存连接
• shmctl 对共享内存提供控制

  首先要用的函数是shmget()，它获得一个共享存储标识符。

#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/shm.h> 
int shmget(key_t key, int size, int flag); 

  这个函数有点类似malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的 key。数据类型key_t是在头文件<sys/types.h>中定义的，它是一个长整形的数据。
  当共享内存创建后，其余进程可以调用shmat()将其连接到自身的地址空间中。
  void *shmat(int shmid, void *addr, int flag);
   shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。
  使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <sys/ipc.h>
#include <sys/shm.h>

#define IPC_KEY 2048
#define MAXLINE 80
#define MAXSIZE MAXLINE*100

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    int shm_id, ret;
    char *shm_ptr;
    struct shmid_ds shm_stat;

    char buf[MAXLINE];
    char output[MAXSIZE], content[MAXSIZE];

    memset(content, 0, sizeof(content));

    shm_id = shmget(IPC_KEY, MAXSIZE, IPC_CREAT);
    if_error(shm_id, "shmget");

    shm_ptr = shmat(shm_id, NULL, 0);
    if_error(*(int*)shm_ptr, "shmat");

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        printf("input msg:\n");
        while (1) {
            /* input msg */
            fgets(buf, MAXLINE, stdin);
            buf[strlen(buf)-1] = '\0';
            /* finish input msg */
            if (strncmp(buf, "exit", 4) == 0) break;
            strcat(content, buf);
        }
        /* cp content to shm_ptr */
        memcpy(shm_ptr, content, MAXSIZE);
    } else {
    /* parent process */
        chi_pid = wait(NULL);
        if_error(chi_pid, "wait");

        /* get content from shm_ptr */
        memcpy(output, shm_ptr, MAXSIZE);
        printf("%s\n", output);
        /* get shm info */
        shmctl(shm_id, IPC_STAT, &shm_stat);
        printf("PID: %d, shared memory size is %ld\n", getpid(), shm_stat.shm_segsz);
        /* disconnect */
        ret = shmdt(shm_ptr);
        if_error(ret, "shmdt");
    }
    return 0;
}

四 信号 (sinal )

  Linux信号机制分析(七)：https://blog.csdn.net/essity/article/details/99656599
  线程间信号处理(八)：https://blog.csdn.net/essity/article/details/81735412

五 信号量(semophore )

  信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：
  （1） 测试控制该资源的信号量。
  （2）若此信号量的值为正，则允许进行使用该资源。进程将信号量减1。
  （3）若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）。
  （4）当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。
  维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include　/linux　/sem.h 中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合，用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget，用以获 得一个信号量ID。

struct sem
{
    short sempid;/* pid of last operaton */
    ushort semval;/* current value */
    ushort semncnt;/* num procs awaiting increase in semval */
    ushort semzcnt;/* num procs awaiting semval = 0 */
}
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/sem.h> 
int semget(key_t key, int nsems, int flag); 

  key是前面讲过的IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新 集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。
  semctl函数用来对信号量进行操作。
  int semctl(int semid, int semnum, int cmd, union semun arg);
  不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。
semop函数自动执行信号量集合上的操作数组。
  int semop(int semid, struct sembuf semoparray[], size_t nops);
  semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。
  具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/sem.h> 
#include <sys/ipc.h>

void main()
{ 
    key_t unique_key; /* 定义一个IPC关键字*/ 
    int id; 
    struct sembuf lock_it; 
    union semun options; 
    int i; 

    unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/ 
    /* 创建一个新的信号量集合*/ 
    id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666); 
    printf("semaphore id=%d/n", id); 
    options.val = 1; /*设置变量值*/ 
    semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/ 
 
    /*打印出信号量的值*/ 
    i = semctl(id, 0, GETVAL, 0);  
    printf("value of semaphore at index 0 is %d/n", i); 
 
    /*下面重新设置信号量*/ 
    lock_it.sem_num = 0; /*设置哪个信号量*/ 
    lock_it.sem_op = -1; /*定义操作*/ 
    lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/ 
    if (semop(id, &lock_it, 1) == -1)
     {   
        printf("can not lock semaphore./n"); 
        exit(1); 
    } 
 
    i = semctl(id, 0, GETVAL, 0); 
    printf("value of semaphore at index 0 is %d/n", i); 
 
    /*清除信号量*/ 
    semctl(id, 0, IPC_RMID, 0); 
}

  intsemget(key_t key,int nsems,int semflg);创建一个新的信号量集，或者存取一个已经存在的信号量集。返回值：如果成功，则返回信号量集的IPC标识符。如果失败，则返回-1。

errno=EACCESS(没有权限)
EEXIST(信号量集已经存在，无法创建)
EIDRM(信号量集已经删除)
ENOENT(信号量集不存在，同时没有使用IPC_CREAT)
ENOMEM(没有足够的内存创建新的信号量集)
ENOSPC(超出限制)

  系统调用semget()的第一个参数是关键字值（一般是由系统调用ftok()返回的）。系统内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在，则创建信号量集。IPC_EXCL当和 IPC_CREAT一同使用时，如果信号量集已经存在，则调用失败。如果单独使用IPC_CREAT，则semget()要么返回新创建的信号量集的标识符，要么返回系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用，则要么返回新创建的信号量集的标识符，要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集中应该创建的信号量的个数。信号量集中最多的信号量的个数是在linux/sem.h中定义的：
#define SEMMSL 32/*<=512maxnumofsemaphoresperid*/
下面是一个打开和创建信号量集的程序：

intopen_semaphore_set(key_t keyval,int numsems)
{
    intsid;
    if(!numsems)
    return(-1);
    if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)
    {
        return(-1);
    }
    return(sid);
}

  int semop(int semid,struct sembuf*sops,unsign ednsops);第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组中的操作的个数。参数sops指向由sembuf组成的数组。返回值：0，如果成功。-1，如果失败：errno=E2BIG(nsops大于最大的ops数目)
  此数组是在linux/sem.h中定义的：

/*semop systemcall takes an array of these*/
struct sembuf{
    ushortsem_num;/*semaphore index in array*/
    shortsem_op;/*semaphore operation*/
    shortsem_flg;/*operation flags*/
    sem_num将要处理的信号量的个数。
    sem_op要执行的操作。
    sem_flg操作标志。

EACCESS(权限不够)
EAGAIN(使用了IPC_NOWAIT，但操作不能继续进行)
EFAULT(sops指向的地址无效)
EIDRM(信号量集已经删除)
EINTR(当睡眠时接收到其他信号)
EINVAL(信号量集不存在,或者semid无效)
ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)
ERANGE(信号量值超出范围)

  如果sem_op是负数，那么信号量将减去它的值。这和信号量控制的资源有关。如果没有使用IPC_NOWAIT，那么调用进程将进入睡眠状态，直到信号量控制的资源可以使用为止。如果sem_op是正数，则信号量加上它的值。这也就是进程释放信号量控制的资源。最后，如果sem_op是0，那么调用进程将调用sleep()，直到信号量的值为0。这在一个进程等待完全空闲的资源时使用。
  int semctl(int semid,int semnum,int cmd,union semunarg);返回值：如果成功，则为一个正数。如果失败，则为-1：errno=EACCESS(权限不够)

EFAULT(arg指向的地址无效)
EIDRM(信号量集已经删除)
EINVAL(信号量集不存在，或者semid无效)
EPERM(EUID没有cmd的权利)
ERANGE(信号量值超出范围)

  系统调用semctl用来执行在信号量集上的控制操作。这和在消息队列中的系统调用msgctl是十分相似的。但这两个系统调用的参数略有不同。因为信号量一般是作为一个信号量集使用的，而不是一个单独的信号量。所以在信号量集的操作中，不但要知道IPC关键字值，也要知道信号量集中的具体的信号量。这两个系统调用都使用了参数cmd，它用来指出要操作的具体命令。两个系统调用中的最后一个参数也不一样。在系统调用msgctl中，最后一个参数是指向内核中使用的数据结构的指针。我们使用此数据结构来取得有关消息队列的一些信息，以及设置或者改变队列的存取权限和使用者。但在信号量中支持额外的可选的命令，这样就要求有一个更为复杂的数据结构。
系统调用semctl()的第一个参数是关键字值。第二个参数是信号量数目。
  参数cmd中可以使用的命令如下：

IPC_STAT读取一个信号量集的数据结构semid_ds，并将其存储在semun中的buf参数中。
IPC_SET设置信号量集的数据结构semid_ds中的元素ipc_perm，其值取自semun中的buf参数。
IPC_RMID将信号量集从内存中删除。
GETALL用于读取信号量集中的所有信号量的值。
GETNCNT返回正在等待资源的进程数目。
GETPID返回最后一个执行semop操作的进程的PID。
GETVAL返回信号量集中的一个单个的信号量的值。
GETZCNT返回这在等待完全空闲的资源的进程数目。
SETALL设置信号量集中的所有的信号量的值。
SETVAL设置信号量集中的一个单独的信号量的值。

  参数arg代表一个semun的实例。semun是在linux/sem.h中定义的：

/*arg for semctl systemcalls.*/
unionsemun{
intval;/*value for SETVAL*/
structsemid_ds*buf;/*buffer for IPC_STAT&IPC_SET*/
ushort*array;/*array for GETALL&SETALL*/
structseminfo*__buf;/*buffer for IPC_INFO*/
void*__pad;

  val当执行SETVAL命令时使用。buf在IPC_STAT/IPC_SET命令中使用。代表了内核中使用的信号量的数据结构。array在使用GETALL/SETALL命令时使用的指针。
  下面的程序返回信号量的值。当使用GETVAL命令时，调用中的最后一个参数被忽略：

intget_sem_val(intsid,intsemnum)
{
    return(semctl(sid,semnum,GETVAL,0));
}

  下面是一个实际应用的例子：

#defineMAX_PRINTERS5
printer_usage()
{
    int x;
    for(x=0;x<MAX_PRINTERS;x++)
        printf("Printer%d:%d/n/r",x,get_sem_val(sid,x));
}

  下面的程序可以用来初始化一个新的信号量值：

void init_semaphore(int sid,int semnum,int initval)
{
    union semunsemopts;
    semopts.val=initval;
    semctl(sid,semnum,SETVAL,semopts);
}

  注意系统调用semctl中的最后一个参数是一个联合类型的副本，而不是一个指向联合类型的指针。

六 消息队列( messagequeue )

  消息队列是由消息的链表，链表中节点的结构用msg声明，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点消息。事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它。

七 套接字(socket )

  套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同主机间的进程通信。

八 相关命令

  ipcs -u：显示ipc的状态。
  ipcs -l：显示内核对ipc的限制信息。

九 参考链接

  【Linux】进程间通信（IPC）之信号量详解与测试用例：https://blog.csdn.net/a1414345/article/details/64513946
  Linux 系统应用编程——进程间通信（下）：https://cn.aliyun.com/jiaocheng/152585.html?spm=5176.100033.1.26.eba94a31F95uvj
  posix和system v 信号量哪个更快？：https://www.zhihu.com/question/35169528
  消息队列接口API(posix 接口和 system v接口)：https://www.bbsmax.com/A/kmzLoRkKdG/
  Linux进程通信 之 信号灯(semphore)(System V && POSIX)：https://www.bbsmax.com/A/VGzlMeGyJb/
  system v和posix的共享内存对比 & 共享内存位置：https://www.bbsmax.com/A/xl56ZZq15r/
  System V 与 POSIX：https://blog.csdn.net/firstlai/article/details/50705042