Linux C/C++ 学习日记（35）：协程（五）：同步、多线程、多协程在IO密集型场景中的性能测试

注：该文用于个人学习记录和知识交流，如有不足，欢迎指点。

性能测试：向百度服务器发送多个http请求，对比所有响应完成需要的时间

一、半夜测的（网络通畅）

1000 个请求

common_http_client

nty_http_client

创建1000个协程

（没有问题）

二、白天测的

650个请求

1. common_http_client.c

（没问题）

2. thread_http_client.c

构建650个线程

（没问题）

3. nty_http_client.c

构建650个协程

（没问题）

1000 个 请求

1. common_http_client.c

（没有问题：均受到响应长度为8191字节）

2. thread_http_client.c

构建1000个线程

（有问题：一些临近最后的请求收到0个字节的响应）

3. nty_http_client.c

构建1000个协程

（有问题：一些临近最后的请求收到0个字节的响应，之前半夜测的那次好像是没这个情况的！！！）

三、对比结果

在IO密集型场景中：

传统的一请求一接收的同步编程方式效率低的可怜！！！

协程与线程：

• 协程的效率跟线程已经很接近了（甚至超过线程）。
• 重要的是协程在高并发级别的时候可以做到一fd一协程（KB级别），但是线程却不可以（MB级别）。

四、相关测试代码

1. common_http_client.c

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

#define MAX_REQUESTS 650
#define BUFFER_SIZE 8192
#define SERVER_IP "183.240.99.58" // 百度的IP地址
#define SERVER_PORT 80            // HTTP默认端口


int count = 0; // 请求成功数

// HTTP请求参数与结果
typedef struct
{
    int n;               // 请求序号
    const char *host;    // 服务器IP或域名
    int port;            // 端口（HTTP默认80）
    const char *path;    // 请求路径（如"/index.html"）
    char response[8192]; // 存储响应数据
    int resp_len;        // 响应长度
    int error;           // 错误码（0表示成功）
} HTTPRequest;

// 协程函数：处理单个HTTP请求
void http_request(void *arg)
{
    HTTPRequest *req = (HTTPRequest *)arg;
    req->error = 0; // 初始化错误码

    // 1. 创建非阻塞socket（库自动设置O_NONBLOCK）
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        req->error = -1;
        printf("请求 %s:%d 失败：创建socket失败\n", req->host, req->port);
        return;
    }


    // 2. 解析服务器地址（简化示例：直接用IP，实际可加域名解析）
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(req->port);
    if (inet_pton(AF_INET, req->host, &addr.sin_addr) <= 0)
    {
        req->error = -2;
        printf("请求 %s:%d 失败：无效IP\n", req->host, req->port);
        close(sockfd);
        return;
    }

    if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        req->error = -3;
        printf("请求 %s:%d 失败：连接超时/拒绝\n", req->host, req->port);
        close(sockfd);
        return;
    }


    char http_req[1024];
    snprintf(http_req, sizeof(http_req),
             "GET %s HTTP/1.1\r\n"
             "Host: %s:%d\r\n"
             "Connection: close\r\n\r\n",
             req->path, req->host, req->port);

    // 5. 发送请求（IO等待时协程自动挂起）
    ssize_t send_len = send(sockfd, http_req, strlen(http_req), 0);
    if (send_len <= 0)
    {
        req->error = -4;
        printf("请求 %s:%d 失败：发送数据失败\n", req->host, req->port);
        close(sockfd);
        return;
    }

    // 6. 接收响应（IO等待时协程自动挂起，循环读取完整响应）
    req->resp_len = 0;
    while (1)
    {
        ssize_t recv_len = recv(sockfd,
                                req->response + req->resp_len,
                                sizeof(req->response) - req->resp_len - 1,
                                0); // recv是阻塞的，但是不用担心挑不出循环，因为服务器发完响应之后就会关闭连接，从而使得recv返回0，跳出循环。
                                // sizeof(req->response) - req->resp_len - 1 = 0 的时候recv_len也会返回0，也会跳出循环。
        if (recv_len <= 0)
        {
            break; // 连接关闭或出错或buffer满了，退出循环
        }
        req->resp_len += recv_len;
        
    }
    req->response[req->resp_len] = '\0'; // 字符串结尾

    // 7. 关闭连接，标记成功
    close(sockfd);
    printf("请求 %d 完成，响应长度：%d字节\n",
           req->n, req->resp_len);
    count++;
}

