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_tsize,
ACE_Message_Block::ACE_Message_Typemsg_type,
const char *msg_data,
ACE_Allocator *allocator_strategy,
ACE_Lock *locking_strategy,
ACE_Message_Block::Message_Flagsflags,
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 (constchar *data,
size_tsize,
unsignedlong priority)
ACE_Message_Block (size_tsize,
ACE_Message_Typemsg_type,
ACE_Message_Block *msg_cont,
const char *msg_data,
ACE_Allocator *allocator_strategy,
ACE_Lock *locking_strategy,
unsignedlong 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);