Win32 Threading primitives
[Win32 Tools Library]

Collaboration diagram for Win32 Threading primitives:

Classes
class	IIOPool
	An interface to an I/O thread pool (usually based on an I/O completion port) that can have operations on buffers and handlers dispatched to it (either directly or as a result of an I/O completion packet being generated by some asynchronous I/O event) and that handles these events on one of the threads in the pool. More...
class	CIOPool
	An I/O thread pool implementing IIOPool. More...
class	CIOPool::WorkerThread
	A worker thread class for the CIOPool. More...
class	ICollectableThreadPool
class	IIOCPWorkerThreadCallback
	An interface to an object that acts as a worker thread for an I/O completion port driven work queue. The life-cycle of an object that implements this interface is as follows: one call to Initialise() (and, if it returns true), 0 or many calls to Process() and then one call to Shutdown(). More...
class	IManageThreadPoolThreads
	An interface to allow a thread pool to monitor the actions of the threads that it manages. More...
class	IMonitorThreadPool
	An interface to allow a class to monitor the operation of an instance of CThreadPool. Incrementing a counter when OnThreadPoolThreadStarted() is called and decrementing it when OnThreadPoolThreadStopped() is called will give you a count of the number of threads that are in the thread pool. A corresponding counter that is incremented in OnThreadPoolProcessingStarted() and decremented when OnThreadPoolProcessingStopped() is called will give a count of the threads that are currently processing work items. More...
class	CIOCompletionPort
	A simple wrapper around the I/O Completion Port API. I/O completion ports are, essentially, thread safe queues that can control how many threads are allowed to run and process items on the queue in a way that simply isn't possible if you stay entirely in "user mode". The queue keeps the threads that are waiting in fifo order to minimise memory paging and can limit the number of 'runable'threads that it releases. See here and here for more details. More...
class	IRunnable
	An interface to code that can be Run() on a thread. Usually passed to the CThread constructor. More...
class	IThreadPoolWorkerThreadFactory
	An interface to create instances of IIOCPWorkerThreadCallback. Usually passed to the CThreadPool constructor. More...
class	CThread
	A class that wraps the operating system Threading API and provides a thread object that runs code which implements the IRunnable interface. More...
class	CThreadAffinity
	A class that wraps the operating system SetThreadAffinityMask API. More...
class	CThreadedCallbackTimerQueue
	A class that manages a group of timers that implement IQueueTimers::Timer and which have their IQueueTimers::Timer::OnTimer() method called when the timer expires. The class uses an implementation of IManageTimerQueue to manage the timers and then manages its own timeouts using a thread to call IManageTimerQueue::HandleTimeouts() or IManageTimerQueue::BeginTimeoutHandling() every GetNextTimeout() milliseconds. You can configure it to use CCallbackTimerQueue, CCallbackTimerQueueEx or supply your own implementation of IManageTimerQueue and you can configure either lock held timer dispatch or no locks timer dispatch. See here for more details. More...
class	CThreadLocalStorage
	A class that wraps the operating system Thread Local Storage API. More...
class	CThreadPool
	A thread pool which can expand and contract (i.e. change the number of pooled threads) based on the work load. The pool has minimum and maximum sizes and a dispatch timeout. If dispatching a work item to a worker thread takes longer than the timeout then the pool is enlarged by one thread. There is also a maximum number of "dormant" threads, that is threads that are not working and when this number is reached worker threads are removed from the pool. The thread pool uses two I/O completion ports to do its work. Work items are dispatched to the dispatch port and are processed by the maintenance thread which dispatches the work items to the work port where the worker threads are waiting. This two layer dispatching means that dispatching from user code is fast but the pool can adjust its size depending on how long it takes for a worker thread to pick up a work item. Work items only ever queue on the dispatch port, the work port will only ever have a single work item on it at a time. More...
class	CThreadPool::WorkerThread
	A worker thread for the CThreadPool. The user work is done by an instance of IThreadPoolWorkerThread which is created by the supplied factory in the worker thread's constructor and destroyed in the destructor. More...
class	CThreadPoolCollection

---