ACE消息队列

1    消息队列

ACE消息队列由三个部分组成：消息队列（ACE_Message_Queue）、消息块（ACE_Message_Block）、数据块（ACE_Data_Block）

 

1.1    ACE_Data_Block：通过计数器来决定数据块释放时是否被删除。只有计数器为0时，对象才会被删除。

1.1.1  构造函数：

ACE_Data_Block (size_t size,

                                ACE_Message_Block::ACE_Message_Type msg_type,

                                const char *msg_data,

                                ACE_Allocator *allocator_strategy,

                                ACE_Lock *locking_strategy,

                                ACE_Message_Block::Message_Flags flags,

                                ACE_Allocator *data_block_allocator)

可以由对象自己分配内存（msg_data=0），也可以由使用者分配内存（赋值给msg_data），ACE_Data_Block进行管理。

1.1.2  得到数据块指针：

char *base (void) const;

1.1.3  引用数据块：计算器加1

ACE_Data_Block *duplicate (void);

1.1.4  释放数据块：当计算器减1，当计数器变成0后，就销毁数据块。

ACE_Data_Block *release (ACE_Lock *lock = 0);

 

1.2    ACE_Message_Block：数据块的引用。由消息队列管理。

1.2.1  构造函数：

由数据块构造消息块：

ACE_Message_Block (ACE_Data_Block *data_block,

                     Message_Flags flags = 0,

                     ACE_Allocator *message_block_allocator = 0);

直接引用数据：

ACE_Message_Block (const char *data,

                                      size_t size,

                                      unsigned long priority)

 

ACE_Message_Block (size_t size,

                                      ACE_Message_Type msg_type,

                                      ACE_Message_Block *msg_cont,

                                      const char *msg_data,

                                      ACE_Allocator *allocator_strategy,

                                      ACE_Lock *locking_strategy,

                                      unsigned long priority,

                                      const ACE_Time_Value &execution_time,

                                      const ACE_Time_Value &deadline_time,

                                      ACE_Allocator *data_block_allocator,

                                      ACE_Allocator *message_block_allocator)

1.2.2  得到数据块指针：

ACE_Data_Block *data_block()

1.2.3  释放消息块：

ACE_Message_Block *release (void)

1.2.4   析构函数：

会调用内部数据块的release

ACE_Message_Block::~ACE_Message_Block (void)

{

  ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");

 

  if (ACE_BIT_DISABLED (this->flags_,

                        ACE_Message_Block::DONT_DELETE)&&

      this->data_block ())

    this->data_block ()->release ();

 

  this->prev_ = 0;

  this->next_ = 0;

  this->cont_ = 0;

}

 

 

1.3         ACE_Message_Queue：消息队列

1.3.1  入列

enqueue (ACE_Message_Block *new_item, ACE_Time_Value *timeout)

enqueue_head (ACE_Message_Block *new_item, ACE_Time_Value *timeout)

enqueue_tail (ACE_Message_Block *new_item, ACE_Time_Value *timeout)

 

1.3.2   出列

dequeue (ACE_Message_Block *&first_item, ACE_Time_Value *timeout = 0);

dequeue_head (ACE_Message_Block *&first_item, ACE_Time_Value *timeout = 0);

dequeue_tail (ACE_Message_Block *&dequeued, ACE_Time_Value *timeout = 0);

 

1.4         ACE_Task:封装了消息队列：

// For the following five method if @a timeout == 0, the caller will

  // block until action is possible, else will wait until the

  // <{absolute}> time specified in *@a timeout elapses).  These calls

  // will return, however, when queue is closed, deactivated, when a

  // signal occurs, or if the time specified in timeout elapses, (in

  // which case errno = EWOULDBLOCK).

 

  /// Insert message into the message queue.  Note that @a timeout uses

  /// <{absolute}> time rather than <{relative}> time.

  int putq (ACE_Message_Block *, ACE_Time_Value *timeout = 0);

 

  /**

   * Extract the first message from the queue (blocking).  Note that

   * @a timeout uses <{absolute}> time rather than <{relative}> time.

   * Returns number of items in queue if the call succeeds or -1 otherwise.

   */

  int getq (ACE_Message_Block *&mb, ACE_Time_Value *timeout = 0);

 

  /// Return a message to the queue.  Note that @a timeout uses

  /// <{absolute}> time rather than <{relative}> time.

  int ungetq (ACE_Message_Block *, ACE_Time_Value *timeout = 0);

 

  /**

   * Turn the message around, sending it in the opposite direction in

   * the stream. To do this, the message is put onto the task next in

   * the stream after this task's sibling.

   *

   * @param mb Pointer to the block that is used in the reply.

   * @param tv The absolute time at which the put operation used to

   *           send the message block to the next module in the stream

   *           will time out. If 0, this call blocks until it can be

   *           completed.

   */

  int reply (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);

 

  /**

   * Transfer message to the adjacent ACE_Task in a ACE_Stream.  Note

   * that @a timeout uses <{absolute}> time rather than <{relative}>

   * time.

   */

  int put_next (ACE_Message_Block *msg, ACE_Time_Value *timeout = 0);