Thread Klasa

Definicja

Tworzy i kontroluje wątek, ustawia jego priorytet i pobiera jego stan.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.ComVisible(true)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Thread : 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
Dziedziczenie
Thread
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Poniższy przykład ilustruje prostą funkcję wątkowości.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

Ten kod generuje dane wyjściowe podobne do następujących: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.  

Uwagi

Po rozpoczęciu procesu środowisko uruchomieniowe języka wspólnego automatycznie tworzy jeden wątek pierwszego planu, aby wykonać kod aplikacji.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Wraz z tym głównym wątkiem pierwszego planu proces może utworzyć jeden lub więcej wątków, aby wykonać część kodu programu skojarzonego z procesem.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. Te wątki można wykonać na pierwszym planie lub w tle.These threads can execute either in the foreground or in the background. Ponadto można użyć klasy ThreadPool, aby wykonać kod w wątkach roboczych, które są zarządzane przez środowisko uruchomieniowe języka wspólnego.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

W tej sekcjiIn this section

Uruchamianie wątku Starting a thread
Pobieranie obiektów wątku Retrieving Thread objects
Wątki pierwszego planu i tła Foreground and background threads
Kultura i wątki Culture and threads
Pobieranie informacji o wątkach i sterowanie nimiGetting information about and controlling threads

Uruchamianie wątkuStarting a thread

Wątek można uruchomić, dostarczając delegata, który reprezentuje metodę, którą wątek ma wykonać w konstruktorze klasy.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Następnie należy wywołać metodę Start, aby rozpocząć wykonywanie.You then call the Start method to begin execution.

Konstruktory Thread mogą przyjmować jeden z dwóch typów delegatów, w zależności od tego, czy można przekazać argument do metody, która ma zostać wykonana:The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Jeśli metoda nie ma argumentów, przekazujesz ThreadStart delegata do konstruktora.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Ma podpis:It has the signature:

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

    Poniższy przykład tworzy i uruchamia wątek, który wykonuje metodę ExecuteInForeground.The following example creates and starts a thread that executes the ExecuteInForeground method. Metoda Wyświetla informacje o niektórych właściwościach wątku, a następnie wykonuje pętlę, w której wstrzymuje się w ciągu pół sekundy i wyświetla upłynęło liczbę sekund.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. Gdy wątek jest wykonywany przez co najmniej pięć sekund, pętla kończy się i wątek kończy wykonywanie.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
    
  • Jeśli metoda ma argument, przekazujesz ParameterizedThreadStart delegata do konstruktora.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Ma podpis:It has the signature:

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

    Metoda wykonywana przez delegata może następnie rzutować (w C#) lub skonwertować (w Visual Basic) parametr do odpowiedniego typu.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    Poniższy przykład jest identyczny z poprzednim, z tą różnicą, że wywołuje konstruktora Thread(ParameterizedThreadStart).The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Ta wersja metody ExecuteInForeground ma jeden parametr reprezentujący przybliżoną liczbę milisekund, jaką ma wykonać pętla.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
    

Nie jest konieczne zachowywanie odwołania do obiektu Thread po rozpoczęciu wątku.It is not necessary to retain a reference to a Thread object once you have started the thread. Wątek będzie nadal wykonywany do momentu zakończenia procedury wątku.The thread continues to execute until the thread procedure is complete.

Pobieranie obiektów wątkówRetrieving Thread objects

Można użyć właściwości CurrentThread static (Shared in Visual Basic), aby pobrać odwołanie do aktualnie wykonywanego wątku z kodu, który wykonuje wątek.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. Poniższy przykład używa właściwości CurrentThread, aby wyświetlić informacje o wątku głównej aplikacji, innym wątku pierwszego planu, wątku w tle i wątku puli wątków.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

Wątki pierwszego planu i tłaForeground and background threads

Wystąpienia klasy Thread reprezentują wątki pierwszego planu lub wątki w tle.Instances of the Thread class represent either foreground threads or background threads. Wątki w tle są takie same jak wątki pierwszego planu z jednym wyjątkiem: wątek w tle nie utrzymuje procesu uruchomionego, jeśli wszystkie wątki pierwszego planu zostały zakończone.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. Po zatrzymaniu wszystkich wątków pierwszego planu środowisko uruchomieniowe zatrzymuje wszystkie wątki w tle i zamknie.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Domyślnie następujące wątki są wykonywane na pierwszym planie:By default, the following threads execute in the foreground:

  • Główny wątek aplikacji.The main application thread.

  • Wszystkie wątki utworzone przez wywołanie konstruktora klasy Thread.All threads created by calling a Thread class constructor.

Następujące wątki są domyślnie wykonywane w tle:The following threads execute in the background by default:

  • Wątki puli wątków, które są pulą wątków roboczych obsługiwanych przez środowisko uruchomieniowe.Thread pool threads, which are a pool of worker threads maintained by the runtime. Można skonfigurować pulę wątków i zaplanować prace w wątkach puli wątków przy użyciu klasy ThreadPool.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Uwaga

    Asynchroniczne operacje oparte na zadaniach są automatycznie wykonywane w wątkach puli wątków.Task-based asynchronous operations automatically execute on thread pool threads. Asynchroniczne operacje oparte na zadaniach używają klas Task i Task<TResult> do implementowania wzorca asynchronicznego opartego na zadaniach.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Wszystkie wątki, które wprowadzają zarządzane środowisko wykonawcze z kodu niezarządzanego.All threads that enter the managed execution environment from unmanaged code.

Można zmienić wątek do wykonania w tle, ustawiając właściwość IsBackground w dowolnym momencie.You can change a thread to execute in the background by setting the IsBackground property at any time. Wątki w tle są przydatne w przypadku każdej operacji, która powinna być kontynuowana, gdy aplikacja jest uruchomiona, ale nie powinna uniemożliwiać przerwania działania aplikacji, na przykład monitorowania zmian systemu plików lub połączeń gniazd przychodzących.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.

Poniższy przykład ilustruje różnicę między wątkiem na pierwszym planie i w tle.The following example illustrates the difference between foreground and background threads. Jest on podobny do pierwszego przykładu w sekcji Uruchamianie wątku , z tą różnicą, że ustawia wątek do wykonania w tle przed jego uruchomieniem.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. Jak widać, pętla zostanie przerwana przed wykonaniem przez pięć sekund.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...

Kultura i wątkiCulture and threads

Każdy wątek ma kulturę, reprezentowana przez właściwość CurrentCulture i kulturę interfejsu użytkownika reprezentowane przez właściwość CurrentUICulture.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. Bieżąca kultura obsługuje takie operacje, które są zależne od kultury, jak analizowanie i formatowanie, Porównywanie ciągów i sortowanie, a także kontroluje system pisania i kalendarz używany przez wątek.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. Bieżąca kultura interfejsu użytkownika umożliwia pobieranie zasobów z uwzględnieniem kultury w plikach zasobów.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Ważne

Właściwości CurrentCulture i CurrentUICulture nie działają prawidłowo, gdy są używane z jakimkolwiek wątkiem innym niż bieżący wątek.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. W .NET Framework odczytywanie tych właściwości jest niezawodne, chociaż ustawienie tych właściwości dla wątku innego niż bieżący wątek nie jest.In .NET Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. W przypadku platformy .NET Core jest generowany InvalidOperationException, jeśli wątek próbuje odczytać lub zapisać te właściwości w innym wątku.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. Zalecamy używanie właściwości CultureInfo.CurrentCulture i CultureInfo.CurrentUICulture do pobierania i ustawiania bieżącej kultury.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

Podczas tworzenia wystąpienia nowego wątku jego kultura i kultura interfejsu użytkownika są definiowane przez bieżącą kulturę systemu i kulturę interfejsu użytkownika, a nie przez kulturę i kultury interfejsu użytkownika wątku, z którego tworzony jest nowy wątek.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. Oznacza to, na przykład, że jeśli bieżącą kulturą systemu jest angielski (Stany Zjednoczone), a bieżąca kultura wątku aplikacji głównej jest francuski (Francja), kultura nowego wątku utworzonego przez wywołanie konstruktora Thread(ParameterizedThreadStart) z wątku podstawowego to angielski (Stany Zjednoczone), a nie francuski (Francja).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). Aby uzyskać więcej informacji, zobacz sekcję "Kultura i wątki" tematu CultureInfo klasy.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Ważne

Nie jest to prawdziwe w przypadku wątków wykonujących operacje asynchroniczne dla aplikacji, które są przeznaczone dla .NET Framework 4.6.NET Framework 4.6 i nowszych wersji, w tym przypadku kultura i kultura interfejsu użytkownika jest częścią operacji asynchronicznych ". wątek, w którym wykonywana jest operacja asynchroniczna, domyślnie dziedziczy kultury i kulturę interfejsu użytkownika wątku, z którego została uruchomiona operacja asynchroniczna.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. Aby uzyskać więcej informacji, zobacz sekcję "kultury i operacje asynchroniczne oparte na zadaniach" w temacie klasy CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

Możesz wykonać jedną z następujących czynności, aby upewnić się, że wszystkie wątki wykonywane w aplikacji mają tę samą kulturę i kulturę interfejsu użytkownika: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:

Aby uzyskać więcej informacji i przykładów, zobacz sekcję "Kultura i wątki" tematu CultureInfo klasy.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Pobieranie informacji o wątkach i sterowanie nimiGetting information about and controlling threads

Można pobrać wiele wartości właściwości, które dostarczają informacje o wątku.You can retrieve a number of property values that provide information about a thread. W niektórych przypadkach można również ustawić te wartości właściwości w celu kontrolowania operacji wątku.In some cases, you can also set these property values to control the operation of the thread. Te właściwości wątku obejmują:These thread properties include:

  • Nazwa.A name. Name to właściwość jednokrotnego zapisu, która służy do identyfikowania wątku.Name is a write-once property that you can use to identify a thread. Wartość domyślna to null.Its default value is null.

  • Kod skrótu, który można pobrać, wywołując metodę GetHashCode.A hash code, which you can retrieve by calling the GetHashCode method. Kod skrótu może służyć do unikatowego identyfikowania wątku; w przypadku okresu istnienia wątku jego kod skrótu nie koliduje z wartością z dowolnego innego wątku, niezależnie od domeny aplikacji, z której ma zostać uzyskana wartość.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.

  • Identyfikator wątku.A thread ID. Wartość właściwości ManagedThreadId tylko do odczytu jest przypisana przez środowisko uruchomieniowe i jednoznacznie identyfikuje wątek w ramach procesu.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    Uwaga

    ThreadID systemu operacyjnego nie ma stałej relacji z zarządzanym wątkiem, ponieważ niezarządzany host może kontrolować relacje między wątki zarządzane i niezarządzane.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. W przypadku zaawansowanego hosta można użyć interfejsu API hostingu środowiska CLR do zaplanowania wielu zarządzanych wątków w tym samym wątku systemu operacyjnego lub przenoszenia zarządzanego wątku między różnymi wątkami systemu operacyjnego.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.

  • Bieżący stan wątku.The thread's current state. Na czas istnienia wątek jest zawsze w co najmniej jednym ze Stanów zdefiniowanych przez właściwość ThreadState.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Poziom priorytetu planowania zdefiniowany przez właściwość ThreadPriority.A scheduling priority level, which is defined by the ThreadPriority property. Mimo że można ustawić tę wartość, aby zażądać priorytetu wątku, nie ma gwarancji, że jest on uznawany przez system operacyjny.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • Właściwość IsThreadPoolThread tylko do odczytu, która wskazuje, czy wątek jest wątkiem puli wątków.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • Właściwość IsBackground.The IsBackground property. Aby uzyskać więcej informacji, zobacz sekcję dotyczącą wątków pierwszego planu i tła .For more information, see the Foreground and background threads section.

Konstruktory

Thread(ParameterizedThreadStart)

Inicjuje nowe wystąpienie klasy Thread, określając delegata, który umożliwia przekazanie obiektu do wątku, gdy wątek zostanie uruchomiony.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)

Inicjuje nowe wystąpienie klasy Thread, określając delegata, który umożliwia przekazanie obiektu do wątku podczas uruchamiania wątku i określanie maksymalnego rozmiaru stosu dla wątku.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)

Inicjuje nowe wystąpienie klasy Thread.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32)

Inicjuje nowe wystąpienie klasy Thread, określając maksymalny rozmiar stosu dla wątku.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Właściwości

ApartmentState

Pobiera lub ustawia stan apartamentu tego wątku.Gets or sets the apartment state of this thread.

CurrentContext

Pobiera bieżący kontekst, w którym wykonywany jest wątek.Gets the current context in which the thread is executing.

CurrentCulture

Pobiera lub ustawia kulturę dla bieżącego wątku.Gets or sets the culture for the current thread.

CurrentPrincipal

Pobiera lub ustawia bieżący podmiot zabezpieczeń wątku (dla zabezpieczeń opartych na rolach).Gets or sets the thread's current principal (for role-based security).

CurrentThread

Pobiera aktualnie uruchomiony wątek.Gets the currently running thread.

CurrentUICulture

Pobiera lub ustawia bieżącą kulturę używaną przez Menedżer zasobów do wyszukiwania zasobów specyficznych dla kultury w czasie wykonywania.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext

Pobiera ExecutionContext obiektu, który zawiera informacje o różnych kontekstach bieżącego wątku.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive

Pobiera wartość wskazującą stan wykonywania bieżącego wątku.Gets a value indicating the execution status of the current thread.

IsBackground

Pobiera lub ustawia wartość wskazującą, czy wątek jest wątkiem w tle.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread

Pobiera wartość wskazującą, czy wątek należy do puli zarządzanych wątków.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId

Pobiera unikatowy identyfikator bieżącego wątku zarządzanego.Gets a unique identifier for the current managed thread.

Name

Pobiera lub ustawia nazwę wątku.Gets or sets the name of the thread.

Priority

Pobiera lub ustawia wartość wskazującą priorytet planowania wątku.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState

Pobiera wartość zawierającą Stany bieżącego wątku.Gets a value containing the states of the current thread.

Metody

Abort()

Wywołuje ThreadAbortException w wątku, w którym jest wywoływana, aby rozpocząć proces kończenia wątku.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. Wywołanie tej metody zwykle kończy działanie wątku.Calling this method usually terminates the thread.

Abort(Object)

Podnosi ThreadAbortException w wątku, w którym jest wywoływana, aby rozpocząć proces kończenia wątku, jednocześnie dostarczając informacje o wyjątku dotyczące zakończenia wątku.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. Wywołanie tej metody zwykle kończy działanie wątku.Calling this method usually terminates the thread.

AllocateDataSlot()

Przydziela nienazwane gniazdo danych we wszystkich wątkach.Allocates an unnamed data slot on all the threads. Aby uzyskać lepszą wydajność, zamiast tego użyj pól, które są oznaczone atrybutem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String)

Przydziela nazwane gniazdo danych we wszystkich wątkach.Allocates a named data slot on all threads. Aby uzyskać lepszą wydajność, zamiast tego użyj pól, które są oznaczone atrybutem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

BeginCriticalRegion()

Powiadamia hosta, że wykonanie polega na wprowadzeniu regionu kodu, w którym efekty przerwania wątku lub nieobsłużonego wyjątku mogą zagrozić innym zadaniom w domenie aplikacji.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()

Powiadamia hosta, że kod zarządzany ma wykonać instrukcje, które są zależne od tożsamości bieżącego fizycznego wątku systemu operacyjnego.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup()

Wyłącza automatyczne czyszczenie wywoływanych otok (RCW) środowiska uruchomieniowego dla bieżącego wątku.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current thread.

EndCriticalRegion()

Powiadamia hosta, że wykonanie polega na wprowadzeniu regionu kodu, w którym efekty przerwania wątku lub nieobsłużonego wyjątku są ograniczone do bieżącego zadania.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()

Powiadamia hosta, że kod zarządzany zakończył wykonywanie instrukcji, które są zależne od tożsamości bieżącego fizycznego wątku systemu operacyjnego.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zapewnia, że zasoby są zwolnione i inne operacje czyszczenia są wykonywane, gdy moduł zbierający elementy bezużyteczne odzyskuje Thread obiektu.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String)

Eliminuje skojarzenie między nazwą i miejscem, dla wszystkich wątków w procesie.Eliminates the association between a name and a slot, for all threads in the process. Aby uzyskać lepszą wydajność, zamiast tego użyj pól, które są oznaczone atrybutem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState()

Zwraca wartość ApartmentState wskazującą stan apartamentu.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack()

Zwraca obiekt CompressedStack, który może służyć do przechwytywania stosu dla bieżącego wątku.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId()

Pobiera identyfikator używany do wskazania procesora, który wykonuje bieżący wątek.Gets an ID used to indicate on which processor the current thread is executing.

GetData(LocalDataStoreSlot)

Pobiera wartość z określonego gniazda w bieżącym wątku w bieżącej domenie bieżącego wątku.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Aby uzyskać lepszą wydajność, zamiast tego użyj pól, które są oznaczone atrybutem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain()

Zwraca bieżącą domenę, w której jest uruchomiony bieżący wątek.Returns the current domain in which the current thread is running.

GetDomainID()

Zwraca unikatowy identyfikator domeny aplikacji.Returns a unique application domain identifier.

GetHashCode()

Zwraca kod skrótu dla bieżącego wątku.Returns a hash code for the current thread.

GetNamedDataSlot(String)

Wyszukuje nazwane gniazdo danych.Looks up a named data slot. Aby uzyskać lepszą wydajność, zamiast tego użyj pól, które są oznaczone atrybutem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
Interrupt()

Przerywa wątek, który znajduje się w stanie wątku WaitSleepJoin.Interrupts a thread that is in the WaitSleepJoin thread state.

Join()

Blokuje wątek wywołujący do momentu przerwania wątku reprezentowanego przez to wystąpienie, przy jednoczesnym kontynuowaniu wykonywania standardowej pompowania modelu COM i SendMessage.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

Join(Int32)

Blokuje wątek wywołujący do momentu przerwania wątku reprezentowanego przez to wystąpienie lub określonego czasu, przy jednoczesnym kontynuowaniu standardowej pompowania modelu COM i SendMessage.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)

Blokuje wątek wywołujący do momentu przerwania wątku reprezentowanego przez to wystąpienie lub określonego czasu, przy jednoczesnym kontynuowaniu standardowej pompowania modelu COM i SendMessage.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()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemoryBarrier()

Synchronizuje dostęp do pamięci w następujący sposób: procesor wykonujący bieżący wątek nie może zmienić kolejności instrukcji w taki sposób, że dostęp do pamięci przed wywołaniem MemoryBarrier() wykonać po uzyskaniu dostępu do pamięci, który następuje po wywołaniu MemoryBarrier().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()

Anuluje Abort(Object) żądany dla bieżącego wątku.Cancels an Abort(Object) requested for the current thread.

Resume()

Wznawia wątek, który został zawieszony.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState)

Ustawia stan apartamentu wątku przed jego uruchomieniem.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack)

Stosuje przechwycony CompressedStack do bieżącego wątku.Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object)

Ustawia dane w określonym gnieździe w aktualnie uruchomionym wątku dla bieżącej domeny tego wątku.Sets the data in the specified slot on the currently running thread, for that thread's current domain. W celu uzyskania lepszej wydajności należy zamiast tego użyć pól oznaczonych atrybutem ThreadStaticAttribute.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32)

Wstrzymuje bieżący wątek przez określoną liczbę milisekund.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan)

Wstrzymuje bieżący wątek przez określony czas.Suspends the current thread for the specified amount of time.

SpinWait(Int32)

Powoduje, że wątek oczekuje liczby razy zdefiniowanej przez parametr iterations.Causes a thread to wait the number of times defined by the iterations parameter.

Start()

Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na Running.Causes the operating system to change the state of the current instance to Running.

Start(Object)

Powoduje, że system operacyjny zmienia stan bieżącego wystąpienia na Runningi opcjonalnie dostarcza obiekt zawierający dane, które mają być używane przez ten wątek.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()

Zawiesza wątek lub jeśli wątek jest już wstrzymany, nie ma żadnego wpływu.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TrySetApartmentState(ApartmentState)

Ustawia stan apartamentu wątku przed jego uruchomieniem.Sets the apartment state of a thread before it is started.

VolatileRead(Byte)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Odczytuje wartość pola.Reads the value of a field. Wartość to Najnowsza wersja zapisywana przez dowolny procesor w komputerze, niezależnie od liczby procesorów lub stanu pamięci podręcznej procesora.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)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr)

Natychmiast zapisuje wartość w polu, tak aby wartość była widoczna dla wszystkich procesorów w komputerze.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield()

Powoduje, że wątek wywołujący przekazuje wykonywanie do innego wątku, który jest gotowy do uruchomienia na bieżącym procesorze.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. System operacyjny wybiera wątek do przeprowadzenia.The operating system selects the thread to yield to.

Jawne implementacje interfejsu

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

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.Maps a set of names to a corresponding set of dispatch identifiers.

_Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 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)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.Provides access to properties and methods exposed by an object.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też