The exception that is thrown when one thread acquires a System.Threading.Mutex object that another thread has abandoned by exiting without releasing it.

Specifies the apartment state of a System.Threading.Thread.

Provides the functionality to restore the migration, or flow, of the execution context between threads.

Notifies a waiting thread that an event has occurred. This class cannot be inherited.

Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases.

The exception that is thrown when the post-phase action of a System.Threading.Barrier fails

Propagates notification that operations should be canceled.

Represents a callback delegate that has been registered with a System.Threading.CancellationToken.

Signals to a System.Threading.CancellationToken that it should be canceled.

Provides methods for setting and capturing the compressed stack on the current thread. This class cannot be inherited.

Represents a method to be called within a new context.

Represents a synchronization primitive that is signaled when its count reaches zero.

Indicates whether an System.Threading.EventWaitHandle is reset automatically or manually after receiving a signal.

Represents a thread synchronization event.

Manages the execution context for the current thread. This class cannot be inherited.

Encapsulates and propagates the host execution context across threads.

Provides the functionality that allows a common language runtime host to participate in the flow, or migration, of the execution context.

Provides atomic operations for variables that are shared by multiple threads.

Receives the error code, number of bytes, and overlapped value type when an I/O operation completes on the thread pool.

Provides lazy initialization routines.

Specifies how a Lazy`1 instance synchronizes access among multiple threads.

Defines the lock that implements single-writer/multiple-reader semantics. This is a value type.

The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock.

Specifies whether a lock can be entered multiple times by the same thread.

Notifies one or more waiting threads that an event has occurred. This class cannot be inherited.

Provides a slimmed down version of System.Threading.ManualResetEvent.

Provides a mechanism that synchronizes access to objects.

A synchronization primitive that can also be used for interprocess synchronization.

Provides an explicit layout that is visible from unmanaged code and that will have the same layout as the Win32 OVERLAPPED structure with additional reserved fields at the end.

Provides a managed representation of a Win32 OVERLAPPED structure, including methods to transfer information from an System.Threading.Overlapped instance to a System.Threading.NativeOverlapped structure.

Represents the method that executes on a System.Threading.Thread.

Defines a lock that supports single writers and multiple readers.

Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing.

Represents a handle that has been registered when calling System.Threading.ThreadPool.RegisterWaitForSingleObject(System.Threading.WaitHandle, System.Threading.WaitOrTimerCallback, object, uint, bool). This class cannot be inherited.

Limits the number of threads that can access a resource or pool of resources concurrently.

The exception that is thrown when the erload:System.Threading.Semaphore.Release method is called on a semaphore whose count is already at the maximum.

A lightweight alternative to System.Threading.Semaphore that limits the number of threads that can access a resource or pool of resources concurrently.

Represents a method to be called when a message is to be dispatched to a synchronization context.

Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available.

Provides support for spin-based waiting.

Provides the basic functionality for propagating a synchronization context in various synchronization models.

The exception that is thrown when a method requires the caller to own the lock on a given Monitor, and the method is invoked by a caller that does not own that lock.

Creates and controls a thread, sets its priority, and gets its status.

The exception that is thrown when a call is made to the System.Threading.Thread.Abort(object) method. This class cannot be inherited.

Provides data for the System.Windows.Forms.Application.ThreadException event.

Represents the method that will handle the System.Windows.Forms.Application.ThreadException event of an System.Windows.Forms.Application.

The exception that is thrown when a System.Threading.Thread is interrupted while it is in a waiting state.

Provides thread-local storage of data.

Provides a pool of threads that can be used to execute tasks, post work items, process asynchronous I/O, wait on behalf of other threads, and process timers.

Specifies the scheduling priority of a System.Threading.Thread.

Represents the method that executes on a System.Threading.Thread.

The exception that is thrown when a failure occurs in a managed thread after the underlying operating system thread has been started, but before the thread is ready to execute user code.

Specifies the execution states of a System.Threading.Thread.

The exception that is thrown when a System.Threading.Thread is in an invalid System.Threading.Thread.ThreadState for the method call.

Contains constants that specify infinite time-out intervals. This class cannot be inherited.

Provides a mechanism for executing a method at specified intervals. This class cannot be inherited.

Represents the method that handles calls from a System.Threading.Timer.

Contains methods for performing volatile memory operations.

Represents a callback method to be executed by a thread pool thread.

Encapsulates operating system–specific objects that wait for exclusive access to shared resources.

The exception that is thrown when an attempt is made to open a system mutex or semaphore that does not exist.

Represents a method to be called when a System.Threading.WaitHandle is signaled or times out.