进程“悄悄话”函数——`socketpair`

<摘要>
本文将以生动形象的方式深入解析socketpair函数。通过生活化的比喻，将其比作“进程间的双向对讲机”，阐述其创建一对相互连接的套接字、实现双向通信的核心功能，以及在父子进程通信、线程协作、测试调试等场景中的应用。详细介绍函数的声明（来自<sys/socket.h>，属POSIX标准）、返回值（成功返回0，失败返回-1并设置errno）及参数（域、类型、协议、套接字数组）。提供3个完整示例（父子进程流套接字通信、数据报套接字通信、错误处理），讲解编译运行注意事项与结果分析，并结合Mermaid图可视化其工作机制与总结，帮助读者全面掌握该函数的原理与实践。

---

<解析>
各位编程路上的伙伴，今天咱们来聊聊一个能让进程“悄悄话”的函数——socketpair。光听名字，“socket”是套接字，“pair”是一对，合起来就是“一对套接字”。这对套接字有什么特别之处呢？咱们先从一个生活场景说起。

想象一下，你和同桌之间拉了一根看不见的“线”，这根线很特别，你可以通过它给同桌递小纸条，同桌也能通过它给你递；而且这线是“专用”的，只有你们俩能用，别人插不进来。这根线，就像socketpair创建的那对套接字——它们相互连接，能双向传递数据，而且是进程间（或线程间）私密通信的好工具。

在计算机世界里，进程之间要交流可没那么容易，因为每个进程都有自己独立的内存空间，就像一个个封闭的房间。socketpair就像是在两个房间之间打了一个双向的洞，让数据能在两个房间之间自由流动，既可以从A到B，也可以从B到A。

一、函数的基本介绍与用途

咱们再换个例子：socketpair就像一根两头都能开口的吸管，你从一头吹气，另一头能感觉到气流；反过来，从另一头吹气，这一头也能感觉到。这对套接字就是这样，两个端点都可以读写数据，形成一个闭环的通信通道。

它的常见使用场景可不少，咱们一个个来说：

1. 父子进程通信

当一个进程（父进程）创建出另一个进程（子进程）后，它们俩就像两个独立的人，需要交流怎么办？socketpair就是个好选择。父进程在创建子进程前先调用socketpair创建一对套接字，然后把其中一个套接字“交给”子进程（通过继承），这样父子俩就能通过这对套接字互发消息了。比如，父进程给子进程下达任务，子进程汇报任务进度，都可以通过它来实现。

2. 线程间协作

虽然线程共享进程的内存空间，但有时候用socketpair来同步或传递数据更方便，尤其是在已经使用IO多路复用（比如select、epoll）的程序中。可以把其中一个套接字加入监控集合，当有数据到来时，线程就能感知到，这比用全局变量加锁的方式更灵活，尤其是在处理异步事件时。

3. 测试与调试

在编写网络程序时，有时候需要模拟两个端点的通信。比如测试一个处理套接字读写的函数，用socketpair创建一对套接字，一个当客户端，一个当服务器，就能很方便地模拟通信场景，不用真的去连接网络。

4. 信号处理中的通知

当进程收到信号（比如SIGINT）时，信号处理函数通常不能做太复杂的操作。这时候可以用socketpair：让一个套接字在epoll中监控，信号处理函数往另一个套接字里写一个字节，这样主循环就能通过epoll感知到信号，再进行后续处理，避免了信号处理函数中的潜在问题。

简单说，socketpair就是为进程（或线程）间创建“专属双向通道”的工具，它比管道（pipe）更灵活（管道是单向的，socketpair是双向的），比网络套接字更高效（因为它是本地通信，不经过网络协议栈）。

二、函数的声明与来源

socketpair这个函数可不是凭空出现的，它有明确的“出身”。

它定义在<sys/socket.h>这个头文件里，属于POSIX标准的一部分。在Linux系统中，它由glibc（GNU C库）实现，所以只要你的系统安装了glibc，通常不需要额外链接库，直接编译就能使用。

