Classe System.Threading.Thread
Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.
La Thread classe crea e controlla un thread, ne imposta la priorità e ne ottiene lo stato.
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 ThreadPool classe per eseguire codice nei thread di lavoro gestiti da Common Language Runtime.
Avviare un thread
Si avvia un thread specificando un delegato che rappresenta il metodo che il thread deve essere eseguito nel relativo costruttore di classe. Chiamare quindi il metodo per iniziare l'esecuzione Start .
I Thread costruttori possono accettare uno dei due tipi di delegato, a seconda che sia possibile passare un argomento al metodo da eseguire:
Se il metodo non contiene argomenti, passare un ThreadStart 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
ExecuteInForegroundmetodo . Il metodo visualizza informazioni su alcune proprietà del thread, quindi esegue un ciclo in cui viene sospeso per mezzo secondo e visualizza il numero trascorso di secondi. 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 Example2 { 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 secondsopen System.Diagnostics open System.Threading let executeInForeground () = let sw = Stopwatch.StartNew() printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}" while sw.ElapsedMilliseconds <= 5000 do printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds" Thread.Sleep 500 sw.Stop() let th = Thread executeInForeground th.Start() Thread.Sleep 1000 printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..." // 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 secondsImports System.Diagnostics Imports System.Threading Module Example3 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 secondsSe il metodo ha un argomento, si passa un ParameterizedThreadStart 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
ExecuteInForegroundmetodo ha un singolo parametro che rappresenta il numero approssimativo di millisecondi da eseguire.using System; using System.Diagnostics; using System.Threading; public class Example3 { 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 secondsopen System open System.Diagnostics open System.Threading let executeInForeground obj = let interval = try unbox<int> obj with :? InvalidCastException -> 5000 let sw = Stopwatch.StartNew() printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}" while sw.ElapsedMilliseconds <= interval do printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds" Thread.Sleep 500 sw.Stop() let th = Thread(ParameterizedThreadStart executeInForeground) th.Start 4500 Thread.Sleep 1000 printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..." // 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 secondsImports System.Diagnostics Imports System.Threading Module Example4 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 conservare un riferimento a un Thread oggetto dopo aver avviato il thread. Il thread continua a essere eseguito fino al completamento della routine del thread.
Recuperare oggetti Thread
È possibile utilizzare la proprietà statica (Shared in Visual Basic) CurrentThread per recuperare un riferimento al thread attualmente in esecuzione dal codice in cui è in esecuzione il thread. Nell'esempio seguente viene utilizzata la CurrentThread proprietà per visualizzare informazioni sul thread applicazione principale, un altro thread in primo piano, un thread in background e un thread del pool di thread.
using System;
using System.Threading;
public class Example1
{
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
open System.Threading
let obj = obj ()
let showThreadInformation (state: obj) =
lock obj (fun () ->
let th = Thread.CurrentThread
printfn $"Managed thread #{th.ManagedThreadId}: "
printfn $" Background thread: {th.IsBackground}"
printfn $" Thread pool thread: {th.IsThreadPoolThread}"
printfn $" Priority: {th.Priority}"
printfn $" Culture: {th.CurrentCulture.Name}"
printfn $" UI culture: {th.CurrentUICulture.Name}"
printfn "")
ThreadPool.QueueUserWorkItem showThreadInformation |> ignore
let th1 = Thread(ParameterizedThreadStart showThreadInformation)
th1.Start()
let th2 = Thread(ParameterizedThreadStart showThreadInformation)
th2.IsBackground <- true
th2.Start()
Thread.Sleep 500
showThreadInformation ()
// 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 Example2
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'unica eccezione: un thread in background non mantiene un processo in esecuzione se tutti i thread in primo piano hanno terminato. 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 sono eseguiti in primo piano:
Thread dell'applicazione principale.
Tutti i thread creati chiamando un Thread costruttore di classe.
Per impostazione predefinita, i thread seguenti sono eseguiti in background:
Thread del pool di thread, provenienti da 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 le Task classi e Task<TResult> per implementare il modello asincrono basato su attività.
Tutti i thread che immettono l'ambiente di esecuzione gestita da codice non gestito.
È possibile modificare un thread da eseguire 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 all'applicazione di terminare, ad esempio il monitoraggio delle modifiche del file system o delle connessioni socket in ingresso.
L'esempio seguente illustra la differenza tra thread in primo piano e in background. È come il primo esempio nella sezione Avvia 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 dell'esecuzione 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...
open System.Diagnostics
open System.Threading
let executeInForeground () =
let sw = Stopwatch.StartNew()
printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
while sw.ElapsedMilliseconds <= 5000 do
printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
Thread.Sleep 500
sw.Stop()
let th = Thread executeInForeground
th.IsBackground <- true
th.Start()
Thread.Sleep 1000
printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
// 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 Example1
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 CurrentCulture proprietà e dalle impostazioni cultura dell'interfaccia CurrentUICulture utente, rappresentate dalla proprietà . Le impostazioni cultura correnti supportano operazioni sensibili alle impostazioni cultura, ad esempio l'analisi e la formattazione, il confronto di stringhe e l'ordinamento e controllano anche il sistema di scrittura e il calendario usati da un thread. Le impostazioni cultura correnti dell'interfaccia utente forniscono il recupero sensibile alle impostazioni cultura delle risorse nei file di risorse.
Importante
Le CurrentCulture proprietà e CurrentUICulture non funzionano in modo affidabile quando vengono usate con qualsiasi thread diverso dal thread 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 è. In .NET Core viene generata un'eccezione InvalidOperationException se un thread tenta di leggere o scrivere queste proprietà in un thread diverso. È consigliabile usare le CultureInfo.CurrentCulture proprietà e CultureInfo.CurrentUICulture per recuperare e impostare le impostazioni cultura 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 e dalle impostazioni cultura correnti 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 di sistema correnti sono inglese (Stati Uniti) e le impostazioni cultura correnti del thread applicazione primario sono francese (Francia), le impostazioni cultura di un nuovo thread creato chiamando il Thread(ParameterizedThreadStart) costruttore dal thread primario sono inglese (Stati Uniti) e non francese (Francia). Per altre informazioni, vedere la sezione "Impostazioni cultura e thread" dell'argomento della CultureInfo classe.
Importante
Questo non vale per i thread che eseguono operazioni asincrone per le app destinate a .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 per impostazione predefinita eredita 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 "Impostazioni cultura e operazioni asincrone basate su attività" delle osservazioni della CultureInfo classe.
È possibile eseguire una delle operazioni seguenti per assicurarsi che tutti i thread in esecuzione in un'applicazione condividono le stesse impostazioni cultura e impostazioni cultura dell'interfaccia utente:
È possibile passare un CultureInfo oggetto che rappresenta le impostazioni cultura al ParameterizedThreadStart delegato o al ThreadPool.QueueUserWorkItem(WaitCallback, Object) metodo .
Per le app in esecuzione in .NET Framework 4.5 e versioni successive, è possibile definire le impostazioni cultura e le impostazioni cultura dell'interfaccia utente da assegnare a tutti i thread creati in un dominio applicazione impostando il valore delle CultureInfo.DefaultThreadCurrentCulture proprietà e CultureInfo.DefaultThreadCurrentUICulture . Si noti che si tratta di un'impostazione di dominio per applicazione.
Per altre informazioni ed esempi, vedere la sezione "Impostazioni cultura e thread" delle osservazioni della CultureInfo classe.
Ottenere informazioni sui thread di controllo e
È 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 l'operazione del thread. Queste proprietà del thread includono:
Un nome. Name è una proprietà write-once 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 relativo codice hash non sarà 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 ManagedThreadId lettura viene assegnato dal runtime e identifica in modo univoco un thread all'interno del relativo 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 sullo stesso thread del sistema operativo o spostare un thread gestito tra diversi thread del sistema operativo.
Stato corrente del thread. Per la durata dell'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 venga 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 .
Esempi
Nell'esempio seguente viene illustrata una semplice funzionalità di threading.
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();
}
}
open System.Threading
// Simple threading scenario: Start a static method running
// on a second thread.
// 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.
let threadProc () =
for i = 0 to 9 do
printfn $"ThreadProc: {i}"
// Yield the rest of the time slice.
Thread.Sleep 0
printfn "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. F# simplifies the creation of this delegate.
let t = Thread 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 _ = 0 to 3 do
printfn "Main thread: Do some work."
Thread.Sleep 0
printfn "Main thread: Call Join(), to wait until ThreadProc ends."
t.Join()
printfn "Main thread: ThreadProc.Join has returned. Press Enter to end program."
stdin.ReadLine() |> ignore
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:
[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 e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per