Thread Constructeurs

Référence

Définition

Espace de noms:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Initialise une nouvelle instance de la classe Thread.

Surcharges

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é.
Thread(ThreadStart)	Initialise une nouvelle instance de la classe Thread.
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.
Thread(ThreadStart, Int32)	Initialise une nouvelle instance de la classe Thread, en spécifiant la taille de pile maximale pour le thread.

Thread(ParameterizedThreadStart)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

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é.

public:
 Thread(System::Threading::ParameterizedThreadStart ^ start);

public Thread (System.Threading.ParameterizedThreadStart start);

new System.Threading.Thread : System.Threading.ParameterizedThreadStart -> System.Threading.Thread

Public Sub New (start As ParameterizedThreadStart)

Paramètres

start: ParameterizedThreadStart

Délégué qui représente les méthodes à appeler au début de l'exécution de ce thread.

Exceptions

ArgumentNullException

start a la valeur null.

Exemples

L’exemple suivant montre la syntaxe de création et d’utilisation d’un ParameterizedThreadStart délégué avec une méthode statique et une méthode d’instance.

using namespace System;
using namespace System::Threading;

namespace SystemThreadingExample
{
    public ref class Work
    {
    public:
        void StartThreads()
        {
            // Start a thread that calls a parameterized static method.
            Thread^ newThread = gcnew
                Thread(gcnew ParameterizedThreadStart(Work::DoWork));
            newThread->Start(42);
              
            // Start a thread that calls a parameterized instance method.
            Work^ someWork = gcnew Work;
            newThread = gcnew Thread(
                        gcnew ParameterizedThreadStart(someWork,
                        &Work::DoMoreWork));
            newThread->Start("The answer.");
        }

        static void DoWork(Object^ data)
        {
            Console::WriteLine("Static thread procedure. Data='{0}'", 
                data);
        }

        void DoMoreWork(Object^ data)
        {
            Console::WriteLine("Instance thread procedure. Data='{0}'", 
                data);
        }
    };
}

//Entry point of example application
int main()
{
    SystemThreadingExample::Work^ samplework = 
        gcnew SystemThreadingExample::Work();
    samplework->StartThreads();
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

using System;
using System.Threading;

public class Work
{
    public static void Main()
    {
        // Start a thread that calls a parameterized static method.
        Thread newThread = new Thread(Work.DoWork);
        newThread.Start(42);

        // Start a thread that calls a parameterized instance method.
        Work w = new Work();
        newThread = new Thread(w.DoMoreWork);
        newThread.Start("The answer.");
    }
 
    public static void DoWork(object data)
    {
        Console.WriteLine("Static thread procedure. Data='{0}'",
            data);
    }

    public void DoMoreWork(object data)
    {
        Console.WriteLine("Instance thread procedure. Data='{0}'",
            data);
    }
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

open System.Threading

type Work() =
    static member DoWork(data: obj) =
        printfn $"Static thread procedure. Data='{data}'"

    member _.DoMoreWork(data: obj) =
        printfn $"Instance thread procedure. Data='{data}'"

// Start a thread that calls a parameterized static method.
let newThread = Thread(ParameterizedThreadStart Work.DoWork)
newThread.Start 42

// Start a thread that calls a parameterized instance method.
let w = Work()
let newThread2 = Thread(ParameterizedThreadStart w.DoMoreWork)
newThread.Start "The answer."

// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

Imports System.Threading

Public Class Work
    Shared Sub Main()
        ' Start a thread that calls a parameterized static method.
        Dim newThread As New Thread(AddressOf Work.DoWork)
        newThread.Start(42)

        ' Start a thread that calls a parameterized instance method.
        Dim w As New Work()
        newThread = New Thread(AddressOf w.DoMoreWork)
        newThread.Start("The answer.")
    End Sub
 
    Public Shared Sub DoWork(ByVal data As Object)
        Console.WriteLine("Static thread procedure. Data='{0}'",
                          data)
    End Sub

    Public Sub DoMoreWork(ByVal data As Object) 
        Console.WriteLine("Instance thread procedure. Data='{0}'",
                          data)
    End Sub
End Class
' This example displays output like the following:
'    Static thread procedure. Data='42'
'    Instance thread procedure. Data='The answer.'

Remarques

Un thread ne commence pas à s’exécuter lors de sa création. Pour planifier l’exécution du thread, appelez la Start méthode . Pour passer un objet de données au thread, utilisez la surcharge de méthode Start(Object) .

Remarque

Les utilisateurs Visual Basic peuvent omettre le constructeur lors de la ThreadStart création d’un thread. Utilisez l’opérateur AddressOf lors de la transmission de votre méthode, par exemple, Dim t As New Thread(AddressOf ThreadProc). Visual Basic appelle automatiquement le ThreadStart constructeur.

Voir aussi

S’applique à

Thread(ThreadStart)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

Initialise une nouvelle instance de la classe Thread.

public:
 Thread(System::Threading::ThreadStart ^ start);

public Thread (System.Threading.ThreadStart start);

new System.Threading.Thread : System.Threading.ThreadStart -> System.Threading.Thread

Public Sub New (start As ThreadStart)

Paramètres

start: ThreadStart

Délégué ThreadStart qui représente les méthodes à appeler au début de l'exécution de ce thread.

Exceptions

ArgumentNullException

Le paramètre start a la valeur null.

Exemples

L’exemple de code suivant montre comment créer un thread qui exécute une méthode statique.

using namespace System;
using namespace System::Threading;
ref class Work
{
private:
   Work(){}


public:
   static void DoWork(){}

};

int main()
{
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( &Work::DoWork ) );
   newThread->Start();
}

using System;
using System.Threading;

class Test
{
    static void Main() 
    {
        Thread newThread = 
            new Thread(new ThreadStart(Work.DoWork));
        newThread.Start();
    }
}

class Work 
{
    Work() {}

    public static void DoWork() {}
}

open System.Threading

module Work =
    let doWork () = ()

let newThread = Thread(ThreadStart Work.doWork)
newThread.Start()

Imports System.Threading

Public Class Test
    <MTAThread> _
    Shared Sub Main()
        Dim newThread As New Thread(AddressOf Work.DoWork)
        newThread.Start()
    End Sub
End Class

Public Class Work 

    Private Sub New()
    End Sub

    Shared Sub DoWork()
    End Sub

End Class

L’exemple de code suivant montre comment créer un thread qui exécute une méthode d’instance.

using namespace System;
using namespace System::Threading;
ref class Work
{
public:
   Work(){}

   void DoWork(){}

};

int main()
{
   Work^ threadWork = gcnew Work;
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( threadWork, &Work::DoWork ) );
   newThread->Start();
}

using System;
using System.Threading;

class Test
{
    static void Main() 
    {
        Work threadWork = new Work();
        Thread newThread = 
            new Thread(new ThreadStart(threadWork.DoWork));
        newThread.Start();
    }
}

class Work 
{
    public Work() {}

    public void DoWork() {}
}

open System.Threading

type Work() =
    member _.DoWork() = ()

let threadWork = Work()
let newThread = Thread(ThreadStart threadWork.DoWork)
newThread.Start()

Imports System.Threading

Public Class Test
    <MTAThread> _
    Shared Sub Main() 
        Dim threadWork As New Work()
        Dim newThread As New Thread(AddressOf threadWork.DoWork)
        newThread.Start()
    End Sub
End Class

Public Class Work

    Sub New()
    End Sub

    Sub DoWork() 
    End Sub

End Class

Remarques

Un thread ne commence pas à s’exécuter lors de sa création. Pour planifier l’exécution du thread, appelez la Start méthode .

Remarque

Voir aussi

S’applique à

Thread(ParameterizedThreadStart, Int32)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

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.

public:
 Thread(System::Threading::ParameterizedThreadStart ^ start, int maxStackSize);

public Thread (System.Threading.ParameterizedThreadStart start, int maxStackSize);

new System.Threading.Thread : System.Threading.ParameterizedThreadStart * int -> System.Threading.Thread

Public Sub New (start As ParameterizedThreadStart, maxStackSize As Integer)

Paramètres

start: ParameterizedThreadStart

Délégué ParameterizedThreadStart qui représente les méthodes à appeler au début de l'exécution de ce thread.

maxStackSize: Int32

Taille de pile maximale, en octets, à utiliser par le thread, ou 0 pour utiliser la taille de pile maximale par défaut spécifiée dans l'en-tête pour le fichier exécutable.

Important Pour le code partiellement approuvé, maxStackSize est ignoré s’il est supérieur à la taille de la pile par défaut. Aucune exception n’est générée.

Exceptions

ArgumentNullException

start a la valeur null.

ArgumentOutOfRangeException

maxStackSize est inférieur à zéro.

Remarques

Évitez d’utiliser cette surcharge de constructeur. La taille de pile par défaut utilisée par la surcharge du Thread(ParameterizedThreadStart) constructeur est la taille de pile recommandée pour les threads. Si un thread rencontre des problèmes de mémoire, la cause la plus probable est une erreur de programmation, telle que la récursivité infinie.

Important

À compter de .NET Framework 4, seul le code entièrement approuvé peut définir maxStackSize une valeur supérieure à la taille de la pile par défaut (1 mégaoctet). Si une valeur plus élevée est spécifiée pour maxStackSize lorsque le code s’exécute avec une approbation partielle, maxStackSize est ignorée et la taille de la pile par défaut est utilisée. Aucune exception n’est générée. Le code à n’importe quel niveau d’approbation peut définir maxStackSize une valeur inférieure à la taille de la pile par défaut.

Remarque

Si vous développez une bibliothèque entièrement approuvée qui sera utilisée par du code partiellement approuvé, et que vous devez démarrer un thread qui nécessite une grande pile, vous devez affirmer une confiance totale avant de créer le thread, sinon la taille de pile par défaut sera utilisée. Ne le faites pas, sauf si vous contrôlez entièrement le code qui s’exécute sur le thread.

Remarque

Sur les versions de Microsoft Windows antérieures à Windows XP et Windows Server 2003, maxStackSize est ignoré et la taille de pile spécifiée dans l’en-tête exécutable est utilisée.

Si vous spécifiez une très petite taille de pile, vous devrez peut-être désactiver la détection de dépassement de pile. Lorsque la pile est sévèrement contrainte, la détection peut elle-même provoquer un dépassement de capacité de pile. Pour désactiver l’analyse du dépassement de capacité de pile, ajoutez ce qui suit au fichier de configuration de votre application dans une application .NET Framework.

<configuration>
  <runtime>
    <disableStackOverflowProbing enabled="true"/>
  </runtime>
</configuration>

S’applique à

Thread(ThreadStart, Int32)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

Initialise une nouvelle instance de la classe Thread, en spécifiant la taille de pile maximale pour le thread.

public:
 Thread(System::Threading::ThreadStart ^ start, int maxStackSize);

public Thread (System.Threading.ThreadStart start, int maxStackSize);

new System.Threading.Thread : System.Threading.ThreadStart * int -> System.Threading.Thread

Public Sub New (start As ThreadStart, maxStackSize As Integer)

Paramètres

start: ThreadStart

Délégué ThreadStart qui représente les méthodes à appeler au début de l'exécution de ce thread.

maxStackSize: Int32

Taille de pile maximale, en octets, à utiliser par le thread, ou 0 pour utiliser la taille de pile maximale par défaut spécifiée dans l'en-tête pour le fichier exécutable.

Important Pour le code partiellement approuvé, maxStackSize est ignoré s’il est supérieur à la taille de la pile par défaut. Aucune exception n’est générée.

Exceptions

ArgumentNullException

start a la valeur null.

ArgumentOutOfRangeException

maxStackSize est inférieur à zéro.

Remarques

Évitez d’utiliser cette surcharge de constructeur. La taille de pile par défaut utilisée par la surcharge du Thread(ThreadStart) constructeur est la taille de pile recommandée pour les threads. Si un thread rencontre des problèmes de mémoire, la cause la plus probable est une erreur de programmation, telle que la récursivité infinie.

Important

Remarque

Si maxStackSize est inférieur à la taille minimale de la pile, la taille minimale de la pile est utilisée. Si maxStackSize n’est pas un multiple de la taille de la page, il est arrondi au multiple plus grand suivant de la taille de page. Par exemple, si vous utilisez .NET Framework version 2.0 sur Windows Vista, 256 Ko (262 144 octets) est la taille minimale de la pile et la taille de page est de 64 Ko (65 536 octets).

Remarque

Sur les versions de Microsoft Windows antérieures à Windows XP et Windows Server 2003, maxStackSize est ignoré et la taille de pile spécifiée dans l’en-tête exécutable est utilisée.

<configuration>
  <runtime>
    <disableStackOverflowProbing enabled="true"/>
  </runtime>
</configuration>

S’applique à

Partage via

Thread Constructeurs

Définition

Surcharges

Thread(ParameterizedThreadStart)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Thread(ThreadStart)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Thread(ParameterizedThreadStart, Int32)

Paramètres

Exceptions

Remarques

S’applique à

Thread(ThreadStart, Int32)

Paramètres

Exceptions

Remarques

S’applique à

Ressources supplémentaires