它的函数声明长这样：

#include <sys/socket.h>int socketpair(int domain, int type, int protocol, int sv[2]);

看起来不算复杂，四个参数，一个返回值。接下来咱们就仔细拆解一下。

三、返回值的含义

调用socketpair后，它会给我们一个“结果报告”，也就是返回值：

• 如果成功创建了一对套接字，函数返回0。这就像告诉你：“通道已经打通，两个端点分别是sv[0]和sv[1]，可以开始通信啦！”
• 如果失败，函数返回-1，同时会设置全局变量errno来告诉你哪里出了问题。这就像施工队告诉你：“抱歉，通道没打通，原因是XXX。”

常见的errno错误码有这么几种：

• EAFNOSUPPORT：指定的domain（域）不被支持。比如你传了一个系统不认识的域，函数就不知道该创建哪种类型的通道了。
• EPROTONOSUPPORT：protocol（协议）不被支持，或者type和protocol不匹配。
• EMFILE：进程打开的文件描述符达到了上限，没法再创建新的了。就像你的手里已经拿满了东西，再也拿不下新的了。
• ENFILE：系统范围内打开的文件描述符总数达到上限。这时候不光是当前进程，整个系统都快“满”了。
• EOPNOTSUPP：type类型不支持socketpair。比如某些类型的套接字不允许创建成对的连接。
• ENOMEM：内存不足，无法分配资源来创建套接字对。

所以，调用socketpair后，一定要检查返回值是否为-1，如果是，就通过errno来排查问题，这是良好的编程习惯。

四、参数详解

要让socketpair正确创建出通信通道，咱们得把四个参数都设置对，就像给施工队明确通道的类型、规格一样。

1. domain（域，地址族）

domain参数指定了套接字的“域”，也就是通信的范围和使用的地址格式。它就像在说：“我们要创建的通道是用于本地通信，还是网络通信？”

对于socketpair来说，最常用的（也是几乎唯一实用的）是AF_UNIX（也叫AF_LOCAL）。AF_UNIX表示这对套接字用于同一台主机上的进程间通信，不涉及网络。为什么说几乎唯一呢？因为虽然理论上有些系统支持AF_INET（IPv4）等网络域的socketpair，但实际上很少用，而且POSIX标准也主要规定了AF_UNIX下的行为。

AF_UNIX的通信效率很高，因为数据不需要经过网络协议栈的处理，直接在内核中传递。就像同一栋楼里的两个房间之间打洞，比两个城市之间挖隧道快多了。

2. type（类型）

type参数指定了套接字的类型，决定了数据的传输方式。主要有两种常用类型：

• SOCK_STREAM：流式套接字。这种类型的通信是面向连接的、可靠的、双向的字节流，就像打电话——双方建立连接后，数据按顺序传输，不会丢失、不会重复，而且可以一直聊（持续传输）。它的特点是“无边界”，比如发送方分两次发“Hello”和“World”，接收方可能一次收到“HelloWorld”。
• SOCK_DGRAM：数据报套接字。这种类型是无连接的，数据以“数据包”的形式发送，就像发短信——每个数据包都是独立的，可能会丢失、乱序，但发送方发一次，接收方就收到一个完整的包（有边界）。比如发送方发“Hello”，接收方要么完整收到“Hello”，要么收不到，不会只收到“Hel”。

在socketpair中，这两种类型都可以用，但SOCK_STREAM更常用，因为它提供可靠的传输，适合大多数进程间通信场景。SOCK_DGRAM则适合那些需要明确消息边界，且能容忍偶尔丢包（虽然在本地通信中丢包概率极低）的场景。

另外，还可以在type上加上SOCK_NONBLOCK标志，让创建的套接字是非阻塞的；加上SOCK_CLOEXEC标志，让套接字在执行exec系列函数时自动关闭。这些是进阶用法，比如type = SOCK_STREAM | SOCK_NONBLOCK。

3. protocol（协议）

protocol参数指定了使用的具体协议。对于AF_UNIX域，通常不需要指定具体协议，设为0即可。因为在AF_UNIX下，SOCK_STREAM和SOCK_DGRAM各自对应唯一的协议，系统会自动选择。

如果非要指定，可以查系统支持的协议，但一般情况下，设为0是最省事且正确的选择。

4. sv（套接字数组）

sv是一个指向包含两个整数的数组的指针，socketpair会把创建好的两个套接字的文件描述符存到这个数组里。其中，sv[0]和sv[1]就是这对“双向通道”的两个端点。

这两个文件描述符是平等的，没有主次之分。你可以从sv[0]写数据，从sv[1]读；也可以从sv[1]写，从sv[0]读，就像一条双向车道，两个方向都能走车。

使用时，你需要提前定义一个数组，比如int sv[2];，然后把这个数组的地址传给socketpair。函数成功返回后，sv[0]和sv[1]就可以用来读写了。

五、使用示例

光说理论太枯燥，咱们来三个实际的例子，看看socketpair到底怎么用。

示例1：父子进程通过流式套接字（SOCK_STREAM）双向通信

这个例子中，父进程创建子进程，通过socketpair创建的流式套接字，父进程给子进程发一条消息，子进程收到后回复一条，展示双向通信。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>int main() {int sv[2];  // 用来存放两个套接字的文件描述符char buf[1024];  // 接收数据的缓冲区// 1. 创建套接字对，使用AF_UNIX域，SOCK_STREAM类型if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {fprintf(stderr, "创建socketpair失败：%s\n", strerror(errno));exit(EXIT_FAILURE);}// 2. 创建子进程pid_t pid = fork();if (pid == -1) {fprintf(stderr, "fork失败：%s\n", strerror(errno));close(sv[0]);close(sv[1]);exit(EXIT_FAILURE);}if (pid == 0) {  // 子进程// 子进程只需要用sv[1]，关闭sv[0]（好习惯，避免资源泄漏）close(sv[0]);// 3. 子进程从sv[1]读取父进程发来的消息ssize_t n = read(sv[1], buf, sizeof(buf) - 1);if (n == -1) {fprintf(stderr, "子进程read失败：%s\n", strerror(errno));close(sv[1]);exit(EXIT_FAILURE);}buf[n] = '\0';  // 加上字符串终止符printf("子进程收到：%s\n", buf);// 4. 子进程给父进程回复一条消息const char *reply = "收到，谢谢爸爸！";if (write(sv[1], reply, strlen(reply)) == -1) {fprintf(stderr, "子进程write失败：%s\n", strerror(errno));close(sv[1]);exit(EXIT_FAILURE);}printf("子进程发送：%s\n", reply);// 5. 子进程完成任务，关闭套接字close(sv[1]);exit(EXIT_SUCCESS);} else {  // 父进程// 父进程只需要用sv[0]，关闭sv[1]close(sv[1]);// 6. 父进程给子进程发一条消息const char *msg = "儿子你好，我是爸爸！";if (write(sv[0], msg, strlen(msg)) == -1) {fprintf(stderr, "父进程write失败：%s\n", strerror(errno));close(sv[0]);wait(NULL);  // 等待子进程结束，避免僵尸进程exit(EXIT_FAILURE);}printf("父进程发送：%s\n", msg);// 7. 父进程读取子进程的回复ssize_t n = read(sv[0], buf, sizeof(buf) - 1);if (n == -1) {fprintf(stderr, "父进程read失败：%s\n", strerror(errno));close(sv[0]);wait(NULL);exit(EXIT_FAILURE);}buf[n] = '\0';printf("父进程收到：%s\n", buf);// 8. 等待子进程结束，关闭套接字close(sv[0]);wait(NULL);exit(EXIT_SUCCESS);}
}

代码说明：

1. 首先调用socketpair创建一对流式套接字，存到sv数组中。
2. 调用fork创建子进程，子进程会继承这两个套接字的文件描述符。
3. 子进程关闭sv[0]，只使用sv[1]；父进程关闭sv[1]，只使用sv[0]（这是好习惯，避免每个进程持有不必要的文件描述符）。
4. 父进程通过sv[0]发送消息，子进程通过sv[1]接收；然后子进程通过sv[1]回复，父进程通过sv[0]接收，实现双向通信。
5. 通信完成后，双方都关闭自己使用的套接字，父进程等待子进程结束后退出。

示例2：使用数据报套接字（SOCK_DGRAM）通信

这个例子展示SOCK_DGRAM类型的套接字对，特点是消息有边界，每次发送都是一个独立的数据包。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>int main() {int sv[2];char buf[1024];// 1. 创建数据报类型的套接字对if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) == -1) {fprintf(stderr, "socketpair失败：%s\n", strerror(errno));exit(EXIT_FAILURE);}pid_t pid = fork();if (pid == -1) {perror("fork");close(sv[0]);close(sv[1]);exit(EXIT_FAILURE);}if (pid == 0) {  // 子进程close(sv[0]);// 数据报套接字可以多次发送，每次都是独立的包const char *msg1 = "这是第一包数据";const char *msg2 = "这是第二包数据";// 发送第一包if (sendto(sv[1], msg1, strlen(msg1), 0, NULL, 0) == -1) {perror("子进程sendto 1");close(sv[1]);exit(EXIT_FAILURE);}printf("子进程发送：%s\n", msg1);// 发送第二包if (sendto(sv[1], msg2, strlen(msg2), 0, NULL, 0) == -1) {perror("子进程sendto 2");close(sv[1]);exit(EXIT_FAILURE);}printf("子进程发送：%s\n", msg2);close(sv[1]);exit(EXIT_SUCCESS);} else {  // 父进程close(sv[1]);// 读取第一包，会完整收到第一个消息ssize_t n = recvfrom(sv[0], buf, sizeof(buf)-1, 0, NULL, NULL);if (n == -1) {perror("父进程recvfrom 1");close(sv[0]);wait(NULL);exit(EXIT_FAILURE);}buf[n] = '\0';printf("父进程收到第一包：%s\n", buf);// 读取第二包，会完整收到第二个消息n = recvfrom(sv[0], buf, sizeof(buf)-1, 0, NULL, NULL);if (n == -1) {perror("父进程recvfrom 2");close(sv[0]);wait(NULL);exit(EXIT_FAILURE);}buf[n] = '\0';printf("父进程收到第二包：%s\n", buf);close(sv[0]);wait(NULL);exit(EXIT_SUCCESS);}
}

代码说明：

1. 这次创建的是SOCK_DGRAM类型的套接字对，用于数据报通信。
2. 子进程连续发送两个消息，使用sendto（数据报套接字常用的发送函数）。
3. 父进程用recvfrom（数据报套接字常用的接收函数）依次接收，每次调用recvfrom会收到一个完整的消息，体现了数据报的“边界性”。
4. 注意，对于socketpair创建的SOCK_DGRAM套接字，sendto和recvfrom的地址参数（后三个参数）可以忽略（设为NULL和0），因为它们已经是相互连接的，不需要指定目标地址。

示例3：错误处理（不支持的域）

这个例子故意使用一个不支持的域（比如AF_INET，虽然有些系统可能支持，但很多系统对AF_INET的socketpair有限制），看看函数如何返回错误。

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>int main() {int sv[2];// 尝试用AF_INET域创建socketpair（很多系统不支持）if (socketpair(AF_INET, SOCK_STREAM, 0, sv) == -1) {fprintf(stderr, "预期错误：创建AF_INET的socketpair失败：%s\n", strerror(errno));// 常见错误可能是EAFNOSUPPORT或EPROTONOSUPPORTexit(EXIT_FAILURE);} else {// 如果系统支持，就关闭套接字printf("意外：系统支持AF_INET的socketpair\n");close(sv[0]);close(sv[1]);exit(EXIT_SUCCESS);}
}

代码说明：

