TCP客户端-服务端性能优化：非阻塞套接字应用及连接管控问询

问题1：是否可根据服务器规则优化函数以实现更快执行？ #

完全可以，现有代码存在不少可优化的点，结合服务器12ms连接间隔的规则，核心优化方向如下：

• 复用固定资源：将sockaddr_in服务器地址初始化、套接字创建等重复操作移到程序启动阶段完成，避免每次连接都执行冗余的系统调用和内存初始化。
• 简化内存操作：memset(server_message, '\0', sizeof(server_message))属于冗余操作——read会覆盖缓冲区内容，只需在首次使用前初始化，或直接检查响应头部固定位置的内容，无需全量清空。
• 提升时间控制精度：替换usleep为clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, ...)，基于绝对时间实现微秒级精度的休眠，避免系统调度带来的误差。
• 优化响应解析：如果服务器返回的"OK"固定出现在响应头部，直接对比缓冲区前两个字节即可，比strstr遍历整个缓冲区更快。
• 合并等待逻辑：allowed函数中返回0时的额外10ms休眠可合并到main循环的12ms间隔控制中，无需单独执行。

问题2：非阻塞套接字在此场景中如何发挥作用？如何确保连接间隔符合要求？ #

非阻塞套接字的作用 #

阻塞模式下，connect、write、read会无条件等待，可能因网络抖动浪费数百毫秒。非阻塞套接字配合epoll/select可：

• 精准控制IO操作的等待超时，避免无意义的阻塞；
• 快速识别连接失败的情况，避免长时间挂起；
• 在等待IO就绪的间隙完成轻量准备工作，提升单次连接流程的执行效率。

确保连接间隔符合要求 #

连接间隔的控制核心在上层时间调度，与套接字阻塞与否无关：

1. 用CLOCK_MONOTONIC时钟记录每次连接发起的绝对时间；
2. 每次循环计算当前时间与上次连接时间的差值，若不足12ms，用clock_nanosleep精准休眠到12ms间隔的节点；
3. 无论单次连接流程耗时长短，必须严格等到12ms间隔到期后再发起下一次连接，绝对不能提前触发，避免IP被封禁。

问题3：如何实现从套接字创建到接收数据的最快耗时，同时最大化每秒连接数？ #

最大化每秒连接数的核心逻辑 #

服务器限制每12ms仅允许1次连接，理论最大连接数为1/0.012 ≈ 83次/秒。要达到这个上限，必须精准控制连接发起时间，确保每次连接都卡在12ms间隔的节点上发起，既不提前（触发封禁）也不延后（浪费时间）。

优化单次连接耗时的关键措施 #

1. 提前初始化资源：
   • 程序启动时完成sockaddr_in服务器地址初始化；
   • 提前创建套接字并设置SO_REUSEADDR/SO_REUSEPORT选项，避免TIME_WAIT状态占用端口，加快套接字复用速度。
2. 非阻塞IO配合epoll：
   • 将套接字设为非阻塞模式，用connect发起连接后，通过epoll_wait等待连接就绪（设置合理超时，避免无限等待）；
   • 连接就绪后，切换监听事件完成请求发送与响应接收，全程无多余阻塞。
3. 减少系统调用次数：
   • 用recv代替read，指定MSG_DONTWAIT选项实现非阻塞读取；
   • 仅读取响应头部必要字节判断结果，无需遍历整个缓冲区。
4. 优化内存访问：
   • 将响应缓冲区设为静态变量或栈上固定缓冲区，避免每次函数调用重新分配内存。

优化后代码示例 #

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

#define SERVER_IP "xxx.xxx.xxx.xxx"
#define SERVER_PORT 8080
#define CONNECT_INTERVAL_NS 12000000LL // 12ms转为纳秒
#define EPOLL_TIMEOUT 10000 // 10ms超时（微秒）

static struct sockaddr_in server_addr;
static int epoll_fd;

// 初始化全局资源
void init_resources() {
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);

    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1 failed");
        exit(EXIT_FAILURE);
    }
}

// 精准休眠到指定时间点
void sleep_until(struct timespec *target) {
    while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, target, NULL) == EINTR);
}

// 非阻塞连接+收发数据
int allowed_nonblock(const char *request) {
    int socket_desc = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
    if (socket_desc == -1) {
        perror("socket failed");
        return 0;
    }

    // 开启端口复用
    int opt = 1;
    setsockopt(socket_desc, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

    // 发起非阻塞连接
    int ret = connect(socket_desc, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (ret == -1 && errno != EINPROGRESS) {
        perror("connect failed");
        close(socket_desc);
        return 0;
    }

    struct epoll_event ev;
    ev.events = EPOLLOUT | EPOLLET;
    ev.data.fd = socket_desc;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_desc, &ev) == -1) {
        perror("epoll_ctl add failed");
        close(socket_desc);
        return 0;
    }

    // 等待连接就绪
    struct epoll_event events[1];
    int nfds = epoll_wait(epoll_fd, events, 1, EPOLL_TIMEOUT);
    if (nfds <= 0) {
        close(socket_desc);
        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_desc, NULL);
        return 0;
    }

    // 发送请求
    ssize_t bytes_written = write(socket_desc, request, strlen(request));
    if (bytes_written != strlen(request)) {
        close(socket_desc);
        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_desc, NULL);
        return 0;
    }

    // 切换监听读事件
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epoll_fd, EPOLL_CTL_MOD, socket_desc, &ev);

    // 等待响应
    nfds = epoll_wait(epoll_fd, events, 1, EPOLL_TIMEOUT);
    if (nfds <= 0) {
        close(socket_desc);
        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_desc, NULL);
        return 0;
    }

    // 读取响应头部判断结果
    char buf[2];
    ssize_t bytes_read = read(socket_desc, buf, 2);
    int result = 0;
    if (bytes_read == 2 && memcmp(buf, "OK", 2) == 0) {
        result = 1;
    }

    close(socket_desc);
    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_desc, NULL);
    return result;
}

int main() {
    init_resources();
    const char *request = "YOUR_REQUEST_CONTENT";
    struct timespec next_connect_time;
    clock_gettime(CLOCK_MONOTONIC, &next_connect_time);

    while (1) {
        sleep_until(&next_connect_time);

        if (allowed_nonblock(request) == 1) {
            dojob();
            break;
        }

        // 更新下一次连接时间
        next_connect_time.tv_nsec += CONNECT_INTERVAL_NS;
        if (next_connect_time.tv_nsec >= 1000000000LL) {
            next_connect_time.tv_sec += 1;
            next_connect_time.tv_nsec -= 1000000000LL;
        }
    }

    close(epoll_fd);
    return 0;
}

// 业务逻辑实现
void dojob() {
    // 自定义业务代码
}

内容的提问来源于stack exchange，提问作者Aer