国产成人精品综合久久久,久久久久国产亚洲AV麻豆,久久精品国产亚洲77777

一��M��写情况下�Q�无锁环形队列如何实玎ͼ�

Kyee Ye — Sun, 22 May 2011 03:35:00 GMT

--------------------------------------------------------------------------------
标题: 一��M��写情况下�Q�无锁环形队列如何实玎ͼ�
作�? 叉��?br />日期: 2009.03.09
--------------------------------------------------------------------------------

无锁环�Ş队列的设计及�C�Z��Q�读写队列最大的应用是：(x��)一个线�E�收��C��件或消息后直�?br />加入到队列，而处理线�E�读取队列中的事件或消息�Q��ƈ加以处理。在�q�个模式中，有一个线
�E�负责写�Q�多个处理线�E�读自己的队列�ƈ处理。虽然看��h��象是一写多读，其实不然�Q�针�?br />某一事�g队列而言�Q�只有一个线�E�是写一个线�E�是诅R�?/p>

环�Ş一��M��写队列中�Q�不需要担心unsigned long溢出问题�Q�因为溢出后自动回归�Q�相�?br />��D��?x��)保留�?/p>

  1 �C�Z��一(注：(x��)Max_Count 必须�?nbsp;2 的指敎ͼ�卻I��(x��)2, 4, 8, 16)�Q?br />  2 
  3 // 队列���寸
  4 #define Max_Count    4096
  5 #define Max_Mask     4095     // = Max_Count - 1
  6 
  7 // 变量
  8 void*          List[Max_Count];
  9 unsigned long  Push_Count;
 10 unsigned long  Pop_Count;
 11 
 12 // 初始化队�?/span>
 13 void InitQueue()
 14 {
 15    Push_Count  = 0;
 16    Pop_Count   = 0;
 17    memset(List, 0, sizeof(List));
 18 }
 19 
 20 // 加入
 21 bool Push(void* AData)
 22 {
 23    if (Push_Count - Pop_Count < Max_Count)
 24    {
 25       List[Push_Count & Max_Mask] = AData;
 26       Push_Count++;
 27       return true;
 28    }
 29    else
 30       return false;
 31 }
 32 
 33 // 取出
 34 void* Pop()
 35 {
 36    // 初始�?/span>
 37    void* result = NULL;
 38 
 39    // 判断是否为空
 40    if (Push_Count != Pop_Count)
 41    {
 42       result = List[Pop_Count & Max_Mask];
 43       Pop_Count++;
 44    }
 45 
 46    // �q�回�l�果
 47    return result;
 48 }
 49 
 50 �C�Z���?注：(x��)Max_Count >= 2)�Q?br /> 51 
 52 // 队列���寸
 53 #define Max_Count    4096
 54 #define High_Index   4095     // = Max_Count - 1
 55 
 56 // 变量
 57 void*          List[Max_Count];
 58 unsigned long  Push_Count;
 59 unsigned long  Push_Index;
 60 unsigned long  Pop_Count;
 61 unsigned long  Pop_Index;
 62 
 63 // 初始化队�?/span>
 64 void InitQueue()
 65 {
 66    Push_Count  = 0;
 67    Push_Index  = 0;
 68    Pop_Count   = 0;
 69    Pop_Index   = 0;
 70    memset(List, 0, sizeof(List));
 71 }
 72 
 73 // 加入
 74 bool Push(void* AData)
 75 {
 76    if (Push_Count - Pop_Count < Max_Count)
 77    {
 78       List[Push_Index] = AData;
 79       Push_Count++;
 80       if (Push_Index == High_Index)
 81          Push_Index = 0;
 82       else
 83          Push_Index++;
 84 
 85       return true;
 86    }
 87    else
 88       return false;
 89 }
 90 
 91 // 取出
 92 void* Pop()
 93 {
 94    // 初始�?/span>
 95    void* result = NULL;
 96 
 97    // 判断是否为空
 98    if (Push_Count != Pop_Count)
 99    {
100       result = List[Pop_Index];
101       Pop_Count++;
102       if (Pop_Index == High_Index)
103          Pop_Index = 0;
104       else
105          Pop_Index++;
106    }
107 
108    // �q�回�l�果
109    return result;
110 }
111 

Kyee Ye 2011-05-22 11:35 发表评论

一��M��写情况下�Q�无锁队列如何实玎ͼ�

Kyee Ye — Sun, 22 May 2011 03:31:00 GMT

--------------------------------------------------------------------------------
标题: 一��M��写情况下�Q�无锁队列如何实玎ͼ�
作�? 叉��?br />日期: 2009.03.09
--------------------------------------------------------------------------------

一��M��写情况下�Q�无锁队列如何实玎ͼ�其实�q�不难，先说说一��M��写无锁队列的实际�?br />用吧。读写队列最大的应用是：(x��)一个线�E�收��C��件或消息后直接加入到队列�Q�而处理线�E�读
取队列中的事件或消息�Q��ƈ加以处理。在�q�个模式中，有一个线�E�负责写�Q�多个处理线�E�读
自己的队列�ƈ处理。虽然看��h��象是一写多读，其实不然�Q�针�Ҏ(gu��)��一事�g队列而言�Q�只有一
个线�E�是写一个线�E�是诅R�?/p>

此示例可以封装成一个Queue�c�，在KYLib中有TKYQueue�c�，其实现原理相同。代码示�?br />如下�Q?/p>

 1 // 链接数据��结�?/span>
 2 typedef struct TLinkItem
 3 {
 4    void*       Data;
 5    TLinkItem*  Next;
 6 } *PLinkItem;
 7 
 8 TLinkItem*     FLinkHead;        // 队列�?/span>
 9 TLinkItem*     FLinkTail;        // 队列��?br />10 
11 // 初始化队�?/span>
12 void InitQueue()
13 {
14    // 分配队列头项
15    FLinkTail = NULL;
16    FLinkHead = new TLinkItem;
17 
18    // 保证 Head �?nbsp;Tail 非空, 是一个线�E�读一个线�E�写的关�?
19    if (FLinkHead != NULL)
20    {
21       // 初始化队列头
22       FLinkHead->Data = NULL;
23       FLinkHead->Next = NULL;
24       FLinkTail       = FLinkHead;
25    }
26    else
27       throw;
28 }
29 
30 // 加入
31 bool Push(void* AData)
32 {
33    // 初始�?/span>
34    bool        result = false;
35    TLinkItem*  pItem  = new TLinkItem;
36 
37    // 加入队列
38    if (pItem != NULL)
39    {
40       // 写�?/span>
41       pItem->Data     = AData;
42       pItem->Next     = NULL;
43 
44       // 加到末尾
45       FLinkTail->Next = pItem;
46       FLinkTail       = pItem;
47 
48       // �q�回�l�果
49       result = true;
50    }
51 
52    // �q�回�l�果
53    return result;
54 }
55 
56 // 取出
57 void* Pop()
58 {
59    // 初始�?/span>
60    void* result = NULL;
61 
62    // ��d����?/span>
63    if (FLinkHead->Next != NULL)
64    {
65       // 取�?/span>
66       TLinkItem* pItem = FLinkHead;
67       FLinkHead        = FLinkHead->Next;
68       result           = FLinkHead->Data;
69 
70       // 释放��?/span>
71       delete pItem;
72    }
73 
74    // �q�回�l�果
75    return result;
76 }
77 

Kyee Ye 2011-05-22 11:31 发表评论

队列和事件的配合使用�C�Z��

Kyee Ye — Sun, 22 May 2011 03:08:00 GMT

--------------------------------------------------------------------------------
标题: 队列和事件的配合使用�C�Z��
作�? 叉��?br />日期: 2009.09.09
--------------------------------------------------------------------------------

