System.Threading.Thread osztály
Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.
Az Thread osztály létrehoz és vezérel egy szálat, beállítja annak prioritását, és megkapja az állapotát.
Amikor egy folyamat elindul, a közös nyelvi futtatókörnyezet automatikusan létrehoz egy előtérszálat az alkalmazáskód végrehajtásához. Ezzel a fő előtérszállal együtt egy folyamat létrehozhat egy vagy több szálat a folyamathoz társított programkód egy részének végrehajtásához. Ezek a szálak az előtérben vagy a háttérben is végrehajthatók. Emellett az ThreadPool osztály használatával kódot hajthat végre a közös nyelvi futtatókörnyezet által felügyelt munkavégző szálakon.
Szál indítása
Egy szál elindításához adjon meg egy meghatalmazottat, amely azt a metódust jelöli, amelyet a szál az osztálykonstruktorban hajt végre. Ezután meghívja a metódust a Start végrehajtás megkezdéséhez.
A Thread konstruktorok két delegálttípus egyikét is használhatják attól függően, hogy átadhat-e argumentumot a végrehajtandó metódusnak:
Ha a metódus nem rendelkezik argumentumokkal, egy meghatalmazottat ThreadStart ad át a konstruktornak. Az aláírása:
public delegate void ThreadStart()Public Delegate Sub ThreadStart()Az alábbi példa létrehoz és elindít egy szálat, amely végrehajtja a metódust
ExecuteInForeground. A metódus információkat jelenít meg néhány száltulajdonságról, majd végrehajt egy ciklust, amelyben fél másodpercig szünetel, és megjeleníti az eltelt másodpercek számát. Ha a szál legalább öt másodpercen át fut, a hurok véget ér, és a szál leállítja a végrehajtást.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 secondsHa a metódus argumentumot használ, egy meghatalmazottat ParameterizedThreadStart ad át a konstruktornak. Az aláírása:
public delegate void ParameterizedThreadStart(object obj)Public Delegate Sub ParameterizedThreadStart(obj As Object)A meghatalmazott által végrehajtott metódus ezután leadhatja (C#-ban) vagy átalakíthatja (a Visual Basicben) a paramétert a megfelelő típusra.
Az alábbi példa megegyezik az előző példával, azzal a kivételel, hogy meghívja a konstruktort Thread(ParameterizedThreadStart) . A metódus ezen verziója
ExecuteInForegroundegyetlen paraméterrel rendelkezik, amely a ciklus végrehajtásának körülbelül ennyi ezredmásodpercét jelöli.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
A szál elindítása után nem szükséges megőrizni egy objektumra Thread mutató hivatkozást. A szál végrehajtása a szál eljárásának befejezéséig folytatódik.
Szálobjektumok lekérése
A statikus (Shared Visual Basic) CurrentThread tulajdonság használatával lekérheti az aktuálisan végrehajtó szálra mutató hivatkozást a szál által futtatott kódból. Az alábbi példa a CurrentThread tulajdonság használatával jeleníti meg a fő alkalmazásszálra, egy másik előtérszálra, egy háttérszálra és egy szálkészlet-szálra vonatkozó információkat.
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
Előtér- és háttérszálak
Az osztály példányai Thread előtérszálakat vagy háttérszálakat jelölnek. A háttérszálak egyetlen kivétellel megegyeznek az előtérszálakkal: a háttérszálak nem futtatják a folyamatot, ha az összes előtérszál leállt. Miután az összes előtérszál le lett állítva, a futtatókörnyezet leállítja az összes háttérszálat, és leáll.
Alapértelmezés szerint a következő szálak futnak az előtérben:
A fő alkalmazásszál.
Az osztálykonstruktor meghívásával Thread létrehozott összes szál.
Alapértelmezés szerint a következő szálak futnak a háttérben:
A szálkészlet szálai, amelyek a futtatókörnyezet által karbantartott munkaszálak készletéből származnak. Az osztály használatával konfigurálhatja a szálkészletet, és ütemezheti a ThreadPool szálkészlet-szálakon végzett munkát.
Feljegyzés
A tevékenységalapú aszinkron műveletek automatikusan futnak a szálkészlet-szálakon. A tevékenységalapú aszinkron műveletek az és Task<TResult> az Task osztályok használatával implementálják a feladatalapú aszinkron mintát.
Minden szál, amely nem felügyelt kódból adja meg a felügyelt végrehajtási környezetet.
A háttérben futó szálat bármikor módosíthatja a IsBackground tulajdonság beállításával. A háttérszálak hasznosak minden olyan művelethez, amely addig folytatódik, amíg egy alkalmazás fut, de nem akadályozhatja meg az alkalmazás leállását, például a fájlrendszer változásainak monitorozását vagy a bejövő szoftvercsatornák kapcsolatait.
Az alábbi példa az előtér- és háttérszálak közötti különbséget szemlélteti. Ez olyan, mint a Szál indítása szakasz első példája, azzal a kivételrel, hogy a szálat a háttérben hajtja végre a kezdés előtt. Ahogy a kimenet is mutatja, a ciklus öt másodpercig megszakad, mielőtt végrehajtanák.
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...
Kultúra és szálak
Minden szál rendelkezik a tulajdonság által CurrentCulture képviselt kultúrával és a tulajdonság által képviselt felhasználói felületi kultúrával CurrentUICulture . A jelenlegi kultúra támogatja a kultúra szempontjából érzékeny műveleteket, például elemzést és formázást, sztring-összehasonlítást és rendezést, valamint szabályozza a szál által használt írási rendszert és naptárt. A jelenlegi felhasználói felületi kultúra az erőforrásfájlokban lévő erőforrások kulturális szempontból érzékeny lekérését teszi lehetővé.
Fontos
A CurrentCulture tulajdonságok és CurrentUICulture a tulajdonságok nem működnek megbízhatóan, ha az aktuális száltól eltérő szálakkal használják. A .NET-keretrendszer ezek a tulajdonságok megbízhatóak, bár az aktuális száltól eltérő szál tulajdonságainak beállítása nem. A .NET Core-on egy InvalidOperationException olyan üzenet jelenik meg, amely akkor jelenik meg, ha egy szál megkísérli olvasni vagy írni ezeket a tulajdonságokat egy másik szálon. Javasoljuk, hogy a CultureInfo.CurrentCulture jelenlegi kultúra lekéréséhez és CultureInfo.CurrentUICulture beállításához használja a tulajdonságokat és a tulajdonságokat.
Az új szál példányosításakor annak kultúráját és felhasználói felületi kultúráját a jelenlegi rendszerkultúra és felhasználói felületi kultúra határozza meg, nem pedig annak a szálnak a kulturális és felhasználói felületi kultúrája, amelyből az új szál létrejön. Ez azt jelenti például, hogy ha a jelenlegi rendszerkultúra angol (Egyesült Államok), és az elsődleges alkalmazásszál jelenlegi kultúrája a francia (Franciaország), akkor az elsődleges szál konstruktorának meghívásával Thread(ParameterizedThreadStart) létrehozott új szál kultúrája az angol (Egyesült Államok), nem pedig a francia (Franciaország). További információt az osztálytéma "Kultúra és szálak" című szakaszában CultureInfo talál.
Fontos
Ez nem igaz azokra a szálakra, amelyek aszinkron műveleteket hajtanak végre a .NET-keretrendszer 4.6-os és újabb verziójú alkalmazásokhoz. Ebben az esetben a kultúra és a felhasználói felület kultúrája egy aszinkron művelet kontextusának része; Az a szál, amelyen alapértelmezés szerint egy aszinkron művelet fut, örökli annak a szálnak a kulturális és felhasználói felületi kultúráját, amelyből az aszinkron műveletet elindították. További információt az osztály megjegyzéseinek "Kultúra és feladatalapú aszinkron műveletek" című szakaszában CultureInfo talál.
Az alábbiak egyikével biztosíthatja, hogy az alkalmazásban végrehajtó összes szál azonos kultúrával és felhasználói felületi kultúrával rendelkezzen:
Az adott kultúrát CultureInfo képviselő objektumot átadhatja a ParameterizedThreadStart meghatalmazottnak vagy a metódusnak ThreadPool.QueueUserWorkItem(WaitCallback, Object) .
A .NET-keretrendszer 4.5-ös és újabb verziókon futó alkalmazások esetében az alkalmazástartományban létrehozott összes szálhoz hozzárendelendő kulturális és felhasználói felületi kultúrát a tulajdonságok és CultureInfo.DefaultThreadCurrentUICulture a CultureInfo.DefaultThreadCurrentCulture tulajdonságok értékének beállításával határozhatja meg. Vegye figyelembe, hogy ez egy alkalmazásonkénti tartománybeállítás.
További információkért és példákért tekintse meg az osztály megjegyzéseinek "Kultúra és szálak" szakaszát CultureInfo .
Információk lekérése és a szálak szabályozása
Számos tulajdonságértéket lekérhet, amelyek információt nyújtanak egy szálról. Bizonyos esetekben ezeket a tulajdonságértékeket is beállíthatja a szál működésének szabályozásához. Ezek a száltulajdonságok a következők:
Egy név. Name egy írásvédett tulajdonság, amellyel azonosíthatja a szálat. Az alapértelmezett érték a .
nullKivonatkód, amelyet a GetHashCode metódus meghívásával lekérhet. A kivonatkód egy szál egyedi azonosítására használható; a szál élettartama alatt a kivonatkód nem ütközik más szál értékével, függetlenül attól, hogy melyik alkalmazástartományból szerzi be az értéket.
Szálazonosító. Az írásvédett ManagedThreadId tulajdonság értékét a futtatókörnyezet rendeli hozzá, és egyedileg azonosít egy szálat a folyamaton belül.
Feljegyzés
Az operációs rendszer threadId-jének nincs rögzített kapcsolata egy felügyelt szálhoz, mert egy nem felügyelt gazdagép szabályozhatja a felügyelt és a nem felügyelt szálak közötti kapcsolatot. A kifinomult gazdagépek a CLR Hosting API használatával ütemezhetnek több felügyelt szálat ugyanazon operációsrendszer-szálon, vagy áthelyezhetnek egy felügyelt szálat különböző operációsrendszer-szálak között.
A szál aktuális állapota. A szál a létezésének időtartama alatt mindig a tulajdonság által ThreadState meghatározott egy vagy több állapotban van.
A tulajdonság által meghatározott ütemezési prioritási ThreadPriority szint. Bár ezt az értéket beállíthatja egy szál prioritásának lekérésére, az operációs rendszer nem garantáltan betartja azt.
Az írásvédett IsThreadPoolThread tulajdonság, amely azt jelzi, hogy egy szál szálkészlet-szál-e.
A IsBackground tulajdonság. További információkért tekintse meg az Előtér és a háttérszálak szakaszt .
Példák
Az alábbi példa az egyszerű szálkezelést mutatja be.
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
Ez a kód a következőhöz hasonló kimenetet hoz létre:
[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.
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: