17年1月的时候，使用siege工具对cgi进行压测，然而当时仅仅只是使用，没有好好了解内部的代码实现，最后压测出来的数据也是不如意，走了不少弯路 siege是多线程模型，n个并发通过创建n个线程来执行任务实现，同时还会有控制线程和计时线程，可以满足指定压测时间的要求。线程直接并发的控制主要通过互斥锁和等待条件变量来实现

首先大家来看下压测工具怎么使用

参数详解： siege --help SIEGE 3.0.6 Usage: siege [options] siege [options] URL siege -g URL Options: -V, --version VERSION, prints the version number. -h, --help HELP, prints this section. -C, --config CONFIGURATION, show the current config. #在屏幕上打印显示出当前的配置,配置是包括在他的配置文件$HOME/.siegerc中, #可以编辑里面的参数,这样每次siege 都会按照它运行. -v, --verbose VERBOSE, prints notification to screen. #运行时能看到详细的运行信息 -q, --quiet QUIET turns verbose off and suppresses output. -g, --get GET, pull down HTTP headers and display the transaction. Great for application debugging. -c, --concurrent=NUM CONCURRENT users, default is 10 #模拟有n个用户在同时访问,n不要设得太大,因为越大,siege 消耗本地机器的资源越多 -i, --internet INTERNET user simulation, hits URLs randomly. #随机访问urls.txt中的url列表项,以此模拟真实的访问情况(随机性) -b, --benchmark BENCHMARK: no delays between requests. -t, --time=NUMm TIMED testing where "m" is modifier S, M, or H ex: --time=1H, one hour test. #持续运行siege ‘n’秒(如10S),分钟(10M),小时(10H) -r, --reps=NUM REPS, number of times to run the test. #重复运行测试n次,不能与 -t同时存在 -f, --file=FILE FILE, select a specific URLS FILE. #指定用urls文件,默认为siege安装目录下的etc/urls.txt #urls.txt文件：是很多行待测试URL的列表以换行符断开,格式为: #[protocol://]host.domain.com[:port][path/to/file] -R, --rc=FILE RC, specify an siegerc file #指定用特定的siege配置文件来运行,默认的为$HOME/.siegerc -l, --log[=FILE] LOG to FILE. If FILE is not specified, the default is used: PREFIX/var/siege.log #运行结束,将统计数据保存到日志文件siege.log中,可在.siegerc中自定义日志文件 -m, --mark="text" MARK, mark the log file with a string. -d, --delay=NUM Time DELAY, random delay before each requst between 1 and NUM. (NOT COUNTED IN STATS) #hit每个url之间的延迟,在0-n之间 -H, --header="text" Add a header to request (can be many) -A, --user-agent="text" Sets User-Agent in request -T, --content-type="text" Sets Content-Type in request

例如压测命令如下：

/usr/local/bin/test/result.txt;/root/affiliu/siege -c 200 -r 750 -f /usr/local/bin/test/yace_buy_url_150000.txt -R /root/.siege/siege.conf -b 2>>/usr/local/bin/test/result.txt

-c代表并发量，实际上会低一点，-r是每个进程重复请求的次数，-f 指定请求的url文件 -b是请求和请求之间不要有延迟，2>>/usr/local/bin/test/result.txt 是吧统计结果重定向到这个文件下，-R /root/.siege/siege.conf这个是读取配置文件的路径 压测总共压测的请求数目为：200*750=150000

siege压测时候的一些注意点

修改siege的配置：

修改/root/.siege/siege.conf文件，修改里面的配置

limit配置，siege可以开的最大的进程数目，将它修改成1024

verbose配置，修改成false，减少每次请求之后io操作，从而减少请求与请求直接的延迟，提高压测的可靠性

修改压测机器的配置：

在/etc/security/limits.conf文件末尾添加

soft noproc 102400

hard noproc 102400

soft nofile 102400

hard nofile 102400

修改用户级的最大文件描述符限制，防止开进程开到一定数目之后报错

Siege输出结果

** SIEGE 2.72 ** Preparing 300 concurrent users for battle. The server is now under siege.. done. Transactions: 30000 hits #完成30000次处理 Availability: 100.00 % #成功率 Elapsed time: 68.59 secs #总共使用时间 Data transferred: 817.76 MB #共数据传输 817.76 MB Response time: 0.04 secs #响应时间，显示网络连接的速度 Transaction rate: 437.38 trans/sec #平均每秒完成 437.38 次处理 Throughput: 11.92 MB/sec #平均每秒传送数据 Concurrency: 17.53 #实际并发连接数，代码里对这个的实现是根据每个线程的执行时间只和/压测的时间来计算 Successful transactions: 30000 #成功处理次数 Failed transactions: 0 #失败处理次数 Longest transaction: 3.12 #每次传输所花最长时间 Shortest transaction: 0.00 #每次传输所花最短时间

然而在压测的过程中总是遇到一些问题，当设置的压测线程很大的时候，实际统计输出的执行线程数输出往往小很多，总感觉压不起来的样子（这里可能是由于之前siege代码里面有个bug（同事发现），导致tcp设置非阻塞不起作用，单纯的通过加大线程加大并发反而会线程切换过多导致效率降低），现在我们来看下代码，分析下

siege的实现


核心数据结构

CREW_T，在程序中所有线程共用的这样一个结构体实例，通过锁和信号量控制每个线程串行修改和获取压测任务

struct CREW_T { int size; //目标并发数目，即压测线程个数 int maxsize; //最大并发数目，即压测线程个数 int cursize; //目前的可用并发数（压测任务可用数），添加一个压测任务时+1，压测线程取出任务进行压测时-1 int total; //实际启动的并发数 WORK *head; //压测任务链表头部 WORK *tail; //压测任务链表尾部 BOOLEAN block; //当已经达到最大并发时，则不准再添加新的压测线程 BOOLEAN closed; //压测线程是否已经关闭 BOOLEAN shutdown; //压测线程是否应该停止了 pthread_t *threads; //长度为size的数组，存储线程号 pthread_mutex_t lock;//修改本结构体都要先加锁 pthread_cond_t not_empty; //用于表示cursize不为0（即压测任务不为0）的条件，主要用于唤醒线程 pthread_cond_t not_full; //用于表示cursize不等于maxsize的条件，用于通知可以添加新的压测任务 pthread_cond_t empty; //用于表示cursize等于0的条件，最后等待线程终止的信号 };

CREW的存储的压测链表结构体WORD,压测时，线程从获取到结构体的函数指针和相应参数即可执行

typedef struct work { void (*routine)();//函数指针 void *arg;//执行参数 struct work *next; } WORK;

每个线程分别维护的BROWSER_T结构体，存储压测url数组，存储该线程压测数据的统计结果

struct BROWSER_T { int id;//线程编号 从0——n-1 ARRAY urls;//压测需要访问的url列表 //统计数据变量等 ...... };

核心代码简析

我们首先来看mian函数，整个框架也不太复杂，就是初始化，设置线程，等待回收线程，收集结果。其中线程的控制是我们比较需要注意的地方 main函数： int main(int argc, char *argv[]) { ...... __signal_setup();//初始化信号 __config_setup(argc, argv);//读取配置文件，根据输入指令进行初始化 lines = __urls_setup();//初始化存储压测的url结构体LINES //设置线程属性 //初始化存储需要压测任务结构体BROWSER，存储压测所需url //初始化线程公共的CREW结构体，创建n个压测线程,这时候，每个压测线程都阻塞等待not_empty信号，直至下面添加压测任务的时候not_empty信号广播，压测才真正执行 if ((crew = new_crew(my.cusers, my.cusers, FALSE)) == NULL) { NOTIFY(FATAL, "unable to allocate memory for %d simulated browser", my.cusers); } //创建控制线程，等待计时线程的终止信号，收到信号终止正在压测的线程 if ((result = pthread_create(&cease, NULL, (void*)sig_handler, (void*)crew)) < 0) { NOTIFY(FATAL, "failed to create handler: %d\n", result); } if (my.secs > 0) { //创建计时线程，到达指定时间发送信号通知控制线程终止任务 if ((result = pthread_create(&timer, NULL, (void*)siege_timer, (void*)cease)) < 0) { NOTIFY(FATAL, "failed to create handler: %d\n", result); } } ...... //初始化最后的结果统计结构体 data = new_data(); data_set_start(data); //添加压测任务到crew的word链表里面，cursize=0时发送not_empty信号，每增加一个任务，cursize的值加一 for (i = 0; i < my.cusers && crew_get_shutdown(crew) != TRUE; i++) { BROWSER B = (BROWSER)array_get(browsers, i); result = crew_add(crew, (void*)start, B); if (result == FALSE) { my.verbose = FALSE; fprintf(stderr, "Unable to spawn additional threads; you may need to\n"); fprintf(stderr, "upgrade your libraries or tune your system in order\n"); fprintf(stderr, "to exceed %d users.\n", my.cusers); NOTIFY(FATAL, "system resources exhausted"); } } //等待压测线程执行完毕，等待CREW的cursize为0以及empty信号 crew_join(crew, TRUE, &status); data_set_stop(data); //统计结果信息 ...... //释放内存,退出 ...... } /* end of int main **/ new_crew函数，n个压测线程的初始化，以及初始化信号和互斥锁，在这里压测线程就已经都建立成功了，然后都循环等到not_empty信号来触发执行。 CREW new_crew(int size, int maxsize, BOOLEAN block) { int x; int c; CREW this; //分配内存 if ((this = calloc(sizeof(*this),1)) == NULL) return NULL; if ((this->threads = (pthread_t *)malloc(sizeof(pthread_t)*size)) == NULL) return NULL; this->size = size; this->maxsize = maxsize; this->cursize = 0;//刚开始可用压测数量为0，使得n个初始化的线程先阻塞在循环等待not_empty信号处 this->total = 0; this->block = block; this->head = NULL; this->tail = NULL; this->closed = FALSE; this->shutdown = FALSE; //初始化锁和条件变量 if ((c = pthread_mutex_init(&(this->lock), NULL)) != 0) return NULL; if ((c = pthread_cond_init(&(this->not_empty), NULL)) != 0) return NULL; if ((c = pthread_cond_init(&(this->not_full), NULL)) != 0) return NULL; if ((c = pthread_cond_init(&(this->empty), NULL)) != 0) return NULL; //创建n个压测线程 for (x = 0; x != size; x++) { if ((c = pthread_create(&(this->threads[x]), NULL, crew_thread, (void *)this)) != 0) { switch (errno) { case EINVAL: { NOTIFY(ERROR, "Error creating additional threads %s:%d", __FILE__, __LINE__); break; } case EPERM: { NOTIFY(ERROR, "Inadequate permission to create pool %s:%d", __FILE__, __LINE__); break; } case EAGAIN: { NOTIFY(ERROR, "Inadequate resources to create pool %s:%d", __FILE__, __LINE__); break; } case ENOMEM: { NOTIFY(ERROR, "Exceeded thread limit for this system %s:%d", __FILE__, __LINE__); break; } default: { NOTIFY(ERROR, "Unknown error building thread pool %s:%d", __FILE__, __LINE__); break; } } return NULL; } } return this; } crew_thread线程的执行函数，简单来说就是当cursize=0时等待not_empty信号执行压测任务cursize–，当cursize=maxsize的时候发送not_full信号，cursize– private void *crew_thread(void *crew) { int c; WORK *workptr; CREW this = (CREW)crew; while (TRUE) { //获取锁 if ((c = pthread_mutex_lock(&(this->lock))) != 0) { NOTIFY(FATAL, "mutex lock"); } // 如果目前可用并发数cursize是空的，则等待。刚开始的时候所有线程停留在此处。 while ((this->cursize == 0) && (!this->shutdown)) { //先解锁，使得所有线程进入等待信号，获取到信号的线程再加锁，保证每次只有一个线程修改CREW对象 if ((c = pthread_cond_wait(&(this->not_empty), &(this->lock))) != 0) NOTIFY(FATAL, "pthread wait"); } // 线程停止，则释放锁，退出 if (this->shutdown == TRUE) { if ((c = pthread_mutex_unlock(&(this->lock))) != 0) { NOTIFY(FATAL, "mutex unlock"); } pthread_exit(NULL); } //从链表里面取出压测程序 workptr = this->head; //修改CREW结构体，cursize-1，链表头指针偏移到下一位 this->cursize--; if (this->cursize == 0) { this->head = this->tail = NULL; } else { this->head = workptr->next; } //如果已经达到了最大并发量，并且设置了此时不允许添加新线程的参数，发送nit_full信号，不允许新建线程 if ((this->block) && (this->cursize == (this->maxsize - 1))) { if ((c = pthread_cond_broadcast(&(this->not_full))) != 0) { NOTIFY(FATAL, "pthread broadcast"); } } //现在并发量如果为0，唤醒empty condition if (this->cursize == 0) { if ((c = pthread_cond_signal(&(this->empty))) != 0){ NOTIFY(FATAL, "pthread signal"); } } //解锁 if ((c = pthread_mutex_unlock(&(this->lock))) != 0) { NOTIFY(FATAL, "pthread unlock"); } //执行压测函数 (*(workptr->routine))(workptr->arg); xfree(workptr); } return(NULL); } crew_add函数，添加压测任务到crew的word链表里面，cursize=0时发送not_empty信号，每增加一个任务，cursize的值加一，当cursize=maxsize的时候等待not_full信号再继续添加，cursize值加一 BOOLEAN crew_add(CREW crew, void (*routine)(), void *arg) { int c; WORK *workptr; //加锁 if ((c = pthread_mutex_lock(&(crew->lock))) != 0) { NOTIFY(FATAL, "pthread lock"); } //如果已经达到最大线程数并且不允许新增新线程，退出 if ((crew->cursize == crew->maxsize) && !crew->block) { if ((c = pthread_mutex_unlock(&(crew->lock))) != 0) { NOTIFY(FATAL, "pthread unlock"); } return FALSE; } //如果已经达到最大线程数，但是还允许执行的情况下，等待not_full信号添加新的压测任务 while ((crew->cursize == crew->maxsize ) && (!(crew->shutdown || crew->closed))) { if ((c = pthread_cond_wait(&(crew->not_full), &(crew->lock))) != 0) { NOTIFY(FATAL, "pthread wait"); } } if (crew->shutdown || crew->closed) { if ((c = pthread_mutex_unlock(&(crew->lock))) != 0) { NOTIFY(FATAL, "pthread unlock"); } return FALSE; } if ((workptr = (WORK *)malloc(sizeof(WORK))) == NULL) { NOTIFY(FATAL, "out of memory"); } workptr->routine = routine; workptr->arg = arg; workptr->next = NULL; //将压测任务添加到CREW的任务列表里面，如果CREW的cursize的当前执行线程数为0则发送not_empty信号，唤醒线程竞争锁，执行压测任务 if (crew->cursize == 0) { crew->tail = crew->head = workptr; if ((c = pthread_cond_broadcast(&(crew->not_empty))) != 0) { NOTIFY(FATAL, "pthread signal"); } } else { crew->tail->next = workptr; crew->tail = workptr; } crew->cursize++; crew->total ++; if ((c = pthread_mutex_unlock(&(crew->lock))) != 0) { NOTIFY(FATAL, "pthread unlock"); } return TRUE; } start函数，真正的压测函数，选取需要执行的url并请求，具体的http，https和ftp的实现这次没有详细说明，有兴趣的可以看看实现，对自己代码编写会有不少帮助 void * start(BROWSER this) { //进行初始化 ...... /** * 根据每个线程的需要执行数量，选择url进行调用和解析返回结果 */ for (x = 0; x < len; x++, y++) { URL tmp = array_get(this->urls, y); if (tmp != NULL && url_get_hostname(tmp) != NULL) { this->auth.bids.www = 0; /* reset */ //调用所选择的url if ((ret = __request(this, tmp))==FALSE) { __increment_failures(); } } //这里判断请求与请求之间是否需要间隔，如果有则线程先睡眠一段时间，一般来说进行压测都是不需要间隔的 if (my.delay >= 1) { pthread_sleep_np( (unsigned int) (((double)pthread_rand_np(&(this->rseed)) / ((double)RAND_MAX + 1) * my.delay ) + .5) ); } else if (my.delay >= .001) { pthread_usleep_np( (unsigned int) (((double)pthread_rand_np(&(this->rseed)) / ((double)RAND_MAX + 1) * my.delay * 1000000 ) + .0005) ); } //进行清理，退出 return NULL; } crew_join回收线程函数。结束的时候，当cursize不为0的时候，循环等待empty信号，empty信号只有在计时进程到时间 控制进程强制结束才发，等待empty信号并且设置了等待时间。在等待到了empty信号或者等待超时并且此时设置了结束或者已经没有压测任务了，退出。 BOOLEAN crew_join(CREW crew, BOOLEAN finish, void **payload) { //获取锁，设置变量 //当cursize不为0的时候，循环计时等待empty信号 if (finish == TRUE) { while ((crew->cursize != 0) && (!crew->shutdown)) { int rc; struct timespec ts; struct timeval tp; rc = gettimeofday(&tp,NULL); if( rc != 0 ) perror("gettimeofday"); ts.tv_sec = tp.tv_sec+60; ts.tv_nsec = tp.tv_usec*1000; rc = pthread_cond_timedwait(&(crew->empty), &(crew->lock), &ts); if (rc==ETIMEDOUT) { pthread_mutex_unlock(&crew->lock); } if (rc != 0) { NOTIFY(FATAL, "pthread wait"); } } } //设置关闭，释放锁，广播not_empty，not_full，empty信号 return TRUE; }

总结

总而言之，siege是一个非常方便的压测工具，支持http，https和ftp协议，提供了很全面的压测功能。 但是因为siege的线程控制主要是通过锁和信号来进行，线程执行压测任务时，需要先抢到锁，获取到压测任务。有n个压测线程相互竞争锁。siege的算并发数的算法为：所有线程的执行时间只和/压测总时间 ，每个线程开始工作时间不统一，压测的总时间的计算其实也不是很准确，这样子肯定算出来会比实际小。如果真的需要使用siege进行高并发，高精准的压测任务，还是需要好好读下代码并且进行适当的修改。