Thread Classe

Definizione

Crea e controlla un thread, ne imposta le priorità e ne ottiene lo stato.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject
public ref class Thread sealed
public ref class Thread sealed : System::Runtime::InteropServices::_Thread
public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, System::Runtime::InteropServices::_Thread
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.InteropServices._Thread
[System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
[System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject
type Thread = class
    inherit CriticalFinalizerObject
[<System.Runtime.InteropServices.ComVisible(true)>]
type Thread = class
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    interface _Thread
[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    inherit CriticalFinalizerObject
    interface _Thread
[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    inherit CriticalFinalizerObject
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Public NotInheritable Class Thread
Public NotInheritable Class Thread
Implements _Thread
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Implements _Thread
Ereditarietà
Ereditarietà
Thread
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrata una semplice funzionalità di threading.

// [C++]
// Compile using /clr option.
using namespace System;
using namespace System::Threading;

// Simple threading scenario:  Start a Shared method running
// on a second thread.
public ref class ThreadExample
{
public:

   // The ThreadProc method is called when the thread starts.
   // It loops ten times, writing to the console and yielding 
   // the rest of its time slice each time, and then ends.
   static void ThreadProc()
   {
      for ( int i = 0; i < 10; i++ )
      {
         Console::Write(  "ThreadProc: " );
         Console::WriteLine( i );
         
         // Yield the rest of the time slice.
         Thread::Sleep( 0 );

      }
   }

};

int main()
{
   Console::WriteLine( "Main thread: Start a second thread." );
   
   // Create the thread, passing a ThreadStart delegate that
   // represents the ThreadExample::ThreadProc method.  For a 
   // delegate representing a static method, no object is
   // required.
   Thread^ oThread = gcnew Thread( gcnew ThreadStart( &ThreadExample::ThreadProc ) );
   
   // Start ThreadProc.  Note that on a uniprocessor, the new 
   // thread does not get any processor time until the main thread 
   // is preempted or yields.  Uncomment the Thread::Sleep that 
   // follows oThread->Start() to see the difference.
   oThread->Start();
   
   //Thread::Sleep(0);
   for ( int i = 0; i < 4; i++ )
   {
      Console::WriteLine(  "Main thread: Do some work." );
      Thread::Sleep( 0 );

   }
   Console::WriteLine(  "Main thread: Call Join(), to wait until ThreadProc ends." );
   oThread->Join();
   Console::WriteLine(  "Main thread: ThreadProc.Join has returned.  Press Enter to end program." );
   Console::ReadLine();
   return 0;
}
using System;
using System.Threading;

// Simple threading scenario:  Start a static method running
// on a second thread.
public class ThreadExample {
    // The ThreadProc method is called when the thread starts.
    // It loops ten times, writing to the console and yielding
    // the rest of its time slice each time, and then ends.
    public static void ThreadProc() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("ThreadProc: {0}", i);
            // Yield the rest of the time slice.
            Thread.Sleep(0);
        }
    }

    public static void Main() {
        Console.WriteLine("Main thread: Start a second thread.");
        // The constructor for the Thread class requires a ThreadStart
        // delegate that represents the method to be executed on the
        // thread.  C# simplifies the creation of this delegate.
        Thread t = new Thread(new ThreadStart(ThreadProc));

        // Start ThreadProc.  Note that on a uniprocessor, the new
        // thread does not get any processor time until the main thread
        // is preempted or yields.  Uncomment the Thread.Sleep that
        // follows t.Start() to see the difference.
        t.Start();
        //Thread.Sleep(0);

        for (int i = 0; i < 4; i++) {
            Console.WriteLine("Main thread: Do some work.");
            Thread.Sleep(0);
        }

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
        t.Join();
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.");
        Console.ReadLine();
    }
}
Imports System.Threading

' Simple threading scenario:  Start a Shared method running
' on a second thread.
Public Class ThreadExample
    ' The ThreadProc method is called when the thread starts.
    ' It loops ten times, writing to the console and yielding 
    ' the rest of its time slice each time, and then ends.
    Public Shared Sub ThreadProc()
        Dim i As Integer
        For i = 0 To 9
            Console.WriteLine("ThreadProc: {0}", i)
            ' Yield the rest of the time slice.
            Thread.Sleep(0)
        Next
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Main thread: Start a second thread.")
        ' The constructor for the Thread class requires a ThreadStart 
        ' delegate.  The Visual Basic AddressOf operator creates this
        ' delegate for you.
        Dim t As New Thread(AddressOf ThreadProc)

        ' Start ThreadProc.  Note that on a uniprocessor, the new 
        ' thread does not get any processor time until the main thread 
        ' is preempted or yields.  Uncomment the Thread.Sleep that 
        ' follows t.Start() to see the difference.
        t.Start()
        'Thread.Sleep(0)

        Dim i As Integer
        For i = 1 To 4
            Console.WriteLine("Main thread: Do some work.")
            Thread.Sleep(0)
        Next

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
        t.Join()
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.")
        Console.ReadLine()
    End Sub
End Class

Questo codice genera un output simile al seguente:

[VB, C++, C#]  
Main thread: Start a second thread.  
Main thread: Do some work.  
ThreadProc: 0  
Main thread: Do some work.  
ThreadProc: 1  
Main thread: Do some work.  
ThreadProc: 2  
Main thread: Do some work.  
ThreadProc: 3  
Main thread: Call Join(), to wait until ThreadProc ends.  
ThreadProc: 4  
ThreadProc: 5  
ThreadProc: 6  
ThreadProc: 7  
ThreadProc: 8  
ThreadProc: 9  
Main thread: ThreadProc.Join has returned.  Press Enter to end program.  

Commenti

All'avvio di un processo, Common Language Runtime crea automaticamente un singolo thread in primo piano per eseguire il codice dell'applicazione. Insieme a questo thread principale in primo piano, un processo può creare uno o più thread per eseguire una parte del codice del programma associato al processo. Questi thread possono essere eseguiti in primo piano o in background. Inoltre, è possibile usare la classe per eseguire codice sui thread di ThreadPool lavoro gestiti da Common Language Runtime.

Contenuto della sezione

Avvio di un thread
Recupero di oggetti Thread
Thread in primo piano e in background
Impostazioni cultura e thread
Ottenere informazioni sui thread e controllarne il controllo

Avvio di un thread

Per avviare un thread, specificare un delegato che rappresenta il metodo che il thread deve eseguire nel costruttore della classe. Chiamare quindi il metodo Start per avviare l'esecuzione.

I costruttori possono assumere uno dei due tipi delegati seguenti, a seconda che sia possibile passare un argomento Thread al metodo da eseguire:

  • Se il metodo non ha argomenti, si passa ThreadStart un delegato al costruttore. Ha la firma:

    public delegate void ThreadStart()  
    
    Public Delegate Sub ThreadStart()  
    

    Nell'esempio seguente viene creato e avviato un thread che esegue il ExecuteInForeground metodo . Il metodo visualizza informazioni su alcune proprietà del thread, quindi esegue un ciclo in cui viene sospeso per mezzo secondo e visualizza il numero di secondi trascorso. Quando il thread è stato eseguito per almeno cinque secondi, il ciclo termina e il thread termina l'esecuzione.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start();
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...",
                            Thread.CurrentThread.ManagedThreadId);
       }
    
       private static void ExecuteInForeground()
       {
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do {
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= 5000);
          sw.Stop();
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.51 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.02 seconds
    //       Thread 3: Elapsed 1.53 seconds
    //       Thread 3: Elapsed 2.05 seconds
    //       Thread 3: Elapsed 2.55 seconds
    //       Thread 3: Elapsed 3.07 seconds
    //       Thread 3: Elapsed 3.57 seconds
    //       Thread 3: Elapsed 4.07 seconds
    //       Thread 3: Elapsed 4.58 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start()
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground()
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= 5000
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.51 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.02 seconds
    '       Thread 3: Elapsed 1.53 seconds
    '       Thread 3: Elapsed 2.05 seconds
    '       Thread 3: Elapsed 2.55 seconds
    '       Thread 3: Elapsed 3.07 seconds
    '       Thread 3: Elapsed 3.57 seconds
    '       Thread 3: Elapsed 4.07 seconds
    '       Thread 3: Elapsed 4.58 seconds
    
  • Se il metodo ha un argomento , si passa ParameterizedThreadStart un delegato al costruttore. Ha la firma:

    public delegate void ParameterizedThreadStart(object obj)  
    
    Public Delegate Sub ParameterizedThreadStart(obj As Object)  
    

    Il metodo eseguito dal delegato può quindi eseguire il cast (in C#) o convertire (in Visual Basic) il parametro nel tipo appropriato.

    L'esempio seguente è identico a quello precedente, ad eccezione del fatto che chiama il Thread(ParameterizedThreadStart) costruttore . Questa versione del ExecuteInForeground metodo ha un singolo parametro che rappresenta il numero approssimativo di millisecondi che il ciclo deve eseguire.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start(4500);
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...",
                            Thread.CurrentThread.ManagedThreadId);
       }
    
       private static void ExecuteInForeground(Object obj)
       {
          int interval;
          try {
             interval = (int) obj;
          }
          catch (InvalidCastException) {
             interval = 5000;
          }
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do {
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= interval);
          sw.Stop();
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.52 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.03 seconds
    //       Thread 3: Elapsed 1.55 seconds
    //       Thread 3: Elapsed 2.06 seconds
    //       Thread 3: Elapsed 2.58 seconds
    //       Thread 3: Elapsed 3.09 seconds
    //       Thread 3: Elapsed 3.61 seconds
    //       Thread 3: Elapsed 4.12 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start(4500)
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground(obj As Object)
          Dim interval As Integer
          If IsNumeric(obj) Then
             interval = CInt(obj)
          Else
             interval = 5000
          End If   
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= interval
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.52 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.03 seconds
    '       Thread 3: Elapsed 1.55 seconds
    '       Thread 3: Elapsed 2.06 seconds
    '       Thread 3: Elapsed 2.58 seconds
    '       Thread 3: Elapsed 3.09 seconds
    '       Thread 3: Elapsed 3.61 seconds
    '       Thread 3: Elapsed 4.12 seconds
    

Non è necessario mantenere un riferimento a un Thread oggetto dopo aver avviato il thread. L'esecuzione del thread continua fino al completamento della routine del thread.

Recupero di oggetti Thread

È possibile usare la proprietà statica ( in Visual Basic) per recuperare un riferimento al thread attualmente in esecuzione dal codice in esecuzione Shared CurrentThread nel thread. Nell'esempio seguente viene utilizzata la proprietà per visualizzare informazioni sul thread principale dell'applicazione, un altro thread in primo piano, un thread in CurrentThread background e un thread del pool di thread.

using System;
using System.Threading;

public class Example
{
   static Object obj = new Object();
   
   public static void Main()
   {
      ThreadPool.QueueUserWorkItem(ShowThreadInformation);
      var th1 = new Thread(ShowThreadInformation);
      th1.Start();
      var th2 = new Thread(ShowThreadInformation);
      th2.IsBackground = true;
      th2.Start();
      Thread.Sleep(500);
      ShowThreadInformation(null); 
   }
   
   private static void ShowThreadInformation(Object state)
   {
      lock (obj) {
         var th  = Thread.CurrentThread;
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId);
         Console.WriteLine("   Background thread: {0}", th.IsBackground);
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread);
         Console.WriteLine("   Priority: {0}", th.Priority);
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name);
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
Imports System.Threading

Module Example
   Private lock As New Object()
                    
   Public Sub Main()
      ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
      Dim th1 As New Thread(AddressOf ShowThreadInformation)
      th1.Start()
      Dim th2 As New Thread(AddressOf ShowThreadInformation)
      th2.IsBackground = True
      th2.Start()
      Thread.Sleep(500)
      ShowThreadInformation(Nothing) 
   End Sub
   
   Private Sub ShowThreadInformation(state As Object)
      SyncLock lock
         Dim th As Thread = Thread.CurrentThread
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
         Console.WriteLine("   Background thread: {0}", th.IsBackground)
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread)
         Console.WriteLine("   Priority: {0}", th.Priority)
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name)
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name)
         Console.WriteLine()
      End SyncLock
   End Sub
