进程之间交互信息可以通过函数fork、exec或者是文件系统来传送打开的文件，而进程间的相互通信则是由IPC(InterProcess Communication)技术实现。

通信方式

  • 管道：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用，进程的亲缘关系通常是指父子进程关系。
  • 命名管道FIFO：FIFO也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
  • 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
  • 信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
  • 共享存储SharedMemory：共享存储就是映射一段能被其他进程所访问的内存，这段共享存储由一个进程创建，但多个进程都可以访问。共享存储是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。
  • 套接字Socket：套接字也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同网络环境间的进程通信。

管道

概述

管道是UNIX系统IPC的最古老的通信方式，所有UNIX系统都提供该通信方式，它是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道可以被循环利用。
当管道中没有信息的话，从管道中读取的进程会等待，直到另一端的进程放入信息。当管道被放满信息的时候，尝试放入信息的进程会等待，直到另一端的进程取出信息。当两个进程都终结的时候，管道也自动消失。
管道可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

相应函数1

管道是通过调用pipe函数创建的。

  1. #include <unistd.h>
  2. int pipe(int fd[2]);

其中参数fd是一个数组，一条管道有两个文件描述符，在调用pipe函数成功后，会填充fd数组：

  • fd[0]：通过该文件描述符可以从管道中读取数据。
  • fd[1]：通过该文件描述符可以向管道写入数据。

管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道，如下图所示：
image.png
一般情况下，我们并不需要多余的连接，父进程关闭读端，而子进程关闭写端，这样就行成了一个从父进程到子进程的管道，如下图所示：
image.png

例子1

  1. #include <sys/wait.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  7. int main() 
  8. {
  9.     int n;
  10.     int fd[2];
  11.     pid_t pid;
  12.     char pipe_buf;
  13.     memset(fd, 0, sizeof(fd));
  14.     if(pipe(fd) == -1)
  15.     {
  16.         return -1;
  17.         }
  18.     if((pid = fork()) < 0)
  19.     {
  20.         return -1;
  21.     } 
  22.     // 父进程关读端，写hello
  23.     else if (pid > 0)
  24.     {
  25.         close(fd[0]);
  26.         write(fd[1], "hello", 5);
  27.     }
  28.     // 子进程关写端，读hello并打印
  29.     else
  30.     {
  31.         close(fd[1]);
  32.         n = read(fd[0],&pipe_buf, 5);
  33.         write(STDOUT_FILENO, &pipe_buf, n);
  34.     }
  35.     exit(0);
  37. }

相应函数2

标准I/O库为此又提供了2个函数，popen与pclose，来简化创建一个连接到另一个进程的管道：

  1. #include<stdio.h>
  3. // 返回值，成功则返回文件指针，失败返回NULL
  4. FILE *popen(const char *cmdstring, const char *type);
  5. // 返回值， 成功返回cmdstring的终止状态，失败返回-1
  6. int pclose(FILE *fp);
  • popen：通过创建一个管道，调用fork()产生一个子进程，然后调用exec执行cmdstring。type有“r”跟“w”两种值，“r”则文件指针连接到cmdstring的标准输出，“w”则则文件指针连接到cmdstring的标准输入。
  • pclose：关闭标准I/O流，等待命令的终止。

例子2

  1. #include <sys/types.h>  
  2. #include <unistd.h>  
  3. #include <stdlib.h>  
  4. #include <stdio.h>  
  5. #include <string.h>
  7. int main()  
  8. {  
  9.     FILE   *fpin;  
  10.     FILE   *fpout;
  11.     char   buf[1024]; 
  12.     // 初始化buf,以免后面写如乱码到文件中
  13.     memset( buf, '\0', sizeof(buf) );
  14.     // 将“ls －l”命令的输出 通过管道读取（“r”参数）到FILE* stream
  15.     fpin = popen( "ls -l", "r" ); 
  16.     // 新建一个可写的文件
  17.     fpout = fopen( "test_popen.txt", "w+"); 
  18.     // 将刚刚FILE* fpin的数据流读取到buf中
  19.     fread( buf, sizeof(char), sizeof(buf),  fpin);
  20.     // 将buf中的数据写到FILE* fpout对应的流中，也是写到文件中  
  21.     fwrite( buf, 1, sizeof(buf), fpout);
  23.     pclose( fpin );  
  24.     fclose( fpout );
  26.     return 0;
  27. }

FIFO

概述

和管道的主要区别在于，FIFO在磁盘上有文件 .p文件，但磁盘上的文件大小始终为零，它在内核缓冲区内有一个对应的缓冲区，数据是存储在缓冲区中而不是磁盘中，所以其实FIFO也是一个伪文件，但在磁盘上有文件名，所以能够实现没有血缘关系的进程间通信。

