os

Linux 网络编程基础：Socket API 与 TCP 连接生命周期

在 Linux 系统中，网络通信的基石是 Berkeley Socket API。无论你是在编写 Web 服务器、微服务网关，还是分布式系统的 RPC 框架，最终都会落到 、 、 、 这些系统调用上。

Leeting Yan 9 分钟阅读 4049 字

在 Linux 系统中，网络通信的基石是 Berkeley Socket API。无论你是在编写 Web 服务器、微服务网关，还是分布式系统的 RPC 框架，最终都会落到 socket()、connect()、send()、recv() 这些系统调用上。本文从 Socket 类型讲起，深入 TCP 连接的生命周期，覆盖关键 Socket 选项、I/O 模型以及生产环境编程中的最佳实践，帮助你构建健壮的网络应用。

1. Socket 类型概览

Socket 本质上是一种进程间通信（IPC）机制。它允许同一主机或不同主机的进程通过统一的文件描述符接口交换数据。Linux 支持多种 Socket 类型：

类型协议特征典型场景
SOCK_STREAMTCP可靠、有序、面向连接HTTP、SSH、MySQL
SOCK_DGRAMUDP不可靠、无序、无连接DNS、视频流、NTP
SOCK_RAWIP/ICMP直接访问 IP 层ping、traceroute、网络扫描
SOCK_SEQPACKETSCTP可靠、有序、面向消息电信信令
Unix Domain Socket本地协议不涉及网络协议栈Nginx-PHP-FPM、Docker

Unix Domain Socket（AF_UNIX 或 AF_LOCAL）值得特别提及。由于数据无需经过 TCP/IP 协议栈，仅在内核内存中拷贝，其延迟通常比 localhost TCP 低一个数量级，吞吐量也更高。这就是为什么系统级服务（如 Docker daemon、PostgreSQL 本地连接）优先使用它的原因。

2. TCP 客户端/服务端流程

2.1 系统调用序列

TCP 服务端和客户端的建立流程是对称但又略有差异的：

服务端: socket() → bind() → listen() → accept() → recv()/send() → close()
客户端: socket() → connect() → send()/recv() → close()
  • socket()：创建套接字文件描述符，分配内部数据结构（struct socket、struct sock）。
  • bind()：将套接字与本地 IP 地址和端口绑定。服务端必须调用此接口；客户端通常由内核在 connect() 时自动绑定一个临时端口。
  • listen()：将套接字标记为被动套接字，初始化全连接队列和半连接队列（SYN backlog）。
  • accept()：从全连接队列中取出一个已完成三次握手的连接，返回新的文件描述符用于通信。原监听套接字继续等待新连接。
  • connect()：客户端发起三次握手。该调用在握手完成前阻塞（默认模式下）。
  • send()/recv()：在用户缓冲区与内核 Socket 缓冲区之间拷贝数据。
  • close()：关闭文件描述符，触发四次挥手。

2.2 完整的 Echo 服务端与客户端

以下是一个基于阻塞 I/O 的 TCP Echo 服务端实现：

// tcp_echo_server.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BACKLOG 128
#define BUF_SIZE 4096

int main() {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    int reuse = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    struct sockaddr_in serv_addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(PORT),
        .sin_addr   = { .s_addr = INADDR_ANY }
    };

    if (bind(listen_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    if (listen(listen_fd, BACKLOG) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d...\n", PORT);

    while (1) {
        struct sockaddr_in cli_addr;
        socklen_t cli_len = sizeof(cli_addr);
        int conn_fd = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_len);
        if (conn_fd < 0) {
            perror("accept");
            continue;
        }

        char buf[BUF_SIZE];
        ssize_t n;
        while ((n = recv(conn_fd, buf, sizeof(buf) - 1, 0)) > 0) {
            buf[n] = '\0';
            printf("Received: %s", buf);
            send(conn_fd, buf, n, 0);
        }

        close(conn_fd);
    }

    close(listen_fd);
    return 0;
}

对应的客户端实现：

// tcp_echo_client.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1"
#define PORT 8080
#define BUF_SIZE 4096

int main() {
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in serv_addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(PORT)
    };
    inet_pton(AF_INET, SERVER_IP, &serv_addr.sin_addr);

    if (connect(sock_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("connect");
        exit(EXIT_FAILURE);
    }

    const char *msg = "Hello, TCP Socket!\n";
    send(sock_fd, msg, strlen(msg), 0);

    char buf[BUF_SIZE];
    ssize_t n = recv(sock_fd, buf, sizeof(buf) - 1, 0);
    if (n > 0) {
        buf[n] = '\0';
        printf("Server echo: %s", buf);
    }

    close(sock_fd);
    return 0;
}

编译并运行：

gcc -o server tcp_echo_server.c && ./server
gcc -o client tcp_echo_client.c && ./client

3. TCP 三次握手与四次挥手

3.1 系统调用与状态机映射

TCP 连接的建立与拆除遵循严格的状态机。系统调用只是触发状态转换的入口：

  • connect()：客户端发送 SYN，进入 SYN_SENT 状态。收到 SYN+ACK 后回复 ACK，进入 ESTABLISHED。connect() 返回。
  • listen() + accept()：服务端进入 LISTEN 状态。收到 SYN 后发送 SYN+ACK，连接进入 SYN_RCVD（半连接）。收到 ACK 后进入 ESTABLISHED（全连接），accept() 成功返回。
  • close()（主动关闭方）：发送 FIN，进入 FIN_WAIT_1；收到 ACK 后进入 FIN_WAIT_2；收到对方 FIN 并回复 ACK 后进入 TIME_WAIT。
  • close()（被动关闭方）：收到 FIN 后回复 ACK，进入 CLOSE_WAIT；应用层调用 close() 后发送 FIN，进入 LAST_ACK；收到 ACK 后彻底关闭。

3.2 为什么需要 TIME_WAIT

TIME_WAIT 状态持续 2MSL（Maximum Segment Lifetime，通常 60 秒），其存在有两个核心原因：

  1. 可靠地终止连接：确保最后一个 ACK 能被对端收到。如果 ACK 丢失，对端会重发 FIN，主动关闭方需要能够处理。
  2. 防止旧数据包干扰新连接：如果立即重用同一四元组（源 IP、源端口、目的 IP、目的端口），网络中滞留的旧数据包可能被新连接误收。

但在高并发短连接场景（如大量 HTTP/1.0 请求）下，TIME_WAIT 状态的连接会迅速耗尽本地端口，导致 connect() 失败。应对策略包括：

  • 在服务端设置 SO_REUSEADDR，允许绑定处于 TIME_WAIT 状态的端口。
  • 使用长连接（HTTP Keep-Alive、gRPC 流）。
  • 客户端启用 net.ipv4.tcp_tw_reuse（仅对客户端出连接有效）。

3.3 SO_REUSEADDR 与 SO_REUSEPORT

int opt = 1;
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

SO_REUSEADDR 允许进程绑定一个处于 TIME_WAIT 状态的端口，是服务端快速重启的标配。但注意，它只允许一个进程绑定到特定的 IP:Port 组合。

SO_REUSEPORT（Linux 3.9+）则允许多个进程或线程同时绑定到完全相同的地址和端口。内核会自动在这些 Socket 之间做负载均衡，是实现多进程/多线程高性能服务端（如 Nginx）的关键。

setsockopt(sock_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

4. 常用 Socket 选项

通过 setsockopt() 和 getsockopt()，我们可以精细控制 Socket 的行为。

选项层级作用
SO_REUSEADDRSOL_SOCKET允许重用 TIME_WAIT 状态的地址
SO_REUSEPORTSOL_SOCKET允许多个进程绑定相同地址，内核负载均衡
TCP_NODELAYIPPROTO_TCP禁用 Nagle 算法，立即发送小数据包
TCP_QUICKACKIPPROTO_TCP禁用延迟 ACK，立即回复确认
SO_KEEPALIVESOL_SOCKET启用 TCP 保活机制，检测死连接
SO_SNDTIMEOSOL_SOCKET设置发送超时
SO_RCVTIMEOSOL_SOCKET设置接收超时
SO_RCVBUFSOL_SOCKET设置接收缓冲区大小
SO_SNDBUFSOL_SOCKET设置发送缓冲区大小

TCP_NODELAY 与 TCP_QUICKACK 的组合常用于低延迟场景（如游戏服务器、高频交易）。Nagle 算法会将多个小数据包合并发送以减少网络负载，但会引入延迟；延迟 ACK 会让接收方等待一段时间或等待有数据要发时才回复 ACK，同样会增大延迟。

超时设置示例：

struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
setsockopt(sock_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

5. I/O 模型

Linux 提供了五种 I/O 模型，理解它们的差异对于构建高并发服务至关重要。

模型阻塞性数据拷贝方式适用规模代表实现
阻塞 I/O阻塞读/写内核→用户同步拷贝低并发上面的 Echo Server
非阻塞 I/O立即返回 EAGAIN内核→用户同步拷贝需轮询，较少单独使用fcntl(O_NONBLOCK)
I/O 多路复用select/poll/epoll 阻塞等待事件内核→用户同步拷贝数万~百万连接Nginx、Redis
信号驱动 I/O信号通知可读内核→用户同步拷贝极少使用SIGIO
异步 I/O内核完成拷贝后通知内核→用户异步拷贝高吞吐磁盘/网络io_uring

5.1 基于 select 的非阻塞服务端

select 可以同时监视多个文件描述符的可读/可写/异常状态。以下是改造后的非阻塞 Echo Server：

// select_echo_server.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/select.h>

#define PORT 8080
#define MAX_CLIENTS 1024
#define BUF_SIZE 4096

void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    set_nonblocking(listen_fd);

    int reuse = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    struct sockaddr_in serv_addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(PORT),
        .sin_addr   = { .s_addr = INADDR_ANY }
    };
    bind(listen_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    listen(listen_fd, 128);

    int client_fds[MAX_CLIENTS];
    memset(client_fds, -1, sizeof(client_fds));

    fd_set read_fds;
    int max_fd = listen_fd;

    while (1) {
        FD_ZERO(&read_fds);
        FD_SET(listen_fd, &read_fds);

        for (int i = 0; i < MAX_CLIENTS; i++) {
            if (client_fds[i] != -1) {
                FD_SET(client_fds[i], &read_fds);
                if (client_fds[i] > max_fd) max_fd = client_fds[i];
            }
        }

        int ret = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
        if (ret < 0) {
            perror("select");
            break;
        }

        if (FD_ISSET(listen_fd, &read_fds)) {
            struct sockaddr_in cli_addr;
            socklen_t cli_len = sizeof(cli_addr);
            int conn_fd = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_len);
            if (conn_fd >= 0) {
                set_nonblocking(conn_fd);
                for (int i = 0; i < MAX_CLIENTS; i++) {
                    if (client_fds[i] == -1) {
                        client_fds[i] = conn_fd;
                        break;
                    }
                }
            }
        }

        for (int i = 0; i < MAX_CLIENTS; i++) {
            if (client_fds[i] != -1 && FD_ISSET(client_fds[i], &read_fds)) {
                char buf[BUF_SIZE];
                ssize_t n = recv(client_fds[i], buf, sizeof(buf) - 1, 0);
                if (n > 0) {
                    buf[n] = '\0';
                    send(client_fds[i], buf, n, 0);
                } else if (n == 0 || (n < 0 && errno != EAGAIN)) {
                    close(client_fds[i]);
                    client_fds[i] = -1;
                }
            }
        }
    }

    close(listen_fd);
    return 0;
}

生产环境中，通常使用 epoll（边缘触发或水平触发）代替 select，因为它在等待大量文件描述符时性能不会线性下降。

5.2 io_uring：异步 I/O 的未来

io_uring（Linux 5.1+）通过共享内存中的提交队列和完成队列，实现了真正的异步 I/O。请求提交后，内核在后台执行，完成后通过队列通知用户态，避免了传统多路复用的上下文切换和系统调用开销。它是高吞吐网络应用（如下一代存储、代理服务器）的前沿方向。

6. 生产环境编程实践

6.1 处理部分读/写

send() 和 recv() 返回的字节数可能小于请求量。健壮的网络程序必须循环处理：

ssize_t send_all(int fd, const char *buf, size_t len) {
    size_t total = 0;
    while (total < len) {
        ssize_t n = send(fd, buf + total, len - total, 0);
        if (n < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN) break; // 非阻塞，稍后再试
            return -1;
        }
        total += n;
    }
    return total;
}

