Linux网络编程的核心在于使用Socket API，在TCP/IP协议栈基础上实现进程间网络通信。其核心流程围绕创建Socket、绑定地址、建立连接、数据传输、关闭连接展开，并因协议（TCP/UDP）和I/O模型的不同而有显著差异。

一、核心概念与协议

特性 TCP (传输控制协议) UDP (用户数据报协议)
连接性 面向连接，需三次握手建立连接 无连接
可靠性 可靠，提供确认、重传、排序、流量控制 不可靠，尽最大努力交付
数据形式 字节流，无边界 数据报，有边界
速度 相对较慢 相对较快
应用场景 文件传输、Web浏览、邮件（要求可靠） 视频流、DNS查询、广播（要求实时）
Socket类型 SOCK_STREAM SOCK_DGRAM

二、Socket编程核心函数与流程

1. TCP服务器端典型流程（并发迭代式）

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>

int main() {
    // 1. 创建Socket (TCP)
    int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // 
    if (server_fd == -1) { /* 错误处理 */ }

    // 2. 设置Socket选项（避免地址占用错误）
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); // 

    // 3. 绑定地址和端口
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET; // IPv4
    server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡
    server_addr.sin_port = htons(8080); // 端口转换为网络字节序

    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        /* 错误处理 */
    }

    // 4. 监听连接请求
    if (listen(server_fd, 10) == -1) { // 第二个参数为等待队列长度
        /* 错误处理 */
    }

    printf("TCP Server listening on port 8080...
");

    while(1) {
        // 5. 接受客户端连接
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len); // 
        if (client_fd == -1) {
            continue; // 接受失败，继续循环
        }

        // 6. 处理连接（例如：fork子进程或创建线程）
        // 此处为简单示例，直接在主进程处理
        char buffer[1024];
        ssize_t num_bytes = read(client_fd, buffer, sizeof(buffer)-1);
        if (num_bytes > 0) {
            buffer[num_bytes] = '\0';
            printf("Received: %s
", buffer);
            write(client_fd, "Hello from TCP Server!", 22);
        }

        // 7. 关闭客户端Socket
        close(client_fd);
    }

    // 8. 关闭服务器Socket (实际不会执行到这里)
    close(server_fd);
    return 0;
}

2. TCP客户端典型流程

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main() {
    // 1. 创建Socket
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);

    // 2. 准备服务器地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 将点分十进制IP转为网络字节序

    // 3. 连接服务器
    if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("Connect failed");
        return -1;
    }

    // 4. 发送数据
    char *message = "Hello TCP Server!";
    send(sock_fd, message, strlen(message), 0);

    // 5. 接收数据
    char buffer[1024];
    ssize_t num_bytes = recv(sock_fd, buffer, sizeof(buffer)-1, 0);
    if (num_bytes > 0) {
        buffer[num_bytes] = '\0';
        printf("Server replied: %s
", buffer);
    }

    // 6. 关闭Socket
    close(sock_fd);
    return 0;
}

3. UDP服务器/客户端流程（无连接）

UDP通信中，服务器端无需listen()和accept()，客户端也无需connect()。双方都使用sendto()和recvfrom()函数，在每次收发数据时指定对端地址。

// UDP 服务器端核心代码示例
int sock_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // 
struct sockaddr_in server_addr, client_addr;
// ... 绑定(bind)地址 ...

while(1) {
    socklen_t client_len = sizeof(client_addr);
    // 接收数据，同时获取客户端地址
    ssize_t num_bytes = recvfrom(sock_fd, buffer, sizeof(buffer), 0,
                                 (struct sockaddr*)&client_addr, &client_len);
    // 处理数据...
    // 发送数据回客户端，使用recvfrom获取的地址
    sendto(sock_fd, response, strlen(response), 0,
           (struct sockaddr*)&client_addr, client_len);
}

三、关键技术与高级主题

1. I/O多路复用（解决C10K问题）

当需要同时处理大量连接时，循环阻塞处理（如上例）效率极低。I/O多路复用允许单个线程监控多个文件描述符（Socket）的就绪状态。

模型 描述 特点
select 跨平台，监控描述符集合 有文件描述符数量限制（通常1024），效率随描述符增多线性下降
poll 改进的select，使用链表存储 无硬性数量限制，但效率问题同select
epoll (Linux特有) 事件驱动，仅通知就绪描述符 高效，支持边缘触发(ET)和水平触发(LT)，适合高并发

epoll 使用示例：

#include <sys/epoll.h>
// 创建epoll实例
int epoll_fd = epoll_create1(0);
struct epoll_event ev, events[MAX_EVENTS];

// 将监听socket加入epoll监控
ev.events = EPOLLIN; // 监控可读事件
ev.data.fd = server_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev);

while(1) {
    // 等待事件发生
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for(int i = 0; i < nfds; ++i) {
        if(events[i].data.fd == server_fd) {
            // 有新连接
            int client_fd = accept(server_fd, ...);
            ev.events = EPOLLIN | EPOLLET; // 边缘触发模式
            ev.data.fd = client_fd;
            epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
        } else {
            // 已连接socket有数据可读
            handle_client_data(events[i].data.fd);
        }
    }
}

2. 地址与字节序转换

网络字节序统一使用大端序。主机字节序（可能是小端序）需转换。

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong); // 主机到网络 (长整型)
uint16_t htons(uint16_t hostshort); // 主机到网络 (短整型)
uint32_t ntohl(uint32_t netlong);   // 网络到主机
uint16_t ntohs(uint16_t netshort);

// 点分十进制IP地址与二进制网络地址互转
int inet_pton(int af, const char *src, void *dst); // 字符串->二进制
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); // 二进制->字符串

3. TCP粘包与拆包处理

TCP是字节流协议，发送的多个数据包可能在接收缓冲区中被合并（粘包）或拆分。解决方案包括：

  • 定长消息：所有消息固定长度。
  • 分隔符：使用特殊字符（如 ）分隔消息。
  • 长度前缀：在消息头部添加固定长度的字段表示消息体长度（常用）。

长度前缀法示例：

// 发送端
uint32_t msg_len = htonl(strlen(actual_message)); // 转换为网络字节序
send(sock_fd, &msg_len, sizeof(msg_len), 0); // 先发送长度
send(sock_fd, actual_message, strlen(actual_message), 0); // 再发送数据

// 接收端
uint32_t msg_len_net;
recv(sock_fd, &msg_len_net, sizeof(msg_len_net), MSG_WAITALL);
uint32_t msg_len_host = ntohl(msg_len_net); // 转换为主机字节序
char *buffer = malloc(msg_len_host + 1);
recv(sock_fd, buffer, msg_len_host, MSG_WAITALL);
buffer[msg_len_host] = '\0';

4. Socket选项设置

使用setsockopt()函数可配置Socket行为。

// 设置地址重用，防止重启服务器时“Address already in use”错误
int reuse = 1;
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)); // 

// 设置接收超时
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

四、常见网络编程模型对比

模型 描述 优点 缺点 适用场景
阻塞I/O + 多进程/线程 每个连接分配一个进程/线程 编程简单，逻辑清晰 资源消耗大，上下文切换开销高 连接数较少（<1000）
I/O多路复用 (select/poll) 单线程轮询多个连接 资源占用少，可处理更多连接 效率随连接数线性下降，编程复杂 中等并发，跨平台要求
I/O多路复用 (epoll) 事件驱动，回调通知 高效，可处理数万乃至数十万连接 Linux特有，编程复杂 Linux下高并发服务器
异步I/O (AIO) 内核完成I/O后通知应用 理论上性能最高 实现复杂，生态不成熟 特定高性能场景

五、调试与工具

  • netstat / ss: 查看网络连接、监听端口、路由表等信息。
  • tcpdump / Wireshark: 抓取和分析网络数据包。
  • strace: 跟踪系统调用，排查程序行为。
  • nc (netcat): 网络调试的瑞士军刀，可模拟TCP/UDP客户端/服务器。

参考来源

# linux # ubuntu # 计算机网络
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

AtomGit 首发：PhyAI 具身智能推理引擎开源入驻

avatar AtomGit开源社区
cover

告别网页点点点，一行命令管理开源项目——AtomGit CLI 带你飞

avatar AtomGit开源社区
cover

CANN 开发者 Meetup 南京站圆满落幕：轻量开发专场，硬核技术面对面

avatar AtomGit开源社区