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_--;
    }
}