在最近的项目中,使用了大量的boost::shared_ptr。在游戏服务器中,有时候同一数据块要发送给不同的连接(例如A玩家的一个行走消息包要发给所有附近的玩家),如果为每个连接都拷贝一份数据,显的代价比较大且难以维护,想想发送完数据之后还要释放这些数据块,极易出错,而且性能也不佳。使用智能指针,只需要一份数据块的拷贝,并且不需要去管理内存的释放。但这几天,我又在想,boost::shared_ptr号称是线程安全的,那么在低层维护对象的引用计数时,必定有加琐/解琐。如果频繁的对智能指针进行复制,性能开销也不能忽略。我现在对boost的线程库使用还不是很熟练,网上查了一下,shared_ptr好像是通过Boost.Thread的mutex对象来保护引用计数,如果真是这样,那么我推断:在windows上使用shared_ptr,性能肯定没有直接使用windows api来进行同步的智能指针性能高。基于这样的猜测,我自己写了一些简单的智能指针,通过windows api Interlocked系列函数来维护智能指针引用计数。大概代码如下:
#ifndef AUTOPTR_H_INCLUDED
#define AUTOPTR_H_INCLUDED
#include <windows.h>
template<typename T>
class AutoPtr
{
public:
AutoPtr(void)
: _ptr(0), _refCount(0)
{ }
explicit AutoPtr(T *ptr)
: _ptr(ptr)
{
_refCount = new long(1);
}
AutoPtr(const AutoPtr &rhs)
: _ptr(rhs._ptr), _refCount(rhs._refCount)
{
if (_ptr && _refCount)
::InterlockedIncrement(_refCount); // 引用计数加1
}
~AutoPtr(void)
{
if (!_ptr)
return;
long refCount = ::InterlockedExchangeAdd(_refCount, -1);
if (refCount == 1)
{
delete _refCount;
delete _ptr;
}
}
T &operator*(void)
{
return *_ptr;
}
const T&operator*(void) const
{
return *_ptr;
}
T *operator->(void)
{
return _ptr;
}
const T*operator->(void) const
{
return _ptr;
}
const AutoPtr &operator=(const AutoPtr &rhs);
// T *get(void)
// {
// return _ptr;
// }
//
// const T *get(void) const
// {
// return _ptr;
// }
//
// T *release(void)
// {
//
// }
//
// void reset(T *ptr)
// {
//
// }
private:
T *_ptr;
long *_refCount;
};
template<typename T>
const AutoPtr<T> &AutoPtr<T>::operator=(const AutoPtr &rhs)
{
if (_ptr)
{
long refCount = ::InterlockedExchangeAdd(_refCount, -1);
if (refCount == 1)
{
delete _refCount;
delete _ptr;
}
}
_ptr = rhs._ptr;
_refCount = rhs._refCount;
if (_refCount)
::InterlockedIncrement(_refCount);
return *this;
}
#endif // AUTOPTR_H_INCLUDED
并写了一个简单的测试程序,用来对比自己写的AutoPtr,boost::shared_ptr,std::tr1::shared_ptr。测试代码如下:
int main(int argc, char *argv[])
{
AutoPtr<int> intPtr1(new int(0));
time_t beg1 = clock();
for (int i = 0; i < 10000000; ++i)
{
AutoPtr<int> tmp = intPtr1;
++(*tmp);
}
time_t end1 = clock();
std::cout << "AutoPtr cost: " << end1 - beg1 << ", Result: " << *intPtr1 << std::endl;
boost::shared_ptr<int> intPtr2(new int(0));
time_t beg2 = clock();
for (int i = 0; i < 10000000; ++i)
{
boost::shared_ptr<int> tmp = intPtr2;
++(*tmp);
}
time_t end2 = clock();
std::cout << "boost::shared_ptr cost:" << end2 - beg2 << ", Result: " << *intPtr2 << std::endl;
std::tr1::shared_ptr<int> intPtr3(new int(0));
time_t beg3 = clock();
for (int i = 0; i < 10000000; ++i)
{
std::tr1::shared_ptr<int> tmp = intPtr3;
++(*tmp);
}
time_t end3 = clock();
std::cout << "std::tr1::shared_ptr cost:" << end3 - beg3 << ", Result: " << *intPtr3 << std::endl;
return 0;
}
结果出乎我的意料:
在VC9下的结果为:
在gcc4.4.2下的结果:
结果表明,boost:;shared_ptr的性能并没有我想像是的那么差,在vc9下,三种智能指针的性能在同一水平上;而在gcc4.4.2下,boost::shared_ptr与AutoPtr性能相近,但与tr1版本的shared_ptr相差一个数量级。