System.Threading Namespace

L'espace de noms System.Threading fournit des classes et des interfaces permettant la programmation multithread. The System.Threading namespace provides classes and interfaces that enable multithreaded programming. En plus des classes destinées à la synchronisation des activités des threads et de l’accès aux données (Mutex, Monitor, Interlocked, AutoResetEvent, etc.), cet espace de noms comprend une classe ThreadPool qui permet d’utiliser un pool de threads fournis par le système et une classe Timer qui exécute des méthodes de rappel sur les threads du pool. In addition to classes for synchronizing thread activities and access to data (Mutex, Monitor, Interlocked, AutoResetEvent, and so on), this namespace includes a ThreadPool class that allows you to use a pool of system-supplied threads, and a Timer class that executes callback methods on thread pool threads.

Classes

AbandonedMutexException

Exception levée lorsqu'un thread acquiert un objet Mutex qu'un autre thread a abandonné en se terminant sans le libérer.The exception that is thrown when one thread acquires a Mutex object that another thread has abandoned by exiting without releasing it.

AsyncLocal<T>

Représente les données ambiantes qui sont locales à un flux de contrôle asynchrone donné, par exemple une méthode asynchrone.Represents ambient data that is local to a given asynchronous control flow, such as an asynchronous method.

AutoResetEvent

Représente un événement de synchronisation de threads qui, quand il est signalé, se réinitialise automatiquement après avoir libéré un thread en attente.Represents a thread synchronization event that, when signaled, resets automatically after releasing a single waiting thread. Cette classe ne peut pas être héritée.This class cannot be inherited.

Barrier

Permet à plusieurs tâches de coopérer en parallèle sur un algorithme via plusieurs phases.Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases.

BarrierPostPhaseException

L'exception levée lorsque l'action post-phase d'un Barrier échoue.The exception that is thrown when the post-phase action of a Barrier fails

CancellationTokenSource

Signale à un CancellationToken qu'il doit être annulé.Signals to a CancellationToken that it should be canceled.

CompressedStack

Fournit des méthodes pour définir et capturer la pile compressée sur le thread actuel.Provides methods for setting and capturing the compressed stack on the current thread. Cette classe ne peut pas être héritée.This class cannot be inherited.

CountdownEvent

Représente une primitive de synchronisation qui est signalée lorsque son décompte atteint zéro.Represents a synchronization primitive that is signaled when its count reaches zero.

EventWaitHandle

Représente un événement de synchronisation de threads.Represents a thread synchronization event.

ExecutionContext

Gère le contexte d'exécution du thread actuel.Manages the execution context for the current thread. Cette classe ne peut pas être héritée.This class cannot be inherited.

HostExecutionContext

Encapsule et propage le contexte d'exécution de l'hôte à travers des threads.Encapsulates and propagates the host execution context across threads.

HostExecutionContextManager

Fournit les fonctionnalités qui permettent à un hôte du Common Language Runtime de participer au flux, ou migration, du contexte d'exécution.Provides the functionality that allows a common language runtime host to participate in the flow, or migration, of the execution context.

Interlocked

Fournit des opérations atomiques pour des variables partagées par plusieurs threads.Provides atomic operations for variables that are shared by multiple threads.

LazyInitializer

Fournit des routines d'initialisation tardives.Provides lazy initialization routines.

LockRecursionException

L'exception levée lorsque l'entrée récursive dans un verrou n'est pas compatible avec la stratégie de récurrence pour le verrou.The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock.

ManualResetEvent

Représente un événement de synchronisation de thread qui, quand il est signalé, doit être réinitialisé manuellement.Represents a thread synchronization event that, when signaled, must be reset manually. Cette classe ne peut pas être héritée.This class cannot be inherited.

ManualResetEventSlim

Représente un événement de synchronisation de thread qui, quand il est signalé, doit être réinitialisé manuellement.Represents a thread synchronization event that, when signaled, must be reset manually. Cette classe est une alternative légère à ManualResetEvent.This class is a lightweight alternative to ManualResetEvent.

Monitor

Fournit un mécanisme qui synchronise l'accès aux objets.Provides a mechanism that synchronizes access to objects.

Mutex

Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus.A synchronization primitive that can also be used for interprocess synchronization.

Overlapped

Fournit une représentation managée d’une structure OVERLAPPED Win32, notamment les méthodes pour transférer des informations d’une instance Overlapped à une structure NativeOverlapped.Provides a managed representation of a Win32 OVERLAPPED structure, including methods to transfer information from an Overlapped instance to a NativeOverlapped structure.

PreAllocatedOverlapped

Représente l’état préalloué pour les opérations d’E/S natives avec chevauchement.Represents pre-allocated state for native overlapped I/O operations.

ReaderWriterLock

Définit un verrou qui prend en charge les writers uniques et les lecteurs multiples.Defines a lock that supports single writers and multiple readers.

ReaderWriterLockSlim

Représente un verrou utilisé pour gérer l'accès à une ressource, en autorisant plusieurs threads pour la lecture ou un accès exclusif en écriture.Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing.

RegisteredWaitHandle

Représente un handle inscrit lors de l'appel à RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean).Represents a handle that has been registered when calling RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean). Cette classe ne peut pas être héritée.This class cannot be inherited.

Semaphore

Limite le nombre de threads qui peuvent accéder simultanément à une ressource ou à un pool de ressources.Limits the number of threads that can access a resource or pool of resources concurrently.

SemaphoreFullException

Exception levée lorsque la méthode Release est appelée sur un sémaphore dont le compteur est déjà au maximum.The exception that is thrown when the Release method is called on a semaphore whose count is already at the maximum.

SemaphoreSlim

Représente une alternative légère à Semaphore qui limite le nombre de threads pouvant accéder simultanément à une ressource ou à un pool de ressources.Represents a lightweight alternative to Semaphore that limits the number of threads that can access a resource or pool of resources concurrently.

SynchronizationContext

Fournit les fonctionnalités de base pour propager un contexte de synchronisation dans plusieurs modèles de synchronisation.Provides the basic functionality for propagating a synchronization context in various synchronization models.

SynchronizationLockException

Exception levée lorsqu'une méthode exige de l'appelant qu'il possède un verrou sur un objet Monitor donné et que la méthode est appelée par un appelant qui ne possède pas ce verrou.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

Crée et contrôle un thread, définit sa priorité et obtient son état.Creates and controls a thread, sets its priority, and gets its status.

ThreadAbortException

Exception levée lors d'un appel adressé à la méthode Abort(Object).The exception that is thrown when a call is made to the Abort(Object) method. Cette classe ne peut pas être héritée.This class cannot be inherited.

ThreadExceptionEventArgs

Fournit des données pour l'événement ThreadException.Provides data for the ThreadException event.

ThreadingAclExtensions
ThreadInterruptedException

Exception levée lorsque l'interruption survient alors que Threadest en état d'attente.The exception that is thrown when a Thread is interrupted while it is in a waiting state.

ThreadLocal<T>

Fournit le stockage local des données de thread.Provides thread-local storage of data.

ThreadPool

Fournit un pool de threads qui peuvent servir à exécuter des tâches, publier des éléments de travail, traiter des E/S asynchrones, attendre au nom d’autres threads et traiter des minuteries.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.

ThreadPoolBoundHandle

Représente un handle d’E/S lié au pool de threads système et permet aux composants de bas niveau de recevoir des notifications pour les opérations d’E/S asynchrones.Represents an I/O handle that is bound to the system thread pool and enables low-level components to receive notifications for asynchronous I/O operations.

ThreadStartException

Exception levée lorsqu'une erreur se produit dans un thread managé après le démarrage du thread de système d'exploitation sous-jacent, mais avant que le thread soit prêt à exécuter le code utilisateur.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

Exception qui est levée lorsque Thread est dans un état ThreadState non valide pour l'appel de méthode.The exception that is thrown when a Thread is in an invalid ThreadState for the method call.

Timeout

Contient les constantes qui spécifient des intervalles de délai d'attente infinis.Contains constants that specify infinite time-out intervals. Cette classe ne peut pas être héritée.This class cannot be inherited.

Timer

Fournit un mécanisme permettant d'exécuter une méthode sur un thread de pool de threads à intervalles spécifiés.Provides a mechanism for executing a method on a thread pool thread at specified intervals. Cette classe ne peut pas être héritée.This class cannot be inherited.

Volatile

Contient des méthodes pour effectuer des opérations de mémoire volatile.Contains methods for performing volatile memory operations.

WaitHandle

Encapsule des objets spécifiques au système d'exploitation, qui attendent un accès exclusif aux ressources partagées.Encapsulates operating system-specific objects that wait for exclusive access to shared resources.

