volatile (odwołanie w C#)

volatile Słowa kluczowego wskazuje, że pola może zostać zmodyfikowany przez wiele wątków, które są wykonywane w tym samym czasie.Pola, które są uznane za volatile są przedmiotem optymalizacje kompilatora, które zakładają dostępu przez pojedynczy wątek.Zapewnia to, że najbardziej aktualną wartość jest obecny w polu przez cały czas.

volatile Modyfikator jest zwykle używany dla pola, który jest używany przez wiele wątków, bez korzystania z lock instrukcji, aby szeregować dostęp.

volatile Słowa kluczowego, które można stosować do pól tych typów:

• Typy odwołań.

• Typy wskaźnik (w kontekście niebezpieczne).Należy zauważyć, że chociaż sam wskaźnik może być lotnych, obiekt, który wskazuje na nie.Innymi słowy nie można zadeklarować "wskaźnik do lotnych."

• Typy, takich jak sbyte, byte, short, ushort, int, uint, char, pływak i bool.

• Typ wyliczenia z jednym z następujących typów podstawowych: byte, sbyte, short, ushort, int lub uint.

• Parametr typu rodzajowego, znane jako typy odwołań.

• IntPtrand UIntPtr.

Lotne słowa kluczowego dotyczą wyłącznie pola z klasy lub struktury.Nie można deklarować zmiennych lokalnych volatile.

Przykład

Poniższy przykład ilustruje sposób deklarowania zmiennej publicznej pola jako volatile.

class VolatileTest
    {
        public volatile int i;

        public void Test(int _i)
        {
            i = _i;
        }
    }

Poniższy przykład ilustruje, jak wątek pomocniczych lub pracownik mogą być tworzone i używane do wykonywania przetwarzania równolegle z wątkiem głównym.Aby uzyskać ogólne informacje o wielowątkowość, zobacz Zarządzana wątkowość i Wątkowość (C# i 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.
}

Specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Zobacz też

Informacje

Słowa kluczowe języka C#

Modyfikatory (odwołanie w C#)

Koncepcje

Przewodnik programowania w języku C#

Inne zasoby

Odwołanie w C#