volatile (Referência de C#)
O volatile palavra-chave indica que um campo pode ser modificado por vários segmentos que estão em execução ao mesmo tempo. Os campos que são declarados volatile são não sujeitas a otimizações do compilador que assumem o acesso por um único thread. Isso garante que o valor mais atualizado está presente no campo em todos os momentos.
O volatile modificador geralmente é usado para um campo que é acessado por vários threads sem usar o lock instrução para serializar o acesso.
O volatile palavra-chave pode ser aplicado a campos desses tipos:
Tipos de referência.
Tipos de ponteiro (em um contexto sem segurança). Observe que embora o ponteiro em si pode ser volátil, o objeto ao qual ele aponta não pode. Em outras palavras, você não pode declarar um "ponteiro para volátil".
Tipos como, por exemplo, sbyte, byte, short, ushort, int, uint, char, float e bool.
Um tipo enum com um dos seguintes tipos de base: byte, sbyte, short, ushort, int ou uint.
Parâmetros de tipo genérico conhecidos como tipos de referência.
A palavra-chave volátil só pode ser aplicada aos campos de uma classe ou struct. Variáveis locais não podem ser declaradas volatile.
Exemplo
O exemplo a seguir mostra como declarar uma variavel como um campo público volatile.
class VolatileTest
{
public volatile int i;
public void Test(int _i)
{
i = _i;
}
}
O exemplo a seguir demonstra como um segmento auxiliar ou de trabalho pode ser criado e usado para executar o processamento em paralelo com o do segmento primário. Para obter informações detalhadas sobre consulte multithreading, Threading gerenciado e Threading (C# e Visual Basic).
using System;
using System.Threading;
public class Worker
{
// This method is called when the thread is started.
public void DoWork()
{
while (!_shouldStop)
{
Console.WriteLine("Worker thread: working...");
}
Console.WriteLine("Worker thread: terminating gracefully.");
}
public void RequestStop()
{
_shouldStop = true;
}
// Keyword volatile is used as a hint to the compiler that this data
// member is accessed by multiple threads.
private volatile bool _shouldStop;
}
public class WorkerThreadExample
{
static void Main()
{
// Create the worker thread object. This does not start the thread.
Worker workerObject = new Worker();
Thread workerThread = new Thread(workerObject.DoWork);
// Start the worker thread.
workerThread.Start();
Console.WriteLine("Main thread: starting worker thread...");
// Loop until the worker thread activates.
while (!workerThread.IsAlive) ;
// Put the main thread to sleep for 1 millisecond to
// allow the worker thread to do some work.
Thread.Sleep(1);
// Request that the worker thread stop itself.
workerObject.RequestStop();
// Use the Thread.Join method to block the current thread
// until the object's thread terminates.
workerThread.Join();
Console.WriteLine("Main thread: worker thread has terminated.");
}
// Sample output:
// Main thread: starting worker thread...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: terminating gracefully.
// Main thread: worker thread has terminated.
}
Especificação da linguagem C#
Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.
Consulte também
Referência
Modificadores (Referência de C#)