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

• IntPtr e UIntPtr.

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, 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 Especificação de linguagem do C# A especificação da linguagem é a fonte definitiva para a sintaxe e o uso da linguagem C#.

Consulte também

Referência

Palavras-chave C#

Modificadores (referência de C#)

Conceitos

Guia de programação do C#

Outros recursos

Referência de C#