6.2 字节序转换

网络协议统一采用大端字节序（Big-Endian）。主机字节序可能是小端（x86/x64）或大端（部分 ARM）。必须使用转换函数：

uint16_t htons(uint16_t hostshort);   // 主机 → 网络（16位）
uint32_t htonl(uint32_t hostlong);    // 主机 → 网络（32位）
uint16_t ntohs(uint16_t netshort);    // 网络 → 主机（16位）
uint32_t ntohl(uint32_t netlong);     // 网络 → 主机（32位）

端口号和 IP 地址在放入 sockaddr_in 结构前必须做转换。

6.3 地址解析

现代程序应使用 getaddrinfo() 替代废弃的 gethostbyname()，它支持 IPv4/IPv6 双栈：

struct addrinfo hints, *res;
memset(&hints, 0, sizeof(hints));
hints.ai_family   = AF_UNSPEC;      // IPv4 或 IPv6
hints.ai_socktype = SOCK_STREAM;    // TCP

int ret = getaddrinfo("example.com", "8080", &hints, &res);
if (ret == 0) {
    int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    connect(fd, res->ai_addr, res->ai_addrlen);
    freeaddrinfo(res);
}

6.4 处理 EINTR 与 EAGAIN

在 Linux 下，慢速系统调用可能被信号中断：

  • EINTR：被信号中断，通常应重试（continue）。
  • EAGAIN / EWOULDBLOCK：非阻塞模式下资源暂时不可用，应在多路复用中等待下次事件。

信号安全、可重入的系统调用设计，是保证服务在 SIGTERM 等信号下优雅退出的基础。

6.5 优雅关闭连接

close() 会同时关闭读写两个方向。如果只想关闭发送方向，让客户端知道不会再发数据，但仍能接收，应使用 shutdown()：

shutdown(sock_fd, SHUT_WR);  // 发送 FIN，进入半关闭状态
// 仍可以 recv() 读取对端剩余数据

这在 HTTP/1.1 的持久连接、TLS 协议中有广泛应用。

7. Socket 选项演示

以下代码综合展示了多个关键选项的设置：

// socket_options_demo.c
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>

void configure_socket(int fd) {
    int opt = 1;
    struct timeval tv = { .tv_sec = 5, .tv_usec = 0 };

    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
    setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, &opt, sizeof(opt));
    setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt));
    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

    int bufsize = 65536;
    setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));

    int actual;
    socklen_t len = sizeof(actual);
    getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &actual, &len);
    printf("Actual receive buffer size: %d\n", actual); // 内核会翻倍
}

注意：SO_RCVBUF 和 SO_SNDBUF 的值会被内核翻倍（用于 bookkeeping overhead），所以 getsockopt() 返回的值通常是你设置的两倍。

结语

Linux Socket API 看起来简单——不过是十几个系统调用——但背后隐藏着 TCP 状态机、内核缓冲区管理、信号处理和并发模型等复杂机制。从阻塞 I/O 到 epoll，再到 io_uring，网络编程的演进本质上是在解决同一个问题：如何用有限的系统资源高效地服务海量并发连接。

掌握本文所述的 Socket 类型、TCP 生命周期、关键选项和 I/O 模型，将为你深入理解 Nginx、Redis、Linux 内核网络栈以及云原生负载均衡器奠定坚实基础。在编写网络程序时，始终牢记：网络是不稳定的，数据是不完整的，系统调用是会被中断的——编程的健壮性，正来源于对这些不确定性的敬畏和处理。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「os」更多文章

  1. 进程与线程：从 PCB 到内核调度实体
  2. 虚拟内存与分页机制：从 MMU 到 TLB
  3. 系统性能诊断与调优：strace、perf、bpftrace