Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Lorsqu’un processus de système d’exploitation est créé, le système d’exploitation injecte un thread pour exécuter du code dans ce processus, y compris tout domaine d’application d’origine. À partir de ce stade, les domaines d’application peuvent être créés et détruits sans threads de système d’exploitation nécessairement créés ou détruits. Si le code en cours d’exécution est du code managé, un Thread objet pour le thread qui s’exécute dans le domaine d’application actuel peut être obtenu en récupérant la propriété statique CurrentThread de type Thread. Cette rubrique décrit la création de threads et traite des alternatives pour transmettre des données à la procédure de thread.
Création d’un thread
La création d’un Thread objet crée un thread managé. La Thread classe possède des constructeurs qui acceptent un ThreadStart délégué ou un ParameterizedThreadStart délégué ; ce délégué encapsule la méthode invoquée par le nouveau thread lorsque vous appelez la méthode Start. Appeler Start plusieurs fois entraîne le lancer d'une ThreadStateException.
La Start méthode retourne immédiatement, souvent avant le démarrage du nouveau thread. Vous pouvez utiliser les propriétés ThreadState et IsAlive pour déterminer l’état du thread à un moment donné, mais ces propriétés ne doivent jamais être utilisées pour synchroniser les activités des threads.
Remarque
Une fois qu’un thread est démarré, il n’est pas nécessaire de conserver une référence à l’objet Thread . Le thread continue à s’exécuter jusqu’à ce que la procédure thread se termine.
L’exemple de code suivant crée deux nouveaux threads pour appeler une instance et des méthodes statiques sur un autre objet.
using System;
using System.Threading;
public class ServerClass
{
// The method that will be called when the thread is started.
public void InstanceMethod()
{
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(3000);
Console.WriteLine(
"The instance method called by the worker thread has ended.");
}
public static void StaticMethod()
{
Console.WriteLine(
"ServerClass.StaticMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(5000);
Console.WriteLine(
"The static method called by the worker thread has ended.");
}
}
public class Simple
{
public static void Main()
{
ServerClass serverObject = new ServerClass();
// Create the thread object, passing in the
// serverObject.InstanceMethod method using a
// ThreadStart delegate.
Thread InstanceCaller = new(new ThreadStart(serverObject.InstanceMethod));
// Start the thread.
InstanceCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new InstanceCaller thread.");
// Create the thread object, passing in the
// serverObject.StaticMethod method using a
// ThreadStart delegate.
Thread StaticCaller = new(new ThreadStart(ServerClass.StaticMethod));
// Start the thread.
StaticCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new StaticCaller thread.");
}
}
// The example displays the output like the following:
// The Main() thread calls this after starting the new InstanceCaller thread.
// The Main() thread calls this after starting the new StaticCaller thread.
// ServerClass.StaticMethod is running on another thread.
// ServerClass.InstanceMethod is running on another thread.
// The instance method called by the worker thread has ended.
// The static method called by the worker thread has ended.
Imports System.Threading
Public class ServerClass
' The method that will be called when the thread is started.
Public Sub InstanceMethod()
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(3000)
Console.WriteLine(
"The instance method called by the worker thread has ended.")
End Sub
Public Shared Sub SharedMethod()
Console.WriteLine(
"ServerClass.SharedMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(5000)
Console.WriteLine(
"The Shared method called by the worker thread has ended.")
End Sub
End Class
Public class Simple
Public Shared Sub Main()
Dim serverObject As New ServerClass()
' Create the thread object, passing in the
' serverObject.InstanceMethod method using a
' ThreadStart delegate.
Dim InstanceCaller As New Thread(AddressOf serverObject.InstanceMethod)
' Start the thread.
InstanceCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new InstanceCaller thread.")
' Create the thread object, passing in the
' serverObject.SharedMethod method using a
' ThreadStart delegate.
Dim SharedCaller As New Thread( _
New ThreadStart(AddressOf ServerClass.SharedMethod))
' Start the thread.
SharedCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new SharedCaller thread.")
End Sub
End Class
' The example displays output like the following:
' The Main() thread calls this after starting the new InstanceCaller thread.
' The Main() thread calls this after starting the new StaticCaller thread.
' ServerClass.StaticMethod is running on another thread.
' ServerClass.InstanceMethod is running on another thread.
' The instance method called by the worker thread has ended.
' The static method called by the worker thread has ended.
Passage de données à des threads
Le ParameterizedThreadStart délégué offre un moyen simple de transmettre un objet contenant des données à un thread lorsque vous appelez Thread.Start(Object). Consultez ParameterizedThreadStart pour un exemple de code.
L’utilisation du ParameterizedThreadStart délégué n’est pas un moyen sûr de transmettre des données, car la Thread.Start(Object) méthode accepte n’importe quel objet. Une alternative consiste à encapsuler la procédure de fil d'exécution et les données dans une classe utilitaire et à utiliser le délégué ThreadStart pour exécuter la procédure de fil d'exécution. L’exemple suivant illustre cette technique :
using System;
using System.Threading;
// The ThreadWithState class contains the information needed for
// a task, and the method that executes the task.
//
public class ThreadWithState
{
// State information used in the task.
private string _boilerplate;
private int _numberValue;
// The constructor obtains the state information.
public ThreadWithState(string text, int number)
{
_boilerplate = text;
_numberValue = number;
}
// The thread procedure performs the task, such as formatting
// and printing a document.
public void ThreadProc()
{
Console.WriteLine(_boilerplate, _numberValue);
}
}
// Entry point for the example.
public class Example
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState tws = new("This report displays the number {0}.", 42);
// Create a thread to execute the task, and then
// start the thread.
Thread t = new(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
}
// The example displays the following output:
// Main thread does some work, then waits.
// This report displays the number 42.
// Independent task has completed; main thread ends.
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, and the method that executes the task.
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private numberValue As Integer
' The constructor obtains the state information.
Public Sub New(text As String, number As Integer)
boilerplate = text
numberValue = number
End Sub
' The thread procedure performs the task, such as formatting
' and printing a document.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, numberValue)
End Sub
End Class
' Entry point for the example.
'
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0}.", 42)
' Create a thread to execute the task, and then
' start the thread.
Dim t As New Thread(New ThreadStart(AddressOf tws.ThreadProc))
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed main thread ends.")
End Sub
End Class
' The example displays the following output:
' Main thread does some work, then waits.
' This report displays the number 42.
' Independent task has completed; main thread ends.
Ni ThreadStart ni ParameterizedThreadStart délégué n’a de valeur de retour, car il n’existe aucun moyen de renvoyer les données à partir d’un appel asynchrone. Pour récupérer les résultats d’une méthode de thread, vous pouvez utiliser une méthode de rappel, comme indiqué dans la section suivante.
Récupération de données à partir de threads avec des méthodes de rappel
L’exemple suivant illustre une méthode de rappel qui récupère des données à partir d’un thread. Le constructeur de la classe qui contient les données et la méthode de thread accepte également un délégué représentant la méthode de rappel ; avant la fin de la méthode de thread, elle appelle le délégué de rappel.
using System;
using System.Threading;
// The ThreadWithState2 class contains the information needed for
// a task, the method that executes the task, and a delegate
// to call when the task is complete.
public class ThreadWithState2
{
// State information used in the task.
private string _boilerplate;
private int _numberValue;
// Delegate used to execute the callback method when the
// task is complete.
private ExampleCallback _callback;
// The constructor obtains the state information and the
// callback delegate.
public ThreadWithState2(string text, int number,
ExampleCallback callbackDelegate)
{
_boilerplate = text;
_numberValue = number;
_callback = callbackDelegate;
}
// The thread procedure performs the task, such as
// formatting and printing a document, and then invokes
// the callback delegate with the number of lines printed.
public void ThreadProc()
{
Console.WriteLine(_boilerplate, _numberValue);
_callback?.Invoke(1);
}
}
// Delegate that defines the signature for the callback method.
public delegate void ExampleCallback(int lineCount);
// Entry point for the example.
public class Example2
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState2 tws = new(
"This report displays the number {0}.",
42,
new ExampleCallback(ResultCallback)
);
Thread t = new(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
// The callback method must match the signature of the
// callback delegate.
public static void ResultCallback(int lineCount)
{
Console.WriteLine($"Independent task printed {lineCount} lines.");
}
}
// The example displays the following output:
// Main thread does some work, then waits.
// This report displays the number 42.
// Independent task printed 1 lines.
// Independent task has completed; main thread ends.
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, the method that executes the task, and a delegate
' to call when the task is complete.
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private numberValue As Integer
' Delegate used to execute the callback method when the
' task is complete.
Private callback As ExampleCallback
' The constructor obtains the state information and the
' callback delegate.
Public Sub New(text As String, number As Integer, _
callbackDelegate As ExampleCallback)
boilerplate = text
numberValue = number
callback = callbackDelegate
End Sub
' The thread procedure performs the task, such as
' formatting and printing a document, and then invokes
' the callback delegate with the number of lines printed.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, numberValue)
If Not (callback Is Nothing) Then
callback(1)
End If
End Sub
End Class
' Delegate that defines the signature for the callback method.
'
Public Delegate Sub ExampleCallback(lineCount As Integer)
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0}.", _
42, _
AddressOf ResultCallback)
Dim t As New Thread(AddressOf tws.ThreadProc)
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed; main thread ends.")
End Sub
Public Shared Sub ResultCallback(lineCount As Integer)
Console.WriteLine( _
"Independent task printed {0} lines.", lineCount)
End Sub
End Class
' The example displays the following output:
' Main thread does some work, then waits.
' This report displays the number 42.
' Independent task printed 1 lines.
' Independent task has completed; main thread ends.
Voir aussi
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