HTTPRequest *HTTPRequest_init(int n)
{
    if (n <= 0)
    {
        fprintf(stderr, "无效的大小（必须为正数）\n");
        return NULL;
    }

    // 2. 动态分配n个HTTPRequest的内存
    HTTPRequest *reqs = (HTTPRequest *)malloc(n * sizeof(HTTPRequest));
    if (reqs == NULL)
    { // 检查分配是否成功
        perror("内存分配失败");
        return NULL;
    }

    // 3. 初始化每个元素（替代原来的静态初始化列表）
    for (int i = 0; i < n; i++)
    {
        reqs[i].host = SERVER_IP;
        reqs[i].port = SERVER_PORT;
        reqs[i].path = "/";
        reqs[i].n = i + 1; // 设置请求序号
    }

    return reqs;
}

int main()
{
    // 定义n个不同的HTTP请求（可扩展为更多）,这里均为百度，模拟同时向百度发送三个http请求
    HTTPRequest *reqs = HTTPRequest_init(MAX_REQUESTS);

    for (int i = 0; i < MAX_REQUESTS; i++)
    {
        http_request(&reqs[i]);
    }
    free(reqs);


    if (count == MAX_REQUESTS)
    {
        printf("所有请求均已成功完成！, 请求数为 %d\n", count);
    }
    else
    {
        printf("部分请求未完成，成功请求数：%d\n", count);
    }

    return 0;
}

2. thread_pool.h

#ifndef THREAD_POOL_H
#define THREAD_POOL_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>

#define LIST_INSERT(item, list)  \
	do                           \
	{                            \
		item->prev = NULL;       \
		item->next = list;       \
		if ((list) != NULL)      \
			(list)->prev = item; \
		(list) = item;           \
	} while (0)

#define LIST_REMOVE(item, list)            \
	do                                     \
	{                                      \
		if (item->prev != NULL)            \
			item->prev->next = item->next; \
		if (item->next != NULL)            \
			item->next->prev = item->prev; \
		if (list == item)                  \
			list = item->next;             \
		item->prev = item->next = NULL;    \
	} while (0)

struct nTask
{
	void (*task_func)(void *task);
	void *user_data;
	void (*cleanup_func)(void *task); // 任务清理函数
	struct nTask *prev;
	struct nTask *next;
};

struct nWorker
{
	pthread_t threadid;
	int terminate;
	struct nManager *manager;

	struct nWorker *prev;
	struct nWorker *next;
};

typedef struct nManager
{
	struct nTask *tasks;
	struct nWorker *workers;
	int worker_count;
	int is_shutdown;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
} ThreadPool;

// callback != task
static void *nThreadPoolCallback(void *arg)
{

	struct nWorker *worker = (struct nWorker *)arg;

	while (1)
	{

		pthread_mutex_lock(&worker->manager->mutex);
		while (worker->manager->tasks == NULL)
		{
			if (worker->terminate)
				break;
			pthread_cond_wait(&worker->manager->cond, &worker->manager->mutex);
		}
		if (worker->terminate)
		{
			pthread_mutex_unlock(&worker->manager->mutex);
			break;
		}

		struct nTask *task = worker->manager->tasks;
		LIST_REMOVE(task, worker->manager->tasks);

		pthread_mutex_unlock(&worker->manager->mutex);

		task->task_func(task);

		if (task == NULL)
			continue;

		if (task->cleanup_func)
			task->cleanup_func(task); // 自定义清理函数

		else
		{
			if (task->user_data)
			{
				free(task->user_data);
			}

			free(task);
		}
	}
	pthread_mutex_lock(&worker->manager->mutex);
	worker->manager->worker_count--;
	pthread_cond_signal(&worker->manager->cond);
	pthread_mutex_unlock(&worker->manager->mutex);

	free(worker);
}

// API
int nThreadPoolCreate(ThreadPool *pool, int numWorkers)
{

	if (pool == NULL)
		return -1;
	if (numWorkers < 1)
		numWorkers = 1;
	memset(pool, 0, sizeof(ThreadPool));

	pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
	memcpy(&pool->cond, &blank_cond, sizeof(pthread_cond_t));

	// pthread_mutex_init(&pool->mutex, NULL);
	pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;
	memcpy(&pool->mutex, &blank_mutex, sizeof(pthread_mutex_t));

	int i = 0;
	for (i = 0; i < numWorkers; i++)
	{
		struct nWorker *worker = (struct nWorker *)malloc(sizeof(struct nWorker));
		if (worker == NULL)
		{
			perror("malloc");
			return -2;
		}
		memset(worker, 0, sizeof(struct nWorker));
		worker->manager = pool; //

		int ret = pthread_create(&worker->threadid, NULL, nThreadPoolCallback, worker);
		if (ret)
		{
			perror("pthread_create");
			free(worker);
			return -3;
		}

		LIST_INSERT(worker, pool->workers);
		pool->worker_count++;
	}

	// success
	return 0;
}

