Thread.Start Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Threading

Zestaw:: System.Threading.Thread.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Powoduje zaplanowanie wykonywania wątku.

Przeciążenia

Start()	Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na Running .
Start(Object)	Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na i opcjonalnie dostarcza obiekt zawierający dane, które mają być używane przez metodę Running wykonywaną przez wątek.

Start()

Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na 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 ()

Atrybuty: UnsupportedOSPlatformAttribute

Wyjątki

ThreadStateException

Wątek został już uruchomiony.

OutOfMemoryException

Za mało pamięci dostępnej do uruchomienia tego wątku.

Przykłady

Poniższy przykład tworzy i uruchamia wątek.

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

Uwagi

Gdy wątek jest w stanie, system operacyjny może ThreadState.Running zaplanować jego wykonanie. Wątek rozpoczyna wykonywanie w pierwszym wierszu metody reprezentowanej przez ThreadStart delegata lub ParameterizedThreadStart dostarczonego do konstruktora wątku. Należy pamiętać, że wywołanie Start funkcji nie blokuje wątku wywołującego.

Uwaga

Jeśli to przeciążenie jest używane z wątkiem utworzonym przy użyciu delegata, jest przekazywane do ParameterizedThreadStart null metody wykonywanej przez wątek.

Po zakończeniu wątku nie można go ponownie uruchomić przy użyciu innego wywołania do Start .

Zobacz też

Dotyczy

Start(Object)

Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na i opcjonalnie dostarcza obiekt zawierający dane, które mają być używane przez metodę Running wykonywaną przez wątek.

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)

Parametry

parameter: Object

Obiekt zawierający dane, które mają być używane przez metodę wykonywaną przez wątek.

Atrybuty: UnsupportedOSPlatformAttribute

Wyjątki

ThreadStateException

Wątek został już uruchomiony.

OutOfMemoryException

Za mało pamięci dostępnej do uruchomienia tego wątku.

InvalidOperationException

Ten wątek został utworzony przy użyciu ThreadStart delegata zamiast ParameterizedThreadStart delegata.

Przykłady

Poniższy przykład tworzy ParameterizedThreadStart delegata przy użyciu metody statycznej i metody wystąpienia.

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

Uwagi

Po zakończeniu wątku nie można go ponownie uruchomić przy użyciu innego wywołania do Start .

To przeciążenie i delegat ułatwiają przekazania danych do procedury wątku, ale technika nie jest bezpieczna, ponieważ dowolny obiekt może zostać przekazany ParameterizedThreadStart do tego przeciążenia. Bardziej niezawodnym sposobem przekazania danych do procedury wątku jest umieścić zarówno procedurę wątku, jak i pola danych w obiekcie procesu roboczego. Aby uzyskać więcej informacji, zobacz Creating Threads and Passing Data at Start Time (Tworzenie wątków i przekazywanie danych w czasie rozpoczęcia).

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

Thread.Start Metoda

Definicja

Przeciążenia

Start()

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Start(Object)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby