linux环境编程(3): 使用POSIX IPC完成进程间通信

谢雨峰

1. 写在前面

之前的文章总结了使用管道进行进程间通信的方法，除了pipe和fifo，Linux内核还为我们提供了其他更高级的IPC方式，包括共享内存，消息队列，信号量等，本篇文章会通过一个具有完整逻辑功能的示例说明如何使用这些IPC方法。毕竟单纯地查手册，写代码...周而复始，这个过程还是比较枯燥的，而且并没有哪个IPC方法能解决所有的进程间通信问题，每种方法都不是孤立存在的，通过一个小例子把它们串联起来，是一种更好的学习方式。下文中的代码实现可以参考我的代码仓库。
2. POSIX IPC概述

进程间通信，主要解决两个问题，即数据传递和同步。POSIX IPC提供了下面三种方法：

• 消息队列
  
• 共享内存
  
• 信号量
  

操作系统中运行的进程，彼此之间是隔离的，要想实现通信，就必须有一个媒介，是通信双方都可以访问到的。从这个角度看，操作系统内核正是每个进程都可以访问到的那个媒介，就像一个"全局变量"。消息队列不过是内核维护的一个队列，保存了用户进程发送来的消息，其他进程可以从队列中取走消息，每个消息可以设置优先级，进程发送和接收消息的行为可以是阻塞或者非阻塞的，这一点类似管道；共享内存就是利用了虚拟地址空间以及物理地址空间，让不同进程的虚拟地址映射到同一个物理页面上，这样就实现了共享，对于映射的地址空间可以设定可读，可写以及可执行的标志；信号量就像一个内核中的整型变量，这个变量的数值记录了某种资源的数量，进程可以对它进行加减操作，合理使用的话就能完成想要的进程之间的同步逻辑。可以看到，这三种IPC方法在内核中都对应了一种数据结构，为了能够让用户进程访问到这些数据结构，POSIX IPC延续了“一切皆文件”的设计思路，我们可以用类似“/somename”这种形式的文件名去创建或者打开这些IPC对象，然后对它们进行各种操作，和文件的访问权限类似，进程操作IPC对象时也会进行权限检查。可能上面对三种POSIX IPC的描述存在不严谨的地方，但对于使用者来说，我们只要在脑子里建立一个合适的，能够描述它们工作方式的模型就可以了，而不是不断重复手册中对每个api的叙述。下面的表格列出了常用的POSIX IPC api：
消息队列共享内存信号量打开mq_openshm_opensem_open关闭mq_closeshm_closesem_close操作mq_send/mq_receive内存读写sem_wait/sem_post删除mq_unlinkshm_unlinksem_unlink3. POSIX IPC使用

3.1 项目功能说明

下面将使用三种POSIX IPC实现一个简单的项目，用来记录IPC的使用方法。项目包含一个server进程和若干个client进程，他们各自的功能如下：

• server进程
  
  
  
  • 首先运行，等待client的连接到来；
    
  • 收到client的连接，fork出一个新的进程去处理client的请求；
    
  
  
• client进程
  
  
  
  • 可以同时运行多个；
    
  • 启动时和server建立连接，连接建立完成之后，接受用于输入，向server发起请求；
    
  • 可以完成主动断开连接，终止server进程，以及其他操作；
    
  
  

首先启动server进程，然后启动多个client进程向server发送请求，项目实现之后的效果如下：

3.2 项目实现原理

• client如何和server建立连接？
  client进程和server进程都可以访问一段共享内存，当server进程启动时，会对这段共享内存进行初始化，初始化完成之后，server对信号量A执行post操作，表明共享内存准备完毕，之后server进程就通过信号量B等待新连接的建立；当有新的client进程想建立连接时，会先通过对信号量A执行wait操作，等待共享内存可用，如果可用，client会把请求参数写到共享内存之中，写入完成后会对信号量B执行post操作，通知server进程有新的连接已经建立。
  
• client建立连接之后如何发送请求？
  client通过两个消息队列实现发送请求和接收响应。在client建立连接时，会在共享内存中写入用于和server通信的两个消息队列的名字，server在处理连接时会打开消息队列，然后和client进行通信。对于每个新建立的连接，server会fork出一个新的进程去处理该连接对应的client发送来的请求。
  
• client如何通过发送请求关闭server？
  client通过向请求消息队列中写入kill_server请求，可以实现关闭server。当server进程fork出的进程从消息队列中读到kill_server请求，该进程会通过管道写入数据，通知server的主进程结束运行。
  
• server和client之间的时序关系：
  通过前面3点的描述可以看出，这个简单的项目几乎用到了全部常用的IPC方法，下面这个时序图更直观地说明了其工作原理：
  
  
  server和client之间的同步操作主要集中在步骤6,7,8,9。当server准备好共享内存之后，通过第6步的信号量A通知client可以建立连接了，之后client向共享内存写入数据，再操作第9步的信号量B通知server连接数据已经写入，最后server会创建子进程去处理client的请求。实际上server的主进程是一个循环，处理请求都是在server的子进程中完成的，以上内容说明了server主进程在循环中完成的工作。
  
• 资源清理
  当我们使用POSIX IPC时，内核会建立相应的数据结构，并且通过文件系统接口展示给用户，但IPC资源不能无限创建，当我们的程序运行结束之后应该清理自己用到的IPC资源。运行程序时创建的POSIX IPC对象可以在/dev/shm以及/dev/mqueue下查看，程序结束之后，server和client会释放掉自己创建的IPC资源。所以，要查看server和client创建的共享内存，信号量以及消息队列，需要在程序运行期间查看上述的两个目录。
  

3.3 主要代码功能

• 消息格式：
  server和client之间通过消息队列传递请求和响应数据，消息队列中消息格式定义如下：
  1. struct msgbuf {
  2.     int type;
  3.     union {
  4.         struct {
  5.             int a;
  6.             int b;
  7.         } request_add;
  9.         struct {
  10.             int c;
  11.         } response_add;
  13.         struct {
  14.             int disconect;
  15.         } request_disconnect;
  17.         struct {
  18.             int kill_server;
  19.         } request_kill_server;
  20.     } data;
  21. };

  复制代码
• server主进程：
  1. int main(int argc, char **argv) {
  3.     int err = server_init();
  4.     if (err) {
  5.         log_warning("server_init failed\n");
  6.         return -1;
  7.     }
  8.     server_start();
  9.     server_shutdown();
  11.     return 0;
  12. }

  复制代码
  其中，在server_init中，server会创建需要使用的共享内存，信号量以及管道。
  1. int server_init() {
  2.     memset(&ipc_server, 0, sizeof(ipc_server));
  4.     // shared memory init
  5.     ipc_server.conn_buf_fd =
  6.         shm_open(CONNECTION_SHM, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
  8.     ...
  10.     if (ftruncate(ipc_server.conn_buf_fd, CONNECTION_SHM_SIZE) < 0) {
  11.         log_warning("server failed ftruncate\n");
  12.         return -1;
  13.     }
  15.     ipc_server.conn_buf = (struct connection *)mmap(
  16.         NULL, CONNECTION_SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
  17.         ipc_server.conn_buf_fd, 0);
  19.     ...
  21.     memset(ipc_server.conn_buf, 0, CONNECTION_SHM_SIZE);
  23.     ipc_server.conn_buf_ready =
  24.         sem_open(CONNECTION_BUF_SEM, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
  26.     ...
  28.     ipc_server.conn_new_ready =
  29.         sem_open(CONNECTION_NEW_SEM, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
  30.    
  31.     ...
  33.     // pipe init
  34.     int pipefd[2];
  35.     if (pipe2(ipc_server.pipefd, O_NONBLOCK)) {
  36.         log_warning("server failed pipe2\n");
  37.         return -1;
  38.     }
  40.     log_info("server init done\n");
  41.     return 0;
  42. }

  复制代码
  在server_start中会循环处理来自client的连接。
  1. void server_start() {
  2.     int err = sem_post(ipc_server.conn_buf_ready);
  4.     ...
  6.     struct connection conn;
  7.     int stop = 0;
  8.     while (!stop) {
  9.         // handle new connection
  10.         sem_wait(ipc_server.conn_new_ready);
  11.         if (read(ipc_server.pipefd[0], &stop, sizeof(int)) <= 0)
  12.             stop = 0;
  14.         if (ipc_server.conn_buf->valid) {
  15.             log_info("new connection established\n");
  16.             memcpy(&conn, ipc_server.conn_buf, sizeof(conn));
  17.             handle_connection(&conn);
  18.             memset(ipc_server.conn_buf, 0, sizeof(struct connection));
  19.             sem_post(ipc_server.conn_buf_ready);
  20.         }
  21.     }
  22. }

  复制代码
  当server主进程退出之后，server_shutdown会清理IPC资源。
  
• client进程：
  client启动之后，首先会尝试和server建立连接，建立连接之后会循环处理用户输入，通过消息队列向server的服务进程发送请求。
  1. int main(int argc, char **argv) {
  3.     if (build_connection()) {
  4.         log_info("client failed build_connection\n");
  5.         return -1;
  6.     }
  7.     handle_command();
  8.     cleanup();
  10.     log_info("client %d exit\n", getpid());
  11.     return 0;
  12. }

  复制代码
  client建立连接的过程如下：建立连接时client需要等待共享内存可用，并且在写入连接数据之后通知server，这些同步操作都是通过信号量实现的。
  1. int build_connection() {
  2.    
  3.     ...
  5.     connection.mqreq_fd =
  6.         mq_open(connection.mqreq, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
  7.     connection.mqrsp_fd =
  8.         mq_open(connection.mqrsp, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
  10.     ...
  12.     // open and map shared memory
  13.     int fd = shm_open(CONNECTION_SHM, O_RDWR, 0);
  14.     void *conn_buf = mmap(NULL, CONNECTION_SHM_SIZE, PROT_READ | PROT_WRITE,
  15.                         MAP_SHARED, fd, 0);
  17.     // write connection to conn_buf, notify server new conncection is comming
  18.     sem_t *conn_buf_ready = sem_open(CONNECTION_BUF_SEM, O_RDWR);
  19.     sem_t *conn_new_ready = sem_open(CONNECTION_NEW_SEM, O_RDWR);
  21.     ...
  23.     sem_wait(conn_buf_ready);
  24.     connection.valid = 1;
  25.     memcpy(conn_buf, &connection, sizeof(connection));
  26.     sem_post(conn_new_ready);
  28.     ...
  30.     return 0;
  31. }

  复制代码

写在最后

通过一个包含server和client的代码示例，说明了POSIX IPC中共享内存，消息队列以及信号量的使用方法。具体实现可以参考我的代码仓库。

来源:https://www.cnblogs.com/kfggww/p/17087335.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！