Thread Thread Thread Thread Class

Définition

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.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, System::Runtime::InteropServices::_Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
type Thread = class
    inherit CriticalFinalizerObject
    interface _Thread
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Implements _Thread
Héritage
Attributs
Implémente

Exemples

L’exemple suivant illustre la fonctionnalité de thread simple.The following example demonstrates simple threading functionality.

// [C++]
// Compile using /clr option.
using namespace System;
using namespace System::Threading;

// Simple threading scenario:  Start a Shared method running
// on a second thread.
public ref class ThreadExample
{
public:

   // The ThreadProc method is called when the thread starts.
   // It loops ten times, writing to the console and yielding 
   // the rest of its time slice each time, and then ends.
   static void ThreadProc()
   {
      for ( int i = 0; i < 10; i++ )
      {
         Console::Write(  "ThreadProc: " );
         Console::WriteLine( i );
         
         // Yield the rest of the time slice.
         Thread::Sleep( 0 );

      }
   }

};

int main()
{
   Console::WriteLine( "Main thread: Start a second thread." );
   
   // Create the thread, passing a ThreadStart delegate that
   // represents the ThreadExample::ThreadProc method.  For a 
   // delegate representing a static method, no object is
   // required.
   Thread^ oThread = gcnew Thread( gcnew ThreadStart( &ThreadExample::ThreadProc ) );
   
   // Start ThreadProc.  Note that on a uniprocessor, the new 
   // thread does not get any processor time until the main thread 
   // is preempted or yields.  Uncomment the Thread::Sleep that 
   // follows oThread->Start() to see the difference.
   oThread->Start();
   
   //Thread::Sleep(0);
   for ( int i = 0; i < 4; i++ )
   {
      Console::WriteLine(  "Main thread: Do some work." );
      Thread::Sleep( 0 );

   }
   Console::WriteLine(  "Main thread: Call Join(), to wait until ThreadProc ends." );
   oThread->Join();
   Console::WriteLine(  "Main thread: ThreadProc.Join has returned.  Press Enter to end program." );
   Console::ReadLine();
   return 0;
}

using System;
using System.Threading;

// Simple threading scenario:  Start a static method running
// on a second thread.
public class ThreadExample {
    // The ThreadProc method is called when the thread starts.
    // It loops ten times, writing to the console and yielding 
    // the rest of its time slice each time, and then ends.
    public static void ThreadProc() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("ThreadProc: {0}", i);
            // Yield the rest of the time slice.
            Thread.Sleep(0);
        }
    }

    public static void Main() {
        Console.WriteLine("Main thread: Start a second thread.");
        // The constructor for the Thread class requires a ThreadStart 
        // delegate that represents the method to be executed on the 
        // thread.  C# simplifies the creation of this delegate.
        Thread t = new Thread(new ThreadStart(ThreadProc));

        // Start ThreadProc.  Note that on a uniprocessor, the new 
        // thread does not get any processor time until the main thread 
        // is preempted or yields.  Uncomment the Thread.Sleep that 
        // follows t.Start() to see the difference.
        t.Start();
        //Thread.Sleep(0);

        for (int i = 0; i < 4; i++) {
            Console.WriteLine("Main thread: Do some work.");
            Thread.Sleep(0);
        }

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
        t.Join();
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.");
        Console.ReadLine();
    }
}
Imports System
Imports System.Threading

' Simple threading scenario:  Start a Shared method running
' on a second thread.
Public Class ThreadExample
    ' The ThreadProc method is called when the thread starts.
    ' It loops ten times, writing to the console and yielding 
    ' the rest of its time slice each time, and then ends.
    Public Shared Sub ThreadProc()
        Dim i As Integer
        For i = 0 To 9
            Console.WriteLine("ThreadProc: {0}", i)
            ' Yield the rest of the time slice.
            Thread.Sleep(0)
        Next
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Main thread: Start a second thread.")
        ' The constructor for the Thread class requires a ThreadStart 
        ' delegate.  The Visual Basic AddressOf operator creates this
        ' delegate for you.
        Dim t As New Thread(AddressOf ThreadProc)

        ' Start ThreadProc.  Note that on a uniprocessor, the new 
        ' thread does not get any processor time until the main thread 
        ' is preempted or yields.  Uncomment the Thread.Sleep that 
        ' follows t.Start() to see the difference.
        t.Start()
        'Thread.Sleep(0)

        Dim i As Integer
        For i = 1 To 4
            Console.WriteLine("Main thread: Do some work.")
            Thread.Sleep(0)
        Next

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
        t.Join()
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.")
        Console.ReadLine()
    End Sub
End Class

