Threading Objects and Features

Explains the ThreadPool class, which enables you to request a thread to execute a task without having to do any thread management yourself.

Explains how to use a Timer to specify a delegate to be called at a specified time.

Explains how to use the Monitor class to synchronize access to a member or to build your own thread management types.

Describes the WaitHandle class, the abstract base class for event wait handles, mutexes, and semaphores, which enables waiting for multiple synchronization events.

Describes managed event wait handles, which are used to synchronize thread activities by signaling and waiting for signals.

Explains how to use a Mutexto synchronize access to an object or to build your own synchronization mechanisms.

Explains how to use the Interlocked class to increment or decrement a value and store the value in a single atomic operation.

Defines a lock that implements single-writer/multiple-reader semantics.

Describes Semaphore objects and explains how to use them to control access to limited resources.

Compares the features of the .NET Framework classes provided for locking and synchronizing managed threads.

Describes Barrier objects that implement the barrier pattern for coordination of threads in phased operations.

Describes SpinLock, a lightweight alternative to the Monitor class for certain low-level scenarios.

Describes CancellationToken, which is a lightweight object that can be used to implement cooperative cancellation between threads.

Describes SpinWait, a low level synchronization primitive that performs busy spinning prior to initiating a kernel-based wait.

Provides reference documentation for the Thread class, which represents a managed thread, whether it came from unmanaged code or was created in a managed application.

Enables background tasks that interact with the user interface, communicating via events raised on the user-interface thread.

Describes how I/O asynchronous completion ports use the thread pool to require processing only when an input/output operation completes.

Describes the recommended approach for multithreaded programming in the .NET Framework 4 and later.