1. 尝试使用AF_INET（IPv4网络域）创建套接字对，这在很多系统上是不支持的，因为socketpair主要设计用于本地通信。
2. 函数会返回-1，并设置errno为EAFNOSUPPORT（不支持的域）或其他相关错误。
3. 这个例子展示了如何处理socketpair的错误情况，在实际编程中，检查错误是非常重要的。

六、编译与运行

这三个示例都是标准的C程序，编译方法很简单，不需要链接额外的库（因为socketpair在glibc中，默认会链接）。

编译命令如下：

• 示例1：gcc socketpair_stream.c -o stream_example -Wall
• 示例2：gcc socketpair_dgram.c -o dgram_example -Wall
• 示例3：gcc socketpair_error.c -o error_example -Wall

加上-Wall选项可以让编译器显示更多警告信息，帮助我们发现潜在问题。

运行方法也很直接，编译后执行生成的可执行文件：

• ./stream_example
• ./dgram_example
• ./error_example

编译与运行注意事项：

1. 头文件必须包含：一定要#include <sys/socket.h>，否则编译器不认识socketpair、AF_UNIX、SOCK_STREAM等标识符。
2. 关闭不需要的文件描述符：在父子进程中，各自关闭不需要的那个套接字（比如子进程关sv[0]，父进程关sv[1]），这是个好习惯。如果不关闭，可能导致read函数一直阻塞（因为另一端的套接字还没关闭，系统认为可能还有数据传来）。
3. 处理僵尸进程：父进程一定要用wait或waitpid等待子进程结束，否则子进程会变成僵尸进程，占用系统资源。
4. 读写操作的阻塞性：默认情况下，socketpair创建的套接字是阻塞的。如果调用read时没有数据，进程会阻塞直到有数据到来；如果调用write时缓冲区满了，也会阻塞。如果需要非阻塞操作，可以在type参数中加入SOCK_NONBLOCK标志。
5. 数据报的大小：使用SOCK_DGRAM时，发送的数据不能超过系统规定的最大数据报大小（可以用SO_SNDBUF选项查询），否则sendto会失败（返回-1，errno为EMSGSIZE）。
6. 跨平台注意：socketpair是POSIX标准函数，在Linux、macOS等类Unix系统上可用，但在Windows系统上（除非使用Cygwin或WSL）可能不支持，需要注意跨平台兼容性。

七、执行结果分析

咱们来看看这三个示例运行后会输出什么，以及背后的原因。

示例1运行结果：

父进程发送：儿子你好，我是爸爸！
子进程收到：儿子你好，我是爸爸！
子进程发送：收到，谢谢爸爸！
父进程收到：收到，谢谢爸爸！

分析：

• 父进程先通过sv[0]写入消息，子进程通过sv[1]读取到该消息，说明数据从父进程成功传到子进程。
• 子进程通过sv[1]写入回复，父进程通过sv[0]读取到回复，说明数据从子进程成功传到父进程，实现了双向通信。
• 因为使用的是SOCK_STREAM（流式套接字），数据是可靠传输的，而且没有边界（不过这个例子中每次只发一条消息，所以read一次就能读完）。
• 注意输出顺序可能不是严格按发送顺序，因为父子进程是并发执行的，但通常父进程发送后子进程很快收到，所以顺序会如上述所示。

示例2运行结果：

子进程发送：这是第一包数据
子进程发送：这是第二包数据
父进程收到第一包：这是第一包数据
父进程收到第二包：这是第二包数据

分析：

• 子进程发送两个独立的数据报，父进程两次调用recvfrom，分别收到这两个包，每个包的内容完整，体现了SOCK_DGRAM的“边界性”——每个sendto对应一个recvfrom。
• 本地通信中，SOCK_DGRAM的数据报不会丢失，也不会乱序，所以父进程收到的顺序和发送顺序一致。但在网络中使用SOCK_DGRAM（比如UDP）时，可能会有丢包或乱序的情况。
• 这里用sendto和recvfrom是数据报套接字的常规用法，虽然对于socketpair创建的已连接数据报套接字，也可以用read和write，但sendto和recvfrom更符合数据报的使用习惯。

示例3运行结果：

预期错误：创建AF_INET的socketpair失败：Address family not supported by protocol

（不同系统的错误信息可能略有不同，比如有的系统可能显示“Protocol not supported”）

分析：

• 大多数系统的socketpair不支持AF_INET域，因为AF_INET主要用于网络通信，而socketpair设计用于本地进程间通信。因此，调用会失败，errno被设置为EAFNOSUPPORT（地址族不支持）。
• 这个结果验证了socketpair主要用于AF_UNIX域的特点，也展示了错误处理的重要性——通过检查返回值和errno，我们可以知道哪里出了问题。

八、核心机制可视化

咱们用Mermaid图来展示socketpair的创建和通信流程，这样更直观：

graph TDA[进程A调用socketpair] --> B[内核创建一对相互连接的套接字sv[0]和sv[1]]B --> C[进程A得到sv[0]和sv[1]的文件描述符]C --> D[进程A调用fork创建进程B]D --> E[进程B继承sv[0]和sv[1]]E --> F[进程A关闭sv[1]，使用sv[0]]E --> G[进程B关闭sv[0]，使用sv[1]]F --> H[进程A通过sv[0]写入数据]H --> I[内核将数据从sv[0]传递到sv[1]]I --> J[进程B通过sv[1]读取数据]G --> K[进程B通过sv[1]写入数据]K --> L[内核将数据从sv[1]传递到sv[0]]L --> M[进程A通过sv[0]读取数据]

这个流程图展示了socketpair的核心工作过程：

1. 首先由一个进程（进程A）创建套接字对，得到两个文件描述符。
2. 进程A创建子进程（进程B），子进程继承这两个文件描述符。
3. 父子进程各自关闭不需要的描述符，保留一个用于通信。
4. 数据通过内核在两个套接字之间传递，实现双向通信。

可以看到，整个过程中，数据不需要经过外部网络，直接在系统内核中传递，所以效率很高。

九、深入理解：与其他IPC机制的对比

为了更好地理解socketpair的优势和适用场景，咱们把它和其他常见的进程间通信（IPC）机制做个对比：

1. 与管道（pipe）对比

• 管道是单向的，有“读端”和“写端”之分，数据只能从写端流向读端。如果需要双向通信，得创建两个管道。
• socketpair是双向的，一对套接字就能实现双向通信，更简洁。
• 管道只能用于父子进程或兄弟进程间通信（通过继承文件描述符）。
• socketpair也主要用于有亲缘关系的进程，但使用上更灵活（比如可以通过dup等函数传递）。

2. 与命名管道（FIFO）对比

• 命名管道有文件名，存在于文件系统中，能用于无亲缘关系的进程间通信。
• socketpair创建的套接字没有文件名，只能通过继承或文件描述符传递，主要用于有亲缘关系的进程。
• 命名管道也是单向的，双向通信需要两个FIFO。
• socketpair双向通信更方便，且效率略高（不需要操作文件系统）。

3. 与共享内存（shared memory）对比

• 共享内存是最快的IPC方式，进程直接访问同一块内存区域。
• 但共享内存需要同步机制（如信号量）来避免竞争条件，否则会出现数据不一致。
• socketpair的通信需要经过内核复制数据（从一个进程的缓冲区到另一个进程），效率比共享内存低，但不需要额外的同步机制，使用更简单。

4. 与网络套接字（TCP/UDP）对比

• 网络套接字可以用于不同主机上的进程通信，socketpair只能用于同一主机。
• 网络套接字需要处理地址绑定、连接建立等步骤，socketpair创建后直接可用，更简单。
• 本地使用网络套接字（比如连接localhost）会经过网络协议栈，效率比socketpair低。

总结来说，socketpair的优势在于：双向通信、使用简单、本地通信效率高，适合有亲缘关系的进程（或线程）间进行中等频率的双向数据交换。如果需要最高效率，选共享内存；如果需要跨主机通信，选网络套接字；如果需要无亲缘关系的本地通信，选FIFO；而如果是父子进程间双向通信，socketpair往往是最佳选择。

