Thread Classe

Definizione

Crea e controlla un thread, ne imposta le priorità e ne ottiene lo stato.Creates and controls a thread, sets its priority, and gets its status.

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

Esempi

Nell'esempio seguente viene illustrata la funzionalità di threading semplice.The following example demonstrates simple threading functionality.

// [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 produce un output simile al seguente:This code produces output similar to the following:

[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, il Common Language Runtime crea automaticamente un singolo thread in primo piano per l'esecuzione del codice dell'applicazione.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Insieme a questo thread in primo piano principale, un processo può creare uno o più thread per eseguire una parte del codice programma associato al processo.Along with this main foreground thread, a process can create one or more threads to execute a portion of the program code associated with the process. Questi thread possono essere eseguiti in primo piano o in background.These threads can execute either in the foreground or in the background. Inoltre, è possibile utilizzare la classe ThreadPool per eseguire codice nei thread di lavoro gestiti dal Common Language Runtime.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

In questa sezioneIn this section

Avvio di un thread Starting a thread
Recupero di oggetti Thread Retrieving Thread objects
Thread in primo piano e in background Foreground and background threads
Impostazioni cultura e thread Culture and threads
Ottenere informazioni su e controllare i threadGetting information about and controlling threads

Avvio di un threadStarting a thread

Per avviare un thread, fornire un delegato che rappresenta il metodo che deve essere eseguito dal thread nel costruttore della classe.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Chiamare quindi il metodo Start per iniziare l'esecuzione.You then call the Start method to begin execution.

I costruttori di Thread possono assumere uno dei due tipi delegati, a seconda che sia possibile passare un argomento al metodo da eseguire:The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Se il metodo non ha argomenti, passare un delegato ThreadStart al costruttore.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Ha la firma:It has the signature:

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

    Nell'esempio seguente viene creato e avviato un thread che esegue il metodo ExecuteInForeground.The following example creates and starts a thread that executes the ExecuteInForeground method. Il metodo Visualizza informazioni su alcune proprietà del thread, quindi esegue un ciclo in cui viene sospesa per mezzo di un secondo e visualizza il numero di secondi trascorso.The method displays information about some thread properties, then executes a loop in which it pauses for half a second and displays the elapsed number of seconds. Quando il thread è stato eseguito per almeno cinque secondi, il ciclo termina e il thread termina l'esecuzione.When the thread has executed for at least five seconds, the loop ends and the thread terminates execution.

    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()
       {
          DateTime start = DateTime.Now;
          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, viene passato un delegato ParameterizedThreadStart al costruttore.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Ha la firma:It has the signature:

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

    Il metodo eseguito dal delegato può quindi eseguire il cast ( C#in) o convertire (in Visual Basic) il parametro nel tipo appropriato.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    L'esempio seguente è identico a quello precedente, ad eccezione del fatto che chiama il costruttore Thread(ParameterizedThreadStart).The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Questa versione del metodo ExecuteInForeground dispone di un singolo parametro che rappresenta il numero approssimativo di millisecondi per l'esecuzione del ciclo.This version of the ExecuteInForeground method has a single parameter that represents the approximate number of milliseconds the loop is to execute.

    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;
          }
          DateTime start = DateTime.Now;
          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 oggetto Thread dopo l'avvio del thread.It is not necessary to retain a reference to a Thread object once you have started the thread. Il thread continua a essere eseguito fino al completamento della procedura del thread.The thread continues to execute until the thread procedure is complete.

Recupero di oggetti threadRetrieving Thread objects

È possibile usare la proprietà statica (Shared in Visual Basic) CurrentThread per recuperare un riferimento al thread attualmente in esecuzione dal codice in esecuzione nel thread.You can use the static (Shared in Visual Basic) CurrentThread property to retrieve a reference to the currently executing thread from the code that the thread is executing. Nell'esempio seguente viene utilizzata la proprietà CurrentThread per visualizzare informazioni sul thread principale dell'applicazione, un altro thread in primo piano, un thread in background e un thread del pool di thread.The following example uses the CurrentThread property to display information about the main application thread, another foreground thread, a background thread, and a thread pool 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 backgroundForeground and background threads

Le istanze della classe Thread rappresentano i thread in primo piano o i thread in background.Instances of the Thread class represent either foreground threads or background threads. I thread in background sono identici ai thread in primo piano con un'unica eccezione: un thread in background non mantiene un processo in esecuzione se tutti i thread in primo piano sono terminati.Background threads are identical to foreground threads with one exception: a background thread does not keep a process running if all foreground threads have terminated. Una volta arrestati tutti i thread in primo piano, il runtime arresta tutti i thread in background e si arresta.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Per impostazione predefinita, i thread seguenti vengono eseguiti in primo piano:By default, the following threads execute in the foreground:

  • Thread principale dell'applicazione.The main application thread.

  • Tutti i thread creati chiamando un costruttore della classe Thread.All threads created by calling a Thread class constructor.

Per impostazione predefinita, i thread seguenti vengono eseguiti in background:The following threads execute in the background by default:

  • Thread del pool di thread, ovvero un pool di thread di lavoro gestiti dal runtime.Thread pool threads, which are a pool of worker threads maintained by the runtime. È possibile configurare il pool di thread e pianificare il lavoro nei thread del pool di thread utilizzando la classe ThreadPool.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Nota

    Le operazioni asincrone basate su attività vengono eseguite automaticamente nei thread del pool di thread.Task-based asynchronous operations automatically execute on thread pool threads. Le operazioni asincrone basate su attività usano le classi Task e Task<TResult> per implementare il modello asincrono basato su attività.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Tutti i thread che entrano nell'ambiente di esecuzione gestito da codice non gestito.All threads that enter the managed execution environment from unmanaged code.

È possibile modificare un thread per l'esecuzione in background impostando la proprietà IsBackground in qualsiasi momento.You can change a thread to execute in the background by setting the IsBackground property at any time. I thread in background sono utili per qualsiasi operazione che deve continuare fino a quando un'applicazione è in esecuzione, ma non impedisce la terminazione dell'applicazione, ad esempio il monitoraggio file system le modifiche o le connessioni socket in ingresso.Background threads are useful for any operation that should continue as long as an application is running but should not prevent the application from terminating, such as monitoring file system changes or incoming socket connections.

Nell'esempio seguente viene illustrata la differenza tra i thread in primo piano e in background.The following example illustrates the difference between foreground and background threads. È come il primo esempio nella sezione avvio di un thread , con la differenza che imposta il thread per l'esecuzione in background prima di avviarlo.It is like the first example in the Starting a thread section, except that it sets the thread to execute in the background before starting it. Come illustrato nell'output, il ciclo viene interrotto prima dell'esecuzione per cinque secondi.As the output shows, the loop is interrupted before it executes for five seconds.

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()
   {
      DateTime start = DateTime.Now;
      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 threadCulture and threads

Ogni thread dispone di impostazioni cultura, rappresentate dalla proprietà CurrentCulture e delle impostazioni cultura dell'interfaccia utente, rappresentate dalla proprietà CurrentUICulture.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. Le impostazioni cultura correnti supportano le operazioni dipendenti dalle impostazioni cultura come l'analisi e la formattazione, il confronto e l'ordinamento delle stringhe e controlla anche il sistema di scrittura e il calendario usati da un thread.The current culture supports such culture-sensitive operations as parsing and formatting, string comparison and sorting, and also controls the writing system and calendar used by a thread. Le impostazioni cultura dell'interfaccia utente correnti forniscono il recupero con distinzione delle impostazioni cultura delle risorse nei file di risorse.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Importante

Le proprietà CurrentCulture e CurrentUICulture non funzionano in modo affidabile quando vengono usate con un thread diverso dal thread corrente.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. 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 Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. In .NET Core viene generata un'InvalidOperationException se un thread tenta di leggere o scrivere queste proprietà in un thread diverso.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. Si consiglia di utilizzare le proprietà CultureInfo.CurrentCulture e CultureInfo.CurrentUICulture per recuperare e impostare le impostazioni cultura correnti.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

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 dalle impostazioni cultura dell'interfaccia utente e non dalle impostazioni cultura e dalle impostazioni cultura dell'interfaccia utente del thread da cui viene creato il nuovo thread.When a new thread is instantiated, its culture and UI culture are defined by the current system culture and UI culture, and not by the culture and UI culture of the thread from which the new thread is created. Ciò significa, ad esempio, che se le impostazioni cultura correnti del sistema sono in inglese (Stati Uniti) e le impostazioni cultura correnti del thread dell'applicazione principale sono francesi (Francia), le impostazioni cultura di un nuovo thread creato chiamando il costruttore di Thread(ParameterizedThreadStart) dal thread primario sono in inglese (Stati Uniti) e non in francese (Francia).This means, for example, that if the current system culture is English (United States) and the current culture of the primary application thread is French (France), the culture of a new thread created by calling the Thread(ParameterizedThreadStart) constructor from the primary thread is English (United States), and not French (France). Per ulteriori informazioni, vedere la sezione "impostazioni cultura e thread" dell'argomento classe CultureInfo.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Importante

Questo non vale per i thread che eseguono operazioni asincrone per le app destinate a .NET Framework 4.6.NET Framework 4.6 e versioni successive, in questo caso, le impostazioni cultura e le impostazioni cultura dell'interfaccia utente fanno parte di un contesto di operazioni asincrone. il thread sul quale viene eseguita un'operazione asincrona per impostazione predefinita eredita le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del thread da cui è stata avviata l'operazione asincrona.This is not true of threads that execute asynchronous operations for apps that target the .NET Framework 4.6.NET Framework 4.6 and later versions, In this case, the culture and UI culture is part of an asynchronous operations' context; the thread on which an asynchronous operation executes by default inherits the culture and UI culture of the thread from which the asynchronous operation was launched. Per altre informazioni, vedere la sezione dedicata alle impostazioni cultura e alle operazioni asincrone basate su attività nell'argomento relativo alla classe CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

Per assicurarsi che tutti i thread in esecuzione in un'applicazione condividano le stesse impostazioni cultura e le stesse impostazioni cultura dell'interfaccia utente, è possibile eseguire una delle operazioni seguenti:You can do either of the following to ensure that all of the threads executing in an application share the same culture and UI culture:

Per ulteriori informazioni ed esempi, vedere la sezione "impostazioni cultura e thread" dell'argomento classe CultureInfo.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Ottenere informazioni su e controllare i threadGetting information about and controlling threads

È possibile recuperare un numero di valori di proprietà che forniscono informazioni su un thread.You can retrieve a number of property values that provide information about a thread. In alcuni casi, è anche possibile impostare questi valori di proprietà per controllare l'operazione del thread.In some cases, you can also set these property values to control the operation of the thread. Queste proprietà del thread includono:These thread properties include:

  • Un nomeA name. Name è una proprietà Write-Once che è possibile usare per identificare un thread.Name is a write-once property that you can use to identify a thread. Il valore predefinito è null.Its default value is null.

  • Codice hash, che può essere recuperato chiamando il metodo GetHashCode.A hash code, which you can retrieve by calling the GetHashCode method. Il codice hash può essere usato per identificare in modo univoco un thread. per la durata del thread, il codice hash non entrerà in conflitto con il valore di qualsiasi altro thread, indipendentemente dal dominio dell'applicazione da cui si ottiene il valore.The hash code can be used to uniquely identify a thread; for the lifetime of your thread, its hash code will not collide with the value from any other thread, regardless of the application domain from which you obtain the value.

  • ID thread.A thread ID. Il valore della proprietà ManagedThreadId di sola lettura viene assegnato dal runtime e identifica in modo univoco un thread all'interno del processo.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    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.An operating-system ThreadId has no fixed relationship to a managed thread, because an unmanaged host can control the relationship between managed and unmanaged threads. In particolare, un host sofisticato può usare l' API di hosting CLR per pianificare molti thread gestiti sullo stesso thread del sistema operativo o per spostare un thread gestito tra diversi thread del sistema operativo.Specifically, a sophisticated host can use the CLR Hosting API to schedule many managed threads against the same operating system thread, or to move a managed thread between different operating system threads.

  • Stato corrente del thread.The thread's current state. Per la durata della sua esistenza, un thread si trova sempre in uno o più stati definiti dalla proprietà ThreadState.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Un livello di priorità di pianificazione, definito dalla proprietà ThreadPriority.A scheduling priority level, which is defined by the ThreadPriority property. Sebbene sia possibile impostare questo valore per richiedere la priorità di un thread, non è garantito che venga rispettato dal sistema operativo.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • Proprietà di IsThreadPoolThread di sola lettura, che indica se un thread è un thread del pool di thread.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • Proprietà IsBackground.The IsBackground property. Per ulteriori informazioni, vedere la sezione thread in primo piano e in background .For more information, see the Foreground and background threads section.

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.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started.

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.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started and specifying the maximum stack size for the thread.

Thread(ThreadStart)

Inizializza una nuova istanza della classe Thread.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32)

Inizializza una nuova istanza della classe Thread, specificando la dimensione massima dello stack per il thread.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Proprietà

ApartmentState

Ottiene o imposta lo stato dell'apartment del thread.Gets or sets the apartment state of this thread.

CurrentContext

Ottiene il contesto corrente in cui è in esecuzione il thread.Gets the current context in which the thread is executing.

CurrentCulture

Ottiene o imposta le impostazioni cultura per il thread corrente.Gets or sets the culture for the current thread.

CurrentPrincipal

Ottiene o imposta l'entità corrente del thread (per la sicurezza basata sui ruoli).Gets or sets the thread's current principal (for role-based security).

CurrentThread

Ottiene il thread attualmente in esecuzione.Gets the currently running thread.

CurrentUICulture

Ottiene o imposta le impostazioni cultura correnti usate da Gestione risorse per cercare le risorse specifiche delle impostazioni cultura in fase di esecuzione.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext

Ottiene un oggetto ExecutionContext contenente informazioni sui diversi contesti del thread corrente.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive

Ottiene un valore che indica lo stato di esecuzione del thread corrente.Gets a value indicating the execution status of the current thread.

IsBackground

Ottiene o imposta un valore che indica se il thread viene eseguito in background.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread

Ottiene un valore che indica se un thread appartiene o meno al pool di thread gestiti.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId

Ottiene un identificatore univoco per il thread gestito corrente.Gets a unique identifier for the current managed thread.

Name

Ottiene o imposta il nome del thread.Gets or sets the name of the thread.

Priority

Ottiene o imposta un valore che indica la priorità di pianificazione di un thread.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState

Ottiene un valore contenente gli stati del thread corrente.Gets a value containing the states of the current thread.

Metodi

Abort()

Genera un'eccezione ThreadAbortException nel thread in cui viene richiamato, per iniziare il processo di terminazione del thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. La chiamata a questo metodo in genere termina il thread.Calling this method usually terminates the thread.

Abort(Object)

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.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. La chiamata a questo metodo in genere termina il thread.Calling this method usually terminates the thread.

AllocateDataSlot()

Alloca uno slot di dati senza nome su tutti i thread.Allocates an unnamed data slot on all the threads. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String)

Alloca uno slot di dati denominato su tutti i thread.Allocates a named data slot on all threads. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

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.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception might jeopardize other tasks in the application domain.

BeginThreadAffinity()

Notifica a un host che il codice gestito sta per eseguire istruzioni che dipendono dall'identità del thread fisico corrente del sistema operativo.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup()

Disattiva la pulizia automatica dei Runtime Callable Wrapper (RCW) per il thread corrente.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current thread.

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.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception are limited to the current task.

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.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(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.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String)

Elimina l'associazione tra un nome e uno slot per tutti i thread del processo.Eliminates the association between a name and a slot, for all threads in the process. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState()

Restituisce un valore ApartmentState che indica lo stato dell'apartment.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack()

Restituisce un oggetto CompressedStack che può essere usato per acquisire lo stack per il thread corrente.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId()

Ottiene un ID usato per indicare il processore in cui è in esecuzione il thread corrente.Gets an ID used to indicate on which processor the current thread is executing.

GetData(LocalDataStoreSlot)

Recupera il valore dallo slot specificato sul thread corrente, all'interno del dominio corrente del thread corrente.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain()

Restituisce il dominio corrente in cui viene eseguito il thread corrente.Returns the current domain in which the current thread is running.

GetDomainID()

Restituisce un identificatore di dominio applicazione univoco.Returns a unique application domain identifier.

GetHashCode()

Restituisce un codice hash per il thread corrente.Returns a hash code for the current thread.

GetNamedDataSlot(String)

Cerca uno slot di dati denominato.Looks up a named data slot. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
Interrupt()

Interrompe un thread il cui stato è WaitSleepJoin.Interrupts a thread that is in the WaitSleepJoin thread state.

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.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

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.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

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.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(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().Synchronizes memory access as follows: The processor executing the current thread cannot reorder instructions in such a way that memory accesses prior to the call to MemoryBarrier() execute after memory accesses that follow the call to MemoryBarrier().

ResetAbort()

Annulla il metodo Abort(Object) richiesto per il thread corrente.Cancels an Abort(Object) requested for the current thread.

Resume()

Riprende un thread che era stato sospeso.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack)

Applica un oggetto CompressedStack acquisito al thread corrente.Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object)

