前端服务器框架---EPOLL+线程池

基于EPOLL+多进程+线程池的server框架设想

最近，看了几个开源代码的server框架，有了一些自己的想法，把它记下来。

针对server要求高性能的同时还需要稳定性的特点，有了这样一个构思，建立一个EPOLL+多进程+线程池的server框架，暂且叫它emptyServer(e:epoll,m:muti,p:process,t:thread,y:ycc.哈哈)。

考虑的出发点如下：

(1)     为什么用epoll？

众所周知的原因，这里就不多说了。

(2)     为什么使用多进程模型？

在emptyServer框架中，多进程的想法来源于apache和lighttpd。它的作用是多个进程共享监听socket，当有连接过来时，唤醒其中一个进程处理，这样可以保证了emptyServer的稳定性，又可以提高emptyServer的处理能力。

也许，大家会想，这不就会引起“惊群”问题了吗？linux2.4以后的内核版本，已经解决了“惊群”问题，所以不需要担心“惊群”影响性能。

注：“惊群”问题，多进程共享监听socket，当有请求过来时，系统会唤醒所有的进程，从而造成系统颠簸使性能严重下降。

(3)     为什么要使用线程池？

线程池的作用：线程处理具体的逻辑，不参与主线程的网络IO，通过socketpair与主线程交互。

使用线程是基于以下的考虑：

1)       对于耗时比较长的逻辑，如数据库访问、复杂数值计算等，如果不启用另外的线程处理，主线程就会把时间都花在处理逻辑上，就会影响网络IO的处理和其它请求的逻辑处理，从而影响整体性能。

2)       现在的服务器基本上都是多核多cpu的，通过多线程，可以把线程映射到不同的cpu去执行，充分利用多核多cpu的处理能力。

线程池的技术背景

   在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务(不止一个不同的任务)就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。比如大家所熟悉的数据库连接池正是遵循这一思想而产生的，本文将介绍的线程池技术同样符合这一思想。

   目前，一些著名的大公司都特别看好这项技术，并早已经在他们的产品中应用该技术。比如IBM的WebSphere，IONA的Orbix 2000在SUN的 Jini中，Microsoft的MTS（Microsoft Transaction Server 2.0），COM+等。

现在您是否也想在服务器程序应用该项技术?

 

线程池技术如何提高服务器程序的性能

   我所提到服务器程序是指能够接受客户请求并能处理请求的程序，而不只是指那些接受网络客户请求的网络服务器程序。

   多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。但如果对多线程应用不当，会增加对单个任务的处理时间。可以举一个简单的例子：

 

假设在一台服务器完成一项任务的时间为T

T1 创建线程的时间                                 

T2 在线程中执行任务的时间，包括线程间同步所需时间 

T3 线程销毁的时间                                 

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。

   可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例(在传统的多线程服务器模型中是这样实现的：一旦有个请求到达，就创建一个新的线程，由该线程执行任务，任务执行完毕之后，线程就退出。这就是"即时创建，即时销毁"的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数非常频繁，那么服务器就将处于一个不停的创建线程和销毁线程的状态。这笔开销是不可忽略的，尤其是线程执行的时间非常非常短的情况。)。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

   线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段(在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中。这些线程都是处于阻塞状态，这些线程只占一点内存，不占用CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源)，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

   线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。再看一个例子：

   假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。我们比较利用线程池技术和不利于线程池技术的服务器处理这些请求时所产生的线程总数。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目或者上限（以下简称线程池尺寸），而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池尺寸是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

简单线程池的实现

下面是一个简单线程池的实现, 它所使用的方案如下：

   1.程序启动之前，初始化线程池，此时线程池中没有任何线程, 需要调用addTask方法向线程池中添加任务;

   2.如果此时线程池有空闲(处于等待)的线程, 就不会创建新的线程, 这样就省去了T1, T3的时间;

   3.如果此时线程池中没有处于等待的线程(由于此时线程刚刚初始化, 此时线程池中肯定是没有处于等待状态的线程的)并且此时线程池中的线程数并没有达到阈值, 才创建并启动线程; 

   4.如果此时线程池中的线程数已经达到阈值, 那就只能等待现在还执行任务的线程, 等到其执行完其当前正在执行任务, 然后才从任务队列中将新任务取出然后执行;

 

线程池主要由两个文件组成, 一个threadpool.h头文件和一个threadpool.cpp源文件组成。源码中已有重要的注释，就不加以分析了。

[cpp] view plaincopyprint?

1. //ThreadPool设计  
2. void *thread_routine(void *args);  
3. class ThreadPool  
4. {  
5.     friend void *thread_routine(void *args);  
6. private:  
7.     //回调函数类型  
8.     typedef void *(*callback_t)(void *);  
9.     //任务结构体  
10.     struct task_t  
11.     {  
12.         callback_t run; //任务回调函数  
13.         void *args;     //任务函数参数  
14.     };  
15.   
16. public:  
17.     ThreadPool(int _maxThreads = 36, unsigned int _waitSeconds = 2);  
18.     ~ThreadPool();  
19.     //添加任务接口  
20.     void addTask(callback_t run, void *args);  
21.   
22. private:  
23.     void startTask();  
24.   
25. private:  
26.     Condition ready;                //任务准备就绪或线程池销毁通知  
27.     std::queue<task_t *> taskQueue; //任务队列  
28.   
29.     unsigned int maxThreads;        //线程池最多允许的线程数  
30.     unsigned int counter;           //线程池当前线程数  
31.     unsigned int idle;              //线程池空闲线程数  
32.     unsigned int waitSeconds;       //线程可以等待的秒数  
33.     bool         quit;              //线程池销毁标志  
34. };  

[cpp] view plaincopyprint?

1. //构造函数  
2. ThreadPool::ThreadPool(int _maxThreads, unsigned int _waitSeconds)  
3.     : maxThreads(_maxThreads), counter(0), idle(0),  
4.       waitSeconds(_waitSeconds), quit(false) {}  

[cpp] view plaincopyprint?

1. // 线程入口函数  
2. // 这其实就相当于一个消费者线程, 不断的消费任务(执行任务)  
3. void *thread_routine(void *args)  
4. {  
5.     //将子线程设置成为分离状态, 这样主线程就可以不用jion  
6.     pthread_detach(pthread_self());  
7.     printf("*thread 0x%lx is starting...\n", (unsigned long)pthread_self());  
8.     ThreadPool *pool = (ThreadPool *)args;  
9.   
10.     //等待任务的到来, 然后执行任务  
11.     while (true)  
12.     {  
13.         bool timeout = false;  
14.   
15.         pool->ready.lock();  
16.         //当处于等待的时候, 则说明空闲的线程多了一个  
17.         ++ pool->idle;  
18.   
19.         //pool->ready中的条件变量有三个作用:  
20.         // 1.等待任务队列中有任务到来  
21.         // 2.等待线程池销毁通知  
22.         // 3.确保当等待超时的时候, 能够将线程销毁(线程退出)  
23.         while (pool->taskQueue.empty() && pool->quit == false)  
24.         {  
25.             printf("thread 0x%lx is waiting...\n", (unsigned long)pthread_self());  
26.             //等待waitSeconds  
27.             if (0 != pool->ready.timedwait(pool->waitSeconds))  
28.             {  
29.                 //如果等待超时  
30.                 printf("thread 0x%lx is wait timeout ...\n", (unsigned long)pthread_self());  
31.                 timeout = true;  
32.                 //break出循环, 继续向下执行, 会执行到下面第1个if处  
33.                 break;  
34.             }  
35.         }  
36.         //条件成熟(当等待结束), 线程开始执行任务或者是线程销毁, 则说明空闲线程又少了一个  
37.         -- pool->idle;  
38.   
39.         // 状态3.如果等待超时(一般此时任务队列已经空了)  
40.         if (timeout == true && pool->taskQueue.empty())  
41.         {  
42.             -- pool->counter;  
43.             //解锁然后跳出循环, 直接销毁线程(退出线程)  
44.             pool->ready.unlock();  
45.             break;  
46.         }  
47.   
48.         // 状态2.如果是等待到了线程的销毁通知, 且任务都执行完毕了  
49.         if (pool->quit == true && pool->taskQueue.empty())  
50.         {  
51.             -- pool->counter;  
52.             //如果没有线程了, 则给线程池发送通知  
53.             //告诉线程池, 池中已经没有线程了  
54.             if (pool->counter == 0)  
55.                 pool->ready.signal();  
56.             //解锁然后跳出循环  
57.             pool->ready.unlock();  
58.             break;  
59.         }  
60.   
61.         // 状态1.如果是有任务了, 则执行任务  
62.         if (!(pool->taskQueue.empty()))  
63.         {  
64.             //从队头取出任务进行处理  
65.             ThreadPool::task_t *t = pool->taskQueue.front();  
66.             pool->taskQueue.pop();  
67.   
68.             //执行任务需要一定的时间  
69.             //解锁以便于其他的生产者可以继续生产任务, 其他的消费者也可以消费任务  
70.             pool->ready.unlock();  
71.             //处理任务  
72.             t->run(t->args);  
73.             delete t;  
74.         }  
75.     }  
76.   
77.     //跳出循环之后, 打印退出信息, 然后销毁线程  
78.     printf("thread 0x%lx is exiting...\n", (unsigned long)pthread_self());  
79.     pthread_exit(NULL);  
80. }  

[cpp] view plaincopyprint?

1. //addTask函数  
2. //添加任务函数, 类似于一个生产者, 不断的将任务生成, 挂接到任务队列上, 等待消费者线程进行消费  
3. void ThreadPool::addTask(callback_t run, void *args)  
4. {  
5.     /** 1. 生成任务并将任务添加到"任务队列"队尾 **/  
6.     task_t *newTask = new task_t {run, args};  
7.   
8.     ready.lock();   //注意需要使用互斥量保护共享变量  
9.     taskQueue.push(newTask);  
10.   
11.     /** 2. 让线程开始执行任务 **/  
12.     startTask();  
13.     ready.unlock();//解锁以使任务开始执行  
14. }  

[cpp] view plaincopyprint?

1. //线程启动函数  
2. void ThreadPool::startTask()  
3. {  
4.     // 如果有等待线程, 则唤醒其中一个, 让它来执行任务  
5.     if (idle > 0)  
6.         ready.signal();  
7.     // 没有等待线程, 而且当前先线程总数尚未达到阈值, 我们就需要创建一个新的线程  
8.     else if (counter < maxThreads)  
9.     {  
10.         pthread_t tid;  
11.         pthread_create(&tid, NULL, thread_routine, this);  
12.         ++ counter;  
13.     }  
14. }  

[cpp] view plaincopyprint?

1. //析构函数  
2. ThreadPool::~ThreadPool()  
3. {  
4.     //如果已经调用过了, 则直接返回  
5.     if (quit == true)  
6.         return;  
7.   
8.     ready.lock();  
9.     quit = true;  
10.     if (counter > 0)  
11.     {  
12.         //对于处于等待状态, 则给他们发送通知,  
13.         //这些处于等待状态的线程, 则会接收到通知,  
14.         //然后直接退出  
15.         if (idle > 0)  
16.             ready.broadcast();  
17.   
18.         //对于正处于执行任务的线程, 他们接收不到这些通知,  
19.         //则需要等待他们执行完任务  
20.         while (counter > 0)  
21.             ready.wait();  
22.     }  
23.     ready.unlock();  
24. }  

完整源代码:http://download.csdn.net/download/hanqing280441589/8449049

 

关于高级线程池的探讨

   简单线程池存在一些问题，比如如果有大量的客户要求服务器为其服务，但由于线程池的工作线程是有限的，服务器只能为部分客户服务，其它客户提交的任务，只能在任务队列中等待处理。一些系统设计人员可能会不满这种状况，因为他们对服务器程序的响应时间要求比较严格，所以在系统设计时可能会怀疑线程池技术的可行性，但是线程池有相应的解决方案。调整优化线程池尺寸是高级线程池要解决的一个问题。主要有下列解决方案：

 

方案一：动态增加工作线程

   在一些高级线程池中一般提供一个可以动态改变的工作线程数目的功能，以适应突发性的请求。一旦请求变少了将逐步减少线程池中工作线程的数目。当然线程增加可以采用一种超前方式，即批量增加一批工作线程，而不是来一个请求才建立创建一个线程。批量创建是更加有效的方式。该方案还有应该限制线程池中工作线程数目的上限和下限。否则这种灵活的方式也就变成一种错误的方式或者灾难，因为频繁的创建线程或者短时间内产生大量的线程将会背离使用线程池原始初衷--减少创建线程的次数。

   举例：Jini中的TaskManager，就是一个精巧线程池管理器，它是动态增加工作线程的。SQL Server采用单进程(Single Process)多线程(Multi-Thread)的系统结构，1024个数量的线程池，动态线程分配，理论上限32767。

方案二：优化工作线程数目

   如果不想在线程池应用复杂的策略来保证工作线程数满足应用的要求，你就要根据统计学的原理来统计客户的请求数目，比如高峰时段平均一秒钟内有多少任务要求处理，并根据系统的承受能力及客户的忍受能力来平衡估计一个合理的线程池尺寸。线程池的尺寸确实很难确定，所以有时干脆用经验值。

   举例：在MTS中线程池的尺寸固定为100。 

方案三：一个服务器提供多个线程池

   在一些复杂的系统结构会采用这个方案。这样可以根据不同任务或者任务优先级来采用不同线程池处理。

   举例：COM+用到了多个线程池。

这三种方案各有优缺点。在不同应用中可能采用不同的方案或者干脆组合这三种方案来解决实际问题。

 

线程池技术适用范围及应注意的问题

下面是我总结的一些线程池应用范围,可能是不全面的。

线程池的应用范围：

   (1)需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

   (2)对性能要求苛刻的应用，比如要求服务器迅速相应客户请求。

   (3)接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，并出现"OutOfMemory"的错误。

 

结束语

   本文只是简单介绍线程池技术。可以看出线程池技术对于服务器程序的性能改善是显著的。线程池技术在服务器领域有着广泛的应用前景。希望这项技术能够应用到您的多线程服务程序中。

   注:这是网上一篇博客的改造: 将Java版本的线程池改造成了基于Linux 的C++版本, 原文链接为:http://www.ibm.com/developerworks/cn/java/l-threadPool/, 如果读者的兴趣所在为Java, 请移步于此, 向您郑重推荐, 这是一篇非常好的文章, 谢谢!