thread.h(3)

NAME

thread.h - Synchronization and threading services.

SYNOPSIS

#include <cc++/config.h>
#include <ctime>
#include <pthread.h>
#include <time.h>
#include <signal.h>
#include <unistd.h>
Namespaces
namespace ost
Classes
class ost::Mutex
    The Mutex class is used to protect a section of code so that at any
    given time only a single thread can perform the protected
    operation.
class ost::MutexLock
    The MutexLock class is used to protect a section of code so that at
    any given time only a single thread can perform the protected
    operation.
class ost::ThreadLock
    The ThreadLock class impliments a thread rwlock for optimal reader
    performance on systems which have rwlock support, and reverts to a
    simple mutex for those that do not.
class ost::ReadLock
    The ReadLock class is used to protect a section of code through a
    ThreadLock for 'read' access to the member function.
class ost::WriteLock
    The WriteLock class is used to protect a section of code through a
    ThreadLock for 'write' access to the member function.
class ost::MutexCounter
    The Mutex Counter is a counter variable which can safely be
    incremented or decremented by multiple threads.
class ost::AtomicCounter
    The AtomicCounter class offers thread-safe manipulation of an
    integer counter.
class ost::Conditional
    A conditional variable synchcronization object for one to one and
    one to many signal and control events between processes.
class ost::Semaphore
    A semaphore is generally used as a synchronization object between
    multiple threads or to protect a limited and finite resource such
    as a memory or thread pool.
class ost::SemaphoreLock
    The SemaphoreLock class is used to protect a section of code
    through a semaphore so that only x instances of the member function
    may execute concurrently.
class ost::Event
    The Event class implements a feature originally found in the WIN32
    API; event notification.
class ost::Thread
    Every thread of execution in an application is created by
    instantiating an object of a class derived from the Thread class.
class ost::Cancellation
    A class to automatically set the thread cancellation mode of a
    member function.
class ost::PosixThread
class ost::ThreadKey
    This class allows the creation of a thread context unique 'pointer'
    that can be set and retrieved and can be used to create thread
    specific data areas for implementing 'thread safe' library
    routines.
class ost::TimerPort
    Timer ports are used to provide synchronized timing events when
    managed under a 'service thread' such as SocketService.
class ost::SysTime
    This class is used to access non-reentrant date and time functions
    in the standard C library.
Defines
#define CCXX_POSIX
#define TIMEOUT_INF   ~((timeout_t) 0)
#define ENTER_CRITICAL   enterMutex();
#define LEAVE_CRITICAL   leaveMutex();
#define ENTER_DEFERRED   setCancel(cancelDeferred);
#define LEAVE_DEFERRED   setCancel(cancelImmediate);
#define psleep(x)   (sleep)(x)
Typedefs
typedef pthread_t cctid_t
typedef unsigned long timeout_t
typedef int ost::signo_t
Functions
struct timespec * ost::getTimeout (struct timespec *spec, timeout_t
    timeout)
void ost::wait (signo_t signo)
Thread * ost::getThread (void)
struct tm * ost::localtime_r (const time_t *t, struct tm *b)
char * ost::ctime_r (const time_t *t, char *buf)
struct tm * ost::gmtime_r (const time_t *t, struct tm *b)
char * ost::asctime_r (const struct tm *tm, char *b)
Variables
class __EXPORT ost::Thread
class __EXPORT ost::ThreadKey
class __EXPORT ost::Conditional
class __EXPORT ost::Event

Detailed Description

Synchronization and threading services.

Define Documentation

#define CCXX_POSIX
#define ENTER_CRITICAL enterMutex();
#define ENTER_DEFERRED setCancel(cancelDeferred);
#define LEAVE_CRITICAL leaveMutex();
#define LEAVE_DEFERRED setCancel(cancelImmediate);
#define psleep(x) (sleep)(x) #define TIMEOUT_INF ~((timeout_t) 0)

Typedef Documentation

typedef pthread_t cctid_t
typedef unsigned long timeout_t

Author

Generated automatically by Doxygen for GNU CommonC++ from the source
code.

GNU CommonC++ 25 Aug 2008 thread.h(3)