---
name: "corelinux_Thread"
section: "3"
platform: "linux"
package: "libcorelinux-dev"
version: "0.4.32-5"
release: "Debian 3.1 (Sarge)"
platforms: ["linux"]
url: "https://new.carta.tech/corelinux_Thread"
---

# corelinux\_Thread(3)

Thread is a framework for the creation, management, and destruction of caller threads.

## NAME

corelinux::Thread - **Thread** is a framework for the creation, management, and destruction of caller threads.

## SYNOPSIS

`#include <Thread.hpp>`

Inherits **corelinux::Synchronized**.

### Public Member Functions

**Thread** (void)  throw ( Assertion )\
 *Default constructor.*  virtual **~Thread** (void)\
 *Virtual destructor.*

### Static Public Member Functions

Int **getKernelError** (void)\
 *getKernelError returns the thread instance errno for the last kernel call the thread made*  ThreadIdentifier **getThreadIdentifier** (void)\
 *getThreadIdentifier retrieves the kernel process id for the caller thread*  ThreadIdentifier **getParentThreadIdentifier** (void)\
 *getParentThreadIdentifier retrieves the parent thread of the current thread.*  ThreadIdentifierCref **getThreadManagerIdentifier** (void)\
 *getThreadManagerIdentifier retrieves the thread that* **Thread** *was instantiated from*  **ThreadContextCref** **getThreadContext** (ThreadIdentifierCref)  throw ( InvalidThreadException )\
 *Retrieve a* **ThreadContext** *given a identifier.*  Count **getCreatedThreadCount** (void)\
 *Retrieve the number of created threads.*  Count **getActiveThreadCount** (void)\
 *Retrieve the number of threads that are starting or running.*  Count **getBlockedThreadCount** (void)\
 *Retrieve the number of threads that are waiting ro tun.*  Count **getCompletedThreadCount** (void)\
 *Retrieve the number of threads that are not starting or running or waiting to run.*  void **dump** (void)\
 *Debugging method for the moment.*  ThreadIdentifier **startThread** (**ThreadContextRef**)\
 *Start a thread as described by the context.*  Int **waitForThread** (ThreadIdentifierCref)  throw ( InvalidThreadException )\
 *Blocks the caller until the thread has ended execution, retrieving the return code from the associated thread context.*  void **destroyThreadContext** (ThreadIdentifierCref)  throw ( InvalidThreadException, Assertion )\
 *Destroys the managed context for the given identifier.*  Int **getThreadPriority** (ThreadIdentifierCref)  throw ( InvalidThreadException, Assertion )\
 *Get thread priority for the given indentifier.*  void **setThreadPriority** (ThreadIdentifierCref, Int)  throw ( InvalidThreadException, Assertion )\
 *Set thread priority for the given indentifier.*

### Protected Member Functions

**Thread** (**ThreadCref**)  throw ( Assertion )\
 *Copy constructor won't do, its a singleton.*  **ThreadRef** **operator=** (**ThreadCref**)  throw ( Assertion )\
 *Assignment operator won't do, we should never get here anyway but the compiler will generate the missing method.*  bool **operator==** (**ThreadCref**) const   throw ( Assertion )\
 *Equality operator not valid for class utility.*

### Static Protected Member Functions

void **threadTerminated** (Int, VoidPtr, VoidPtr)\

### Static Protected Attributes

**ThreadManager** **theThreadManager**\
 *The singleton instance of* **Thread** *for synchronization.*

## Detailed Description

**Thread** is a framework for the creation, management, and destruction of caller threads.

It accomplishes this by allowing the caller to setup a context for execution and calling their defined entry point. There is still much work to be done such as:

- •

  **Thread** completion notification and processing

- •

  Signal handling and masking

- •

  Subject/Observer relationships

- •

  Instrumentation

- •

  Testing...testing...testing!

## Constructor & Destructor Documentation

### corelinux::Thread::Thread (ThreadCref) throw ( Assertion )` [protected]`

Copy constructor won't do, its a singleton. **Parameters:**

*Thread* reference to another **Thread**

**Exceptions:**

*Assertion* NEVER\_GET\_HERE

## Member Function Documentation

### void corelinux::Thread::destroyThreadContext (ThreadIdentifierCref) throw ( InvalidThreadException, Assertion )` [static]`

Destroys the managed context for the given identifier. **Parameters:**

*ThreadIdentifier* unique thread id

**Exceptions:**

*InvalidThreadException* if the thread id is not one in the managed store. \
 *Assertion* if the thread is in a running state.

### Count corelinux::Thread::getActiveThreadCount (void)` [static]`

Retrieve the number of threads that are starting or running. **Returns:**

Count number of active threads

### Count corelinux::Thread::getBlockedThreadCount (void)` [static]`

Retrieve the number of threads that are waiting ro tun. **Returns:**

Count number of active threads

### Count corelinux::Thread::getCompletedThreadCount (void)` [static]`

Retrieve the number of threads that are not starting or running or waiting to run. **Returns:**

Count number of completed threads

### Count corelinux::Thread::getCreatedThreadCount (void)` [static]`

Retrieve the number of created threads. **Returns:**

Count number of active threads

### Int corelinux::Thread::getKernelError (void)` [static]`

getKernelError returns the thread instance errno for the last kernel call the thread made **Returns:**

Int errno for thread function

### ThreadIdentifier corelinux::Thread::getParentThreadIdentifier (void)` [static]`

getParentThreadIdentifier retrieves the parent thread of the current thread. **Returns:**

ThreadIdentifier identifies the parent

### ThreadContextCref corelinux::Thread::getThreadContext (ThreadIdentifierCref) throw ( InvalidThreadException )` [static]`

Retrieve a **ThreadContext** given a identifier. **Parameters:**

*ThreadIdentifier* unique id

**Returns:**

**ThreadContext** const reference

**Exceptions:**

*InvalidThreadException* if it does not exist.

### ThreadIdentifier corelinux::Thread::getThreadIdentifier (void)` [static]`

getThreadIdentifier retrieves the kernel process id for the caller thread **Returns:**

ThreadIdentifier identifies the caller

### ThreadIdentifierCref corelinux::Thread::getThreadManagerIdentifier (void)` [static]`

getThreadManagerIdentifier retrieves the thread that **Thread** was instantiated from **Returns:**

ThreadIdentifier identifies the owner

### Int corelinux::Thread::getThreadPriority (ThreadIdentifierCref) throw ( InvalidThreadException, Assertion )` [static]`

Get thread priority for the given indentifier. **Parameters:**

*ThreadIdentifier* unique thread id

**Exceptions:**

*InvalidThreadException* if the thread id is not one in the managed store. \
 *Assertion* if the thread is in a running state.

### ThreadRef corelinux::Thread::operator= (ThreadCref) throw ( Assertion )` [protected]`

Assignment operator won't do, we should never get here anyway but the compiler will generate the missing method. **Parameters:**

*Thread* reference to another **Thread**

**Returns:**

**Thread** reference to self

**Exceptions:**

*Assertion* NEVER\_GET\_HERE

### bool corelinux::Thread::operator== (ThreadCref) const throw ( Assertion )` [protected]`

Equality operator not valid for class utility. **Parameters:**

*Thread* reference to **Thread**

**Returns:**

bool True if equal

**Exceptions:**

*Assertion* NEVER\_GET\_HERE

### void corelinux::Thread::setThreadPriority (ThreadIdentifierCref, Int) throw ( InvalidThreadException, Assertion )` [static]`

Set thread priority for the given indentifier. **Parameters:**

*ThreadIdentifier* unique thread id \
 *prio* priority value

**Exceptions:**

*InvalidThreadException* if the thread id is not one in the managed store. \
 *Assertion* if the thread is in a running state.

### ThreadIdentifier corelinux::Thread::startThread (ThreadContextRef)` [static]`

Start a thread as described by the context. **Parameters:**

*ThreadContext* reference to thread context object. This object is copied into a managed context.

**Returns:**

ThreadIdentifier identifies the process/thread id as assigned by the operating system.

### Int corelinux::Thread::waitForThread (ThreadIdentifierCref) throw ( InvalidThreadException )` [static]`

Blocks the caller until the thread has ended execution, retrieving the return code from the associated thread context. **Parameters:**

*ThreadIdentifier* unique thread id

**Returns:**

Int return code from thread context

**Exceptions:**

*InvalidThreadException* if not a valid thread identifier.

## Author

Generated automatically by Doxygen for CoreLinux++ from the source code.
