ACE 栅栏同步体介绍

yunh

        ACE 提供了一种特别的线程同步对象：ACE_Barrier，与其它的同步对象 Semaphore、Condition Variable、Mutex、Event、Readers/Writer Lock 不同，栅栏同步体在同步多个线程同时到达时更加有效，也更直观一些。下面是一个使用栅栏同步体的例子：

1. #include "stdafx.h"
2. #include "ace/Barrier.h"
3. #include "ace/Task_T.h"
4. #include "ace/OS_NS_unistd.h"
6. #define HAS_BARRIER
8. class HA_CommandHandler : public ACE_Task <ACE_MT_SYNCH>
9. {
10. public:
11.     enum {
12.         N_THREADS = 5
13.     };
15.     HA_CommandHandler (ACE_Barrier &startup_barrier,
16.         ACE_Barrier &shutdown_barrier)
17.         : startup_barrier_ (startup_barrier)
18.         , shutdown_barrier_ (shutdown_barrier)
19.     {
20.     }
22.     void init_handler ()
23.     {
24.         ACE_OS::srand (ACE_Thread::self ());
25.         ACE_OS::sleep (ACE_Time_Value (0, ACE_OS::rand () % 1000000));
26.     }
28.     int handle_requests ()
29.     {
30.         for (int i=0; i<128; ++ i)
31.         {
32.             ACE_OS::sleep (ACE_Time_Value (0, ACE_OS::rand () % 100000));
33.             ACE_DEBUG ((LM_DEBUG, "(%t: %T) working %u\n", i));
34.         }
36.         return -1;
37.     }
39.     virtual int svc ()
40.     {
41.         init_handler ();
42. #if defined (HAS_BARRIER)
43.         startup_barrier_.wait ();
44. #endif
45.         ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t: %D) started\n")));
47.         while(handle_requests () > 0)
48.             ;
50. #if defined (HAS_BARRIER)
51.         shutdown_barrier_.wait ();
52. #endif
53.         ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t: %D) ended\n")));
54.         return 0;
55.     }
57. private:
58.     ACE_Barrier &startup_barrier_;
59.     ACE_Barrier &shutdown_barrier_;
60. };
62. int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
63. {
64.     ACE_Barrier startup_barrier (HA_CommandHandler::N_THREADS);
65.     ACE_Barrier shutdown_barrier (HA_CommandHandler::N_THREADS);
67.     HA_CommandHandler handler (startup_barrier, shutdown_barrier);
68.     handler.activate (THR_NEW_LWP | THR_JOINABLE, HA_CommandHandler::N_THREADS);
69.     handler.wait ();
70.     return 0;
71. }

复制代码

       这个例子是直接从《ACE Programmer's Guide》P238 摘过来的，ACE_Barrier 的用法相对简单，在构造器中输入要同步的线程数，例子中是5，在需要同步的集合点，调用 wait 即可，如果没有达到预期的线程数 (5)，wait 会陷入等待，当最后一个线程调用了 wait 后，会释放之前所有等待的线程，包括它自身，此时这些线程将如同开闸放水一般，同时向下继续奔涌。使用了同步体后的输出如下：

1. (1380:  11:32:20.434000) working 126
2. (3240:  11:32:20.450000) working 127
3. (1172:  11:32:20.450000) working 126
4. (1380:  11:32:20.466000) working 127
5. (1172:  11:32:20.481000) working 127
6. (1172: Mon Mar  3 2014 11:32:20.481000) ended
7. (3240: Mon Mar  3 2014 11:32:20.481000) ended
8. (1380: Mon Mar  3 2014 11:32:20.481000) ended
9. (6916: Mon Mar  3 2014 11:32:20.481000) ended
10. (3780: Mon Mar  3 2014 11:32:20.481000) ended

复制代码

       可以看到，在结束时各个线程的输出时间基本一样，为了与不使用同步体的情况做对比，我在例子代码中加入了预编译条件 HAS_BARRIER，将其注释并重编译后，就可以看到不一样的情况：

1. (7888:  11:34:19.946000) working 126
2. (4992:  11:34:19.946000) working 121
3. (2808:  11:34:19.962000) working 127
4. (7888:  11:34:19.962000) working 127
5. (4992:  11:34:19.962000) working 122
6. (2808: Mon Mar  3 2014 11:34:19.962000) ended
7. (7888: Mon Mar  3 2014 11:34:19.962000) ended
8. (8092:  11:34:19.977000) working 122
9. (4992:  11:34:19.993000) working 123
10. (8092:  11:34:20.009000) working 123
11. (4992:  11:34:20.024000) working 124
12. (8092:  11:34:20.024000) working 124
13. (8092:  11:34:20.024000) working 125
14. (8092:  11:34:20.055000) working 126
15. (4992:  11:34:20.055000) working 125
16. (4992:  11:34:20.071000) working 126
17. (8092:  11:34:20.087000) working 127
18. (8092: Mon Mar  3 2014 11:34:20.087000) ended
19. (4992:  11:34:20.102000) working 127
20. (4992: Mon Mar  3 2014 11:34:20.102000) ended

复制代码

       各个线程的结束时间就参差不齐了，看来 ACE_Barrier 确实起作用了。
        总结一下，Semaphore 适合于解决生产者/消费者问题，用来控制活动线程的个数，保证与当前可用资源相匹配；Readers/Writer Lock 适合于一种资源被多个线程访问，其中读取者数量明显多于写入者；Mutex 为二元信号量，适合于锁定临界区代码；Event 与 Condition Variable 则比较适合于线程间的某种条件得到满足的通知；Barrier 则适合于在某一个集合点同步关联线程。

freeeyes

好贴，加精