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++;}// successreturn 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_H3. 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;
}