1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
#ifndef BU_ITO_H
#define BU_ITO_H
#include <pthread.h>
namespace Bu
{
/**
* Simple thread class. This wraps the basic pthread (posix threads)
* system in an object oriented sort of way. It allows you to create a
* class with standard member variables and callable functions that can be
* run in it's own thread, one per class instance.
*@author Mike Buland
*@ingroup Threading
*/
class Ito
{
public:
/**
* Construct an Ito thread.
*/
Ito();
/**
* Destroy an Ito thread.
*/
virtual ~Ito();
/**
* Begin thread execution. This will call the overridden run function,
* which will simply execute in it's own thread until the function
* exits, the thread is killed, or the thread is cancelled (optionally).
* The thread started in this manner has access to all of it's class
* variables, but be sure to protect possible multiple-access with
* ItoMutex objects.
* @returns True if starting the thread was successful. False if
* something went wrong and the thread has not started.
*/
bool start();
/**
* Forcibly kill a thread. This is not generally considered a good
* thing to do, but in those rare cases you need it, it's invaluable.
* The problem with stopping (or killing) a thread is that it stops it
* the moment you call stop, no matter what it's doing. The object
* oriented approach to this will help clean up any class variables
* that were used, but anything not managed as a member variable will
* probably create a memory leak type of situation. Instead of stop,
* consider using cancel, which can be handled by the running thread in
* a graceful manner.
*@returns True if the thread was stopped, false otherwise. When this
* function returns the thread may not have stopped, to ensure that the
* thread has really stopped, call join.
*/
bool stop();
/**
* The workhorse of the Ito class. This is the function that will run
* in the thread, when this function exits the thread dies and is
* cleaned up by the system. Make sure to read up on ItoMutex,
* ItoCondition, and cancel to see how to control and protect
* everything you do in a safe way within this function.
*@returns I'm not sure right now, but this is the posix standard form.
*/
virtual void *run()=0;
/**
* Join the thread in action. This function performs what is commonly
* called a thread join. That is that it effectively makes the calling
* thread an the Ito thread contained in the called object one in the
* same, and pauses the calling thread until the called thread exits.
* That is, when called from, say, your main(), mythread.join() will
* not return until the thread mythread has exited. This is very handy
* at the end of programs to ensure all of your data was cleaned up.
*@returns True if the thread was joined, false if the thread couldn't
* be joined, usually because it isn't running to begin with.
*/
bool join();
private:
pthread_t ptHandle; /**< Internal handle to the posix thread. */
int nHandle; /**< Numeric handle to the posix thread. */
protected:
/**
* This is the hidden-heard of the thread system. While run is what the
* user gets to override, and everything said about it is true, this is
* the function that actually makes up the thread, it simply calls the
* run member function in an OO-friendly way. This is what allows us to
* use member variables from within the thread itself.
*@param Should always be this.
*@returns This is specified by posix, I'm not sure yet.
*/
static void *threadRunner( void *pThread );
void yield();
};
}
#endif
|
