volatile (odwołanie w C#)volatile (C# Reference)

volatile — Słowo kluczowe wskazuje, że pola mogą zostać zmodyfikowane przez wiele wątków, które są wykonywane w tym samym czasie.The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Kompilator, system plików środowiska uruchomieniowego i sprzętu może zmienić kolejność operacji odczytu i zapisu do lokalizacji pamięci, ze względu na wydajność.The compiler, the runtime system, and even hardware may rearrange reads and writes to memory locations for performance reasons. Pola, które są zadeklarowane volatile nie podlegają Optymalizacje te.Fields that are declared volatile are not subject to these optimizations. Dodawanie volatile modyfikator gwarantuje, że wszystkie wątki będzie przestrzegać volatile zapisów wykonywane przez inny wątek, w kolejności, w którym zostały wykonane.Adding the volatile modifier ensures that all threads will observe volatile writes performed by any other thread in the order in which they were performed. Nie ma żadnej gwarancji, pojedynczy całkowita kolejności volatile zapisów wyświetlanego ze wszystkich wątków wykonania.There is no guarantee of a single total ordering of volatile writes as seen from all threads of execution.

volatile — Słowo kluczowe mogą być stosowane do pól z następujących typów:The volatile keyword can be applied to fields of these types:

  • Typy odwołań.Reference types.
  • Typy wskaźników (w niebezpiecznym kontekście).Pointer types (in an unsafe context). Należy pamiętać, że chociaż wskaźnika, sama może być nietrwałe, obiekt, który wskazuje nie może.Note that although the pointer itself can be volatile, the object that it points to cannot. Innymi słowy nie można zadeklarować "wskaźnik volatile."In other words, you cannot declare a "pointer to volatile."
  • Proste typy, takie jak sbyte, byte, short, ushort, int, uint, char, float, i bool.Simple types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.
  • enum Typu z jednym z następujących typów podstawowych: byte, sbyte, short, ushort, int, lub uint.An enum type with one of the following base types: byte, sbyte, short, ushort, int, or uint.
  • Parametry typu ogólnego, znane jako typy odwołań.Generic type parameters known to be reference types.
  • IntPtr i UIntPtr.IntPtr and UIntPtr.

Inne typy, w tym double i long, nie można oznaczyć volatile ponieważ odczyty i zapisy do pól z tych typów, nie można zagwarantować niepodzielnych.Other types, including double and long, cannot be marked volatile because reads and writes to fields of those types cannot be guaranteed to be atomic. Aby chronić wielowątkowych dostęp do tych typów pól, użyj Interlocked elementy członkowskie klasy lub ochrona dostępu przy użyciu lock instrukcji.To protect multi-threaded access to those types of fields, use the Interlocked class members or protect access using the lock statement.

volatile — Słowo kluczowe może być stosowany tylko do pól class lub struct.The volatile keyword can only be applied to fields of a class or struct. Nie można zadeklarować zmienne lokalne volatile.Local variables cannot be declared volatile.

PrzykładExample

Poniższy przykład pokazuje sposób deklarowania zmiennej pole publiczne volatile.The following example shows how to declare a public field variable as volatile.

class VolatileTest
{
    public volatile int sharedStorage;

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

Poniższy przykład pokazuje, jak wątek wiadomości pomocniczych lub procesu roboczego można tworzyć i używany do wykonywania przetwarzania równolegle z wątku głównego.The following example demonstrates how an auxiliary or worker thread can be created and used to perform processing in parallel with that of the primary thread. Aby uzyskać więcej informacji o wielowątkowości, zobacz zarządzana wątkowość.For more information about multithreading, see Managed Threading.

public class Worker
{
    // This method is called when the thread is started.
    public void DoWork()
    {
        bool work = false;
        while (!_shouldStop)
        {
            work = !work; // simulate some work
        }
        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
{
    public 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 500 milliseconds to
        // allow the worker thread to do some work.
        Thread.Sleep(500);

        // 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: terminating gracefully.
    // Main thread: worker thread has terminated.
}

Za pomocą volatile modyfikator dodane do deklaracji _shouldStop w miejscu, zawsze uzyskasz takie same wyniki (podobnie jak fragment, jak pokazano w poprzednim kodzie).With the volatile modifier added to the declaration of _shouldStop in place, you'll always get the same results (similar to the excerpt shown in the preceding code). Jednak bez ten modyfikator na _shouldStop elementu członkowskiego, zachowanie jest nieprzewidywalne.However, without that modifier on the _shouldStop member, the behavior is unpredictable. DoWork Metoda może zoptymalizować dostęp do elementu członkowskiego, wynikiem odczytywanie nieaktualnych danych.The DoWork method may optimize the member access, resulting in reading stale data. Ze względu na charakter programowania wielowątkowe liczba odczytów starych jest nieprzewidywalne.Because of the nature of multi-threaded programming, the number of stale reads is unpredictable. Różnych tras program generuje wyniki nieco inny.Different runs of the program will produce somewhat different results.

specyfikacja języka C#C# language specification

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#.For more information, see the C# Language Specification. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.The language specification is the definitive source for C# syntax and usage.

Zobacz takżeSee also