相应函数

创建FIFO类似于创建文件：

  1. #include<sys/stat.h>
  2. // 返回值：成功0，出错-1
  3. int mkfifo(const char *path, mode_t mode);
  4. int mkfifoat(int fd, const char *path, mode_t mode);

FIFO有2个用途：

  • shell命令使用FIFO将数据从一条管道传送到另一条管道时，无需创建中间临时文件。
  • 客户进程-服务器进程关系中，FIFO用作汇聚点，在客户进程和服务器进程之间传递数据。

例子

创建一个读(fifo_read.c)与写(fifo_write.c)的进程，然后通过FIFO进行通信，写进程不断打印hello world,读进程不断输出hello world。

  1. gcc -o fifo_read fifo_read.c
  2. gcc -o fifo_write fifo_wirte.c
  3. ./fifo_read fifo1
  4. # 切换到另一个shell窗口
  5. ./fifo_write fifo1

演示结果如下：
image.png

fifo_write.c

  1. #include<stdio.h>
  2. #include<unistd.h>
  3. #include<stdlib.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<string.h>
  7. #include<fcntl.h>
  9. int main(int argc,const char* argv[])
  10. {
  11.   if(argc<2)
  12.    {
  13.      printf("./a.out fifioname\n");
  14.      exit(1);
  15.    }
  16.    //判断文件是否存在
  17.    int ret =access(argv[1],F_OK);
  18.    if(ret==-1)
  19.    {
  20.      int r=mkfifo(argv[1],0664);
  21.      if(r==-1)
  22.       {
  23.         perror("mkfifo error");
  24.         exit(1);
  25.       }
  26.       printf("创建有名管道%s成功\n",argv[1]);
  27.    }
  28.    int fd=open(argv[1],O_WRONLY);        
  29.    if(fd==-1)
  30.    {
  31.      perror("open error");
  32.      exit(1); 
  33.    }
  34.    char *p="hello,world";
  35.    while(1) 
  36.    {
  37.      sleep(1);
  38.      int len=write(fd,p,strlen(p)+1);
  39.    }
  40.    close(fd);
  41.    return 0;
  42. }

fifo_read.c

  1. #include<stdio.h>
  2. #include<unistd.h>
  3. #include<stdlib.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<string.h>
  7. #include<fcntl.h>
  9. int main(int argc,const char* argv[])
  10. {
  11.   if(argc<2)
  12.    {
  13.      printf("./a.out fifioname\n");
  14.      exit(1);
  15.    }
  16.    //判断文件是否存在
  17.    int ret =access(argv[1],F_OK);
  18.    if(ret==-1)
  19.    {
  20.      int r=mkfifo(argv[1],0664);
  21.      if(r==-1)
  22.       {
  23.         perror("mkfifo error");
  24.         exit(1);
  25.       }
  26.       printf("创建有名管道%s成功\n",argv[1]);
  27.    }
  28.    int fd=open(argv[1],O_RDONLY);        
  29.    if(fd==-1)
  30.    {
  31.      perror("open error");
  32.      exit(1); 
  33.    }
  34.   char buf[512];
  35.    while(1) 
  36.    {
  37.      int len=read(fd,buf,sizeof(buf));
  38.      buf[len]=0;
  39.      printf("buf=%s,len=%d\n",buf,len);
  40.    }
  41.    close(fd);
  42.    return 0;
  43. }

消息队列

概述

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

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

相关函数

ftok

ftok() 函数用于获得一个IPC 关键字

  1. #include <sys/types.h>
  2. #include <sys/ipc.h>
  4. key_t ftok(const char *pathname, int proj_id);

ftok函数返回一个以pathname 指向的文件相对应的文件和proj_id 来确定一个IPC 关键字key_t。pathname必须是一个已经存在并具有访问权限的文件，proj_id 只有最低的8个字节是有效的，所以通常用一个ASCII 字符来作为proj_id。

当pathname 和proj_id 完全相同时，每次调用ftok() 都会获取一个相同的关键字。

IPC 关键字可以通过ftok() 函数来获得，也可以设为IPC_PRIVATE，这时操作系统确保创建一个新的IPC，其标识符需要由进程自己记录并告诉其他进程。
[

](https://blog.csdn.net/shift_wwx/article/details/89387905)

创建消息队列

系统调用msgget() 来创建一个新的消息队列，或者存取一个已经存在的消息队列，原型：

  1. #include <sys/msg.h>
  3. int msgget(key_t key, int msgflag);
  • key：某个消息队列的名字，用ftok()产生
  • msgflag：有两个选项IPC_CREAT和IPC_EXCL，单独使用IPC_CREAT，如果消息队列不存在则创建之，如果存在则打开返回；单独使用IPC_EXCL是没有意义的；两个同时使用，如果消息队列不存在则创建之，如果存在则出错返回。
  • 返回值：成功返回一个非负整数，即消息队列的标识码，失败返回-1。可以通过errno和perror函数来查看错误信息。

控制消息队列

消息队列标识符的属性被记录在一个msgid_ds的结构体：

  1. struct msqid_ds {
  2.     struct ipc_perm msg_perm;        /* structure describing operation permission */
  3.     time_t          msg_stime;       /* time of last msgsnd command */
  4.     time_t          msg_rtime;       /* time of last msgrcv command */
  5.     time_t          msg_ctime;       /* time of last change */
  6.     unsigned log    __msg_cbytes;    /* current number of bytes on queue */
  7.     msgqnum_t       msg_qnum;        /* number of messages currently on queue */
  8.     msglen_t        msg_qbytes;      /* max number of bytes allowed on queue */
  9.     pid_t           msg_lspid;       /* pid of last msgsnd() */
  10.     pid_t           msg_lrpid;       /* pid of last msgrcv() */
  11.     ...
  12. }

通过msgctl() 可以对消息队列进行控制或者一些属性的修改，函数原型：

  1. #include <sys/msg.h>          //里面包含了 #include <sys/ipc.h>
  3. int msgctl(int msqid, int cmd, struct msqid_ds *buf);
  • msqid：由msgget函数返回的消息队列标识码
  • cmd：有三个可选的值
    • IPC_STAT 把msqid_ds结构中的数据设置为消息队列的当前关联值
    • IPC_SET 在进程有足够权限的前提下，把消息队列的当前关联值设置为msqid_ds数据结构中给出的
    • IPC_RMID 删除消息队列
  • 返回值： 成功返回0，失败返回-1

发送消息

msgsnd() 向队列发送一条消息，函数原型：

  1. #include <sys/msg.h>
  3. int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
  • msgid：由msgget函数返回的消息队列标识码
  • msgp：指针指向准备发送的消息
  • msgze：msgp指向的消息的长度（不包括消息类型的long int长整型）
  • msgflg：默认为0 ，即从队列中取出最长时间的一条消息。
  • 返回值：成功返回0，失败返回-1

消息结构一方面必须小于系统规定的上限，另一方面必须以一个long int长整型开始，接受者以此来确定消息的类型。

接受消息

msgrcv() 用于从消息队列中读取一条消息，函数原型：

  1. #include <sys/msg.h>
  3. int msgrcv(int msqid, const void *msgp, size_t msgsz, long msgtype int msgflg);
  • msgid：由msgget函数返回的消息队列标识码
  • msgp：指针指向准备发送的消息
  • msgze：msgp指向的消息的长度（不包括消息类型的long int长整型）
  • msgtype：指定读取的消息的type
  • msgflg：默认为0， 即从队列中取出最长时间的一条消息。
  • 返回值：成功返回0，失败返回-1

注意，参数msgflg 取值为：

  • 0：从队列中取出最长时间的一条消息。
  • IPC_NOWAIT：当队列没有消息时，调用会立即返回ENOMSG错误。否则，调用进程会被挂起，直到队列中的一条细细满足msgrcv() 的参数要求。

例子

  1.     在两个终端分别运行msg_snd、msg_rcv，一端输入信息发送，另一端会自动接收信息，实现消息传递。<br />msg_snd.c
  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <sys/msg.h>
  6. #include <errno.h>
  7. #define MAX_TEXT 512
  8. struct msg_st
  9. {  
  10.     long int msg_type; 
  11.     char text[MAX_TEXT];
  12. };
  13. int main()
  14. {  
  15.     int running = 1;   
  16.     struct msg_st data;
  17.     char buffer[BUFSIZ];
  18.     int msgid = -1;
  19.     // 建立消息队列
  20.     msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
  21.     if(msgid == -1)
  22.     {  
  23.         fprintf(stderr, "msgget failed with error: %d\n", errno);  
  24.         exit(EXIT_FAILURE);
  25.     }
  26.     // 向消息队列中写消息，直到写入end
  27.     while(running) 
  28.     {        
  29.         printf("Enter some text: ");   
  30.         fgets(buffer, BUFSIZ, stdin);  
  31.         data.msg_type = 1; 
  32.         strcpy(data.text, buffer);
  33.         //向队列发送数据  
  34.         if(msgsnd(msgid, (void*)&data, MAX_TEXT, 0) == -1) 
  35.         {      
  36.             fprintf(stderr, "msgsnd failed\n");    
  37.             exit(EXIT_FAILURE);    
  38.         }
  39.         // 输入end结束输入 
  40.         if(strncmp(buffer, "end", 3) == 0)     
  41.             running = 0;   
  42.         sleep(1);
  43.     }  
  44.     exit(EXIT_SUCCESS);
  45. }

msg_rcv.c

  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <errno.h>
  6. #include <sys/msg.h>
  7. struct msg_st
  8. {  
  9.     long int msg_type; 
  10.     char text[BUFSIZ];
  11. };
  12. int main()
  13. {  
  14.     int running = 1;   
  15.     int msgid = -1;
  16.     struct msg_st data;
  17.     // 注意1
  18.     long int msgtype = 0;
  19.     // 建立消息队列   
  20.     msgid = msgget((key_t)1234, 0666 | IPC_CREAT); 
  21.     if(msgid == -1)
  22.     {      
  23.         fprintf(stderr, "msgget failed with error: %d\n", errno);  
  24.         exit(EXIT_FAILURE);
  25.     }
  26.     // 从队列中获取消息，直到遇到end消息为止
  27.     while(running) 
  28.     {  
  29.         if(msgrcv(msgid, (void*)&data, BUFSIZ, msgtype, 0) == -1)  
  30.         {  
  31.             fprintf(stderr, "msgrcv failed with errno: %d\n", errno);  
  32.             exit(EXIT_FAILURE);    
  33.         }  
  34.         printf("You wrote: %s\n",data.text);
  35.         // 遇到end结束,跳出循环 
  36.         if(strncmp(data.text, "end", 3) == 0)      
  37.             running = 0;   
  38.     }
  39.     // 删除消息队列
  40.     if(msgctl(msgid, IPC_RMID, 0) == -1)   
  41.     {      
  42.         fprintf(stderr, "msgctl(IPC_RMID) failed\n");  
  43.         exit(EXIT_FAILURE);
  44.     }  
  45.     exit(EXIT_SUCCESS);
  46. }

信号量

概述

信号量与已经介绍过的IPC机构不同，它是一个计数器，用于为多个进程提供对共享数据对象的访问。为了获得共享资源，进程需要执行下列操作：

  • 测试控制该资源的信号量。
  • 若此信号量的值为正，则进程可以使用该资源.。在这种情况下，进程会将信号量值减去1，表示它使用了一个资源单位。
  • 否则，若此信号量的值为0，则进程进入休眠状态，直至信号量值大于0.。如果有进程正在休眠等待此信号量，则唤醒他们。

为了正确地实现信号量，信号量值的测试及减1操作应当是原子操作，为此，信号量通常是在内核中实现的。
信号量有几个需要注意的地方:

  1. 信号量并非是单个非负值，而必需定义为含有一个或多个信号量值的集合。当创建信号量时，要指定集合中信号量值的数量。
  2. 信号量的创建(semget)时独立于它的初始化(semctl)的，这是一个致命的缺点，因为不能原子地创建一个信号量集合，并且对该集合中的各个信号量值赋初值。
  3. 即使没有进程正在使用各种形式的IPC，他们依然是存在的。有的程序在终止时并没有释放已经分配给它的信号量，所以我们不得不为这种程序担心。 后面将要说明undo功能就是处理这种情况的：为了防止多个因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生产并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占试的执行。而信号量就可以提供这样 的一种访问机制，让一个临界区 同一时 间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。其中共享存储的使用就要用到信号量。

内核为每一个信号量集合维护这一个semid_ds结构：

  1. struct semid_ds
  2. {
  3.     struct ipc_perm sem_perm;
  4.     unsigned short  sem_nsems;
  5.     time_t          sem_otime;
  6.     time_t          sem_ctime;
  7. };

每个信号量由一个无名结构表示，它至少包含下列成员:

  1. struct ...
  2. {
  3.     unsigned short semval;
  4.     pid_t          sempid;
  5.     unsigned        semncnt;
  6.     unsigned       semzcnt;
  7.     .
  8.     .
  9.     .
  10. }

最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

相应函数

创建信号量

  1. #include <sys/sem.h>
  3. int semget(key_t key, int nsems, int semflg);
  • key：信号量的关键字，可以通过ftok() 创建，详细看 进程间通信——消息队列
  • nsems：信号量的数目。如果是创建新的信号量，必须要指定nsems。如果是引用现有的信号量，nsems指定为0。
  • shmflg： 有两个选项，IPC_CREAT 表示内核中没有此信号量则创建它。IPC_EXCL 当和IPC_CREAT一起使用时，如果信号量已经存在，则返回错误。
  • 返回值：成功返回信号量id，失败返回-1。通过errno和perror函数可以查看错误信息。

通过nsems 可以看出，创建一个信号量，里面可能包含多个信号量值。该信号量就相当于一个集合。该值表明有多少个共享资源单位可供共享应用。下面semctl 也是通过nsems 中的某一个进行操作。
如果nsems 设为1，该信号量又被称为二元信号量(binary semaphore)。

控制信号量

信号量标识符信息被记录在结构体semid_ds中：

  1. struct semid_ds {
  2.     struct ipc_perm  sem_perm;       /* operation permission struct */
  3.     time_t           sem_otime;      /* last semop() time */
  4.     time_t           sem_ctime;      /* last time changed by semctl() */
  5.     unsigned short   sem_nsems;      /* number of semaphores in set */
  6.     ...
  7. }
  1. #include <sys/sem.h>
  3. int semctl(int semid, int semnum, int cmd, .../* union semun arg */);
  • semid： 信号的标识符
  • semnum： 指定nsems 个信号量中的一个。semnum值在0 和nsems-1 之间，包括0 和 nsems-1。
  • cmd： 有10个命令，其中有5中命令是针对一个特定的信号量值的（semnun 指定的）。
  • arg: 第4个参数，详细见下面分析。
  • 返回值：若成功返回0（GETALL 等GET 命令详细看下面），若出错，则返回-1。通过errno 和perror 函数可以查看错误信息。

第 4 个参数 arg，是否使用取决于所请求的命令，如果使用该参数，则其类型是semun，它是多个命令特定参数的联合，其中包括semid_ds。如下：

  1. union semun {
  2.     int val;                      /* value for cmd SETVAL */
  3.     struct semid_ds *buf;         /* buffer for IPC_STAT & IPC_SET */
  4.     unsigned short int *array;    /* array for GETALL & SETALL */
  5.     struct seminfo *__buf;        /* buffer for IPC_INFO */
  6. }

注意，这个选项参数是一个联合，而非指向联合的指针。

下面来看下cmd 的10 个命令：

  • IPC_STAT 获取semid_ds结构，并存储在由arg.buf 指向的结构中。
  • IPC_SET 按arg.buf 指向的结构中的值，设置与信号量相关的sem_perm.uid、sem_perm.gid 和sem_perm.mode 字段。此命令只能由两种进程执行：一种是其有效用户ID 等于sem_perm.cuid 或sem_perm.uid 的进程；另一种是具有超级用户特权的进程。
  • IPC_RMID 删除信号量。这种删除是立即发生的。删除时仍在使用此信号量的其他进程，在它们下次试图对此信号量进行操作时，将出错返回EIDRM。此命令只能由两种进程执行：一种是其有效用户ID 等于sem_perm.cuid 或sem_perm.uid 的进程；另一种是具有超级用户特权的进程。
  • GETVAL 返回成员semnum 的semval 值
  • SETVAL 设置成员semnum 的semval值，该值由 arg.val 指定。
  • GETPID 返回成员semnum 的sempid 值。
  • GETNCNT 返回成员semnum 的semncnt 值
  • GETZCNT 返回成员semnum 的semzcnt 值
  • GETALL 取出信号量集合中所有信号量的值。这些值存储在 arg.array 指向的数组中。
  • SETALL 将该集合中所有信号量的值设置成arg.array 指向的数组中的值。

对于出GETALL 以外的所有GET 命令，semctl 函数都返回相应值。其他命令，若成功返回0，若出错，返回-1。
[

](https://blog.csdn.net/shift_wwx/article/details/89395569)

信号量PV操作

信号量中最重要的就是P、V操作。P就是减1操作，V就是加1操作。

  1. #include <sys/sem.h>
  3. int semop(int semid, struct sembuf semoparray[], size_t nops);
  • semid 信号量的标识符
  • semoparray 一个指针，指向一个由sembuf 结构表示的信号量操作数组。
  • nops 规定semoparray 中操作的数量（元素个数）
  • 返回值：若成功，返回0；若失败，返回-1。通过errno和perror函数可以查看错误信息。

sembuf 的数据结构：

  1. struct sembuf {
  2.     unsigned short int sem_num;          /* semaphore number */
  3.     short int sem_op;                    /* semaphore operation */
  4.     short int sem_flg;                   /* operation flag */
  5. }

sem_op值可以是负值、0 或正值。

  1. 最易于处理的情况是sem_op 为正值。这对应于进程释放的占用的资源数。sem_op 值会加到信号量上。如果指定了undo 标志，则也从该进程的此信号量调整中减去sem_op。
  2. 若sem_op 为负值，则表示要获取由该信号量控制的资源。

如信号量的值大于等于sem_op的绝对值（具有所需的资源），则从信号量值减去sem_op的绝对值。这能保证信号量的结果值大于0。如果指定了undo 标志，则sem_op 的绝对值也加到该进程的此信号量调整值上。

如果信号量值小于sem_op的绝对值（资源不能满足要求），则使用下列条件：

  • 若指定了IPC_NOWAIT，则semop 函数返回EAGAIN。
  • 若未指定IPC_NOWAIT，则该信号量的semncnt值加1（因为调用进程将进入休眠状态），然后调用进程被挂起直至下列事件之一发生：
    • 此信号量值变成大于等于sem_op的绝对值（即某个进程已经释放了某些资源）。此信号量的semncnt值减1（因为已结束等待），并且从信号量值中减去sem_op 的绝对值。如果指定了undo 标志，则sem_op 的绝对值也加到该进程的此信号量调整值上。
    • 从系统中删除了此信号量。在这种情况下，函数出错返回EIDRM。
    • 进程捕捉到一个信号，从此案好处理程序返回，在这种情况下，此信号量的semncnt值减1（因为调用进程不再等待），并且函数出错返回EINTR。
  • 若sem_op 为0，这表示调用进程希望等待到该信号值变0.

如果信号量值当前是0，则此函数立即返回。
如果信号量值非0，则使用下列条件：

  • 若指定了IPC_NOWAIT，则出错返回EAGAIN。
  • 若未指定IPC_NOWAIT，则该信号量的semzcnt值加1（因为调用进程将进入休眠状态），然后调用进程被挂起，直至下面事件发生：
    • 此信号量值变成0。此信号量的semzcnt值减1（因为调用进程已结束等待）。
    • 从系统中删除了此信号量。在这种情况下，函数出错返回EIDRM。
    • 进程捕捉到一个信号，并从信号处理程序返回。在这种情况下，此信号量的semzcnt值减1（因为调用进程不再等待），并且函数出错返回EINTR。

例子

子进程间隔时间输出AA，父进程间隔时间输出BB，如果没有信号量控制的话，输出的AB是无序,比如no_sem.c；如果加入信号量的话，就可以做到输出有序，比如sem.c

no_sem.c

  1. #include<stdio.h>
  2. #include<sys/types.h>
  3. #include<sys/ipc.h>
  4. #include<sys/sem.h>
  5. #include<unistd.h>
  7. int main()
  8. {
  10.     pid_t id = fork();
  12.     if (id == 0)
  13.      {
  14.         while (1)
  15.         {
  17.             printf("A");
  18.             fflush(stdout);
  19.             usleep(100000);
  20.             printf("A ");
  21.             fflush(stdout);
  22.             usleep(300000);
  25.         }
  27.     }
  28.     else
  29.     {
  30.         while (1)
  31.         {
  32.             printf("B");
  33.             fflush(stdout);
  34.             usleep(200000);
  35.             printf("B ");
  36.             fflush(stdout);
  37.             usleep(100000);
  39.         }
  40.     }
  41.     return 0;
  43. }

sem.c

  1. #include<stdio.h>
  2. #include<sys/types.h>
  3. #include<sys/ipc.h>
  4. #include<sys/sem.h>
  5. #include<unistd.h>
  6. #define PATHNAME "."
  7. #define PROJ_ID 0X6666
  9. int creatsem(int nums);
  10. int initsem(int semid,int nums,int initval);
  11. int getsem(int nums);
  12. int p(int semid,int who);
  13. int v(int semid,int who);
  14. int destroysem(int semid);
  16. union semun
  17. {
  18.     int val;
  19. };
  20. int commsem(int nums, int flags)
  21. {
  22.     key_t key = ftok(PATHNAME, PROJ_ID);
  23.     if (key<0)
  24.     {
  25.         perror("ftok");
  26.         return -1;
  27.     }
  28.     int semid = semget(key, nums, flags);
  29.     if (semid<0)
  30.     {
  31.         perror("semget");
  32.         return -2;
  33.     }
  34.     return semid;
  35. }
  37. int creatsem(int nums)
  38. {
  39.     return commsem(nums, IPC_CREAT | IPC_EXCL | 0666);
  40. }
  42. int initsem(int semid, int nums, int value)
  43. {
  44.     union semun u;
  45.     u.val = value;
  46.     if (semctl(semid, nums, SETVAL, u)<0)
  47.     {
  48.         perror("semctl");
  49.         return -1;
  50.     }
  51.     return 0;
  52. }
  54. int getsem(int nums)
  55. {
  56.     return commsem(nums, IPC_CREAT);
  57. }
  59. int commpv(int semid, int who, int op)
  60. {
  61.     struct sembuf sf;
  62.     sf.sem_num = who;
  63.     sf.sem_op = op;
  64.     sf.sem_flg = 0;
  65.     if (semop(semid, &sf, 1)<0)
  66.     {
  67.         perror("semop");
  68.         return -1;
  69.     }
  70.     return 0;
  71. }
  73. int p(int semid, int who)
  74. {
  75.     return commpv(semid, who, -1);
  76. }
  78. int v(int semid, int who)
  79. {
  80.     return commpv(semid, who, 1);
  81. }
  83. int destroyaem(int semid)
  84. {
  85.     if (semctl(semid, 0, IPC_RMID)<0)
  86.     {
  87.         perror("semctl");
  88.         return -1;
  89.     }
  90. }
  91. int main()
  92. {
  94.     int semid = creatsem(1);
  95.     initsem(semid, 0, 1);
  96.     pid_t id = fork();
  97.     int _semid = getsem(0);
  98.     if (id == 0)
  99.      {
  100.         while (1)
  101.         {
  102.             // 子进程p-> +1
  103.             p(_semid, 0);
  104.             printf("A");
  105.             fflush(stdout);
  106.             usleep(100000);
  107.             printf("A ");
  108.             fflush(stdout);
  109.             usleep(300000);
  110.             // 子进程v-> -1
  111.             v(_semid, 0);
  113.         }
  115.     }
  116.     else
  117.     {
  118.         while (1)
  119.         {
  120.             // 父进程p-> +1
  121.             p(_semid, 0);
  122.             printf("B");
  123.             fflush(stdout);
  124.             usleep(200000);
  125.             printf("B ");
  126.             fflush(stdout);
  127.             usleep(100000);
  128.             // 父进程v-> -1
  129.             v(_semid, 0);
  131.         }
  132.     }
  133.     destroysem(semid);
  134.     return 0;
  136. }

共享存储

概述

共享存储允许两个或多个进程共享一个给定的存储区，是进程间通信最快的一种方式。
不要同时对共享存储空间进行写操作，通常，信号量用于同步共享存储访问。

相应函数

创建

  1. #include <sys/shm.h>
  3. int shmget(key_t key, size_t size, int shmflg);
  • key 共享存储的关键字，可以通过ftok() 创建，详细看上面的消息队列的相应函数
  • size 共享存储的大小
  • shmflg 有两个选项，IPC_CREAT 表示内核中没有此共享内存则创建它。IPC_EXCL 当和IPC_CREAT一起使用时，如果共享存储已经存在，则返回错误。
  • 返回值：成功返回标识符，否则返回-1。通过errno和perror函数可以查看错误信息。

连接

获取一个共享存储的地址，并将其连接到进程中。

  1. #include <sys/shm.h>
  3. void *shmat(int shmid, const void *shmaddr, int shmflg);
  • shmid 共享存储的标识符。
  • shmaddr 指定的连接地址。若shmaddr取NULL，表示核心自动选择一个地址；若不为NULL且shmflg⽆SHM_RND标记，则以shmaddr为连接地址；若不为NULL且shmflg设置了SHM_RND标记，则连接的地址会⾃自动向下调整为SHMLBA的整数倍。公式：shmaddr - (shmaddr % SHMLBA)
  • shmflg：它的两个可能取值是SHM_RND和SHM_RDONLY（只读共享存储）
  • 返回值：成功返回一个指针，指向共享存储的第⼀个节；失败返回-1

脱离共享存储

当一个进程不在需要共享存储时，用shmdt() 把共享存储从进程地址空间中脱离，但不等于将共享存储段从系统内核中删除。

  1. #include <sys/shm.h>
  3. int shmdt(const void *shmaddr);
  • shmaddr 为shmat() 函数的连接共享存储的地址。
  • 返回值：成功返回0；失败返回-1

控制共享存储

在共享存储中标识符的属性被记录在一个shmid_ds的结构中：

  1. struct shmid_ds{
  2.     struct ipc_perm   shm_perm;         /* operation permission struct */
  3.     size_t            shm_segsz;        /* size of segment in bytes */
  4.     time_t            shm_amime;        /* time of last shmat() */
  5.     time_t            shm_dtime;        /* time of last shmdt() */
  6.     time_t            shm_ctime;        /* time of last change by shmctl() */
  7.     pid_t             shm_cpid;         /* pid of creator */
  8.     pid_t             shm_lpid;         /* pid of last shmdt */
  9.     shmatt_t          shm_nattach;      /* number of current attaches */
  10.     ...
  11. }

可以对共享存储进行控制或一些属性的修改:

  1. #include <sys/shm.h>
  3. int shmctl(int shmid, int cmd, struct shmid_ds *buf);
  • shmid：共享存储的标识码
  • cmd:有三个可选的值，在此我们使用IPC_RMID
    • IPC_STAT 把msqid_ds结构中的数据设置为共享内存的当前关联值
    • IPC_SET 进程有足够权限的前提下，把共享内存的当前关联值设置为msqid_ds数据结构中给出的值
    • IPC_RMID 删除共享内存段
  • 返回值：成功返回0；失败返回-1

例子

两个进程，shm_read进程读取共享存储的数据；shm_write进程写共享存储的数据，输入 end 结束进程。
shm_read.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/shm.h>
  6. #define SHARE_BUF 16 * 1024
  7. #define TEXT_SZ 2048
  9. struct shared_use_st
  10. {
  11.     int written_by_you;
  12.     char some_text[TEXT_SZ];
  13. };
  15. int main()
  16. {
  17.     int running = 1;
  18.     void *shared_memory = (void *)0;
  19.     struct shared_use_st *shared_stuff;
  20.     int shmid;
  22.     // 获取共享存储
  23.     shmid = shmget((key_t)1, SHARE_BUF, 0666 | IPC_CREAT);
  24.     if (shmid == -1)
  25.     {
  26.         fprintf(stderr, "shmget failed\n");
  27.         exit(-1);
  28.     }
  30.     // 连接共享存储
  31.     shared_memory = shmat(shmid, (void *)0, 0);
  32.     if (shared_memory == (void *)-1)
  33.     {
  34.         fprintf(stderr, "shmat failed\n");
  35.         exit(-1);
  36.     }
  38.     // 转换
  39.     shared_stuff = (struct shared_use_st *)shared_memory;
  40.     shared_stuff->written_by_you = 0;
  41.     while (running)
  42.     {
  43.         if (shared_stuff->written_by_you)
  44.         {
  45.             printf("You wrote: %s", shared_stuff->some_text);
  46.             sleep(rand() % 4);
  47.             shared_stuff->written_by_you = 0;
  48.             if (strncmp(shared_stuff->some_text, "end", 3) == 0)
  49.             {
  50.                 running = 0;
  51.             }
  52.         }
  53.     }
  55.     if (shmdt(shared_memory) == -1)
  56.     {
  57.         fprintf(stderr, "shmdt failed!\n");
  58.         exit(-1);
  59.     }
  61.     if (shmctl(shmid, IPC_RMID, 0) == -1)
  62.     {
  63.         fprintf(stderr, "shmctl(IPC_RMID) failed!\n");
  64.         exit(-1);
  65.     }
  67.     exit(0);
  68. }

shm_write.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/shm.h>
  6. #define SHARE_BUF 16 * 1024
  7. #define TEXT_SZ 2048
  9. struct shared_use_st
  10. {
  11.     int written_by_you;
  12.     char some_text[TEXT_SZ];
  13. };
  15. int main()
  16. {
  17.     int running = 1;
  18.     void *shared_memory = (void *)0;
  19.     struct shared_use_st *shared_stuff;
  20.     char buffer[TEXT_SZ];
  21.     int shmid;
  23.     // 获取
  24.     shmid = shmget((key_t)1, SHARE_BUF, 0666 | IPC_CREAT);
  25.     if (shmid == -1)
  26.     {
  27.         fprintf(stderr, "Shmget failed!\n");
  28.         exit(-1);
  29.     }
  31.     //连接
  32.     shared_memory = shmat(shmid, (void *)0, 0);
  33.     if (shared_memory == (void *)-1)
  34.     {
  35.         fprintf(stderr, "Shmat failed!\n");
  36.         exit(-1);
  37.     }
  39.     shared_stuff = (struct shared_use_st *)shared_memory;
  40.     while (running)
  41.     {
  42.         while (shared_stuff->written_by_you == 1)
  43.         {
  44.             sleep(1);
  45.             printf("Waiting for client...\n");
  46.         }
  47.         printf("Enter some text: ");
  48.         fgets(buffer, TEXT_SZ, stdin);
  50.         strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
  51.         shared_stuff->written_by_you = 1;
  53.         if (strncmp(buffer, "end", 3) == 0)
  54.         {
  55.             running = 0;
  56.         }
  57.     }
  59.     if (shmdt(shared_memory) == -1)
  60.     {
  61.         fprintf(stderr, "Shmdt failed\n");
  62.         exit(-1);
  63.     }
  65.     exit(0);
  66. }