Thread Thread Thread Thread Class

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

Das folgende Beispiel zeigt einfachen threading-Funktionen.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
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 die common Language Runtime automatisch eine einzelne Vordergrundthread, 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 Hauptmenü Vordergrundthread kann ein Prozess eine oder mehrere Threads, um einen Teil der Programmcode, der dem Prozess zugeordneten ausführen erstellen.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 ausführen.These threads can execute either in the foreground or in the background. Darüber hinaus können Sie die ThreadPool Klasse zum Ausführen von Code auf die Anzahl der Arbeitsthreads, die von der 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
Abrufen von Informationen zu und Steuern von threadsGetting information about and controlling threads

Starten eines ThreadsStarting a thread

Sie starten ein Threads durch Angabe ein Delegaten, das die Methode darstellt, die der Thread befindet sich in seinem Klassenkonstruktor ausgeführt.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Rufen Sie dann die Start Methode, um die Ausführung zu starten.You then call the Start method to begin execution.

Die Thread Konstruktoren akzeptiert entweder von zwei Delegattypen, je nachdem, ob Sie ein Argument an die Methode, die ausgeführt werden ü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 keine Argumente verfügt, Sie übergeben eine ThreadStart delegieren an den Konstruktor.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Er trägt die Signatur:It has the signature:

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

    Das folgende Beispiel erstellt und startet einen Thread, der ausgeführt wird die ExecuteInForeground Methode.The following example creates and starts a thread that executes the ExecuteInForeground method. Die Methode zeigt Informationen zu einigen Threadeigenschaften, führt dann eine Schleife in der sie für eine halbe Sekunde angehalten wird, und zeigt die verstrichene Anzahl von Sekunden.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, beendet die Schleife beendet und der Thread 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 ein Argument verfügt, Sie übergeben eine ParameterizedThreadStart delegieren an den Konstruktor.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Er trägt die Signatur:It has the signature:

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

    Die Methode ausgeführt wird, durch den Delegaten kann dann umgewandelt (in C# -Referenz) oder konvertieren den Parameter (in Visual Basic) aus, in den entsprechenden Typ.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    Im folgende Beispiel ist identisch mit dem vorherigen Beispiel, außer dass sie ruft die Thread(ParameterizedThreadStart) Konstruktor.The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Diese Version von der ExecuteInForeground Methode verfügt über einen einzelnen Parameter, der die ungefähre Anzahl von Millisekunden darstellt, die Schleife wird ausgeführt.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, beizubehalten, einen Verweis auf eine Thread Objekt, 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 weiterhin ausgeführt, bis die Threadprozedur abgeschlossen ist.The thread continues to execute until the thread procedure is complete.

Abrufen von Thread-ObjektenRetrieving Thread objects

Sie können mithilfe der statischen (Shared in Visual Basic) CurrentThread Eigenschaft, um einen Verweis auf den gerade ausgeführten Thread aus dem Code abzurufen, die der Thread ausgeführt wird.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, um Informationen zum Thread der hauptanwendung, eine andere Vordergrundthread, einem Hintergrundthread und einen Threadpool-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 Vordergrundthreads oder Hintergrundthreads Klasse darstellen.Instances of the Thread class represent either foreground threads or background threads. Hintergrundthreads sind identisch mit Vordergrundthreads mit einer Ausnahme: ein Hintergrundthread keinen laufenden Prozess beibehalten, 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. Sobald alle Vordergrundthreads beendet wurden, wird die Laufzeit beendet alle Hintergrundthreads und fährt.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Führen die folgenden Threads in der Standardeinstellung im Vordergrund:By default, the following threads execute in the foreground:

  • Der Thread der hauptanwendung.The main application thread.

  • Alle Threads, die durch den Aufruf erstellt einen Thread Klassenkonstruktor.All threads created by calling a Thread class constructor.

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

  • Thread Poolthreads, die einen Pool von Arbeitsthreads, die von der Laufzeit verwaltet werden.Thread pool threads, which are a pool of worker threads maintained by the runtime. Sie können die Thread-Pool und den Zeitplan der Arbeit in Threads im Threadpool konfigurieren, mit der ThreadPool Klasse.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 Threads im Threadpool ausgeführt.Task-based asynchronous operations automatically execute on thread pool threads. Aufgabenbasierte asynchrone Vorgänge verwenden die Task und Task<TResult> Klassen implementieren die aufgabenbasierte asynchrone Muster.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Alle Threads, die die verwaltete ausführungsumgebung von nicht verwaltetem Code eingeben.All threads that enter the managed execution environment from unmanaged code.

Sie können ändern, dass einen Thread im Hintergrund ausführen, durch Festlegen der IsBackground Eigenschaft zu einem beliebigen Zeitpunkt.You can change a thread to execute in the background by setting the IsBackground property at any time. Hintergrundthreads sind nützlich für jeden Vorgang, der fortgesetzt werden soll, solange Sie eine Anwendung ausgeführt wird, jedoch sollte nicht zu verhindern, dass die Anwendung beendet wird, wie z. B. das Überwachen von dateisystemänderungen oder eingehende WebSocket-Verbindungen.Background 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. Es ist wie im ersten Beispiel in der Starten eines Threads Abschnitt, außer dass sie im Hintergrund ausführen, vor dem Starten des Threads.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. Die Ausgabe zeigt, wird die Schleife unterbrochen, bevor er fünf Sekunden 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 hat eine Kultur, dargestellt durch die CurrentCulture -Eigenschaft und eine Benutzeroberflächenkultur, dargestellt durch die CurrentUICulture Eigenschaft.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. Die aktuelle Kultur unterstützt kulturabhängige Vorgänge wie Analyse und Formatierung, Zeichenfolgenvergleich und-Sortierung und steuert auch die Schriftsystems und Kalenders, die von einem Thread verwendet.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ächenkultur bietet für kulturabhängige-Abruf von Ressourcen in Ressourcendateien.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Wenn ein neuer Thread instanziiert wird, werden die Kultur und Benutzeroberflächenkultur definiert, durch die aktuelle Systemkultur und UI-Kultur, und nicht von der Kultur und Benutzeroberflächenkultur des Threads aus der 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. Also, z. B. wenn die aktuelle Systemkultur Englisch (Vereinigte Staaten ist) und der aktuellen Kultur des Threads primäranwendung Französisch (Frankreich), die Kultur eines neuen Threads erstellt durch Aufrufen der Thread(ParameterizedThreadStart) Konstruktor aus dem primären Thread ist nicht Französisch (Frankreich) und Englisch (USA).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", der die CultureInfo Thema-Klasse.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Wichtig

Dies gilt nicht für Threads, die ausgeführt werden asynchrone Vorgänge für apps, die auf die .NET Framework 4.6.NET Framework 4.6 und höhere Versionen, In diesem Fall werden die Kultur und Benutzeroberflächenkultur ist Teil eines asynchronen Vorgänge Kontext; der Thread auf dem eines asynchronen Vorgangs führt standardmäßig erbt der Kultur und Benutzeroberflächenkultur 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.

Führen Sie einen der folgenden Optionen, um sicherzustellen, dass alle Threads in einer Anwendung ausführen freigeben, das dieselbe Kultur und Benutzeroberflächenkultur: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", der die CultureInfo Thema-Klasse.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Abrufen von Informationen zu und Steuern von threadsGetting information about and controlling threads

Sie können eine Anzahl von Eigenschaftswerten abrufen, die Informationen über einen Thread zu bieten.You can retrieve a number of property values that provide information about a thread. In einigen Fällen können Sie auch diese Eigenschaftswerte, die Ausführung des Threads steuern festlegen.In some cases, you can also set these property values to control the operation of the thread. Zu diesen Threadeigenschaften zählen:These thread properties include:

  • Einen Namen.A name. Name ein Schreibvorgang-einmal-Eigenschaft, die Sie verwenden können, um einen Thread zu identifizieren.Name is a write-once property that you can use to identify a thread. Der Standardwert ist null.Its default value is null.

  • Ein Hashcode, die Sie durch den Aufruf abrufen können die GetHashCode Methode.A hash code, which you can retrieve by calling the GetHashCode method. Der Hashcode kann verwendet werden, um einen Thread eindeutig zu identifizieren. für die Lebensdauer des Threads wird der Hashcode nicht mit dem Wert eines anderen Threads, unabhängig von der Anwendungsdomäne in Konflikt stehen aus dem Sie den Wert abrufen.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.

  • Ein Thread-ID.A thread ID. Der Wert der Read-only ManagedThreadId Eigenschaft wird von der Laufzeit zugewiesen und einen Thread innerhalb des Prozesses eindeutig identifiziert.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. Ein komplexer Host können insbesondere die CLR Hosting-API um viele verwaltete Threads für die gleiche Betriebssystemthread zu planen oder um 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 Thread den aktuellen Status.The thread's current state. Für die Dauer der vorhanden ist, ein Thread ist immer in einer oder mehreren der Zustände von definiert die ThreadState Eigenschaft.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Eine Planung Prioritätsstufe, die durch definiert wird die ThreadPriority Eigenschaft.A scheduling priority level, which is defined by the ThreadPriority property. Obwohl Sie diesen Wert zum Anfordern der Priorität des Threads festlegen können, ist es nicht garantiert, vom Betriebssystem berücksichtigt werden.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 ein Thread einen Threadpool-Thread ist.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

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

Konstruktoren

Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) 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) Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32) 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) Thread(ThreadStart) Thread(ThreadStart) Thread(ThreadStart)

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

Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) 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 ApartmentState ApartmentState ApartmentState

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

CurrentContext CurrentContext CurrentContext CurrentContext

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

CurrentCulture CurrentCulture CurrentCulture CurrentCulture

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

CurrentPrincipal CurrentPrincipal CurrentPrincipal 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 CurrentThread CurrentThread CurrentThread

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

CurrentUICulture CurrentUICulture CurrentUICulture 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 ExecutionContext ExecutionContext 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 IsAlive IsAlive 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 IsBackground IsBackground 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 IsThreadPoolThread IsThreadPoolThread 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 ManagedThreadId ManagedThreadId ManagedThreadId

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

Name Name Name Name

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

Priority Priority Priority 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 ThreadState ThreadState 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() Abort() Abort() 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) Abort(Object) Abort(Object) 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() AllocateDataSlot() AllocateDataSlot() 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) AllocateNamedDataSlot(String) AllocateNamedDataSlot(String) 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() BeginCriticalRegion() BeginCriticalRegion() 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() BeginThreadAffinity() BeginThreadAffinity() 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() DisableComObjectEagerCleanup() DisableComObjectEagerCleanup() 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() EndCriticalRegion() EndCriticalRegion() 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() EndThreadAffinity() EndThreadAffinity() 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) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
Finalize() Finalize() Finalize() 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) FreeNamedDataSlot(String) FreeNamedDataSlot(String) 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() GetApartmentState() GetApartmentState() GetApartmentState()

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

GetCompressedStack() GetCompressedStack() GetCompressedStack() 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() GetCurrentProcessorId() GetCurrentProcessorId() GetCurrentProcessorId()
GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) 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() GetDomain() GetDomain() 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() GetDomainID() GetDomainID() GetDomainID()

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

GetNamedDataSlot(String) GetNamedDataSlot(String) GetNamedDataSlot(String) 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() GetType() GetType() GetType()

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

(Inherited from Object)
Interrupt() Interrupt() Interrupt() Interrupt()

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

Join() Join() Join() 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) Join(Int32) Join(Int32) 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) Join(TimeSpan) Join(TimeSpan) 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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
MemoryBarrier() MemoryBarrier() MemoryBarrier() 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. 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() ResetAbort() ResetAbort() ResetAbort()

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

Resume() Resume() Resume() Resume()

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

SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) 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) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack)

Übernimmt einen erfassten CompressedStack für den aktuellen Thread. Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) 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) Sleep(Int32) Sleep(Int32) 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) Sleep(TimeSpan) Sleep(TimeSpan) 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) SpinWait(Int32) SpinWait(Int32) 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() Start() Start() 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) Start(Object) Start(Object) 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() Suspend() Suspend() 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() ToString() ToString() ToString()

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

(Inherited from Object)
TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) 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) VolatileRead(Byte) VolatileRead(Byte) 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) VolatileRead(Double) VolatileRead(Double) 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) VolatileRead(Int16) VolatileRead(Int16) 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) VolatileRead(Int32) VolatileRead(Int32) 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) VolatileRead(Int64) VolatileRead(Int64) 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) VolatileRead(IntPtr) VolatileRead(IntPtr) 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) VolatileRead(Object) VolatileRead(Object) 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) VolatileRead(SByte) VolatileRead(SByte) 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) VolatileRead(Single) VolatileRead(Single) 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) VolatileRead(UInt16) VolatileRead(UInt16) 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) VolatileRead(UInt32) VolatileRead(UInt32) 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) VolatileRead(UInt64) VolatileRead(UInt64) 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) VolatileRead(UIntPtr) VolatileRead(UIntPtr) 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) VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte) 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) VolatileWrite(Double, Double) VolatileWrite(Double, Double) 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) VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16) 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) VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32) 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) VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64) 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) VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr) 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) VolatileWrite(Object, Object) VolatileWrite(Object, Object) 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) VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte) 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) VolatileWrite(Single, Single) VolatileWrite(Single, Single) 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) VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16) 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) VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32) 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) VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64) 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) VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr) 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() Yield() Yield() 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) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _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) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _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) _Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32) _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) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _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