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 = );

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

1.2.1  构造函数：

由数据块构造消息块：

ACE_Message_Block (ACE_Data_Block *data_block,

                 Message\_Flags flags = ,

                 ACE\_Allocator \*message\_block\_allocator = );

直接引用数据：

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

this->next_ = ;

this->cont_ = ;

}

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 = );

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

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

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 = );

/**

\* 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 = );

/// 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 = );

/**

\* 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 = );

/**

\* 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 = );

转自：http://blog.csdn.net/kl222/article/details/8159812