End Module
' The example displays output like the following:
'       ' Managed thread #6:
'          Background thread: True
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #3:
'          Background thread: True
'          Thread pool thread: True
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #4:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #1:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US

Thread in primo piano e in background

Le istanze della Thread classe rappresentano thread in primo piano o thread in background. I thread in background sono identici ai thread in primo piano con un'eccezione: un thread in background non mantiene un processo in esecuzione se tutti i thread in primo piano sono stati terminati. Una volta arrestati tutti i thread in primo piano, il runtime arresta tutti i thread in background e si arresta.

Per impostazione predefinita, i thread seguenti vengono eseguiti in primo piano:

  • Thread principale dell'applicazione.

  • Tutti i thread creati chiamando un Thread costruttore di classe.

Per impostazione predefinita, i thread seguenti vengono eseguiti in background:

  • Thread del pool di thread, ovvero un pool di thread di lavoro gestiti dal runtime. È possibile configurare il pool di thread e pianificare il lavoro sui thread del pool di thread usando la ThreadPool classe .

    Nota

    Le operazioni asincrone basate su attività vengono eseguite automaticamente nei thread del pool di thread. Le operazioni asincrone basate su attività usano Task le classi e per Task<TResult> implementare il modello asincrono basato su attività.

  • Tutti i thread che entrano nell'ambiente di esecuzione gestito da codice non gestito.

È possibile modificare un thread per l'esecuzione in background impostando la IsBackground proprietà in qualsiasi momento. I thread in background sono utili per qualsiasi operazione che deve continuare finché un'applicazione è in esecuzione, ma non deve impedire la terminazione dell'applicazione, ad esempio il monitoraggio delle modifiche file system o delle connessioni socket in ingresso.

Nell'esempio seguente viene illustrata la differenza tra thread in primo piano e in background. È simile al primo esempio nella sezione Avvio di un thread, ad eccezione del fatto che imposta il thread da eseguire in background prima di avviarlo. Come illustrato nell'output, il ciclo viene interrotto prima di essere eseguito per cinque secondi.

using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   public static void Main()
   {
      var th = new Thread(ExecuteInForeground);
      th.IsBackground = true;
      th.Start();
      Thread.Sleep(1000);
      Console.WriteLine("Main thread ({0}) exiting...",
                        Thread.CurrentThread.ManagedThreadId);
   }

   private static void ExecuteInForeground()
   {
      var sw = Stopwatch.StartNew();
      Console.WriteLine("Thread {0}: {1}, Priority {2}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority);
      do {
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         Thread.Sleep(500);
      } while (sw.ElapsedMilliseconds <= 5000);
      sw.Stop();
   }
}
// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...
Imports System.Diagnostics
Imports System.Threading

