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 manages and recycles individual Poco::Thread objects
to help reduce thread creation costs in programs that use threads.
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.