一个线�E�收��C��件或消息后直接加入到队列�Q�而处理线�E�读取队列中的事件或消息�Q��ƈ
加以处理。在�q�个模式中，有一个线�E�负责写�Q�多个处理线�E�读自己的队列�ƈ处理。虽然看
��h��象是一写多读，其实不然�Q�针�Ҏ(gu��)��一事�g队列而言�Q�只有一个线�E�是写一个线�E�是诅R�?/p>

队列和事件的配合使用�C�Z��如下�Q?/p>

  1 /* �Ҏ(gu��)��一: 独立�U�程处理队列 */
  2 
  3 // �U�程执行�?/span>
  4 void TDealThread::Execute()
  5 {
  6    // 初始�?/span>
  7    Longword dwNo;
  8    Longword dwCount;
  9    TItem*   pItem;
 10 
 11    // �U�程循环�?/span>
 12    while (!Terminated())
 13    {
 14       // �{�待事�g
 15       FEvent->Wait(INFINITE);
 16 
 17       // 循环处理事�g��?/span>
 18       dwCount = FQueue->Count();
 19       for (dwNo = 0; !Terminated() && (dwNo < dwCount); dwNo++)
 20       {
 21          pItem = (TItem*)FQueue->Pop();
 22          if (pItem != NULL)
 23          {
 24             // 处理事�g��?br /> 25             // ???  
 26 
 27             // 释放��?/span>
 28             delete pItem;
 29          }
 30       }
 31    }
 32 }
 33 
 34 // ��d��事�g
 35 bool TDealThread::AddEvent(const TItem& AItem)
 36 {
 37    // 初始�?/span>
 38    bool result = false;
 39 
 40    // 判断�U�程是否未终�?/span>
 41    if (!Terminated())
 42    {
 43       // 初始�?/span>
 44       TItem* pItem;
 45 
 46       // 新徏��?/span>
 47       pItem  = new TItem;
 48       *pItem = AItem;
 49 
 50       // 加入队列
 51       if (FQueue->Push(pItem))
 52       {
 53          // 事�g�|�位
 54          FEvent->Set();
 55          result = true;
 56       }
 57       else
 58          delete pItem;
 59    }
 60 
 61    // �q�回�l�果
 62    return result;
 63 }
 64 
 65 // 关闭�U�程
 66 void TDealThread::Close()
 67 {
 68    // �|�终止标�?/span>
 69    Terminate();
 70    FEvent->Set();
 71 
 72    // 唤醒休眠�U�程
 73    if (!Finished() && Suspended())
 74       Resume();
 75 }
 76 
 77 /* �Ҏ(gu��)���? 外部�U�程处理 */
 78 
 79 // 外部�U�程取事�?/span>
 80 bool TOwnerObj::GetEvent(TItem& AItem, Longword ATimeout)
 81 {
 82    // 先取队列��?/span>
 83    bool result = GetItem(AItem);
 84 
 85    // 判断是否需要等�?/span>
 86    if (!result && (ATimeout != 0))
 87    {
 88       // 初始�?/span>
 89       Longword dwBegin = GetTickCount();
 90 
 91       // 循环�{�待事�g
 92       while (GetTickCount() - dwBegin < ATimeout)
 93       {
 94          // 防止其它多线�E�读取时信号取不�? 50 毫秒�{�待
 95          FEvent->Wait(50);
 96 
 97          // 取队列项
 98          if (GetItem(AItem))
 99          {
100             result = true;
101             break;
102          }
103       }
104    }
105 
106    // �q�回�l�果
107    return result;
108 }
109 
110 // ��d��事�g
111 bool TOwnerObj::AddEvent(const TItem& AItem)
112 {
113    // 初始�?/span>
114    bool   result = false;
115    TItem* pItem;
116 
117    // 新徏��?/span>
118    pItem  = new TItem;
119    *pItem = AItem;
120 
121    // 加入队列
122    if (FQueue->Push(pItem))
123    {
124       // 事�g�|�位
125       FEvent->Set();
126       result = true;
127    }
128    else
129       delete pItem;
130 
131    // �q�回�l�果
132    return result;
133 }
134 
135 // 取队列项
136 bool TOwnerObj::GetItem(TItem& AItem)
137 {
138    // 初始�?/span>
139    TItem* pItem;
140    bool   result = false;
141 
142    // 判断队列是否非空
143    while (FQueue->Count() != 0)
144    {
145       pItem = (TItem*)FQueue->Pop();
146       if (pItem != NULL)
147       {
148          AItem  = *pItem;
149          result = true;
150 
151          // 释放��?/span>
152          delete pItem;
153          break;
154       }
155    }
156 
157    // �q�回�l�果
158    return result;
159 }
160 

Kyee Ye 2011-05-22 11:08 发表评论

Kyee Ye — Sun, 22 May 2011 03:01:00 GMT

--------------------------------------------------------------------------------
标题: 如何使用�cȝ��成员�Ҏ(gu��)��指针�Q?br />作�? 叉��?br />日期: 2009.03.22
--------------------------------------------------------------------------------

其实�Q�类�Ҏ(gu��)��调用原理很简单，若知道如何��用C语言模拟�c�d��现就知道怎么回事了，�?br />是这个工作由�~�译器来做�Ş了。调用方法与调用函数的区别是在调用方法时�Q�编译器把当�?br />对象的指针当做第一个参��C��入，其它参数的传递与函数没有区别�Q�也��p��Q�这为提供回�?br />事�g的方法指针提供一条方便之门。方法指针不能滥用，用好它可以��你的视野更加开阔！

  1 /* TObject - 基类 */
  2 
  3 class TObject
  4 {
  5 };
  6 
  7 
  8 /* TDemoA - A �c?nbsp;*/
  9 
 10 class TDemoA
 11 {
 12 public:
 13    TDemoA();
 14    virtual ~TDemoA();
 15 
 16    void  AF1(void* AParam);
 17    void  AF2(const char* AStr, long AValue);
 18 
 19    // ???  
 20 };
 21 
 22 /* TDemoB - B �c?nbsp;*/
 23 
 24 class TDemoB
 25 {
 26 public:
 27    TDemoB();
 28    virtual ~TDemoB();
 29 
 30    void  BF1(void* AParam);
 31    void  BF2(const char* AStr, long AValue);
 32 
 33    // ???  
 34 };
 35 
 36 /* TDemoC - C �c?nbsp;*/
 37 
 38 class TDemoC
 39 {
 40 public:
 41    // TOnFunc1 事�g�c�d��
 42    typedef void (TObject::*TDoFunc1)(void* AParam);
 43    typedef struct
 44    {
 45       TDoFunc1          Method;
 46       void*             Object;
 47    } TOnFunc1;
 48 
 49    // TOnFunc2 事�g�c�d��
 50    typedef void (TObject::*TDoFunc2)(const char* AStr, long AValue);
 51    typedef struct
 52    {
 53       TDoFunc2          Method;
 54       void*             Object;
 55    } TOnFunc2;
 56 
 57 public:
 58    TDemoC();
 59    virtual ~TDemoC();
 60 
 61    // Func1
 62    void  Func1(void* AParam)
 63    {
 64       if (OnFunc1.Method != NULL)
 65          ((TObject*)OnFunc1.Object->*OnFunc1.Method)(AParam);
 66    }
 67 
 68    // Func2
 69    void  Func2(const char* AStr, long AValue)
 70    {
 71       if (OnFunc2.Method != NULL)
 72          ((TObject*)OnFunc2.Object->*OnFunc2.Method)(AStr, AValue);
 73    }
 74 
 75    // 事�g
 76    TOnFunc1    OnFunc1;
 77    TOnFunc1    OnFunc2;
 78 };
 79 
 80 
 81 // 例子
 82 TDemoA A;
 83 TDemoB B;
 84 TDemoC C;
 85 
 86 int demo()
 87 {
 88    // ???  
 89 
 90    C.OnFunc1.Object  = &B;
 91    C.OnFunc1.Method  = (TDemoC::TDoFunc1)&TDemoB::BF1;
 92 
 93    C.OnFunc2.Object  = &A;
 94    C.OnFunc2.Method  = (TDemoC::TDoFunc2)&TDemoA::AF2;
 95 
 96    // 调用 C �Ҏ(gu��)��
 97    C.Func1();     // <=> B.BF1();
 98    C.Func2();     // <=> A.AF2();
 99 
100    // ???  
101 
102    C.OnFunc1.Object  = &A;
103    C.OnFunc1.Method  = (TDemoC::TDoFunc1)&TDemoA::AF1;
104 
105    C.OnFunc2.Object  = &B;
106    C.OnFunc2.Method  = (TDemoC::TDoFunc2)&TDemoB::BF2;
107 
108    // 调用 C �Ҏ(gu��)��
109    C.Func1();     // <=> A.AF1();
110    C.Func2();     // <=> B.BF2();
111 
112    // ???  
113 
114 }
115 
116 /* TKYFmtMemEvent - 格式化内存项事�g�c?nbsp;*/
117 
118 class TKYFmtMemEvent
119 {
120 public:
121    // TOnFormat 事�g�c�d��
122    typedef void (TObject::*TDoFormat)(void* AItem, Word ASize);
123    typedef struct
124    {
125       TDoFormat         Method;
126       void*             Object;
127    } TOnFormat;
128 
129 public:
130    TKYFmtMemEvent()  { Clear(); }
131    ~TKYFmtMemEvent() { Clear(); }
132 
133    // 清除
134    void  Clear();
135 
136    // 执行 OnInitialize 事�g
137    void  DoInitialize(void* AItem, Word ASize)
138    {
139       if (OnInitialize.Method != NULL)
140          ((TObject*)OnInitialize.Object->*OnInitialize.Method)(AItem, ASize);
141    }
142 
143    // 执行 OnFinalize 事�g
144    void  DoFinalize(void* AItem, Word ASize)
145    {
146       if (OnFinalize.Method != NULL)
147          ((TObject*)OnFinalize.Object->*OnFinalize.Method)(AItem, ASize);
148    }
149 
150    // 事�g
151    TOnFormat   OnInitialize;
152    TOnFormat   OnFinalize;
153 
154 protected:
155 private:
156 };
157 
158 // 例子�Q�如何设�|�事件方法指�?/span>
159 void TDemo::SetEvent()
160 {
161    FDemo.OnInitialize.Object = this;
162    FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)&TDemo::DoFormat;
163 
164    // ???  
165 }
166 
167 // FDemo �?nbsp;OnInitialize 事�g�Ҏ(gu��)��
168 void TDemo::DoFormat(void* AItem, Word ASize)
169 {
170    // ???  
171 }
172 

回调事�g的方法指针需要C++�~�译器支持，臛_��VC的不同版本及GCC�~�译器都支持�?br />在VC6和VC2003中设�|�方法指针相对较宽松�Q�VC2005之后��很严格了，如下�Q?br />FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)&TDemo::DoFormat;

�q�行代码都被不同版本VC�~�译器支持，但如下代码就只能被VC6、VC2003支持�Q?br />FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)DoFormat;

其实�Q�类�Ҏ(gu��)��调用原理很简单，若知道如何��用C语言模拟�c�d��现就知道怎么回事了，�?br />是这个工作由�~�译器来做�Ş了。不�q�不是什么方法都可以调用的，如：(x��)静态方法就只能当做
函数指针来用�Q�而重载方法、虚�Ҏ(gu��)��{�等是不可靠的，所以最好��用普通的�c�L��法指针�?/p>

调用�Ҏ(gu��)��与调用函数的区别是在调用�Ҏ(gu��)��Ӟ��~�译器把当前对象的指针当做第一个参��C��
入，其它参数的传递与函数没有区别�Q�也��p��Q�这为提供回调事件的�Ҏ(gu��)��指针提供一条方便之门�?/p>

�Ҏ(gu��)��指针不能滥用�Q�用好它可以使你的视野更加开阔！

Kyee Ye 2011-05-22 11:01 发表评论