WaitHandleCannotBeOpenedException

Exception levée durant une tentative d’ouverture d’un mutex système, d’un sémaphore ou d’un handle d’attente d’événement qui n’existe pas.The exception that is thrown when an attempt is made to open a system mutex, semaphore, or event wait handle that does not exist.

WaitHandleExtensions

Fournit des méthodes pratiques pour utiliser un handle sécurisé pour un handle d'attente.Provides convenience methods to for working with a safe handle for a wait handle.

Structures

AsyncFlowControl

Fournit les fonctionnalités pour restaurer la migration, ou le flux, du contexte d'exécution entre threads.Provides the functionality to restore the migration, or flow, of the execution context between threads.

AsyncLocalValueChangedArgs<T>

Classe qui fournit les informations de modification des données aux instances de AsyncLocal<T> qui s'inscrivent pour les notifications de modification.The class that provides data change information to AsyncLocal<T> instances that register for change notifications.

CancellationToken

Propage une notification indiquant que des opérations doivent être annulées.Propagates notification that operations should be canceled.

CancellationTokenRegistration

Représente un délégué de rappel inscrit avec un CancellationToken.Represents a callback delegate that has been registered with a CancellationToken.

LockCookie

Définit le verrou qui implémente une sémantique writer unique / lecteurs multiples.Defines the lock that implements single-writer/multiple-reader semantics. Il s'agit d'un type valeur.This is a value type.

NativeOverlapped

Fournit une disposition explicite qui est visible à partir de code non managé et qui aura la même disposition que la structure Win32 OVERLAPPED avec des champs réservés supplémentaires à la fin.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

Fournit une primitive de verrou d'exclusion mutuelle où un thread, qui tente d'acquérir le verrou, attend dans une boucle en effectuant des vérifications de manière répétée jusqu'à ce que le verrou devienne disponible.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

Fournit une prise en charge de l'attente basée sur les spins.Provides support for spin-based waiting.

Interfaces

IThreadPoolWorkItem

Énumérations

ApartmentState

Spécifie l'état apartment (cloisonné) de Thread.Specifies the apartment state of a Thread.

EventResetMode

Indique si un EventWaitHandle est réinitialisé automatiquement ou manuellement après la réception d'un signal.Indicates whether an EventWaitHandle is reset automatically or manually after receiving a signal.

LazyThreadSafetyMode

Spécifie comment une instance de Lazy<T> synchronise l’accès entre plusieurs threads.Specifies how a Lazy<T> instance synchronizes access among multiple threads.

LockRecursionPolicy

Spécifie si un verrou peut être entré plusieurs fois par le même thread.Specifies whether a lock can be entered multiple times by the same thread.

ThreadPriority

Spécifie la priorité de planification de Thread.Specifies the scheduling priority of a Thread.

ThreadState

Spécifie les états d'exécution de Thread.Specifies the execution states of a Thread.

Délégués

ContextCallback

Représente une méthode à appeler dans un nouveau contexte.Represents a method to be called within a new context.

IOCompletionCallback

Reçoit le code d'erreur, le nombre d'octets et le type valeur chevauché lorsqu'une opération d'E/S est effectuée sur le pool de threads.Receives the error code, number of bytes, and overlapped value type when an I/O operation completes on the thread pool.

ParameterizedThreadStart

Représente la méthode qui s’exécute sur un élément Thread.Represents the method that executes on a Thread.

SendOrPostCallback

Représente une méthode à appeler lorsqu'un message doit être distribué à un contexte de synchronisation.Represents a method to be called when a message is to be dispatched to a synchronization context.

ThreadExceptionEventHandler

Représente la méthode qui gérera l’événement ThreadException d’un Application.Represents the method that will handle the ThreadException event of an Application.

ThreadStart

Représente la méthode qui s’exécute sur un élément Thread.Represents the method that executes on a Thread.

TimerCallback

Représente la méthode qui gère des appels d'un Timer.Represents the method that handles calls from a Timer.

WaitCallback

Représente une méthode de rappel qu'un thread du pool doit exécuter.Represents a callback method to be executed by a thread pool thread.

WaitOrTimerCallback

Représente une méthode à appeler lorsqu'un WaitHandle est signalé ou expire.Represents a method to be called when a WaitHandle is signaled or times out.