Imposta i dati nello slot specificato sul thread in esecuzione per il dominio corrente di tale thread.Sets the data in the specified slot on the currently running thread, for that thread's current domain. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32)

Sospende il thread corrente per il numero specificato di millisecondi.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan)

Sospende il thread corrente per il periodo di tempo specificato.Suspends the current thread for the specified amount of time.

SpinWait(Int32)

Determina che un thread rimanga in attesa il numero di volte definito dal parametro iterations.Causes a thread to wait the number of times defined by the iterations parameter.

Start()

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running.Causes the operating system to change the state of the current instance to 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.Causes the operating system to change the state of the current instance to Running, and optionally supplies an object containing data to be used by the method the thread executes.

Suspend()

Sospende il thread o, se il thread è già sospeso, non avrà alcun effetto.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TrySetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.Sets the apartment state of a thread before it is started.

VolatileRead(Byte)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Double)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int16)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int32)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int64)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(IntPtr)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Object)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(SByte)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Single)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt16)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt32)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt64)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UIntPtr)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileWrite(Byte, Byte)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield()

Determina che il thread chiamante ceda l'esecuzione a un altro thread pronto per l'esecuzione sul processore corrente.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. Il sistema operativo seleziona il thread a cui cedere l'esecuzione.The operating system selects the thread to yield to.

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.Maps a set of names to a corresponding set of dispatch identifiers.

_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.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

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

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche