System.Threading.Thread-klasse

Artikel
01/10/2024

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

De Thread klasse maakt en beheert een thread, stelt de prioriteit ervan in en haalt de status op.

Wanneer een proces wordt gestart, maakt de algemene taalruntime automatisch één voorgrondthread om toepassingscode uit te voeren. Samen met deze hoofdthread op de voorgrond kan een proces een of meer threads maken om een deel van de programmacode uit te voeren die aan het proces is gekoppeld. Deze threads kunnen op de voorgrond of op de achtergrond worden uitgevoerd. Daarnaast kunt u de ThreadPool klasse gebruiken om code uit te voeren op werkrolthreads die worden beheerd door de algemene taalruntime.

Een thread starten

U start een thread door een gemachtigde op te geven die de methode aangeeft die de thread moet uitvoeren in de klasseconstructor. Vervolgens roept u de Start methode aan om de uitvoering te starten.

De Thread constructors kunnen een van de twee typen gemachtigden gebruiken, afhankelijk van of u een argument kunt doorgeven aan de methode die moet worden uitgevoerd:

Als de methode geen argumenten heeft, geeft u een ThreadStart gemachtigde door aan de constructor. Deze heeft de handtekening:

public delegate void ThreadStart()

Public Delegate Sub ThreadStart()

In het volgende voorbeeld wordt een thread gemaakt en gestart waarmee de ExecuteInForeground methode wordt uitgevoerd. De methode geeft informatie weer over bepaalde threadeigenschappen en voert vervolgens een lus uit waarin deze een halve seconde pauzeert en het verstreken aantal seconden weergeeft. Wanneer de thread ten minste vijf seconden is uitgevoerd, eindigt de lus en beëindigt de thread de uitvoering.

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

Als de methode een argument heeft, geeft u een ParameterizedThreadStart gemachtigde door aan de constructor. Deze heeft de handtekening:

public delegate void ParameterizedThreadStart(object obj)

Public Delegate Sub ParameterizedThreadStart(obj As Object)

De methode die door de gemachtigde wordt uitgevoerd, kan vervolgens casten (in C#) of de parameter converteren (in Visual Basic) naar het juiste type.

Het volgende voorbeeld is identiek aan de vorige, behalve dat deze de Thread(ParameterizedThreadStart) constructor aanroept. Deze versie van de ExecuteInForeground methode heeft één parameter die het geschatte aantal milliseconden aangeeft dat de lus moet worden uitgevoerd.

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

Het is niet nodig om een verwijzing naar een Thread object te behouden zodra u de thread hebt gestart. De thread wordt nog steeds uitgevoerd totdat de threadprocedure is voltooid.

Thread-objecten ophalen

U kunt de eigenschap Static (Shared in Visual Basic) CurrentThread gebruiken om een verwijzing op te halen naar de thread die momenteel wordt uitgevoerd uit de code die door de thread wordt uitgevoerd. In het volgende voorbeeld wordt de CurrentThread eigenschap gebruikt om informatie weer te geven over de hoofdtoepassingsthread, een andere voorgrondthread, een achtergrondthread en een threadpoolthread.

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

Voorgrond- en achtergrondthreads

Exemplaren van de Thread klasse vertegenwoordigen voorgrondthreads of achtergrondthreads. Achtergrondthreads zijn identiek aan voorgrondthreads met één uitzondering: een achtergrondthread houdt een proces niet actief als alle voorgrondthreads zijn beëindigd. Zodra alle voorgrondthreads zijn gestopt, stopt de runtime alle achtergrondthreads en wordt afgesloten.

Standaard worden de volgende threads uitgevoerd op de voorgrond:

De belangrijkste toepassingsthread.
Alle threads die zijn gemaakt door een Thread klasseconstructor aan te roepen.

De volgende threads worden standaard op de achtergrond uitgevoerd:

Threadpoolthreads, die afkomstig zijn van een pool met werkthreads die door de runtime worden onderhouden. U kunt de threadgroep configureren en werk plannen voor threadpoolthreads met behulp van de ThreadPool klasse.

Notitie

Op taken gebaseerde asynchrone bewerkingen worden automatisch uitgevoerd op threadpoolthreads. Op taken gebaseerde asynchrone bewerkingen gebruiken de Task en Task<TResult> klassen om het asynchrone patroon op basis van taken te implementeren.
Alle threads die de beheerde uitvoeringsomgeving invoeren vanuit onbeheerde code.

U kunt een thread op de achtergrond wijzigen door de IsBackground eigenschap op elk gewenst moment in te stellen. Achtergrondthreads zijn handig voor elke bewerking die moet worden voortgezet zolang een toepassing wordt uitgevoerd, maar niet mag voorkomen dat de toepassing wordt beëindigd, zoals het controleren van wijzigingen in het bestandssysteem of binnenkomende socketverbindingen.

In het volgende voorbeeld ziet u het verschil tussen voorgrond- en achtergrondthreads. Het is vergelijkbaar met het eerste voorbeeld in de sectie Een thread starten, behalve dat de thread op de achtergrond wordt uitgevoerd voordat deze wordt gestart. Zoals in de uitvoer wordt weergegeven, wordt de lus onderbroken voordat deze vijf seconden wordt uitgevoerd.

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

Cultuur en threads

Elke thread heeft een cultuur, vertegenwoordigd door de CurrentCulture eigenschap en een UI-cultuur, vertegenwoordigd door de CurrentUICulture eigenschap. De huidige cultuur ondersteunt cultuurgevoelige bewerkingen, zoals parseren en opmaken, tekenreeksvergelijking en sortering, en bepaalt ook het schrijfsysteem en de agenda die door een thread worden gebruikt. De huidige UI-cultuur biedt cultuurgevoelige ophaalbewerking van resources in resourcebestanden.

Belangrijk

De CurrentCulture eigenschappen en CurrentUICulture eigenschappen werken niet betrouwbaar wanneer ze worden gebruikt met andere threads dan de huidige thread. In .NET Framework is het lezen van deze eigenschappen betrouwbaar, hoewel het instellen van deze eigenschappen voor een andere thread dan de huidige thread niet is. In .NET Core wordt er een InvalidOperationException gegenereerd als een thread probeert deze eigenschappen op een andere thread te lezen of te schrijven. U wordt aangeraden de CultureInfo.CurrentCulture en CultureInfo.CurrentUICulture eigenschappen te gebruiken om de huidige cultuur op te halen en in te stellen.

Wanneer een nieuwe thread wordt geïnstantieerd, worden de cultuur en ui-cultuur gedefinieerd door de huidige systeemcultuur en UI-cultuur, en niet door de cultuur en UI-cultuur van de thread waaruit de nieuwe thread wordt gemaakt. Dit betekent bijvoorbeeld dat als de huidige systeemcultuur Engels (Verenigde Staten) is en de huidige cultuur van de primaire toepassingsthread Frans (Frankrijk) is, de cultuur van een nieuwe thread die is gemaakt door de Thread(ParameterizedThreadStart) constructor aan te roepen vanuit de primaire thread Engels (Verenigde Staten) en niet Frans (Frankrijk). Zie de sectie Cultuur en threads van het CultureInfo klasonderwerp voor meer informatie.

Belangrijk

Dit geldt niet voor threads die asynchrone bewerkingen uitvoeren voor apps die gericht zijn op .NET Framework 4.6 en latere versies. In dit geval maakt de cultuur en ui-cultuur deel uit van de context van een asynchrone bewerking; de thread waarop een asynchrone bewerking wordt uitgevoerd, neemt standaard de cultuur en ui-cultuur over van de thread waaruit de asynchrone bewerking is gestart. Zie de sectie 'Asynchrone bewerkingen op basis van cultuur en taken' van de CultureInfo klasaanmerkingen voor meer informatie.

U kunt een van de volgende handelingen uitvoeren om ervoor te zorgen dat alle threads die worden uitgevoerd in een toepassing dezelfde cultuur en ui-cultuur delen:

U kunt een CultureInfo object doorgeven dat die cultuur aan de ParameterizedThreadStart gemachtigde of de ThreadPool.QueueUserWorkItem(WaitCallback, Object) methode vertegenwoordigt.
Voor apps die worden uitgevoerd op .NET Framework 4.5 en latere versies, kunt u de cultuur en ui-cultuur definiëren die moet worden toegewezen aan alle threads die in een toepassingsdomein worden gemaakt door de waarde van de CultureInfo.DefaultThreadCurrentCulture en CultureInfo.DefaultThreadCurrentUICulture eigenschappen in te stellen. Houd er rekening mee dat dit een domeininstelling per toepassing is.

Zie de sectie 'Cultuur en threads' van de CultureInfo klas-opmerkingen voor meer informatie en voorbeelden.

Informatie over en controlethreads ophalen

U kunt een aantal eigenschapswaarden ophalen die informatie geven over een thread. In sommige gevallen kunt u deze eigenschapswaarden ook instellen om de werking van de thread te beheren. Deze threadeigenschappen zijn onder andere:

Een naam. Name is een write-once-eigenschap die u kunt gebruiken om een thread te identificeren. De standaardwaarde is null.
Een hash-code die u kunt ophalen door de methode aan te GetHashCode roepen. De hashcode kan worden gebruikt om een thread uniek te identificeren; voor de levensduur van uw thread komt de hashcode niet in conflict met de waarde van een andere thread, ongeacht het toepassingsdomein waaruit u de waarde verkrijgt.
Een thread-id. De waarde van de eigenschap Alleen-lezen ManagedThreadId wordt toegewezen door de runtime en identificeert een thread in het proces.

Notitie

Een threadId van een besturingssysteem heeft geen vaste relatie met een beheerde thread, omdat een niet-beheerde host de relatie tussen beheerde en onbeheerde threads kan beheren. Een geavanceerde host kan de CLR Hosting-API gebruiken om veel beheerde threads te plannen op dezelfde besturingssysteemthread of om een beheerde thread tussen verschillende besturingssysteemthreads te verplaatsen.
De huidige status van de thread. Voor de duur van het bestaan heeft een thread altijd een of meer statussen die door de ThreadState eigenschap zijn gedefinieerd.
Een planningsprioriteitsniveau, dat wordt gedefinieerd door de ThreadPriority eigenschap. Hoewel u deze waarde kunt instellen om de prioriteit van een thread aan te vragen, wordt deze niet gegarandeerd door het besturingssysteem gehonoreerd.
De eigenschap Alleen-lezen IsThreadPoolThread , die aangeeft of een thread een thread-pool-thread is.
De IsBackground eigenschap. Zie de sectie Voorgrond- en achtergrondthreads voor meer informatie.

Voorbeelden

In het volgende voorbeeld ziet u een eenvoudige threading-functionaliteit.

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

Deze code produceert uitvoer die vergelijkbaar is met de volgende:

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

Delen via