System.Threading.Thread – třída

Článek
01/10/2024

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Třída Thread vytvoří a řídí vlákno, nastaví jeho prioritu a získá její stav.

Při spuštění procesu modul CLR (Common Language Runtime) automaticky vytvoří jedno vlákno popředí pro spuštění kódu aplikace. Spolu s tímto hlavním vláknem popředí může proces vytvořit jedno nebo více vláken pro spuštění části kódu programu přidruženého k procesu. Tato vlákna se můžou spouštět buď v popředí, nebo na pozadí. Kromě toho můžete pomocí ThreadPool třídy spustit kód na pracovních vláknech spravovaných modulem CLR (Common Language Runtime).

Spuštění vlákna

Vlákno spustíte zadáním delegáta, který představuje metodu, je spuštění vlákna v jeho konstruktoru třídy. Pak zavoláte metodu Start , která zahájí provádění.

Konstruktory Thread mohou mít jeden ze dvou typů delegátů v závislosti na tom, jestli můžete předat argument metodě, která se má provést:

Pokud metoda nemá žádné argumenty, předáte ThreadStart delegát konstruktoru. Má podpis:

public delegate void ThreadStart()

Public Delegate Sub ThreadStart()

Následující příklad vytvoří a spustí vlákno, které spustí metodu ExecuteInForeground . Metoda zobrazí informace o některých vlastnostech vlákna a pak spustí smyčku, ve které se pozastaví půl sekundy a zobrazí uplynulý počet sekund. Když se vlákno spustí nejméně pět sekund, smyčka skončí a vlákno ukončí provádění.

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 seconds

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.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 seconds

Imports 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 seconds

Pokud má metoda argument, předáte ParameterizedThreadStart delegát konstruktoru. Má podpis:

public delegate void ParameterizedThreadStart(object obj)

Public Delegate Sub ParameterizedThreadStart(obj As Object)

Metoda spuštěná delegátem pak může přetypovat (v jazyce C#) nebo převést (v jazyce Visual Basic) parametr na příslušný typ.

Následující příklad je stejný jako předchozí, s tím rozdílem, že volá Thread(ParameterizedThreadStart) konstruktor. Tato verze ExecuteInForeground metody má jeden parametr, který představuje přibližný počet milisekund smyčky ke spuštění.

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 seconds

open 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 seconds

Imports 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

Po spuštění vlákna není nutné zachovat odkaz na Thread objekt. Vlákno se bude dál spouštět, dokud nebude procedura vlákna dokončena.

Načtení objektů vlákna

Statickou vlastnost (Shared v jazyce Visual Basic) CurrentThread můžete použít k načtení odkazu na aktuálně spuštěné vlákno z kódu, který vlákno spouští. Následující příklad používá CurrentThread vlastnost k zobrazení informací o hlavním vlákně aplikace, další vlákno popředí, vlákno na pozadí a vlákno fondu vláken.

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

Popředí a vlákna na pozadí

Thread Instance třídy představují vlákna popředí nebo vlákna na pozadí. Vlákna na pozadí jsou shodná s vlákny popředí s jednou výjimkou: Vlákno na pozadí neudržuje proces spuštěný, pokud všechna vlákna popředí skončila. Po zastavení všech vláken popředí zastaví modul runtime všechna vlákna na pozadí a vypne se.

Ve výchozím nastavení se v popředí spustí následující vlákna:

Hlavní vlákno aplikace.
Všechna vlákna vytvořená voláním konstruktoru Thread třídy.

Ve výchozím nastavení se na pozadí spouští následující vlákna:

Vlákna fondu vláken, která pocházejí z fondu pracovních vláken udržovaných modulem runtime. Fond vláken můžete nakonfigurovat a naplánovat práci na vláknech fondu vláken pomocí ThreadPool třídy.

Poznámka:

Asynchronní operace založené na úlohách se automaticky spouštějí na vláknech fondu vláken. Asynchronní operace založené na úlohách používají Task a Task<TResult> třídy k implementaci asynchronního vzoru založeného na úlohách.
Všechna vlákna, která zadávají spravované spouštěcí prostředí z nespravovaného kódu.

Vlákno, které se má spustit na pozadí, můžete kdykoli změnit nastavením IsBackground vlastnosti. Vlákna na pozadí jsou užitečná pro všechny operace, které by měly pokračovat, pokud je aplikace spuštěná, ale neměla by bránit ukončení aplikace, například monitorování změn systému souborů nebo příchozích soketů připojení.

Následující příklad znázorňuje rozdíl mezi vlákny popředí a pozadí. Je to jako první příklad v části Start a thread , s tím rozdílem, že nastaví vlákno tak, aby se spustilo na pozadí před jeho spuštěním. Jak ukazuje výstup, smyčka se před provedením po dobu pěti sekund přeruší.

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

Jazykové verze a vlákna

Každé vlákno má jazykovou verzi reprezentovanou CurrentCulture vlastností a jazykovou verzi uživatelského rozhraní reprezentovanou CurrentUICulture vlastností. Aktuální jazyková verze podporuje operace citlivé na jazykovou verzi, jako je analýza a formátování, porovnání řetězců a řazení, a také řídí systém zápisu a kalendář používaný vláknem. Aktuální jazyková verze uživatelského rozhraní poskytuje načítání prostředků v souborech prostředků citlivé na jazykovou verzi.

Důležité

CurrentUICulture Vlastnosti CurrentCulture a vlastnosti nefungují spolehlivě při použití s jakýmkoli jiným vláknem než s aktuálním vláknem. V rozhraní .NET Framework je čtení těchto vlastností spolehlivé, i když nastavení těchto vlastností pro vlákno jiné než aktuální vlákno není. V .NET Core je vyvolán, InvalidOperationException pokud se vlákno pokusí číst nebo zapisovat tyto vlastnosti do jiného vlákna. K načtení a nastavení aktuální jazykové verze doporučujeme použít CultureInfo.CurrentCulture vlastnosti a CultureInfo.CurrentUICulture vlastnosti.

Při vytvoření instance nového vlákna se její jazyková verze a jazyková verze uživatelského rozhraní definují aktuální jazykovou verzí systému a jazykovou verzí uživatelského rozhraní, a ne jazykovou verzí jazyka a jazykovou verzí uživatelského rozhraní vlákna, ze kterého se vytvoří nové vlákno. To například znamená, že pokud je aktuální systémová jazyková verze angličtina (USA) a aktuální jazyková verze primárního vlákna aplikace je francouzština (Francie), jazyková verze nového vlákna vytvořená voláním Thread(ParameterizedThreadStart) konstruktoru z primárního vlákna je angličtina (USA) a ne francouzština (Francie). Další informace najdete v části CultureInfo Jazyková verze a vlákna tématu třídy.

Důležité

To neplatí pro vlákna, která spouští asynchronní operace pro aplikace, které cílí na rozhraní .NET Framework 4.6 a novější verze. V tomto případě je jazyková verze a jazyková verze uživatelského rozhraní součástí kontextu asynchronní operace; vlákno, ve kterém se asynchronní operace spouští ve výchozím nastavení, dědí jazykovou verzi a jazykovou verzi uživatelského rozhraní vlákna, ze kterého byla spuštěna asynchronní operace. Další informace naleznete v části CultureInfo "Jazykové verze a asynchronní operace založené na úlohách" poznámek třídy.

Pokud chcete zajistit, aby všechna vlákna spuštěná v aplikaci sdílela stejnou jazykovou verzi a jazykovou verzi uživatelského rozhraní, můžete provést jednu z následujících akcí:

Můžete předat CultureInfo objekt, který představuje tuto jazykovou verzi delegátu ParameterizedThreadStart ThreadPool.QueueUserWorkItem(WaitCallback, Object) nebo metodě.
U aplikací spuštěných v rozhraní .NET Framework 4.5 a novějších verzích můžete definovat jazykovou verzi a jazykovou verzi uživatelského rozhraní, která se mají přiřadit ke všem vláknům vytvořeným v doméně aplikace nastavením hodnoty CultureInfo.DefaultThreadCurrentCulture a CultureInfo.DefaultThreadCurrentUICulture vlastností. Všimněte si, že se jedná o nastavení domény pro jednotlivé aplikace.

Další informace a příklady najdete v části CultureInfo Jazykové verze a vlákna poznámek třídy.

Získání informací o vláknech ovládacích prvků a jejich řízení

Můžete načíst řadu hodnot vlastností, které poskytují informace o vlákně. V některých případech můžete také nastavit tyto hodnoty vlastností pro řízení operace vlákna. Mezi tyto vlastnosti vlákna patří:

Název. Name je vlastnost zápisu jednou, kterou můžete použít k identifikaci vlákna. Výchozí hodnota je null.
Kód hash, který můžete načíst voláním GetHashCode metody. Kód hash lze použít k jednoznačné identifikaci vlákna; po celou dobu životnosti vlákna nebude jeho kód hash kolidovat s hodnotou z žádného jiného vlákna bez ohledu na doménu aplikace, ze které hodnotu získáte.
ID vlákna. Hodnota vlastnosti jen ManagedThreadId pro čtení je přiřazena modulem runtime a jednoznačně identifikuje vlákno v rámci procesu.

Poznámka:

ThreadId operačního systému nemá žádný pevný vztah ke spravovanému vláknu, protože nespravovaný hostitel může řídit vztah mezi spravovanými a nespravovanými vlákny. Konkrétně sofistikovaný hostitel může rozhraní API pro hostování CLR použít k naplánování mnoha spravovaných vláken na stejném vlákně operačního systému nebo k přesunutí spravovaného vlákna mezi různými vlákny operačního systému.
Aktuální stav vlákna. Po dobu trvání existence je vlákno vždy v jednom nebo více stavech definovaných ThreadState vlastností.
Úroveň priority plánování, která je definována ThreadPriority vlastností. I když tuto hodnotu můžete nastavit tak, aby požadovala prioritu vlákna, není zaručeno, že bude dodržen operační systém.
Vlastnost jen IsThreadPoolThread pro čtení, která označuje, zda vlákno je vlákno vlákno fondu vláken.
Vlastnost IsBackground . Další informace najdete v části Popředí a vlákna na pozadí.

Příklady

Následující příklad ukazuje jednoduchou funkci threadingu.

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

Tento kód vytvoří výstup podobný následujícímu:

[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.

Sdílet prostřednictvím