Thread.Start Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Determina la pianificazione dell'esecuzione di un thread.

Overload

Start()	Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running.
Start(Object)	Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running e, facoltativamente, fornisce un oggetto contenente i dati che devono essere usati dal metodo eseguito dal thread.

Start()

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in 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 ()

Attributi: UnsupportedOSPlatformAttribute

Eccezioni

ThreadStateException

Il thread è già stato avviato.

OutOfMemoryException

La memoria disponibile non è sufficiente per avviare il thread.

Esempio

Nell'esempio seguente viene creato e avviato 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...

Commenti

Quando un thread è nello stato ThreadState.Running , il sistema operativo può pianificarlo per l'esecuzione. Il thread inizia l'esecuzione nella prima riga del metodo rappresentato dal delegato ThreadStart o fornito al costruttore del ParameterizedThreadStart thread. Si noti che la chiamata a Start non blocca il thread chiamante.

Nota

Se questo overload viene usato con un thread creato usando un ParameterizedThreadStart delegato, null viene passato al metodo eseguito dal thread.

Una volta terminato, il thread non può essere riavviato con un'altra chiamata a Start .

Vedi anche

Si applica a

Start(Object)

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running e, facoltativamente, fornisce un oggetto contenente i dati che devono essere usati dal metodo eseguito dal thread.

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)

Parametri

parameter: Object

Oggetto contenente i dati che devono essere usati dal metodo eseguito dal thread.

Attributi: UnsupportedOSPlatformAttribute

Eccezioni

ThreadStateException

Il thread è già stato avviato.

OutOfMemoryException

La memoria disponibile non è sufficiente per avviare il thread.

InvalidOperationException

Questo thread è stato creato usando un delegato di ThreadStart invece di uno di ParameterizedThreadStart.

Esempio

Nell'esempio seguente viene creato ParameterizedThreadStart un delegato con un metodo statico e un metodo di istanza.

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

Commenti

Una volta terminato, il thread non può essere riavviato con un'altra chiamata a Start .

Questo overload e il delegato semplificano il passaggio di dati a una routine di thread, ma la tecnica non è indipendente dai tipi perché qualsiasi oggetto può ParameterizedThreadStart essere passato a questo overload. Un modo più affidabile per passare i dati a una routine di thread è inserire sia la routine del thread che i campi dati in un oggetto di lavoro. Per altre informazioni, vedere Creazione di thread e passaggio di dati all'ora di inizio.

Vedi anche

Si applica a

Condividi tramite

Thread.Start Metodo

Definizione

Overload

Start()

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Start(Object)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Risorse aggiuntive