4 minutes to read
In this article
[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the
latest documentation. ]
The System.Threading namespace provides classes and interfaces that enable multithreaded programming. In addition to classes for synchronizing thread activities and access to data (
Monitor, Interlocked, AutoResetEvent, and so on), this namespace includes a ThreadPool class that enables you to use a pool of system-supplied threads, and a Timer class that executes callback methods on thread pool threads. In addition to the features provided in the System.Threading namespace, the BackgroundWorker class provides a simple, event-based way to synchronize access to the main application thread. Classes
AbandonedMutexException The exception that is thrown when one thread acquires a
Mutex object that another thread has abandoned by exiting without releasing it.
AutoResetEvent Notifies a waiting thread that an event has occurred. This class cannot be inherited.
Barrier Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases.
BarrierPostPhaseException The exception that is thrown when the post-phase action of a
CancellationTokenSource Signals to a
CancellationToken that it should be canceled.
CountdownEvent Represents a synchronization primitive that is signaled when its count reaches zero.
EventWaitHandle Represents a thread synchronization event.
Interlocked Provides atomic operations for variables that are shared by multiple threads.
LazyInitializer Provides lazy initialization routines.
LockRecursionException The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock.
ManualResetEvent Notifies one or more waiting threads that an event has occurred. This class cannot be inherited.
ManualResetEventSlim Provides a slimmed down version of
Monitor Provides a mechanism that synchronizes access to objects.
Mutex A synchronization primitive that can also be used for interprocess synchronization.
Overlapped Provides a managed representation of a Win32
OVERLAPPED structure, including methods to transfer information from an Overlapped instance to a NativeOverlapped structure.
ReaderWriterLockSlim Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing.
RegisteredWaitHandle Represents a handle that has been registered when calling
RegisterWaitForSingleObject. This class cannot be inherited.
Semaphore Limits the number of threads that can access a resource or pool of resources concurrently.
SemaphoreFullException The exception that is thrown when the
Semaphore..::.Release method is called on a semaphore whose count is already at the maximum.
SemaphoreSlim A lightweight alternative to
Semaphore that limits the number of threads that can access a resource or pool of resources concurrently.
SynchronizationContext Provides the basic functionality for propagating a synchronization context in various synchronization models.
SynchronizationLockException 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.
Thread Creates and controls a thread, and gets its status.
ThreadAbortException The exception that is thrown when a call is made to the
Abort method. This class cannot be inherited.
ThreadLocal<(Of <(T>)>) Provides thread-local storage of data.
ThreadPool Provides a pool of threads that can be used to post work items, process asynchronous I/O, wait on behalf of other threads, and process timers.
ThreadStartException 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.
ThreadStateException The exception that is thrown when a
Thread is in an invalid ThreadState for the method call.
Timeout Contains a constant that is used to specify an infinite amount of time. This class cannot be inherited.
Timer Provides a mechanism for executing a method at specified intervals. This class cannot be inherited.
Volatile Contains methods for performing volatile memory operations.
WaitHandle Encapsulates operating system–specific objects that wait for exclusive access to shared resources.
WaitHandleCannotBeOpenedException The exception that is thrown when an attempt is made to open a system mutex or semaphore that does not exist.
CancellationToken Propagates notification that operations should be canceled.
CancellationTokenRegistration Represents a callback delegate that has been registered with a
NativeOverlapped 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.
SpinLock 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.
SpinWait Provides support for spin-based waiting.
BackgroundWorker Other Resources
How to use a background worker for Windows Phone 8