# Thread Class Reference

Thread support class. More...

`#include <yateclass.h>`

Inheritance diagram for Thread:

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 Thread * | current ()
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

virtual void cleanup | ( |  | ) | `[virtual]`

This method is called when the current thread terminates.

Reimplemented in Router.

bool startup | ( |  | ) |

Actually starts running the new thread which lingers after creation

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

bool error | ( |  | ) | const

Check if the thread creation failed

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

bool running | ( |  | ) | const

Check if the thread is running or not

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

int locks | ( |  | ) | const`[inline]`

Count how many Yate mutexes are kept locked by this thread

Returns:
  Number of Mutex locks held by this thread

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

const char* name | ( |  | ) | const

Get the name of this thread

Returns:
  The pointer that was passed in the constructor

static const char* currentName | ( |  | ) | `[static]`

Get the name of the currently running thread

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

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

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

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

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 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 int count | ( |  | ) | `[static]`

Get the number of Yate created threads

Returns:
  Count of current Thread objects

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

static void exit | ( |  | ) | `[static]`

Terminates the current thread.

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

bool isCurrent | ( |  | ) | const`[inline]`

Check if this thread is the currently running thread

Returns:
  True if this is the current thread

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

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 void killall | ( |  | ) | `[static]`

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

static void preExec | ( |  | ) | `[static]`

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

The documentation for this class was generated from the following file:

- yateclass.h