volátil (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 são declarados volatile não sujeita aos otimizações do compilador que pressupõem que o acesso por um único segmento. 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 segmentos sem usar o bloqueio a 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 que ela aponta para não. 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 variável do campo público como 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, Threads gerenciadas 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 C# Language Specification A especificação de linguagem é a fonte definitiva para a sintaxe e o uso de C#.