Ce code produit une sortie similaire à ce qui suit :This code produces output similar to the following:

[VB, C++, C#]  
Main thread: Start a second thread.  
Main thread: Do some work.  
ThreadProc: 0  
Main thread: Do some work.  
ThreadProc: 1  
Main thread: Do some work.  
ThreadProc: 2  
Main thread: Do some work.  
ThreadProc: 3  
Main thread: Call Join(), to wait until ThreadProc ends.  
ThreadProc: 4  
ThreadProc: 5  
ThreadProc: 6  
ThreadProc: 7  
ThreadProc: 8  
ThreadProc: 9  
Main thread: ThreadProc.Join has returned.  Press Enter to end program.  

Remarques

Quand un processus démarre, le common language runtime crée automatiquement un thread de premier plan pour exécuter le code d’application.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. En même temps que ce thread de premier plan principal, un processus peut créer un ou plusieurs threads pour exécuter une partie du code du programme associé au processus.Along with this main foreground thread, a process can create one or more threads to execute a portion of the program code associated with the process. Ces threads peuvent exécuter au premier plan ou en arrière-plan.These threads can execute either in the foreground or in the background. En outre, vous pouvez utiliser la ThreadPool classe pour exécuter du code sur les threads de travail qui sont gérés par le common language runtime.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

Dans cette sectionIn this section

À partir d’un thread Starting a thread
Récupération d’objets de Thread Retrieving Thread objects
Threads de premier plan et d’arrière-plan Foreground and background threads
Culture et des threads Culture and threads
Obtenir des informations sur et contrôler les threadsGetting information about and controlling threads

À partir d’un threadStarting a thread

Démarrer un thread en fournissant un délégué qui représente la méthode que le thread consiste à exécuter dans son constructeur de classe.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Vous appelez ensuite la Start méthode pour commencer l’exécution.You then call the Start method to begin execution.

Le Thread constructeurs peuvent prendre un des types de délégué deux, selon que vous pouvez passer un argument à la méthode à exécuter :The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Si la méthode n’a aucun argument, vous passez un ThreadStart déléguer au constructeur.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Il a la signature :It has the signature:

    public delegate void ThreadStart()  
    
    Public Delegate Sub ThreadStart()  
    

    L’exemple suivant crée et démarre un thread qui exécute le ExecuteInForeground (méthode).The following example creates and starts a thread that executes the ExecuteInForeground method. La méthode affiche des informations sur certaines propriétés de thread, puis exécute une boucle dans laquelle elle s’interrompt pendant une demi-seconde et affiche le nombre de secondes écoulé.The method displays information about some thread properties, then executes a loop in which it pauses for half a second and displays the elapsed number of seconds. Lorsque le thread a été exécutée pendant au moins cinq secondes, fin de la boucle et le thread se termine l’exécution.When the thread has executed for at least five seconds, the loop ends and the thread terminates execution.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start();
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...", 
                            Thread.CurrentThread.ManagedThreadId); 
       }
       
       private static void ExecuteInForeground()
       {
          DateTime start = DateTime.Now;
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do { 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= 5000);
          sw.Stop(); 
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.51 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.02 seconds
    //       Thread 3: Elapsed 1.53 seconds
    //       Thread 3: Elapsed 2.05 seconds
    //       Thread 3: Elapsed 2.55 seconds
    //       Thread 3: Elapsed 3.07 seconds
    //       Thread 3: Elapsed 3.57 seconds
    //       Thread 3: Elapsed 4.07 seconds
    //       Thread 3: Elapsed 4.58 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start()
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground()
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= 5000
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.51 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.02 seconds
    '       Thread 3: Elapsed 1.53 seconds
    '       Thread 3: Elapsed 2.05 seconds
    '       Thread 3: Elapsed 2.55 seconds
    '       Thread 3: Elapsed 3.07 seconds
    '       Thread 3: Elapsed 3.57 seconds
    '       Thread 3: Elapsed 4.07 seconds
    '       Thread 3: Elapsed 4.58 seconds
    
  • Si la méthode possède un argument, vous passez un ParameterizedThreadStart déléguer au constructeur.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Il a la signature :It has the signature:

    public delegate void ParameterizedThreadStart(object obj)  
    
    Public Delegate Sub ParameterizedThreadStart(obj As Object)  
    

    La méthode exécutée par le délégué peut ensuite effectuer un cast (en c#) ou convertir (en Visual Basic) le paramètre du type approprié.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    L’exemple suivant est identique au précédent, excepté qu’il appelle le Thread(ParameterizedThreadStart) constructeur.The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Cette version de la ExecuteInForeground méthode possède un paramètre unique qui représente le nombre approximatif de millisecondes de la boucle doit s’exécuter.This version of the ExecuteInForeground method has a single parameter that represents the approximate number of milliseconds the loop is to execute.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start(4500);
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...", 
                            Thread.CurrentThread.ManagedThreadId); 
       }
       
       private static void ExecuteInForeground(Object obj)
       {
          int interval;
          try {
             interval = (int) obj;
          }
          catch (InvalidCastException) {
             interval = 5000;
          }
          DateTime start = DateTime.Now;
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do { 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= interval);
          sw.Stop(); 
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.52 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.03 seconds
    //       Thread 3: Elapsed 1.55 seconds
    //       Thread 3: Elapsed 2.06 seconds
    //       Thread 3: Elapsed 2.58 seconds
    //       Thread 3: Elapsed 3.09 seconds
    //       Thread 3: Elapsed 3.61 seconds
    //       Thread 3: Elapsed 4.12 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start(4500)
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground(obj As Object)
          Dim interval As Integer
          If IsNumeric(obj) Then
             interval = CInt(obj)
          Else
             interval = 5000
          End If   
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= interval
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.52 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.03 seconds
    '       Thread 3: Elapsed 1.55 seconds
    '       Thread 3: Elapsed 2.06 seconds
    '       Thread 3: Elapsed 2.58 seconds
    '       Thread 3: Elapsed 3.09 seconds
    '       Thread 3: Elapsed 3.61 seconds
    '       Thread 3: Elapsed 4.12 seconds
    

Il n’est pas nécessaire de conserver une référence à un Thread une fois que vous avez démarré le thread de l’objet.It is not necessary to retain a reference to a Thread object once you have started the thread. Le thread continue à s’exécuter jusqu'à la fin de la procédure de thread.The thread continues to execute until the thread procedure is complete.

Récupération d’objets de ThreadRetrieving Thread objects

Vous pouvez utiliser la méthode statique (Shared en Visual Basic) CurrentThread propriété à récupérer une référence au thread en cours d’exécution à partir du code que le thread s’exécute.You can use the static (Shared in Visual Basic) CurrentThread property to retrieve a reference to the currently executing thread from the code that the thread is executing. L’exemple suivant utilise le CurrentThread propriété pour afficher des informations sur le thread principal de l’application, un autre thread de premier plan, un thread d’arrière-plan et un thread de pool de threads.The following example uses the CurrentThread property to display information about the main application thread, another foreground thread, a background thread, and a thread pool thread.

using System;
using System.Threading;

public class Example
{
   static Object obj = new Object();
   
   public static void Main()
   {
      ThreadPool.QueueUserWorkItem(ShowThreadInformation);
      var th1 = new Thread(ShowThreadInformation);
      th1.Start();
      var th2 = new Thread(ShowThreadInformation);
      th2.IsBackground = true;
      th2.Start();
      Thread.Sleep(500);
      ShowThreadInformation(null); 
   }
   
   private static void ShowThreadInformation(Object state)
   {
      lock (obj) {
         var th  = Thread.CurrentThread;
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId);
         Console.WriteLine("   Background thread: {0}", th.IsBackground);
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread);
         Console.WriteLine("   Priority: {0}", th.Priority);
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name);
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
Imports System.Threading

Module Example
   Private lock As New Object()
                    
   Public Sub Main()
      ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
      Dim th1 As New Thread(AddressOf ShowThreadInformation)
      th1.Start()
      Dim th2 As New Thread(AddressOf ShowThreadInformation)
      th2.IsBackground = True
      th2.Start()
      Thread.Sleep(500)
      ShowThreadInformation(Nothing) 
   End Sub
   
   Private Sub ShowThreadInformation(state As Object)
      SyncLock lock
         Dim th As Thread = Thread.CurrentThread
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
         Console.WriteLine("   Background thread: {0}", th.IsBackground)
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread)
         Console.WriteLine("   Priority: {0}", th.Priority)
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name)
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name)
         Console.WriteLine()
      End SyncLock
   End Sub
