linux C语言编程----进程间通信

最新推荐文章于 2023-01-30 20:01:28 发布
最新推荐文章于 2023-01-30 20:01:28 发布
阅读量3.6k 收藏 5
点赞数 1
分类专栏： 编程知识点

转载来源：http://book.51cto.com/art/200912/169555.htm

进程间通信

一个大型的应用软件往往需要众多进程协作，进程间通信（IPC）的重要性显而易见。Linux系统下的进程通信机制基本上是从UNIX平台上的进程通信机制移植而来的。主要的进程间通信机制有以下几种。

一，无名管道（Pipe）及命名管道（Named pipe）：管道可用于具有父子关系进程间的通信，命名管道用于无父子关系的进程之间通信。无父子关系的进程可将信息发送到某个命名管道中，并通过管道名读取信息。

二，信号（Signal）：信号是进程间高级的通信方式，用于通知其他进程有何种事件发生。此外，进程可以向自身发送信号，还可以获得Linux内核发出的信号。Linux支持UNIX系统早期信号函数sigal()，并从BSD引入了信号函数sigaction()。sigaction()函数不仅提供了更为有效的通信机制，并保持了接口的统一，已替代sigal()函数。

三，报文（Message）队列：报文队列又称为消息队列，是以Posix和System V为标准的通信机制。报文队列克服了信号的数据结构过于简单的问题，同时也解决了管道数据流无格式和缓冲区长度受限等问题。报文队列规定了每个进程的权限，避免了仿冒信息的出现。

四，共享内存：共享内存是让多个进程访问同一个内存空间，适合于数据量极大和数据结构极为复杂的进程间通信。但这种方式牺牲了系统的安全性，所以通常与其他进程间通信形式混合使用，并避免以根用户权限执行。

五，信号量（Semaphore）：信号量是用于解决进程的同步和相关资源抢占而设计的。

六，套接字（Socket）：套接字是一种数据访问机制，不仅可用于进程间通信，还可用于网络通信。使用套接字最大的好处在于，Linux下的程序能快速移植到其他类UNIX平台上。很多高级的进程间通信机制以套接字为基础实现。

七，D-Bus：D-Bus是一种高级的进程间通信机制，以前述机制为基础实现。它提供了丰富的接口和功能，简化了程序设计难度。

 一，进程间使用管道通信 pipe

本节将以管道方式为例讲解进程间通信的使用方法。管道本身是一种数据结构，遵循先进先出原则。先进入管道的数据，也能先从管道中读出。数据一旦读取后，就会在管道中自动删除。管道通信以管道数据结构作为内部数据存储方式，以文件系统作为数据存储媒体。Linux系统中有两种管道，分别是无名管道和命名管道。pipe系统调用可创建无名管道，open系统调用可创建命名管道。下面介绍这两种管道的实现方式。


pipe系统调用

系统调用pipe用来建立管道。与之相关的函数只有一个，即pipe()函数，该函数被定义在头文件unistd.h中，它的一般形式是：

 
 
  1. int pipe(int filedes[2]);  

pipe系统调用需要打开两个文件，文件标识符通过参数传递给pipe()函数。文件描述符filedes[0]用来读数据，filedes[1]用来写数据。调用成功时，返回值为0，错误时返回-1。管道的工作方式可以总结为以下3个步骤。

1．将数据写入管道

将数据写入管道使用的是write()函数，与写入普通文件的操作方法一样。与文件不同的是，管道的长度受到限制，管道满时写入操作会被阻塞。执行写操作的进程进入睡眠状态，直到管道中的数据被读取。fcntl()函数可将管道设置为非阻塞模式，管道满时，write()函数的返回值为0。如果写入数据长度小于管道长度，则要求一次写入完成。如果写入数据长度大于管道长度，在写完管道长度的数据时，write()函数将被阻塞。

2．从管道读取数据

读取数据使用read()函数实现，读取的顺序与写入顺序相同。当数据被读取后，这些数据将自动被管道清除。因此，使用管道通信的方式只能是一对一，不能由一个进程同时向多个进程传递同一数据。如果读取的管道为空，并且管道写入端口是打开的，read()函数将被阻塞。读取操作的进程进入睡眠状态，直到有数据写入管道为止。fcntl()函数也可将管道读取模式设置为非阻塞。

3．关闭管道

管道虽然有2个端口，但只有一个端口能被打开，这样避免了同时对管道进行读和写的操作。关闭端口使用的是close()函数，关闭读端口时，在管道上进行写操作的进程将收到SIGPIPE信号。关闭写端口时，进行读操作的read()函数将返回0。如下例所示：

 
 
  1. #include <unistd.h>                     // 标准函数库  
  2. #include <sys/types.h>                  // 该头文件提供系统调用的标志  
  3. #include <sys/wait.h>                   // wait系统调用相关函数库  
  4. #include <stdio.h>                      // 基本输入输出函数库  
  5. #include <string.h>                     // 字符串处理函数库  
  6. int main()  
  7. {  
  8.    int fd[2], cld_pid, status;          // 创建文件标识符数组  
  9.    char buf[200], len;                  // 创建缓冲区  
  10.    if (pipe(fd) == -1) {                // 创建管道  
  11.       perror("创建管道出错");  
  12.       exit(1);  
  13.    }  
  14.    if ((cld_pid=fork()) == 0) {         // 创建子进程，判断进程自身是否是子进程  
  15.       close(fd[1]);                     // 关闭写端口  
  16.       len = read(fd[0], buf, sizeof(buf));      // 从读端口中读取管道内数据  
  17.       buf[len]=0;                               // 为缓冲区内的数据加入字符串  
  18.                                                 // 结束符  
  19.       printf("子进程从管道中读取的数据是：%s ",buf);  // 输出管道中的数据  
  20.       exit(0);                                  // 结束子进程  
  21.    }  
  22.    else {  
  23.       close(fd[0]);                             // 关闭读端口  
  24.       sprintf(buf, "父进程为子进程（PID=%d）创建该数据", cld_pid);  
  25.                                                 // 在缓冲区创建字符串信息  
  26.       write(fd[1], buf, strlen(buf));           // 通过写端口向管道写入数据  
  27.       exit(0);                                  // 结束父进程  
  28.    }  
  29.    return 0;  
  30. } 

程序中，首先创建了一个管道，并且将管道的文件标识符传递给fp[]数组。该数组有2个元素，fd[0]是读取管道的端口，fd[1]是写入管道的端口。然后，通过fork()系统调用创建了一个子进程。父进程的操作是向管道写入数据，子进程的操作是读取管道内的数据，最后子进程将所读取的数据显示到终端上。


dup系统调用

系统调用dup用来复制一个文件描述符，该操作是通过对u区中文件描述符复制实现的。因此，系统调用dup能让多个文件描述符指向同一文件，便于管道操作。与该调用相关的函数有两个，分别是dup()函数和dup2()函数，一般形式如下：

 
 
  1. int dup(int oldfd);  
  2. int dup2(int oldfd, int newfd); 

其中，oldfd是原有的文件描述符，newfd为指定的新文件描述符。这两个函数的区别为，dup()函数自动分配新文件描述符，并保证该文件描述符没有被使用。dup2()函数使用newfd参数指定新文件描述符，如果该文件描述符已存在，则覆盖对应的文件描述符。新旧文件描述符可交换使用，并共享文件锁、文件指针和文件状态。调用成功时，函数返回值为新文件描述符，否则返回-1。如下例所示：

 
 
  1. #include <unistd.h>                         // 标准函数库  
  2. #include <stdio.h>                          // 基本输入输出函数库  
  3. #include <sys/types.h>                      // 该头文件提供系统调用的标志  
  4. #include <sys/stat.h>                       // 进程状态及相关操作函数库  
  5. #include <fcntl.h>                          // 该头文件包含文件I/O操作相关  
  6.                                             // 标志  
  7. int main()  
  8. {  
  9.    int fd;  
  10.    if ((fd = open("output", O_CREAT|O_RDWR,0644)) == -1) {  
  11.                                             // 打开或创建文件  
  12.       perror("打开或创建文件出错");  
  13.       return 1;  
  14.    }  
  15.    close(1);                                    // 关闭标准输出  
  16.    dup(fd);                                 // 复制fd到文件描述符1上  
  17.    close(fd);                               // 关闭文件描述符fd  
  18.    puts("该行数据将输出到文件中");  
  19.    return 0;  
  20. } 

代码中，标准输出（文件描述符为1）关闭，并将一个普通文件output的文件描述符复制到标准输出上。因为刚关闭了文件描述符1，文件描述符表的第一个空表项是1，dup()函数调用将fd的文件描述符复制到该位置上。所以，程序以后的向标准输出写的内容都写到了文件output中。

七，进程间使用D-Bus通信

D-Bus是一种高级的进程间通信机制，它由freedesktop.org项目提供，使用GPL许可证发行。D-Bus最主要的用途是在Linux桌面环境为进程提供通信，同时能将Linux桌面环境和Linux内核事件作为消息传递到进程。D-Bus的主要概率为总线，注册后的进程可通过总线接收或传递消息，进程也可注册后等待内核事件响应，例如等待网络状态的转变或者计算机发出关机指令。目前，D-Bus已被大多数Linux发行版所采用，开发者可使用D-Bus实现各种复杂的进程间通信任务。

  D-Bus的基本概念

D-Bus是一个消息总线系统，其功能已涵盖进程间通信的所有需求，并具备一些特殊的用途。D-Bus是三层架构的进程间通信系统，其中包括：

接口层：接口层由函数库libdbus提供，进程可通过该库使用D-Bus的能力。

总线层：总线层实际上是由D-Bus总线守护进程提供的。它在Linux系统启动时运行，负责进程间的消息路由和传递，其中包括Linux内核和Linux桌面环境的消息传递。

包装层：包装层一系列基于特定应用程序框架的Wrapper库。

D-Bus具备自身的协议，协议基于二进制数据设计，与数据结构和编码方式无关。该协议无需对数据进行序列化，保证了信息传递的高效性。无论是libdbus，还是D-Bus总线守护进程，均不需要太大的系统开销。

总线是D-Bus的进程间通信机制，一个系统中通常存在多条总线，这些总线由D-Bus总线守护进程管理。最重要的总线为系统总线（System Bus），Linux内核引导时，该总线就已被装入内存。只有Linux内核、Linux桌面环境和权限较高的程序才能向该总线写入消息，以此保障系统安全性，防止有恶意进程假冒Linux发送消息。

会话总线（Session Buses）由普通进程创建，可同时存在多条。会话总线属于某个进程私有，它用于进程间传递消息。

进程必须注册后才能收到总线中的消息，并且可同时连接到多条总线中。D-Bus提供了匹配器（Matchers）使进程可以有选择性的接收消息，另外运行进程注册回调函数，在收到指定消息时进行处理。匹配器的功能等同与路由，用于避免处理无关消息造成进程的性能下降。除此以外，D-Bus机制的重要概念有以下几个。

对象：对象是封装后的匹配器与回调函数，它以对等（peer-to-peer）协议使每个消息都有一个源地址和一个目的地址。这些地址又称为对象路径，或者称之为总线名称。对象的接口是回调函数，它以类似C++的虚拟函数实现。当一个进程注册到某个总线时，都要创建相应的消息对象。

消息：D-Bus的消息分为信号（signals）、方法调用（method calls）、方法返回（method returns）和错误（errors）。信号是最基本的消息，注册的进程可简单地发送信号到总线上，其他进程通过总线读取消息。方法调用是通过总线传递参数，执行另一个进程接口函数的机制，用于某个进程控制另一个进程。方法返回是注册的进程在收到相关信息后，自动做出反应的机制，由回调函数实现。错误是信号的一种，是注册进程错误处理机制之一。

服务：服务（Services）是进程注册的抽象。进程注册某个地址后，即可获得对应总线的服务。D-Bus提供了服务查询接口，进程可通过该接口查询某个服务是否存在。或者在服务结束时自动收到来自系统的消息。

安装D-Bus可在其官方网站下载源码编译，地址为http://dbus.freedesktop.org。或者在终端上输入下列指令：

 
 
  1. yum install dbus dbus-devel dbus-doc 
安装后，头文件位于"/usr/include/dbus-<版本号>/dbus"目录中，编译使用D-Bus的程序时需加入编译指令"`pkg-config --cflags --libs dbus-1`"。


D-Bus的用例

在使用GNOME桌面环境的Linux系统中，通常用GLib库提供的函数来管理总线。在测试下列用例前，首先需要安装GTK+开发包（见22.3节）并配置编译环境。该用例一共包含两个程序文件，每个程序文件需单独编译成为可执行文件。

1．消息发送程序

"dbus-ding-send.c"程序每秒通过会话总线发送一个参数为字符串Ding!的信号。该程序的源代码如下：

 
 
  1. #include <glib.h>                               // 包含glib库  
  2. #include <dbus/dbus-glib.h>                     // 包含
glib库中D-Bus管理库  
  3. #include <stdio.h> 
  4. static gboolean send_ding(DBusConnection *bus);// 定义发送消息函数的原型  
  5. int main ()  
  6. {  
  7.    GMainLoop *loop;                             // 定义一个事件循环对象的指针  
  8.    DBusConnection *bus;                         // 定义总线连接对象的指针  
  9.    DBusError error;                             // 定义D-Bus错误消息对象  
  10.    loop = g_main_loop_new(NULL, FALSE);         // 创建新事件循环对象  
  11.    dbus_error_init (&error);                    // 将错误消息对象连接到D-Bus  
  12.                                                 // 错误消息对象  
  13.    bus = dbus_bus_get(DBUS_BUS_SESSION, &error);// 连接到总线  
  14.    if (!bus) {                              // 判断是否连接错误  
  15. g_warning("连接到D-Bus失败: %s", error.message);  
  16.                                         // 使用GLib输出错误警告信息  
  17.       dbus_error_free(&error);              // 清除错误消息  
  18.       return 1;  
  19.    }  
  20.    dbus_connection_setup_with_g_main(bus, NULL);  
  21.                                             // 将总线设为接收GLib事件循环  
  22.    g_timeout_add(1000, (GSourceFunc)send_ding, bus);  
  23.                                     // 每隔1000ms调用一次send_ding()函数  
  24.                                             // 将总线指针作为参数  
  25.    g_main_loop_run(loop);                   // 启动事件循环  
  26.    return 0;  
  27. }  
  28. static gboolean send_ding(DBusConnection *bus)  // 定义发送消息函数的细节  
  29. {  
  30.    DBusMessage *message;                        // 创建消息对象指针  
  31.    message = dbus_message_new_signal("/com/burtonini/dbus/ding",   
  32.                                        "com.burtonini.dbus.Signal",  
  33.                                        "ding");     // 创建消息对象并标识路径  
  34.    dbus_message_append_args(message,  
  35.                             DBUS_TYPE_STRING, "ding!",  
  36.                             DBUS_TYPE_INVALID);     // 将字符串Ding!定义为消息  
  37.    dbus_connection_send(bus, message, NULL);    // 发送该消息  
  38.    dbus_message_unref(message);                 // 释放消息对象  
  39.    g_print("ding!\n");                          // 该函数等同与标准输入输出库的printf()  
  40.    return TRUE;  
  41. } 

main()函数创建一个GLib事件循环，获得会话总线的一个连接，并将D-Bus事件处理集成到GLib事件循环之中。然后它创建了一个名为send_ding()函数作为间隔为一秒的计时器，并启动事件循环。send_ding()函数构造一个来自于对象路径"/com/burtonini/dbus/ding"和接口"com.burtonini.dbus.Signal"的新的Ding信号。然后，字符串Ding!作为参数添加到信号中并通过总线发送。在标准输出中会打印一条消息以让用户知道发送了一个信号。

2．消息接收程序

dbus-ding-listen.c程序通过会话总线接收dbus-ding-send.c程序发送到消息。该程序的源代码如下：

 
 
  1. #include <glib.h>                               // 包含glib库  
  2. #include <dbus/dbus-glib.h>                     // 包含glib库中D-Bus管理库  
  3. static DBusHandlerResult signal_filter      // 定义接收消息函数的原型  
  4.       (DBusConnection *connection, DBusMessage *message, void *user_data);  
  5. int main()  
  6. {  
  7.    GMainLoop *loop;                             // 定义一个事件循环对象的指针  
  8.    DBusConnection *bus;                         // 定义总线连接对象的指针  
  9.    DBusError error;                             // 定义D-Bus错误消息对象  
  10.    loop = g_main_loop_new(NULL, FALSE);         // 创建新事件循环对象  
  11.    dbus_error_init(&error);                     // 将错误消息对象连接到D-Bus  
  12.                                                 // 错误消息对象  
  13.    bus = dbus_bus_get(DBUS_BUS_SESSION, &error);    // 连接到总线  
  14.    if (!bus) {                              // 判断是否连接错误  
  15. g_warning("连接到D-Bus失败: %s", error.message);  
  16.                                         // 使用GLib输出错误警告信息  
  17.       dbus_error_free(&error);              // 清除错误消息  
  18.       return 1;  
  19.   }  
  20.    dbus_connection_setup_with_g_main(bus, NULL);      
  21.                                             // 将总线设为接收GLib事件循环  
  22.    dbus_bus_add_match(bus, "type='signal',interface
='com.burtonini.dbus.Signal'");  // 定义匹配器  
  23.    dbus_connection_add_filter(bus, signal_filter, loop, NULL);  
  24.                                             // 调用函数接收消息  
  25.    g_main_loop_run(loop);                   // 启动事件循环  
  26.    return 0;  
  27. }  
  28. static DBusHandlerResult                    // 定义接收消息函数的细节  
  29. signal_filter (DBusConnection *connection, 
DBusMessage *message, void *user_data)  
  30. {  
  31.    GMainLoop *loop = user_data;             // 定义事件循环对象的指针，并与主函数中的同步  
  32.    if (dbus_message_is_signal               // 接收连接成功消息，判断是否连接  
  33.                                             // 失败  
  34.         (message, DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
"Disconnected")) {  
  35.       g_main_loop_quit (loop);              // 退出主循环  
  36.       return DBUS_HANDLER_RESULT_HANDLED;  
  37.    }  
  38.    if (dbus_message_is_signal(message, "com.burtonini.dbus.Signal",   
  39.    "Ping")) {  
  40.                                             // 指定消息对象路径，判断是否成功  
  41.       DBusError error;                      // 定义错误对象  
  42.       char *s;  
  43. dbus_error_init(&error);                // 将错误消息对象连接到D-Bus错误消息对象  
  44.       if (dbus_message_get_args                 // 接收消息，并判断是否有错误  
  45.          (message, &error, DBUS_TYPE_STRING, &s, 
DBUS_TYPE_INVALID)) {  
  46.          g_print("接收到的消息是: %s\n", s);   // 输出接收到的消息  
  47.          dbus_free (s);                     // 清除该消息  
  48.       }   
  49.       else {                                    // 有错误时执行下列语句  
  50.          g_print("消息已收到，但有错误提示: %s\n", error.message);  
  51.          dbus_error_free (&error);  
  52.       }  
  53.       return DBUS_HANDLER_RESULT_HANDLED;  
  54.    }  
  55.    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;  
  56. } 

该程序侦听dbus-ping-send.c程序正在发出的信号。main()函数和前面一样启动，创建一个到总线的连接。然后它声明愿意在使用com.burtonini.dbus.Signal接口的信号被发送时得到通知，将signal_filter()函数设置为通知函数，然后进入事件循环。当满足匹配的消息被发送时，signal_func()函数会被调用。

如果需要确定在接收消息时如何处理，可通过检测消息头实现。若收到的消息为总线断开信号，则主事件循环将被终止，因为监听的总线已经不存在了。若收到其他的消息，首先将收到的消息与期待的消息进行比较，两者相同则输出其中参数，并退出程序。两者不相同则告知总线并没有处理该消息，这样消息会继续保留在总线中供别的程序处理。


_银叶先生
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dbus的代码范例 linux_Dbus简介与简单的收发示例程序
weixin_39693950的博客
12-20 529
Dbus简介与简单的收发示例程序。D-BUS 是一个大有前途的消息总线和活动系统，正开始深入地渗透到 Linux® 桌面之中。了解创建它的原因、它的用途以及发展前景。D-BUS 本质上是 进程间通信(inter-processcommunication)(IPC)的一个实现。不过，有一些特性使得 D-BUS 远远不是“只是另一个 IPC 实现”。有很多不同的 IPC实现，因为每一个都定位于解决特定...
linux-C编程-进程间通信
gexiaobaoHelloWorld的专栏
07-09 1万+
1 信号 函数原型： void (*signal (int signo, void (*func)(int))) (int); 函数名是signal，返回值是void (*XXXX) (int)。XXXX为一个函数指针。函数signal的参数中，func是指向的一个函数的指针。 typedef void (*sighandler_t)(int); sighandler_t signal(int
DBus例子
perpetual mode machine
01-26 871
 D-BUS 代码的示例。dbus-ping-send.c 每秒通过会话总线发送一个参数为字符串“Ping!”的信号。我使用 Glib 来管理总线，以使得我不需要自己来处理总线的连接细节。    清单 1. dbus-ping-send.c#include #include static gboolean send_ping (DBusConnectio
DBus 介绍
hfut_zhanghu的博客
02-22 1万+
一、什么是 DBus？ D-Bus是一个为应用程序间通信的消息总线系统, 用于进程之间的通信。 1.1 三层架构 1、函数库libdbus ------>>>>> 用于两个应用程序互相联系和交互消息。 2、基于 libdbus 构造的消息总线守护进程，可同时与多个应用程序相连，并能把来自一个应用程序的消息路由到0或者多个其他程序。 3、基于特定应用程序框架的封装库或捆绑（wrapper libraries or bindings ）。 1.2 高层功能 结构化..
DBus使用非缺省Glib的maincontext的问题
会飞的鱼的专栏
01-21 2893
     MMI中间层封装库已经移植到linux平台下稳定运行一两个月了，最近在给其加入插件系统时，却遇到了一点麻烦。插件中的数据库数据变化的Glib信号处理函数在其他应用对数据库进行插入、修改等操作时不会被调用，即无法接收到数据变化的Glib信号。    我们的数据库封装采用C/S架构，客户端使用DBus和服务端通讯，当数据库的数据发生变化时（插入、修改、删除）时，服务端通过DBus向客户端发送
linux 进程通信——C语言实现
热门推荐
piaojun_pj的专栏
10-15 1万+
一.低级通信--信号通信signal.c#include #include #include /*捕捉到信号sig之后，执行预先预定的动作函数*/void sig_alarm(int sig){ printf("---the signal received is %d. /n", sig); signal(SIGINT, SIG_DFL); //SIGINT终端中断信号，SIG_DFL：恢复默认行为，SIN_IGN：忽略信号}int main(){ signal(SIGINT, sig_alarm);//捕
linux系统编程_linux系统编程-中文_
10-04
进程间通信（IPC）也是Linux系统编程的重要部分，包括管道、消息队列、共享内存、信号量和套接字等方法。了解这些机制如何协同工作，可以帮助你设计出高效的多进程和多线程程序。 最后，理解Makefile和构建系统是...
Linux系统下C语言编程--进程的创建
03-04
在Linux系统中，C语言编程涉及的一个...这涉及到进程的生命周期、状态转换、标识符、权限控制以及进程间的通信等多个方面。通过对这些概念和技术的深入学习和实践，开发者可以更好地构建和维护多任务的Linux应用程序。
linux下c语言编程4-使用共享内存实现进程间通信.pdf
11-01
在Linux系统中，C语言编程实现进程间通信（IPC，Inter-Process Communication）时，共享内存是一种高效且直接的方式。共享内存允许多个进程访问同一块内存区域，从而实现在进程间的数据交换。以下是对标题“linux下...
linux下c语言编程4-使用共享内存实现进程间通信.docx
11-01
。。。
linux-c.zip_C语言_Linux C语言_linux_linux-c
09-22
常见的系统调用包括：`fork`用于创建进程，`exec`系列用于执行新程序，`wait`和`waitpid`用于等待子进程结束，`open`、`close`、`read`和`write`用于文件操作，以及`pipe`和`socket`用于进程间通信。理解并熟练运用...
C语言实现进程间通信
zhangts318的博客
04-11 8882
在linux系统中的进程间通信方式有7种。原始的通信方式：无名管道 有名管道 信号， system V的系统上引入如下三种方式：​消息队列 共享内存 信号灯， 通过套接字进行本地进程间通信：BSD​
LinuxC—进程通信
wait2023的博客
01-30 1285
定义匿名管道用来实现具有亲缘关系的进程之间的通信，匿名管道是由内核创建的一块内存区域，返回这块区域对应的文件描述符后，进程间可以通过这个文件描述符的操作来进行通信。特点相关函数1024。
c语言进程间通信
赵凯月的博客
12-04 410
进程间通信
与Dbus相关的文章,完成两个简单的收发程序。
Harrison_zhu的专栏
09-07 1536
D-BUS 是一个大有前途的消息总线和活动系统，正开始深入地渗透到 Linux® 桌面之中。了解创建它的原因、它的用途以及发展前景。 D-BUS 本质上是 进程间通信（inter-process communication）（IPC）的一个实现。不过，有一些特性使得 D-BUS 远远不是“只是另一个 IPC 实现”。有很多不同的 IPC 实现，因为每一个都定位于解决特定的明确定义的问题。
关于C语言中进程通信的5种方式
qq_38954792的博客
07-30 3760
Unix/Linux系统中C语言进程通信的5种方式进程通信广义进程通信方式单机环境中常见的进程通信方式管道通信命名管道内存映射信号共享内存 进程通信 操作系统中每个进程地址空间相互独立，进程间通信必须经过内核。 广义进程通信方式 文件 管道 内存映射 共享内存 信号 套接字 消息队列 剪切板 远程过程调用 … 单机环境中常见的进程通信方式 管道通信 管道通信也成为匿名管道。管道通信使用方式最简单，用于有血缘关系的进程间通信。 主要特点： 使用两个文件描述符，一端表示读，一端表示写 两个进程都终结管道才
分包合同计量单.docx
最新发布
07-13
分包合同计量单.docx
树莓派简介PPT课件.ppt
07-13
树莓派简介PPT课件.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值