Windows Programming uses C + + to implement multithreaded classes

Sometimes we want to implement multi-threading in a class, the main thread gets the data at some point, can "notify" the child thread to process it, and then return the result. The following example is the main thread every 2s generates 10 random numbers, the 10 random number to the multithreaded class, so that it receives data immediately after printing.

First look at the definition of the class:

[CPP]View PlainCopy

2. #pragma once
4. #include <iostream>
6. #include <atlbase.h>//Use of ATL classes
8. #include <atlsync.h>
10. #include <vector>
12. Using namespace std;
16. Class Cmultithreadtest
18. {
20. Public
22. bool Init (); //Initialize class members
24. bool UnInit (); //Release Resources
26. void Notifydowork (const std::vector<int> &data);
30. static DWORD CALLBACK testthread (lpvoid); //thread function, must be a static function
32. DWORD TestProc (); //thread work implementation
36. Private
38. std::vector<int> m_data; //Sync data
40. Atl::cevent m_notifyevent; //Notification Events
42. HANDLE M_hthread; //thread handle
44. };

The Alt class is used in the class and needs to contain the atlbase.h and altsync.h header files. The function Testthread must be a static function, because CreateThread only accepts global or static functions.
First look at the implementation of the Init () and UnInit () functions:

[CPP]View PlainCopy

2. BOOL Cmultithreadtest::init ()
4. {
6. //Create Event
8. BOOL bRet = m_notifyevent.create (null, TRUE, FALSE, NULL);
10. if (!bret) {
12. return false;
14. }
18. //Suspended way to create threads
20. M_hthread = CreateThread (null, 0, &cmultithreadtest::testthread, this , create_suspended, NULL);
22. if (NULL = = m_hthread) {
24. return false;
26. }
30. //wake-up thread
32. ResumeThread (M_hthread);
34. return true;
36. }
42. BOOL Cmultithreadtest::uninit ()
44. {
46. //Notifies the thread to process data
48. if (m_notifyevent! = NULL) {
50. M_notifyevent.set ();
52. }
56. if (m_hthread! = NULL)
58. {
60. //reserved 100ms let the thread finish processing the data, 100ms is an estimate
62. WaitForSingleObject (M_hthread, 100);
64. CloseHandle (M_hthread);
66. M_hthread = NULL;
68. }
72. return true;
74. }

Atl::cevent member function create receives 4 parameters, the fourth parameter specifies the name of the event (it can have a name) so that the event can be found in other processes, where we do not need to use it, set it to null, other parameters are easy to understand, do not repeat.
The Init () function is worth noting that the thread we created is created in a suspended manner, so we must call the ResumeThread wakeup thread, otherwise the thread one value is asleep and no thread function is executed.
The UnInit () function is relatively straightforward, primarily informing the thread to perform the finishing touches and freeing the class's resources.

Let's take a look at the implementation of the remaining functions.

[CPP]View PlainCopy

2. DWORD CALLBACK cmultithreadtest::testthread (lpvoid lpparam)
4. {
6. if (Lpparam = = NULL) {
8. return 0;
10. }
14. Cmultithreadtest *lpthis = reinterpret_cast<cmultithreadtest *> (Lpparam);
16. return Lpthis->testproc ();
18. }
24. DWORD Cmultithreadtest::testproc ()
26. {
28. While (true)
30. {
32. //5s listening every time, the number of seconds directly affect the performance of the program
34. DWORD dwret = WaitForSingleObject (m_notifyevent, 5000);
38. //Enter the Loop 5s No event occurred, do not do any processing
40. if (Dwret = = wait_timeout) {
42. continue;
44. }
48. //print array
50. For (unsigned int i = 0; i < m_data.size (); i++)
52. {
54. cout <<m_data[i] <<"";
56. }
60. cout <<endl;
64. //Reset Events
66. M_notifyevent.reset ();
68. }
70. return 0;
72. }
78. void Cmultithreadtest::notifydowork (const std::vector<int> &data)
80. {
82. m_data = data;
84. M_notifyevent.set ();  //Notify the thread to do something!
86. }

First we look at the Testthread function, which is the "portal" of the thread, and the thread is awakened after the function is executed. It is worth noting that when creating a thread, we pass the object pointer this as a parameter to the Create thread function, which is passed back when the system calls Testthread, where the weak type conversion is used reinterpret_ Cast converts the lpvoid into a pointer to the Cmultithreadtest class, reinterpret_cast is a dangerous type conversion, and generally applies only to conversions between pointers and integers. Interested students can refer to the C + + Primer 4th edition 18.2.1 chapter.

After the thread function converts the parameter lpparam to an object pointer, executes the object's member function TestProc (), TestProc () implements the primary logic. There may be questions here, why not implement the main logic directly in the Testthread () function? There are two advantages to this, one is the ability to separate the thread function logic from the business logic, and the second is that Testthread is a static function, the class static function can only handle static member variables of the class, and many times we want the thread to handle the non-static member variables of the class.
The last Notifydowork function is very simple, and the function is called externally, which assigns the externally transmitted data to the non-static member variable of the class M_data, and notifies the thread to process m_data data. TestProc the WaitForSingleObject function receives the event and executes it, and prints the m_data.

Let's look at the implementation of the main function:

[CPP]View PlainCopy

2. int _tmain (int argc, _tchar* argv[])
4. {
6. Cmultithreadtest multithreadtest;
10. //initialization failed
12. if (!multithreadtest.init ()) {
14. return 0;
16. }
20. Srand (unsigned int (time (NULL)));
22. std::vector<int> data;
26. While (true)
28. {
30. Data.clear ();
34. //Generate 10 random numbers
36. For (int i = 0; i <; i++)
38. Data.push_back (rand ()% 1000);
42. //Notify multithreaded class to perform work
44. Multithreadtest.notifydowork (data);
48. Sleep (2000);
50. }
54. Multithreadtest.uninit ();
56. return 0;
58. }

This code does not have to explain, remember to include the header files Windows.h, time.h and vector.

Summarize:
The usage scenario for multithreaded classes is that when a thread or data is obtained, it is expected that other threads will be able to handle this part number. Multithreaded class implementation is also relatively simple, first create thread and thread events, implemented to the external call interface, external through the interface set events, notify the thread to execute.

Windows Programming uses C + + to implement multithreaded classes