ACE内存分配器二

ACE_Free_List是一个空闲链表的接口

template <class T>　　　　//链表节点的类型
class ACE_Free_List
{
public:
virtual ~ACE_Free_List (void); //移除（释放）链表中的所有节点
virtual void add (T *element) = 0;　//把一个新节点添加到链表中，如果没有超出高水位线
virtual T *remove (void) = 0;　　//拿走一个节点，如果低于了低水位线，内部将回自动创建新的节点
virtual size_t size (void) = 0;　　//当前链表中的节点个数
virtual void resize (size_t newsize) = 0;//重修调整链表的节点数到指定的值
};

ACE_Locked_Free_List　实现一个线程安全的链表

template <class T, class ACE_LOCK>　　//节点类型和锁类型
class ACE_Locked_Free_List : public ACE_Free_List<T>
{

//这里有个限制，节点类型必须拥有2个方法get_next和set_next
public:
ACE_Locked_Free_List (int mode = ACE_FREE_LIST_WITH_POOL,　//操作类型
size_t prealloc = ACE_DEFAULT_FREE_LIST_PREALLOC,　//预创建节点数
size_t lwm = ACE_DEFAULT_FREE_LIST_LWM,　//低水位线
size_t hwm = ACE_DEFAULT_FREE_LIST_HWM,　//高水位线
size_t inc = ACE_DEFAULT_FREE_LIST_INC); //每次增加节点时，增加的节点数
virtual ~ACE_Locked_Free_List (void);
virtual void add (T *element);
virtual T *remove (void);
virtual size_t size (void);
virtual void resize (size_t newsize);

protected:
virtual void alloc (size_t n);　　//增加n个节点到链表中
virtual void dealloc (size_t n);　//从链表中释放n个节点
int mode_;
T *free_list_;　//指向链表的第一个节点
size_t lwm_;
size_t hwm_;
size_t inc_;
size_t size_;
ACE_LOCK mutex_;　//同步锁
}

在构造函数中必须指定链表的操作类型（mode成员变量），这里定义的有2个类型

# define ACE_FREE_LIST_WITH_POOL 1

所有的链表节点由链表在内部自动创建，并且负责释放这些节点

# define ACE_PURE_FREE_LIST 2

一个简单的链表，不负责任何节点的创建和释放

现在我们来看看各个函数的实现

template <class T, class ACE_LOCK>
ACE_Locked_Free_List<T, ACE_LOCK>::~ACE_Locked_Free_List (void)
{
if (this->mode_ != ACE_PURE_FREE_LIST)　//判断操作类型决定是否释放链表
while (this->free_list_ != 0) //循环释放每个节点
{
T *temp = this->free_list_;
this->free_list_ = this->free_list_->get_next ();
delete temp;
}
}

template <class T, class ACE_LOCK> void
ACE_Locked_Free_List<T, ACE_LOCK>::add (T *element)
{
ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));　　//同步，我们可以自己同过宏ACE_MT_SAFE来控制是否需要同步

//如果操作类型是ACE_PURE_FREE_LIST则把节点添加到链表中,否则我们就要判断当前的节点数是否超过了高水位线，如果超过了就释放该节点，否则就添加到链表中
if (this->mode_ == ACE_PURE_FREE_LIST　
|| this->size_ < this->hwm_)
{
element->set_next (this->free_list_);
this->free_list_ = element;
this->size_++;
}
else
delete element;
}

template <class T, class ACE_LOCK> T *
ACE_Locked_Free_List<T, ACE_LOCK>::remove (void)
{
ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0));

　//如果类型不是ACE_PURE_FREE_LIST ，且节点数低于水位线，则我们创建inc_个节点
if (this->mode_ != ACE_PURE_FREE_LIST && this->size_ <= this->lwm_)
this->alloc (this->inc_);
T *temp = this->free_list_;　//分配节点

if (temp != 0)
{
this->free_list_ = this->free_list_->get_next (); //更新头节点信息
this->size_--;
}

return temp;
}

template <class T, class ACE_LOCK> void
ACE_Locked_Free_List<T, ACE_LOCK>::resize (size_t newsize)
{
ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));
if (this->mode_ != ACE_PURE_FREE_LIST)　//判断是否进行调整，如果节点是链表自己创建的则进行节点数调整，增加或者释放相应的节点数

if (newsize < this->size_)
this->dealloc (this->size_ - newsize);
else
this->alloc (newsize - this->size_);
}

template <class T, class ACE_LOCK> void
ACE_Locked_Free_List<T, ACE_LOCK>::alloc (size_t n)
{
for (; n > 0; n--) //循环创建n个节点
{
T *temp = 0;
ACE_NEW (temp, T);
temp->set_next (this->free_list_);
this->free_list_ = temp;
this->size_++;
}
}

template <class T, class ACE_LOCK> void
ACE_Locked_Free_List<T, ACE_LOCK>::dealloc (size_t n)　//循环释放n个节点
{
for (; this->free_list_ != 0 && n > 0;
n--)
{
T *temp = this->free_list_;
this->free_list_ = this->free_list_->get_next ();
delete temp;
this->size_--;
}
}