Proactor 自带例子 问题

peakzhang

在ACE自带的例子中.D:\ACE_wrappers\examples\Reactor\Proactor
里面有个Proactor_End_Event_Loops. 运行是,结果正常,但是运行到
ACE_Thread_Manager::instance ()->wait (); 程序就停住了,并不能结束.
本人的运行环境: ACE - 5.5   ACE_AS_STATIC_LIBS  操作系统WINXP
在LINUX 2.6.9-5.EL 下试过也是一样.
之前在用 Reactor时也遇到过 ACE_Thread_Manager::instance ()->wait (); 时出错,导致 core 掉.
请大家帮忙怎么解决.

2. // test_end_event_loop.cpp,v 1.7 2004/05/05 18:59:34 shuston Exp
3. // ============================================================================
4. //
5. // = FILENAME
6. //     test_end_event_loop.cpp
7. //
8. // = DESCRITPTION
9. //     This program tests the event loop mechanism of the
10. //     Proactor. To end the event loop, threads that are blocked in
11. //     waiting for completions are  woken up and the event loop comes
12. //     to the end. This is tested in this program.
13. //
14. //     Threads are doing <run_event_loop> with/without time_out
15. //     values and the main thread calls <end_event_loop>.
16. //
17. // = COMPILATION
18. //     make
19. //
20. // = RUN
21. //     ./test_end_event_loop
22. //
23. // = AUTHOR
24. //     Alexander Babu Arulanthu <alex@cs.wustl.edu>
25. //
26. // =====================================================================
27. #include "ace/OS_NS_unistd.h"
28. #include "ace/Proactor.h"
29. #include "ace/Task.h"
30. #include "ace/WIN32_Proactor.h"
31. #include "ace/POSIX_Proactor.h"
32. #include "ace/OS_main.h"
33. #if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || \
34.      (defined (ACE_HAS_AIO_CALLS)) && !defined (ACE_POSIX_AIOCB_PROACTOR))
35. // This only works on Win32 platforms and on Unix platforms supporting
36. // POSIX aio calls.
37. class My_Task: public ACE_Task <ACE_NULL_SYNCH>
38. {
39.   // = TITLE
40.   //
41.   //     Contains thread functions which execute event loops. Each
42.   //     thread waits for a different signal.
43.   //
44. public:
45.   // Constructor.
46.   My_Task (void)
47.     : time_flag_ (0)
48.     {}
50.   virtual ~My_Task (void) {}
51.   // Destructor.
52.   // If time_flag is zero do the eventloop indefinitely, otherwise do
53.   // it for finite amount of time (13secs!!!).
54.   int open (void *timed_event_loop)
55.     {
56.       // Set the local variable.
57.       if (timed_event_loop == 0)
58.         this->time_flag_ = 0;
59.       else
60.         this->time_flag_ = 1;
61.       // Spawn the threads.
62.       if (this->activate (THR_NEW_LWP, 5) == -1)
63.         ACE_ERROR_RETURN ((LM_ERROR,
64.                            "%N:%l:%p\n",
65.                            "My_Task:open: <activate> failed"),
66.                           -1);
67.       return 0;
68.     }
69.   // Thread function.
70.   int svc (void)
71.     {
72.       ACE_DEBUG ((LM_DEBUG,
73.                   "(%P|%t):Starting svc routine\n"));
74.       if (this->time_flag_)
75.         {
76.           ACE_DEBUG ((LM_DEBUG,
77.                       "(%P|%t):Going to do *timed* <run_event_loop> \n"));
78.           ACE_Time_Value run_time (13);
79.           if (ACE_Proactor::instance ()->run_event_loop (run_time) == -1)
80.             ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t):%p.\n",
81.                                "<Proactor::run_event_loop> failed"),
82.                               -1);
83.         }
84.       else
85.         {
86.           ACE_DEBUG ((LM_DEBUG,
87.                       "(%P|%t):Going to do *indefinite* <run_event_loop> \n"));
88.           if (ACE_Proactor::instance ()->run_event_loop () == -1)
89.             ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t):%p.\n",
90.                                "<Proactor::run_event_loop> failed"),
91.                               -1);
92.         }
93.       return 0;
94.     };
95. private:
96.   int time_flag_;
97.   // If zero, indefinite event loop, otherwise timed event loop.
98. };
99. int
100. ACE_TMAIN (int argc, ACE_TCHAR *argv [])
101. {
102.   ACE_UNUSED_ARG (argc);
103.   ACE_UNUSED_ARG (argv);
104.   ACE_DEBUG ((LM_DEBUG,
105.               "(%P | %t):Test starts \n"));
106.   // Let us get the singleton proactor created here. This is very
107.   // important. This will mask the signal used in the Proactor masked
108.   // for the main thread (and all the threads).
109.   ACE_Proactor *proactor = ACE_Proactor::instance ();
110.   ACE_UNUSED_ARG (proactor);
111.   My_Task task1, task2;
112.   // Test the indefinite run event loop.
113.   if (task1.open (0) == -1)
114.     ACE_ERROR_RETURN ((LM_ERROR,
115.                        "%N:%l:(%P | %t):Failed to <open> the task\n"),
116.                       1);
117.   // Test the indefinite run event loop. Just pass a non-zero.
118.   if (task2.open ((void *)&task2) == -1)
119.     ACE_ERROR_RETURN ((LM_ERROR,
120.                        "%N:%l:(%P | %t):Failed to <open> the task\n"),
121.                       1);
122.   // Give a gap.
123.   ACE_OS::sleep (3);
124.   // End the event loop.
125.   if (ACE_Proactor::instance ()->end_event_loop () == -1)
126.     ACE_ERROR_RETURN ((LM_ERROR,
127.                        "%N:%l:(%P | %t):Failed to <end_event_loop>\n"),
128.                       1);
129.   ACE_Thread_Manager::instance ()->wait ();
130.   ACE_DEBUG ((LM_DEBUG,
131.               "(%P | %t):Test ends\n"));
132.   return 0;
133. }
134. #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
135. template class ACE_Task <ACE_NULL_SYNCH>;
136. #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
137. #pragma instantiate ACE_Task <ACE_NULL_SYNCH>
138. #endif /* ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA */
139. #else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
140. int
141. main (int, char *[])
142. {
143.   ACE_DEBUG ((LM_DEBUG,
144.               "This example cannot work with AIOCB_Proactor.\n"));
145.   return 1;
146. }
147. #endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/

复制代码

peakzhang

在ACE_Proactor里面,在默认,超时时是使用 ACE_Timer_Heap timer queue mechamism来分发事件,在
创建 ACE_Proactor时 创建了一个线程, 在proactor.cpp :349 行
  // Set the timer queue.
this->timer_queue (tq);
// Create the timer handler
ACE_NEW (this->timer_handler_,
ACE_Proactor_Timer_Handler (*this));
// Activate <timer_handler>.
if (this->timer_handler_->activate (THR_NEW_LWP) == -1)
   
结合本例子,跟踪时,发现该线程 在proactor.cpp : 146行 等待了,
      else
    // The timer queue has no entries, so wait indefinitely.
    result = this->timer_event_.wait ();
而主线程ACE_Thread_Manager::instance ()->wait ();会不会因为这个而等待了,导致程序不能结束?


请大家帮帮忙,,急啊!!!

peakzhang

这个是完全正常的程序行为,不是异常，不是程序的bug。所有人跑这个程序，都是这个结果。呵呵。

peakzhang

如果要结束程序，需要使用一个Ctrl + C的响应中断。很简单的，ACE的例子里面有演示。

peakzhang

谢谢 winston 的帮助.你的意思是

定义捕捉信号量类,handle_single 然后强行exit()程序 ?

使用了另外的方法也可以,不过实际可能不会这样用.

把所有创建的线程都归到一个组里面.

static int g_nGrpID = 10;

activate (THR_NEW_LWP|THR_JOINABLE , 3,0,ACE_DEFAULT_THREAD_PRIORITY,g_nGrpID)

在ACE_TMAIN 里面 使用:

ACE_Thread_Manager::instance ()->wait_grp(g_nGrpID);

这样就可以正常结束了.

正常结束程序很重要,析构类,最少不会有core文件.

peakzhang

我说的不是强行结束，ACE的程序都是可以正常结束的。

peakzhang

谢谢winston版主的关注,

你的意思是 发送一个 SIGINT /*中断*/信号什么的终断程序? 我试过直接 ctrl+c 关闭程序,发现自己定义的类是没有正常析构的.当然 ACE_Thread_Manager类里面是正常析够的.

有没有更好的解决办法?

我也试过加个信号处理类,但是捕捉到 SIGINT后,怎么样解除 ACE_Thread_Manager的wait();

virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0)
{
  ACE_TRACE (ACE_TEXT ("MySignalHandler::handle_signal"));

  // Make sure the right handler was called back..
  // ACE_ASSERT(signum == this->signum_);
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("信号%d occured\n"), signum));

  ACE_Reactor::instance()->end_reactor_event_loop();
  //捕捉到CTRL + C 后这里需要如何处理???? 解除ACE_Thread_Manager的wait(),或者Proactor产生的线程 让程序正常结束?

  return 0;
}

wishel

可以不用ACE_Thread_Manager::instance ()->wait ();

用
task1.wait();
task2.wait();
代替

wishel

发现proactor和ACE_Thread_Manager::instance ()->wait ()有冲突

int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
  ACE_DEBUG ((LM_DEBUG,
              "(%P | %t):Test begins\n"));
  ACE_Proactor::instance ();
  ACE_Thread_Manager::instance ()->wait ();
  ACE_DEBUG ((LM_DEBUG,
              "(%P | %t):bye!\n"));
  return 0;
}
就不会走到结束，如果把ACE_Proactor::instance ();这一行注释掉就可以。
按道理不应该这样，应该算是bug了吧。

winston

没有冲突。我所有的系统中，都是用ACE_Thread_Manager::instance ()的。你用法不对头。