一个简单的HTTP并发测试程序

#include <stdio.h>
#include <stdlib.h>
#include <curl/curl.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

#define MAX_THREAD 500

static unsigned long long run_time = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

struct HttpStatistics	//计时
{
unsigned long long requestTime;
unsigned long long responseTime;
};

struct HttpGetParam	//参数
{
char *url;
struct HttpStatistics httpStatistics;
};

unsigned long long GetCurrentNanoseconds()//当前时间
{
struct timespec tvTime;
clock_gettime(CLOCK_REALTIME, &tvTime);
return (unsigned long long)tvTime.tv_sec * 1000000000ULL + (unsigned long long)tvTime.tv_nsec;
}

static size_t write_data(void *ptr, size_t size, size_t nmemb, void *param)
{
return size * nmemb;
}

static size_t head_data(void *ptr, size_t size, size_t nmemb, void *param)
{
struct HttpGetParam *phttpGetParam = (struct HttpGetParam *)param;
unsigned long long currentTime = 0;
unsigned long long usedTime = 0;

if ( phttpGetParam->httpStatistics.responseTime == 0)//只记录第一次收到报文时候的内容
{
currentTime = GetCurrentNanoseconds();
phttpGetParam->httpStatistics.responseTime = currentTime;
usedTime = currentTime - phttpGetParam->httpStatistics.requestTime;
//printf("Time is:%llu\n", usedTime/1000000);
//printf("%s\n", (char*)ptr);
pthread_mutex_lock(&mutex);
run_time++;
pthread_mutex_unlock(&mutex);
}
return size * nmemb;
}

//每个线程的处理
void * http_get(void *param)
{
struct HttpGetParam *phttpGetParam = (struct HttpGetParam *)param;

CURL *curl;//定义CURL类型的指针
CURLcode res; //定义CURLcode类型的变量

//pthread_detach(pthread_self());
curl = curl_easy_init();//初始化一个CURL类型的指针

//curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);//这里打开libcurl打印所有调试信息

//curl_easy_setopt(curl, CURLOPT_WRITEDATA, phttpGetParam);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, phttpGetParam);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); //加上这一句就不会把HTTP Body打出来了。。。
//curl_easy_setopt(curl, CURLOPT_NOBODY, 1);//CURLOPT_NOBODY只下报文头，不包括数据.但是这里默认是head命令，这里注释掉，则是GET命令
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, head_data);

//设置curl选项. 其中CURLOPT_URL是让用户指定url. argv[1]中存放的命令行传进来的网址
curl_easy_setopt(curl, CURLOPT_URL, phttpGetParam->url);

while( 1 )
{
phttpGetParam->httpStatistics.requestTime = GetCurrentNanoseconds();
phttpGetParam->httpStatistics.responseTime = 0;
//调用curl_easy_perform 执行我们的设置.并进行相关的操作. 在这里只在屏幕上显示出来.
res = curl_easy_perform(curl);//这里可以用循环实现每个线程内部多次处理
//printf("res=%d\n", res);
}
//清除curl操作.
curl_easy_cleanup(curl);
return NULL;
}

int main(int argc, char *argv[])
{
CURLcode res; //定义CURLcode类型的变量
pthread_t threads[MAX_THREAD];//PID
int i, ret;
struct HttpGetParam httpGetParams[MAX_THREAD];
pthread_attr_t thread_attr;
size_t stack_size;

if (argc !=2)
{
printf("Usage : %s <url>;\n", argv[0]);
exit(1);
}

res = curl_global_init(CURL_GLOBAL_ALL);
if (res != CURLE_OK)
{
printf( "Failed to global init default [%d]\n", res );
return -1;
}

memset(threads, 0, sizeof(threads));
memset(httpGetParams, 0, sizeof(httpGetParams));

for ( i = 0; i < MAX_THREAD; i++)
{
httpGetParams[i].url = argv[1];
}

printf("PTHREAD_STACK_MIN=%d\n", PTHREAD_STACK_MIN);
pthread_attr_init(&thread_attr);
pthread_attr_getstacksize(&thread_attr, &stack_size);
printf("Default stack size is %u; minimum is %u\n",
stack_size, PTHREAD_STACK_MIN);
pthread_attr_setstacksize(&thread_attr, 1024 * 1024); //设置线程栈大小，这里设置成了1M，这个可能需要根据情况调，最小不能小于PTHREAD_STACK_MIN,如果太小有可能出现栈溢出
pthread_attr_getstacksize(&thread_attr, &stack_size);
printf("New stack size is %u; minimum is %u\n",
stack_size, PTHREAD_STACK_MIN);
for ( i = 0; i < MAX_THREAD; i++)
{
//创建线程，threads线程ID
//ret = pthread_create(&threads[i], NULL, http_get, (void *)&httpGetParams[i]);
ret = pthread_create(&threads[i], &thread_attr, http_get, (void *)&httpGetParams[i]);
if (0 != ret)
{
perror("pthread_create failed!!! The reason is:");
}

if ( (i + 1) % 5 == 0)
{
sleep(10);
printf("Thread num:%d,\tAVG request per second:%llu,\tAVG response time:%f\n", i + 1, run_time/10, 10.0/run_time);
pthread_mutex_lock(&mutex);
run_time = 0;
pthread_mutex_unlock(&mutex);
}
}
pthread_attr_destroy(&thread_attr);

//sleep(30);
//等待线程退出
for ( i = 0; i < MAX_THREAD; i++)
{
//判断pthread_t是否有效,解决了段错误问题。
if (threads[i] != 0)
{
pthread_cancel(threads[i]);
pthread_join(threads[i], NULL);
}
}
return 0;
}