十、高级用法与注意事项

除了基本用法，socketpair还有一些高级用法和需要注意的细节：

1. 非阻塞模式

通过在type参数中加入SOCK_NONBLOCK标志，可以创建非阻塞的套接字对：

int sv[2];
socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, sv);

非阻塞模式下，read和write不会阻塞：如果没有数据可读，read会返回-1，errno为EAGAIN或EWOULDBLOCK；如果缓冲区满了，write也会返回-1，errno同样为EAGAIN或EWOULDBLOCK。这在使用epoll、select等IO多路复用机制时非常有用，可以将套接字加入监控集合，当有数据可读或可写时再进行操作。

2. 与IO多路复用结合

socketpair创建的套接字可以像其他套接字一样，被加入epoll、select或poll的监控集合中。例如，在一个多线程程序中，主线程用epoll监控多个文件描述符（包括socketpair的一个端点），工作线程可以通过往另一个端点写数据来通知主线程处理事件。这种方式比用信号或全局变量更安全、更灵活。

示例片段：

// 主线程创建socketpair
int sv[2];
socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, sv);// 主线程创建epoll实例，添加sv[0]到监控集合，关注EPOLLIN事件
int epfd = epoll_create1(0);
struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = sv[0];
epoll_ctl(epfd, EPOLL_CTL_ADD, sv[0], &event);// 工作线程往sv[1]写数据，通知主线程
write(sv[1], "event", 5);// 主线程在epoll_wait中会收到sv[0]的EPOLLIN事件，然后处理

3. 关闭套接字的影响

当其中一个套接字被关闭后，另一端的read操作会有不同的行为：

• 如果是SOCK_STREAM类型：当一端关闭后，另一端read会返回0（表示EOF），之后再read会一直返回0。如果继续往已关闭的套接字写数据，会收到SIGPIPE信号（默认会终止进程），或者返回-1，errno为EPIPE。
• 如果是SOCK_DGRAM类型：一端关闭后，另一端read可能会返回-1（errno为ECONNREFUSED），具体行为可能因系统而异。

因此，在通信结束后，正确关闭套接字是很重要的，这样可以让对方知道通信已经结束。

4. 传递文件描述符

通过socketpair（以及sendmsg和recvmsg函数），还可以在进程间传递文件描述符。这是一个非常强大的功能，比如父进程打开一个文件，然后通过socketpair把文件描述符传递给子进程，子进程就可以操作这个文件了，而不需要知道文件的路径。

传递文件描述符的核心是使用struct cmsghdr来封装文件描述符，通过辅助数据（ancillary data）的形式发送。这部分内容比较进阶，但充分体现了socketpair的灵活性。

十一、总结

到这里，咱们对socketpair这个“进程间双向对讲机”已经有了全面的了解。咱们再来回顾一下它的核心信息：

• 作用：创建一对相互连接的套接字，提供双向通信通道，用于同一主机上的进程（或线程）间通信。
• 头文件：<sys/socket.h>
• 所属标准：POSIX，通常由glibc实现。
• 参数：
  • domain：地址族，几乎只用AF_UNIX（AF_LOCAL）。
  • type：套接字类型，SOCK_STREAM（流式，可靠无边界）或SOCK_DGRAM（数据报，有边界）。
  • protocol：协议，通常设为0。
  • sv：存放两个套接字文件描述符的数组。
• 返回值：成功返回0，失败返回-1并设置errno。
• 优势：双向通信、使用简单、本地效率高，适合亲缘进程间通信。
• 常见用途：父子进程通信、线程协作、信号通知、测试模拟等。

最后，咱们用一个Mermaid图来概括socketpair的核心信息：

希望通过今天的讲解，你对socketpair有了清晰的认识。下次在需要实现进程间双向通信时，不妨考虑这个简单又高效的工具，它可能会让你的代码变得更简洁、更优雅。记住，好的工具能让编程之路更顺畅，而理解工具的原理，能让你在使用时更得心应手。