面试题：C语言Linux Socket连接管理中的网络优化

Socket选项设置

TCP_NODELAY：
- 作用：禁用Nagle算法，该算法会将小的数据包积攒起来发送以提高网络利用率，但在一些实时性要求高的场景下会引入延迟。设置TCP_NODELAY可以立即发送数据，减少延迟。
- 代码示例：

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

#define PORT 8080
#define IP "127.0.0.1"
#define BUFFER_SIZE 1024

int main(int argc, char const *argv[]) {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    int opt = 1;
    if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char *)&opt, sizeof(opt)) < 0) {
        perror("setsockopt TCP_NODELAY failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    memset(&servaddr, 0, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = inet_addr(IP);

    if (connect(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("connect failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    char buffer[BUFFER_SIZE] = "Hello, Server!";
    send(sockfd, buffer, strlen(buffer), 0);
    close(sockfd);
    return 0;
}

SO_RCVBUF 和 SO_SNDBUF：
- 作用：调整接收和发送缓冲区大小。合适的缓冲区大小可以提高带宽利用率，减少丢包。例如，对于高带宽长连接，可以增大缓冲区。
- 代码示例：

// 设置接收缓冲区大小
int rcvbuf_size = 65536;
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(rcvbuf_size)) < 0) {
    perror("setsockopt SO_RCVBUF failed");
}
// 设置发送缓冲区大小
int sndbuf_size = 65536;
if (setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(sndbuf_size)) < 0) {
    perror("setsockopt SO_SNDBUF failed");
}

缓冲区管理

应用层缓冲区：
- 作用：在应用层合理设置缓冲区大小和管理机制。例如，使用环形缓冲区来高效地处理数据的收发，避免频繁的内存分配和释放。
- 代码示例（简单环形缓冲区示例）：

#define BUFFER_SIZE 1024
typedef struct {
    char data[BUFFER_SIZE];
    int head;
    int tail;
} CircularBuffer;

void initCircularBuffer(CircularBuffer *cb) {
    cb->head = 0;
    cb->tail = 0;
}

int isCircularBufferFull(CircularBuffer *cb) {
    return (cb->head + 1) % BUFFER_SIZE == cb->tail;
}

int isCircularBufferEmpty(CircularBuffer *cb) {
    return cb->head == cb->tail;
}

void putInCircularBuffer(CircularBuffer *cb, char c) {
    if (!isCircularBufferFull(cb)) {
        cb->data[cb->head] = c;
        cb->head = (cb->head + 1) % BUFFER_SIZE;
    }
}

char getFromCircularBuffer(CircularBuffer *cb) {
    char c = '\0';
    if (!isCircularBufferEmpty(cb)) {
        c = cb->data[cb->tail];
        cb->tail = (cb->tail + 1) % BUFFER_SIZE;
    }
    return c;
}

内核缓冲区与应用层同步：
- 作用：及时从内核接收缓冲区读取数据，避免缓冲区溢出导致数据丢失。同样，及时将应用层数据写入内核发送缓冲区。可以使用select、poll或epoll等多路复用机制来高效地监控Socket状态，以便及时处理数据。
- 代码示例（使用epoll）：

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

#define PORT 8080
#define IP "127.0.0.1"
#define MAX_EVENTS 10
#define BUFFER_SIZE 1024

int main(int argc, char const *argv[]) {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    memset(&servaddr, 0, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = inet_addr(IP);

    if (connect(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("connect failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    int epollfd = epoll_create1(0);
    if (epollfd == -1) {
        perror("epoll_create1");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    struct epoll_event event;
    event.data.fd = sockfd;
    event.events = EPOLLIN | EPOLLET;
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &event) == -1) {
        perror("epoll_ctl: sockfd");
        close(sockfd);
        close(epollfd);
        exit(EXIT_FAILURE);
    }

    struct epoll_event events[MAX_EVENTS];
    char buffer[BUFFER_SIZE];
    while (1) {
        int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == sockfd) {
                ssize_t read_bytes = recv(sockfd, buffer, sizeof(buffer), 0);
                if (read_bytes > 0) {
                    buffer[read_bytes] = '\0';
                    printf("Received: %s\n", buffer);
                } else if (read_bytes == 0) {
                    printf("Connection closed by peer\n");
                    close(sockfd);
                    close(epollfd);
                    exit(EXIT_SUCCESS);
                } else {
                    perror("recv");
                    close(sockfd);
                    close(epollfd);
                    exit(EXIT_FAILURE);
                }
            }
        }
    }
    return 0;
}

协议优化

选择合适的协议：
- 作用：对于实时性要求高且对数据准确性要求相对较低的场景（如视频流、音频流），可以考虑使用UDP协议，并结合应用层的可靠传输机制（如RUDP）。对于数据准确性要求严格的场景（如文件传输、数据库同步），TCP协议是更好的选择，但可以通过调整TCP参数（如拥塞控制算法）来优化性能。
- 示例：在Linux下，可以通过修改/proc/sys/net/ipv4/tcp_congestion_control文件来更改TCP拥塞控制算法，例如：

echo cubic > /proc/sys/net/ipv4/tcp_congestion_control

优化TCP参数：
- 作用：调整TCP的重传超时（RTO）、最大段大小（MSS）等参数。合理的RTO设置可以避免不必要的重传等待，而合适的MSS可以提高带宽利用率。
- 代码示例（设置MSS）：

// 获取当前MSS
int mss;
socklen_t optlen = sizeof(mss);
if (getsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &optlen) < 0) {
    perror("getsockopt TCP_MAXSEG");
}
// 设置新的MSS
int new_mss = 1460;
if (setsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &new_mss, sizeof(new_mss)) < 0) {
    perror("setsockopt TCP_MAXSEG");
}

高负载情况下避免连接超时和数据丢失

连接超时处理：
- 心跳机制：在应用层实现心跳机制，定期发送心跳包给对方，以检测连接是否正常。如果在一定时间内没有收到心跳响应，则认为连接超时，关闭连接并尝试重新连接。
- 代码示例（简单心跳示例）：

// 发送心跳包
while (1) {
    if (send(sockfd, "HEARTBEAT", strlen("HEARTBEAT"), 0) < 0) {
        perror("send heartbeat failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    sleep(5); // 每5秒发送一次心跳
}

设置合理的超时时间：在使用connect、send、recv等函数时，可以设置超时时间。例如，使用setsockopt设置SO_SNDTIMEO和SO_RCVTIMEO选项。

// 设置发送超时时间为3秒
struct timeval send_timeout;
send_timeout.tv_sec = 3;
send_timeout.tv_usec = 0;
if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &send_timeout, sizeof(send_timeout)) < 0) {
    perror("setsockopt SO_SNDTIMEO");
}
// 设置接收超时时间为3秒
struct timeval recv_timeout;
recv_timeout.tv_sec = 3;
recv_timeout.tv_usec = 0;
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &recv_timeout, sizeof(recv_timeout)) < 0) {
    perror("setsockopt SO_RCVTIMEO");
}

数据丢失处理：
- 重传机制：TCP本身有重传机制，但在高负载情况下，可能需要在应用层进行额外的重传。例如，记录已发送的数据和发送时间，在一定时间内没有收到确认时，重新发送数据。
- 代码示例（简单应用层重传示例）：

#define MAX_RETRIES 3
int retries = 0;
while (retries < MAX_RETRIES) {
    ssize_t send_bytes = send(sockfd, buffer, strlen(buffer), 0);
    if (send_bytes < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            // 非阻塞情况下的处理
            continue;
        } else {
            perror("send failed");
            break;
        }
    } else if (send_bytes == 0) {
        // 连接关闭等情况处理
        break;
    } else {
        // 假设这里接收到确认信息
        // 如果没有接收到确认，retries++ 并继续循环重传
        break;
    }
    retries++;
}
if (retries == MAX_RETRIES) {
    printf("Max retries reached, giving up\n");
}

冗余数据传输：在一些对数据准确性要求极高的场景下，可以发送冗余数据，接收方通过校验和等方式进行数据恢复，以减少数据丢失的影响。

星途面试题库

面试题：C语言Linux Socket连接管理中的网络优化

知识考点

面试题答案

Socket选项设置

缓冲区管理

协议优化

高负载情况下避免连接超时和数据丢失