Thread Klasse

Definition

Erstellt und steuert einen Thread, legt dessen Priorität fest und ruft den Status ab.Creates and controls a thread, sets its priority, and gets its status.

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

Beispiele

Im folgenden Beispiel werden einfache Threading Funktionen veranschaulicht.The following example demonstrates simple threading functionality.

// [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();
    }
}
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:This code produces output similar to the following:

[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 der Common Language Runtime automatisch einen einzelnen Vordergrund Thread, um Anwendungscode auszuführen.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Zusammen mit diesem Haupt Vordergrund Thread kann ein Prozess einen oder mehrere Threads erstellen, um einen Teil des Programmcodes auszuführen, der dem Prozess zugeordnet ist.Along with this main foreground thread, a process can create one or more threads to execute a portion of the program code associated with the process. Diese Threads können entweder im Vordergrund oder im Hintergrund ausgeführt werden.These threads can execute either in the foreground or in the background. Außerdem können Sie die ThreadPool-Klasse verwenden, um Code für Arbeitsthreads auszuführen, die vom Common Language Runtime verwaltet werden.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

In diesem AbschnittIn this section

Starten eines Threads Starting a thread
Abrufen von Thread Objekten Retrieving Thread objects
Vordergrund-und Hintergrundthreads Foreground and background threads
Kultur und Threads Culture and threads
Erhalten von Informationen über und Steuern von ThreadsGetting information about and controlling threads

Starten eines ThreadsStarting a thread

Sie starten einen Thread, indem Sie einen Delegaten bereitstellen, der die Methode darstellt, die der Thread in seinem Klassenkonstruktor ausführen soll.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Anschließend wird die Start-Methode aufgerufen, um die Ausführung zu starten.You then call the Start method to begin execution.

Die Thread-Konstruktoren können einen von zwei Delegattypen annehmen, je nachdem, ob Sie ein Argument an die auszuführende Methode übergeben können:The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Wenn die Methode über keine Argumente verfügt, übergeben Sie einen ThreadStart-Delegaten an den Konstruktor.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Sie hat die folgende Signatur:It has the signature:

    public delegate void ThreadStart()  
    
    Public Delegate Sub ThreadStart()  
    

    Im folgenden Beispiel wird ein Thread erstellt und gestartet, der die ExecuteInForeground-Methode ausführt.The following example creates and starts a thread that executes the ExecuteInForeground method. Die-Methode zeigt Informationen zu einigen Thread Eigenschaften an und führt dann eine Schleife aus, in der Sie für eine halbe Sekunde angehalten wird, und zeigt die verstrichene Anzahl von Sekunden an.The method displays information about some thread properties, then executes a loop in which it pauses for half a second and displays the elapsed number of seconds. Wenn der Thread mindestens fünf Sekunden lang ausgeführt wurde, wird die-Schleife beendet, und der Thread beendet die Ausführung.When the thread has executed for at least five seconds, the loop ends and the thread terminates execution.

    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()
       {
          DateTime start = DateTime.Now;
          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
    
    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.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Sie hat die folgende Signatur:It has the signature:

    public delegate void ParameterizedThreadStart(object obj)  
    
    Public Delegate Sub ParameterizedThreadStart(obj As Object)  
    

    Die vom Delegaten ausgeführte Methode kann dann den- C#Parameter in den entsprechenden Typ umwandeln (in) oder (in Visual Basic).The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    Das folgende Beispiel ist mit dem vorherigen identisch, mit der Ausnahme, dass der Konstruktor Thread(ParameterizedThreadStart) aufgerufen wird.The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Diese Version der ExecuteInForeground-Methode verfügt über einen einzelnen Parameter, der die ungefähre Anzahl von Millisekunden darstellt, die die Schleife ausgeführt werden soll.This version of the ExecuteInForeground method has a single parameter that represents the approximate number of milliseconds the loop is to execute.

    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;
          }
          DateTime start = DateTime.Now;
          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
    
    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.It is not necessary to retain a reference to a Thread object once you have started the thread. Der Thread wird weiter ausgeführt, bis die Thread Prozedur vollständig ist.The thread continues to execute until the thread procedure is complete.

Abrufen von Thread ObjektenRetrieving Thread objects

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.You can use the static (Shared in Visual Basic) CurrentThread property to retrieve a reference to the currently executing thread from the code that the thread is executing. Im folgenden Beispiel wird die CurrentThread-Eigenschaft verwendet, um Informationen zum Hauptanwendungs Thread, einen weiteren Vordergrund Thread, einen Hintergrund Thread und einen Thread Pool Thread anzuzeigen.The following example uses the CurrentThread property to display information about the main application thread, another foreground thread, a background thread, and a thread pool thread.

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
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 HintergrundthreadsForeground and background threads

Instanzen der Thread-Klasse stellen entweder Vordergrundthreads oder Hintergrundthreads dar.Instances of the Thread class represent either foreground threads or background threads. Hintergrundthreads sind mit einer Ausnahme mit den Vordergrundthreads identisch: ein Hintergrund Thread führt keinen Prozess aus, wenn alle Vordergrundthreads beendet wurden.Background threads are identical to foreground threads with one exception: a background thread does not keep a process running if all foreground threads have terminated. Nachdem alle Vordergrundthreads beendet wurden, beendet die Common Language Runtime alle Hintergrundthreads und wird heruntergefahren.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Standardmäßig werden die folgenden Threads im Vordergrund ausgeführt:By default, the following threads execute in the foreground:

  • Der Hauptanwendungs Thread.The main application thread.

  • Alle Threads, die durch Aufrufen eines Thread-Klassenkonstruktors erstellt wurden.All threads created by calling a Thread class constructor.

Die folgenden Threads werden standardmäßig im Hintergrund ausgeführt:The following threads execute in the background by default:

  • Thread Poolthreads, bei denen es sich um einen Pool von Arbeitsthreads handelt, die von der Laufzeit verwaltet werden.Thread pool threads, which are a pool of worker threads maintained by the runtime. Sie können den Thread Pool konfigurieren und arbeiten an Threads im Thread Pool mithilfe der ThreadPool-Klasse planen.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Hinweis

    Aufgabenbasierte asynchrone Vorgänge werden automatisch in Thread Pool-Threads ausgeführt.Task-based asynchronous operations automatically execute on thread pool threads. Aufgabenbasierte asynchrone Vorgänge verwenden die Klassen Task und Task<TResult>, um das aufgabenbasierte asynchrone Musterzu implementieren.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Alle Threads, die aus nicht verwaltetem Code in die verwaltete Ausführungsumgebung eintreten.All threads that enter the managed execution environment from unmanaged code.

Sie können einen Thread so ändern, dass er im Hintergrund ausgeführt wird, indem Sie die IsBackground-Eigenschaft jederzeit festlegen.You can change a thread to execute in the background by setting the IsBackground property at any time. Hintergrundthreads sind für jeden Vorgang nützlich, der fortgesetzt werden sollte, wenn eine Anwendung ausgeführt wird, aber nicht verhindern soll, dass die Anwendung beendet wird, z. b. das Überwachen von Dateisystem Änderungen oder eingehenden SocketverbindungenBackground threads are useful for any operation that should continue as long as an application is running but should not prevent the application from terminating, such as monitoring file system changes or incoming socket connections.

Das folgende Beispiel veranschaulicht den Unterschied zwischen Vordergrund-und Hintergrundthreads.The following example illustrates the difference between foreground and background threads. Dies entspricht dem ersten Beispiel im Abschnitt " Starten eines Threads ", mit dem Unterschied, dass der Thread vor dem Starten im Hintergrund ausgeführt wird.It is like the first example in the Starting a thread section, except that it sets the thread to execute in the background before starting it. Wie die Ausgabe zeigt, wird die Schleife unterbrochen, bevor Sie fünf Sekunden lang ausgeführt wird.As the output shows, the loop is interrupted before it executes for five seconds.

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()
   {
      DateTime start = DateTime.Now;
      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...
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 ThreadsCulture and threads

Jeder Thread verfügt über eine Kultur, die durch die CurrentCulture-Eigenschaft dargestellt wird, und eine Benutzeroberflächen Kultur, die durch die CurrentUICulture-Eigenschaft dargestellt wird.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. Die aktuelle Kultur unterstützt solche Kultur abhängigen Vorgänge wie das durcharbeiten und formatieren, den Zeichen folgen Vergleich und die Sortierung sowie das von einem Thread verwendete Schriftsystem und den von einem Thread verwendeten Kalender.The current culture supports such culture-sensitive operations as parsing and formatting, string comparison and sorting, and also controls the writing system and calendar used by a thread. Die aktuelle Benutzeroberflächen Kultur ermöglicht das Kultur abhängige Abrufen von Ressourcen in Ressourcen Dateien.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Wichtig

Die Eigenschaften "CurrentCulture" und "CurrentUICulture" funktionieren nicht zuverlässig, wenn Sie mit einem anderen Thread als dem aktuellen Thread verwendet werden.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. In .NET Framework ist das Lesen dieser Eigenschaften zuverlässig, auch wenn diese Eigenschaften für einen anderen Thread als den aktuellen Thread festgelegt werden.In .NET Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. In .net Core wird eine InvalidOperationException ausgelöst, wenn ein Thread versucht, diese Eigenschaften in einem anderen Thread zu lesen oder zu schreiben.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. Es wird empfohlen, dass Sie die Eigenschaften "CultureInfo.CurrentCulture" und "CultureInfo.CurrentUICulture" verwenden, um die aktuelle Kultur abzurufen und festzulegen.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

Wenn ein neuer Thread instanziiert wird, werden seine Kultur und Benutzeroberflächen Kultur von der aktuellen System Kultur und Benutzeroberflächen Kultur definiert, nicht von der Kultur und Benutzeroberflächen Kultur des Threads, von dem aus der neue Thread erstellt wird.When a new thread is instantiated, its culture and UI culture are defined by the current system culture and UI culture, and not by the culture and UI culture of the thread from which the new thread is created. Dies bedeutet beispielsweise Folgendes: Wenn die aktuelle System Kultur Englisch (USA) und die aktuelle Kultur des primären Anwendungs Threads Französisch (Frankreich) ist, ist 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).This means, for example, that if the current system culture is English (United States) and the current culture of the primary application thread is French (France), the culture of a new thread created by calling the Thread(ParameterizedThreadStart) constructor from the primary thread is English (United States), and not French (France). Weitere Informationen finden Sie im Abschnitt "Kultur und Threads" im Thema CultureInfo-Klasse.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Wichtig

Dies gilt nicht für Threads, die asynchrone Vorgänge für apps ausführen, die auf .NET Framework 4.6.NET Framework 4.6 und spätere Versionen abzielen. in diesem Fall ist die Kultur und die UI-Kultur Teil eines asynchronen Vorgangs Kontexts. der Thread, für den ein asynchroner Vorgang standardmäßig ausgeführt wird, erbt die Kultur und die UI-Kultur des Threads, von dem der asynchrone Vorgang gestartet wurde.This is not true of threads that execute asynchronous operations for apps that target the .NET Framework 4.6.NET Framework 4.6 and later versions, In this case, the culture and UI culture is part of an asynchronous operations' context; the thread on which an asynchronous operation executes by default inherits the culture and UI culture of the thread from which the asynchronous operation was launched. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" im Thema zur CultureInfo-Klasse.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

Sie können eine der folgenden Aktionen durchführen, um sicherzustellen, dass alle in einer Anwendung ausgeführten Threads dieselbe Kultur und Benutzeroberflächen Kultur gemeinsam nutzen:You can do either of the following to ensure that all of the threads executing in an application share the same culture and UI culture:

Weitere Informationen und Beispiele finden Sie im Abschnitt "Kultur und Threads" im Thema CultureInfo-Klasse.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Erhalten von Informationen über und Steuern von ThreadsGetting information about and controlling threads

Sie können eine Reihe von Eigenschafts Werten abrufen, die Informationen zu einem Thread bereitstellen.You can retrieve a number of property values that provide information about a thread. In einigen Fällen können Sie auch diese Eigenschaftswerte festlegen, um den Thread Vorgang zu steuern.In some cases, you can also set these property values to control the operation of the thread. Zu diesen Thread Eigenschaften gehören:These thread properties include:

  • Einen Namen.A name. Name ist eine Write-Once-Eigenschaft, mit der Sie einen Thread identifizieren können.Name is a write-once property that you can use to identify a thread. Der Standardwert lautet null.Its default value is null.

  • Ein Hashcode, den Sie abrufen können, indem Sie die GetHashCode-Methode aufrufen.A hash code, which you can retrieve by calling the GetHashCode method. Der Hashcode kann verwendet werden, um einen Thread eindeutig zu identifizieren. der Hashcode für die Lebensdauer des Threads findet nicht mit dem Wert eines anderen Threads in Konflikt, unabhängig von der Anwendungsdomäne, aus der der Wert abgerufen wird.The hash code can be used to uniquely identify a thread; for the lifetime of your thread, its hash code will not collide with the value from any other thread, regardless of the application domain from which you obtain the value.

  • Eine Thread-ID.A thread ID. Der Wert der schreibgeschützten ManagedThreadId-Eigenschaft wird von der Common Language Runtime zugewiesen und identifiziert einen Thread innerhalb des Prozesses eindeutig.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    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.An operating-system ThreadId has no fixed relationship to a managed thread, because an unmanaged host can control the relationship between managed and unmanaged threads. Insbesondere kann ein hoch entwickelter Host die CLR-Hosting-API verwenden, um viele verwaltete Threads mit demselben Betriebssystem Thread zu planen oder einen verwalteten Thread zwischen verschiedenen Betriebssystemthreads zu verschieben.Specifically, a sophisticated host can use the CLR Hosting API to schedule many managed threads against the same operating system thread, or to move a managed thread between different operating system threads.

  • Der aktuelle Zustand des Threads.The thread's current state. Für die Dauer des Vorhandenseins ist ein Thread immer in einem oder mehreren der Zustände, die durch die ThreadState-Eigenschaft definiert sind.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Eine Prioritätsstufe für die Planung, die durch die ThreadPriority-Eigenschaft definiert wird.A scheduling priority level, which is defined by the ThreadPriority property. Obwohl Sie diesen Wert festlegen können, um die Priorität eines Threads anzufordern, ist es nicht gewährleistet, dass er vom Betriebssystem berücksichtigt wird.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • Die schreibgeschützte IsThreadPoolThread-Eigenschaft, die angibt, ob es sich bei einem Thread um einen Thread Pool Thread handelt.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • Die IsBackground-EigenschaftThe IsBackground property. Weitere Informationen finden Sie im Abschnitt Vordergrund-und Hintergrundthreads .For more information, see the Foreground and background threads section.

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.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started.

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.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started and specifying the maximum stack size for the thread.

Thread(ThreadStart)

Initialisiert eine neue Instanz der Thread-Klasse.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32)

Initialisiert eine neue Instanz der Thread-Klasse und gibt die maximale Stapelgröße für den Thread an.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Eigenschaften

ApartmentState

Ruft den Apartmentzustand dieses Threads ab oder legt diesen fest.Gets or sets the apartment state of this thread.

CurrentContext

Ruft den aktuellen Kontext ab, in dem der Thread ausgeführt wird.Gets the current context in which the thread is executing.

CurrentCulture

Ruft die Kultur für den aktuellen Thread ab oder legt diese fest.Gets or sets the culture for the current thread.

CurrentPrincipal

Ruft den aktuellen Prinzipal des Threads (für rollenbasierte Sicherheit) ab oder legt diesen fest.Gets or sets the thread's current principal (for role-based security).

CurrentThread

Ruft den derzeit ausgeführten Thread ab.Gets the currently running thread.

CurrentUICulture

Ruft die aktuelle Kultur ab, mit deren Hilfe der Ressourcen-Manager zur Laufzeit kulturabhängige Ressourcen sucht, oder legt diese fest.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext

Ruft ein ExecutionContext-Objekt ab, das Informationen zu den verschiedenen Kontexten des aktuellen Threads enthält.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive

Ruft einen Wert ab, der den Ausführungsstatus des aktuellen Threads angibt.Gets a value indicating the execution status of the current thread.

IsBackground

Ruft einen Wert ab, der angibt, ob es sich bei einem Thread um einen Hintergrundthread handelt, oder legt diesen fest.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread

Ruft einen Wert ab, der angibt, ob ein Thread zu dem verwalteten Threadpool gehört.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId

Ruft einen eindeutigen Bezeichner für den aktuellen verwalteten Thread ab.Gets a unique identifier for the current managed thread.

Name

Ruft den Namen des Threads ab oder legt diesen fest.Gets or sets the name of the thread.

Priority

Ruft einen Wert ab, der die Planungspriorität eines Threads angibt, oder legt diesen fest.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState

Ruft einen Wert ab, der die Zustände des aktuellen Threads enthält.Gets a value containing the states of the current thread.

Methoden

Abort()

Löst eine ThreadAbortException im Thread aus, für den der Aufruf erfolgte, um das Beenden des Threads zu beginnen.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. Durch den Aufruf dieser Methode wird der Thread i. d. R. beendet.Calling this method usually terminates the thread.

Abort(Object)

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.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. Durch den Aufruf dieser Methode wird der Thread i. d. R. beendet.Calling this method usually terminates the thread.

AllocateDataSlot()

Reserviert einen unbenannten Datenslot für alle Threads.Allocates an unnamed data slot on all the threads. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String)

Reserviert einen benannten Datenslot für alle Threads.Allocates a named data slot on all threads. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

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.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception might jeopardize other tasks in the application domain.

BeginThreadAffinity()

Benachrichtigt einen Host, dass verwalteter Code im Begriff ist, Anweisungen auszuführen, die von der Identität des aktuellen physischen Betriebssystemthreads abhängen.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup()

Deaktiviert die automatische Bereinigung von Runtime Callable Wrappern (RCW) für den aktuellen Thread.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current 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.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception are limited to the current task.

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.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(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.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String)

Entfernt die Zuordnung zwischen einem Namen und einem Slot für alle Threads in dem Prozess.Eliminates the association between a name and a slot, for all threads in the process. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState()

Gibt einen ApartmentState-Wert zurück, der den Apartmentzustand angibt.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack()

Gibt ein CompressedStack-Objekt zurück, mit dem der Stapel für den aktuellen Thread erfasst werden kann.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId()

Ruft eine ID ab, mit der angegeben wird, mit welchem Prozessor der aktuelle Thread ausgeführt wird.Gets an ID used to indicate on which processor the current thread is executing.

GetData(LocalDataStoreSlot)

Ruft in der aktuellen Domäne des aktuellen Threads den Wert aus dem angegebenen Slot für den aktuellen Thread ab.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain()

Gibt die aktuelle Domäne zurück, in der der aktuelle Thread ausgeführt wird.Returns the current domain in which the current thread is running.

GetDomainID()

Gibt einen eindeutigen Bezeichner der Anwendungsdomäne zurück.Returns a unique application domain identifier.

GetHashCode()

Gibt einen Hashcode für den aktuellen Thread zurück.Returns a hash code for the current thread.

GetNamedDataSlot(String)

Sucht einen benannten Datenslot.Looks up a named data slot. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
Interrupt()

Unterbricht einen Thread, der sich im WaitSleepJoin-Threadzustand befindet.Interrupts a thread that is in the WaitSleepJoin thread state.

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.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

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.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

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.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemoryBarrier()

Synchronisiert den Arbeitsspeicherzugriff wie folgt: 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.Synchronizes memory access as follows: The processor executing the current thread cannot reorder instructions in such a way that memory accesses prior to the call to MemoryBarrier() execute after memory accesses that follow the call to MemoryBarrier().

ResetAbort()

Bricht ein Abort(Object) ab, das für den aktuellen Thread angefordert wurde.Cancels an Abort(Object) requested for the current thread.

Resume()

Nimmt die Ausführung eines angehaltenen Threads wieder auf.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState)

Legt den Apartmentzustand eines Threads fest, bevor dieser gestartet wird.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack)

Übernimmt einen erfassten CompressedStack für den aktuellen Thread.Applies a captured CompressedStack to the current 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.Sets the data in the specified slot on the currently running thread, for that thread's current domain. Eine höhere Leistung erzielen Sie, wenn Sie stattdessen Felder verwenden, die mit dem ThreadStaticAttribute-Attribut markiert sind.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32)

Hält den aktuellen Thread für die angegebene Anzahl von Millisekunden an.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan)

Hält den aktuellen Thread während des angegebenen Zeitraums an.Suspends the current thread for the specified amount of time.

SpinWait(Int32)

Veranlasst, dass ein Thread so oft wartet, wie vom iterations-Parameter definiert.Causes a thread to wait the number of times defined by the iterations parameter.

Start()

Weist das Betriebssystem an, den Zustand der aktuellen Instanz in Running zu ändern.Causes the operating system to change the state of the current instance to Running.

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.Causes the operating system to change the state of the current instance to Running, and optionally supplies an object containing data to be used by the method the thread executes.

Suspend()

Hält den Thread an. Hat keine Auswirkungen, wenn der Thread bereits angehalten ist.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)
TrySetApartmentState(ApartmentState)

Legt den Apartmentzustand eines Threads fest, bevor dieser gestartet wird.Sets the apartment state of a thread before it is started.

VolatileRead(Byte)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Double)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int16)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int32)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int64)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(IntPtr)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Object)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(SByte)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Single)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt16)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt32)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt64)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UIntPtr)

Liest den Wert eines Felds.Reads the value of a field. Der Wert entspricht dem letzten von einem Prozessor in dem Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileWrite(Byte, Byte)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr)

Schreibt einen Wert sofort in ein Feld, sodass der Wert für alle Prozessoren des Computers sichtbar ist.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield()

Bewirkt, dass der aufrufende Thread die Ausführung an einen anderen Thread übergibt, der auf dem aktuellen Prozessor ausgeführt werden kann.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. Das Betriebssystem wählt den Thread für die Übergabe aus.The operating system selects the thread to yield to.

Explizite Schnittstellenimplementierungen

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

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.Maps a set of names to a corresponding set of dispatch identifiers.

_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.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Siehe auch