System.Threading.Threading,Thread, klasa
Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.
Klasa Thread tworzy i kontroluje wątek, ustawia swój priorytet i pobiera jego stan.
Po uruchomieniu procesu środowisko uruchomieniowe języka wspólnego automatycznie tworzy pojedynczy wątek pierwszego planu w celu wykonania kodu aplikacji. Wraz z tym głównym wątkiem pierwszego planu proces może utworzyć co najmniej jeden wątek, aby wykonać część kodu programu skojarzonego z procesem. Te wątki mogą być wykonywane na pierwszym planie lub w tle. Ponadto można użyć ThreadPool klasy do wykonywania kodu w wątkach procesów roboczych zarządzanych przez środowisko uruchomieniowe języka wspólnego.
Uruchamianie wątku
Należy uruchomić wątek, podając delegata reprezentującego metodę, którą wątek ma zostać wykonany w konstruktorze klasy. Następnie wywołaj metodę Start , aby rozpocząć wykonywanie.
Konstruktory Thread mogą przyjmować jeden z dwóch typów delegatów, w zależności od tego, czy można przekazać argument do metody do wykonania:
Jeśli metoda nie ma argumentów, należy przekazać ThreadStart delegata do konstruktora. Ma podpis:
public delegate void ThreadStart()Public Delegate Sub ThreadStart()Poniższy przykład tworzy i uruchamia wątek, który wykonuje metodę
ExecuteInForeground. Metoda wyświetla informacje o niektórych właściwościach wątku, a następnie wykonuje pętlę, w której jest wstrzymana przez pół sekundy i wyświetla upłynął czas rzędu sekund. Po wykonaniu wątku przez co najmniej pięć sekund pętla kończy się, a wątek kończy wykonywanie.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 secondsJeśli metoda ma argument, należy przekazać ParameterizedThreadStart delegata do konstruktora. Ma podpis:
public delegate void ParameterizedThreadStart(object obj)Public Delegate Sub ParameterizedThreadStart(obj As Object)Metoda wykonywana przez delegata może następnie rzutować (w języku C#) lub przekonwertować (w Visual Basic) parametr na odpowiedni typ.
Poniższy przykład jest identyczny z poprzednim, z tą różnicą, że wywołuje Thread(ParameterizedThreadStart) konstruktor. Ta wersja
ExecuteInForegroundmetody ma jeden parametr, który reprezentuje przybliżoną liczbę milisekund, którą należy wykonać.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
Nie jest konieczne zachowanie odwołania do Thread obiektu po uruchomieniu wątku. Wątek będzie kontynuowany do momentu ukończenia procedury wątku.
Pobieranie obiektów wątku
Możesz użyć właściwości static (Shared w Visual Basic), CurrentThread aby pobrać odwołanie do aktualnie wykonywanego wątku z kodu, który wykonuje wątek. W poniższym przykładzie użyto CurrentThread właściwości do wyświetlania informacji o głównym wątku aplikacji, innym wątku pierwszego planu, wątku tła i wątku puli wątków.
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
Wątki pierwszego planu i tła
Thread Wystąpienia klasy reprezentują wątki pierwszego planu lub wątki tła. Wątki w tle są identyczne z wątkami pierwszego planu z jednym wyjątkiem: wątek w tle nie zachowuje działania procesu, jeśli wszystkie wątki pierwszego planu zostały zakończone. Po zatrzymaniu wszystkich wątków pierwszego planu środowisko uruchomieniowe zatrzymuje wszystkie wątki w tle i zamyka je.
Domyślnie następujące wątki są wykonywane na pierwszym planie:
Główny wątek aplikacji.
Wszystkie wątki utworzone przez wywołanie konstruktora Thread klasy.
Następujące wątki są domyślnie wykonywane w tle:
Wątki puli wątków, które pochodzą z puli wątków roboczych obsługiwanych przez środowisko uruchomieniowe. Pulę wątków można skonfigurować i zaplanować pracę w wątkach puli wątków przy użyciu ThreadPool klasy .
Uwaga
Operacje asynchroniczne oparte na zadaniach są wykonywane automatycznie w wątkach puli wątków. Operacje asynchroniczne oparte na zadaniach używają Task klas i Task<TResult> do implementowania wzorca asynchronicznego opartego na zadaniach.
Wszystkie wątki, które wchodzą w zarządzane środowisko wykonywania z niezarządzanego kodu.
Możesz zmienić wątek, aby był wykonywany w tle, ustawiając IsBackground właściwość w dowolnym momencie. Wątki w tle są przydatne w przypadku każdej operacji, która powinna być kontynuowana tak długo, jak działa aplikacja, ale nie powinna uniemożliwiać aplikacji zakończenia, takich jak monitorowanie zmian systemu plików lub połączeń gniazd przychodzących.
Poniższy przykład ilustruje różnicę między wątkami pierwszego planu i tła. Jest on podobny do pierwszego przykładu w sekcji Rozpocznij wątek, z tą różnicą, że ustawia wątek do wykonania w tle przed jego uruchomieniem. Jak pokazano w danych wyjściowych, pętla jest przerywana, zanim zostanie wykonana przez pięć sekund.
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...
Kultura i wątki
Każdy wątek ma kulturę reprezentowaną przez CurrentCulture właściwość i kulturę interfejsu użytkownika reprezentowaną CurrentUICulture przez właściwość. Bieżąca kultura obsługuje operacje wrażliwe na kulturę, takie jak analizowanie i formatowanie, porównywanie ciągów i sortowanie, a także kontroluje system zapisu i kalendarz używany przez wątek. Bieżąca kultura interfejsu użytkownika umożliwia pobieranie zasobów w plikach zasobów z uwzględnieniem kultury.
Ważne
Właściwości CurrentCulture i CurrentUICulture nie działają niezawodnie w przypadku użycia z żadnym wątkiem innym niż bieżący wątek. W programie .NET Framework odczytywanie tych właściwości jest niezawodne, chociaż ustawienie tych właściwości dla wątku innego niż bieżący wątek nie jest. Na platformie .NET Core element jest zgłaszany, InvalidOperationException jeśli wątek próbuje odczytać lub zapisać te właściwości w innym wątku. Zalecamy użycie CultureInfo.CurrentCulture właściwości i CultureInfo.CurrentUICulture do pobrania i ustawienia bieżącej kultury.
Po utworzeniu wystąpienia nowego wątku jego kultura i kultura interfejsu użytkownika są definiowane przez bieżącą kulturę systemu i kulturę interfejsu użytkownika, a nie kulturę i kulturę interfejsu użytkownika wątku, z którego tworzony jest nowy wątek. Oznacza to na przykład, że jeśli bieżąca kultura systemowa to angielski (Stany Zjednoczone), a bieżąca kultura podstawowego wątku aplikacji to francuski (Francja), kultura nowego wątku utworzonego przez wywołanie Thread(ParameterizedThreadStart) konstruktora z wątku podstawowego to angielski (Stany Zjednoczone), a nie francuski (Francja). Aby uzyskać więcej informacji, zobacz sekcję "Kultura i wątki" tematu CultureInfo klasy.
Ważne
Nie dotyczy to wątków, które wykonują operacje asynchroniczne dla aplikacji przeznaczonych dla platformy .NET Framework 4.6 i nowszych wersji. W tym przypadku kultura i kultura interfejsu użytkownika są częścią kontekstu operacji asynchronicznej; wątek, na którym jest wykonywana operacja asynchroniczna, domyślnie dziedziczy kulturę i kulturę interfejsu użytkownika wątku, z którego została uruchomiona operacja asynchroniczna. Aby uzyskać więcej informacji, zobacz sekcję "Operacje asynchroniczne oparte na kulturze i zadaniach" w CultureInfo uwagach klasy.
Możesz wykonać jedną z następujących czynności, aby upewnić się, że wszystkie wątki wykonywane w aplikacji mają taką samą kulturę i kulturę interfejsu użytkownika:
Możesz przekazać obiekt reprezentujący tę kulturę CultureInfo do delegata ParameterizedThreadStart lub ThreadPool.QueueUserWorkItem(WaitCallback, Object) metody.
W przypadku aplikacji działających w programie .NET Framework 4.5 lub nowszych wersjach można zdefiniować kulturę i kulturę interfejsu użytkownika, która ma zostać przypisana do wszystkich wątków utworzonych w domenie aplikacji, ustawiając wartość CultureInfo.DefaultThreadCurrentCulture właściwości i CultureInfo.DefaultThreadCurrentUICulture . Należy pamiętać, że jest to ustawienie domeny dla aplikacji.
Aby uzyskać więcej informacji i przykładów, zobacz sekcję CultureInfo "Kultura i wątki" w uwagach klasy.
Uzyskiwanie informacji o wątkach sterujących i
Możesz pobrać kilka wartości właściwości, które zawierają informacje o wątku. W niektórych przypadkach można również ustawić te wartości właściwości, aby kontrolować działanie wątku. Te właściwości wątku obejmują:
Nazwa. Name jest właściwością typu "jeden raz", której można użyć do identyfikowania wątku. Jego wartością domyślną jest
null.Kod skrótu, który można pobrać, wywołując metodę GetHashCode . Kod skrótu może służyć do unikatowego identyfikowania wątku; w okresie istnienia wątku jego kod skrótu nie będzie zderzać się z wartością z żadnego innego wątku, niezależnie od domeny aplikacji, z której uzyskujesz wartość.
Identyfikator wątku. Wartość właściwości tylko ManagedThreadId do odczytu jest przypisywana przez środowisko uruchomieniowe i jednoznacznie identyfikuje wątek w ramach jego procesu.
Uwaga
Identyfikator ThreadId systemu operacyjnego nie ma stałej relacji z zarządzanym wątkiem, ponieważ host niezarządzany może kontrolować relację między zarządzanymi i niezarządzanych wątkami. W szczególności zaawansowany host może używać interfejsu API hostingu CLR do planowania wielu zarządzanych wątków względem tego samego wątku systemu operacyjnego lub przenoszenia zarządzanego wątku między różnymi wątkami systemu operacyjnego.
Bieżący stan wątku. W czasie jego istnienia wątek jest zawsze w jednym lub kilku stanach zdefiniowanych ThreadState przez właściwość.
Poziom priorytetu planowania, który jest definiowany ThreadPriority przez właściwość . Mimo że można ustawić tę wartość na żądanie priorytetu wątku, nie ma gwarancji, że jest on honorowany przez system operacyjny.
Właściwość tylko do IsThreadPoolThread odczytu, która wskazuje, czy wątek jest wątkiem puli wątków.
Właściwość IsBackground . Aby uzyskać więcej informacji, zobacz sekcję Wątki pierwszego planu i tła.
Przykłady
W poniższym przykładzie pokazano proste funkcje wątkowości.
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
Ten kod generuje dane wyjściowe podobne do następujących:
[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.
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla