最近在做一个性能要求较高的项目，有个服务器需要处理每秒2万个udp包，每个包内有40个元素（当然这是高峰期）。服务器需要一个链表，算法中有个逻辑要把每个元素添加到链表末尾（只是这个元素对象的指针，不存在对象复制的问题），再从链表中把这些元素取出（另一个时间点）。就是一个单线程在做这件事。
既然逻辑这么简单，我自然选用了C++的标准STL容器List（Linux GNU），想来如此简单的事情，不过是一次末尾插入，一次头部取出而已，就用STL的List容器吧。没有想到这是痛苦的开始。我预想中每秒处理80万元素应该是很轻松写意的，没想到每秒一千个包时服务器就顶不住了，处理算法的线程占用CPU达到百分之百，大量的包得不到及时处理而超时。由于算法较为复杂，定位这问题耗了不少时间，终于感觉到LIST容器似乎有严重性能问题。
于是干脆自己写了个简单的链表，替代了STL的容器后性能有了极大的提升。为此我特意写了个简单的程序，大致模仿我算法中的场景，程序流程如下：
每3秒中向链表中插入N个元素（指针），再把这N个元素从链表中取出释放。之后查看耗时t，如果t小于3秒，就sleep(3-t)秒，并打印出睡眠的时间。
在我的测试机上，出现了差异很大的测试结果，大约每3秒测试2万个元素时，使用STL LIST的压力程序导致CPU已经达到70%了，而使用自己写的简单链表几乎没有感觉。直到每3秒测试2000万个元素时，才导致CPU占用80%。结果有一千倍的差距！这里没有对象的复制，我插入链表的都只是指针而已！（下面附测试程序，这里只是对比两种list的性能，所以我想机器的参数并不重要，大家随意找台Linux机器用下述代码执行下就可对比出。）
#include <list>
#include <sys/time.h>
#include <iostream>
using namespace std;
//待测试的对象，链表中的每个元素就是对象A的指针
class A {};
//每3秒钟插入链表末尾/从链表首部取出的元素个数
int testPressureNum = 40000;
//测试的STL链表
list<A*> testList;
//自己写的链表
typedef struct
{
A* p;
void* prev;
void* next;
} SelfListElement;
SelfListElement* myListHead;
SelfListElement* myListTail;
int myListSize;
//向自己写的链表首部添加元素
bool add(A* packet)
{
SelfListElement* ele = new SelfListElement;
ele->p = packet;
myListSize++;
if (myListHead == NULL)
{
myListHead = myListTail = ele;
ele->prev = NULL;
ele->next = NULL;
return true;
}
ele->next = myListHead;
myListHead->prev = ele;
ele->prev = NULL;
myListHead = ele;
return true;
}
// 从自己写的链表尾部取出元素
SelfListElement* get()
{
if (myListTail == NULL)
return NULL;
myListSize--;
SelfListElement* p = myListTail;
if (myListTail->prev == NULL)
{
myListHead = myListTail = NULL;
}
else
{
myListTail = (SelfListElement*)myListTail->prev;
myListTail->next = NULL;
}
return p;
}
//从STL链表中取出元素并删除
void testDelete1()
{
while (testList.size() > 0)
{
A* p = testList.back();
testList.pop_back();
delete p;
p = NULL;
}
}
//从简单链表中取出元素并删除
void testDelete2()
{
do {
SelfListElement* packet = myListTail;
if (packet == NULL)
break;
packet = get();
delete packet->p;
delete packet;
packet = NULL;
} while (true);
}
//向Stl链表中添加元素
void testAdd1()
{
for (int i = 0; i < testPressureNum; i++)
{
A* p = new A();
testList.push_front(p);
}
}
//向简单链表中添加元素
void testAdd2()
{
for (int i = 0; i < testPressureNum; i++)
{
A* p = new A();
add(p);
}
}
void printUsage(int argc, char**argv)
{
cout<<"usage: "<<argv[0]<<" [1|2] [oneRoundPressueNum]"<<endl
<<"1 means STL, 2 means simple list\noneRoundPressueNum means in 3 seconds how many elements add/del in list"<<endl;
}
int main(int argc, char** argv)
{
//为方便测试可使用2个参数
if (argc < 2)
{
printUsage(argc, argv);
return -1;
}
int type = atoi(argv[1]);
if (type != 1 && type != 2)
{
printUsage(argc, argv);
return -2;
}
if (argc >= 2)
testPressureNum = atoi(argv[2]);
cout<<"every 3 seconds add/del element number is "<<testPressureNum<<endl;
struct timeval time1, time2;
gettimeofday(&time1, NULL);
while (true)
{
gettimeofday(&time1, NULL);
if (type == 1)
{
testAdd1();
cout<<"stl list has "<<testList.size()<<" elements"<<endl;
}
else
{
testAdd2();
cout<<"my list has "<<myListSize<<" elements"<<endl;
}
//每3秒一个周期
gettimeofday(&time2, NULL);
unsigned long interval = 1000000*(time2.tv_sec-time1.tv_sec)+
time2.tv_usec-time1.tv_usec;
if (interval < 3000000)
{
cout<<"after add sleep "<<3000000-interval<<" usec"<<endl;
usleep(3000000-interval);
}
else
cout<<"add cost time too much"<<interval<<endl;
gettimeofday(&time1, NULL);
if (type == 1)
{
testDelete1();
cout<<"stl list has "<<testList.size()<<" elements"<<endl;
}
else
{
testDelete2();
cout<<"my list has "<<myListSize<<" elements"<<endl;
}
//每3秒一个周期
gettimeofday(&time2, NULL);
interval = 1000000*(time2.tv_sec-time1.tv_sec)+
time2.tv_usec-time1.tv_usec;
if (interval < 3000000)
{
cout<<"after delete sleep "<<3000000-interval<<" usec"<<endl;
usleep(3000000-interval);
}
else
cout<<"delete cost time too much"<<interval<<endl;
}
return 0;
}
一千倍的性能差距太夸张了。究竟是什么原因导致STL性能这么差呢？修改上面的测试代码，分别在testAdd和 testDelete中加时间点，结果发现，自己写的插入删除耗时相差不大，然而STL就差距极大了，下面列下我机器上测试得到的结果。
使用STL LIST的结果：
[root@AT-HOUYIDEV-AG]$./test 1 30000
every 3 seconds add/del element number is 30000
stl list has 30000 elements
after add sleep 2993282 usec
stl list has 0 elements
delete cost time too much3290628
stl list has 30000 elements
after add sleep 2996936 usec
stl list has 0 elements
delete cost time too much3273876
使用自写LIST的结果：
[root@AT-HOUYIDEV-AG]$./test 2 20000000
every 3 seconds add/del element number is 20000000
my list has 20000000 elements
after add sleep 1222930 usec
my list has 0 elements
after delete sleep 2187505 usec
my list has 20000000 elements
after add sleep 2064313 usec
my list has 0 elements
after delete sleep 2187214 usec
可以看到，
STL最大问题在于删除，LIST的插入还是算快的，但是删除就非常之慢了。测试同样多的元素时，两者消耗的内存也是相近的！为什么CPU消耗差这么多呢？
随便下了个sgi STL 3.3的源码，可以看到从LIST头尾删除元素的方法最终都是调用erase方法：
void pop_front() { erase(begin()); }
void pop_back() {
iterator __tmp = end();
erase(--__tmp);
}
那么erase又干了些什么呢？
iterator erase(iterator __position) {
_List_node_base* __next_node = __position._M_node->_M_next;
_List_node_base* __prev_node = __position._M_node->_M_prev;
_Node* __n = (_Node*) __position._M_node;
__prev_node->_M_next = __next_node;
__next_node->_M_prev = __prev_node;
_Destroy(&__n->_M_data);
_M_put_node(__n);
return iterator((_Node*) __next_node);
}
看来耗CPU确实是因为LIST在删除元素时做了太多事，特别是为迭代器做了太多事！我仅仅只是从链表中删除一个8字节的指针而已，就消耗了这么多的CPU！如果不编写服务器，或者服务器性能要求不高，到是可以用STL的LIST，否则，真是得不偿失啊！如果只是简单需要LIST的功能，还是自己写个吧，层层封装的STL试图使程序员使用简单，试图满足最广泛的程序员，但性能确实很糟糕！
为什么插入相对快很多呢？两个插入头尾的方法如下：
void push_front(const _Tp& __x) { insert(begin(), __x); }
void push_front() {insert(begin());}
void push_back(const _Tp& __x) { insert(end(), __x); }
void push_back() {insert(end());}
其中insert方法是这样的：
iterator insert(iterator __position, const _Tp& __x) {
_Node* __tmp = _M_create_node(__x);
__tmp->_M_next = __position._M_node;
__tmp->_M_prev = __position._M_node->_M_prev;
__position._M_node->_M_prev->_M_next = __tmp;
__position._M_node->_M_prev = __tmp;
return __tmp;
}
插入时只是简单分配了个Node，并没有做迭代器的修改。
