volatile (Referenční dokumentace jazyka C#)

volatile Klíčové slovo označuje, že pole mohou být změněna více podprocesů, které jsou spuštěny současně.Pole, která jsou volatile jsou předmětem kompilátor optimalizace, které předpokládají přístup jediný podproces.Tím zajistíte, že je k dispozici v poli vždy aktuální hodnotu.

volatile Modifikátor se obvykle používá pro pole, které je přístup bez použití více podprocesů lock prohlášení serializovat přístup.

volatile Lze použít klíčové slovo do pole těchto typů:

• Typy odkazů.

• Typy ukazatele (v kontextu unsafe.).Všimněte si, že ačkoli samotný ukazatele mohou být těkavých, odkazující na objekt nelze.Jinými slovy nemůžete deklarovat "ukazatel na volatile."

• Typy například sbyte, bajt, short, ushort, int, uint, char, float a bool.

• Výčtovým typem s jedním z následujících základních typů: byte, sbyte, short, ushort, int nebo uint.

• Obecný typ parametry známé typy odkazů.

• IntPtr a UIntPtr.

Klíčové slovo těkavých lze použít pouze pro pole třídy nebo struct.Nelze použít deklaraci lokální proměnné volatile.

Příklad

Následující příklad ukazuje, jak deklarovat proměnnou veřejné pole jako volatile.

class VolatileTest
    {
        public volatile int i;

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

Následující příklad ukazuje, jak lze vytvořit a použít k provádění zpracování paralelně s, primární podproces zřetězení pomocných nebo pracovník.Základní informace o multithreading, viz Dělení na spravovaná vlákna a Dělení na vlákna (C# and 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.
}

Specifikace jazyka C#

Další informace najdete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.

Viz také

Referenční dokumentace

Klíčová slova jazyka C#

Modifikátory (Referenční dokumentace jazyka C#)

Koncepty

Průvodce programováním v C#

Další zdroje

Referenční dokumentace jazyka C#