Module Example
   Public Sub Main()
      Dim th As New Thread(AddressOf ExecuteInForeground)
      th.IsBackground = True
      th.Start()
      Thread.Sleep(1000)
      Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
   End Sub
   
   Private Sub ExecuteInForeground()
      Dim start As DateTime = DateTime.Now
      Dim sw As Stopwatch = Stopwatch.StartNew()
      Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority)
      Do 
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000)
         Thread.Sleep(500)
      Loop While sw.ElapsedMilliseconds <= 5000
      sw.Stop() 
   End Sub
End Module
' The example displays output like the following:
'       Thread 3: Background, Priority Normal
'       Thread 3: Elapsed 0.00 seconds
'       Thread 3: Elapsed 0.51 seconds
'       Main thread (1) exiting...

Impostazioni cultura e thread

Ogni thread ha impostazioni cultura, rappresentate dalla proprietà , e impostazioni cultura CurrentCulture dell'interfaccia utente, rappresentate dalla CurrentUICulture proprietà . Le impostazioni cultura correnti supportano operazioni con distinzione delle impostazioni cultura quali analisi e formattazione, confronto e ordinamento delle stringhe e controllano anche il sistema di scrittura e il calendario utilizzati da un thread. Le impostazioni cultura correnti dell'interfaccia utente forniscono il recupero delle risorse con distinzione delle impostazioni cultura nei file di risorse.

