AbstractThread Class Reference

Abstract for thread implementation. More...

#include <AbstractThread.hpp>

Inheritance diagram for AbstractThread:

Public Member Functions
	AbstractThread ()
	Constructor. Initialize the class attributes.
virtual	~AbstractThread ()
	Destructor.
bool	start ()
	Starts execution of the thread by calling run().
bool	stop ()
	Stops the running thread.
bool	waitForTermination ()
	Blocks the calling thread until the thread is finished.
bool	sendSignal (int sig)
	Sends a signal to the thread.
bool	setSchedParam (int policy, int priority)
	Set scheduling policy and priority.
bool	getSchedParam (int *policy, int *priority)
	Get current scheduling policy and priority.

Static Public Member Functions
static bool	blockSignal (int sig)
	Masks a specific signal on this thread.
static bool	unblockSignal (int sig)
	Unmasks a signal previously masked.
static bool	setSignalHandler (int sig, void(*handler)(int))
	Set a handler for a specific signal.

Protected Member Functions
virtual void	run ()=0
	This function must be reimplemented in a derived class to define the specific function run by the thread.

Static Protected Member Functions
static void	checkTermination ()
	Function to know if the thread has finished computation.

Protected Attributes
pthread_t	handle_

Private Member Functions
	AbstractThread (const AbstractThread &)
AbstractThread &	operator= (const AbstractThread &)

Static Private Member Functions
static void *	Execute (void *param)
	The static function representing the code executed in the thread context.

Private Attributes
bool	isStarted_
	If the thread is running.

Detailed Description

Abstract for thread implementation.

Base abstract non copyable class for thread implementation. Derived classes must implement the pure virtual function run() to define their specific behavior. This class makes use of POSIX threads (pthreads). The thread starts stopped. To start it, the start() method must be explicitly called.

Example of usage:

class MyThread: public AbstractThread {
        // Put thread arguments here
public:
     MyThread() {
        // Initialize arguments here
     }
        void run() {
                // Put thread code here
                // Access arguments as normal attributes
        }
};

int main ()
{
        MyThread t;
        t.start();
        t.waitForTermination();
}

In case a return value must be passed from the finished thread to the other thread, this can be achieved as follows:

class MyThread: public AbstractThread {
        int returnValue_;
public:
     MyThread(): returnValue_(0) {
        // Initialize other arguments here
     }
        void run() {
                // Put thread code here
                returnValue_ = ...;
        }
        inline int getReturnValue() {
        return returnValue_;
     }
};

int main ()
{
        MyThread t;
        t.start();
        t.waitForTermination();
     // Attention: get return arguments only after the thread has
     // terminated the execution, to avoid race conditions!
        int ret = t.getReturnValue();
}

Definition at line 99 of file AbstractThread.hpp.

Constructor & Destructor Documentation

AbstractThread ( const AbstractThread &  )

private

AbstractThread

(

)

Constructor. Initialize the class attributes.

Definition at line 51 of file AbstractThread.cpp.

                              :
                                isStarted_(false)
{