// API
int nThreadPoolDestory(ThreadPool *pool)
{
	if (pool == NULL)
	{
		return -1;
	}

	// 如果已经关闭，直接返回
	if (pool->is_shutdown)
	{

		return 0;
	}

	pthread_mutex_lock(&pool->mutex);
	// 标记线程池为已关闭
	pool->is_shutdown = 1;

	// 标记所有工作线程为终止状态
	struct nWorker *worker = NULL;
	for (worker = pool->workers; worker != NULL; worker = worker->next)
	{
		worker->terminate = 1;
	}

	// 唤醒所有等待的工作线程
	pthread_cond_broadcast(&pool->cond);

	// 等待所有工作线程结束
	while (pool->worker_count > 0)
	{
		pthread_cond_wait(&pool->cond, &pool->mutex);
	}

	// 清理剩余任务
	struct nTask *task = NULL, *next_task = NULL;
	for (task = pool->tasks; task != NULL; task = next_task)
	{
		next_task = task->next;
		if (task->cleanup_func)
			task->cleanup_func(task); // 自定义清理函数
		else
		{
			if (task->user_data)
			{
				free(task->user_data);
			}

			free(task);
		}
	}

	// 清理互斥锁和条件变量
	pthread_mutex_unlock(&pool->mutex);
	pthread_mutex_destroy(&pool->mutex);
	pthread_cond_destroy(&pool->cond);

	// 清空指针
	pool->workers = NULL;
	pool->tasks = NULL;

	return 0;
}

// API
int nThreadPoolPushTask(ThreadPool *pool, struct nTask *task)
{

	pthread_mutex_lock(&pool->mutex);

	LIST_INSERT(task, pool->tasks);

	pthread_cond_signal(&pool->cond);

	pthread_mutex_unlock(&pool->mutex);
}

#endif // THREAD_POOL_H

3. thread_http_client.c

#include "thread_pool.h"

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

// 获取当前毫秒时间
int64_t current_ms()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}


#define MAX_REQUESTS 1000
#define BUFFER_SIZE 8192
#define SERVER_IP "183.240.99.58" // 百度的IP地址
#define SERVER_PORT 80            // HTTP默认端口

int count = 0; // 请求成功数

// HTTP请求参数与结果
typedef struct
{
    int n;               // 请求序号
    const char *host;    // 服务器IP或域名
    int port;            // 端口（HTTP默认80）
    const char *path;    // 请求路径（如"/index.html"）
    char response[8192]; // 存储响应数据
    int resp_len;        // 响应长度
    int error;           // 错误码（0表示成功）
} HTTPRequest;

// 协程函数：处理单个HTTP请求
void http_request(void *arg)
{
    struct nTask *task = (struct nTask *)arg;
    HTTPRequest *req = (HTTPRequest *)(task->user_data);

    req->error = 0; // 初始化错误码

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        req->error = -1;
        printf("请求 %s:%d 失败：创建socket失败\n", req->host, req->port);
        return;
    }

    // 2. 解析服务器地址（简化示例：直接用IP，实际可加域名解析）
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(req->port);
    if (inet_pton(AF_INET, req->host, &addr.sin_addr) <= 0)
    {
        req->error = -2;
        printf("请求 %s:%d 失败：无效IP\n", req->host, req->port);
        close(sockfd);
        return;
    }

    if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        req->error = -3;
        printf("请求 %s:%d 失败：连接超时/拒绝\n", req->host, req->port);
        close(sockfd);
        return;
    }

    char http_req[1024];
    snprintf(http_req, sizeof(http_req),
             "GET %s HTTP/1.1\r\n"
             "Host: %s:%d\r\n"
             "Connection: close\r\n\r\n",
             req->path, req->host, req->port);

    // 5. 发送请求（IO等待时协程自动挂起）
    ssize_t send_len = send(sockfd, http_req, strlen(http_req), 0);
    if (send_len <= 0)
    {
        req->error = -4;
        printf("请求 %s:%d 失败：发送数据失败\n", req->host, req->port);
        close(sockfd);
        return;
    }

    // 6. 接收响应（IO等待时协程自动挂起，循环读取完整响应）
    req->resp_len = 0;
    while (1)
    {
        ssize_t recv_len = recv(sockfd,
                                req->response + req->resp_len,
                                sizeof(req->response) - req->resp_len - 1,
                                0); // recv是阻塞的，但是不用担心挑不出循环，因为服务器发完响应之后就会关闭连接，从而使得recv返回0，跳出循环。
                                    // sizeof(req->response) - req->resp_len - 1 = 0 的时候recv_len也会返回0，也会跳出循环。
        if (recv_len <= 0)
        {
            break; // 连接关闭或出错或buffer满了，退出循环
        }
        req->resp_len += recv_len;
    }
    req->response[req->resp_len] = '\0'; // 字符串结尾

    // 7. 关闭连接，标记成功
    close(sockfd);
    printf("请求 %d 完成，响应长度：%d字节\n",
           req->n, req->resp_len);
    count++;
}