Importante

Le proprietà e non funzionano in modo affidabile se usate CurrentCulture con thread diversi da quello CurrentUICulture corrente. In .NET Framework, la lettura di queste proprietà è affidabile, anche se l'impostazione di queste proprietà per un thread diverso dal thread corrente non lo è. In .NET Core viene generata un'eccezione se un thread tenta di leggere o InvalidOperationException scrivere queste proprietà in un thread diverso. È consigliabile usare le CultureInfo.CurrentCulture proprietà e per recuperare e impostare le impostazioni cultura CultureInfo.CurrentUICulture correnti.

Quando viene creata un'istanza di un nuovo thread, le impostazioni cultura e le impostazioni cultura dell'interfaccia utente vengono definite dalle impostazioni cultura correnti del sistema e dell'interfaccia utente e non dalle impostazioni cultura e dalle impostazioni cultura dell'interfaccia utente del thread da cui viene creato il nuovo thread. Ciò significa, ad esempio, che se le impostazioni cultura correnti del sistema sono inglese (Stati Uniti) e le impostazioni cultura correnti del thread dell'applicazione primario sono francese (Francia), le impostazioni cultura di un nuovo thread creato chiamando il costruttore dal thread primario sono inglese (Stati Uniti) e non francese Thread(ParameterizedThreadStart) (Francia). Per altre informazioni, vedere la sezione "Impostazioni cultura e thread" CultureInfo dell'argomento relativo alla classe .

Importante

Questo non vale per i thread che eseguono operazioni asincrone per le app che hanno come destinazione .NET Framework 4.6 e versioni successive. In questo caso, le impostazioni cultura e le impostazioni cultura dell'interfaccia utente fanno parte del contesto di un'operazione asincrona. Il thread in cui viene eseguita un'operazione asincrona eredita per impostazione predefinita le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del thread da cui è stata avviata l'operazione asincrona. Per altre informazioni, vedere la sezione dedicata alle impostazioni cultura e alle operazioni asincrone basate su attività nell'argomento relativo alla classe CultureInfo.

È possibile eseguire una delle operazioni seguenti per assicurarsi che tutti i thread in esecuzione in un'applicazione convitino le stesse impostazioni cultura e impostazioni cultura dell'interfaccia utente:

Per altre informazioni ed esempi, vedere la sezione "Impostazioni cultura e thread" CultureInfo dell'argomento relativo alla classe .

Ottenere informazioni sui thread e controllarne il controllo

È possibile recuperare una serie di valori di proprietà che forniscono informazioni su un thread. In alcuni casi, è anche possibile impostare questi valori di proprietà per controllare il funzionamento del thread. Queste proprietà del thread includono:

  • Un nome Name è una proprietà di scrittura che è possibile usare per identificare un thread. Il valore predefinito è null.

  • Codice hash che è possibile recuperare chiamando il GetHashCode metodo . Il codice hash può essere usato per identificare in modo univoco un thread. per la durata del thread, il codice hash non entra in conflitto con il valore di qualsiasi altro thread, indipendentemente dal dominio dell'applicazione da cui si ottiene il valore.

  • ID thread. Il valore della proprietà di sola lettura viene assegnato dal runtime e identifica in modo univoco ManagedThreadId un thread all'interno del processo.

    Nota

    L'oggetto ThreadId di un sistema operativo non ha una relazione fissa con un thread gestito, perché un host non gestito può controllare la relazione tra thread gestiti e non gestiti. In particolare, un host sofisticato può usare l'API di hosting CLR per pianificare molti thread gestiti rispetto allo stesso thread del sistema operativo o per spostare un thread gestito tra thread del sistema operativo diversi.

  • Stato corrente del thread. Per la durata della sua esistenza, un thread si trova sempre in uno o più stati definiti dalla ThreadState proprietà .

  • Livello di priorità di pianificazione, definito dalla ThreadPriority proprietà . Sebbene sia possibile impostare questo valore per richiedere la priorità di un thread, non è garantito che sia rispettato dal sistema operativo.

  • Proprietà di sola IsThreadPoolThread lettura, che indica se un thread è un thread del pool di thread.

  • La proprietà IsBackground. Per altre informazioni, vedere la sezione Thread in primo piano e in background.

