research/transmission_spectroscopy/TOF/Win32++/include/thread.h

   1 // Win32++   Version 7.3\r
   2 // Released: 30th November 2011\r
   3 //\r
   4 //      David Nash\r
   5 //      email: [email protected]\r
   6 //      url: https://sourceforge.net/projects/win32-framework\r
   7 //\r
   8 //\r
   9 // Copyright (c) 2005-2011  David Nash\r
  10 //\r
  11 // Permission is hereby granted, free of charge, to\r
  12 // any person obtaining a copy of this software and\r
  13 // associated documentation files (the "Software"),\r
  14 // to deal in the Software without restriction, including\r
  15 // without limitation the rights to use, copy, modify,\r
  16 // merge, publish, distribute, sublicense, and/or sell\r
  17 // copies of the Software, and to permit persons to whom\r
  18 // the Software is furnished to do so, subject to the\r
  19 // following conditions:\r
  20 //\r
  21 // The above copyright notice and this permission notice\r
  22 // shall be included in all copies or substantial portions\r
  23 // of the Software.\r
  24 //\r
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF\r
  26 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
  27 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
  28 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\r
  29 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r
  30 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
  31 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  32 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE\r
  33 // OR OTHER DEALINGS IN THE SOFTWARE.\r
  34 //\r
  35 ////////////////////////////////////////////////////////\r
  36 \r
  37 \r
  38 // The CThread class simplifies the use of threads with Win32++.\r
  39 // To use threads in your Win32++ application, inherit a class from\r
  40 // CThread, and override InitInstance. When your class is instanciated,\r
  41 // a new thread is started, and the InitInstance function is called to\r
  42 // run in the new thread.\r
  43 \r
  44 // If your thread is used to run one or more windows, InitInstance should \r
  45 // return TRUE, causing the MessageLoop function to be called. If your\r
  46 // thread doesn't require a MessageLoop, it should return FALSE. Threads\r
  47 // which don't run a message loop as sometimes referred to as "worker" threads.\r
  48 \r
  49 // Note: It is your job to end the thread before CThread ends!\r
  50 //       To end a thread with a message loop, use PostQuitMessage on the thread.\r
  51 //       To end a thread without a message loop, set an event, and end the thread \r
  52 //       when the event is received.\r
  53 \r
  54 // Hint: It is never a good idea to use things like TerminateThread or ExitThread to \r
  55 //       end your thread. These represent poor programming techniques, and are likely \r
  56 //       to leak memory and resources.\r
  57 \r
  58 // More Hints for thread programming:\r
  59 // 1) Avoid using SendMessage between threads, as this will cause one thread to wait for\r
  60 //    the other to respond. Use PostMessage between threads to avoid this problem.\r
  61 // 2) Access to variables and resources shared between threads need to be made thread safe.\r
  62 //    Having one thread modify a resouce or variable while another thread is accessing it is\r
  63 //    a recipe for disaster.\r
  64 // 3) Thread Local Storage (TLS) can be used to replace global variables to make them thread\r
  65 //    safe. With TLS, each thread gets its own copy of the variable.\r
  66 // 4) Critical Sections can be used to make shared resources thread safe.\r
  67 // 5) Window messages (including user defined messages) can be posted between GUI threads to\r
  68 //    communicate information between them.\r
  69 // 6) Events (created by CreateEvent) can be used to comunicate information between threads \r
  70 //    (both GUI and worker threads).\r
  71 // 7) Avoid using sleep to synchronise threads. Generally speaking, the various wait \r
  72 //    functions (e.g. WaitForSingleObject) will be better for this.\r
  73 \r
  74 // About Threads:\r
  75 // Each program that executes has a "process" allocated to it. A process has one or more\r
  76 // threads. Threads run independantly of each other. It is the job of the operating system\r
  77 // to manage the running of the threads, and do the task switching between threads as required.\r
  78 // Systems with multiple CPUs will be able to run as many threads simultaneously as there are\r
  79 // CPUs. \r
  80 \r
  81 // Threads behave like a program within a program. When the main thread starts, the application \r
  82 // runs the WinMain function and ends when WinMain ends. When another thread starts, it too\r
  83 // will run the function provided to it, and end when that function ends.\r
  84 \r
  85 \r
  86 #ifndef _WIN32XX_WINTHREAD_H_\r
  87 #define _WIN32XX_WINTHREAD_H_\r
  88 \r
  89 \r
  90 #include <process.h>\r
  91 \r
  92 \r
  93 namespace Win32xx\r
  94 {\r
  95 \r
  96         //////////////////////////////////////\r
  97         // Declaration of the CThread class\r
  98         //\r
  99         class CThread\r
 100         {\r
 101         public:\r
 102                 CThread();\r
 103                 CThread(LPSECURITY_ATTRIBUTES pSecurityAttributes, unsigned stack_size, unsigned initflag);\r
 104                 virtual ~CThread();\r
 105                 \r
 106                 // Overridables\r
 107                 virtual BOOL InitInstance();\r
 108                 virtual int MessageLoop();\r
 109 \r
 110                 // Operations\r
 111                 HANDLE  GetThread()     const;\r
 112                 int             GetThreadID() const;\r
 113                 int             GetThreadPriority() const;\r
 114                 DWORD   ResumeThread() const;\r
 115                 BOOL    SetThreadPriority(int nPriority) const;\r
 116                 DWORD   SuspendThread() const;\r
 117 \r
 118         private:\r
 119                 CThread(const CThread&);                                // Disable copy construction\r
 120                 CThread& operator = (const CThread&);   // Disable assignment operator\r
 121                 void CreateThread(LPSECURITY_ATTRIBUTES pSecurityAttributes, unsigned stack_size, unsigned initflag);\r
 122                 static  UINT WINAPI StaticThreadCallback(LPVOID pCThread);\r
 123 \r
 124                 HANDLE m_hThread;                       // Handle of this thread\r
 125                 UINT m_nThreadID;                       // ID of this thread\r
 126         };\r
 127         \r
 128 }\r
 129 \r
 130 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
 131 \r
 132 namespace Win32xx\r
 133 {\r
 134 \r
 135         ///////////////////////////////////////\r
 136         // Definitions for the CThread class\r
 137         //\r
 138         inline CThread::CThread() : m_hThread(0), m_nThreadID(0)\r
 139         {\r
 140                 CreateThread(0, 0, CREATE_SUSPENDED);\r
 141         }\r
 142 \r
 143         inline CThread::CThread(LPSECURITY_ATTRIBUTES pSecurityAttributes, unsigned stack_size, unsigned initflag)\r
 144                 : m_hThread(0), m_nThreadID(0)\r
 145                                                                                 \r
 146         {\r
 147                 // Valid argument values:\r
 148                 // pSecurityAttributes          Either a pointer to SECURITY_ATTRIBUTES or 0\r
 149                 // stack_size                           Either the stack size or 0\r
 150                 // initflag                                     Either CREATE_SUSPENDED or 0\r
 151                 \r
 152                 CreateThread(pSecurityAttributes, stack_size, initflag);\r
 153         }\r
 154 \r
 155         inline CThread::~CThread()\r
 156         {       \r
 157                 // A thread's state is set to signalled when the thread terminates.\r
 158                 // If your thread is still running at this point, you have a bug.\r
 159                 if (0 != WaitForSingleObject(m_hThread, 0))\r
 160                         TRACE(_T("*** Error *** Ending CThread before ending its thread\n"));\r
 161 \r
 162                 // Close the thread's handle\r
 163                 ::CloseHandle(m_hThread);\r
 164         }\r
 165 \r
 166         inline void CThread::CreateThread(LPSECURITY_ATTRIBUTES pSecurityAttributes, unsigned stack_size, unsigned initflag)\r
 167         {\r
 168                 // NOTE:  By default, the thread is created in the default state.\r
 169                 m_hThread = (HANDLE)_beginthreadex(pSecurityAttributes, stack_size, CThread::StaticThreadCallback, (LPVOID) this, initflag, &m_nThreadID);\r
 170 \r
 171                 if (0 == m_hThread)\r
 172                         throw CWinException(_T("Failed to create thread"));\r
 173         }\r
 174 \r
 175         inline HANDLE CThread::GetThread() const\r
 176         {\r
 177                 assert(m_hThread);\r
 178                 return m_hThread;\r
 179         }\r
 180 \r
 181         inline int CThread::GetThreadID() const \r
 182         {\r
 183                 assert(m_hThread);\r
 184                 return m_nThreadID;\r
 185         }\r
 186 \r
 187         inline int CThread::GetThreadPriority() const\r
 188         {\r
 189                 assert(m_hThread);\r
 190                 return ::GetThreadPriority(m_hThread);\r
 191         }\r
 192 \r
 193         inline BOOL CThread::InitInstance()\r
 194         {\r
 195                 // Override this function to perform tasks when the thread starts.\r
 196 \r
 197                 // return TRUE to run a message loop, otherwise return FALSE.\r
 198                 // A thread with a window must run a message loop.\r
 199                 return FALSE;\r
 200         }\r
 201 \r
 202         inline int CThread::MessageLoop()\r
 203         {\r
 204                 // Override this function if your thread needs a different message loop\r
 205                 return GetApp()->MessageLoop();\r
 206         }\r
 207 \r
 208         inline DWORD CThread::ResumeThread() const\r
 209         {\r
 210                 assert(m_hThread);\r
 211                 return ::ResumeThread(m_hThread);\r
 212         }\r
 213 \r
 214         inline DWORD CThread::SuspendThread() const\r
 215         {\r
 216                 assert(m_hThread);\r
 217                 return ::SuspendThread(m_hThread); \r
 218         }\r
 219         \r
 220         inline BOOL CThread::SetThreadPriority(int nPriority) const\r
 221         {\r
 222                 assert(m_hThread);\r
 223                 return ::SetThreadPriority(m_hThread, nPriority);\r
 224         }\r
 225 \r
 226         inline UINT WINAPI CThread::StaticThreadCallback(LPVOID pCThread)\r
 227         // When the thread starts, it runs this function.\r
 228         {\r
 229                 // Get the pointer for this CMyThread object\r
 230                 CThread* pThread = (CThread*)pCThread;\r
 231 \r
 232                 if (pThread->InitInstance())\r
 233                         return pThread->MessageLoop();\r
 234 \r
 235                 return 0;\r
 236         }\r
 237         \r
 238 }\r
 239 \r
 240 #endif // #define _WIN32XX_WINTHREAD_H_\r
 241 \r