# Library Foundation

# Package Threading

## Overview

Classes: AbstractTimerCallback, ActiveDispatcher, ActiveMethod, ActiveResult, ActiveResultHolder, ActiveRunnable, ActiveRunnableBase, ActiveStarter, ActiveThreadPool, Activity, Condition, ErrorHandler, Event, FastMutex, IOLock, Mutex, NullMutex, RWLock, Runnable, RunnableAdapter, ScopedIOLock, 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 IOLock

IOLock provides synchronization for IO operations that may race with close/shutdown.

### 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 ScopedIOLock

ScopedIOLock is a RAII wrapper for IOLock that automatically calls leave() when the scope exits.

### 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.