Costruttori

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(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)

Inizializza una nuova istanza della classe Thread.

Thread(ThreadStart, Int32)

Inizializza una nuova istanza della classe Thread, specificando la dimensione massima dello stack per il thread.

Proprietà

ApartmentState
Obsoleta.
Obsoleta.
Obsoleta.

Ottiene o imposta lo stato dell'apartment del thread.

CurrentContext

Ottiene il contesto corrente in cui è in esecuzione il thread.

CurrentCulture

Ottiene o imposta le impostazioni cultura per il thread corrente.

CurrentPrincipal

Ottiene o imposta l'entità corrente del thread (per la sicurezza basata sui ruoli).

CurrentThread

Ottiene il thread attualmente in esecuzione.

CurrentUICulture

Ottiene o imposta le impostazioni cultura correnti usate da Gestione risorse per cercare le risorse specifiche delle impostazioni cultura in fase di esecuzione.

ExecutionContext

Ottiene un oggetto ExecutionContext contenente informazioni sui diversi contesti del thread corrente.

IsAlive

Ottiene un valore che indica lo stato di esecuzione del thread corrente.

IsBackground

Ottiene o imposta un valore che indica se il thread viene eseguito in background.

IsThreadPoolThread

Ottiene un valore che indica se un thread appartiene o meno al pool di thread gestiti.

ManagedThreadId

Ottiene un identificatore univoco per il thread gestito corrente.

Name

Ottiene o imposta il nome del thread.

Priority

Ottiene o imposta un valore che indica la priorità di pianificazione di un thread.

ThreadState

Ottiene un valore contenente gli stati del thread corrente.

Metodi

Abort()
Obsoleta.

Genera un'eccezione ThreadAbortException nel thread in cui viene richiamato, per iniziare il processo di terminazione del thread. La chiamata a questo metodo in genere termina il thread.

Abort(Object)
Obsoleta.

Genera un'eccezione ThreadAbortException nel thread in cui viene richiamato per iniziare il processo di terminazione del thread fornendo anche informazioni sull'eccezione relative alla terminazione del thread. La chiamata a questo metodo in genere termina il thread.

AllocateDataSlot()

Alloca uno slot di dati senza nome su tutti i thread. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

AllocateNamedDataSlot(String)

Alloca uno slot di dati denominato su tutti i thread. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

BeginCriticalRegion()

Notifica a un host che l'esecuzione sta per entrare in un'area di codice in cui gli effetti di un'interruzione del thread o di un'eccezione non gestita possono rappresentare un rischio per altre attività nel dominio applicazione.

BeginThreadAffinity()

Notifica a un host che il codice gestito sta per eseguire istruzioni che dipendono dall'identità del thread fisico corrente del sistema operativo.

DisableComObjectEagerCleanup()

Disattiva la pulizia automatica dei Runtime Callable Wrapper (RCW) per il thread corrente.

EndCriticalRegion()

Notifica a un host che l'esecuzione sta per entrare in un'area di codice in cui gli effetti di un'interruzione del thread o di un'eccezione non gestita sono limitati all'attività corrente.

EndThreadAffinity()

Notifica a un host che il codice gestito ha terminato l'esecuzione di istruzioni che dipendono dall'identità del thread fisico corrente del sistema operativo.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
Finalize()