HTTPRequest *HTTPRequest_init(int n)
{
    if (n <= 0)
    {
        fprintf(stderr, "无效的大小（必须为正数）\n");
        return NULL;
    }

    // 2. 动态分配n个HTTPRequest的内存
    HTTPRequest *reqs = (HTTPRequest *)malloc(n * sizeof(HTTPRequest));
    if (reqs == NULL)
    { // 检查分配是否成功
        perror("内存分配失败");
        return NULL;
    }

    // 3. 初始化每个元素（替代原来的静态初始化列表）
    for (int i = 0; i < n; i++)
    {
        reqs[i].host = SERVER_IP;
        reqs[i].port = SERVER_PORT;
        reqs[i].path = "/";
        reqs[i].n = i + 1; // 设置请求序号
    }

    return reqs;
}

void free_task(void *arg)
{
    struct nTask *task = (struct nTask *)arg;
    if (task == NULL)
        return;

    /*
    reqs 是 malloc(n * sizeof(HTTPRequest)) 分配的数组整体，元素是数组的一部分，不能单独 free 某个元素。
    这样会触发「释放非堆内存」错误，导致程序崩溃，正确做法是在所有任务完成后 free(reqs)，而非单个元素释放。
    if (task->user_data)
    {
        free(task->user_data);
    }
    */

    free(task);
}

int main()
{


    ThreadPool pool = {0};
    nThreadPoolCreate(&pool, MAX_REQUESTS);

    int64_t start_time = current_ms();

    // 定义n个不同的HTTP请求（可扩展为更多）,这里均为百度，模拟同时向百度发送三个http请求
    HTTPRequest *reqs = HTTPRequest_init(MAX_REQUESTS);

    for (int i = 0; i < MAX_REQUESTS; i++)
    {
        struct nTask *task = (struct nTask *)malloc(sizeof(struct nTask));
        if (task == NULL)
        {
            perror("malloc");
            exit(1);
        }
        memset(task, 0, sizeof(struct nTask));

        task->task_func = http_request;
        task->user_data = &reqs[i];
        task->cleanup_func = free_task;

        nThreadPoolPushTask(&pool, task);
    }

    // 等待所有任务完成
    while (pool.tasks != NULL)
    {
    }

    nThreadPoolDestory(&pool);

    free(reqs);

    if (count == MAX_REQUESTS)
    {
        printf("所有请求均已成功完成！, 请求数为 %d\n", count);
    }
    else
    {
        printf("部分请求未完成，成功请求数：%d\n", count);
    }

    int64_t end_time = current_ms();
    printf("总耗时(不含线程池的创建时间）：%ld ms\n", (end_time - start_time));
    return 0;
}

4. nty_http_client.c

#include "../core/nty_coroutine.h"
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

#define MAX_REQUESTS 1000
#define BUFFER_SIZE 8192 
#define SERVER_IP "183.240.99.58" // 百度的IP地址
#define SERVER_PORT 80           // HTTP默认端口

int count = 0;  // 请求成功数

// HTTP请求参数与结果
typedef struct
{
    int n;               // 请求序号
    const char *host;    // 服务器IP或域名
    int port;            // 端口（HTTP默认80）
    const char *path;    // 请求路径（如"/index.html"）
    char response[8192]; // 存储响应数据
    int resp_len;        // 响应长度
    int error;           // 错误码（0表示成功）
} HTTPRequest;

