Thread Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.Thread.dll

Forrás:

Thread.cs

Létrehoz és vezérel egy szálat, beállítja a prioritást, és megkapja az állapotát.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject

public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject

type Thread = class
    inherit CriticalFinalizerObject

Public NotInheritable Class Thread
Inherits CriticalFinalizerObject

Öröklődés

Object

CriticalFinalizerObject

Thread

Példák

Az alábbi példa az egyszerű szálkezelést mutatja be.

using System;
using System.Threading;

// Simple threading scenario:  Start a static method running
// on a second thread.
public class ThreadExample {
    // The ThreadProc method is called when the thread starts.
    // It loops ten times, writing to the console and yielding
    // the rest of its time slice each time, and then ends.
    public static void ThreadProc() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("ThreadProc: {0}", i);
            // Yield the rest of the time slice.
            Thread.Sleep(0);
        }
    }

    public static void Main() {
        Console.WriteLine("Main thread: Start a second thread.");
        // The constructor for the Thread class requires a ThreadStart
        // delegate that represents the method to be executed on the
        // thread.  C# simplifies the creation of this delegate.
        Thread t = new Thread(new ThreadStart(ThreadProc));

        // Start ThreadProc.  Note that on a uniprocessor, the new
        // thread does not get any processor time until the main thread
        // is preempted or yields.  Uncomment the Thread.Sleep that
        // follows t.Start() to see the difference.
        t.Start();
        //Thread.Sleep(0);

        for (int i = 0; i < 4; i++) {
            Console.WriteLine("Main thread: Do some work.");
            Thread.Sleep(0);
        }

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
        t.Join();
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.");
        Console.ReadLine();
    }
}

open System.Threading

// Simple threading scenario:  Start a static method running
// on a second thread.

// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
let threadProc () =
    for i = 0 to 9 do
        printfn $"ThreadProc: {i}"
        // Yield the rest of the time slice.
        Thread.Sleep 0

printfn "Main thread: Start a second thread."
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. F# simplifies the creation of this delegate.
let t = Thread threadProc

// Start ThreadProc.  Note that on a uniprocessor, the new
// thread does not get any processor time until the main thread
// is preempted or yields.  Uncomment the Thread.Sleep that
// follows t.Start() to see the difference.
t.Start()
//Thread.Sleep 0

for _ = 0 to 3 do
    printfn "Main thread: Do some work."
    Thread.Sleep 0

printfn "Main thread: Call Join(), to wait until ThreadProc ends."
t.Join()
printfn "Main thread: ThreadProc.Join has returned.  Press Enter to end program."
stdin.ReadLine() |> ignore

Imports System.Threading

' Simple threading scenario:  Start a Shared method running
' on a second thread.
Public Class ThreadExample
    ' The ThreadProc method is called when the thread starts.
    ' It loops ten times, writing to the console and yielding 
    ' the rest of its time slice each time, and then ends.
    Public Shared Sub ThreadProc()
        Dim i As Integer
        For i = 0 To 9
            Console.WriteLine("ThreadProc: {0}", i)
            ' Yield the rest of the time slice.
            Thread.Sleep(0)
        Next
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Main thread: Start a second thread.")
        ' The constructor for the Thread class requires a ThreadStart 
        ' delegate.  The Visual Basic AddressOf operator creates this
        ' delegate for you.
        Dim t As New Thread(AddressOf ThreadProc)

        ' Start ThreadProc.  Note that on a uniprocessor, the new 
        ' thread does not get any processor time until the main thread 
        ' is preempted or yields.  Uncomment the Thread.Sleep that 
        ' follows t.Start() to see the difference.
        t.Start()
        'Thread.Sleep(0)

        Dim i As Integer
        For i = 1 To 4
            Console.WriteLine("Main thread: Do some work.")
            Thread.Sleep(0)
        Next

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
        t.Join()
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.")
        Console.ReadLine()
    End Sub
End Class

Ez a kód a következőhöz hasonló kimenetet hoz létre:

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

Megjegyzések

Az Thread osztály létrehoz és vezérel egy szálat, beállítja annak prioritását, és megkapja az állapotát.

Amikor egy folyamat elindul, a közös nyelvi futtatókörnyezet automatikusan létrehoz egy előtérszálat az alkalmazáskód végrehajtásához. Ezzel a fő előtérszállal együtt egy folyamat létrehozhat egy vagy több szálat a folyamathoz társított programkód egy részének végrehajtásához. Ezek a szálak az előtérben vagy a háttérben is végrehajthatók. Emellett az ThreadPool osztály használatával kódot hajthat végre a közös nyelvi futtatókörnyezet által felügyelt munkavégző szálakon.

Szál indítása

Egy szál elindításához adjon meg egy meghatalmazottat, amely azt a metódust jelöli, amelyet a szál az osztálykonstruktorban hajt végre. Ezután meghívja a metódust a Start végrehajtás megkezdéséhez.

A Thread konstruktorok két delegálttípus egyikét is használhatják attól függően, hogy átadhat-e argumentumot a végrehajtandó metódusnak:

• Ha a metódus nem rendelkezik argumentumokkal, egy meghatalmazottat ThreadStart ad át a konstruktornak. Megvan az aláírás:

  public delegate void ThreadStart()
  

  Public Delegate Sub ThreadStart()
  

  Az alábbi példa létrehoz és elindít egy szálat, amely végrehajtja a metódust ExecuteInForeground . A metódus információkat jelenít meg néhány száltulajdonságról, majd végrehajt egy ciklust, amelyben fél másodpercig szünetel, és megjeleníti az eltelt másodpercek számát. Ha a szál legalább öt másodpercen át fut, a hurok véget ér, és a szál leállítja a végrehajtást.

  using System;
  using System.Diagnostics;
  using System.Threading;
  
  public class Example
  {
     public static void Main()
     {
        var th = new Thread(ExecuteInForeground);
        th.Start();
        Thread.Sleep(1000);
        Console.WriteLine("Main thread ({0}) exiting...",
                          Thread.CurrentThread.ManagedThreadId);
     }
  
     private static void ExecuteInForeground()
     {
        var sw = Stopwatch.StartNew();
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority);
        do {
           Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000.0);
           Thread.Sleep(500);
        } while (sw.ElapsedMilliseconds <= 5000);
        sw.Stop();
     }
  }
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.51 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.02 seconds
  //       Thread 3: Elapsed 1.53 seconds
  //       Thread 3: Elapsed 2.05 seconds
  //       Thread 3: Elapsed 2.55 seconds
  //       Thread 3: Elapsed 3.07 seconds
  //       Thread 3: Elapsed 3.57 seconds
  //       Thread 3: Elapsed 4.07 seconds
  //       Thread 3: Elapsed 4.58 seconds
  

  open System.Diagnostics
  open System.Threading
  
  let executeInForeground () =
      let sw = Stopwatch.StartNew()
  
      printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
  
      while sw.ElapsedMilliseconds <= 5000 do
          printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
          Thread.Sleep 500
  
      sw.Stop()
  
  let th = Thread executeInForeground
  th.Start()
  Thread.Sleep 1000
  printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
  
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.51 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.02 seconds
  //       Thread 3: Elapsed 1.53 seconds
  //       Thread 3: Elapsed 2.05 seconds
  //       Thread 3: Elapsed 2.55 seconds
  //       Thread 3: Elapsed 3.07 seconds
  //       Thread 3: Elapsed 3.57 seconds
  //       Thread 3: Elapsed 4.07 seconds
  //       Thread 3: Elapsed 4.58 seconds
  

  Imports System.Diagnostics
  Imports System.Threading
  
  Module Example3
      Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start()
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
      End Sub
  
      Private Sub ExecuteInForeground()
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority)
          Do
              Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000)
              Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= 5000
          sw.Stop()
      End Sub
  End Module
  ' The example displays output like the following:
  '       Thread 3: Running, Priority Normal
  '       Thread 3: Elapsed 0.00 seconds
  '       Thread 3: Elapsed 0.51 seconds
  '       Main thread (1) exiting...
  '       Thread 3: Elapsed 1.02 seconds
  '       Thread 3: Elapsed 1.53 seconds
  '       Thread 3: Elapsed 2.05 seconds
  '       Thread 3: Elapsed 2.55 seconds
  '       Thread 3: Elapsed 3.07 seconds
  '       Thread 3: Elapsed 3.57 seconds
  '       Thread 3: Elapsed 4.07 seconds
  '       Thread 3: Elapsed 4.58 seconds
  

• Ha a metódus argumentumot használ, egy delegáltat ParameterizedThreadStart ad át a konstruktornak. Megvan az aláírás:

  public delegate void ParameterizedThreadStart(object obj)
  

  Public Delegate Sub ParameterizedThreadStart(obj As Object)
  

  A meghatalmazott által végrehajtott metódus ezután leadhatja (C#-ban) vagy átalakíthatja (a Visual Basicben) a paramétert a megfelelő típusra.

  Az alábbi példa megegyezik az előző példával, azzal a kivételel, hogy meghívja a konstruktort Thread(ParameterizedThreadStart) . A metódus ezen verziója ExecuteInForeground egyetlen paraméterrel rendelkezik, amely a ciklus végrehajtásának körülbelül ennyi ezredmásodpercét jelöli.

  using System;
  using System.Diagnostics;
  using System.Threading;
  
  public class Example
  {
     public static void Main()
     {
        var th = new Thread(ExecuteInForeground);
        th.Start(4500);
        Thread.Sleep(1000);
        Console.WriteLine("Main thread ({0}) exiting...",
                          Thread.CurrentThread.ManagedThreadId);
     }
  
     private static void ExecuteInForeground(Object obj)
     {
        int interval;
        try {
           interval = (int) obj;
        }
        catch (InvalidCastException) {
           interval = 5000;
        }
        var sw = Stopwatch.StartNew();
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority);
        do {
           Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000.0);
           Thread.Sleep(500);
        } while (sw.ElapsedMilliseconds <= interval);
        sw.Stop();
     }
  }
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.52 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.03 seconds
  //       Thread 3: Elapsed 1.55 seconds
  //       Thread 3: Elapsed 2.06 seconds
  //       Thread 3: Elapsed 2.58 seconds
  //       Thread 3: Elapsed 3.09 seconds
  //       Thread 3: Elapsed 3.61 seconds
  //       Thread 3: Elapsed 4.12 seconds
  

  open System
  open System.Diagnostics
  open System.Threading
  
  let executeInForeground obj =
      let interval =
          try
              unbox<int> obj
          with :? InvalidCastException ->
              5000
  
      let sw = Stopwatch.StartNew()
  
      printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
  
      while sw.ElapsedMilliseconds <= interval do
          printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
          Thread.Sleep 500
  
      sw.Stop()
  
  let th = Thread(ParameterizedThreadStart executeInForeground)
  th.Start 4500
  Thread.Sleep 1000
  printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
  
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.52 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.03 seconds
  //       Thread 3: Elapsed 1.55 seconds
  //       Thread 3: Elapsed 2.06 seconds
  //       Thread 3: Elapsed 2.58 seconds
  //       Thread 3: Elapsed 3.09 seconds
  //       Thread 3: Elapsed 3.61 seconds
  //       Thread 3: Elapsed 4.12 seconds
  

  Imports System.Diagnostics
  Imports System.Threading
  
  Module Example4
      Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start(4500)
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
      End Sub
  
      Private Sub ExecuteInForeground(obj As Object)
          Dim interval As Integer
          If IsNumeric(obj) Then
              interval = CInt(obj)
          Else
              interval = 5000
          End If
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority)
          Do
              Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000)
              Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= interval
          sw.Stop()
      End Sub
  End Module
  ' The example displays output like the following:
  '       Thread 3: Running, Priority Normal
  '       Thread 3: Elapsed 0.00 seconds
  '       Thread 3: Elapsed 0.52 seconds
  '       Main thread (1) exiting...
  '       Thread 3: Elapsed 1.03 seconds
  '       Thread 3: Elapsed 1.55 seconds
  '       Thread 3: Elapsed 2.06 seconds
  '       Thread 3: Elapsed 2.58 seconds
  '       Thread 3: Elapsed 3.09 seconds
  '       Thread 3: Elapsed 3.61 seconds
  '       Thread 3: Elapsed 4.12 seconds
  

A szál elindítása után nem szükséges megőrizni egy objektumra Thread mutató hivatkozást. A szál végrehajtása a szál eljárásának befejezéséig folytatódik.

Szálobjektumok lekérése

A statikus (Shared Visual Basic) CurrentThread tulajdonság használatával lekérheti az aktuálisan végrehajtó szálra mutató hivatkozást a szál által futtatott kódból. Az alábbi példa a CurrentThread tulajdonság használatával jeleníti meg a fő alkalmazásszálra, egy másik előtérszálra, egy háttérszálra és egy szálkészlet-szálra vonatkozó információkat.

using System;
using System.Threading;

public class Example
{
   static Object obj = new Object();
   
   public static void Main()
   {
      ThreadPool.QueueUserWorkItem(ShowThreadInformation);
      var th1 = new Thread(ShowThreadInformation);
      th1.Start();
      var th2 = new Thread(ShowThreadInformation);
      th2.IsBackground = true;
      th2.Start();
      Thread.Sleep(500);
      ShowThreadInformation(null); 
   }
   
   private static void ShowThreadInformation(Object state)
   {
      lock (obj) {
         var th  = Thread.CurrentThread;
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId);
         Console.WriteLine("   Background thread: {0}", th.IsBackground);
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread);
         Console.WriteLine("   Priority: {0}", th.Priority);
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name);
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US

open System.Threading

let obj = obj ()

let showThreadInformation (state: obj) =
    lock obj (fun () ->
        let th = Thread.CurrentThread
        printfn $"Managed thread #{th.ManagedThreadId}: "
        printfn $"   Background thread: {th.IsBackground}"
        printfn $"   Thread pool thread: {th.IsThreadPoolThread}"
        printfn $"   Priority: {th.Priority}"
        printfn $"   Culture: {th.CurrentCulture.Name}"
        printfn $"   UI culture: {th.CurrentUICulture.Name}"
        printfn "")

ThreadPool.QueueUserWorkItem showThreadInformation |> ignore
let th1 = Thread(ParameterizedThreadStart showThreadInformation)
th1.Start()
let th2 = Thread(ParameterizedThreadStart showThreadInformation)
th2.IsBackground <- true
th2.Start()
Thread.Sleep 500
showThreadInformation ()

// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US

Imports System.Threading

Module Example2
    Private lock As New Object()

    Public Sub Main()
        ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
        Dim th1 As New Thread(AddressOf ShowThreadInformation)
        th1.Start()
        Dim th2 As New Thread(AddressOf ShowThreadInformation)
        th2.IsBackground = True
        th2.Start()
        Thread.Sleep(500)
        ShowThreadInformation(Nothing)
    End Sub

    Private Sub ShowThreadInformation(state As Object)
        SyncLock lock
            Dim th As Thread = Thread.CurrentThread
            Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
            Console.WriteLine("   Background thread: {0}", th.IsBackground)
            Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread)
            Console.WriteLine("   Priority: {0}", th.Priority)
            Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name)
            Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name)
            Console.WriteLine()
        End SyncLock
    End Sub
End Module
' The example displays output like the following:
'       ' Managed thread #6:
'          Background thread: True
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #3:
'          Background thread: True
'          Thread pool thread: True
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #4:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #1:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US

Előtér- és háttérszálak

A Thread osztály példányai lehetnek előtérszálak vagy háttérszálak. A háttérszálak egyetlen kivétellel megegyeznek az előtérszálakkal: a háttérszálak nem futtatják a folyamatot, ha az összes előtérszál leállt. Miután az összes előtérszál le lett állítva, a futtatókörnyezet leállítja az összes háttérszálat, és leáll.

Alapértelmezés szerint a következő szálak futnak az előtérben:

• A fő alkalmazásszál.

• Az Thread osztálykonstruktor meghívásával létrehozott szálak összessége.

Alapértelmezés szerint a következő szálak futnak a háttérben:

• A szálkészlet szálai, amelyek a futtatókörnyezet által karbantartott munkaszálak készletéből származnak. Az osztály használatával konfigurálhatja a szálkészletet, és ütemezheti a ThreadPool szálkészlet-szálakon végzett munkát.

  Note

  A feladat-alapú aszinkron műveletek automatikusan futnak a szálkészlet szálain. A feladatalapú aszinkron műveletek a Task és Task<TResult> osztályok használatával implementálják a feladatalapú aszinkron mintát.

• Minden szál, amely belép a felügyelt végrehajtási környezetbe a nem felügyelt kódból.

A háttérben futó szálat bármikor módosíthatja a IsBackground tulajdonság beállításával. A háttérszálak hasznosak minden olyan művelethez, amely addig folytatódik, amíg egy alkalmazás fut, de nem akadályozhatja meg az alkalmazás leállását, például a fájlrendszer változásainak monitorozását vagy a bejövő szoftvercsatornák kapcsolatait.

Az alábbi példa az előtér- és háttérszálak közötti különbséget szemlélteti. Ez olyan, mint a Szál indítása szakasz első példája, azzal a különbséggel, hogy a szálat az indulás előtt a háttérben hajtja végre. Ahogy a kimenet is mutatja, a ciklus öt másodpercig megszakad, mielőtt végrehajtanák.

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

public class Example
{
   public static void Main()
   {
      var th = new Thread(ExecuteInForeground);
      th.IsBackground = true;
      th.Start();
      Thread.Sleep(1000);
      Console.WriteLine("Main thread ({0}) exiting...",
                        Thread.CurrentThread.ManagedThreadId);
   }

   private static void ExecuteInForeground()
   {
      var sw = Stopwatch.StartNew();
      Console.WriteLine("Thread {0}: {1}, Priority {2}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority);
      do {
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         Thread.Sleep(500);
      } while (sw.ElapsedMilliseconds <= 5000);
      sw.Stop();
   }
}
// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...

open System.Diagnostics
open System.Threading

let executeInForeground () =
    let sw = Stopwatch.StartNew()
    printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
    while sw.ElapsedMilliseconds <= 5000 do
        printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
        Thread.Sleep 500
    sw.Stop()

let th = Thread executeInForeground
th.IsBackground <- true
th.Start()
Thread.Sleep 1000
printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."

// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...

Imports System.Diagnostics
Imports System.Threading

Module Example1
    Public Sub Main()
        Dim th As New Thread(AddressOf ExecuteInForeground)
        th.IsBackground = True
        th.Start()
        Thread.Sleep(1000)
        Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
    End Sub

    Private Sub ExecuteInForeground()
        Dim start As DateTime = DateTime.Now
        Dim sw As Stopwatch = Stopwatch.StartNew()
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority)
        Do
            Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000)
            Thread.Sleep(500)
        Loop While sw.ElapsedMilliseconds <= 5000
        sw.Stop()
    End Sub
End Module
' The example displays output like the following:
'       Thread 3: Background, Priority Normal
'       Thread 3: Elapsed 0.00 seconds
'       Thread 3: Elapsed 0.51 seconds
'       Main thread (1) exiting...

Kultúra és szálak

Minden szál rendelkezik egy kultúrával, amelyet a CurrentCulture tulajdonság képvisel, és egy felhasználói felületi kultúrával, amelyet a CurrentUICulture tulajdonság képvisel. A jelenlegi kultúra támogatja a kultúraspecifikus műveleteket, például az elemzést és a formázást, a szövegösszehasonlítást és a rendezést, valamint szabályozza az írásrendszert és a naptárt, amit a szál használ. A jelenlegi felhasználói felületi kultúra az erőforrásfájlokban lévő erőforrások kulturális szempontból érzékeny lekérését teszi lehetővé.

Important

A CurrentCulture tulajdonságok és CurrentUICulture a tulajdonságok nem működnek megbízhatóan, ha az aktuális száltól eltérő szálakkal használják. A InvalidOperationException rendszer akkor jelenik meg, ha egy szál megkísérli olvasni vagy írni ezeket a tulajdonságokat egy másik szálon. Javasoljuk, hogy a CultureInfo.CurrentCulture és CultureInfo.CurrentUICulture tulajdonságokat használja a jelenlegi kultúra lekéréséhez és beállításához.

Az új szál példányosításakor annak kultúráját és felhasználói felületi kultúráját a jelenlegi rendszerkultúra és felhasználói felületi kultúra határozza meg, nem pedig annak a szálnak a kulturális és felhasználói felületi kultúrája, amelyből az új szál létrejön. Ez azt jelenti például, hogy ha a jelenlegi rendszerkultúra angol (Egyesült Államok), és az elsődleges alkalmazásszál jelenlegi kultúrája a francia (Franciaország), akkor az elsődleges szál konstruktorának meghívásával Thread(ParameterizedThreadStart) létrehozott új szál kultúrája az angol (Egyesült Államok), nem pedig a francia (Franciaország). További információt az osztálytéma "Kultúra és szálak" című szakaszában CultureInfo talál.

Important

Ez nem igaz azokra a szálakra, amelyek aszinkron műveleteket hajtanak végre a .NET-keretrendszer 4.6-os és újabb verzióit célzó alkalmazásokhoz. Ebben az esetben a kultúra és a felhasználói felület kultúrája egy aszinkron művelet kontextusának része; Az a szál, amelyen alapértelmezés szerint egy aszinkron művelet fut, örökli annak a szálnak a kulturális és felhasználói felületi kultúráját, amelyből az aszinkron műveletet elindították. További információt az osztály megjegyzéseinek "Kultúra és feladatalapú aszinkron műveletek" című szakaszában CultureInfo talál.

Az alábbiak egyikével biztosíthatja, hogy az alkalmazásban végrehajtó összes szál azonos kultúrával és felhasználói felületi kultúrával rendelkezzen:

• Az adott kultúrát CultureInfo képviselő objektumot átadhatja a ParameterizedThreadStart meghatalmazottnak vagy a metódusnak ThreadPool.QueueUserWorkItem(WaitCallback, Object) .

• A .NET-keretrendszer 4.5-ös és újabb verzióiban futó alkalmazások esetében az alkalmazástartományban létrehozott összes szálhoz hozzárendelendő kulturális és felhasználói felületi kultúrát a tulajdonságok és CultureInfo.DefaultThreadCurrentCulture a CultureInfo.DefaultThreadCurrentUICulture tulajdonságok értékének beállításával határozhatja meg. Vegye figyelembe, hogy ez egy alkalmazásonkénti tartománybeállítás.

További információkért és példákért tekintse meg az osztály megjegyzéseinek "Kultúra és szálak" szakaszát CultureInfo .

Információk lekérése és a szálak szabályozása

Számos tulajdonságértéket lekérhet, amelyek információt nyújtanak egy szálról. Bizonyos esetekben ezeket a tulajdonságértékeket is beállíthatja a szál működésének szabályozásához. Ezek a száltulajdonságok a következők:

• Egy név. Name egy egyszer írható tulajdonság, amellyel azonosíthatja a szálat. Az alapértelmezett érték a .null

• Kivonatkód, amelyet a GetHashCode metódus meghívásával lekérhet. A kivonatkód egy szál egyedi azonosítására használható; a szál élettartama alatt a kivonatkód nem ütközik más szál értékével, függetlenül attól, hogy melyik alkalmazástartományból szerzi be az értéket.

• Szálazonosító. Az írásvédett ManagedThreadId tulajdonság értékét a futtatókörnyezet rendeli hozzá, és egyedileg azonosít egy szálat a folyamaton belül.

  Note

  Az operációs rendszer threadId-jének nincs rögzített kapcsolata egy felügyelt szálhoz, mert egy nem felügyelt gazdagép szabályozhatja a felügyelt és a nem felügyelt szálak közötti kapcsolatot. A kifinomult gazdagép a CLR Hosting API használatával ütemezhet több felügyelt szálat ugyanazon operációs rendszer szálán, vagy áthelyezhet egy felügyelt szálat különböző operációs rendszer szálak között.

• A szál aktuális állapota. A szál a létezésének időtartama alatt mindig a tulajdonság által ThreadState meghatározott egy vagy több állapotban van.

• A tulajdonság által meghatározott ütemezési prioritási ThreadPriority szint. Bár ezt az értéket beállíthatja egy szál prioritásának lekérésére, az operációs rendszer nem garantáltan betartja azt.

• Az írásvédett IsThreadPoolThread tulajdonság, amely azt jelzi, hogy egy szál a szálkészletben van-e.

• A IsBackground tulajdonság. További információkért tekintse meg az Előtér és a háttérszálak szakaszt .

Konstruktorok

Name	Description
Thread(ParameterizedThreadStart, Int32)	Inicializálja az Thread osztály új példányát, megadva egy delegáltat, amely lehetővé teszi, hogy egy objektum átadható legyen a szálnak a szál indításakor, és megadja a szál maximális veremméretét.
Thread(ParameterizedThreadStart)	Inicializálja az Thread osztály új példányát, megadva egy delegáltat, amely lehetővé teszi, hogy egy objektumot a szál indításakor átadjon a szálnak.
Thread(ThreadStart, Int32)	Inicializálja az Thread osztály új példányát, megadva a szál maximális veremméretét.
Thread(ThreadStart)	Inicializálja a Thread osztály új példányát.

Tulajdonságok

Name	Description
ApartmentState	Elavult. Lekéri vagy beállítja ennek a szálnak a lakásállapotát.
CurrentCulture	Lekéri vagy beállítja az aktuális szál kultúráját.
CurrentPrincipal	Lekéri vagy beállítja a szál aktuális tagját (a szerepköralapú biztonság érdekében).
CurrentThread	Lekéri az éppen futó szálat.
CurrentUICulture	Lekéri vagy beállítja a Resource Manager által használt jelenlegi kultúrát, hogy futásidőben kultúrkultúra-specifikus erőforrásokat keressen.
ExecutionContext	ExecutionContext Lekéri az aktuális szál különböző környezeteiről szóló információkat tartalmazó objektumot.
IsAlive	Lekéri az aktuális szál végrehajtási állapotát jelző értéket.
IsBackground	Lekéri vagy beállít egy értéket, amely jelzi, hogy egy szál háttérszál-e.
IsThreadPoolThread	Beolvas egy értéket, amely jelzi, hogy egy szál a felügyelt szálkészlethez tartozik-e.
ManagedThreadId	Az aktuális felügyelt szál egyedi azonosítójának lekérdezése.
Name	Lekéri vagy beállítja a szál nevét.
Priority	Lekéri vagy beállítja a szál ütemezési prioritását jelző értéket.
ThreadState	Lekéri az aktuális szál állapotát tartalmazó értéket.

Metódusok

Name	Description
Abort()	Elavult. Felvesz egy ThreadAbortException olyan szálat, amelyre meghívják, hogy megkezdje a szál megszüntetésének folyamatát. A metódus meghívása általában megszakítja a szálat.
Abort(Object)	Elavult. Elindít egy ThreadAbortException olyan szálat, amelyre meghívják, hogy megkezdje a szál megszüntetésének folyamatát, miközben kivételadatokat is ad a szálvégzítésről. A metódus meghívása általában megszakítja a szálat.
AllocateDataSlot()	Egy névtelen adathelyet foglal le az összes szálon. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
AllocateNamedDataSlot(String)	Egy elnevezett adathelyet foglal le az összes szálon. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
BeginCriticalRegion()	Értesíti a gazdagépet, hogy a végrehajtás olyan kódterületet fog megadni, amelyben a szál megszakadása vagy a kezeletlen kivétel hatásai veszélyeztethetik az alkalmazástartomány egyéb feladatait.
BeginThreadAffinity()	Értesíti a gazdagépet, hogy a felügyelt kód az aktuális fizikai operációs rendszer szálának identitásától függő utasításokat hajt végre.
DisableComObjectEagerCleanup()	Kikapcsolja az aktuális szál futásidejű hívható burkolóinak (RCW) automatikus törlését.
EndCriticalRegion()	Értesíti a gazdagépet, hogy a végrehajtás olyan kódterületet ír be, amelyben a szál megszakítása vagy a kezeletlen kivétel hatása az aktuális tevékenységre korlátozódik.
EndThreadAffinity()	Értesíti a gazdagépet, hogy a felügyelt kód befejezte az aktuális fizikai operációs rendszer szál identitásától függő utasítások végrehajtását.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Finalize()	Biztosítja, hogy az erőforrások felszabadítva legyenek, és más tisztítási műveletek is végrehajtva legyenek, amikor a szemétgyűjtő visszanyeri az Thread objektumot.
FreeNamedDataSlot(String)	Megszünteti a név és a pont közötti társításokat a folyamat összes szálához. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
GetApartmentState()	ApartmentState A lakás állapotát jelző értéket ad vissza.
GetCompressedStack()	Elavult. Egy objektumot ad CompressedStack vissza, amely az aktuális szál veremének rögzítésére használható.
GetCurrentProcessorId()	Lekéri az aktuális szálat végrehajtó processzor azonosítóját.
GetData(LocalDataStoreSlot)	Lekéri az értéket az aktuális szál megadott pontjáról az aktuális szál aktuális tartományán belül. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
GetDomain()	Azt az aktuális tartományt adja vissza, amelyben az aktuális szál fut.
GetDomainID()	Egyedi alkalmazástartomány-azonosítót ad vissza.
GetHashCode()	Az aktuális szál kivonatkódját adja vissza.
GetNamedDataSlot(String)	Névvel ellátott adathelyet keres. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
Interrupt()	Megszakítja a szál állapotában lévő WaitSleepJoin szálakat.
Join()	Blokkolja a hívó szálat, amíg a példány által képviselt szál le nem áll, miközben továbbra is szabványos COM-t és SendMessage szivattyúzást végez.
Join(Int32)	Blokkolja a hívó szálat, amíg a példány által képviselt szál le nem áll, vagy a megadott idő el nem telik, miközben folytatja a szabványos COM- és SendMessage-szivattyúzást.
Join(TimeSpan)	Blokkolja a hívó szálat, amíg a példány által képviselt szál le nem áll, vagy a megadott idő el nem telik, miközben folytatja a szabványos COM- és SendMessage-szivattyúzást.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemoryBarrier()	A következő módon szinkronizálja a memóriahozzáférést: Az aktuális szálat végrehajtó processzor nem tudja úgy átrendezni az utasításokat, hogy a memória a hívás előtt hozzáférhessen MemoryBarrier() a híváshoz, miután a hívást követő memóriahozzáférések következnek MemoryBarrier().
ResetAbort()	Elavult. Megszakítja az Abort(Object) aktuális szálhoz kért kérést.
Resume()	Elavult. Folytatja a felfüggesztett szálat.
SetApartmentState(ApartmentState)	Beállítja egy szál lakásállapotát a kezdés előtt.
SetCompressedStack(CompressedStack)	Elavult. Rögzítettet CompressedStack alkalmaz az aktuális szálra.
SetData(LocalDataStoreSlot, Object)	Beállítja az aktuálisan futó szál megadott pontjában lévő adatokat a szál aktuális tartományához. A jobb teljesítmény érdekében használjon inkább az ThreadStaticAttribute attribútummal megjelölt mezőket.
Sleep(Int32)	Felfüggeszti az aktuális szálat a megadott számú ezredmásodperchez.
Sleep(TimeSpan)	Felfüggeszti az aktuális szálat a megadott ideig.
SpinWait(Int32)	A szál a paraméter által meghatározott hányszor várakozik iterations .
Start()	Az operációs rendszer az aktuális példány állapotát a következőre Runningmódosítja: .
Start(Object)	Az operációs rendszer az aktuális példány Runningállapotát a következőre módosítja, és opcionálisan egy olyan objektumot biztosít, amely a szál által végrehajtott metódus által használandó adatokat tartalmazza.
Suspend()	Elavult. Vagy felfüggeszti a szálat, vagy ha a szál már fel van függesztve, nincs hatása.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
TrySetApartmentState(ApartmentState)	Beállítja egy szál lakásállapotát a kezdés előtt.
UnsafeStart()	Az operációs rendszer az aktuális példány állapotát a következőre Runningmódosítja: .
UnsafeStart(Object)	Az operációs rendszer az aktuális példány Runningállapotát a következőre módosítja, és opcionálisan egy olyan objektumot biztosít, amely a szál által végrehajtott metódus által használandó adatokat tartalmazza.
VolatileRead(Byte)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Double)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Int16)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Int32)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Int64)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(IntPtr)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Object)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(SByte)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(Single)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(UInt16)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(UInt32)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(UInt64)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileRead(UIntPtr)	Elavult. Beolvassa egy mező értékét. Olyan rendszereken, amelyek megkövetelik, beszúr egy memóriakorlátot, amely megakadályozza, hogy a processzor átrendezze a memóriaműveleteket a következőképpen: Ha a metódus után olvasás vagy írás jelenik meg a kódban, a processzor nem tudja áthelyezni a metódus előtt.
VolatileWrite(Byte, Byte)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Double, Double)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Int16, Int16)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Int32, Int32)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Int64, Int64)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(IntPtr, IntPtr)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Object, Object)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(SByte, SByte)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(Single, Single)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(UInt16, UInt16)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(UInt32, UInt32)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(UInt64, UInt64)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
VolatileWrite(UIntPtr, UIntPtr)	Elavult. Értéket ír egy mezőbe. Az azt igénylő rendszereken szúrjon be egy memóriakorlátot, amely megakadályozza, hogy a processzor a következőképpen rendezze át a memóriaműveleteket: Ha olvasás vagy írás jelenik meg a metódus előtt a kódban, a processzor nem tudja áthelyezni a metódus után.
Yield()	A hívószál egy másik, az aktuális processzoron való futtatásra kész szál végrehajtását eredményezi. Az operációs rendszer kiválasztja a kívánt szálat.

Szálbiztonság

Ez a típus szálbiztos.

Lásd még

• Szálak és szálkezelés
• Szálak és szálkezelés használata
• A szálosztály referenciaforrása