End Module
' The example displays output like the following:
'       ' Managed thread #6:
'          Background thread: True
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #3:
'          Background thread: True
'          Thread pool thread: True
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #4:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #1:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US

Threads de premier plan et d’arrière-planForeground and background threads

Instances de la Thread classe représentent les threads de premier plan ou de threads d’arrière-plan.Instances of the Thread class represent either foreground threads or background threads. Threads d’arrière-plan sont identiques aux threads de premier plan à une exception près : un thread d’arrière-plan ne conserve pas un processus exécuté si tous les threads de premier plan sont terminés.Background threads are identical to foreground threads with one exception: a background thread does not keep a process running if all foreground threads have terminated. Une fois que tous les threads de premier plan ont été arrêtés, le runtime arrête tous les threads d’arrière-plan et s’arrête.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Par défaut, les threads suivants s’exécutent au premier plan :By default, the following threads execute in the foreground:

  • Le thread principal de l’application.The main application thread.

  • Tous les threads créés en appelant un Thread constructeur de classe.All threads created by calling a Thread class constructor.

Les threads suivants s’exécutent en arrière-plan par défaut :The following threads execute in the background by default:

  • Thread du pool de threads, qui constituent un pool de threads de travail géré par le runtime.Thread pool threads, which are a pool of worker threads maintained by the runtime. Vous pouvez configurer le travail de pool et de planification de thread sur les threads du pool à l’aide de la ThreadPool classe.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Note

    Opérations asynchrones basées sur la tâche s’exécute automatiquement sur les threads du pool.Task-based asynchronous operations automatically execute on thread pool threads. Utilisent des opérations asynchrones basées sur une tâche le Task et Task<TResult> classes pour implémenter le modèle asynchrone basé sur les tâches.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Tous les threads qui entrent dans l’environnement d’exécution managé à partir de code non managé.All threads that enter the managed execution environment from unmanaged code.

