Thread.Start Méthode

  • Référence

Définition

Espace de noms:
System.Threading
Assembly:
System.Threading.Thread.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

Entraîne la planification de l'exécution d'un thread.

Surcharges

Start()

Provoque le changement, par le système d'exploitation, de l'état de l'instance actuelle en Running.
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.

Start()

Provoque le changement, par le système d'exploitation, de l'état de l'instance actuelle en Running.

public:
 void Start();
public void Start ();
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public void Start ();
member this.Start : unit -> unit
[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
member this.Start : unit -> unit
Public Sub Start ()
Attributs
UnsupportedOSPlatformAttribute

Exceptions

ThreadStateException

Le thread a déjà été démarré.

OutOfMemoryException

La mémoire disponible est insuffisante pour démarrer ce thread.

Exemples

L’exemple suivant crée et démarre un thread.

using namespace System;
using namespace System::Threading;

public ref class ThreadWork
{
public:
   static void DoWork()
   {
      for ( int i = 0; i < 3; i++ )
      {
         Console::WriteLine( "Working thread..." );
         Thread::Sleep( 100 );
      }
   }
};

int main()
{
   ThreadStart^ myThreadDelegate = gcnew ThreadStart(&ThreadWork::DoWork);
   Thread^ thread1 = gcnew Thread( myThreadDelegate );
   thread1->Start();
   for ( int i = 0; i < 3; i++ )
   {
      Console::WriteLine( "In main." );
      Thread::Sleep( 100 );
   }
}
// The example displays output like the following:
//       In main.
//       Working thread...
//       In main.
//       Working thread...
//       In main.
//       Working thread...

using System;
using System.Threading;

public class ThreadWork
{
   public static void DoWork()
   {
      for(int i = 0; i<3;i++) {
         Console.WriteLine("Working thread...");
         Thread.Sleep(100);
      }
   }
}
class ThreadTest
{
   public static void Main()
   {
      Thread thread1 = new Thread(ThreadWork.DoWork);
      thread1.Start();
      for (int i = 0; i<3; i++) {
         Console.WriteLine("In main.");
         Thread.Sleep(100);
      }
   }
}
// The example displays output like the following:
//       In main.
//       Working thread...
//       In main.
//       Working thread...
//       In main.
//       Working thread...

Imports System.Threading

Public Class ThreadWork
   Public Shared Sub DoWork()
      Dim i As Integer
      For i = 0 To 2
         Console.WriteLine("Working thread...")
         Thread.Sleep(100)
      Next i
   End Sub
End Class

Class ThreadTest
   Public Shared Sub Main()
      Dim thread1 As New Thread(AddressOf ThreadWork.DoWork)
      thread1.Start()
      Dim i As Integer
      For i = 0 To 2
         Console.WriteLine("In main.")
         Thread.Sleep(100)
      Next
   End Sub
End Class
' The example displays output like the following:
'       In main.
'       Working thread...
'       In main.
'       Working thread...
'       In main.
'       Working thread...

Remarques

Une fois qu’un thread est dans l' ThreadState.Running État, le système d’exploitation peut le planifier en vue de son exécution. Le thread commence à s’exécuter à la première ligne de la méthode représentée par ThreadStart le ParameterizedThreadStart délégué ou fourni au constructeur de thread. Notez que l’appel à Start ne bloque pas le thread appelant.

Notes

Si cette surcharge est utilisée avec un thread créé à l’aide d’un ParameterizedThreadStart délégué, null est passé à la méthode exécutée par le thread.

Une fois que le thread s’arrête, il ne peut pas être redémarré avec un autre appel à Start .

Voir aussi

S’applique à

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.

public:
 void Start(System::Object ^ parameter);
public void Start (object? parameter);
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public void Start (object? parameter);
public void Start (object parameter);
member this.Start : obj -> unit
[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
member this.Start : obj -> unit
Public Sub Start (parameter As Object)

Paramètres

parameter
Object

Objet contenant les données que la méthode exécutée par le thread doit utiliser.

Attributs
UnsupportedOSPlatformAttribute

Exceptions

ThreadStateException

Le thread a déjà été démarré.

OutOfMemoryException

La mémoire disponible est insuffisante pour démarrer ce thread.

InvalidOperationException

Ce thread a été créé à l’aide d’un délégué ThreadStart au lieu d’un délégué ParameterizedThreadStart.

Exemples

L’exemple suivant crée 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.'

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

Une fois qu’un thread est dans l' ThreadState.Running État, le système d’exploitation peut le planifier en vue de son exécution. Le thread commence à s’exécuter à la première ligne de la méthode représentée par ThreadStart le ParameterizedThreadStart délégué ou fourni au constructeur de thread. Notez que l’appel à Start ne bloque pas le thread appelant.

Une fois que le thread s’arrête, il ne peut pas être redémarré avec un autre appel à Start .

Cette surcharge et le ParameterizedThreadStart délégué facilitent le passage de données à une procédure de thread, mais la technique n’est pas de type sécurisé, car tout objet peut être passé à cette surcharge. Un moyen plus robuste de passer des données à une procédure de thread consiste à placer la procédure de thread et les champs de données dans un objet de travail. Pour plus d’informations, consultez création de threads et passage de données à l’heure de début.

Voir aussi

S’applique à