Thread Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.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.

Inizializza una nuova istanza della classe Thread.

Overload

Thread(ParameterizedThreadStart)	Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato.
Thread(ThreadStart)	Inizializza una nuova istanza della classe Thread.
Thread(ParameterizedThreadStart, Int32)	Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato e specificando la dimensione massima dello stack per il thread.
Thread(ThreadStart, Int32)	Inizializza una nuova istanza della classe Thread, specificando la dimensione massima dello stack per il thread.

Thread(ParameterizedThreadStart)

Origine:: Thread.cs

Origine:: Thread.cs

Origine:: Thread.cs

Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato.

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)

Parametri

start: ParameterizedThreadStart

Delegato che rappresenta i metodi da richiamare quando inizia l'esecuzione di questo thread.

Eccezioni

ArgumentNullException

start è null.

Esempio

Nell'esempio seguente viene illustrata la sintassi per la creazione e l'uso di un ParameterizedThreadStart 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.'

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

Commenti

Un thread non inizia l'esecuzione al momento della creazione. Per pianificare il thread per l'esecuzione, chiamare il Start metodo . Per passare un oggetto dati al thread, utilizzare l'overload del Start(Object) metodo .

Nota

Gli utenti di Visual Basic possono omettere il costruttore durante la ThreadStart creazione di un thread. Usare l'operatore AddressOf quando si passa il metodo, ad esempio Dim t As New Thread(AddressOf ThreadProc). Visual Basic chiama automaticamente il ThreadStart costruttore.

Vedi anche

Si applica a

Thread(ThreadStart)

Origine:: Thread.cs

Origine:: Thread.cs

Origine:: Thread.cs

Inizializza una nuova istanza della 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)

Parametri

start: ThreadStart

Delegato ThreadStart che rappresenta i metodi da richiamare quando inizia l'esecuzione di questo thread.

Eccezioni

ArgumentNullException

Il valore del parametro start è null.

Esempio

Nell'esempio di codice seguente viene illustrato come creare un thread che esegue un metodo statico.

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

Nell'esempio di codice seguente viene illustrato come creare un thread che esegue un metodo di istanza.

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

Commenti

Un thread non inizia l'esecuzione al momento della creazione. Per pianificare il thread per l'esecuzione, chiamare il Start metodo .

Nota

Vedi anche

Si applica a

Thread(ParameterizedThreadStart, Int32)

Origine:: Thread.cs

Origine:: Thread.cs

Origine:: Thread.cs

Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato e specificando la dimensione massima dello stack per il 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)

Parametri

start: ParameterizedThreadStart

Delegato ParameterizedThreadStart che rappresenta i metodi da richiamare quando inizia l'esecuzione di questo thread.

maxStackSize: Int32

Dimensione massima dello stack, in byte, usata dal thread oppure 0 per usare la dimensione massima predefinita specificata nell'intestazione del file eseguibile.

Importante Per il codice parzialmente attendibile, maxStackSize viene ignorato se è maggiore delle dimensioni dello stack predefinite. Non viene generata alcuna eccezione.

Eccezioni

ArgumentNullException

start è null.

ArgumentOutOfRangeException

maxStackSize è minore di zero.

Commenti

Evitare di usare questo overload del costruttore. Le dimensioni dello stack predefinite usate dall'overload del Thread(ParameterizedThreadStart) costruttore sono le dimensioni dello stack consigliate per i thread. Se un thread presenta problemi di memoria, la causa più probabile è l'errore di programmazione, ad esempio la ricorsione infinita.

Importante

A partire da .NET Framework 4, solo il codice completamente attendibile può impostare maxStackSize su un valore maggiore delle dimensioni dello stack predefinite (1 megabyte). Se viene specificato un valore maggiore per maxStackSize quando il codice viene eseguito con attendibilità parziale, maxStackSize viene ignorato e viene usata la dimensione dello stack predefinita. Non viene generata alcuna eccezione. Il codice a qualsiasi livello di attendibilità può essere impostato su maxStackSize un valore minore delle dimensioni dello stack predefinite.

Nota

Se si sviluppa una libreria completamente attendibile che verrà usata da codice parzialmente attendibile ed è necessario avviare un thread che richiede uno stack di grandi dimensioni, è necessario asserire l'attendibilità completa prima di creare il thread o verranno usate le dimensioni dello stack predefinite. Non eseguire questa operazione a meno che non si controlli completamente il codice eseguito nel thread.

Nota

Nelle versioni di Microsoft Windows precedenti a Windows XP e Windows Server 2003, maxStackSize viene ignorata e viene usata la dimensione dello stack specificata nell'intestazione eseguibile.

Se si specificano dimensioni dello stack molto ridotte, potrebbe essere necessario disabilitare il probe di overflow dello stack. Quando lo stack è fortemente vincolato, il probe può causare un overflow dello stack. Per disabilitare il probe di overflow dello stack, aggiungere quanto segue al file di configurazione dell'applicazione in un'app .NET Framework.

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

Si applica a

Thread(ThreadStart, Int32)

Origine:: Thread.cs

Origine:: Thread.cs

Origine:: Thread.cs

Inizializza una nuova istanza della classe Thread, specificando la dimensione massima dello stack per il 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)

Parametri

start: ThreadStart

Delegato ThreadStart che rappresenta i metodi da richiamare quando inizia l'esecuzione di questo thread.

maxStackSize: Int32

Dimensione massima dello stack, in byte, usata dal thread oppure 0 per usare la dimensione massima predefinita specificata nell'intestazione del file eseguibile.

Importante Per il codice parzialmente attendibile, maxStackSize viene ignorato se è maggiore delle dimensioni dello stack predefinite. Non viene generata alcuna eccezione.

Eccezioni

ArgumentNullException

start è null.

ArgumentOutOfRangeException

maxStackSize è minore di zero.

Commenti

Evitare di usare questo overload del costruttore. Le dimensioni dello stack predefinite usate dall'overload del Thread(ThreadStart) costruttore sono le dimensioni dello stack consigliate per i thread. Se un thread presenta problemi di memoria, la causa più probabile è l'errore di programmazione, ad esempio la ricorsione infinita.

Importante

Nota

Se maxStackSize è minore della dimensione minima dello stack, viene usata la dimensione minima dello stack. Se maxStackSize non è un multiplo delle dimensioni della pagina, viene arrotondato al multiplo più grande successivo della dimensione della pagina. Ad esempio, se si usa .NET Framework versione 2.0 in Windows Vista, 256 KB (262.144 byte) è la dimensione minima dello stack e la dimensione della pagina è 64 KB (65.536 byte).

Nota

Nelle versioni di Microsoft Windows precedenti a Windows XP e Windows Server 2003, maxStackSize viene ignorata e viene usata la dimensione dello stack specificata nell'intestazione eseguibile.

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

Si applica a

Condividi tramite

Thread Costruttori

Definizione

Overload

Thread(ParameterizedThreadStart)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Thread(ThreadStart)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Thread(ParameterizedThreadStart, Int32)

Parametri

Eccezioni

Commenti

Si applica a

Thread(ThreadStart, Int32)

Parametri

Eccezioni

Commenti

Si applica a

Risorse aggiuntive