Thread Classe

Definição

Cria e controla um thread, define sua prioridade e obtém seu status.Creates and controls a thread, sets its priority, and gets its status.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, System::Runtime::InteropServices::_Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
type Thread = class
    inherit CriticalFinalizerObject
    interface _Thread
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Implements _Thread
Herança
Atributos
Implementações

Exemplos

O exemplo a seguir demonstra a funcionalidade de Threading simples.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

Esse código produz uma saída semelhante à seguinte: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.  

Comentários

Quando um processo é iniciado, o Common Language Runtime cria automaticamente um único thread de primeiro plano para executar o código do aplicativo.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Junto com esse thread de primeiro plano principal, um processo pode criar um ou mais threads para executar uma parte do código do programa associado ao processo.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. Esses threads podem ser executados em primeiro plano ou em segundo plano.These threads can execute either in the foreground or in the background. Além disso, você pode usar a classe ThreadPool para executar código em threads de trabalho que são gerenciados pelo Common Language Runtime.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

Nesta seçãoIn this section

Iniciando um thread Starting a thread
Recuperando objetos de Thread Retrieving Thread objects
Threads em primeiro e segundoplano Foreground and background threads
Cultura e threads Culture and threads
Obtendo informações e controlando threadsGetting information about and controlling threads

Iniciando um threadStarting a thread

Você inicia um thread fornecendo um delegado que representa o método que o thread deve executar em seu construtor de classe.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. Em seguida, você chama o método Start para iniciar a execução.You then call the Start method to begin execution.

Os construtores Thread podem usar um dos dois tipos delegados, dependendo se você pode passar um argumento para o método a ser executado:The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Se o método não tiver argumentos, você passará um delegado ThreadStart para o construtor.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Ele tem a assinatura:It has the signature:

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

    O exemplo a seguir cria e inicia um thread que executa o método ExecuteInForeground.The following example creates and starts a thread that executes the ExecuteInForeground method. O método exibe informações sobre algumas propriedades de thread, em seguida, executa um loop no qual ele pausa por meio segundo e exibe o número decorrido de segundos.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. Quando o thread é executado por pelo menos cinco segundos, o loop termina e o thread encerra a execução.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
    
  • Se o método tiver um argumento, você passará um delegado ParameterizedThreadStart para o construtor.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Ele tem a assinatura:It has the signature:

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

    O método executado pelo delegado pode então converter (in C#) ou converter (em Visual Basic) o parâmetro para o tipo apropriado.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    O exemplo a seguir é idêntico ao anterior, exceto que ele chama o Construtor Thread(ParameterizedThreadStart).The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Esta versão do método ExecuteInForeground tem um único parâmetro que representa o número aproximado de milissegundos que o loop deve executar.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
    

Não é necessário manter uma referência a um objeto Thread depois de iniciar o thread.It is not necessary to retain a reference to a Thread object once you have started the thread. O thread continua a ser executado até que o procedimento de thread seja concluído.The thread continues to execute until the thread procedure is complete.

Recuperando objetos de threadRetrieving Thread objects

Você pode usar a propriedade estática (Shared em Visual Basic) CurrentThread para recuperar uma referência ao thread em execução no momento do código que o thread está executando.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. O exemplo a seguir usa a propriedade CurrentThread para exibir informações sobre o thread do aplicativo principal, outro thread de primeiro plano, um thread em segundo plano e um thread do pool de threads.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

Threads em primeiro e segundo planoForeground and background threads

As instâncias da classe Thread representam threads em primeiro plano ou threads em segundo plano.Instances of the Thread class represent either foreground threads or background threads. Threads em segundo plano são idênticos aos threads em primeiro plano com uma exceção: um thread em segundo plano não mantém um processo em execução se todos os threads de primeiro plano tiverem terminado.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. Depois que todos os threads de primeiro plano forem interrompidos, o tempo de execução interromperá todos os threads em segundo plano e será desligado.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Por padrão, os seguintes threads são executados em primeiro plano:By default, the following threads execute in the foreground:

  • O thread do aplicativo principal.The main application thread.

  • Todos os threads criados chamando um construtor de classe Thread.All threads created by calling a Thread class constructor.

Os seguintes threads são executados em segundo plano por padrão:The following threads execute in the background by default:

  • Threads do pool de threads, que são um pool de threads de trabalho mantidos pelo tempo de execução.Thread pool threads, which are a pool of worker threads maintained by the runtime. Você pode configurar o pool de threads e agendar o trabalho em threads do pool de threads usando a classe ThreadPool.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Observação

    As operações assíncronas baseadas em tarefas são executadas automaticamente em threads do pool de threads.Task-based asynchronous operations automatically execute on thread pool threads. As operações assíncronas baseadas em tarefas usam as classes Task e Task<TResult> para implementar o padrão assíncrono baseado em tarefas.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Todos os threads que entram no ambiente de execução gerenciado por meio de código não gerenciado.All threads that enter the managed execution environment from unmanaged code.

Você pode alterar um thread para ser executado em segundo plano definindo a propriedade IsBackground a qualquer momento.You can change a thread to execute in the background by setting the IsBackground property at any time. Os threads em segundo plano são úteis para qualquer operação que deve continuar desde que um aplicativo esteja em execução, mas não deve impedir que o aplicativo seja encerrado, como monitoramento de alterações do sistema de arquivos ou conexões de soquete de entrada.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.

O exemplo a seguir ilustra a diferença entre os threads de primeiro plano e de segundo plano.The following example illustrates the difference between foreground and background threads. É como o primeiro exemplo na seção iniciando um thread , exceto pelo fato de que ele define o thread a ser executado em segundo plano antes de iniciá-lo.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. Como mostra a saída, o loop é interrompido antes de ser executado por cinco segundos.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...

Cultura e threadsCulture and threads

Cada thread tem uma cultura, representada pela propriedade CurrentCulture, e uma cultura de interface do usuário, representada pela propriedade CurrentUICulture.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. A cultura atual dá suporte a operações sensíveis à cultura como análise e formatação, comparação e classificação de cadeia de caracteres e também controla o sistema de escrita e o calendário usado por um thread.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. A cultura da interface do usuário atual fornece a recuperação sensível à cultura de recursos em arquivos de recursos.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Importante

As propriedades CurrentCulture e CurrentUICulture não funcionam de maneira confiável quando usadas com qualquer thread diferente do thread atual.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. No .NET Framework, a leitura dessas propriedades é confiável, embora a definição dessas propriedades para um thread diferente do thread atual não seja.In .NET Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. No .NET Core, um InvalidOperationException será gerado se um thread tentar ler ou gravar essas propriedades em um thread diferente.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. Recomendamos que você use as propriedades CultureInfo.CurrentCulture e CultureInfo.CurrentUICulture para recuperar e definir a cultura atual.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

Quando um novo segmento é instanciado, sua cultura e cultura de interface do usuário são definidas pela cultura do sistema atual e cultura da interface do usuário, e não pela cultura e cultura da interface do usuário do thread do qual o novo thread é criado.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. Isso significa, por exemplo, que se a cultura atual do sistema for inglês (Estados Unidos) e a cultura atual do thread do aplicativo primário for francês (França), a cultura de um novo thread criado chamando o Construtor Thread(ParameterizedThreadStart) do thread primário será Inglês (Estados Unidos) e não francês (França).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). Para obter mais informações, consulte a seção "Culture and threads" do tópico CultureInfo Class.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Importante

Isso não é verdade para threads que executam operações assíncronas para aplicativos direcionados ao .NET Framework 4.6.NET Framework 4.6 e versões posteriores, nesse caso, a cultura e a cultura da interface do usuário fazem parte de um contexto de operações assíncronas; o thread no qual uma operação assíncrona é executada por padrão herda a cultura da cultura e da interface do usuário do thread do qual a operação assíncrona foi iniciada.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. Para saber mais, confira a seção "Cultura e operações assíncronas baseadas em tarefas" do tópico da classe CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

Você pode executar uma das ações a seguir para garantir que todos os threads em execução em um aplicativo compartilhem a mesma cultura e cultura de interface do usuário: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:

Para obter mais informações e exemplos, consulte a seção "Culture and threads" do tópico CultureInfo Class.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Obtendo informações e controlando threadsGetting information about and controlling threads

Você pode recuperar um número de valores de propriedade que fornecem informações sobre um thread.You can retrieve a number of property values that provide information about a thread. Em alguns casos, você também pode definir esses valores de propriedade para controlar a operação do thread.In some cases, you can also set these property values to control the operation of the thread. Essas propriedades de thread incluem:These thread properties include:

  • Um nome.A name. Name é uma propriedade Write-Once que você pode usar para identificar um thread.Name is a write-once property that you can use to identify a thread. Seu valor padrão é null.Its default value is null.

  • Um código hash, que pode ser recuperado chamando o método GetHashCode.A hash code, which you can retrieve by calling the GetHashCode method. O código hash pode ser usado para identificar exclusivamente um thread; para o tempo de vida do seu thread, seu código hash não colidirá com o valor de qualquer outro thread, independentemente do domínio do aplicativo do qual você obtém o valor.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.

  • Uma ID de thread.A thread ID. O valor da propriedade somente leitura ManagedThreadId é atribuído pelo tempo de execução e identifica exclusivamente um thread dentro de seu processo.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    Observação

    Um ThreadId do sistema operacional não tem relação fixa com um thread gerenciado porque hosts não gerenciados podem controlar a relação entre threads gerenciados e não gerenciados.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. Especificamente, um host sofisticado pode usar a API de hospedagem do CLR para agendar muitos threads gerenciados no mesmo thread do sistema operacional ou para mover um thread gerenciado entre diferentes threads do sistema operacional.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.

  • O estado atual do thread.The thread's current state. Durante a sua existência, um thread sempre está em um ou mais dos Estados definidos pela propriedade ThreadState.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Um nível de prioridade de agendamento, que é definido pela propriedade ThreadPriority.A scheduling priority level, which is defined by the ThreadPriority property. Embora você possa definir esse valor para solicitar a prioridade de um thread, não há garantia de que ele seja respeitado pelo sistema operacional.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • A propriedade somente leitura IsThreadPoolThread, que indica se um thread é um thread do pool de threads.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • A propriedade de IsBackground .The IsBackground property. Para obter mais informações, consulte a seção threads de primeiro e segundo plano .For more information, see the Foreground and background threads section.

Construtores

Thread(ParameterizedThreadStart)

Inicializa uma nova instância da classe Thread, especificando um delegado que permite que um objeto seja passado para o thread quando o thread for iniciado.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)

Inicializa uma nova instância da classe Thread, especificando um delegado que permite que um objeto seja passado para o thread quando o thread é iniciado e especificando o tamanho máximo da pilha para o thread.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)

Inicializa uma nova instância da classe Thread.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32)

Inicializa uma nova instância da classe Thread, especificando o tamanho máximo da pilha do thread.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Propriedades

ApartmentState

Obtém ou define o estado de apartment desse thread.Gets or sets the apartment state of this thread.

CurrentContext

Obtém o contexto atual no qual o thread está em execução.Gets the current context in which the thread is executing.

CurrentCulture

Obtém ou define a cultura do thread atual.Gets or sets the culture for the current thread.

CurrentPrincipal

Obtém ou define a entidade de segurança atual do thread (para segurança baseada em função).Gets or sets the thread's current principal (for role-based security).

CurrentThread

Obtém o thread em execução no momento.Gets the currently running thread.

CurrentUICulture

Obtém ou define a cultura atual usada pelo Gerenciador de Recursos para procurar recursos específicos da cultura em tempo de execução.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext

Obtém um objeto ExecutionContext que contém informações sobre os diversos contextos do thread atual.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive

Obtém um valor que indica o status de execução do thread atual.Gets a value indicating the execution status of the current thread.

IsBackground

Obtém ou define um valor que indica se um thread é ou não um thread de segundo plano.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread

Obtém um valor que indica se um thread pertence ao pool de threads gerenciados ou não.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId

Obtém um identificador exclusivo para o thread gerenciado atual.Gets a unique identifier for the current managed thread.

Name

Obtém ou define o nome do thread.Gets or sets the name of the thread.

Priority

Obtém ou define um valor que indica a prioridade de agendamento de um thread.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState

Obtém um valor que contém os estados do thread atual.Gets a value containing the states of the current thread.

Métodos

Abort()

Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de encerramento do thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. Geralmente, a chamada a esse método termina o thread.Calling this method usually terminates the thread.

Abort(Object)

Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de término do thread e ao mesmo tempo fornecer informações de exceção sobre o término do thread.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. Geralmente, a chamada a esse método termina o thread.Calling this method usually terminates the thread.

AllocateDataSlot()

Aloca um slot de dados sem nome em todos os threads.Allocates an unnamed data slot on all the threads. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String)

Aloca um slot de dados nomeado em todos os threads.Allocates a named data slot on all threads. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

BeginCriticalRegion()

Notifica um host que a execução está prestes a entrar em uma região de código em que os efeitos de uma exceção sem tratamento ou anulação de thread podem comprometer outras tarefas no domínio do aplicativo.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()

Notifica um host de que o código gerenciado está prestes a executar instruções que dependem da identidade do thread atual do sistema operacional físico.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup()

Desativa a limpeza automática de RCWs (Runtime Callable Wrappers) para o thread atual.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current thread.

EndCriticalRegion()

Notifica um host de que a execução está prestes a entrar em uma região de código na qual os efeitos de uma exceção sem tratamento ou anulação de thread estão limitados à tarefa atual.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()

Notifica um host que o código gerenciado terminou de executar as instruções que dependem da identidade do thread do sistema operacional físico atual.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
Finalize()

Garante que os recursos são liberados e outras operações de limpeza são executadas quando o coletor de lixo recupera o objeto Thread.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String)

Elimina a associação entre um nome e um slot em todos os threads do processo.Eliminates the association between a name and a slot, for all threads in the process. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState()

Retorna um valor ApartmentState que indica o estado do apartment.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack()

Retorna um objeto CompressedStack que pode ser usado para capturar a pilha do thread atual.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId()

Obtém uma ID usada para indicar em qual processador o thread atual está sendo executado.Gets an ID used to indicate on which processor the current thread is executing.

GetData(LocalDataStoreSlot)

Recupera o valor do slot especificado no thread atual, no domínio atual do thread atual.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain()

Retorna o domínio atual no qual o thread atual está em execução.Returns the current domain in which the current thread is running.

GetDomainID()

Retorna um identificador de domínio do aplicativo exclusivo.Returns a unique application domain identifier.

GetHashCode()

Retorna um código hash para o thread atual.Returns a hash code for the current thread.

GetNamedDataSlot(String)

Pesquisa um slot de dados nomeado.Looks up a named data slot. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
Interrupt()

Interrompe um thread que está no estado de thread WaitSleepJoin.Interrupts a thread that is in the WaitSleepJoin thread state.

Join()

Bloqueia o thread de chamada até que o thread representado por essa instância termine, enquanto continua a executar COM padrão e o bombeamento de SendMessage.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

Join(Int32)

Bloqueia o thread de chamada até que o thread representado por essa instância termine ou até que o tempo especificado tenha decorrido, enquanto continua executando o COM padrão e o bombeamento de 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)

Bloqueia o thread de chamada até que o thread representado por essa instância termine ou até que o tempo especificado tenha decorrido, enquanto continua executando o COM padrão e o bombeamento de 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()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
MemoryBarrier()

Sincroniza o acesso à memória da seguinte maneira: o processador que executa o thread atual não pode reorganizar as instruções de forma que os acessos à memória anteriores à chamada para MemoryBarrier() sejam executados depois dos acessos à memória posteriores à chamada para 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()

Cancela um Abort(Object) solicitado para o thread atual.Cancels an Abort(Object) requested for the current thread.

Resume()

Retoma um thread que foi suspenso.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState)

Define o estado do apartment de um thread antes que ele seja iniciado.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack)

Aplica uma CompressedStack capturada ao thread atual.Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object)

Define os dados no slot especificado no thread em execução no momento, para o domínio atual do thread.Sets the data in the specified slot on the currently running thread, for that thread's current domain. Para melhorar o desempenho, use os campos marcados com o atributo ThreadStaticAttribute.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32)

Suspende o thread atual no número especificado de milissegundos.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan)

Suspende o thread atual para o período de tempo especificado.Suspends the current thread for the specified amount of time.

SpinWait(Int32)

Faz com que um thread aguarde o número de vezes definido pelo parâmetro iterations.Causes a thread to wait the number of times defined by the iterations parameter.

Start()

Faz com que o sistema operacional altere o estado da instância atual para Running.Causes the operating system to change the state of the current instance to Running.

Start(Object)

Faz com que o sistema operacional altere o estado da instância atual para Running e, opcionalmente, fornece um objeto que contém dados a serem usados pelo método executado pelo thread.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()

Suspende o thread ou, se o thread já está suspenso, não tem efeito.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
TrySetApartmentState(ApartmentState)

Define o estado do apartment de um thread antes que ele seja iniciado.Sets the apartment state of a thread before it is started.

VolatileRead(Byte)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Lê o valor de um campo.Reads the value of a field. O valor é o último gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador.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)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr)

Grava um valor em um campo imediatamente, para que o valor esteja visível para todos os processadores no computador.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield()

Faz com que o thread de chamada conceda a execução para outro thread que está pronto para ser executado no processador atual.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. O sistema operacional seleciona o thread de recebimento.The operating system selects the thread to yield to.

Implantações explícitas de interface

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

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.Maps a set of names to a corresponding set of dispatch identifiers.

_Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 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)

Fornece acesso a propriedades e métodos expostos por um objeto.Provides access to properties and methods exposed by an object.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também