Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members

Thread Class Reference

Thread support class. More...

#include <yateclass.h>

Inheritance diagram for Thread:

Runnable Client Router List of all members.

Public Types

enum  Priority {
  Lowest, Low, Normal, High,
  Highest
}

Public Member Functions

virtual void cleanup ()
bool startup ()
bool error () const
bool running () const
int locks () const
bool locked () const
const char * name () const
void cancel (bool hard=false)
bool isCurrent () const

Static Public Member Functions

static const char * currentName ()
static void yield (bool exitCheck=false)
static void sleep (unsigned int sec, bool exitCheck=false)
static void msleep (unsigned long msec, bool exitCheck=false)
static void usleep (unsigned long usec, bool exitCheck=false)
static Threadcurrent ()
static int count ()
static bool check (bool exitNow=true)
static void exit ()
static Priority priority (const char *name, Priority defvalue=Normal)
static const char * priority (Priority prio)
static void killall ()
static void preExec ()

Protected Member Functions

 Thread (const char *name=0, Priority prio=Normal)
 Thread (const char *name, const char *prio)
virtual ~Thread ()

Friends

class ThreadPrivate
class MutexPrivate

Detailed Description

Thread support class.

A thread is a separate execution context that exists in the same address space. Threads make better use of multiple processor machines and allow blocking one execution thread while allowing other to run.


Member Enumeration Documentation

enum Priority
 

Running priorities, their mapping is operating system dependent


Constructor & Destructor Documentation

Thread const char *  name = 0,
Priority  prio = Normal
[protected]
 

Creates and starts a new thread

Parameters:
name Static name of the thread (for debugging purpose only)
prio Thread priority

Thread const char *  name,
const char *  prio
[protected]
 

Creates and starts a new thread

Parameters:
name Static name of the thread (for debugging purpose only)
prio Thread priority level name

virtual ~Thread  )  [protected, virtual]
 

The destructor is called when the thread terminates


Member Function Documentation

void cancel bool  hard = false  ) 
 

Terminates the specified thread.

Parameters:
hard Kill the thread the hard way rather than just setting an exit check marker

static bool check bool  exitNow = true  )  [static]
 

Check if the current thread was asked to terminate.

Parameters:
exitNow If thread is marked as cancelled then terminate immediately
Returns:
False if thread should continue running, true if it should stop

virtual void cleanup  )  [virtual]
 

This method is called when the current thread terminates.

Reimplemented in Router.

static int count  )  [static]
 

Get the number of Yate created threads

Returns:
Count of current Thread objects

static Thread* current  )  [static]
 

Get a pointer to the currently running thread

Returns:
A pointer to the current thread or NULL for the main thread or threads created by other libraries

static const char* currentName  )  [static]
 

Get the name of the currently running thread

Returns:
The pointer that was passed in the thread's constructor

bool error  )  const
 

Check if the thread creation failed

Returns:
True if an error occured, false if created ok

static void exit  )  [static]
 

Terminates the current thread.

bool isCurrent  )  const [inline]
 

Check if this thread is the currently running thread

Returns:
True if this is the current thread

static void killall  )  [static]
 

Kills all other running threads. Ouch! Must be called from the main thread or it does nothing.

bool locked  )  const [inline]
 

Check if the thread is currently helding or attempting to lock a mutex

Returns:
True if the current thread is in an unsafe to cancel state

int locks  )  const [inline]
 

Count how many Yate mutexes are kept locked by this thread

Returns:
Number of Mutex locks held by this thread

static void msleep unsigned long  msec,
bool  exitCheck = false
[static]
 

Sleep for a number of milliseconds

Parameters:
msec Number of milliseconds to sleep
exitCheck Terminate the thread if asked so

const char* name  )  const
 

Get the name of this thread

Returns:
The pointer that was passed in the constructor

static void preExec  )  [static]
 

On some platforms this method kills all other running threads. Must be called after fork() but before any exec*() call.

static const char* priority Priority  prio  )  [static]
 

Convert a priority level to a textual name

Parameters:
prio Priority level to convert
Returns:
Name of the level or NULL if an invalid argument was provided

static Priority priority const char *  name,
Priority  defvalue = Normal
[static]
 

Convert a priority name to a thread priority level

Parameters:
name Name of the requested level
defvalue Priority to return in case of an invalid name
Returns:
A thread priority level

bool running  )  const
 

Check if the thread is running or not

Returns:
True if running, false if it has terminated or no startup called

static void sleep unsigned int  sec,
bool  exitCheck = false
[static]
 

Sleep for a number of seconds

Parameters:
sec Number of seconds to sleep
exitCheck Terminate the thread if asked so

bool startup  ) 
 

Actually starts running the new thread which lingers after creation

Returns:
False if an error occured, true if started ok

static void usleep unsigned long  usec,
bool  exitCheck = false
[static]
 

Sleep for a number of microseconds

Parameters:
usec Number of microseconds to sleep, may be rounded to milliseconds on some platforms
exitCheck Terminate the thread if asked so

static void yield bool  exitCheck = false  )  [static]
 

Give up the currently running timeslice. Note that on some platforms it also sleeps for the operating system's scheduler resolution

Parameters:
exitCheck Terminate the thread if asked so


The documentation for this class was generated from the following file:
Generated on Fri Jul 7 03:11:38 2006 for Yate by  doxygen 1.4.4