Thread Klasse

  • Referenz

Definition

Namespace:
System.Threading
Assembly:
System.Threading.Thread.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Erstellt und steuert einen Thread, legt dessen Priorität fest und ruft den Status ab.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject
public ref class Thread sealed
public ref class Thread sealed : System::Runtime::InteropServices::_Thread
public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, System::Runtime::InteropServices::_Thread
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.InteropServices._Thread
[System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
[System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject
type Thread = class
    inherit CriticalFinalizerObject
[<System.Runtime.InteropServices.ComVisible(true)>]
type Thread = class
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    interface _Thread
[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    inherit CriticalFinalizerObject
    interface _Thread
[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Thread = class
    inherit CriticalFinalizerObject
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Public NotInheritable Class Thread
Public NotInheritable Class Thread
Implements _Thread
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Implements _Thread
Vererbung
Object
CriticalFinalizerObject
Thread
Vererbung
Object
Thread
Attribute
ComVisibleAttribute ClassInterfaceAttribute
Implementiert
_Thread

Beispiele

Im folgenden Beispiel wird die Einfache Threadingfunktionalität veranschaulicht.

// [C++]
// Compile using /clr option.
using namespace System;
using namespace System::Threading;

// Simple threading scenario:  Start a Shared method running
// on a second thread.
public ref class ThreadExample
{
public:

   // 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.
   static void ThreadProc()
   {
      for ( int i = 0; i < 10; i++ )
      {
         Console::Write(  "ThreadProc: " );
         Console::WriteLine( i );
         
         // Yield the rest of the time slice.
         Thread::Sleep( 0 );

      }
   }

};

int main()
{
   Console::WriteLine( "Main thread: Start a second thread." );
   
   // Create the thread, passing a ThreadStart delegate that
   // represents the ThreadExample::ThreadProc method.  For a 
   // delegate representing a static method, no object is
   // required.
   Thread^ oThread = gcnew Thread( gcnew ThreadStart( &ThreadExample::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 oThread->Start() to see the difference.
   oThread->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." );
   oThread->Join();
   Console::WriteLine(  "Main thread: ThreadProc.Join has returned.  Press Enter to end program." );
   Console::ReadLine();
   return 0;
}

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

Dieser Code erzeugt eine Ausgabe ähnlich der folgenden:

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

Hinweise

Wenn ein Prozess gestartet wird, erstellt die Common Language Runtime automatisch einen einzelnen Vordergrundthread, um Anwendungscode auszuführen. Zusammen mit diesem Hauptthread im Vordergrund kann ein Prozess einen oder mehrere Threads erstellen, um einen Teil des Programmcodes auszuführen, der dem Prozess zugeordnet ist. Diese Threads können entweder im Vordergrund oder im Hintergrund ausgeführt werden. Darüber hinaus können Sie die ThreadPool -Klasse verwenden, um Code für Workerthreads auszuführen, die von der Common Language Runtime verwaltet werden.

In diesem Abschnitt

Starten eines Threads
Abrufen von Threadobjekten
Vordergrund- und Hintergrundthreads
Kultur und Threads
Abrufen von Informationen zu und Steuern von Threads

Starten eines Threads

Sie starten einen Thread, indem Sie einen Delegaten angeben, der die Methode darstellt, die der Thread in seinem Klassenkonstruktor ausführen soll. Anschließend rufen Sie die -Methode auf, um mit der Start Ausführung zu beginnen.

Die Thread Konstruktoren können einen von zwei Delegattypen verwenden, je nachdem, ob Sie ein Argument an die auszuführende Methode übergeben können:

  • Wenn die Methode keine Argumente enthält, übergeben Sie einen ThreadStart Delegaten an den Konstruktor. Es hat die Signatur:

    public delegate void ThreadStart()  

    Public Delegate Sub ThreadStart()

    Im folgenden Beispiel wird ein Thread erstellt und gestartet, der die ExecuteInForeground -Methode ausführt. Die -Methode zeigt Informationen zu einigen Threadeigenschaften an, führt dann eine Schleife aus, in der sie eine halbe Sekunde anhält und die verstrichene Anzahl von Sekunden anzeigt. Wenn der Thread mindestens fünf Sekunden lang ausgeführt wurde, endet die Schleife, und der Thread beendet die Ausführung.

    using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   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 Example
   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

  • Wenn die Methode über ein Argument verfügt, übergeben Sie einen ParameterizedThreadStart Delegaten an den Konstruktor. Es hat die Signatur:

    public delegate void ParameterizedThreadStart(object obj)  

    Public Delegate Sub ParameterizedThreadStart(obj As Object)

    Die vom Delegaten ausgeführte Methode kann dann den Parameter (in C#) umwandeln oder (in Visual Basic) in den entsprechenden Typ konvertieren.

    Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, mit der Ausnahme, dass der Thread(ParameterizedThreadStart) -Konstruktor aufgerufen wird. Diese Version der ExecuteInForeground -Methode verfügt über einen einzelnen Parameter, der die ungefähre Anzahl von Millisekunden darstellt, die die Schleife ausführen soll.

    using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   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 Example
   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

Es ist nicht erforderlich, einen Verweis auf ein Thread Objekt beizubehalten, nachdem Sie den Thread gestartet haben. Der Thread wird weiterhin ausgeführt, bis die Threadprozedur abgeschlossen ist.

Abrufen von Threadobjekten

Sie können die statische Eigenschaft (Shared in Visual Basic) CurrentThread verwenden, um einen Verweis auf den aktuell ausgeführten Thread aus dem Code abzurufen, den der Thread ausführt. Im folgenden Beispiel wird die CurrentThread -Eigenschaft verwendet, um Informationen zum Hauptanwendungsthread, einem anderen Vordergrundthread, einem Hintergrundthread und einem Threadpoolthread anzuzeigen.

using System;
using System.Threading;

public class Example
{
   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 Example
   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

Vordergrund- und Hintergrundthreads

Instanzen der Thread -Klasse stellen entweder Vordergrund- oder Hintergrundthreads dar. Hintergrundthreads sind mit Vordergrundthreads identisch, mit einer Ausnahme: Ein Hintergrundthread führt keinen Prozess weiter, wenn alle Vordergrundthreads beendet wurden. Nachdem alle Vordergrundthreads beendet wurden, beendet die Runtime alle Hintergrundthreads und wird heruntergefahren.

Standardmäßig werden die folgenden Threads im Vordergrund ausgeführt:

  • Der Hauptanwendungsthread.

  • Alle Threads, die durch Aufrufen eines Thread Klassenkonstruktors erstellt werden.

Die folgenden Threads werden standardmäßig im Hintergrund ausgeführt:

  • Threadpoolthreads, die aus einem Pool von Arbeitsthreads stammen, die von der Runtime verwaltet werden. Sie können den Threadpool konfigurieren und die Arbeit an Threadpoolthreads planen, indem Sie die ThreadPool -Klasse verwenden.

    Hinweis

    Aufgabenbasierte asynchrone Vorgänge werden automatisch für Threadpoolthreads ausgeführt. Aufgabenbasierte asynchrone Vorgänge verwenden die Task Klassen und Task<TResult> , um das aufgabenbasierte asynchrone Muster zu implementieren.

  • Alle Threads, die aus nicht verwaltetem Code in die verwaltete Ausführungsumgebung gelangen.

Sie können einen Thread so ändern, dass er im Hintergrund ausgeführt wird, indem Sie die IsBackground -Eigenschaft jederzeit festlegen. Hintergrundthreads sind nützlich für alle Vorgänge, die so lange fortgesetzt werden sollen, wie eine Anwendung ausgeführt wird, aber nicht verhindern sollten, dass die Anwendung beendet wird, z. B. das Überwachen von Dateisystemänderungen oder eingehenden Socketverbindungen.

Im folgenden Beispiel wird der Unterschied zwischen Vordergrund- und Hintergrundthreads veranschaulicht. Dies entspricht dem ersten Beispiel im Abschnitt Starten eines Threads , mit der Ausnahme, dass der Thread vor dem Starten im Hintergrund ausgeführt werden soll. Wie die Ausgabe zeigt, wird die Schleife unterbrochen, bevor sie fünf Sekunden lang ausgeführt wird.

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

Kultur und Threads

Jeder Thread verfügt über eine Kultur, die durch die CurrentCulture -Eigenschaft dargestellt wird, und eine Benutzeroberflächenkultur, die durch die CurrentUICulture -Eigenschaft dargestellt wird. Die aktuelle Kultur unterstützt kulturabhängige Vorgänge, z. B. Analysieren und Formatieren, Zeichenfolgenvergleich und Sortierung, und steuert auch das von einem Thread verwendete Schreibsystem und Kalender. Die aktuelle Benutzeroberflächenkultur ermöglicht den kulturabhängigen Abruf von Ressourcen in Ressourcendateien.

Wichtig

Die CurrentCulture Eigenschaften und CurrentUICulture funktionieren nicht zuverlässig, wenn sie mit einem anderen Thread als dem aktuellen Thread verwendet werden. In .NET Framework ist das Lesen dieser Eigenschaften zuverlässig, obwohl das Festlegen dieser Eigenschaften für einen anderen Thread als den aktuellen Thread nicht erfolgt. Unter .NET Core wird ein InvalidOperationException ausgelöst, wenn ein Thread versucht, diese Eigenschaften in einem anderen Thread zu lesen oder zu schreiben. Es wird empfohlen, die CultureInfo.CurrentCulture Eigenschaften und CultureInfo.CurrentUICulture zu verwenden, um die aktuelle Kultur abzurufen und festzulegen.

Wenn ein neuer Thread instanziiert wird, werden seine Kultur und Benutzeroberflächenkultur durch die aktuelle System- und Benutzeroberflächenkultur und nicht durch die Kultur und Benutzeroberflächenkultur des Threads definiert, aus dem der neue Thread erstellt wird. Wenn die aktuelle Systemkultur z. B. Englisch (USA) und die aktuelle Kultur des primären Anwendungsthreads Französisch (Frankreich) ist, lautet die Kultur eines neuen Threads, der durch Aufrufen des Thread(ParameterizedThreadStart) Konstruktors aus dem primären Thread erstellt wird, Englisch (USA) und nicht Französisch (Frankreich). Weitere Informationen finden Sie im Abschnitt "Kultur und Threads" des CultureInfo Klassenthemas.

Wichtig

Dies gilt nicht für Threads, die asynchrone Vorgänge für Apps ausführen, die auf .NET Framework Version 4.6 und höher ausgerichtet sind. In diesem Fall sind die Kultur und die Benutzeroberflächenkultur Teil des Kontexts eines asynchronen Vorgangs. Der Thread, in dem ein asynchroner Vorgang ausgeführt wird, erbt standardmäßig die Kultur und Benutzeroberflächenkultur des Threads, aus dem der asynchrone Vorgang gestartet wurde. Weitere Informationen finden Sie im Abschnitt "Kultur- und aufgabenbasierte asynchrone Vorgänge" der CultureInfo Klassenbemerkungen.

Sie können eine der folgenden Aktionen ausführen, um sicherzustellen, dass alle Threads, die in einer Anwendung ausgeführt werden, dieselbe Kultur und Benutzeroberflächenkultur verwenden:

Weitere Informationen und Beispiele finden Sie im Abschnitt "Kultur und Threads" der CultureInfo Klassenbemerkungen.

Abrufen von Informationen zu und Steuern von Threads

Sie können eine Reihe von Eigenschaftswerten abrufen, die Informationen zu einem Thread bereitstellen. In einigen Fällen können Sie diese Eigenschaftswerte auch festlegen, um den Betrieb des Threads zu steuern. Zu diesen Threadeigenschaften gehören:

  • Einen Namen. Name ist eine Write-Once-Eigenschaft, die Sie verwenden können, um einen Thread zu identifizieren. Der Standardwert lautet null.

  • Ein Hashcode, den Sie durch Aufrufen der GetHashCode -Methode abrufen können. Der Hashcode kann verwendet werden, um einen Thread eindeutig zu identifizieren. Für die Lebensdauer des Threads kollidiert der Hashcode nicht mit dem Wert aus einem anderen Thread, unabhängig von der Anwendungsdomäne, von der Sie den Wert erhalten.

  • Eine Thread-ID. Der Wert der schreibgeschützten ManagedThreadId Eigenschaft wird von der Runtime zugewiesen und identifiziert einen Thread innerhalb seines Prozesses eindeutig.

    Hinweis

    Eine Betriebssystem- ThreadId hat keine feste Beziehung zu einem verwalteten Thread, da ein nicht verwalteter Host die Beziehung zwischen verwalteten und nicht verwalteten Threads steuern kann. Insbesondere kann ein komplexer Host die CLR-Hosting-API verwenden, um viele verwaltete Threads für denselben Betriebssystemthread zu planen oder einen verwalteten Thread zwischen verschiedenen Betriebssystemthreads zu verschieben.

  • Der aktuelle Status des Threads. Für die Dauer seiner Existenz befindet sich ein Thread immer in einem oder mehreren der durch die ThreadState -Eigenschaft definierten Zustände.

  • Eine Planungsprioritätsebene, die durch die ThreadPriority -Eigenschaft definiert wird. Obwohl Sie diesen Wert festlegen können, um die Priorität eines Threads anzufordern, ist es nicht garantiert, dass er vom Betriebssystem berücksichtigt wird.

  • Die schreibgeschützte IsThreadPoolThread Eigenschaft, die angibt, ob ein Thread ein Threadpoolthread ist.

  • Die IsBackground-Eigenschaft Weitere Informationen finden Sie im Abschnitt Vordergrund- und Hintergrundthreads .

Konstruktoren

Thread(ParameterizedThreadStart)

Initialisiert eine neue Instanz der Thread-Klasse und gibt dabei einen Delegaten an, der das Übergeben eines Objekts an den Thread bei dessen Start ermöglicht.
Thread(ParameterizedThreadStart, Int32)

Initialisiert eine neue Instanz der Thread-Klasse und gibt dabei einen Delegaten, der das Übergeben eines Objekts an den Thread bei dessen Start ermöglicht, sowie eine maximale Stapelgröße für den Thread an.
Thread(ThreadStart)

Initialisiert eine neue Instanz der Thread-Klasse.
Thread(ThreadStart, Int32)

Initialisiert eine neue Instanz der Thread-Klasse und gibt die maximale Stapelgröße für den Thread an.

Eigenschaften

ApartmentState
Veraltet.
Veraltet.
Veraltet.

Ruft den Apartmentzustand dieses Threads ab oder legt diesen fest.
CurrentContext

Ruft den aktuellen Kontext ab, in dem der Thread ausgeführt wird.
CurrentCulture

Ruft die Kultur für den aktuellen Thread ab oder legt diese fest.
CurrentPrincipal

Ruft den aktuellen Prinzipal des Threads (für rollenbasierte Sicherheit) ab oder legt diesen fest.
CurrentThread

Ruft den derzeit ausgeführten Thread ab.
CurrentUICulture

Ruft die aktuelle Kultur ab, mit deren Hilfe der Ressourcen-Manager zur Laufzeit kulturabhängige Ressourcen sucht, oder legt diese fest.
ExecutionContext

Ruft ein ExecutionContext-Objekt ab, das Informationen zu den verschiedenen Kontexten des aktuellen Threads enthält.
IsAlive

Ruft einen Wert ab, der den Ausführungsstatus des aktuellen Threads angibt.
IsBackground

Ruft einen Wert ab, der angibt, ob es sich bei einem Thread um einen Hintergrundthread handelt, oder legt diesen fest.
IsThreadPoolThread

Ruft einen Wert ab, der angibt, ob ein Thread zu dem verwalteten Threadpool gehört.
ManagedThreadId

Ruft einen eindeutigen Bezeichner für den aktuellen verwalteten Thread ab.
Name

Ruft den Namen des Threads ab oder legt diesen fest.
Priority

Ruft einen Wert ab, der die Planungspriorität eines Threads angibt, oder legt diesen fest.
ThreadState

Ruft einen Wert ab, der die Zustände des aktuellen Threads enthält.

Methoden

Abort()
Veraltet.

Löst eine ThreadAbortException im Thread aus, für den der Aufruf erfolgte, um das Beenden des Threads zu beginnen. Durch den Aufruf dieser Methode wird der Thread i. d. R. beendet.
Abort(Object)
Veraltet.

Löst eine ThreadAbortException im Thread aus, für den der Aufruf erfolgte, um das Beenden des Threads zu beginnen. Gleichzeitig werden Ausnahmeinformationen über das Beenden des Threads bereitgestellt. Durch den Aufruf dieser Methode wird der Thread i. d. R. beendet.
AllocateDataSlot()

Reserviert einen unbenannten Datenslot für alle Threads. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
AllocateNamedDataSlot(String)

Reserviert einen benannten Datenslot für alle Threads. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
BeginCriticalRegion()

Benachrichtigt einen Host, dass die Ausführung im Begriff ist, zu einem Codebereich überzugehen, in dem die Auswirkungen eines Threadabbruchs oder einer nicht behandelten Ausnahme andere Aufgaben in der Anwendungsdomäne gefährden könnten.
BeginThreadAffinity()

Benachrichtigt einen Host, dass verwalteter Code im Begriff ist, Anweisungen auszuführen, die von der Identität des aktuellen physischen Betriebssystemthreads abhängen.
DisableComObjectEagerCleanup()

Deaktiviert die automatische Bereinigung von Runtime Callable Wrappern (RCW) für den aktuellen Thread.
EndCriticalRegion()

Benachrichtigt einen Host, dass die Ausführung im Begriff ist, zu einem Codebereich überzugehen, in dem die Auswirkungen eines Threadabbruchs oder einer nicht behandelten Ausnahme auf die aktuelle Aufgabe beschränkt sind.
EndThreadAffinity()

Benachrichtigt einen Host, dass verwalteter Code die Ausführung von Anweisungen beendet hat, die von der Identität des aktuellen physischen Betriebssystemthreads abhängen.
Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Finalize()

Stellt das Freigeben von Ressourcen und das Ausführen anderer Garbage Collector-Vorgänge sicher, wenn der Garbage Collector das Thread-Objekt verarbeitet.
FreeNamedDataSlot(String)

Entfernt die Zuordnung zwischen einem Namen und einem Slot für alle Threads in dem Prozess. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
GetApartmentState()

Gibt einen ApartmentState-Wert zurück, der den Apartmentzustand angibt.
GetCompressedStack()
Veraltet.
Veraltet.

Gibt ein CompressedStack-Objekt zurück, mit dem der Stapel für den aktuellen Thread erfasst werden kann.
GetCurrentProcessorId()

Ruft eine ID ab, mit der angegeben wird, mit welchem Prozessor der aktuelle Thread ausgeführt wird.
GetData(LocalDataStoreSlot)

Ruft in der aktuellen Domäne des aktuellen Threads den Wert aus dem angegebenen Slot für den aktuellen Thread ab. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
GetDomain()

Gibt die aktuelle Domäne zurück, in der der aktuelle Thread ausgeführt wird.
GetDomainID()

Gibt einen eindeutigen Bezeichner der Anwendungsdomäne zurück.
GetHashCode()

Gibt einen Hashcode für den aktuellen Thread zurück.
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetNamedDataSlot(String)

Sucht einen benannten Datenslot. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
Interrupt()

Unterbricht einen Thread, der sich im WaitSleepJoin-Threadzustand befindet.
Join()

Blockiert den aufrufenden Thread, bis der durch diese Instanz dargestellte Thread beendet wird, während das Standard-COM- und das SendMessage-Pumping fortgesetzt werden.
Join(Int32)

Blockiert den aufrufenden Thread, bis der von dieser Instanz dargestellte Thread beendet wird, oder die festgelegte Zeit verstreicht, während das Standard-COM- und das SendMessage-Pumping fortgesetzt werden.
Join(TimeSpan)

Blockiert den aufrufenden Thread, bis der von dieser Instanz dargestellte Thread beendet wird, oder die festgelegte Zeit verstreicht, während das Standard-COM- und das SendMessage-Pumping fortgesetzt werden.
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemoryBarrier()

Der Prozessor, der den aktuellen Thread ausführt, kann Anweisungen nicht so neu anordnen, dass Speicherzugriffe vor dem Aufruf von MemoryBarrier() nach Speicherzugriffen ausgeführt werden, die nach dem Aufruf von MemoryBarrier() erfolgen.
ResetAbort()
Veraltet.

Bricht ein Abort(Object) ab, das für den aktuellen Thread angefordert wurde.
Resume()
Veraltet.
Veraltet.
Veraltet.

Nimmt die Ausführung eines angehaltenen Threads wieder auf.
SetApartmentState(ApartmentState)

Legt den Apartmentzustand eines Threads fest, bevor dieser gestartet wird.
SetCompressedStack(CompressedStack)
Veraltet.
Veraltet.

Übernimmt einen erfassten CompressedStack für den aktuellen Thread.
SetData(LocalDataStoreSlot, Object)

Legt die Daten im angegebenen Slot auf den derzeit ausgeführten Thread und für die aktuelle Domäne des betreffenden Threads fest. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.
Sleep(Int32)

Hält den aktuellen Thread für die angegebene Anzahl von Millisekunden an.
Sleep(TimeSpan)

Hält den aktuellen Thread während des angegebenen Zeitraums an.
SpinWait(Int32)

Veranlasst, dass ein Thread so oft wartet, wie vom iterations-Parameter definiert.
Start()

Weist das Betriebssystem an, den Zustand der aktuellen Instanz in Running zu ändern.
Start(Object)

Bewirkt, dass das Betriebssystem den Zustand der aktuellen Instanz in Running ändert, und stellt optional ein Objekt mit Daten bereit, die von der vom Thread ausgeführten Methode verwendet werden sollen.
Suspend()
Veraltet.
Veraltet.
Veraltet.

Hält den Thread an. Hat keine Auswirkungen, wenn der Thread bereits angehalten ist.
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
TrySetApartmentState(ApartmentState)

Legt den Apartmentzustand eines Threads fest, bevor dieser gestartet wird.
UnsafeStart()

Weist das Betriebssystem an, den Zustand der aktuellen Instanz in Running zu ändern.
UnsafeStart(Object)

Bewirkt, dass das Betriebssystem den Zustand der aktuellen Instanz in Running ändert, und stellt optional ein Objekt mit Daten bereit, die von der vom Thread ausgeführten Methode verwendet werden sollen.
VolatileRead(Byte)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Double)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Int16)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Int32)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Int64)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(IntPtr)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Object)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(SByte)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(Single)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(UInt16)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(UInt32)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(UInt64)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileRead(UIntPtr)

Liest den Wert eines Felds. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden.
VolatileWrite(Byte, Byte)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Double, Double)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Int16, Int16)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Int32, Int32)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Int64, Int64)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(IntPtr, IntPtr)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Object, Object)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(SByte, SByte)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(Single, Single)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(UInt16, UInt16)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(UInt32, UInt32)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(UInt64, UInt64)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
VolatileWrite(UIntPtr, UIntPtr)

Schreibt einen Wert in ein Feld. Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden.
Yield()

Bewirkt, dass der aufrufende Thread die Ausführung an einen anderen Thread übergibt, der auf dem aktuellen Prozessor ausgeführt werden kann. Das Betriebssystem wählt den Thread für die Übergabe aus.

Explizite Schnittstellenimplementierungen

_Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.
_Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.
_Thread.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).
_Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen