ACE消息队列（转）

1    消息队列

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

 

 

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

1.1.1  构造函数：

 1 ACE_Data_Block (size_t size,
 2 
 3                                 ACE_Message_Block::ACE_Message_Type msg_type,
 4 
 5                                 const char *msg_data,
 6 
 7                                 ACE_Allocator *allocator_strategy,
 8 
 9                                 ACE_Lock *locking_strategy,
10 
11                                 ACE_Message_Block::Message_Flags flags,
12 
13                                 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);

 

直接引用数据：

 1 ACE_Message_Block (const char *data,
 2 
 3                                       size_t size,
 4 
 5                                       unsigned long priority)
 6 
 7  
 8 
 9 ACE_Message_Block (size_t size,
10 
11                                       ACE_Message_Type msg_type,
12 
13                                       ACE_Message_Block *msg_cont,
14 
15                                       const char *msg_data,
16 
17                                       ACE_Allocator *allocator_strategy,
18 
19                                       ACE_Lock *locking_strategy,
20 
21                                       unsigned long priority,
22 
23                                       const ACE_Time_Value &execution_time,
24 
25                                       const ACE_Time_Value &deadline_time,
26 
27                                       ACE_Allocator *data_block_allocator,
28 
29                                       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

 1 ACE_Message_Block::~ACE_Message_Block (void)
 2 
 3 {
 4 
 5   ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");
 6 
 7  
 8 
 9   if (ACE_BIT_DISABLED (this->flags_,
10 
11                         ACE_Message_Block::DONT_DELETE)&&
12 
13       this->data_block ())
14 
15     this->data_block ()->release ();
16 
17  
18 
19   this->prev_ = 0;
20 
21   this->next_ = 0;
22 
23   this->cont_ = 0;
24 
25 }

 

 

 

1.3         ACE_Message_Queue：消息队列

1.3.1  入列

1 enqueue (ACE_Message_Block *new_item, ACE_Time_Value *timeout)
2 
3 enqueue_head (ACE_Message_Block *new_item, ACE_Time_Value *timeout)
4 
5 enqueue_tail (ACE_Message_Block *new_item, ACE_Time_Value *timeout)

 

 

1.3.2   出列

1 dequeue (ACE_Message_Block *&first_item, ACE_Time_Value *timeout = 0);
2 
3 dequeue_head (ACE_Message_Block *&first_item, ACE_Time_Value *timeout = 0);
4 
5 dequeue_tail (ACE_Message_Block *&dequeued, ACE_Time_Value *timeout = 0);

 

 

1.4         ACE_Task:封装了消息队列：

 1 // For the following five method if @a timeout == 0, the caller will
 2 
 3   // block until action is possible, else will wait until the
 4 
 5   // <{absolute}> time specified in *@a timeout elapses).  These calls
 6 
 7   // will return, however, when queue is closed, deactivated, when a
 8 
 9   // signal occurs, or if the time specified in timeout elapses, (in
10 
11   // which case errno = EWOULDBLOCK).
12 
13  
14 
15   /// Insert message into the message queue.  Note that @a timeout uses
16 
17   /// <{absolute}> time rather than <{relative}> time.
18 
19   int putq (ACE_Message_Block *, ACE_Time_Value *timeout = 0);
20 
21  
22 
23   /**
24 
25    * Extract the first message from the queue (blocking).  Note that
26 
27    * @a timeout uses <{absolute}> time rather than <{relative}> time.
28 
29    * Returns number of items in queue if the call succeeds or -1 otherwise.
30 
31    */
32 
33   int getq (ACE_Message_Block *&mb, ACE_Time_Value *timeout = 0);
34 
35  
36 
37   /// Return a message to the queue.  Note that @a timeout uses
38 
39   /// <{absolute}> time rather than <{relative}> time.
40 
41   int ungetq (ACE_Message_Block *, ACE_Time_Value *timeout = 0);
42 
43  
44 
45   /**
46 
47    * Turn the message around, sending it in the opposite direction in
48 
49    * the stream. To do this, the message is put onto the task next in
50 
51    * the stream after this task's sibling.
52 
53    *
54 
55    * @param mb Pointer to the block that is used in the reply.
56 
57    * @param tv The absolute time at which the put operation used to
58 
59    *           send the message block to the next module in the stream
60 
61    *           will time out. If 0, this call blocks until it can be
62 
63    *           completed.
64 
65    */
66 
67   int reply (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
68 
69  
70 
71   /**
72 
73    * Transfer message to the adjacent ACE_Task in a ACE_Stream.  Note
74 
75    * that @a timeout uses <{absolute}> time rather than <{relative}>
76 
77    * time.
78 
79    */
80 
81   int put_next (ACE_Message_Block *msg, ACE_Time_Value *timeout = 0);

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

posted @ 2017-08-01 16:12  鸭子船长  阅读(715)  评论(0)  编辑  收藏  举报