// 协程函数：处理单个HTTP请求
void http_request_coroutine(void *arg)
{
    HTTPRequest *req = (HTTPRequest *)arg;
    req->error = 0; // 初始化错误码

    // 1. 创建非阻塞socket（库自动设置O_NONBLOCK）
    int sockfd = nty_socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        req->error = -1;
        printf("请求 %s:%d 失败：创建socket失败\n", req->host, req->port);
        return;
    }

    // 2. 解析服务器地址（简化示例：直接用IP，实际可加域名解析）
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(req->port);
    if (inet_pton(AF_INET, req->host, &addr.sin_addr) <= 0)
    {
        req->error = -2;
        printf("请求 %s:%d 失败：无效IP\n", req->host, req->port);
        nty_close(sockfd);
        return;
    }

    // 3. 连接服务器（IO等待时协程自动挂起）
    if (nty_connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        req->error = -3;
        printf("请求 %s:%d 失败：连接超时/拒绝\n", req->host, req->port);
        nty_close(sockfd);
        return;
    }

    // 4. 构造HTTP GET请求报文
    char http_req[1024];
    snprintf(http_req, sizeof(http_req),
             "GET %s HTTP/1.1\r\n"
             "Host: %s:%d\r\n"
             "Connection: close\r\n\r\n",
             req->path, req->host, req->port);

    // 5. 发送请求（IO等待时协程自动挂起）
    ssize_t send_len = nty_send(sockfd, http_req, strlen(http_req), 0);
    if (send_len <= 0)
    {
        req->error = -4;
        printf("请求 %s:%d 失败：发送数据失败\n", req->host, req->port);
        nty_close(sockfd);
        return;
    }

    // 6. 接收响应（IO等待时协程自动挂起，循环读取完整响应）
    req->resp_len = 0;
    while (1)
    {
        ssize_t recv_len = nty_recv(sockfd,
                                    req->response + req->resp_len,
                                    sizeof(req->response) - req->resp_len - 1,
                                    0); // 注意nty_recv默认是阻塞的， 但是不用担心协程一直挂起，因为服务器发完响应之后就会关闭连接，从而使得recv返回0，跳出循环。
                                    // sizeof(req->response) - req->resp_len - 1 = 0 的时候recv_len也会返回0，也会跳出循环。
        if (recv_len <= 0)
        {

            break; // 连接关闭或出错或buffer满了，退出循环
        }
        req->resp_len += recv_len;
    }
    req->response[req->resp_len] = '\0'; // 字符串结尾

    // 7. 关闭连接，标记成功
    nty_close(sockfd);
    printf("请求 %d 完成，响应长度：%d字节\n",
           req->n, req->resp_len);
    count++;
}

HTTPRequest *HTTPRequest_init(int n)
{
    if (n <= 0)
    {
        fprintf(stderr, "无效的大小（必须为正数）\n");
        return NULL;
    }

    // 2. 动态分配n个HTTPRequest的内存
    HTTPRequest *reqs = (HTTPRequest *)malloc(n * sizeof(HTTPRequest));
    if (reqs == NULL)
    { // 检查分配是否成功
        perror("内存分配失败");
        return NULL;
    }

    // 3. 初始化每个元素（替代原来的静态初始化列表）
    for (int i = 0; i < n; i++)
    {
        reqs[i].host = SERVER_IP;
        reqs[i].port = SERVER_PORT;
        reqs[i].path = "/";
        reqs[i].n = i + 1; // 设置请求序号
    }

    return reqs;
}

int main()
{
    // 定义n个不同的HTTP请求（可扩展为更多）,这里均为百度，模拟同时向百度发送三个http请求
    HTTPRequest *reqs = HTTPRequest_init(MAX_REQUESTS);

    // 为每个请求创建协程
    nty_coroutine *cos[MAX_REQUESTS];
    for (int i = 0; i < MAX_REQUESTS; i++)
    {
        int ret = nty_coroutine_create(&cos[i], http_request_coroutine, &reqs[i]);
        if (ret != 0)
        {
            printf("创建协程失败：%d\n", i);
            return -1;
        }
    }

    // 启动调度器，自动管理所有协程的并发执行
    nty_schedule_run();

    free(reqs);

    if (count == MAX_REQUESTS)
    {
        printf("所有请求均已成功完成！, 请求数为 %d\n", count);
    }
    else
    {
        printf("部分请求未完成，成功请求数：%d\n", count);
    }

    return 0;
}