Garantisce che le risorse vengano liberate e che vengano eseguite le altre operazioni di pulizia quando l'oggetto Thread viene recuperato da Garbage Collector.

FreeNamedDataSlot(String)

Elimina l'associazione tra un nome e uno slot per tutti i thread del processo. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

GetApartmentState()

Restituisce un valore ApartmentState che indica lo stato dell'apartment.

GetCompressedStack()
Obsoleta.
Obsoleta.

Restituisce un oggetto CompressedStack che può essere usato per acquisire lo stack per il thread corrente.

GetCurrentProcessorId()

Ottiene un ID usato per indicare il processore in cui è in esecuzione il thread corrente.

GetData(LocalDataStoreSlot)

Recupera il valore dallo slot specificato sul thread corrente, all'interno del dominio corrente del thread corrente. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

GetDomain()

Restituisce il dominio corrente in cui viene eseguito il thread corrente.

GetDomainID()

Restituisce un identificatore di dominio applicazione univoco.

GetHashCode()

Restituisce un codice hash per il thread corrente.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetNamedDataSlot(String)

Cerca uno slot di dati denominato. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
Interrupt()

Interrompe un thread il cui stato è WaitSleepJoin.

Join()

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza, pur continuando a eseguire la distribuzione di SendMessage e COM standard.

Join(Int32)

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza o finché non trascorre l'intervallo di tempo specificato, pur continuando a eseguire la distribuzione di SendMessage e COM standard.

Join(TimeSpan)

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza o finché non trascorre l'intervallo di tempo specificato, pur continuando a eseguire la distribuzione di SendMessage e COM standard.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemoryBarrier()

Sincronizza l'accesso alla memoria come segue: il processore che esegue il thread corrente non può riordinare le istruzioni in modo tale che gli accessi alla memoria prima della chiamata al metodo MemoryBarrier() vengano eseguiti dopo quelli successivi alla chiamata al metodo MemoryBarrier().

ResetAbort()
Obsoleta.

Annulla il metodo Abort(Object) richiesto per il thread corrente.

Resume()
Obsoleta.
Obsoleta.
Obsoleta.

Riprende un thread che era stato sospeso.

SetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.

SetCompressedStack(CompressedStack)
Obsoleta.
Obsoleta.

Applica un oggetto CompressedStack acquisito al thread corrente.

SetData(LocalDataStoreSlot, Object)

Imposta i dati nello slot specificato sul thread in esecuzione per il dominio corrente di tale thread. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.

Sleep(Int32)

Sospende il thread corrente per il numero specificato di millisecondi.

Sleep(TimeSpan)

Sospende il thread corrente per il periodo di tempo specificato.

SpinWait(Int32)

Determina che un thread rimanga in attesa il numero di volte definito dal parametro iterations.

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.

Suspend()
Obsoleta.
Obsoleta.
Obsoleta.

Sospende il thread o, se il thread è già sospeso, non avrà alcun effetto.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
TrySetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.

UnsafeStart()

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running.

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

VolatileRead(Byte)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Double)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Int16)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Int32)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Int64)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(IntPtr)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Object)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(SByte)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(Single)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(UInt16)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(UInt32)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(UInt64)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileRead(UIntPtr)

Legge il valore di un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso.

VolatileWrite(Byte, Byte)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Double, Double)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Int16, Int16)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Int32, Int32)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Int64, Int64)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(IntPtr, IntPtr)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Object, Object)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(SByte, SByte)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(Single, Single)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(UInt16, UInt16)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(UInt32, UInt32)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(UInt64, UInt64)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

VolatileWrite(UIntPtr, UIntPtr)

Scrive un valore in un campo. Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso.

Yield()

Determina che il thread chiamante ceda l'esecuzione a un altro thread pronto per l'esecuzione sul processore corrente. Il sistema operativo seleziona il thread a cui cedere l'esecuzione.

Implementazioni dell'interfaccia esplicita

_Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.

_Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.

_Thread.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).

_Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.

Si applica a

Thread safety

Questo tipo è thread-safe.

Vedi anche