Vous pouvez modifier un thread d’exécuter en arrière-plan en définissant le IsBackground propriété à tout moment.You can change a thread to execute in the background by setting the IsBackground property at any time. Threads d’arrière-plan sont utiles pour toute opération qui doit se poursuivre tant qu’une application est en cours d’exécution mais ne doit pas empêcher l’application à partir de la fin d’exécution, comme la surveillance des modifications de système de fichiers ou les connexions de socket entrante.Background threads are useful for any operation that should continue as long as an application is running but should not prevent the application from terminating, such as monitoring file system changes or incoming socket connections.

L’exemple suivant illustre la différence entre les threads de premier plan et d’arrière-plan.The following example illustrates the difference between foreground and background threads. C’est comme le premier exemple dans le à partir d’un thread section, sauf qu’il définit le thread de s’exécuter en arrière-plan avant de le démarrer.It is like the first example in the Starting a thread section, except that it sets the thread to execute in the background before starting it. Comme le montre la sortie, la boucle est interrompue avant de s’exécuter pendant cinq secondes.As the output shows, the loop is interrupted before it executes for five seconds.

using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   public static void Main()
   {
      var th = new Thread(ExecuteInForeground);
      th.IsBackground = true;
      th.Start();
      Thread.Sleep(1000);
      Console.WriteLine("Main thread ({0}) exiting...", 
                        Thread.CurrentThread.ManagedThreadId); 
   }
   
   private static void ExecuteInForeground()
   {
      DateTime start = DateTime.Now;
      var sw = Stopwatch.StartNew();
      Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority);
      do { 
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         Thread.Sleep(500);
      } while (sw.ElapsedMilliseconds <= 5000);
      sw.Stop(); 
   }
}
// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...
Imports System.Diagnostics
Imports System.Threading

Module Example
   Public Sub Main()
      Dim th As New Thread(AddressOf ExecuteInForeground)
      th.IsBackground = True
      th.Start()
      Thread.Sleep(1000)
      Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
   End Sub
   
   Private Sub ExecuteInForeground()
      Dim start As DateTime = DateTime.Now
      Dim sw As Stopwatch = Stopwatch.StartNew()
      Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority)
      Do 
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000)
         Thread.Sleep(500)
      Loop While sw.ElapsedMilliseconds <= 5000
      sw.Stop() 
   End Sub
End Module
' The example displays output like the following:
'       Thread 3: Background, Priority Normal
'       Thread 3: Elapsed 0.00 seconds
'       Thread 3: Elapsed 0.51 seconds
'       Main thread (1) exiting...

Culture et des threadsCulture and threads

Chaque thread possède une culture, représentée par le CurrentCulture propriété et une culture d’interface utilisateur, représentée par le CurrentUICulture propriété.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. La culture actuelle prend en charge ces opérations dépendantes de la culture en tant que l’analyse et mise en forme, comparaison de chaînes et le tri et contrôle également le système d’écriture et le calendrier utilisé par un thread.The current culture supports such culture-sensitive operations as parsing and formatting, string comparison and sorting, and also controls the writing system and calendar used by a thread. La culture d’interface utilisateur actuelle fournit pour la récupération de la culture des ressources dans les fichiers de ressources.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Important

Le CurrentCulture et CurrentUICulture propriétés ne fonctionnent de façon fiable lorsqu’il est utilisé avec n’importe quel thread autre que le thread actuel.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. Dans .NET Framework, la lecture de ces propriétés est fiable, bien que la définition de ces propriétés pour un thread autre que le thread actuel n’est pas.In .NET Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. Sur .NET Core, un InvalidOperationException est levée si un thread tente de lire ou écrire ces propriétés sur un thread différent.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. Nous vous recommandons d’utiliser le CultureInfo.CurrentCulture et CultureInfo.CurrentUICulture propriétés à récupérer et définir la culture actuelle.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

Quand un nouveau thread est instancié, sa culture et la culture d’interface utilisateur sont définis par la culture système actuelle et la culture d’interface utilisateur et non par la culture et la culture d’interface utilisateur du thread à partir duquel le nouveau thread est créé.When a new thread is instantiated, its culture and UI culture are defined by the current system culture and UI culture, and not by the culture and UI culture of the thread from which the new thread is created. Cela signifie, par exemple, que si la culture système actuelle est anglais (États-Unis) et la culture actuelle du thread d’application principal est le Français (France), la culture d’un nouveau thread créé en appelant le Thread(ParameterizedThreadStart) constructeur à partir du thread principal est anglais (États-Unis) et pas Français (France).This means, for example, that if the current system culture is English (United States) and the current culture of the primary application thread is French (France), the culture of a new thread created by calling the Thread(ParameterizedThreadStart) constructor from the primary thread is English (United States), and not French (France). Pour plus d’informations, consultez la section « Culture et threads » de la CultureInfo rubrique de la classe.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Important

Cela n’est pas vrai pour les threads qui exécutent des opérations asynchrones pour les applications qui ciblent le .NET Framework 4.6.NET Framework 4.6 et versions ultérieures, dans ce cas, la culture et la culture d’interface utilisateur fait partie d’une commande asynchrone contexte des opérations ; le thread sur lequel une opération asynchrone s’exécute par défaut hérite de la culture et la culture d’interface utilisateur du thread à partir duquel l’opération asynchrone a été lancée.This is not true of threads that execute asynchronous operations for apps that target the .NET Framework 4.6.NET Framework 4.6 and later versions, In this case, the culture and UI culture is part of an asynchronous operations' context; the thread on which an asynchronous operation executes by default inherits the culture and UI culture of the thread from which the asynchronous operation was launched. Pour plus d'informations, consultez la section « Culture et opérations asynchrones basées sur les tâches » de la rubrique relative à la classe CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

Vous pouvez effectuer l’une des opérations suivantes pour vous assurer que tous les threads de l’exécution dans une application partagent la même culture et la culture d’interface utilisateur :You can do either of the following to ensure that all of the threads executing in an application share the same culture and UI culture:

Pour plus d’informations et des exemples, consultez la section « Culture et threads » de la CultureInfo rubrique de la classe.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Obtenir des informations sur et contrôler les threadsGetting information about and controlling threads

Vous pouvez récupérer un nombre de valeurs de propriétés qui fournissent des informations sur un thread.You can retrieve a number of property values that provide information about a thread. Dans certains cas, vous pouvez également définir ces valeurs de propriété pour contrôler le fonctionnement du thread.In some cases, you can also set these property values to control the operation of the thread. Ces propriétés de thread sont les suivantes :These thread properties include:

  • Nom.A name. Name est une écriture-propriété une fois que vous pouvez utiliser pour identifier un thread.Name is a write-once property that you can use to identify a thread. Sa valeur par défaut est null.Its default value is null.

  • Un code de hachage, vous pouvez récupérer en appelant le GetHashCode (méthode).A hash code, which you can retrieve by calling the GetHashCode method. Le code de hachage peut être utilisé pour identifier de façon unique un thread ; pour la durée de vie de votre thread, son code de hachage ne sera pas entrer en conflit avec la valeur à partir de n’importe quel autre thread, quel que soit le domaine d’application à partir de laquelle vous obtenez la valeur.The hash code can be used to uniquely identify a thread; for the lifetime of your thread, its hash code will not collide with the value from any other thread, regardless of the application domain from which you obtain the value.

  • Un ID de thread.A thread ID. La valeur de la lecture seule ManagedThreadId propriété est attribuée par le runtime et identifie de façon unique un thread au sein de son processus.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    Note

    Un ID de thread de système d'exploitation n'est pas lié de manière fixe à un thread managé, car un hôte non managé peut contrôler la relation entre les threads managés et les threads non managés.An operating-system ThreadId has no fixed relationship to a managed thread, because an unmanaged host can control the relationship between managed and unmanaged threads. Plus précisément, un hôte élaboré peut utiliser le API d’hébergement CLR pour planifier de nombreux threads managés sur le même thread de système d’exploitation, ou pour déplacer un thread managé entre les threads de système d’exploitation différent.Specifically, a sophisticated host can use the CLR Hosting API to schedule many managed threads against the same operating system thread, or to move a managed thread between different operating system threads.

  • L’état du thread actuel.The thread's current state. Pendant la durée de son existence, un thread se trouve toujours dans un ou plusieurs des états définis par le ThreadState propriété.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Un niveau de priorité de planification est défini par le ThreadPriority propriété.A scheduling priority level, which is defined by the ThreadPriority property. Bien que vous pouvez définir cette valeur pour demander une priorité de thread, il n’est pas garanti à être respectées par le système d’exploitation.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • En lecture seule IsThreadPoolThread propriété, qui indique si un thread est un thread de pool de threads.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • La propriété IsBackground.The IsBackground property. Pour plus d’informations, consultez le les threads de premier plan et arrière-plan section.For more information, see the Foreground and background threads section.

Constructeurs

Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart)

Initialise une nouvelle instance de la classe Thread, en spécifiant un délégué qui permet à un objet d'être passé au thread quand le thread est démarré.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started.

Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32)

Initialise une nouvelle instance de la classe Thread, en spécifiant un délégué qui permet à un objet d'être passé au thread quand le thread est démarré et en spécifiant la taille de pile maximale pour le thread.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started and specifying the maximum stack size for the thread.

Thread(ThreadStart) Thread(ThreadStart) Thread(ThreadStart) Thread(ThreadStart)

Initialise une nouvelle instance de la classe Thread.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) Thread(ThreadStart, Int32)

Initialise une nouvelle instance de la classe Thread, en spécifiant la taille de pile maximale pour le thread.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Propriétés

ApartmentState ApartmentState ApartmentState ApartmentState

Obtient ou définit l'état de cloisonnement de ce thread.Gets or sets the apartment state of this thread.

CurrentContext CurrentContext CurrentContext CurrentContext

Obtient le contexte actuel dans lequel le thread s'exécute.Gets the current context in which the thread is executing.

CurrentCulture CurrentCulture CurrentCulture CurrentCulture

Obtient ou définit la culture du thread actuel.Gets or sets the culture for the current thread.

CurrentPrincipal CurrentPrincipal CurrentPrincipal CurrentPrincipal

Obtient ou définit le principal actuel du thread (pour une sécurité basée sur les rôles).Gets or sets the thread's current principal (for role-based security).

CurrentThread CurrentThread CurrentThread CurrentThread

Obtient le thread en cours d'exécution.Gets the currently running thread.

CurrentUICulture CurrentUICulture CurrentUICulture CurrentUICulture

Obtient ou définit la culture actuelle utilisée par le Gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext ExecutionContext ExecutionContext ExecutionContext

Obtient un objet ExecutionContext qui contient des informations relatives aux divers contextes du thread actuel.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive IsAlive IsAlive IsAlive

Obtient une valeur indiquant l'état de l'exécution du thread actuel.Gets a value indicating the execution status of the current thread.

IsBackground IsBackground IsBackground IsBackground

Obtient ou définit une valeur indiquant si le thread est un thread d'arrière-plan ou non.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread IsThreadPoolThread IsThreadPoolThread IsThreadPoolThread

Obtient une valeur indiquant si un thread appartient au pool de threads managés ou non.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId ManagedThreadId ManagedThreadId ManagedThreadId

Obtient un identificateur unique pour le thread managé actuel.Gets a unique identifier for the current managed thread.

Name Name Name Name

Obtient ou définit le nom du thread.Gets or sets the name of the thread.

Priority Priority Priority Priority

Obtient ou définit une valeur indiquant la priorité de planification d'un thread.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState ThreadState ThreadState ThreadState

Obtient une valeur contenant les états du thread actuel.Gets a value containing the states of the current thread.

Méthodes

Abort() Abort() Abort() Abort()

Déclenche ThreadAbortException dans le thread sur lequel l'appel a lieu pour commencer le processus d'arrêt du thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. L'appel de cette méthode arrête généralement le thread.Calling this method usually terminates the thread.

Abort(Object) Abort(Object) Abort(Object) Abort(Object)

Déclenche une ThreadAbortException dans le thread sur lequel l'appel a lieu pour commencer le processus d'arrêt du thread, tout en fournissant des informations sur les exceptions relatives à l'arrêt du thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. L'appel de cette méthode arrête généralement le thread.Calling this method usually terminates the thread.

AllocateDataSlot() AllocateDataSlot() AllocateDataSlot() AllocateDataSlot()

Alloue sur tous les threads un emplacement de données sans nom.Allocates an unnamed data slot on all the threads. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String) AllocateNamedDataSlot(String) AllocateNamedDataSlot(String) AllocateNamedDataSlot(String)

Alloue sur tous les threads un emplacement de données nommé.Allocates a named data slot on all threads. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

BeginCriticalRegion() BeginCriticalRegion() BeginCriticalRegion() BeginCriticalRegion()

Avertit un hôte que l'exécution est sur le point d'entrer dans une zone de code dans laquelle les effets d'un abandon de thread ou d'une exception non gérée peuvent compromettre d'autres tâches dans le domaine d'application.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception might jeopardize other tasks in the application domain.

BeginThreadAffinity() BeginThreadAffinity() BeginThreadAffinity() BeginThreadAffinity()

Avertit un hôte que le code managé est sur le point d'exécuter des instructions qui dépendent de l'identité du thread du système d'exploitation physique actuel.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup() DisableComObjectEagerCleanup() DisableComObjectEagerCleanup() DisableComObjectEagerCleanup()

Désactive le nettoyage automatique des wrappers RCW (Runtime Callable Wrapper) pour le thread actuel.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current thread.

EndCriticalRegion() EndCriticalRegion() EndCriticalRegion() EndCriticalRegion()

Avertit un hôte que l’exécution est sur le point d’entrer dans une zone de code dans laquelle les effets d’un abandon de thread ou d’une exception non gérée sont limités à la tâche actuelle.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception are limited to the current task.

EndThreadAffinity() EndThreadAffinity() EndThreadAffinity() EndThreadAffinity()

Avertit un hôte que le code managé a terminé l'exécution des instructions qui dépendent de l'identité du thread du système d'exploitation physique actuel.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Vérifie que les ressources sont libérées et que toute autre opération de nettoyage est effectuée quand le garbage collector récupère l'objet Thread.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String) FreeNamedDataSlot(String) FreeNamedDataSlot(String) FreeNamedDataSlot(String)

Élimine l'association entre un nom et un emplacement pour tous les threads du processus.Eliminates the association between a name and a slot, for all threads in the process. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState() GetApartmentState() GetApartmentState() GetApartmentState()

Retourne une valeur ApartmentState qui indique l'état de cloisonnement.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack() GetCompressedStack() GetCompressedStack() GetCompressedStack()

Retourne un objet CompressedStack qui peut être utilisé pour capturer la pile pour le thread actuel.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId() GetCurrentProcessorId() GetCurrentProcessorId() GetCurrentProcessorId()
GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot)

Récupère la valeur de l'emplacement spécifié sur le thread actif, dans le domaine actuel du thread actif.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain() GetDomain() GetDomain() GetDomain()

Retourne le domaine actuel dans lequel le thread actif est en cours d'exécution.Returns the current domain in which the current thread is running.

GetDomainID() GetDomainID() GetDomainID() GetDomainID()

Retourne un identificateur unique de domaine d'application.Returns a unique application domain identifier.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne un code de hachage pour le thread actuel.Returns a hash code for the current thread.

GetNamedDataSlot(String) GetNamedDataSlot(String) GetNamedDataSlot(String) GetNamedDataSlot(String)

Recherche un emplacement de données nommé.Looks up a named data slot. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
Interrupt() Interrupt() Interrupt() Interrupt()

Interrompt un thread dont l'état est WaitSleepJoin.Interrupts a thread that is in the WaitSleepJoin thread state.

Join() Join() Join() Join()

Bloque le thread appelant jusqu’à ce que le thread représenté par cette instance s’arrête, tout en continuant d’exécuter le pompage COM et SendMessage standard.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

Join(Int32) Join(Int32) Join(Int32) Join(Int32)

Bloque le thread appelant jusqu'à ce que le thread représenté par cette instance s'arrête ou que la durée spécifiée soit écoulée, tout en continuant d'exécuter le pompage COM et SendMessage standard.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

Join(TimeSpan) Join(TimeSpan) Join(TimeSpan) Join(TimeSpan)

Bloque le thread appelant jusqu'à ce que le thread représenté par cette instance s'arrête ou que la durée spécifiée soit écoulée, tout en continuant d'exécuter le pompage COM et SendMessage standard.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
MemoryBarrier() MemoryBarrier() MemoryBarrier() MemoryBarrier()

Synchronise l’accès à la mémoire comme suit : le processeur qui exécute le thread actuel ne peut pas réorganiser les instructions de sorte que les accès à la mémoire antérieurs à l’appel de MemoryBarrier() s’exécutent après les accès à la mémoire postérieurs à l’appel de MemoryBarrier().Synchronizes memory access as follows: The processor executing the current thread cannot reorder instructions in such a way that memory accesses prior to the call to MemoryBarrier() execute after memory accesses that follow the call to MemoryBarrier().

ResetAbort() ResetAbort() ResetAbort() ResetAbort()

Annule un Abort(Object) demandé pour le thread actuel.Cancels an Abort(Object) requested for the current thread.

Resume() Resume() Resume() Resume()

Reprend un thread qui a été suspendu.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) SetApartmentState(ApartmentState)

Définit l'état de cloisonnement d'un thread avant qu'il ne soit démarré.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack)

Applique une CompressedStack capturée au thread actuel.Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object)

Définit les données dans l'emplacement spécifié sur le thread en cours d'exécution, pour le domaine actuel de ce thread.Sets the data in the specified slot on the currently running thread, for that thread's current domain. Pour de meilleures performances, utilisez à la place les champs marqués avec l'attribut ThreadStaticAttribute.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32) Sleep(Int32) Sleep(Int32) Sleep(Int32)

Suspend le thread actuel pendant le nombre spécifié de millisecondes.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan) Sleep(TimeSpan) Sleep(TimeSpan) Sleep(TimeSpan)

Suspend le thread actuel pendant la durée spécifiée.Suspends the current thread for the specified amount of time.

SpinWait(Int32) SpinWait(Int32) SpinWait(Int32) SpinWait(Int32)

Provoque l'attente d'un thread pendant le nombre de fois défini par le paramètre iterations.Causes a thread to wait the number of times defined by the iterations parameter.

Start() Start() Start() Start()

Provoque le changement, par le système d'exploitation, de l'état de l'instance actuelle en Running.Causes the operating system to change the state of the current instance to Running.

Start(Object) Start(Object) Start(Object) Start(Object)

Provoque le changement, par le système d'exploitation, de l'état de l'instance actuelle en Running, et fournit éventuellement un objet contenant les données que la méthode exécutée par le thread doit utiliser.Causes the operating system to change the state of the current instance to Running, and optionally supplies an object containing data to be used by the method the thread executes.

Suspend() Suspend() Suspend() Suspend()

Suspend le thread ou, s'il est déjà suspendu, n'a aucun effet.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState)

Définit l'état de cloisonnement d'un thread avant qu'il ne soit démarré.Sets the apartment state of a thread before it is started.

VolatileRead(Byte) VolatileRead(Byte) VolatileRead(Byte) VolatileRead(Byte)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Double) VolatileRead(Double) VolatileRead(Double) VolatileRead(Double)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int16) VolatileRead(Int16) VolatileRead(Int16) VolatileRead(Int16)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int32) VolatileRead(Int32) VolatileRead(Int32) VolatileRead(Int32)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int64) VolatileRead(Int64) VolatileRead(Int64) VolatileRead(Int64)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(IntPtr) VolatileRead(IntPtr) VolatileRead(IntPtr) VolatileRead(IntPtr)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Object) VolatileRead(Object) VolatileRead(Object) VolatileRead(Object)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(SByte) VolatileRead(SByte) VolatileRead(SByte) VolatileRead(SByte)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Single) VolatileRead(Single) VolatileRead(Single) VolatileRead(Single)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt16) VolatileRead(UInt16) VolatileRead(UInt16) VolatileRead(UInt16)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt32) VolatileRead(UInt32) VolatileRead(UInt32) VolatileRead(UInt32)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt64) VolatileRead(UInt64) VolatileRead(UInt64) VolatileRead(UInt64)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UIntPtr) VolatileRead(UIntPtr) VolatileRead(UIntPtr) VolatileRead(UIntPtr)

Lit la valeur d'un champ.Reads the value of a field. Il s'agit de la dernière valeur écrite par un processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeurs.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double) VolatileWrite(Double, Double) VolatileWrite(Double, Double) VolatileWrite(Double, Double)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object) VolatileWrite(Object, Object) VolatileWrite(Object, Object) VolatileWrite(Object, Object)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single) VolatileWrite(Single, Single) VolatileWrite(Single, Single) VolatileWrite(Single, Single)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr)

Écrit immédiatement une valeur dans un champ pour que la valeur soit visible pour tous les processeurs de l'ordinateur.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield() Yield() Yield() Yield()

Oblige le thread appelant à céder l'exécution à un autre thread prêt à s'exécuter sur le processeur actuel.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. Le système d'exploitation sélectionne le thread auquel l'exécution doit être cédée.The operating system selects the thread to yield to.

Implémentations d’interfaces explicites

_Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

_Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

_Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi