Overview

Classes: AbstractTimerCallback, ActiveDispatcher, ActiveMethod, ActiveResult, ActiveResultHolder, ActiveRunnable, ActiveRunnableBase, ActiveStarter, ActiveThreadPool, Activity, Condition, ErrorHandler, Event, FastMutex, Mutex, NullMutex, RWLock, Runnable, RunnableAdapter, ScopedLock, ScopedLockWithUnlock, ScopedRWLock, ScopedReadRWLock, ScopedUnlock, ScopedWriteRWLock, Semaphore, SignalHandler, SpinlockMutex, SynchronizedObject, TLSAbstractSlot, TLSSlot, Thread, ThreadLocal, ThreadLocalStorage, ThreadPool, ThreadTarget, Timer, TimerCallback

Classes

class AbstractTimerCallback

This is the base class for all instantiations of the TimerCallback template. 

class ActiveDispatcher

This class is used to implement an active object with strictly serialized method execution. 

class ActiveMethod

An active method is a method that, when called, executes in its own thread. 

class ActiveResult

Creates an ActiveResultHolder. 

class ActiveResultHolder

This class holds the result of an asynchronous method invocation. 

class ActiveRunnable

This class is used by ActiveMethod. 

class ActiveRunnableBase

The base class for all ActiveRunnable instantiations. 

class ActiveStarter

The default implementation of the StarterType policy for ActiveMethod. 

class ActiveThreadPool

A thread pool always keeps a number of threads running, ready to accept work. 

class Activity

This template class helps to implement active objects. 

class Condition

A Condition is a synchronization object used to block a thread until a particular condition is met. 

class ErrorHandler

This is the base class for thread error handlers. 

class Event

An Event is a synchronization object that allows one thread to signal one or more other threads that a certain event has happened. 

class FastMutex

A FastMutex (mutual exclusion) is similar to a Mutex. 

class Mutex

A Mutex (mutual exclusion) is a synchronization mechanism used to control access to a shared resource in a concurrent (multithreaded) scenario. 

class NullMutex

A NullMutex is an empty mutex implementation which performs no locking at all. 

class RWLock

A reader writer lock allows multiple concurrent readers or one exclusive writer. 

class Runnable

The Runnable interface with the run() method must be implemented by classes that provide an entry point for a thread. 

class RunnableAdapter

This adapter simplifies using ordinary methods as targets for threads. 

class ScopedLock

A class that simplifies thread synchronization with a mutex. 

class ScopedLockWithUnlock

A class that simplifies thread synchronization with a mutex. 

class ScopedRWLock

A variant of ScopedLock for reader/writer locks. 

class ScopedReadRWLock

A variant of ScopedLock for reader locks. 

class ScopedUnlock

A class that simplifies thread synchronization with a mutex. 

class ScopedWriteRWLock

A variant of ScopedLock for writer locks. 

class Semaphore

A Semaphore is a synchronization object with the following characteristics: A semaphore has a value that is constrained to be a non-negative integer and two atomic operations. 

class SignalHandler

This helper class simplifies the handling of POSIX signals. 

class SpinlockMutex

A SpinlockMutex, implemented in terms of std::atomic_flag, as busy-wait mutual exclusion. 

class SynchronizedObject

This class aggregates a Mutex and an Event and can act as a base class for all objects requiring synchronization in a multithreaded scenario. 

class TLSAbstractSlot

This is the base class for all objects that the ThreadLocalStorage class manages. 

class TLSSlot

The Slot template wraps another class so that it can be stored in a ThreadLocalStorage object. 

class Thread

This class implements a platform-independent wrapper to an operating system thread. 

class ThreadLocal

This template is used to declare type safe thread local variables. 

class ThreadLocalStorage

This class manages the local storage for each thread. 

class ThreadPool

A thread pool always keeps a number of threads running, ready to accept work. 

class ThreadTarget

This adapter simplifies using static member functions as well as standalone functions as targets for threads. 

class Timer

This class implements a thread-based timer. 

class TimerCallback

This template class implements an adapter that sits between a Timer and an object's method invoked by the timer.