ACE/examples/Threads/auto_event.cpp

   1 // This test shows the use of an ACE_Auto_Event as a signaling
   2 // mechanism. Two threads are created (one a reader, the other a
   3 // writer). The reader waits till the writer has completed
   4 // calculations. Upon waking up the reader prints the data calculated
   5 // by the writer. The writer thread calculates the value and signals
   6 // the reader when the calculation completes.
   7
   8 #include "ace/OS_NS_unistd.h"
   9 #include "ace/OS_main.h"
  10 #include "ace/Service_Config.h"
  11 #include "ace/Auto_Event.h"
  12 #include "ace/Singleton.h"
  13 #include "ace/Thread_Manager.h"
  14
  15 #if defined (ACE_HAS_THREADS)
  16 // Shared event between reader and writer.  The ACE_Thread_Mutex is
  17 // necessary to make sure that only one ACE_Auto_Event is created.
  18 // The default constructor for ACE_Auto_Event sets it initially into
  19 // the non-signaled state.
  20
  21 typedef ACE_Singleton <ACE_Auto_Event, ACE_Thread_Mutex> EVENT;
  22
  23 // work time for writer
  24 static int work_time;
  25
  26 // Reader thread.
  27 static void *
  28 reader (void *arg)
  29 {
  30   // Shared data via a reference.
  31   int& data = *(int *) arg;
  32
  33   // Wait for writer to complete.
  34
  35   ACE_DEBUG ((LM_DEBUG, "(%t) reader: waiting......\n"));
  36
  37   if (EVENT::instance ()->wait () == -1)
  38     {
  39       ACE_ERROR ((LM_ERROR, "thread wait failed"));
  40       ACE_OS::exit (0);
  41     }
  42
  43   // Read shared data.
  44   ACE_DEBUG ((LM_DEBUG, "(%t) reader: value of data is: %d\n", data));
  45
  46   return 0;
  47 }
  48
  49 // Writer thread.
  50 static void *
  51 writer (void *arg)
  52 {
  53   int& data = *(int *) arg;
  54
  55   // Calculate (work).
  56   ACE_DEBUG ((LM_DEBUG, "(%t) writer: working for %d secs\n", work_time));
  57   ACE_OS::sleep (work_time);
  58
  59   // Write shared data.
  60   data = 42;
  61
  62   // Wake up reader.
  63   ACE_DEBUG ((LM_DEBUG, "(%t) writer: calculation complete, waking reader\n"));
  64
  65   if (EVENT::instance ()->signal () == -1)
  66     {
  67       ACE_ERROR ((LM_ERROR, "thread signal failed"));
  68       ACE_OS::exit (0);
  69     }
  70
  71   return 0;
  72 }
  73
  74 int
  75 ACE_TMAIN (int argc, ACE_TCHAR **argv)
  76 {
  77   // Shared data: set by writer, read by reader.
  78   int data;
  79
  80   // Work time for writer.
  81   work_time = argc == 2 ? ACE_OS::atoi (argv[1]) : 5;
  82
  83   // threads manager
  84   ACE_Thread_Manager& tm = *ACE_Thread_Manager::instance ();
  85
  86   // Create reader thread.
  87   if (tm.spawn ((ACE_THR_FUNC) reader, (void *) &data) == -1)
  88     ACE_ERROR_RETURN ((LM_ERROR, "thread create for reader failed"), -1);
  89
  90   // Create writer thread.
  91   if (tm.spawn ((ACE_THR_FUNC) writer, (void *) &data) == -1)
  92     ACE_ERROR_RETURN ((LM_ERROR, "thread create for writer failed"), -1);
  93
  94   // Wait for both.
  95   if (tm.wait () == -1)
  96     ACE_ERROR_RETURN ((LM_ERROR, "thread wait failed"), -1);
  97   else
  98     ACE_DEBUG ((LM_ERROR, "graceful exit\n"));
  99
 100   return 0;
 101 }
 102
 103 ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_Singleton, ACE_Auto_Event, ACE_Thread_Mutex);
 104
 105
 106 #else
 107 int
 108 ACE_TMAIN (int, ACE_TCHAR *[])
 109 {
 110   ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
 111   return 0;
 112 }
 113 #endif /* ACE_HAS_THREADS */